tensorflow

 1 import tensorflow as tf
 2 
 3 #创建一个常量
 4 m1 = tf.constant([[3,3]])#一行两列
 5 m2 = tf.constant([[2],[3]])#两行一列
 6 
 7 #矩阵乘法
 8 product = tf.matmul(m1,m2)
 9 print(product)
10 
11 #定义一个会话，启动默认图
12 sess = tf.Session()
13 result = sess.run(product)# 调用run方法执行图，这个触发了三个op(操作)，两个常量的建立，矩阵的乘法
14 print(result)
15 sess.close()
16 
17 #无需关闭会话 # with as的这种结构会自动关闭会话
18 with tf.Session() as sess:
19     result = sess.run(product)
20     print(result)

 1 import tensorflow as tf
 2 
 3 x=tf.Variable([1,2])    # 定义一个变量，这里是张量的加减法，所以一维数组即可
 4 a=tf.constant([3,3])    # 定义一个常量
 5 
 6 sub=tf.subtract(x,a)    # 增加一个减法op
 7 add=tf.add(x,sub)       # 增加一个加法op
 8 
 9 init=tf.global_variables_initializer()   # 在tensorflow中使用变量要初始化，此条语句也可以初始化多个变量，这句代码提示没有(),多加练习
10 #没有第13行会FailedPreconditionError: Attempting to use uninitialized value Variable_1 试图使用未初始化的值Variable_1
11 with tf.Session() as sess:
12     sess.run(init)                       # 变量初始化，也要放在会话中，才能执行
13     print(sess.run(sub))
14     print(sess.run(add))

 1 a=tf.Variable(0,name=‘counter‘)        # 创建一个变量初始化为0，并命名为counter。（此段代码中命名无作用）
 2 new_value = tf.add(a,1)                # 创建一个加法op，作用是使state加1
 3 update=tf.assign(a,new_value)          # 此句话是赋值op，在tensorflow中，赋值也需要对应的op
 4 init=tf.global_variables_initializer() # 变量初始化
 5 with tf.Session() as sess:
 6     sess.run(init)
 7     print(sess.run(a))
 8     for i in range(5):                
 9         sess.run(update)
10         print(sess.run(a))

 1 import tensorflow as tf
 2 
 3 input1 = tf.constant(3.0)
 4 input2 = tf.constant(2.0)
 5 input3 = tf.constant(5.0)
 6 
 7 add = tf.add(input2,input3)
 8 mul = tf.multiply(input1,add)
 9 
10 with tf.Session() as sess:
11     result = sess.run([mul,add])       # 执行了两个op，要注意格式
12     print(result)

1 import tensorflow as tf
2 
3 input1 = tf.placeholder(tf.float32)      # 使用placeholder()占位，需要提供类型
4 input2 = tf.placeholder(tf.float32)
5 output = tf.multiply(input1,input2)
6 
7 with tf.Session() as sess:
8     print(sess.run(output,feed_dict={input1:8.0,input2:2.0}))  # 以字典形式输入feed_dict

import tensorflow as tf
import numpy as np
#使用numpy生成100个随机点
x_data = np.random.rand(100)
y_data=x_data * 0.1 +0.2

#构造一个线性模型
b = tf.Variable(1.5)#随机取一个数，最后结果接近0.2
k = tf.Variable(3.2)#随机取一个数，最后结果接近0.1

#二次代价函数（损失函数）
loss  =  tf.reduce_mean(tf.square(y_data-y))
#定义一个梯度下降法来训练的优化器
optimizer = tf.train.GrandientDescentOptimizer(0.2)
#最小化代价函数
train = optimizer.minimize(loss)

