月度归档：2018年06月

26.1交通标志识别简介

26.1.1 交通标记易识特性

由于交通标志采用特定的文字、图形和符号，在一定范围内具有标准、醒目、信息明确的特性，一直是图像识别技术在交通领域应用的首选。从图像识别技术诞生之日起，交通标志识别的算法和模型就一直受到广泛的关注，也让这一技术发展相对成熟，并应用到自动驾驶领域中来。

图1 交通标志识别技术
我国的交通标志一共有一百余种，按类别可分为黄底黑边的警告标志、白底红圈的禁令标志、蓝底白字的指示标志，形状上以三角形、圆形和矩形为主。明确的形状和颜色区分、有限的标志数量，都为图像识别提供了一个相对稳定的应用环境。

图2 我国的交通标志

26.1.2交通标志识别技术的原理

利用图像识别技术的交通标志识别系统一般分为以下几个工作步骤：

图3 图像识别的步骤
1. 图像预处理：
在实际的交通场景中，由于运动抖动、自然光、天气条件等各种因素的影响，不可避免的会在采集的图像中引入一定程度的干扰和噪声，所以首先需要将这些不利因素消除，对采集到的图像进行一些预处理。通过图像均衡、图像增强和图像去噪等算法，将图像的光线均衡，突出关键信息。这一步基本和美图秀秀中的那些工具类似，都是将图像变得清晰、易辨认。

图4 对图像进行预处理，去除噪声、提高亮度和对比度
2. 交通标志分割：
预处理后的图像仍然包含很多信息，交通标志在其中只有很小的一个区域，为了减小处理的数据量，加快处理速度，一般都会先将交通标志的区域检测出来，再去判断这个区域中的交通标志的具体含义。交通标志在颜色和形状上都有一定的特殊性，并可按照下图进行一定程度的分类，所以一般通过这两个特征去检测交通标志。

图5 交通标志按颜色和形状分类
2.1颜色分割：
颜色按照国际标准可划分为RGB、HSV、HSI等颜色空间，并进行量化分析，以RGB空间为例，将颜色按照红色、绿色、蓝色三种颜色进行分割，通过给定交通标志牌中常用的蓝色、黄色、红色的色度坐标范围，即可过滤掉与之不相关的颜色信息，快速检测到交通标志牌。

图 6 通过RGB色彩空间处理，快速定位红色区域
2.2形状分割：
仅仅检测颜色显然又是不够的，由于光照、背景色的影响和干扰，还需要在颜色检测结果的基础上对相应区域进行形状检测。交通标志具有边缘清晰、形状简单易辨认的特点。这些特征在排除颜色影响后的灰度图像中更加明显，因此通过一定的边缘检测算子去判断图像像素中出现的灰度阶跃变化，一般就能较为准确的检测出交通标志的形状和轮廓特征。

图7 对检测区域进行灰度处理，再通过灰度阶跃检测其形状边界
3. 交通标志特征提取
在图像检测完成以后，图像中基本就只剩下了交通标志的关键信息，这些信息简单直观，但计算机依然不会知道这些信息的具体含义，这时候需要再进一步对这些图像特征进行提取和比对，才能对具体的信息进行识别。
图像的关键特征，是识别具体信息的关键因素，特征的好坏直接决定了识别的准确度。一般说来这些关键特征需要具有可区分性、简约性和抗干扰等几个要素，可区分性即不同标志的特征要具有足够的差异性，简约性是在保证可区分性的前提下用尽量少的数据表示图像特征，这可以保证检测的速度和效率，抗干扰度即图像特征信息要保证尽量少的会被噪声、自然光和图像畸变影响。
在交通标志识别上，一般会提取颜色特征、线条变化特征、矩特征、灰度直方图统计特征等等，并会在事先维护一个足够样本数量的特征库，包含现有交通标志的图像特征信息。在识别的时候将采集到的图像的特征提取出来与数据库中的条件进行比对，即可判断出该交通标志的实际意义。
4. 识别结果匹配
目前有多种方法实现图像特征与特征库数据的比对，最为简单直接的方式是模板匹配：即在特征库中将不同交通标志的特征参数规定为某些特定的参数，当所采集图像的特征参数在某个范围内，就判断是这个交通标志信息。但由于图像在采集的时候难免发生形状畸变、颜色失真等误差，在实际使用场景中用模板匹配来识别的成功率和准确度并不是特别高，即便优化了图像处理算法，也还有很多局限。

图 8 通过匹配特征库信息识别标志
近些年机器学习技术的发展，让图像识别也有了很大的变化，通过设定一些简单的判断条件，并在特征库中加入各种形态和场景下的学习样本，让系统不断加深交通标志识别的认知和识别概率。机器学习让识别不再依靠具体固定的参数，而是通过一系列的条件判断让系统找到概率最大的目标，以此提升识别的准确度和灵活性。这一技术在目前成为研究的热点，并有效提高了图像识别的准确率。

图 9 机器学习在图像识别中的应用

26.1.3 总结

交通标志识别是图像识别技术在自动驾驶领域较为成功的应用，其情景相对简单固定，识别准确度和成功率都让人满意。现在自动驾驶中摄像头识别车辆、行人、自行车、车道线等其他目标的工作原理基本和交通标志识别类似，只是针对不同的对象所用的的算法和模型也会进行一定的调整和优化，并维护一个更为多样的样本学习库。Mobileye在自动驾驶摄像头领域已经耕耘了17年，其算法集成优化、样本库丰富度、识别精确度都处于绝对领先，也为自动驾驶的普及带来了巨大的福音。

26.2 交通标志识别常用模型

1、LeNet(X)
是交通标志识别中非常经典的算法结构，其结构如下：

但是要实现交通标志识别还需要对该算法的初始结构进行调整。比如输出层的分类数调整为43；Subsampling layers 转为max pooling layers；增加Dropout 层，初始设置keep_prob=0.9；激活函数采用RELU。
改进后的架构流程如下表所示：

2、AlexNet
AlexNet是2012年发表的一个经典网络，在当年取得了ImageNet的最好成绩。
这是AlexNet的网络结构图：

网络共有8层，其中前5层是卷积层，后边3层是全连接层，在每一个卷积层中包含了激励函数RELU以及局部响应归一化（LRN）处理，然后再经过池化（max pooling），最后的一个全连接层的输出是具有1000个输出的softmax层，最后的优化目标是最大化平均的多元逻辑回归。
3、其它多层神经网络
36.3 实例1（使用多层神经网络）
这个Project的目的是利用神经卷积网路（CNN）来分类（classify）常见的交通标志。 CNN 在读图领域已经全面超过了传统的机器学习方法（SVC, OpenCV）。大量的资料是深度学习准确性的保证，在资料不够的情况下也可以人为的对原有资料进行小改动从而来提高识别的准确度。汇入必要的软体包（pickle, numpy, cv2, matplotlib, sklearn, tensorflow, Keras）
这里使用python3.6，TensorFlow1.6 等，使用GPU比使用CPU快约100倍！
1）导入需要的模块或库

import pickle
import cv2
import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from tensorflow.python.keras.preprocessing.image import ImageDataGenerator
from sklearn.model_selection import train_test_split
import tensorflow as tf
from tensorflow.contrib.layers import flatten
### Load the images and plot them here.
import os
# Visualizations will be shown in the notebook.
%matplotlib inline

import pickle

import cv2

import matplotlib.pyplot as plt

import numpy as np

from sklearn.model_selection import train_test_split

from tensorflow.python.keras.preprocessing.image import ImageDataGenerator

from sklearn.model_selection import train_test_split

import tensorflow as tf

from tensorflow.contrib.layers import flatten

### Load the images and plot them here.

import os

# Visualizations will be shown in the notebook.

%matplotlib inline

【注意】如果环境已安装keras，可以直接使用，导入方式可改为：

import pickle
from keras.preprocessing.image import ImageDataGenerator

1 2	import pickle from keras.preprocessing.image import ImageDataGenerator

资料来源：和大部分的机器学习的要求一样， CNN需要大量有label的资料，German Traffic Sign Dataset提供了对于这个project的研究所需的数据，本章数据集下载

2）导入数据

training_file = '/home/wumg/data/autocar/train.p' # change it to your local dir
testing_file = '/home/wumg/data/autocar/test.p' # change it to your local dir

with open(training_file, mode='rb') as f:
    train = pickle.load(f)
with open(testing_file, mode='rb') as f:
    test = pickle.load(f)

X_train, y_train = train['features'], train['labels']
X_test, y_test = test['features'], test['labels']

# Number of training examples
n_train = X_train.shape[0]

# Number of testing examples.
n_test = X_test.shape[0]

# What's the shape of an traffic sign image?
image_shape = X_train[0].shape

# How many unique classes/labels there are in the dataset？
n_classes = len(set(y_train))

print("Number of training examples =", n_train)
print("Number of testing examples =", n_test)
print("Image data shape =", image_shape)
print("Number of classes =", n_classes)

training_file = '/home/wumg/data/autocar/train.p' # change it to your local dir

testing_file = '/home/wumg/data/autocar/test.p' # change it to your local dir

with open(training_file, mode='rb') as f:

train = pickle.load(f)

with open(testing_file, mode='rb') as f:

test = pickle.load(f)

X_train, y_train = train['features'], train['labels']

X_test, y_test = test['features'], test['labels']

# Number of training examples

n_train = X_train.shape[0]

# Number of testing examples.

