Tensorflow 基础入门和实现一个神经网络逼近股票价格

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_38863413/article/details/88042888

这是一篇tensorflow 的常用计算方法的入门教程，阅读本文并跟着写代码即可掌握tensorflow基础知识，再了解了神经网络的相关概念后也可以理解最后实现的用神经网络逼近股票价格的代码，从而入门tensorflow 框架的使用。（安装请见官网教程，这里不再赘述，下面的例子黑色为代码块，白色为输出，使用 jupyter notebook 编写运行，python 版本 3.6）

01 tensorflow 常量变量

import tensorflow as tf
data1=tf.constant(2.5)
data2=tf.Variable(2.0,name='data2')
print(data1)
print(data2)
# tensorflow 中的常量的变量的值并不能直接输出，输出的是变量的常量的描述
# 下面的Tensort 表示张量，可以理解为数组

Tensor("Const_2:0", shape=(), dtype=float32)
<tf.Variable 'data2_1:0' shape=() dtype=float32_ref>

import tensorflow as tf
data1=tf.constant(2.5)
data2=tf.Variable(2.0,name='data2')
print(data1)
print(data2)

#使用session会话才可以进行值的输出

session=tf.Session()
print(session.run(data1))
print(session.run(data2))

Tensor("Const_4:0", shape=(), dtype=float32)

2.5

---------------------------------------------------------------------------

FailedPreconditionError                   Traceback (most recent call last)

D:\Anaconda\envs\tensorflow\lib\site-packages\tensorflow\python\client\session.py in _do_call(self, fn, *args)
   1333     try:
-> 1334       return fn(*args)
   1335     except errors.OpError as e:
FailedPreconditionError: Attempting to use uninitialized value data2_3
     [[{{node _retval_data2_3_0_0}}]]

#从上面的输出可以看出，常量的输出正确，但是变量的输出发生错误
# 从日志中可以看出是变量没有初始化的错误

import tensorflow as tf
data1=tf.constant(2.5)
data2=tf.Variable(2.0,name='data2')
session=tf.Session()
#变量的初始化：
init=tf.global_variables_initializer()
session.run(init)

#输出检测：

print(session.run(data1))
print(session.run(data2))

session.close()
# tensorflow 的本质：  tf = tendor + 计算图
# tensor 是数据，可以是一维也可以是多维数据
# op 擦作，可以是赋值操作，也可以是四则运算操作
# 计算图 ： 数据操作的过程
# 所有的计算都要放在session中才可以运行，session 是运行的交互环境

2.5
2.0

# 在执行完session后还要进行关闭操作，但是关闭操作经常会被遗忘，所以可以使用with语句
import tensorflow as tf
data1=tf.constant(2.5)
data2=tf.Variable(2.0,name='data2')
init =tf.global_variables_initializer()

session=tf.Session()
with session:
    session.run(init)
    print(session.run(data1))
    print(session.run(data2))

2.5
2.0

tensorflow 四则运算

import tensorflow as tf
data1=tf.constant(2)
data2=tf.constant(6)
#无变量运算
add=tf.add(data1,data2)
sub=tf.subtract(data1,data2)
mul=tf.multiply(data1,data2)
div=tf.divide(data1,data2)
with tf.Session() as s:
    print(s.run(add))
    print(s.run(sub))
    print(s.run(mul))
    print(s.run(div))

8
-4
12
0.3333333333333333

# 有变量的四则运算
import tensorflow as tf
data1=tf.constant(2)
data2=tf.Variable(6)
add=tf.add(data1,data2)
sub=tf.subtract(data1,data2)
mul=tf.multiply(data1,data2)
div=tf.divide(data1,data2)

# 赋值运算：
copy = tf.assign(data2,add)
# 初始化变量：
init=tf.global_variables_initializer()

with tf.Session() as s:
    s.run(init)
    print(s.run(data1))
    print(s.run(data2))
    print(s.run(add))
    print(s.run(sub))
    print(s.run(mul))
    print(s.run(div))
    # 调用赋值函数之后data2 的值变化了
    print(s.run(copy))
    print(s.run(data2))

2
6
8
-4
12
0.3333333333333333
8
8

tensorflow placeholder用法

import tensorflow as tf
data1=tf.placeholder(tf.float32)
data2=tf.placeholder(tf.float32)

add=tf.add(data1,data2)
with tf.Session() as s:
    print(s.run(add,feed_dict={data1:6,data2:2}))

8.0

tensorflow 矩阵运算

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)

matmul=tf.matmul(data1,data2)
matadd=tf.add(data1,data3)
matmul2=tf.multiply(data1,data2)
with tf.Session() as s:
    #打印整个矩阵
    print(s.run(data4))
    # 打印某一行
    print(s.run(data4[0]))
    # 打印某一列  第0 列：
    print(s.run(data4[:,0]))
    # 打印某一行某一类的数据
    print(s.run(data4[0,0]))
    # 打印矩阵运算结果：
    print("------------")
    print(s.run(matmul))
    print(s.run(matadd))
    print(s.run(matmul2))

Tensor("Const_72:0", shape=(3, 2), dtype=int32)
[[1 2]
 [3 4]
 [5 6]]
[1 2]
[1 3 5]
1
------------
[[24]]
[[9 9]]
[[12 12]
 [12 12]]

特殊矩阵的初始化