init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    for step in range(300):
        sess.run(train)
    if step%20==0
    print(step,sess.run([k,b]

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

#使用numpy在[-0.5,0.5]生成200个数（200行1列）---样本
x_data = np.linspace(-0.5,0.5,200)[:,np.newaxis]#增加一个维度
noise = np.random.normal(0,0.02,x_data.shape)
y_data = np.square(x_data) + noise

#定义两个占位符
x = tf.placeholder(tf.float32,[None,1])
y = tf.placeholder(tf.float32,[None,1])

#定义神经网络的中间层
weights_L1  = tf.Variable(tf.random_normal([1,10]))#一行十列
biases_L1 = tf.Variable(tf.zeros([1,10]))#定义只有一个神经元在输入层
Wx_plus_b_L1 =  tf.matmul(x,weights_L1)  +  biases_L1
#矩阵相乘（输入和中间层权重）
L1 = tf.nn.tanh(Wx_plus_b_L1)#tanh为激活函数

#定义神经网络的输出层
weights_L2  = tf.Variable(tf.random_normal([10,1]))
biases_L2 = tf.Variable(tf.zeros([1,1]))#定义只有一个神经元在输入层
Wx_plus_b_L2 =  tf.matmul(L1,weights_L2)  +  biases_L2
#矩阵相乘（输入和中间层权重）
prediction = tf.nn.tanh(Wx_plus_b_L2)#tanh为激活函数


#定义损失函数
loss = tf.reduce_mean(tf.square(y - prediction))
#计算张量tensor沿着某一维度的平均值，用于降维

#使用梯度下降法（0.35为学习率）
train_step = tf.train.GradientDescentOptimizer(0.35).minimize(loss)#loss的值和bias和weight有关，不停地回调他们
#其中 minimize() 实际上包含了两个步骤，即 compute_gradients 和 apply_gradients，
#前者用于计算梯度，后者用于使用计算得到的梯度来更新对应的variable。下面对这两个函数做具体介绍。
print(sess.run(train_step))
with tf.Session() as sess:
    #初始化变量
    sess.run(tf.global_variables_initializer())
    for _ in range(1000):
        sess.run(train_step,feed_dict={x:x_data,y:y_data})
        #获得预测值
        prediction_value = sess.run(prediction,feed_dict={x:x_data})
        #画图
        plt.figure()
        plt.scatter(x_data,y_data)#散点出样本分布
        plt.plot(x_data,prediction_value,‘r-‘,lw=5)#红色实线，线宽为5
        plt.show()         

 1 import tensorflow as tf
 2 import tensorflow.example.tutorials.mnist import input_data
 3 
 4 #载入数据集
 5 print("--"*36)
 6 mnist = input_data.read_data_set("MNIST_data",one_hot=True)
 7 #one_hot是一位是1
 8 
 9 #每个批次的大小（以矩阵的形式放进去训练）
10 batch_size = 50
11 #计算有多少个批次
12 n_batch = mnist.train.num_examples//batch_size #整除
13 
14 #定义两个占位符
15 x = tf.placeholder(tf.float32,[None,28*28])#None的赋值与批次有关
16 y = tf.placeholder(tf.float32,[None,10])#标签：10个数字
17 
18 #创建有关简单的神经网络（隐藏层为10个神经元）
19 w = tf.Variable(tf.zero([784,10]))
20 b = tf.Variable(tf.zero([10]))
21 prediction = tf.nn.softmax(tf.matmul(x,w)+b)#softmax：输出值转换成概率
22 
23 #损失函数
24 loss = tf.reduce_mean(tf.square(y-prediction))
25 
26 #梯度下降法
27 train_step = tf.train.GradientDesentOptimizer(0.4)minimize(loss)
28 
29 #比较equal()函数内参数是否一致，一致返回“true”
30 #argmax函数返回一维张量中最大值所在位置
31 correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))
32 #求准确率cast()将布尔型转换成浮点型（true转换成1.0，false转换成0）
33 
34 accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
35 
36 with tf.Session() as sess:
37     sess.run(tf.global_variables_initializer())
38     for iter in range(25):
39         for batch in range(n_batch):
40             #next_batch()第二次执行获取第二个批次的数据
41             batch_xs,batch_ys = mnist.train.next_batch(batch_size)
42             sess.run(train_step,feed={x:batch_x,y:batch_y})
43         ac=sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
44         print("--"*36)
45         print(">>>Iter:" +str(iter)+ ",>>>Testing Accuracy"" +str(ac))

#L1，L2demo
w = tf.constant([[1.0,2.],[-2.,4.]])
with tf.Session() as sess:
    print(sess.run(tf.contrib.layers.l1_regularizer(0.5)(w)))
    print(sess.run(tf.contrib.layers.l2_regularizer(0.5)(w)))
    print(sess.run(tf.contrib.layers.l1_l2_regularizer(scale_l1=0.5,scale_l2=0.5)(w)))
out:
4.5      #1+2+2+4=9  9*0.5=4.5
6.25    #1+4+4+16=25 25/2=12.5  12.5*0.5=6.25   
10.75  #9*0.5+12.5*0.5=10.75

 1     import tensorflow as tf
 2     from tensorflow.examples.tutorials.mnist import input_data
 3 
 4     #获取mnist训练集
 5     mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) 
 6 
 7     #交互式session
 8     sess = tf.InteractiveSession()
 9 
