Я внедряю нейронную сеть, используя алгоритм обратного распространения в python. Используемый метод аналогичен тому, который преподавал Эндрю Нг в своем курсе машинного обучения.Но NN предсказывает один и тот же класс и почти одинаковые значения для каждого входа во время обучения и тестирования. Для каждого набора входных данных класс вывода с наибольшей вероятностью одинаков.
Я пытался добавить единицы смещения, нормализовать входы, регуляризацию,Кажется, ничего не работает. Используемый метод аналогичен тому, который преподавал Эндрю Нг, и я использовал векторизацию для операций.
iris = datasets.load_iris()
X = iris.data[:,:]
Y = iris.target
a=np.amax(X,axis=0)#column wise maximum of input data
b=np.amin(X,axis=0)#column wise minimum
for row in X:#divide each values by difference of max-min for that column
row[0]=row[0]/(a[0]-b[0])
row[1]=row[1]/(a[1]-b[1])
row[2]=row[2]/(a[2]-b[2])
row[3]=row[3]/(a[3]-b[3])
X_train, X_test, Y_train, Y_test = train_test_split(X, Y,
test_size=0.3,
random_state=1)
biasa2=np.random.rand(5,1) #defining bias nodes for hidden layer a2
biasa3=np.random.rand(3,1) #defining bias nodes for output layes a3
def sigmoid(z):
return 1/(1+np.exp(-z)) #returns sigmoid of given array
def gradient_descent(theta,delta):
num_iterations=50000
learning_rate=.07
for i in range(0,num_iterations):
t heta=np.subtract(theta,(learning_rate*delta)/2)
return theta
def back_prop():
a1=zeros([4,1])#input layer
a2=zeros([5,1])#hidden layer
a3=zeros([3,1])#output layer
theta1=np.random.rand(5,4) #input to hidden layer weights
theta2=np.random.rand(3,5) #hidden t output layer weights
#print(theta1)
#print(theta2)
delta1=zeros([5,4]) #diffrential of cost function wrt every
#weight in input to hidden layer
delta2=zeros([3,5]) #diffrential of cost function in hidden to
#output layer
for i in range(0,len(X_train)):
y=zeros([3,1]) #store expected output for input
a1=X_train[i,:] #input matrix
a1= a1.reshape(len(X_train[i]),1)
#a1=a1/np.amax(a1,axis=0)
print("a1 is")
print(a1)
z=np.matmul(theta1,a1)#
z=z+biasa2
a2=sigmoid(z) #hidden layer node values
#a2=z
a2=a2.reshape(len(a2),1)
print("a2 is ")
print(z)
a2[0,0]=1
z=np.matmul(theta2,a2)
z=z+biasa3
a3=sigmoid(z) #output layer values
#a3=z
a3=a3.reshape(len(a3),1)
print("a3 is ")
print(z)
y[Y_train[i],0]=1 #setting index with output to 1,rest are
zero
prev_del=np.subtract(y,a3) #expected -current output
prev_del=np.multiply(prev_del,np.multiply(a3,1-
a3)) #multipling with diffrential
#print("Error in output is")
#print(prev_del)
temp=np.matmul(prev_del,a2.transpose())
delta2=np.add(delta2,temp) #calculating diffrential for layer
#2
_del=np.matmul(theta2.transpose(),prev_del) #calculating error
#for layer 2
temp2=ones([5,1])
temp2=np.subtract(temp2,a2)
_del=np.multiply(_del,np.multiply(temp2,a2)) #error of layer 2
delta1=np.add(delta1,np.matmul(_del,a1.transpose()))
#diffrential for hidden layer
d1=zeros([5,4]) #array to store final diffrentiation of cost
wrt hidden layer weights
d2=zeros([3,5]) #array to store final diffrentiation of cost
wrt output layer weights
lmbda=.004#regularization parameter
d1=(delta1+lmbda*theta1)/len(X_train)
d2=(delta2+lmbda*theta2)/len(X_train)
theta=hstack((theta1.flatten(),theta2.flatten())) #flattening
#theta matrices for gradient descent
delta=hstack((d1.flatten(),d2.flatten())) #flattening delta
#matrices for gd
theta= gradient_descent(theta,delta)
#print(theta)
return theta #return final theta values after training data
, если при выполнении кода и печатать матрицы a1, a2, a3 в каждой итерацииобучающего цикла, индекс в выходном классе с самым высоким значением одинаков для каждого входа. Иногда a3 [0] является самым высоким для каждого входа, иногда a3 [2] является самым высоким.это значения матриц без применения сигмоидальной функции.