第九十二篇 搭建神经网络

最新推荐文章于 2024-03-08 22:21:08 发布
最新推荐文章于 2024-03-08 22:21:08 发布
阅读量263 收藏
点赞数
分类专栏： 机器学习 文章标签： 神经网络 机器学习
原文链接：https://blog.csdn.net/u013733326/article/details/79702148
版权

Follow Your Heart：面临太多的选择，人总会迷茫，有好有坏，理性的选择往往是最好的选择，但往往会有人选择感性，遵从自己的内心，哪怕举步维艰，不知道是成功还是失败，还是想这样选择，可能有些人有些事有些东西值得你付出，但愿这一切都会变得好起来。

一、神经网络

初步接触神经网络，感觉被高大上名词给吓住了，高深莫测的CNN,DNN,让人望而却步。

简单来说神经网络是用来预测数据的一种模型，而这种模型是由一个个神经元组成，共同对数据进行训练决策，输出结果。一个神经元会接收信号，输出信号。
在这里插入图片描述

二、 搭建神经网络

构建神经网络的一般方法是：

  • 定义神经网络结构（输入单元的数量，隐藏单元的数量等）。
  • 初始化模型的参数
  • 循环：
  1. 实施前向传播
  2. 计算损失
  3. 实现向后传播
  4. 更新参数（梯度下降）

搭建一个两层神经网络

在这里插入图片描述

1. 向前传播计算Z,A

计算Z和A
在这里插入图片描述
代码:

def initialize_parameters(n_x, n_h, n_y):
    """
    参数：
        n_x - 输入层节点的数量
        n_h - 隐藏层节点的数量
        n_y - 输出层节点的数量

    返回：
        parameters - 包含参数的字典：
            W1 - 权重矩阵,维度为（n_h，n_x）
            b1 - 偏向量，维度为（n_h，1）
            W2 - 权重矩阵，维度为（n_y，n_h）
            b2 - 偏向量，维度为（n_y，1）

    """
    np.random.seed(2)  # 指定一个随机种子，以便你的输出与我们的一样。
    W1 = np.random.randn(n_h, n_x) * 0.01
    b1 = np.zeros(shape=(n_h, 1))
    W2 = np.random.randn(n_y, n_h) * 0.01
    b2 = np.zeros(shape=(n_y, 1))

    # 使用断言确保我的数据格式是正确的
    assert (W1.shape == (n_h, n_x))
    assert (b1.shape == (n_h, 1))
    assert (W2.shape == (n_y, n_h))
    assert (b2.shape == (n_y, 1))

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

    return parameters

def forward_propagation( X , parameters ):
    """
    参数：
         X - 维度为（n_x，m）的输入数据。
         parameters - 初始化函数（initialize_parameters）的输出
    
    返回：
         A2 - 使用sigmoid()函数计算的第二次激活后的数值
         cache - 包含“Z1”，“A1”，“Z2”和“A2”的字典类型变量
     """
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    #前向传播计算A2
    Z1 = np.dot(W1 , X) + b1
    A1 = np.tanh(Z1)
    Z2 = np.dot(W2 , A1) + b2
    A2 = sigmoid(Z2)
    #使用断言确保我的数据格式是正确的
    assert(A2.shape == (1,X.shape[1]))
    cache = {"Z1": Z1,
             "A1": A1,
             "Z2": Z2,
             "A2": A2}
    
    return (A2, cache)

2. 向前传播计算Cost

计算Cost
在这里插入图片描述
代码：

def compute_cost(A2,Y,parameters):
    """
    计算方程（6）中给出的交叉熵成本，
    
    参数：
         A2 - 使用sigmoid()函数计算的第二次激活后的数值
         Y - "True"标签向量,维度为（1，数量）
         parameters - 一个包含W1，B1，W2和B2的字典类型的变量
    
    返回：
         成本 - 交叉熵成本给出方程（13）
    """
    
    m = Y.shape[1]
    W1 = parameters["W1"]
    W2 = parameters["W2"]
    
    #计算成本
    logprobs = logprobs = np.multiply(np.log(A2), Y) + np.multiply((1 - Y), np.log(1 - A2))
    cost = - np.sum(logprobs) / m
    cost = float(np.squeeze(cost))
    
    assert(isinstance(cost,float))
    
    return cost

3. 向后传播

