TensorFlow程式碼實現（一）[MNIST手寫數字識別]

阿新 • • 發佈：2019-01-04

最簡單的神經網路結構：

資料來源準備：資料在之前的文章中分析過了
在這裡我們就構造一層神經網路：
- 前提準備：
  - 引數：
    - train images：因為圖片是28*28的個數，換算成一維陣列就是784，因此我們定義x = tf.placeholder(tf.float32,[None,784])
    - train labels：因為圖片最終要輸出10個分類，所以我們定義為y_ = tf.placeholder(tf.float32,[None,10])
    - weight：因為我們需要將輸入的784轉換成輸出對的10，因此我們將權重定義為W = tf.Variable(tf.zeros([784,10]))
    - biases：因為我們分類後的結果是10類，所以我們將偏差定義為b = tf.Variable(tf.zeros([10]))
    - 成本函式：我們使用交叉熵：cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=tf.log(y),labels=y_))
    - 預測值：我們將預測值，也就是輸出通過softmax函式進行處理後輸出，因此：y = tf.nn.softmax(tf.matmul(x,W)+b)
- 流程：

程式碼實現：

import tensorflow as tf
import data.input 
_data as input_data
mnist = input_data.read_data_sets("MNIST_data",one_hot=True)
x = tf.placeholder(tf.float32, [None,784])
y_ = tf.placeholder(tf.float32,[None,10])
W = tf.Variable(tf.zeros([784,10]))
b = tf.Variable(tf.zeros([10]))
y = tf.nn.softmax(tf.matmul(x, W)+b)

cross_entropy = tf.reduce_mean(tf.nn 
.softmax_cross_entropy_with_logits(labels=y_, logits=tf.log(y)))
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
init = tf.global_variables_initializer()
sess = tf.InteractiveSession()
sess.run(init)
for i in range(1000):
    batch_x,batch_y = mnist.train.next_batch(100)
    sess.run(train_step,feed_dict={x:batch_x,y_:batch_y})
correct_prediction = tf.equal(tf.arg_max(y, 1),tf.arg_max(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float"))
print(sess.run(accuracy,feed_dict = {x:mnist.test.images,y_:mnist.test.labels}))
sess.close()

CNN

流程如下：
- Layer1：
  input【28x28x1】->conv【5x5，(1:32)】->relu【28x28x32】->max_pool【2x2，14x14x32】->dropout【0.75】
- Layer2：
  【14x14x32】->conv【5x5，(32:64)】->relu【14x14x64】->max_pool【2x2，7x7x64】->dropout【0.75】
- Layer3：
【7x7x64】->FC【1024】->relu->dropout->y = wx+b【10】

2
程式碼如下：

import tensorflow as tf
import data.input_data as input_data
from numpy import outer
mnist = input_data.read_data_sets("MNIST/",one_hot=True)
#Parameters
learning_rate = 0.001
training_iters = 100000
batch_size = 128
display_step = 10
#Network Parameters
n_input = 784#MNIST data input(image shape = [28,28])
n_classes = 10#MNIST total classes (0-9digits)
dropout = 0.75# probability to keep units

#tf Graph input
x = tf.placeholder(tf.float32,[None,n_input])
y = tf.placeholder(tf.float32,[None,n_classes])
keep_prob = tf.placeholder(tf.float32)#drop(keep probability)

#Create model
def conv2d(image,w,b):
    return tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(image,w,strides=[1,1,1,1],padding='SAME'),b))
def max_pooling(image,k):
    return tf.nn.max_pool(image, ksize=[1,k,k,1], strides=[1,k,k,1], padding='SAME')

