這裡我們採用cifar10作為我們的實驗資料庫。
首先下載TensorFlow Models庫，以便使用其中提供的CIFAR-10資料的類。

git clone https://github.com/tensorflow/models.git
cd models/tutorials/image/cifar10

下面開始構建CNN網路

import cifar10
import cifar10_input
import tensorflow as tf
import numpy as np
import time

max_steps = 3000  # 訓練輪數（每一輪一個batch參與訓練）
batch_size = 128
 
  # batch 大小
data_dir = '/tmp/cifar10_data/cifar-10-batches-bin'  # 資料目錄

# 權重初始化函式
# shape：卷積核引數，格式類似於[5,5,3,32]，代表卷積核尺寸（前兩個數字），通道數和卷積核個數
# stddev：標準差
# wl：L2正則化的權值引數
# 返回帶有L2正則的初始化的權重引數


def variable_with_weight_loss(shape, stddev, wl):
    var = tf.Variable(tf.truncated_normal(shape, stddev=stddev))
    # 截斷產生正態分佈，就是說產生正態分佈的值如果與均值的差值大於兩倍的標準差，
 

    # 那就重新生成。和一般的正太分佈的產生隨機資料比起來，這個函式產生的隨機數
    # 與均值的差距不會超過兩倍的標準差
    if wl is not None:
        weight_loss = tf.multiply(tf.nn.l2_loss(var), wl, name='weight_loss')
        # 給權重W加上L2正則，並用wl引數控制L2 loss的大小
        tf.add_to_collection('losses', weight_loss)
        # 將weight loss存在一個名為‘losses’的collection裡，後面會用到
 

    return var

# loss計算函式
# logits：未經softmax處理過的CNN的原始輸出
# labels：樣本標籤
# 輸出：總體loss值


def loss(logits, labels):

    labels = tf.cast(labels, tf.int64)  # 型別轉換為tf.int64
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
        logits=logits, labels=labels, name='cross_entropy_per_example')
    # 計算結合softmax的交叉熵（即對logits進行softmax處理，由於softmax與cross_entropy經常一起用，
    # 所以TensorFlow把他們整合到一起了），算是一個標準正規化
    cross_entropy_mean = tf.reduce_mean(cross_entropy, name='cross_entropy')
    # 計算一個batch中交叉熵的均值
    tf.add_to_collection('losses', cross_entropy_mean)
    # 將交叉熵存在名為‘losses’的collection裡

    return tf.add_n(tf.get_collection('losses'), name='total_loss')
    # 返回total loss，total loss包括交叉熵和上面提到的weight loss


cifar10.maybe_download_and_extract()  # 下載資料集，並解壓到預設位置


images_train, labels_train = cifar10_input.distorted_inputs(data_dir=data_dir,
                                                            batch_size=batch_size)
# 產生訓練需要的資料，每次執行都會生成一個batch_size的數量的樣本（這裡進行了樣本擴張）

images_test, labels_test = cifar10_input.inputs(eval_data=True,
                                                data_dir=data_dir,
                                                batch_size=batch_size)
# 產生訓練需要的測試資料，每次執行都會生成一個batch_size的數量的測試樣本

image_holder = tf.placeholder(tf.float32, [batch_size, 24, 24, 3])
label_holder = tf.placeholder(tf.int32, [batch_size])
# 建立輸入資料的placeholder（相當於佔位符）

weight1 = variable_with_weight_loss(shape=[5, 5, 3, 64], stddev=5e-2, wl=0.0)
# 第一層權重初始化，產生64個3通道（RGB圖片），尺寸為5*5的卷積核，不帶L2正則（wl=0.0）
kernel1 = tf.nn.conv2d(image_holder, weight1, [1, 1, 1, 1], padding='SAME')
# 對輸入原始影象進行卷積操作，步長為[1, 1, 1, 1]，即將每一個畫素點都計算到，
# 補零模式為'SAME'（不夠卷積核大小的塊就補充0）
bias1 = tf.Variable(tf.constant(0.0, shape=[64]))
# 定義第一層的偏置引數，由於有64個卷積核，這裡有偏置尺寸為shape=[64]
conv1 = tf.nn.relu(tf.nn.bias_add(kernel1, bias1))
# 卷積結果加偏置後採用relu啟用
pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
                       padding='SAME')
# 第一層的池化操作，使用尺寸為3*3，步長為2*2的池化層進行操作
# 這裡的ksize和strides第一個和第四個數字一般都為1
norm1 = tf.nn.lrn(pool1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)
# 用LRN對結果進行處理，使得比較大的值變得更大，比較小的值變得更小，模仿神經系統的側抑制機制