n_test = X_test.shape[0]

# What's the shape of an traffic sign image?

image_shape = X_train[0].shape

# How many unique classes/labels there are in the dataset？

n_classes = len(set(y_train))

print("Number of training examples =", n_train)

print("Number of testing examples =", n_test)

print("Image data shape =", image_shape)

print("Number of classes =", n_classes)

打印结果
Number of training examples = 39209
Number of testing examples = 12630
Image data shape = (32, 32, 3)
Number of classes = 43

3）探索数据
从上面我们可以看到有39209个用作训练的影象和 12630个testing data。 39209张照片对于训练CNN来说是不够的（100000张以上是比较理想的资料量），所以之后要加入data augment 的模组来人为增加资料。每张影象的大小是是32×32 并且有3个通道。总共有43个不同的label。我们也可以把每个label对应的图片随机选择一张画出来。

# show a random sample from each class of the traffic sign dataset
rows, cols = 4, 12
fig, ax_array = plt.subplots(rows, cols) # ax_array is a array object consistint of plt object
plt.suptitle('RANDOM SAMPLES FROM TRAINING SET (one for each class)')
for class_idx, ax in enumerate(ax_array.ravel()):
    if class_idx < n_classes:
        cur_X = X_train[y_train == class_idx]
        cur_img = cur_X[np.random.randint(len(cur_X))]
        ax.imshow(cur_img)
        ax.set_title('{:02d}'.format(class_idx))
    else:
        ax.axis('off')
# hide both x and y ticks
plt.setp([a.get_xticklabels() for a in ax_array.ravel()], visible=False)
plt.setp([a.get_yticklabels() for a in ax_array.ravel()], visible=False)

plt.draw()

# show a random sample from each class of the traffic sign dataset

rows, cols = 4, 12

fig, ax_array = plt.subplots(rows, cols) # ax_array is a array object consistint of plt object

plt.suptitle('RANDOM SAMPLES FROM TRAINING SET (one for each class)')

for class_idx, ax in enumerate(ax_array.ravel()):

if class_idx < n_classes:

cur_X = X_train[y_train == class_idx]

cur_img = cur_X[np.random.randint(len(cur_X))]

ax.imshow(cur_img)

ax.set_title('{:02d}'.format(class_idx))

else:

ax.axis('off')

# hide both x and y ticks

plt.setp([a.get_xticklabels() for a in ax_array.ravel()], visible=False)

plt.setp([a.get_yticklabels() for a in ax_array.ravel()], visible=False)

plt.draw()

4）查看各种标志的分布情况

train_distribution, test_distribution = np.zeros(n_classes), np.zeros(n_classes)
for c in range(n_classes):
    train_distribution[c] = np.sum(y_train == c) / n_train
    test_distribution[c] = np.sum(y_test == c) / n_test
fig, ax = plt.subplots()
col_width = 0.5
bar_train = ax.bar(np.arange(n_classes), train_distribution, width=col_width, color='r')
bar_test = ax.bar(np.arange(n_classes)+col_width, test_distribution, width=col_width, color='b')
ax.set_ylabel('PERCENTAGE OF PRESENCE')
ax.set_xlabel('CLASS LABEL')
ax.set_title('Classes distribution in traffic-sign dataset')
ax.set_xticks(np.arange(0, n_classes, 5) )
ax.set_xticklabels(['{:02d}'.format(c) for c in range(0, n_classes, 5)])
ax.legend((bar_train[0], bar_test[0]), ('train set', 'test set'))
plt.show()

train_distribution, test_distribution = np.zeros(n_classes), np.zeros(n_classes)

for c in range(n_classes):

train_distribution[c] = np.sum(y_train == c) / n_train

test_distribution[c] = np.sum(y_test == c) / n_test

fig, ax = plt.subplots()

col_width = 0.5

bar_train = ax.bar(np.arange(n_classes), train_distribution, width=col_width, color='r')

bar_test = ax.bar(np.arange(n_classes)+col_width, test_distribution, width=col_width, color='b')

ax.set_ylabel('PERCENTAGE OF PRESENCE')

ax.set_xlabel('CLASS LABEL')

ax.set_title('Classes distribution in traffic-sign dataset')

ax.set_xticks(np.arange(0, n_classes, 5) )

ax.set_xticklabels(['{:02d}'.format(c) for c in range(0, n_classes, 5)])

ax.legend((bar_train[0], bar_test[0]), ('train set', 'test set'))

plt.show()

从上图可以看到这43个类别的资料量的分配是很不均匀的。这个会给CNN带来bias(偏见)：CNN会更倾向于预测在training data里出现频率多的那些分类。

5）数据预处理
资料前期处理根据这篇论文[Sermanet, LeCun]，把RGB的照片转化成YUV(除了RGB模型外，还有一种广泛采用的模型，称为YUV模型，又被称为亮度-色度模型（Luma-ChromaModel）。它是通过数学转换，将RGB三通道转换为一个代表亮度的通道(Y,又称为Luma)，和两个代表色度的通道(UV，并称为Chroma)来记录图像的模型) 然后只选择Y通道的图片可以在不影响精度的同时减少资料计算量。然后每张图片都转化成以0为平均值，以1为标准差的阵列。

def preprocess_features(X, equalize_hist=True):
    # Convert from RGB to YUV
    X = np.array([np.expand_dims(cv2.cvtColor(rgb_img, cv2.COLOR_RGB2YUV)[:, :, 0], 2) for rgb_img in X])

    # adjust image contrast
    if equalize_hist:
        X = np.array([np.expand_dims(cv2.equalizeHist(img), 2) for img in X])

    X = np.float32(X)

    # Standardize features
    X -= np.mean(X, axis=0)
    X /= (np.std(X, axis=0) + np.finfo('float32').eps)

    return X

X_train_norm = preprocess_features(X_train)
X_test_norm = preprocess_features(X_test)

def preprocess_features(X, equalize_hist=True):

# Convert from RGB to YUV

X = np.array([np.expand_dims(cv2.cvtColor(rgb_img, cv2.COLOR_RGB2YUV)[:, :, 0], 2) for rgb_img in X])

# adjust image contrast

if equalize_hist:

X = np.array([np.expand_dims(cv2.equalizeHist(img), 2) for img in X])

X = np.float32(X)

# Standardize features

X -= np.mean(X, axis=0)

X /= (np.std(X, axis=0) + np.finfo('float32').eps)

return X

X_train_norm = preprocess_features(X_train)

X_test_norm = preprocess_features(X_test)

人为添加数据（data augment）对于图片来时，一定程度的旋转，上下左右移动，放大或者缩小都应该不会影响它的标签。虽然图片数据已经完全不一样了，我们肉眼还是能够识别的出来，这能够在增加数据量的同时帮助CNN 总结（generalize）. Keras 有个很方便的函数ImageDataGenerator(rotation_range=15., zoom_range=0.2, width_shift_range=0.1, height_shift_range=0.1) 可以实现这个，这个函数可以设置旋转的角度rotation_range，放大或缩小的倍数zoom_range, 左右移动的比例width_shift_range 和上下移动的比例height_shift_range ，随机在区间内改动原来的照片并产生无数新的照片，下面我选择一张作为示范：

# creat the generator to perform online data augmentation
image_datagen = ImageDataGenerator(rotation_range=15.,
                                   zoom_range=0.2,
                                   width_shift_range=0.1,
                                   height_shift_range=0.1)

# take a random image from the training set
img_rgb = X_train[10]
#print("img_rgb shape:",img_rgb.shape)

# plot the original image
plt.figure(figsize=(1,1))
plt.imshow(img_rgb)
plt.title('Example of RGB image (class = {})'.format(y_train[10]))
plt.axis('off')
plt.show()
 

# plot some randomly augmented images
rows, cols = 4, 10
fig, ax_array = plt.subplots(rows, cols)
for ax in ax_array.ravel():
    augmented_img, _ = image_datagen.flow(np.expand_dims(img_rgb, 0), y_train[10:11]).next()
    ax.imshow(np.uint8(np.squeeze(augmented_img)))
plt.setp([a.get_xticklabels() for a in ax_array.ravel()], visible=False)
plt.setp([a.get_yticklabels() for a in ax_array.ravel()], visible=False)
plt.suptitle('Random examples of data augment (starting from the previous image)')
plt.show()

# creat the generator to perform online data augmentation

image_datagen = ImageDataGenerator(rotation_range=15.,

zoom_range=0.2,

width_shift_range=0.1,

height_shift_range=0.1)

# take a random image from the training set

img_rgb = X_train[10]

#print("img_rgb shape:",img_rgb.shape)

# plot the original image

plt.figure(figsize=(1,1))

plt.imshow(img_rgb)

plt.title('Example of RGB image (class = {})'.format(y_train[10]))

plt.axis('off')

plt.show()

# plot some randomly augmented images

rows, cols = 4, 10

fig, ax_array = plt.subplots(rows, cols)

for ax in ax_array.ravel():

augmented_img, _ = image_datagen.flow(np.expand_dims(img_rgb, 0), y_train[10:11]).next()

ax.imshow(np.uint8(np.squeeze(augmented_img)))

plt.setp([a.get_xticklabels() for a in ax_array.ravel()], visible=False)

plt.setp([a.get_yticklabels() for a in ax_array.ravel()], visible=False)

plt.suptitle('Random examples of data augment (starting from the previous image)')

plt.show()