weights = {
    'wc1':tf.Variable(tf.random_normal([5,5,1,32])),
    'wc2':tf.Variable(tf.random_normal([5,5,32,64])),
    'wd1':tf.Variable(tf.random_normal([7*7*64,1024])),
    'out':tf.Variable(tf.random_normal([1024,n_classes]))
}
biases = {
    'bc1':tf.Variable(tf.random_normal([32])),
    'bc2':tf.Variable(tf.random_normal([64])),
    'bd1':tf.Variable(tf.random_normal([1024])),
    'out':tf.Variable(tf.random_normal([n_classes]))
}
def conv_net(_X,_weights,_biases,_dropout):
    #Layer 1
    _X = tf.reshape(_X,[-1,28,28,1])
    conv1 = conv2d(_X,_weights['wc1'],_biases['bc1'])
    conv1 = max_pooling(conv1, k = 2)
    conv1 = tf.nn.dropout(conv1, keep_prob=_dropout)
    #Layer 2
    conv2 = conv2d(conv1,_weights['wc2'],_biases['bc2'])
    conv2 = max_pooling(conv2, k=2)
    conv2 = tf.nn.dropout(conv2,keep_prob=_dropout)
    #Fully Connected
    dense1 = tf.reshape(conv2,[-1,_weights['wd1'].get_shape().as_list()[0]])
    dense1 = tf.nn.relu(tf.add(tf.matmul(dense1,_weights['wd1']),_biases['bd1']))
    dense1 = tf.nn.dropout(dense1,_dropout)
    out = tf.add(tf.matmul(dense1,_weights['out']),_biases['out'])
    print(out)
    return out
#Construct model
pred = conv_net(x, weights, biases, keep_prob)
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=pred))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

#Evaluate model
correct_pred = tf.equal(tf.argmax(pred,1),tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred,tf.float32))
init = tf.initialize_all_variables()

with tf.Session() as sess:
    sess.run(init)
    step = 1
    while step * batch_size<training_iters:
        batch_xs,batch_ys = mnist.train.next_batch(batch_size)
        sess.run(optimizer,feed_dict = {x:batch_xs,y:batch_ys,keep_prob:dropout})
        if step %display_step==0:
            acc = sess.run(accuracy,feed_dict={x:batch_xs,y:batch_ys,keep_prob:1.})
            loss = sess.run(cost, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})
            print("Iter " + str(step*batch_size) + ", Minibatch Loss= " + "{:.6f}".format(loss) + ", Training Accuracy= " + "{:.5f}".format(acc))

        step += 1
    print("Optimization Finished!")
    print("Testing Accuracy:",sess.run(accuracy,feed_dict={x: mnist.test.images[:256], y: mnist.test.labels[:256], keep_prob: 1.}))

修改後的CNN

流程如下：
- 卷積的流程：conv->max_pool->norm->dropout
- 總流程：卷積層1->卷積層2->卷積層3->卷積層4->全連線層->全連線層->輸出:softmax
- shape的變化：[28x28x1]->[14x14x64]->[7x7x128]->[4x4x256]->[2x2x512]->[1024]->[1024]->[10]
程式碼如下：

import data.input_data as input_data
mnist = input_data.read_data_sets("MNIST/", one_hot=True)

import tensorflow as tf

# Parameters
learning_rate = 0.001
training_iters = 200000
batch_size = 64
display_step = 20

# Network Parameters
n_input = 784 # MNIST data input (img shape: 28*28)
n_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.8 # Dropout, probability to keep units

# tf Graph input
x = tf.placeholder(tf.float32, [None, n_input])
y = tf.placeholder(tf.float32, [None, n_classes])
keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)

# Create custom model
def conv2d(name, l_input, w, b):
    return tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(l_input,w,strides=[1,1,1,1],padding='SAME'),b),name = name)
def max_pool(name, l_input, k):
    return tf.nn.max_pool(l_input,ksize=[1,k,k,1],strides=[1,k,k,1],padding='SAME',name=name)

def norm(name, l_input, lsize=4):
    return tf.nn.lrn(l_input,lsize,bias=1.0,alpha=0.001/9.0,beta=0.75,name=name)
