神经网络

最新推荐文章于 2024-12-07 13:51:17 发布
转载 最新推荐文章于 2024-12-07 13:51:17 发布 · 139 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/zenan/p/9341137.html
文章标签：

#人工智能 #大数据 #python

 

浅层神经网络：

神经网络的输出

 

 

矩阵公式：输出=激活函数（输入x权重+偏差）

 

多层感知器识别手写数字：

关键点：

  1. input:[None,784]
  2. output:[None,10]
  3. 隐藏层:256
  4. 如何随机初始化参数
  5. loss函数如何计算
 

随机初始化

weight:
np.random.randn() or np.random.uniform() # 正态分布打破对称性
bias:
初始化为0是可行的。

 

深层神经网络：

深层神经网络

 

 
为什么深层的网络在很多问题上比浅层的好？
 
  1. 前几层学习低层次简单特征
  2. 后几层结合多个简单特征，探测复杂特征
 

深层的网络隐藏单元数量相对较少，隐藏层数目较多，如果浅层的网络想要达到同样的 计算结果则需要指数级增长的单元数量才能达到。

 

参数VS超参数

 
  1. 学习率
  2. 梯度下降循环数量
  3. 隐藏层数
  4. 隐藏层单元数目
  5. 激活函数选择
 

应用深度学习领域，一个很大程度基于经验的过程，凭经验的过程通俗来说，就是试直到你找到合适的数值。

 

改善深层神经网络：

关于训练集、验证集、测试集的划分。

大数据时代，测试集的主要目的是正确评估分类器的性能，
所以，如果拥有百万数据，我们只需要 1000 条数据，便足以评估单个分类器，并且准确评估该分类器的性能.
98%,1%,1%.

 

验证集和测试集要确保同一分布

 

数据归一化：

机器学习模型使用梯度下降法求最优解时，归一化往往非常有必要，否则很难收敛甚至不能收敛，一般归一化操作有两种：

1.最值归一化

 

2. 均值标准差归一化

 

交叉验证集：

 

正则化：

1. 岭回归和lasso回归

2. dropout

3. 数据扩增

4. early stopping(提早停止训练神经网络)

为什么正则化可以减少过拟合？

直观上理解就是如果正则化设置得足够大，权重矩阵

被设置为接近于 0 的值，直观
理解就是把多隐藏单元的权重设为 0，于是基本上消除了这些隐藏单元的影响。

 

梯度消失、梯度爆炸：

解决：随机初始化神经网络参数。

如何初始化神经网络权重参数？

relu激活函数:

w[i] = np.random.randn(shape)*np.sqrt(2/n[i-1]) # n[i-1]:上一层的输入特征数，w[i]这一层的权重系数

#### np.sqrt(1/n[i-1])

#### np.sqrt(2/(n[i-1]+n[i]))   

梯度调试(只在调试的时候使用)：

采用双边误差检验时，我们使用双边误差，（f(θ+x)-f(θ-x)）/2x,因为单边误差(f(θ+x)/x)不够准确。

如果不正确，程序可能有bug需要你去解决。。。

 

Adam优化算法：

 

系统地组织超参调试过程的技巧:

学习率α>隐藏层节点数>mini_batch size >隐藏层数>学习次数

 大量阅读别人的案例。

 

自己实现的DNN封装：

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import r2_score
from sklearn.model_selection import train_test_split



