G换一种活法

深度学习框架-tensorflow基础入门

目录(?)[+]

本篇博文只是用来记录自己的学习过程，作为2018年积累的开始，从这篇博文开始，我要养成一周一篇博文的习惯。今年要实现50篇博文的目标。

目录
- tensorflow的基础使用
  - 创建图启动图
  - 变量
  - fetch and feed
  - tensorflow的简单使用
- tensorflow线性回归以及分类的简单实用softmax介绍
  - 非线性回归
  - MNIST数据集分类简单版
- 交叉熵过拟合dropout以及tensorflow中各种优化器的介绍
  - 交叉熵
  - dropout
  - optimizer优化器
  - 本章作业继续优化网络提高识别率
- tensorboard可视化
  - tensorboard网络结构
  - tensorboard网络运行
  - tensorboard可视化
- 卷积神经网络
  - 卷积神经网络应用于MNIST数据集分类
  - 作业卷积神经网络可视化
- 递归神经网络LSTM的讲解以及LSTM网络的使用
  - 递归神经网络RNN

tensorflow的基础使用

创建图，启动图

import tensorflow as tf
     
     
     
     
      
      
      
      1

#创建一个常量op
m1 = tf.constant([[3,3]])
#创建一个常量op
m2 = tf.constant([[2],[3]])
#创建一个矩阵乘法op，把m1和m2传入
product = tf.matmul(m1,m2)
print(product)
     
     
     
     
      
      
      
      1
      
      
      
      2
      
      
      
      3
      
      
      
      4
      
      
      
      5
      
      
      
      6
      
      
      
      7

结果是：
Tensor(“MatMul_1:0”, shape=(1, 1), dtype=int32)
说明这是一个张量

#定义一个会话，自动启动默认图
sess = tf.Session()
#调用sess的run方法来执行矩阵乘法op
#run(product)触发了图中3个op
result = sess.run(product)
print(result)
sess.close()
     
     
     
     
      
      
      
      1
      
      
      
      2
      
      
      
      3
      
      
      
      4
      
      
      
      5
      
      
      
      6
      
      
      
      7

结果是：
[[15]]

需要建立一个会话，才能得到两个常量的乘积

#上面这段启动session可以改写成如下形式，此时就不用手动的去调用sess.close去关闭session
with tf.Session() as sess:
    #调用sess的run方法来执行矩阵乘法op
    #run(product)触发了图中3个op
    result = sess.run(product)
    print(result)
     
     
     
     
      
      
      
      1
      
      
      
      2
      
      
      
      3
      
      
      
      4
      
      
      
      5
      
      
      
      6

变量

import tensorflow as tf
     
     
     
     
      
      
      
      1

#定义变量
x = tf.Variable([1,2])
a = tf.constant([3,3])
#定义减法和加法的op
sub = tf.subtract(x,a)
add = tf.add(x,sub)

#使用变量前要先初始化
init = tf.global_variables_initializer()

#定义会话
with tf.Session() as sess:
    #先运行初始化变量
    sess.run(init)

    print(sess.run(sub))
    print(sess.run(add))
     
     
     
     
      
      
      
      1
      
      
      
      2
      
      
      
      3
      
      
      
      4
      
      
      
      5
      
      
      
      6
      
      
      
      7
      
      
      
      8
      
      
      
      9
      
      
      
      10
      
      
      
      11
      
      
      
      12
      
      
      
      13
      
      
      
      14
      
      
      
      15
      
      
      
      16
      
      
      
      17

[-2 -1]
[-1 1]

#变量可以初始化，初始化的值为0，名字为counter
state = tf.Variable(0,name='counter')

new_value = tf.add(state,1)

#调用赋值操作，不能直接用等号赋值
update = tf.assign(state,new_value)

#因为state是变量，所以需要初始化
init = tf.global_variables_initializer()

#定义会话
with tf.Session() as sess:
    #先运行初始化变量
    sess.run(init)
    #查看初始化的值
    print(sess.run(state))

    for _ in range(5):
        sess.run(update)
        print(sess.run(state))
     
     
     
     
      
      
      
      1
      
      
      
      2
      
      
      
      3
      
      
      
      4
      
      
      
      5
      
      
      
      6
      
      
      
      7
      
      
      
      8
      
      
      
      9
      
      
      
      10
      
      
      
      11
      
      
      
      12
      
      
      
      13
      
      
      
      14
      
      
      
      15
      
      
      
      16
      
      
      
      17
      
      
      
      18
      
      
      
      19
      
      
      
      20
      
      
      
      21

运行结果：
0
1
2
3
4
5

fetch and feed

import tensorflow as tf
     
     
     
     
      
      
      
      1

#Fetch： 可以同时运行多个op
input1 = tf.constant(3.0)
input2 = tf.constant(2.0)
input3 = tf.constant(5.0)

add = tf.add(input2,input3)
mul = tf.multiply(input1,add)

with tf.Session() as sess:
    #fetch多个op时，只要用中括号将多个op括起来即可
    result = sess.run([add,mul])
    print(result)
     
     
     
     
      
      
      
      1
      
      
      
      2
      
      
      
      3
      
      
      
      4
      
      
      
      5
      
      
      
      6
      
      
      
      7
      
      
      
      8
      
      
      
      9
      
      
      
      10
      
      
      
      11
      
      
      
      12

[7.0, 21.0]

#Feed
#创建占位符 ：placeholder
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)

#可以在运行output时，再将input1和input2的值传入，传入时采用字典的形式
output = tf.multiply(input1,input2)
with tf.Session() as sess:
    #传入时采用字典的形式
    print(sess.run(output,feed_dict={input1:[8.],input2:[3.]}))
     
     
     
     
      
      
      
      1
      
      
      
      2
      
      
      
      3
      
      
      
      4
      
      
      
      5
      
      
      
      6
      
      
      
      7
      
      
      
      8
      
      
      
      9
      
      
      
      10

[ 24.]

tensorflow的简单使用

import tensorflow as tf
import numpy as np
     
     
     
     
      
      
      
      1
      
      
      
      2

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

#构建一个线性模型
b = tf.Variable(0.)
k = tf.Variable(0.)
y = x_data*k + b

#使用tensorflow训练出模型，即得到k和b的值
#定义二次代价函数
loss = tf.reduce_mean(tf.square(y_data - y))
#使用梯度下降函数来进行训练的优化器，下面学习率是0.2
optimizer = tf.train.GradientDescentOptimizer(0.2)
#最小化代价函数
train = optimizer.minimize(loss)


#初始化变量
init = tf.global_variables_initializer()
with tf.Session() as sess:
    #先运行初始化变量
    sess.run(init)

    for step in range(201):
        sess.run(train)
        if step%20 ==0 :
            print(step,sess.run([k,b]))
     
     
     
     
      
      
      
      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

0 [0.0517033, 0.099609137]
20 [0.1019343, 0.1989941]
40 [0.10121739, 0.19936697]
60 [0.10076618, 0.19960159]
80 [0.10048222, 0.19974925]
100 [0.1003035, 0.19984218]
120 [0.10019101, 0.19990067]
140 [0.10012019, 0.19993751]
160 [0.10007564, 0.19996066]
180 [0.10004761, 0.19997525]
200 [0.10002997, 0.19998442]

tensorflow线性回归以及分类的简单实用，softmax介绍

非线性回归

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
     
     
     
     
      
      
      
      1
      
      
      
      2
      
      
      
      3

#使用numpy生成200个随机点
#生成范围[-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


#定义两个placeholder
#下面[]里面表示行不确定，列只有一列
x = tf.placeholder(tf.float32,[None,1])
y = tf.placeholder(tf.float32,[None,1])

#定义神经网络中间层
#神经元定义为[1,10],是因为输入的神经元是1个，中间层的神经元定义了10个
Weight_L1 = tf.Variable(tf.random_normal([1,10]))
biases_L1 = tf.Variable(tf.zeros([1,10]))
Wx_plus_b_L1 = tf.matmul(x,Weight_L1) + biases_L1
L1 = tf.nn.tanh(Wx_plus_b_L1)

#定义神经网络输出层
Weight_L2 = tf.Variable(tf.random_normal([10,1]))
biases_L2 = tf.Variable(tf.zeros([1,1]))
Wx_plus_b_L2 = tf.matmul(L1,Weight_L2) + biases_L2
prediction = tf.nn.tanh(Wx_plus_b_L2)


#二次代价函数
loss = tf.reduce_mean(tf.square(y-prediction))


#使用梯度下降法训练
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)


with tf.Session() as sess:
    #变量初始化
    sess.run(tf.global_variables_initializer())
    for _ in range(2000):
        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)
    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

MNIST数据集分类简单版

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
     
     
     
     
      
      
      
      1
      
      
      
      2

#载入数据集
#one_hot是将数据改成0-1的格式
mnist = input_data.read_data_sets("MNIST_data",one_hot=True)

#每个批次的大小
batch_size = 100

#计算一共有多少个批次
n_batch = mnist.train.num_examples // batch_size

#定义两个placeholder,一个图片是28x28=784
x = tf.placeholder(tf.float32,[None,784])
y = tf.placeholder(tf.float32,[None,10])

#创建一个简单的神经网络
Weight_L1 = tf.Variable(tf.zeros([784,10]))
biases_L1 = tf.Variable(tf.zeros([10]))
Wx_plus_b_L1 = tf.matmul(x,Weight_L1) + biases_L1
prediction = tf.nn.softmax(Wx_plus_b_L1)



#二次代价函数
loss = tf.reduce_mean(tf.square(y-prediction))

#使用梯度下降法训练
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)

#初始化变量
init = tf.global_variables_initializer()

#结果存在一个布尔型的列表中
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1)) #argmax返回一个张量中最大值存在的位置

#求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)) #将布尔型转换为float32, true->1 false ->0

