lesson20 神经网络搭建八股

最新推荐文章于 2020-08-17 23:19:32 发布
最新推荐文章于 2020-08-17 23:19:32 发布
阅读量272 收藏
点赞数
分类专栏： Tensorflow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ldinvicible/article/details/82828230
版权

 

https://www.bilibili.com/video/av22530538/?p=20

#lesson20 神经网络搭建八股
#搭建模块化的神经网络八股：
#前向传播就是搭建网络，设计网络结构（forward.py）
#def forward(x, regularizer):
#    w=
#    b=
#    y=
#    return y

#def get_weight(shape, regularizer):
#    w = tf.Variable()
#    tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer)(w)
#    return w

#def get_bias(shape)
#    b = tf.Variable(   )
#    reutrn b
#

#搭建模块化的神经网络八股：
#反向传播就是训练网络，优化网络参数（backward.py）
#  def backward():
#    x = tf.placeholder(   )
#    y_ = tf.placeholder(   )
#    y = forward.orward(x, REGULARIZER)
#    global_step = tf.Variable(0, trainable=False)
#    loss = 
     
#=================正则化：
#loss可以是：
#y与y_的差距(loss_max) = tf.reduce_mean(tf.square(y-y_))
#也可以是：
#ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))
#y与y_的差距（cem）=tf.reduce_mean(ce)

#加入正则化后
#loss=y与y_的差距 + tf.add_n(tf.get_clooection('losses'))

#===============指数衰减学习率：
#learning_rate = tf.train.exponential_docay(
#    LEARNIG_RATE_BASE,
#    global_step,
##    数据集总样本数/BATCH_SIZE，
#    LEARNING_RATE_DECAY,
#    staircase=Trus)

#train_step = tf.train.GradientDescentOptimize(learning_rate).minimize(loss,
#            global_step=global_step)

#===============滑动平均
#ema=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
#ema_op = ema.apply(tf.trainable_variables())
#with tf.control_dependencies(train_step, ema_op):
#    train_op = tf.no_op(name='train')
    

#with tf.Session() as sess:
#    init_op = tf.global_variables_initializer()
#    sess.run(init_op)
    
#    for i in range(STEPS):
#        sess.run(train_step, feed_dict={x: ,y_: })
 #       if i%轮数 == 0:
#            print
            
#if __name__='__main__'
#    backward()
    
    
#生成数据集 generateds.py
#前行传播 forward.py
#反向传播 backward.py
 


#============================================
#生成数据集 generateds.py
#generateds.py
#导入模块，生成模拟数据集
import numpy as np 
import matplotlib.pyplot as plt
seed = 2
def generateds():
    #基于seed产生随机数
    rdm = np.random.RandomState(seed)
    #随机数返回300行2列的矩阵，表示300组坐标点（x0.x1）作文输入数据集
    X = rdm.randn(300,2)
    #从X这个300行2列的矩阵中取出一行，判断如果两个坐标的平方和小于2，给Y赋值1，其余赋值0
    #作为输入数据集的标签（正确答案）
    Y = [int(x0*x0 + x1*x1 <2) for (x0,x1) in X]
    #遍历Y中的每个元素，1赋值‘red’其他赋值‘blue’,这样可视化显示时人可以直观区分
    Y_c = [['red' if y else 'blue'] for y in Y_]
    #对数据集X和标签Y进行形状整理，第一个元素为-1表示跟随第二列计算，第二个元素表示多少列，
    #可见X为两列，Y为1列
    X = np.vstack(X).reshape(-1,2)
    Y_ = np.vstack(Y_).reshape(-1,1)
    return X,Y_,Y_c

#print(X)
#print(Y)
#print(Y_c)
#用plt.scatter画出数据集X各行中第0列元素和第一列元素的点即各行的（x0，x1），用各行Y_c对应
#的值表示颜色（c时color的缩写）
#plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c))
#plt.show()

#===============================================
#forward.py
import tensorflow as tf