def customnet(_X, _weights, _biases, _dropout):
    # Reshape input picture
    _X = tf.reshape(_X,shape=[-1,28,28,1])
    # Convolution Layer
    conv1 = conv2d('conv1',_X,_weights['wc1'],_biases['bc1'])
    # Max Pooling (down-sampling)
    pool1 = max_pool('conv1',conv1,k=2)
    # Apply Normalization
    norm1 = norm('conv1',pool1,lsize=4)
    # Apply Dropout
    norm = tf.nn.dropout(norm1, _dropout)
    # Convolution Layer
    conv2 = conv2d('conv2',norm1,_weights['wc2'],_biases['bc2'])
    pool2 = max_pool('conv2', conv2, k=2)
    norm2 = norm('conv2',pool2,lsize=4)
    norm2 = tf.nn.dropout(norm2,_dropout)
    # Convolution Layer
    conv3 = conv2d('conv3',norm2,_weights['wc3'],_biases['bc3'])
    # Max Pooling (down-sampling)
    pool3 = max_pool('conv3', conv3, k=2)
    # Apply Normalization
    norm3 = norm('norm3',pool3,lsize = 4)
    # Apply Dropout
    norm3 = tf.nn.dropout(norm3, _dropout)
    #conv4
    conv4 = conv2d('conv4',norm3,_weights['wc4'],_biases['bc4'])
    # Max Pooling (down-sampling)
    pool4 = max_pool('pool4', conv4, k=2)
    # Apply Normalization
    norm4 = norm('norm4',pool4,lsize=4)
    # Apply Dropout
    norm4 = tf.nn.dropout(norm4,_dropout)
    # Fully connected layer
    dense1 = tf.reshape(norm4,[-1,_weights['wd1'].get_shape().as_list()[0]])
    dense1 = tf.nn.relu(tf.matmul(dense1,_weights['wd1'])+_biases['bd1'],name='fc1')
    dense2 = tf.nn.relu(tf.matmul(dense1,_weights['wd2'])+_biases['bd2'],name='fc2')
    # Output, class prediction
    out = tf.matmul(dense2,_weights['out'])+_biases['out']
# Store layers weight & bias
weights = {
    'wc1': tf.Variable(tf.random_normal([5, 5, 1, 64])),
    'wc2': tf.Variable(tf.random_normal([5, 5, 64, 128])),
    'wc3': tf.Variable(tf.random_normal([3, 3, 128, 256])),
    'wc4': tf.Variable(tf.random_normal([2, 2, 256, 512])),
    'wd1': tf.Variable(tf.random_normal([2*2*512, 1024])), 
    'wd2': tf.Variable(tf.random_normal([1024, 1024])),
    'out': tf.Variable(tf.random_normal([1024, 10]))
}
biases = {
    'bc1': tf.Variable(tf.random_normal([64])),
    'bc2': tf.Variable(tf.random_normal([128])),
    'bc3': tf.Variable(tf.random_normal([256])),
    'bc4': tf.Variable(tf.random_normal([512])),
    'bd1': tf.Variable(tf.random_normal([1024])),
    'bd2': tf.Variable(tf.random_normal([1024])),
    'out': tf.Variable(tf.random_normal([n_classes]))
}

# Construct model
pred = customnet(x, weights, biases, keep_prob)

# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=pred))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

# Evaluate model
correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initializing the variables
init = tf.initialize_all_variables()

# Launch the graph
with tf.Session() as sess:
    sess.run(init)
    step = 1
    # Keep training until reach max iterations
    while step * batch_size < training_iters:
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        # Fit training using batch data
        sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys, keep_prob: dropout})
        if step % display_step == 0:
            # Calculate batch accuracy
            acc = sess.run(accuracy, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})
            # Calculate batch loss
            loss = sess.run(cost, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})
            print ("Iter " + str(step*batch_size) + ", Minibatch Loss= " + "{:.6f}".format(loss) + ", Training Accuracy= " + "{:.5f}".format(acc))
        step += 1
    print ("Optimization Finished!")
    # Calculate accuracy for 256 mnist test images
    print ("Testing Accuracy:", sess.run(accuracy, feed_dict={x: mnist.test.images[:256], y: mnist.test.labels[:256], keep_prob: 1.}))

DNN

