金莎娱乐电子游戏网TensorFlow怎么样实现反向传来,tensorflow达成反向

TensorFlow如何完毕反向传播,tensorflow完毕反向

运用TensorFlow的贰个优势是,它能够保证操作情状和基于反向传来活动地翻新模型变量。
TensorFlow通过测算图来更新变量和最小化损失函数来反向传播相对误差的。那步将经过证明优化函数(optimization
function)来落实。一旦注解好优化函数,TensorFlow将透过它在具有的总括图中国化学工业进出口总公司解反向传播的项。当大家传入数据,最小化损失函数,TensorFlow会在总计图中依据事态相应的调节和测量试验变量。

回归算法的例证从均值为1、标准差为0.1的正态分布中抽样随机数,然后乘以变量A,损失函数为L2正则损失函数。理论上,A的最优值是10,因为变化的样例数据均值是1。

三个例证是叁个粗略的二值分类算法。从多个正态布满(N(-1,1)和N(3,1))生成玖拾陆个数。全数从正态布满N(-1,1)生成的数据标为目的类0;从正态布满N(3,1)生成的数量标为目的类1,模型算法通过sigmoid函数将那几个变迁的数目转变来指标类数据。换句话讲,模型算法是sigmoid(x+A),个中,A是要拟合的变量,理论上A=-1。即使,四个正态分布的均值分别是m1和m2,则到达A的取值时,它们通过-(m1+m2)/2转变到到0等距的值。前面将会在TensorFlow中见证如何取到相应的值。

况且,钦点贰个确切的学习率对机器学习算法的熄灭是有帮扶的。优化器类型也急需钦定,前边的八个例子会采用专门的工作梯度下落法,它在TensorFlow中的实现是GradientDescentOptimizer()函数。

# 反向传播
#----------------------------------
#
# 以下Python函数主要是展示回归和分类模型的反向传播

import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
from tensorflow.python.framework import ops
ops.reset_default_graph()

# 创建计算图会话
sess = tf.Session()

# 回归算法的例子:
# We will create sample data as follows:
# x-data: 100 random samples from a normal ~ N(1, 0.1)
# target: 100 values of the value 10.
# We will fit the model:
# x-data * A = target
# Theoretically, A = 10.

# 生成数据,创建占位符和变量A
x_vals = np.random.normal(1, 0.1, 100)
y_vals = np.repeat(10., 100)
x_data = tf.placeholder(shape=[1], dtype=tf.float32)
y_target = tf.placeholder(shape=[1], dtype=tf.float32)

# Create variable (one model parameter = A)
A = tf.Variable(tf.random_normal(shape=[1]))

# 增加乘法操作
my_output = tf.multiply(x_data, A)

# 增加L2正则损失函数
loss = tf.square(my_output - y_target)

# 在运行优化器之前,需要初始化变量
init = tf.global_variables_initializer()
sess.run(init)

# 声明变量的优化器
my_opt = tf.train.GradientDescentOptimizer(0.02)
train_step = my_opt.minimize(loss)

# 训练算法
for i in range(100):
  rand_index = np.random.choice(100)
  rand_x = [x_vals[rand_index]]
  rand_y = [y_vals[rand_index]]
  sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y})
  if (i+1)%25==0:
    print('Step #' + str(i+1) + ' A = ' + str(sess.run(A)))
    print('Loss = ' + str(sess.run(loss, feed_dict={x_data: rand_x, y_target: rand_y})))

# 分类算法例子
# We will create sample data as follows:
# x-data: sample 50 random values from a normal = N(-1, 1)
#     + sample 50 random values from a normal = N(1, 1)
# target: 50 values of 0 + 50 values of 1.
#     These are essentially 100 values of the corresponding output index
# We will fit the binary classification model:
# If sigmoid(x+A) < 0.5 -> 0 else 1
# Theoretically, A should be -(mean1 + mean2)/2

# 重置计算图
ops.reset_default_graph()

# Create graph
sess = tf.Session()

# 生成数据
x_vals = np.concatenate((np.random.normal(-1, 1, 50), np.random.normal(3, 1, 50)))
y_vals = np.concatenate((np.repeat(0., 50), np.repeat(1., 50)))
x_data = tf.placeholder(shape=[1], dtype=tf.float32)
y_target = tf.placeholder(shape=[1], dtype=tf.float32)