class MlpClassifier():
    """DNN Classifier 二分类"""
    def __init__(self, hiddenNodes, hiddenDeep=3):
        """隐藏层节点数，隐藏层层数"""
        self.hiddenNodes = hiddenNodes
        self.hiddenDeep = hiddenDeep
  
    def fit(self, trainX, trainY, AdamStep, learnRate=0.1,testX=None,testY=None):
        """trainY must be one-hot"""
        trainX,validationX,trainY,validationY = train_test_split(trainX,trainY,test_size=0.1)
        self.input_ = trainX.shape[1]
        self.output_ = 2
        self.trainX_ = trainX
        self.trainY_ = trainY
        self.AdamStep = AdamStep
        self.learnRate = learnRate
  
        dataInput = tf.placeholder(tf.float32, shape=(None, self.input_))
        labelInput = tf.placeholder(tf.float32, shape=(None, self.output_))
        var = locals()
        for i in range(1, self.hiddenDeep + 1):          
            if self.hiddenDeep == 1:
                """深度为1时特殊"""
                var["w" + str(i)] = tf.Variable(tf.random_uniform((self.input_, 1)) * tf.sqrt(2 / self.input_))
                var["b" + str(i)] = tf.Variable(tf.zeros((1, 1)))
                var["layer" + str(i)] = tf.nn.relu(tf.add(tf.matmul(dataInput, var["w" + str(i)]), var["b" + str(i)]))
                break
  
            if i == 1:
                var["w" + str(i)] = tf.Variable(tf.random_uniform((self.input_, self.hiddenNodes)) * tf.sqrt(2 / self.input_))
                var["b" + str(i)] = tf.Variable(tf.zeros((1, self.hiddenNodes)))
                var["layer" + str(i)] = tf.nn.relu(tf.add(tf.matmul(dataInput, var["w" + str(i)]), var["b" + str(i)]))
            elif i == self.hiddenDeep:
                var["w" + str(i)] = tf.Variable(tf.random_uniform((self.hiddenNodes, 1)) * tf.sqrt(2 / self.hiddenNodes))
                var["b" + str(i)] = tf.Variable(tf.zeros((1, self.output_)))
                var["layer" + str(i)] = tf.nn.relu(tf.add(tf.matmul(var["layer" + str(i - 1)], var["w" + str(i)]), var["b" + str(i)]))
            else:
                var["w" + str(i)] = tf.Variable(
                    tf.random_uniform((self.hiddenNodes, self.hiddenNodes)) * tf.sqrt(2 / self.hiddenNodes))
                var["b" + str(i)] = tf.Variable(tf.zeros((1, self.hiddenNodes)))
                var["layer" + str(i)] = tf.nn.relu(tf.add(tf.matmul(var["layer" + str(i - 1)], var["w" + str(i)]), var["b" + str(i)]))
                  
        result = tf.nn.softmax(var["layer" + str(self.hiddenDeep)],axis=1) # [None,2]
        loss = tf.reduce_sum(-labelInput*tf.log(result)) # 交叉熵损失函数
        train = tf.train.AdamOptimizer(learnRate).minimize(loss)
  
          
        # session
        ratios = []
        validations = []
        with tf.Session() as sess:
            sess.run(tf.global_variables_initializer())
            sess.run(tf.local_variables_initializer())
            for i in range(AdamStep):
                sess.run(train,feed_dict={dataInput:trainX,labelInput:trainY})
                trainYHat = sess.run(result,feed_dict={dataInput:trainX})
                ratio = np.sum(np.argmax(trainY,axis=1)==np.argmax(trainYHat,axis=1))/trainY.shape[0]
                ratios.append(ratio)
                  
                validationYHat = sess.run(result,feed_dict={dataInput:validationX})
                validation = np.sum(np.argmax(validationY,axis=1)==np.argmax(validationYHat,axis=1))/validationY.shape[0]
                validations.append(validation)
                  
            # predict
            if testY is not None and testX is not None:
                YHat = sess.run(result, feed_dict={dataInput: testX})
                ratio = np.sum(np.argmax(testY,axis=1)==np.argmax(YHat,axis=1))/testY.shape[0]
                return ratio
              
            elif testY is None and testX is not None:
                YHat = sess.run(result, feed_dict={dataInput: testX})
                return np.argmax(YHat,axis=1)
              
            elif testY is None and testX is None:
              
                x = [i for i in range(1,AdamStep+1)]  
                plt.plot(x,ratios,color="blue",label="train")
                plt.plot(x,validations,color="yellow",label="validation")
                plt.ylim(0,1)
                plt.legend()
                plt.show()
            else:
                print("输入格式错误")
              
    def predict(self,testX,AdamStep):
        YHat = self.fit(self.trainX_,self.trainY_,AdamStep,self.learnRate,testX=testX)
        return YHat
  
    def score(self,testX,testY,AdamStep):
        score = self.fit(self.trainX_,self.trainY_,AdamStep,self.learnRate,testX=testX,testY=testY)
        return score

 
