1. from numpy import 
2. import os
3. from pylab import 
4. import numpy as np
5. import matplotlib.pyplot as plt
6. import matplotlib.cbook as cbook
7. import time
8. from scipy.misc import imread
9. from scipy.misc import imresize
10. import matplotlib.image as mpimg
11. from scipy.ndimage import filters
12. import urllib
13. from numpy import random
14. 
    
15. 
    
16. import tensorflow as tf
17. from caffe_classes import class_names
18. 
    
19.  train_x = zeros((1, 227,227,3)).astype(float32)
20.  train_y = zeros((1, 1000))
21.  xdim = train_x.shape[1:]
22.  ydim = train_y.shape[1]
23.  
24. 
    
25. net_data = load("bvlc_alexnet.npy").item()
26. 
    
27.  def conv(input, kernel, biases, k_h, k_w, c_o, s_h, s_w,  padding="VALID", group=1):
28.      '''From [https://github.com/ethereon/caffe-tensorflow](https://github.com/ethereon/caffe-tensorflow)
29.      '''
30.      c_i = input.get_shape()[-1]
31.      assert c_i%group==0
32.      assert c_o%group==0
33.      convolve = lambda i, k: tf.nn.conv2d(i, k, [1, s_h, s_w, 1], padding=padding)
34. 
    
35. 
    
36.      if group==1:
37.          conv = convolve(input, kernel)
38.      else:
39.          input_groups = tf.split(3, group, input)
40.          kernel_groups = tf.split(3, group, kernel)
41.          output_groups = [convolve(i, k) for i,k in zip(input_groups, kernel_groups)]
42.          conv = tf.concat(3, output_groups)
43.      return  tf.reshape(tf.nn.bias_add(conv, biases), conv.get_shape().as_list())
44. 
    
45. 
    
46. 
    
47.  x = tf.Variable(i)
48. 
    
49.  #conv1
50.  #conv(11, 11, 96, 4, 4, padding='VALID', name='conv1')
51.  k_h = 11; k_w = 11; c_o = 96; s_h = 4; s_w = 4
52.  conv1W = tf.Variable(net_data["conv1"][0])
53.  conv1b = tf.Variable(net_data["conv1"][1])
54.  conv1_in = conv(x, conv1W, conv1b, k_h, k_w, c_o, s_h, s_w, padding="SAME", group=1)
55.  conv1 = tf.nn.relu(conv1_in)
56. 
    
57.  #lrn1
58.  #lrn(2, 2e-05, 0.75, name='norm1')
59.  radius = 2; alpha = 2e-05; beta = 0.75; bias = 1.0
60.  lrn1 = tf.nn.local_response_normalization(conv1,
61.                                                    depth_radius=radius,
62.                                                    alpha=alpha,
63.                                                    beta=beta,
64.                                                    bias=bias)
65. 
    
66.  #maxpool1
67.  #max_pool(3, 3, 2, 2, padding='VALID', name='pool1')
68.  k_h = 3; k_w = 3; s_h = 2; s_w = 2; padding = 'VALID'
69.  maxpool1 = tf.nn.max_pool(lrn1, ksize=[1, k_h, k_w, 1], strides=[1, s_h, s_w, 1], padding=padding)
70. 
    
71. 
    
72.  #conv2
73.  #conv(5, 5, 256, 1, 1, group=2, name='conv2')
74.  k_h = 5; k_w = 5; c_o = 256; s_h = 1; s_w = 1; group = 2
75.  conv2W = tf.Variable(net_data["conv2"][0])
76.  conv2b = tf.Variable(net_data["conv2"][1])
77.  conv2_in = conv(maxpool1, conv2W, conv2b, k_h, k_w, c_o, s_h, s_w, padding="SAME", group=group)
78.  conv2 = tf.nn.relu(conv2_in)
79. 
    
80. 
    
81.  #lrn2
82.  #lrn(2, 2e-05, 0.75, name='norm2')
83.  radius = 2; alpha = 2e-05; beta = 0.75; bias = 1.0
84.  lrn2 = tf.nn.local_response_normalization(conv2,
85.                                                    depth_radius=radius,
86.                                                    alpha=alpha,
87.                                                    beta=beta,
88.                                                    bias=bias)
89. 
    