# 偏差变量A (one model parameter = A)
A = tf.Variable(tf.random_normal(mean=10, shape=[1]))

# 增加转换操作
# Want to create the operstion sigmoid(x + A)
# Note, the sigmoid() part is in the loss function
my_output = tf.add(x_data, A)

# 由于指定的损失函数期望批量数据增加一个批量数的维度
# 这里使用expand_dims()函数增加维度
my_output_expanded = tf.expand_dims(my_output, 0)
y_target_expanded = tf.expand_dims(y_target, 0)

# 初始化变量A
init = tf.global_variables_initializer()
sess.run(init)

# 声明损失函数 交叉熵(cross entropy)
xentropy = tf.nn.sigmoid_cross_entropy_with_logits(logits=my_output_expanded, labels=y_target_expanded)

# 增加一个优化器函数 让TensorFlow知道如何更新和偏差变量
my_opt = tf.train.GradientDescentOptimizer(0.05)
train_step = my_opt.minimize(xentropy)

# 迭代
for i in range(1400):
  rand_index = np.random.choice(100)
  rand_x = [x_vals[rand_index]]
  rand_y = [y_vals[rand_index]]

  sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y})
  if (i+1)%200==0:
    print('Step #' + str(i+1) + ' A = ' + str(sess.run(A)))
    print('Loss = ' + str(sess.run(xentropy, feed_dict={x_data: rand_x, y_target: rand_y})))

# 评估预测
predictions = []
for i in range(len(x_vals)):
  x_val = [x_vals[i]]
  prediction = sess.run(tf.round(tf.sigmoid(my_output)), feed_dict={x_data: x_val})
  predictions.append(prediction[0])

accuracy = sum(x==y for x,y in zip(predictions, y_vals))/100.
print('最终精确度 = ' + str(np.round(accuracy, 2)))

输出:

Step #25 A = [ 6.12853956]
Loss = [ 16.45088196]
Step #50 A = [ 8.55680943]
Loss = [ 2.18415046]
Step #75 A = [ 9.50547695]
Loss = [ 5.29813051]
Step #100 A = [ 9.89214897]
Loss = [ 0.34628963]
Step #200 A = [ 3.84576249]
Loss = [[ 0.00083012]]
Step #400 A = [ 0.42345378]
Loss = [[ 0.01165466]]
Step #600 A = [-0.35141727]
Loss = [[ 0.05375391]]
Step #800 A = [-0.74206048]
Loss = [[ 0.05468176]]
Step #1000 A = [-0.89036471]
Loss = [[ 0.19636908]]
Step #1200 A = [-0.90850282]
Loss = [[ 0.00608062]]
Step #1400 A = [-1.09374011]
Loss = [[ 0.11037558]]
最终精确度 = 1.0

上述正是本文的全体内容,希望对大家的学习抱有协助,也可望我们多多帮忙帮客之家。

使用TensorFlow的三个优势是,它能够维护操作景况和依据反向传播活动地翻新模型变量。
Tens…

您可能感兴趣的作品:

  • Python完毕的人工神经互连网算法示例【基于反向传播算法】

日前的Logistic回归:最基础的神经网络和神经网络编制程序原则&Logistic
Regression的算法分析讲解了Logistic
regression的基本原理,並且自身关系过那些玩意儿在小编眼里是上学神经网络和纵深学习的根基,学到前面就发掘,其实假设这些事物弄精晓了,前边的就很好通晓。其他,即便说未来有那三个众多的机器学习包和纵深学习框架,像sklearn、TensorFlow、Keras等等,让大家贯彻一个神经网络十一分轻松,不过如若您不理解原理,固然给你多个框架,里面包车型地铁大度的函数和办法您依旧不亮堂怎样出手,不通晓什么时候该行使什么,而这么些框架之中日常提到的“前向传来”、“反向传播”、“计算图”、种种梯度下跌、mini-batch、各个initialization方法等等你也不便了解,更别提如何针对你的其实景况在不分厚薄了。因而,小编的纵深学习系列笔记,首假诺教课神经网络的笔触、算法、原理,然后前期重要运用python和numpy来兑现,只有到大家把神经网络基本讲完,才会开头采取诸如TensorFlow那样的框架来贯彻。当然,那也是本身正在听的吴恩达的吃水学习连串课程的特征,不急不躁,耐心地用最省力的法子来进行具有的规律,那样才干融会贯通,玩转各样框架。

