机器学习入门实践——线性回归&非线性回归&mnist手写体识别

把一本《白话深度学习与tensorflow》给啃完了，了解了一下基本的BP网络，CNN，RNN这些。感觉实际上算法本身不是特别的深奥难懂，最简单的BP网络基本上学完微积分和概率论就能搞懂，CNN引入的卷积，池化等也是数字图像处理中比较成熟的理论，RNN使用的数学工具相对而言比较高深一些，需要再深入消化消化，最近也在啃白皮书，争取从数学上把这些理论吃透

当然光学理论不太行，还是得要有一些实践的，下面是三个入门级别的，可以用来辅助对BP网络的理解

环境：win10 WSL ubuntu 18.04

1.线性回归

入门：tensorflow线性回归

https://zhuanlan.zhihu.com/p/37368943

代码：

from?__future__?import??print_function
import?tensorflow?as?tf
import?numpy
import?matplotlib.pyplot?as?plt
rng?=?numpy.random
#?Parameters
learning_rate?=?0.01
training_epochs?=?1000
display_step?=?50
save_step?=?500
#?Training?Data
train_X?=?numpy.asarray([3.3,?4.4,?5.5,?6.71,?6.93,?4.168,?9.779,?6.182,?7.59,?2.167,
?????????????????????????7.042,?10.791,?5.313,?7.997,?5.654,?9.27,?3.1])
train_Y?=?numpy.asarray([3,?4.7,?5,?7.21,?6.93,?4.168,?9.779,?6.182,?7.59,?2.167,
?????????????????????????7.042,?10.291,?5.813,?7.997,?5.654,?9.17,?3.2])
#?define?graph?input
X?=?tf.placeholder(dtype=tf.float32,?name="X")
Y?=?tf.placeholder(dtype=tf.float32,?name="Y")
with?tf.variable_scope("linear_regression"):
????#?set?model?weight
????W?=?tf.get_variable(initializer=rng.randn(),?name="weight")
????b?=?tf.get_variable(initializer=rng.randn(),?name="bias")
????#?Construct?a?linear?model
????mul?=?tf.multiply(X,?W,?name="mul")
????pred?=?tf.add(mul,?b,?name="pred")
#?L2?loss
with?tf.variable_scope("l2_loss"):
????loss?=?tf.reduce_mean(tf.pow(pred-Y,?2))
#?Gradient?descent
train_op?=?tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
#?Initialize?the?variables
init_op?=?tf.global_variables_initializer()
#?Checkpoint?save?path
ckpt_path?=?'./ckpt/linear-regression-model.ckpt'
#?create?a?saver
saver?=?tf.train.Saver()
#?Summary?save?path
summary_path?=?'./ckpt/'
#?Create?a?summary?to?monitor?tensors?which?you?want?to?show?in?tensorboard
tf.summary.scalar('weight',?W)
tf.summary.scalar('bias',?b)
tf.summary.scalar('loss',?loss)
#?Merges?all?summaries?collected?in?the?default?graph
merge_summary_op?=?tf.summary.merge_all()
#?Start?training
with?tf.Session()?as?sess:
????summary_writer?=?tf.summary.FileWriter(summary_path,?sess.graph)
????#?Run?the?initializer
????sess.run(init_op)
????#?Fit?all?training?data
????for?epoch?in?range(training_epochs):
????????for?(x,?y)?in?zip(train_X,?train_Y):
????????????#?Do?feed?dict
????????????_,?summary?=?sess.run([train_op,?merge_summary_op],?feed_dict={X:?x,?Y:?y})
????????if?(epoch?+?1)?%?save_step?==?0:
????????????#?Do?save?model
????????????save_path?=?saver.save(sess,?ckpt_path,?global_step=epoch)
????????????print("Model?saved?in?file?%s"?%?save_path)
????????if?(epoch?+?1)?%?display_step?==?0:
????????????#?Display?loss?and?value
????????????c?=?sess.run(loss,?feed_dict={X:?train_X,?Y:?train_Y})
????????????print("Epoch:",?"%04d"?%?(epoch+1),?"loss=",?"{:.9f}".format(c),
??????????????????"W=",?W.eval(),?"b=",?b.eval())
????????????#?Add?variable?state?to?summary?file
????????????summary_writer.add_summary(summary,?global_step=epoch)
????print("Optimization?finished")
????#?Save?the?final?model
????summary_writer.close()
????#?Calculate?final?loss?after?training
????training_loss?=?sess.run(loss,?feed_dict={X:?train_X,?Y:?train_Y})
????print("Training?loss=",?training_loss,?"W=",?sess.run(W),?"b=",?sess.run(b),?'\n')
????plt.plot(train_X,?train_Y,?'ro',?label='Origin?data')
????plt.plot(train_X,?sess.run(W)?*?train_X?+?sess.run(b),?label='fitted?line')
????plt.legend()
????plt.show()

