深度学习零基础学习笔记一（优达学城）
2017-07-19 本文已影响0人
linanwx
前言
突发奇想想学机器学习，这里是学习过程的笔记
准备
我做了这些准备工作
- MacBook 一台，搭建好Python环境，安装numpy和matplotlib
- 优达学城注册免费的《深度学习》课程（Google合作）
- 廖雪峰Python入门教程学习
- 花费两天时间大致浏览《机器学习实战》
学习这些知识应该足以进行接下来的优达学城的学习
课程一 从机器学习到深度学习
前言
小节1-8，主要介绍了深度学习的发展现状等等知识。
image.png
小节9-12介绍了softmax模型。
粗略浏览机器学习实战后，在机器学习实战这本书中，大致介绍了机器学习的几种算法。从表面上来看，机器学习是一些分类和聚类算法。在这些算法中，介绍了一种算法，叫做逻辑回归分类。
在小节9-12中，主要介绍了分类器模型——逻辑回归，分类函数使用的是softmax函数。
- 什么是softmax函数
softmax
这张图片可以表明什么是softmax函数了。对原来数列中的每个数z求exp(z)，新数的大小所占的比例就是新数的softmax概率。
- 性质
如果输入同比例扩大，则分类器的结果越两极化，越自信，如果输入同比例缩小，分类器结果趋于平均，不自信。
- 算法
import numpy as np
def softmax(x):
"""Compute softmax values for each sets of scores in x."""
expList = [np.exp(i) for i in x]
expSum = sum(expList)
x = [i/expSum for i in expList]
return np.array(x)
image.png
13-14节主要讲One-Hot编码。在softmax函数给出一组概率数列之后，如何确定分类呢？例如概率最高的为1，其他的为0，这样的一个数列，属于One-Hot编码。这种编码是已经确定了分类。
交叉熵
15-16节讲了交叉熵。softmax可以计算概率数列，OneHot是已经确定的分类，那如何计算概率数列到某个分类的距离呢？使用交叉熵来度量这个距离。
image.png
image.png
17-20 节讲解了如何使用这个分类器。其中，18节讲了为什么需要采用一种特殊的初始数据。
sum = 1000000000
for i in range(1000000):
sum += 0.000001
sum -= 1000000000
print(sum)
这段代码运行结果不是1。如果把sum换成一个很小的数字，例如1，而不是1000000000，我们发现结果误差变小了。基于这个原因，我们希望初始数据总是均值为0，并且各个方向的方差为一致的。例如一个灰度图片的像素值0-255，我们需要把它减去128，然后除以128，这样每一个数字都是-1到1之间的数字，这样的初始数据更适合用来训练。
image.png
这样，我们就可以进行训练了。回顾一下视频内容，xi是训练数据矩阵，w是随机权重矩阵，为了性能，随机值取自正态分布中轴为0，方差很小的分布函数，然后计算概率数列，和目标的距离。然后求出到所有目标的平均距离。我们的目的是让距离变小，所以我们沿着梯度下降的方向优化权重矩阵，同时优化截距b。不断重复这一个过程，直到局部最优为止。
- 安装docker
https://www.docker-cn.com/community-edition#/download
配置官方中国镜像。
image.png
- 安装jupyter notebook
$ pip3 install jupyter
$ jupyter notebook
此时可以使用命令jupyter notebook打开一个jupyter编辑器
- tensorflow环境搭建
$ docker run -it -p 8888:8888 tensorflow/tensorflow
运行上述命令会自动下载tensorflow镜像，前提是仓库镜像设置成中国的镜像，否则下载很慢。运行命令后，会提示你打开网页，打开这个网址以后会显示tensorflow的jupyter编辑环境，前提是jupyter notebook安装正确
- 挂载docker的文件目录
我们需要把官方的作业导进去。关闭容器，重新打开容器，使用-v 主机目录:容器目录来进行挂载。
docker run -v /Users/hahaha/tensorflow/:/notebooks -it -p 8888:8888 tensorflow/tensorflow
其中/Users/hahaha/tensorflow/是我的mac的一个文件夹，notebooks是tensorflow中的jupyter默认编辑目录。
在主机目录的挂载目录下面粘贴第一个作业文件，1_notmnist.ipynb。这个文件可以在这里找到： 1_notmnist.ipynb
作业一内容
作业代码段一
首先运行一下第一段代码的import，应该是没有任何出错的，此时什么也不会发生，如果出现了红色的输出错误，那就说明这些from import没有导入成功。
# These are all the modules we'll be using later. Make sure you can import them
# before proceeding further.
from __future__ import print_function
# print函数
import matplotlib.pyplot as plt
# 绘图工具
import numpy as np
# 矩阵计算
import os
# 文件路径
import sys
# 文件输出
import tarfile
# 解压缩
from IPython.display import display, Image
# 显示图片
from scipy import ndimage
# 图像处理
from sklearn.linear_model import LogisticRegression
# 逻辑回归模块线性模型
from six.moves.urllib.request import urlretrieve
# url处理
from six.moves import cPickle as pickle
# 数据处理
# Config the matplotlib backend as plotting inline in IPython
%matplotlib inline
# matplotlib是最著名的Python图表绘制扩展库，
# 它支持输出多种格式的图形图像，并且可以使用多种GUI界面库交互式地显示图表。
# 使用%matplotlib命令可以将matplotlib的图表直接嵌入到Notebook之中，
# 或者使用指定的界面库显示图表，它有一个参数指定matplotlib图表的显示方式。
# inline表示将图表嵌入到Notebook中。
作业代码段二
接下来是第二段代码，会进行下载用于训练和测试的字母集合，大概是300mb大小。下载成功后，可以看到挂载目录下面的这两个文件。
作业
url = 'https://commondatastorage.googleapis.com/books1000/'
last_percent_reported = None
data_root = '.' # Change me to store data elsewhere
def download_progress_hook(count, blockSize, totalSize):
"""A hook to report the progress of a download. This is mostly intended for users with
slow internet connections. Reports every 5% change in download progress.
"""
# 钩子函数用来实时显示下载进度
global last_percent_reported
percent = int(count * blockSize * 100 / totalSize)
if last_percent_reported != percent:
if percent % 5 == 0:
sys.stdout.write("%s%%" % percent)
sys.stdout.flush()
else:
sys.stdout.write(".")
sys.stdout.flush()
last_percent_reported = percent
def maybe_download(filename, expected_bytes, force=False):
"""Download a file if not present, and make sure it's the right size."""
dest_filename = os.path.join(data_root, filename)
# data_root是当前目录，在这个目录上加上文件名，设置为要保存的文件位置
if force or not os.path.exists(dest_filename):
# force是强制下载，忽略已经下载的文件
print('Attempting to download:', filename)
filename, _ = urlretrieve(url + filename, dest_filename, reporthook=download_progress_hook)
# 使用urlretrieve来下载文件，挂上钩子
print('\nDownload Complete!')
statinfo = os.stat(dest_filename)
# 获取下载到的文件的信息
if statinfo.st_size == expected_bytes:
# 正确大小
print('Found and verified', dest_filename)
else:
# 错误大小，提示用户使用浏览器下载
raise Exception(
'Failed to verify ' + dest_filename + '. Can you get to it with a browser?')
return dest_filename
train_filename = maybe_download('notMNIST_large.tar.gz', 247336696)
test_filename = maybe_download('notMNIST_small.tar.gz', 8458043)
作业代码段三
解压缩用例
num_classes = 10
# 数字总共有多少个
np.random.seed(133)
# 初始化随机种子
def maybe_extract(filename, force=False):
# 假设已经解压缩了
root = os.path.splitext(os.path.splitext(filename)[0])[0] # remove .tar.gz
# splitext(filename)[0]用于去除一个后缀，用两次就是去除两次后缀，也就是去除.tar.gz这个后缀
if os.path.isdir(root) and not force:
# You may override by setting force=True.
# 已经解压缩了就不再解压缩了
print('%s already present - Skipping extraction of %s.' % (root, filename))
else:
print('Extracting data for %s. This may take a while. Please wait.' % root)
tar = tarfile.open(filename)
sys.stdout.flush()
tar.extractall(data_root)
tar.close()
# 解压缩到当前目录下面
data_folders = [
os.path.join(root, d) for d in sorted(os.listdir(root))
if os.path.isdir(os.path.join(root, d))]
if len(data_folders) != num_classes:
raise Exception(
'Expected %d folders, one per class. Found %d instead.' % (
num_classes, len(data_folders)))
print(data_folders)
# 检查解压缩文件目录的数量与期待是否一致，并且打印解压缩出来文件的目录
return data_folders
train_folders = maybe_extract(train_filename)
test_folders = maybe_extract(test_filename)
问题一
写出代码显示解压缩的文件内容信息
- 参考答案
import random
import matplotlib.image as mpimg
def plot_samples(data_folders, sample_size, title=None):
fig = plt.figure()
# 建立空图像
if title: fig.suptitle(title, fontsize=16, fontweight='bold')
# 加入标题
for folder in data_folders:
# 遍历每个字母
image_files = os.listdir(folder)
image_sample = random.sample(image_files, sample_size)
# 从该字母中随机选取一定数量的图片
for image in image_sample:
image_file = os.path.join(folder, image)
ax = fig.add_subplot(len(data_folders), sample_size, sample_size * data_folders.index(folder) +
image_sample.index(image) + 1)
# 创建一个子图
image = mpimg.imread(image_file)
# 加载子图图片
ax.imshow(image)
# 显示子图图片
ax.set_axis_off()
# 关闭子图坐标线
fig.set_size_inches(18.5, 10.5)
# 设置图片显示的大小
plt.show()
plot_samples(train_folders, 20, 'Train')
plot_samples(test_folders, 20, 'Test')
运行效果如下
训练.png
测试.png
可以看出，部分训练数据是有问题的
作业代码段四
这之后需要进行数据的归一化处理，就是让图像的每一个像素由0255变换到-1.01.0，并且持久化到文件中
image_size = 28 # Pixel width and height.
pixel_depth = 255.0 # Number of levels per pixel.
# 图片长宽和图片像素深度
def load_letter(folder, min_num_images):
"""Load the data for a single letter label."""
# 处理一个属于一个字母文件夹下面的文件
image_files = os.listdir(folder)
# 列出该文件夹目录下面的所有文件
dataset = np.ndarray(shape=(len(image_files), image_size, image_size),
dtype=np.float32)
# 创建一个长度为文件个数，宽度和高度为28的
print(folder)
# 打印目录
num_images = 0
# 初始化num_images
for image in image_files:
# 对每一个文件处理
image_file = os.path.join(folder, image)
# 获取完整文件路径
try:
image_data = (ndimage.imread(image_file).astype(float) -
pixel_depth / 2) / pixel_depth
# 读入图像，并且归一化处理
if image_data.shape != (image_size, image_size):
# 检查图像的宽高
raise Exception('Unexpected image shape: %s' % str(image_data.shape))
dataset[num_images, :, :] = image_data
# 读入到数据集合中
num_images = num_images + 1
# 图片序号加一
except IOError as e:
# 如果无法读取文件的话，则忽略该文件
print('Could not read:', image_file, ':', e, '- it\'s ok, skipping.')
dataset = dataset[0:num_images, :, :]
# 如果读进来的文件数量少于最小需要文件数量
if num_images < min_num_images:
raise Exception('Many fewer images than expected: %d < %d' %
(num_images, min_num_images))
# 显示缺少的文件数量
print('Full dataset tensor:', dataset.shape)
# 显示文件数量，图片长宽
print('Mean:', np.mean(dataset))
# 平均值
print('Standard deviation:', np.std(dataset))
# 标准差
return dataset
def maybe_pickle(data_folders, min_num_images_per_class, force=False):
dataset_names = []
for folder in data_folders:
# 对每一个字母文件夹处理
set_filename = folder + '.pickle'
# 设置输出的文件
dataset_names.append(set_filename)
# 设置处理过的文件夹
if os.path.exists(set_filename) and not force:
# You may override by setting force=True.
# 检查是否存在已处理过的文件
print('%s already present - Skipping pickling.' % set_filename)
else:
print('Pickling %s.' % set_filename)
dataset = load_letter(folder, min_num_images_per_class)
# 归一化处理这个文件夹下面的所有图片
try:
with open(set_filename, 'wb') as f:
pickle.dump(dataset, f, pickle.HIGHEST_PROTOCOL)
# 持久化数据，将数据保存在硬盘上，而不是一直放在内存中
except Exception as e:
print('Unable to save data to', set_filename, ':', e)
return dataset_names
train_datasets = maybe_pickle(train_folders, 45000)
test_datasets = maybe_pickle(test_folders, 1800)
问题2
显示处理过的图片
- 参考答案
def plot_samples_2(data_folders, sample_size, title=None):
fig = plt.figure()
# 建立空图像
if title: fig.suptitle(title, fontsize=16, fontweight='bold')
# 加入标题
for folder in data_folders:
# 遍历每个字母
with open(folder, 'rb') as pk_f:
data = pickle.load(pk_f)
for index, image in enumerate(data):
if index < sample_size :
# 从该字母中随机选取一定数量的图片
ax = fig.add_subplot(len(data_folders), sample_size, sample_size * data_folders.index(folder) +
index + 1)
# 加载子图图片
ax.imshow(image)
# 显示子图图片
ax.set_axis_off()
# 关闭子图坐标线
fig.set_size_inches(18.5, 10.5)
# 设置图片显示的大小
plt.show()
plot_samples_2(train_datasets, 20, 'Train')
plot_samples_2(test_datasets, 20, 'Test')
image.png
image.png
问题3
检查每个字母下面的文件数目是否相似。
- 参考答案
file_path = 'notMNIST_large/{0}.pickle'
for ele in 'ABCDEFJHIJ':
with open(file_path.format(ele), 'rb') as pk_f:
# 遍历每一个目录
dat = pickle.load(pk_f)
# 加载这个目录下面的持久化文件
print('number of pictures in {}.pickle = '.format(ele), dat.shape[0])
# 打印相关信息
结果表明数目基本一致。
问题3效果
代码段——数据分割
数据不可能一次性就全部加载到内存中，这里对这些数据进行分割，接下来的这份代码对数据进行了分割
def make_arrays(nb_rows, img_size):
if nb_rows:
dataset = np.ndarray((nb_rows, img_size, img_size), dtype=np.float32)
# 创建一个空集合，数据类型是长rows宽img_size高img_size的矩阵，数据类型是浮点32位
labels = np.ndarray(nb_rows, dtype=np.int32)
# 创建一个标签，数据类型是32位整型，长度是rows
else:
dataset, labels = None, None
return dataset, labels
# 返回创建的数据类型
def merge_datasets(pickle_files, train_size, valid_size=0):
num_classes = len(pickle_files)
# 需要处理的类别数量
valid_dataset, valid_labels = make_arrays(valid_size, image_size)
# 建立有效数据集合，长度为有效长度
train_dataset, train_labels = make_arrays(train_size, image_size)
# 建立训练数据集合，长度为训练长度
vsize_per_class = valid_size // num_classes
tsize_per_class = train_size // num_classes
# 计算给定训练长度和有效长度下每个类别的平均长度
start_v, start_t = 0, 0
# 初始化下标，start_v是有效数据的开始，start_t是训练数据的开始
end_v, end_t = vsize_per_class, tsize_per_class
# 初始化下标，end_v是有效数据的结束，end_t是训练数据的结束
end_l = vsize_per_class + tsize_per_class
# 初始化下标，end_l是字母集合的结束，等于每个类别有效数据的长度+训练数据的长度
for label, pickle_file in enumerate(pickle_files):
# 遍历每一个pickle_file
try:
with open(pickle_file, 'rb') as f:
# 打开这个持久化文件
letter_set = pickle.load(f)
# 加载数据集
# let's shuffle the letters to have random validation and training set
np.random.shuffle(letter_set)
# 打乱数据集的顺序
if valid_dataset is not None:
# 如果不是测试集的话，更新测试集，否则 valid_dataset 不更新
valid_letter = letter_set[:vsize_per_class, :, :]
# numpy切片 http://brieflyx.me/2015/python-module/numpy-array-split/
# 从打乱的数据中选择 每类有效数据 数量的数据进行处理，放到 valid_letter 中
valid_dataset[start_v:end_v, :, :] = valid_letter
# 把这份数据放到valid_dataset中
valid_labels[start_v:end_v] = label
# 标记label 应该是 0~9中的一种
start_v += vsize_per_class
end_v += vsize_per_class
# 更新下标
# 循环结束时， valid_dataset 应该总长度为 valid_size 的一份数据， valid_labels是对应位置的标签
train_letter = letter_set[vsize_per_class:end_l, :, :]
# 除去valid部分的随机其他元素，长度为 end_l - vsize_per_class = tsize_per_class
train_dataset[start_t:end_t, :, :] = train_letter
# 循环结束时，train_dataset应该是总长为 train_size 的 一份数据
#
train_labels[start_t:end_t] = label
start_t += tsize_per_class
end_t += tsize_per_class
# 更新下标
except Exception as e:
print('Unable to process data from', pickle_file, ':', e)
raise
return valid_dataset, valid_labels, train_dataset, train_labels
train_size = 200000
valid_size = 10000
test_size = 10000
valid_dataset, valid_labels, train_dataset, train_labels = merge_datasets(
train_datasets, train_size, valid_size)
_, _, test_dataset, test_labels = merge_datasets(test_datasets, test_size)
print('Training:', train_dataset.shape, train_labels.shape)
print('Validation:', valid_dataset.shape, valid_labels.shape)
print('Testing:', test_dataset.shape, test_labels.shape)
代码段——打散数据
permutation函数介绍：http://www.jianshu.com/p/f0eb10acaa2d
def randomize(dataset, labels):
# labels.shape[0] 是 labels 的长度
permutation = np.random.permutation(labels.shape[0])
# 随机取出这么多数字的打乱
print(labels.shape[0])
shuffled_dataset = dataset[permutation,:,:]
# 打乱数据
shuffled_labels = labels[permutation]
# 打乱标签
return shuffled_dataset, shuffled_labels
train_dataset, train_labels = randomize(train_dataset, train_labels)
test_dataset, test_labels = randomize(test_dataset, test_labels)
valid_dataset, valid_labels = randomize(valid_dataset, valid_labels)
问题4
检验打散后的数据是否正确
- 参考答案
import random
def plot_sample_3(dataset, labels, title):
fig = plt.figure()
plt.suptitle(title, fontsize=16, fontweight='bold')
# 设置标题样式
items = random.sample(range(len(labels)), 200)
# 打散 labels 长的顺序序列
for i, item in enumerate(items):
# 随机取一个
plt.subplot(10, 20, i + 1)
# 画子图
plt.axis('off')
# 关闭坐标轴
plt.title(chr(ord('A') + labels[item]))
# 加标题
plt.imshow(dataset[item])
# 显示对应位置的子图
fig.set_size_inches(18.5, 10.5)
plt.show()
# 显示图片
plot_sample_3(train_dataset, train_labels, 'train dataset suffled')
plot_sample_3(valid_dataset, valid_labels, 'valid dataset suffled')
plot_sample_3(test_dataset, test_labels, 'test dataset suffled')
问题4
省略类似的两图
代码段——保存数据
pickle_file = os.path.join(data_root, 'notMNIST.pickle')
# 输出文件路径
try:
f = open(pickle_file, 'wb')
# 打开这个文件
save = {
'train_dataset': train_dataset,
'train_labels': train_labels,
'valid_dataset': valid_dataset,
'valid_labels': valid_labels,
'test_dataset': test_dataset,
'test_labels': test_labels,
}
# 写入一个字典 string-ndarray
pickle.dump(save, f, pickle.HIGHEST_PROTOCOL)
f.close()
except Exception as e:
print('Unable to save data to', pickle_file, ':', e)
raise
代码段——显示保存数据的大小
statinfo = os.stat(pickle_file)
print('Compressed pickle size:', statinfo.st_size)
问题5
题目的Google翻译
通过构建，此数据集可能包含大量重叠样本，包括验证和测试集中也包含的训练数据！ 训练和测试之间的重叠可能会使结果偏斜，如果您希望在没有重叠的环境中使用您的模型，但如果您希望在使用训练样本时再次看到训练样本，那么实际上是可以的。 测量培训，验证和测试样本之间的重叠程度。
可选问题：
数据集之间的重复数据怎么样？ （几乎相同的图像）
创建一个消毒验证和测试集，并比较您在随后的作业中的准确性。
大概意思是训练数据不能和测试用的数据重合，否则导致准确度不准
参考代码：
- 仅仅查看重复的图片数量
import hashlib
pickle_file = os.path.join('.', 'notMNIST.pickle')
try:
with open(pickle_file, 'rb') as f:
data = pickle.load(f)
except Exception as e:
print('Unable to open data from', pickle_file, ':', e)
raise
# 自从保存数据后，如果kernel挂了，就可以从本地直接读取，不用重新运行之前的代码
# 如果报错的话，可以在网上搜索报错的异常
def calcOverlap(sourceSet, targetSet, description):
sourceSetMd5 = np.array([hashlib.md5(img).hexdigest() for img in sourceSet])
# 建立一个md5表格
targetSetMd5 = np.array([hashlib.md5(img).hexdigest() for img in targetSet])
# 建立一个md5表格
overlap = np.intersect1d(sourceSetMd5, targetSetMd5, assume_unique=False)
# 去重
print(description)
print("overlap",overlap.shape[0], "from",sourceSetMd5.shape[0],"to", targetSetMd5.shape[0])
print("rate",overlap.shape[0]*100.0/sourceSetMd5.shape[0],"% and", overlap.shape[0]*100.0/targetSetMd5.shape[0],"%")
# 打印重叠数量
calcOverlap(data['train_dataset'], data['valid_dataset'], "train_dataset & valid_dataset")
calcOverlap(data['train_dataset'], data['test_dataset'], "train_dataset & test_dataset")
calcOverlap(data['test_dataset'], data['valid_dataset'], "test_dataset & valid_dataset")```
- 去除重复图片资源
待更新
## 问题6
使用逻辑回归训练模型并且进行测试
- 参考代码
import random
def disp_sample_dataset(dataset, labels,trueLabels, title=None):
展示训练的结果
fig = plt.figure()
if title: fig.suptitle(title, fontsize=16, fontweight='bold')
设置标题样式
items = random.sample(range(len(labels)), 200)
随机选择一系列图片
for i, item in enumerate(items):
plt.subplot(10, 20, i + 1)
设置一个子图
plt.axis('off')
关闭坐标线
lab = str(chr(ord('A') + labels[item]))
trueLab = str(chr(ord('A') + trueLabels[item]))
if lab == trueLab:
plt.title( lab )
else:
plt.title(lab + " but " + trueLab)
加上标题
plt.imshow(dataset[item])
显示这个图片
fig.set_size_inches(18.5, 10.5)
plt.show()
def train_and_predict(train_dataset, train_labels, test_dataset, test_labels ,sample_size):
regr = LogisticRegression()
生成训练器
X_train = train_dataset[:sample_size].reshape(sample_size, 784)
根据sample_size选择要训练的数据量
把二维向量压缩到一维向量
y_train = train_labels[:sample_size]
取出训练数据
regr.fit(X_train, y_train)
训练数据
X_test = test_dataset.reshape(test_dataset.shape[0], 28 * 28)
将测试数据压缩到一维向量
y_test = test_labels
测试数据所对应的真实标签
pred_labels = regr.predict(X_test)
生成预测数据
print('Accuracy:', regr.score(X_test, y_test), 'when sample_size=', sample_size)
disp_sample_dataset(test_dataset, pred_labels, test_labels, 'sample_size=' + str(sample_size))
train_and_predict(data['train_dataset'],data['train_labels'],data['test_dataset'],data['test_labels'], 1000)
## 模型性能
小节22~27提到了模型性能的相关知识。我们通常希望模型的性能能够达到100%，显然是不可能的。并且，为了使训练集的准确性提高，模型可能会发生过拟合。这时要遵循两点。
- 不要将训练数据一次性使用，而是分块使用，每次训练一部分
- 当模型参数使30个以上的用例由错误变成正确，则这个参数的改变是有效果的。
## 随机梯度下降
小节29~31讲解了什么是随机梯度下降
在训练过程中，为了让模型朝着最优的方向走，需要计算该点的导数。1.导数的计算量比较大，我们需要随机选择一部分样本来计算导数，来代替真实的导数。这就是随机梯度下降。2.为了减缓随机选择的随机性，我们使用动量的惯性来减少随机性。3.为了让后期模型能够稳定，我们减少学习的步长。
课程一结束
> 作业代码参考
> http://www.hankcs.com/ml/notmnist.html