# 這一部分和上面基本相同，不加贅述
weight2 = variable_with_weight_loss(shape=[5, 5, 64, 64], stddev=5e-2, wl=0.0)
kernel2 = tf.nn.conv2d(norm1, weight2, [1, 1, 1, 1], padding='SAME')
bias2 = tf.Variable(tf.constant(0.1, shape=[64]))
conv2 = tf.nn.relu(tf.nn.bias_add(kernel2, bias2))
norm2 = tf.nn.lrn(conv2, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)
pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
                       padding='SAME')

# 這裡定義一個全連線層
reshape = tf.reshape(pool2, [batch_size, -1])
# 將上一層的輸出結果拉平（flatten），[batch_size, -1]中的-1代表不確定多大
dim = reshape.get_shape()[1].value
# 得到資料扁平化後的長度

# 建立一個隱含節點數為384的全連線層
weight3 = variable_with_weight_loss(shape=[dim, 384], stddev=0.04, wl=0.004)
bias3 = tf.Variable(tf.constant(0.1, shape=[384]))
local3 = tf.nn.relu(tf.matmul(reshape, weight3) + bias3)

# 建立一個隱含節點數為192的全連線層
weight4 = variable_with_weight_loss(shape=[384, 192], stddev=0.04, wl=0.004)
bias4 = tf.Variable(tf.constant(0.1, shape=[192]))
local4 = tf.nn.relu(tf.matmul(local3, weight4) + bias4)

# 建立輸出層（由於cifar資料庫一共有10個類別的標籤，所以這裡輸出節點數為10）
weight5 = variable_with_weight_loss(shape=[192, 10], stddev=1/192.0, wl=0.0)
bias5 = tf.Variable(tf.constant(0.0, shape=[10]))
logits = tf.add(tf.matmul(local4, weight5), bias5)
# 注意這裡，這裡直接是網路的原始輸出（wx+b這種形式），沒有加softmax啟用

loss = loss(logits, label_holder)
# 計算總體loss，包括weight loss 和 cross_entropy

train_op = tf.train.AdamOptimizer(1e-3).minimize(loss)
# 選擇AdamOptimizer作為優化器

top_k_op = tf.nn.in_top_k(logits, label_holder, 1)
# 關於tf.nn.in_top_k函式的用法見http://blog.csdn.net/uestc_c2_403/article/details/73187915
# tf.nn.in_top_k會返回一個[batch_size, classes(類別數)]大小的布林型張量，記錄是否判斷正確

sess = tf.InteractiveSession()  # 註冊為預設session
tf.global_variables_initializer().run()  # 初始化全部模型引數

tf.train.start_queue_runners()  # 啟動執行緒（QueueRunner是一個不存在於程式碼中的東西，而是後臺運作的一個概念）

for step in range(max_steps):
    start_time = time.time()
    image_batch, label_batch = sess.run([images_train, labels_train])
    # 獲得一個batch的訓練資料
    _, loss_value = sess.run([train_op, loss], feed_dict={image_holder: image_batch,
                                                          label_holder: label_batch})
    # 執行訓練過程並獲得一個batch的total_loss

    duration = time.time() - start_time  # 記錄跑一個batch所耗費的時間

    if step % 10 == 0:  # 每10個batch輸出資訊
        examples_per_sec = batch_size / duration  # 計算每秒能跑多少個樣本
        sec_per_batch = float(duration)  # 計算每個batch需要耗費的時間

        format_str = (
            'step %d, loss = %.2f (%.1f examples/sec; %.3f sec/batch)')
        print(format_str % (step, loss_value, examples_per_sec, sec_per_batch))

# 在測試集上驗證精度
num_examples = 10000
import math
num_iter = int(math.ceil(num_examples / batch_size))  # math.ceil 對浮點數向上取整
true_count = 0
total_sample_count = num_iter * batch_size
step = 0
while step < num_iter:
    image_batch, label_batch = sess.run([images_test, labels_test])
    # 獲得一個batch的測試資料
    predictions = sess.run([top_k_op], feed_dict={image_holder: image_batch,
                                                  label_holder: label_batch})
    true_count += np.sum(predictions)  # 獲得預測正確的樣本數
    step += 1

precision = true_count / total_sample_count  # 獲得預測精度
print('precision @ 1 = %.4f' % precision*100)