#定义神经网络的输入，参数和输出，定义前向传输过程
def get_weight(shape, regularizer):
    w = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
    tf.add_to_collection('losses',tf.contrib.laters.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])
    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 反向传输过程
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
#import generateds
#import forward

STEPS = 40000
BATCH_SIZE = 30
LEARNING_RATE_BASE = 0.001
LEARNING_RATE_DELAY = 0.999
REAULARIZER = 0.01

seed = 2
def generateds():
    #基于seed产生随机数
    rdm = np.random.RandomState(seed)
    #随机数返回300行2列的矩阵，表示300组坐标点（x0.x1）作文输入数据集
    X = rdm.randn(300,2)
    #从X这个300行2列的矩阵中取出一行，判断如果两个坐标的平方和小于2，给Y赋值1，其余赋值0
    #作为输入数据集的标签（正确答案）
    Y_ = [int(x0*x0 + x1*x1 <2) for (x0,x1) in X]
    #遍历Y中的每个元素，1赋值‘red’其他赋值‘blue’,这样可视化显示时人可以直观区分
    Y_c = [['red' if y else 'blue'] for y in Y_]
    #对数据集X和标签Y进行形状整理，第一个元素为-1表示跟随第二列计算，第二个元素表示多少列，
    #可见X为两列，Y为1列
    X = np.vstack(X).reshape(-1,2)
    Y_ = np.vstack(Y_).reshape(-1,1)
    return X,Y_,Y_c

#定义神经网络的输入，参数和输出，定义前向传输过程
def get_weight(shape, regularizer):
    w = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
    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])
    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

def backward():
    x = tf.placeholder(tf.float32, shape=(None, 2))
    y_ = tf.placeholder(tf.float32, shape=(None, 1))
    
    X, Y_, Y_c = generateds()
    y = forward(x, REAULARIZER)
    
    global_step = tf.Variable(0 ,trainable=False)
    
    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,
        global_step,
        300/BATCH_SIZE,
        LEARNING_RATE_DELAY,
        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 is :%f",i,loss_v)
        
        
        xx, yy = np.mgrid[-3:3:.01, -3:3:.01]
        grid = np.c_[xx.ravel(), yy.ravel()]
        probs = sess.run(y, feed_dict={x:grid})
        probs = probs.reshape(xx.shape)
    
    plt.scatter(X[:,0],X[:,1], c=np.squeeze(Y_c))
    plt.contour(xx, yy, probs, levels=[.5])
    plt.show()


if __name__=='__main__':
    backward()
('After %d steps,loss is :%f', 0, array([2.5668302, 1.5089796, 2.8902187, 1.86826  , 2.350546 , 1.8803072,
       2.02993  , 1.6785502, 2.2765093, 1.9777875, 1.8130226, 1.7081144,
       3.0880344, 1.5002894, 2.360821 , 2.2844257, 2.055157 , 1.4747636,
       1.2552826, 1.2468123, 1.2820654, 1.2078395, 1.3171003, 1.2813532,
       1.2867427, 1.2050648, 1.3131422, 1.2158824, 1.2640666, 1.2566302,
       1.2597053, 1.1940591], dtype=float32))
('After %d steps,loss is :%f', 2000, array([0.11640423, 0.0843224 , 0.16034338, 0.09978531, 0.10764869,
       0.13265155, 0.09050597, 0.10181741, 0.11102612, 0.11681367,
       0.08165098, 0.08410578, 0.2140159 , 0.08326143, 0.10304309,
       0.23503497, 0.13361564, 0.08139104, 0.08313721, 0.08707693,
       0.08981416, 0.08109941, 0.08609113, 0.08641067, 0.08542567,
       0.08087707, 0.08501144, 0.08107177, 0.08583382, 0.08696566,
       0.16831538, 0.10605212], dtype=float32))
