Hive本身不提供内建的URLEncode和URLDecode来实现url的编解码，我们可以基于编解码的原理来自己写一个UDF来实现。

另一种更直接的方法是通过reflect来调用Java的URLEncode和URLDecode。

示例如下：

URLEncode

select reflect("java.net.URLEncoder", "encode","https://gaussic.com/chi2-keyword-extraction/");

得到结果：

https%3A%2F%2Fgaussic.com%2Fchi2-keyword-extraction%2F

URLDecode

select reflect("java.net.URLDecoder", "decode","https%3A%2F%2Fgaussic.com%2Fchi2-keyword-extraction%2F");

得到结果：

https://gaussic.com/chi2-keyword-extraction/

转载请注明出处： https://gaussic.com/chi2-keyword-extraction/

用朴素贝叶斯做文本分类的原理是，计算文本中出现的词属于某一类的联合概率。

其中，一个词在不同分类下的概率是不同的，例如，「基金」这一词属于「投资」类的概率比属于「餐饮」类的概率要高，「火锅」这个词则相反。

那么，我们是否可以预先计算出一个分类下所有词的概率呢？答案是：可以！

词频统计

我们首先想到的是词频。首先使用分词工具，将文本切分为合适的词组形式。当前工业界使用较为广泛的是「jieba分词」，它在保障准确性的同时也能达到较快的分词速度。

import re
import jieba

def segment(sentence, cut_all=False):
    sentences = re.sub('[\n\u3000。,，；\?？\u00a0”“\(\)（）、\-—：/《》！～【】%\d+]', ' ', sentence)
    sentence = [x for x in jieba.cut(sentences, cut_all=cut_all) if x != ' ']
    return sentence

segment('上海星巴克咖啡经营有限公司淮海中路五店')

# 分词结果：
['上海', '星巴克', '咖啡', '经营', '有限公司', '淮海中路', '五店']

我们以「THUCNews 新闻数据集」为例，抽取财经类5000篇文档，统计各词的词频：

import os
from collections import Counter

ROOT_DIR = '/Users/gaussic/data/THUCNews'
category = '财经'

word_cat_cnt = Counter()  # 记录词频

for i, fname in enumerate(os.listdir(os.path.join(ROOT_DIR, category)), 1):
    fname = os.path.join(ROOT_DIR, category, fname) # 文件名
    sentence = open(fname, 'r', encoding='utf-8', errors='ignore').read()
    word_cat_cnt.update(segment(sentence))  # 更新词频
    if i == 5000:
        break

word_cat_cnt.most_common(30)

# 输出top30词
[('的', 148410),
 ('基金', 51183),
 ('在', 33436),
 ('.', 30862),
 ('了', 21543),
 ('市场', 20365),
 ('是', 20228),
 ('和', 18462),
 ('月', 17807),
 ('公司', 14630),
 ('也', 14405),
 ('年', 13635),
 ('为', 13414),
 ('将', 12783),
 ('投资', 11926),
 ('有', 11730),
 ('对', 11092),
 ('日', 9663),
 ('中', 9377),
 ('期货', 9356),
 ('而', 9326),
 ('元', 8809),
 ('但', 8460),
 ('上', 8081),
 ('价格', 7537),
 ('从', 7415),
 ('等', 6846),
 ('目前', 6841),
 ('上涨', 6790),
 ('中国', 6688)]

值得一提的是，像「基金、投资、期货、价格、上涨」这些词正如我们所预期的排在了前面，它们是将一篇文档划分为财经类的重要参考。

但是，像「的、在、了、是、和」这些词，它们几乎出现在所有类型的文章中，对分类不提供任何的参考价值，甚至会对机器分类产生极大的干扰。

解决这一问题的一种方法是维护一张过滤词表，把不需要的词从词频排序中过滤掉，自然语言处理称它们为「停用词」。但是，随着数据量的增大，所需要过滤的词会越来越多，人工干预的成本会越来越高，显然不利于后期的维护。

TF-IDF关键词抽取

另一种方法，就是我们通常使用到的TF-IDF关键词抽取算法。它的原理很简单：

• 如果一个词在某个分类下出现的频率很高，同时在所有文档出现的频率也很高，那么这个词大概率是没有意义的，正如前面出现的「的、在、了」等；
• 如果一个词在某个分类下出现的频率很高，而在其他类中出现的频率很低，那么这个词对于这个行业很关键，如「财经」类中的「基金、投资」，「体育」类中的「篮球、比赛」等；
• 如果一个词在所有的分类下出现的频率都很低，那么它为分类带来的参考价值不大，可以适当剔除，如生僻词、个别人名等。

有关TF-IDF的原理与实现可以看这篇：基于特定语料库的 TF-IDF 关键词提取实现

显而易见的，这一结果相比词频统计有了极大的提升。首先，停用词问题得到了极大程度的解决。其次，一些低频词的权重得到了提升，如「ETF、QDII、A股」三个词频较低但非常明显的财经类词。

需要注意的是，部分词可以同时是其他分类下的关键词，如「公司、吨、元、经理、合约、大豆」等。单纯将它们视作某一行业的关键词容易造成分类的混淆。需要适当降低它们的权重。

Chi2 - 卡方检验

卡方检验的本质，是检验两个变量之间有没有关系。

在文本分类的特征选择阶段，一般使用「词t与类别c不相关」来做原假设，计算出的卡方值越大，说明对原假设的偏离越大，我们越倾向于认为原假设的反面情况是正确的。

选择的过程为每个词计算它与类别c的开方值，从大到小排个序，取前k个即可。

以上面的「基金」为例，我们考虑它与「财经」类的相关性。

基于原假设，「财经」类文章中包含「基金」这一词的比例应该与所有文档中包含「基金」的比例相同，因此，A的理论值应为：

$$
E_{11} = (A+C)\frac{A+B}{N}
$$

实际值与理论值的差值为：

$$
D_{11} = \frac{(A-E_{11})^2}{E_{11}}
$$

分别计算表格中4种情况的差值 $D_{11}, D_{12}, D_{21}, D_{22}$ ，求和即为「基金」与「财经」类文章的卡方结果：

$$
\chi^2{(基金, 财经)} = \frac{N(AD-BC)^2}{(A+B)(C+D)(A+C)(B+D)}
$$

其中，N 是总文档数，A+C 和 B+D 对应财经类和非财经类的文档数，在计算某个词属于某个类别时，它们是固定值，可以忽略。

因此结果简化为：

$$
\chi^2{(基金, 财经)} = \frac{(AD-BC)^2}{(A+B)(C+D)}
$$

可见，当$(AD-BC)^2$越大，$\chi^2$也越大，当前词越有可能属于当前类别的关键词。

我们继续使用「THUCNews」实操一下。

首先，从每个类别载入5000篇文档，并统计以下三个值：

from collections import defaultdict, Counter

categories = ['时尚', '家居', '教育', '股票', '娱乐', '彩票', '社会', 
              '房产', '星座', '科技', '财经', '时政', '游戏', '体育']

doc_cat_cnt = defaultdict(int)       # 每类文档数
word_tot_cnt = Counter()             # 每个词出现的文档数
word_cat_cnt = defaultdict(Counter)  # 每个词在每个分类下出现的文档数
for cat in categories:
    for fname in os.listdir(os.path.join(ROOT_DIR, cat))[:5000]:
        doc = open(os.path.join(ROOT_DIR, cat, fname), 'r', encoding='utf-8', errors='ignore').read()
        doc = set(segment(doc))  # 注意，在chi2中，每个词在每个文档中只统计一次
        word_tot_cnt.update(doc)
        word_cat_cnt[cat].update(doc)
        doc_cat_cnt[cat] += 1

接下来，使用pandas来批量计算卡方值：

import pandas as pd
import numpy as np

# 词-文档数
word_tot_df = pd.DataFrame(list(word_tot_cnt.items()), columns=['word', 'tot_freq'])  

# 词-分类-文档数
word_cat_df = []
for cat in categories:
    cur_cat_df = pd.DataFrame(list(word_cat_cnt[cat].items()), columns=['word', 'cat_freq'])
    cur_cat_df['cat'] = cat
    word_cat_df.append(cur_cat_df)
word_cat_df = pd.concat(word_cat_df, ignore_index=True)

# 双表连接
word_cat_df = word_cat_df.merge(word_tot_df, on=['word'], how='inner')
word_cat_df['doc_cnt'] = word_cat_df['cat'].map(doc_cat_cnt)

word_cat_df[word_cat_df['word']=='基金']

N = sum(doc_cat_cnt.values()) # 总文档数

def get_chi2(x):
    A = x['cat_freq']
    B = x['tot_freq'] - x['cat_freq']
    C = x['doc_cnt'] - x['cat_freq']
    D = N - x['tot_freq'] - x['doc_cnt'] + x['cat_freq']
    return  np.round((A*D - B*C)**2 / (A+B) / (C+D), 4)

# 计算chi2值
word_cat_df['chi2'] = word_cat_df.apply(get_chi2, axis=1)

# chi2原始值较大，可使用min-max逐行业归一化
cat_max = dict(word_cat_df.groupby('cat')['chi2'].max())
cat_min = dict(word_cat_df.groupby('cat')['chi2'].min())

def get_chi2_norm(x):
    return np.round((x['chi2'] - cat_min[x['cat']]) / (cat_max[x['cat']] - cat_min[x['cat']]), 4)

# 计算chi2_norm值
word_cat_df['chi2_norm'] = word_cat_df.apply(get_chi2_norm, axis=1)

# 按照行业和chi2逆序排列
word_cat_df.sort_values(by=['cat', 'chi2'], ascending=False, inplace=True)

输出4类新闻的TOP20关键词:

相比TF-IDF，Chi2卡方检验更大程度的较低了类别混淆词的权重，并且一些整体词频较低但在当前行业出现次数较高的词的权重得到了提升，这使我们更容易发现一些分类中的新词。

值得一提的是，由于Chi2只统计词所出现的文档数，而不考虑在每一篇文档中出现的次数，这可能会将低频词的权重过度放大，影响对高频词的判断。

当然，在一些特定的场景，如短文本分类，Chi2的低频词缺陷问题便不复存在。

例如商户名称分析，如何从多个行业的千万级商户名录中，抽取各个行业的关键词，Chi2不失为一种及其有效的方法。

在抽取完商户关键词后，我们可以将商户行业进一步细分，如餐饮继续划分为火锅、甜品、饮品、中餐、西餐等等，甚至可以挖掘出大量的品牌名称。

试想，如果我们拥有大量的客户交易数据，使用行业关键词抽取方法对客户的交易商户信息进行细分后，是否就能充分挖掘到客户的消费偏好，而进行更加定制化的推荐呢？

答案是不言而喻的。

转载请注明出处： https://gaussic.com/chi2-keyword-extraction/

Geolocataion conversion between WGS84, BD09 and GCJ02.

WGS84 / BD09 / GCJ02 / MapBar 经纬度坐标互转。

• WGS84: GPS coordinates for Google Earth (GPS 坐标，谷歌地球使用)
• GCJ02: national coordinate system developed by China (国测局坐标，谷歌中国地图、腾讯地图、高德地图使用)
• BD09: Baidu coordinates (百度坐标系，百度地图使用)
• MapBar: MapBar coordinates (图吧坐标系，图吧地图使用)

Test website: http://gpsspg.com/maps.htm

Author: Gaussic

Date: 2019-05-09

Github 链接：gaussic/geo_convert

全部代码：

# coding: utf-8

"""
Geolocataion converting between WGS84, BD09 and GCJ02.
WGS84 / BD09 / GCJ02 / MapBar 经纬度坐标互转。
- WGS84: GPS coordinates for Google Earth (GPS 坐标，谷歌地球使用)
- GCJ02: national coordinate system developed by China (国测局坐标，谷歌中国地图、腾讯地图、高德地图使用)
- BD09: Baidu coordinates (百度坐标系，百度地图使用)
- MapBar: MapBar coordinates (图吧坐标系，图吧地图使用)
Test website: http://gpsspg.com/maps.htm
Author: Gaussic
Date:   2019-05-09
"""

import math

PI = math.pi
PIX = math.pi * 3000 / 180
EE = 0.00669342162296594323
A = 6378245.0


def bd09_to_gcj02(lng, lat):
    """BD09 -> GCJ02"""
    x, y =  lng - 0.0065, lat - 0.006
    z = math.sqrt(x * x + y * y) - 0.00002 * math.sin(y * PIX)
    theta = math.atan2(y, x) - 0.000003 * math.cos(x * PIX)
    lng, lat = z * math.cos(theta), z * math.sin(theta)
    return lng, lat


def gcj02_to_bd09(lng, lat):
    """GCJ02 -> BD09"""
    z = math.sqrt(lng * lng + lat * lat) + 0.00002 * math.sin(lat * PIX)
    theta = math.atan2(lat, lng) + 0.000003 * math.cos(lng * PIX)
    lng, lat = z * math.cos(theta) + 0.0065, z * math.sin(theta) + 0.006
    return lng, lat


def gcj02_to_wgs84(lng, lat):
    """GCJ02 -> WGS84"""
    if out_of_china(lng, lat):
        return lng, lat
    dlat = transform_lat(lng - 105.0, lat - 35.0)
    dlng = transform_lng(lng - 105.0, lat - 35.0)
    radlat = lat / 180.0 * PI
    magic = math.sin(radlat)
    magic = 1 - EE * magic * magic
    sqrtmagic = math.sqrt(magic)
    dlat = (dlat * 180.0) / ((A * (1 - EE)) / (magic * sqrtmagic) * PI)
    dlng = (dlng * 180.0) / (A / sqrtmagic * math.cos(radlat) * PI)
    lng, lat = lng - dlng, lat - dlat
    return lng, lat


def wgs84_to_gcj02(lng, lat):
    """WGS84 -> GCJ02"""
    if out_of_china(lng, lat):
        return lng, lat
    dlat = transform_lat(lng - 105.0, lat - 35.0)
    dlng = transform_lng(lng - 105.0, lat - 35.0)
    radlat = lat / 180.0 * PI
    magic = math.sin(radlat)
    magic = 1 - EE * magic * magic
    sqrtmagic = math.sqrt(magic)
    dlat = (dlat * 180.0) / ((A * (1 - EE)) / (magic * sqrtmagic) * PI)
    dlng = (dlng * 180.0) / (A / sqrtmagic * math.cos(radlat) * PI)
    lng, lat = lng + dlng, lat + dlat
    return lng, lat


def mapbar_to_wgs84(lng, lat):
    """MapBar -> WGS84"""
    lng = lng * 100000.0 % 36000000
    lat = lat * 100000.0 % 36000000
    lng1 = int(lng - math.cos(lat / 100000.0) * lng / 18000.0 - math.sin(lng / 100000.0) * lat / 9000.0) 
    lat1 = int(lat - math.sin(lat / 100000.0) * lng / 18000.0 - math.cos(lng / 100000.0) * lat / 9000.0)
    lng2 = int(lng - math.cos(lat1 / 100000.0) * lng1 / 18000.0 - math.sin(lng1 / 100000.0) * lat1 / 9000.0 + (1 if lng > 0 else -1))
    lat2 = int(lat - math.sin(lat1 / 100000.0) * lng1 / 18000.0 - math.cos(lng1 / 100000.0) * lat1 / 9000.0 + (1 if lat > 0 else -1)) 
    lng, lat = lng2 / 100000.0, lat2 / 100000.0
    return lng, lat


def transform_lat(lng, lat):
    """GCJ02 latitude transformation"""
    ret = -100 + 2.0 * lng + 3.0 * lat + 0.2 * lat * lat + 0.1 * lng * lat + 0.2 * math.sqrt(math.fabs(lng))
    ret += (20.0 * math.sin(6.0 * lng * PI) + 20.0 * math.sin(2.0 * lng * PI)) * 2.0 / 3.0
    ret += (20.0 * math.sin(lat * PI) + 40.0 * math.sin(lat / 3.0 * PI)) * 2.0 / 3.0
    ret += (160.0 * math.sin(lat / 12.0 * PI) + 320.0 * math.sin(lat * PI / 30.0)) * 2.0 / 3.0
    return ret


def transform_lng(lng, lat):
    """GCJ02 longtitude transformation"""
    ret = 300.0 + lng + 2.0 * lat + 0.1 * lng * lng + 0.1 * lng * lat + 0.1 * math.sqrt(math.fabs(lng))
    ret += (20.0 * math.sin(6.0 * lng * PI) + 20.0 * math.sin(2.0 * lng * PI)) * 2.0 / 3.0
    ret += (20.0 * math.sin(lng * PI) + 40.0 * math.sin(lng / 3.0 * PI)) * 2.0 / 3.0
    ret += (150.0 * math.sin(lng / 12.0 * PI) + 300.0 * math.sin(lng / 30.0 * PI)) * 2.0 / 3.0
    return ret


def out_of_china(lng, lat):
    """No offset when coordinate out of China."""
    if lng < 72.004 or lng > 137.8437:
        return True
    if lat < 0.8293 or lat > 55.8271:
        return True
    return False


def bd09_to_wgs84(lng, lat):
    """BD09 -> WGS84"""
    lng, lat = bd09_to_gcj02(lng, lat)
    lng, lat = gcj02_to_wgs84(lng, lat)
    return lng, lat


def wgs84_to_bd09(lng, lat):
    """WGS84 -> BD09"""
    lng, lat = wgs84_to_gcj02(lng, lat)
    lng, lat = gcj02_to_bd09(lng, lat)
    return lng, lat


def mapbar_to_gcj02(lng, lat):
    """MapBar -> GCJ02"""
    lng, lat = mapbar_to_wgs84(lng, lat)
    lng, lat = wgs84_to_gcj02(lng, lat)
    return lng, lat


def mapbar_to_bd09(lng, lat):
    """MapBar -> BD09"""
    lng, lat = mapbar_to_wgs84(lng, lat)
    lng, lat = wgs84_to_bd09(lng, lat)
    return lng, lat


if __name__ == '__main__':
    blng, blat = 121.4681891220,31.1526609317
    print('BD09:', (blng, blat))
    print('BD09 -> GCJ02:', bd09_to_gcj02(blng, blat))
    print('BD09 -> WGS84:',bd09_to_wgs84(blng, blat))
    wlng, wlat = 121.45718237717077, 31.14846209914084
    print('WGS84:', (wlng, wlat))
    print('WGS84 -> GCJ02:', wgs84_to_gcj02(wlng, wlat))
    print('WGS84 -> BD09:', wgs84_to_bd09(wlng, wlat))
    mblng, mblat = 121.4667323772, 31.1450420991
    print('MapBar:', (mblng, mblat))
    print('MapBar -> WGS84:', mapbar_to_wgs84(mblng, mblat))
    print('MapBar -> GCJ02:', mapbar_to_gcj02(mblng, mblat))
    print('MapBar -> BD09:', mapbar_to_bd09(mblng, mblat))

转载请注明出处：https://gaussic.com/lyric-generation-2/

接上一篇：从零开始做歌词生成器 - 0 - 抓取网易云 3 万首歌词

上一篇中详述了歌词的抓取部分，大约抓取到了 3 万 7 千多篇歌词，未经过任何清洗。在这一篇中，需要对歌词做一些简单的清洗和分析工作。

代码暂时放在这个 repo 里，到后面整合到完整的系统中：gaussic/crawl_scripts

环境依赖：

jieba、gensim、pandas

前言

如下图所见，这些歌词中包含了中、韩、日、英四种语言，中文还分繁、简。以及时间线、工作人员等等。由于是针对中文的歌词生成器，因此需要过滤掉大量的文本。

关于时间线、工作人员，基本都有固定的模式，可以使用正则表达式去除。

关于语言的问题，有一个简单的方案，把外文歌手从库中删除，这样做没有办法排除有些华语歌手唱的外文歌曲，以及一些带有中文翻译的歌曲，治标不治本。另一个解决方案，是根据中文字符区间，用正则表达式来处理，这样似乎更加合情合理。

此外，为了缩小词汇表的大小，减少模型参数，将繁体字转换为简体字，这个可以通过繁简对照表完成。

另外一个问题，同一个歌手的一首歌会有多个不同的版本（Remix，Live 等等），但是歌词是相似的，需要尽量的只保留一个版本，因此需要去重。当然，这个步骤是可选的，保存一定的重复对模型其实影响并不大。对于去重，需要计算各文档相似度，然后再去除相似度高的文档。

关于以上步骤的实现，我们逐步叙述。

初步清洗

大部分的时间轴和额外信息，被包在 [] 中，可以把这一部分直接去除。此外，还有一工作人员的信息，基本（并非全部）都有固定的格式，可以根据几个关键词去除大部分。

关于语言判断，中文字符区间是 \u4e00-\u9fa5，统计符合该区间内字符数量，如果超过 8 成都是中文，则判断为中文。这个百分比可以调整，因为还存在一些双语歌词。

使用正则表达式，初步清洗的函数如下：

def open_file(filename, mode='r'):
    return open(filename, mode=mode, encoding='utf-8', errors='ignore')


def is_chinese(text):
    text = ''.join([x.strip() for x in text.split('\n')])
    res = ' '.join([r for r in re.findall(r"[\u4e00-\u9fa5]+", text)])  # 中文字符区间
    return len(res) >= 0.8 * len(text)  # 8成以上是中文


def clean_text(filename):
    text = open_file(filename).read()
    text = re.sub(r"\[.*\]", "", text)  # 过滤时间轴
    text = re.sub(r"作词.*\n", "", text)  # 过滤掉工作人员
    text = re.sub(r"作曲.*\n", "", text)
    text = re.sub(r"编曲.*\n", "", text)
    text = re.sub(r"演唱.*\n", "", text)
    text = re.sub(r"制作人.*\n", "", text).strip()
    return text

繁简转换

部分的粤语歌繁体居多，因此可以考虑将繁体转换为简体，降低词汇表大小。

总结了一张对照表，格式如下：

瀋	沈
畫	划
鍾	钟
靦	腼
餘	余
鯰	鲇
鹼	碱
㠏	㟆
...

我们需要读取这张表，再将初筛后的文本转换为简体，需要两个辅助函数：

def read_convert_words(filename):
    """读取繁简字体转换表"""
    tr_to_cn = {}
    with open_file(filename) as f:
        for line in f:
            key, value = line.strip().split()
            tr_to_cn[key] = value
    return tr_to_cn


def convert_tr_to_cn(sentence, tr_to_cn):
    """繁简转换"""
    cn_s = ''
    for x in sentence:
        if x in tr_to_cn:
            x = tr_to_cn[x]
        cn_s += x
    return cn_s

接下来，就是遍历所有目录下的所有歌词文档，然后一片片处理再转存：

base_dir = "data"
new_dir = "data_clean"   # 保存到新的目录下
if os.path.exists(new_dir):
    shutil.rmtree(new_dir)
os.mkdir(new_dir)

cnt = 0   # 编号
tr_to_cn = read_convert_words('tr-cn.txt')
for cur_dir in os.walk(base_dir):  # 遍历所有文档
    for filename in cur_dir[2]:
        try:
            file_dir = os.path.join(cur_dir[0], filename)
            data = clean_text(file_dir)

            if is_chinese(data) and len(data) >= 200:  # 中文，200字符以上
                data = convert_tr_to_cn(data, tr_to_cn)   # 转换为简体

                filename = convert_tr_to_cn(filename, tr_to_cn)

                filename = ''.join(filename.split('.')[:-1])
                new_file = filename + ' - ' + str(cnt) + '.txt' # 防止重名覆盖，打个编号
                open_file(os.path.join(new_dir, new_file), 'w').write(data)  # 汇总写入新目录
                cnt += 1
        except:
            pass

这里只保留清洗之后 200 字符以上的歌词，处理完毕大约剩下 16000 多篇。

经过初筛后和繁简转换后的示例如下：