10     #已将32×32的图片展开成行向量，None代表该维度上数量不确定，程序中指的是取样的图像数量不确定
11     x=tf.placeholder(tf.float32, shape=[None,784])
12     #图片的标签
13     y_label=tf.placeholder(tf.float32, shape=[None,10])  
14     -------------------------------------------------------------------------
15     #第一层网络
16     #reshape()将按照设定的shape=[-1,28,28,1]对x:shape=[None,784]的结构进行重新构建
17     #参数-1代表该维度上数量不确定，由系统自动计算
18     x_image = tf.reshape(x, shape=[-1,28,28,1]) 
19     #32个卷积核，卷积核大小5×5
20     W_conv1 = weight_variable([5,5,1,32])
21     #32个前置，对应32个卷积核输出
22     b_conv1 = bias_varibale([32]) 
23 
24     #卷积操作 
25     layer_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) 
26     #池化操作
27     layer_pool1 = tf.nn.max_pool(layer_conv1) 
28     -------------------------------------------------------------------------
29     #第二层网络
30     #64个卷积核，卷积核大小5×5，32个channel
31     W_conv2 = weight_variable([5,5,32,64]) 
32     #64个前置，对应64个卷积核输出
33     b_conv2 = bias_varibale([64]) 
34 
35     #卷积操作 
36     layer_conv2 = tf.nn.relu(conv2d(layer_pool1, W_conv2) + b_conv2) 
37     #池化操作
38     layer_pool2 = tf.nn.max_pool(layer_conv2) 
39     -------------------------------------------------------------------------
40     #full-connected网络
41     #图片尺寸变化28×28-->14×14-->7×7
42     #该层设定1024个神经元
43     layer_pool2_flat = tf.reshape(layer_pool2,[-1,7*7*64])
44 
45     W_fc1 = weight_variable([7*7*64,1024])
46     b_fc1 = bias_variable([1024])
47 
48     h_fc1 = tf.nn.relu(tf.matmul(layer_pool2_flat, W_fc1) + b_fc1)
49     -------------------------------------------------------------------------
50     #droput网络
51     keep_prob = tf.placeholder(tf.float32)
52     h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
53     -------------------------------------------------------------------------
54     #输出层
55     W_fc2 = weight_variable([1024,10])
56     b_fc2 = bias_variable([10])
57 
58     y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2)+b_fc2)
59     -------------------------------------------------------------------------
60     #loss-function
61     cross_entropy = -tf.reduce_sum(y_lable*tf.log(y_conv))
62     #梯度下降
63     train = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy) 
64     #tf.argmax(x,1)表示从x的第二维度选取最大值
65     correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_lable,1)) 
66     accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
67     sess.run(tf.global_variables_initializer())
68     -------------------------------------------------------------------------
69     #训练train
70     #训练3000次
71     for i in range(3000) 
72       #每次选取50训练集
73       batch = mnist.train.next_batch(50) 
74 
75       if i%100 == 0:
76         train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_labe: batch[1], keep_prob: 1.0})
77         print ("step %d, training accuracy %g"%(i, train_accuracy))
78 
79       train.run(feed_dict={x: batch[0], y_label: batch[1], keep_prob: 0.5})
80       print ("test accuracy %g"%accuracy.eval(feed_dict={x: mnist.test.images, y_label: mnist.test.labels, keep_prob: 1.0}))