Training method
mini-batch(size): 256
momentum: 0.9
weight decay: 5*10^-4
dropout ratio: 0.5
initial learning rate: 10^-2, decreased by a factor of 10(when validation set accuracy stopped improving).
Initialization of network weights
-shallow network(hidden layer 수가 작아 비교적 학습하기 용이한 구조)로 먼저 시작.
-더 깊은(복잡한) network 구조를 학습할 때 이미 학습된 shallow 구조의 weight 값을 사용.
-예를 들면, 입력 layer에 바로 붙어 있는 초기 4개의 layer와 출력단에 붙어 있는 FC(full connection) 3개는 shallow weight로 초기화하고, 중간의 나머지 layer만 random하게 초기화
-random 초기화에도 uniform이 아니라 N(0,10^-2)의 정규분포에서 weight를 샘플링
Training image의 준비
-학습에 사용할 이미지의 크기는 224x224의 고정 크기를 사용하는데 이것은 스케일 변환된 원 이미지에서 random하게 잘라낸(cropped) 샘플이다.
-학습 샘플 수를 증가시키기 위해 잘라낸 샘플을 다시 수평 flip시키고 random color shift(Krizhevsky 2012)시켜 더 많은 샘플을 만들어 낸다.
Training image size
-원 이미지를 등방성(가로, 세로방향으로 동일한 비로) 스케일링하고 여기서 학습 샘플을 추출(crop)한다. 인자 s를 scaling된 이미지의 가로, 세로 크기 중에서 더 작은 값이라 하면(즉, s=min(w,h)이다) s는 224보다는 더 커야 한다.
-s가 크다면(s>>224라면) crop image는 스케일 이미지 내의 작은 부분이 되고, 작은 물체나 물체의 부분을 표현하게 된다.
s값을 설정하는 2가지 방법
(1) 고정 크기로 s값을 사용(single-scale training): 실험에서 두개의 고정 값을 사용하였음(s=256, s=384). 먼저 s=256를 사용하여 net를 학습. s=384에서 학습 속도를 올리기 위해 s=256학습 초기치를 사용하고 더 작은 학습률(10^-3) 사용
(2) s값을 독립적으로 rescaling(multi-scale training): [s_min, s_max] 범위 사이에서 s를 랜덤하게 선택하고 이 값으로 이미지를 rescaling함. (s_min=256, s_max=512사용). 이렇게 하면 이미지 내의 물체는 각기 다른 크기가 될 수 있으므로 더 좋음. scaling jittering(small fast variation)에 의한 training set augmentation과 유사함.
-학습 속도를 높이기 위해 먼저 single-scale model(s=384)로 학습하고 multi-scale model를 적용.
Reference
K. Simonyan and A. Zisserman, Very deep convolutional networks for large-scale image recognition, ICLR 2015.
2015년 2월 2일 월요일
Theano 튜토리얼
[출처] http://newsight.tistory.com/161
i파이썬 서버를 mlc서버에 있음
컨트롤 엔터가 실행
쉬프트 엔터가 다른 쉘
심볼릭 변수는, 미지수 변수 x,y등을 할당하는 것
theano.function 은 CUDA C코드를 컴파일해내는 과정이고, 여기서 최적화가 일어난다.
또한 병렬화도 자동으로 처리해준다.
theano.function(inputs, outputs)
inputs는 변수의 리스트를 넣어야한다.
outputs는 인풋들로부터 계산가능한 식이 들어옴.
outputs=f(inputs)
심볼릭 변수들에대한 연산은 그래프로써 표현됨.
심볼릭 algebra들로만 연산을 하다가,
실제로 숫자를 넣어서 계산할 때 theano.function 을 이용해야함.
(함수형 언어의 철학을 따르는 방식)
심파이, 메스메티카 등도 마찬가지의 심볼릭 알제브라를 사용함.
theano.function 은 이 그래프를 CUDA 코드로 컴파일 해주는 것임
CPU/GPU 변환은 theano코드를 실행시키기 전에 해주어야함.
그래야 theano.function 에서 컴파일을 다르게 하겠네.
print(theano.config.floatX) : default 타입 확인
#심볼릭 변수의 타입
T.scalar() : 타입을 지정하지 않는 default 타입인 float32으로 되는 듯
T.iscalar() : int 32 타입을 사용하겠다
T.lscalar() : int 64
T.dscalar() : float64
#심볼릭 변수의 차원
T.scalar() : 0차원 점
T.vector() : 1차원 직선
T.matrix() : 2차원 평면
T.tensor3() : 3차원 큐브
T.tensor4() : 4차원
x=T.matrix()
y=T.matrix()
z=T.dot(x,y)
ftnSum_mat = theano.function([x,y],z)
print(ftnSum_mat(3,4))
----- 3,4는 matrix가 아니라서 에러가 남
x=T.matrix()
y=T.matrix()
z=T.dot(x,y)
ftnSum_mat = theano.function([x,y],z)
a = np.random.random((3,3))
b = np.random.random((3,3))
print(a,b,ftnSum_mat(a,b))
---------
x=T.matrix()
y=T.matrix()
z=T.dot(x,y)
ftnSum_mat = theano.function([x,y],z)
a = np.random.random((3,3))
b = np.random.random((3,3))
print(a,b,ftnSum_mat(a,b))
#이렇게 해도 변수 타입이 넘파이는 float64인데, 씨아노는 float32라서 에러가남
따라서 아래와같이 asarray함수로 float32타입으로 바꿔주어야함.
------
x=T.matrix()
y=T.matrix()
z=T.dot(x,y)
ftnSum_mat = theano.function([x,y],z)
a = np.asarray(np.random.random((3,3)),dtype=theano.config.floatX)
b = np.asarray(np.random.random((3,3)),dtype=theano.config.floatX)
print(a,b,ftnSum_mat(a,b))
-------
결론 -> 항상 float32를 쓰도록 주의할것
python 변수는 실제로 값을 가진 변수임
symbolic 변수는 실제값이 없는 미지수 변수임
shared 변수는 심볼릭 변수인데, 값을 가지고 있는 녀석임.
GPU의 셰어드 메모리에 올라가는 변수로, theano변수가 접근 가능한
값을 가지고 있음.
--
a = np.array([[1,2],[3,4]], dtype = theano.config.floatX)
x = theano.shared(a)
#a 매트릭스가 gpu 메모리에 올라가서, theano 변수가 접근 가능함
----만약 gpu메모리가 모자라면, 여기서 올리다가 에러가 남
print(x.get_value())
x.set_value(x.get_value()+1)
print(x.get_value())
# set 은 cpu -> gpu로 메모리를 올리는 것
# get 은 gpu -> cpu로 메모리를 가져오는 것
따라서 get과 set을 최대한 안써야함.
이건 거의 디버깅 용이라고 할 수 있음.
그리고 안쓰고 어차피 function에서 한방에 계산하기때문에 필요없음
---
a = np.array([[1,2],[3,4]], dtype = theano.config.floatX)
x = theano.shared(a)
y = x**2
ftnShared = theano.function([],y)
print(ftnShared())
#
여기서는 input으로 shared변수를 전달하면 안됨.
input에는 심볼릭 변수만 전달이 가능함.
shared 변수는 함수의 인자가아님.
---
T.nnet.conv.conv2d()
함수 등에 컨벌루션 레이어가 정의되어있음.
-
x = T.scalar()
y = x**2
diff = theano.function([x],T.grad(y,[x]))
print(diff(3))
결과 : [array(6.0, dtype=float32)]
#
array가 붙은 이유는 T.grad의 반환 값이 array라서 그럼.
왜냐하면 x 하나가아니라 여러개의 변수들의 리스트로 편미분을 해서
T.grad(y,[x])
즉, y 함수를 x로 편미분하는 것임,
--
x = T.scalar()
y = x**2
diff = theano.function([x],T.grad(y,[x])[0])
print(diff(3))
결과: 6.0
[0]을 해서, 첫번째 변수로 미분한 값만 array에서 가져옴
--
x = T.scalar()
w = theano.shared(np.array(3,dtype=theano.config.floatX),borrow=True)
obj = (1 - x*w)**2
learn_w = (w, w-0.1*T.grad(obj,w))
learn = theano.function([x],obj,updates=[learn_w])
print(learn(2))
#shared memory는 보통 아주 큰 memory를 GPU에서 사용하기 위함이고, cpu에서 gpu로 shallow copy가 유용하다. borrow=True옵션은 shallow copy이다. False옵션은 deep copy.
#updates는 list of tuples로 준다: [(before, after), (before, after), ...]이고 독립 변수가 여러 개인 경우, target의 독립 변수 당 derivative를 설정할 수 있다. 표기에서 []: list(수정가능), (): tuple(수정불가) 이다.
updates 는
learn_w = (w, w-0.1*T.grad(obj,w))
이런식으로 정의를 해주어야함.
즉 w를 매 스탭마다 바꾸어갈 식을 정의함
function의 순서가 input 에서 output을 계산하고, 그다음 update 식을 수행함
while(){
learn(2)를 해주어야 이제 계속 업데이트 하는 것임
}
---
x = T.scalar()
w = theano.shared(np.array(3,dtype=theano.config.floatX),borrow=True)
obj = (1 - x*w)**2
learn_w = (w, w-0.1*T.grad(obj,w))
learn = theano.function([x],obj,updates=[learn_w])
print(learn(2),w.get_value())
print(learn(2),w.get_value())
print(learn(2),w.get_value())
print(learn(2),w.get_value())
----
theano는 update가 뉴럴넷을 전제로 깔고 정의됨.
굳이 이걸 안 쓰고, 업데이트를 function 으로 해줘도됨
--
import theano
import theano.tensor as T
class opt_problem:
def __init__(self):
# optimization variables
self.x = theano.shared(numpy.array(100.,dtype=theano.config.floatX), borrow=True)
self.y = theano.shared(numpy.array(100.,dtype=theano.config.floatX), borrow=True)
self.pos = [self.x, self.y]
# hyperparameters
self.lr = theano.shared(np.array(0.05, dtype=theano.config.floatX), borrow=True) # learning rate
# optimization objective
self.ftn_eqn = (self.x ** 2) + 10*(self.y ** 2)
self.grad = T.grad(self.ftn_eqn, self.pos)
# evaluating current value
self.ftn = theano.function([], self.ftn_eqn)
def plot(self, scope=20.):
# visualizing code
x = np.arange(-scope, scope, 0.05)
y = np.arange(-scope, scope, 0.05)
X, Y = np.meshgrid(x, y)
X = np.asarray(X, dtype=theano.config.floatX)
Y = np.asarray(Y, dtype=theano.config.floatX)
Z = (X ** 2) + 10*(Y ** 2)
plt.figure()
C = plt.contour(X,Y,Z)
def build_gd(self):
self.updates = []
for posi, grad in zip(self.pos, self.grad):
self.updates.append((posi, posi - self.lr*grad))
# zip은 pos도 리스트고, grad도 리스트인데 각각을 지퍼로 연결해서 for문을 돌림
# 독립 변수가 2개 이므로 각 변수에 대한 tuple의 list들 만듬
# gradient descent function
self.gd = theano.function([], self.ftn_eqn,
updates=self.updates)
problem = opt_problem()
problem.plot()
problem.build_gd()
Xs = []
Ys = []
Xs.append(problem.x.get_value()) # gpu로 내부적으로 shared된 x변수는 값이 계속 바뀜
Ys.append(problem.y.get_value())
for epoch in xrange(20):
if(epoch%5)==1:
problem.lr.set_value(problem.lr.get_value()/2)
f_val = problem.gd()
Xs.append(problem.x.get_value())
Ys.append(problem.y.get_value())
plt.plot(Xs, Ys, '-ro')
print(f_val)
----
numpy에서 아이겐벡터, 아이겐 벨류 계산 가능
-
matplotlib 는 매틀랩하고 거의 똑같은 인터페이스로 구성되어있음
-
뉴럴넷 짤때, 백프로퍼게이션 구현안하고 짤 수 있음.
--
x = T.scalar()
w = theano.shared(np.array(3,dtype=theano.config.floatX),borrow=True)
obj = (1 - x*w)**2
#learn_w = (w, w-0.1*T.grad(obj,w))
learn = theano.function([x],obj)
w = w-0.1*T.grad(obj,w)
m_update = theano.function([],w)
print(learn(2), m_update())
print(learn(2), m_update())
print(learn(2), m_update())
print(learn(2), m_update())
#
update따로구현해보기
i파이썬 서버를 mlc서버에 있음
컨트롤 엔터가 실행
쉬프트 엔터가 다른 쉘
심볼릭 변수는, 미지수 변수 x,y등을 할당하는 것
theano.function 은 CUDA C코드를 컴파일해내는 과정이고, 여기서 최적화가 일어난다.
또한 병렬화도 자동으로 처리해준다.
theano.function(inputs, outputs)
inputs는 변수의 리스트를 넣어야한다.
outputs는 인풋들로부터 계산가능한 식이 들어옴.
outputs=f(inputs)
심볼릭 변수들에대한 연산은 그래프로써 표현됨.
심볼릭 algebra들로만 연산을 하다가,
실제로 숫자를 넣어서 계산할 때 theano.function 을 이용해야함.
(함수형 언어의 철학을 따르는 방식)
심파이, 메스메티카 등도 마찬가지의 심볼릭 알제브라를 사용함.
theano.function 은 이 그래프를 CUDA 코드로 컴파일 해주는 것임
CPU/GPU 변환은 theano코드를 실행시키기 전에 해주어야함.
그래야 theano.function 에서 컴파일을 다르게 하겠네.
print(theano.config.floatX) : default 타입 확인
#심볼릭 변수의 타입
T.scalar() : 타입을 지정하지 않는 default 타입인 float32으로 되는 듯
T.iscalar() : int 32 타입을 사용하겠다
T.lscalar() : int 64
T.dscalar() : float64
#심볼릭 변수의 차원
T.scalar() : 0차원 점
T.vector() : 1차원 직선
T.matrix() : 2차원 평면
T.tensor3() : 3차원 큐브
T.tensor4() : 4차원
x=T.matrix()
y=T.matrix()
z=T.dot(x,y)
ftnSum_mat = theano.function([x,y],z)
print(ftnSum_mat(3,4))
----- 3,4는 matrix가 아니라서 에러가 남
x=T.matrix()
y=T.matrix()
z=T.dot(x,y)
ftnSum_mat = theano.function([x,y],z)
a = np.random.random((3,3))
b = np.random.random((3,3))
print(a,b,ftnSum_mat(a,b))
---------
x=T.matrix()
y=T.matrix()
z=T.dot(x,y)
ftnSum_mat = theano.function([x,y],z)
a = np.random.random((3,3))
b = np.random.random((3,3))
print(a,b,ftnSum_mat(a,b))
#이렇게 해도 변수 타입이 넘파이는 float64인데, 씨아노는 float32라서 에러가남
따라서 아래와같이 asarray함수로 float32타입으로 바꿔주어야함.
------
x=T.matrix()
y=T.matrix()
z=T.dot(x,y)
ftnSum_mat = theano.function([x,y],z)
a = np.asarray(np.random.random((3,3)),dtype=theano.config.floatX)
b = np.asarray(np.random.random((3,3)),dtype=theano.config.floatX)
print(a,b,ftnSum_mat(a,b))
-------
결론 -> 항상 float32를 쓰도록 주의할것
python 변수는 실제로 값을 가진 변수임
symbolic 변수는 실제값이 없는 미지수 변수임
shared 변수는 심볼릭 변수인데, 값을 가지고 있는 녀석임.
GPU의 셰어드 메모리에 올라가는 변수로, theano변수가 접근 가능한
값을 가지고 있음.
--
a = np.array([[1,2],[3,4]], dtype = theano.config.floatX)
x = theano.shared(a)
#a 매트릭스가 gpu 메모리에 올라가서, theano 변수가 접근 가능함
----만약 gpu메모리가 모자라면, 여기서 올리다가 에러가 남
print(x.get_value())
x.set_value(x.get_value()+1)
print(x.get_value())
# set 은 cpu -> gpu로 메모리를 올리는 것
# get 은 gpu -> cpu로 메모리를 가져오는 것
따라서 get과 set을 최대한 안써야함.
이건 거의 디버깅 용이라고 할 수 있음.
그리고 안쓰고 어차피 function에서 한방에 계산하기때문에 필요없음
---
a = np.array([[1,2],[3,4]], dtype = theano.config.floatX)
x = theano.shared(a)
y = x**2
ftnShared = theano.function([],y)
print(ftnShared())
#
여기서는 input으로 shared변수를 전달하면 안됨.
input에는 심볼릭 변수만 전달이 가능함.
shared 변수는 함수의 인자가아님.
---
T.nnet.conv.conv2d()
함수 등에 컨벌루션 레이어가 정의되어있음.
-
x = T.scalar()
y = x**2
diff = theano.function([x],T.grad(y,[x]))
print(diff(3))
결과 : [array(6.0, dtype=float32)]
#
array가 붙은 이유는 T.grad의 반환 값이 array라서 그럼.
왜냐하면 x 하나가아니라 여러개의 변수들의 리스트로 편미분을 해서
T.grad(y,[x])
즉, y 함수를 x로 편미분하는 것임,
--
x = T.scalar()
y = x**2
diff = theano.function([x],T.grad(y,[x])[0])
print(diff(3))
결과: 6.0
[0]을 해서, 첫번째 변수로 미분한 값만 array에서 가져옴
--
x = T.scalar()
w = theano.shared(np.array(3,dtype=theano.config.floatX),borrow=True)
obj = (1 - x*w)**2
learn_w = (w, w-0.1*T.grad(obj,w))
learn = theano.function([x],obj,updates=[learn_w])
print(learn(2))
#shared memory는 보통 아주 큰 memory를 GPU에서 사용하기 위함이고, cpu에서 gpu로 shallow copy가 유용하다. borrow=True옵션은 shallow copy이다. False옵션은 deep copy.
#updates는 list of tuples로 준다: [(before, after), (before, after), ...]이고 독립 변수가 여러 개인 경우, target의 독립 변수 당 derivative를 설정할 수 있다. 표기에서 []: list(수정가능), (): tuple(수정불가) 이다.
updates 는
learn_w = (w, w-0.1*T.grad(obj,w))
이런식으로 정의를 해주어야함.
즉 w를 매 스탭마다 바꾸어갈 식을 정의함
function의 순서가 input 에서 output을 계산하고, 그다음 update 식을 수행함
while(){
learn(2)를 해주어야 이제 계속 업데이트 하는 것임
}
---
x = T.scalar()
w = theano.shared(np.array(3,dtype=theano.config.floatX),borrow=True)
obj = (1 - x*w)**2
learn_w = (w, w-0.1*T.grad(obj,w))
learn = theano.function([x],obj,updates=[learn_w])
print(learn(2),w.get_value())
print(learn(2),w.get_value())
print(learn(2),w.get_value())
print(learn(2),w.get_value())
----
theano는 update가 뉴럴넷을 전제로 깔고 정의됨.
굳이 이걸 안 쓰고, 업데이트를 function 으로 해줘도됨
--
import theano
import theano.tensor as T
class opt_problem:
def __init__(self):
# optimization variables
self.x = theano.shared(numpy.array(100.,dtype=theano.config.floatX), borrow=True)
self.y = theano.shared(numpy.array(100.,dtype=theano.config.floatX), borrow=True)
self.pos = [self.x, self.y]
# hyperparameters
self.lr = theano.shared(np.array(0.05, dtype=theano.config.floatX), borrow=True) # learning rate
# optimization objective
self.ftn_eqn = (self.x ** 2) + 10*(self.y ** 2)
self.grad = T.grad(self.ftn_eqn, self.pos)
# evaluating current value
self.ftn = theano.function([], self.ftn_eqn)
def plot(self, scope=20.):
# visualizing code
x = np.arange(-scope, scope, 0.05)
y = np.arange(-scope, scope, 0.05)
X, Y = np.meshgrid(x, y)
X = np.asarray(X, dtype=theano.config.floatX)
Y = np.asarray(Y, dtype=theano.config.floatX)
Z = (X ** 2) + 10*(Y ** 2)
plt.figure()
C = plt.contour(X,Y,Z)
def build_gd(self):
self.updates = []
for posi, grad in zip(self.pos, self.grad):
self.updates.append((posi, posi - self.lr*grad))
# zip은 pos도 리스트고, grad도 리스트인데 각각을 지퍼로 연결해서 for문을 돌림
# 독립 변수가 2개 이므로 각 변수에 대한 tuple의 list들 만듬
# gradient descent function
self.gd = theano.function([], self.ftn_eqn,
updates=self.updates)
problem = opt_problem()
problem.plot()
problem.build_gd()
Xs = []
Ys = []
Xs.append(problem.x.get_value()) # gpu로 내부적으로 shared된 x변수는 값이 계속 바뀜
Ys.append(problem.y.get_value())
for epoch in xrange(20):
if(epoch%5)==1:
problem.lr.set_value(problem.lr.get_value()/2)
f_val = problem.gd()
Xs.append(problem.x.get_value())
Ys.append(problem.y.get_value())
plt.plot(Xs, Ys, '-ro')
print(f_val)
----
numpy에서 아이겐벡터, 아이겐 벨류 계산 가능
-
matplotlib 는 매틀랩하고 거의 똑같은 인터페이스로 구성되어있음
-
뉴럴넷 짤때, 백프로퍼게이션 구현안하고 짤 수 있음.
--
x = T.scalar()
w = theano.shared(np.array(3,dtype=theano.config.floatX),borrow=True)
obj = (1 - x*w)**2
#learn_w = (w, w-0.1*T.grad(obj,w))
learn = theano.function([x],obj)
w = w-0.1*T.grad(obj,w)
m_update = theano.function([],w)
print(learn(2), m_update())
print(learn(2), m_update())
print(learn(2), m_update())
print(learn(2), m_update())
#
update따로구현해보기
2015년 1월 19일 월요일
2015년 1월 8일 목요일
2015년 1월 6일 화요일
Energy Based Model
$E(x)$는 $x$의 함수이고 $x$에 따라 크기가 결정되는 값이다. $x$ 값을 잘 조절하면 $E$의 크기를 줄일 수 있다. 즉, $E(x)$는 $x$의 구성(또는 배치, configuration)에
따라 크기가 결정되며, $x$라는 상태에 대해 값을 부여하는 하나의 방법이다. 에너지의 크기로 이 값을 본다면, 이러한
표현방식을 EBM(Energy Based Model)이라 부른다.
에너지 값을 확률 값(pdf)으로 표현하면
$p(x)=e^{-E(x)}/Z$, $Z=\sum_x{e^{-E(x)} }$
만일 $x$가 입력 벡터(즉, data)이고 $E$가 어떤 $x$와 함께 결합된 파라메터 $\theta$의 조합으로 구성(즉, $E(x)=E(x; \theta)$)되었다면 다양한 여러 입력 $x$에 대해 $E$가 최소화되도록 $\theta$를 조절할 수 있다. 이는 data에 따라 파라메터(모델) $\theta$를 결정하는 학습(learning) 과정이 된다.
Reference
[1] 볼츠만분포
가 되고 EBPM(Energy Based Probabilistic Model)이
된다. $E$가 0이될 때 확률 값이 최대이다.
만일 $x$가 입력 벡터(즉, data)이고 $E$가 어떤 $x$와 함께 결합된 파라메터 $\theta$의 조합으로 구성(즉, $E(x)=E(x; \theta)$)되었다면 다양한 여러 입력 $x$에 대해 $E$가 최소화되도록 $\theta$를 조절할 수 있다. 이는 data에 따라 파라메터(모델) $\theta$를 결정하는 학습(learning) 과정이 된다.
위의 확률분포를 볼츠만분포(Boltzmann Distribution)라고 부르고 물리적으로는 평형계에서 에너지가 분배될 때 가장 가능성 높은 분포(열역학적으로 입자운동에 의한 점유 분포에서 최빈 분포. 어떤 온도에서 일정 공간 내의 입자수를 볼 때 가장 흔한 입자 수의 분포)를 의미한다. 에너지가 높아지면 확률 값이 작아진다.
Reference
[1] 볼츠만분포
2015년 1월 5일 월요일
Intel xdk
설치
http://benzydad.tistory.com/category/%EC%9D%B8%ED%85%94%20%EC%97%90%EB%94%94%EC%8A%A8
mraa library(Python이용 제어)
http://arsviator.blogspot.kr/2015/01/python-intel-edison-gpio.html
XDK 간략 소개
http://t9t9.com/486
기타 인텔 제공
https://software.intel.com/en-us/xdk/docs/lp-xdk-iot-edition
https://software.intel.com/en-us/getting-started-with-the-intel-xdk-iot-edition
인텔 IoT 솔루션 소개
http://www.iotedu.co.kr/index.asp
http://benzydad.tistory.com/category/%EC%9D%B8%ED%85%94%20%EC%97%90%EB%94%94%EC%8A%A8
mraa library(Python이용 제어)
http://arsviator.blogspot.kr/2015/01/python-intel-edison-gpio.html
XDK 간략 소개
http://t9t9.com/486
기타 인텔 제공
https://software.intel.com/en-us/xdk/docs/lp-xdk-iot-edition
https://software.intel.com/en-us/getting-started-with-the-intel-xdk-iot-edition
인텔 IoT 솔루션 소개
http://www.iotedu.co.kr/index.asp
2015년 1월 2일 금요일
MV References
Realtime On-Road Vehicle detection with optical flows and Haar-like feature detector
adept mobilerobots: Aqua2, underwater mini unmannedrobot company
Thrun research
Robust Vehicle Localization in Urban Environments Using Probabilistic Maps, 2010. ICRA
Map-Based Precision Vehicle Localization in Urban Environments
Towards Fully Autonomous Driving: Systems and Algorithms
adept mobilerobots: Aqua2, underwater mini unmannedrobot company
Thrun research
Robust Vehicle Localization in Urban Environments Using Probabilistic Maps, 2010. ICRA
Map-Based Precision Vehicle Localization in Urban Environments
Towards Fully Autonomous Driving: Systems and Algorithms
피드 구독하기:
글 (Atom)