![lyric-1-2.jpg])(https://gaussic.com/content/images/2020/01/lyric-1-2.jpg)

相比原始的数据，已经干净了许多。

歌词去重

接下来还需要处理歌词重复的问题，查看剩下的文档，发现重复情况还是比较严重的，仅陈奕迅的一首 K歌之王 就出现了 10 次以上。

去重的一个简单思路是提取所有文档的 TF-IDF 特征向量。然后再逐个计算每一篇文档的特征向量与其他所有文档的相似度。如果相似度最高的两篇文档的相似度小于所设阈值，那么说明这篇文档没有出现过。

有一个问题是，这个算法的复杂度是 $O(n^2)$，1.6 万文档计算量过亿，外加每篇文档的相似度对比还需要一定的时间，总体可能需要话费数小时。

另外一种快速的海量文档匹配方法，Simhash，测试之后，发现速度虽然快，但是效果并不让人满意。

再次分析数据，把文档按名称排序后，终于找到了优化方法：

依次打开名称相似的文档，发现其中的内容是几乎相同的。也就是说，我们每次只要对比名称相近的几篇文档就可以了，这样 $O(n^2)$ 变成了 $O(n*k)$，优化相当显著。

在 How do I compare document similarity using Python? 一文中给出了一个使用 gensim 实现文档相似度计算的实例。由于要同时处理多篇文档，在此对其进行了进一步的封装：

# coding: utf-8

import os
import sys
import gensim
import shutil


def open_file(filename, mode='r'):
    return open(filename, mode=mode, encoding='utf-8', errors='ignore')


class DocSimilarity(object):

    def __init__(self, in_dir):
        """读取所有歌词"""
        self.lyrics = []  # 所有歌词
        self.fnames = []  # 所有文件名
        for fname in sorted(os.listdir(in_dir)):  # 排序，让内容相似的更加靠近
            self.fnames.append(fname)
            self.lyrics.append(list(open_file(os.path.join(in_dir, fname)).read()))

        print("原歌词总数:", len(self.lyrics))
        self.corpus_pr()

    def corpus_pr(self):
        """gensim文档tf_idf计算"""
        dictionary = gensim.corpora.Dictionary(self.lyrics)  # 文档词汇表
        corpus = [dictionary.doc2bow(lyric) for lyric in self.lyrics]  # 文档BOW特征向量
        tf_idf = gensim.models.TfidfModel(corpus)
        corpus = list(tf_idf[corpus])  # 文档TF-IDF特征

        self.vocab_size = len(dictionary)
        self.corpus = corpus
        print("文档TF-IDF特征计算完毕。")

    def remove_sim(self, out_dir, max_similarity=0.2, last_k=20):
        """移除相似文档，保存到新目录"""
        if os.path.exists(out_dir):
            shutil.rmtree(out_dir)
        os.mkdir(out_dir)

        cnt, yes = 1, 1
        c_corpus = [self.corpus[0]]  # 第0篇直接放入
        open_file(os.path.join(out_dir, self.fnames[0]), 'w').write(''.join(self.lyrics[0]))

        for i in range(1, len(self.corpus)):
            try:
                # 注意，只对比last_k篇文档，而不是所有歌词
                sims = gensim.similarities.Similarity('/Users/gaussic/',
                                                      c_corpus[-last_k:],
                                                      num_features=self.vocab_size)
                if sims[self.corpus[i]].max() < max_similarity:  # 如果最相似文本的相似度小于阈值
                    c_corpus.append(self.corpus[i])
                    open_file(os.path.join(out_dir, self.fnames[i]), 'w').write(''.join(self.lyrics[i]))
                    yes += 1
                cnt += 1
            except:
                pass
            if cnt % 2000 == 0:
                print('已处理：', cnt, '保留：', yes)
        print("保留歌词数：", yes)


if __name__ == '__main__':
    data_dir = sys.argv[1]
    docsim = DocSimilarity(data_dir)
    # 对比前20篇文档，相似度低于0.2
    docsim.remove_sim('data_unique', max_similarity=0.2, last_k=20)

运行上述代码，原先的 1.6 万文档经过去重后剩余约 5800 篇，且用时不到 5 分钟，效果提升显著。

整合所有歌词

在经过以上清洗之后，数据应该算比较干净了。为了方便后面的训练和测试，现在把所有独立的文档分词并整合到一个文档中，做进一步的预处理。

分词使用jieba分词工具，每一行分词后，每个词以空格隔开。

需要注意的 3 点是:

1. 部分歌词前部和后部仍然有一些噪声，考虑直接扔掉前 3 行和后 3 行。
2. 分词后列表中存在大量空格和空字符，可以结合 join() 和 split() 去除。
3. 一行歌词太长和太短都会对模型的训练造成一定的影响，因而只保留适当长度的行。

import os
import jieba

jieba.enable_parallel(10)  # 并行分词

base_dir = 'data_unique'


def open_file(filename, mode='r'):
    return open(filename, mode=mode, encoding='utf-8', errors='ignore')


def lyric_group():
    lyric_full = open_file('lyric_full.txt', 'w')
    for fname in sorted(os.listdir(base_dir)):
        data = open_file(os.path.join(base_dir, fname)).readlines()
        if len(data) <= 6:  # 歌词太短，不要
            continue
        lyric = []
        for line in data[3:-3]:  # 前3行后三行都不要
            cur_line = list(jieba.cut(line.strip().lower()))
            if len(cur_line) >= 30:  # 太长不要
                continue
            lyric.extend(' '.join(cur_line).split())
            if len(lyric) >= 5:
                lyric_full.write(' '.join(lyric) + '\n')
                lyric = []
        lyric_full.write('\n')  # 每首歌词用空行隔开

    lyric_full.close()

整合后的歌词片段示例：

剩下 破折号 有些 人 什么 都 不 知道

好像 一个 人 巨大 的 问号

我 也 不 晓得 他们 如何是好

我 只有 祈祷 不用 别的 标点 和 符号

只 需要 一个 感叹号 不爱 什么 天荒 和 地 老

最 喜欢 一个 感叹号 不管 什么 伟大 和 渺小

只要 只要 出乎意料 感叹 我 的 奇妙

有些 人有 一双 怪 眉毛

皱 起来 好像 一对 括号

他们 越 烦恼 看来 越是 可笑

oh ~ ~ 有些 人 不当 主角

在 人家 的 故事 当 逗号

不 晓得 时候 不 早

我 只有 祈祷 不用 别的 标点 和 符号

只 需要 一个 感叹号 不爱 什么 天荒 和 地 老

最 喜欢 一个 感叹号 不管 什么 伟大 和 渺小

只要 只要 出乎意料 感叹 我 的 奇妙

不论 恋爱 还是 开玩笑 这 是 找 一时 热闹

我要 别人 看到 也 会 说不得 了

不用 别的 标点 和 符号

只 需要 一个 感叹号 不爱 什么 天荒 和 地 老

数据分析

这一步的数据分析，同样为构建模型时的参数选择服务。

首先是总词数和词汇量：

from collections import Counter
lyrics = open_file('lyric_full.txt').read().strip().replace('\n', ' ').split()
counter = Counter(lyrics)
count_pairs = counter.most_common()

print("总词数:", len(lyrics))
print("词汇量:", len(counter))
print("高频词:", count_pairs[:10])

输出：

总词数: 1011164
词汇量: 49280
高频词: [('的', 48193), ('我', 44841), ('你', 41828), ('在', 12436), ('是', 11583), ('了', 10560), ('爱', 8357), ('不', 7975), ('都', 7203), ('有', 6621)]

可以看到，词数达到了 100 万以上，词汇量接近 5 万，前 10 高频词无疑就是汉语常用字。进一步观察：

print(count_pairs[5000])
print(count_pairs[10000])
print(count_pairs[20000])
print(count_pairs[40000])

输出：

('抓不住', 20)
('别爱', 8)
('距', 3)
('严重性', 1)

排行 1 万的词出现 8 次，2 万的词出现 3 次，而 4 万以后的词只出现了 1 词。需要知道，我们的总词量是 100 万以上，这些词频太低的词对模型的影响是微不足道的，因此可以考虑将 1 万以后的这些词替换成 <unk> 标志，词汇表的减小大大降低了模型复杂性。

unk = 0
for i in range(10000, len(counter)):
    unk += count_pairs[i][1]
print("UNK所占百分比：{:.3}%".format(unk / len(lyrics) * 100))

取词汇表大小为 1 万，UNK 所占百分比约为 9%，可以进一步地删除部分数据来减小这个量。

count_pairs = counter.most_common(10000)
words, _ = list(zip(*count_pairs))
ws = set(words)    # 前1万个词

lyrics = []
for line in open_file('lyric_full.txt'):
    line = line.strip().split()
    if len(line) == 0:
        continue
    if len([x for x in line if x not in ws]) <= 0.3 * len(line):
        lyrics.append(line)
print(len(lyrics))

在只取 1 万词的情况下，过滤掉 unk 比例超过 0.3 的行，得到 12.5 万行歌词。

import pandas as pd

lengths = list(map(len, lyrics))
lengths = pd.DataFrame(lengths, columns=['lengths'])
print(lengths.describe())
输出：
             lengths
count  125940.000000
mean        7.424782
std         2.089210
min         5.000000
25%         6.000000
50%         7.000000
75%         9.000000
max        29.000000

总行数为 125940，每行平均长度 7.42，最小长度为 5，最大为 29，75% 的行长度为 9。

有一些模型在批处理时，需要定长的数据，因此需要把每行 pad 成固定的长度，不足的补 0，太长的裁剪，在这里，我们可以得出，把长度定为 10 左右会比较合理。

这一些分析，不似产品汪所强调的情绪、情节、情怀，但都是对于参数设置非常有意义的分析，在后面的章节会用到。因为我们的目的不单单是通过简单的词频统计来找到歌手的 pattern，而是要创造出一个能够写出兼具各家风格的歌词生成器。

代码暂时放在这个 repo 里，到后面整合到完整的系统中：gaussic/crawl_scripts

本篇和接下来的几篇文章，将从零开始，记录数据的抓取、清洗与分析，到歌词生成模型的构建、训练与分析过程。

要做歌词生成器，首先得有丰富的数据。花了点时间在网易云音乐网页版上面摸索，最后找到了几个页面，几个 API，终于把一整套的流程整理了出来。

转载请注明出处：从零开始做歌词生成器 - 0 - 抓取网易云3万首歌词

抓取流程分析

首先是这个页面：网易云音乐

基本上把热门的歌手都涵盖了，如果觉得不满足，还可以点左边的分栏，能找到更多的歌手。

接下来，以周董为例，点击进入周董的页面：周杰伦 - 网易云

周董页面的链接为：

http://music.163.com/#/artist?id=6452

每个歌手都有唯一的 id，使用这个 id 就能找到歌手的页面。不过如果只抓这个链接的话，我们只能抓取到 50 首歌。点击所有专辑，发现每页列出了 12 张专辑。专辑页面的链接如下：

http://music.163.com/#/artist/album?id=6452

可以看到，参数依然是歌手的 id。

为了不处理分页，可以再传一个 limit 参数：

http://music.163.com/#/artist/album?id=6452&limit=100

这样，所有的专辑都在一个页面显示。再点击进入一张专辑：

专辑页面链接为：

http://music.163.com/#/album?id=34720827

每一张专辑都有唯一的 id。在点击进入一首歌，发现歌也是由 id 表示的。

http://music.163.com/#/song?id=415792916

这样，整个的思路就清晰了，先抓取所有热门歌手的 id，再根据歌手 id 抓取其专辑列表，再根据每一张专辑的 id 抓取该专辑下所有歌曲 id，再根据歌曲 id 抓取该歌曲的歌词。

整个从歌手到歌词是一个树形结构。

抓取代码

搞明白这个流程，接下来就是抓取的实现，目标是一次性把这些热门歌手的所有歌全部抓取下来。

环境依赖：python 3，requests 2，BeautifulSoup 4。

requests 抓取函数及其他配置：

import os
import json
import requests
from bs4 import BeautifulSoup

base_url = "http://music.163.com"
start_url = base_url + "/artist/album?id={}&limit=100"  # 根据歌手的id，抓取其专辑列表
song_url = base_url + "/api/song/lyric?id={}&lv=1&kv=1&tv=-1"  # 根据歌曲的id，抓取歌词

headers = {
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/537.36 "
                  "(KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36",
    "Referer": "http://music.163.com",
    "Host": "music.163.com"
}


def get_html(url):  # requests抓取
    resp = requests.get(url, headers=headers)
    html = str(resp.content, encoding='utf-8', errors='ignore')
    return html

首先抓取歌手 id 列表，保存到文件中，注意到这是一个 API，返回的是 JSON 数据，直接访问网页链接是无效的：

def find_artist_ids():
    """只能拿到前100位的歌手ID"""
    url = 'http://music.163.com/api/artist/top?limit=100&offset=0'
    html = get_html(url)
    artists = json.loads(html)['artists']
    with open('artists.txt', 'w', encoding='utf-8', errors='ignore') as fa:
        for artist in artists:
            artist_name = artist['name'].strip().replace(" ", "_")
            fa.write(artist_name + ' ' + str(artist['id']) + '\n')

这样，100 位歌手 id 就保存到了 artists.txt 中：

周杰伦 6452
陈奕迅 2116
薛之谦 5781
BIGBANG 126339
林俊杰 3684
Maroon_5 96266
王菲 9621
李荣浩 4292
G.E.M.邓紫棋 7763
张学友 6460
杨宗纬 6066
许巍 5770
蔡健雅 7214
Adele 46487
Bruno_Mars 178059
Coldplay 89365
...

这其中包含中日韩欧美各种语言歌手，可以根据需要自行增删歌手（比如这几篇就只关注中文），不过这篇中，先把全部都抓下来。

然后就是抓取的核心代码：

def crawl_lyrics(art_id):
    """抓取一整个歌手的所有歌词"""
    html = get_html(start_url.format(art_id))  # 先抓该歌手的专辑列表
    soup = BeautifulSoup(html, 'lxml')

    artist = soup.find('h2', id='artist-name').text.strip().replace(' ', '_')
    artist_dir = 'data/' + artist
    if not os.path.exists(artist_dir):  # 歌手目录
        os.mkdir(artist_dir)
    print("歌手名：", artist)

    albums = soup.find('ul', class_='m-cvrlst').find_all('a', class_='msk')  # 专辑列表
    for album in albums:
        html = get_html(base_url + album.get('href'))  # 再抓取该专辑下歌曲列表
        soup = BeautifulSoup(html, 'lxml')

        album_title = soup.find('h2', class_='f-ff2').text.strip().replace(' ', '_').replace('/', '_')  # '/'会影响目录
        album_dir = os.path.join(artist_dir, album_title)
        if not os.path.exists(album_dir):  # 专辑目录
            os.mkdir(album_dir)
        print("  " + artist + "---" + album_title)

        links = soup.find('ul', class_='f-hide').find_all('a')  # 歌曲列表
        for link in links:
            song_name = link.text.strip().replace(' ', '_').replace('/', '_')
            song_id = link.get('href').split('=')[1]
            html = get_html(song_url.format(song_id))  # 抓取歌词

            try:  # 存在无歌词的歌曲，直接忽略
                lyric_json = json.loads(html)
                lyric_text = lyric_json['lrc']['lyric']

                open(os.path.join(album_dir, song_name + '.txt'), 'w', encoding='utf-8').write(lyric_text)
                print("    " + song_name + ", URL: " + song_url.format(song_id))
            except:
                print("    " + song_name + ": 无歌词, URL: " + song_url.format(song_id))
        print()

可以看到，整个代码的核心就是三层结构。保存的时候，也是按照层级结构来保存的。

下面开始抓取：

with open('artists.txt', 'r', encoding='utf-8') as f:
    for line in f:
        art_id = line.strip().split()[1]
        crawl_lyrics(art_id)

整个的代码，加上空行，加上输出提示，加上异常处理，不到 80 行。抓取到的示例如下：

整个 100 名歌手，大概 3 万 7 千多首，未经过任何清洗，当然有很多重复，比如说包含一些 live 的歌词。光陈奕迅一个人就有 1370 多首。

代码暂时放在这个 repo 里，到后面整合到完整的系统中：gaussic/crawl_scripts

如果需要现成的数据，我在百度云上面分享了一份：

链接:https://pan.baidu.com/s/1o9NNDjG 密码:0xe1

提示：

运行的代码的时候，发现半路上断了，估计是速度太快被禁止访问了，一个解决方案是，把抓完的歌手从 artists.txt 放到另外一个文件中，等一段时间，重新运行把剩下的抓了。另一个方案是，加代理，这样比较有效，不过速度比直接访问稍慢。经过测试，两者时间查不了太多。

下一篇再叙述，如何做一些数据清洗与简单的分析。

转载请注明出处：从零开始做歌词生成器 - 0 - 抓取网易云3万首歌词

中英文默认字体

使用 XeLatex + xeCJK 包

setmainfont 设置主字体，即英文字体

setCJKmainfont 中文字体

\usepackage{xeCJK}
\setmainfont{Times New Roman}
\setCJKmainfont[BoldFont=Hei]{Hei}
\setCJKmonofont{Hei}
\parindent 2em

合并单元格

转自：http://blog.csdn.net/wzxlovesy/article/details/69063271

合并一行多列单元格

合并 1 行多列可以使用 \multicolumn{cols}{pos}{text} 来实现

\documentclass[a4paper,12pt]{report}
\usepackage[UTF8,nopunct]{ctex}

\begin{document}

\begin{table}
	\centering
	\begin{tabular}{|c|c|c|c|}
		\hline
		\multicolumn{2}{|c|}{合并一行两列} & 三 & 四 \\
		\hline
		1 & 2 & 3 & 4 \\
		\hline
	\end{tabular}
\end{table}

\end{document}

合并多行一列单元格

合并多行 1 列单元格可以用 multirow 包中的 \multirow{rows}{width}{text} 来实现

注意这里的第2个参数是 {width}，与 \multicolumn 第 2 个参数不同。如果不确定 {width} 需要填什么，就将其替换为 *，如代码中所示

注意：下述代码中第 2 行表格第 1 列填入了 ~，这个符号放在这里表示这个单元格什么都不填，但是一定要保留这个空位，不然会产生文字叠加与表格不对齐，各位可以自行尝试，暂时不在这里演示效果，以免混淆。

\documentclass[a4paper,12pt]{report}
\usepackage[UTF8,nopunct]{ctex}
\usepackage{multirow}

\begin{document}

\begin{table}
	\centering
	\begin{tabular}{|c|c|c|c|}
		\hline
		\multirow{2}*{合并两行一列} & 二 & 三 & 四 \\
		~ & 2 & 3 & 4 \\
		\hline
	\end{tabular}
\end{table}

\end{document}

注意到这里并没有进行划线，如果直接在第 1 行和第 2 行之间插入一个 \hline，这条划线会穿过第 1 个单元格

\begin{table}
	\centering
	\begin{tabular}{|c|c|c|c|}
		\hline
		\multirow{2}*{合并两行一列} & 二 & 三 & 四 \\
		~ & 2 & 3 & 4 \\
		\hline
	\end{tabular}
\end{table}

解决方法是划一条从第 2 列开始到末尾的横线，使用命令 \cline{start-end}

\begin{table}
	\centering
	\begin{tabular}{|c|c|c|c|}
		\hline
		\multirow{2}*{合并两行一列} & 二 & 三 & 四 \\
		\cline{2-4}
		~ & 2 & 3 & 4 \\
		\hline
	\end{tabular}
\end{table}

合并多行多列单元格

合并多行多列有多种实现方式，这里仅提供一种个人使用感觉比较方便的方法，即组合 \multicomumn 和 \multirow 来实现

例如我们要插入一个合并 2 行 2 列的单元格

\documentclass[a4paper,12pt]{report}
\usepackage[UTF8,nopunct]{ctex}
\usepackage{multirow}

\begin{document}

\begin{table}
	\centering
	\begin{tabular}{|c|c|c|c|}
		\hline
		\multicolumn{2}{|c|}{\multirow{2}*{合并两行两列}}  & 三 & 四 \\
		\cline{3-4}
		\multicolumn{2}{|c|}{~} & 3 & 4 \\
		\hline
	\end{tabular}
\end{table}

\end{document}

注意：这里在第二行采用 \multicolumn 来进行空白占位，这样可以避免一些奇怪的划线行为，如果直接采用 ~ & ~ & ... 的方式来占位，会受到表格划线方式 {|c|c|c|c|} 的影响而多划一条竖线，如下

\begin{table}
	\centering
	\begin{tabular}{|c|c|c|c|}
		\hline
		\multicolumn{2}{|c|}{\multirow{2}*{合并两行两列}}  & 三 & 四 \\
		\cline{3-4}
		~ & ~ & 3 & 4 \\
		\hline
	\end{tabular}
\end{table}

代码地址：GitHub - gaussic/text-classification-cnn-rnn

转载请注明出处：CNN 与 RNN 中文文本分类 - 基于 TensorFlow 实现

CNN 做句子分类的论文可以参看: Convolutional Neural Networks for Sentence Classification

还可以去读 dennybritz 的博客：Implementing a CNN for Text Classification in TensorFlow

以及字符级 CNN 的论文：Character-level Convolutional Networks for Text Classification

如今，TensorFlow 大版本已经升级到了 1.3，对很多的网络层实现了更高层次的封装和实现，甚至还整合了如 Keras 这样优秀的一些高层次框架，使得其易用性大大提升。相比早起的底层代码，如今的实现更加简洁和优雅。

本文是基于 TensorFlow 在中文数据集上的简化实现，使用了字符级 CNN 和 RNN 对中文文本进行分类，达到了较好的效果。

数据集

本文采用了清华 NLP 组提供的 THUCNews 新闻文本分类数据集的一个子集（原始的数据集大约 74 万篇文档，训练起来需要花较长的时间）。数据集请自行到 THUCTC：一个高效的中文文本分类工具包 下载，请遵循数据提供方的开源协议。

本次训练使用了其中的 10 个分类，每个分类 6500 条数据。

类别如下：

体育, 财经, 房产, 家居, 教育, 科技, 时尚, 时政, 游戏, 娱乐

这个子集可以在此下载：链接: http://pan.baidu.com/s/1bpq9Eub 密码:ycyw

数据集划分如下：

• 训练集: 5000*10
• 验证集: 500*10
• 测试集: 1000*10

从原数据集生成子集的过程请参看 helper 下的两个脚本。其中，copy_data.sh 用于从每个分类拷贝 6500 个文件，cnews_group.py 用于将多个文件整合到一个文件中。执行该文件后，得到三个数据文件：

• cnews.train.txt: 训练集 (50000 条)
• cnews.val.txt: 验证集 (5000 条)
• cnews.test.txt: 测试集 (10000 条)

预处理

data/cnews_loader.py 为数据的预处理文件。

• read_file(): 读取文件数据;
• build_vocab(): 构建词汇表，使用字符级的表示，这一函数会将词汇表存储下来，避免每一次重复处理;
• read_vocab(): 读取上一步存储的词汇表，转换为 {词：id} 表示;
• read_category(): 将分类目录固定，转换为 {类别: id} 表示;
• to_words(): 将一条由 id 表示的数据重新转换为文字;
• preocess_file(): 将数据集从文字转换为固定长度的 id 序列表示;
• batch_iter(): 为神经网络的训练准备经过 shuffle 的批次的数据。

经过数据预处理，数据的格式如下：

CNN 卷积神经网络

配置项

CNN 可配置的参数如下所示，在 cnn_model.py 中。

class TCNNConfig(object):
    """CNN配置参数"""

    embedding_dim = 64      # 词向量维度
    seq_length = 600        # 序列长度
    num_classes = 10        # 类别数
    num_filters = 128        # 卷积核数目
    kernel_size = 5         # 卷积核尺寸
    vocab_size = 5000       # 词汇表达小

    hidden_dim = 128        # 全连接层神经元

    dropout_keep_prob = 0.5 # dropout保留比例
    learning_rate = 1e-3    # 学习率

    batch_size = 64         # 每批训练大小
    num_epochs = 10         # 总迭代轮次

    print_per_batch = 100    # 每多少轮输出一次结果
    save_per_batch = 10      # 每多少轮存入tensorboard

CNN 模型

具体参看 cnn_model.py 的实现。

大致结构如下：

训练与验证

运行 python run_cnn.py train，可以开始训练。

若之前进行过训练，请把 tensorboard/textcnn 删除，避免 TensorBoard 多次训练结果重叠。

Configuring CNN model...
Configuring TensorBoard and Saver...
Loading training and validation data...
Time usage: 0:00:14
Training and evaluating...
Epoch: 1
Iter:      0, Train Loss:    2.3, Train Acc:  10.94%, Val Loss:    2.3, Val Acc:   8.92%, Time: 0:00:01 *
Iter:    100, Train Loss:   0.88, Train Acc:  73.44%, Val Loss:    1.2, Val Acc:  68.46%, Time: 0:00:04 *
Iter:    200, Train Loss:   0.38, Train Acc:  92.19%, Val Loss:   0.75, Val Acc:  77.32%, Time: 0:00:07 *
Iter:    300, Train Loss:   0.22, Train Acc:  92.19%, Val Loss:   0.46, Val Acc:  87.08%, Time: 0:00:09 *
Iter:    400, Train Loss:   0.24, Train Acc:  90.62%, Val Loss:    0.4, Val Acc:  88.62%, Time: 0:00:12 *
Iter:    500, Train Loss:   0.16, Train Acc:  96.88%, Val Loss:   0.36, Val Acc:  90.38%, Time: 0:00:15 *
Iter:    600, Train Loss:  0.084, Train Acc:  96.88%, Val Loss:   0.35, Val Acc:  91.36%, Time: 0:00:17 *
Iter:    700, Train Loss:   0.21, Train Acc:  93.75%, Val Loss:   0.26, Val Acc:  92.58%, Time: 0:00:20 *
Epoch: 2
Iter:    800, Train Loss:   0.07, Train Acc:  98.44%, Val Loss:   0.24, Val Acc:  94.12%, Time: 0:00:23 *
Iter:    900, Train Loss:  0.092, Train Acc:  96.88%, Val Loss:   0.27, Val Acc:  92.86%, Time: 0:00:25
Iter:   1000, Train Loss:   0.17, Train Acc:  95.31%, Val Loss:   0.28, Val Acc:  92.82%, Time: 0:00:28
Iter:   1100, Train Loss:    0.2, Train Acc:  93.75%, Val Loss:   0.23, Val Acc:  93.26%, Time: 0:00:31
Iter:   1200, Train Loss:  0.081, Train Acc:  98.44%, Val Loss:   0.25, Val Acc:  92.96%, Time: 0:00:33
Iter:   1300, Train Loss:  0.052, Train Acc: 100.00%, Val Loss:   0.24, Val Acc:  93.58%, Time: 0:00:36
Iter:   1400, Train Loss:    0.1, Train Acc:  95.31%, Val Loss:   0.22, Val Acc:  94.12%, Time: 0:00:39
Iter:   1500, Train Loss:   0.12, Train Acc:  98.44%, Val Loss:   0.23, Val Acc:  93.58%, Time: 0:00:41
Epoch: 3
Iter:   1600, Train Loss:    0.1, Train Acc:  96.88%, Val Loss:   0.26, Val Acc:  92.34%, Time: 0:00:44
Iter:   1700, Train Loss:  0.018, Train Acc: 100.00%, Val Loss:   0.22, Val Acc:  93.46%, Time: 0:00:47
Iter:   1800, Train Loss:  0.036, Train Acc: 100.00%, Val Loss:   0.28, Val Acc:  92.72%, Time: 0:00:50
No optimization for a long time, auto-stopping...

在验证集上的最佳效果为 94.12%，且只经过了 3 轮迭代就已经停止。

准确率和误差如图所示：

测试

运行 python run_cnn.py test 在测试集上进行测试。

Configuring CNN model...
Loading test data...
Testing...
Test Loss:   0.14, Test Acc:  96.04%
Precision, Recall and F1-Score...
             precision    recall  f1-score   support

         体育       0.99      0.99      0.99      1000
         财经       0.96      0.99      0.97      1000
         房产       1.00      1.00      1.00      1000
         家居       0.95      0.91      0.93      1000
         教育       0.95      0.89      0.92      1000
         科技       0.94      0.97      0.95      1000
         时尚       0.95      0.97      0.96      1000
         时政       0.94      0.94      0.94      1000
         游戏       0.97      0.96      0.97      1000
         娱乐       0.95      0.98      0.97      1000

avg / total       0.96      0.96      0.96     10000

Confusion Matrix...
[[991   0   0   0   2   1   0   4   1   1]
 [  0 992   0   0   2   1   0   5   0   0]
 [  0   1 996   0   1   1   0   0   0   1]
 [  0  14   0 912   7  15   9  29   3  11]
 [  2   9   0  12 892  22  18  21  10  14]
 [  0   0   0  10   1 968   4   3  12   2]
 [  1   0   0   9   4   4 971   0   2   9]
 [  1  16   0   4  18  12   1 941   1   6]
 [  2   4   1   5   4   5  10   1 962   6]
 [  1   0   1   6   4   3   5   0   1 979]]
Time usage: 0:00:05

在测试集上的准确率达到了 96.04%，且各类的 precision, recall 和 f1-score 都超过了 0.9。

从混淆矩阵也可以看出分类效果非常优秀。

RNN循环神经网络

配置项

RNN 可配置的参数如下所示，在 rnn_model.py 中。

class TRNNConfig(object):
    """RNN配置参数"""

    # 模型参数
    embedding_dim = 64      # 词向量维度
    seq_length = 600        # 序列长度
    num_classes = 10        # 类别数
    vocab_size = 5000       # 词汇表达小

    num_layers= 2           # 隐藏层层数
    hidden_dim = 128        # 隐藏层神经元
    rnn = 'gru'             # lstm 或 gru

    dropout_keep_prob = 0.8 # dropout保留比例
    learning_rate = 1e-3    # 学习率

    batch_size = 128         # 每批训练大小
    num_epochs = 10          # 总迭代轮次

    print_per_batch = 100    # 每多少轮输出一次结果
    save_per_batch = 10      # 每多少轮存入tensorboard

RNN模型

具体参看 rnn_model.py 的实现。

大致结构如下：

训练与验证

这部分的代码与 run_cnn.py 极为相似，只需要将模型和部分目录稍微修改。

运行 python run_rnn.py train，可以开始训练。

若之前进行过训练，请把 tensorboard/textrnn 删除，避免 TensorBoard 多次训练结果重叠。

Configuring RNN model...
Configuring TensorBoard and Saver...
Loading training and validation data...
Time usage: 0:00:14
Training and evaluating...
Epoch: 1
Iter:      0, Train Loss:    2.3, Train Acc:   8.59%, Val Loss:    2.3, Val Acc:  11.96%, Time: 0:00:08 *
Iter:    100, Train Loss:   0.95, Train Acc:  64.06%, Val Loss:    1.3, Val Acc:  53.06%, Time: 0:01:15 *
Iter:    200, Train Loss:   0.61, Train Acc:  79.69%, Val Loss:   0.94, Val Acc:  69.88%, Time: 0:02:22 *
Iter:    300, Train Loss:   0.49, Train Acc:  85.16%, Val Loss:   0.63, Val Acc:  81.44%, Time: 0:03:29 *
Epoch: 2
Iter:    400, Train Loss:   0.23, Train Acc:  92.97%, Val Loss:    0.6, Val Acc:  82.86%, Time: 0:04:36 *
Iter:    500, Train Loss:   0.27, Train Acc:  92.97%, Val Loss:   0.47, Val Acc:  86.72%, Time: 0:05:43 *
Iter:    600, Train Loss:   0.13, Train Acc:  98.44%, Val Loss:   0.43, Val Acc:  87.46%, Time: 0:06:50 *
Iter:    700, Train Loss:   0.24, Train Acc:  91.41%, Val Loss:   0.46, Val Acc:  87.12%, Time: 0:07:57
Epoch: 3
Iter:    800, Train Loss:   0.11, Train Acc:  96.09%, Val Loss:   0.49, Val Acc:  87.02%, Time: 0:09:03
Iter:    900, Train Loss:   0.15, Train Acc:  96.09%, Val Loss:   0.55, Val Acc:  85.86%, Time: 0:10:10
Iter:   1000, Train Loss:   0.17, Train Acc:  96.09%, Val Loss:   0.43, Val Acc:  89.44%, Time: 0:11:18 *
Iter:   1100, Train Loss:   0.25, Train Acc:  93.75%, Val Loss:   0.42, Val Acc:  88.98%, Time: 0:12:25
Epoch: 4
Iter:   1200, Train Loss:   0.14, Train Acc:  96.09%, Val Loss:   0.39, Val Acc:  89.82%, Time: 0:13:32 *
Iter:   1300, Train Loss:    0.2, Train Acc:  96.09%, Val Loss:   0.43, Val Acc:  88.68%, Time: 0:14:38
Iter:   1400, Train Loss:  0.012, Train Acc: 100.00%, Val Loss:   0.37, Val Acc:  90.58%, Time: 0:15:45 *
Iter:   1500, Train Loss:   0.15, Train Acc:  96.88%, Val Loss:   0.39, Val Acc:  90.58%, Time: 0:16:52
Epoch: 5
Iter:   1600, Train Loss:  0.075, Train Acc:  97.66%, Val Loss:   0.41, Val Acc:  89.90%, Time: 0:17:59
Iter:   1700, Train Loss:  0.042, Train Acc:  98.44%, Val Loss:   0.41, Val Acc:  90.08%, Time: 0:19:06
Iter:   1800, Train Loss:   0.08, Train Acc:  97.66%, Val Loss:   0.38, Val Acc:  91.36%, Time: 0:20:13 *
Iter:   1900, Train Loss:  0.089, Train Acc:  98.44%, Val Loss:   0.39, Val Acc:  90.18%, Time: 0:21:20
Epoch: 6
Iter:   2000, Train Loss:  0.092, Train Acc:  96.88%, Val Loss:   0.36, Val Acc:  91.42%, Time: 0:22:27 *
Iter:   2100, Train Loss:  0.062, Train Acc:  98.44%, Val Loss:   0.39, Val Acc:  90.56%, Time: 0:23:34
Iter:   2200, Train Loss:  0.053, Train Acc:  98.44%, Val Loss:   0.39, Val Acc:  90.02%, Time: 0:24:41
Iter:   2300, Train Loss:   0.12, Train Acc:  96.09%, Val Loss:   0.37, Val Acc:  90.84%, Time: 0:25:48
Epoch: 7
Iter:   2400, Train Loss:  0.014, Train Acc: 100.00%, Val Loss:   0.41, Val Acc:  90.38%, Time: 0:26:55
Iter:   2500, Train Loss:   0.14, Train Acc:  96.88%, Val Loss:   0.37, Val Acc:  91.22%, Time: 0:28:01
Iter:   2600, Train Loss:   0.11, Train Acc:  96.88%, Val Loss:   0.43, Val Acc:  89.76%, Time: 0:29:08
Iter:   2700, Train Loss:  0.089, Train Acc:  97.66%, Val Loss:   0.37, Val Acc:  91.18%, Time: 0:30:15
Epoch: 8
Iter:   2800, Train Loss: 0.0081, Train Acc: 100.00%, Val Loss:   0.44, Val Acc:  90.66%, Time: 0:31:22
Iter:   2900, Train Loss:  0.017, Train Acc: 100.00%, Val Loss:   0.44, Val Acc:  89.62%, Time: 0:32:29
Iter:   3000, Train Loss:  0.061, Train Acc:  96.88%, Val Loss:   0.43, Val Acc:  90.04%, Time: 0:33:36
No optimization for a long time, auto-stopping...

在验证集上的最佳效果为 91.42%，经过了 8 轮迭代停止，速度相比 CNN 慢很多。

准确率和误差如图所示：

测试

运行 python run_rnn.py test 在测试集上进行测试。

Testing...
Test Loss:   0.21, Test Acc:  94.22%
Precision, Recall and F1-Score...
             precision    recall  f1-score   support

         体育       0.99      0.99      0.99      1000
         财经       0.91      0.99      0.95      1000
         房产       1.00      1.00      1.00      1000
         家居       0.97      0.73      0.83      1000
         教育       0.91      0.92      0.91      1000
         科技       0.93      0.96      0.94      1000
         时尚       0.89      0.97      0.93      1000
         时政       0.93      0.93      0.93      1000
         游戏       0.95      0.97      0.96      1000
         娱乐       0.97      0.96      0.97      1000

avg / total       0.94      0.94      0.94     10000

Confusion Matrix...
[[988   0   0   0   4   0   2   0   5   1]
 [  0 990   1   1   1   1   0   6   0   0]
 [  0   2 996   1   1   0   0   0   0   0]
 [  2  71   1 731  51  20  88  28   3   5]
 [  1   3   0   7 918  23   4  31   9   4]
 [  1   3   0   3   0 964   3   5  21   0]
 [  1   0   1   7   1   3 972   0   6   9]
 [  0  16   0   0  22  26   0 931   2   3]
 [  2   3   0   0   2   2  12   0 972   7]
 [  0   3   1   1   7   3  11   5   9 960]]
Time usage: 0:00:33

在测试集上的准确率达到了 94.22%，且各类的 precision, recall 和 f1-score，除了家居这一类别，都超过了 0.9。

从混淆矩阵可以看出分类效果非常优秀。

对比两个模型，可见 RNN 除了在家居分类的表现不是很理想，其他几个类别较 CNN 差别不大。

还可以通过进一步的调节参数，来达到更好的效果。

读了将近一个下午的 TensorFlow Recurrent Neural Network 教程，翻看其在 PTB 上的实现，感觉晦涩难懂，因此参考了部分代码，自己写了一个简化版的 Language Model，思路借鉴了 Keras 的 LSTM text generation。

代码地址：GitHub - gaussic/tf-rnnlm

转载请注明出处：使用 TensorFlow 训练循环神经网络语言模型

语言模型

Language Model，即语言模型，其主要思想是，在知道前一部分的词的情况下，推断出下一个最有可能出现的词。例如，知道了 The fat cat sat on the，我们认为下一个词为 mat 的可能性比 hat 要大，因为猫更有可能坐在毯子上，而不是帽子上。

这可能被你认为是常识，但是在自然语言处理中，这个任务是可以用概率统计模型来描述的。就拿 The fat cat sat on the mat 来说。我们可能统计出第一个词 The 出现的概率 $p(The)$ ，The 后面是 fat 的条件概率为 $p(fat|The)$ ，The fat 同时出现的联合概率：

$$
p(The, fat) = p(The)·p(fat|The)
$$

这个联合概率，就是 The fat 的合理性，即这句话的出现符不符合自然语言的评判标准，通俗点表述就是这是不是句人话。同理，根据链式规则，The fat cat 的联合概率可求：

$$
p(The, fat, cat) = p(The)·p(fat|The)·p(cat|The, fat)
$$

在知道前面的词为 The cat 的情况下，下一个词为 cat 的概率可以推导出来：

$$
p(cat|The, fat) = \frac{p(The, fat, cat)}{p(The, fat)}
$$

分子是 The fat cat 在语料库中出现的次数，分母是 The fat 在语料库中出现的次数。

因此，The fat cat sat on the mat 整个句子的合理性同样可以推导，这个句子的合理性即为它的概率。公式化的描述如下：

$$
p(S) = p(w_1, w_2, ···, w_n) = p(w_1)·p(w_2|w_1)·p(w_3|w_1, w_2)···p(w_n|w_1, w_2, w_3, ···, w_{n-1})
$$

可以看出一个问题，每当计算下一个词的条件概率，需要计算前面所有词的联合概率。这个计算量相当的庞大。并且，一个句子中大部分词同时出现的概率往往少之又少，数据稀疏非常严重，需要一个非常大的语料库来训练。

一个简单的优化是基于马尔科夫假设，下一个词的出现仅与前面的一个或 n 个词有关。

最简单的情况，下一个词的出现仅仅和前面一个词有关，称之为 bigram。

$$
p(S) = p(w_1, w_2, ···, w_n) = p(w_1)·p(w_2|w_1)·p(w_3|w_2)·p(w_4|w_3)···p(w_n|w_{n-1})
$$

再复杂点，下一个词的出现仅和前面两个词有关，称之为 trigram。

$$
p(S) = p(w_1, w_2, ···, w_n) = p(w_1)·p(w_2|w_1)·p(w_3|w_1, w_2)·p(w_4|w_2, w_3)···p(w_n|w_n-2, w_{n-1})
$$

这样的条件概率虽然好求，但是会丢失大量的前面的词的信息，有时会对结果产生不良影响。因此如何选择一个有效的 n，使得既能简化计算，又能保留大部分的上下文信息。

以上均是传统语言模型的描述。如果不太深究细节，我们的任务就是，知道前面 n 个词，来计算下一个词出现的概率。并且使用语言模型来生成新的文本。

在本文中，我们更加关注的是，如何使用 RNN 来推测下一个词。

数据准备

TensorFlow 的官方文档使用的是 Mikolov 准备好的 PTB 数据集。我们可以将其下载并解压出来：

$ wget http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz
$ tar xvf simple-examples.tgz

部分数据如下，不常用的词转换成了 <unk> 标记，数字转换成了 N：

we 're talking about years ago before anyone heard of asbestos having any questionable properties
there is no asbestos in our products now
neither <unk> nor the researchers who studied the workers were aware of any research on smokers of the kent cigarettes
we have no useful information on whether users are at risk said james a. <unk> of boston 's <unk> cancer institute
the total of N deaths from malignant <unk> lung cancer and <unk> was far higher than expected the researchers said

读取文件中的数据，将换行符转换为 <eos>，然后转换为词的 list：

def _read_words(filename):
    with open(filename, 'r', encoding='utf-8') as f:
        return f.read().replace('\', '<eos>').split()

f = _read_words('simple-examples/data/ptb.train.txt')
print(f[:20])

得到：

['aer', 'banknote', 'berlitz', 'calloway', 'centrust', 'cluett', 'fromstein', 'gitano', 'guterman', 'hydro-quebec', 'ipo', 'kia', 'memotec', 'mlx', 'nahb', 'punts', 'rake', 'regatta', 'rubens', 'sim']

构建词汇表，词与 id 互转：

def _build_vocab(filename):
    data = _read_words(filename)

    counter = Counter(data)
    count_pairs = sorted(counter.items(), key=lambda x: -x[1])

    words, _ = list(zip(*count_pairs))
    word_to_id = dict(zip(words, range(len(words))))

    return words, word_to_id

words, words_to_id = _build_vocab('simple-examples/data/ptb.train.txt')
print(words[:10])
print(list(map(lambda x: words_to_id[x], words[:10])))

输出：

('the', '<unk>', '<eos>', 'N', 'of', 'to', 'a', 'in', 'and', "'s")
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

将一个文件转换为 id 表示：

def _file_to_word_ids(filename, word_to_id):
    data = _read_words(filename)
    return [word_to_id[x] for x in data if x in word_to_id]

words_in_file = _file_to_word_ids('simple-examples/data/ptb.train.txt', words_to_id)
print(words_in_file[:20])

词汇表已根据词频进行排序，由于第一句话非英文，所以 id 靠后。

[9980, 9988, 9981, 9989, 9970, 9998, 9971, 9979, 9992, 9997, 9982, 9972, 9993, 9991, 9978, 9983, 9974, 9986, 9999, 9990]

将一句话从 id 列表转换回词：

def to_words(sentence, words):
    return list(map(lambda x: words[x], sentence))

将以上函数整合：

def ptb_raw_data(data_path=None):
    train_path = os.path.join(data_path, 'ptb.train.txt')
    valid_path = os.path.join(data_path, 'ptb.valid.txt')
    test_path = os.path.join(data_path, 'ptb.test.txt')

    words, word_to_id = _build_vocab(train_path)
    train_data = _file_to_word_ids(train_path, word_to_id)
    valid_data = _file_to_word_ids(valid_path, word_to_id)
    test_data = _file_to_word_ids(test_path, word_to_id)

    return train_data, valid_data, test_data, words, word_to_id

以上部分和官方的例子有一定的相似之处。接下来的处理和官方存在很大的不同，主要参考了 Keras 例程处理文档的操作：

def ptb_producer(raw_data, batch_size=64, num_steps=20, stride=1):
    data_len = len(raw_data)

    sentences = []
    next_words = []
    for i in range(0, data_len - num_steps, stride):
        sentences.append(raw_data[i:(i + num_steps)])
        next_words.append(raw_data[i + num_steps])

    sentences = np.array(sentences)
    next_words = np.array(next_words)

    batch_len = len(sentences) // batch_size
    x = np.reshape(sentences[:(batch_len * batch_size)], \\
        [batch_len, batch_size, -1])

    y = np.reshape(next_words[:(batch_len * batch_size)], \\
        [batch_len, batch_size])

    return x, y

参数解析：

• raw_data: 即 ptb_raw_data() 函数产生的数据
• batch_size: 神经网络使用随机梯度下降，数据按多个批次输出，此为每个批次的数据量
• num_steps: 每个句子的长度，相当于之前描述的 n 的大小，这在循环神经网络中又称为时序的长度。
• stride: 取数据的步长，决定数据量的大小。

代码解析：

这个函数将一个原始数据 list 转换为多个批次的数据，即 [batch_len, batch_size, num_steps]。

首先，程序每一次取了 num_steps 个词作为一个句子，即 x，以这 num_steps 个词后面的一个词作为它的下一个预测，即为 y。这样，我们首先把原始数据整理成了 batch_len * batch_size 个 x 和 y 的表示，类似于已知 x 求 y 的分类问题。

为了满足随机梯度下降的需要，我们还需要把数据整理成一个个小的批次，每次喂一个批次的数据给 TensorFlow 来更新权重，这样，数据就整理为 [batch_len, batch_size, num_steps] 的格式。

打印部分数据：

train_data, valid_data, test_data, words, word_to_id = ptb_raw_data('simple-examples/data')
x_train, y_train = ptb_producer(train_data)
print(x_train.shape)
print(y_train.shape)

输出：

(14524, 64, 20)
(14524, 64)

可见我们得到了 14524 个批次的数据，每个批次的训练集维度为 [64, 20]。

print(' '.join(to_words(x_train[100, 3], words)))

第 100 个批次的第 3 句话为：

despite steady sales growth <eos> magna recently cut its quarterly dividend in half and the company 's class a shares

print(words[np.argmax(y_train[100, 3])])

它的下一个词为：

the

构建模型

配置项

class LMConfig(object):
    """language model 配置项"""
    batch_size = 64       # 每一批数据的大小
    num_steps = 20        # 每一个句子的长度
    stride = 3            # 取数据时的步长

    embedding_dim = 64    # 词向量维度
    hidden_dim = 128      # RNN隐藏层维度
    num_layers = 2        # RNN层数

    learning_rate = 0.05  # 学习率
    dropout = 0.2         # 每一层后的丢弃概率

读取输入

让模型可以按批次的读取数据。

class PTBInput(object):
    """按批次读取数据"""
    def __init__(self, config, data):
        self.batch_size = config.batch_size
        self.num_steps = config.num_steps
        self.vocab_size = config.vocab_size # 词汇表大小

        self.input_data, self.targets = ptb_producer(data,
            self.batch_size, self.num_steps)

        self.batch_len = self.input_data.shape[0] # 总批次
        self.cur_batch = 0  # 当前批次

    def next_batch(self):
        """读取下一批次"""
        x = self.input_data[self.cur_batch]
        y = self.targets[self.cur_batch]

        # 转换为one-hot编码
        y_ = np.zeros((y.shape[0], self.vocab_size), dtype=np.bool)
        for i in range(y.shape[0]):
            y_[i][y[i]] = 1

        # 如果到最后一个批次，则回到最开头
        self.cur_batch = (self.cur_batch +1) % self.batch_len

        return x, y_

模型

class PTBModel(object):
    def __init__(self, config, is_training=True):

        self.num_steps = config.num_steps
        self.vocab_size = config.vocab_size

        self.embedding_dim = config.embedding_dim
        self.hidden_dim = config.hidden_dim
        self.num_layers = config.num_layers
        self.rnn_model = config.rnn_model

        self.learning_rate = config.learning_rate
        self.dropout = config.dropout

        self.placeholders()  # 输入占位符
        self.rnn()           # rnn 模型构建
        self.cost()          # 代价函数
        self.optimize()      # 优化器
        self.error()         # 错误率


    def placeholders(self):
        """输入数据的占位符"""
        self._inputs = tf.placeholder(tf.int32, [None, self.num_steps])
        self._targets = tf.placeholder(tf.int32, [None, self.vocab_size])


    def input_embedding(self):
        """将输入转换为词向量表示"""
        with tf.device("/cpu:0"):
            embedding = tf.get_variable(
                "embedding", [self.vocab_size,
                    self.embedding_dim], dtype=tf.float32)
            _inputs = tf.nn.embedding_lookup(embedding, self._inputs)

        return _inputs


    def rnn(self):
        """rnn模型构建"""
        def lstm_cell():  # 基本的lstm cell
            return tf.contrib.rnn.BasicLSTMCell(self.hidden_dim,
                state_is_tuple=True)

        def gru_cell():   # gru cell，速度更快
            return tf.contrib.rnn.GRUCell(self.hidden_dim)

        def dropout_cell():    # 在每个cell后添加dropout
            if (self.rnn_model == 'lstm'):
                cell = lstm_cell()
            else:
                cell = gru_cell()
            return tf.contrib.rnn.DropoutWrapper(cell,
                output_keep_prob=self.dropout)

        cells = [dropout_cell() for _ in range(self.num_layers)]
        cell = tf.contrib.rnn.MultiRNNCell(cells, state_is_tuple=True)  # 多层rnn

        _inputs = self.input_embedding()
        _outputs, _ = tf.nn.dynamic_rnn(cell=cell,
            inputs=_inputs, dtype=tf.float32)

        # _outputs的shape为 [batch_size, num_steps, hidden_dim]
        last = _outputs[:, -1, :]  # 只需要最后一个输出

        # dense 和 softmax 用于分类，以找出各词的概率
        logits = tf.layers.dense(inputs=last, units=self.vocab_size)   
        prediction = tf.nn.softmax(logits)  

        self._logits = logits
        self._pred = prediction

    def cost(self):
        """计算交叉熵代价函数"""
        cross_entropy = tf.nn.softmax_cross_entropy_with_logits(
            logits=self._logits, labels=self._targets)
        cost = tf.reduce_mean(cross_entropy)
        self.cost = cost

    def optimize(self):
        """使用adam优化器"""
        optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate)
        self.optim = optimizer.minimize(self.cost)

    def error(self):
        """计算错误率"""
        mistakes = tf.not_equal(
            tf.argmax(self._targets, 1), tf.argmax(self._pred, 1))
        self.errors = tf.reduce_mean(tf.cast(mistakes, tf.float32))

训练

def run_epoch(num_epochs=10):
    config = LMConfig()   # 载入配置项

    # 载入源数据，这里只需要训练集
    train_data, _, _, words, word_to_id = \\
        ptb_raw_data('simple-examples/data')
    config.vocab_size = len(words)

    # 数据分批
    input_train = PTBInput(config, train_data)
    batch_len = input_train.batch_len

    # 构建模型
    model = PTBModel(config)

    # 创建session，初始化变量
    sess = tf.Session()
    sess.run(tf.global_variables_initializer())

    print('Start training...')
    for epoch in range(num_epochs):  # 迭代轮次
        for i in range(batch_len):   # 经过多少个batch
            x_batch, y_batch = input_train.next_batch()

            # 取一个批次的数据，运行优化
            feed_dict = {model._inputs: x_batch, model._targets: y_batch}
            sess.run(model.optim, feed_dict=feed_dict)

            # 每500个batch，输出一次中间结果
            if i % 500 == 0:
                cost = sess.run(model.cost, feed_dict=feed_dict)

                msg = "Epoch: {0:>3}, batch: {1:>6}, Loss: {2:>6.3}"
                print(msg.format(epoch + 1, i + 1, cost))

                # 输出部分预测结果
                pred = sess.run(model._pred, feed_dict=feed_dict)
                word_ids = sess.run(tf.argmax(pred, 1))
                print('Predicted:', ' '.join(words[w] for w in word_ids))
                true_ids = np.argmax(y_batch, 1)
                print('True:', ' '.join(words[w] for w in true_ids))

    print('Finish training...')
    sess.close()

需要经过多次的训练才能得到一个较为合理的结果。

这是一篇 dandelionmane 在 TensorFlow Dev Summit 2017 关于 TensorBoard 介绍的总结教程。

转载请说明出处：TensorFlow (5) - TensorBoard 可视化

在之前的章节中，几乎所有的性能评估都是通过打印中间结果字符串来完成的。使用更多的可视化的图表可以让人对模型有一个更加直观的认识。在本章中，我们将使用 TensorBoard 对模型进行可视化。

计算图可视化

要可视化 TensorFlow 的计算图，需要先构建网络。

网络层

本章的网络，依然使用之前几个章节对 MNIST 数据集使用的网络结构。为了方便实现，固定了其中的一部分参数。相关层如下：

# 简单卷积层，为方便本章教程叙述，固定部分参数
def conv_layer(input,
               channels_in,    # 输入通道数
               channels_out):  # 输出通道数

    weights = tf.Variable(tf.truncated_normal([5, 5, channels_in, channels_out], stddev=0.05))
    biases = tf.Variable(tf.constant(0.05, shape=[channels_out]))
    conv = tf.nn.conv2d(input, filter=weights, strides=[1, 1, 1, 1], padding='SAME')
    act = tf.nn.relu(conv + biases)
    return act

# 简化全连接层
def fc_layer(input, num_inputs, num_outputs, use_relu=True):
    weights = tf.Variable(tf.truncated_normal([num_inputs, num_outputs], stddev=0.05))
    biases = tf.Variable(tf.constant(0.05, shape=[num_outputs]))
    act = tf.matmul(input, weights) + biases

    if use_relu:
        act = tf.nn.relu(act)
    return act     

# max pooling 层
def max_pool(input):
    return tf.nn.max_pool(input, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

载入数据，构建网络

from tensorflow.examples.tutorials.mnist import input_data
data = input_data.read_data_sets('data/MNIST', one_hot=True)

x = tf.placeholder(tf.float32, shape=[None, 784])   # 固定这部分值
y = tf.placeholder(tf.float32, shape=[None, 10])
x_image = tf.reshape(x, [-1, 28, 28, 1])

conv1 = conv_layer(x_image, 1, 32)   # 增加了卷积核数目
pool1 = max_pool(conv1)

conv2 = conv_layer(pool1, 32, 64)
pool2 = max_pool(conv2)

flat_shape = pool2.get_shape()[1:4].num_elements()
flattened = tf.reshape(pool2, [-1, flat_shape])

fc1 = fc_layer(flattened, flat_shape, 1024)     # 增大神经元数目
logits = fc_layer(fc1, 1024, 10, use_relu=False)

交叉熵，优化器，准确率

# 计算交叉熵
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=logits))

