Однослойная нейронная сеть каждый раз дает приблизительно 0,5 прогноза проблемы XOR - PullRequest
Новая
       43

Однослойная нейронная сеть каждый раз дает приблизительно 0,5 прогноза проблемы XOR

1 голос
/ 26 марта 2020

Я попытался построить нейронную сеть (с одним скрытым слоем) для решения проблемы XOR. но это дает мне примерно 0,5 на каждый вклад, который я даю. Я предполагаю, что есть проблема в Обратном распространении.

Я использовал сигмовидную функцию в качестве функции активации.

Я не использовал регуляризацию.
Я пробовал несколько курсов обучения и пробовал несколько итерационных чисел. но стоимость не уменьшается, как это должно быть.

Код выглядит следующим образом: - 

#!/usr/bin/env python
# coding: utf-8

# In[1]:


import numpy as np
import matplotlib.pyplot as plt


# In[2]:


data = [[0,0], [0,1], [1,0], [1,1]]
X = np.array(data)
X = X.T
Y = [[1,0,0,1]]
Y = np.array(Y)
print(np.shape(X))
print(np.shape(Y))


# In[3]:


def set_nodes():
    print("Enter number of nodes of Input Layer: ")
    x_n = int(input())
    print("Enter number of nodes of Hidden Layer: ")
    h_n = int(input())
    print("Enter number of nodes of Output Layer: ")
    o_n = int(input())
    nodes = {"x_n":x_n, "h_n":h_n, "o_n":o_n}
    return(nodes)


# In[4]:


nodes = set_nodes()


# In[35]:


def set_param():
    x_n = nodes["x_n"]
    h_n = nodes["h_n"]
    o_n = nodes["o_n"]

    W1 = np.random.randn(h_n, x_n)*0.01
    b1 = np.zeros((h_n,1))
    W2 = np.random.randn(o_n, h_n)*0.01
    b2 = np.zeros((o_n,1))

    parameters = {"W1":W1, "b1":b1, "W2":W2, "b2":b2}
    return parameters


# In[36]:


parameters = set_param()
np.shape(parameters["b2"])


# In[37]:


def sigmoid(z):
    a_sig = 1/(1+np.exp(-z))
    return a_sig


# In[38]:


def hypotheses(X_para, parameters):
    z1 = np.dot(parameters["W1"], X_para)+parameters["b1"]
    a1 = sigmoid(z1)
    #print("A1 shape", np.shape(a1))
    z2 = np.dot(parameters["W2"], a1) + parameters["b2"]
    a2 = sigmoid(z2)
    cache = {"Z1":z1, "A1":a1, "Z2":z2, "A2":a2}
    return a2, cache


# In[39]:


A2, cache = hypotheses(X,parameters)
print(np.shape(A2))
print(A2)
print(np.shape(cache["A2"]))
print(1-Y[0])


# In[40]:


m = Y.shape[1]
def find_cost(A2, Y, cache):
    Loss = (np.multiply(Y, np.log(A2)))+(np.multiply((1-Y), np.log(1-A2)))
    cost = -1*(1/m)*np.sum(Loss)
    cost = float(np.squeeze(cost))
    return(cost)


# In[41]:


cost = find_cost(cache["A2"], Y, cache)
print(cost)


# In[42]:


def back_prop(cache, parameters):
    dZ2 = cache["A2"]-Y
    dW2 = (1/m)*(np.dot(dZ2, cache['A2'].T))
    db2 = (1/m)*np.sum(dZ2, axis = 1, keepdims = True)
    dZ1 = np.dot(parameters["W2"].T, dZ2) *(1 - np.power(cache["A1"],2))
    dW1 = (1/m)*np.dot(dZ1, X.T)
    db1 = (1/m)*np.sum(dZ1, axis=1, keepdims = True)
    grads = {"dZ2":dZ2, "dW2":dW2, "db2":db2, "dZ1":dZ1, "dW1":dW1, "db1":db1}
    return grads


# In[43]:


grads = back_prop(cache, parameters)
# print(grads["dZ1"])
print(np.shape(parameters["W2"]))
print(np.shape(np.power(cache["A1"],2)))
print(np.shape(grads["dZ1"]))
print(np.shape(grads["dW1"]))
print(grads["dW1"])


# In[44]:


def update_parameters(grads, parameters, learning_rate = 0.012):
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]

    W2 = W2-learning_rate*grads["dW2"]
    b2 = b2-learning_rate*grads["db2"]
    W1 = W1-learning_rate*grads["dW1"]
    b1 = b1-learning_rate*grads["db1"]
    parameters = {"W2":W2, "b2": b2, "W1":W1, "b1":b1}
    return(parameters)


# In[45]:


parameters = update_parameters(grads, parameters)


# In[46]:


def nn_final(X, Y, parameters, iterations = 1000):
    X_temp = X
    costl = []
    for i in range(iterations):
    a2, cache = hypotheses(X_temp, parameters)
    cost = find_cost(a2, Y, cache)
    costl.append(cost)
    grads = back_prop(cache, parameters)
    parameters = update_parameters(grads, parameters)
    return costl, parameters


# In[47]:


costl, parameters = nn_final(X,Y,parameters)
plt.plot(costl)
plt.show()


# In[48]:


print(costl[len(costl)-2]-costl[len(costl)-1])


# In[49]:



print("Enter First Input: ")
inp1 = int(input())
print("Enter Second Input: ")
inp2 = int(input())
ls = [inp1, inp2]
print(ls)
inp = np.array(ls)
inp = inp.T
inp = np.array(inp)
inp = np.reshape(inp, (2,1))
print("inp",np.shape(inp))
a2,cache = hypotheses(inp, parameters)
print("A2=", a2)
...