class MlpRegression():
    """DNN Regression"""
   
    def __init__(self, hiddenNodes, hiddenDeep=3):
        """隐藏层节点数，隐藏层层数"""
        self.hiddenNodes = hiddenNodes
        self.hiddenDeep = hiddenDeep
   
    def fit(self, trainX, trainY, AdamStep, learnRate=0.1,testX=None,testY=None):
        """trainY must be one-hot"""
        trainX,validationX,trainY,validationY = train_test_split(trainX,trainY,test_size=0.1)
        self.input_ = trainX.shape[1]
        self.output_ = 1
        self.trainX_ = trainX
        self.trainY_ = trainY
        self.AdamStep = AdamStep
        self.learnRate = learnRate
   
        dataInput = tf.placeholder(tf.float32, shape=(None, self.input_))
        labelInput = tf.placeholder(tf.float32, shape=(None, self.output_))
        var = locals()
        for i in range(1, self.hiddenDeep + 1):         
            if self.hiddenDeep == 1:
                """深度为1时特殊"""
                var["w" + str(i)] = tf.Variable(tf.random_uniform((self.input_, 1)) * tf.sqrt(2 / self.input_))
                var["b" + str(i)] = tf.Variable(tf.zeros((1, 1)))
                var["layer" + str(i)] = tf.nn.relu(tf.add(tf.matmul(dataInput, var["w" + str(i)]), var["b" + str(i)]))
                break
   
            if i == 1:
                var["w" + str(i)] = tf.Variable(tf.random_uniform((self.input_, self.hiddenNodes)) * tf.sqrt(2 / self.input_))
                var["b" + str(i)] = tf.Variable(tf.zeros((1, self.hiddenNodes)))
                var["layer" + str(i)] = tf.nn.relu(tf.add(tf.matmul(dataInput, var["w" + str(i)]), var["b" + str(i)]))
            elif i == self.hiddenDeep:
                var["w" + str(i)] = tf.Variable(tf.random_uniform((self.hiddenNodes, 1)) * tf.sqrt(2 / self.hiddenNodes))
                var["b" + str(i)] = tf.Variable(tf.zeros((1, self.output_)))
                var["layer" + str(i)] = tf.nn.relu(tf.add(tf.matmul(var["layer" + str(i - 1)], var["w" + str(i)]), var["b" + str(i)]))
            else:
                var["w" + str(i)] = tf.Variable(
                    tf.random_uniform((self.hiddenNodes, self.hiddenNodes)) * tf.sqrt(2 / self.hiddenNodes))
                var["b" + str(i)] = tf.Variable(tf.zeros((1, self.hiddenNodes)))
                var["layer" + str(i)] = tf.nn.relu(tf.add(tf.matmul(var["layer" + str(i - 1)], var["w" + str(i)]), var["b" + str(i)]))
                 
        result = var["layer"+str(self.hiddenDeep)]  
        loss = tf.reduce_mean(tf.square(labelInput-result)) # 均方根损失函数       
        train = tf.train.AdamOptimizer(learnRate).minimize(loss)
   
           
        # session
        ratios = []
        validations = []
        with tf.Session() as sess:
            sess.run(tf.global_variables_initializer())
            sess.run(tf.local_variables_initializer())
            for i in range(AdamStep):
                sess.run(train,feed_dict={dataInput:trainX,labelInput:trainY})
                trainYHat = sess.run(result,feed_dict={dataInput:trainX})
                ratio = r2_score(trainY,trainYHat)
                ratios.append(ratio)
                   
                validationYHat = sess.run(result,feed_dict={dataInput:validationX})
                validation = r2_score(validationY,validationYHat)
                validations.append(validation)
                   
            # predict
            if testY is not None and testX is not None:
                YHat = sess.run(result, feed_dict={dataInput: testX})
                ratio = r2_score(testY,YHat)
                return ratio
               
            elif testY is None and testX is not None:
                YHat = sess.run(result, feed_dict={dataInput: testX})
                return YHat
               
            elif testY is None and testX is None:
               
                x = [i for i in range(1,AdamStep+1)] 
                plt.plot(x,ratios,color="blue",label="train")
                plt.plot(x,validations,color="yellow",label="validation")
                plt.ylim(0,1)
                plt.legend()
                plt.show()
            else:
                print("输入格式错误")
               
    def predict(self,testX,AdamStep):
        YHat = self.fit(self.trainX_,self.trainY_,AdamStep,self.learnRate,testX=testX)
        return YHat
   
    def score(self,testX,testY,AdamStep):
        score = self.fit(self.trainX_,self.trainY_,AdamStep,self.learnRate,testX=testX,testY=testY)
        return score

　　

