【深度学习】1.2：简单神经网络的python实现

资料参考：
[1]知乎专栏总结：https//zhuanlan.zhihu.com/p/21423252
[2]Youtube上的视频network demystified playlist
以下实现神经网络，但此处的矩阵是Youtube视频上的转置
参数的选取：
learn_rate：步子大了，容易跳过最优点；步子小了，容易陷入局部最优
hidden_nodes: 隐藏层节点个数多了，容易过拟合，节点个数少，容易欠拟合
epho: 迭代次数多了，容易过拟合，时间长；次数少了，容易欠拟合

代码块

#有56个输入节点，2个隐藏节点，1个输出节点，做个示例
#隐藏层激活函数为sigmoid，输出层为f(x)=x.
class NeuralNetwork(object):
    def __init__(self, input_nodes, hidden_nodes, output_nodes, learning_rate):
        # Set number of nodes in input, hidden and output layers.
        self.input_nodes = input_nodes
        self.hidden_nodes = hidden_nodes
        self.output_nodes = output_nodes

        # Initialize weights，注意权重的shape
        self.weights_input_to_hidden = np.random.normal(0.0, self.hidden_nodes**-0.5, 
                                       (self.hidden_nodes, self.input_nodes))

        self.weights_hidden_to_output = np.random.normal(0.0, self.output_nodes**-0.5, 
                                       (self.output_nodes, self.hidden_nodes))
        self.lr = learning_rate

        #### Set this to your implemented sigmoid function ####
        # Activation function is the sigmoid function
        def sigmoid(x):
             return 1 / (1 + np.exp(-x))
        self.activation_function = sigmoid

    def train(self, inputs_list, targets_list):
        # Convert inputs list to 2d array
        inputs = np.array(inputs_list, ndmin=2).T # inputs的shape为 [feature_diemension, 1]=[56,1]，1是指1个实例
        targets = np.array(targets_list, ndmin=2).T#[1,1]
        #print("input",inputs.shape)
        #print("targets",targets.shape)

        #### Implement the forward pass here ####
        ### Forward pass ###
        # TODO: Hidden layer
        hidden_inputs = np.dot(self.weights_input_to_hidden,inputs)#hidden_inputs是[hidden_nodes,1]=[2,1]
        hidden_outputs = self.activation_function(hidden_inputs)#hidden_outputs是[hidden_nodes,1]=[2,1]
        #print("hidden_inputs",(hidden_inputs.shape))
        #print(("hidden_outputs"),hidden_outputs.shape)

        # TODO: Output layer
        final_inputs = np.dot(self.weights_hidden_to_output,hidden_outputs)#[output_nodes,1]
        final_outputs = final_inputs #[output,input]=[1,1]
        #print("final_inputs",final_inputs.shape)
        #print("final_outputs",final_outputs.shape)

        #### Implement the backward pass here ####
        ### Backward pass ###

        # TODO: Output error
        output_errors = targets-final_outputs #[output,1]

        # TODO: Backpropagated error
        hidden_errors = np.dot(self.weights_hidden_to_output.T, output_errors)#[hidden_nodes,1]
        hidden_grads = hidden_outputs * ( 1-hidden_outputs )#[hidden_nodes,1]


        #  Update the weights  
        #  update hidden-to-output weights with gradient descent step  
        self.weights_hidden_to_output += np.dot(output_errors, hidden_outputs.T) * self.lr  #[output,hidden]
        # update input-to-hidden weights with gradient descent step  
        self.weights_input_to_hidden += np.dot(hidden_errors * hidden_grads, inputs.T) * self.lr #[hidden,input]


    def run(self, inputs_list):
        # Run a forward pass through the network
        inputs = np.array(inputs_list, ndmin=2).T

        #### Implement the forward pass here ####
        # TODO: Hidden layer
        hidden_inputs = np.dot(self.weights_input_to_hidden,inputs)
        hidden_outputs = self.activation_function(hidden_inputs)

        # TODO: Output layer
        final_inputs = np.dot(self.weights_hidden_to_output,hidden_outputs)
        final_outputs = final_inputs 

        return final_outputs