第1关：什么是神经网络

1、

上图中的神经网络一共有多少个权重？
A、8
B、12
C、20
D、24

C

第2关：神经元与感知机

#encoding=utf8

import numpy as np
#构建感知机算法
class Perceptron(object):
    def __init__(self, learning_rate = 0.01, max_iter = 200):
        self.lr = learning_rate
        self.max_iter = max_iter
    def fit(self, data, label):
        '''
        input:data(ndarray):训练数据特征
              label(ndarray):训练数据标签
        output:w(ndarray):训练好的权重
               b(ndarry):训练好的偏置
        '''
        #编写感知机训练方法，w为权重，b为偏置
        self.w = np.random.randn(data.shape[1])
        self.b = np.random.rand(1)
        #********* Begin *********#
        for i in range(len(label)):
            while label[i]*(np.matmul(self.w,data[i])+self.b) <= 0:
                self.w = self.w + self.lr * (label[i]*data[i])
                self.b = self.b + self.lr * label[i]
        #********* End *********#
        return None
    def predict(self, data):
        '''
        input:data(ndarray):测试数据特征
        '''
        #编写感知机预测方法，若是正类返回1，负类返回-1
        #********* Begin *********#        
        yc = np.matmul(data,self.w) + self.b
        for i in range(len(yc)):
            if yc[i] >= 0:
                yc[i] = 1
            else:
                yc[i] = -1
        predict = yc
        return predict
        #********* End *********#

第3关：激活函数

#encoding=utf8

def relu(x):
    '''
    input:x(ndarray)输入数据
    '''
    #********* Begin *********#
    if x<=0:
        return 0
    else:
        return x
    #********* End *********#

第4关：反向传播算法

#encoding=utf8
import numpy as np
from math import sqrt

#bp神经网络训练方法
def bp_train(feature,label,n_hidden,maxcycle,alpha,n_output):
    '''
    计算隐含层的输入
    input:feature(mat):特征
          label(mat):标签
          n_hidden(int)隐藏层的节点个数
          maxcycle(int):最大迭代次数
          alpha(float):学习率
          n_output(int):输出层的节点个数
    output:w0(mat):输入层到隐藏层之间的权重
           b0(mat):输入层到隐藏层之间的偏置
           w1(mat):隐藏层到输出层之间的权重
           b1(mat):隐藏层到输出层之间的偏置          
    '''
    m,n = np.shape(feature)
    #初始化
    w0 = np.mat(np.random.rand(n,n_hidden))
    w0 = w0*(8.0*sqrt(6)/sqrt(n+n_hidden))-\
         np.mat(np.ones((n,n_hidden)))*\
         (4.0*sqrt(6)/sqrt(n+n_hidden))
    b0 = np.mat(np.random.rand(1,n_hidden))
    b0 = b0*(8.0*sqrt(6)/sqrt(n+n_hidden))-\
         np.mat(np.ones((1,n_hidden)))*\
         (4.0*sqrt(6)/sqrt(n+n_hidden))
    w1 = np.mat(np.random.rand(n_hidden,n_output))
    w1 = w1*(8.0*sqrt(6)/sqrt(n_hidden+n_output))-\
         np.mat(np.ones((n_hidden,n_output)))*\
         (4.0*sqrt(6)/sqrt(n_hidden+n_output))
    b1 = np.mat(np.random.rand(1,n_output))
    b1 = b1*(8.0*sqrt(6)/sqrt(n_hidden+n_output))-\
         np.mat(np.ones((1,n_output)))*\
         (4.0*sqrt(6)/sqrt(n_hidden+n_output))

    #训练
    i = 0
    while i <= maxcycle:
        #********* Begin *********# 
        #2.1 信号正向传播
        #2.1.1 计算隐含层的输入
        hidden_input=hidden_in(feature,w0,b0) #mXn_hidden
        #2.1.2 计算隐含层的输出
        hidden_output=hidden_out(hidden_input)
        #2.1.3 计算输出层的输入
        output_in=predict_in(hidden_output,w1,b1) #mXn_output
        #2.1.4 计算输出层的输出
        output_out=predict_out(output_in)
        
        #2.2 误差的反向传播
        #2.2.1 隐含层到输出层之间的残差
        delta_output=-np.multiply((label-output_out),partial_sig(output_in))
        #2.2.2 输入层到隐含层之间的残差
        delta_hidden=np.multiply((delta_output*w1.T),partial_sig(hidden_input))
        
        #2.3 修正权重和偏置
        w1=w1-alpha*(hidden_output.T*delta_output)
        b1=b1-alpha*np.sum(delta_output,axis=0)*(1.0/m)
        w0=w0-alpha*(feature.T*delta_hidden)
        b0=b0-alpha*np.sum(delta_hidden,axis=0)*(1.0/m)

        #********* End *********#
        i +=1
    return w0,w1,b0,b1

