卷积神经网络（Convolutional Neural Network, CNN）是一种前馈神经网络，它的人工神经元可以响应一部分覆盖范围内的周围单元，对于大型图像处理有出色表现。与普通神经网络非常相似，它们都由具有可学习的权重和偏置常量(biases)的神经元组成。每个神经元都接收一些输入，并做一些点积计算，输出是每个分类的分数，普通神经网络里的一些计算技巧到这里依旧适用。
卷积神经网络通常包含以下几种层：
- 卷积层（Convolutional layer），卷积神经网路中每层卷积层由若干卷积单元组成，每个卷积单元的参数都是通过反向传播算法优化得到的。卷积运算的目的是提取输入的不同特征，第一层卷积层可能只能提取一些低级的特征如边缘、线条和角等层级，更多层的网络能从低级特征中迭代提取更复杂的特征。
- 线性整流层（Rectified Linear Units layer, ReLU layer），这一层神经的活性化函数（Activation function）使用线性整流（Rectified Linear Units, ReLU）f(x)=max(0,x)。
- 池化层（Pooling layer），通常在卷积层之后会得到维度很大的特征，将特征切成几个区域，取其最大值或平均值，得到新的、维度较小的特征。
- Drop out, 通常我们在训练Covnets时，会随机的丢弃一部分训练获得的参数，这样可以在一定程度上来防止过度拟合
- 全连接层（ Fully-Connected layer）, 把所有局部特征结合变成全局特征，用来计算最后每一类的得分。
下面是代码部分，今天我将使用Covnets去完成一件非常非常简单的图像分类任务。这里我们将对 CIFAR-10 数据集 中的图片进行分类。该数据集包含飞机、猫狗和其他物体。
首先，我们先获得数据集 （或者直接从 https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz ）这里直接下载
1 from urllib.request import urlretrieve 2 from os.path import isfile, isdir 3 from tqdm import tqdm 4 import tarfile 5 6 cifar10_dataset_folder_path = ‘cifar-10-batches-py‘ 7 8 class DLProgress(tqdm): 9 last_block = 0 10 11 def hook(self, block_num=1, block_size=1, total_size=None): 12 self.total = total_size 13 self.update((block_num - self.last_block) * block_size) 14 self.last_block = block_num 15 16 if not isfile(tar_gz_path): 17 with DLProgress(unit=‘B‘, unit_scale=True, miniters=1, desc=‘CIFAR-10 Dataset‘) as pbar: 18 urlretrieve( 19 ‘https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz‘, 20 tar_gz_path, 21 pbar.hook) 22 23 if not isdir(cifar10_dataset_folder_path): 24 with tarfile.open(tar_gz_path) as tar: 25 tar.extractall() 26 tar.close()
在数据载入之后，我们需要对我们的图片预处理下，因为现在的像素点是0-255之间，我们需要把图片的像素点的值变成0-1之间，这样方便在后面的计算
1 def normalize(x): 2 """ 3 Normalize a list of sample image data in the range of 0 to 1 4 : x: List of image data. The image shape is (32, 32, 3) 5 : return: Numpy array of normalize data 6 """ 7 a = 0 8 b = 1 9 grayscale_min = 0 10 grayscale_max = 255 11 return a + (((x - grayscale_min) * (b - a))/(grayscale_max - grayscale_min))
因为CIFAR数据集里面有10类不同的图片，现在我们需要使用ONE-HOT的方法来给图片打上标签
1 def one_hot_encode(x):
2 """
3 One hot encode a list of sample labels. Return a one-hot encoded vector for each label.
4 : x: List of sample Labels
5 : return: Numpy array of one-hot encoded labels
6 """
7 d = {0:[1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
8 1:[0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
9 2:[0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
10 3:[0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
11 4:[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
12 5:[0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
13 6:[0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
14 7:[0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
15 8:[0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
16 9:[0, 0, 0, 0, 0, 0, 0, 0, 0, 1]}
17
18 map_list = []
19 for item in x:
20 map_list.append(d[item])
21 target = np.array(map_list)
22
23 return target
下面，我们就开始构建我们的Covnets了，首先，我们需要构建placeholder来储存我们的训练图片，训练数据的one-hot标签的编码以及我们dropout时候的概率值
1 import tensorflow as tf 2 3 def neural_net_image_input(image_shape): 4 """ 5 Return a Tensor for a batch of image input 6 : image_shape: Shape of the images 7 : return: Tensor for image input. 8 """ 9 x = tf.placeholder(tf.float32,[None, image_shape[0], image_shape[1],image_shape[2]],‘x‘) 10 return x 11 12 13 def neural_net_label_input(n_classes): 14 """ 15 Return a Tensor for a batch of label input 16 : n_classes: Number of classes 17 : return: Tensor for label input. 18 """ 19 y = tf.placeholder(tf.float32,[None, n_classes],‘y‘) 20 return y 21 22 23 def neural_net_keep_prob_input(): 24 """ 25 Return a Tensor for keep probability 26 : return: Tensor for keep probability. 27 """ 28 keep_prob = tf.placeholder(tf.float32,None,‘keep_prob‘) 29 return keep_prob
接着 我们来构建Covnets中最核心的 卷积层+最大池化层（这里我们用最大池化）
1 def conv2d_maxpool(x_tensor, conv_num_outputs, conv_ksize, conv_strides, pool_ksize, pool_strides): 2 """ 3 Apply convolution then max pooling to x_tensor 4 :param x_tensor: TensorFlow Tensor 5 :param conv_num_outputs: Number of outputs for the convolutional layer 6 :param conv_ksize: kernal size 2-D Tuple for the convolutional layer 7 :param conv_strides: Stride 2-D Tuple for convolution 8 :param pool_ksize: kernal size 2-D Tuple for pool 9 :param pool_strides: Stride 2-D Tuple for pool 10 : return: A tensor that represents convolution and max pooling of x_tensor 11 """ 12 ## Weights and Bias 13 weight = tf.Variable(tf.truncated_normal([conv_ksize[0],conv_ksize[1], 14 x_tensor.get_shape().as_list()[-1],conv_num_outputs],stddev=0.1)) 15 bias = tf.Variable(tf.zeros(conv_num_outputs)) 16 ## Apply Convolution 17 conv_layer = tf.nn.conv2d(x_tensor,weight,strides = [1,conv_strides[0],conv_strides[1],1], padding=‘SAME‘) 18 ## Add Bias 19 conv_layer = tf.nn.bias_add(conv_layer,bias) 20 ## Apply Relu 21 conv_layer = tf.nn.relu(conv_layer) 22 23 return tf.nn.max_pool(conv_layer, 24 ksize=[1,pool_ksize[0],pool_ksize[1],1], 25 strides=[1,pool_strides[0],pool_strides[1],1], 26 padding=‘SAME‘)
实现 flatten 层，将 x_tensor 的维度从四维张量（4-D tensor）变成二维张量。输出应该是形状（部分大小（Batch Size），扁平化图片大小（Flattened Image Size））
1 def flatten(x_tensor): 2 """ 3 Flatten x_tensor to (Batch Size, Flattened Image Size) 4 : x_tensor: A tensor of size (Batch Size, ...), where ... are the image dimensions. 5 : return: A tensor of size (Batch Size, Flattened Image Size). 6 """ 7 # Get the shape of tensor 8 shape = x_tensor.get_shape().as_list() 9 # Compute the dim for image 10 dim = np.prod(shape[1:]) 11 # reshape the tensor 12 13 return tf.reshape(x_tensor, [-1,dim])
在网络的最后一步，我们需要做一个全连接层 + 输出层，然后输出一个1*10的结果（10种结果的概率）
1 def fully_conn(x_tensor, num_outputs): 2 """ 3 Apply a fully connected layer to x_tensor using weight and bias 4 : x_tensor: A 2-D tensor where the first dimension is batch size. 5 : num_outputs: The number of output that the new tensor should be. 6 : return: A 2-D tensor where the second dimension is num_outputs. 7 """ 8 weight = tf.Variable(tf.truncated_normal([x_tensor.get_shape().as_list()[-1], num_outputs],stddev=0.1)) 9 bias = tf.Variable(tf.zeros([num_outputs])) 10 11 fc = tf.reshape(x_tensor,[-1, weight.get_shape().as_list()[0]]) 12 fc = tf.add(tf.matmul(fc,weight), bias) 13 fc = tf.nn.relu(fc) 14 15 return fc 16 17 def output(x_tensor, num_outputs): 18 """ 19 Apply a output layer to x_tensor using weight and bias 20 : x_tensor: A 2-D tensor where the first dimension is batch size. 21 : num_outputs: The number of output that the new tensor should be. 22 : return: A 2-D tensor where the second dimension is num_outputs. 23 """ 24 25 weight_out = tf.Variable(tf.truncated_normal([x_tensor.get_shape().as_list()[-1],num_outputs],stddev=0.1)) 26 bias_out = tf.Variable(tf.zeros([num_outputs])) 27 28 out = tf.reshape(x_tensor, [-1, weight_out.get_shape().as_list()[0]]) 29 out = tf.add(tf.matmul(out,weight_out),bias_out) 30 31 return out
在我们都完成基本的元素之后,我们这个时候来构建我们的网络
1 def conv_net(x, keep_prob): 2 """ 3 Create a convolutional neural network model 4 : x: Placeholder tensor that holds image data. 5 : keep_prob: Placeholder tensor that hold dropout keep probability. 6 : return: Tensor that represents logits 7 """ 8 9 conv1 = conv2d_maxpool(x, 32,(5,5),(2,2),(4,4),(2,2)) 10 11 conv2 = conv2d_maxpool(conv1, 128, (5,5),(2,2),(2,2),(2,2)) 12 13 conv3 = conv2d_maxpool(conv2, 256, (5,5),(2,2),(2,2),(2,2)) 14 15 16 # flatten(x_tensor) 17 18 flatten_layer = flatten(conv3) 19 20 # fully_conn(x_tensor, num_outputs) 21 22 fc = fully_conn(flatten_layer, 1024) 23 24 # Set this to the number of classes 25 # Function Definition from Above: 26 # output(x_tensor, num_outputs) 27 28 output_layer = output(fc, 10) 29 30 return output_layer 31 32 33 ############################## 34 ## Build the Neural Network ## 35 ############################## 36 37 # Remove previous weights, bias, inputs, etc.. 38 tf.reset_default_graph() 39 40 # Inputs 41 x = neural_net_image_input((32, 32, 3)) 42 y = neural_net_label_input(10) 43 keep_prob = neural_net_keep_prob_input() 44 45 # Model 46 logits = conv_net(x, keep_prob) 47 48 # Name logits Tensor, so that is can be loaded from disk after training 49 logits = tf.identity(logits, name=‘logits‘) 50 51 # Loss and Optimizer 52 cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y)) 53 optimizer = tf.train.AdamOptimizer().minimize(cost) 54 55 # Accuracy 56 correct_pred = tf.equal(tf.argmax(logits, 1), tf.argmax(y, 1)) 57 accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32), name=‘accuracy‘)
在网络构建完成后，我们可以开始把我们的数据喂进去，训练我们的模型了
这里我随便设置下Hyper-Paramter
1 epochs = 30 2 batch_size = 256 3 keep_probability = 0.5
还需要设置下，在训练的过程中，我们一直需要看到测试集的accuracy来观测我们训练的情况
1 def print_stats(session, feature_batch, label_batch, cost, accuracy):
2 """
3 Print information about loss and validation accuracy
4 : session: Current TensorFlow session
5 : feature_batch: Batch of Numpy image data
6 : label_batch: Batch of Numpy label data
7 : cost: TensorFlow cost function
8 : accuracy: TensorFlow accuracy function
9 """
10 loss = sess.run(cost, feed_dict = {
11 x:feature_batch,
12 y:label_batch,
13 keep_prob:1.
14 })
15
16 valid_acc = sess.run(accuracy,feed_dict = {
17 x:valid_features,
18 y:valid_labels,
19 keep_prob:1.
20 })
21
22 print(‘Loss: {:>10.4f} Validation Accuracy: {:.6f}‘.format(
23 loss,
24 valid_acc))
模型训练
1 save_model_path = ‘./image_classification‘
2
3 print(‘Training...‘)
4 with tf.Session() as sess:
5 # Initializing the variables
6 sess.run(tf.global_variables_initializer())
7
8 # Training cycle
9 for epoch in range(epochs):
10 # Loop over all batches
11 n_batches = 5
12 for batch_i in range(1, n_batches + 1):
13 for batch_features, batch_labels in helper.load_preprocess_training_batch(batch_i, batch_size):
14 train_neural_network(sess, optimizer, keep_probability, batch_features, batch_labels)
15 print(‘Epoch {:>2}, CIFAR-10 Batch {}: ‘.format(epoch + 1, batch_i), end=‘‘)
16 print_stats(sess, batch_features, batch_labels, cost, accuracy)
17
18 # Save Model
19 saver = tf.train.Saver()
20 save_path = saver.save(sess, save_model_path)
贴上我在训练的最后的验证集的准确率
Epoch 29, CIFAR-10 Batch 4: Loss: 0.0139 Validation Accuracy: 0.625600 Epoch 29, CIFAR-10 Batch 5: Loss: 0.0090 Validation Accuracy: 0.631000 Epoch 30, CIFAR-10 Batch 1: Loss: 0.0138 Validation Accuracy: 0.638800 Epoch 30, CIFAR-10 Batch 2: Loss: 0.0192 Validation Accuracy: 0.627400 Epoch 30, CIFAR-10 Batch 3: Loss: 0.0055 Validation Accuracy: 0.633400 Epoch 30, CIFAR-10 Batch 4: Loss: 0.0114 Validation Accuracy: 0.641800 Epoch 30, CIFAR-10 Batch 5: Loss: 0.0050 Validation Accuracy: 0.647400
还不错，50%以上了，如果瞎猜 只有10%的
当然了，我们的模型的效率可以进一步提高，比如我们进一步去选择更合适的超参数，或者加入一些其他的技巧。
http://rodrigob.github.io/are_we_there_yet/build/classification_datasets_results.html#43494641522d3130
这里有个链接，是大家利用这个数据集训练的结果，现在最高的已经96.53%了，看看大佬们是怎么做的吧。。。。
原文地址：https://www.cnblogs.com/chenyusheng0803/p/9030679.html
时间： 2024-11-04 01:14:59