2 计算机视觉入门之OpenCV入门、TensorFlow入门
2-1 本章介绍
本章主要内容：
- OpenCV初识
- OpenCV文件结构
- Demo1 图片读取：图片封装格式、压缩编码
- Demo2 图片写入：图片质量
- Demo3 像素操作：矩阵颜色空间
- 课程小结
OpenCV是一个开源的计算机视觉库，应用领域很广泛，在地图、导航、手机、嵌入式等等应用很常见。
2-2 Mac下一站式开发环境anaconda搭建
Mac版本的详细搭建流程我自己试了，其实大同小异，大家可以根据下面我给的链接按照操作一步一步搭建，很简单的。
- 下载并安装anaconda
- 下载并安装tensorflow和OpenCV
- 下载并安装notebook
点击这里，附上Mac详细安装教程
2-3 Windows下一站式开发环境anaconda搭建
这个视频里面讲的是tf1.x版本的，虽然现在工业界很多都还是使用的1.x版本，但是2.x确实比1.x强大很多，也在慢慢转换成2.x，大家也可以学习2.x版本的TensorFlow。
- 下载并安装anaconda
- 下载并安装tensorflow和OpenCV
- 下载并安装notebook
点击这里，附上Windows详细安装教程
2-4 测试案例Hello World
#1 import 2 string 3 print
import tensorflow as tf
hello = tf.constant('hello tf!')
sess = tf.Session()
print(sess.run(hello))
#常量 sess print
这里必须使用tf1.x版本，如果你的是tf2.x版本建议降级之后再使用
import cv2
print('hello opencv')
2-5 案例1：图片的读取和展示
import cv2
img = cv2.imread('image0.jpg',1)
cv2.imshow('image',img)
cv2.waitKey (0)
2-6 Opencv模块组织结构
opencv的框架与各模块功能介绍这里介绍了各个模块中的功能。
其中，比较重要的模块有core、imgcodecs、imgproc、ml、photo这几个模块。
2-7 案例2：图片写入
图片文件分为文件头和文件数据，不同的文件格式（jpg、png等），文件头和文件数据都是不一样的，文件数据也是文件进行压缩编码后的文件数据，而大部分的文件头描述的就是数据部分的的解码信息和以及附加信息，解码器可以根据附加信息将文件数据还原成图像最原始的数据。
代码如下：
import cv2
# 1 文件的读取 2 封装格式解析 3 数据解码 4 数据加载
img = cv2.imread('image0.jpg',1)
cv2.imshow('image',img)
# jpg png 1 文件头 2 文件数据
cv2.waitKey (0)
# 1.14M 130k
import cv2
img = cv2.imread('image0.jpg',1)
cv2.imwrite('image1.jpg',img) # 1 name 2 data
2-8 案例3：不同图片质量保存
不同图片质量也就是不同压缩比的图片。
1. JPEG
JPEG是有损压缩，压缩比为0-100，为0时，压缩比越高，越模糊；为100时，压缩比越低，越清晰（见下图）
import cv2
img = cv2.imread('image_jpg.jpg', 1) # 1M 100k 10k 0-100 有损压缩
cv2.imwrite('imageTest0.jpg', img, [cv2.IMWRITE_JPEG_QUALITY, 0])
cv2.imwrite('imageTest100.jpg', img, [cv2.IMWRITE_JPEG_QUALITY, 100])
imageTest0 = cv2.imread('imageTest0.jpg', 1)
imageTest100 = cv2.imread('imageTest100.jpg', 1)
cv2.imshow('img', img)
cv2.imshow('imageTest0', imageTest0)
cv2.imshow('imageTest100', imageTest100)
cv2.waitKey(0)
2. PNG
PNG是无损压缩，压缩比为0-9；为0时，压缩比越低，越清晰；为9时，压缩比越高，越模糊
import cv2
image_png = cv2.imread('image_png.png', 1) # 1M 100k 10k 0-100 有损压缩
cv2.imwrite('imageTest0.png', image_png, [cv2.IMWRITE_PNG_COMPRESSION, 0])
cv2.imwrite('imageTest9.png', image_png, [cv2.IMWRITE_PNG_COMPRESSION, 9])
imageTest0 = cv2.imread('imageTest0.png', 1)
imageTest9 = cv2.imread('imageTest9.png', 1)
cv2.imshow('image_png', image_png)
cv2.imshow('imageTest0', imageTest0)
cv2.imshow('imageTest9', imageTest9)
cv2.waitKey(0)
直观上，PNG图片看不出来有啥大变化，但是看直接看图片大小，我们可以清晰的看到为0时图片大小和原图一样，为9时小了很多。
2-9 像素操作基础
我们看到的每一张图片或者视频里面的每一帧，其实都是由像素点组成的，那么什么是像素点呢？百度吧！，上面都有，这里就不说了。
下图中，表示一个像素点由RGB三种颜色组成，RGB每一个基色都有8位，也就是0~255，而计算机只能识别二进制，所以下面那串数字就是对应计算机中读取到的这个像素点的数值。
下图中，第6点是png图片有个α系数，表示透明系数。还有，我们的彩色图像的通道由B、G、R这个顺序组成的。
2-10 案例4：像素读取写入
不要偷懒，手动敲一边。
这里有个小技巧，当我们输入某一个函数，不知道这个函数括号里面的变量是什么意思的时候，我们输入一个左括号或者第一个变量之后输入一个逗号，都会提示你下一个变量写什么，如果真的不知道什么意思，可以按住ctrl+点击鼠标左键进入函数内部查看
也有可能是ctrl+alt+鼠标左键，就比如我的电脑按住ctrl+左键就只是显示一堆|这个竖线。根据个人情况而议。
接下来就是像素读取写入代码：
import cv2
img = cv2.imread('1.jpg', 1) # 读取图片，其中0表示读入彩色图片，-1表示灰度图片，1表示保留读取图片原有的颜色通道
# 上面一句也可以用以下方式表示
img_color = cv2.imread('1.jpg', cv2.IMREAD_COLOR) # 可以用0表示cv2.IMREAD_COLOR
img_gray = cv2.imread('1.jpg', cv2.IMREAD_GRAYSCALE) # 可以用-1表示cv2.IMREAD_GRAYSCALE
img_unchanged = cv2.imread('1.jpg', cv2.IMREAD_UNCHANGED) # 可以用1表示cv2.IMREAD_UNCHANGED
(b, g, r) = img[50, 50] # img[50, 50]表示img在50,50这个位置的像素点，因为是三通道，分别对应着B、G、R，千万不能弄错
print(b, g, r) # 输出结果为251 252 250
# 50,150-->150,150，即画一条竖线
for i in range(1, 150):
img[50 + i, 150] = (0, 0, 255) # (0, 0, 255)表示红色
# 150,50-->150,150，即画一条横线
for i in range(1, 150):
img_color[150, 50 + i] = (0, 255, 0) # (0, 255, 0)表示绿色
# 50,50-->150,150，即将左上到右下组成的的矩形进行内部填充
for i in range(1, 150):
for j in range(1, 150):
img_gray[50 + i, 50 + j] = 255 # 255白色
# 50,150-->150,50，即将左下到右上组成的的矩形进行内部填充
for i in range(1, 150):
for j in range(1, 150):
img_unchanged[50 + i, 150 - j] = (255, 0, 0) # (255, 0, 0)表示蓝色
cv2.imshow("img", img)
cv2.imshow("img_color", img_color)
cv2.imshow("img_gray", img_gray)
cv2.imshow("img_unchanged", img_unchanged)
cv2.waitKey(0)
2-11 tensorflow常量变量定义
import tensorflow as tf
data1 = tf.constant(2, dtype=tf.int32)
data2 = tf.Variable(10, name='var')
print(data1)
print(data2)
sess = tf.Session()
print(sess.run(data1))
sess.run(tf.global_variables_initializer())
print(sess.run(data2))
2-12 tensorflow运算原理
下面内容只适用于tf1.x版本，tf2.x抛弃了张量，所以想要运行必须下载1.x版本。
import tensorflow as tf
data1 = tf.constant(2, dtype=tf.int32)
data2 = tf.Variable(10, name='var')
print(data1)
print(data2)
sess = tf.Session()
print(sess.run(data1))
'''
sess.run(tf.global_variables_initializer())
print(sess.run(data2))
sess.close() # 关闭会话，如果不用close，也可以用with进行关闭
# 本质 tf=tensor+计算图
# tensor数据
# op
# graphs数据操作
# session
'''
init = tf.global_variables_initializer()
sess = tf.Session()
with sess:
sess.run(init)
print(sess.run(data2))
2-13 常量变量四则运算
import tensorflow as tf
data1 = tf.constant(6)
data2 = tf.constant(2)
dataAdd = tf.add(data1, data2)
dataSub = tf.subtract(data1, data2)
dataMul = tf.multiply(data1, data2)
dataDiv = tf.divide(data1, data2)
with tf.Session() as sess:
print("data1+data2={}".format(sess.run(dataAdd)))
print("data1-data2={}".format(sess.run(dataSub)))
print("data1*data2={}".format(sess.run(dataMul)))
print("data1/data2={}".format(sess.run(dataDiv)))
print('end!')
运行结果为：
data1+data2=8
data1-data2=4
data1*data2=12
data1/data2=3.0
end!
上面都是常亮的加减乘除，下面修改一个值为变量进行加减乘除看看效果：
import tensorflow as tf
data1 = tf.constant(6)
# data2 = tf.constant(2)
data2 = tf.Variable(2) # 将data2改为变量
dataAdd = tf.add(data1, data2)
dataCopy = tf.assign(data2, dataAdd) # 将dataAdd的值复制给data2，这时data2为6+2=8
dataSub = tf.subtract(data1, data2)
dataMul = tf.multiply(data1, data2)
dataDiv = tf.divide(data1, data2)
init = tf.global_variables_initializer() # 存在变量，需要进行初始化
with tf.Session() as sess:
sess.run(init)
print("data1+data2={}".format(sess.run(dataAdd)))
print("data1-data2={}".format(sess.run(dataSub)))
print("data1*data2={}".format(sess.run(dataMul)))
print("data1/data2={}".format(sess.run(dataDiv)))
print("sess.run(dataCopy)=", sess.run(dataCopy)) # 值为8
print("dataCopy.eval()=", dataCopy.eval()) # 8+6=14->dataCopy
print("tf.get_default_session()=", tf.get_default_session().run(dataCopy)) # 14+6=20->dataCopy,和上面eval功能一样
print('end!')
运行结果为：
data1+data2=8
data1-data2=4
data1*data2=12
data1/data2=3.0
sess.run(dataCopy)= 8
dataCopy.eval()= 14
tf.get_default_session()= 20
end!
2-14 矩阵基础1
placeholder，中文意思是占位符，在tensorflow中类似于函数参数，运行时必须传入值。
import tensorflow as tf
data1 = tf.placeholder(tf.float32) # 这里通过placeholder先填坑
data2 = tf.placeholder(tf.float32)
dataAdd = tf.add(data1, data2)
with tf.Session() as sess:
# 通过feed_dict()函数向占位符喂入数据，用字典的方式填坑
print(sess.run(dataAdd, feed_dict={
data1: 8, data2: 6}))
print('end')
运行结果：
14.0
end
以下是矩阵基础知识：
import tensorflow as tf
# 外面的中括号表示这是一个矩阵，里面的中括号表示这是几行几列
data1 = tf.constant([[8, 8]])
data2 = tf.constant([[2],
[2]])
data3 = tf.Variable(6, name='var')
print('data1:', data1) # 直接输出不会打印矩阵，输出的第一个表示常量还是变量，第二个表示形状，第三个表示类型
print('data2:{}'.format(data2)) # format用法和上面一样
data3 = tf.constant([[3, 3]])
data4 = tf.constant([[1, 3],
[2, 4],
[7, 8]])
print('data3.shape:', data3.shape)
print('data4.shape:', data4.shape)
with tf.Session() as sess:
print(sess.run(data4)) # 打印整体
print(sess.run(data4[1])) # 打印某一行
print(sess.run(data4[:, 0])) # :表示打印所有行，0表示打印第一列
print(sess.run(data4[0, 1])) # 0,1表示打印第1行第二列的数
print('end!')
运行结果：
data1: Tensor("Const:0", shape=(1, 2), dtype=int32)
data2:Tensor("Const_1:0", shape=(2, 1), dtype=int32)
data3.shape: (1, 2)
data4.shape: (3, 2)
[[1 3]
[2 4]
[7 8]]
[2 4]
[1 2 7]
3
end!
2-15 矩阵基础2
矩阵的广播在TensorFlow官方文档里面有介绍。
import tensorflow as tf
data1 = tf.constant([[6, 6]])
data2 = tf.constant([[2],
[3]])
data3 = tf.constant([[2, 2]])
data4 = tf.constant([[1, 2],
[4, 5],
[8, 9]])
# 相同维度的矩阵加法
matAdd = tf.add(data1, data3)
# 这里data1和data4的维度不同，用了广播的特性，将低维扩展成高维，data1变成data4相同维度，且每一行相同
matAdd2 = tf.add(data1, data4)
# 矩阵乘法,要满足矩阵相乘格式，即第一个矩阵列要和第二个矩阵行相同
matMul = tf.matmul(data1, data2)
# 这里乘法是将矩阵中对应元素各自相乘，不同维度用广播特性，并且数据类型必须相同，否则报错
matMul2 = tf.multiply(data1, data4)
with tf.Session() as sess:
print(sess.run(matAdd))
print(sess.run(matAdd2))
print(sess.run(matMul))
print(sess.run(matMul2))
运行结果如下：
[[8 8]]
[[ 7 8]
[10 11]
[14 15]]
[[30]]
[[ 6 12]
[24 30]
[48 54]]
2-16 矩阵基础3
一定要自己手敲，多动手，多思考，自己写一遍写多遍，代码如下：
import tensorflow as tf
# 这里定义了一个2行3列全0的矩阵，很麻烦
data1 = tf.constant([[0, 0, 0], [0, 0, 0]])
# 这里直接用zeros函数给定一个2行3列全0的矩阵,默认float32型，很简单
data2 = tf.zeros([2, 3])
# 这里直接用ones函数给定一个3行2列全1的矩阵,格式转为int32型
data3 = tf.ones([3, 2], dtype=tf.int32)
# 这里直接用fill函数填充一个全为88的6行6列的矩阵
data4 = tf.fill([6, 6], 88)
# 这里定义了一个3行1列的矩阵
data5 = tf.constant([[6], [8], [6]])
# 这里直接用zeros_like给定了一个格式像data5全为0的矩阵
data6 = tf.zeros_like(data5)
# 这里直接用ones_like给定了一个格式像data5全为1的矩阵
data7 = tf.ones_like(data5)
# 这里调用了linspace函数，将0.0-3.0等分为5等份，开始为0.0，结束为3.0
data8 = tf.linspace(0., 3., 5)
# 这里调用random_uniform函数，随机生成-2~2之间的6行6列的数组，最小值为-2，最大值为2
data9 = tf.random_uniform([6, 6], -2, 2)
with tf.Session() as sess:
print('===========data1===========')
print(sess.run(data1))
print('===========data2===========')
print(sess.run(data2))
print('===========data3===========')
print(sess.run(data3))
print('===========data4===========')
print(sess.run(data4))
print('===========data5===========')
print(sess.run(data5))
print('===========data6===========')
print(sess.run(data6))
print('===========data7===========')
print(sess.run(data7))
print('===========data8===========')
print(sess.run(data8))
print('===========data9===========')
print(sess.run(data9))
运行结果如下：
===========data1===========
[[0 0 0]
[0 0 0]]
===========data2===========
[[0. 0. 0.]
[0. 0. 0.]]
===========data3===========
[[1 1]
[1 1]
[1 1]]
===========data4===========
[[88 88 88 88 88 88]
[88 88 88 88 88 88]
[88 88 88 88 88 88]
[88 88 88 88 88 88]
[88 88 88 88 88 88]
[88 88 88 88 88 88]]
===========data5===========
[[6]
[8]
[6]]
===========data6===========
[[0]
[0]
[0]]
===========data7===========
[[1]
[1]
[1]]
===========data8===========
[0. 0.75 1.5 2.25 3. ]
===========data9===========
[[ 0.11197186 1.4124808 1.0134263 -1.9970236 -0.47386456 -0.9146967 ]
[ 1.0346313 0.6334176 0.42210913 1.9567823 0.5573721 -0.5008154 ]
[-1.3602605 0.28631544 -1.1130176 1.0130343 0.25490332 1.5334082 ]
[-1.5158668 -1.1822262 1.2910948 -0.19497156 1.2264953 1.0197816 ]
[ 1.9740758 -0.83928776 0.09417915 1.7391467 0.5077319 -0.6977172 ]
[-0.21380329 -1.2817559 0.6250396 -0.39457607 1.6598969 -0.43963957]]
2-17 numpy模块使用
更多numpy相关的功能请查看numpy官方文档
代码如下：
# 使用numpy模块进行增(Create)\删(Delete)\改(Update)\查(Read)==CURD
import numpy as np
# 用array创建一个一维数组
data1 = np.array([1, 2, 3, 4, 5, 6])
# 用array创建一个二维数组
data2 = np.array([[1, 2, 3],
[4, 5, 6]])
print(data1)
print('===========before update===========')
print(data2)
# shape表示维度
print('data1.shape:{0}\ndata2.shape:{1}'.format(data1.shape, data2.shape))
# numpy的ones和zeros这些都和TensorFlow一样
print(np.ones([3, 3]))
print(np.zeros(([2, 2])))
# 修改data2中第2行第2列的数据为88
data2[1, 1] = 88
print('===========after update===========')
print(data2)
# 读取data2第2行第2列的数据
print(data2[1, 1])
# 定义一个2行3列全为1的矩阵
data3 = np.ones([2, 3])
# 矩阵与数字基本运算
print('data3 = \n', data3)
print('data3 + 3 = \n', data3 + 3) # data3直接与3相加
print('data3 - 3 = \n', data3 - 3) # data3直接与3相减
print('data3 * 3 = \n', data3 * 3) # data3直接与3相乘
print('data3 / 3 = \n', data3 / 3) # data3直接与3相除
# 两个矩阵的+和*，当然不同，不同维度就会产生广播特性
data4 = np.array([[1, 2, 1],
[4, 5, 4]])
print('data3 + data4 = \n', data3 + data4)
# 由于data3为全为1
print('data3 * data4 = \n', data3 * data4)
运行结果如下：
[1 2 3 4 5 6]
===========before update===========
[[1 2 3]
[4 5 6]]
data1.shape:(6,)
data2.shape:(2, 3)
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]
[[0. 0.]
[0. 0.]]
===========after update===========
[[ 1 2 3]
[ 4 88 6]]
88
data3 =
[[1. 1. 1.]
[1. 1. 1.]]
data3 + 3 =
[[4. 4. 4.]
[4. 4. 4.]]
data3 - 3 =
[[-2. -2. -2.]
[-2. -2. -2.]]
data3 * 3 =
[[3. 3. 3.]
[3. 3. 3.]]
data3 / 3 =
[[0.33333333 0.33333333 0.33333333]
[0.33333333 0.33333333 0.33333333]]
data3 + data4 =
[[2. 3. 2.]
[5. 6. 5.]]
data3 * data4 =
[[1. 2. 1.]
[4. 5. 4.]]
2-18 matplotlib模块的使用
更多numpy相关的功能请查看matplotlib官方文档
代码如下：
import numpy as np
import matplotlib.pyplot as plt
# x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
# y = np.array([5, 2, 3, 7, 4, 8, 10, 13, 15])
# 生成1~10(不包括10)，步长为1的9组数
x = np.arange(1, 10, 1)
# 随机生成3~20之间，大小为9的数组
y = np.random.randint(3, 20, size=9)
# plot是折线图，x为x轴坐标，y为y轴左边，'r'为颜色,lw=5表示线宽
plt.plot(x, y, 'r', lw=5)
# plt.show() #如果这里加上show就会将折线图和柱状图分为两个窗口显示
x = np.arange(1, 10, 1)
y = np.random.randint(3, 20, size=9)
# bar表示，柱状图和png图片一样，这里的alpha也表示透明度，0(完全透明)~1(不透明)
plt.bar(x, y, alpha=0.5, color='g')
plt.show()
运行结果如下：
2-19 小综合：人工神经网络逼近股票价格1
股票相信大家都应该玩过吧，开盘价<收盘价就是红色K线图，我们心情就像吃了蜜一样甜。开盘价>收盘价就是绿色K线图，我们的心情就行吃了苦瓜一样，整个人都不好受。下面就是具体的K线图。
代码如下所示：
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
# 先用linspace生成一组1~15的个数为15个的等差数列
data = np.linspace(1, 15, 15, dtype=np.int32)
data2 = np.arange(1, 16) # 输出结果上面一样，np.arange(1, 16)输出不包括16
startPrice = np.array([2438.71, 2500.88, 2534.95, 2512.52, 2594.04, 2743.26, 2697.47,
2695.24, 2678.23, 2722.13, 2674.93, 2744.13, 2717.46, 2832.73, 2877.40])
endPrice = np.array([2511.90, 2538.26, 2510.68, 2591.66, 2732.98, 2701.69, 2701.29,
2678.67, 2726.50, 2681.50, 2739.17, 2715.07, 2823.58, 2864.90, 2919.08])
# 自动生成随机的开始结束价格
# startPrice = np.random.uniform(2500, 2600, 15)
# endPrice = np.random.uniform(2550, 2700, 15)
print("data2:", data2)
print('startPrice:', startPrice)
print('endPrice:', endPrice)
# figure作用为连续画几个图，如果只用画一个图，可以不需要,这里只有一个图，所以可以不用要
# plt.figure(num='stock')
for i in range(0, 15):
# 柱状图
dataSet = np.zeros([2]) # 生成两组值为0的数组，分别用来存放开始结束价格的横坐标
dataSet[0] = i
dataSet[1] = i
priceSet = np.zeros([2]) # 生成两组值为0的数组，分别用来存放开始结束价格的价格值
priceSet[0] = startPrice[i]
priceSet[1] = endPrice[i]
# 画线进行判断，如果开始价格>结束价格，说明是价格下降了，对应绿色K线
if startPrice[i] > endPrice[i]:
plt.plot(dataSet, priceSet, color='g', lw=6)
else: # 如果开始价格<结束价格，说明是价格上涨了，对应红色K线
plt.plot(dataSet, priceSet, color='r', lw=6)
plt.show()
运行结果如下：
2-20 小综合：人工神经网络逼近股票价格2
这一节的内容是将生成的股票价格K线图用传统的神经网络来模拟，下面是具体的过程：
从上图可以看出，输入层对应着天数，可以自己定义，这里是一个15行1列的矩阵。隐藏层设的是一个1x10的矩阵，输出层是15x1的矩阵，
ConvNetJS是一个Javascript库，用于完全在您的浏览器中训练深度学习模型（神经网络），大家可以试试看看。
这里是一个训练数据的循环体，将每一次的输出值和输入值做差，若果差异大于2%，就会进行梯度下降，然后循环，一直到它们的差异小于2%才会结束循环。
2-21~2-22 小综合：人工神经网络逼近股票价格3-4
代码如下：
# 导入必要模块
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
# date = np.arange(1, 16)
date = np.linspace(1, 15, 15)
# print(date)
startPrice = np.array([2438.71, 2500.88, 2534.95, 2512.52, 2594.04, 2743.26, 2697.47,
2695.24, 2678.23, 2722.13, 2674.93, 2744.13, 2717.46, 2832.73, 2877.40])
endPrice = np.array([2511.90, 2538.26, 2510.68, 2591.66, 2732.98, 2701.69, 2701.29,
2678.67, 2726.50, 2681.50, 2739.17, 2715.07, 2823.58, 2864.90, 2919.08])
# print(startPrice)
# print(endPrice)
plt.figure()
for i in range(1, 15):
dateSet = np.zeros([2])
dateSet[0] = i
dateSet[1] = i
priceSet = np.zeros([2])
priceSet[0] = startPrice[i]
priceSet[1] = endPrice[i]
if startPrice[i] > endPrice[i]:
plt.plot(dateSet, priceSet, 'g', lw=8)
else:
plt.plot(dateSet, priceSet, 'r', lw=8)
# plt.show()
# A(15x1)*w1(1x10)+b1(1*10) = B(15x10)
# B(15x10)*w2(10x1)+b2(15x1) = C(15x1)
dateNormal = np.zeros([15, 1])
priceNormal = np.zeros([15, 1])
for i in range(0, 15):
dateNormal[i, 0] = i / 14 # 将日期归一化
priceNormal[i, 0] = endPrice[i] / 3000.0 # 将价格归一化
# 先将x和y用占位符占好位置，还不知道多少行，用None填充
x = tf.placeholder(tf.float32, [None, 1])
y = tf.placeholder(tf.float32, [None, 1])
# B => A(15x1) * w1(1x10) + b1(1x10) = B(15x10)
w1 = tf.Variable(tf.random_uniform([1, 10], 0, 1)) # 定义一个1行10列在0~1之间的矩阵
b1 = tf.Variable(tf.zeros([1, 10])) # 定义一个1行10列为0的矩阵
wb1 = tf.matmul(x, w1) + b1
layer1 = tf.nn.relu(wb1) # 激励函数
# C => B(15*10) * w2(10x1) +b2(15x1) = C(15x1)
w2 = tf.Variable(tf.random_uniform([10, 1], 0, 1))
b2 = tf.Variable(tf.zeros([15, 1]))
wb2 = tf.matmul(layer1, w2) + b2
layer2 = tf.nn.relu(wb2) # 激励函数
# 将真实y值与最后的输出值layer2计算差值，square表示求平方，reduce_mean用作降维或者求平均值
loss = tf.reduce_mean(tf.square(y - layer2))
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for i in range(0, 10000):
sess.run(train_step, feed_dict={
x: dateNormal, y: priceNormal})
pred = sess.run(layer2, feed_dict={
x: dateNormal})
predPrice = np.zeros([15, 1])
for i in range(0, 15):
predPrice[i, 0] = (pred * 3000)[i, 0]
plt.plot(date, predPrice, 'b', lw=2)
plt.show()
运行结果如下：
