zoukankan      html  css  js  c++  java
  • tensorFlow入门实践(二)模块化

    实现过一个例子之后,对TensorFlow运行机制有了初步的了解,但脑海中还没有一个如何实现神经网络的一个架构模型。下面我们来探讨如何模块化搭建神经网络,完成数据训练和预测。

    首先我们将整体架构分为两个模块:

    forward.py 和 backward.py

    forward.py  主要完成神经网络模型的搭建,即构建计算图

    backward.py 训练出网络参数

    test.py 测试模型准确率

    下面是用随机生成数据来完成整个过程,如果对上面的总结理解不是很清楚的话,看着下面具体的代码,对照上面提出的框架,可以更好地理解。

     generateds.py 生成数据

    import numpy as np
    import matplotlib.pyplot as plt
    seed = 2
    def generateds():
        #基于seed产生随机数
        rdm = np.random.RandomState(seed)
        #随机数返回200列2行的矩阵,表示300组坐标点(x0,x1)作为输入数据集
        X = rdm.randn(300,2)
        #如果X中的2个数的平方和<2,y=1,否则y=2
        #作为输入数据集的标签(正确答案)
        Y_ = [int(x0*x0 + x1*x1 <2) for (x0,x1) in X]
        #为方便可视化,遍历Y_中的每个元素,1为红,0为蓝
        Y_c = [['red' if y else 'blue'] for y in Y_]
        #对数据集X和标签Y进行形状整理,-1表示n,n行2列写为reshape(-1,2)
        X = np.vstack(X).reshape(-1,2)
        Y_ = np.vstack(Y_).reshape(-1,1)
        #print(X)
        #print(Y)
        #print(Y_c)
        return X,Y_,Y_c
    
    '''
    if __name__ == '__main__':
        X,Y_,Y_c=generateds()
    
        #用 plt.scatter画出数据集X中的点(x0.x1),Y_c表示颜色
        plt.scatter(X[:,0], X[:,1],c=np.squeeze(Y_c))
        plt.show()
    '''

    forward.py 定义向前传播过程,完成计算图的构建

    #coding:utf-8
    import tensorflow as tf
    
    #定义神经网络的输入、参数和输出,定义前项传播过程
    def get_weight(shape, regularizer):
        w = tf.Variable(tf.random_normal(shape),dtype=tf.float32)
        #把每个w的正则化损失加到总损失losses中
        tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
        return w
    
    def get_bias(shape):
        b=tf.Variable(tf.constant(0.01, shape=shape))
        return b
    
    #搭建前向传播框架
    def forward(x, regularizer):
    
        w1 = get_weight([2,11], regularizer)
        b1 = get_bias([11])
        #(x和w1实现矩阵乘法 + b1)过非线性函数(激活函数)
        y1 = tf.nn.relu(tf.matmul(x, w1) + b1)
    
        w2 = get_weight([11,1], regularizer)
        b2 = get_bias([1])
        #输出层不过激活函数
        y = tf.matmul(y1, w2) + b2
    
        return y

    backward.py 完成网络参数训练

    #coding:utf-8
    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    import generateds
    import forward
    
    STEPS = 40000#共进行40000轮
    BATCH_SIZE = 30#表示一次为喂入NN多少组数据
    LEARNING_RATE_BASE = 0.001#学习率基数,学习率初始值
    LEARNING_RATE_DECAY = 0.999#学习率衰减率
    REGULARIZER = 0.01#参数w的loss在总losses中的比例,即正则化权重
    
    def backward():
        x = tf.placeholder(tf.float32,(None,2))
        y_ = tf.placeholder(tf.float32,(None,1))
    
        X,Y_,Y_c = generateds.generateds()
    
        y=forward.forward(x, REGULARIZER)
    
        global_step = tf.Variable(0, trainable = False)
    
        learning_rate = tf.train.exponential_decay(
            LEARNING_RATE_BASE,
            global_step,300/BATCH_SIZE,
            LEARNING_RATE_DECAY,
            staircase = True)
    
        #定义损失函数
        loss_mse = tf.reduce_mean(tf.square(y-y_))#利用均方误差
        loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))
    
        #定义反向传播方法:包含正则化
        train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss_total)
    
        with tf.Session() as sess :
            init_op = tf.global_variables_initializer()
            sess.run(init_op)
            for i in range(STEPS):
                start =(i*BATCH_SIZE) % 300
                end = start + BATCH_SIZE
                sess.run(train_step, feed_dict={x:X[start:end], y_:Y_[start:end]})
                if i % 2000 == 0:
                    loss_v = sess.run(loss_total, feed_dict={x:X,y_:Y_})
                    print('After %d steps, loss if %f '%(i,loss_v))
    
                #xx在-3到3之间步长为0.01,yy在-3到3之间步长为0.01生成二维网格坐标点 
                xx, yy = np.mgrid[-3:3.01, -3:3:.01]
                #将xx,yy拉直,并合并成一个2列的矩阵,得到一个网格坐标点的集合
                grid = np.c_[xx.ravel(), yy.ravel()]
                #将网格坐标点喂入神经网络,probs为输出
                probs = sess.run(y, feed_dict={x:grid})
                #将probs的shape调整成xx的样子
                probs = probs.reshape(xx.shape)
    
            #画出离散点
            plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c))
            #画出probs,0.5的曲线
            plt.contour(xx, yy, probs, levels=[.5])
            plt.show()
    
    if __name__ == '__main__':
        backward()

     输出结果:

     

     

     

     

  • 相关阅读:
    HYSBZ 3813 奇数国
    HYSBZ 4419 发微博
    HYSBZ 1079 着色方案
    HYSBZ 3506 排序机械臂
    HYSBZ 3224 Tyvj 1728 普通平衡树
    Unity 3D,地形属性
    nginx 的naginx 种包含include关键字
    Redis 出现NOAUTH Authentication required解决方案
    mysql 8.0出现 Public Key Retrieval is not allowed
    修改jar包里的源码时候需要注意的问题
  • 原文地址:https://www.cnblogs.com/veraLin/p/10293506.html
Copyright © 2011-2022 走看看