# 使用Adam优化器来训练
optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cross_entropy)

# 计算准确率
correct_prediction = tf.equal(tf.argmax(y, axis=1), tf.argmax(logits, axis=1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

创建 session，训练

session = tf.Session()
session.run(tf.global_variables_initializer())

train_batch_size = 100

for i in range(2001):
    x_batch, y_batch = data.train.next_batch(train_batch_size)

    feed_dict = {x: x_batch, y: y_batch}

    if i % 500 == 0:
        train_accuracy = session.run(accuracy, feed_dict=feed_dict)
        print("迭代轮次: {0:>6}, 训练准确率: {1:>6.4%}".format(i, train_accuracy))

    session.run(optimizer, feed_dict=feed_dict)

迭代轮次:      0, 训练准确率: 9.0000%
迭代轮次:    500, 训练准确率: 93.0000%
迭代轮次:   1000, 训练准确率: 97.0000%
迭代轮次:   1500, 训练准确率: 98.0000%
迭代轮次:   2000, 训练准确率: 100.0000%

可见训练效果比较理想。

可视化计算图

现在需要将计算图可视化，需要使用 tf.summary.FileWriter 来将计算图写入指定目录：

tensorboard_dir = 'tensorboard/mnist'   # 保存目录
if not os.path.exists(tensorboard_dir):
    os.makedirs(tensorboard_dir)

writer = tf.summary.FileWriter(tensorboard_dir)
writer.add_graph(session.graph)

以上代码运行结束后，在保存目录下生成了相应文件。在终端运行如下命令：

$ tensorboard --logdir tensorboard/mnist

浏览器中访问 localhost:6006 便可进入 TensorBoard 控制台。

当前导航栏除了 GRAPHS 以外，其他均没有数据，点击进入 GRAPHS，可查看如下计算图：

然而，目前来看，这个图实在过于复杂，因为它显示了所有的计算细节。我们需要对代码进行相应的调整。

命名范围

我们在之前的章节已经使用了为某个网络模块命名的方法。TensorFlow 使用 name scope 来确定模块的作用范围。对代码进行相应的调整，添加部分名称和作用域：

# 简单卷积层，为方便本章教程叙述，固定部分参数
def conv_layer(input,
               channels_in,    # 输入通道数
               channels_out,   # 输出通道数
               name='conv'):   # 名称
    with tf.name_scope(name):    # 在该名称作用域下的子变量
        weights = tf.Variable(tf.truncated_normal([5, 5, channels_in, channels_out],
                                                  stddev=0.05), name='W')
        biases = tf.Variable(tf.constant(0.05, shape=[channels_out]), name='B')
        conv = tf.nn.conv2d(input, filter=weights, strides=[1, 1, 1, 1], padding='SAME')
        act = tf.nn.relu(conv + biases)
        return act

# 简化全连接层
def fc_layer(input, num_inputs, num_outputs, use_relu=True, name='fc'):
    with tf.name_scope(name):   # 在该名称作用域下的子变量
        weights = tf.Variable(tf.truncated_normal([num_inputs, num_outputs],
                                                  stddev=0.05), name='W')
        biases = tf.Variable(tf.constant(0.05, shape=[num_outputs]), name='B')
        act = tf.matmul(input, weights) + biases

        if use_relu:
            act = tf.nn.relu(act)
        return act     

# max pooling 层
def max_pool(input):
    return tf.nn.max_pool(input, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

给其他的部分同样添加名称和相关作用域：

x = tf.placeholder(tf.float32, shape=[None, 784], name='x')
y = tf.placeholder(tf.float32, shape=[None, 10], name='labels')
x_image = tf.reshape(x, [-1, 28, 28, 1])

conv1 = conv_layer(x_image, 1, 32, 'conv1')
pool1 = max_pool(conv1)

conv2 = conv_layer(pool1, 32, 64, 'conv2')
pool2 = max_pool(conv2)

flat_shape = pool2.get_shape()[1:4].num_elements()
flattened = tf.reshape(pool2, [-1, flat_shape])

fc1 = fc_layer(flattened, flat_shape, 1024, name='fc1')
logits = fc_layer(fc1, 1024, 10, use_relu=False, name='fc2')

# 计算交叉熵
with tf.name_scope("xent"):
    cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=logits))

# 使用Adam优化器来训练
with tf.name_scope('optimizer'):
    optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cross_entropy)