转载于:https://www.cnblogs.com/zenan/p/9341137.html

图神经网络实战（1）——图神经网络(Graph Neural Networks, GNN)基础
盼小辉丶的博客
01-02 12万+
本节全面介绍了图神经网络 (Graph Neural Network, GNN) ，包括其在数据分析和机器学习中的重要性。首先探讨了图作为数据表示的相关概念及其在各个领域的广泛应用；然后深入探讨图学习的重要性，包括不同的应用和技术。最后，重点介绍了 GNN 架构，并对比了它与其他方法之间的原理和性能差异。
PyTorch深度学习实战（3）——使用PyTorch构建神经网络
热门推荐
盼小辉丶的博客
06-13 7万+
PyTorch 是一个用于构建深度神经网络的库，具有灵活性和可扩展性，可以轻松自定义模型。在本节中，我们将使用 PyTorch 库构建神经网络，利用张量对象操作和梯度值计算更新网络权重，并利用 Sequential 类简化网络构建过程，最后还介绍了如何使用 save、load 方法保存和加载模型，以节省模型训练时间。
PyTorch - 12 - 深度学习代码 - ArgMax和缩减Tensor Ops
weixin_48367136的博客
01-11 660
欢迎回到有关神经网络编程的系列文章。 在本文中，我们将学习张量的约简操作。我们将重点介绍常用的argmax（）函数，并了解如何访问张量中的数据。 事不宜迟，让我们开始吧。
使用神经网络拟合argmax函数
csldh的博客
11-14 5273
最近比较闲，听说神经网络可以拟合任意函数，因此尝试使用神经网络拟合argmax函数。 我使用的是pytorch，就是堆叠多层感知机来拟合一个argmax函数。为了防止不收敛，我的输入是一个 20维的向量，要求输出的值是 0~1 范围之内的，0表示第0个数是最大的，1表示第19个数是最大的，0.4表示第15个数是最大的，可以用  int(输出*20) 转回下标。代码如下： import tor...
argmax
qq_74693232的博客
04-22 1286
argmax是一个在编程中常用的函数，特别是在处理数组或张量（tensor）时。argmax意味着它返回数组中最大值的索引。
pytorch argmax_轻松学pytorch构建卷积神经网络
weixin_39812046的博客
11-25 196
点击上方蓝字关注我们微信公众号：OpenCV学堂关注获取更多计算机视觉与深度学习知识网络实现大家好，这个是我的pytorch学习笔记第三篇，主要是使用pytorch来构建一个简单的卷积神经网络，完成mnist手写字符识别。涉及到主要知识点是如何使用torch.nn.Module这个基类来实现一个网络结构定义。这个基类中最重要的是实现自己的forward方法，这个也是自定义网络结构的实现方...
有关TensorFlow里的argmax()函数理解
CoderLife_的博客
06-18 1943
tf.argmax()此函数是对矩阵按行或列计算最大值,并且返回这个最大值所在的下标 For example: import numpy as np test=np.array([[3,2,1],[4,5,6],[9,8,7]]) np.argmax(test,0) 此时 ，结果返回 array([2, 2, 2], dtype=int64) argmax(pre,0)是指 按照数组...
图神经网络实战（6）——使用PyTorch构建图神经网络
盼小辉丶的博客
03-28 1万+
图数据集通常比简单的连接集合更加丰富，因为节点和边可以具有表示分数、颜色、单词等特征。包含这些额外信息在输入数据中对于生成最佳嵌入至关重要。在本节中，我们将使用 Cora 和 Facebook Page-Page 数据集，首先将它们视为表格数据集，观察香草神经网络在节点特征上的表现如何。然后，尝试在神经网络中加入拓扑信息，实现图神经网络 (Graph Neural Networks, GNN) 架构：一个同时考虑节点特征和边的简单模型。最后，我们将比较两种架构的性能。
BP神经网络的人脸识别matlab代码
06-16
BP神经网络，全称为Backpropagation Neural Network，是一种在机器学习领域广泛应用的多层前馈神经网络。这种网络通过反向传播算法进行训练，能够学习输入与输出之间的复杂非线性关系。在本项目中，BP神经网络被用于...
Visio画的卷积神经网络结构图模板
08-24
卷积神经网络（Convolutional Neural Network，简称CNN）是一种深度学习模型，广泛应用于图像识别、计算机视觉等领域。Visio是一款强大的图形设计软件，能够帮助用户轻松创建各种图表，包括复杂的网络结构图。本资源...
神经网络完整模型训练套路
深浅卡布星的博客
10-19 2244
pytorch
pytorch minist
James_bobo的博客
12-20 513
导入相关库 import torch from torch import nn from torch.nn import functional as F from torch import optim import torchvision from matplotlib import pyplot as plt from utils import plot_image, plot_curve,...
神经网络入门实战：（十八）Argmax函数的详细介绍，可以用来计算模型训练准确率
最新发布
qq_51409113的博客
12-07 2026
详细介绍了神经网路中用于计算模型训练准确率的Argmax函数
argmax函数_TensorFlow从0到1 - 14 - 交叉熵损失函数——克服学习缓慢
weixin_39605345的博客
11-20 328
通过上一篇 13 驯兽师：神经网络调教综述，对神经网络的调教有了一个整体印象，本篇从学习缓慢这一常见问题入手，根据Michael Nielsen的《Neural Networks and Deep Learning》chap3 Improving the way neural networks learn中的建议，引入交叉熵损失函数，并分析它是如何克服学习缓慢问题。“严重错误”导致学习缓慢回顾识别...
pytorch argmax_怎样克服神经网络训练中argmax的不可导性？
weixin_39935654的博客
11-27 728
公众号关注“ML_NLP”设为 “星标”，重磅干货，第一时间送达！来自 |知乎地址 |https://www.zhihu.com/question/422373907/answer/1490072620?作者 | Zhenyue Qin编辑 |机器学习算法与自然语言处理公众号本文仅作学术分享，若侵权，请联系后台删文处理有个东西叫strainght through Gumbel (...
max 和 argmax (matlab)
Adultf的专栏
02-14 1万+
y = f(t) 是一般常見的函数式，如果給定一個t值，f（t）函数式會赋一個值給y。 y = max f(t) 代表：y 是f(t)函式所有的值中最大的output。 y = arg max f(t) 代表：y 是f(t)函式中，會產生最大output的那個參數t。 看起來很模糊，舉個例子應該比較好理解： 假設有一個函式 f(t)，t 的可能範圍是 {0,1,2}
神经网络之softmax函数，np.argmax（）方法
weixin_44229976的博客
03-15 920
输出层softmax函数公式： 由公式和图可知输出yi和每一个ai有关。 实例python3.代码： def softmax(a): c = np.max(a) exp_a = np.exp(a - c) # 溢出对策 sum_exp_a = np.sum(exp_a) y = exp_a / sum_exp_a return y # coding: utf-8 import sys, os sys.path.append(os.pardir) # 为了导入
TensorFlow：最大最小值、均值、和、softmax 及 argmax 的应用
南淮北安的博客
12-27 9083
文章目录一、最大最小值、均值、和二、softmax 和 argmax 一、最大最小值、均值、和 通过 tf.reduce_max, tf.reduce_min, tf.reduce_mean, tf.reduce_sum 可以求解张量在某个维度上的最大、最小、均值、和，也可以求全局最大、最小、均值、和信息。 考虑 shape 为[4,10]的张量，其中第一个维度代表样本数量，第二个维度代表了当前样...
【Tensorflow】tf.nn.relu函数
zj360202的专栏
04-20 2万+
tf.nn.relu(features, name=None)  = max(0, features) 参数： features：A `Tensor`. 必须类型: `float32`, `float64`, `int32`, `int64`, `uint8`, `int16`, `int8`, `uint16`, `half`. name：名称 返回：Tensor
MATLAB神经网络人脸识别代码与图像实例
本知识点将围绕“人脸识别代码实例下载”这一主题，详细解释神经网络在人脸识别中的应用以及如何利用MATLAB这一工具来实现人脸识别。 ### 知识点一：人脸识别技术概述 人脸识别技术是指通过计算机视觉技术，使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值