6）搭建神经网络
搭建CNN 每一层的神经网络都加了dropout 来防止overfitting。这个CNN的特点是把两层conv的output做了一个合成：fc0 = tf.concat([flatten(drop1), flatten(drop2)],1 ) 然后再连接到fully_connected layer 和output layer（43 classes）。文献中说这样做的好处是“the classifier is explicitly provided both the local “motifs” (learned by conv1) and the more “global” shapes and structure (learned by conv2) found in the features.” 我的理解是： CNN 能够在图片的局部和整体都能作为判断的依据，从而提高准确率

n_classes = 43
def weight_variable(shape, mu=0, sigma=0.1):
    initialization = tf.truncated_normal(shape=shape, mean=mu, stddev=sigma)
    return tf.Variable(initialization)

def bias_variable(shape, start_val=0.1):
    initialization = tf.constant(start_val,shape=shape)
    return tf.Variable(initialization)

def conv2d(x, W, strides=[1,1,1,1], padding='SAME'):
    return tf.nn.conv2d(input=x, filter=W, strides=strides, padding=padding)

def max_pool2x2(x):
    return tf.nn.max_pool(value=x, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')

# network architecture definition
def my_net(x, n_classes):

    c1_out = 64
    conv1_W = weight_variable(shape=(3,3,1,c1_out))
    #conv1_W = weight_variable(shape=(3,3,3,c1_out))
    conv1_b = bias_variable(shape=(c1_out,))
    conv1 = tf.nn.relu(conv2d(x, conv1_W) + conv1_b)

    pool1 = max_pool2x2(conv1)

    drop1 = tf.nn.dropout(pool1, keep_prob=keep_prob)

    c2_out = 128
    conv2_W = weight_variable(shape=(3,3,c1_out, c2_out))
    conv2_b = bias_variable(shape=(c2_out,))
    conv2 = tf.nn.relu(conv2d(drop1, conv2_W) + conv2_b)

    pool2 = max_pool2x2(conv2)

    drop2 = tf.nn.dropout(pool2, keep_prob=keep_prob)

    fc0 = tf.concat([flatten(drop1), flatten(drop2)],1 )

    fc1_out = 64
    fc1_W = weight_variable(shape=(fc0.shape[1].value, fc1_out))
    fc1_b = bias_variable(shape=(fc1_out,))
    fc1 = tf.matmul(fc0, fc1_W) + fc1_b

    drop_fc1 = tf.nn.dropout(fc1, keep_prob=keep_prob)

    fc2_out = n_classes
    fc2_W = weight_variable(shape=(drop_fc1.shape[1].value, fc2_out))
    fc2_b = bias_variable(shape=(fc2_out,))
    logits = tf.matmul(drop_fc1, fc2_W) + fc2_b

    return logits

tf.reset_default_graph()
# placeholders
x = tf.placeholder(dtype=tf.float32, shape=(None, 32, 32,1))
#x = tf.placeholder(dtype=tf.float32, shape=(None, 32, 32,3))
y = tf.placeholder(dtype=tf.int64, shape=None)
keep_prob = tf.placeholder(tf.float32)

# training pipeline
lr = 0.0008
logits = my_net(x, n_classes=n_classes)
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y)
loss_function = tf.reduce_mean(cross_entropy)
optimizer = tf.train.AdamOptimizer(learning_rate=lr)
training_operation = optimizer.minimize(loss=loss_function)

correct_prediction = tf.equal(tf.argmax(logits, 1), y)
accuracy_operation = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
saver = tf.train.Saver()

def evaluate(X_data, y_data):
    num_examples = len(X_data)
    total_accuracy = 0
    sess = tf.get_default_session()
    for offset in range(0, num_examples, BATCH_SIZE):
        batch_x, batch_y = X_data[offset:offset+BATCH_SIZE], y_data[offset:offset+BATCH_SIZE]
        accuracy = sess.run(accuracy_operation, feed_dict={x: batch_x, y: batch_y, keep_prob:1.0})
        total_accuracy += (accuracy * len(batch_x))
    return total_accuracy / num_examples

n_classes = 43

def weight_variable(shape, mu=0, sigma=0.1):

initialization = tf.truncated_normal(shape=shape, mean=mu, stddev=sigma)

return tf.Variable(initialization)

def bias_variable(shape, start_val=0.1):

initialization = tf.constant(start_val,shape=shape)

return tf.Variable(initialization)

def conv2d(x, W, strides=[1,1,1,1], padding='SAME'):

return tf.nn.conv2d(input=x, filter=W, strides=strides, padding=padding)

def max_pool2x2(x):

return tf.nn.max_pool(value=x, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')

# network architecture definition

def my_net(x, n_classes):

c1_out = 64

conv1_W = weight_variable(shape=(3,3,1,c1_out))

#conv1_W = weight_variable(shape=(3,3,3,c1_out))

conv1_b = bias_variable(shape=(c1_out,))

conv1 = tf.nn.relu(conv2d(x, conv1_W) + conv1_b)

pool1 = max_pool2x2(conv1)

drop1 = tf.nn.dropout(pool1, keep_prob=keep_prob)

c2_out = 128

conv2_W = weight_variable(shape=(3,3,c1_out, c2_out))

conv2_b = bias_variable(shape=(c2_out,))

conv2 = tf.nn.relu(conv2d(drop1, conv2_W) + conv2_b)

pool2 = max_pool2x2(conv2)

drop2 = tf.nn.dropout(pool2, keep_prob=keep_prob)

fc0 = tf.concat([flatten(drop1), flatten(drop2)],1 )

fc1_out = 64

fc1_W = weight_variable(shape=(fc0.shape[1].value, fc1_out))

fc1_b = bias_variable(shape=(fc1_out,))

fc1 = tf.matmul(fc0, fc1_W) + fc1_b

drop_fc1 = tf.nn.dropout(fc1, keep_prob=keep_prob)

fc2_out = n_classes

fc2_W = weight_variable(shape=(drop_fc1.shape[1].value, fc2_out))

fc2_b = bias_variable(shape=(fc2_out,))

logits = tf.matmul(drop_fc1, fc2_W) + fc2_b

return logits

tf.reset_default_graph()

# placeholders

x = tf.placeholder(dtype=tf.float32, shape=(None, 32, 32,1))

#x = tf.placeholder(dtype=tf.float32, shape=(None, 32, 32,3))

y = tf.placeholder(dtype=tf.int64, shape=None)

keep_prob = tf.placeholder(tf.float32)

# training pipeline

lr = 0.0008

logits = my_net(x, n_classes=n_classes)

cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y)

loss_function = tf.reduce_mean(cross_entropy)

optimizer = tf.train.AdamOptimizer(learning_rate=lr)

training_operation = optimizer.minimize(loss=loss_function)

correct_prediction = tf.equal(tf.argmax(logits, 1), y)

accuracy_operation = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

saver = tf.train.Saver()

def evaluate(X_data, y_data):

num_examples = len(X_data)

total_accuracy = 0

sess = tf.get_default_session()

for offset in range(0, num_examples, BATCH_SIZE):

batch_x, batch_y = X_data[offset:offset+BATCH_SIZE], y_data[offset:offset+BATCH_SIZE]

accuracy = sess.run(accuracy_operation, feed_dict={x: batch_x, y: batch_y, keep_prob:1.0})

total_accuracy += (accuracy * len(batch_x))

return total_accuracy / num_examples

【备注】如果lr大小，如小于0.0001可能需要花费更多训练时间，如果太大，如0.1可能很难提高精度，所以选择合适lr很重要。
定义超参数

EPOCHS = 100
BATCHES_PER_EPOCH = 40
BATCH_SIZE = 128

EPOCHS = 100

BATCHES_PER_EPOCH = 40

BATCH_SIZE = 128

【备注】大家可以根据情况，增加迭代次数，批量大小，批量一般不宜过大，否则将迅速增加训练时间。
7）训练CNN模型

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

    print("Training...")
    print()
    for epoch in range(EPOCHS):
        batch_counter = 0
        for batch_x, batch_y in image_datagen.flow(X_train_norm, y_train, batch_size=BATCH_SIZE):
            batch_counter += 1
            sess.run(training_operation, feed_dict={x: batch_x, y: batch_y, keep_prob:0.9})
            if batch_counter == BATCHES_PER_EPOCH:
                break
        # at epoch end, evaluate accuracy on both training and validation set
        train_accuracy = evaluate(X_train_norm, y_train)
        #validation_accuracy = evaluate(X_validation, y_validation)
        print("EPOCH {} ...".format(epoch+1))
        #print("Training Accuracy = {:.3f}, Validation Accuracy = {:.3f}".format(train_accuracy, validation_accuracy))
        print("Training Accuracy = {:.3f}".format(train_accuracy))
        print()
        saver.save(sess, save_path='./checkpoints/traffic_sign_model.ckpt', global_step=epoch)

with tf.Session() as sess:

sess.run(tf.global_variables_initializer())

print("Training...")

print()

for epoch in range(EPOCHS):

batch_counter = 0

for batch_x, batch_y in image_datagen.flow(X_train_norm, y_train, batch_size=BATCH_SIZE):

batch_counter += 1

sess.run(training_operation, feed_dict={x: batch_x, y: batch_y, keep_prob:0.9})

if batch_counter == BATCHES_PER_EPOCH:

break

# at epoch end, evaluate accuracy on both training and validation set

train_accuracy = evaluate(X_train_norm, y_train)

#validation_accuracy = evaluate(X_validation, y_validation)

