这几个库现在更新了，用书上的会出错，未解决，建议直接学新的
# -*- coding: utf-8 -*-
"""
Created on Sun Oct 14 09:09:58 2018
@author: asus
"""
#11 用深度学习方法为图像中的物体进行分类
import os
batch1_filename = os.path.join(
"E:\\books\Python数据挖掘入门与实践\用深度学习方法为图像中的物体进行分类",
"cifar-10-batches-py", "data_batch_1")
def unpickle(file):
import pickle
with open(file, 'rb') as fo:
dict = pickle.load(fo, encoding='bytes')
return dict
batch1 = unpickle(batch1_filename)
#这一批图像文件读进来后为一个字典结构，包含numpy数组形式的图像数据、图像类别、文件名
#以及该批文件的简短说明(training batch 1 of 5 表示训练集共五批，这是第一批)。
#提取一张图像
image_index = 100
image = batch1[b'data'][image_index]
#图像数据格式与matplotlib(绘制图像)所使用的有所不同，因此，要改变数组形状，对矩阵进行
#转换。
image = image.reshape((32, 32, 3), order='F')
import numpy as np
image = np.rot90(image, -1)
#之后，就可以用matplotlib绘制图像
%matplotlib inline
from matplotlib import pyplot as plt
plt.imshow(image)
#11.3 深度神经网络
#深度神经网络和基本神经网络的差别在于规模大小。至少包含两层隐含层的神经网络被称为深度
#神经网络。实际工作者遇到的深度神经网络通常规模很大，每层神经元数量和层次都非常多。
#神经网络接收很基础的特征作为输出——就计算机视觉而言，输入为简单的像素值。神经网络算法
#把这些数据整合起来向网络中传输，在这个过程中，基本的特征组合为复杂的特征。计算机依靠
#它们进行分类。
#11.3.3 Theano简介
#Theano使用来创建和运行数学表达式的工具。在Theano中，我们定义函数要做什么而不是怎么做
#这样才能以最佳的方式对表达式进行求值。
#我们可以用Theano来定义函数，处理标量、数组和矩阵以及其他数学表达式。如我们可以创建计
#算直角三角形斜边长度的函数。
import theano
from theano import tensor as T
a = T.dscalar() #标量
b = T.dscalar()
c = T.sqrt(a ** 2 + b ** 2) #c是一个表达式，即不是函数，也不是数值
f = theano.function([a,b], c) #函数 f(3,4)
#这个函数接收a、b，返回经过计算得到的结果，也就是输出值c
#11.3.4 Lasagne简介
#该库是专门用来构建神经网络的，实践了几种比较新的神经网络层和组成这些层的模块
#内置网络层(Network-in-network layers):这些小神经网络比传统的神经网络层更容易解释。
#删除层(Dropout layers):训练过程随机删除神经元，放置产生神经网络常见的过拟合问题。
#噪音层(Noise layers):为神经元引入噪音，也是为了解决过拟合问题。
#本章使用卷积层(convolution layers, 层级结构模拟人类视觉工作原理)。卷积层使用少量的
#相互连接的神经元，分析一部分输入值，便于神经网络实现对数据的标准转换，比如对图像数据
#的转换。视觉分析实验，就是用卷积层对图像进行转换。
#用第一章的Iris数据集测试卷积神经网络
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data.astype(np.float32)
y_true = iris.target.astype(np.int32)
#Lasagne对数据类型有特殊要求，因此，需要把类别值转换为int32类型(在原始数据集中用int64
#类型存储)。
#把数据集分为训练集和测试集两部分
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y_true, random_state=14)
#接着，分别创建卷积神经网络各层。
#首先，创建输入层,其神经元数量跟数据集特征数量相同。可以指定每一批输入的数量(设置为10)
#这样Lasagne可以在训练阶段做些优化。
import lasagne
input_layer = lasagne.layers.InputLayer(shape=(10, X.shape[1]))
#接着创建隐含层。该层从输入层接收输入(由第一个参数指定)，该层一共有12个神经元，使用非
#线性的sigmoid函数。
hidden_layer = lasagne.layers.DenseLayer(
input_layer, num_units=12,
nonlinearity=lasagne.nonlinearities.sigmoid)
#接着创建输出层，它接受来自隐含层的输入，输出层共有三个神经元，使用非线性的softmax函
#数主要用于神经网络的最后一层。
output_layer = lasagne.layers.DenseLayer(hidden_layer, num_units=3,nonlinearity
=lasagne.nonlinearities.softmax)
#为了训练刚创建的网络，我们需要定义几个Theano训练函数。在这之前，需要定义一个Theano表
#达式和函数。我们先来为神经网络的输入数据、输入结果和实际输出结果声明变量。
import theano.tensor as T
net_input = T.matrix('net_input')
net_output = output_layer.get_output(net_input)
true_output = T.ivector('true_output')
#接着定义损失函数，训练函数如何提升网络效果需要参考它的返回值——训练神经网络时，我们以
#最小化损失函数的返回值为前提。我们用类别交叉熵表示损失，这是一种衡量分类数据分类效果
#好坏的标准。损失函数表示的是网络的期望输出和实际输出两者之间的差距。
loss = T.mean(T.nnet.categorical_crossentropy(net_output, true_output))
#接着定义修改网络权重的函数。我们获取到网络的所有参数，创建调整权重的函数，使损失降低
#到最小。
all_params = lasagne.layers.get_all_params(output_layer)
updates = lasagne.updates.sgd(loss, all_params, learning_rate=0.1)
#最后，创建两个Theano函数，先是训练网络，然后获取网络的输出，以用于后续测试。
import theano
train = theano.function([net_input, true_output], loss, updates=updates)
get_output = theano.function([net_input], net_output)
#然后调用训练函数，在训练集上进行一轮迭代，接收训练数据，预测类别，与给定类别作比较，
#更新特征权重，以最小化损失。然后再进行1000次迭代，逐渐改进神经网络。
for n in range(1000):
train(X_train, y_train)
#接着，对输出计算F值，以评估分类效果。
y_output = get_output(X_test)
import numpy as np
y_pred = np.argmax(y_output, axis=1)
from sklearn.metrics import f1_score
print(f1_score(y_test, y_pred))
#11.3.5 用nolearn实现神经网络
import numpy as np
from PIL import Image, ImageDraw, ImageFont
from skimage.transform import resize
from skimage import transform as tf
from skimage.measure import label, regionprops
from sklearn.utils import check_random_state
from sklearn.preprocessing import OneHotEncoder
from sklearn.cross_validation import train_test_split
def create_captcha(text, shear=0, size=(100, 24)):
im = Image.new("L", size, "black")
draw = ImageDraw.Draw(im)
font = ImageFont.truetype(r"Coval.otf", 22)
draw.text((2, 2), text, fill=1, font=font)
image = np.array(im)
affine_tf = tf.AffineTransform(shear=shear)
image = tf.warp(image, affine_tf)
return image / image.max()
def segment_image(image):
labeled_image = label(image > 0)
subimages = []
for region in regionprops(labeled_image):
start_x, start_y, end_x, end_y = region.bbox
subimages.append(image[start_x:end_x,start_y:end_y])
if len(subimages) == 0:
return [image,]
return subimages
random_state = check_random_state(14)
letters = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
shear_values = np.arange(0, 0.5, 0.05)
def generate_sample(random_state=None):
random_state = check_random_state(random_state)
letter = random_state.choice(letters)
shear = random_state.choice(shear_values)
return create_captcha(letter, shear=shear, size=(20, 20)), letters.index(letter)
dataset, targets = zip(*(generate_sample(random_state) for i in range(3000)))
dataset = np.array(dataset, dtype='float')
targets = np.array(targets)
onehot = OneHotEncoder()
y = onehot.fit_transform(targets.reshape(targets.shape[0],1))
y = y.todense().astype(np.float32)
dataset = np.array([resize(segment_image(sample)[0], (20, 20)) for sample in dataset])
X = dataset.reshape((dataset.shape[0], dataset.shape[1] * dataset.shape[2]))
X = X / X.max()
X = X.astype(np.float32)
X_train, X_test, y_train, y_test = \
train_test_split(X, y, train_size=0.9, random_state=14)
#神经网络由一系列的层组成。在nolearn中实现神经网络，只徐定义它由Lasagne哪几种类型的层
#组成就行，跟PyBrain做法大同小异。
from lasagne import layers
layers=[
('input', layers.InputLayer),
('hidden', layers.DenseLayer),
('output', layers.DenseLayer),
]
from lasagne import updates
from nolearn.lasagne import NeuralNet
from lasagne.nonlinearities import sigmoid, softmax
net1 = NeuralNet(layers=layers,
input_shape=X.shape,
hidden_num_units=100,
output_num_units=26,
hidden_nonlinearity=sigmoid,
output_nonlinearity=softmax,
hidden_b=np.zeros((100,), dtype=np.float64),
update=updates.momentum,
update_learning_rate=0.9,
update_momentum=0.1,
regression=True,
max_epochs=1000,
)
net1.fit(X_train, y_train)
y_pred = net1.predict(X_test)
y_pred = y_pred.argmax(axis=1)
assert len(y_pred) == len(X_test)
if len(y_test.shape) > 1:
y_test = y_test.argmax(axis=1)
print(f1_score(y_test, y_pred))
#11.4 GPU优化
#11.6 应用
#用CIFAR图像创建数据集。保留像素结构——像素的行列号。
import os
import numpy as np
batches = []
for i in range(1, 6):
batch_filename = os.path.join(
"E:\\books\Python数据挖掘入门与实践\用深度学习方法为图像中的物体进行分类",
"cifar-10-batches-py", "data_batch_{}".format(i))
batches.append(unpickle(batch_filename))
break
#把每批次的图像文件一次添加到数据里。
X = np.vstack([batch[b'data'] for batch in batches])
#然后，把像素归一化，并将其强制转换为32位浮点型数据(GPU进行计算的虚拟机唯一支持的数据
#类型)。
X = np.array(X) / X.max()
X = X.astype(np.float32)
#类别的处理方法相同，只不过我们使用hstack，它为数组末尾追加一列数据。然后使用
#OneHotEncoder把它转换为只含有一维有效编码的数组。
from sklearn.preprocessing import OneHotEncoder
y = np.hstack(batch[b'labels'] for batch in batches).flatten()
y = OneHotEncoder().fit_transform(y.reshape(y.shape[0],1)).todense()
y = y.astype(np.float32)
#把数据集切分为训练集和测试集。
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
#调整数组形状以保留原始图像的数据结构。图像原本是32像素见方，每个像素由三个值组成(分别
#表示红、绿、蓝的颜色值)。
#11.6.2 创建神经网络
#创建神经网络的各层
from lasagne import layers
layers = [
('input', layers.InputLayer),
('conv1', layers.Conv2DLayer),
('pool1', layers.MaxPool2DLayer),
('conv2', layers.Conv2DLayer),
('pool2', layers.MaxPool2DLayer),
('conv3', layers.Conv2DLayer),
('pool3', layers.MaxPool2DLayer),
('hidden4', layers.DenseLayer),
('hidden5', layers.DenseLayer),
('output', layers.DenseLayer),
]
#最后三层使用密集层，但是前面使用三组卷积层和池化层。此外，我们必须以输入层开始。这样
#一共有10层。输入数据跟数据集同型，而不只跟输入层的神经元数量相同，输入层和输出层的大
#小仍由数据集来定。
#开是创建神经网络
import theano
import lasagne
from nolearn.lasagne import NeuralNet
from lasagne.nonlinearities import sigmoid, softmax
nnet = NeuralNet(layers=layers, input_shape=(None, 3, 32, 32),
conv1_num_filters=32,
conv1_filter_size=(3, 3),
conv2_num_filters=64,
conv2_filter_size=(2, 2),
conv3_num_filters=128,
conv3_filter_size=(2, 2),
pool1_ds=(2,2),
pool2_ds=(2,2),
pool3_ds=(2,2),
hidden4_num_units=500,
hidden5_num_units=500,
output_num_units=10,
output_nonlinearity=softmax,
updata_learning_rate=0.01,
update_momentum=0.9,
regression=True,
max_epochs=3,
verbose=1)
#11.6.3 组装起来
nnet.fit(X_train, y_train)
from sklearn.metrics import f1_score
y_pred = nnet.predict(X_test)
print(f1_score(y_test.argmax(axis=1), y_pred.argmax(axis=1)))