使用tensorboard的方法：

tensorboard --logdir=./ckpt/  (程序中存储summary的地址)

然后在浏览器输入

127.0.0.1:6006

即可查看

我训练的时候出现过loss不降反升的问题，说明选择的学习率有问题

除了学习率之外，学习的效果和优化算法的选择也有关系，我一开始选择的是梯度下降算法

train_op = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)

但是效果很不好

而更换优化算法为

train_op = tf.train.AdamOptimizer(learning_rate).minimize(loss)

效果好了不少

loss也比梯度下降小了一倍多

关于各个梯度算法的介绍

https://ruder.io/optimizing-gradient-descent/index.html

https://zhuanlan.zhihu.com/p/22252270

SGD（随机梯度下降）的缺点：

由于从头至尾使用的学习率完全一致，难以选择合适的学习率

容易困于鞍点（可以通过合适的初始化和step size克服）

而Adam算法通过引入梯度的一阶矩和二阶矩估计，引入了近似于动量和摩擦力的物理性质，使得训练具有了自适应性，所以比单纯的梯度下降往往要好用一些。

借助tensorboard可视化的观察loss，bias和weight的变化还是比较方便的，另外查看graph的功能也很好用

使用checkpoint保存的模型：

1.定义一个一模一样的graph，然后导入，可以发现创建图的过程和线性回归的代码一模一样的，创建完毕之后最关键的就是创建tf.train.Saver()，然后调用Saver类下面的restore方法，参数一个是sess一个是ckpt文件的路径

2.直接导入meta文件，这样可以将graph和参数一起导入

1.代码

from?__future__?import?print_function
import?tensorflow?as?tf
import?matplotlib.pyplot?as?plt
import?numpy
rng?=?numpy.random
X?=?tf.placeholder(dtype=tf.float32,?name="X")
Y?=?tf.placeholder(dtype=tf.float32,?name="Y")
with?tf.variable_scope("linear_regression"):
????W?=?tf.Variable(rng.randn(),?name="weight")
????b?=?tf.Variable(rng.randn(),?name="bias")
????mul?=?tf.multiply(X,?W,?name="mul")
????pred?=?tf.add(mul,?b,?name="pred")
saver?=?tf.train.Saver()
ckpt_path?=?'./ckpt/linear-regression-model.ckpt-999'
with?tf.Session()?as?sess:
????saver.restore(sess,?ckpt_path)
????print('Restored?Value?W={},?b={}'.format(W.eval(),b.eval()))

结果：

2.代码

采用import_meta_graph导入graph，需要筑起启动Session时要设置参数config=config

调用graph中的tensor时可以直接使用graph.get_tensor_by_name

from __future__ import print_function

import tensorflow as tf

import matplotlib.pyplot as plt

import numpy

config = tf.ConfigProto(allow_soft_placement=True)

*# path of the .meta file*

ckpt = './ckpt/linear-regression-model.ckpt-999'

with tf.Session(config=config) as sess:

 saver = tf.train.import_meta_graph(ckpt + '.meta')

 saver.restore(sess, ckpt)

 graph = sess.graph

 X = graph.get_tensor_by_name("X:0")

 pred = graph.get_tensor_by_name("linear_regression/pred:0")

 W = graph.get_tensor_by_name("linear_regression/weight:0")

 b = graph.get_tensor_by_name("linear_regression/bias:0")

 print('Restored value W={}, b={}'.format(W.eval(), b.eval()))