print("EPOCH {} ...".format(epoch+1))

#print("Training Accuracy = {:.3f}, Validation Accuracy = {:.3f}".format(train_accuracy, validation_accuracy))

print("Training Accuracy = {:.3f}".format(train_accuracy))

print()

saver.save(sess, save_path='./checkpoints/traffic_sign_model.ckpt', global_step=epoch)

【备注】keep_prob参数控制dropout的比例，这个参数很重要，大家可以修改该参数，看它对精度的影响。
Training...

EPOCH 1 ...
Training Accuracy = 0.224

EPOCH 2 ...
Training Accuracy = 0.339

EPOCH 3 ...
Training Accuracy = 0.400

EPOCH 4 ...
Training Accuracy = 0.452

EPOCH 5 ...
Training Accuracy = 0.508

EPOCH 6 ...
Training Accuracy = 0.548

EPOCH 7 ...
Training Accuracy = 0.587

EPOCH 8 ...
Training Accuracy = 0.609

EPOCH 9 ...
Training Accuracy = 0.658

.......................

EPOCH 90 ...
Training Accuracy = 0.971

EPOCH 91 ...
Training Accuracy = 0.968

EPOCH 92 ...
Training Accuracy = 0.971

EPOCH 93 ...
Training Accuracy = 0.975

EPOCH 94 ...
Training Accuracy = 0.965

EPOCH 95 ...
Training Accuracy = 0.977

EPOCH 96 ...
Training Accuracy = 0.967

EPOCH 97 ...
Training Accuracy = 0.976

EPOCH 98 ...
Training Accuracy = 0.976

EPOCH 99 ...
Training Accuracy = 0.976

EPOCH 100 ...
Training Accuracy = 0.977
【说明】因时间关系，我这里只训练100次，看来精度也还可以，如果增加迭代次数，可以达到99%左右
8）用测试数据验证模型

with tf.Session() as sess:

    # restore saved session with highest validation accuracy
    saver.restore(sess, './checkpoints/traffic_sign_model.ckpt-99')
    test_accuracy = evaluate(X_test_norm, y_test)
    print('Performance on test set: {:.3f}'.format(test_accuracy))
INFO:tensorflow:Restoring parameters from ./checkpoints/traffic_sign_model.ckpt-99
Performance on test set: 0.911

with tf.Session() as sess:

# restore saved session with highest validation accuracy

saver.restore(sess, './checkpoints/traffic_sign_model.ckpt-99')

test_accuracy = evaluate(X_test_norm, y_test)

print('Performance on test set: {:.3f}'.format(test_accuracy))

INFO:tensorflow:Restoring parameters from ./checkpoints/traffic_sign_model.ckpt-99

Performance on test set: 0.911

26.3 实例2（使用LeNet神经网络）

待续

本文将介绍如何使用 Keras + Tensorflow1.6，python为3.6 创建卷积神经网络，并对其进行训练，以使得车辆保持在两条白线之间,如下图：

import os
import urllib.request
import pickle
%matplotlib inline
import matplotlib
from matplotlib.pyplot import imshow

import os

import urllib.request

import pickle

%matplotlib inline

import matplotlib

from matplotlib.pyplot import imshow

下载数据

#downlaod driving data (450Mb) 
data_url = 'https://s3.amazonaws.com/donkey_resources/indoor_lanes.pkl'
file_path, headers = urllib.request.urlretrieve(data_url)
print(file_path)

#downlaod driving data (450Mb)

data_url = 'https://s3.amazonaws.com/donkey_resources/indoor_lanes.pkl'

file_path, headers = urllib.request.urlretrieve(data_url)

print(file_path)

备注：由于下载经常出现超时情况，大家可以先下载该文件，然后放到指定目录。

file_path='./autocar/indoor_lanes.pkl'

1	file_path='./autocar/indoor_lanes.pkl'

步骤1：获取驾驶数据

数据集由 ~7900 个图像和手动开车时收集的转向角组成。大约三分之二的图像与线之间的汽车。另外三分之一的车开始偏离航线，并且驶回线路之间。
数据集由 2 个 pickled 数组组成。X 是图像阵列，Y 是相应转向角度的阵列。

#抽取数据
with open(file_path, 'rb') as f:
    X, Y = pickle.load(f)

print('X.shape: ', X.shape)
print('Y.shape: ', Y.shape)
imshow(X[0])

#抽取数据

with open(file_path, 'rb') as f:

X, Y = pickle.load(f)

print('X.shape: ', X.shape)

print('Y.shape: ', Y.shape)

imshow(X[0])

打印结果
X.shape: (7892, 120, 160, 3)
Y.shape: (7892,)

步骤2：拆分数据

在这里，对数据进行洗牌（shuffle），并将数据分成三部分。训练数据将用于训练我们的驾驶模型，使用验证数据避免过度拟合模型，测试数据用于测试我们的模型。

import numpy as np
#用shuffle把数据打乱
def unison_shuffled_copies(X, Y):
    assert len(X) == len(Y)
    p = np.random.permutation(len(X))
    return X[p], Y[p]

shuffled_X, shuffled_Y = unison_shuffled_copies(X,Y)

len(shuffled_X)

import numpy as np

#用shuffle把数据打乱

def unison_shuffled_copies(X, Y):

assert len(X) == len(Y)

p = np.random.permutation(len(X))

return X[p], Y[p]

shuffled_X, shuffled_Y = unison_shuffled_copies(X,Y)

len(shuffled_X)

打印结果
7892

test_cutoff = int(len(X) * .8) # 80% of data used for training
val_cutoff = test_cutoff + int(len(X) * .1) # 10% of data used for validation and test data 

train_X, train_Y = shuffled_X[:test_cutoff], shuffled_Y[:test_cutoff]
val_X, val_Y = shuffled_X[test_cutoff:val_cutoff], shuffled_Y[test_cutoff:val_cutoff]
test_X, test_Y = shuffled_X[val_cutoff:], shuffled_Y[val_cutoff:]

len(train_X) + len(val_X) + len(test_X)

test_cutoff = int(len(X) * .8) # 80% of data used for training

val_cutoff = test_cutoff + int(len(X) * .1) # 10% of data used for validation and test data

train_X, train_Y = shuffled_X[:test_cutoff], shuffled_Y[:test_cutoff]

val_X, val_Y = shuffled_X[test_cutoff:val_cutoff], shuffled_Y[test_cutoff:val_cutoff]

test_X, test_Y = shuffled_X[val_cutoff:], shuffled_Y[val_cutoff:]

len(train_X) + len(val_X) + len(test_X)

打印结果
7892

步骤3：增强训练数据

为了加倍我们的训练数据并防止转向偏差，我们翻转每个图像和转向角并将其添加到数据集中。还有其他的方法来增加使用翻译和假阴影驾驶数据，但我没有使用这些自动驾驶仪。

X_flipped = np.array([np.fliplr(i) for i in train_X])
Y_flipped = np.array([-i for i in train_Y])
train_X = np.concatenate([train_X, X_flipped])
train_Y = np.concatenate([train_Y, Y_flipped])
len(train_X)

X_flipped = np.array([np.fliplr(i) for i in train_X])

Y_flipped = np.array([-i for i in train_Y])

train_X = np.concatenate([train_X, X_flipped])

train_Y = np.concatenate([train_Y, Y_flipped])

len(train_X)

打印结果
12626

步骤4：创建驾驶模式

这种驾驶模式将是一个端到端的神经网络，接受图像阵列作为输入，并输出-90（左）和90（右）之间的转向角。要做到这一点，我们将使用一个完全连接图层的3层卷积网络。该模型基于 Otavio 的 Carputer，但不产生油门值输出，不使用过去的转向值作为模型的输入，并且使用较少的卷积层。

from tensorflow.python.keras.models import Model, load_model
from tensorflow.python.keras.layers import Input, Convolution2D, MaxPooling2D, Activation, Dropout, Flatten, Dense
from tensorflow.python.keras import backend as K

from tensorflow.python.keras.models import Model, load_model

from tensorflow.python.keras.layers import Input, Convolution2D, MaxPooling2D, Activation, Dropout, Flatten, Dense

from tensorflow.python.keras import backend as K

使用 TensorFlow 后端。
查看目前image数据格式，是tensorflow格式（channels_last）还是theano格式（channels_first）

K.image_data_format()

1	K.image_data_format()

'channels_last'

如果不是tensorflow格式，可以通过K.set_image_data_format('channels_last')进行修改，或修改~/.keras/keras.json文件。前者只对当前会话有效，后者修改，将永久有效。

img_in = Input(shape=(120, 160, 3), name='img_in')
angle_in = Input(shape=(1,), name='angle_in')

x = Convolution2D(8, kernel_size=(3, 3),strides=(1,1))(img_in)
x = Activation('relu')(x)
x = MaxPooling2D(pool_size=(2, 2))(x)

x = Convolution2D(16, kernel_size=(3, 3),strides=(1,1))(x)
x = Activation('relu')(x)
x = MaxPooling2D(pool_size=(2, 2))(x)

x = Convolution2D(32, kernel_size=(3, 3),strides=(1,1))(x)
x = Activation('relu')(x)
x = MaxPooling2D(pool_size=(2, 2))(x)

merged = Flatten()(x)

x = Dense(256)(merged)
x = Activation('linear')(x)
x = Dropout(.2)(x)

angle_out = Dense(1, name='angle_out')(x)

