二、openCV+TensorFlow入门

一、openCV入门

1 - 简单图片操作

• 图片读取与展示：imread第2参数，0表示灰度图片，1表示彩色图片

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
1
2
3
4
5
6
7

• 图片写入

import cv2
img = cv2.imread('image0.jpg',1)
cv2.imwrite('image1.jpg',img) # 1 name 2 data 
1
2
3

• 有损压缩：cv2.IMWRITE_JPEG_QUALITY，范围是0-100，数字越大图片越清晰
  • 可以看到压缩后为35kb，同时图片质量降低了

import cv2
img = cv2.imread('image0.jpg',1)
cv2.imwrite('imageTest.jpg',img,[cv2.IMWRITE_JPEG_QUALITY,50])
#1M 100k 10k 0-100 有损压缩
1
2
3
4

• png压缩：cv2.IMWRITE_PNG_COMPRESSION，压缩范围0-9，数字越小图片越清晰
  • 特点1：png是无损压缩
  • 特点2：png有图像透明度，jpg是没有图像透明度属性的

2 - 像素操作

• RGB：每一种颜色（像素）都是由RGB三种分量构成的
• 颜色深度：对于8位的颜色深度来说，可以表示0-255；也就是说一个颜色可以使用256256256来表示
• 图片的宽高：比如w：h = 640 * 480 -> 这个表示在水平方向上有640个像素点，在垂直方向上有480个像素点
• 图片的大小计算：假设图片的宽为720，高位547；那么图片的大小=7205473*8 bit/8（B）=1.14M
  • 其中720是宽，547是高，3代表RGB三种分量，第1个8代表是8位，第2个8代表bit转成B
• alpha通道：图片的透明度信息，上面介绍过png是无损压缩，有透明度信息
• BGR：颜色深度格式，除了RGB之外，还有BGR
  • opencv读取图片时获取的是bgr
  • BGR与RGB不同的是第一个像素值是B蓝色
  • BGR每个称之为一个分量，每个分量又叫做颜色通道
• 案例：像素读取与写入：注意像素写入的时候第一个是b

import cv2

# 像素的读取
img = cv2.imread('image0.jpg', 1)
(b, g, r) = img[100, 100]
print(b, g, r)  # bgr

# 像素的写入
for i in range(1, 100):
    img[10 + i, 100] = (255, 0, 0)
cv2.imshow('image', img)
cv2.waitKey(0)

1
2
3
4
5
6
7
8
9
10
11
12
13

二、TensorFlow入门

1 - TensorFlow常量变量

• 变量的使用注意：session使用前需要sess.run(init)初始化

import tensorflow as tf

data1 = tf.constant(2, dtype=tf.int32)
data2 = tf.Variable(10, name='var')
print(data1)
print(data2)

init = tf.global_variables_initializer()
sess = tf.Session()
with sess:
    sess.run(init)
    print(sess.run(data1))
    print(sess.run(data2))
1
2
3
4
5
6
7
8
9
10
11
12
13

2 - TensorFlow运算本质

• tensorflow的本质：张量tensor+计算图grahps
  • tf = tensor + grahps
  • tensor：数据
  • op：操作，可以是赋值操作也可以是四则运算操作
  • grahps：数据操作的过程
  • Session：在tf中所有的grahps都需要放到Session会话中来执行，Session可以理解成一个运算的交互环境
    

3 - TensorFlow四则运算

• 常量间的四则运算

import tensorflow as tf
data1 = tf.constant(6)
data2 = tf.constant(2)
dataAdd = tf.add(data1,data2)
dataMul = tf.multiply(data1,data2)
dataSub = tf.subtract(data1,data2)
dataDiv = tf.divide(data1,data2)
with tf.Session() as sess:
    print(sess.run(dataAdd))
    print(sess.run(dataMul))
    print(sess.run(dataSub))
    print(sess.run(dataDiv))
print('end!')
1
2
3
4
5
6
7
8
9
10
11
12
13

• 常量变量间的四则运算

import tensorflow as tf