TensorFlow平台下Python实现神经互联网,tensorflowpython

本篇文章首要透过贰个简便的例子来促成神经网络。磨炼多少是随机发生的效仿数据集,化解二分类难题。

上边大家率先说一下,练习神经网络的貌似经过:

1.定义神经互联网的构造和前向传来的出口结果

2.定义损失函数以及反向传播优化的算法

3.生成会话(Session)何况在教练多少上频仍运营反向传播优化算法

要铭记的少数是,无论神经网络的结构怎样转换,以上多少个步骤是不会变动的。

总体代码如下:

import tensorflow as tf 
#导入TensorFlow工具包并简称为tf 

from numpy.random import RandomState 
#导入numpy工具包,生成模拟数据集 

batch_size = 8 
#定义训练数据batch的大小 

w1 = tf.Variable(tf.random_normal([2,3],stddev=1,seed=1)) 
w2 = tf.Variable(tf.random_normal([3,1],stddev=1,seed=1)) 
#分别定义一二层和二三层之间的网络参数,标准差为1,随机产生的数保持一致 

x = tf.placeholder(tf.float32,shape=(None,2),name='x-input') 
y_ = tf.placeholder(tf.float32,shape=(None,1),name='y-input') 
#输入为两个维度,即两个特征,输出为一个标签,声明数据类型float32,None即一个batch大小 
#y_是真实的标签 

a = tf.matmul(x,w1) 
y = tf.matmul(a,w2) 
#定义神经网络前向传播过程 

cross_entropy = -tf.reduce_mean(y_ * tf.log(tf.clip_by_value(y,1e-10,1.0))) 
train_step = tf.train.AdamOptimizer(0.001).minimize(cross_entropy) 
#定义损失函数和反向传播算法 

rdm = RandomState(1) 
dataset_size = 128 
#产生128组数据 
X = rdm.rand(dataset_size,2) 
Y = [[int(x1+x2 < 1)] for (x1,x2) in X] 
#将所有x1+x2<1的样本视为正样本,表示为1;其余为0 

#创建会话来运行TensorFlow程序 
with tf.Session() as sess: 
 init_op = tf.global_variables_initializer() 
 #初始化变量 
 sess.run(init_op) 

 print(sess.run(w1)) 
 print(sess.run(w2)) 
 #打印出训练网络之前网络参数的值 

 STEPS = 5000 
 #设置训练的轮数 
 for i in range(STEPS): 
  start = (i * batch_size) % dataset_size 
  end = min(start+batch_size,dataset_size) 
 #每次选取batch_size个样本进行训练 

  sess.run(train_step,feed_dict={x:X[start:end],y_:Y[start:end]}) 
 #通过选取的样本训练神经网络并更新参数 

  if i%1000 == 0: 
   total_cross_entropy = sess.run(cross_entropy,feed_dict={x:X,y_:Y}) 
   print("After %d training step(s),cross entropy on all data is %g" % (i,total_cross_entropy)) 
 #每隔一段时间计算在所有数据上的交叉熵并输出,随着训练的进行,交叉熵逐渐变小 

 print(sess.run(w1)) 
 print(sess.run(w2)) 
 #打印出训练之后神经网络参数的值 

运营结果如下:

金莎娱乐电子游戏网 1

结果表明:

首先是打字与印刷出磨炼以前的互连网参数,也正是轻便产生的参数值,然后将练习进度中每隔1000次的陆陆续续熵输出,发掘交叉熵在稳步减小,表明分类的性质在变好。末了是教练互连网甘休后互连网的参数。

享用一个图形化神经网络磨练进程的网站:点这里,可以自身定义网络参数的分寸,层数以及学习速率的分寸,何况磨练进度会以很直观的款型呈现出来。比方:

金莎娱乐电子游戏网 2

 金莎娱乐电子游戏网 3

上述对于神经互联网练习进度能够有三个很深入的明亮。

终极,再补偿部分TensorFlow相关的学问:

1.TensorFlow总括模子-总括图

      
Tensor表示张量,能够简轻巧单的理解为多维数据结构;Flow则反映了它的测算模型。Flow翻译过来是“流”,它直观地球表面述了张量之间通过估测计算相互转变的历程。TensorFlow中的每贰个盘算都以计算图上的八个节点,而节点之间的边描述了总括之间的依靠关系。

点名GPU方法,命令如下:

import tensorflow as tf
a = tf.constant([1.0,2.0],name=“a”)
b = tf.constant([3.0,4.0],name=“b”)
g = tf.Graph()
with g.device(/gpu:0):
result = a + b
sess = tf.Session()
sess.run(result)

2.TensorFlow数据模型-张量

     
张量是管理数据的花样。零阶张量表示标量,第一阶张量为向量,也正是一维数组,一般的话,第n阶张量可以清楚为多个n维数组。张量本人不存款和储蓄存运输算的结果,它只是获得对结果的二个援引。能够动用tf.Session().run(result)语句来获得总结结果。

3.TensorFlow运作模型-会话

我们选择session来试行定义好的演算。

主要有以下二种办法,第一种会发出内部存款和储蓄器泄漏,第二种不会有这种主题材料。

#创建一个会话
sess = tf.Session()
sess.run(…)
#关闭会话使得本次运行中使用的资源得到释放
sess.close()

其次种办法是经过Python的上下文财富管理器来行使会话。

with tf.Session() as sess:
sess.run(…)

此种方式自行关闭和机关进行财富的假释

4.TensorFlow-神经互连网例子

动用神经互连网消除分类难题能够分成以下三个步骤:
①领到难点中实体的特征向量作为输入。
②定义神经网络的构造,并定义怎么样从神经网络的输入获得输出。这么些进度便是神经网络的前向传来算法。
③透过练习多少来调动神经互连网中参数的安装,那即是教练互连网的历程。
④选拔练习好的神经互连网来预测未知的多寡  

在TensorFlow中声贝因美个2*3的矩阵变量的格局:

weight =
tf.Variable(tf.random_normal([2,3],stddev=2))

 即表示为方差为0、规范差为2的正态布满

在TensorFlow中,二个变量的值在被使用从前,那个变量的开首化进程供给被醒目调用。一下子起首化全数的变量

sess = tf.Session()
init_op = tf.initialize_all_variables()

仍旧换来init_op = tf.global_variables_initializer()也可

sess.run(init_op)

如上就是本文的全部内容,希望对我们的读书抱有援助,也愿意大家多多援救帮客之家。

本篇作品首要透过一个简约的例子来兑现神经互连网。训练多少是自由发生的模仿数据集,解…

三个例证是一个简约的二值分类算法。从四个正态遍布(N(-1,1)和N(3,1))生成玖15个数。全数从正态分布N(-1,1)生成的数量标为指标类0;从正态布满N(3,1)生成的数指标为目的类1,模型算法通过sigmoid函数将这么些变迁的数码调换来目的类数据。换句话讲,模型算法是sigmoid(x+A),在那之中,A是要拟合的变量,理论上A=-1。假使,八个正态布满的均值分别是m1和m2,则到达A的取值时,它们通过-(m1+m2)/2转变来到0等距的值。前边将会在TensorFlow中见证如何取到相应的值。

本次的前言有一些啰嗦了。。。主借使怕有个别读者说“明明得以用机器学习包几行代码化解,为什么偏要用纯python费力去实现”。好了,步向正题:

输出:

二、开端编制程序吧

上面大家使用“体今世码和注释+器重地方详解”的主意来一步步落到实处:

# 导入数据,“_orig”代表这里是原始数据,我们还要进一步处理才能使用:train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()#由数据集获取一些基本参数,如训练样本数m,图片大小:m_train = train_set_x_orig.shape[0] #训练集大小209m_test = test_set_x_orig.shape[0] #测试集大小209num_px = train_set_x_orig.shape[1] #图片宽度64,大小是64×64#将图片数据向量化:train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).Ttest_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0],-1).T#对数据进行标准化:train_set_x = train_set_x_flatten/255.test_set_x = test_set_x_flatten/255.

