一、tensorflow和opencv测试

import tensorflow as tf
import cv2hello = tf.constant('hello tensorflow')
session = tf.Session()
print(session.run(hello))print('hello opencv')

运行效果如下：

二、基础部分

1、opencv基础

代码三部曲：

1、引入OpenCV
2、调用相关API
3、通过stop让图片暂停方便观察

imread处理过程：1，文件的读取、2，封装格式解析、3，数据解码、4，数据加载

图片封装格式主要包括：jpg和png；
其主要包括：文件头和文件数据（图片压缩编码之后的数据）

cv2.imread('E:\Jupyter_workspace\study\img/water.png',1)
参数1:图片路径
参数2:图片类型 1彩色 0灰色

import cv2img = cv2.imread('E:\Jupyter_workspace\study\img/water.png',1)#读取图片。参数1:图片路径；参数2:图片类型 1彩色 0灰色
cv2.imshow('img',img)#参数1：窗体名称   参数2：展示的内容
cv2.waitKey(0)#暂停方便观察

opencv模块组织结构，其中每个文件夹代表一个模块

calib3d：主要用于相机的校准和3d内容相关的模块
core：记录了当前opencv的基础数据类型，矩阵操作、绘图相关（重要） dnn：神经网络相关的模块
feature2d：与角点检测，图像匹配相关 flann：与矩阵相关的模块，领域搜索算法等等 highgui：图形相关交互
imgcodecs和imgproc：图像处理相关的模块，滤波器，直方图统计，均衡化、几何变换、颜色处理（重要） ml：机器学习模块（重要）
objdetect：物体检测模块 photo：图片处理模块，图片的修复、去噪（重要） shape：
stitching：拼接模块，大图像的拼接，例如360全景相机
video、videoil和videostab：视频信息模块，视频分解图像，图像合成视频

2、图片的写入

cv2.imwrite('E:\Jupyter_workspace\study\img/water666.jpg',img)
参数1：所写入图片的名称，必须有后缀
参数2：当前图片的数据，这里是解码之后的元素数据

import cv2img = cv2.imread('E:\Jupyter_workspace\study\img/water.png',1)
cv2.imwrite('E:\Jupyter_workspace\study\img/water666.jpg',img)

3、图片不同质量保存

对jpg图像操作
cv2.imwrite('E:\Jupyter_workspace\study\img/water666.jpg',img,[cv2.IMWRITE_JPEG_QUALITY,0])
参数1：所写入图片的名称，必须有后缀
参数2：当前图片的数据，这里是解码之后的元素数据
参数3：对写入照片的质量进行选取，范围为0-100，0表示压缩包最高，即体积最小，效果最差，以牺牲数据模糊为代价减小体积（有损压缩）

import cv2img = cv2.imread('E:\Jupyter_workspace\study\img/water.png',1)cv2.imwrite('E:\Jupyter_workspace\study\img/water_0.jpg',img,[cv2.IMWRITE_JPEG_QUALITY,0])
cv2.imwrite('E:\Jupyter_workspace\study\img/water_50.jpg',img,[cv2.IMWRITE_JPEG_QUALITY,50])
cv2.imwrite('E:\Jupyter_workspace\study\img/water_90.jpg',img,[cv2.IMWRITE_JPEG_QUALITY,90])

对png图像操作
cv2.imwrite('E:\Jupyter_workspace\study\img/water_90.jpg',img,[cv2.IMWRITE_PNG_COMPRESSION,0])
参数1：所写入图片的名称，必须有后缀
参数2：当前图片的数据，这里是解码之后的元素数据
参数3：对写入照片的质量进行选取，范围为0-9，0表示压缩包最低，即体积最大，效果最好

import cv2img = cv2.imread('E:\Jupyter_workspace\study\img/water.png',1)cv2.imwrite('E:\Jupyter_workspace\study\img/water_1.png',img,[cv2.IMWRITE_PNG_COMPRESSION,1])
cv2.imwrite('E:\Jupyter_workspace\study\img/water_2.png',img,[cv2.IMWRITE_PNG_COMPRESSION,2])
cv2.imwrite('E:\Jupyter_workspace\study\img/water_8.png',img,[cv2.IMWRITE_PNG_COMPRESSION,8])

png和jpg的区别：

1、jpg是有损压缩，png是无损压缩
2、png有透明度属性，在修改RGB值的时候也可以修改图片的透明度

4、像素操作

1，像素：图片放大后的一个一个的小方块
2，RGB：每个彩色图像都是有RGB三种颜色所构成的
3，颜色深度：8bit的颜色深度可以表示的颜色范围为0-255，可以表示256（2^{8）种颜色；对应彩色图像，RGB各有256种，其总共可以表示256}3种颜色
4，图片的宽高：（w，h）=（640，480）表示在x轴方向（宽w）有640个像素点，在y轴方向（高h）有480个像素点
例如：720* 547的图像未压缩的大小====720 * 547 * 3 * 8（bit）===720 * 547 * 3（Byte）===1.14 MB 3个颜色通道，颜色深度为8位
5，对应png图像，包含RGN和alpha（α透明度）
6，在opencv中为BGR颜色通道