90.  #maxpool2
91.  #max_pool(3, 3, 2, 2, padding='VALID', name='pool2')
92.  k_h = 3; k_w = 3; s_h = 2; s_w = 2; padding = 'VALID'
93.  maxpool2 = tf.nn.max_pool(lrn2, ksize=[1, k_h, k_w, 1], strides=[1, s_h, s_w, 1], padding=padding)
94. 
    
95.  #conv3
96.  #conv(3, 3, 384, 1, 1, name='conv3')
97.  k_h = 3; k_w = 3; c_o = 384; s_h = 1; s_w = 1; group = 1
98.  conv3W = tf.Variable(net_data["conv3"][0])
99.  conv3b = tf.Variable(net_data["conv3"][1])
100.  conv3_in = conv(maxpool2, conv3W, conv3b, k_h, k_w, c_o, s_h, s_w, padding="SAME", group=group)
101.  conv3 = tf.nn.relu(conv3_in)
102. 
     
103.  #conv4
104.  #conv(3, 3, 384, 1, 1, group=2, name='conv4')
105.  k_h = 3; k_w = 3; c_o = 384; s_h = 1; s_w = 1; group = 2
106.  conv4W = tf.Variable(net_data["conv4"][0])
107.  conv4b = tf.Variable(net_data["conv4"][1])
108.  conv4_in = conv(conv3, conv4W, conv4b, k_h, k_w, c_o, s_h, s_w, padding="SAME", group=group)
109.  conv4 = tf.nn.relu(conv4_in)
110. 
     
111. 
     
112.  #conv5
113.  #conv(3, 3, 256, 1, 1, group=2, name='conv5')
114.  k_h = 3; k_w = 3; c_o = 256; s_h = 1; s_w = 1; group = 2
115.  conv5W = tf.Variable(net_data["conv5"][0])
116.  conv5b = tf.Variable(net_data["conv5"][1])
117.  conv5_in = conv(conv4, conv5W, conv5b, k_h, k_w, c_o, s_h, s_w, padding="SAME", group=group)
118.  conv5 = tf.nn.relu(conv5_in)
119. 
     
120.  #maxpool5
121.  #max_pool(3, 3, 2, 2, padding='VALID', name='pool5')
122.  k_h = 3; k_w = 3; s_h = 2; s_w = 2; padding = 'VALID'
123.  maxpool5 = tf.nn.max_pool(conv5, ksize=[1, k_h, k_w, 1], strides=[1, s_h, s_w, 1], padding=padding)
124. 
     
125.  #fc6
126.  #fc(4096, name='fc6')
127.  fc6W = tf.Variable(net_data["fc6"][0])
128.  fc6b = tf.Variable(net_data["fc6"][1])
129.  fc6 = tf.nn.relu_layer(tf.reshape(maxpool5, [1, int(prod(maxpool5.get_shape()[1:]))]), fc6W, fc6b)
130. 
     
131.  #fc7
132.  #fc(4096, name='fc7')
133.  fc7W = tf.Variable(net_data["fc7"][0])
134.  fc7b = tf.Variable(net_data["fc7"][1])
135.  fc7 = tf.nn.relu_layer(fc6, fc7W, fc7b)
136. 
     
137.  #fc8
138.  #fc(1000, relu=False, name='fc8')
139.  fc8W = tf.Variable(net_data["fc8"][0])
140.  fc8b = tf.Variable(net_data["fc8"][1])
141.  fc8 = tf.nn.xw_plus_b(fc7, fc8W, fc8b)
142. 
     
143. 
     
144.  #prob
145.  #softmax(name='prob'))
146.  prob = tf.nn.softmax(fc8)
147. 
     
148.  init = tf.initialize_all_variables()
149.  sess = tf.Session()
150.  sess.run(init)
151. 
     
152.  output = sess.run(prob)
153.  ################################################################################
154. 
     
155.  #Output:
156. 
     
157.  inds = argsort(output)[0,:]
158.  for i in range(5):
159.      print class_names[inds[-1-i]], output[0, inds[-1-i]]
160. 
     

 　　这个是基于原生tensorflow的一版代码，好长而且看着比较麻烦一点，还load了caffe里面生成的网络模型，比较麻烦