地点的代码有几点要验证:

  1. 数量导入是直接用吴恩达网课中的数据集,他提供了两个接口load_dataset()能够间接导入数据,借使急需多少的话能够在篇章下方留言获得。这里关键是展现情势,完全可以用自身的数码集来操作。数据集是一对图片,我们要锻练一个识别猫的分类器。train_set_x_orig,也正是咱们的庐山真面目数据形状(209,
    64,
    64, 3)
    先是维代表m,即样本数量,第二维第三维分别是图形的长和宽,第四维代表图片的奥迪Q7GB七个通道
  2. numpy包有至关重大的关于矩阵“形状”的法子:.shape.reshape().shape能够拿走三个矩阵的形制,于是我们能够通过[i]来领悟每一维的高低;.reshape()用来重构矩阵的形态,直接在其间填写维度就能够,还或许有部分差异平日用法,比方此处的用法:当大家要把二个向量X这么些四维向量扁平化成X_flatten(m,a*
    b*
    c)的二维向量,可以写X_flatten=X.reshape(X.shape[0],-1)就可以,当中“-1”代表把剩余维度压扁的格局。而代码中还应该有多个.T,代表转置,因为我们盼望把磨炼样本压缩成(64*
    64 *3,m)的形式。
  3. 怎么要求标准?在证实为什么要条件前,大家不要紧说说一般的标准化是怎么办的:先求出数据的均值和方差,然后对每叁个样本数量,先减去均值,然后除以方差,约等于/σ2,说白了就是转化成标准正态布满!那样,各个特征都转化成了同一的遍及,不管原本的范围是什么,以后都基本限定在一样的界定内了。那样做的裨益是哪些呢?且看上面四个等高线图:金莎娱乐电子游戏网 4未规范化金莎娱乐电子游戏网 5规格之后上面八个图体现了数码在未标准化和标准之后的动静。原数据的不一致风味的限制恐怕会有不小区别,比方一堆数量中“年龄”的界定就相当的小,或者20岁
    ~ 陆九岁之间,不过另一个特点“每年薪俸”只怕波动范围就十分的大,也许0.5万 ~
    一千万,这种景色下回导致大家的等高线图变得拾分“扁平”,在梯度下跌的时候会很轻易走弯路,因此梯度下跌会相当的慢,精度也不高。不过透过标准化之后,等高线就变规矩了,就很轻巧梯度下落了。别的,对于图片数据的话,举办规范很轻易,因为CR-VGB八个通道的限定都以255,大家对图片的拍卖正是间接除以255就能够。

到现在,数据预管理就达成了,大家走入下一步:

1. 激活函数/sigmoid函数:

