机器学习-11.神经网络

Pretend ^^

已于 2023-01-08 02:43:45 修改

阅读量1.3w

点赞数 21

分类专栏： # 机器学习&头歌实训答案文章标签：神经网络 python

于 2021-12-18 18:56:13 首次发布

本文链接：https://blog.csdn.net/MrKingloveyou/article/details/122007641

版权

机器学习&头歌实训答案专栏收录该内容

10 篇文章 160 订阅

订阅专栏

EduCoder：机器学习—神经网络

第1关：什么是神经网络

在这里插入图片描述

第2关：神经元与感知机

编程要求：

根据提示，在右侧编辑器补充 python 代码，构建一个感知机模型，底层代码会调用您实现的感知机模型进行训练，并对一个特征值分别为青绿、稍蜷、沉闷（即特征向量为[0,2,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关：激活函数

编程要求：

根据提示，在右侧编辑器补充Python代码，实现relu激活函数，底层代码会调用您实现的relu激活函数来进行测试。
测试说明：

输入：9

预期输出：9

输入：-1

预期输出：0

代码如下：

#encoding=utf8

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

    #********* End *********#

第4关：反向传播算法

编程要求：

根据提示，在右侧编辑器补充 python 代码，你需要完成神经网络的前向传播、反向传播以及梯度下降部分，然后用训练好的神经网络对鸢尾花进行分类。

测试说明：

只需返回预测结果即可，程序内部会检测您的代码，预测正确率高于90%视为过关。

代码如下：

#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 *********# 
        #前向传播
        #计算隐藏层的输入
        hidden_input=hidden_in(feature,w0,b0)
        #计算隐藏层的输出
        hidden_output=hidden_out(hidden_input)
        #计算输出层的输入
        output_in=predict_in(hidden_output,w1,b1)
        #计算输出层的输出
        output_out=predict_out(output_in)
        #反向传播
        #隐藏层到输出层之间的残差
        delta_output=-np.multiply((label-output_out),partial_sig(output_in))
        #输入层到隐藏层之间的残差
        delta_hidden=np.multiply((delta_output*w1.T),partial_sig(hidden_input))
        #更新权重与偏置
        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

编程要求：

根据提示，在右侧编辑器补充Python代码，实现Dropout方法，底层代码会调用您实现的Dropout方法来进行测试。

测试说明：

输入：[0,1,2,3,4,5,6,7,8,9]

预期输出：[0 0 0 3 0 0 6 7 0 9]

输入：[10,11,12,13,14,15,16,17,18,19]

预期输出：[11 0 0 14 0 0 17 18 0 20]

代码如下：

#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中的神经网络

编程要求：

填写iris_predict(train_sample, train_label, test_sample)函数完成鸢尾花分类任务，其中：

train_sample：训练样本
train_label：训练标签
test_sample：测试样本

测试说明：

只需返回预测结果即可，程序内部会检测您的代码，预测正确率高于95%视为过关。

代码如下：

#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)
    trre_clf=tree_clf.fit(train_sample,train_label)
    y_pred=tree_clf.predict(test_sample)
    return y_pred
    
    #********* End *********#