DNN與CNN的本質差不多，只不過CNN加上了卷積層C以及池化層。做了卷積操作，引數共享減少了網路之間的連線引數。

DNN就是去掉C之後，使用全連線層+dropout下降+relu啟用，一層一層的WX+B的網路模式。
1. 流程：
兩層全連線（y = wx+b）
2. 程式碼實現：

'''
@author: smile
'''
import tensorflow as tf
import data.input_data as input_data
mnist = input_data.read_data_sets("MNIST/",one_hot=True)
#Paramters
learning_rate = 0.001
training_iters = 100000
batch_size = 128
display_step = 10

#Network parameters
n_input = 784
n_classes = 10
dropout = 0.8
#tf Graph input
x = tf.placeholder(tf.float32,[None,n_input])
y = tf.placeholder(tf.float32,[None,n_classes])
keep_prob = tf.placeholder(tf.float32)
#Create model
def conv2d(image,w,b):
    return tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(image,w,strides=[1,1,1,1],padding='SAME'),b))
def max_pool(image,k):
    return tf.nn.max_pool(image,ksize=[1,k,k,1],strides=[1,k,k,1],padding='SAME')

def dnn(_X,_weights,_biases,_dropout):
    _X = tf.nn.dropout(_X,_dropout)
    d1 = tf.nn.relu(tf.nn.bias_add(tf.matmul(_X, _weights['wd1']),_biases['bd1']),name='d1')
    d2x = tf.nn.dropout(d1,_dropout)
    d2 = tf.nn.relu(tf.nn.bias_add(tf.matmul(d2x,_weights['wd2']),_biases['bd2']),name='d2')
    dout = tf.nn.dropout(d2,_dropout)
    out = tf.matmul(dout,weights['out'])+_biases['out']
    return out
weights = {
    'wd1':tf.Variable(tf.random_normal([784,600],stddev=0.01)),
    'wd2':tf.Variable(tf.random_normal([600,480],stddev=0.01)),
    'out':tf.Variable(tf.random_normal([480,10]))
}
biases = {
    'bd1':tf.Variable(tf.random_normal([600])),
    'bd2':tf.Variable(tf.random_normal([480])),
    'out':tf.Variable(tf.random_normal([10])),
}
#Construct model
pred = dnn(x, weights, biases, keep_prob)

#Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=pred))
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)
#Evaluate model
correct_pred = tf.equal(tf.argmax(pred,1),tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred,tf.float32))

init = tf.initialize_all_variables()

with tf.Session() as sess:
    sess.run(init)
    step = 1
    while step * batch_size < training_iters:
        batch_xs,batch_ys = mnist.train.next_batch(batch_size)
        sess.run(optimizer,feed_dict={x:batch_xs,y:batch_ys,keep_prob:dropout})
        if step % display_step == 0:
            acc = sess.run(accuracy,feed_dict={x:batch_xs,y:batch_ys,keep_prob:1.})
            loss = sess.run(cost,feed_dict = {x:batch_xs,y:batch_ys,keep_prob:1.})
            print("Iter "+str(step*batch_size)+",Minibatch Loss = "+"{:.6f}".format(loss)+", Training Accuracy = "+"{:.5f}".format(acc))
        step += 1
    print("Optimization Finished!")
    print("Testing Accuarcy : ",sess.run(accuracy,feed_dict={x:mnist.test.images[:256],y:mnist.test.labels[:256]}))

ANN

'''
@author: smile
'''
import tensorflow as tf
import data.input_data as input_data
from pyexpat import features
mnist = input_data.read_data_sets("MNIST_data/",one_hot=True)
learning_rate = 0.001
training_epochs = 15
batch_size = 100
display_step = 1
#NetWork parameters
n_hidden_1 = 256#1st layer num features
n_hidden_2 = 256#2nd layer num features
n_input = 784
n_classses = 10

x = tf.placeholder("float", [None,n_input])
y = tf.placeholder("float",[None,n_classses])