def sigmoid: a = 1/(1+np.exp return a

仿佛此easy,sigmoid的公式正是1/,这里用np.exp()就足以轻便创设。

2. 参数起初化函数(给参数都起来化为0):

def initialize_with_zeros: w = np.zeros b = 0 return w,b

W是三个列向量,传入维度dim,再次来到shape为的W,b正是一个数。这里运用的艺术是np.zeros.

3.propagate函数:此间再度解释一下这么些propagate,它满含了forward-propagate和backward-propagate,即正向传播和反向传播。正向传播求的是cost,反向传播是从cost的表明式倒推W和b的偏导数,当然我们会先求出Z的偏导数。那多少个方向的传入也是神经互联网的精髓。具体倒数怎么求,这里就不推导了,正是很简单的求导嘛,公式请参见上一篇小说:神经网络编制程序原则&Logistic
Regression的算法深入分析那么笔者就平素上代码了:

def propagate(w, b, X, Y): """ 传参: w -- 权重, shape: (num_px * num_px * 3, 1) b -- 偏置项, 一个标量 X -- 数据集,shape: (num_px * num_px * 3, m),m为样本数 Y -- 真实标签,shape:  返回值: cost, dw ,db,后两者放在一个字典grads里 """ #获取样本数m: m = X.shape[1] # 前向传播 : A = sigmoid(np.dot #调用前面写的sigmoid函数 cost = -(np.sum(Y*np.log*np.log/m # 反向传播: dZ = A-Y dw = (np.dot/m db = (np.sum/m #返回值: grads = {"dw": dw, "db": db} return grads, cost

这里须要十一分表明的正是,numpy中矩阵的点乘,相当于内积运算,是用np.dot,它须求前二个矩阵的列数等于后一个矩阵的行数。但矩阵也能够扩充要素相乘(element
product)
,正是七个同样形状的矩阵对于元素相乘得到七个新的一样形状的矩阵,能够平昔用A
*
B
,或者用np.multiply。上面的代码中,既有一点点乘,也许有成分相乘,我们在写的时候,先搞了然形状,再分明用如何乘法。上边还应该有种种numpy的数学函数,对矩阵求log就用np.log(),对矩阵成分求和就用np.sum(),贼方便。

4.optimize函数:有了地点那么些函数的加持,optimize函数就很好写了,就是在迭代中调用各种我们正好写的函数正是:

def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False): #定义一个costs数组,存放每若干次迭代后的cost,从而可以画图看看cost的变化趋势: costs = [] #进行迭代: for i in range(num_iterations): # 用propagate计算出每次迭代后的cost和梯度: grads, cost = propagate dw = grads["dw"] db = grads["db"] # 用上面得到的梯度来更新参数: w = w - learning_rate*dw b = b - learning_rate*db # 每100次迭代,保存一个cost看看: if i % 100 == 0: costs.append # 这个可以不在意,我们可以每100次把cost打印出来看看,从而随时掌握模型的进展: if print_cost and i % 100 == 0: print ("Cost after iteration %i: %f" % #迭代完毕,将最终的各个参数放进字典,并返回: params = {"w": w, "b": b} grads = {"dw": dw, "db": db} return params, grads, costs

本条函数就没怎么好解释的了。

5.predict函数:推断就一点也不细略了,大家早就学到了参数W和b,那么让我们的数据经过布置这个参数的模型就可获取预测值。注意,X->Z->激活得到A,此时还并非预测值,由sigmoid函数咱们清楚,A的限制是01,不过大家的标签值是0和1,因而,大家得以设置准绳:0.51的A对于预测值1,小于0.5的照拂预测值0:

def predict: m = X.shape[1] Y_prediction = np.zeros A = sigmoid(np.dot for i in range: if A[0,i]>0.5: Y_prediction[0,i] = 1 else: Y_prediction[0,i] = 0 return Y_prediction

恭喜,借使您有耐心看到此间了。。。那。。。小编真正忍不住送你一朵fa了:

金莎娱乐电子游戏网 6

究竟作者本人都不相信会有几人真的去看那样干Baba的长河。不过本身相信,每一份耐心和交给都有回报吧,学习那件事情,急不来。

迄今,大家早已构建好了具有的增加援救函数。接下来正是结合在一道,然后用大家的多少去磨练、预测了!

def logistic_model(X_train,Y_train,X_test,Y_test,learning_rate=0.1,num_iterations=2000,print_cost=False): #获特征维度,初始化参数: dim = X_train.shape[0] W,b = initialize_with_zeros #梯度下降,迭代求出模型参数: params,grads,costs = optimize(W,b,X_train,Y_train,num_iterations,learning_rate,print_cost) W = params['w'] b = params['b'] #用学得的参数进行预测: prediction_train = predict(W,b,X_test) prediction_test = predict(W,b,X_train) #计算准确率,分别在训练集和测试集上: accuracy_train = 1 - np.mean(np.abs(prediction_train - Y_train)) accuracy_test = 1 - np.mean(np.abs(prediction_test - Y_test)) print("Accuracy on train set:",accuracy_train ) print("Accuracy on test set:",accuracy_test ) #为了便于分析和检查,我们把得到的所有参数、超参数都存进一个字典返回出来: d = {"costs": costs, "Y_prediction_test": prediction_test , "Y_prediction_train" : prediction_train , "w" : w, "b" : b, "learning_rate" : learning_rate, "num_iterations": num_iterations, "train_acy":train_acy, "test_acy":test_acy } return d

相关文章