结果：

2.非线性回归

https://blog.csdn.net/y12345678904/article/details/77743696

线性回归中使用的multiply()，但是由于实际使用中都是矩阵相乘，所以matmul更加的常用一些

tf.matmul() 和tf.multiply() 的区别

1.tf.multiply（）两个矩阵中对应元素各自相乘

格式: tf.multiply(x, y, name=None)

参数:

x: 一个类型为:half, float32, float64, uint8, int8, uint16, int16, int32, int64, complex64, complex128的张量。

y: 一个类型跟张量x相同的张量。

返回值： x * y element-wise.

注意：

（1）multiply这个函数实现的是元素级别的相乘，也就是两个相乘的数元素各自相乘，而不是矩阵乘法，注意和tf.matmul区别。

（2）两个相乘的数必须有相同的数据类型，不然就会报错。

2.tf.matmul（）将矩阵a乘以矩阵b，生成a * b。

格式: tf.matmul(a, b, transpose_a=False, transpose_b=False, adjoint_a=False, adjoint_b=False, a_is_sparse=False, b_is_sparse=False, name=None)

参数:

a: 一个类型为 float16, float32, float64, int32, complex64, complex128 且张量秩 > 1 的张量。

b: 一个类型跟张量a相同的张量。

transpose_a: 如果为真, a则在进行乘法计算前进行转置。

transpose_b: 如果为真, b则在进行乘法计算前进行转置。

adjoint_a: 如果为真, a则在进行乘法计算前进行共轭和转置。

adjoint_b: 如果为真, b则在进行乘法计算前进行共轭和转置。

a_is_sparse: 如果为真, a会被处理为稀疏矩阵。

b_is_sparse: 如果为真, b会被处理为稀疏矩阵。

name: 操作的名字（可选参数）

返回值： 一个跟张量a和张量b类型一样的张量且最内部矩阵是a和b中的相应矩阵的乘积。

注意：

（1）输入必须是矩阵（或者是张量秩 >２的张量，表示成批的矩阵），并且其在转置之后有相匹配的矩阵尺寸。

（2）两个矩阵必须都是同样的类型，支持的类型如下：float16, float32, float64, int32, complex64, complex128。

代码：

import?tensorflow?as?tf
import?numpy?as?np
import?matplotlib.pyplot?as?plt
learning_rate?=?0.1
training_epochs?=?20000
display_step?=?500
x_data?=?np.linspace(-1,1,200)
x_data?=?x_data.reshape((200,1))
noise?=?np.random.normal(0,?0.05,?x_data.shape)
y_data?=?np.square(x_data)?+?noise
x?=?tf.placeholder(tf.float32,?[200,1])
y?=?tf.placeholder(tf.float32,?[200,1])
#?hidden?layer
weights_l1?=?tf.Variable(tf.random_normal([1,?10]))
biases_l1?=?tf.Variable(tf.zeros([1,?10]))
wx_plus_b_l1?=?tf.matmul(x,?weights_l1)?+?biases_l1
l1?=?tf.nn.tanh(wx_plus_b_l1)
#?output?layer
weights_l2?=?tf.Variable(tf.random_normal([10,1]))
biases_l2?=?tf.Variable(tf.zeros([1,1]))
wx_plus_b_l2?=?tf.matmul(l1,?weights_l2)?+?biases_l2
prediction?=?tf.nn.tanh(wx_plus_b_l2)
#?loss?function
loss?=?tf.reduce_mean(tf.square(y?-?prediction))
#?gradient?descent
train_step?=?tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
with?tf.Session()?as?sess:
????sess.run(tf.global_variables_initializer())
????for?global_epochs?in?range(training_epochs):
????????sess.run(train_step,?feed_dict={x:x_data,?y:y_data})