def multilayer_perceptron(_X,_weights,_biases):
    layer1 = tf.nn.sigmoid(tf.add(tf.matmul(_X, _weights['h1']), _biases['b1']))
    layer2 = tf.nn.relu(tf.add(tf.matmul(layer1,_weights['h2']),_biases['b2']))
    return tf.matmul(layer2,_weights['out'])+_biases['out']

weights = {
    'h1':tf.Variable(tf.random_normal([n_input,n_hidden_1])),
    'h2':tf.Variable(tf.random_normal([n_hidden_1,n_hidden_2])),
    'out':tf.Variable(tf.random_normal([n_hidden_2,n_classses]))
}
biases = {
    'b1':tf.Variable(tf.random_normal([n_hidden_1])),
    'b2':tf.Variable(tf.random_normal([n_hidden_2])),
    'out':tf.Variable(tf.random_normal([n_classses]))
}
pred = multilayer_perceptron(x, weights, biases)
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=pred))

optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
init = tf.initialize_all_variables()

with tf.Session() as sess:
    sess.run(init)
    #Training cycle
    for epoch in range(training_epochs):
        avg_cost = 0.
        total_batch = int(mnist.train._num_examples/batch_size)
        for i in range(total_batch):
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys})
            avg_cost += sess.run(cost, feed_dict={x: batch_xs, y: batch_ys})/total_batch
        if epoch % display_step == 0:
            print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))
    print("Optimization Finished!")
    correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
    # Calculate accuracy
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    print("Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))

RNN

import data.input_data as input_data
from src.MNIST_ANN import pred, cost
mnist = input_data.read_data_sets("MNIST_data",one_hot=True)
import tensorflow as tf
import numpy as np
from tensorflow.contrib import rnn

"""
To classify images using a rnn,we consider every image row as a sequence of pixels
becaues MNIST image shape is 28*28px,we will then handle 28 sequences of 28 steps for every sample
"""
#Parameters
learning_rate = 0.001
training_iters = 100000
batch_size = 128
display_step = 10

#Network parameters
n_input = 28
n_steps = 28
n_hidden = 128#hidden layer num
n_classes = 10

#tf Graph input
x = tf.placeholder("float",[None,n_steps,n_input])
#Tensorflow LSTM cell requires 2xn_hidden length(state&cell)
istate = tf.placeholder("float",[None,2*n_hidden])
#output
y = tf.placeholder("float",[None,n_classes])
#random initialize biases and weights
weights = {
    "hidden":tf.Variable(tf.random_normal([n_input,n_hidden])),
    "out":tf.Variable(tf.random_normal([n_hidden,n_classes]))
}
biases = {
    "hidden":tf.Variable(tf.random_normal([n_hidden])),
    "out":tf.Variable(tf.random_normal([n_classes]))
}
#RNN
def RNN(_X,_istate,_weights,_biases):
    _X = tf.transpose(_X,[1,0,2])
    _X = tf.reshape(_X,[-1,n_input])
    #input Layer to hidden Layer
    _X = tf.matmul(_X,_weights['hidden'])+_biases['hidden']
    #LSTM cell
    lstm_cell = rnn.BasicLSTMCell(n_hidden,state_is_tuple=False)
    #28 sequence need to splite 28 time
    _X = tf.split(_X,n_steps,0)
    #start to run rnn
    outputs,states = rnn.static_rnn(lstm_cell,_X,initial_state = _istate)
    return tf.matmul(outputs[-1],weights['out'])+biases['out']

pred = RNN(x,istate,weights,biases)
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels = y))
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)

correct_pred = tf.equal(tf.argmax(pred,1),tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred,tf.float32))