1.  # 输入数据
2.  import input_data
3.  mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
4. 
   
5.  import tensorflow as tf
6. 
   
7.  # 定义网络超参数
8.  learning_rate = 0.001
9.  training_iters = 200000
10.  batch_size = 64
11.  display_step = 20
12. 
    
13.  # 定义网络参数
14.  n_input = 784 # 输入的维度
15.  n_classes = 10 # 标签的维度
16.  dropout = 0.8 # Dropout 的概率
17. 
    
18.  # 占位符输入
19.  x = tf.placeholder(tf.types.float32, [None, n_input])
20.  y = tf.placeholder(tf.types.float32, [None, n_classes])
21.  keep_prob = tf.placeholder(tf.types.float32)
22. 
    
23.  # 卷积操作
24.  def conv2d(name, l_input, w, b):
25.      return tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(l_input, w, strides=[1, 1, 1, 1], padding='SAME'),b), name=name)
26. 
    
27.  # 最大下采样操作
28.  def max_pool(name, l_input, k):
29.      return tf.nn.max_pool(l_input, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME', name=name)
30. 
    
31.  # 归一化操作
32.  def norm(name, l_input, lsize=4):
33.      return tf.nn.lrn(l_input, lsize, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name=name)
34. 
    
35.  # 定义整个网络 
36.  def alex_net(_X, _weights, _biases, _dropout):
37.      # 向量转为矩阵
38.      _X = tf.reshape(_X, shape=[-1, 28, 28, 1])
39. 
    
40.      # 卷积层
41.      conv1 = conv2d('conv1', _X, _weights['wc1'], _biases['bc1'])
42.      # 下采样层
43.      pool1 = max_pool('pool1', conv1, k=2)
44.      # 归一化层
45.      norm1 = norm('norm1', pool1, lsize=4)
46.      # Dropout
47.      norm1 = tf.nn.dropout(norm1, _dropout)
48. 
    
49.      # 卷积
50.      conv2 = conv2d('conv2', norm1, _weights['wc2'], _biases['bc2'])
51.      # 下采样
52.      pool2 = max_pool('pool2', conv2, k=2)
53.      # 归一化
54.      norm2 = norm('norm2', pool2, lsize=4)
55.      # Dropout
56.      norm2 = tf.nn.dropout(norm2, _dropout)
57. 
    
58.      # 卷积
59.      conv3 = conv2d('conv3', norm2, _weights['wc3'], _biases['bc3'])
60.      # 下采样
61.      pool3 = max_pool('pool3', conv3, k=2)
62.      # 归一化
63.      norm3 = norm('norm3', pool3, lsize=4)
64.      # Dropout
65.      norm3 = tf.nn.dropout(norm3, _dropout)
66. 
    
67.      # 全连接层，先把特征图转为向量
68.      dense1 = tf.reshape(norm3, [-1, _weights['wd1'].get_shape().as_list()[0]]) 
69.      dense1 = tf.nn.relu(tf.matmul(dense1, _weights['wd1']) + _biases['bd1'], name='fc1') 
70.      # 全连接层
71.      dense2 = tf.nn.relu(tf.matmul(dense1, _weights['wd2']) + _biases['bd2'], name='fc2') # Relu activation
72. 
    
73.      # 网络输出层
74.      out = tf.matmul(dense2, _weights['out']) + _biases['out']
75.      return out
76. 
    
77.  # 存储所有的网络参数
78.  weights = {
79.      'wc1': tf.Variable(tf.random_normal([3, 3, 1, 64])),
80.      'wc2': tf.Variable(tf.random_normal([3, 3, 64, 128])),
81.      'wc3': tf.Variable(tf.random_normal([3, 3, 128, 256])),
82.      'wd1': tf.Variable(tf.random_normal([4\*4\*256, 1024])),
83.      'wd2': tf.Variable(tf.random_normal([1024, 1024])),
84.      'out': tf.Variable(tf.random_normal([1024, 10]))
85.  }
86.  biases = {
87.      'bc1': tf.Variable(tf.random_normal([64])),
88.      'bc2': tf.Variable(tf.random_normal([128])),
89.      'bc3': tf.Variable(tf.random_normal([256])),
90.      'bd1': tf.Variable(tf.random_normal([1024])),
91.      'bd2': tf.Variable(tf.random_normal([1024])),
92.      'out': tf.Variable(tf.random_normal([n_classes]))
93.  }
94. 
    
95.  # 构建模型
96.  pred = alex_net(x, weights, biases, keep_prob)
97. 
    
98.  # 定义损失函数和学习步骤
99.  cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y))
100.  optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
101. 
     