# 计算准确率
with tf.name_scope('accuracy'):
    correct_prediction = tf.equal(tf.argmax(y, axis=1), tf.argmax(logits, axis=1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

先不训练，创建一个新的目录保存新的计算图，然后将计算图写入这个目录

tensorboard_dir = 'tensorboard/mnist2'   # 保存目录
if not os.path.exists(tensorboard_dir):
    os.makedirs(tensorboard_dir)

writer = tf.summary.FileWriter(tensorboard_dir)
writer.add_graph(session.graph)

运行 tensorboard，将 logdir 指向新的目录，计算图如下：

现在的计算图变得更加直观容易理解，因为它将部分的细节藏在了一个个大的模块里面。点击某个模块可以查看它的内部细节：

可以看到，定义的名称 W 和 B 是属于 conv2 内部的子名称。

点击左边的 Trace inputs，可以查看数据到某一模块的流向，例如计算 accuracy，是 x 经过了一系列网络层并比对 label 计算出来的。

标量，直方图

除了画出模型的计算图外，TensorBoard 还支持收集一些准确率、损失等标量信息，检查输入的图像，以及描绘变量的直方图信息等等，这些信息对于评判模型的性能有着重要作用。

我们需要对代码做一定修改，来收集这些信息。

卷积层直方图

使用 tf.summary.histogram 收集直方图信息。

# 简单卷积层，为方便本章教程叙述，固定部分参数
def conv_layer(input,
               channels_in,    # 输入通道数
               channels_out,   # 输出通道数
               name='conv'):   # 名称
    with tf.name_scope(name):
        weights = tf.Variable(tf.truncated_normal([5, 5, channels_in, channels_out],
                                                  stddev=0.05), name='W')
        biases = tf.Variable(tf.constant(0.05, shape=[channels_out]), name='B')
        conv = tf.nn.conv2d(input, filter=weights, strides=[1, 1, 1, 1], padding='SAME')
        act = tf.nn.relu(conv + biases)

        # 收集以下三个信息，统计直方图
        tf.summary.histogram('weights', weights)   
        tf.summary.histogram('biases', biases)     
        tf.summary.histogram('activations', act)
        return act

交叉熵，准确率，图像输入

使用 tf.summary.scalar 收集标量信息，使用 tf.summary.image 收集图像。

tf.summary.scalar('cross_entropy', cross_entropy)
tf.summary.scalar('accuracy', accuracy)
tf.summary.image('input', x_image, 3)

保存这些信息

使用 tf.summary.merge_all()，喂入训练数据，可以收集以上定义的所有信息。

tensorboard_dir = 'tensorboard/mnist3'   # 保存到新的目录
if not os.path.exists(tensorboard_dir):
    os.makedirs(tensorboard_dir)

merged_summary = tf.summary.merge_all()   # 使用tf.summary.merge_all()，可以收集以上定义的所有信息
writer = tf.summary.FileWriter(tensorboard_dir)
writer.add_graph(session.graph)

通过训练进行数据收集

train_batch_size = 100

for i in range(2001):
    x_batch, y_batch = data.train.next_batch(train_batch_size)

    feed_dict = {x: x_batch, y: y_batch}

    if i % 5 == 0:   # 运行merger_summary，使用add_summary写入数据
        # 这里的feed_dict应该使用验证集，但是当前仅作为演示目的，在此不做修改
        s = session.run(merged_summary, feed_dict=feed_dict)
        writer.add_summary(s, i)

    if i % 500 == 0:
        train_accuracy = session.run(accuracy, feed_dict=feed_dict)
        print("迭代轮次: {0:>6}, 训练准确率: {1:>6.4%}".format(i, train_accuracy))

    session.run(optimizer, feed_dict=feed_dict)

运行 tensorboard，指向 tensorboard/mnist3。点击导航栏 SCALARS：

显示了准确率和交叉熵在迭代过程中的变化情况，准确率在稳步上升，交叉熵逐渐下降，可见该模型的效果还算理想。

点击导航栏 HISTOGRAMS：

可以查看变量在不同迭代轮次的直方图分布情况。第一层卷积的权重随着迭代变化较为明显，第二层表现出平滑的趋势。

点击导航栏 IMAGES，可以显示不同迭代轮次的 3 张图片：

参数搜索

以上的示例中，TensorBoard 都只显示了一个模型的可视化数据。对于不同的参数，如何将多个模型显示在一张图中进行对比？TensorBoard 对这一问题作了同样的支持。我们需要调整部分代码，并加入一些参数搜索的代码。

将 max_pooling 合并到卷积中，将 relu 从全连接抽离

# 简单卷积层，为方便本章教程叙述，固定部分参数
def conv_layer(input,
               channels_in,    # 输入通道数
               channels_out,   # 输出通道数
               name='conv'):   # 名称
    with tf.name_scope(name):
        weights = tf.Variable(tf.truncated_normal([5, 5, channels_in, channels_out],
                                                  stddev=0.05), name='W')
        biases = tf.Variable(tf.constant(0.05, shape=[channels_out]), name='B')
        conv = tf.nn.conv2d(input, filter=weights, strides=[1, 1, 1, 1], padding='SAME')
        act = tf.nn.relu(conv + biases)

        tf.summary.histogram('weights', weights)
        tf.summary.histogram('biases', biases)
        tf.summary.histogram('activations', act)

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

# 简化全连接层
def fc_layer(input, num_inputs, num_outputs, name='fc'):
    with tf.name_scope(name):
        weights = tf.Variable(tf.truncated_normal([num_inputs, num_outputs],
                                                  stddev=0.05), name='W')
        biases = tf.Variable(tf.constant(0.05, shape=[num_outputs]), name='B')
        act = tf.matmul(input, weights) + biases

        tf.summary.histogram('weights', weights)
        tf.summary.histogram('biases', biases)
        tf.summary.histogram('activations', act)

        return act

保存到新的目录

tensorboard_dir = 'tensorboard/mnist4/'   # 保存目录
if not os.path.exists(tensorboard_dir):
    os.makedirs(tensorboard_dir)

根据不同参数构建模型

def mnist_model(learning_rate, use_two_fc, use_two_conv, hparam):
    tf.reset_default_graph()    # 重置计算图
    sess = tf.Session()

    x = tf.placeholder(tf.float32, shape=[None, 784], name="x")
    x_image = tf.reshape(x, [-1, 28, 28, 1])
    tf.summary.image('input', x_image, 3)
    y = tf.placeholder(tf.float32, shape=[None, 10], name="labels")

    if use_two_conv:    # 是否使用两个卷积
        conv1 = conv_layer(x_image, 1, 32, "conv1")
        conv_out = conv_layer(conv1, 32, 64, "conv2")
    else:
        conv1 = conv_layer(x_image, 1, 64, "conv")    # 如果使用一个卷积，则再添加一个max_pooling保证维度相通
        conv_out = tf.nn.max_pool(conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")

    flattened = tf.reshape(conv_out, [-1, 7 * 7 * 64])

    if use_two_fc:    # 是否使用两个全连接
        fc1 = fc_layer(flattened, 7 * 7 * 64, 1024, "fc1")
        relu = tf.nn.relu(fc1)
        tf.summary.histogram("fc1/relu", relu)
        logits = fc_layer(fc1, 1024, 10, "fc2")
    else:
        logits = fc_layer(flattened, 7*7*64, 10, "fc")

    with tf.name_scope("xent"):
        xent = tf.reduce_mean(
            tf.nn.softmax_cross_entropy_with_logits(
                logits=logits, labels=y), name="xent")
        tf.summary.scalar("xent", xent)

    with tf.name_scope("train"):
        train_step = tf.train.AdamOptimizer(learning_rate).minimize(xent)

    with tf.name_scope("accuracy"):
        correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(y, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
        tf.summary.scalar("accuracy", accuracy)

    summ = tf.summary.merge_all()    # 收集所有的summary

    saver = tf.train.Saver()     # 保存训练过程

    sess.run(tf.global_variables_initializer())
    writer = tf.summary.FileWriter(tensorboard_dir + hparam)
    writer.add_graph(sess.graph)

    for i in range(2001):
        batch = data.train.next_batch(100)
        if i % 5 == 0:   # 每5轮写入一次
            # 同上，feed_dict应该使用验证集，但是当前仅作为演示目的，在此不做修改
            [train_accuracy, s] = sess.run([accuracy, summ], feed_dict={x: batch[0], y: batch[1]})
            writer.add_summary(s, i)

        if i % 100 == 0:    # 每100轮保存依存训练过程
            train_accuracy = sess.run(accuracy, feed_dict={x: batch[0], y: batch[1]})
            saver.save(sess, os.path.join(tensorboard_dir, "model.ckpt"), i)

            print("迭代轮次: {0:>6}, 训练准确率: {1:>6.4%}".format(i, train_accuracy))

        sess.run(train_step, feed_dict={x: batch[0], y: batch[1]})

以下函数用于生成超参数的字符串：

def make_hparam_string(learning_rate, use_two_fc, use_two_conv):
    conv_param = "conv=2" if use_two_conv else "conv=1"
    fc_param = "fc=2" if use_two_fc else "fc=1"
    return "lr_%.0E,%s,%s" % (learning_rate, conv_param, fc_param)

开始训练：

for learning_rate in [1E-3, 1E-4, 1e-5]:
    for use_two_fc in [False, True]:
        for use_two_conv in [False, True]:
            hparam = make_hparam_string(learning_rate, use_two_fc, use_two_conv)
            print('Starting run for %s' % hparam)

            mnist_model(learning_rate, use_two_fc, use_two_conv, hparam)

print('Done training!')

在训练过程中即可直接打开tensorboard实时查看训练情况：

$ tensorboard --logdir tensorboard/mnist4

以上就显示了不同参数情况下的准确率和交叉熵变化情况，左下角区域可以选择显示几条线。中间的 Horizontal Axis 同样给了三种不同的显示，STEP 按步长，RELATIVE 按相对时间，WALL 将它们分开显示。鼠标移动到图像上，会给出部分的详细信息：

其他几个部分也是如此，不再详述。

Embeddings

Embeddings 可能是 TensorBoard 最惊艳的部分。它显示了训练样本在三维空间的距离。如下图所示：

但是目前我们无法确定某个样本的标签，因此无法确认。需要对代码做一定的修改。

这里只显示 1024 张图片，需要两个额外的文件，一个存储标签，一个存储每个点的缩略图。这两个文件可以在 dandelionmane的GitHub 下载。

LABELS = os.path.join(os.getcwd(), "labels_1024.tsv")
SPRITES = os.path.join(os.getcwd(), "sprite_1024.png")

def mnist_model(learning_rate, use_two_fc, use_two_conv, hparam):
    tf.reset_default_graph()    # 重置计算图
    sess = tf.Session()

    x = tf.placeholder(tf.float32, shape=[None, 784], name="x")
    x_image = tf.reshape(x, [-1, 28, 28, 1])
    tf.summary.image('input', x_image, 3)
    y = tf.placeholder(tf.float32, shape=[None, 10], name="labels")

    if use_two_conv:    # 是否使用两个卷积
        conv1 = conv_layer(x_image, 1, 32, "conv1")
        conv_out = conv_layer(conv1, 32, 64, "conv2")
    else:
        conv1 = conv_layer(x_image, 1, 64, "conv")    # 如果使用一个卷积，则再添加一个max_pooling保证维度相通
        conv_out = tf.nn.max_pool(conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")

    flattened = tf.reshape(conv_out, [-1, 7 * 7 * 64])

    if use_two_fc:    # 是否使用两个全连接
        fc1 = fc_layer(flattened, 7 * 7 * 64, 1024, "fc1")
        relu = tf.nn.relu(fc1)
        embedding_input = relu
        tf.summary.histogram("fc1/relu", relu)
        embedding_size = 1024
        logits = fc_layer(fc1, 1024, 10, "fc2")
    else:
        embedding_input = flattened   # 新添加的embedding_input和embedding_size
        embedding_size = 7*7*64
        logits = fc_layer(flattened, 7*7*64, 10, "fc")

    with tf.name_scope("xent"):
        xent = tf.reduce_mean(
            tf.nn.softmax_cross_entropy_with_logits(
                logits=logits, labels=y), name="xent")
        tf.summary.scalar("xent", xent)

    with tf.name_scope("train"):
        train_step = tf.train.AdamOptimizer(learning_rate).minimize(xent)

    with tf.name_scope("accuracy"):
        correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(y, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
        tf.summary.scalar("accuracy", accuracy)

    summ = tf.summary.merge_all()    # 收集所有的summary

    # 添加embedding变量
    embedding = tf.Variable(tf.zeros([1024, embedding_size]), name="test_embedding")
    assignment = embedding.assign(embedding_input)
    saver = tf.train.Saver()     # 保存训练过程

    sess.run(tf.global_variables_initializer())
    writer = tf.summary.FileWriter(tensorboard_dir + hparam)
    writer.add_graph(sess.graph)

    # embedding的配置，详见官方文档
    config = tf.contrib.tensorboard.plugins.projector.ProjectorConfig()
    embedding_config = config.embeddings.add()
    embedding_config.tensor_name = embedding.name
    embedding_config.sprite.image_path = SPRITES
    embedding_config.metadata_path = LABELS
    # Specify the width and height of a single thumbnail.
    embedding_config.sprite.single_image_dim.extend([28, 28])
    tf.contrib.tensorboard.plugins.projector.visualize_embeddings(writer, config)

    for i in range(2001):
        batch = data.train.next_batch(100)
        if i % 5 == 0:   # 每5轮写入一次
            # 同样，最好使用验证集
            [train_accuracy, s] = sess.run([accuracy, summ], feed_dict={x: batch[0], y: batch[1]})
            writer.add_summary(s, i)

        if i % 100 == 0:    # 每100轮保存依存训练过程
            sess.run(assignment, feed_dict={x: data.test.images[:1024], y: data.test.labels[:1024]})
            train_accuracy = sess.run(accuracy, feed_dict={x: batch[0], y: batch[1]})
            saver.save(sess, os.path.join(tensorboard_dir, "model.ckpt"), i)

            print("迭代轮次: {0:>6}, 训练准确率: {1:>6.4%}".format(i, train_accuracy))

        sess.run(train_step, feed_dict={x: batch[0], y: batch[1]})

初始运行时，样本基本分散在空间中，没有什么特殊的规律：

在经过多轮的迭代后，相同类别的样本聚集在了一起，不同类别的样本分散开来，呈现聚类趋势，虽然存在部分的误分样本。

可见，Embedding 能够反映聚类的属性，这对我们观察分类性能有很直观的帮助。Embedding 常用在文本中，例如判断词向量的相似程度。

这是几篇与原作不完全相同的教程。

转载请说明出处：TensorFlow (4) - 保存/恢复/提前终止

原作者：Magnus Erik Hvass Pedersen / GitHub / Videos on YouTube

在 第三章 中，我们使用 TensorFlow 的 API 重新构建了网络，并且训练了 10000 轮次得到了 98.7% 的测试准确率。然而，在实际训练过程中，模型的结构往往比这更加复杂，数据量也更多，训练 10000 轮次需要较长的时间。长时间的训练存在多个问题：

• 如果不保存训练过程中的状态，在程序运行完后，整个训练过程被销毁，无法运用到新的数据集上，这样的模型没有意义。
• 如果在训练过程中一旦出现突发情况停止，之前的训练将前功尽弃，必须从头开始训练。
• 如果经过多次的训练，模型的性能不再提升，那么这些训练是没有意义的，如果不提前终止，将浪费大量时间。

事实上，TensorFlow 提供了保存和恢复训练的方法，可以避免这类事情的发生。在本章中，我们将继续使用 第三章 的大部分代码，只做小部分的修改，以实现我们的目的。

载入数据，构建模型

这一部分与第三章相似，但是我们在本章中使用验证集来验证模型性能，因此需要稍作改动。此外，需要用到上一章给出的 cnn_helper.py。

from cnn_helper import *

# notebook使用
%load_ext autoreload  
%autoreload 2
%matplotlib inline

数据

from tensorflow.examples.tutorials.mnist import input_data
data = input_data.read_data_sets('data/MNIST/', one_hot=True)

print()
print("数据集大小：")
print('- 训练集：{}'.format(len(data.train.labels)))
print('- 测试集：{}'.format(len(data.test.labels)))
print('- 验证集：{}'.format(len(data.validation.labels)))

数据集大小：
- 训练集：55000
- 测试集：10000
- 验证集：5000

data.test.cls = np.argmax(data.test.labels, axis=1)
data.validation.cls = np.argmax(data.validation.labels, axis=1)

神经网络参数

img_size = 28                        # 图片的高度和宽度
img_size_flat = img_size * img_size  # 展平为向量的尺寸
img_shape = (img_size, img_size)     # 图片的二维尺寸

num_channels = 1                     # 输入为单通道灰度图像
num_classes = 10                     # 类别数目

# 卷积层 1
filter_size1 = 5          # 5 x 5 卷积核
num_filters1 = 16         # 共 16 个卷积核

# 卷积层 2
filter_size2 = 5          # 5 x 5 卷积核
num_filters2 = 36         # 共 36 个卷积核

# 全连接层
fc_size = 128             # 全连接层神经元数

占位符

x = tf.placeholder(tf.float32, shape=[None, img_size_flat], name='x')          # 原始输入
x_image = tf.reshape(x, [-1, img_size, img_size, num_channels])                # 转换为2维图像
y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true')  # 原始输出
y_true_cls = tf.argmax(y_true, axis=1)                                         # 转换为真实类别

卷积神经网络

layer_conv1 = tf.layers.conv2d(inputs=x_image,            # 输入
                               filters=num_filters1,      # 卷积核个数
                               kernel_size=filter_size1,  # 卷积核尺寸
                               padding='same',            # padding方法
                               activation=tf.nn.relu,     # 激活函数relu
                               name='layer_conv1')        # 命名用于获取变量

net = tf.layers.max_pooling2d(inputs=layer_conv1, pool_size=2, strides=(2, 2),  padding='same')
layer_conv2 = tf.layers.conv2d(inputs=net,          
                               filters=num_filters2,
                               kernel_size=filter_size2,
                               padding='same',
                               activation=tf.nn.relu,
                               name='layer_conv2')

net = tf.layers.max_pooling2d(inputs=layer_conv2, pool_size=2, strides=(2, 2),  padding='same')
layer_flat = tf.contrib.layers.flatten(net)    # flatten暂时在tf.contrib一层

layer_fc1 = tf.layers.dense(inputs=layer_flat, units=fc_size, activation=tf.nn.relu, name='layer_fc1')
layer_fc2 = tf.layers.dense(inputs=layer_fc1, units=num_classes, name='layer_fc2')

代价、优化器、准确率

y_pred = tf.nn.softmax(layer_fc2)              # softmax归一化
y_pred_cls = tf.argmax(y_pred, axis=1)         # 真实类别

cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=layer_fc2, labels=y_true)
cost = tf.reduce_mean(cross_entropy)

optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cost)

correct_prediction = tf.equal(y_pred_cls, y_true_cls)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

获取权重

def get_weights_variable(layer_name):
    # 根据给定的layer_name，返回名为'kernel'的变量
    with tf.variable_scope(layer_name, reuse=True):
        variable = tf.get_variable('kernel')
    return variable

weights_conv1 = get_weights_variable(layer_name='layer_conv1')
weights_conv2 = get_weights_variable(layer_name='layer_conv2')

Saver

为了保存神经网络中的变量，我们需要创建一个 Saver 对象用来存储和检索 TensorFlow 计算图中的所有变量。我们可以保存训练过程中的所有结果，在这里仅保存最优的结果。

saver = tf.train.Saver()    # 用于保存变量

save_dir = 'checkpoints/'   # 保存目录
if not os.path.exists(save_dir):
    os.makedirs(save_dir)

save_path = os.path.join(save_dir, 'best_validation')   # 最佳验证结果保存路径

运行TensorFlow

创建session并初始化

session = tf.Session()
session.run(tf.global_variables_initializer())

优化器的迭代过程

为了测试优化器的性能，需要多添加几个指标，对代码进行相应调整。

train_batch_size = 64

best_validation_accuracy = 0.0    # 当前最佳验证集准确率
last_improvement = 0     # 上一次有所改进的轮次
require_improvement = 1000    # 如果在1000轮内没有改进，停止迭代

# 计算目前执行的总迭代次数
total_iterations = 0

def optimize(num_iterations):
    # 保证更新全局变量.
    global total_iterations
    global best_validation_accuracy
    global last_improvement

    # 用来输出用时.
    start_time = time.time()

    for i in range(num_iterations):
        total_iterations += 1

        # 获取一批数据，运行优化器
        x_batch, y_true_batch = data.train.next_batch(train_batch_size)
        feed_dict_train = {x: x_batch, y_true: y_true_batch}
        session.run(optimizer, feed_dict=feed_dict_train)

        # 每100轮迭代输出状态
        if (total_iterations % 100 == 0) or (i == num_iterations - 1):
            # 计算训练集准确率.
            acc_train = session.run(accuracy, feed_dict=feed_dict_train)
            # 验证集准确率，为了尽可能重用代码，这个函数会在后面实现
            acc_validation, _ = validation_accuracy()

            if acc_validation > best_validation_accuracy:   # 如果当前验证集准确率大于之前的最好准确率
                best_validation_accuracy = acc_validation   # 更新最好准确率
                last_improvement = total_iterations         # 更新上一次提升的迭代轮次

                saver.save(sess=session, save_path=save_path)   # 将这一次更新保存下来
                improved_str = '*'    # 标注为找到提升
            else:
                improved_str = ''    

            msg = "迭代轮次: {0:>6}, 训练集准确率: {1:>6.1%}, 验证集准确率: {2:>6.1%} {3}"
            print(msg.format(i + 1, acc_train, acc_validation, improved_str))

        # 如果在require_improvement轮次内未有提升
        if total_iterations - last_improvement > require_improvement:
            print("长时间未提升, 停止优化。")
            break  # 跳出循环

    end_time = time.time()
    time_dif = end_time - start_time

    # 输出用时.
    print("用时: " + str(timedelta(seconds=int(round(time_dif)))))

计算分类性能

为了重用代码以评估验证集和测试集的性能，需要重构这部分代码：

batch_size = 256

def predict_cls(images, labels, cls_true):
    num_images = len(images)

    # 为预测结果申请一个数组
    cls_pred = np.zeros(shape=num_images, dtype=np.int)

    i = 0  # 数据集的起始id为0

    while i < num_images:
        # j为下一批次的截止id
        j = min(i + batch_size, num_images)

        # 创建feed_dict
        feed_dict = {x: images[i:j, :], y_true: labels[i:j, :]}

        # 计算预测结果
        cls_pred[i:j] = session.run(y_pred_cls, feed_dict=feed_dict)

        # 设定为下一批次起始值.
        i = j

    # 正确的分类
    correct = (cls_true == cls_pred)

    return correct, cls_pred

def predict_cls_test():    # 测试集分类结果
    return predict_cls(images = data.test.images,
                       labels = data.test.labels,
                       cls_true = data.test.cls)

def predict_cls_validation():   # 验证集分类结果
    return predict_cls(images = data.validation.images,
                       labels = data.validation.labels,
                       cls_true = data.validation.cls)

def cls_accuracy(correct):    # 准确率
    # 计算总的正确个数
    correct_sum = correct.sum()
    #计算准确率
    acc = float(correct_sum) / len(correct)
    return acc, correct_sum

def validation_accuracy():    # optimize()用到的验证集准确率函数
    correct, _ = predict_cls_validation()
    return cls_accuracy(correct)

测试集性能评估

def print_test_accuracy(show_example_errors=False,
                        show_confusion_matrix=False):

    # 返回测试集的正确情况与预测结果
    correct, cls_pred = predict_cls_test()

    # 计算准确率，准确数
    acc, num_correct = cls_accuracy(correct)

    num_images = len(correct)

    # 打印准确率.
    msg = "测试集准确率: {0:.1%} ({1} / {2})"
    print(msg.format(acc, num_correct, num_images))

    # 打印部分错误样例.
    if show_example_errors:
        print("Example errors:")
        plot_example_errors(data_test=data.test, cls_pred=cls_pred, correct=correct, img_shape=img_shape)

    # 打印混淆矩阵.
    if show_confusion_matrix:
        print("Confusion Matrix:")
        plot_confusion_matrix(cls_true=data.test.cls, cls_pred=cls_pred)

优化前性能：

print_test_accuracy()

测试集准确率: 13.5% (1348 / 10000)

执行 10000 轮迭代：

optimize(num_iterations=10000)

迭代轮次:    100, 训练集准确率:  81.2%, 验证集准确率:  78.9% *
迭代轮次:    200, 训练集准确率:  85.9%, 验证集准确率:  86.9% *
迭代轮次:    300, 训练集准确率:  93.8%, 验证集准确率:  90.9% *
迭代轮次:    400, 训练集准确率:  92.2%, 验证集准确率:  92.1% *
迭代轮次:    500, 训练集准确率:  93.8%, 验证集准确率:  93.0% *
迭代轮次:    600, 训练集准确率:  95.3%, 验证集准确率:  93.7% *
迭代轮次:    700, 训练集准确率:  90.6%, 验证集准确率:  94.3% *
迭代轮次:    800, 训练集准确率:  98.4%, 验证集准确率:  94.7% *
迭代轮次:    900, 训练集准确率:  96.9%, 验证集准确率:  95.4% *
迭代轮次:   1000, 训练集准确率:  96.9%, 验证集准确率:  95.5% *
迭代轮次:   1100, 训练集准确率:  93.8%, 验证集准确率:  95.7% *
迭代轮次:   1200, 训练集准确率:  98.4%, 验证集准确率:  96.0% *
迭代轮次:   1300, 训练集准确率:  96.9%, 验证集准确率:  95.8%
迭代轮次:   1400, 训练集准确率:  96.9%, 验证集准确率:  96.1% *
迭代轮次:   1500, 训练集准确率:  98.4%, 验证集准确率:  96.3% *
迭代轮次:   1600, 训练集准确率:  98.4%, 验证集准确率:  96.7% *
迭代轮次:   1700, 训练集准确率:  92.2%, 验证集准确率:  96.8% *
迭代轮次:   1800, 训练集准确率:  96.9%, 验证集准确率:  96.9% *
迭代轮次:   1900, 训练集准确率: 100.0%, 验证集准确率:  96.8%
迭代轮次:   2000, 训练集准确率:  98.4%, 验证集准确率:  97.0% *
迭代轮次:   2100, 训练集准确率: 100.0%, 验证集准确率:  97.0% *
迭代轮次:   2200, 训练集准确率:  98.4%, 验证集准确率:  97.4% *
迭代轮次:   2300, 训练集准确率:  96.9%, 验证集准确率:  97.3%
迭代轮次:   2400, 训练集准确率:  96.9%, 验证集准确率:  97.3%
迭代轮次:   2500, 训练集准确率:  96.9%, 验证集准确率:  97.5% *
迭代轮次:   2600, 训练集准确率:  98.4%, 验证集准确率:  97.3%
迭代轮次:   2700, 训练集准确率:  95.3%, 验证集准确率:  97.4%
迭代轮次:   2800, 训练集准确率: 100.0%, 验证集准确率:  97.7% *
迭代轮次:   2900, 训练集准确率:  98.4%, 验证集准确率:  97.7%
迭代轮次:   3000, 训练集准确率:  93.8%, 验证集准确率:  97.8% *
迭代轮次:   3100, 训练集准确率:  98.4%, 验证集准确率:  97.9% *
迭代轮次:   3200, 训练集准确率:  98.4%, 验证集准确率:  97.9%
迭代轮次:   3300, 训练集准确率:  96.9%, 验证集准确率:  97.9%
迭代轮次:   3400, 训练集准确率:  98.4%, 验证集准确率:  97.9%
迭代轮次:   3500, 训练集准确率:  96.9%, 验证集准确率:  97.8%
迭代轮次:   3600, 训练集准确率: 100.0%, 验证集准确率:  98.0% *
迭代轮次:   3700, 训练集准确率:  98.4%, 验证集准确率:  97.8%
迭代轮次:   3800, 训练集准确率: 100.0%, 验证集准确率:  97.9%
迭代轮次:   3900, 训练集准确率:  98.4%, 验证集准确率:  97.9%
迭代轮次:   4000, 训练集准确率: 100.0%, 验证集准确率:  97.7%
迭代轮次:   4100, 训练集准确率:  98.4%, 验证集准确率:  98.1% *
迭代轮次:   4200, 训练集准确率:  98.4%, 验证集准确率:  98.0%
迭代轮次:   4300, 训练集准确率: 100.0%, 验证集准确率:  97.9%
迭代轮次:   4400, 训练集准确率:  98.4%, 验证集准确率:  98.1% *
迭代轮次:   4500, 训练集准确率: 100.0%, 验证集准确率:  98.1%
迭代轮次:   4600, 训练集准确率: 100.0%, 验证集准确率:  97.9%
迭代轮次:   4700, 训练集准确率:  98.4%, 验证集准确率:  98.2% *
迭代轮次:   4800, 训练集准确率:  96.9%, 验证集准确率:  98.2% *
迭代轮次:   4900, 训练集准确率: 100.0%, 验证集准确率:  98.2%
迭代轮次:   5000, 训练集准确率: 100.0%, 验证集准确率:  98.3% *
迭代轮次:   5100, 训练集准确率: 100.0%, 验证集准确率:  98.3%
迭代轮次:   5200, 训练集准确率:  98.4%, 验证集准确率:  98.3%
迭代轮次:   5300, 训练集准确率: 100.0%, 验证集准确率:  98.4% *
迭代轮次:   5400, 训练集准确率:  98.4%, 验证集准确率:  98.3%
迭代轮次:   5500, 训练集准确率:  96.9%, 验证集准确率:  98.4% *
迭代轮次:   5600, 训练集准确率:  98.4%, 验证集准确率:  98.3%
迭代轮次:   5700, 训练集准确率:  98.4%, 验证集准确率:  98.4% *
迭代轮次:   5800, 训练集准确率:  98.4%, 验证集准确率:  98.4% *
迭代轮次:   5900, 训练集准确率:  96.9%, 验证集准确率:  98.4%
迭代轮次:   6000, 训练集准确率:  95.3%, 验证集准确率:  98.4%
迭代轮次:   6100, 训练集准确率: 100.0%, 验证集准确率:  98.3%
迭代轮次:   6200, 训练集准确率: 100.0%, 验证集准确率:  98.5% *
迭代轮次:   6300, 训练集准确率: 100.0%, 验证集准确率:  98.4%
迭代轮次:   6400, 训练集准确率: 100.0%, 验证集准确率:  98.6% *
迭代轮次:   6500, 训练集准确率: 100.0%, 验证集准确率:  98.4%
迭代轮次:   6600, 训练集准确率: 100.0%, 验证集准确率:  98.7% *
迭代轮次:   6700, 训练集准确率: 100.0%, 验证集准确率:  98.7% *
迭代轮次:   6800, 训练集准确率: 100.0%, 验证集准确率:  98.4%
迭代轮次:   6900, 训练集准确率: 100.0%, 验证集准确率:  98.6%
迭代轮次:   7000, 训练集准确率:  96.9%, 验证集准确率:  98.7%
迭代轮次:   7100, 训练集准确率:  98.4%, 验证集准确率:  98.4%
迭代轮次:   7200, 训练集准确率: 100.0%, 验证集准确率:  98.5%
迭代轮次:   7300, 训练集准确率:  98.4%, 验证集准确率:  98.6%
迭代轮次:   7400, 训练集准确率:  98.4%, 验证集准确率:  98.6%
迭代轮次:   7500, 训练集准确率:  98.4%, 验证集准确率:  98.4%
迭代轮次:   7600, 训练集准确率: 100.0%, 验证集准确率:  98.6%
迭代轮次:   7700, 训练集准确率: 100.0%, 验证集准确率:  98.7%
长时间未提升, 停止优化。
用时: 0:13:31

我们发现，在经过 6700 轮次后，由于性能不再提升，优化器提前停止了迭代，减少了部分的训练时间，而验证集的准确率达到了 98.7%。

print_test_accuracy(show_example_errors=True, show_confusion_matrix=True)

测试集准确率: 98.7% (9865 / 10000)
Example errors:

Confusion Matrix:
[[ 973    0    1    0    0    1    2    1    2    0]
 [   0 1127    2    0    0    0    2    1    3    0]
 [   0    1 1021    1    1    0    0    3    4    1]
 [   0    0    1  998    0    7    0    1    3    0]
 [   0    0    1    0  979    0    1    1    0    0]
 [   2    0    0    3    0  885    2    0    0    0]
 [   5    3    0    0    3    5  940    0    2    0]
 [   1    1    6    2    0    0    0 1017    1    0]
 [   3    0    4    2    1    2    0    3  957    2]
 [   2    4    1    4   13    6    0    7    4  968]]

打印权重

weights1 = session.run(weights_conv1)
plot_conv_weights(weights=weights1)

重新初始化

再次重新初始化所有的变量

session.run(tf.global_variables_initializer())    # 重新初始化

print_test_accuracy()     # 准确率降回随机

测试集准确率: 19.4% (1937 / 10000)

可见，输出降回了随机的情况。

weights1 = session.run(weights_conv1)   
plot_conv_weights(weights=weights1)     # 权重也与上面的权重不同

权重也与训练好的模型大不相同。

恢复路径下的变量

现在需要从变量所保存的路径下恢复所有的变量。

saver.restore(sess=session, save_path=save_path)   # 现在从保存的目录中重新载入所有的变量

再次计算准确率

# 再次打印测试准确率
print_test_accuracy(show_example_errors=True, show_confusion_matrix=True)

测试集准确率: 98.6% (9864 / 10000)
Example errors:

Confusion Matrix:
[[ 974    0    1    0    0    1    2    0    1    1]
 [   0 1126    3    0    0    0    2    1    3    0]
 [   0    0 1022    1    1    0    0    3    4    1]
 [   0    0    1 1002    0    3    0    1    2    1]
 [   0    0    1    0  980    0    1    0    0    0]
 [   2    0    0    4    0  882    2    0    0    2]
 [   3    2    0    0    3    6  942    0    2    0]
 [   1    3    7    3    0    0    0 1005    1    8]
 [   4    0    6    6    1    3    1    2  946    5]
 [   2    3    2    3    7    4    0    2    1  985]]

可以发现，测试集的准确率达到了 98.6%，与前面训练好的模型相差无几。

weights1 = session.run(weights_conv1)
plot_conv_weights(weights=weights1)

这一次权重和训练过后的就基本相同了，存在轻微不同的原因是原始的模型多训练了 1000 次。

在重新载入变量后，我们还可以继续优化这些变量。

关闭 session

session.close()

这是几篇与原作不完全相同的教程。

转载请说明出处：TensorFlow (3) - Layers API

原作者：Magnus Erik Hvass Pedersen / GitHub / Videos on YouTube

在 第二章 中，我们实现了使用卷积神经网络对 MNIST 数据集进行分类。可以发现，需要实现一个简单的 CNN 模型，也需要实现很多细节类的代码，如定义权重、偏置、展平操作等。TensorFlow 对这些模型做了一定的 API 封装，使得使用者可以更加方便地实现神经网络的构建。

在 TensorFlow 中存在的 API 有多个，最大的是 tf.contrib ，其中封装了大量的网络层layers，以及新集成的 keras 网络层。部分的 layers 也重定向到了外层，可直接使用 tf.layers，而不需要 tf.contrib.layers。访问 这个链接 可以了解 tf.layers 所支持的网络层。

本章节尝试使用 tf.layers 来重新实现 第二章 的卷积神经网络。其中大量的帮助函数可以重用。重用这些函数需要做一定的修改。现在把这些函数放在一个单独的脚本中。

文件：cnn_helper.py

import tensorflow as tf          # TensorFlow
import matplotlib.pyplot as plt  # matplotlib绘图
import numpy as np               # Numpy
from sklearn.metrics import confusion_matrix    # 混淆矩阵，分析模型误差

import time       # 计时
from datetime import timedelta
import math


def plot_images(images, cls_true, img_shape, cls_pred=None):
    """
    绘制图像，输出真实标签与预测标签
    images:   图像（9张）
    cls_true: 真实类别
    cls_pred: 预测类别
    """
    assert len(images) == len(cls_true) == 9   # 保证存在9张图片


    fig, axes = plt.subplots(3, 3)   # 创建3x3个子图的画布
    fig.subplots_adjust(hspace=0.3, wspace=0.3)  # 调整每张图之间的间隔

    for i, ax in enumerate(axes.flat):
        # 绘图，将一维向量变为二维矩阵，黑白二值图像使用 binary
        ax.imshow(images[i].reshape(img_shape), cmap='binary')

        if cls_pred is None:  # 如果未传入预测类别
            xlabel = "True: {0}".format(cls_true[i])
        else:
            xlabel = "True: {0}, Pred: {1}".format(cls_true[i], cls_pred[i])
        ax.set_xlabel(xlabel)

        # 删除坐标信息
        ax.set_xticks([])
        ax.set_yticks([])    
    plt.show()


def plot_example_errors(data_test, cls_pred, correct, img_shape):
    # 计算错误情况
    incorrect = (correct == False)
    images = data_test.images[incorrect]
    cls_pred = cls_pred[incorrect]
    cls_true = data_test.cls[incorrect]

    # 随机挑选9个
    indices = np.arange(len(images))
    np.random.shuffle(indices)
    indices = indices[:9]

    plot_images(images[indices], cls_true[indices], img_shape, cls_pred[indices])


def plot_confusion_matrix(cls_true, cls_pred):  

    # 使用scikit-learn的confusion_matrix来计算混淆矩阵
    cm = confusion_matrix(y_true=cls_true, y_pred=cls_pred)

    # 打印混淆矩阵
    print(cm)

    num_classes = cm.shape[0]

    # 将混淆矩阵输出为图像
    plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)

    # 调整图像
    plt.tight_layout()
    plt.colorbar()
    tick_marks = np.arange(num_classes)
    plt.xticks(tick_marks, range(num_classes))
    plt.yticks(tick_marks, range(num_classes))
    plt.xlabel('Predicted')
    plt.ylabel('True')
    plt.show()


def plot_conv_weights(weights, input_channel=0):
    # weights_conv1 or weights_conv2.


    # 获取权重最小值最大值，这将用户纠正整个图像的颜色密集度，来进行对比
    w_min = np.min(weights)
    w_max = np.max(weights)

    # 卷积核树木
    num_filters = weights.shape[3]

    # 每行需要输出的卷积核网格数
    num_grids = math.ceil(math.sqrt(num_filters))

    fig, axes = plt.subplots(num_grids, num_grids)
    for i, ax in enumerate(axes.flat):
        # 只输出有用的子图.
        if i<num_filters:
            # 获得第i个卷积核在特定输入通道上的权重
            img = weights[:, :, input_channel, i]

            ax.imshow(img, vmin=w_min, vmax=w_max,
                      interpolation='nearest', cmap='seismic')

        # 移除坐标.
        ax.set_xticks([])
        ax.set_yticks([])
    plt.show()


def plot_conv_layer(values):
    # layer_conv1 or layer_conv2

    # 卷积核数目
    num_filters = values.shape[3]

    # 每行需要输出的卷积核网格数
    num_grids = math.ceil(math.sqrt(num_filters))

    fig, axes = plt.subplots(num_grids, num_grids)
    for i, ax in enumerate(axes.flat):
        # 只输出有用的子图.
        if i<num_filters:
            # 获取第i个卷积核的输出
            img = values[0, :, :, i]

            ax.imshow(img, interpolation='nearest', cmap='binary')

        # 移除坐标.
        ax.set_xticks([])
        ax.set_yticks([])
    plt.show()


def plot_image(image, img_shape):
    plt.imshow(image.reshape(img_shape),
               interpolation='nearest',
               cmap='binary')
    plt.show()

引入

from cnn_helper import *

# notebook使用
%load_ext autoreload  
%autoreload 2
%matplotlib inline

载入数据

这一块与前几章一样，不做介绍：

from tensorflow.examples.tutorials.mnist import input_data
data = input_data.read_data_sets('data/MNIST/', one_hot=True)

print("数据集大小：")
print('- 训练集：{}'.format(len(data.train.labels)))
print('- 测试集：{}'.format(len(data.test.labels)))
print('- 验证集：{}'.format(len(data.validation.labels)))

数据集大小：
- 训练集：55000
- 测试集：10000
- 验证集：5000

data.test.cls = np.argmax(data.test.labels, axis=1)
print("样本维度：", data.train.images.shape)
print("标签维度：", data.train.labels.shape)

样本维度： (55000, 784)
标签维度： (55000, 10)

img_size = 28                        # 图片的高度和宽度
img_size_flat = img_size * img_size  # 展平为向量的尺寸
img_shape = (img_size, img_size)     # 图片的二维尺寸

num_channels = 1                     # 输入为单通道灰度图像
num_classes = 10                     # 类别数目

# 随机取9张图片
indices = np.arange(len(data.test.cls))
np.random.shuffle(indices)
indices = indices[:9]    

images = data.test.images[indices]
cls_true = data.test.cls[indices]

plot_images(images, cls_true, img_shape)

输入输出占位符

# 卷积层 1
filter_size1 = 5          # 5 x 5 卷积核
num_filters1 = 16         # 共 16 个卷积核

# 卷积层 2
filter_size2 = 5          # 5 x 5 卷积核
num_filters2 = 36         # 共 36 个卷积核

# 全连接层
fc_size = 128             # 全连接层神经元数

x = tf.placeholder(tf.float32, shape=[None, img_size_flat], name='x')          # 原始输入
x_image = tf.reshape(x, [-1, img_size, img_size, num_channels])                # 转换为2维图像
y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true')  # 原始输出
y_true_cls = tf.argmax(y_true, axis=1)                                         # 转换为真实类别

使用layers API构建网络

layer_conv1 = tf.layers.conv2d(inputs=x_image,            # 输入
                               filters=num_filters1,      # 卷积核个数
                               kernel_size=filter_size1,  # 卷积核尺寸
                               padding='same',            # padding方法
                               activation=tf.nn.relu,     # 激活函数relu
                               name='layer_conv1')        # 命名用于获取变量
print(layer_conv1)

Tensor("layer_conv1/Relu:0", shape=(?, 28, 28, 16), dtype=float32)

输出为 (?, 28, 28, 16) 的 Tensor，可以发现，使用 API 省去了大量的操作，如定义 weight, biase, strides, relu 等参数，只需要传入适当的参数，就可以完成与之前同样的操作。

net = tf.layers.max_pooling2d(inputs=layer_conv1, pool_size=2, strides=(2, 2),  padding='same')
layer_conv2 = tf.layers.conv2d(inputs=net,          
                               filters=num_filters2,
                               kernel_size=filter_size2,
                               padding='same',
                               activation=tf.nn.relu,
                               name='layer_conv2')
print(layer_conv2)

Tensor("layer_conv2/Relu:0", shape=(?, 14, 14, 36), dtype=float32)

我们为两个卷积层都加了一个 name 参数，这个参数用来指明该网络层在 TensorFlow 计算图中的名字，在后面可以根据这个名字来访问这一层的信息。

net = tf.layers.max_pooling2d(inputs=layer_conv2, pool_size=2, strides=(2, 2),  padding='same')
layer_flat = tf.contrib.layers.flatten(net)    # flatten暂时在tf.contrib一层
print(layer_flat)

Tensor("Flatten/Reshape:0", shape=(?, 1764), dtype=float32)

展平层自动的将输入展平成 2 维的 tensor，而不需要人为的使用 tf.reshape 来操作。目前该层仍然在 tf.contrib.layers 下，未来可能会直接到 tf.layers 下。

layer_fc1 = tf.layers.dense(inputs=layer_flat, units=fc_size, activation=tf.nn.relu, name='layer_fc1')
print(layer_fc1)

Tensor("layer_fc1/Relu:0", shape=(?, 128), dtype=float32)

TensorFlow 与 Keras 一样，使用了 dense 来表示全连接层，用户无需在使用 tf.matmul 来定义这一层。

layer_fc2 = tf.layers.dense(inputs=layer_fc1, units=num_classes, name='layer_fc2')
print(layer_fc2)

Tensor("layer_fc2/BiasAdd:0", shape=(?, 10), dtype=float32)

最后使用一个 dense 层将其映射为 (?, 10) 的 tensor，用于后续的分类。

预测

这一部分的代码与第二章完全相同：

y_pred = tf.nn.softmax(layer_fc2)              # softmax归一化
y_pred_cls = tf.argmax(y_pred, axis=1)         # 真实类别

cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=layer_fc2,
                                                        labels=y_true)
cost = tf.reduce_mean(cross_entropy)

optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cost)

correct_prediction = tf.equal(y_pred_cls, y_true_cls)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

权重输出

为了输出网络的权重，还需要一些其他的操作。TensorFlow 内部维护了一系列的变量名。

尝试打印所有的变量名：

for var in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES):
    print(var)