with tf.Session() as sess:
    sess.run(init)

    for epoch in range(21):
        for batch in range (n_batch):
            #获取每个batch的图片
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys})

        acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
        print("Iter " + str(epoch) + ",Testing Accuracy "+ str(acc))
     
     
     
     
      
      
      
      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

#第三章作业，修改神经网络使得识别率达到95%以上
#载入数据集
#one_hot是将数据改成0-1的格式
mnist = input_data.read_data_sets("MNIST_data",one_hot=True)

#每个批次的大小
batch_size = 100

#计算一共有多少个批次
n_batch = mnist.train.num_examples // batch_size

#定义两个placeholder,一个图片是28x28=784
x = tf.placeholder(tf.float32,[None,784])
y = tf.placeholder(tf.float32,[None,10])

#创建一个简单的神经网络
Weight_L1 = tf.Variable(tf.zeros([784,20]))
biases_L1 = tf.Variable(tf.zeros([20]))
Wx_plus_b_L1 = tf.matmul(x,Weight_L1) + biases_L1
L1 = tf.nn.tanh(Wx_plus_b_L1)


#定义神经网络输出层
Weight_L2 = tf.Variable(tf.random_normal([20,10]))
biases_L2 = tf.Variable(tf.zeros([10]))
Wx_plus_b_L2 = tf.matmul(L1,Weight_L2) + biases_L2
prediction = tf.nn.softmax(Wx_plus_b_L2)

#二次代价函数
loss = tf.reduce_mean(tf.square(y-prediction))

#使用梯度下降法训练
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)

#初始化变量
init = tf.global_variables_initializer()

#结果存在一个布尔型的列表中
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1)) #argmax返回一个张量中最大值存在的位置

#求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)) #将布尔型转换为float32, true->1 false ->0

with tf.Session() as sess:
    sess.run(init)

    for epoch in range(100):
        for batch in range (n_batch):
            #获取每个batch的图片
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys})

        acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
        print("Iter " + str(epoch) + ",Testing Accuracy "+ str(acc))
     
     
     
     
      
      
      
      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

交叉熵，过拟合，dropout以及tensorflow中各种优化器的介绍

交叉熵

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
     
     
     
     
      
      
      
      1
      
      
      
      2

#将二次代价函数替换成交叉熵
# tf.nn.sigmod_cross_entropy_with_logits() 来表示跟sigmod搭配使用的交叉熵
# tf.nn.softmax_cross_entropy_with_logits() 来表示跟softmax搭配使用的交叉熵
#载入数据集
#one_hot是将数据改成0-1的格式
mnist = input_data.read_data_sets("MNIST_data",one_hot=True)

#每个批次的大小
batch_size = 100

#计算一共有多少个批次
n_batch = mnist.train.num_examples // batch_size

#定义两个placeholder,一个图片是28x28=784
x = tf.placeholder(tf.float32,[None,784])
y = tf.placeholder(tf.float32,[None,10])

#创建一个简单的神经网络
Weight_L1 = tf.Variable(tf.zeros([784,10]))
biases_L1 = tf.Variable(tf.zeros([10]))
Wx_plus_b_L1 = tf.matmul(x,Weight_L1) + biases_L1
prediction = tf.nn.softmax(Wx_plus_b_L1)



#二次代价函数
#loss = tf.reduce_mean(tf.square(y-prediction))

#交叉熵
#首先看输入logits，它的shape是[batch_size, num_classes] ，一般来讲，就是神经网络最后一层的输入z。
#另外一个输入是labels，它的shape也是[batch_size, num_classes]，就是我们神经网络期望的输出。
loss=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=prediction))
#使用梯度下降法训练
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)

#初始化变量
init = tf.global_variables_initializer()

#结果存在一个布尔型的列表中
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1)) #argmax返回一个张量中最大值存在的位置

#求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)) #将布尔型转换为float32, true->1 false ->0

with tf.Session() as sess:
    sess.run(init)

    for epoch in range(21):
        for batch in range (n_batch):
            #获取每个batch的图片
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys})

        acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
        print("Iter " + str(epoch) + ",Testing Accuracy "+ str(acc))
     
     
     
     
      
      
      
      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

dropout

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
     
     
     
     
      
      
      
      1
      
      
      
      2

#将二次代价函数替换成交叉熵
# tf.nn.sigmod_cross_entropy_with_logits() 来表示跟sigmod搭配使用的交叉熵
# tf.nn.softmax_cross_entropy_with_logits() 来表示跟softmax搭配使用的交叉熵
#载入数据集
#one_hot是将数据改成0-1的格式
mnist = input_data.read_data_sets("MNIST_data",one_hot=True)

#每个批次的大小
batch_size = 100

#计算一共有多少个批次
n_batch = mnist.train.num_examples // batch_size

#定义两个placeholder,一个图片是28x28=784
x = tf.placeholder(tf.float32,[None,784])
y = tf.placeholder(tf.float32,[None,10])
keep_prob = tf.placeholder(tf.float32) #dropout的参数，表示多少神经元被激活,1 表示所有神经元都是工作的

#创建一个简单的神经网络
Weight_L1 = tf.Variable(tf.truncated_normal([784,2000],stddev=0.1))
biases_L1 = tf.Variable(tf.zeros([2000])+0.1)
Wx_plus_b_L1 = tf.nn.tanh(tf.matmul(x,Weight_L1) + biases_L1)
L1_drop = tf.nn.dropout(Wx_plus_b_L1,keep_prob)


Weight_L2 = tf.Variable(tf.truncated_normal([2000,2000],stddev=0.1))
biases_L2 = tf.Variable(tf.zeros([2000])+0.1)
Wx_plus_b_L2 = tf.nn.tanh(tf.matmul(L1_drop,Weight_L2) + biases_L2)
L2_drop = tf.nn.dropout(Wx_plus_b_L2,keep_prob)


Weight_L3 = tf.Variable(tf.truncated_normal([2000,1000],stddev=0.1))
biases_L3 = tf.Variable(tf.zeros([1000])+0.1)
Wx_plus_b_L3 = tf.nn.tanh(tf.matmul(L2_drop,Weight_L3) + biases_L3)
L3_drop = tf.nn.dropout(Wx_plus_b_L3,keep_prob)

Weight_L4 = tf.Variable(tf.truncated_normal([1000,10],stddev=0.1))
biases_L4 = tf.Variable(tf.zeros([10])+0.1)
prediction = tf.nn.softmax(tf.matmul(L3_drop,Weight_L4) + biases_L4)

#二次代价函数
#loss = tf.reduce_mean(tf.square(y-prediction))

#交叉熵
#首先看输入logits，它的shape是[batch_size, num_classes] ，一般来讲，就是神经网络最后一层的输入z。
#另外一个输入是labels，它的shape也是[batch_size, num_classes]，就是我们神经网络期望的输出。
loss=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=prediction))
#使用梯度下降法训练
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)

#初始化变量
init = tf.global_variables_initializer()

#结果存在一个布尔型的列表中
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1)) #argmax返回一个张量中最大值存在的位置

#求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)) #将布尔型转换为float32, true->1 false ->0

with tf.Session() as sess:
    sess.run(init)

    for epoch in range(21):
        for batch in range (n_batch):
            #获取每个batch的图片
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys,keep_prob:1.0})

        test_acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels,keep_prob:1.0})
        train_acc = sess.run(accuracy,feed_dict={x:mnist.train.images,y:mnist.train.labels,keep_prob:1.0})

        print("Iter " + str(epoch) + ",Testing Accuracy "+ str(test_acc)+", training Accuracy "+str(train_acc))
     
     
     
     
      
      
      
      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
      
      
      
      67
      
      
      
      68
      
      
      
      69
      
      
      
      70
      
      
      
      71
      
      
      
      72

optimizer优化器

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
     
     
     
     
      
      
      
      1
      
      
      
      2

#将二次代价函数替换成交叉熵
# tf.nn.sigmod_cross_entropy_with_logits() 来表示跟sigmod搭配使用的交叉熵
# tf.nn.softmax_cross_entropy_with_logits() 来表示跟softmax搭配使用的交叉熵
#载入数据集
#one_hot是将数据改成0-1的格式
mnist = input_data.read_data_sets("MNIST_data",one_hot=True)

#每个批次的大小
batch_size = 100

#计算一共有多少个批次
n_batch = mnist.train.num_examples // batch_size

#定义两个placeholder,一个图片是28x28=784
x = tf.placeholder(tf.float32,[None,784])
y = tf.placeholder(tf.float32,[None,10])

#创建一个简单的神经网络
Weight_L1 = tf.Variable(tf.zeros([784,10]))
biases_L1 = tf.Variable(tf.zeros([10]))
Wx_plus_b_L1 = tf.matmul(x,Weight_L1) + biases_L1
prediction = tf.nn.softmax(Wx_plus_b_L1)



#二次代价函数
#loss = tf.reduce_mean(tf.square(y-prediction))

#交叉熵
#首先看输入logits，它的shape是[batch_size, num_classes] ，一般来讲，就是神经网络最后一层的输入z。
#另外一个输入是labels，它的shape也是[batch_size, num_classes]，就是我们神经网络期望的输出。
loss=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=prediction))

#使用梯度下降法训练
#train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)
#使用其他优化器
train_step = tf.train.AdamOptimizer(1e-2).minimize(loss)

#初始化变量
init = tf.global_variables_initializer()

#结果存在一个布尔型的列表中
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1)) #argmax返回一个张量中最大值存在的位置

#求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)) #将布尔型转换为float32, true->1 false ->0

with tf.Session() as sess:
    sess.run(init)

    for epoch in range(21):
        for batch in range (n_batch):
            #获取每个batch的图片
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys})

        acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
        print("Iter " + str(epoch) + ",Testing Accuracy "+ str(acc))
     
     
     
     
      
      
      
      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