init = tf.initialize_all_variables()
with tf.Session() as sess:
    sess.run(init)
    step = 1
    while step * batch_size < training_iters:
        batch_xs,batch_ys = mnist.train.next_batch(batch_size)
        batch_xs = batch_xs.reshape((batch_size,n_steps,n_input))
        sess.run(optimizer,feed_dict={x:batch_xs,y:batch_ys,
                                      istate:np.zeros((batch_size,2*n_hidden))})
        if step % display_step == 0:
            acc = sess.run(accuracy, feed_dict={x: batch_xs, y: batch_ys,  
                                                istate: np.zeros((batch_size, 2 * n_hidden))})  
            # Calculate batch loss  
            loss = sess.run(cost, feed_dict={x: batch_xs, y: batch_ys,  
                                             istate: np.zeros((batch_size, 2 * n_hidden))})  
            print("Iter " + str(step * batch_size) + ", Minibatch Loss= " + "{:.6f}".format(loss) + ", Training Accuracy= " + "{:.5f}".format(acc))
        step += 1  
    print ("Optimization Finished!")  
    test_len = 256
    test_data = mnist.test.images[:test_len].reshape((-1,n_steps,n_input))
    test_label = mnist.test.labels[:test_len]
    print ("Testing Accuracy:", sess.run(accuracy, feed_dict={x: test_data, y: test_label,  
                                                             istate: np.zeros((test_len, 2 * n_hidden))}))

TensorFlow程式碼實現（一）[MNIST手寫數字識別]

