Python 은 numpy 를 바탕 으로 신경 망 구 조 를 유연 하 게 정의 하 는 방법
numpy 로 신경 망 구 조 를 유연 하 게 정의 할 수 있 고 numpy 의 강력 한 행렬 연산 기능 도 응용 할 수 있 습 니 다!
용법
1).3 층 신경 망 을 정의 합 니 다.
''' '''
nn = NeuralNetworks([3,4,2]) #
nn.fit(X,y) #
print(nn.predict(X)) #
설명:입력 층 노드 수:3
숨겨 진 층 노드 수:4
출력 층 노드 수:2
2).5 층 신경 망 을 정의 한다.
''' '''
nn = NeuralNetworks([3,5,7,4,2]) #
nn.fit(X,y) #
print(nn.predict(X)) #
설명:입력 층 노드 수:3
숨겨 진 층 1 노드 수:5
숨겨 진 층 2 노드 수:7
숨겨 진 층 3 노드 수:4
출력 층 노드 수:2
실현
다음 실현 방식 은 본인(@hhh 5460)의 오리지널 입 니 다.요점:dtype=object
import numpy as np
class NeuralNetworks(object):
''''''
def __init__(self, n_layers=None, active_type=None, n_iter=10000, error=0.05, alpha=0.5, lamda=0.4):
''' '''
# ( )
self.n = np.array(n_layers) # 'n_layers list , :[3,4,2] n_layers=[3,4,2]'
self.size = self.n.size #
# ( )
self.z = np.empty(self.size, dtype=object) # ( ),dtype=object !
self.a = np.empty(self.size, dtype=object)
self.data_a = np.empty(self.size, dtype=object)
# ( )
self.b = np.empty(self.size, dtype=object)
self.delta_b = np.empty(self.size, dtype=object)
# ( )
self.w = np.empty(self.size, dtype=object)
self.delta_w = np.empty(self.size, dtype=object)
#
for i in range(self.size):
self.a[i] = np.zeros(self.n[i]) #
self.z[i] = np.zeros(self.n[i]) #
self.data_a[i] = np.zeros(self.n[i]) #
if i < self.size - 1:
self.b[i] = np.ones(self.n[i+1]) #
self.delta_b[i] = np.zeros(self.n[i+1]) #
mu, sigma = 0, 0.1 # 、
self.w[i] = np.random.normal(mu, sigma, (self.n[i], self.n[i+1])) # #
self.delta_w[i] = np.zeros((self.n[i], self.n[i+1])) #
아래 의 전체 코드 는 제 가 스 탠 퍼 드 기계 학습 과정 을 배 워 서 완전히 스스로 두 드 린 것 입 니 다.
import numpy as np
'''
:http://ufldl.stanford.edu/wiki/index.php/%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C
'''
class NeuralNetworks(object):
''''''
def __init__(self, n_layers=None, active_type=None, n_iter=10000, error=0.05, alpha=0.5, lamda=0.4):
''' '''
self.n_iter = n_iter #
self.error = error #
self.alpha = alpha #
self.lamda = lamda # # !
if n_layers is None:
raise ' !'
elif not isinstance(n_layers, list):
raise 'n_layers list , :[3,4,2] n_layers=[3,4,2]'
# ( )
self.n = np.array(n_layers)
self.size = self.n.size #
# ( )
self.a = np.empty(self.size, dtype=object) # ( ),dtype=object !
self.z = np.empty(self.size, dtype=object)
# ( )
self.b = np.empty(self.size, dtype=object)
self.delta_b = np.empty(self.size, dtype=object)
# ( )
self.w = np.empty(self.size, dtype=object)
self.delta_w = np.empty(self.size, dtype=object)
# ( )
self.data_a = np.empty(self.size, dtype=object)
#
for i in range(self.size):
self.a[i] = np.zeros(self.n[i]) #
self.z[i] = np.zeros(self.n[i]) #
self.data_a[i] = np.zeros(self.n[i]) #
if i < self.size - 1:
self.b[i] = np.ones(self.n[i+1]) #
self.delta_b[i] = np.zeros(self.n[i+1]) #
mu, sigma = 0, 0.1 # 、
self.w[i] = np.random.normal(mu, sigma, (self.n[i], self.n[i+1])) # #
self.delta_w[i] = np.zeros((self.n[i], self.n[i+1])) #
#
self.active_functions = {
'sigmoid': self.sigmoid,
'tanh': self.tanh,
'radb': self.radb,
'line': self.line,
}
#
self.derivative_functions = {
'sigmoid': self.sigmoid_d,
'tanh': self.tanh_d,
'radb': self.radb_d,
'line': self.line_d,
}
if active_type is None:
self.active_type = ['sigmoid'] * (self.size - 1) #
else:
self.active_type = active_type
def sigmoid(self, z):
if np.max(z) > 600:
z[z.argmax()] = 600
return 1.0 / (1.0 + np.exp(-z))
def tanh(self, z):
return (np.exp(z) - np.exp(-z)) / (np.exp(z) + np.exp(-z))
def radb(self, z):
return np.exp(-z * z)
def line(self, z):
return z
def sigmoid_d(self, z):
return z * (1.0 - z)
def tanh_d(self, z):
return 1.0 - z * z
def radb_d(self, z):
return -2.0 * z * np.exp(-z * z)
def line_d(self, z):
return np.ones(z.size) #
def forward(self, x):
''' ( )'''
# x , z, a
self.a[0] = x
for i in range(self.size - 1):
self.z[i+1] = np.dot(self.a[i], self.w[i]) + self.b[i]
self.a[i+1] = self.active_functions[self.active_type[i]](self.z[i+1]) #
def err(self, X, Y):
''' '''
last = self.size-1
err = 0.0
for x, y in zip(X, Y):
self.forward(x)
err += 0.5 * np.sum((self.a[last] - y)**2)
err /= X.shape[0]
err += sum([np.sum(w) for w in self.w[:last]**2])
return err
def backward(self, y):
''' ( )'''
last = self.size - 1
# y , delta_w, delta_b
self.data_a[last] = -(y - self.a[last]) * self.derivative_functions[self.active_type[last-1]](self.z[last]) #
for i in range(last-1, 1, -1):
self.data_a[i] = np.dot(self.w[i], self.data_a[i+1]) * self.derivative_functions[self.active_type[i-1]](self.z[i]) #
#
p_w = np.outer(self.a[i], self.data_a[i+1]) # ! numpy !
p_b = self.data_a[i+1]
# delta_w, delta_w
self.delta_w[i] = self.delta_w[i] + p_w
self.delta_b[i] = self.delta_b[i] + p_b
def update(self, n_samples):
''' '''
last = self.size - 1
for i in range(last):
self.w[i] -= self.alpha * ((1/n_samples) * self.delta_w[i] + self.lamda * self.w[i])
self.b[i] -= self.alpha * ((1/n_samples) * self.delta_b[i])
def fit(self, X, Y):
''' '''
for i in range(self.n_iter):
# ,
for x, y in zip(X, Y):
self.forward(x) # , a, z;
self.backward(y) # , delta_w, delta_b
# , w, b
self.update(len(X))
#
err = self.err(X, Y)
if err < self.error:
break
# ( !)
if i % 1000 == 0:
print('iter: {}, error: {}'.format(i, err))
def predict(self, X):
''' '''
last = self.size - 1
res = []
for x in X:
self.forward(x)
res.append(self.a[last])
return np.array(res)
if __name__ == '__main__':
nn = NeuralNetworks([2,3,4,3,1], n_iter=5000, alpha=0.4, lamda=0.3, error=0.06) #
X = np.array([[0.,0.], #
[0.,1.],
[1.,0.],
[1.,1.]])
y = np.array([0,1,1,0])
nn.fit(X,y) #
print(nn.predict(X)) #
더 많은 파 이 썬 관련 내용 은 본 사이트 의 주 제 를 볼 수 있 습 니 다.Python 수학 연산 기법 총화,Python 데이터 구조 및 알고리즘 튜 토리 얼,Python 함수 사용 기법 총화,Python 문자열 조작 기법 집합과Python 입문 및 진급 고전 튜 토리 얼본 논문 에서 말 한 것 이 여러분 의 Python 프로 그래 밍 에 도움 이 되 기 를 바 랍 니 다.
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
Python의 None과 NULL의 차이점 상세 정보그래서 대상 = 속성 + 방법 (사실 방법도 하나의 속성, 데이터 속성과 구별되는 호출 가능한 속성 같은 속성과 방법을 가진 대상을 클래스, 즉 Classl로 분류할 수 있다.클래스는 하나의 청사진과 같아서 하나의 ...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.