????????if?(global_epochs?+?1)?%?display_step?==?0:
????????????loss_value?=?sess.run(loss,?feed_dict={x:x_data,?y:y_data})
????????????print("epoch:",?"%04d"?%(global_epochs?+?1),?"loss=",?"{:.9f}".format(loss_value))?
????prediction_value?=?sess.run(prediction,?feed_dict={x:x_data})
????plt.figure()
????plt.scatter(x_data,?y_data)
????plt.plot(x_data,?prediction_value,'r-',lw=3)
????plt.show()

结果：

下降的效果还是比较明显的，从0.0076一直下降到了0.0027

图像：

Gradient Descent的结果，比较符合二次曲线的分布规律

Adam的结果，虽然loss比Gradient Descent小，但是实际上有比较明显的过拟合了

另外这里的激活函数采用的是tanh，更换成sigmoid之后

效果差于tanh做激活函数，因为tanh的导数值大于sigmoid，收敛速度实际上是快于sigmoid的，不过我把训练次数翻到了40000次后发现好像sigmoid作为激活函数，训练的上限就是0.004几了，而如果采用ReLU的话，就直接起飞了，根本无法收敛

ReLU还是适合在深度网络中做激活函数，在这种就一层的网络里面来搞效果就比较差（本来的目的就是为了解决深度网络中的梯度爆炸）

3.全连接网络实例（mnist）

https://geektutu.com/post/tensorflow-mnist-simplest.html

分为一个mnist_model.py用于构建网络，一个mnist_train.py用于训练，这种构建方式是大多数神经网络都会采取的方式

一维向量既可以用[1, 维数]来表示，也可以用[None, 维数]来表示

l由于label采用了1-10的独热编码，loss函数使用的是交叉熵，公式为（p为真实分布，q为非真实分布）

代码为

self.loss = -tf.reduce_sum(self.label * tf.log(self.y + 1e-10))

这里加1e-10的目的是为了防止y=0时出现数值溢出错误

关于feed_dict
sess.run() 中的feed_dict

结果是1，本质上就是一个临时赋值的功能

model的代码：

import?tensorflow?as?tf
class?Network:
????def?__init__(self):
????????#?learning?rate
????????self.learning_rate?=?0.01
????????#?input?tensor
????????self.x?=?tf.placeholder(tf.float32,?[None,?784])
????????#?label?tensor
????????self.label?=?tf.placeholder(tf.float32,?[None,?10])
????????#?weight
????????self.w?=?tf.Variable(tf.random_normal([784,?10]))
????????#?bias
????????self.b?=?tf.Variable(tf.random_normal([10]))
????????#?output?tensor
????????self.y?=?tf.nn.softmax(tf.matmul(self.x,?self.w)?+?self.b)
????????#?loss
????????self.loss?=?-tf.reduce_sum(self.label?*?tf.log(self.y?+?1e-10))
????????#?train
????????self.train?=?tf.train.GradientDescentOptimizer(self.learning_rate).minimize(self.loss)
????????#?verify
????????predict?=?tf.equal(tf.arg_max(self.label,?1),?tf.arg_max(self.y,?1))
????????#?calc?the?accuracy
????????self.accuracy?=?tf.reduce_mean(tf.cast(predict,?"float"))

train的代码:

train的代码
import?tensorflow?as?tf
from?tensorflow.examples.tutorials.mnist?import?input_data
from?mnist_model?import?Network
class?Train:
????def?__init__(self):
????????self.net?=?Network()
????????#?initialize?session
????????self.sess?=?tf.Session()
????????#?initialize?variables
????????self.sess.run(tf.global_variables_initializer())
????????#?input?data
????????self.data?=?input_data.read_data_sets('/home/satori/python/tensorflow_test/data_set',?one_hot=True)
????????#?create?a?saver
????????self.saver?=?tf.train.Saver()
????def?train(self):
????????batch_size?=?64
????????train_epoch?=?10000
????????save_interval?=?1000
????????display_interval?=?100
????????ckpt_path?=?'./ckpt/mnist-model.ckpt'
????????for?step?in?range(train_epoch):
????????????x,?label?=?self.data.train.next_batch(batch_size)
????????????#?training
????????????self.sess.run(self.net.train,?feed_dict={self.net.x:x,?self.net.label:label})
????????????if?(step?+?1)?%?display_interval?==?0:
????????????????#?print?the?loss
????????????????loss?=?self.sess.run(self.net.loss,?feed_dict={self.net.x:x,?self.net.label:label})
????????????????print("step=%d,?loss=%.2f"?%((step+1),?loss))
????????????
????????????if?(step?+?1)?%?save_interval?==?0:
????????????????#?save?the?model
????????????????self.saver.save(self.sess,?ckpt_path,?global_step=step)
????????????????print("model?saved?in?file?%s"?%ckpt_path)