本章作业，继续优化网络，提高识别率

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
     
     
     
     
      
      
      
      1
      
      
      
      2

#将二次代价函数替换成交叉熵
# tf.nn.sigmod_cross_entropy_with_logits() 来表示跟sigmod搭配使用的交叉熵
# tf.nn.softmax_cross_entropy_with_logits() 来表示跟softmax搭配使用的交叉熵
#载入数据集
#one_hot是将数据改成0-1的格式
mnist = input_data.read_data_sets("MNIST_data",one_hot=True)

#每个批次的大小
batch_size = 100

#计算一共有多少个批次
n_batch = mnist.train.num_examples // batch_size

#定义两个placeholder,一个图片是28x28=784
x = tf.placeholder(tf.float32,[None,784])
y = tf.placeholder(tf.float32,[None,10])
keep_prob = tf.placeholder(tf.float32) #dropout的参数，表示多少神经元被激活,1 表示所有神经元都是工作的
#学习率的变量
lr = tf.Variable(0.001,dtype = tf.float32)

#创建一个简单的神经网络
Weight_L1 = tf.Variable(tf.truncated_normal([784,500],stddev=0.1))
biases_L1 = tf.Variable(tf.zeros([500])+0.1)
Wx_plus_b_L1 = tf.nn.tanh(tf.matmul(x,Weight_L1) + biases_L1)
L1_drop = tf.nn.dropout(Wx_plus_b_L1,keep_prob)


Weight_L2 = tf.Variable(tf.truncated_normal([500,300],stddev=0.1))
biases_L2 = tf.Variable(tf.zeros([300])+0.1)
Wx_plus_b_L2 = tf.nn.tanh(tf.matmul(L1_drop,Weight_L2) + biases_L2)
L2_drop = tf.nn.dropout(Wx_plus_b_L2,keep_prob)


Weight_L3 = tf.Variable(tf.truncated_normal([300,10],stddev=0.1))
biases_L3 = tf.Variable(tf.zeros([10])+0.1)
#Wx_plus_b_L3 = tf.nn.tanh(tf.matmul(L2_drop,Weight_L3) + biases_L3)
#L3_drop = tf.nn.dropout(Wx_plus_b_L3,keep_prob)

#Weight_L4 = tf.Variable(tf.truncated_normal([300,10],stddev=0.1))
#biases_L4 = tf.Variable(tf.zeros([10])+0.1)
prediction = tf.nn.softmax(tf.matmul(L2_drop,Weight_L3) + biases_L3)

#二次代价函数
#loss = tf.reduce_mean(tf.square(y-prediction))

#交叉熵
#首先看输入logits，它的shape是[batch_size, num_classes] ，一般来讲，就是神经网络最后一层的输入z。
#另外一个输入是labels，它的shape也是[batch_size, num_classes]，就是我们神经网络期望的输出。
loss=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=prediction))
#使用梯度下降法训练
#train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)
#使用其他优化器
train_step = tf.train.AdamOptimizer(lr).minimize(loss)


#初始化变量
init = tf.global_variables_initializer()

#结果存在一个布尔型的列表中
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1)) #argmax返回一个张量中最大值存在的位置

#求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)) #将布尔型转换为float32, true->1 false ->0

with tf.Session() as sess:
    sess.run(init)

    for epoch in range(51):
        sess.run(tf.assign(lr,0.001 * (0.95 ** epoch)))
        for batch in range (n_batch):
            #获取每个batch的图片
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys,keep_prob:1.0})

        learning_rate = sess.run(lr)

        test_acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels,keep_prob:1.0})
        train_acc = sess.run(accuracy,feed_dict={x:mnist.train.images,y:mnist.train.labels,keep_prob:1.0})

        print("Iter " + str(epoch) + ",Testing Accuracy "+ str(test_acc)+", training Accuracy "+str(train_acc))
     
     
     
     
      
      
      
      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
      
      
      
      67
      
      
      
      68
      
      
      
      69
      
      
      
      70
      
      
      
      71
      
      
      
      72
      
      
      
      73
      
      
      
      74
      
      
      
      75
      
      
      
      76
      
      
      
      77
      
      
      
      78
      
      
      
      79
      
      
      
      80

Extracting MNIST_data\train-images-idx3-ubyte.gz
Extracting MNIST_data\train-labels-idx1-ubyte.gz
Extracting MNIST_data\t10k-images-idx3-ubyte.gz
Extracting MNIST_data\t10k-labels-idx1-ubyte.gz
Iter 0,Testing Accuracy 0.952, training Accuracy 0.955818
Iter 1,Testing Accuracy 0.9604, training Accuracy 0.9672
Iter 2,Testing Accuracy 0.9675, training Accuracy 0.976364
Iter 3,Testing Accuracy 0.9712, training Accuracy 0.982236
Iter 4,Testing Accuracy 0.9736, training Accuracy 0.985655
Iter 5,Testing Accuracy 0.9751, training Accuracy 0.988509
Iter 6,Testing Accuracy 0.9755, training Accuracy 0.989909
Iter 7,Testing Accuracy 0.9752, training Accuracy 0.990855
Iter 8,Testing Accuracy 0.9784, training Accuracy 0.992382
Iter 9,Testing Accuracy 0.977, training Accuracy 0.9936
Iter 10,Testing Accuracy 0.9782, training Accuracy 0.993345
Iter 11,Testing Accuracy 0.9764, training Accuracy 0.9944
Iter 12,Testing Accuracy 0.978, training Accuracy 0.994891
Iter 13,Testing Accuracy 0.9789, training Accuracy 0.995309
Iter 14,Testing Accuracy 0.9792, training Accuracy 0.995327
Iter 15,Testing Accuracy 0.9787, training Accuracy 0.995309
Iter 16,Testing Accuracy 0.9792, training Accuracy 0.9958
Iter 17,Testing Accuracy 0.9799, training Accuracy 0.996
Iter 18,Testing Accuracy 0.9801, training Accuracy 0.995927
Iter 19,Testing Accuracy 0.9806, training Accuracy 0.9962
Iter 20,Testing Accuracy 0.9805, training Accuracy 0.996055
Iter 21,Testing Accuracy 0.9815, training Accuracy 0.9964
Iter 22,Testing Accuracy 0.9808, training Accuracy 0.996545
Iter 23,Testing Accuracy 0.9802, training Accuracy 0.996273
Iter 24,Testing Accuracy 0.982, training Accuracy 0.996618
Iter 25,Testing Accuracy 0.9814, training Accuracy 0.996709
Iter 26,Testing Accuracy 0.9808, training Accuracy 0.996727
Iter 27,Testing Accuracy 0.9815, training Accuracy 0.9968
Iter 28,Testing Accuracy 0.9813, training Accuracy 0.996836
Iter 29,Testing Accuracy 0.9818, training Accuracy 0.997018
Iter 30,Testing Accuracy 0.9819, training Accuracy 0.997036
Iter 31,Testing Accuracy 0.9818, training Accuracy 0.997091
Iter 32,Testing Accuracy 0.9822, training Accuracy 0.997145
Iter 33,Testing Accuracy 0.9812, training Accuracy 0.9972
Iter 34,Testing Accuracy 0.9813, training Accuracy 0.997255
Iter 35,Testing Accuracy 0.9822, training Accuracy 0.997273
Iter 36,Testing Accuracy 0.9817, training Accuracy 0.997309
Iter 37,Testing Accuracy 0.9824, training Accuracy 0.997345
Iter 38,Testing Accuracy 0.9809, training Accuracy 0.997345
Iter 39,Testing Accuracy 0.9819, training Accuracy 0.997364
Iter 40,Testing Accuracy 0.981, training Accuracy 0.997236
Iter 41,Testing Accuracy 0.9818, training Accuracy 0.9974
Iter 42,Testing Accuracy 0.9821, training Accuracy 0.997418
Iter 43,Testing Accuracy 0.9816, training Accuracy 0.997473
Iter 44,Testing Accuracy 0.9815, training Accuracy 0.997473
Iter 45,Testing Accuracy 0.9817, training Accuracy 0.997491
Iter 46,Testing Accuracy 0.9817, training Accuracy 0.997491
Iter 47,Testing Accuracy 0.9819, training Accuracy 0.997491
Iter 48,Testing Accuracy 0.9819, training Accuracy 0.997509
Iter 49,Testing Accuracy 0.9819, training Accuracy 0.997527
Iter 50,Testing Accuracy 0.9818, training Accuracy 0.997527

tensorboard可视化

tensorboard网络结构

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
     
     
     
     
      
      
      
      1
      
      
      
      2

#以3-2的程序为例介绍tensorboard的用法
#载入数据集
#one_hot是将数据改成0-1的格式
mnist = input_data.read_data_sets("MNIST_data",one_hot=True)

#每个批次的大小
batch_size = 100

#计算一共有多少个批次
n_batch = mnist.train.num_examples // batch_size


#*****要可视化网络结果，必须要用到命名空间***********
with tf.name_scope('input'):
    #定义两个placeholder,一个图片是28x28=784
    x = tf.placeholder(tf.float32,[None,784],name='x-input')
    y = tf.placeholder(tf.float32,[None,10],name='y-input')

#创建一个简单的神经网络
with tf.name_scope('layer'):
    with tf.name_scope('wights'):
        Weight_L1 = tf.Variable(tf.zeros([784,10]),name='W')
    with tf.name_scope('biases'):
        biases_L1 = tf.Variable(tf.zeros([10]),name='b')
    with tf.name_scope('wx_plus_b'):
        Wx_plus_b_L1 = tf.matmul(x,Weight_L1) + biases_L1
    with tf.name_scope('softmax'):
        prediction = tf.nn.softmax(Wx_plus_b_L1)



#二次代价函数
#loss = tf.reduce_mean(tf.square(y-prediction))
with tf.name_scope('loss'):
    loss=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=prediction))