最簡單的神經網路結構：資料來源準備：資料在之前的文章中分析過了在這裡我們就構造一層神經網路：前提準備：引數： train images：因為圖片是28*28的個數，換算成一維陣列就是784，因此我們定義x = tf.placeholder(tf

Pytorch 快速入門（六）MNIST 手寫數字識別之CNN

接觸過深度學習的朋友對MNIST資料集肯定不陌生。基本上算是玩神經網路裡的“hello,world！”本節基於MNIST資料集，實現CNN學習過程。下面是一個 CNN 最後一層的學習過程, 我們先視覺化看看:MNIST手寫資料首先是資料集下載，為了看看資料集裡究竟是長什麼樣

TensorFlow學習筆記（1）—— MNIST手寫識別

1、初步學習資料處理 xs：60000張圖片，28*28大小，將所有畫素點按一列排列，資料集變為了[60000, 784]的二維矩陣。 ys：60000張圖片，每個圖片有一個標籤標識圖片中數字，採用one-hot向量，資料集變為[60000, 10]的二維矩陣。 softm

Tensorflow深度學習筆記（二）--BPNN手寫數字識別視覺化

資料集：MNIST 啟用函式：Relu 損失函式：交叉熵 Optimizer：AdamOptimizer 視覺化工具：tensorboad 迭代21epoch，accuracy結果如下： Iter 16,Testing Accuracy:

深度學習之PyTorch實戰（3）——實戰手寫數字識別

　　上一節，我們已經學會了基於PyTorch深度學習框架高效，快捷的搭建一個神經網路，並對模型進行訓練和對引數進行優化的方法，接下來讓我們牛刀小試，基於PyTorch框架使用神經網路來解決一個關於手寫數字識別的計算機視覺問題，評價我們搭建的模型的標準是它是否能準確的對手寫數字圖片進行識別。　　

pytorch 入門（二） cnn 手寫數字識別

import torch import torch.nn as nn import torchvision.datasets as normal_datasets import torchvision.transforms as transforms from

Tensorflow案例5：CNN演算法-Mnist手寫數字識別

學習目標目標應用tf.nn.conv2d實現卷積計算應用tf.nn.relu實現啟用函式計算應用tf.nn.max_pool實現池化層的計算應用卷積神經網路實現影象分類識別應用

基於k近鄰（KNN）的手寫數字識別

作者：faaronzheng 轉載請註明出處！最近再看Machine Learning in Action. k近鄰演算法這一章節提供了不少例子，本著Talk is cheap的原則，我們用手寫數字識別來實際測試一下。簡單的介紹一下k近鄰演算法（KNN）：給定測試樣本

TensorFlow——Mnist手寫數字識別並可視化實戰教程（一）

要點：該教程為深度學習tensorflow框架mnist手寫數字識別。實戰教程分為（一）（二）（三）分別從tensorflow和MATLAB雙角度來實現。筆者資訊：Next_Legend Q

Tensorflow之MNIST手寫數字識別：分類問題（1）

一、MNIST資料集讀取 one hot 獨熱編碼獨熱編碼是一種稀疏向量，其中：一個向量設為1，其他元素均設為0.獨熱編碼常用於表示擁有有限個可能值的字串或識別符號優點： 1、將離散特徵的取值擴充套件到了歐式空間，離散特徵的某個取值就對應歐式空間的某個點　　　　2、機器學習演算法中，

Tensorflow之MNIST手寫數字識別：分類問題（2）

整體程式碼： #資料讀取 import tensorflow as tf import matplotlib.pyplot as plt import numpy as np from tensorflow.examples.tutorials.mnist import input_data mnis

TensorFlow筆記（1）非線性迴歸、MNIST手寫數字識別

程式 import tensorflow as tf import numpy as np import matplotlib.pyplot as plt # numpy生成200個隨機點，下面這麼寫可以得到200行1列的矩陣 x_data = np.linspace(-0.5,

Java常用的八種排序演算法與程式碼實現（一）：氣泡排序法、插入排序法、選擇排序法

這三種排序演算法適合小規模資料排序－－－　　共同點：基於比較，時間複雜度均為O(n2)，空間複雜度均為O(1)（原地排序演算法）　　不同點：插入排序和氣泡排序是穩定的排序演算法，選擇排序不是－－－　　穩定排序演算法：可以保持數值相等的兩個物件，在排序之

機器學習：資訊熵，基尼係數，條件熵，條件基尼係數，資訊增益，資訊增益比，基尼增益，決策樹程式碼實現（一）

文章目錄初始化，涉及到使用的變數：資訊熵定義公式，經驗公式程式碼：基尼係數定義公式，經驗公式程式碼：條件熵，條件基尼係數條件熵定義公式，經驗公式

基於tensorflow的MNIST手寫數字識別（二）--入門篇

一、本文的意義因為谷歌官方其實已經寫了MNIST入門和深入兩篇教程了，那我寫這些文章又是為什麼呢，只是抄襲？那倒並不是，更準確的說應該是筆記吧，然後用更通俗的語言來解釋，並且補充

搶紅包案例分析以及程式碼實現（一）侵立刪

轉自：https://mp.weixin.qq.com/s/d3HyAtWua38TSpelF-v6nQ 概述電商的秒殺、搶購，春運搶票，微信QQ搶紅包，從技術的角度來說，這對於Web 系統是一個很大的考驗. 高併發場景下，系統的優化和穩定是至關重要的. 網際網路的開

HBase基本程式碼實現（一）

Step 1: 載入設定 HConnection hTablePool = null; static Configuration conf =null; public HB

ActiveMQ解決分散式事務方案以及程式碼實現（一）

1.場景描述可以設想一個比較常見的分散式事務場景，商品上架操作，該操作涉及到商品模組的Service服務中的上架操作，同時必須要滿足在solr中建立商品的索引方便前臺搜尋以及生成商品的靜態化頁面，在上架操作中傳送了一條訊息，訊息接收方搜尋工程以及靜態化工程分

TensorFlow程式碼實現（二）[實現異或門（XOR）]

第一個實驗：用神經網路實現異或門測試資料如下： [0,0]->[0] [1,0]->[1] [1,1]->[0] [0,1]->[1] 資料量很小，但異或門遠沒有我想象的好寫，原來在第一層的時候我使用的啟用函式是relu，第

MNIST 手寫數字識別（一）

MNIST 手寫數字識別模型建立與優化本篇的主要內容有： TensorFlow 處理MNIST資料集的基本操作建立一個基礎的識別模型介紹 SoftmaxSoftmaxSoftmax迴歸以及交叉熵等 MNIST是一個很有名的手寫數字識別資料集（基本可以算

TensorFlow程式碼實現（一）[MNIST手寫數字識別]

最簡單的神經網路結構：

CNN

【7x7x64】->FC【1024】->relu->dropout->y = wx+b【10】

修改後的CNN

DNN

ANN

RNN

相關推薦