data1 = tf.constant(6)
data2 = tf.Variable(2)
dataAdd = tf.add(data1, data2)
dataCopy = tf.assign(data2, dataAdd)  # dataAdd ->data2，数据拷贝
dataMul = tf.multiply(data1, data2)
dataSub = tf.subtract(data1, data2)
dataDiv = tf.divide(data1, data2)
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    print(sess.run(dataAdd))
    print(sess.run(dataMul))
    print(sess.run(dataSub))
    print(sess.run(dataDiv))
    print('sess.run(dataCopy)', sess.run(dataCopy))  # 8->data2
    print('dataCopy.eval()', dataCopy.eval())  # 8+6->14->data = 14
    print('tf.get_default_session()', tf.get_default_session().run(dataCopy))
print('end!')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4 - tensorflow矩阵基础

• placeholder使用

import tensorflow as tf

data1 = tf.placeholder(tf.float32)
data2 = tf.placeholder(tf.float32)
dataAdd = tf.add(data1, data2)
with tf.Session() as sess:
    print(sess.run(dataAdd, feed_dict={data1: 6, data2: 2}))
    # 1 dataAdd 2 data (feed_dict = {1:6,2:2})
print('end!')

1
2
3
4
5
6
7
8
9
10

• 矩阵加法：2个矩阵的行列要相同
  

• 矩阵乘法：第1个矩阵的列数要和第2个矩阵的行数相同
  

• ---

  • matmul：矩阵乘法，需要满足第1个矩阵的列数和第2个矩阵的行数相同
  • multiply：普通的乘法，无要求，两个矩阵对应元素相乘

import tensorflow as tf

data1 = tf.constant([[6, 6]])
data2 = tf.constant([[2],
                     [2]])
data3 = tf.constant([[3, 3]])
matMul = tf.matmul(data1, data2)
matMul2 = tf.multiply(data1, data2)
matAdd = tf.add(data1, data3)
with tf.Session() as sess:
    print(sess.run(matMul))  # 1 维 M=1 N=2. 1X2(MK) 2X1(KN) = 1(MN)
    print(sess.run(matAdd))  # 1行2列
    print(sess.run(matMul2))  # 1x2 2x1 = 2x2
    print(sess.run([matMul, matAdd]))  # 一次打印多个

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 矩阵填充：tf.zeros、tf.ones、tf.fill

import tensorflow as tf

mat0 = tf.constant([[0, 0, 0], [0, 0, 0]])
mat1 = tf.zeros([2, 3])  # 2*3的空矩阵
mat2 = tf.ones([3, 2])  # 3行2列的全1矩阵
mat3 = tf.fill([2, 3], 15)  # 3行2列的全固定值矩阵
with tf.Session() as sess:
    # print(sess.run(mat0))
    # print(sess.run(mat1))
    # print(sess.run(mat2))
    print(sess.run(mat3))

1
2
3
4
5
6
7
8
9
10
11
12

• 其他矩阵操作
  • tf.zeros_like：填充维度相同的0矩阵
  • tf.linspace：生成等分数据的数组
  • tf.random_uniform：随机矩阵

import tensorflow as tf

mat1 = tf.constant([[2], [3], [4]])  # 3行1列
mat2 = tf.zeros_like(mat1)  # 定义一个与mat1相同行列数的全0矩阵
mat3 = tf.linspace(0.0, 2.0, 11)  # 将0-2之间的数据分成10等分的数据
mat4 = tf.random_uniform([2, 3], -1, 2)  # 随机矩阵：2*3矩阵，在-1到2之间产生随机数
with tf.Session() as sess:
    print(sess.run(mat2))
    print('----------------------------')
    print(sess.run(mat3))
    print('----------------------------')
    print(sess.run(mat4))

1
2
3
4
5
6
7
8
9
10
11
12
13

5 - numpy矩阵

import numpy as np

data1 = np.array([1, 2, 3, 4, 5])
print(data1)
data2 = np.array([[1, 2],
                  [3, 4]])
print(data2)
# 维度
print(data1.shape, data2.shape)
print('------------------------------')
# zero ones
print(np.zeros([2, 3]), '\n', np.ones([2, 2]))
# 改查
data2[1, 0] = 5
print(data2)
print(data2[1, 1])
print('------------------------------')
# 基本运算
data3 = np.ones([2, 3])
print(data3 * 2)  # 每个元素对应相乘
print(data3 / 3)
print(data3 + 2)
print('------------------------------')
# 矩阵+*
data4 = np.array([[1, 2, 3], [4, 5, 6]])
print(data3 + data4)  # 对应元素相加
print(data3 * data4)  # 对应元素相乘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