model = Model(inputs=[img_in], outputs=[angle_out])
model.compile(optimizer='adam', loss='mean_squared_error')
model.summary()

img_in = Input(shape=(120, 160, 3), name='img_in')

angle_in = Input(shape=(1,), name='angle_in')

x = Convolution2D(8, kernel_size=(3, 3),strides=(1,1))(img_in)

x = Activation('relu')(x)

x = MaxPooling2D(pool_size=(2, 2))(x)

x = Convolution2D(16, kernel_size=(3, 3),strides=(1,1))(x)

x = Activation('relu')(x)

x = MaxPooling2D(pool_size=(2, 2))(x)

x = Convolution2D(32, kernel_size=(3, 3),strides=(1,1))(x)

x = Activation('relu')(x)

x = MaxPooling2D(pool_size=(2, 2))(x)

merged = Flatten()(x)

x = Dense(256)(merged)

x = Activation('linear')(x)

x = Dropout(.2)(x)

angle_out = Dense(1, name='angle_out')(x)

model = Model(inputs=[img_in], outputs=[angle_out])

model.compile(optimizer='adam', loss='mean_squared_error')

model.summary()

打印结果
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
img_in (InputLayer) (None, 120, 160, 3) 0
_________________________________________________________________
conv2d_1 (Conv2D) (None, 118, 158, 8) 224
_________________________________________________________________
activation_1 (Activation) (None, 118, 158, 8) 0
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 59, 79, 8) 0
_________________________________________________________________
conv2d_2 (Conv2D) (None, 57, 77, 16) 1168
_________________________________________________________________
activation_2 (Activation) (None, 57, 77, 16) 0
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 28, 38, 16) 0
_________________________________________________________________
conv2d_3 (Conv2D) (None, 26, 36, 32) 4640
_________________________________________________________________
activation_3 (Activation) (None, 26, 36, 32) 0
_________________________________________________________________
max_pooling2d_3 (MaxPooling2 (None, 13, 18, 32) 0
_________________________________________________________________
flatten_1 (Flatten) (None, 7488) 0
_________________________________________________________________
dense_1 (Dense) (None, 256) 1917184
_________________________________________________________________
activation_4 (Activation) (None, 256) 0
_________________________________________________________________
dropout_1 (Dropout) (None, 256) 0
_________________________________________________________________
angle_out (Dense) (None, 1) 257
=================================================================
Total params: 1,923,473
Trainable params: 1,923,473
Non-trainable params: 0

步骤5：训练模型

我们已经学会了很难的方法，即使这一切都是完美的，如果你没有正确地训练，你的自动驾驶仪将无法工作。我遇到的最大的问题是过度适应模型，以至于在很少的情况下都不能正常工作。这里是 2 个 Keras回调，将节省您的时间。警告 - 如果仅使用CPU，则需要较长时间，这里我采用GPU进行训练

import os
from tensorflow.python.keras import callbacks

model_path = os.path.expanduser('~/best_autopilot.hdf5')

#Save the model after each epoch if the validation loss improved.
save_best = callbacks.ModelCheckpoint(model_path, monitor='val_loss', verbose=1, 
                                     save_best_only=True, mode='min')

#stop training if the validation loss doesn't improve for 5 consecutive epochs.
early_stop = callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=5, 
                                     verbose=0, mode='auto')

callbacks_list = [save_best, early_stop]

import os

from tensorflow.python.keras import callbacks

model_path = os.path.expanduser('~/best_autopilot.hdf5')

#Save the model after each epoch if the validation loss improved.

save_best = callbacks.ModelCheckpoint(model_path, monitor='val_loss', verbose=1,

save_best_only=True, mode='min')

#stop training if the validation loss doesn't improve for 5 consecutive epochs.

early_stop = callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=5,

verbose=0, mode='auto')

callbacks_list = [save_best, early_stop]

因时间关系，这里只进行 10 次迭代（epochs），训练时间2分钟左右，比较快。

model.fit(train_X, train_Y, batch_size=64, epochs=10, validation_data=(val_X, val_Y), callbacks=callbacks_list)

1	model.fit(train_X, train_Y, batch_size=64, epochs=10, validation_data=(val_X, val_Y), callbacks=callbacks_list)

运行结果
Train on 12626 samples, validate on 789 samples
Epoch 1/10
12608/12626 [============================>.]12608/12626 [============================>.] - ETA: 0s - loss: 41288.4184
Epoch 00001: val_loss improved from inf to 656.89127, saving model to /home/wumg/best_autopilot.hdf5
12626/12626 [==============================]12626/12626 [==============================] - 22s 2ms/step - loss: 41230.2161 - val_loss: 656.8913

Epoch 2/10
12608/12626 [============================>.]12608/12626 [============================>.] - ETA: 0s - loss: 550.5565
Epoch 00002: val_loss improved from 656.89127 to 543.14232, saving model to /home/wumg/best_autopilot.hdf5
12626/12626 [==============================]12626/12626 [==============================] - 15s 1ms/step - loss: 550.1622 - val_loss: 543.1423

Epoch 3/10
12608/12626 [============================>.]12608/12626 [============================>.] - ETA: 0s - loss: 476.8377
Epoch 00003: val_loss improved from 543.14232 to 417.43844, saving model to /home/wumg/best_autopilot.hdf5
12626/12626 [==============================]12626/12626 [==============================] - 15s 1ms/step - loss: 476.6054 - val_loss: 417.4384

Epoch 4/10
12608/12626 [============================>.]12608/12626 [============================>.] - ETA: 0s - loss: 420.1108
Epoch 00004: val_loss improved from 417.43844 to 416.97928, saving model to /home/wumg/best_autopilot.hdf5
12626/12626 [==============================]12626/12626 [==============================] - 15s 1ms/step - loss: 420.0584 - val_loss: 416.9793

Epoch 5/10
12608/12626 [============================>.]12608/12626 [============================>.] - ETA: 0s - loss: 399.4089
Epoch 00005: val_loss did not improve
12626/12626 [==============================]12626/12626 [==============================] - 15s 1ms/step - loss: 399.0109 - val_loss: 420.7120

Epoch 6/10
12608/12626 [============================>.]12608/12626 [============================>.] - ETA: 0s - loss: 373.5299
Epoch 00006: val_loss improved from 416.97928 to 411.31800, saving model to /home/wumg/best_autopilot.hdf5
12626/12626 [==============================]12626/12626 [==============================] - 15s 1ms/step - loss: 373.7999 - val_loss: 411.3180

Epoch 7/10
12608/12626 [============================>.]12608/12626 [============================>.] - ETA: 0s - loss: 356.3707
Epoch 00007: val_loss improved from 411.31800 to 384.65238, saving model to /home/wumg/best_autopilot.hdf5
12626/12626 [==============================]12626/12626 [==============================] - 15s 1ms/step - loss: 356.4031 - val_loss: 384.6524

Epoch 8/10
12608/12626 [============================>.]12608/12626 [============================>.] - ETA: 0s - loss: 338.6780
Epoch 00008: val_loss did not improve
12626/12626 [==============================]12626/12626 [==============================] - 15s 1ms/step - loss: 338.4380 - val_loss: 435.1508

Epoch 9/10
12608/12626 [============================>.]12608/12626 [============================>.] - ETA: 0s - loss: 325.1715
Epoch 00009: val_loss improved from 384.65238 to 348.49219, saving model to /home/wumg/best_autopilot.hdf5
12626/12626 [==============================]12626/12626 [==============================] - 15s 1ms/step - loss: 325.0649 - val_loss: 348.4922

Epoch 10/10
12608/12626 [============================>.]12608/12626 [============================>.] - ETA: 0s - loss: 304.1439
Epoch 00010: val_loss did not improve
12626/12626 [==============================]12626/12626 [==============================] - 15s 1ms/step - loss: 304.2825 - val_loss: 349.3760

步骤6：评估性能

我们可以通过绘制预测值和实际值来检查我们的模型预测是否合理。第一个图表显示我们的测试数据中存在一个学习关系（在训练期间,部分测试数据我们的模型没有注意到）。

import pandas as pd

model = load_model(model_path)
test_P = model.predict(test_X)
test_P = test_P.reshape((test_P.shape[0],)) 


df = pd.DataFrame({'predicted':test_P, 'actual':test_Y})
ax = df.plot.scatter('predicted', 'actual')

import pandas as pd

model = load_model(model_path)

test_P = model.predict(test_X)

test_P = test_P.reshape((test_P.shape[0],))

df = pd.DataFrame({'predicted':test_P, 'actual':test_Y})

ax = df.plot.scatter('predicted', 'actual')

第二张图，使用包含训练数据的非混洗（unshuffled）数据，来显示预测角度紧跟实际转向角度。

P = model.predict(X[:700])
#predict outputs nested arrays so we need to reshape to plot.
P = P.reshape((P.shape[0],)) 

ax = pd.DataFrame({'predicted':P, 'actual':Y[:700]}).plot()
ax.set_ylabel("steering angle")

P = model.predict(X[:700])

#predict outputs nested arrays so we need to reshape to plot.

P = P.reshape((P.shape[0],))

ax = pd.DataFrame({'predicted':P, 'actual':Y[:700]}).plot()

ax.set_ylabel("steering angle")

后续可进一步完善