('After %d steps,loss is :%f', 4000, array([0.06900894, 0.06897151, 0.06960355, 0.06899273, 0.06903058,
       0.06973132, 0.06897207, 0.06902046, 0.06899735, 0.06910895,
       0.06897138, 0.06897139, 0.06986102, 0.06897141, 0.06897403,
       0.08034473, 0.06984935, 0.06897138, 0.06897847, 0.06913827,
       0.06931876, 0.06897138, 0.06900185, 0.06898616, 0.06899941,
       0.06897138, 0.06899171, 0.06897138, 0.06903948, 0.06903877,
       0.1513815 , 0.09422117], dtype=float32))
('After %d steps,loss is :%f', 6000, array([0.06662133, 0.06662133, 0.06662133, 0.06662133, 0.06662133,
       0.06662133, 0.06662133, 0.06662133, 0.06662133, 0.06662133,
       0.06662133, 0.06662133, 0.06662133, 0.06662133, 0.06662133,
       0.06664878, 0.06662134, 0.06662133, 0.06662133, 0.06662134,
       0.06662144, 0.06662133, 0.06662133, 0.06662133, 0.06662133,
       0.06662133, 0.06662133, 0.06662133, 0.06662133, 0.06662133,
       0.14575696, 0.09205279], dtype=float32))
('After %d steps,loss is :%f', 8000, array([0.06590896, 0.06590896, 0.06590896, 0.06590896, 0.06590896,
       0.06590896, 0.06590896, 0.06590896, 0.06590896, 0.06590896,
       0.06590896, 0.06590896, 0.06590896, 0.06590896, 0.06590896,
       0.06590896, 0.06590896, 0.06590896, 0.06590896, 0.06590896,
       0.06590896, 0.06590896, 0.06590896, 0.06590896, 0.06590896,
       0.06590896, 0.06590896, 0.06590896, 0.06590896, 0.06590896,
       0.14273688, 0.09171701], dtype=float32))
('After %d steps,loss is :%f', 10000, array([0.06535169, 0.06535169, 0.06535169, 0.06535169, 0.06535169,
       0.06535169, 0.06535169, 0.06535169, 0.06535169, 0.06535169,
       0.06535169, 0.06535169, 0.06535169, 0.06535169, 0.06535169,
       0.06535169, 0.06535169, 0.06535169, 0.06535169, 0.06535169,
       0.06535169, 0.06535169, 0.06535169, 0.06535169, 0.06535169,
       0.06535169, 0.06535169, 0.06535169, 0.06535169, 0.06535169,
       0.13991964, 0.09166954], dtype=float32))
('After %d steps,loss is :%f', 12000, array([0.06512178, 0.06512178, 0.06512178, 0.06512178, 0.06512178,
       0.06512178, 0.06512178, 0.06512178, 0.06512178, 0.06512178,
       0.06512178, 0.06512178, 0.06512178, 0.06512178, 0.06512178,
       0.06512178, 0.06512178, 0.06512178, 0.06512178, 0.06512178,
       0.06512178, 0.06512178, 0.06512178, 0.06512178, 0.06512178,
       0.06512178, 0.06512178, 0.06512178, 0.06512178, 0.06512178,
       0.13719082, 0.09161621], dtype=float32))
('After %d steps,loss is :%f', 14000, array([0.06500839, 0.06500839, 0.06500839, 0.06500839, 0.06500839,
       0.06500839, 0.06500839, 0.06500839, 0.06500839, 0.06500839,
       0.06500839, 0.06500839, 0.06500839, 0.06500839, 0.06500839,
       0.06500839, 0.06500839, 0.06500839, 0.06500839, 0.06500839,
       0.06500839, 0.06500839, 0.06500839, 0.06500839, 0.06500839,
       0.06500839, 0.06500839, 0.06500839, 0.06500839, 0.06500839,
       0.1346513 , 0.09156334], dtype=float32))