#使用梯度下降法训练
with tf.name_scope('train'):
    train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)

#初始化变量
init = tf.global_variables_initializer()

#结果存在一个布尔型的列表中
with tf.name_scope('accuracy'):
    with tf.name_scope('correct_prediction'):
        correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1)) #argmax返回一个张量中最大值存在的位置
    with tf.name_scope('accuracy'):
        #求准确率
        accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)) #将布尔型转换为float32, true->1 false ->0

with tf.Session() as sess:
    sess.run(init)
    writer = tf.summary.FileWriter('C:/Users/zgyxf183/Desktop/logs',sess.graph)
    for epoch in range(1):
        for batch in range (n_batch):
            #获取每个batch的图片
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys})

        acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
        print("Iter " + str(epoch) + ",Testing Accuracy "+ str(acc))
     
     
     
     
      
      
      
      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

tensorboard网络运行

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
     
     
     
     
      
      
      
      1
      
      
      
      2

#载入数据集
mnist = input_data.read_data_sets("MNIST_data",one_hot=True)

#每个批次的大小
batch_size = 100
#计算一共有多少个批次
n_batch = mnist.train.num_examples // batch_size

#参数概要
def variable_summaries(var):
    with tf.name_scope('summaries'):
        mean = tf.reduce_mean(var)
        tf.summary.scalar('mean', mean)#平均值
        with tf.name_scope('stddev'):
            stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
        tf.summary.scalar('stddev', stddev)#标准差
        tf.summary.scalar('max', tf.reduce_max(var))#最大值
        tf.summary.scalar('min', tf.reduce_min(var))#最小值
        tf.summary.histogram('histogram', var)#直方图

#命名空间
with tf.name_scope('input'):
    #定义两个placeholder
    x = tf.placeholder(tf.float32,[None,784],name='x-input')
    y = tf.placeholder(tf.float32,[None,10],name='y-input')

with tf.name_scope('layer'):
    #创建一个简单的神经网络
    with tf.name_scope('wights'):
        W = tf.Variable(tf.zeros([784,10]),name='W')
        variable_summaries(W)
    with tf.name_scope('biases'):    
        b = tf.Variable(tf.zeros([10]),name='b')
        variable_summaries(b)
    with tf.name_scope('wx_plus_b'):
        wx_plus_b = tf.matmul(x,W) + b
    with tf.name_scope('softmax'):
        prediction = tf.nn.softmax(wx_plus_b)

#二次代价函数
# loss = tf.reduce_mean(tf.square(y-prediction))
with tf.name_scope('loss'):
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=prediction))
    tf.summary.scalar('loss',loss)
with tf.name_scope('train'):
    #使用梯度下降法
    train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)

#初始化变量
init = tf.global_variables_initializer()

with tf.name_scope('accuracy'):
    with tf.name_scope('correct_prediction'):
        #结果存放在一个布尔型列表中
        correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))#argmax返回一维张量中最大的值所在的位置
    with tf.name_scope('accuracy'):
        #求准确率
        accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
        tf.summary.scalar('accuracy',accuracy)

#合并所有的summary
merged = tf.summary.merge_all()

with tf.Session() as sess:
    sess.run(init)
    writer = tf.summary.FileWriter('logs/',sess.graph)
    for epoch in range(51):
        for batch in range(n_batch):
            batch_xs,batch_ys =  mnist.train.next_batch(batch_size)
            summary,_ = sess.run([merged,train_step],feed_dict={x:batch_xs,y:batch_ys})

        writer.add_summary(summary,epoch)
        acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
        print("Iter " + str(epoch) + ",Testing Accuracy " + str(acc))
     
     
     
     
      
      
      
      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
      
      
      
      67
      
      
      
      68
      
      
      
      69
      
      
      
      70
      
      
      
      71
      
      
      
      72
      
      
      
      73
      
      
      
      74

tensorboard可视化

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
from tensorflow.contrib.tensorboard.plugins import projector
     
     
     
     
      
      
      
      1
      
      
      
      2
      
      
      
      3

#载入数据集
mnist = input_data.read_data_sets("MNIST_data/",one_hot=True)
#运行次数
max_steps = 1001
#图片数量
image_num = 3000
#文件路径
DIR = "C:/Users/zgyxf183/Documents/jupyter/tensorFlow Learning/"

#定义会话
sess = tf.Session()

#载入图片
embedding = tf.Variable(tf.stack(mnist.test.images[:image_num]), trainable=False, name='embedding')

#参数概要
def variable_summaries(var):
    with tf.name_scope('summaries'):
        mean = tf.reduce_mean(var)
        tf.summary.scalar('mean', mean)#平均值
        with tf.name_scope('stddev'):
            stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
        tf.summary.scalar('stddev', stddev)#标准差
        tf.summary.scalar('max', tf.reduce_max(var))#最大值
        tf.summary.scalar('min', tf.reduce_min(var))#最小值
        tf.summary.histogram('histogram', var)#直方图

#命名空间
with tf.name_scope('input'):
    #这里的none表示第一个维度可以是任意的长度
    x = tf.placeholder(tf.float32,[None,784],name='x-input')
    #正确的标签
    y = tf.placeholder(tf.float32,[None,10],name='y-input')

#显示图片
with tf.name_scope('input_reshape'):
    image_shaped_input = tf.reshape(x, [-1, 28, 28, 1])
    tf.summary.image('input', image_shaped_input, 10)

with tf.name_scope('layer'):
    #创建一个简单神经网络
    with tf.name_scope('weights'):
        W = tf.Variable(tf.zeros([784,10]),name='W')
        variable_summaries(W)
    with tf.name_scope('biases'):
        b = tf.Variable(tf.zeros([10]),name='b')
        variable_summaries(b)
    with tf.name_scope('wx_plus_b'):
        wx_plus_b = tf.matmul(x,W) + b
    with tf.name_scope('softmax'):    
        prediction = tf.nn.softmax(wx_plus_b)

with tf.name_scope('loss'):
    #交叉熵代价函数
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=prediction))
    tf.summary.scalar('loss',loss)
with tf.name_scope('train'):
    #使用梯度下降法
    train_step = tf.train.GradientDescentOptimizer(0.5).minimize(loss)

#初始化变量
sess.run(tf.global_variables_initializer())

with tf.name_scope('accuracy'):
    with tf.name_scope('correct_prediction'):
        #结果存放在一个布尔型列表中
        correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))#argmax返回一维张量中最大的值所在的位置
    with tf.name_scope('accuracy'):
        #求准确率
        accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))#把correct_prediction变为float32类型
        tf.summary.scalar('accuracy',accuracy)

#产生metadata文件
if tf.gfile.Exists(DIR + 'projector/projector/metadata.tsv'):
    tf.gfile.DeleteRecursively(DIR + 'projector/projector/metadata.tsv')
with open(DIR + 'projector/projector/metadata.tsv', 'w') as f:
    labels = sess.run(tf.argmax(mnist.test.labels[:],1))
    for i in range(image_num):   
        f.write(str(labels[i]) + '\n')        

#合并所有的summary
merged = tf.summary.merge_all()   


projector_writer = tf.summary.FileWriter(DIR + 'projector/projector',sess.graph)
saver = tf.train.Saver()
config = projector.ProjectorConfig()
embed = config.embeddings.add()
embed.tensor_name = embedding.name
embed.metadata_path = DIR + 'projector/projector/metadata.tsv'
embed.sprite.image_path = DIR + 'projector/data/mnist_10k_sprite.png'
embed.sprite.single_image_dim.extend([28,28])
projector.visualize_embeddings(projector_writer,config)

for i in range(max_steps):
    #每个批次100个样本
    batch_xs,batch_ys = mnist.train.next_batch(100)
    run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
    run_metadata = tf.RunMetadata()
    summary,_ = sess.run([merged,train_step],feed_dict={x:batch_xs,y:batch_ys},options=run_options,run_metadata=run_metadata)
    projector_writer.add_run_metadata(run_metadata, 'step%03d' % i)
    projector_writer.add_summary(summary, i)

    if i%100 == 0:
        acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
        print ("Iter " + str(i) + ", Testing Accuracy= " + str(acc))

saver.save(sess, DIR + 'projector/projector/a_model.ckpt', global_step=max_steps)
projector_writer.close()
sess.close()
     
     
     
     
      
      
      
      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
      
      
      
      67
      
      
      
      68
      
      
      
      69
      
      
      
      70
      
      
      
      71
      
      
      
      72
      
      
      
      73
      
      
      
      74
      
      
      
      75
      
      
      
      76
      
      
      
      77
      
      
      
      78
      
      
      
      79
      
      
      
      80
      
      
      
      81
      
      
      
      82
      
      
      
      83
      
      
      
      84
      
      
      
      85
      
      
      
      86
      
      
      
      87
      
      
      
      88
      
      
      
      89
      
      
      
      90
      
      
      
      91
      
      
      
      92
      
      
      
      93
      
      
      
      94
      
      
      
      95
      
      
      
      96
      
      
      
      97
      
      
      
      98
      
      
      
      99
      
      
      
      100
      
      
      
      101
      
      
      
      102
      
      
      
      103
      
      
      
      104
      
      
      
      105
      
      
      
      106
      
      
      
      107
      
      
      
      108
      
      
      
      109
      
      
      
      110

卷积神经网络

卷积神经网络应用于MNIST数据集分类

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
     
     
     
     
      
      
      
      1
      
      
      
      2

#将二次代价函数替换成交叉熵
# tf.nn.sigmod_cross_entropy_with_logits() 来表示跟sigmod搭配使用的交叉熵
# tf.nn.softmax_cross_entropy_with_logits() 来表示跟softmax搭配使用的交叉熵
#载入数据集
#one_hot是将数据改成0-1的格式
mnist = input_data.read_data_sets("MNIST_data",one_hot=True)