改善模型，这个模型是纯粹（navie）的，因为它不使用过去的值来帮助预测未来。我们可以通过将过去的转向角度作为模型的输入来进行试验，添加一个递归层，或者只是改变卷积层的结构。
添加更多数据，随着我们添加更多驾驶数据，此模型将会得到改进。预测油门，输出目前自动驾驶仪只能转向并保持恒定的速度。一个更复杂的模型将加速在直路上，并在路缘之前放缓。

机器学习、深度学习有三块基石：线性代数、概率与信息论、数值分析。线性代数上章已介绍，数值分析后续将介绍，三块基石缺一块都会地动山摇。本章讨论概率和信息论，概率是用于表示不确定性陈述的数学框架，即它是对事物不确定性的度量，而信息论主要研究信号或随机变量所包含的信息量。
在人工智能领域，概率法则告诉我们AI系统应该如何推理，概率和统计从理论上分析我们提出的AI系统的行为。
计算机科学的许多分支处理的对象都是完全确定的实体，但机器学习却大量使用概率。如果你了解机器学习的工作原理，或许你有更深的体会。因为机器学习大部分时候处理的都是不确定量或随机量。
概率论和信息论是众多学科的基础，也是机器学习、深度学习的重要基础。
如果你对概率论和信息论很熟悉了，可以跳过这章。如果你觉得本章内容还不够，希望进一步了解更多，可以参考相关专业教材。本章主要内容包括：

为何要学概率与信息论
样本空间与随机变量
概率分布
边缘概率
条件概率
期望、方差及协方差
贝叶斯定理
信息论

4.1为何要学概率、信息论

机器学习、深度学习需要借助概率、信息论？
概率研究对象不是预先知道或确定的事情，而是预先不确定或随机的事件，研究这些不确定或随机事件背后的规律或规则。或许有人会说，这些不确定或随机事件有啥好研究？他们本来就不确定或随机的，飘忽不定、不可捉摸。表面上看似如此，有句话说得好：偶然中有必然，必然中有偶然。就拿我们比较熟悉微积分来说吧，如果单看有限的几步，很多问题都显得杂乱无章，毫无规律可言，而且还很难处理，但是一旦加上一个无穷大（∞）这个“照妖镜”，其背后规律立显，原来难处理的也好处理了。如大数定律、各种分布等带给我们这样的认识。
信息论主要研究对一个信号包含信息的多少进行量化。它的基本思想是一个不太可能的事件居然发生了，其提供的信息量要比一个非常可能发生的事件更多。这中情况也似乎与我们的直觉相矛盾。
机器学习、深度学习与概率、信息论有哪些内在关联呢？
（1）被建模系统内在的随机性。例如一个假想的纸牌游戏，在这个游戏中我们假设纸牌被真正混洗成了随机顺序。
（2不完全观测。即使是确定的系统，当我们不能观测到所有驱动系统行为的所有变量或因素时，该系统也会呈现随机性。
（3）不完全建模。假设我们制作了一个机器人，它可以准确观察周围每一个对象的位置。在对这些对象将来的位置进行预测时，如果机器人采用的是离散化的空间，那么离散化的方法将使得机器人无法确定对象们的精确位置：因为每个对象都可能处于它被观测到的离散单元的任何一个角落。也就是说，当不完全建模时，我们不能明确的确定结果，这个时候的不确定，就需要借助概率来处理。
由此看来，概率、信息论很重要，机器学习、深度学习确实很需要它们。后续我们可以看到很多实例，见证概率、信息论在机器学习、深度学习中是如何发挥它们作用的。

4.2样本空间与随机变量