('After %d steps,loss is :%f', 16000, array([0.06486929, 0.06486929, 0.06486929, 0.06486929, 0.06486929,
       0.06486929, 0.06486929, 0.06486929, 0.06486929, 0.06486929,
       0.06486929, 0.06486929, 0.06486929, 0.06486929, 0.06486929,
       0.06486929, 0.06486929, 0.06486929, 0.06486929, 0.06486929,
       0.06486929, 0.06486929, 0.06486929, 0.06486929, 0.06486929,
       0.06486929, 0.06486929, 0.06486929, 0.06486929, 0.06486929,
       0.13226455, 0.09145759], dtype=float32))
('After %d steps,loss is :%f', 18000, array([0.06449515, 0.06449515, 0.06449515, 0.06449515, 0.06449515,
       0.06449515, 0.06449515, 0.06449515, 0.06449515, 0.06449515,
       0.06449515, 0.06449515, 0.06449515, 0.06449515, 0.06449515,
       0.06449515, 0.06449515, 0.06449515, 0.06449515, 0.06449515,
       0.06449515, 0.06449515, 0.06449515, 0.06449515, 0.06449515,
       0.06449515, 0.06449515, 0.06449515, 0.06449515, 0.06449515,
       0.12961197, 0.09132565], dtype=float32))
('After %d steps,loss is :%f', 20000, array([0.06434211, 0.06434211, 0.06434211, 0.06434211, 0.06434211,
       0.06434211, 0.06434211, 0.06434211, 0.06434211, 0.06434211,
       0.06434211, 0.06434211, 0.06434211, 0.06434211, 0.06434211,
       0.06434211, 0.06434211, 0.06434211, 0.06434211, 0.06434211,
       0.06434211, 0.06434211, 0.06434211, 0.06434211, 0.06434211,
       0.06434211, 0.06434211, 0.06434211, 0.06434211, 0.06434211,
       0.12742466, 0.09139441], dtype=float32))
('After %d steps,loss is :%f', 22000, array([0.06424362, 0.06424362, 0.06424362, 0.06424362, 0.06424362,
       0.06424362, 0.06424362, 0.06424362, 0.06424362, 0.06424362,
       0.06424362, 0.06424362, 0.06424362, 0.06424362, 0.06424362,
       0.06424362, 0.06424362, 0.06424362, 0.06424362, 0.06424362,
       0.06424362, 0.06424362, 0.06424362, 0.06424362, 0.06424362,
       0.06424362, 0.06424362, 0.06424362, 0.06424362, 0.06424362,
       0.1256089 , 0.09149027], dtype=float32))
('After %d steps,loss is :%f', 24000, array([0.0637516 , 0.0637516 , 0.0637516 , 0.0637516 , 0.0637516 ,
       0.0637516 , 0.0637516 , 0.0637516 , 0.0637516 , 0.0637516 ,
       0.0637516 , 0.0637516 , 0.0637516 , 0.0637516 , 0.0637516 ,
       0.0637516 , 0.0637516 , 0.0637516 , 0.0637516 , 0.0637516 ,
       0.0637516 , 0.0637516 , 0.0637516 , 0.0637516 , 0.0637516 ,
       0.0637516 , 0.0637516 , 0.0637516 , 0.0637516 , 0.0637516 ,
       0.12329023, 0.09123979], dtype=float32))
('After %d steps,loss is :%f', 26000, array([0.06317926, 0.06317926, 0.06317926, 0.06317926, 0.06317926,
       0.06317926, 0.06317926, 0.06317926, 0.06317926, 0.06317926,
       0.06317926, 0.06317926, 0.06317926, 0.06317926, 0.06317926,
       0.06317926, 0.06317926, 0.06317926, 0.06317926, 0.06317926,
       0.06317926, 0.06317926, 0.06317926, 0.06317926, 0.06317926,
       0.06317926, 0.06317926, 0.06317926, 0.06317926, 0.06317926,
       0.12079911, 0.0911139 ], dtype=float32))