#每个批次的大小
batch_size = 100

#计算一共有多少个批次
n_batch = mnist.train.num_examples // batch_size

#初始化权值
def weight_variable(shape):
    initial = tf.truncated_normal(shape,stddev=0.1)#生成一个截断的正态分布
    return tf.Variable(initial)

#初始化偏移量
def bias_variable(shape):
    initial = tf.constant(0.1,shape=shape)
    return tf.Variable(initial)


#定义卷积层
def conv2d(x,W):
    return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')

#定义池化层
def max_pool_2x2(x):
    return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')



#定义两个placeholder,一个图片是28x28=784
x = tf.placeholder(tf.float32,[None,784])
y = tf.placeholder(tf.float32,[None,10])

#改变x的格式转为4D的向量[batch, in_height, in_width, in_channels]`
#输入的数据是784行的一列数据，要转换成 28x28
x_image = tf.reshape(x,[-1,28,28,1])

#初始化第一个卷积层的权值和偏置
W_conv1 = weight_variable([5,5,1,32])#5*5的采样窗口，32个卷积核从1个平面抽取特征
b_conv1 = bias_variable([32])#每一个卷积核一个偏置值


#把x_image和权值向量进行卷积，再加上偏置值，然后应用于relu激活函数
h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)

#初始化第二个卷积层的权值和偏置
W_conv2 = weight_variable([5,5,32,64])#5*5的采样窗口，64个卷积核从32个平面抽取特征
b_conv2 = bias_variable([64])#每一个卷积核一个偏置值

#把h_pool1和权值向量进行卷积，再加上偏置值，然后应用于relu激活函数
h_conv2 = tf.nn.relu(conv2d(h_pool1,W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)#进行max-pooling

#28*28的图片第一次卷积后还是28*28，第一次池化后变为14*14
#第二次卷积后为14*14，第二次池化后变为了7*7
#进过上面操作后得到64张7*7的平面



#初始化第一个全连接层的权值
W_fc1 = weight_variable([7*7*64,1024])#上一层有7*7*64个神经元，全连接层有1024个神经元
b_fc1 = bias_variable([1024])#1024个节点


#把池化层2的输出扁平化为1维
h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64])

#求第一个全连接层的输出
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1) + b_fc1)


#keep_prob用来表示神经元的输出概率
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)

#初始化第二个全连接层
W_fc2 = weight_variable([1024,10])
b_fc2 = bias_variable([10])

#计算输出
prediction = tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2) + b_fc2)

#二次代价函数
#loss = tf.reduce_mean(tf.square(y-prediction))

#交叉熵
#首先看输入logits，它的shape是[batch_size, num_classes] ，一般来讲，就是神经网络最后一层的输入z。
#另外一个输入是labels，它的shape也是[batch_size, num_classes]，就是我们神经网络期望的输出。
loss=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=prediction))
#使用梯度下降法训练
#train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)
#使用其他优化器
train_step = tf.train.AdamOptimizer(1e-4).minimize(loss)


#初始化变量
init = tf.global_variables_initializer()

#结果存在一个布尔型的列表中
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1)) #argmax返回一个张量中最大值存在的位置

#求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)) #将布尔型转换为float32, true->1 false ->0

with tf.Session() as sess:
    sess.run(init)

    for epoch in range(51):

        for batch in range (n_batch):
            #获取每个batch的图片
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys,keep_prob:0.7})

        #learning_rate = sess.run(lr)

        test_acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels,keep_prob:1.0})
        train_acc = sess.run(accuracy,feed_dict={x:mnist.train.images,y:mnist.train.labels,keep_prob:1.0})

        print("Iter " + str(epoch) + ",Testing Accuracy "+ str(test_acc)+", training Accuracy "+str(train_acc))
     
     
     
     
      
      
      
      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
      
      
      
      67
      
      
      
      68
      
      
      
      69
      
      
      
      70
      
      
      
      71
      
      
      
      72
      
      
      
      73
      
      
      
      74
      
      
      
      75
      
      
      
      76
      
      
      
      77
      
      
      
      78
      
      
      
      79
      
      
      
      80
      
      
      
      81
      
      
      
      82
      
      
      
      83
      
      
      
      84
      
      
      
      85
      
      
      
      86
      
      
      
      87
      
      
      
      88
      
      
      
      89
      
      
      
      90
      
      
      
      91
      
      
      
      92
      
      
      
      93
      
      
      
      94
      
      
      
      95
      
      
      
      96
      
      
      
      97
      
      
      
      98
      
      
      
      99
      
      
      
      100
      
      
      
      101
      
      
      
      102
      
      
      
      103
      
      
      
      104
      
      
      
      105
      
      
      
      106
      
      
      
      107
      
      
      
      108
      
      
      
      109
      
      
      
      110
      
      
      
      111
      
      
      
      112
      
      
      
      113
      
      
      
      114
      
      
      
      115
      
      
      
      116
      
      
      
      117
      
      
      
      118
      
      
      
      119
      
      
      
      120
      
      
      
      121
      
      
      
      122
      
      
      
      123
      
      
      
      124
      
      
      
      125
      
      
      
      126

作业，卷积神经网络可视化

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
     
     
     
     
      
      
      
      1
      
      
      
      2

mnist = input_data.read_data_sets('MNIST_data',one_hot=True)

#每个批次的大小
batch_size = 100
#计算一共有多少个批次
n_batch = mnist.train.num_examples // batch_size

#参数概要
def variable_summaries(var):
    with tf.name_scope('summaries'):
        mean = tf.reduce_mean(var)
        tf.summary.scalar('mean', mean)#平均值
        with tf.name_scope('stddev'):
            stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
        tf.summary.scalar('stddev', stddev)#标准差
        tf.summary.scalar('max', tf.reduce_max(var))#最大值
        tf.summary.scalar('min', tf.reduce_min(var))#最小值
        tf.summary.histogram('histogram', var)#直方图

#初始化权值
def weight_variable(shape,name):
    initial = tf.truncated_normal(shape,stddev=0.1)#生成一个截断的正态分布
    return tf.Variable(initial,name=name)

#初始化偏置
def bias_variable(shape,name):
    initial = tf.constant(0.1,shape=shape)
    return tf.Variable(initial,name=name)

#卷积层
def conv2d(x,W):
    #x input tensor of shape `[batch, in_height, in_width, in_channels]`
    #W filter / kernel tensor of shape [filter_height, filter_width, in_channels, out_channels]
    #`strides[0] = strides[3] = 1`. strides[1]代表x方向的步长，strides[2]代表y方向的步长
    #padding: A `string` from: `"SAME", "VALID"`
    return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')

#池化层
def max_pool_2x2(x):
    #ksize [1,x,y,1]
    return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')

#命名空间
with tf.name_scope('input'):
    #定义两个placeholder
    x = tf.placeholder(tf.float32,[None,784],name='x-input')
    y = tf.placeholder(tf.float32,[None,10],name='y-input')
    with tf.name_scope('x_image'):
        #改变x的格式转为4D的向量[batch, in_height, in_width, in_channels]`
        x_image = tf.reshape(x,[-1,28,28,1],name='x_image')


with tf.name_scope('Conv1'):
    #初始化第一个卷积层的权值和偏置
    with tf.name_scope('W_conv1'):
        W_conv1 = weight_variable([5,5,1,32],name='W_conv1')#5*5的采样窗口，32个卷积核从1个平面抽取特征
    with tf.name_scope('b_conv1'):  
        b_conv1 = bias_variable([32],name='b_conv1')#每一个卷积核一个偏置值

    #把x_image和权值向量进行卷积，再加上偏置值，然后应用于relu激活函数
    with tf.name_scope('conv2d_1'):
        conv2d_1 = conv2d(x_image,W_conv1) + b_conv1
    with tf.name_scope('relu'):
        h_conv1 = tf.nn.relu(conv2d_1)
    with tf.name_scope('h_pool1'):
        h_pool1 = max_pool_2x2(h_conv1)#进行max-pooling

with tf.name_scope('Conv2'):
    #初始化第二个卷积层的权值和偏置
    with tf.name_scope('W_conv2'):
        W_conv2 = weight_variable([5,5,32,64],name='W_conv2')#5*5的采样窗口，64个卷积核从32个平面抽取特征
    with tf.name_scope('b_conv2'):  
        b_conv2 = bias_variable([64],name='b_conv2')#每一个卷积核一个偏置值

    #把h_pool1和权值向量进行卷积，再加上偏置值，然后应用于relu激活函数
    with tf.name_scope('conv2d_2'):
        conv2d_2 = conv2d(h_pool1,W_conv2) + b_conv2
    with tf.name_scope('relu'):
        h_conv2 = tf.nn.relu(conv2d_2)
    with tf.name_scope('h_pool2'):
        h_pool2 = max_pool_2x2(h_conv2)#进行max-pooling

#28*28的图片第一次卷积后还是28*28，第一次池化后变为14*14
#第二次卷积后为14*14，第二次池化后变为了7*7
#进过上面操作后得到64张7*7的平面

with tf.name_scope('fc1'):
    #初始化第一个全连接层的权值
    with tf.name_scope('W_fc1'):
        W_fc1 = weight_variable([7*7*64,1024],name='W_fc1')#上一场有7*7*64个神经元，全连接层有1024个神经元
    with tf.name_scope('b_fc1'):
        b_fc1 = bias_variable([1024],name='b_fc1')#1024个节点

    #把池化层2的输出扁平化为1维
    with tf.name_scope('h_pool2_flat'):
        h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64],name='h_pool2_flat')
    #求第一个全连接层的输出
    with tf.name_scope('wx_plus_b1'):
        wx_plus_b1 = tf.matmul(h_pool2_flat,W_fc1) + b_fc1
    with tf.name_scope('relu'):
        h_fc1 = tf.nn.relu(wx_plus_b1)

    #keep_prob用来表示神经元的输出概率
    with tf.name_scope('keep_prob'):
        keep_prob = tf.placeholder(tf.float32,name='keep_prob')
    with tf.name_scope('h_fc1_drop'):
        h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob,name='h_fc1_drop')