102.  # 测试网络
103.  correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
104.  accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
105. 
     
106.  # 初始化所有的共享变量
107.  init = tf.initialize_all_variables()
108. 
     
109.  # 开启一个训练
110.  with tf.Session() as sess:
111.      sess.run(init)
112.      step = 1
113.      # Keep training until reach max iterations
114.      while step \* batch_size < training_iters:
115.          batch_xs, batch_ys = mnist.train.next_batch(batch_size)
116.          # 获取批数据
117.          sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys, keep_prob: dropout})
118.          if step % display_step == 0:
119.              # 计算精度
120.              acc = sess.run(accuracy, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})
121.              # 计算损失值
122.              loss = sess.run(cost, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})
123.              print "Iter " + str(step\*batch_size) + ", Minibatch Loss= " + "{:.6f}".format(loss) + ", Training Accuracy= " + "{:.5f}".format(acc)
124.          step += 1
125.      print "Optimization Finished!"
126.      # 计算测试精度
127.      print "Testing Accuracy:", sess.run(accuracy, feed_dict={x: mnist.test.images[:256], y: mnist.test.labels[:256], keep_prob: 1.})

　　基于mnist 构建alexnet，这里的input可以去tensorflow的github上去找找，这一版代码比较简单。

　后来发现了tflearn里面有一个alexnet来分类Oxford的例子，好开心，在基于tflearn对一些日常layer的封装，代码量只有不到50行，看了下内部layer的实现，挺不错的，写代码的时候可以多参考参考，代码地址：https://github.com/tflearn/tflearn/blob/master/examples/images/alexnet.py.

1.  from __future__ import division, print_function, absolute_import
2. 
   
3.  import tflearn
4.  from tflearn.layers.core import input_data, dropout, fully_connected
5.  from tflearn.layers.conv import conv_2d, max_pool_2d
6.  from tflearn.layers.normalization import local_response_normalization
7.  from tflearn.layers.estimator import regression
8. 
   
9.  import tflearn.datasets.oxflower17 as oxflower17
10.  X, Y = oxflower17.load_data(one_hot=True, resize_pics=(227, 227))
11. 
    
12.  # Building 'AlexNet'
13.  network = input_data(shape=[None, 227, 227, 3])
14.  network = conv_2d(network, 96, 11, strides=4, activation='relu')
15.  network = max_pool_2d(network, 3, strides=2)
16.  network = local_response_normalization(network)
17.  network = conv_2d(network, 256, 5, activation='relu')
18.  network = max_pool_2d(network, 3, strides=2)
19.  network = local_response_normalization(network)
20.  network = conv_2d(network, 384, 3, activation='relu')
21.  network = conv_2d(network, 384, 3, activation='relu')
22.  network = conv_2d(network, 256, 3, activation='relu')
23.  network = max_pool_2d(network, 3, strides=2)
24.  network = local_response_normalization(network)
25.  network = fully_connected(network, 4096, activation='tanh')
26.  network = dropout(network, 0.5)
27.  network = fully_connected(network, 4096, activation='tanh')
28.  network = dropout(network, 0.5)
29.  network = fully_connected(network, 17, activation='softmax')
30.  network = regression(network, optimizer='momentum',
31.                       loss='categorical_crossentropy',
32.                       learning_rate=0.001)
33. 
    
34.  # Training
35.  model = tflearn.DNN(network, checkpoint_path='model_alexnet',
36.                      max_checkpoints=1, tensorboard_verbose=2)
37.  model.fit(X, Y, n_epoch=1000, validation_set=0.1, shuffle=True,
38.            show_metric=True, batch_size=64, snapshot_step=200,
39.            snapshot_epoch=False, run_id='alexnet_oxflowers17')

　　使用tflearn版本的alexnet来做实验，从TensorBoard上得到的基本效果如下， alexnet graph 如下：