('After %d steps,loss is :%f', 28000, array([0.06305233, 0.06305233, 0.06305233, 0.06305233, 0.06305233,
       0.06305233, 0.06305233, 0.06305233, 0.06305233, 0.06305233,
       0.06305233, 0.06305233, 0.06305233, 0.06305233, 0.06305233,
       0.06305233, 0.06305233, 0.06305233, 0.06305233, 0.06305233,
       0.06305233, 0.06305233, 0.06305233, 0.06305233, 0.06305233,
       0.06305233, 0.06305233, 0.06305233, 0.06305233, 0.06305233,
       0.11917313, 0.09124077], dtype=float32))
('After %d steps,loss is :%f', 30000, array([0.06297403, 0.06297403, 0.06297403, 0.06297403, 0.06297403,
       0.06297403, 0.06297403, 0.06297403, 0.06297403, 0.06297403,
       0.06297403, 0.06297403, 0.06297403, 0.06297403, 0.06297403,
       0.06297403, 0.06297403, 0.06297403, 0.06297403, 0.06297403,
       0.06297403, 0.06297403, 0.06297403, 0.06297403, 0.06297403,
       0.06297403, 0.06297403, 0.06297403, 0.06297403, 0.06297403,
       0.11783044, 0.09133194], dtype=float32))
('After %d steps,loss is :%f', 32000, array([0.062908  , 0.062908  , 0.062908  , 0.062908  , 0.062908  ,
       0.062908  , 0.062908  , 0.062908  , 0.062908  , 0.062908  ,
       0.062908  , 0.062908  , 0.062908  , 0.062908  , 0.062908  ,
       0.062908  , 0.062908  , 0.062908  , 0.062908  , 0.062908  ,
       0.062908  , 0.062908  , 0.062908  , 0.062908  , 0.062908  ,
       0.062908  , 0.062908  , 0.062908  , 0.062908  , 0.062908  ,
       0.11658072, 0.09141951], dtype=float32))

('After %d steps,loss is :%f', 34000, array([0.06284633, 0.06284633, 0.06284633, 0.06284633, 0.06284633,
       0.06284633, 0.06284633, 0.06284633, 0.06284633, 0.06284633,
       0.06284633, 0.06284633, 0.06284633, 0.06284633, 0.06284633,
       0.06284633, 0.06284633, 0.06284633, 0.06284633, 0.06284633,
       0.06284633, 0.06284633, 0.06284633, 0.06284633, 0.06284633,
       0.06284633, 0.06284633, 0.06284633, 0.06284633, 0.06284633,
       0.11543632, 0.091515  ], dtype=float32))
('After %d steps,loss is :%f', 36000, array([0.06278987, 0.06278987, 0.06278987, 0.06278987, 0.06278987,
       0.06278987, 0.06278987, 0.06278987, 0.06278987, 0.06278987,
       0.06278987, 0.06278987, 0.06278987, 0.06278987, 0.06278987,
       0.06278987, 0.06278987, 0.06278987, 0.06278987, 0.06278987,
       0.06278987, 0.06278987, 0.06278987, 0.06278987, 0.06278987,
       0.06278987, 0.06278987, 0.06278987, 0.06278987, 0.06278987,
       0.11436763, 0.09161176], dtype=float32))
('After %d steps,loss is :%f', 38000, array([0.06274156, 0.06274156, 0.06274156, 0.06274156, 0.06274156,
       0.06274156, 0.06274156, 0.06274156, 0.06274156, 0.06274156,
       0.06274156, 0.06274156, 0.06274156, 0.06274156, 0.06274156,
       0.06274156, 0.06274156, 0.06274156, 0.06274156, 0.06274156,
       0.06274156, 0.06274156, 0.06274156, 0.06274156, 0.06274156,
       0.06274156, 0.06274156, 0.06274156, 0.06274156, 0.06274156,
       0.11338855, 0.09172283], dtype=float32))

 