<tf.Variable 'layer_conv1/kernel:0' shape=(5, 5, 1, 16) dtype=float32_ref>
<tf.Variable 'layer_conv1/bias:0' shape=(16,) dtype=float32_ref>
<tf.Variable 'layer_conv2/kernel:0' shape=(5, 5, 16, 36) dtype=float32_ref>
<tf.Variable 'layer_conv2/bias:0' shape=(36,) dtype=float32_ref>
<tf.Variable 'layer_fc1/kernel:0' shape=(1764, 128) dtype=float32_ref>
<tf.Variable 'layer_fc1/bias:0' shape=(128,) dtype=float32_ref>
<tf.Variable 'layer_fc2/kernel:0' shape=(128, 10) dtype=float32_ref>
<tf.Variable 'layer_fc2/bias:0' shape=(10,) dtype=float32_ref>
<tf.Variable 'beta1_power:0' shape=() dtype=float32_ref>
<tf.Variable 'beta2_power:0' shape=() dtype=float32_ref>
<tf.Variable 'layer_conv1/kernel/Adam:0' shape=(5, 5, 1, 16) dtype=float32_ref>
<tf.Variable 'layer_conv1/kernel/Adam_1:0' shape=(5, 5, 1, 16) dtype=float32_ref>
<tf.Variable 'layer_conv1/bias/Adam:0' shape=(16,) dtype=float32_ref>
<tf.Variable 'layer_conv1/bias/Adam_1:0' shape=(16,) dtype=float32_ref>
<tf.Variable 'layer_conv2/kernel/Adam:0' shape=(5, 5, 16, 36) dtype=float32_ref>
<tf.Variable 'layer_conv2/kernel/Adam_1:0' shape=(5, 5, 16, 36) dtype=float32_ref>
<tf.Variable 'layer_conv2/bias/Adam:0' shape=(36,) dtype=float32_ref>
<tf.Variable 'layer_conv2/bias/Adam_1:0' shape=(36,) dtype=float32_ref>
<tf.Variable 'layer_fc1/kernel/Adam:0' shape=(1764, 128) dtype=float32_ref>
<tf.Variable 'layer_fc1/kernel/Adam_1:0' shape=(1764, 128) dtype=float32_ref>
<tf.Variable 'layer_fc1/bias/Adam:0' shape=(128,) dtype=float32_ref>
<tf.Variable 'layer_fc1/bias/Adam_1:0' shape=(128,) dtype=float32_ref>
<tf.Variable 'layer_fc2/kernel/Adam:0' shape=(128, 10) dtype=float32_ref>
<tf.Variable 'layer_fc2/kernel/Adam_1:0' shape=(128, 10) dtype=float32_ref>
<tf.Variable 'layer_fc2/bias/Adam:0' shape=(10,) dtype=float32_ref>
<tf.Variable 'layer_fc2/bias/Adam_1:0' shape=(10,) dtype=float32_ref>

可以发现，在 layer_conv1 和 layer_conv2 下的变量 kernel 与我们所需的权重有着同样的 shape，这正是我们所需要的权重的变量名。现在我们尝试使用这些变量名获取权重这一变量：

def get_weights_variable(layer_name):
    # 根据给定的layer_name，返回名为'kernel'的变量
    with tf.variable_scope(layer_name, reuse=True):
        variable = tf.get_variable('kernel')
    return variable

weights_conv1 = get_weights_variable(layer_name='layer_conv1')
weights_conv2 = get_weights_variable(layer_name='layer_conv2')

优化与测试

创建 session：

session = tf.Session()
session.run(tf.global_variables_initializer())

以下的代码为了适应独立出来的 cnn_helper.py 做了小部分的改变：

train_batch_size = 64

# 计算目前执行的总迭代次数
total_iterations = 0

def optimize(num_iterations):
    # 保证更新全局变量.
    global total_iterations

    # 用来输出用时.
    start_time = time.time()

    for i in range(total_iterations, total_iterations + num_iterations):
        # 获取一批数据，放入dict，同第一章
        x_batch, y_true_batch = data.train.next_batch(train_batch_size)
        feed_dict_train = {x: x_batch,
                           y_true: y_true_batch}
        # 运行优化器
        session.run(optimizer, feed_dict=feed_dict_train)

        # 每100轮迭代输出状态
        if i % 100 == 0:
            # 计算训练集准确率.
            acc = session.run(accuracy, feed_dict=feed_dict_train)
            msg = "迭代轮次: {0:>6}, 训练准确率: {1:>6.1%}"
            print(msg.format(i + 1, acc))

    total_iterations += num_iterations

    end_time = time.time()
    time_dif = end_time - start_time

    # 输出用时.
    print("用时: " + str(timedelta(seconds=int(round(time_dif)))))

# 将测试集分成更小的批次
test_batch_size = 256

def print_test_accuracy(show_example_errors=False,
                        show_confusion_matrix=False):
    # 测试集图像数量.
    num_test = len(data.test.images)

    # 为预测结果申请一个数组.
    cls_pred = np.zeros(shape=num_test, dtype=np.int)

    # 数据集的起始id为0
    i = 0
    while i < num_test:
        # j为下一批次的截止id
        j = min(i + test_batch_size, num_test)

        # 获取i，j之间的图像
        images = data.test.images[i:j, :]

        # 获取相应标签.
        labels = data.test.labels[i:j, :]

        # 创建feed_dict
        feed_dict = {x: images,
                     y_true: labels}

        # 计算预测结果
        cls_pred[i:j] = session.run(y_pred_cls, feed_dict=feed_dict)

        # 设定为下一批次起始值.
        i = j

    cls_true = data.test.cls
    # 正确的分类
    correct = (cls_true == cls_pred)
    # 正确分类的数量
    correct_sum = correct.sum()
    # 分类准确率
    acc = float(correct_sum) / num_test

    # 打印准确率.
    msg = "测试集准确率: {0:.1%} ({1} / {2})"
    print(msg.format(acc, correct_sum, num_test))

    # 打印部分错误样例.
    if show_example_errors:
        print("Example errors:")
        plot_example_errors(data_test=data.test, cls_pred=cls_pred, correct=correct, img_shape=img_shape)

    # 打印混淆矩阵.
    if show_confusion_matrix:
        print("Confusion Matrix:")
        plot_confusion_matrix(cls_true=cls_true, cls_pred=cls_pred)

结果

直接迭代 10000 轮：

optimize(num_iterations=10000)
print_test_accuracy(show_example_errors=True, show_confusion_matrix=True)

