1
다중 클래스 분류를 위해 Backpropagation 신경망을 사용하려고합니다. 나는 this code을 발견하고 그것을 적응 시키려고 노력했다. 그것은 Machine Learning in Coursera from Andrew Ng의 lection을 기반으로합니다.신경 네트워크에서 scipy.optimize.minimize 사용
여기서 정확히 scipy.optimize.minimize 기능 구현을 이해할 수 없습니다. 코드에서 한 번만 사용됩니다. 반복적으로 네트워크의 가중치를 업데이트합니까? 수렴 시점을 시각화 (음모)하여 어떻게 볼 수 있습니까?
이 기능을 사용하면 더 나은 성능을 얻기 위해 어떤 매개 변수를 조정할 수 있습니까? 은닉층 뉴런의
- 번호 : 나는 here 목록 일반적인 매개 변수를 발견이 내 코드
- 학습 속도
hidden_layer_size=25입니다 : 여전히 내장 사용하여 해당 최소화 기능을 조정할 수 있습니다? - 모멘텀 : 내 경우에는
reg_lambda=0입니까? overfitting을 피하기위한 정규화 매개 변수, 맞습니까? - 신기원 :
종속성이 너무 명백하다65535, 3670, 65535, 3885, -0.73, 1 65535, 3962, 65535, 3556, -0.72, 1 65535, 3573, 65535, 3529, -0.61, 1 3758, 3123, 4117, 3173, -0.21, 0 3906, 3119, 4288, 3135, -0.28, 0 3750, 3073, 4080, 3212, -0.26, 0 65535, 3458, 65535, 3330, -0.85, 2 65535, 3315, 65535, 3306, -0.87, 2 65535, 3950, 65535, 3613, -0.84, 2 65535, 32576, 65535, 19613, -0.35, 3 65535, 16657, 65535, 16618, -0.37, 3 65535, 16657, 65535, 16618, -0.32, 3, 나는 그것을 너무 쉽게해야한다고 생각 : 여기
maxiter=500
내 훈련 데이터 (대상 클래스가 마지막 열에입니다)입니다 그것을 분류하기 위해 ...
그러나 결과는 끔찍합니다. 나는 0.6에서 0.8의 정확도를 얻는다. 이것은 내 신청서에 절대적으로 부적합합니다. 주어진에서
import numpy as np
from scipy import optimize
from sklearn import cross_validation
from sklearn.metrics import accuracy_score
import math
class NN_1HL(object):
def __init__(self, reg_lambda=0, epsilon_init=0.12, hidden_layer_size=25, opti_method='TNC', maxiter=500):
self.reg_lambda = reg_lambda
self.epsilon_init = epsilon_init
self.hidden_layer_size = hidden_layer_size
self.activation_func = self.sigmoid
self.activation_func_prime = self.sigmoid_prime
self.method = opti_method
self.maxiter = maxiter
def sigmoid(self, z):
return 1/(1 + np.exp(-z))
def sigmoid_prime(self, z):
sig = self.sigmoid(z)
return sig * (1 - sig)
def sumsqr(self, a):
return np.sum(a ** 2)
def rand_init(self, l_in, l_out):
self.epsilon_init = (math.sqrt(6))/(math.sqrt(l_in + l_out))
return np.random.rand(l_out, l_in + 1) * 2 * self.epsilon_init - self.epsilon_init
def pack_thetas(self, t1, t2):
return np.concatenate((t1.reshape(-1), t2.reshape(-1)))
def unpack_thetas(self, thetas, input_layer_size, hidden_layer_size, num_labels):
t1_start = 0
t1_end = hidden_layer_size * (input_layer_size + 1)
t1 = thetas[t1_start:t1_end].reshape((hidden_layer_size, input_layer_size + 1))
t2 = thetas[t1_end:].reshape((num_labels, hidden_layer_size + 1))
return t1, t2
def _forward(self, X, t1, t2):
m = X.shape[0]
ones = None
if len(X.shape) == 1:
ones = np.array(1).reshape(1,)
else:
ones = np.ones(m).reshape(m,1)
# Input layer
a1 = np.hstack((ones, X))
# Hidden Layer
z2 = np.dot(t1, a1.T)
a2 = self.activation_func(z2)
a2 = np.hstack((ones, a2.T))
# Output layer
z3 = np.dot(t2, a2.T)
a3 = self.activation_func(z3)
return a1, z2, a2, z3, a3
def function(self, thetas, input_layer_size, hidden_layer_size, num_labels, X, y, reg_lambda):
t1, t2 = self.unpack_thetas(thetas, input_layer_size, hidden_layer_size, num_labels)
m = X.shape[0]
Y = np.eye(num_labels)[y]
_, _, _, _, h = self._forward(X, t1, t2)
costPositive = -Y * np.log(h).T
costNegative = (1 - Y) * np.log(1 - h).T
cost = costPositive - costNegative
J = np.sum(cost)/m
if reg_lambda != 0:
t1f = t1[:, 1:]
t2f = t2[:, 1:]
reg = (self.reg_lambda/(2 * m)) * (self.sumsqr(t1f) + self.sumsqr(t2f))
J = J + reg
return J
def function_prime(self, thetas, input_layer_size, hidden_layer_size, num_labels, X, y, reg_lambda):
t1, t2 = self.unpack_thetas(thetas, input_layer_size, hidden_layer_size, num_labels)
m = X.shape[0]
t1f = t1[:, 1:]
t2f = t2[:, 1:]
Y = np.eye(num_labels)[y]
Delta1, Delta2 = 0, 0
for i, row in enumerate(X):
a1, z2, a2, z3, a3 = self._forward(row, t1, t2)
# Backprop
d3 = a3 - Y[i, :].T
d2 = np.dot(t2f.T, d3) * self.activation_func_prime(z2)
Delta2 += np.dot(d3[np.newaxis].T, a2[np.newaxis])
Delta1 += np.dot(d2[np.newaxis].T, a1[np.newaxis])
Theta1_grad = (1/m) * Delta1
Theta2_grad = (1/m) * Delta2
if reg_lambda != 0:
Theta1_grad[:, 1:] = Theta1_grad[:, 1:] + (reg_lambda/m) * t1f
Theta2_grad[:, 1:] = Theta2_grad[:, 1:] + (reg_lambda/m) * t2f
return self.pack_thetas(Theta1_grad, Theta2_grad)
def fit(self, X, y):
num_features = X.shape[0]
input_layer_size = X.shape[1]
num_labels = len(set(y))
theta1_0 = self.rand_init(input_layer_size, self.hidden_layer_size)
theta2_0 = self.rand_init(self.hidden_layer_size, num_labels)
thetas0 = self.pack_thetas(theta1_0, theta2_0)
options = {'maxiter': self.maxiter}
_res = optimize.minimize(self.function, thetas0, jac=self.function_prime, method=self.method,
args=(input_layer_size, self.hidden_layer_size, num_labels, X, y, 0), options=options)
self.t1, self.t2 = self.unpack_thetas(_res.x, input_layer_size, self.hidden_layer_size, num_labels)
np.savetxt("weights_t1.txt", self.t1, newline="\n")
np.savetxt("weights_t2.txt", self.t2, newline="\n")
def predict(self, X):
return self.predict_proba(X).argmax(0)
def predict_proba(self, X):
_, _, _, _, h = self._forward(X, self.t1, self.t2)
return h
##################
# IR data #
##################
values = np.loadtxt('infrared_data.txt', delimiter=', ', usecols=[0,1,2,3,4])
targets = np.loadtxt('infrared_data.txt', delimiter=', ', dtype=(int), usecols=[5])
X_train, X_test, y_train, y_test = cross_validation.train_test_split(values, targets, test_size=0.4)
nn = NN_1HL()
nn.fit(values, targets)
print("Accuracy of classification: "+str(accuracy_score(y_test, nn.predict(X_test))))