import tensorflow as tf
# 使用constant 构建
mat0=tf.constant([[0,0,0],[0,0,0]])
# 使用zeros，ones 函数构建特殊值矩阵
mat1=tf.zeros(2,3)
mat2=tf.ones(3,2)
# 使用fill 函数填充矩阵
mat3=tf.fill([2,3],5)
with tf.Session() as s:
    print(s.run(mat1))
    print("-------------")
    print(s.run(mat2))
    print("-------------")
    print(s.run(mat3))

[0 0]
-------------
[1. 1. 1.]
-------------
[[5 5 5]
 [5 5 5]]

import tensorflow as tf
mat1=tf.constant([[2],[3],[4]])
# 构造一个像mat1一样的全零矩阵：
mat2=tf.zeros_like(mat1)

mat3=tf.linspace(0.0,2.0,6)
mat4=tf.random_uniform([2,4],-1,2)
with tf.Session() as s:
    print(s.run(mat1))
    print("-------------")
    print(s.run(mat2))
    print("*************")
    print(s.run(mat3))
    print("-------------")
    print(s.run(mat4))

[[2]
 [3]
 [4]]
-------------
[[0]
 [0]
 [0]]
*************
[0.  0.4 0.8 1.2 1.6 2. ]
-------------
[[-0.9634737  -0.98235786  0.5139382   0.28657448]
 [ 0.85811424  0.69779825  1.7099376   1.9010782 ]]

import numpy as np
data1=np.array([1,2,3,4,5])
print(data1)
print(data1.shape)
print("----------")
data2=np.array([[1,2],[3,4]])
print(data2)
print(data2.shape)

print("***********")
print(np.zeros([2,3]))
print(np.ones([2,2]))

print("修改")
data2[1,0]=5
print(data2)

#基本运算
print("基本运算")
data3=np.ones([2,3])
print(data3*2)
print(data3/3)

print("矩阵运算：")
data4=np.array([[1,2,3],[4,5,6]])
print(data3+data4)

[1 2 3 4 5]
(5,)
----------
[[1 2]
 [3 4]]
(2, 2)
***********
[[0. 0. 0.]
 [0. 0. 0.]]
[[1. 1.]
 [1. 1.]]
修改
[[1 2]
 [5 4]]
基本运算
[[2. 2. 2.]
 [2. 2. 2.]]
[[0.33333333 0.33333333 0.33333333]
 [0.33333333 0.33333333 0.33333333]]
矩阵运算：
[[2. 3. 4.]
 [5. 6. 7.]]

matloplib 绘制图形

import matplotlib.pyplot as plt
import numpy as np

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',lw=1)
# lw 代表线条的宽度，第三个参数代表颜色，r，表示红色

#柱状图
x=np.array([1,2,3,4,5,6,7,8])
y=np.array([3,5,7,6,2,6,10,15])
# 第三个参数代表的是宽度平均占比，alpha 代表透明度，color 是颜色。
plt.bar(x,y,0.5,alpha=1,color='g')

使用人工神经网络逼近股票的价格（纯属个人娱乐，股市有风险，入坑需谨慎）

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

#建立日期数组，用numpy linspace函数生成，这里表示date 数组数值从1 到 15 之间，平分成15份，也就是间隔为1
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.68
])

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):
    # 初始化横坐标，因为是柱状图，所以 日期方向的增量是 0
    dataone=np.zeros([2])
    dataone[0]=i
    dataone[1]=i
    # 定义y 坐标，也就是价格方向，线条长度就是y 的价格的变化
    priceone=np.zeros([2])
    priceone[1]=endprice[i]
    priceone[0]=beginprice[i]
    # 描绘一下图，如果涨了就是红色柱状，跌了就是绿色柱状（不用我说了吧）
    if endprice[i]>beginprice[i]:
        plt.plot(dataone,priceone,'r',lw=8)
    else:
        plt.plot(dataone,priceone,'g',lw=8)


# 使用神经网络对股票价格进行逼近。

# A(15 x 1) * w1(1 x 10) =b1(1 x 10) =B (15 x 10)
# B(15 x 10) * w2(10 x 1) + b2(15 x 1)
# 输入层 A：(15 x 1)
# 隐含层 B: (15 x 10)
# 输出层 C: (15 x 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
#输入变量进行定义,使用placeholder 进行数据装载
x=tf.placeholder(tf.float32,[None,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]))

f1=tf.matmul(x,w1)+b1
layer1=tf.nn.relu(f1)
# 输出层
w2=tf.Variable(tf.random_uniform([10,1],0,1))
b2=tf.Variable(tf.zeros([15,1]))
f2=tf.matmul(layer1,w2)+b2
layer2=tf.nn.relu(f2)
# 损失函数：
loss=tf.reduce_mean(tf.square(y-layer2))
# 使用梯度下降法进行参数调整
# 0.1 是每次下降多少。
train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)
with tf.Session() as s:
    s.run(tf.global_variables_initializer())
    for i in range(0,10000):
        s.run(train_step,feed_dict={x:datanormal,y:pricenormal})
    pred=s.run(layer2,feed_dict={x:datanormal})

    predprice=np.zeros([15,1])
    for i in range(0,15):
        predprice[i,0]=(pred*3000)[i,0]
    plt.plot(date,predprice,'r',lw=1)

plt.show()