迭代轮次:      1, 训练准确率:  15.6%
迭代轮次:    101, 训练准确率:  76.6%
迭代轮次:    201, 训练准确率:  87.5%
迭代轮次:    301, 训练准确率:  87.5%
迭代轮次:    401, 训练准确率:  90.6%
迭代轮次:    501, 训练准确率:  89.1%
迭代轮次:    601, 训练准确率:  90.6%
迭代轮次:    701, 训练准确率:  93.8%
迭代轮次:    801, 训练准确率:  93.8%
迭代轮次:    901, 训练准确率:  93.8%
迭代轮次:   1001, 训练准确率:  93.8%
迭代轮次:   1101, 训练准确率: 100.0%
迭代轮次:   1201, 训练准确率:  93.8%
迭代轮次:   1301, 训练准确率:  96.9%
迭代轮次:   1401, 训练准确率:  95.3%
迭代轮次:   1501, 训练准确率:  98.4%
迭代轮次:   1601, 训练准确率:  96.9%
迭代轮次:   1701, 训练准确率:  98.4%
迭代轮次:   1801, 训练准确率: 100.0%
迭代轮次:   1901, 训练准确率: 100.0%
迭代轮次:   2001, 训练准确率: 100.0%
迭代轮次:   2101, 训练准确率:  95.3%
迭代轮次:   2201, 训练准确率:  96.9%
迭代轮次:   2301, 训练准确率:  93.8%
迭代轮次:   2401, 训练准确率:  98.4%
迭代轮次:   2501, 训练准确率:  96.9%
迭代轮次:   2601, 训练准确率:  96.9%
迭代轮次:   2701, 训练准确率:  96.9%
迭代轮次:   2801, 训练准确率:  96.9%
迭代轮次:   2901, 训练准确率: 100.0%
迭代轮次:   3001, 训练准确率: 100.0%
迭代轮次:   3101, 训练准确率:  98.4%
迭代轮次:   3201, 训练准确率:  98.4%
迭代轮次:   3301, 训练准确率:  96.9%
迭代轮次:   3401, 训练准确率:  98.4%
迭代轮次:   3501, 训练准确率: 100.0%
迭代轮次:   3601, 训练准确率: 100.0%
迭代轮次:   3701, 训练准确率:  98.4%
迭代轮次:   3801, 训练准确率: 100.0%
迭代轮次:   3901, 训练准确率:  98.4%
迭代轮次:   4001, 训练准确率:  95.3%
迭代轮次:   4101, 训练准确率:  96.9%
迭代轮次:   4201, 训练准确率:  96.9%
迭代轮次:   4301, 训练准确率:  96.9%
迭代轮次:   4401, 训练准确率:  98.4%
迭代轮次:   4501, 训练准确率:  98.4%
迭代轮次:   4601, 训练准确率:  98.4%
迭代轮次:   4701, 训练准确率:  96.9%
迭代轮次:   4801, 训练准确率:  98.4%
迭代轮次:   4901, 训练准确率:  98.4%
迭代轮次:   5001, 训练准确率:  96.9%
迭代轮次:   5101, 训练准确率:  98.4%
迭代轮次:   5201, 训练准确率:  98.4%
迭代轮次:   5301, 训练准确率: 100.0%
迭代轮次:   5401, 训练准确率:  98.4%
迭代轮次:   5501, 训练准确率:  98.4%
迭代轮次:   5601, 训练准确率:  98.4%
迭代轮次:   5701, 训练准确率:  98.4%
迭代轮次:   5801, 训练准确率:  98.4%
迭代轮次:   5901, 训练准确率:  98.4%
迭代轮次:   6001, 训练准确率:  98.4%
迭代轮次:   6101, 训练准确率: 100.0%
迭代轮次:   6201, 训练准确率: 100.0%
迭代轮次:   6301, 训练准确率: 100.0%
迭代轮次:   6401, 训练准确率:  95.3%
迭代轮次:   6501, 训练准确率:  96.9%
迭代轮次:   6601, 训练准确率:  96.9%
迭代轮次:   6701, 训练准确率:  98.4%
迭代轮次:   6801, 训练准确率: 100.0%
迭代轮次:   6901, 训练准确率:  98.4%
迭代轮次:   7001, 训练准确率:  98.4%
迭代轮次:   7101, 训练准确率:  98.4%
迭代轮次:   7201, 训练准确率: 100.0%
迭代轮次:   7301, 训练准确率: 100.0%
迭代轮次:   7401, 训练准确率:  98.4%
迭代轮次:   7501, 训练准确率: 100.0%
迭代轮次:   7601, 训练准确率:  98.4%
迭代轮次:   7701, 训练准确率: 100.0%
迭代轮次:   7801, 训练准确率:  98.4%
迭代轮次:   7901, 训练准确率: 100.0%
迭代轮次:   8001, 训练准确率: 100.0%
迭代轮次:   8101, 训练准确率: 100.0%
迭代轮次:   8201, 训练准确率: 100.0%
迭代轮次:   8301, 训练准确率: 100.0%
迭代轮次:   8401, 训练准确率:  96.9%
迭代轮次:   8501, 训练准确率: 100.0%
迭代轮次:   8601, 训练准确率: 100.0%
迭代轮次:   8701, 训练准确率: 100.0%
迭代轮次:   8801, 训练准确率: 100.0%
迭代轮次:   8901, 训练准确率:  98.4%
迭代轮次:   9001, 训练准确率: 100.0%
迭代轮次:   9101, 训练准确率:  96.9%
迭代轮次:   9201, 训练准确率:  98.4%
迭代轮次:   9301, 训练准确率: 100.0%
迭代轮次:   9401, 训练准确率: 100.0%
迭代轮次:   9501, 训练准确率: 100.0%
迭代轮次:   9601, 训练准确率:  98.4%
迭代轮次:   9701, 训练准确率: 100.0%
迭代轮次:   9801, 训练准确率: 100.0%
迭代轮次:   9901, 训练准确率:  98.4%
用时: 0:13:00
测试集准确率: 98.7% (9867 / 10000)
Example errors:

Confusion Matrix:
[[ 973    0    1    0    0    1    2    1    2    0]
 [   0 1133    1    0    0    0    0    1    0    0]
 [   2    3 1018    0    1    0    0    4    3    1]
 [   1    0    1  992    0   12    0    3    1    0]
 [   0    0    1    0  979    0    0    1    0    1]
 [   1    0    1    1    0  888    1    0    0    0]
 [   6    3    0    0    4   12  933    0    0    0]
 [   0    2    6    1    1    0    0 1017    1    0]
 [   4    0    1    2    1    4    0    2  957    3]
 [   2    4    0    0   11    6    0    8    1  977]]

权重与层的可视化

第一层权重

weights1 = session.run(weights_conv1)
plot_conv_weights(weights=weights1)

第一层输出

image1 = data.test.images[0]
layer1 = session.run(layer_conv1, feed_dict={x: [image1]})
plot_conv_layer(values=layer1)

image2 = data.test.images[13]
layer1 = session.run(layer_conv1, feed_dict={x: [image2]})
plot_conv_layer(values=layer1)

第二层权重

weights2 = session.run(weights_conv2)
plot_conv_weights(weights=weights2, input_channel=0)

plot_conv_weights(weights=weights2, input_channel=0)

第二层输出

layer2 = session.run(layer_conv2, feed_dict={x: [image1]})
plot_conv_layer(values=layer2)

layer2 = session.run(layer_conv2, feed_dict={x: [image2]})
plot_conv_layer(values=layer2)

关闭session

session.close()

尽管 TensorFlow 为使用者提供了一些简化代码的便利，我们仍然应当先了解其中的原理再使用，不要一味地把深度学习当成黑盒子来使用。

这是几篇与原作不完全相同的教程。

转载请说明出处：TensorFlow (2) - 卷积神经网络

原作者：Magnus Erik Hvass Pedersen / GitHub / Videos on YouTube

在上一章节 中，我们在 MNIST 数据集上得到了 91% 的测试准确率。这个结果其实并不太理想。

在本章中，我们将使用卷积神经网络来得到一个准确率更高的模型，接近 99%。卷积神经网络使用共享的卷积核对图像进行卷积操作，以提取图像深层特征。这些深层特征然后组合成特征向量输入全连接的神经网络中，再使用类似上一章的方法进行分类。

网络结构图

在本章中需要实现的整个网络结构如下图所示：

输入为原始的 28x28 的图像，它首先进入第一个拥有 16 个 5x5 卷积核的卷积层，得到 16 张 28x28 的卷积后的图像，再进入降采样层（图中未体现）最终得到 16 张 14x14 的图像（可称为 16 个通道）。为了保证卷积前后图像的像素不变，在卷积过后，对图像边框采取补零的操作（在 TensorFlow 中的 conv2d 的 padding 参数为 'SAME'，如果不采取补零而是缩小像素值， padding 参数值设置为 'VALID'）。降采样层使用 max pooling 操作，将 2x2 的像素块取最大值合并为一个像素点，这个操作会将图像缩小 1 倍。

对于得到的 16 通道的 14x14 图像，进入第二个拥有 36 个卷积核的卷积层，得到 36 张 14x14 的卷积后图像，再进入降采样层得到 36 张 7x7 的图像。在这里包括了一些隐含的操作，对于 16 张原始图像，每一张图像使用 36 个卷积核卷积，应该得到 16x36 张新的图像，但是为了减少模型的参数量，降低复杂度，卷积层对每个卷积核得到的 16 张图像相加，最后得到 36 张卷积后图像。

经过两层卷积后，将 36 张 7x7 的图像展平，得到一个 7x7x3 6的向量，输入到一个 128 维的全连接层，再输入到 10 维的 softmx 层进行分类，这一块与上一章类似。

卷积层

卷积层使用多个卷积核作用于同一幅图像，以得到多个卷积后的图像。如下图所示：

对于原始的图像 7，使用一个 5x5 的卷积核，从左到右从上到下滑动。滑动的过程称为 stride，一个卷积层有两个 stride，分别从上到下，从左到右，步长一般设定为 1 或 2。对卷积核覆盖的区域于卷积核进行点乘操作得到一个值作为该区域的中心点的像素。在上图中，红色代表这部分的像素对原始图像存在一个正的影响，而蓝色表示负的影响，在这个样例中卷积核似乎在识别图像中的横线部分，因为从结果看来 7 的那一横具有更强烈的反应。

此外，对于每一个卷积层的输出，一般会经过一个 relu 层，以保证全部的像素值都为正（因为所有为负的像素值都被设定为 0）。

需要导入的包

import tensorflow as tf          # TensorFlow
import matplotlib.pyplot as plt  # matplotlib绘图
import numpy as np              # Numpy
from sklearn.metrics import confusion_matrix    # 混淆矩阵，分析模型误差

import time      # 计时
from datetime import timedelta
import math

# notebook使用
%matplotlib inline

卷积神经网络配置

# 卷积层 1
filter_size1 = 5          # 5 x 5 卷积核
num_filters1 = 16        # 共 16 个卷积核

# 卷积层 2
filter_size2 = 5          # 5 x 5 卷积核
num_filters2 = 36        # 共 36 个卷积核

# Fully-connected layer.
fc_size = 128            # Number of neurons in fully-connected layer.

载入数据

TensorFlow 在样例教程中已经做了下载并导入 MNIST 数字手写体识别数据集的实现，可以直接使用。以下代码会将 MNIST 数据集下载到 data/MNIST 目录下，将标签保存为 one-hot 编码。

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('data/MNIST', one_hot=True)

MNIST 数据集总共有 70000 张手写数字图片，数据集被分为训练集、测试集和验证集三部分。

print("数据集大小：")
print('- 训练集：{}'.format(len(data.train.labels)))
print('- 测试集：{}'.format(len(data.test.labels)))
print('- 验证集：{}'.format(len(data.validation.labels)))

数据集大小：
- 训练集：55000
- 测试集：10000
- 验证集：5000

One-hot 编码

每一张图的标签使用了 one-hot 编码保存在 numpy 矩阵中，而不是原本的类别，这是为了方便神经网络的处理。

print(data.test.labels[:5])

[[ 0.  0.  0.  0.  0.  0.  0.  1.  0.  0.]
 [ 0.  0.  1.  0.  0.  0.  0.  0.  0.  0.]
 [ 0.  1.  0.  0.  0.  0.  0.  0.  0.  0.]
 [ 1.  0.  0.  0.  0.  0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  1.  0.  0.  0.  0.  0.]]

在 one-hot 编码中，只有对应类别的那个位置为 1，其余都为 0，我们可以使用以下代码将其转换为真实类别：

data.test.cls = np.argmax(data.test.labels, axis=1)
print(data.test.cls[:5])

[7 2 1 0 4]

数据维度

在 MNIST 数据集中，原始的 28*28 像素的黑白图片被展平为 784 维的向量。

print("样本维度：", data.train.images.shape)
print("标签维度：", data.train.labels.shape)

样本维度： (55000, 784)
标签维度： (55000, 10)

为使得网络结构更加清晰，在这里对这些固定维度做如下定义：

img_size = 28                        # 图片的高度和宽度
img_size_flat = img_size * img_size  # 展平为向量的尺寸
img_shape = (img_size, img_size)    # 图片的二维尺寸

num_channels = 1                    # 输入为单通道灰度图像
num_classes = 10                    # 类别数目

打印部分样例图片

def plot_images(images, cls_true, cls_pred=None):
    """
    绘制图像，输出真实标签与预测标签
    images:  图像（9张）
    cls_true: 真实类别
    cls_pred: 预测类别
    """
    assert len(images) == len(cls_true) == 9  # 保证存在9张图片

    fig, axes = plt.subplots(3, 3)  # 创建3x3个子图的画布
    fig.subplots_adjust(hspace=0.3, wspace=0.3)  # 调整每张图之间的间隔

    for i, ax in enumerate(axes.flat):
        # 绘图，将一维向量变为二维矩阵，黑白二值图像使用 binary
        ax.imshow(images[i].reshape(img_shape), cmap='binary')

        if cls_pred is None:  # 如果未传入预测类别
            xlabel = "True: {0}".format(cls_true[i])
        else:
            xlabel = "True: {0}, Pred: {1}".format(cls_true[i], cls_pred[i])
        ax.set_xlabel(xlabel)

        # 删除坐标信息
        ax.set_xticks([])
        ax.set_yticks([])    
    plt.show()

# 随机取9张图片
indices = np.arange(len(data.test.cls))
np.random.shuffle(indices)
indices = indices[:9]    

images = data.test.images[indices]
cls_true = data.test.cls[indices]

plot_images(images, cls_true)

TensorFlow 计算图

TensorFlow 使用计算图模型来构建神经网络。其主要流程是先建立好整个网络的计算图模型，然后再导入数据进行计算。

一个 TensorFlow 计算图包含以下几个部分：

• Placeholder: 占位符，用来读取用户输入与输出；
• Variable: 模型的变量，也称为参数，在计算过程中逐步优化；
• Model: 使用的神经网络模型，也可以使用一些简单的计算；
• Cost Function： 代价函数，也称损失函数，如何计算模型的误差；
• Optimizer： 优化器，使用哪种优化策略来降低损失。

创建变量

def new_weights(shape):  
    return tf.Variable(tf.truncated_normal(shape, stddev=0.05))    # 初始化为随机值

def new_biases(length):
    return tf.Variable(tf.constant(0.05, shape=[length]))          # 初始化为常数

卷积神经网络中同样有两类变量，权重和偏置项。注意，这里的初始化只有在运行计算图时才会执行。

创建卷积层

这个函数创建了一个卷积层。输入为 4 维的 tensor，维度如下：

1. 图像数量
2. 图像高度
3. 图像宽度
4. 通道数

输出同样是一个 4 维的 tensor，维度如下：

1. 图像数量，与输入相同
2. 图像高度，如果使用 2x2 pooling，高宽都除以 2
3. 图像宽度，同上
4. 由卷积层生成的通道数

def new_conv_layer(input,              # 前一层.
                  num_input_channels, # 前一层通道数
                  filter_size,        # 卷积核尺寸
                  num_filters,        # 卷积核数目
                  use_pooling=True):  # 使用 2x2 max-pooling.

    # 卷积核权重的形状，由TensorFlow API决定
    shape = [filter_size, filter_size, num_input_channels, num_filters]

    # 根据跟定形状创建权重
    weights = new_weights(shape=shape)

    # 创建新的偏置，每个卷积核一个偏置
    biases = new_biases(length=num_filters)

    # 创建卷积层。注意stride全设置为1。
    # 第1个和第4个必须是1，因为第1个是图像的数目，第4个是图像的通道。
    # 第2和第3指定和左右、上下的步长。
    # padding设置为'SAME' 意味着给图像补零，以保证前后像素相同。
    layer = tf.nn.conv2d(input=input,
                        filter=weights,
                        strides=[1, 1, 1, 1],
                        padding='SAME')

    # 给卷积层的输出添加一个偏置，每个卷积通道一个偏置值
    layer += biases

    # 是否使用pooling
    if use_pooling:
        # 这是 2x2 max-pooling, 表明使用 2x2 的窗口，选择每一窗口的最大值作为该窗口的像素，
        # 然后移动2格到下一窗口。
        layer = tf.nn.max_pool(value=layer,
                              ksize=[1, 2, 2, 1],
                              strides=[1, 2, 2, 1],
                              padding='SAME')

    # Rectified Linear Unit (ReLU).
    # 对每个输入像素x，计算 max(x, 0)，把负数的像素值变为0.
    # 这一步为原输出添加了一定的非线性特性，允许我们学习更加复杂的函数。
    layer = tf.nn.relu(layer)

    # 注意 relu 通常在pooling前执行，但是由于 relu(max_pool(x)) == max_pool(relu(x))，
    # 我们可以通过先max_pooling再relu省去75%的计算。

    # 返回结果层和权重，结果层用于下一层输入，权重用于显式输出
    return layer, weights

展平操作

一个卷积层的输出为 4 维度的 tensor。我们需要在卷积层后添加一个全连接层，首先得将 4 为的 tensor 展平为 2 维的 tensor，这样才能直接输入到全连接层。

def flatten_layer(layer):
    # 获取输入层的形状，
    # layer_shape == [num_images, img_height, img_width, num_channels]
    layer_shape = layer.get_shape()

    # 特征数量: img_height * img_width * num_channels
    # 可以使用TensorFlow内建操作计算.
    num_features = layer_shape[1:4].num_elements()

    # 将形状重塑为 [num_images, num_features].
    # 注意只设定了第二个维度的尺寸为num_filters，第一个维度为-1，保证第一个维度num_images不变
    # 展平后的层的形状为:
    # [num_images, img_height * img_width * num_channels]
    layer_flat = tf.reshape(layer, [-1, num_features])

    return layer_flat, num_features

创建全连接层

def new_fc_layer(input,          # 前一层.
                num_inputs,    # 前一层输入维度
                num_outputs,    # 输出维度
                use_relu=True): # 是否使用RELU

    # 新的权重和偏置，与第一章一样.
    weights = new_weights(shape=[num_inputs, num_outputs])
    biases = new_biases(length=num_outputs)

    # 计算 y = wx + b，同第一章
    layer = tf.matmul(input, weights) + biases

    # 是否使用RELU
    if use_relu:
        layer = tf.nn.relu(layer)

    return layer

Placeholder 占位符

占位符为输入与输出占据位置，这些输入输出一般在不同的轮次都会有所变化。由于 TensorFlow 先构图再计算，所以需要使用占位符为输入和输出预留位置。

x = tf.placeholder(tf.float32, shape=[None, img_size_flat], name='x')          # 原始输入
x_image = tf.reshape(x, [-1, img_size, img_size, num_channels])                # 转换为2维图像
y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true')  # 原始输出
y_true_cls = tf.argmax(y_true, axis=1)                  # 转换为真实类别，与之前的使用placeholder不同

卷积层 1

layer_conv1, weights_conv1 = \\
    new_conv_layer(input=x_image,                    # 输入图像
                  num_input_channels=num_channels,  # 输入通道数
                  filter_size=filter_size1,          # 卷积核尺寸
                  num_filters=num_filters1,          # 卷积核数目
                  use_pooling=True)
print(layer_conv1)

Tensor("Relu:0", shape=(?, 14, 14, 16), dtype=float32)

输入为 (?, 28, 28, 1) 的图像，其中 ? 为图像数量。可以看到，第一个卷积层的输入为 (?, 14, 14, 16) 的 tensor，即 14x14 像素的 16 道图像。

卷积层 2

layer_conv2, weights_conv2 = \\
    new_conv_layer(input=layer_conv1,
                   num_input_channels=num_filters1,
                   filter_size=filter_size2,
                   num_filters=num_filters2,
                   use_pooling=True)
print(layer_conv2)

Tensor("Relu_1:0", shape=(?, 7, 7, 36), dtype=float32)

解释同上，输入为上一层的输出。

展平层

展平层将第二个卷积层展平为二维 tensor。

layer_flat, num_features = flatten_layer(layer_conv2)
print(layer_flat)

Tensor("Reshape_1:0", shape=(?, 1764), dtype=float32)

输出为 (?, 1764) 的 tensor。

全连接层 1

layer_fc1 = new_fc_layer(input=layer_flat,   # 展平层输出
                         num_inputs=num_features,   # 输入特征维度
                         num_outputs=fc_size,       # 输出特征维度
                         use_relu=True)
print(layer_fc1)

Tensor("Relu_2:0", shape=(?, 128), dtype=float32)

输出为 (?, 128) 的 2 维 tensor。

全连接层 2

layer_fc2 = new_fc_layer(input=layer_fc1,           # 上一全连接层
                         num_inputs=fc_size,        # 输入特征维度
                         num_outputs=num_classes,   # 输出类别数
                         use_relu=False)
print(layer_fc2)

Tensor("add_3:0", shape=(?, 10), dtype=float32)

输出为 (?, 10) 的二维 tensor，意在判定输入图像属于哪一类, 注意该层未使用 relu，因为将要输入到后续的 softmax 中。

预测类别

第二个全连接层估计输入的图像属于某一类别的程度，这个估计有些粗糙，需要添加一个 softmax 层归一化为概率表示。

y_pred = tf.nn.softmax(layer_fc2)              # softmax归一化
y_pred_cls = tf.argmax(y_pred, axis=1)         # 真实类别

代价函数

这一部分与上一章的类似。

cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=layer_fc2,
                                                        labels=y_true)
cost = tf.reduce_mean(cross_entropy)

优化方法

这一部分与上一章类似，但是优化器使用改进版的梯度下降，Adam。

optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cost)

性能度量

同上一章

correct_prediction = tf.equal(y_pred_cls, y_true_cls)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

运行 TensorFlow 计算图

创建 Session 以及变量初始化

TensorFlow 计算图运行在一个 session 中，计算之前需要先创建这个 session，并初始化其中的一些变量（w 和 b），TensorFlow 使用 session.run() 来运行计算图。

session = tf.Session()   # 创建session
session.run(tf.global_variables_initializer())   # 变量初始化

执行优化的帮助函数

同第一章，添加了部分状态输出的代码：

train_batch_size = 64

# 计算目前执行的总迭代次数
total_iterations = 0

def optimize(num_iterations):
    # 保证更新全局变量.
    global total_iterations

    # 用来输出用时.
    start_time = time.time()

    for i in range(total_iterations, total_iterations + num_iterations):
        # 获取一批数据，放入dict，同第一章
        x_batch, y_true_batch = data.train.next_batch(train_batch_size)
        feed_dict_train = {x: x_batch,
                          y_true: y_true_batch}
        # 运行优化器
        session.run(optimizer, feed_dict=feed_dict_train)

        # 每100轮迭代输出状态
        if i % 100 == 0:
            # 计算训练集准确率.
            acc = session.run(accuracy, feed_dict=feed_dict_train)
            msg = "迭代轮次: {0:>6}, 训练准确率: {1:>6.1%}"
            print(msg.format(i + 1, acc))

    total_iterations += num_iterations

    end_time = time.time()
    time_dif = end_time - start_time

    # 输出用时.
    print("用时: " + str(timedelta(seconds=int(round(time_dif)))))

输出部分错误样例和混淆矩阵

与上一章类似。

def plot_example_errors(cls_pred, correct):
    # 计算错误情况
    incorrect = (correct == False)
    images = data.test.images[incorrect]
    cls_pred = cls_pred[incorrect]
    cls_true = data.test.cls[incorrect]

    # 随机挑选9个
    indices = np.arange(len(images))
    np.random.shuffle(indices)
    indices = indices[:9]

    plot_images(images[indices], cls_true[indices], cls_pred[indices])

def plot_confusion_matrix(cls_pred):
    cls_true = data.test.cls  # 真实类别  

    # 使用scikit-learn的confusion_matrix来计算混淆矩阵
    cm = confusion_matrix(y_true=cls_true, y_pred=cls_pred)

    # 打印混淆矩阵
    print(cm)

    # 将混淆矩阵输出为图像
    plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)

    # 调整图像
    plt.tight_layout()
    plt.colorbar()
    tick_marks = np.arange(num_classes)
    plt.xticks(tick_marks, range(num_classes))
    plt.yticks(tick_marks, range(num_classes))
    plt.xlabel('Predicted')
    plt.ylabel('True')
    plt.show()

显示性能的帮助函数

用来输出测试准确率的的函数。计算所有图像的分类需要一定的时间，因此我们在上面定义的一些函数中重用了分类结果。这个函数会占据大量的内存，所以将测试集分成了多个小的批次。如果你的机器内存太小，你可以尝试减小 batch_size。

# 将测试集分成更小的批次
test_batch_size = 256

def print_test_accuracy(show_example_errors=False,
                        show_confusion_matrix=False):
    # 测试集图像数量.
    num_test = len(data.test.images)

    # 为预测结果申请一个数组.
    cls_pred = np.zeros(shape=num_test, dtype=np.int)

    # 数据集的起始id为0
    i = 0
    while i < num_test:
        # j为下一批次的截止id
        j = min(i + test_batch_size, num_test)

        # 获取i，j之间的图像
        images = data.test.images[i:j, :]

        # 获取相应标签.
        labels = data.test.labels[i:j, :]

        # 创建feed_dict
        feed_dict = {x: images,
                    y_true: labels}

        # 计算预测结果
        cls_pred[i:j] = session.run(y_pred_cls, feed_dict=feed_dict)

        # 设定为下一批次起始值.
        i = j

    cls_true = data.test.cls
    # 正确的分类
    correct = (cls_true == cls_pred)
    # 正确分类的数量
    correct_sum = correct.sum()
    # 分类准确率
    acc = float(correct_sum) / num_test

    # 打印准确率.
    msg = "测试集准确率: {0:.1%} ({1} / {2})"
    print(msg.format(acc, correct_sum, num_test))

    # 打印部分错误样例.
    if show_example_errors:
        print("Example errors:")
        plot_example_errors(cls_pred=cls_pred, correct=correct)

    # 打印混淆矩阵.
    if show_confusion_matrix:
        print("Confusion Matrix:")
        plot_confusion_matrix(cls_pred=cls_pred)

优化前的性能测试

print_test_accuracy()

测试集准确率: 4.2% (424 / 10000)

可以看到，测试的准确率极低，但是函数的功能正常。

执行一轮优化后的性能

optimize(num_iterations=1)
print_test_accuracy()

迭代轮次:      1, 训练准确率:   3.1%
用时: 0:00:00
测试集准确率: 5.3% (534 / 10000)

一轮迭代后，性能稍有提升。

100 轮优化后的性能