随机试验中，每一个可能的结果，在试验中发生与否，都带有随机性，所以称为随机事件。而所有可能结果构成的全体，称为样本空间。随机变量、样本空间这两个概念非常重要，以下就这两个概念作进一步说明。
样本空间
样本空间是一个实验或随机试验所有可能结果的集合，随机试验中的每个可能结果称为样本点。例如，如果抛掷一枚硬币，那么样本空间就是集合{正面，反面}。如果投掷一个骰子，那么样本空间就是{1,2,3,4,5,6}。
随机变量
随机变量，顾名思义，就是“其值随机而定”的变量，一个随机试验有许多可能结果，到底出现哪个预先是不知道的，其结果只有等到试验完成后，才能确定。如掷骰子，掷出的点数X是一个随机变量，它可以取1,2,3,4,5,6中的任何一个，到底是哪一个，要等掷了骰子以后才知道。因此，随机变量又是试验结果的函数，它为每一个试验结果分配一个值。比如，在一次扔硬币事件中，如果把获得的背面的次数作为随机变量X,则X可以取两个值，分别是0和1。如果随机变量X的取值是有限的或者是可数无穷尽的值，如：
则称 X为离散随机变量。如果X由全部实数或者由一部分区间组成，如：
X={x| a≤x≤b},其中a<b,它们都为实数。
则称 X为连续随机变量，连续随机变量的取值是不可数及无穷尽的。
有些随机现象需要同时用多个随机变量来描述。例如对地面目标射击，弹着点的位置需要两个坐标(X,Y）才能确定，X,Y都是随机变量，而（X,Y）称为一个二维随机变量或二维随机向量，多维随机向量含义依次类推。

4.3概率分布

概率分布用来描述随机变量（含随机向量）在每一个可能状态的可能性大小。概率分布有不同方式，这取决于随机变量是离散的还是连续的。
对于随机变量X,其概率分布通常记为P(X=x),或X ~P(x)，表示X服从概率分布P(x)。
概率分布描述了取单点值的可能性或概率，但在实际应用中，我们并不关心取某一值的概率，特别是对连续型随机变量，它在某点的概率都是0，这个后续章节将介绍。因此，我们通常比较关心随机变量落在某一区间的概率，为此，引入分布函数的概念。

4.3.1 离散型随机变量

设x_1，x_2，…，x_n是随机变量X的所有可能取值，对每个取值x_i，X = x_i是其样本空间S上的一个事件，为描述随机变量X，还需知道这些事件发生的可能性(概率)。
设离散型随机变量X的所有可能取值为x_i (i=1，2，…,n)。
P(X = x_i) = P_i,i= 1,2,...n
称之为X的概率分布或分布律，也称概率函数。
常用表格形式来表示X的概率分布:

例1：某篮球运动员投中篮圈的概率是0.8，求他两次独立投篮投中次数X的概率分布。

且P(X=0)+P(X=1)+P(X=2)=0.04+0.32+0.64=1
于是随机变量X的概率分布可表示为：
X 0 1 2
P_i 0.04 0.32 0.64
若已知一个离散型随机变量X的概率分布：

例如，设X的概率分布由例1给出，则
F(2)=P(X≤2)=P(X=0)+P(X=l)=0.04+0.32=0.36
常见的离散随机变量的分布有：
（1）两点分布
若随机变量X只可能取0和1两个值，且它的分布列为P(X=1)=p，P(X = 0) = l − P其中(0 < P < 1)，则称X服从参数为p的两点分布，记作X~B(1, p)。其分布函数为

（2）二项分布
二项分布是重要的离散概率分布之一，由瑞士数学家雅各布•伯努利（Jokab Bernoulli）提出。一般用二项分布来计算概率的前提是，每次抽出样品后再放回去，并且只能有两种试验结果，比如黑球或红球，正品或次品等。二项分布指出，假设某样品在随机一次试验出现的概率为p，那么在n次试验中出现k次的概率为：

假设随机变量X满足二项分布，且知道n，p，k等参数，我们如何求出各种情况的概率值呢？方法比较多，这里介绍一种比较简单的方法，利用scipy库的统计接口stats即可，具体如下：

import numpy as np  
import matplotlib.pyplot as plt  
import math  
from scipy import stats  
%matplotlib inline

n = 20  
p = 0.3  
k = np.arange(0,41)  
#定义二项分布
binomial = stats.binom.pmf(k,n,p)  

#二项分布可视化 
plt.plot(k, binomial, 'o-')  
plt.title('binomial:n=%i,p=%.2f'%(n,p),fontsize=15)  
plt.xlabel('number of success')  
plt.ylabel('probalility of success', fontsize=15)  
plt.grid(True)  
plt.show()

import numpy as np

import matplotlib.pyplot as plt

import math

from scipy import stats

%matplotlib inline

n = 20

p = 0.3

k = np.arange(0,41)

#定义二项分布

binomial = stats.binom.pmf(k,n,p)

#二项分布可视化

plt.plot(k, binomial, 'o-')

plt.title('binomial:n=%i,p=%.2f'%(n,p),fontsize=15)

plt.xlabel('number of success')

plt.ylabel('probalility of success', fontsize=15)

plt.grid(True)

plt.show()

运行后的二项分布图如图4-1所示。

图4-1 二项分布图
（3）泊松(Poisson)分布
若随机变量X所有可能取值为0，1，2，…，它取各个值的概率为：

这里介绍了离散型随机变量的分布情况，如果X是连续型随机变量，其分布函数通常通过密度函数来描述，具体请看下一节。

4.3.2 连续型随机变量

与离散型随机变量不同，连续型随机变量采用概率密度函数来描述变量的概率分布。如果一个函数f(x)是密度函数，满足以下三个性质，我们就称f(x)为概率密度函数。
（1）f(x)≥0,注意这里不要求f(x)≤1。

图4-2 概率密度函数
对连续型随机变量在任意一点的概率处处为0。

最常见的正态分布的密度函数为：

这个连续分布被称之为正态分布，或者高斯分布。其密度函数的曲线呈对称钟形，因此又被称之为钟形曲线，其中μ是平均值，σ是标准差（何为平均值、标准差后续我们会介绍）。正态分布是一种理想分布。
正态分布如何用Python实现呢？同样，我们可以借助其scipy库中stats来实现，非常方便。

import numpy as np
import matplotlib.pyplot as plt 
from scipy import stats  
%matplotlib inline

#平均值或期望值
mu=0     
#标准差
sigma1=1 
sigma2=2 

#随机变量的取值
x=np.arange(-6,6,0.1)
y1=stats.norm.pdf(x,0,1) #定义正态分布的密度函数
y2=stats.norm.pdf(x,0,2) #定义正态分布的密度函数
plt.plot(x,y1,label='sigma is 1')
plt.plot(x,y2,label='sigma is 2')
plt.title('normal $\mu$=%.1f,$\sigma$=%.1f or %.1f '%(mu,sigma1,sigma2))
plt.xlabel('x')
plt.ylabel('probability density')
plt.legend(loc='upper left')
plt.show()

import numpy as np

import matplotlib.pyplot as plt

from scipy import stats

%matplotlib inline

#平均值或期望值

mu=0

#标准差

sigma1=1

sigma2=2

#随机变量的取值

x=np.arange(-6,6,0.1)

y1=stats.norm.pdf(x,0,1) #定义正态分布的密度函数

y2=stats.norm.pdf(x,0,2) #定义正态分布的密度函数

plt.plot(x,y1,label='sigma is 1')

plt.plot(x,y2,label='sigma is 2')

plt.title('normal $\mu$=%.1f,$\sigma$=%.1f or %.1f '%(mu,sigma1,sigma2))

plt.xlabel('x')

plt.ylabel('probability density')

plt.legend(loc='upper left')

plt.show()

sigmal系统与正态分布如图4-3所示。

图4-3 sigmal系统与正态分布
正态分布的取值可以从负无穷到正无穷。这里我们为便于可视化，只取把X数据定义在[-6,6]之间，用stats.norm.pdf得到正态分布的概率密度函数。另外从图形可以看出，上面两图的均值u都是0，只是标准差（σ）不同，这就导致图像的离散程度不同，标准差大的更分散，个中原因，我们在介绍随机变量的数字特征时将进一步说明。

4.4边缘概率

对于多维随机变量，如二维随机变量(X,Y),假设其联合概率分布为F(x,y),我们经常遇到求其中一个随机变量的概率分布的情况。这种定义在子集上的概率分布称为边缘概率分布。
例如，假设有两个离散的随机变量X,Y,且知道P(X,Y),那么我们可以通过下面求和的方法，得到边缘概率P(X):

边缘概率如何计算呢？我们通过一个实例来说明。假设有两个离散型随机变量X,Y，其联合分布概率如表4-1所示。
表4-1：X与Y的联合分布

如果我们要求P(Y=0)的边缘概率，根据式（4.7）可得：
P(Y=0)=P(X=1,Y=0)+P(X=2,Y=0)=0.05+0.28=0.33

4.5条件概率

上一节我们介绍了边缘概率，它是多维随机变量一个子集（或分量）上的概率分布。对于含多个随机变量的事件中，经常遇到求某个事件在其他事件发生的概率，例如，在表4-1的分布中，假设我们要求当Y=0的条件下，求X=1的概率？这种概率叫作条件概率。条件概率如何求？我们先看一般情况。
设有两个随机变量X,Y,我们将把X=x，Y=y发生的条件概率记为P(Y=y|X=x),那么这个条件概率可以通过以下公式计算：

其中P(Y=0)是一个边缘概率，其值为：P(X=1,Y=0)+P(X=2,Y=0)=0.05+0.28=0.33
而P(X=1，Y=0)=0.05.故P(X=1|Y=0)=0.05/0.33=5/33
式（4.10）为离散型随机变量的条件概率，对连续型随机变量也有类似公式。假设（X,Y）为二维连续型随机变量，它们的密度函数为f(x,y),关于Y的边缘概率密度函数为f_Y (y),且满足f_Y (y)>0,假设

在X=x的条件下，关于Y的条件分布函数为：

4.6条件概率的链式法则

4.7独立性及条件独立性

两个随机变量X,Y,如果它们的概率分布可以表示为两个因子的乘积，且一个因子只含x，另一个因子只含y，那么我们就称这两个随机变量互相独立。这句话可能不好理解，我们换一种方式的来表达。或许更好理解。
如果对∀x∈X,y∈Y,P(X=x,Y=y)=P(X=x)P(Y=y) 成立，那么随机变量X,Y互相独立。
在机器学习中，随机变量为互相独立的情况非常普遍，一旦互相独立，联合分布的计算就变得非常简单。
这是不带条件的随机变量的独立性定义，如果两个随机变量带有条件，如P(X,Y|Z),它的独立性如何定义呢？这个与上面的定义类似。具体定义如下：
如果对∀x∈X,y∈Y,z∈Z,P(X=x,Y=y|Z=z)=P(X=x|Z=z)P(Y=y|Z=z) 成立
那么随机变量X,Y在给定随机变量Z时是条件独立的。
为便于表达，如果随机变量X,Y互相独立，又可记为X⊥Y,如果随机变量X,Y在给定时互相独立，则可记为X⊥Y|Z。
以上主要介绍离散型随机变量的独立性和条件独立性，如果是连续型随机变量，我们只要把概率换成随机变量的密度函数即可。

4.8期望、方差及协方差

在机器学习、深度学习中经常需要分析随机变量的数据特征及随机变量间的关系等，对于这些指标的衡量在概率统计中有相关的内容，如用来衡量随机变量的取值大小的期望(Expectation)值或平均值、衡量随机变量数据离散程度的方差(Variance)、揭示随机向量间关系的协调方差(Convariance)等。这些衡量指标的定义及公式就是本节主要内容。
首先我们看随机变量的数学期望的定义：
对离散型随机变量X,设其分布律为：

如果是随机变量函数，如随机变量X的g(x)的期望，公式与式（4.21）或式（4.22）类似，只要把x换成g(x)即可，即随机变量函数g(x)的期望为：

期望有一些重要性质，具体如下：
设a,b为一个常数，X和Y是两个随机变量。则有：
（1）E(a)=a
（2）E(aX)=aE(X)
（3）E(aX+bY)=aE(X)+bE(Y) (4.25)
（4）当X和Y相互独立时，则有：
E(XY)=E(X)E(Y) (4.26)
数学期望也常称为均值，即随机变量取值的平均值之意，当然这个平均，是指以概率为权的加权平均。期望值可大致描述数据的大小，但无法描述数据的离散程度，这里我们介绍一种刻画随机变量在其中心位置附近离散程度的数字特征，即方差。如何定义方差？
假设随机向量X有均值E(X)=a。试验中，X取的值当然不一定恰好是a，可能会有所偏离。偏离的量X-a本身也是一个随机变量。如果我们用X-a来刻画随机变量X的离散程度，当然不能取X-a的均值，因E(X-a)=0 ,说明正负偏离抵消了，当然我们可以取|X-a|这样可以防止正负抵消的情况，但绝对值在实际运算时很不方便。人们就考虑另一种方法，先对
方差的平方根被称为标准差。
对于多维随机向量，如二维随机向量(X,Y)如何刻画这些分量间的关系？显然均值、方差都无能为力。这里我们引入协方差的定义，我们知道方差是X-EX乘以X-EX的均值，如果我们把其中一个换成Y-EY，就得到E(X-EX)(Y-EY),其形式接近方差，又有X,Y两者的参与，由此得出协方差的定义，随机变量X,Y的协方差，记为：Cov(X,Y)
Cov(X,Y) =E(X-EX)(Y-EY) (4.28)
协方差的另一种表达方式：
Cov(X,Y) =E(XY)-EX×EY (4.29)
方差可以用来衡量随机变量与均值的偏离程度或随机变量取值的离散度，而协方差则可衡量随机变量间的相关性强度，如果X与Y独立，那么它们的协方差为0。反之，并不一定成立，独立性比协方差为0的条件更强。不过如果随机变量X、Y都是正态分布，此时独立和协方差为0是一个概念。
当协方差为正时，表示随机变量X、Y为正相关；如果协方差为负，表示随机变量X、Y为负相关。
为了更好的衡量随机变量间的相关性，我们一般使用相关系数来衡量，相关系数将每个变量的贡献进行归一化，使其只衡量变量的相关性而不受各变量尺寸大小的影响，相关系统的计算公式如下：
ρ_xy=(Cov(X,Y))/(√(Var(X)) √(Var(Y))) (4.30)
由式（4.30）可知，相关系统是在协方差的基础上进行了正则化，从而把相关系数的值限制在[-1,1]之间。如果ρ_xy=1，说明随机变量X、Y是线性相关的，即可表示为Y=kX+b，其中k，b为任意实数，且k>0;如果ρ_xy=-1，说明随机变量X、Y是负线性相关的，即可表示为Y=-kX+b，其中k>0。
上面我们主要以两个随机变量为例，实际上协方差可以推广到n个随机变量的情况或n维的随机向量。对n维的随机向量，我们可以的第一个nxn的协方差矩阵，而且满足：

求随机变量的方差、协方差、相关系统等，使用Python的numpy相关的函数，如用numpy.var求方差，numpy.cov求协方差，使用numpy.corrcoef求相关系数，比较简单，这里就不展开来说。
在机器学习中多维随机向量，通常以矩阵的方式出现，所以求随机变量间的线性相关性，就转换为求矩阵中列或行的线性相关性。这里我们举一个简单实例，来说明如果分析向量间的线性相关性并可视化结果。这个例子中使用的随机向量（或特征值）共有三个，一个是气温(temp),一个体感温度(atemp),一个是标签（label）说明共享单车每日出租量，以下是这三个特征的部分数据：
表4-2 共享单车示例数据

这里使用Python中数据分析库pandas及画图库matplotlib、sns等。

###探索特征间分布、相关性等
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline

data1=pd.read_csv('./bike/hour.csv',header=0)
#data_pd=data1.toPandas()
sns.set(style='whitegrid',context='notebook')
cols=['temp','atemp','label']
sns.pairplot(data1[cols],size=2.5)
plt.show()

###探索特征间分布、相关性等

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

%matplotlib inline

data1=pd.read_csv('./bike/hour.csv',header=0)

#data_pd=data1.toPandas()

sns.set(style='whitegrid',context='notebook')

cols=['temp','atemp','label']

sns.pairplot(data1[cols],size=2.5)

plt.show()

从图4-4可以看出，特征temp与atemp是线性相关的，其分布接近正态分布。

图4-4 特征分布及相关性

4.9贝叶斯定理

贝叶斯定理是概率论中的一个定理，它跟随机变量的条件概率以及边缘概率分布有关。在有些关于概率的解释中，贝叶斯定理（贝叶斯公式）能够告知我们如何利用新证据修改已有的看法。这个名称来自于托马斯•贝叶斯。
通常，事件A在事件B（发生）的条件下的概率，与事件B在事件A（发生）的条件下的概率是不一样的；然而，这两者是有确定的关系的，贝叶斯定理就是这种关系的陈述。贝叶斯公式的一个用途在于通过已知的三个概率函数推出第四个。
贝叶斯公式为：
P(B|A)=(P(B)P(A|B))/(P(A)) (4.31)
在贝叶斯定理中，每项都有约定俗成的名称：

P(B|A)是已知A发生后B的条件概率，也由于得自A的取值而被称作B的后验概率。
P(B)是B的先验概率（或边缘概率）。之所以称为"先验"是因为它不考虑任何A方面的因素。
P(A|B)是已知B发生后A的条件概率，也称为似然（likelihood），也由于得自B的取值而被称作A的后验概率。
P(A)是A的先验概率或边缘概率。

4.10信息论

信息论是应用数学的一个分支，主要研究的是对信号所含信息的多少进行量化。它的基本想法是一个不太可能的事件居然发生了，要比一个非常可能的事件发生能提供更多的信息。本节主要介绍度量信息的几种常用指标，如信息量、信息熵、条件熵、互信息、交叉熵等。
1.信息量
1948年克劳德•香农（Claude Shannon）发表的论文“通信的数学理论”是世界上首次将通讯过程建立了数学模型的论文，这篇论文和1949年发表的另一篇论文一起奠定了现代信息论的基础。信息量是信息论中度量信息多少的一个物理量，它从量上反应具有确定概率的事件发生时所传递的信息。香农把信息看作是“一种消除不确定性”的量，而概率正好是表示随机事件发生的可能性大小的一个量，因此，可以用概率来定量地描述信息。
在实际运用中，信息量常用概率的负对数来表示，即，。为此，可能有人会问，为何要用对数，前面还要带上负号？
用对数表示是为了计算方便。因为直接用概率表示，在求多条信息总共包含的信息量时，要用乘法，而对数可以变求积为求和。另外，随机事件的概率总是小于1，而真实小于1的对数为负的，概率的对数之前冠以负号，其值便成为正数。所以通过消去不确定性，获取的信息量总是正的。
2.信息熵
信息熵（entropy）又简称为熵，是对随机变量不确定性的度量。熵的概念由鲁道夫•克劳修斯（Rudolf Clausius）于1850年提出，并应用在热力学中。1948年，克劳德•艾尔伍德•香农（Claude Elwood Shannon）第一次将熵的概念引入信息论中，因此它又称为香农熵。
用熵来评价整个随机变量X平均的信息量，而平均最好的量度就是随机变量的期望，即熵的定义如下：

信息熵越大，包含的信息就越多，那么随机变量的不确定性就越大。
以下我们通过一个实例进一步说明这个关系。
假设随机变量X服从0-1分布，其概率分布为：
P(X=1)=p,P(X=0)=1-p
这时，X的熵为：
H(X)=-p log_2(p)-(1-p) log_2(1-p)
我们利用Python具体实现以下概率p与H(X)的关系：

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

#定义概率列表
p=np.arange(0,1.05,0.05)
HX=[]
for i in p:
    if i==0 or i==1:
        HX.append(0)
    else:
        HX.append(-i*np.log2(i)-(1-i)*np.log2(1-i))             
plt.plot(p,HX,label='entropy')
plt.xlabel('p')
plt.ylabel('H(X)')
plt.show()

import numpy as np

import matplotlib.pyplot as plt

%matplotlib inline

#定义概率列表

p=np.arange(0,1.05,0.05)

HX=[]

for i in p:

if i==0 or i==1:

HX.append(0)

else:

HX.append(-i*np.log2(i)-(1-i)*np.log2(1-i))

plt.plot(p,HX,label='entropy')

plt.xlabel('p')

plt.ylabel('H(X)')

plt.show()

图4-5 概率与信息熵
从这个图形可以看出，当概率为0或1时，H(X)为0，说明此时随机变量没有不确定性，当p=0.5时，随机变量的不确定性最大，即信息量最大。H(X)此时取最大值。
3.条件熵
设二维随机变量（X,Y）,其联合概率分布为：

注意，这个条件熵，不是指随机变量X在给定某个数的情况下，另一个变量的熵是多少，变量的不确定性是多少？而是期望！因为条件熵中X也是一个变量，意思是在一个变量X的条件下（变量X的每个值都会取），另一个变量Y熵对X的期望。
条件熵比熵多了一些背景知识，按理说条件熵的不确定性小于熵的不确定，即H(Y|X)≤H(Y)，事实也是如此，下面这个定理有力地说明了这一点。
定理：对二维随机变量（X,Y）,条件熵H（Y|X）和信息熵H（Y）满足如下关系：
H(Y|X)≤H(Y) (4.36)
4.互信息
互信息（mutual information）又称为信息增益，用来评价一个事件的出现对于另一个事件的出现所贡献的信息量。记为：
I(X,Y)=H(Y)-H(Y|X) (2.37)
在决策树的特征选择中，信息增益为主要依据。在给定训练数据集D,假设数据集由n维特征构成，构建决策树时，一个核心问题就是选择哪个特征来划分数据集，使得划分后的纯度最大，一般而言，信息增益越大，意味着使用某属性a来划分所得“纯度提升”越大。因此，我们常用信息增益来构建决策树划分属性。
5.相对熵
相对熵（relative entropy），所谓相对，一般是在两个随机变量之间来说，又被称为KL散度(Kullback–Leibler divergence，KLD)，这里我们假设 p(x) 和 q(x) 是 X 取值的两个概率分布，如p(x)表示X的真实分布，q(x)表示X的训练分布或预测分布，则 p 对 q 的相对熵为：

相对熵有些重要性质：
（1）相对熵不是传统意义上的距离，它没有对称性，即
KL(p(x)||q(x))≠KL(q(x)||p(x))
（2）当预测分布q(x)与真实分布p(x)完全相等时，相对熵为0；
（3）如果两个分别差异越大，那么相对熵也越大；反之，如果两个分布差异越小，相对熵也越小。
（4）相对熵满足非负性，即 KL(p(x)||q(x))≥0
6.交叉熵
交叉熵可在神经网络(机器学习)中作为代价函数，p表示真实标记的分布，q则为训练后的模型的预测标记分布，交叉熵代价函数可以衡量p与q的相似性。交叉熵作为代价函数还有一个好处是使用sigmoid函数在梯度下降时能避免均方误差代价函数学习速率降低的问题，因为学习速率可以被输出的误差所控制。

4.11 小结

概率与信息论是机器学习的重要基础及重要理论依据。本章介绍了概率论、信息论的一些基本概念，如样本空间、随机变量等。根据随机变量取值不同，又可分为有离型和连续型随机变量；根据随机变量的维度又可分为一维或多维随机变量。概率分布、边缘分布是刻画随机变量的重要特征，而期望、方差及协方差是随机变量三个常用统计量。信息论是刻画随机变量的另一种方式，信息论在深度学习、人工智能中应用非常广泛，后续章节也经常会出现。

下载本章代码及数据

Python技术交流与分享

分享技术平台

月度归档：2018年06月

26.1交通标志识别简介

26.1.1 交通标记易识特性

26.1.2交通标志识别技术的原理

26.1.3 总结

26.2 交通标志识别常用模型

26.3 实例2（使用LeNet神经网络）

步骤1：获取驾驶数据

步骤2：拆分数据

步骤3：增强训练数据

步骤4：创建驾驶模式

步骤5：训练模型

步骤6：评估性能

后续可进一步完善

4.1为何要学概率、信息论

4.2样本空间与随机变量

4.3概率分布

4.3.1 离散型随机变量

4.3.2 连续型随机变量

4.4边缘概率

4.5条件概率

4.6条件概率的链式法则

4.7独立性及条件独立性

4.8期望、方差及协方差

4.9贝叶斯定理

4.10信息论

4.11 小结