精华内容
下载资源
问答
  • 吴恩达深度学习第一周编程题2导入模块import math import numpy as np import h5py import matplotlib.pyplot as plt import scipy from PIL import Image from scipy import ndimage ...from tensorflow.python...

    吴恩达深度学习第一周编程题2

    导入模块

    import math
    import numpy as np
    import h5py
    import matplotlib.pyplot as plt
    import scipy
    from PIL import Image
    from scipy import ndimage
    import tensorflow as tf
    from tensorflow.python.framework import ops
    from cnn_utils import *
    
    %matplotlib inline
    np.random.seed(1)

    导入训练数据和测试数据

    # Loading the data (signs)
    X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()

    显示第6张训练图片

    # Example of a picture
    index = 6
    plt.imshow(X_train_orig[index])
    print ("y = " + str(np.squeeze(Y_train_orig[:, index])))

    查看训练图片的个数和信息

    X_train = X_train_orig/255.
    X_test = X_test_orig/255.
    Y_train = convert_to_one_hot(Y_train_orig, 6).T
    Y_test = convert_to_one_hot(Y_test_orig, 6).T
    print ("number of training examples = " + str(X_train.shape[0]))
    print ("number of test examples = " + str(X_test.shape[0]))
    print ("X_train shape: " + str(X_train.shape))
    print ("Y_train shape: " + str(Y_train.shape))
    print ("X_test shape: " + str(X_test.shape))
    print ("Y_test shape: " + str(Y_test.shape))
    conv_layers = {}

    tensorflow创建占位符

    # GRADED FUNCTION: create_placeholders
    
    def create_placeholders(n_H0, n_W0, n_C0, n_y):
        """
        Creates the placeholders for the tensorflow session.
        
        Arguments:
        n_H0 -- scalar, height of an input image
        n_W0 -- scalar, width of an input image
        n_C0 -- scalar, number of channels of the input
        n_y -- scalar, number of classes
            
        Returns:
        X -- placeholder for the data input, of shape [None, n_H0, n_W0, n_C0] and dtype "float"
        Y -- placeholder for the input labels, of shape [None, n_y] and dtype "float"
        """
    
        ### START CODE HERE ### (≈2 lines)
        X = tf.placeholder(tf.float32,[None, n_H0, n_W0, n_C0, n_y])
        Y = tf.placeholder(tf.float32,[None, n_y])
        ### END CODE HERE ###
        
        return X, Y

    测试占位符

    X, Y = create_placeholders(64, 64, 3, 6)
    print ("X = " + str(X))
    print ("Y = " + str(Y))

    tensorflow初始化参数

    # GRADED FUNCTION: initialize_parameters
    
    def initialize_parameters():
        """
        Initializes weight parameters to build a neural network with tensorflow. The shapes are:
                            W1 : [4, 4, 3, 8]
                            W2 : [2, 2, 8, 16]
        Returns:
        parameters -- a dictionary of tensors containing W1, W2
        """
        
        tf.set_random_seed(1)                              # so that your "random" numbers match ours
            
        ### START CODE HERE ### (approx. 2 lines of code)
        W1 = tf.get_variable("W1", [4,4,3,8],initializer=tf.contrib.layers.xavier_initializer(seed = 0))
        W2 = tf.get_variable("W2",[2,2,8,16],initializer=tf.contrib.layers.xavier_initializer(seed = 0))
        ### END CODE HERE ###
    
        parameters = {"W1": W1,
                      "W2": W2}
        
        return parameters

    测试初始化代码

    tf.reset_default_graph()
    with tf.Session() as sess_test:
        parameters = initialize_parameters()
        init = tf.global_variables_initializer()
        sess_test.run(init)
        print("W1 = " + str(parameters["W1"].eval()[1,1,1]))
        print("W2 = " + str(parameters["W2"].eval()[1,1,1]))

    Tensorflow向前传播

    def forward_propagation(X, parameters):  
            """ 
            Implements the forward propagation for the model: 
            CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED 
             
            Arguments: 
            X -- input dataset placeholder, of shape (input size, number of examples) 
            parameters -- python dictionary containing your parameters "W1", "W2" 
                          the shapes are given in initialize_parameters 
         
            Returns: 
            Z3 -- the output of the last LINEAR unit 
            """  
              
            # Retrieve the parameters from the dictionary "parameters"   
            W1 = parameters['W1']  
            W2 = parameters['W2']  
              
            ### START CODE HERE ###  
            # CONV2D: stride of 1, padding 'SAME'  
            Z1 = tf.nn.conv2d(X,W1,strides=[1,1,1,1],padding='SAME')  
            # RELU  
            A1 = tf.nn.relu(Z1)  
            # MAXPOOL: window 8x8, sride 8, padding 'SAME'  
            P1 = tf.nn.max_pool(A1,ksize=[1,8,8,1],strides=[1,8,8,1],padding='SAME')  
            # CONV2D: filters W2, stride 1, padding 'SAME'  
            Z2 = tf.nn.conv2d(P1,W2,strides=[1,1,1,1],padding='SAME')  
            # RELU  
            A2 = tf.nn.relu(Z2)  
            # MAXPOOL: window 4x4, stride 4, padding 'SAME'  
            P2 = tf.nn.max_pool(A2,ksize=[1,4,4,1],strides=[1,4,4,1],padding='SAME')  
            # FLATTEN  
            P2 = tf.contrib.layers.flatten(P2)  
            # FULLY-CONNECTED without non-linear activation function (not not call softmax).  
            # 6 neurons in output layer. Hint: one of the arguments should be "activation_fn=None"   
            Z3 = tf.contrib.layers.fully_connected(P2,6,activation_fn=None)  
            ### END CODE HERE ###  
          
            return Z3  

    测试向前传播

        tf.reset_default_graph()  
          
        with tf.Session() as sess:  
            np.random.seed(1)  
            X, Y = create_placeholders(64, 64, 3, 6)  
            parameters = initialize_parameters()  
            Z3 = forward_propagation(X, parameters)  
            init = tf.global_variables_initializer()  
            sess.run(init)  
            a = sess.run(Z3, {X: np.random.randn(2,64,64,3), Y: np.random.randn(2,6)})  
            print("Z3 = " + str(a))  

    tensflow建模

    # GRADED FUNCTION: model
    
    def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.009,
              num_epochs = 100, minibatch_size = 64, print_cost = True):
        """
        Implements a three-layer ConvNet in Tensorflow:
        CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED
        
        Arguments:
        X_train -- training set, of shape (None, 64, 64, 3)
        Y_train -- test set, of shape (None, n_y = 6)
        X_test -- training set, of shape (None, 64, 64, 3)
        Y_test -- test set, of shape (None, n_y = 6)
        learning_rate -- learning rate of the optimization
        num_epochs -- number of epochs of the optimization loop
        minibatch_size -- size of a minibatch
        print_cost -- True to print the cost every 100 epochs
        
        Returns:
        train_accuracy -- real number, accuracy on the train set (X_train)
        test_accuracy -- real number, testing accuracy on the test set (X_test)
        parameters -- parameters learnt by the model. They can then be used to predict.
        """
        
        ops.reset_default_graph()                         # to be able to rerun the model without overwriting tf variables
        tf.set_random_seed(1)                             # to keep results consistent (tensorflow seed)
        seed = 3                                          # to keep results consistent (numpy seed)
        (m, n_H0, n_W0, n_C0) = X_train.shape             
        n_y = Y_train.shape[1]                            
        costs = []                                        # To keep track of the cost
        
        # Create Placeholders of the correct shape
        ### START CODE HERE ### (1 line)
        X, Y = create_placeholders(n_H0,n_W0,n_C0,n_y)
        ### END CODE HERE ###
    
        # Initialize parameters
        ### START CODE HERE ### (1 line)
        parameters = initialize_parameters()
        ### END CODE HERE ###
        
        # Forward propagation: Build the forward propagation in the tensorflow graph
        ### START CODE HERE ### (1 line)
        Z3 = forward_propagation(X,parameters)
        ### END CODE HERE ###
        
        # Cost function: Add cost function to tensorflow graph
        ### START CODE HERE ### (1 line)
        cost = compute_cost(Z3,Y)
        ### END CODE HERE ###
        
        # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer that minimizes the cost.
        ### START CODE HERE ### (1 line)
        optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
        ### END CODE HERE ###
        
        # Initialize all the variables globally
        init = tf.global_variables_initializer()
         
        # Start the session to compute the tensorflow graph
        with tf.Session() as sess:
            
            # Run the initialization
            sess.run(init)
            
            # Do the training loop
            for epoch in range(num_epochs):
    
                minibatch_cost = 0.
                num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set
                seed = seed + 1
                minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)
    
                for minibatch in minibatches:
    
                    # Select a minibatch
                    (minibatch_X, minibatch_Y) = minibatch
                    # IMPORTANT: The line that runs the graph on a minibatch.
                    # Run the session to execute the optimizer and the cost, the feedict should contain a minibatch for (X,Y).
                    ### START CODE HERE ### (1 line)
                    sess.run(optimizer,feed_dict={X:minibatch_X,Y:minibatch_Y})
                    temp_cost = sess.run(cost,feed_dict={X:minibatch_X,Y:minibatch_Y})
                    ### END CODE HERE ###
                    
                    minibatch_cost += temp_cost / num_minibatches
                    
    
                # Print the cost every epoch
                if print_cost == True and epoch % 5 == 0:
                    print ("Cost after epoch %i: %f" % (epoch, minibatch_cost))
                if print_cost == True and epoch % 1 == 0:
                    costs.append(minibatch_cost)
            
            
            # plot the cost
            plt.plot(np.squeeze(costs))
            plt.ylabel('cost')
            plt.xlabel('iterations (per tens)')
            plt.title("Learning rate =" + str(learning_rate))
            plt.show()
    
            # Calculate the correct predictions
            
            predict_op = tf.argmax(Z3, 1)
            correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))
            
            # Calculate accuracy on the test set
            accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
            print(accuracy)
            train_accuracy = accuracy.eval({X: X_train, Y: Y_train})
            test_accuracy = accuracy.eval({X: X_test, Y: Y_test})
            print("Train Accuracy:", train_accuracy)
            print("Test Accuracy:", test_accuracy)
                    
            return train_accuracy, test_accuracy, parameters

    训练和预测

    , _, parameters = model(X_train, Y_train, X_test, Y_test) 

    展开全文
  • python3_实现BP神经网络 + BP神经网络应用实例

    万次阅读 多人点赞 2018-07-29 22:10:28
    BP神经网络是1986年由Rumelhart和McClelland为首的科学家提出的概念,是一种按照逆向传播算法训练的多层前馈神经网络,是目前应用最广泛的神经网络。 优点:具有任意复杂的模式分类能力和优良的多维函数映射能力,...

    0.目录

    1.BP神经网络简介

    2.前期理论准备

    2.算法数学原理

    (一)符号说明

    (二)公式推导

    3.python实现(python3编程实现)

    (一)sigmoid函数

    (二)BP主函数实现

    4.数据格式

    1.BP神经网络简介

    BP神经网络是1986年由Rumelhart和McClelland为首的科学家提出的概念,是一种按照逆向传播算法训练的多层前馈神经网络,是目前应用最广泛的神经网络。

    目录

    0.目录

    1.BP神经网络简介

    2.前期理论准备

    2.算法数学原理

    (一)符号说明

    (二)公式推导

    3.python实现(python3编程实现)

    (一)sigmoid函数

    (二)BP主函数实现

    4.数据格式


    优点

    • 1.具有任意复杂的模式分类能力和优良的多维函数映射能力,解决了简单感知器不能解决的异或问题的问题(参考博客:https://www.jianshu.com/p/a25788130897 或 https://www.cnblogs.com/xym4869/p/11282469.html
    • 2.从结构上讲,BP神经网络具有输入层、隐含层和输出层
    • 3.从本质上讲,BP算法就是以网络误差平方目标函数、采用梯度下降法来计算目标函数的最小值。基本BP算法包括信号的前向传播误差的反向传播两个过程。

    缺点

    • 1.学习速度慢,即使是一个简单的过程,也需要几百次甚至上千次的学习才能收敛。
    • 2.容易陷入局部极小值
    • 3.网络层数、神经元个数的选择没有相应的理论指导
    • 4.网络推广能力有限。

    应用

    • 1.函数逼近
    • 2.模式识别
    • 3.分类
    • 4.数据压缩

    2.前期理论准备

    网络训练的目标:找到合适的权值和阈值,使得误差E最小。

    sigmoid函数:在信息科学当中,由于其单增以及其反函数单增等性质,sigmoid函数常被用作神经网络的阈值函数,将变量映射当0和1之间。(该函数的对x的求导也应该理解)

    2.算法数学原理

    (一)符号说明

    Xi: 输入信号。

    Xd: 隐层的阈值(是从求和函数中-θ中分离出的-1)。

    Vih: 第h个隐层神经元所对应输入信号Xi的权值。

    αh: 第h个隐层神经元的输入。

    -γh=--1*γh:隐层神经元的阈值。

    bh: 第h个隐层神经元的输入。

    ωhj: 第j个输出层神经元所对应的隐层神经元输出bh的权值。

    -θj=-1*θj:  输出层神经元的阈值(bq)

    :第j个输出层神经元的输出(预测输出值,yj为真实值)

    (二)公式推导

    通过公式变换可得输出层权值与阈值的变化量:

    同理可得隐层权值和阈值的变化量:

    3.python实现(python3编程实现)

    (一)sigmoid函数

    def sigmoid(x):
        """
        隐含层和输出层对应的函数法则
        """
        return 1/(1+np.exp(-x))
    

    (二)BP主函数实现

    def BP(data_tr, data_te, maxiter=600):
    
        # --pandas是基于numpy设计的,效率略低
        # 为提高处理效率,转换为数组
        data_tr, data_te = np.array(data_tr), np.array(data_te)
    
        # --隐层输入
        # -1: 代表的是隐层的阈值
        net_in = np.array([0.0, 0, -1])
        w_mid = np.random.rand(3, 4)          # 隐层权值阈值(-1x其中一个值:阈值)
    
        # 输出层输入
        # -1:代表输出层阈值
        out_in = np.array([0.0, 0, 0, 0, -1])
        w_out = np.random.rand(5)             # 输出层权值阈值(-1x其中一个值:阈值)
        delta_w_out = np.zeros([5])           # 存放输出层权值阈值的逆向计算误差
        delta_w_mid = np.zeros([3, 4])        # 存放因此能权值阈值的逆向计算误差
        yita = 1.75                           # η: 学习速率
        Err = np.zeros([maxiter])             # 记录总体样本每迭代一次的错误率
    
        # 1.样本总体训练的次数
        for it in range(maxiter):
    
            # 衡量每一个样本的误差
            err = np.zeros([len(data_tr)])
    
            # 2.训练集训练一遍
            for j in range(len(data_tr)):
                net_in[:2] = data_tr[j, :2]                       # 存储当前对象前两个属性值
                real = data_tr[j, 2]
    
                # 3.当前对象进行训练
                for i in range(4):
                    out_in[i] = sigmoid(sum(net_in*w_mid[:, i]))  # 计算输出层输入
                res = sigmoid(sum(out_in * w_out))                # 获得训练结果
    
                err[j] = abs(real - res)
    
                # --先调节输出层的权值与阈值
                delta_w_out = yita*res*(1-res)*(real-res)*out_in  # 权值调整
                delta_w_out[4] = -yita*res*(1-res)*(real-res)     # 阈值调整
                w_out = w_out + delta_w_out
    
                # --隐层权值和阈值的调节
                for i in range(4):
                    # 权值调整
                    delta_w_mid[:, i] = yita * out_in[i] * (1 - out_in[i]) * w_out[i] * res * (1 - res) * (real - res) * net_in
                    # 阈值调整
                    delta_w_mid[2, i] = -yita * out_in[i] * (1 - out_in[i]) * w_out[i] * res * (1 - res) * (real - res)
                w_mid = w_mid + delta_w_mid
            Err[it] = err.mean()
        plt.plot(Err)
        plt.show()
    
        # 存储预测误差
        err_te = np.zeros([100])
    
        # 预测样本100个
        for j in range(100):
            net_in[:2] = data_te[j, :2]                         # 存储数据
            real = data_te[j, 2]                                # 真实结果
    
            # net_in和w_mid的相乘过程
            for i in range(4):
                # 输入层到隐层的传输过程
                out_in[i] = sigmoid(sum(net_in*w_mid[:, i]))
            res = sigmoid(sum(out_in*w_out))                    # 网络预测结果输出
            err_te[j] = abs(real-res)                           # 预测误差
            print('res:', res, ' real:', real)
        
        plt.plot(err_te)
        plt.show()
    
    
    
    
    if "__main__" == __name__:
    
        # 1.读取样本
        data_tr = pd.read_csv("5.2 data_tr.txt")
        data_te = pd.read_csv("5.2 data_te.txt")
        BP(data_tr, data_te, maxiter=600)

    4.数据格式

    展开全文
  • python神经网络应用

    2019-05-28 19:30:08
    alexNet 卷积块11*11 VGG 卷积块变小 3*3 resNet变深 1*1卷积层 ......

    alexNet 卷积块11*11    VGG 卷积块变小 3*3   resNet变深  1*1卷积层

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    \

     

     

     

     

     

      基于统计

      word2vec 不能去隐藏层

     

     

     

     

    展开全文
  • 文章目录 前言 1. 安装Tensorflow-gpu 安装版本 系统变量 pip install tensorflow-gpu==版本号 安装测试 2. 数据基础—张量 张量的轴(axis) 张量降维函数reduce_...具体来说,采用全连接网络和卷积神经网络分别实现...

    前言

    学习资料来源Tensorflow中文社区

    1. 安装Tensorflow-gpu

    Tensorflow有CPU版本和GPU加速两个版本,GPU加速版本在处理大型图像识别任务的时候速度会更快一些,但要求安装Cuda和cudnn,这对显卡有要求(本机显卡Nvidia GTX1060)。

    安装版本

    • Python的IDE为Pycharm,Tensorflow各个版本需要匹配python和Cuda以及cudnn,在安装前首先看看自己显卡支持的Cuda最高到版本(如下图在“帮助”—>“系统信息”里面看到,已经支持Cuda10了),现在最高版本的tensorflow只需要Cuda9,所以安装Cuda9,推荐版本:Python/Cuda/cudnn匹配版本
      在这里插入图片描述
      在这里插入图片描述

    系统变量

    • 安装Cuda,之前会检查兼容性,不兼容的话可以不用管,也能安装使用,然后一路默认安装即可。完成后将cudnn解压后的所有文件复制粘贴到Cuda对应的文件夹下C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.0。
    • 用户变量Path下添加:
      • C:\ProgramData\NVIDIA GPU Computing Toolkit\v9.2;
    • 在系统变量中添加如下几个变量:
      • CUDA_SDK_PATH = C:\ProgramData\NVIDIACorporation\CUDA Samples\v9.2
      • CUDA_LIB_PATH = %CUDA_PATH%\lib\x64
      • CUDA_BIN_PATH = %CUDA_PATH%\bin
      • CUDA_SDK_BIN_PATH = %CUDA_SDK_PATH%\bin\win64
      • CUDA_SDK_LIB_PATH = %CUDA_SDK_PATH%\common\lib\x64

    pip install tensorflow-gpu==版本号

    安装测试

    import tensorflow as tf 
    hello =tf.constant("Hello!TensorFlow")
    sess = tf.Session()
    print(sess.run(hello))
    

    结果

    2. 数据基础—张量

    张量可以简单理解为矩阵,只是这个矩阵可以有很多维度,不仅是平时的一维向量或者二维矩阵。

    张量的轴(axis)

    为了帮助理解轴的概念,可以先简单定义3阶张量的构成(3阶以上张量在欧式空间没法理解):

    • 1、首先每一个单独的元素按照行构成向量,如:[1,2,3],假设沿着1,2,3的方向叫做x向,即向量元素延伸的方向;
    • 2、然后不同的向量沿垂直x的方向顺序放在一起,这个方向叫y向,即向量延伸的方向(注意区分向量元素延伸的方向),进而得到了矩阵,如:
      [[1,2,3],
      [4,5,6],
      [7,8,9]]
      (写成:[[1, 2, 3],[4, 5, 6],[7, 8, 9]])
    • 3、最后,将矩阵沿着垂直于xy平面的方向顺序放在一起,这个方向叫z向,即矩阵延伸的方向,就得到3阶张量(长方体)。
      [[[1, 2, 3],[4, 5, 6],[7, 8, 9]],
      [[4, 5, 6],[7, 8, 6],[1, 3.3, 2]]]

    因此,在3阶张量里面就有三个轴,x,y和z,其中z轴是表示矩阵延伸的方向,这是生成3阶张量的最后一步,把这个轴的索引设为0(理解为索引越小,步骤越靠后);y轴是表示向量延伸的方向,这是倒数第二步,这个轴索引设为1;x轴是表示向量元素 延伸的方向,这是倒数第3步,这个轴索引设为2。对于2阶或者1阶张量,只有沿x方向的1轴和沿y方向的0轴。

    总结一下:沿着哪一个轴延伸的内容级别越高(假设级别高低为:矩阵>向量>元素),则哪一个轴的索引就越低。此外,在索引张量中的元素时候,比如索引3阶张量中的元素,通常用(a0,a1,a2)表示:其中,a0表示被索引元素在0轴(z)上的第a0个矩阵里面;a1表示被索引元素在a0这个矩阵的1轴(y)上的第a1个向量里面;a2表示被索引元素即为a1这个向量里面的2轴(x)上的第a2个元素。例如:上述3阶张量的“3.3”这个元素的索引为(2,3,2)。

    张量降维函数reduce_sum/max/mean/…

    理解了张量的轴,就可以使用reduce_sum/max/mean…这个函数了。之所以讲这个函数,就是因为在神经网络设计损失函数—loss函数时,需要用到reduce。reduce可以理解为降维,将高阶张量降维为低阶张量,后面的sum/max/mean这些可以理解为降维的方法。以sum为例,还是如下矩阵:
    [[1,2,3],
    [4,5,6],
    [7,8,9]]
    首先进行如下运算:

    import tensorflow as tf
    A = tf.constant([[1, 2, 3],[4, 5, 6],[7, 8, 9]], dtype= tf.float32)
    B1 = tf.reduce_sum(A,reduction_indices=0)
    sess = tf.Session()
    print(sess.run(B1))
    

    结果输出:[12. 15. 18.]
    再进行以下运算:

    import tensorflow as tf
    A = tf.constant([[1, 2, 3],[4, 5, 6],[7, 8, 9]], dtype= tf.float32)
    B2 = tf.reduce_sum(A,reduction_indices=1)
    sess = tf.Session()
    print(sess.run(B2))
    

    结果输出:[ 6. 15. 24.]
    可以发现,reduce_sum(A,reduction_indices=)中仅reduction_indices不一样,这个参数就是降维时候的参考轴。对于这个张量,索引轴为0,1。因此,reduction_indices=0时,意味将张量A沿着上述的“y”方向压缩,将这个矩阵上下挤扁,即[1+4+7, 2+5+8, 3+6+9] = [12. 15. 18.];reduction_indices=1时,意味将张量A沿着上述的“x”方向压缩,将这个矩阵左右挤扁,即[1+2+3, 4+5+6, 7+8+9] = [ 6. 15. 24.]。但需要注意,不管是上下挤扁还是左右挤扁,最后输出都会转换为行向量输出。

    (未完待续)

    3. 数学基础—梯度下降

    神经网络在对权值更新时,绝大多数采用误差反向传播与梯度下降的方法。tensorflow已经处理好了方向传播求微分的事情,同时也提供了多种更新梯度的方法,随机梯度下降(Stochastic Gradiant Descent, SGD)、Adagrad、Momentum、Adam等算法。目前没有绝对优的算法,这个在后面会进行对比。

    SGD

    随机梯度下降是最原始一种权值更新方法,表达式为:
    [外链图片转存失败(img-H5myZK15-1562574427149)(https://latex.codecogs.com/png.download?W=W-\eta\frac{\partial L}{\partial W})]
    n为学习率,是一个固定值,取值太小,学习效率低下且容易陷入局部最优,取值太大也有可能跳过最优值,来回跳动误差也很大。此外,上述公式中的梯度(偏导部分)反映的是当前点的坡度下降最大的方向而不一定指向全局最优点。例如,在一个三维曲面优化z,曲面沿着x方向的梯度变化很小,沿着y方向梯度变化很大。此时,如果把学习率取值过小,则沿着x方向的优化过程会很慢,如果学习率取值过大,则沿着y向的误差跳动就很大。

    4. Tensorflow基本操作

    数据流图

    [外链图片转存失败(img-Cph2kumI-1562574427150)(http://www.tensorfly.cn/images/tensors_flowing.gif)]
    上图表示了Tensorflow的计算模式——数据流图(后面一一介绍):

    • 使用图 (graph) 来表示计算任务(可以对比Matlab/Simulink的计算模式).
    • 在被称之为会话 (Session) 的上下文 (context) 中执行图.
    • 使用张量(tensor)表示数据.
    • 通过变量 (Variable) 维护状态.
    • 使用 feed 和 fetch 可以为任意的操作(arbitrary operation) 赋值或者从其中获取数据

    数据流图(Data Flow Graph)?(引用自Tensorflow中文社区)
    数据流图用“结点”(nodes)和“线”(edges)的有向图来描述数学计算。“节点” 一般用来表示施加的数学操作,但也可以表示数据输入(feed in)的起点/输出(push out)的终点,或者是读取/写入持久变量(persistent variable)的终点。“线”表示“节点”之间的输入/输出关系。这些数据“线”可以输运“size可动态调整”的多维数据数组,即“张量”(tensor)。张量从图中流过的直观图像是这个工具取名为“Tensorflow”的原因。一旦输入端的所有张量准备好,节点将被分配到各种计算设备完成异步并行地执行运算。

    基本操作

    • 构建数据流图:构建图的第一步, 是创建源 op (source op),把op当作是上面数据流图中的节点,一个节点的输出可以作为其他节点的输入。把一个个节点创建好,定义好输入输出就形成了数据流图;例如:

      import tensorflow as tf
      # 创建一个常量 op, 产生一个 1x2 矩阵. 这个 op 被作为一个节点
      # 加到默认图中.
      # 构造器的返回值代表该常量 op 的返回值.
      matrix1 = tf.constant([[3., 3.]])
      # 创建另外一个常量 op, 产生一个 2x1 矩阵.
      matrix2 = tf.constant([[2.],[2.]])
      # 创建一个矩阵乘法 matmul op , 把 'matrix1' 和 'matrix2' 作为输入.
      # 返回值 'product' 代表矩阵乘法的结果.
      product = tf.matmul(matrix1, matrix2)
      

      则上述图有三个节点, 两个 constant() op, 和一个matmul() op.

    • 启动图:Tensorflow里面创建了数据流图后,如何运行程序不会有数据输出。上面这个例子,print(produce)的话,输出下面结果:
      在这里插入图片描述
      构造完数据流图后,要启动这个图才可以得到数据输出。启动图的第一步是创建一个 Session 对象:

      # 启动默认图.
      sess = tf.Session()
      # 调用 sess 的 'run()' 方法来执行矩阵乘法 op, 传入 'product' 作为该方法的参数. 
      # 上面提到, 'product' 代表了矩阵乘法 op 的输出, 传入它是向方法表明, 我们希望取回
      # 矩阵乘法 op 的输出.
      # 整个执行过程是自动化的, 会话负责传递 op 所需的全部输入. op 通常是并发执行的.
      # 函数调用 'run(product)' 触发了图中三个 op (两个常量 op 和一个矩阵乘法 op) 的执行.
      # 返回值 'result' 是一个 numpy `ndarray` 对象.
      result = sess.run(product)
      print(result)
      # 任务完成, 关闭会话.
      sess.close()
      

      Session 对象在使用完后需要关闭以释放资源. 除了显式调用 close 外, 也可以使用 “with” 代码块 来自动完成关闭动作:

      with tf.Session() as sess:
          result = sess.run([product])
          print(result)
      

      另外,采用这种方式可以指定CPU或者GPU

      with tf.Session() as sess:
         with tf.device("/gpu:1"):
         ...
      

      设备用字符串进行标识. 目前支持的设备包括:

      • “/cpu:0”: 机器的 CPU.
      • “/gpu:0”: 机器的第一个 GPU, 如果有的话.
      • “/gpu:1”: 机器的第二个 GPU, 以此类推
    • 定义与初始化变量:采用以下方式来定义一个变量:

      # 创建一个变量, 初始化为标量 0.
      state = tf.Variable(0, name="counter")
      

      所有变量定义以后都要进行初始化然后才能参与图计算:

      init = tf.global_variables_initializer() #使用变量,就要对其初始化(以前版本是tf.initialize_all_variables())
      sess = tf.Session() #定义Session,并使用Session来初始化步骤
      sess.run(init)
      sess.close()
      
    • 查看数据流图中的数据:在sess.run()中传入需要的节点。

      input1 = tf.constant(3.0)
      input2 = tf.constant(2.0)
      input3 = tf.constant(5.0)
      intermed = tf.add(input2, input3)
      mul = tf.matmul(input1, intermed)
      
      with tf.Session() as sess:
          result = sess.run([mul, intermed])
          print(result)
      
    • Tensor赋值:在数据流图中,有的tensor需要外接传入参数,比如神经网络的输入参数和标签等。TensorFlow 提供了 feed 机制, 该机制可以临时替代图中的任意操作中的 tensor 可以对图中任何操作提交补丁, 直接插入一个 tensor。
      通常,占位符placeholder与feed配合使用。可以把placeholder看作是定义的一个数据输入接口,数据从placeholder这里传输进数据流图中。用例如下:

      input1 = tf.placeholder(tf.float32)
      input2 = tf.placeholder(tf.float32)
      output = tf.matmul(input1, input2)
      
      with tf.Session() as sess:
          print(sess.run([output], feed_dict={input1:[7.], input2:[2.]}))#feed_dict采用字典的形势“喂”数据
      

    5. Tensorflow—手写数字分类

    神经网络基本概念

    神经网络的基本概念可以参见神经网络浅讲:从神经元到深度学习零基础入门深度学习,很详细。这里介绍利用python/Tensorflow实现手写阿拉伯数字的识别和分类。具体来说,采用全连接网络和卷积神经网络分别实现。样本集采用MNIST数据,里面包含60000组训练数据和10000组测试数据。每组数据都对应着一幅图片和该图片的标签。采用如下代码下载MNIST数据:

    from tensorflow.examples.tutorials.mnist import input_data #导入mnist库
    
    mnist = input_data.read_data_sets('./MNIST_data', one_hot=True) #如果没有mnist数据就进行下载;使用one_hot编码
    print(mnist.test.images.shape, mnist.test.labels.shape)
    

    这里运行可能会提示下载不了数据,拒绝访问。一个解决办法就是自己去网站下载数据,这四个数据包下载以后,不需要自己解压,在主程序目录下新建一个文件夹“MNIST_data”,将数据放在文件夹里面即可。上面程序运行后就会自动在这个文件夹里面解压数据并导入。
    在这里插入图片描述
    之后运行上述程序就会输出以下结果。可以看到,mnist的测试集mnist.test包含图像和标签,图像是一个784个数据的行向量,标签是10个数据的行向量。图片包含灰度图和彩色图等。灰度图的通道为1,也就是用一个2维矩阵就可以表示,每一个像素点的值在0-255之间。RGB彩色图的通道为3,每一个像素点的颜色是由3个值决定的,所以需要用3个二维矩阵表示,也就是三维矩阵。这里的MNIST是灰度图,大小为28x28=784,并且灰度图进行了归一化,在0-1之间。这里将这个28x28的矩阵按一行一行首位相连,排成了1x784的行向量。注意,这就是全连接网络的要求,全连接网络只能处理一维数据,而卷积神经网络可以处理三维数据。数据的标签是一个包含10个元素的向量,比如标签[0,0,0,0,0,1,0,0,0,0],表示这张图片的数字是“5”。

    ...
    Extracting ./MNIST_data\train-images-idx3-ubyte.gz
    ...
    Extracting ./MNIST_data\train-labels-idx1-ubyte.gz
    ...
    Extracting ./MNIST_data\t10k-images-idx3-ubyte.gz
    ...
    Extracting ./MNIST_data\t10k-labels-idx1-ubyte.gz
    (10000, 784) (10000, 10)
    

    全连接网络

    所谓全连接网络,就是指上一层所有的神经元都与下一层的所有神经元连接。比如,输入层有3个神经元,隐藏层有4个神经元,那从输入到隐藏层就有3x4=12个权值。
    在这里插入图片描述
    首先,编写一个用于定义神经网络层的文件,命名为Add_Layer.py

    import tensorflow as tf
    
    #添加一个全链接神经网络层
    def add_affine_layer(inputs, w_shape, b_shape, activation_function = None):
        r'''
        :param inputs:上一层所有神经元的输出数据,shape=[batch, -1]
        :param w_shape:权值矩阵, shape=[n_size, out_size], in_size: 上一层神经元输出数据的列数, out_size: 本层神经元个数
        :param b_shape:偏置矩阵,shape=[out_size]
        :param activation_function: 激活函数
        :return: 本层神经元输出,权值,偏置
        '''
        weights = tf.Variable(tf.random_normal(w_shape, stddev=0.1))#定义权值矩阵.,方差选择很重要
        biases = tf.Variable(tf.constant(0.1, shape=b_shape))#定义偏置
        activation_input = tf.matmul(inputs, weights) + biases#诱导局部阈
        if activation_function is None:
            outputs = activation_input
        else:
            outputs = activation_function(activation_input)
        return outputs, weights, biases
    
    #添加卷积层
    def add_conv_layer(input, w_shape, b_shape, strides=[1, 1, 1, 1], padding='SAME', activation_function=None):
        r'''
        :param input:上层神经元输入,shape=[batch, height, width, channel]
        :param w_shape:卷积核,shape=[height, width, channel, num]
        :param b_shape:偏置,shape=[num]
        :param strides:卷积核滑动步长,shape[1, row_step, col_step, 1]
        :param padding:填充,"SAME"或""VALID",填充算法,参见help(tf.nn.convolution)
        :param activation_function:激活函数
        :return:本层神经元输出,权值,偏置
        '''
        weight = tf.Variable(tf.random_normal(w_shape, stddev=0.1))#定义权值矩阵.,方差选择很重要
        biass = tf.Variable(tf.constant(0.1, shape=b_shape))
        activation_input = tf.nn.conv2d(input, weight, strides=strides, padding=padding) + biass
        if activation_function is None:
            output = activation_input
        else:
            output = activation_function(activation_input)
        return output, weight, biass
    
    #添加池化层
    def add_pool_layer(input, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME', pool_function=tf.nn.max_pool):
        r'''
        :param input:卷积结果
        :param ksize:池化窗大小,shape=[1, height, width, 1]
        :param strides:滑动步长
        :param padding:填充,"SAME"或""VALID",填充算法,help(tf.nn.convolution)
        :param pool_function:池化函数
        :return:池化结果
        '''
        return pool_function(input, ksize=ksize, strides=strides, padding=padding)
    

    然后,构建全连接神经网络Example_Affine.py

    from Add_Layer import *
    from tensorflow.examples.tutorials.mnist import input_data
    
    mnist = input_data.read_data_sets('./MNIST_data', one_hot=True)# 导入数据
    
    xs = tf.placeholder(tf.float32, shape=[None, 784])#定义输入接口,输入图像数据
    ys = tf.placeholder(tf.float32, shape=[None, 10])#定义输入接口,输入图像标签
    
    l1, w1, b1 = add_affine_layer(xs, [784, 10], [1, 10], activation_function=tf.nn.softmax)#定义一层全连接网络,输入直接到输出
    
    Loss = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(l1), 1))#定义代价函数,交叉熵函数
    train = tf.train.AdagradOptimizer(0.5).minimize(Loss)
    accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(l1, 1), tf.argmax(ys, 1)), tf.float32))#计算神经网络的精度
    
    '''初始化变量,必须有'''
    sess = tf.InteractiveSession()
    ini = tf.global_variables_initializer()
    sess.run(ini)
    
    for i in range(10000):
        x, y = mnist.train.next_batch(100)
        sess.run(train, feed_dict={xs: x, ys: y})
        if i%100 == 0:#每隔100个对比一下测试精度和训练精度
            train_accuracy = accuracy.eval(feed_dict={xs: x, ys: y})
            test_accuracy = accuracy.eval(feed_dict={xs: mnist.test.images, ys: mnist.test.labels})
            print(train_accuracy, test_accuracy)
    

    这个测试精度在91%左右。

    卷积神经网络

    在这里插入图片描述
    同样,用上面的神经网络层定义卷积神经网络。这里的卷积网络为:“输入-卷积层-Relu-池化-卷积-Relu-池化-全连接-Relu-全连接-Softmax-输出”

    from Add_Layer import *
    from tensorflow.examples.tutorials.mnist import input_data
    
    mnist = input_data.read_data_sets('./MNIST_data', one_hot=True)
    
    xs = tf.placeholder("float")
    ys = tf.placeholder("float", [None, 10])
    xs_in = tf.reshape(xs, [-1, 28, 28, 1])
    
    l1, w1, b1 = add_conv_layer(xs_in, [5, 5, 1, 32], [32], activation_function=tf.nn.relu)#定义卷积层
    p1 = add_pool_layer(l1)#定义池化层
    
    l2, w2 , b2 = add_conv_layer(p1, [5, 5, 32, 64], [64], activation_function=tf.nn.relu)
    p2 = add_pool_layer(l2)
    
    l3_in = tf.reshape(p2, [-1, 64*49])#因为全连接层只支持一维数据,所以要将64个特征图全部展开成一行
    l3, w3, b3 = add_affine_layer(l3_in, [64*49, 1024], [1024], activation_function=tf.nn.relu)#定义全连接层
    
    l4, w4, b4 = add_affine_layer(l3, [1024, 10], [10], activation_function=tf.nn.softmax)
    
    Loss = tf.reduce_mean(-tf.reduce_sum(ys*tf.log(l4), 1))
    train = tf.train.AdamOptimizer(1e-4).minimize(Loss)
    accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(l4, 1), tf.argmax(ys, 1)), "float"))
    
    sess = tf.InteractiveSession()
    ini = tf.global_variables_initializer()
    sess.run(ini)
    
    for i in range(1000):
        x_train, y_train = mnist.train.next_batch(50)
        sess.run(train, feed_dict={xs: x_train, ys: y_train})
        if i % 100 == 0:
            train_accuracy = accuracy.eval(feed_dict={xs: x_train, ys: y_train})
            test_accuracy = accuracy.eval(feed_dict={xs:mnist.test.images, ys: mnist.test.labels})
            print(train_accuracy, test_accuracy)
    

    这个测试精度在99%

    展开全文
  • Python实现神经网络(零基础篇)

    千次阅读 多人点赞 2020-07-17 15:37:18
    并以此为基础,在未来方向的几篇文章将以Python为工具,应用几种较为典型的神经网络以及如何对神经网络进行全方位的优化。本文涉及到数列的简单计算、函数以及类的定义、全连结神经网络的运算方式、损失函数、计算图...
  • Python神经网络编程

    2021-05-09 15:59:54
    Python神经网络的编程实现和简单应用
  • 神经网络/人工神经网络的洋文是Neural Network,这个计算模型在上世纪40年代就出现了,但是直到2011、2012年由于大数据和深度学习的兴起,神经网络才得到广泛应用。 参看wiki神经网络:...
  • 神经网络/人工神经网络的洋文是Neural Network,这个计算模型在上世纪40年代就出现了,但是直到2011、2012年由于大数据和深度学习的兴起,神经网络才得到广泛应用。 参看wiki神经网络:...
  • 主要为大家详细介绍了Python实现神经网络(BP)算法及简单应用,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • BP(back propagation)神经网络是1986年由Rumelhart和McClelland为首的科学家提出的概念,是一种按照误差逆向传播算法训练的多层前馈神经网络,是目前应用最广泛的神经网络。 我们用BP神经网络来解决非线性的二分类...
  • CIFAR10 小图片分类:具有实时数据增强的卷积神经网络 (CNN) IMDB 电影评论情感分类:基于词序列的 LSTM Reuters 新闻主题分类:多层感知器 (MLP) MNIST 手写数字分类:MLP 和 CNN 基于 LSTM 的字符级文本生成 基于...
  • Python-BP神经网络

    2021-01-11 21:22:00
    1.BP (Back Propagation) 神经网络是1986年由Rumelhart和McClelland为首的科学家提出的概念,是一种按照误差逆向传播算法训练的多层前馈神经网络,是应用最广泛的神经网络。 2.BP神经网络的结构 BP神经网络是一种...
  • Python-图形神经网络GNN

    2019-08-11 03:38:49
    图形神经网络(GNN)主要用于分子应用,因为分子结构可以用图形结构表示。 GNN的有趣之处在于它可以有效地建模系统中对象之间的关系或交互。 GNN有各种应用,例如分子应用,网络分析和物理建模。
  • 本文来自于个人博客,这篇文章主要为大家详细介绍了python机器学习之神经网络的实现方法。神经网络在机器学习中有很大的应用,甚至涉及到方方面面。本文主要是简单介绍一下神经网络的基本理论概念和推算。同时也会...
  • 主要为卷积神经网络中的bn层应用,bn层也是一个数据处理的方式,一般位于非线性激活层之前,全连接层之后,本资源涵盖4个代码,分别为bn层建立,cn层在实例中的应用,bn层测试以及有无bn层的对比,供大家更好地了解...
  • 具体是有哪些功能模块,每个库怎么用之类的教程? 因为现在想用Python编写神经网络,据说Tensorflow用的比较多,
  • 本书用轻松的笔触,一步一步揭示了神经网络的数学思想,并介绍如何使用Python编程语言开发神经网络。 本书将带领您进行一场妙趣横生却又有条不紊的旅行——从一个非常简单的想法开始,逐步理解神经网络的工作机制。...
  • 一、Python神经网络编程(Tariq Rashid著) 二、CSDN博客以及简书 矩阵与神经网络 在上一节,我们已经讨论了一个简单的神经网络的由来和构造。我们选择了S函数作为每一个神经元的行为函数(即该神经元的输入*S函数=...
  • bp神经网络matlab源码用 Python 编程 ANN 为什么选择 Python 简单易学 非常易读的代码(易于遵循结构) 程序、面向对象和功能元素都在一定程度上存在 适用于所有平台 完全免费 广泛应用于科学计算(与 MATLAB、...
  • 竞争型学习神经网络 简述 最近对神经网络比较感兴趣,因此花了两三天时间对整个领域...事实上在21世纪之前,各种各样的神经网络模型已经被发明并应用。那时候由于硬件性能的限制,以及由通信网络不发达导致的数据量...
  • 神经网络算法应用举例子 理论参加上一篇博客。 1. 关于非线性转化方程(non-linear transformation function) sigmoid函数(S 曲线)用来作为activation function:  1.1 双曲函数(tanh)   1.2 逻辑函数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,477
精华内容 590
关键字:

python应用神经网络

python 订阅