在这里插入图片描述
代码：

def backward_propagation(parameters,cache,X,Y):
    """
    使用上述说明搭建反向传播函数。
    
    参数：
     parameters - 包含我们的参数的一个字典类型的变量。
     cache - 包含“Z1”，“A1”，“Z2”和“A2”的字典类型的变量。
     X - 输入数据，维度为（2，数量）
     Y - “True”标签，维度为（1，数量）
    
    返回：
     grads - 包含W和b的导数一个字典类型的变量。
    """
    m = X.shape[1]
    
    W1 = parameters["W1"]
    W2 = parameters["W2"]
    
    A1 = cache["A1"]
    A2 = cache["A2"]
    
    dZ2= A2 - Y
    dW2 = (1 / m) * np.dot(dZ2, A1.T)
    db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True)
    dZ1 = np.multiply(np.dot(W2.T, dZ2), 1 - np.power(A1, 2))
    dW1 = (1 / m) * np.dot(dZ1, X.T)
    db1 = (1 / m) * np.sum(dZ1, axis=1, keepdims=True)
    grads = {"dW1": dW1,
             "db1": db1,
             "dW2": dW2,
             "db2": db2 }
    
    return grads

三、完整运行与代码

#!/usr/bin/python
# -*- coding: UTF-8 -*-

"""
@company:UDAI
@author:tianjian
@file:network.py
@time:2021/05/10

"""
import numpy as np
import pandas as pd


def sigmoid(x):
    s = 1 / (1 + np.exp(-x))
    return s


def layer_sizes(X, Y):
    """
    参数：
     X - 输入数据集,维度为（输入的数量，训练/测试的数量）
     Y - 标签，维度为（输出的数量，训练/测试数量）

    返回：
     n_x - 输入层的数量
     n_h - 隐藏层的数量
     n_y - 输出层的数量
    """
    n_x = X.shape[0]  # 输入层
    n_h = 4  # ，隐藏层，硬编码为4
    n_y = Y.shape[0]  # 输出层

    return (n_x, n_h, n_y)


def initialize_parameters(n_x, n_h, n_y):
    """
    参数：
        n_x - 输入层节点的数量
        n_h - 隐藏层节点的数量
        n_y - 输出层节点的数量

    返回：
        parameters - 包含参数的字典：
            W1 - 权重矩阵,维度为（n_h，n_x）
            b1 - 偏向量，维度为（n_h，1）
            W2 - 权重矩阵，维度为（n_y，n_h）
            b2 - 偏向量，维度为（n_y，1）

    """
    np.random.seed(2)  # 指定一个随机种子，以便你的输出与我们的一样。
    W1 = np.random.randn(n_h, n_x) * 0.01
    b1 = np.zeros(shape=(n_h, 1))
    W2 = np.random.randn(n_y, n_h) * 0.01
    b2 = np.zeros(shape=(n_y, 1))

    # 使用断言确保我的数据格式是正确的
    assert (W1.shape == (n_h, n_x))
    assert (b1.shape == (n_h, 1))
    assert (W2.shape == (n_y, n_h))
    assert (b2.shape == (n_y, 1))

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

    return parameters


def forward_propagation(X, parameters):
    """
    参数：
         X - 维度为（n_x，m）的输入数据。
         parameters - 初始化函数（initialize_parameters）的输出

    返回：
         A2 - 使用sigmoid()函数计算的第二次激活后的数值
         cache - 包含“Z1”，“A1”，“Z2”和“A2”的字典类型变量
     """
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    # 前向传播计算A2
    Z1 = np.dot(W1, X) + b1
    A1 = np.tanh(Z1)
    Z2 = np.dot(W2, A1) + b2
    A2 = sigmoid(Z2)
    # 使用断言确保我的数据格式是正确的
    assert (A2.shape == (1, X.shape[1]))
    cache = {"Z1": Z1,
             "A1": A1,
             "Z2": Z2,
             "A2": A2}

    return (A2, cache)