ldinvicible
关注
专栏目录
搭建神经网络的八股
babing2770的博客
07-20 124
准备 前传 反传 迭代 0准备 import 　　　常量定义 　　　生成数据集 1前向传播: 定义输入 参数 和 输出 　　　x= 　　　y_= 　　　w1= 　　　w2= 　　　a= 　　　y= 2反向传播: 定义损失函数 反向传播方法 loss= train_step= 3生成会话: 训练STEPS轮 with tf...
搭建神经八股
weixin_43765314的博客
01-27 629
这里是北京大学曹健老师的tensorflow实践课链接，以后几篇博客会整理这门课的笔记，双系统的安装和python基础不再赘述。我的环境是ubuntu18.04+python3.6+tensorflow-1.5.0-gpu，gpu版本的tensorflow需要安装对应的cuda和cudnn，麻烦一点，但配好以后用其他框架就不用再配置了。tensorflow-1.5.0对应的cuda版本是9.0,c...
神经网络搭建八股
weixin_30678349的博客
01-07 224
一、生成数据集 generator.py #导入模块，生成模拟数据集 import numpy as np import matplotlib.pyplot as plt seed = 2 def generator(): # 基于seed产生随机数 rdm = np.random.RandomState(seed) # 随机数返回300行2列的矩阵，表示300组坐...
搭建神经网络八股
热门推荐
stybill的博客
04-28 5万+
搭建神经网络八股基本骨架： # 搭建模块化的神经网络八股： # 前向传播就是搭建网络。设计网络结构(forword.py) def forward(x, regularizer): w = b = y = return y def get_weight(shape, regularizer): w = tf...
神经网络搭建“八股”
dl_None
08-06 2994
一、基本概念      1.张量 张量就是多维数组，“阶”表示张量的维度 0阶张量是一个单独的数，称为标量，如：S = 123 1阶张量是一个一维数组，称为向量，如：V = [1, 2, 3] 2阶张量是一个二维数组，称为矩阵，如：M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] ....... n阶张量，如：t = [[[[·····]]]···]]] ，...
lesson38-卷积神经网络.zip
最新发布
08-29
深度学习与PyTorch入门实战视频教程 配套源代码和PPT深度学习与PyTorch入门实战视频教程 配套源代码和PPT深度学习与PyTorch入门实战视频教程 配套源代码和PPT深度学习与PyTorch入门实战视频教程 配套源代码和PPT深度...
lesson51-WGAN实战.zip_人工智能/神经网络/深度学习_Python__人工智能/神经网络/深度学习_Python_
08-09
在本项目中，我们主要探讨的是生成式对抗网络（Generative Adversarial Networks，简称GANs），这是一种在人工智能，特别是神经网络和深度学习领域中广泛应用的技术。GANs由两部分组成：生成器（Generator）和判别器...
TensorFlow深度学习笔记TensorFlow实现与优化深度神经网络
01-27
9. 深度神经网络结构：在单层线性模型的基础上，可以增加隐藏层，使用激活函数如ReLU来构建深度神经网络，提高模型的表达能力。深度神经网络的构建涉及矩阵运算和参数数量的增加。 10. 正则化技术：为了防止模型过...
Lesson 12.0 深度学习基础网络手动搭建与快速实现.ipynb
01-20
Lesson 12.0 深度学习基础网络手动搭建与快速实现.ipynb
pytorch卷积神经网络代码教学
04-13
详情参考https://github.com/LianHaiMiao/pytorch-lesson-zh/，这个老师讲的特别详细，或者参考https://blog.csdn.net/a1103688841/article/details/89222614
Tensorflow学习笔记 (基础-第一篇)------ 搭建神经网络，总结搭建八股
perfect1t的博客
07-16 1409
---- 内容                                                                                                                     1、基本概念 2、神经网络的参数 3、神经网络的搭建  4、反向传播 5、搭建神经网络的八股 一、基本概念                 ...
模块化搭建神经网络八股
价值引领，业务立命，技术驱动
07-16 231
1.前向传播描述网络结构 2.反向传播描述网络参数优化方法 3.测试，复现计算图中的节点，测试模型在测试集上的准确率 截图来自【北京大学】Tensorflow学习笔记，从零基础入门到项目实战分享学习教程https://www.bilibili.com/video/BV1GE411k7Q2?p=23 ...
Tensorflow搭建神经网络之模块化八股
Lee0_King的博客
07-26 724
    以下代码是使用tensorflow库，并使用模块化的工程思想，用来搭建神经网络的八股（即必须的基本函数和参数）。补全以下代码，可以实现简单的神经网络的搭建。 注：python3.6 # 搭建模块化的神经网络八股： # 前向传播就是搭建网络。设计网络结构(forword.py) def forward(x, regularizer): w = b = y =...