????def?calculate_accuracy(self):
????????test_x?=?self.data.test.images
????????test_label?=?self.data.test.labels
????????#?using?the?net?trained
????????accuracy?=?self.sess.run(self.net.accuracy,?feed_dict={self.net.x:?test_x,?self.net.label:?test_label})
????????print("accuracy=%.2f,%dof?pictures?are?tested"?%(accuracy,len(test_label)))
????
if?__name__?==?"__main__":
????app?=?Train()
????app.train()
????app.calculate_accuracy()

train中会保存模型，然后我们需要将模型导入predict，对样本进行识别

import?numpy?as?np
import?tensorflow?as?tf
from?PIL?import?Image
from?mnist_model?import?Network
ckpt_path?=?'./ckpt/mnist-model.ckpt-9999'
class?Predict:
????def?__init__(self):
????????#?restore?the?network
????????self.net?=?Network()
????????self.sess?=?tf.Session()
????????self.sess.run(tf.global_variables_initializer())
????????self.restore()
????def?restore(self):
????????saver?=?tf.train.Saver()
????????saver.restore(self.sess,?ckpt_path)
????def?predict(self,?image_path):
????????#?turn?image?into?black?and?white
????????img?=?Image.open(image_path).convert('L')
????????flatten_img?=?np.reshape(img,?784)
????????x?=?np.array([1?-?flatten_img])
????????y?=?self.sess.run(self.net.y,?feed_dict={self.net.x:?x})
????????
????????print(image_path)
????????print('??????????->?Predict?digit',?np.argmax(y[0]))
if?__name__?==?"__main__":
????app?=?Predict()
????app.predict('./test_images/0.png')
????app.predict('./test_images/1.png')
????app.predict('./test_images/4.png')

样本：

运行结果：

另外在导入模型方面，还可以引入

def restore(self):
        saver = tf.train.Saver()
        ckpt = tf.train.get_checkpoint_state(CKPT_DIR)
        if ckpt and ckpt.model_checkpoint_path:
            saver.restore(self.sess, ckpt.model_checkpoint_path)
        else:
            raise FileNotFoundError("未保存任何模型")

进行错误处理

实际上还是可以像线性回归那边一样加入一个summary来方便用tensorboard来可视化，不过因为我上面跑的还挺成功的，就先不搞这个了，总体上还是比较顺利的

机器学习入门实践——线性回归&非线性回归&mnist手写体识别

原文地址：https://www.cnblogs.com/sasasatori/p/12342134.html

时间： 2024-10-12 07:39:21

机器学习入门实践——线性回归&非线性回归&mnist手写体识别的相关文章

机器学习入门：线性回归及梯度下降

机器学习入门:线性回归及梯度下降 本文会讲到: (1)线性回归的定义 (2)单变量线性回归 (3)cost function:评价线性回归是否拟合训练集的方法 (4)梯度下降:解决线性回归的方法之一 (5)feature scaling:加快梯度下降执行速度的方法 (6)多变量线性回归   Linear Regression 注意一句话:多变量线性回归之前必须要Feature Scaling! 方法:线性回归属于监督学习,因此方法和监督学习应该是一样的,先给定一个训练集,根据这个训练集学习出一个

深度学习-mnist手写体识别

mnist手写体识别 Mnist数据集可以从官网下载,网址: http://yann.lecun.com/exdb/mnist/ 下载下来的数据集被分成两部分:55000行的训练数据集(mnist.train)和10000行的测试数据集(mnist.test).每一个MNIST数据单元有两部分组成:一张包含手写数字的图片和一个对应的标签.我们把这些图片设为“xs”,把这些标签设为“ys”.训练数据集和测试数据集都包含xs和ys,比如训练数据集的图片是 mnist.train.images ,训练