5、像素读取与写入操作

import cv2
img = cv2.imread('E:\Jupyter_workspace\study\img/water.png',1)(b,g,r) = img[100,100]#img[h,w]
print(b,g,r)for i in range(1,100):img[10+i,100] = (255,0,0)#[h在变化,w不变]即竖直的蓝线
cv2.imshow('image',img)
cv2.waitKey(0)
#cv2.waitKey(100)#100ms

在图像的宽为100处，从(10,100)到(110,100)，加一条长度为100的蓝线，这里位置为(h,w)：

二、tensorflow基础

1，tensorflow常量变量

import tensorflow as tfdata1 = tf.constant(2.5)
data1_1 = tf.constant(2,dtype=tf.int32)
data2 = tf.Variable(10,name = 'var')
print(data1)
print(data1_1)
print(data2)sess = tf.Session()
print(sess.run(data1))
print(sess.run(data1_1))
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(data2))
sess.close()

结果如下：




结果解释：

Tensor(“Const:0”, shape=(), dtype=float32) Tensor表示为张量，相当于一个数据
Const表示常数 shape表示维度 float32表示当前的数据类型

<tf.Variable ‘var:0’ shape=() dtype=int32_ref> Variable表示变量
int32_ref表示为32位int类型

tensorflow中所有的操作必须使用Session规划进行

2，tensorflow运算原理

tensorflow的实质：张量tensor+计算图graphs，即数据+计算图
张量：就是数据可以是常量也可以是变量，可以是一维也可以是二维
op：operation可以是四则操作也可以是其他常规运算操作
graphs：数据和操作的过程
在tensorflow中，所有的操作都必须在session规划中执行
session可以理解为一个运算交换的环境，故有了session.run()
tensorflow中所有的变量必须初始化之后才能完成，故需要一个init操作，而init的实则也是个计算图，故需要使用session.run(init)，只要运行这个计算图之后，所有的session才能起作用，用完session之后需要close一下，session.close()；当然也可以直接使用with操作。

import tensorflow as tf
data2 = tf.Variable(10,name = 'var')init = tf.global_variables_initializer()
sess = tf.Session()
with sess:sess.run(init)print(sess.run(data2))

运行结果：

3，常量与变量的四则运算

常量的四则运算

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))

变量的四则运算

import tensorflow as tf
data1 = tf.constant(6)
data2 = tf.Variable(2)init = tf.global_variables_initializer()#变量必须执行初始化操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:sess.run(init)print(sess.run(dataAdd))print(sess.run(dataMul))print(sess.run(dataSub))print(sess.run(dataDiv))

import tensorflow as tf
data1 = tf.constant(6)
data2 = tf.Variable(2)init = tf.global_variables_initializer()dataAdd = tf.add(data1,data2)
dataCope = tf.assign(data2,dataAdd)#讲dataAdd的内容赋值给data2with tf.Session() as sess:sess.run(init)print(sess.run(dataAdd))print(sess.run(dataCope))#data1+data2=6+2-->dataAdd-->data2此时为8print(dataCope.eval())#data2+data1=8+6-->data2此时为14print(tf.get_default_session().run(dataCope))#data2+data1=14+6-->data2此时为20

4，矩阵基础

sess.run(dataAdd,feed_dict={data1:6,data2:2})
参数1：运算的张量
参数2：追加的数据，是一个data数据，{feed_dict={参数1:6,参数2:2}}

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}))

矩阵最外面为一个中括号[]
矩阵类比为数组，一个M行N列的数组；[里面为列]，[] 整体为行
例如：一行两列的矩阵 [[6,6]]