with tf.name_scope('fc2'):
    #初始化第二个全连接层
    with tf.name_scope('W_fc2'):
        W_fc2 = weight_variable([1024,10],name='W_fc2')
    with tf.name_scope('b_fc2'):    
        b_fc2 = bias_variable([10],name='b_fc2')
    with tf.name_scope('wx_plus_b2'):
        wx_plus_b2 = tf.matmul(h_fc1_drop,W_fc2) + b_fc2
    with tf.name_scope('softmax'):
        #计算输出
        prediction = tf.nn.softmax(wx_plus_b2)

#交叉熵代价函数
with tf.name_scope('cross_entropy'):
    cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=prediction),name='cross_entropy')
    tf.summary.scalar('cross_entropy',cross_entropy)

#使用AdamOptimizer进行优化
with tf.name_scope('train'):
    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

#求准确率
with tf.name_scope('accuracy'):
    with tf.name_scope('correct_prediction'):
        #结果存放在一个布尔列表中
        correct_prediction = tf.equal(tf.argmax(prediction,1),tf.argmax(y,1))#argmax返回一维张量中最大的值所在的位置
    with tf.name_scope('accuracy'):
        #求准确率
        accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
        tf.summary.scalar('accuracy',accuracy)

#合并所有的summary
merged = tf.summary.merge_all()

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    train_writer = tf.summary.FileWriter('logs/train',sess.graph)
    test_writer = tf.summary.FileWriter('logs/test',sess.graph)
    for i in range(1001):
        #训练模型
        batch_xs,batch_ys =  mnist.train.next_batch(batch_size)
        sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys,keep_prob:0.5})
        #记录训练集计算的参数
        summary = sess.run(merged,feed_dict={x:batch_xs,y:batch_ys,keep_prob:1.0})
        train_writer.add_summary(summary,i)
        #记录测试集计算的参数
        batch_xs,batch_ys =  mnist.test.next_batch(batch_size)
        summary = sess.run(merged,feed_dict={x:batch_xs,y:batch_ys,keep_prob:1.0})
        test_writer.add_summary(summary,i)

        if i%100==0:
            test_acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels,keep_prob:1.0})
            train_acc = sess.run(accuracy,feed_dict={x:mnist.train.images[:10000],y:mnist.train.labels[:10000],keep_prob:1.0})
            print ("Iter " + str(i) + ", Testing Accuracy= " + str(test_acc) + ", Training Accuracy= " + str(train_acc))


     
     
     
     
      
      
      
      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
      
      
      
      67
      
      
      
      68
      
      
      
      69
      
      
      
      70
      
      
      
      71
      
      
      
      72
      
      
      
      73
      
      
      
      74
      
      
      
      75
      
      
      
      76
      
      
      
      77
      
      
      
      78
      
      
      
      79
      
      
      
      80
      
      
      
      81
      
      
      
      82
      
      
      
      83
      
      
      
      84
      
      
      
      85
      
      
      
      86
      
      
      
      87
      
      
      
      88
      
      
      
      89
      
      
      
      90
      
      
      
      91
      
      
      
      92
      
      
      
      93
      
      
      
      94
      
      
      
      95
      
      
      
      96
      
      
      
      97
      
      
      
      98
      
      
      
      99
      
      
      
      100
      
      
      
      101
      
      
      
      102
      
      
      
      103
      
      
      
      104
      
      
      
      105
      
      
      
      106
      
      
      
      107
      
      
      
      108
      
      
      
      109
      
      
      
      110
      
      
      
      111
      
      
      
      112
      
      
      
      113
      
      
      
      114
      
      
      
      115
      
      
      
      116
      
      
      
      117
      
      
      
      118
      
      
      
      119
      
      
      
      120
      
      
      
      121
      
      
      
      122
      
      
      
      123
      
      
      
      124
      
      
      
      125
      
      
      
      126
      
      
      
      127
      
      
      
      128
      
      
      
      129
      
      
      
      130
      
      
      
      131
      
      
      
      132
      
      
      
      133
      
      
      
      134
      
      
      
      135
      
      
      
      136
      
      
      
      137
      
      
      
      138
      
      
      
      139
      
      
      
      140
      
      
      
      141
      
      
      
      142
      
      
      
      143
      
      
      
      144
      
      
      
      145
      
      
      
      146
      
      
      
      147
      
      
      
      148
      
      
      
      149
      
      
      
      150
      
      
      
      151
      
      
      
      152
      
      
      
      153
      
      
      
      154
      
      
      
      155
      
      
      
      156
      
      
      
      157
      
      
      
      158
      
      
      
      159
      
      
      
      160
      
      
      
      161
      
      
      
      162
      
      
      
      163
      
      
      
      164

递归神经网络LSTM的讲解，以及LSTM网络的使用

递归神经网络RNN

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
     
     
     
     
      
      
      
      1
      
      
      
      2

#载入数据集
mnist = input_data.read_data_sets("MNIST_data/",one_hot=True)

# 输入图片是28*28
n_inputs = 28 #输入一行，一行有28个数据
max_time = 28 #一共28行
lstm_size = 100 #隐层单元
n_classes = 10 # 10个分类
batch_size = 50 #每批次50个样本
n_batch = mnist.train.num_examples // batch_size #计算一共有多少个批次

#这里的none表示第一个维度可以是任意的长度
x = tf.placeholder(tf.float32,[None,784])
#正确的标签
y = tf.placeholder(tf.float32,[None,10])

#初始化权值
weights = tf.Variable(tf.truncated_normal([lstm_size, n_classes], stddev=0.1))
#初始化偏置值
biases = tf.Variable(tf.constant(0.1, shape=[n_classes]))


#定义RNN网络
def RNN(X,weights,biases):
    # inputs=[batch_size, max_time, n_inputs]
    inputs = tf.reshape(X,[-1,max_time,n_inputs])
    #定义LSTM基本CELL
    lstm_cell = tf.contrib.rnn.core_rnn_cell.BasicLSTMCell(lstm_size)
#    final_state[state, batch_size, cell.state_size]
#    final_state[0]是cell state
#    final_state[1]是hidden_state
#    outputs: The RNN output `Tensor`.
#       If time_major == False (default), this will be a `Tensor` shaped:
#         `[batch_size, max_time, cell.output_size]`.
#       If time_major == True, this will be a `Tensor` shaped:
#         `[max_time, batch_size, cell.output_size]`.
    outputs,final_state = tf.nn.dynamic_rnn(lstm_cell,inputs,dtype=tf.float32)
    results = tf.nn.softmax(tf.matmul(final_state[1],weights) + biases)
    return results


#计算RNN的返回结果
prediction= RNN(x, weights, biases)  
#损失函数
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=prediction,labels=y))
#使用AdamOptimizer进行优化
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
#结果存放在一个布尔型列表中
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))#argmax返回一维张量中最大的值所在的位置
#求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))#把correct_prediction变为float32类型
#初始化
init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    for epoch in range(6):
        for batch in range(n_batch):
            batch_xs,batch_ys =  mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys})

        acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
        print ("Iter " + str(epoch) + ", Testing Accuracy= " + str(acc))
     
     
     
     
      
      
      
      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

Extracting MNIST_data/train-images-idx3-ubyte.gz
Extracting MNIST_data/train-labels-idx1-ubyte.gz
Extracting MNIST_data/t10k-images-idx3-ubyte.gz
Extracting MNIST_data/t10k-labels-idx1-ubyte.gz
Iter 0, Testing Accuracy= 0.7221
Iter 1, Testing Accuracy= 0.8016
Iter 2, Testing Accuracy= 0.8763
Iter 3, Testing Accuracy= 0.9103
Iter 4, Testing Accuracy= 0.9223
Iter 5, Testing Accuracy= 0.9311
     
     
     
     
      
      
      
      1
      
      
      
      2
      
      
      
      3
      
      
      
      4
      
      
      
      5
      
      
      
      6
      
      
      
      7
      
      
      
      8
      
      
      
      9
      
      
      
      10

上一篇 LeetCode算法思想
下一篇 eclipse部署工程遇到的问题整理