机器学习入门三------线性回归

线性回归 线性回归是一种找到最适合一组点的直线或超平面的方法.本模块会先直观介绍线性回归,为介绍线性回归的机器学习方法奠定基础. 人们早就知晓,相比凉爽的天气,蟋蟀在较为炎热的天气里鸣叫更为频繁.数十年来,专业和业余昆虫学者已将每分钟的鸣叫声和温度方面的数据编入目录.Ruth 阿姨将她喜爱的蟋蟀数据库作为生日礼物送给您,并邀请您自己利用该数据库训练一个模型,从而预测鸣叫声与温度的关系. 首先建议您将数据绘制成图表,了解下数据的分布情况: 图 1. 每分钟的鸣叫声与温度(摄氏度)的关系. 毫无疑问

Tensorflow中使用CNN实现Mnist手写体识别

本文参考Yann LeCun的LeNet5经典架构,稍加ps得到下面适用于本手写识别的cnn结构,构造一个两层卷积神经网络,神经网络的结构如下图所示: 输入-卷积-pooling-卷积-pooling-全连接层-Dropout-Softmax输出 第一层卷积利用5*5的patch,32个卷积核,可以计算出32个特征.然后进行maxpooling.第二层卷积利用5*5的patch,64个卷积核,可以计算出64个特征.然后进行max pooling.卷积核的个数是我们自己设定,可以增加卷积核数目提高

pytorch实现MNIST手写体识别（全连接神经网络）

环境: pytorch1.1 cuda9.0 ubuntu16.04 该网络有3层,第一层input layer,有784个神经元(MNIST数据集是28*28的单通道图片,故有784个神经元).第二层为hidden_layer,设置为500个神经元.最后一层是输出层,有10个神经元(10分类任务).在第二层之后还有个ReLU函数,进行非线性变换. #!/usr/bin/env python # encoding: utf-8 ''' @author: liualex @contact: [em

MNIST数据集手写体识别(CNN实现)

github博客传送门 csdn博客传送门 本章所需知识: 没有基础的请观看深度学习系列视频 tensorflow Python基础 资料下载链接: 深度学习基础网络模型(mnist手写体识别数据集) MNIST数据集手写体识别(CNN实现) import tensorflow as tf import tensorflow.examples.tutorials.mnist.input_data as input_data # 导入下载数据集手写体 mnist = input_data.read

MNIST数据集手写体识别(MLP实现)

github博客传送门 csdn博客传送门 本章所需知识: 没有基础的请观看深度学习系列视频 tensorflow Python基础 资料下载链接: 深度学习基础网络模型(mnist手写体识别数据集) MNIST数据集手写体识别(MLP实现) import tensorflow as tf import tensorflow.examples.tutorials.mnist.input_data as input_data # 导入下载数据集手写体 mnist = input_data.read

MNIST数据集手写体识别(SEQ2SEQ实现)

github博客传送门 csdn博客传送门 本章所需知识: 没有基础的请观看深度学习系列视频 tensorflow Python基础 资料下载链接: 深度学习基础网络模型(mnist手写体识别数据集) MNIST数据集手写体识别(CNN实现) import tensorflow as tf import tensorflow.examples.tutorials.mnist.input_data as input_data # 导入下载数据集手写体 mnist = input_data.read

机器学习入门——单变量线性回归

线性回归的概念,在高中数学书里就出现过. 给你一些样本点,如何找出一条直线,使得最逼近这些样本点. 给出一个例子:假设 x 是房子面积,y是房子价格,确定一条直线需要theta0和theta1. 给出x,我们就可以计算出房子的价格 h(x) = theta0+theta1*x 关键是如何计算出theta0和theta1,也就是如何找出这么一条直线呢? 在这里,引入一个概念,叫做cost function.m表示样本个数,也就是训练样本数目 这是一个square error,学过统计的应该经常见到