def compute_cost(A2, Y, parameters):
    """
    计算方程（6）中给出的交叉熵成本，

    参数：
         A2 - 使用sigmoid()函数计算的第二次激活后的数值
         Y - "True"标签向量,维度为（1，数量）
         parameters - 一个包含W1，B1，W2和B2的字典类型的变量

    返回：
         成本 - 交叉熵成本给出方程（13）
    """

    m = Y.shape[1]
    W1 = parameters["W1"]
    W2 = parameters["W2"]

    # 计算成本
    logprobs = logprobs = np.multiply(np.log(A2), Y) + np.multiply((1 - Y), np.log(1 - A2))
    cost = - np.sum(logprobs) / m
    cost = float(np.squeeze(cost))

    assert (isinstance(cost, float))

    return cost


def backward_propagation(parameters, cache, X, Y):
    """
    使用上述说明搭建反向传播函数。

    参数：
     parameters - 包含我们的参数的一个字典类型的变量。
     cache - 包含“Z1”，“A1”，“Z2”和“A2”的字典类型的变量。
     X - 输入数据，维度为（2，数量）
     Y - “True”标签，维度为（1，数量）

    返回：
     grads - 包含W和b的导数一个字典类型的变量。
    """
    m = X.shape[1]

    W1 = parameters["W1"]
    W2 = parameters["W2"]

    A1 = cache["A1"]
    A2 = cache["A2"]

    dZ2 = A2 - Y
    dW2 = (1 / m) * np.dot(dZ2, A1.T)
    db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True)
    dZ1 = np.multiply(np.dot(W2.T, dZ2), 1 - np.power(A1, 2))
    dW1 = (1 / m) * np.dot(dZ1, X.T)
    db1 = (1 / m) * np.sum(dZ1, axis=1, keepdims=True)
    grads = {"dW1": dW1,
             "db1": db1,
             "dW2": dW2,
             "db2": db2}

    return grads


def update_parameters(parameters, grads, learning_rate=1.2):
    """
    使用上面给出的梯度下降更新规则更新参数

    参数：
     parameters - 包含参数的字典类型的变量。
     grads - 包含导数值的字典类型的变量。
     learning_rate - 学习速率

    返回：
     parameters - 包含更新参数的字典类型的变量。
    """
    W1, W2 = parameters["W1"], parameters["W2"]
    b1, b2 = parameters["b1"], parameters["b2"]

    dW1, dW2 = grads["dW1"], grads["dW2"]
    db1, db2 = grads["db1"], grads["db2"]

    W1 = W1 - learning_rate * dW1
    b1 = b1 - learning_rate * db1
    W2 = W2 - learning_rate * dW2
    b2 = b2 - learning_rate * db2

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

    return parameters


def nn_model(X, Y, n_h, num_iterations, print_cost=False):
    """
    参数：
        X - 数据集,维度为（2，示例数）
        Y - 标签，维度为（1，示例数）
        n_h - 隐藏层的数量
        num_iterations - 梯度下降循环中的迭代次数
        print_cost - 如果为True，则每1000次迭代打印一次成本数值

    返回：
        parameters - 模型学习的参数，它们可以用来进行预测。
     """

    np.random.seed(3)  # 指定随机种子
    n_x = layer_sizes(X, Y)[0]
    n_y = layer_sizes(X, Y)[2]

    parameters = initialize_parameters(n_x, n_h, n_y)
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    print("initialize_parameters is {}".format(parameters))

    for i in range(num_iterations):
        A2, cache = forward_propagation(X, parameters)
        cost = compute_cost(A2, Y, parameters)
        grads = backward_propagation(parameters, cache, X, Y)
        parameters = update_parameters(parameters, grads, learning_rate=0.3)

        if print_cost:
            if i % 500 == 0:
                print("第 ", i, " 次循环，成本为：" + str(cost))
    return parameters


def predict(parameters, X):
    """
        使用学习的参数，为X中的每个示例预测一个类

        参数：
            parameters - 包含参数的字典类型的变量
            X - 输入数据（n_x，m）

        返回
            predictions - 我们模型预测的向量（红色：0 /蓝色：1）

     """
    A2, cache = forward_propagation(X, parameters)
    predictions = np.round(A2)

    return predictions


if __name__ == '__main__':
    data = pd.read_csv("/Users/tian/Projects/my_learning/算法/data/my_data_guest.csv")
    X = data.iloc[:, 2:].values.T
    Y = data.iloc[:, 1].values.reshape(1, -1)

    parameters = nn_model(X, Y, n_h=4, num_iterations=5000, print_cost=True)

    predictions = predict(parameters, X)
    print('准确率: %d' % float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100) + '%')

结果：