你可能感兴趣的:(深度学习框架-tensorflow基础入门)

Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
ESP32-C3入门教程网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能小康师兄 ESP32-C3入门教程 https 服务器 esp32 OTA MQTT
文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
HarmonyOS开发实战（ Beta5.0）搜索框热搜词自动切换让开，我要吃人了 OpenHarmony HarmonyOS 鸿蒙开发 harmonyos 华为鸿蒙移动开发鸿蒙系统前端开发语言
鸿蒙HarmonyOS开发往期必看：HarmonyOSNEXT应用开发性能实践总结最新版！“非常详细的”鸿蒙HarmonyOSNext应用开发学习路线！（从零基础入门到精通）介绍本示例介绍使用TextInput组件与Swiper组件实现搜索框内热搜词自动切换。效果图预览使用说明页面顶部搜索框内热搜词条自动切换，编辑搜索框时自动隐藏。实现思路使用TextInput实现搜索框TextInput({te
【从问题中去学习k8s】k8s中的常见面试题（夯实理论基础）（二十八）向往风的男子 k8s 学习 kubernetes 容器
本站以分享各种运维经验和运维所需要的技能为主《python零基础入门》：python零基础入门学习《python运维脚本》：python运维脚本实践《shell》：shell学习《terraform》持续更新中：terraform_Aws学习零基础入门到最佳实战《k8》从问题中去学习k8s《docker学习》暂未更新《ceph学习》ceph日常问题解决分享《日志收集》ELK+各种中间件《运维日常》
C# 开发教程-入门基础天马3798 教程系列整理 c#开发语言
1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
云服务业界动态简报-20180128 Captain7
一、青云青云QingCloud推出深度学习平台DeepLearningonQingCloud，包含了主流的深度学习框架及数据科学工具包，通过QingCloudAppCenter一键部署交付，可以让算法工程师和数据科学家快速构建深度学习开发环境，将更多的精力放在模型和算法调优。二、腾讯云1.腾讯云正式发布腾讯专有云TCE(TencentCloudEnterprise)矩阵，涵盖企业版、大数据版、AI
Keras深度学习框架入门及实战指南司莹嫣Maude
Keras深度学习框架入门及实战指南keraskeras-team/keras:是一个基于Python的深度学习库，它没有使用数据库。适合用于深度学习任务的开发和实现，特别是对于需要使用Python深度学习库的场景。特点是深度学习库、Python、无数据库。项目地址:https://gitcode.com/gh_mirrors/ke/keras一、项目介绍Keras简介Keras是一款高级神经网络
WebRTC之LiveKit的基础入门使用（入门必看） tabzzz 前端 webrtc web3 typescript
LiveKit本文主要是讲解在Next13+中如何使用LiveKit来实现简单的音视频通话，想了解更多的还是要去官方文档去掌握更复杂、高级的使用方法。什么是LiveKitLiveKit是一个开源的实时通信平台，基于WebRTC，主要用于构建高质量的音视频通话、实时数据传输和互动应用。LiveKit除了方便以外的大优势就是它提供了丰富的API和SDK，支持多种平台，包括Web、iOS、Android
一文说透 Android 应用架构 MVC、MVP、MVVM 和组件化，Android基础入门教程 Java后时代 2024年程序员学习 android 架构 mvc
然后，就是我们的View层的代码，同样，我对代码做了删减：@Route(path=BaseConstants.EYEPETIZER_MENU)publicclassHomeActivityextendsCommonActivityimplementsHomeContract.IView{//实例化PresenterprivateHomeContract.IPresenterpresenter;{p
java 基础 i0208 java 开发语言
基础数据类型，方法，类，异常处理：Java零基础入门学习（小白也能看懂！）_java零基础自学-CSDN博客List在Java中，List接口是集合框架中非常重要的一个接口，它提供了存储和操作有序集合的方法。List是一个接口，因此不能直接实例化，但可以通过其实现类（如ArrayList,LinkedList,Vector等）来使用。List接口的主要实现类ArrayList:动态数组实现，适用于
多模态大语言模型(MLLMs)-一般架构（非常详细）零基础入门到精通，收藏这一篇就够了程序员_大白语言模型人工智能自然语言处理
多模态大语言模型(MultimodalLargeLanguageModel,MLLM），在LLM原有的强大泛化和推理能力基础上，进一步引入了多模态信息处理能力。相比于以往的多模态方法，例如以CLIP为代表的判别式，或以OFA为代表的生成式，新兴的MLLM展现出一些典型的特质，在下面这两种特质的加持下，MLLM涌现出一些以往多模态模型所不具备的能力！模型大。MLLM通常具有数十亿的参数量，更多的参数
Linux+Nginx+Asp.net Core及守护进程部署念童 linux nginx asp.net 运维服务器
上篇《Docker基础入门及示例》文章介绍了Docker部署，以及相关.netcore的打包示例。这篇文章我将以oss.offical.site站点为例，主要介绍下在linux机器下完整的部署流程，.netcore在docker容器中的运行已经介绍，这里.netcore运行环境我会介绍直接在linux运行的场景，内容主要包含以下几个部分：1.基础工具和Linux环境准备2..NetCore环境安装
Linux+Nginx+Asp.net Core部署 dotNET跨平台
上篇《Docker基础入门及示例》文章介绍了Docker部署，以及相关.netcore的打包示例。这篇文章我将以oss.offical.site站点为例，主要介绍下在linux机器下完整的部署流程，.netcore在docker容器中的运行已经介绍，这里.netcore运行环境我会介绍直接在linux运行的场景，内容主要包含以下几个部分：1.基础工具和Linux环境准备2..NetCore环境安装
零基础入门AI：一键本地运行各种开源大语言模型 - Ollama AI大模型知识分享人工智能开源语言模型 pytorch gpt-3 chatgpt openvino
什么是Ollama？Ollama是一个可以在本地部署和管理开源大语言模型的框架，由于它极大的简化了开源大语言模型的安装和配置细节，一经推出就广受好评，目前已在github上获得了46kstar。不管是著名的羊驼系列，还是最新的AI新贵Mistral，等等各种开源大语言模型，都可以用Ollama实现一键安装并运行，支持的更多模型的列表可以查看Ollama官网。ModelParametersSizeD
深度学习入门篇：PyTorch实现手写数字识别 AI_Guru人工智能深度学习 pytorch 人工智能
深度学习作为机器学习的一个分支，近年来在图像识别、自然语言处理等领域取得了显著的成就。在众多的深度学习框架中，PyTorch以其动态计算图、易用性强和灵活度高等特点，受到了广泛的喜爱。本篇文章将带领大家使用PyTorch框架，实现一个手写数字识别的基础模型。手写数字识别简介手写数字识别是计算机视觉领域的一个经典问题，目的是让计算机能够识别并理解手写数字图像。这个问题通常作为深度学习入门的练习，因为
关于python版本与TensorFlow安装的版本问题 iiimharrygGc. python tensorflow 开发语言
实测在conda环境下，python3.12的版本无法安装TensorFlow2.14.0（截至2024.5.21）最新版本在python3.7版本下正常安装ps：上述安装均在anacondanavigator软件内安装
Vue + Django的人脸识别系统 DXSsssss python DRF tensorflow 人脸识别
最近在研究机器学习，刚好最近看了vue+Djangodrf的一些课程，学以致用，做了一个人脸识别系统。项目前端使用Vue框架，用到了elementui组件，写起来真是方便。比之前传统的dtl方便了太多。后端使用了drf，识别知识刚开始打算使用opencv+tensorflow,但是发现吧识别以后的结果返回到浏览器当中时使用opencv比较麻烦（主要是我太菜，想不到比较好的方法），因此最终使用了tf
【从问题中去学习k8s】k8s中的常见面试题（夯实理论基础）（十一）向往风的男子 k8s 学习 kubernetes 容器
本站以分享各种运维经验和运维所需要的技能为主《python零基础入门》：python零基础入门学习《python运维脚本》：python运维脚本实践《shell》：shell学习《terraform》持续更新中：terraform_Aws学习零基础入门到最佳实战《k8》从问题中去学习k8s《docker学习》暂未更新《ceph学习》ceph日常问题解决分享《日志收集》ELK+各种中间件《运维日常》
Awesome TensorFlow weixin_30594001 人工智能移动开发大数据
AwesomeTensorFlowAcuratedlistofawesomeTensorFlowexperiments,libraries,andprojects.Inspiredbyawesome-machine-learning.WhatisTensorFlow?TensorFlowisanopensourcesoftwarelibraryfornumericalcomputationusin
【ShuQiHere】小白也能懂的 TensorFlow 和 PyTorch GPU 配置教程 ShuQiHere tensorflow pytorch 人工智能
【ShuQiHere】在深度学习中，GPU的使用对于加速模型训练至关重要。然而，对于许多刚刚入门的小白来说，如何在TensorFlow和PyTorch中指定使用GPU进行训练可能会感到困惑。在本文中，我将详细介绍如何在这两个主流的深度学习框架中指定使用GPU进行训练，并确保每一个步骤都简单易懂，跟着我的步骤来，你也能轻松上手！1.安装所需库首先，确保你已经安装了TensorFlow或PyTorch
TensorFlow的基本概念以及使用场景张柏慈决策树
TensorFlow是一个机器学习平台，用于构建和训练机器学习模型。它使用图形表示计算任务，其中节点表示数学操作，边表示计算之间的数据流动。TensorFlow的主要特点包括：1.多平台支持：TensorFlow可以运行在多种硬件和操作系统上，包括CPU、GPU和移动设备。2.自动求导：TensorFlow可以自动计算模型参数的梯度，通过优化算法更新参数，以提高模型的准确性。3.分布式计算：Ten
解决ModuleNotFoundError: No module named ‘torch的方法梅菊林各种问题解决方案开发语言
ModuleNotFoundError:Nomodulenamed‘torch’错误是Python在尝试导入名为torch的模块时找不到该模块而抛出的异常。torch是PyTorch深度学习框架的核心库，如果你的Python环境中没有安装这个库，尝试导入时就会遇到这个错误。文章目录报错问题报错原因解决方法报错问题当你尝试在Python脚本或交互式环境中执行以下命令时：importtorch如果Py
NLP_jieba中文分词的常用模块 Hiweir · NLP_jieba的使用自然语言处理中文分词人工智能 nlp
1.jieba分词模式（1）精确模式:把句子最精确的切分开,比较适合文本分析.默认精确模式.（2）全模式:把句子中所有可能成词的词都扫描出来,cut_all=True,缺点:速度快,不能解决歧义（3）paddle:利用百度的paddlepaddle深度学习框架.简单来说就是使用百度提供的分词模型.use_paddle=True.（4）搜索引擎模式:在精确模式的基础上,对长词再进行切分,提高召回率,
大规模语言模型的书籍分享，从零基础入门到精通非常详细收藏我这一篇就够了黑客-雨语言模型人工智能自然语言处理学习大模型学习大模型入门大模型教程
在当今人工智能领域，大规模语言模型成为了研究和应用的热点之一。它们以其大规模的参数和强大的性能表现，推动着机器学习和深度学习技术的发展。对于GPT系列大规模语言模型的发展历程，有两点令人印象深刻。第一点是可拓展的训练架构与学习范式:Transformer架构能够拓展到百亿、千亿甚至万亿参数规模，并且将预训练任务统一为预测下一个词这一通用学习范式;第二点是对于数据质量与数据规模的重视:不同于BERT
基于VGG的猫狗识别卑微小鹿 tensorflow tensorflow
由于猫和狗的数据在这里，所以就做了一下分类的神经网络1、首先进行图像处理：importcsvimportglobimportosimportrandomos.environ['TF_CPP_MIN_LOG_LEVEL']='2'importtensorflowastffromtensorflowimportkerasfromtensorflow.kerasimportlayersimportnum
轻松升级：Ollama + OpenWebUI 安装与配置【AIStarter】 ai_xiaogui AI作画 AI软件人工智能 AI写作 AIStarter
Ollama是一个开源项目，用于构建和训练大规模语言模型，而OpenWebUI则提供了一个方便的前端界面来管理和监控这些模型。本文将指导你如何更新这两个工具，并顺利完成配置。准备工作确保你的系统已安装Git和Python环境。安装必要的依赖库，如TensorFlow或PyTorch等。更新步骤克隆项目：使用Git命令行工具克隆最新的Ollama和OpenWebUI仓库到本地。更新代码：确保你正在使
深度学习之基于Tensorflow卷积神经网络水果蔬菜分类识别系统 qq1744828575 python python plotly
欢迎大家点赞、收藏、关注、评论啦，由于篇幅有限，只展示了部分核心代码。文章目录一项目简介二、功能三、系统四.总结一项目简介一、项目背景与目标背景：在现代农业、智能零售等领域，自动化分类与识别技术对于提高效率、优化供应链管理具有重要意义。为了响应这一需求，本项目旨在构建一个基于深度学习技术的水果蔬菜分类识别系统。目标：构建一个准确率高、性能稳定的水果蔬菜分类识别模型，利用Tensorflow框架
DPDK基础入门（七）：网卡性能优化指针从不空 Linux高性能网络性能优化网络
DPDK的轮询模式运行在操作系统内核态的网卡驱动程序基本都是基于异步中断处理模式，而DPDK采用了轮询或者轮询混杂中断的模式来进行收包和发包。任何包进入到网卡，网卡硬件会进行必要的检查、计算、解析和过滤等，最终包会进入物理端口的某一个队列。物理端口上的每一个收包队列，都会有一个对应的由收包描述符组成的软件队列来进行硬件和软件的交互，以达到收包的目的。轮询模式DPDK的轮询驱动程序负责初始化好每一个
Linux基础入门 --10 DAY 安红豆. Linux学习 linux 运维服务器
文本常见处理工具文件内容查看命令cat格式：cat[OPTION]...[FILE]...常见选项：-E：显示行结束符-A：显示所有控制符-n：对显示出的每一行进行编号-b：对非空行进行编号-s：压缩连续的空行成一行范例：[root@localhost~]#cat-A-nmyasm.s1.section.text$2.global_start$3$4_start:$5^Imovr0,#1$6^Ia
Ollama全面指南：安装、使用与高级定制我就是全世界 ollama
本文全面介绍了Ollama工具，包括其安装、基本使用、高级定制以及实际应用案例。详细讲解了如何在不同操作系统上安装Ollama，如何运行和自定义大型语言模型，以及如何通过Ollama进行模型部署和交互。此外，还提供了丰富的故障排除和FAQ，帮助用户解决使用过程中的常见问题。文章目录Ollama基础入门Ollama简介支持的操作系统安装Ollama快速开始使用OllamaOllama的安装与配置ma
ASM系列四利用Method 组件动态注入方法逻辑 lijingyao8206 字节码技术 jvm AOP 动态代理 ASM
这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
java编程思想 --内部类百合不是茶 java 内部类匿名内部类
内部类;了解外部类并能与之通信内部类写出来的代码更加整洁与优雅 1,内部类的创建内部类是创建在类中的 package com.wj.InsideClass; /* * 内部类的创建 */ public class CreateInsideClass { public CreateInsideClass(
web.xml报错 crabdave web.xml
web.xml报错 The content of element type "web-app" must match "(icon?,display- name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
泛型类的自定义麦田的设计者 java android 泛型
为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。采用泛型类，完成扩展。例如有一个学生类 Student{ Student(){ System.out.println("I'm a student....."); } } 有一个老师类
CSS清除浮动的4中方法 IT独行者 JavaScript UI css
清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。 1、结尾处加空div标签 clear:both 1 2 3 4 .div 1 { background : #000080 ; border : 1px s
Cygwin使用windows的jdk 配置方法 _wy_ jdk windows cygwin
1.[vim /etc/profile] JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43" (windows下jdk路径为D:\Java\jdk1.6.0_43) PATH="$JAVA_HOME/bin:${PATH}" CLAS
linux下安装maven 无量 maven linux 安装
Linux下安装maven(转) 1.首先到Maven官网下载安装文件，目前最新版本为3.0.3，下载文件为 apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令； 2.进入下载文件夹，找到下载的文件，运行如下命令解压 tar -xvf apache-maven-2.2.1-bin.tar.gz 解压后的文件夹
tomcat的https 配置,syslog-ng配置 aichenglong tomcat http跳转到https syslong-ng配置 syslog配置
1) tomcat配置https,以及http自动跳转到https的配置 1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令) keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
关于领号活动总结 alafqq 活动
关于某彩票活动的总结具体需求，每个用户进活动页面，领取一个号码，1000中的一个；活动要求 1，随机性，一定要有随机性； 2，最少中奖概率，如果注数为3200注，则最多中4注 3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）； 4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库）解决方案 1，事先产生随机数1000个，并打
java数据结构冒泡排序的遍历与排序百合不是茶 java
java的冒泡排序是一种简单的排序规则冒泡排序的原理：比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个，此后一样；针对所有的元素重复以上的步骤，除了最后一个例题；将int array[]
JS检查输入框输入的是否是数字的一种校验方法 bijian1013 js
如下是JS检查输入框输入的是否是数字的一种校验方法： <form method=post target="_blank"> 数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br> </form>
Test注解的两个属性：expected和timeout bijian1013 java JUnit expected timeout
JUnit4：Test文档中的解释：　　The Test annotation supports two optional parameters. 　　The first, expected, declares that a test method should throw an exception. 　　If it doesn't throw an exception or if it
[Gson二]继承关系的POJO的反序列化 bit1129 POJO
父类 package inheritance.test2; import java.util.Map; public class Model { private String field1; private String field2; private Map<String, String> infoMap
【Spark八十四】Spark零碎知识点记录 bit1129 spark
1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的 ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中
WAS各种脚本作用大全 ronin47 WAS 脚本
　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html 　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下　　　获取下载这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句 bylijinnan switch
借鉴网上的思路，用java实现： public class NoIfWhile { /** * @param args * * find x=1+2+3+....n */ public static void main(String[] args) { int n=10; int re=find(n); System.o
Netty源码学习-ObjectEncoder和ObjectDecoder bylijinnan java netty
Netty中传递对象的思路很直观： Netty中数据的传递是基于ChannelBuffer（也就是byte[]）；那把对象序列化为字节流，就可以在Netty中传递对象了相应的从ChannelBuffer恢复对象，就是反序列化的过程 Netty已经封装好ObjectEncoder和ObjectDecoder 先看ObjectEncoder ObjectEncoder是往外发送
spring 定时任务中cronExpression表达式含义 chicony cronExpression
一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示：代表含义是否必须允许的取值范围 &nb
Nutz配置Jndi ctrain JNDI
1、使用JNDI获取指定资源： var ioc = { dao : { type :"org.nutz.dao.impl.NutDao", args : [ {jndi :"jdbc/dataSource"} ] } } 以上方法,仅需要在容器中配置好数据源,注入到NutDao即可.
解决 /bin/sh^M: bad interpreter: No such file or directory daizj shell
在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。解决： 1）在windows下转换：利用一些编辑器如UltraEdit或EditPlus等工具
[转]for 循环为何可恨？ dcj3sjt126com 程序员读书
Java的闭包(Closure)特征最近成为了一个热门话题。一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。尤其是他问道“for 循环为何可恨？”[http://ju
Android实用小技巧 dcj3sjt126com android
1、去掉所有Activity界面的标题栏　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar" 2、去掉所有Activity界面的TitleBar 和StatusBar 　　修改AndroidManifes
Oracle 复习笔记之序列 eksliang Oracle 序列 sequence Oracle sequence
转载请出自出处：http://eksliang.iteye.com/blog/2098859 1.序列的作用序列是用于生成唯一、连续序号的对象一般用序列来充当数据库表的主键值 2.创建序列语法如下： create sequence s_emp start with 1 --开始值 increment by 1 --増长值 maxval
有“品”的程序员 gongmeitao 工作
完美程序员的10种品质　　完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质：　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强（范围：用简单方式解决复杂问题）　　
使用KeleyiSQLHelper类进行分页查询 hvt sql .net C#asp.net hovertree
本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
SVG 教程（三）圆形，椭圆，直线天梯梦 svg
SVG <circle> SVG 圆形 - <circle> <circle> 标签可用来创建一个圆：下面是SVG代码： <svg xmlns="http://www.w3.org/2000/svg" version="1.1"> <circle cx="100" c
链表栈 luyulong java 数据结构
public class Node { private Object object; private Node next; public Node() { this.next = null; this.object = null; } public Object getObject() { return object; } public
基础数据结构和算法十：2-3 search tree sunwinner Algorithm 2-3 search tree
Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
spring配置定时任务 stunizhengjia spring timer
最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到： //------------------------定时任务调用的方法------------------------------ /** * 存储过程定时器 */ publi
ITeye 8月技术图书有奖试读获奖名单公布 ITeye管理员活动
ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 8月试读活动回顾： http://webmaster.iteye.com/blog/2102830 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）：《跨终端Web》 gleams：http