Tensorflow

 1 import warnings
 2 warnings.filterwarnings(‘ignore‘)
 3 import numpy as np
 4 import tensorflow as tf
 5 
 6 #常量的计算
 7 nd1=np.random.randint(0,10,size=5)
 8 s=tf.reduce_sum(nd1,name=‘sum‘)
 9 sess=tf.Session()
10 sess.run(s)
11 
12 # 求平均值
13 m=tf.reduce_mean(nd1.astype(np.float16))
14 # 使用with会自动关闭
15 with tf.Session() as sess:
16     print(sess.run(m))
17 
18 # 返回值是操作
19 c=tf.constant(‘Hello Tensorflow‘)
20 c2=tf.constant(1024)
21 c3=tf.constant(512)
22 a=tf.add(c2,c3)
23 b=c3-c2
24 d=tf.abs(b)
25 m=tf.multiply(10,8)
26 # 除法直接返回结果
27 n=tf.divide(1024,100)
28 h=tf.divide(b,d)
29 # sess.run(c) c必须是tensor操作
30 with tf.Session() as sess:
31     print(sess.run(c))
32     print(sess.run(c2))
33     print(sess.run(a))
34     print(sess.run(b))
35     print(sess.run(d))
36     print(sess.run(m))
37     print(n)
38     print(sess.run(h))
39 
40 # 矩阵操作
41 a=np.random.randint(0,10,size=(2,3))
42 b=np.random.randint(0,10,size=(3,4))
43 # 矩阵的点乘
44 c=tf.matmul(a,b)
45 with tf.Session() as sess:
46     print(sess.run(c))

 1 # 变量的计算
 2 # 求解方程时，系数和截距都是变量
 3 # 声明变量
 4 v=tf.Variable(initial_value=0,dtype=np.float16)
 5 v2=tf.Variable(initial_value=3.14,dtype=tf.float16)
 6 with tf.Session() as sess:
 7     # 变量必须进行初始化
 8     sess.run(tf.global_variables_initializer())
 9     result=sess.run([v,v2])
10     print(result)
11     # 将变量更新一下，重新赋值，必须运行之后才会修改
12     assign=tf.assign(v,2.718)
13     sess.run(assign)
14     #相当于求v2-2
15     sess.run(tf.assign_sub(v2,2))
16     print(sess.run([v,v2]))
17 
18 # 占位符
19 # 占位符的作用
20 ‘’‘一方面用TensorFlow写网络的时候，训练前我们往往不知道x和y的具体大小，但在写前项传播时又不得不先在计算图中定义这么一个节点，因为其他变量会依赖它。此时，我们就可以先在网络中给这些变量留（占）一个位置，等到训练的时候根据batch的尺寸就能确定x,y的大小了。
21 另一方面我们迄今为止所做的计算一直很乏味：没有机会获得输入，所以它们总是输出相同的东西。一个实用的应用可能涉及构建这样一个计算图：它接受输入，以某种（一致）方式处理它，并返回一个输出。最直接的方法是使用占位符。占位符是一种用于接受外部输入的节点。
22 ‘’‘
23
24 A=tf.placeholder(dtype=tf.float32,shape=(None,4),name=‘A‘)
25 B=tf.placeholder(dtype=np.float32,shape=(4,None),name=‘B‘)
26 C=tf.matmul(A,B)
27 with tf.Session() as sess:
28     # 占位时使用的None，赋值时可以随意构建形状，只要匹配就可以
29     b=sess.run(tf.random_normal(shape=[4,5]))
30     ret=sess.run(C,feed_dict={A:np.random.randint(0,5,size=(3,4)),B:b})
31     print(ret)

 1 import warnings
 2 warnings.filterwarnings(‘ignore‘)
 3 import numpy as np
 4 import matplotlib.pyplot as plt
 5 %matplotlib inline
 6 from sklearn.linear_model import LinearRegression
 7 import tensorflow as tf
 8 
 9 # 构造数据
10 X=np.linspace(2,12,50).reshape(-1,1)
11 w=np.random.randint(1,6,size=1)[0]
12 b=np.random.randint(-5,5,size=1)[0]
13 y=X*w+b+np.random.randn(50,1)*0.7
14 plt.scatter(X,y)
15 
16 # 用线性回归模型来计算
17 linear=LinearRegression()
18 linear.fit(X,y)
19 print(linear.coef_,linear.intercept_)
20 
21 #用tensorflow来计算
22 # 1.定义占位符，变量
23 # 线性回归理论基础是最小二乘法
24 X_train=tf.placeholder(dtype=tf.float32,shape=[50,1],name=‘data‘)
25 y_train=tf.placeholder(dtype=tf.float32,shape=[50,1],name=‘target‘)
26 w_=tf.Variable(initial_value=tf.random_normal(shape=[1,1]),name=‘weight‘)
27 b_=tf.Variable(initial_value=tf.random_normal(shape=[1]),name=‘bias‘)
28 
29 # 2.构造方程（线性方程，矩阵乘法）
30 # 构建方程 f(x)=Xw+b
31 y_pred=tf.multiply(X_train,w_)+b_
32 # shape=(50,1)
33 
34 # 3.最小二乘法（平均最小二乘法）
35 # 二乘法(y_pred-y_train)**2 返回的结果是一个列表，列表没有办法比较大小
36 # 平均最小二乘法，数值，mean
37 cost=tf.reduce_mean(tf.pow(y_pred-y_train,2))
38 
39 # 4.梯度下降优化
40 # 优化，cost越小越好
41 # 梯度下降优化
42 opt=tf.train.GradientDescentOptimizer(0.01).minimize(cost)
43 
44 # 5.会话进行训练（for循环）
45 with tf.Session() as sess:
46     # w,b,变量初始化
47     sess.run(tf.global_variables_initializer())
48     for i in range(1000):
49         opt_,cost_=sess.run([opt,cost],feed_dict={y_train:y,X_train:X})
50         print(‘执行次数是：%d,损失函数值是：%0.4f‘%(i+1,cost_))
51         # for 循环结束，训练结束
52         # 获取斜率和截距
53     W,B=sess.run([w_,b_])
54     print(‘经过1000次的训练，tensorflow返回的线性方程的斜率是：%0.3f,截距是：%0.3f‘%(W,B))
55 
56 # 6.可视化
57 plt.scatter(X,y)
58 x=np.linspace(2,12,100)
59 plt.plot(x,W[0]*x+B,color=‘green‘)