initialize_parameters is w1:(4, 12),b1:(4, 1),w2:(1, 4),b2:(1, 1)
第  0  次循环，成本为：0.6931408605278057
第  500  次循环，成本为：0.4838800210980355
第  1000  次循环，成本为：0.4711467204406175
第  1500  次循环，成本为：0.4674346759771225
第  2000  次循环，成本为：0.4667805426351949
第  2500  次循环，成本为：0.46655892747687916
第  3000  次循环，成本为：0.4664142526117049
第  3500  次循环，成本为：0.4661852602735777
第  4000  次循环，成本为：0.46571144989740265
第  4500  次循环，成本为：0.46486402363012647
准确率: 81%

参考

https://blog.csdn.net/u013733326/article/details/79702148

https://mooc.study.163.com/learn/2001281002?tid=2403041000&trace_c_p_k2=19be870afe394ccab70e07eff9f18a61#/learn/announce

Laughing@me
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从零开始搭建神经网络-卷积神经网络(CNN)
02-24
卷积神经网络的基础内容可以参考：机器学习算法之卷积神经网络卷积神经网络一般包括卷积层，池化层和全连接层，下面分别介绍一下2.1卷积层卷积神经网络里面的这个卷积和信号里面的卷积是有些差别的，信号中的卷积...
TensorFlow搭建神经网络最佳实践样例
marsjhao Blog
06-01 9422
  一、TensorFlow完整样例   在MNIST数据集上，搭建一个简单神经网络结构，一个包含ReLU单元的非线性化处理的两层神经网络。在训练神经网络的时候，使用带指数衰减的学习率设置、使用正则化来避免过拟合、使用滑动平均模型来使得最终的模型更加健壮。 程序将计算神经网络前向传播的部分单独定义一个函数inference，训练部分定义一个train函数，再定义一个主函数main。 完整...