optimize(num_iterations=99)
print_test_accuracy()

用时: 0:00:08
测试集准确率: 70.8% (7077 / 10000)

可以看到，执行 100 轮迭代后，性能存在大幅度提升。

1000 轮优化后性能

optimize(num_iterations=900)
print_test_accuracy(show_example_errors=True)

迭代轮次:    101, 训练准确率:  70.3%
迭代轮次:    201, 训练准确率:  87.5%
迭代轮次:    301, 训练准确率:  84.4%
迭代轮次:    401, 训练准确率:  84.4%
迭代轮次:    501, 训练准确率:  95.3%
迭代轮次:    601, 训练准确率:  90.6%
迭代轮次:    701, 训练准确率:  95.3%
迭代轮次:    801, 训练准确率:  89.1%
迭代轮次:    901, 训练准确率:  93.8%
用时: 0:01:12
测试集准确率: 93.5% (9351 / 10000)
Example errors:

可以发现，测试集的准确率为 93.5%，已经比第一章的 91.9% 要高。输出的部分错误样例显示，部分形状相似的数字仍然难以区分。

10000 轮次优化后的性能

optimize(num_iterations=9000)
print_test_accuracy(show_example_errors=True,
                    show_confusion_matrix=True)

迭代轮次:   1001, 训练准确率:  93.8%
迭代轮次:   1101, 训练准确率:  92.2%
迭代轮次:   1201, 训练准确率:  95.3%
迭代轮次:   1301, 训练准确率:  98.4%
迭代轮次:   1401, 训练准确率:  96.9%
迭代轮次:   1501, 训练准确率:  92.2%
迭代轮次:   1601, 训练准确率:  96.9%
迭代轮次:   1701, 训练准确率:  92.2%
迭代轮次:   1801, 训练准确率:  98.4%
迭代轮次:   1901, 训练准确率:  98.4%
迭代轮次:   2001, 训练准确率:  98.4%
迭代轮次:   2101, 训练准确率:  93.8%
迭代轮次:   2201, 训练准确率:  98.4%
迭代轮次:   2301, 训练准确率:  93.8%
迭代轮次:   2401, 训练准确率:  96.9%
迭代轮次:   2501, 训练准确率:  95.3%
迭代轮次:   2601, 训练准确率:  95.3%
迭代轮次:   2701, 训练准确率:  95.3%
迭代轮次:   2801, 训练准确率: 100.0%
迭代轮次:   2901, 训练准确率:  96.9%
迭代轮次:   3001, 训练准确率:  90.6%
迭代轮次:   3101, 训练准确率:  98.4%
迭代轮次:   3201, 训练准确率:  98.4%
迭代轮次:   3301, 训练准确率:  98.4%
迭代轮次:   3401, 训练准确率:  96.9%
迭代轮次:   3501, 训练准确率:  96.9%
迭代轮次:   3601, 训练准确率:  96.9%
迭代轮次:   3701, 训练准确率: 100.0%
迭代轮次:   3801, 训练准确率:  96.9%
迭代轮次:   3901, 训练准确率:  98.4%
迭代轮次:   4001, 训练准确率:  96.9%
迭代轮次:   4101, 训练准确率:  96.9%
迭代轮次:   4201, 训练准确率:  98.4%
迭代轮次:   4301, 训练准确率:  98.4%
迭代轮次:   4401, 训练准确率:  98.4%
迭代轮次:   4501, 训练准确率:  96.9%
迭代轮次:   4601, 训练准确率: 100.0%
迭代轮次:   4701, 训练准确率:  96.9%
迭代轮次:   4801, 训练准确率:  98.4%
迭代轮次:   4901, 训练准确率:  98.4%
迭代轮次:   5001, 训练准确率:  93.8%
迭代轮次:   5101, 训练准确率:  98.4%
迭代轮次:   5201, 训练准确率:  92.2%
迭代轮次:   5301, 训练准确率:  96.9%
迭代轮次:   5401, 训练准确率:  98.4%
迭代轮次:   5501, 训练准确率:  98.4%
迭代轮次:   5601, 训练准确率:  98.4%
迭代轮次:   5701, 训练准确率:  98.4%
迭代轮次:   5801, 训练准确率:  95.3%
迭代轮次:   5901, 训练准确率:  96.9%
迭代轮次:   6001, 训练准确率: 100.0%
迭代轮次:   6101, 训练准确率:  98.4%
迭代轮次:   6201, 训练准确率: 100.0%
迭代轮次:   6301, 训练准确率: 100.0%
迭代轮次:   6401, 训练准确率: 100.0%
迭代轮次:   6501, 训练准确率:  98.4%
迭代轮次:   6601, 训练准确率: 100.0%
迭代轮次:   6701, 训练准确率:  95.3%
迭代轮次:   6801, 训练准确率: 100.0%
迭代轮次:   6901, 训练准确率: 100.0%
迭代轮次:   7001, 训练准确率: 100.0%
迭代轮次:   7101, 训练准确率:  98.4%
迭代轮次:   7201, 训练准确率: 100.0%
迭代轮次:   7301, 训练准确率:  96.9%
迭代轮次:   7401, 训练准确率: 100.0%
迭代轮次:   7501, 训练准确率: 100.0%
迭代轮次:   7601, 训练准确率:  98.4%
迭代轮次:   7701, 训练准确率:  98.4%
迭代轮次:   7801, 训练准确率: 100.0%
迭代轮次:   7901, 训练准确率: 100.0%
迭代轮次:   8001, 训练准确率:  95.3%
迭代轮次:   8101, 训练准确率:  98.4%
迭代轮次:   8201, 训练准确率:  96.9%
迭代轮次:   8301, 训练准确率:  98.4%
迭代轮次:   8401, 训练准确率:  98.4%
迭代轮次:   8501, 训练准确率: 100.0%
迭代轮次:   8601, 训练准确率:  96.9%
迭代轮次:   8701, 训练准确率:  98.4%
迭代轮次:   8801, 训练准确率:  98.4%
迭代轮次:   8901, 训练准确率:  96.9%
迭代轮次:   9001, 训练准确率: 100.0%
迭代轮次:   9101, 训练准确率: 100.0%
迭代轮次:   9201, 训练准确率:  98.4%
迭代轮次:   9301, 训练准确率: 100.0%
迭代轮次:   9401, 训练准确率:  98.4%
迭代轮次:   9501, 训练准确率:  98.4%
迭代轮次:   9601, 训练准确率: 100.0%
迭代轮次:   9701, 训练准确率: 100.0%
迭代轮次:   9801, 训练准确率:  98.4%
迭代轮次:   9901, 训练准确率: 100.0%
用时: 0:12:42
测试集准确率: 98.7% (9873 / 10000)
Example errors:

Confusion Matrix:
[[ 974    0    1    0    0    1    1    1    2    0]
 [   0 1130    1    0    0    1    0    2    1    0]
 [   4    1 1020    0    1    0    0    3    3    0]
 [   1    0    1 1000    0    3    0    2    3    0]
 [   0    0    2    0  968    0    1    2    2    7]
 [   2    0    0    6    0  878    2    2    1    1]
 [   5    2    0    0    2    2  945    0    2    0]
 [   1    0    7    2    0    0    0 1016    1    1]
 [   5    0    2    1    0    2    0    2  959    3]
 [   2    5    1    3    4    4    0    5    2  983]]

经过 10000 轮迭代后，测试集的准确率达到了 98.7% 的准确率。在分错的样本中，部分用肉眼也难以分辨。而混淆矩阵表明绝大部分的样本都分类正确。这是一个非常好的模型。

权重和层的可视化

为了更好的理解卷积神经网络为何能识别手写体数字，我来来可视化部分权重和层输出。

卷积权重可视化

def plot_conv_weights(weights, input_channel=0):
    # weights_conv1 or weights_conv2.

    # 运行weights以获得权重
    w = session.run(weights)

    # 获取权重最小值最大值，这将用户纠正整个图像的颜色密集度，来进行对比
    w_min = np.min(w)
    w_max = np.max(w)

    # 卷积核树木
    num_filters = w.shape[3]

    # 需要输出的卷积核
    num_grids = math.ceil(math.sqrt(num_filters))

    fig, axes = plt.subplots(num_grids, num_grids)
    for i, ax in enumerate(axes.flat):
        # 只输出有用的子图.
        if i<num_filters:
            # 获得第i个卷积核在特定输入通道上的权重
            img = w[:, :, input_channel, i]

            ax.imshow(img, vmin=w_min, vmax=w_max,
                      interpolation='nearest', cmap='seismic')

        # 移除坐标.
        ax.set_xticks([])
        ax.set_yticks([])
    plt.show()

卷积层输出可视化

def plot_conv_layer(layer, image):
    # layer_conv1 or layer_conv2.

    # feed_dict只需要x，标签信息在此不需要.
    feed_dict = {x: [image]}

    # 获取该层的输出结果
    values = session.run(layer, feed_dict=feed_dict)

    # 卷积核树木
    num_filters = values.shape[3]

    # 每行需要输出的卷积核网格数
    num_grids = math.ceil(math.sqrt(num_filters))

    fig, axes = plt.subplots(num_grids, num_grids)
    for i, ax in enumerate(axes.flat):
        # 只输出有用的子图.
        if i<num_filters:
            # 获取第i个卷积核的输出
            img = values[0, :, :, i]

            ax.imshow(img, interpolation='nearest', cmap='binary')

        # 移除坐标.
        ax.set_xticks([])
        ax.set_yticks([])
    plt.show()

打印输入图像

def plot_image(image):
    plt.imshow(image.reshape(img_shape),
              interpolation='nearest',
              cmap='binary')

    plt.show()

打印第一章图像：

image1 = data.test.images[0]
plot_image(image1)

打印另一张图像:

image2 = data.test.images[13]
plot_image(image2)

卷积层 1

plot_conv_weights(weights=weights_conv1)

以上就是 16 个卷积核在第一个通道的权重情况。其中红色为正的权重，蓝色为负的权重。在这里我们很难判别这些权重是如何起作用的。

将 image1 喂入卷积层 1，得到使用不同卷积后得到的图像，这些图像的棱角更加分明，而且在不同的边的突出情况也不同：

plot_conv_layer(layer=layer_conv1, image=image1)

将 image2 喂入卷积层 1，得到如下图像，在不同部位的突出情况不同：

plot_conv_layer(layer=layer_conv1, image=image2)

卷积层 2

现在输出第二个卷积层的权重。

由于卷积层 1 有 16 个输出通道，这意味着卷积层 2 有 16 个输入通道，每个通道的输入又对应 36 个输出通道，因此总共有 16x36 个通道的卷积核。我们先输出第一个通道的卷积核。

plot_conv_weights(weights=weights_conv2, input_channel=0)

这些权重相对与卷积层1的权重更加抽象，无法用语言来解释。接下来输出第二个通道的卷积核。

plot_conv_weights(weights=weights_conv2, input_channel=1)

可以说明，不同输入通道对应的卷积核是不同的。将image1在卷积层1的输出再次输入卷积层2，得到如下输出：

plot_conv_layer(layer=layer_conv1, image=image2)

image2的输出如下：

plot_conv_layer(layer=layer_conv1, image=image2)

所输出的图像达到了一个更高的层次，卷积核试图提取一些边缘化的特征，这些特征对于同类图像的变化并不敏感。

在运行完整个计算图后，需要将它关闭，否则将一直占用资源:

session.close()

这是几篇与原作不完全相同的教程。

转载请说明出处：TensorFlow (1) - 线性模型

原作者：Magnus Erik Hvass Pedersen / GitHub / Videos on YouTube

需要导入的包

import tensorflow as tf          # TensorFlow
import matplotlib.pyplot as plt  # matplotlib绘图
import numpy as np               # Numpy
from sklearn.metrics import confusion_matrix    # 混淆矩阵，分析模型误差

# notebook使用
%matplotlib inline

载入数据

TensorFlow 在样例教程中已经做了下载并导入 MNIST 数字手写体识别数据集的实现，可以直接使用。以下代码会将 MNIST 数据集下载到 data/MNIST 目录下，将标签保存为 one-hot 编码。

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('data/MNIST', one_hot=True)

MNIST 数据集总共有 70000 张手写数字图片，数据集被分为训练集、测试集和验证集三部分。

print("数据集大小：")
print('- 训练集：{}'.format(len(data.train.labels)))
print('- 测试集：{}'.format(len(data.test.labels)))
print('- 验证集：{}'.format(len(data.validation.labels)))

数据集大小：
- 训练集：55000
- 测试集：10000
- 验证集：5000

One-hot 编码

每一张图的标签使用了 one-hot 编码保存在 numpy 矩阵中，而不是原本的类别，这是为了方便神经网络的处理。

print(data.test.labels[:5])

[[ 0.  0.  0.  0.  0.  0.  0.  1.  0.  0.]
 [ 0.  0.  1.  0.  0.  0.  0.  0.  0.  0.]
 [ 0.  1.  0.  0.  0.  0.  0.  0.  0.  0.]
 [ 1.  0.  0.  0.  0.  0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  1.  0.  0.  0.  0.  0.]]

在 one-hot 编码中，只有对应类别的那个位置为 1，其余都为 0，我们可以使用以下代码将其转换为真实类别：

data.test.cls = np.argmax(data.test.labels, axis=1)
print(data.test.cls[:5])

[7 2 1 0 4]

数据维度

在 MNIST 数据集中，原始的 28*28 像素的黑白图片被展平为 784 维的向量。

print("样本维度：", data.train.images.shape)
print("标签维度：", data.train.labels.shape)

样本维度： (55000, 784)
标签维度： (55000, 10)

为使得网络结构更加清晰，在这里对这些固定维度做如下定义：

img_size = 28                        # 图片的高度和宽度
img_size_flat = img_size * img_size  # 展平为向量的尺寸
img_shape = (img_size, img_size)     # 图片的二维尺寸

num_classes = 10                     # 类别数目

打印部分样例图片

def plot_images(images, cls_true, cls_pred=None):
    """
    绘制图像，输出真实标签与预测标签
    images:   图像（9张）
    cls_true: 真实类别
    cls_pred: 预测类别
    """
    assert len(images) == len(cls_true) == 9   # 保证存在9张图片

    fig, axes = plt.subplots(3, 3)   # 创建3x3个子图的画布
    fig.subplots_adjust(hspace=0.3, wspace=0.3)  # 调整每张图之间的间隔

    for i, ax in enumerate(axes.flat):
        # 绘图，将一维向量变为二维矩阵，黑白二值图像使用 binary
        ax.imshow(images[i].reshape(img_shape), cmap='binary')

        if cls_pred is None:  # 如果未传入预测类别
            xlabel = "True: {0}".format(cls_true[i])
        else:
            xlabel = "True: {0}, Pred: {1}".format(cls_true[i], cls_pred[i])
        ax.set_xlabel(xlabel)

        # 删除坐标信息
        ax.set_xticks([])
        ax.set_yticks([])            

# 随机取9张图片
indices = np.arange(len(data.test.cls))
np.random.shuffle(indices)
indices = indices[:9]    

images = data.test.images[indices]
cls_true = data.test.cls[indices]

plot_images(images, cls_true)

TensorFlow计算图

TensorFlow 使用计算图模型来构建神经网络。其主要流程是先建立好整个网络的计算图模型，然后再导入数据进行计算。

一个 TensorFlow 计算图包含以下几个部分：

• Placeholder: 占位符，用来读取用户输入与输出；
• Variable: 模型的变量，也称为参数，在计算过程中逐步优化；
• Model: 使用的神经网络模型，也可以使用一些简单的计算；
• Cost Function： 代价函数，也称损失函数，如何计算模型的误差；
• Optimizer： 优化器，使用哪种优化策略来降低损失。

Placeholder 占位符

占位符为输入与输出占据位置，这写输入输出一般在不同的轮次都会有所变化。由于 TensorFlow 先构图再计算，所以需要使用占位符为输入和输出预留位置。

x = tf.placeholder(tf.float32, shape=[None, img_size_flat])
y_true = tf.placeholder(tf.float32, shape=[None, num_classes])
y_true_cls = tf.placeholder(tf.int64, shape=[None])

在上面的代码中，None 表示一次输入多少数据，这一般跟样本的数量和每个批次的数据量 batch_size 有关。

Variable 变量

变量是模型的参数，这些参数在模型的计算过程中会被逐步的优化，以使得模型在训练集上有更好的表现。例如在本文的线性模型中，参数有两个：

$$

y = Wx+b

$$

其中的 $W$ 就是模型的权重，$b$ 就是模型的偏移量，这两个变量会在计算过程中被优化。

weights = tf.Variable(tf.zeros([img_size_flat, num_classes]))
biases = tf.Variable(tf.zeros([num_classes]))

需要注意的是，输入的是 784 维的向量，输出的标签是 10 维的向量，$W$ 是输入到输出的映射，因此它的维度为 [784, 10]，而 $b$ 是偏移量，因此维度为 [10]。我们首先将它们初始化为 0，TensorFlow 会自动进行调整。

Model 模型

上面给出了整个模型的公式，因此实现起来非常简单：

logits = tf.matmul(x, weights) + biases

tf.matmul 表示矩阵乘法。上式返回的结果是一个 [None, num_classes] 的矩阵。 logits 是 TensorFlow 常用术语，这里不去考虑。这个结果离真实的分类还有一定的距离，我们需要使用一个 softmax 来对其归一化，以使得它的和为 1。Softmax 函数类似于计算了每一个维度的概率，其中最大的那个概率即对应它的类别。

y_pred = tf.nn.softmax(logits)
y_pred_cls = tf.argmax(y_pred, axis=1)

y_pred_cls 的计算与之前使用 Numpy 计算类别的方式相似，说明 TensorFlow 的许多操作都和 Numpy 是相通的。不同的是 Numpy 的计算是实时的，而 TensorFlow 只有在运行计算图时才会返回结果。

Cost Function 代价函数

代价函数用来评估模型的错误率。模型的损失越高，说明离真实结果的偏差越大，需要尽可能的减小这个损失，以使得模型尽可能的准确。

代价函数存在多种的形式，比较常用的是平方误差和交叉熵。在这里使用更常用的交叉熵，有关交叉熵的细节请另外查阅资料。

cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y_true)
cost = tf.reduce_mean(cross_entropy)    # 交叉熵平均值即代价

需要注意的是，传入的是计算 softmx 之前的 logits，而非 y_pred，这其中的原因是 softmax 的计算十分耗时，处于速度的考虑，TensorFlow 在实现中直接使用 logits，然后在 tf.nn.softmax_cross_entropy_with_logits 内部使用更高效的方法计算交叉熵，具体的原理仍然是一样的。

在计算完总的交叉熵是，其均值即为代价。

Optimization 优化

现在我们已经有了代价函数的度量方法，接下来就需要使用优化器来优化这个代价函数。常用的做法是使用提督下降将来传播误差，然后在更新权重。TensorFlow 提供了多种计算梯度的 优化器，如果在一个优化器的效果不明显时，可以尝试使用另一个优化器。这里使用基本的 GradientDescentOptimizer，学习率为 0.5，学习率越低收敛越快，学习率过高可能会导致不收敛。

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.5).minimize(cost)

性能度量

一般来说，以上的代码就已经完成了模型的构建。但是为了评估模型的性能，还需要一些其他的代码。最直观的是模型的准确率。

correct_prediction = tf.equal(y_pred_cls, y_true_cls)  # 判断相等的元素
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))  # 计算准确率

运行TensorFlow计算图

创建Session以及变量初始化

TensorFlow 计算图运行在一个 session 中，计算之前需要先创建这个 session，并初始化其中的一些变量（w 和 b），TensorFlow 使用 session.run() 来运行计算图。

session = tf.Session()   # 创建session
session.run(tf.global_variables_initializer())   # 变量初始化

执行优化的帮助函数

在训练集中有 55000 张图片，如果在每一轮迭代过程中都使用全部的图像作为输入的话，计算时间太长。因此使用小批量的随即梯度下降方法来执行每一次优化。梯度下降过程会自动的优化权重 $W$ 和偏置 $b$。

batch_size = 100   # 每一轮的数据量
def optimize(num_iterations):   
    for i in range(num_iterations):   # 迭代轮数
        # TensorFlow自己实现了取MNIST下一个批次的操作，这里直接使用，不必深究
        x_batch, y_true_batch = data.train.next_batch(batch_size)

        # 把这批数据放在要喂入模型的dict里面
        feed_dict_train = {x: x_batch, y_true: y_true_batch}

        # 运行优化器，喂入数据
        session.run(optimizer, feed_dict=feed_dict_train)

评估性能的帮助函数

现在需要评估模型在测试数据上的性能，需要将测试数据整个喂入模型中：

feed_dict_test = {x: data.test.images,
                  y_true: data.test.labels,
                  y_true_cls: data.test.cls}

输出准确率：

def print_accuracy():
    # 运行accuracy来计算acc
    acc = session.run(accuracy, feed_dict=feed_dict_test)
    print("测试集准确率: {0:.1%}".format(acc))   # 保留1位小数

输出混淆矩阵：

def print_confusion_matrix():
    cls_true = data.test.cls   # 真实类别
    # 运行y_pred_cls计算出的真实类别
    cls_pred = session.run(y_pred_cls, feed_dict=feed_dict_test)

    # 使用scikit-learn的confusion_matrix来计算混淆矩阵
    cm = confusion_matrix(y_true=cls_true, y_pred=cls_pred)

    # 打印混淆矩阵
    print(cm)

    # 将混淆矩阵输出为图像
    plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)

    # 调整图像
    plt.tight_layout()
    plt.colorbar()
    tick_marks = np.arange(num_classes)
    plt.xticks(tick_marks, range(num_classes))
    plt.yticks(tick_marks, range(num_classes))
    plt.xlabel('Predicted')
    plt.ylabel('True')

输出部分错误样例

def plot_example_errors():
    # 运行计算图，得到争取情况和预测结果
    correct, cls_pred = session.run([correct_prediction, y_pred_cls],
                                    feed_dict=feed_dict_test)
    # 计算错误情况
    incorrect = (correct == False)
    images = data.test.images[incorrect]
    cls_pred = cls_pred[incorrect]
    cls_true = data.test.cls[incorrect]

    # 随机挑选9个
    indices = np.arange(len(images))
    np.random.shuffle(indices)
    indices = indices[:9]

    plot_images(images[indices], cls_true[indices], cls_pred[indices])

优化前的性能

准确率：

print_accuracy()

输出：

测试集准确率: 9.8%

在未进行训练是，测试集的准确率为 9.8%，因为 $W$ 和 $b$ 全都被初始化为 0，因此所有的预测结果均为 0。

部分错误样例：

plot_example_errors()

这也证明了上面的说法。

一轮迭代后的性能

optimize(num_iterations=1)
print_accuracy()

测试集准确率: 26.7%

尝试一轮迭代后，准确率提升到了 26.7%。

plot_example_errors()

预测结果也有了一定的变化。

最重要的是各个类别的权重情况：

plot_weights()

在上图中，蓝色部分的权重为负数，红色部分的权重为正数，这些权重可以看作图片的过滤器。可以看到，模型的权重偏向于数字所在的位置。对于 0 和 1，由于数字比较简单，模型可以很好的识别，而对于其他的数字，模型在识别上有一定的难度，需要更多次的优化。

10轮迭代后的性能

optimize(num_iterations=9)   # 之前已经做过一轮
print_accuracy()

测试集准确率: 81.0%

测试集的准确率达到了 81.0%，这是一个非常大的进步。再看看部分的错误样例：

plot_example_errors()

可以发现，图片的预测结果和真实类别存在一定的相似之处。例如 4 和 9，5 和 3，模型暂时还无法作出准确的判断。

接下来再看看权重的情况：

plot_weights()

我们发现，图像的红色区域变得更加明显，它们是类别中所有图像的共有属性。对于部分类别（如 4，5，9）还存在一定的提升空间。

100 轮迭代后的性能

optimize(num_iterations=990)   # 之前已经做过10轮
print_accuracy()

测试集准确率: 91.9%

这个结果已经非常好了。再来看看一些分错的样本：

多尝试几次就会发现，部分的样本是在太过抽象，4 和 6 有时候甚至连人都很难分清。因而这样的一个结果应该合情合理。

再来看一下权重：

由于训练集的变化多端，为了覆盖多种变化，各类的权重变得有些宽泛，但是焦点仍然在类别中图像的共同之处。

我们再来看看混淆矩阵的情况：

print_confusion_matrix()

[[ 957    0    1    2    0    4   12    2    2    0]
 [   0 1108    2    2    0    3    4    1   15    0]
 [   6    7  922   20    5    3   19   11   32    7]
 [   3    0   16  938    0   21    4    9   13    6]
 [   2    1    6    3  897    1   22    2   10   38]
 [   9    3    6   50    7  762   19    5   24    7]
 [   9    3    3    2    6   12  921    1    1    0]
 [   2   12   24   10    6    2    0  933    2   37]
 [   7    6    7   38    9   32   16    8  844    7]
 [  10    6    1   13   34    8    1   14    9  913]]

对角线上为分类正确的情况，其他为一个类分成其他类的情况。将这个矩阵图像化：

可以发现，大部分的分类均正确，少部分的淡蓝色区域说明存在一定的误分类情况。

在运行完整个计算图后，需要将它关闭，否则将一直占用资源:

session.close()

转载请注明出处：基于特定语料库的 TF-IDF 关键词提取实现。

GitHub代码：GitHub - gaussic/tf-idf-keyword

分词

对于中文文本的关键词提取，需要先进行分词操作。

去除其中的一些英文和数字，只保留中文：

import jieba
import re

def segment(sentence, cut_all=False):
    sentence = sentence.replace('\n', '').replace('\u3000', '').replace('\u00A0', '')
    sentence = ' '.join(jieba.cut(sentence, cut_all=cut_all))
    return re.sub('[a-zA-Z0-9.。:：,，)）(（！!??”“\"]', '', sentence).split()

语料库逆文档频率统计

高效文件读取

读取指定目录下的所有文本文件，使用结巴分词器进行分词。本文的 IDF 提取基于 THUCNews 清华新闻语料库的大约 80 万篇文本。

基于 python 生成器的实现，以下代码可以实现高效地读取文本并分词：

class MyDocuments(object):    # memory efficient data streaming
    def __init__(self, dirname):
        self.dirname = dirname
        if not os.path.isdir(dirname):
            print(dirname, '- not a directory!')
            sys.exit()

    def __iter__(self):
        for dirfile in os.walk(self.dirname):
            for fname in dirfile[2]:
                text = open(os.path.join(dirfile[0], fname),
                            'r', encoding='utf-8', errors='ignore').read()
                yield segment(text)   # time consuming

词的逆文档频数统计

统计每一个词出现在多少篇文档中：

documents = MyDocuments(inputdir)

ignored = {'', ' ', '', '。', '：', '，', '）', '（', '！', '?', '”', '“'}
id_freq = {}
i = 0
for doc in documents:
    doc = set(x for x in doc if x not in ignored)
    for x in doc:
        id_freq[x] = id_freq.get(x, 0) + 1
    if i % 1000 == 0:
        print('Documents processed: ', i, ', time: ',
            datetime.datetime.now())
    i += 1