6 - matplotlib绘图

• 可以直接在anaconda中安装matplotlib
  
• matplotlib绘图
  • plt.plot：绘制折线图
  • plt.bar：绘制柱状图

import numpy as np
import matplotlib.pyplot as plt

x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = np.array([3, 5, 7, 6, 2, 6, 10, 15])
plt.plot(x, y, 'r')  # 折线 1 x 2 y 3 color
plt.plot(x, y, 'g', lw=10)  # 参数4：lw线条宽度
# 折线 柱状 饼状
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = np.array([13, 25, 17, 36, 21, 16, 10, 15])
plt.bar(x, y, 0.2, alpha=1, color='b')  # alpha 透明度（0-1，越大越粗）
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13

三、神经网络逼近股票收盘均价（案例）

1 - 绘制15天股票K线的柱状图

import numpy as np
import matplotlib.pyplot as plt

date = np.linspace(1, 15, 15)  # 表示日期
# endPrice收盘价
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])
# beginPrice开盘价
beginPrice = 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])
print(date)
plt.figure()  # 绘图
for i in range(0, 15):
    dateOne = np.zeros([2])
    dateOne[0] = i
    dateOne[1] = i
    priceOne = np.zeros([2])
    priceOne[0] = beginPrice[i]
    priceOne[1] = endPrice[i]
    if endPrice[i] > beginPrice[i]:
        plt.plot(dateOne, priceOne, 'r', lw=8)  # 上涨
    else:
        plt.plot(dateOne, priceOne, 'g', lw=8)  # 下跌
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

2 - 人工神经网络简介

• 人工神经网络三层：输入层、隐藏层（中间层）、输出层

• 神经网络三层的转换公式
  • A代表输入矩阵、B代表隐藏矩阵、C代表输出矩阵
  • w代表权重矩阵
  • b代表偏置矩阵
    
• 矩阵维度分析
  
• 梯度下降法：获取最终的w1w2b1b2
  • 终止的2种条件：根据循环次数控制；根据与真实的差异百分比控制
    

3 - 编码实现

• 结果说明：可以看到蓝色的折线图是预测的收盘价格，与实际的收盘价格还是比较接近的

# layer1：激励函数+乘加运算
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

date = np.linspace(1, 15, 15)
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]
)
beginPrice = 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])
print(date)
plt.figure()
for i in range(0, 15):
    # 1 柱状图
    dateOne = np.zeros([2])
    dateOne[0] = i
    dateOne[1] = i
    priceOne = np.zeros([2])
    priceOne[0] = beginPrice[i]
    priceOne[1] = endPrice[i]
    if endPrice[i] > beginPrice[i]:
        plt.plot(dateOne, priceOne, 'r', lw=8)
    else:
        plt.plot(dateOne, priceOne, 'g', lw=8)
# plt.show()
# A(15x1)*w1(1x10)+b1(1*10) = B(15x10)
# B(15x10)*w2(10x1)+b2(15x1) = C(15x1)
# 1 A B C
# 归一化
dateNormal = np.zeros([15, 1])
priceNormal = np.zeros([15, 1])
for i in range(0, 15):
    dateNormal[i, 0] = i / 14.0
    priceNormal[i, 0] = endPrice[i] / 3000.0

# 数据装载
x = tf.placeholder(tf.float32, [None, 1])  # N行1列
y = tf.placeholder(tf.float32, [None, 1])
# 隐藏层
w1 = tf.Variable(tf.random_uniform([1, 10], 0, 1))
b1 = tf.Variable(tf.zeros([1, 10]))
wb1 = tf.matmul(x, w1) + b1
layer1 = tf.nn.relu(wb1)  # 激励函数：简单的映射
# 输出层
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)
# loss差异
loss = tf.reduce_mean(tf.square(y - layer2))  # 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):  # 训练1万次
        sess.run(train_step, feed_dict={x: dateNormal, y: priceNormal})
    # w1w2b1b2，A + wb -->layer2
    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=1)
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66