搭建神经网络的八股过程——案列演示
weixin_45534297的博客
10-14 268
搭建神经网络的八股过程 1 准备 import 常量定义 然后生成数据集 （数据是第一位 练习中可以用random来生成） 2 前向传播 定义输入、参数和输出 x= (输入为x 标准答案是y_) y_= w1= (第一层网络的参数w1) w2= (第二层网络的参数w2） a= y= （用矩阵 求出y）...
简单搭建神经网络
congcong7267的博客
07-29 719
简单的神经网络：准备，前传，后传，迭代 下面是一个简单的神经网络搭建的代码 代码： #coding:utf-8 import tensorflow as tf import numpy as np BATCH_SIZE=8 seed = 23455 #基于seed产生随机数 rng = np.random.RandomState(seed) #随机数返回32行2列的矩阵，作为输入数...
基于Tensorflow神经网络搭建八股
YQ8023family的博客
02-16 572
基于Tensorflow神经网络搭建八股概述张量（tensor) 概述 基于Tensorflow神经网络：张量表示数据，用计算图搭建神经网络，用会话执行计算图，优化线上的权重（参数），得到模型 张量（tensor) 也叫多维数组（列表） 阶：张量的维数 维数 阶 名字 例子 0-D 0 标量 scalar s = 1 2 3 1-D 0 向量 vector v = [1, 2,...
搭建神经网络八股功能增强
Anakin6174的博客
08-17 353
资料来源：北京大学 曹建教授的课程 人工智能实践：TensorFlow笔记 使用八股搭建神经网络参考：https://blog.csdn.net/Anakin6174/article/details/108046166 这次是增强版。 其中二三四五步是大家调试模型常用的步骤。 代码示例： import tensorflow as tf import os import numpy as np from matplotlib import pyplot as plt np.set_printopti
SVM入门（一）SVM的八股简介
weixin_30496751的博客
05-28 181
支持向量机(Support Vector Machine)是Cortes和Vapnik于1995年首先提出的，它在解决小样本、非线性及高维模式识别中表现出许多特有的优势，并能够推广应用到函数拟合等其他机器学习问题中[10]。支持向量机方法是建立在统计学习理论的VC 维理论和结构风险最小原理基础上的，根据有限的样本信息在模型的复杂性（即对特定训练样本的学习精度，Accuracy）和学习能力（即无错误...
北大慕课Tensorflow实践过程笔记3——神经网络八股
irisdududu的博客
03-28 497
神经网络八股搭建网络八股sequential用tf.keras 搭建网络八股Sequential()用法compile()用法fit()用法summary()用法 搭建网络八股sequential 用tf.keras 搭建网络八股 六步法： import——引入相关模块 train，test——告知要喂入网络的训练集和测试集是什么，即制定训练集的输入特征x_train和训练集的标签y_train,...
TensorFlow优化器GradientDescentOptimizer
拼命先生的AI之旅
02-12 1万+
类GradientDescentOptimizer 继承自:Optimizer 这是一个实现实现梯度下降算法的优化器类，用于构造一个新的梯度下降优化器实例   构造器方法__init__ __init__( learning_rate, use_locking = False, name = ' GradientDescent ' ) 参数: learnin...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值