计算逆文档频率并存储

with open(outputfile, 'w', encoding='utf-8') as f:
    for key, value in id_freq.items():
        f.write(key + ' ' + str(math.log(i / value, 2)) + '\n')

逆文档频率 (IDF) 计算公式

$$

IDF(w) = log_2(\frac{D}{D_w})

$$

其中，$D$ 表示总文档数，$D_w$ 表示词 w 出现在多少篇文档中。

运行示例：

Building prefix dict from the default dictionary ...
Loading model from cache /var/folders/65/1sj9q72d15gg80vt9c70v9d80000gn/T/jieba.cache
Loading model cost 0.943 seconds.
Prefix dict has been built succesfully.
Documents processed:  0 , time:  2017-08-08 17:11:15.906739
Documents processed:  1000 , time:  2017-08-08 17:11:18.857246
Documents processed:  2000 , time:  2017-08-08 17:11:21.762615
Documents processed:  3000 , time:  2017-08-08 17:11:24.534753
Documents processed:  4000 , time:  2017-08-08 17:11:27.235600
Documents processed:  5000 , time:  2017-08-08 17:11:29.974688
Documents processed:  6000 , time:  2017-08-08 17:11:32.818768
Documents processed:  7000 , time:  2017-08-08 17:11:35.797916
Documents processed:  8000 , time:  2017-08-08 17:11:39.232018

可见，处理 1000 篇文档用时大约 3 秒，80 万篇大约用时 40 分钟。

TF-IDF 关键词提取

借鉴了结巴分词的处理思路，使用 IDFLoader 载入 IDF 文件：

class IDFLoader(object):
    def __init__(self, idf_path):
        self.idf_path = idf_path
        self.idf_freq = {}     # idf
        self.mean_idf = 0.0    # 均值
        self.load_idf()

    def load_idf(self):       # 从文件中载入idf
        cnt = 0
        with open(self.idf_path, 'r', encoding='utf-8') as f:
            for line in f:
                try:
                    word, freq = line.strip().split(' ')
                    cnt += 1
                except Exception as e:
                    pass
                self.idf_freq[word] = float(freq)

        print('Vocabularies loaded: %d' % cnt)
        self.mean_idf = sum(self.idf_freq.values()) / cnt

使用 TF-IDF 抽取关键词。TF-IDF 计算公式：

$$

TFIDF(w) = TF(w) * IDF(w)

$$

class TFIDF(object):
    def __init__(self, idf_path):
        self.idf_loader = IDFLoader(idf_path)
        self.idf_freq = self.idf_loader.idf_freq
        self.mean_idf = self.idf_loader.mean_idf

    def extract_keywords(self, sentence, topK=20):    # 提取关键词
        # 过滤
        seg_list = segment(sentence)

        freq = {}
        for w in seg_list:
            freq[w] = freq.get(w, 0.0) + 1.0
        total = sum(freq.values())

        for k in freq:   # 计算 TF-IDF
            freq[k] *= self.idf_freq.get(k, self.mean_idf) / total

        tags = sorted(freq, key=freq.__getitem__, reverse=True)  # 排序

        if topK:
            return tags[:topK]
        else:
            return tags

使用：

# idffile为idf文件路径, document为待处理文本路径
tdidf = TFIDF(idffile)
sentence = open(document, 'r', encoding='utf-8', errors='ignore').read()
tags = tdidf.extract_keywords(sentence, topK)

原文档：

AMD力推812核服务器处理器反攻英特尔
　　AMD今日正式推出最新的8核心及12核心系列处理器产品，从而正式在服务器领域向英特尔吹起了进攻的号角。
　　AMD的8核和12核服务器处理器都采用了新的45纳米设计，而且也都是由两块处理器die封装在一起构建，其中12核心处理器正是基于此前曝光的Magny-Cours核心，也就是两个6核伊斯坦布尔核心封装在一起，而8核处理器则是由两颗4核处理器die封装在一起构建。
　　新推出的8核和12核处理器将支持全新的G34插槽，可提供更新的I/O技术，另外由于可以支持四条DDR3内存通道因此每颗处理器可以支持多达12条内存插槽。
　　此次新推的8核和12核处理器产品将会隶属于Opteron 6100系列，最低起始主频为1.8GHz，其中8核最低版本型号为Opteron 6124 HE，而该系列最高版本则为主频2.3GHz的12核Opteron 6176 SE。在Opteron 6100系列里，1.8GHz的8核Opteron 6124 HE功耗较低仅为65W，具体的售价则为455美元，折合人民币3100元出头。主频2.3GHz的12核Opteron 6176 SE功耗为105W，售价为1386美元，折合人民币约为9466元。其他产品的规格和价格多介于这两款产品之间。
　　性能方面，AMD Opteron 6100系列比此前的6核伊斯坦布尔处理器要强悍很多，按照AMD方面的说法整数运算性能提升达88%，同时浮点运算性能更是提升了119%之多。Opteron 6000系列服务器平台主要将配备四个或者两个插槽，也就是说入门级系统核心数量为16个，而高阶版系统核心数量可达48个。
　　与AMD相对的是英特尔也正计划针对多处理器服务器市场推出一款8核心的芯片产品，这款产品也被称为“Nehalem-EX”，这款产品应该也已经离正式上市不远。

示例输出：

核
处理器
服务器
系统核心
封装
系列
插槽
核心
主频
产品
伊斯坦布尔
英特尔
功耗
多处理器
低仅
折合
浮点运算
性能
构建
吹起

官方地址：Deep Learning with PyTorch: A 60 Minute Blitz

感谢作者：Soumith Chintala

转载请说明出处：PyTorch 整理：60 分钟入门

这个教程的目标：

• 更高层次地理解 PyTorch 的 Tensor 库以及神经网络。
• 训练一个小的神经网络模型用于分类图像。

什么是 PyTorch

这是一个基于 Python 的科学计算包，主要针对两类人群：

• 替代 Numpy 以发挥 GPU 的强大能力
• 一个提供最大灵活性和速度的深度学习研究平台

开始

Tensors

Tensors 类似于 numpy 的 ndarray，但是带了一些附加的功能，例如可以使用 GPU 加速计算等等。

构建一个未初始化的 5x3 矩阵：

import torch
x = torch.Tensor(5, 3)
print(x)

1.00000e-28 *
  0.0000  0.2524  0.0000
  0.2524  2.8715  0.0000
  2.9158  0.0000  2.9157
  0.0000  2.9158  0.0000
  0.0003  0.0000  0.0000
[torch.FloatTensor of size 5x3]

构建一个随机初始化的矩阵：

x = torch.rand(5, 3)
print(x)

0.5453  0.4855  0.7236
 0.3199  0.4525  0.4917
 0.6965  0.8742  0.9948
 0.9029  0.1873  0.0018
 0.3080  0.2953  0.4313
[torch.FloatTensor of size 5x3]

获取矩阵维度大小：

print(x.size())

torch.Size([5, 3])

注意：torch.Size 实际上是一个元组，因此它支持相同的操作。

运算操作

运算操作有多种语法，让我们看看加法的例子。

加法：语法 1

y = torch.rand(5, 3)
print(x + y)

1.1177  0.8514  1.1459
 1.1878  0.9249  0.5759
 1.3508  1.4628  1.2833
 1.8678  0.8499  0.2941
 0.9718  1.0785  0.6914
[torch.FloatTensor of size 5x3]

加法：语法 2

print(torch.add(x, y))

1.1177  0.8514  1.1459
 1.1878  0.9249  0.5759
 1.3508  1.4628  1.2833
 1.8678  0.8499  0.2941
 0.9718  1.0785  0.6914
[torch.FloatTensor of size 5x3]

加法：给定一个输出 tensor

result = torch.Tensor(5, 3)
torch.add(x, y, out=result)
print(result)

1.1177  0.8514  1.1459
 1.1878  0.9249  0.5759
 1.3508  1.4628  1.2833
 1.8678  0.8499  0.2941
 0.9718  1.0785  0.6914
[torch.FloatTensor of size 5x3]

加法：就地 (in-place)

# adds x to y
y.add_(x)
print(y)

1.1177  0.8514  1.1459
 1.1878  0.9249  0.5759
 1.3508  1.4628  1.2833
 1.8678  0.8499  0.2941
 0.9718  1.0785  0.6914
[torch.FloatTensor of size 5x3]

注意：任何就地改变一个 tensor 的操作都以 _ 为后缀。例如：x.copy_(y), x.t_()，都会改变 x。

你可以像 numpy 一样使用索引!

print(x[:, 1])

0.4855
 0.4525
 0.8742
 0.1873
 0.2953
[torch.FloatTensor of size 5]

延伸阅读：

100 + Tensor 运算，包括转置、索引、切分、数学运算、线性代数随机数等等，链接：戳这

Numpy 的桥梁

Torch 的 Tensor 和 Numpy 的数组之间的互转简直像一阵清风一样。

Torc h的 Tensor 和 Numpy 的数组会共享它们的底层存储位置，该变其中一个，另外一个也会改变。

将 Torch Tensor 转换为 Numpy 数组

a = torch.ones(5)
print(a)

1
 1
 1
 1
 1
[torch.FloatTensor of size 5]

b = a.numpy()
print(b)

[ 1.  1.  1.  1.  1.]

看看当改变 numpy 数组的值时发生了什么。

a.add_(1)
print(a)
print(b)

2
 2
 2
 2
 2
[torch.FloatTensor of size 5]

[ 2.  2.  2.  2.  2.]

将 Numpy 数组转换为 Torch Tensor

看看更改 Numpy 数组的同时自动地更改了 Torch Tensor

import numpy as np
a = np.ones(5)
b = torch.from_numpy(a)
np.add(a, 1, out=a)
print(a)
print(b)

[ 2.  2.  2.  2.  2.]

 2
 2
 2
 2
 2
[torch.DoubleTensor of size 5]

除了 CharTensor 之外，CPU 上的所有 Tensor 都支持与 Numpy 数组的来回转换。

CUDA Tensors

可以使用 .cuda 函数将 Tensor 转移到 GPU 上。

# let us run this cell only if CUDA is available
if torch.cuda.is_available():
    x = x.cuda()
    y = y.cuda()
    x + y

Autograd: 自动求导

PyTorch 中所有神经网络的中心部分是 autograd 包。我们首先浏览一下它，然后再构建我们的第一个神经网络。

autograd 包为 Tensor 上的所有运算提供了自动求导功能。它是一个由运行定义的框架，即你的反向传播是由你的代码如何运行来决定的，而且每一轮迭代都可能是不同的。

让我们用几个简单的例子来了解几个简单的术语。

Variable 变量

autograd.Variable 是这个包的中心类。它包装一个 Tensor，并且支持几乎所有定义在这个 Tensor 上的运算。一旦你完成了你的计算，你可以调用 .backward() 来自动地计算全部的梯度。

你可以通过 .data 属性来访问最原始的 tensor，而梯度则相应地被累计到了 .grad 中。

autograd 的实现中还有一个非常重要的类 - Function。

Variable 和 Function 是相互关联的并且构建了一个非循环图，其中编码了整个的计算历史。每一个变量都有一个 .creator 属性，它引用一个常见 Variable 的 Function（除了用户创建的 Variables - 它们的 creator 是 None ）。

如果你想计算导数，可以在 Variable 上调用 .backward()。如果 Variable 是个标量（一个单元素数据），那么你不用为 backward() 指定任何参数，然而如果它有多个元素，你需要指定一个 grad_output 参数，它是一个匹配尺寸的 tensor。

import torch
from torch.autograd import Variable

创建一个变量：

x = Variable(torch.ones(2, 2), requires_grad=True)
print(x)

Variable containing:
 1  1
 1  1
[torch.FloatTensor of size 2x2]

对变量进行运算：

y = x + 2
print(y)

Variable containing:
 3  3
 3  3
[torch.FloatTensor of size 2x2]

y 是作为一个运算操作的结果而创建的，因而它有一个 creator

print(y.creator)

<torch.autograd._functions.basic_ops.AddConstant object at 0x108ada4a8>

在 y 上做更多的运算：

z = y * y * 3
out = z.mean()

print(z, out)

Variable containing:
 27  27
 27  27
[torch.FloatTensor of size 2x2]
 Variable containing:
 27
[torch.FloatTensor of size 1]

Gradients 梯度

让我们使用反向传播 out.backward()，它等同于 out.backward(torch.Tensor([1.0]))。

out.backward()

打印梯度 d(out)/dx：

print(x.grad)

Variable containing:
 4.5000  4.5000
 4.5000  4.5000
[torch.FloatTensor of size 2x2]

你应该会得到一个 4.5 的矩阵。让我们称 out 变量为 o。我们有

$$o = \frac{1}{4}\sum_i z_i$$

$$z_i = 3(x_i+2)^2$$

$$ z*i\bigr\rvert*{x_i=1} = 27 $$

因此，

$$\frac{\partial o}{\partial x_i} = \frac{3}{2}(x_i+2)$$

$$\frac{\partial o}{\partial x*i}\bigr\rvert*{x_i=1} = \frac{9}{2} = 4.5$$

你还可以使用 autograd 做一些疯狂的事情！

x = torch.randn(3)
x = Variable(x, requires_grad=True)

y = x * 2
while y.data.norm() < 1000:
    y = y * 2

print(y)

Variable containing:
 596.2775
-807.4459
-550.6819
[torch.FloatTensor of size 3]

gradients = torch.FloatTensor([0.1, 1.0, 0.0001])
y.backward(gradients)

print(x.grad)

Variable containing:
  102.4000
 1024.0000
    0.1024
[torch.FloatTensor of size 3]

延伸阅读：

Variable 和 Function 的文档：http://pytorch.org/docs/autograd

神经网络

神经网络可以使用 torch.nn 包来构建。

现在你大致了解了 autograd，nn 依赖于 autograd 来定义模型并进行求导。一个 nn.Module 包含多个神经网络层，以及一个 forward(input) 方法来返回 output。

例如，看看以下这个分类数字图像的网络：

它是一个简单的前馈网络。它将输入逐步地喂给多个层，然后给出输出。

一个典型的神经网络训练过程如下：

• 定义一个拥有可学习参数（或权重）的神经网络
• 在输入数据上进行迭代
• 在网络中处理数据
• 计算损失（输出离分类正确有多远）
• 梯度反向传播给网络的参数
• 更新网络的权重，通常使用一个简单的更新规则：weight = weight + learning_rate * gradient

定义网络

import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        # 1 图像输入通道, 6 输出通道, 5x5 正方形卷积核
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # 使用 (2, 2) 窗口最大池化
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        size = x.size()[1:]   # 所有维度，除了批尺寸
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

net = Net()
print(net)

Net (
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear (400 -> 120)
  (fc2): Linear (120 -> 84)
  (fc3): Linear (84 -> 10)
)

你只需要定义 forward 函数，backward 函数（用来计算梯度）是使用 autograd 自动为你定义的。你可以在 forward 中使用任意的 Tensor 运算操作。

模型中可学习的参数是通过 net.parameters() 返回的：

params = list(net.parameters())
print(len(params))
print(params[0].size())  # conv1's .weight

10
torch.Size([6, 1, 5, 5])

forward 的输入是一个 autograd.Variable，输出亦然。

input = Variable(torch.randn(1, 1, 32, 32))
out = net(input)
print(out)

Variable containing:
 0.0455 -0.0445  0.0064 -0.0310  0.0945 -0.0362 -0.1971  0.0555  0.0943  0.1016
[torch.FloatTensor of size 1x10]

将梯度缓冲区置 0，并使用随机的梯度进行反向传播：

net.zero_grad()
out.backward(torch.randn(1, 10))

注意：

torch.nn 仅支持 mini-batch。整个的 torch.nn 包仅支持小批量的数据，而不是一个单独的样本。

例如，nn.Conv2d 应传入一个 4D 的 Tensor，维度为 nSamples x nChannels x Height x Width。

如果你有一个单独的样本，使用 input.unsqueeze(0) 来添加一个伪批维度。

在继续之前，我们先回顾一下迄今为止的所有课程。

回顾：

• torch.Tensor 一个多维数组
• autograd.Variable 包装一个 Tensor 并且记录应用在其上的历史运算操作。拥有与 Tensor 相同的 API，添加了一些像 backward() 的操作。还包括相关 tensor 的梯度。
• nn.Module 神经网络模块。封装参数的方便方式，带有将它们转移到 GPU、导出、载入等的帮助函数。
• nn.Parameter 一种 Variable，当给 Module 赋值时自动注册一个参数。
• autograd.Function 实现一个 autograd 操作的 forward 和 backward 定义。每一个 Variable 操作，创建至少一个 Function 节点，来连接那些创建 Variable 的函数，并且记录其历史。

在这里，我们涵盖了：

• 定义神经网络
• 处理输入并调用 backward

还剩下：

• 计算损失
• 更新网络权重

损失函数

一个损失函数以一个 (output, target) 对为输入，然后计算一个值用以估计输出结果离目标结果多远。

存在多种的 损失函数。一个简单的损失函数：nn.MSELoss，它计算输出与目标的均方误差。

例如：

output = net(input)
target = Variable(torch.arange(1, 11))  # a dummy target, for example
criterion = nn.MSELoss()

loss = criterion(output, target)
print(loss)

Variable containing:
 38.3005
[torch.FloatTensor of size 1]

现在，如果你在反方向跟随 loss，使用它的 .creator 属性，你会看到一个如下所示的计算图：

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
      -> view -> linear -> relu -> linear -> relu -> linear
      -> MSELoss
      -> loss

因此，当我们调用 loss.backward() 时，损失对应的整个图都被求导，并且图中所有的变量都会带有累积了梯度的 .grad 属性。

print(loss.creator)  # MSELoss
print(loss.creator.previous_functions[0][0])  # linear
print(loss.creator.previous_functions[0][0].previous_functions[0][0])  # ReLU

<torch.nn._functions.thnn.auto.MSELoss object at 0x10e0bdd68>
<torch.nn._functions.linear.Linear object at 0x10e0bdba8>
<torch.nn._functions.thnn.auto.Threshold object at 0x10e0bdac8>

反向传播

要进行反向传播，我们只需要调用 loss.backward()。你需要清除现有的梯度，否则梯度将累积到现有梯度。

现在我们将调用 loss.backward()，并看看 conv1 在 backward 之前和之后的梯度变化。

net.zero_grad()   # zeroes the gradient buffers of all parameters

print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)

loss.backward()

print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

conv1.bias.grad before backward
Variable containing:
 0
 0
 0
 0
 0
 0
[torch.FloatTensor of size 6]

conv1.bias.grad after backward
Variable containing:
 0.1392
-0.1155
 0.0247
 0.1121
-0.0559
 0.0363
[torch.FloatTensor of size 6]

现在我们知道怎么使用损失函数了。

延伸阅读

神经网络包包含构建深度神经网络的多个模块和损失函数。一个完整的文档列表 在这里

仅剩的一个要学习的东西：

• 更新网络权重

更新权重

实践中最简单的更新规则是随机梯度下降（SGD）：

weight = weight - learning_rate * gradient

我们可以使用简单的 Python 代码实现：

learning_rate = 0.01
for f in net.parameters():
    f.data.sub_(f.grad.data * learning_rate)

然而，当您使用神经网络时，您希望使用各种不同的更新规则，例如 SGD，Nesterov-SGD，Adam，RMSProp 等等。为了实现这一点，我们构建一个小的包：torch.optim，来实现所有的方法。使用非常简单：

import torch.optim as optim

# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)

# in your training loop:
optimizer.zero_grad()   # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # Does the update

训练一个分类器

在此，你已经知道如何定义神经网络，计算损失以及更新网络权重。

现在你可能会想，

数据怎么办

一般来说，当你处理图像、文本、音频或视频数据时，你可以使用标准的 python 包来将数据载入到 numpy 数组中。然后你可以将这个数组转化为 torch.Tensor。

• 对于图像，诸如 Pillow, OpenCV 这些包很好用。
• 对于音频，可以使用 scipy 和 librosa。
• 对于文本，要么使用原始的 Python 或 Cython 载入方式，要么使用 NLTK 和 SpaCy。

特别的对于 vision，我们创建了一个叫做 torchvision 的包，它有一些常用数据集（Imagenet, CIFAR10, MNIST 等）的数据载入器，以及图像的数据转换器, torchvision.datasets 和 torch.utils.data.DataLoader。

这提供了巨大的便利，避免编写样板代码。

在本教程中，我们使用 CIFAR10 数据集。它有 10 个类别：‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’。CIFAR10 中的图像尺寸在 3x32x32，即 3 通道彩色图像，32x32 像素大小。

训练一个图像分类器

我们将按顺序完成以下步骤：

1. 载入和规范化 CIFAR10 的训练和测试集，使用 torchvision
2. 定义一个卷积神经网络
3. 定义损失函数
4. 在训练集上进行训练
5. 在测试集上测试网络

1. 载入和规范化 CIFAR10

使用 torchvision，载入 CIFAR10 非常简单。

import torch
import torchvision
import torchvision.transforms as transforms

torchvision datasets 的输出时范围在 [0, 1] 的 PILImage 图像。我们将它们转换为规范区间 [-1, 1] 的 Tensor。

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                       download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)

testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=True, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

让我们展示一些训练图像。

import matplotlib.pyplot as plt
import numpy as np

# functions to show image
def imshow(img):
    img = img / 2 + 0.5 # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))

# get some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()

# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

2. 定义一个卷积神经网络

复制在神经网络那一节的神经网络，将其更改为 3 通道图像输入（而不是原始的单通道输入）。

from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()

3. 定义损失函数和优化器

让我们来使用分类交叉熵和带有动量的 SGD

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

4. 训练网络

for epoch in range(10): # loop over the dataset multiple times
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the input
        inputs, labels = data

        # wrap time in Variable
        inputs, labels = Variable(inputs), Variable(labels)

        # zero the parameter gradients
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # print statistics
        running_loss += loss.data[0]
        if i % 2000 == 1999:   # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

[1,  2000] loss: 1.184
[1,  4000] loss: 1.206
[1,  6000] loss: 1.186
[1,  8000] loss: 1.162
[1, 10000] loss: 1.195
[1, 12000] loss: 1.165
[2,  2000] loss: 1.095
[2,  4000] loss: 1.076
[2,  6000] loss: 1.086
[2,  8000] loss: 1.092
[2, 10000] loss: 1.060
[2, 12000] loss: 1.110
[3,  2000] loss: 0.999
[3,  4000] loss: 1.005
[3,  6000] loss: 1.016
[3,  8000] loss: 1.016
[3, 10000] loss: 1.017
[3, 12000] loss: 1.023
[4,  2000] loss: 0.922
[4,  4000] loss: 0.933
[4,  6000] loss: 0.959
[4,  8000] loss: 0.975
[4, 10000] loss: 0.985
[4, 12000] loss: 0.968
[5,  2000] loss: 0.861
[5,  4000] loss: 0.908
[5,  6000] loss: 0.911
[5,  8000] loss: 0.932
[5, 10000] loss: 0.920
[5, 12000] loss: 0.919
[6,  2000] loss: 0.839
[6,  4000] loss: 0.853
[6,  6000] loss: 0.887
[6,  8000] loss: 0.891
[6, 10000] loss: 0.890
[6, 12000] loss: 0.876
[7,  2000] loss: 0.819
[7,  4000] loss: 0.808
[7,  6000] loss: 0.831
[7,  8000] loss: 0.852
[7, 10000] loss: 0.842
[7, 12000] loss: 0.869
[8,  2000] loss: 0.761
[8,  4000] loss: 0.784
[8,  6000] loss: 0.808
[8,  8000] loss: 0.827
[8, 10000] loss: 0.841
[8, 12000] loss: 0.860
[9,  2000] loss: 0.731
[9,  4000] loss: 0.758
[9,  6000] loss: 0.801
[9,  8000] loss: 0.784
[9, 10000] loss: 0.831
[9, 12000] loss: 0.817
[10,  2000] loss: 0.723
[10,  4000] loss: 0.733
[10,  6000] loss: 0.775
[10,  8000] loss: 0.763
[10, 10000] loss: 0.802
[10, 12000] loss: 0.799
Finished Training

5. 在测试数据上测试网络

我们已经在训练集上训练了 10 轮。但是我们需要检查网络是否有学到什么。

我们可以通过检测预测的类别标签，再与真实标签进行对比。如果预测是对的，我们将这个样本加到分类正确的列表中。

Okay，第一步。让我们先展示一些测试数据集中的图像。

dataiter = iter(testloader)
images, labels = dataiter.next()

# print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

再来看一下神经网络认为这些样本是什么。

输出是 10 个类别的能量。一个类别能量越高，网络就更多地认为图像是这个特定的类别。因此，让我们获取最高能量类别的索引。

outputs = net(Variable(images))

_, predicted = torch.max(outputs.data, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j][0]] for j in range(4)))

Predicted:  horse plane horse  frog

结果看起来不错。

让我们再来看看网络在整个数据集上的性能。

correct = 0
total = 0
for data in testloader:
    images, labels = data
    outputs = net(Variable(images))
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()

print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))

Accuracy of the network on the 10000 test images: 63 %

这个结果看起来远比随机抽取要好，随机抽取的概率为 10%。看起来网络确实学到了一些东西。

那么，有哪些类别表现优秀，哪些类别表现不佳呢？

class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
for data in testloader:
    images, labels = data
    outputs = net(Variable(images))
    _, predicted = torch.max(outputs.data, 1)
    c = (predicted == labels).squeeze()
    for i in range(4):
        label = labels[i]
        class_correct[label] += c[i]
        class_total[label] += 1

for i in range(10):
    print('Accuracy of %5s: %2d %%' % (classes[i], 100 * class_correct[i] / class_total[i]))

Accuracy of plane: 59 %
Accuracy of   car: 73 %
Accuracy of  bird: 51 %
Accuracy of   cat: 46 %
Accuracy of  deer: 51 %
Accuracy of   dog: 54 %
Accuracy of  frog: 76 %
Accuracy of horse: 69 %
Accuracy of  ship: 78 %
Accuracy of truck: 72 %

Okay，还有什么要说明的？

如何在 GPU 上面运行这个神经网络？

在GPU上训练

与你如何将 Tensor 转移到 GPU 上类似，你可以将神经网络转移到 GPU 上。这将递归的遍历所有的模块并将它们的参数和缓存转化为 CUDA tensors。

net.cuda()

记住，你还必须在每一步将输入和结果数据传输到 GPU 上：

inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())

为什么我没有注意到相比 CPU 的巨大的加速？因为你的神经网络非常小。

训练：试着增加你的网络宽度（将第一个 nn.Conv2d 增广 2，将第二个 nn.Conv2d 增广 1 - 它们需要相同的数量），看看你的网络提速了多少。

目标达成：

• 理解 PyTorch 的 Tensor 库以及高层次的神经网络
• 训练一个小的神经网络来分类图像

转载请说明出处：PyTorch 整理：60 分钟入门