import tensorflow as tf
data1 = tf.constant([[6,6]])#一行两列
data2 = tf.constant([[2],#两行一列[2]])
data3 = tf.constant([[3,3]])#一行两列
data4 = tf.constant([[1,2],#三行两列[3,4],[5,6]])
#print(data4.shape)#打印矩阵的维度with tf.Session() as sess:print(sess.run(data4))#整个data4print(sess.run(data4[0]))#第一行print(sess.run(data4[:,0]))#第一列print(sess.run(data4[0,:]))#第一行print(sess.run(data4[0,1]))#第一行第一列

5，矩阵运算

矩阵相加：对应位置相加
矩阵相乘：前行乘后列

import tensorflow as tf
data1 = tf.constant([[6,6]])#一行两列
data2 = tf.constant([[2],#两行一列[2]])
data3 = tf.constant([[3,3]])#一行两列matNul = tf.matmul(data1,data2)#矩阵相乘
multiply = tf.multiply(data1,data2)#multiply相乘！！！对应位置相乘
matAdd = tf.add(data1,data3)#矩阵相加with tf.Session() as sess:print(sess.run(matNul))print(sess.run(multiply))print(sess.run(matAdd))print(sess.run([matNul,multiply,matAdd]))#可以一次打印多个结果

运行结果如下：

特殊矩阵的初始化

import tensorflow as tf
mat0 = tf.constant([[1,2,3],#constant定义的为固定的矩阵，两行三列且值确定，且最外层必须含有一个中括号[][3,4,5]])mat1 = tf.zeros([2,3])#两行三列全零矩阵
mat2 = tf.ones([3,4])#三行四列全一矩阵
mat3 = tf.fill([4,5],15)#四行五列全15矩阵mat4 = tf.constant([[3],#三行一列矩阵[4],[5]])
mat5 = tf.zeros_like(mat4)#定义一个与mat4维度相同的全是0的矩阵mat6 = tf.linspace(0.0,2.0,11)#将[0.0-2.0]分成相等的10份，也就是11个数划分10份，每个间隔为0.2mat7 = tf.random_uniform([2,3],1,10)#随机创建一个两行三列数组，值用[1,10)进行填充]with tf.Session() as sess:print(sess.run(mat7))

运行结果如下：

三、numpy模块的使用

import numpy as npdata1 = np.array([1,2,3,4,5])
data2 = np.array([[1,2],[3,4]])print(data1)#结果为：[1 2 3 4 5]
print(data2)
#结果为：
'''
[[1 2][3 4]]
'''
print(data1.shape,data2.shape)#结果为：(5,) (2, 2)
print(np.zeros([2,3]))
'''
结果为：
[[0. 0. 0.][0. 0. 0.]]
'''
print(np.ones([2,2]))
'''
结果为：
[[1. 1.][1. 1.]]
'''data2[1,0] = 5
print(data2)
'''
结果为：
[[1 2][5 4]]
'''
print(data2[1,1])#结果为：4data3 = np.ones([2,3])
print(data3)
'''
结果为：
[[1. 1. 1.][1. 1. 1.]]
'''#这里并没有改变data3的值，每次使用的还是两行三列全1的值进行操作
print(data3 * 2)#矩阵乘以2 表示矩阵内所有的元素都乘以2
print(data3 + 2)
print(data3 - 2)
print(data3 / 2)
'''
结果为：
[[2. 2. 2.][2. 2. 2.]]
[[3. 3. 3.][3. 3. 3.]]
[[-1. -1. -1.][-1. -1. -1.]]
[[0.5 0.5 0.5][0.5 0.5 0.5]]
'''data4 = np.array([[1,2,3],[4,5,6]])
print(data4)
'''
结果为：
[[1 2 3][4 5 6]]
'''print(data3+data4)#对应位置元素相加
'''
结果为：
[[2. 3. 4.][5. 6. 7.]]
'''print(data3*data4)#对应位置元素相乘
'''
结果为：
[[1. 2. 3.][4. 5. 6.]]
'''

四、matplotlib模块的使用

绘制折线图
plt.plot(x,y,'b',lw=1)
参数1：x轴坐标
参数2：y轴坐标
参数3：绘图的线条颜色
参数4：绘图的线条宽度

import numpy as np
from matplotlib import pyplot as pltx = np.array([1,2,3,4,5,6,7,8])
y = np.array([7,8,9,5,4,1,8,5])
plt.figure()
plt.plot(x,y,'b',lw=1)
plt.show()

运行结果如下：

绘制柱状图
plt.bar(x,y,0.5,alpha=1,color=‘b’)
参数1：x坐标
参数2：y坐标
参数3：0-1，表示每个柱状间隔，1为紧紧相邻
参数4：透明度
参数5：绘制线条颜色

import numpy as np
from matplotlib import pyplot as pltx = np.array([1,2,3,4,5,6,7,8])
y = np.array([13,25,17,36,21,16,10,15])
plt.figure()
plt.bar(x,y,0.5,alpha=1,color='b')
plt.show()

运行结果如下：

五、神经网络逼近股票收盘均价Demo

给出开盘价和结束价，之间的差用柱状图表示，若赚钱用绿色显示，赔钱用红色显示

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as pltdate = 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])
plt.figure()for i in range(0,15):dateOne = np.zeros([2])dateOne[0] = idateOne[1] = ipriceOne = 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()

运行结果如下：

# 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])
y = tf.placeholder(tf.float32,[None,1])
# B
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) # 激励函数
# C
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 = 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):sess.run(train_step,feed_dict={x:dateNormal,y:priceNormal})# w1w2 b1b2  A + wb -->layer2pred = 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.figure()
plt.show()

运行结果如下：