#计算隐藏层的输入函数    
def hidden_in(feature,w0,b0):
    m = np.shape(feature)[0]
    hidden_in = feature*w0
    for i in range(m):
        hidden_in[i,] += b0
    return hidden_in

#计算隐藏层的输出函数
def hidden_out(hidden_in):
    hidden_output = sig(hidden_in)
    return hidden_output
    
#计算输出层的输入函数
def predict_in(hidden_out,w1,b1):
    m = np.shape(hidden_out)[0]
    predict_in = hidden_out*w1
    for i in range(m):
        predict_in[i,] +=b1
    return predict_in

#计算输出层的输出的函数
def predict_out(predict_in):
    result = sig(predict_in)
    return result

#sigmoid函数
def sig(x):
    return 1.0/(1+np.exp(-x))

#计算sigmoid函数偏导
def partial_sig(x):
    m,n = np.shape(x)
    out = np.mat(np.zeros((m,n)))
    for i in range(m):
        for j in range(n):
            out[i,j] = sig(x[i,j])*(1-sig(x[i,j]))
    return out

第5关：Dropout

#encoding=utf8
import numpy as np

#由于Dropout方法输出存在随机性，我们已经设置好随机种子，你只需要完成Dropout方法就行。
class Dropout:
    def __init__(self,dropout_ratio=0.5):
        self.dropout_ratio = dropout_ratio
        self.mask = None
    
    def forward(self,x,train_flg=True):
        '''
        前向传播中self.mask会随机生成和x形状相同的数组，
        并将值比dropout_ratio大的元素设为True，
        x为一个列表。  
        '''
        #********* Begin *********#
        if train_flg:
            self.mask = np.random.rand(*x.shape) > self.dropout_ratio
            return x * self.mask
        else:
            return x * (1.0 - self.dropout_ratio)
        #********* End *********#

    def backward(self,dout):
        '''
        前向传播时传递了信号的神经元，
        反向传播时按原样传递信号。
        前向传播没有传递信号的神经元，
        反向传播时信号就停在那里。
        dout为一个列表。 
        '''
        #********* Begin *********#
        return dout * self.mask
        #********* End *********#

第6关：sklearn中的神经网络

#encoding=utf8
from sklearn.neural_network import MLPClassifier

def iris_predict(train_sample, train_label, test_sample):
    '''
    实现功能：1.训练模型 2.预测
    :param train_sample: 包含多条训练样本的样本集，类型为ndarray
    :param train_label: 包含多条训练样本标签的标签集，类型为ndarray
    :param test_sample: 包含多条测试样本的测试集，类型为ndarry
    :return: test_sample对应的预测标签
    '''
    
    #********* Begin *********#
    tree_clf = MLPClassifier(solver='lbfgs', alpha=1e-5, random_state=1)
    tree_clf = tree_clf.fit(train_sample, train_label)
    y_pred = tree_clf.predict(test_sample) 
    return y_pred
    #********* End *********#