搭建一个简单的神经网络
hanrui4721960的博客
06-15 962
”’def add_layer():最基础的四个参数：输入值，输入的大小，输出的大小和激励函数，激励函数可以自己添加，也可以不使用激励函数。”’ def add_layer(inputs,in_size,out_size,activation_function=None): 接下来我们定义weight和biases weight=tf.Variable(tf.random_norma...
神经网络的构建
最新发布
2205_75881260的博客
03-08 207
人为添加3～5个负采样方案（negative samples），target=0。3.数据训练：通过指定的滑动窗口，持续地改变输入input和输出output。1.词向量：一般维度在50～300维之间，维度越高，数据的精确度就越高。二级分类：输入值是两个单词，输出值是两个单词是否具有相邻关系的概率。2.skip-gram模型可以输入值，得到相应的相应的上下文。target=1表示是正采样数据，两个词之间具有相邻关系。CBOW模型可以输入上下文，得到中间的预测值。将神经网络想象成一个黑匣子。
搭建简易神经网络（~）
HeLoZhaoFei的博客
03-10 301
参考：《深度学习之Pytorch实战计算机视觉》 该模型只考虑一个隐藏层； 定义四个整型变量； import torch batch_n=100 #一个批次输入的数量 hidden_layer=100 #隐藏层后保留的数据特征个数 input_data=1000 #每个数据包含的数据特征个数 output_data=10 #输出的数据，值为10，代表，我们最后要10个分类结果值 先输入100个具有1000个特征的..
搭建一个简易神经网络（PyTorch）
niexinyu0026的博客
11-22 752
搭建一个简易神经网络（PyTorch） 就是通过对 权重参数（w1，w2） 的更新来优化模型。 一个批次的数据从输入到输出的完整过程是： 先输入 100 个具有 1000 个特征的数据； 经过隐藏层后变成 100 个具有 100 个特征的数据； 再经过输出层后输出 100 个具有 10 个分类结果值的数据； 在得到输出结果之后计算损失并进行后向传播，这样一次模型的训练就完成了。 '''导入必要的包，然后定义 4 个整型变量''' import torch batch_n = 100 #在一个
一文学会用Tensorflow搭建神经网络
02-24
本文来自简书，本文将介绍神经网络的相关知识。读后你将对神经网络有个大概了解,它是如何工作的?如何创建神经网络?讲的很好，浅显易懂，入门首选，而且在有代码，想看视频的也可以去他的。神经网络是一种数学模型，...
搭建神经网络进行分类与回归任务
12-28
搭建神经网络进行分类与回归任务
TensorFlow搭建神经网络最佳实践
12-24
在MNIST数据集上，搭建一个简单神经网络结构，一个包含ReLU单元的非线性化处理的两层神经网络。在训练神经网络的时候，使用带指数衰减的学习率设置、使用正则化来避免过拟合、使用滑动平均模型来使得最终的模型更加...
tensorflow 学习（一）- 搭建一个三层的神经网络
water_93的博客
09-19 1227
一、搭建一个三层的神经网络 定义添加神经层的函数 1.训练的数据 2.定义节点准备接收数据 3.定义神经层：隐藏层和预测层 4.定义 loss 表达式 5.选择 optimizer 使 loss 达到最小 import tensorflow as tf import numpy as np # 添加层 def add_layer(inputs, in_size, out_size, ...
Python实现一个简单三层神经网络的搭建并测试
10-07 2991
废话不多说了，直接步入正题，一个完整的神经网络一般由三层构成：输入层，隐藏层（可以有多层）和输出层。本文所构建的神经网络隐藏层只有一层。一个神经网络主要由三部分构成（代码结构上）：初始化，训练，和预测。首先我们先来初始化这个神经网络吧！
构建基础神经网络（实践篇）
zhanlang619的博客
11-19 1400
构建基础神经网络主要分为四个步骤： 定义训练数据 定义神经层 定义模型 进行模型训练 下面请听我一一为您道来： First:定义训练数据，这里采用Numpy随机定义训练数据 import numpy as np x_data = np.linspace(-1, 1, 300)[:, np.newaxis] # 生成 x noise = np.random.normal(0, 0.05, x_data.shape) # 生成 noise y_data = np.square(x_data)
神经网络的搭建
m0_51816252的博客
05-31 650
关于神经网络的搭建，我们会使用到torch.nn中的一些工具。nn为neural network的缩写。本文主要介绍一些torch.nn中的工具，和使用最多的工具Containers 中的模块。
神经网络(Neural Network)—由浅入深的学习并搭建一个属于自己的神经网络(干货满满)
m0_66360845的博客
10-20 227
近段时间花了大概一周的时间将《Make Your Own Neural Network》这本书仔细阅读了一遍，同时也浏览了它对应的中文版本《Python神经网络编程》。书中有少数几个错误，认真阅读自己能检查出来，这几个错误不会妨碍你学习神经网络。不得不说，这本书写的确实很详细，很适合小白入门Neural Network(简称NN)，我之前也上机器学习的课学过神经网络，但远没有看完这本书理解的深刻。看完了确实收获很大，在此仔细总结一下学到的核心知识，帮助大家更好的理解神经网络。
【机器学习】什么是神经网络？如何去搭建神经网络？神经网络的原理是什么？
m0_51816252的博客
07-13 788
本文主要讲了神经网络的一些基础知识，包括神经网络的原理是什么？以及如何去搭建一个简单的神经网络？相信看完这篇文章，你会对神经网络有所了解
神经网络的基本框架的搭建-nn.Module
qq_55414382的博客
09-29 2469
卷积层是卷积神经网络（CNN）中的核心组件之一，它在图像处理和其他领域的深度学习任务中发挥着重要作用。卷积层通过卷积操作对输入数据进行特征提取和特征映射，具有以下几个主要作用：特征提取：卷积层通过卷积操作从输入数据中提取有用的特征。卷积操作通过滑动窗口的方式在输入数据上进行局部采样，并使用卷积核（也称为滤波器）与采样到的数据进行卷积运算。这样可以检测出输入数据中的边缘、纹理、形状等低级特征。特征映射：卷积层通过应用多个卷积核并对它们的输出进行叠加，生成多个特征映射（feature map）。
【Pytorch】神经网络搭建
m0_61151031的博客
04-16 2304
在之前我们学习了如何用Pytorch去导入我们的数据和数据集，并且对数据进行预处理。接下来我们就需要学习如何利用Pytorch去构建我们的神经网络了。
simulink搭建神经网络
11-12
Simulink是一个功能强大的工具，可以用于搭建神经网络模型。神经网络模型可以用来处理各种类型的数据，并实现各种复杂的任务，如分类、回归、聚类等。 在Simulink中，我们可以使用一系列预定义的神经网络模块来构建...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值