徐昭春

tmux工具个人目录安装

Sat, 18 Apr 2020 00:00:00 +0000

作为一个合格的后端程序员，一般情况下我们都是登录linux服务器在终端上coding。然而作为一个新入门linux开发的萌新，总是习惯于之前在vscode、pycharm这一类IDE开发，可以轻松的在一个窗口里打开多个文件。如果你还在为此烦恼，那么我将诚挚地向你推荐本文的主角————tmux这一神器。

tmux的优点

最直观来说，有两个优点让你忘而难返：

既支持多标签，也支持窗体内部Panel的分割。具体来说可以打开多个窗口(标签区分)，另外可以一个窗口进行分割，每个小窗口即为一个终端；
提供了一个窗体组随时存储和恢复的功能。

tmux的基本概念

tmux的主要元素分为三层：

session，一组窗口的结合，通常一个session概况同一个任务，session可以有自己的名字方便任务之间的切换
windows，单个可见窗口，windows有自己的编号，类似与item2的Tab
pane，窗格，被划分成小块的窗口。

具体展现图如下：

个人目录下安装

一般来说，我们都喜欢用sudo权限安装软件，一行命令即可。但在远程服务器开发，这种方式想想就好，最好还是在个人目录下操作不至于影响别的用户环境。由于tmux依赖libevent以及ncurses，所以这两个也需要一并安装。

1. 源码下载

命令如下：

wget https://github.com/tmux/tmux/releases/download/2.2/tmux-2.2.tar.gz
wget https://github.com/libevent/libevent/releases/download/release-2.0.22-stable/libevent-2.0.22-stable.tar.gz
wget http://ftp.gnu.org/gnu/ncurses/ncurses-6.0.tar.gz

下载完毕后，解压各压缩包。

2. 各软件的安装

libevent

./configure --prefix=$HOME/.local --disable-shared
make
make install

ncurses

./configure --prefix=$HOME/.local
make
make install

tmux

./configure CFLAGS="-I$HOME/.local/include -I$HOME/.local/include/ncurses" LDFLAGS="-L$HOME/.local/lib -L$HOME/.local/include/ncurses -L$HOME/.local/include" --prefix=$HOME/.local
make
cp tmux $HOME/.local/bin

3. bashrc环境更新

上述过程完成了tmux安装，另外可以将$HOME/.local/bin加入PATH中，方便直接tmux命令启动。

# 在~/.bashrc中加入下面命令
export $PATH="$HOME/.local/bin:$PATH"
# 保存后source环境
source ~/.bashrc

以上过程即为tmux的安装方式。

花式tfrecord读取

Tue, 24 Mar 2020 00:00:00 +0000

最近因为推荐服务项目的需要，我们在尝试实现阿里的BST(behavior sequence transformer)模型用于微博的用户行为序列建模时，给模型输入训练数据遇到了一些问题：1) 训练文件过大不能一次全部读入内存(tf限定了tensor的最大大小为2g); 2) 输入batch需要获取shape，placeholder不能满足要求。几番资料查阅后，最终选择了tfrecord格式用于模型训练。好了背景先介绍到此，开始直击今天的主题吧—————tfrecord的读取/转换。

1. tfrecord格式介绍

tf现有3种方式进行数据读取：

直接加载数据，适合于数据量小的情况
文件读取，例如csv格式读取
tfrecord读取，适合于数据量大的情况

tfrecord数据文件是一种将特征数据与标签统一存储的二进制文件，能够更好的利用内存，可以tf中快速复制、移动、读取、存储。tfrecord以字典的方式一次写一个样本。这样在写入tfrecord文件时，将输入$x_i$与标签$y$一起存储时，将$x_i$和$y$均看作feature，后续读取时按字典以key的方式得到特征和标签。

2. tfrecord生成

这里，我这边一条样本包含如下元素：

label，样本标签
steps, 样本的序列长度
types, 样本序列中各step的action_type
embedding, 样本序列各step的embedding向量

假设拿到上述各元素列表，将其转换为tfrecord，具体实现方式如下：

import collections
import tensorflow as tf

def make_tfrecord(labels, steps, types, embeddings, tfpath):
    """
    labels, label数组，shape=(n,)
    steps, step长度数组，shape=(n,)
    types, action_type数组，shape=(n, max_len)
    embeddings, embedding数组，shape=(n, max_len, hidden_size)
    """

    writer = tf.python_io.TFRecordWriter(out_path)

    for i in range(len(labels)):
        feature_ = collections.OrderedDict()
        feature_["label"] = tf.train.Feature(int64_list=tf.train.Int64List(value=[labels[i]]))
        feature_["steps"] = tf.train.Feature(int64_list=tf.train.Int64List(value=[steps[i]]))
        feature_["types"] = tf.train.Feature(int64_list=tf.train.Int64List(value=types[i].tolist()))
        feature_["embedding"] = tf.train.Feature(float_list=tf.train.FloatList(value=embedding[i].reshape(-1).tolist()))

        tf_example = tf.train.Example(features=tf.train.Features(feature=feature_))
        writer.write(tf_example.SerializeToString())
    
    writer.close()

3. tfrecord读取

在读取tfrecord时，tf提供了很多方便的API供开发者使用，读取时方式比较多。

1. 使用tf.data.TFRecordDataset

需要实现一个parse_function，解析每一个example

def parse_funciton(example):
    name_to_features = {
        "label": tf.FixedLenFeature(shape=(), dtype=tf.int64),
        "steps": tf.FixedLenFeature(shape=(), dtype=tf.int64),
        "types": tf.FixedLenFeature(shape=(max_len,), dtype=tf.int64),
        "embedding": tf.FixedLenFeature(shape=(max_len, hidden_size))
    }
    parsed_example = tf.parse_single_example(example, name_to_feature)

    return parsed_example

def get_features(tfpath, num_epoch, batch_size, shuffle=False):
    """
    tfpath, tfrecord文件路径
    num_epoch, 读取tfrecord重复次数，对应于训练的epoch数
    batch_size, 每次返回的样本数，对应于训练的batch大小
    shuffle, 是否需要打散
    """

    dataset = tf.data.TFRecordDataset([tfpath]).map(parse_function)
    if shuffle:
        dataset = dataset.shuffle(128*batch_size)   # 在128*batch_size大小的缓存中进行打散
    dataset = dataset.repeat(num_epoch)
    dataset = dataset.batch(batch_size).prefech(1)  # 预先读取一个batch大小

    return dataset

2. 使用tf.data.TFRecordDataset

使用同上API的另一种方式

def read_tfrecord(filepath, batch_size, num_epochs, is_training=True):
    """
    tfrecord样本读取
    """ 
    name_to_features = {
        "label" : tf.FixedLenFeature(shape=(), dtype=tf.int64),
        "steps" : tf.FixedLenFeature(shape=(), dtype=tf.int64),
        "types" : tf.FixedLenFeature(shape=(max_len,), dtype=tf.int64),
        "embedding" : tf.FixedLenFeature(shape=(max_len, hidden_units), dtype=tf.float32)
    }

    def _decode_record(record, name_to_features):
        example = tf.parse_single_example(record, name_to_features)
        example["label"] = tf.cast(example["label"], tf.int64)
        example["steps"] = tf.cast(example["steps"], tf.int64)
        example["types"] = tf.cast(example["types"], tf.int64)
        example["embedding"] = tf.cast(example["embedding"], tf.float32)
        return example

    data = tf.data.TFRecordDataset(filepath)

    if is_training:
        data = data.shuffle(buffer_size=50000)
        data = data.repeat(num_epochs)

    data = data.apply(
        tf.contrib.data.map_and_batch(
            lambda record:_decode_record(record, name_to_features),
            batch_size=batch_size
        )
    )

    return data

3. 使用tf.train.string_input_producer

相对来说稍繁琐些，直接贴代码了

def read_and_decode(filename_queue):
    reader = tf.TFRecordReader()
    _, serialized_example = reader.read(filename_queue)
 
    name_to_features = {
        "label":tf.FixedLenFeature(shape=(), dtype=tf.int64),
        "steps":tf.FixedLenFeature(shape=(), dtype=tf.int64),
        "types":tf.FixedLenFeature(shape=(max_len,), dtype=tf.int64),
        "embedding":tf.FixedLenFeature(shape=(max_len, hidden_size), dtype=tf.float32)
    }

    parsed_example = tf.parse_single_example(serialized_example, name_to_features)
    return parsed_example

def read_tfrecord(tfpath, num_epochs):
    filename_queue = tf.train.string_input_producer([tfpath], num_epochs=num_epochs, shuffle=True)
    parsed_example = read_and_decode(filename_queue)

    min_after_dequeue = 10000
    capacity = min_after_dequeue + 3 * pm.batch_size
    parsed_example_batch = tf.train.shuffle_batch(
        parsed_example, 
        batch_size=pm.batch_size, 
        capacity=capacity,
        min_after_dequeue=min_after_dequeue
    )

    return parsed_example_batch

4. session中batch读取

在前面得到batch后，还需要一些其它步骤将数据打印出来。这里以get_batch为例读取数据

features = get_batch(tfpath, 1, 256)
iter = tf.data.Iterator.from_structure(features.output_types, features.output_shapes)
batch = iter.get_next()
labels, steps, types, embeddings = batch["label"], batch["steps"], batch["types"], batch["embedding"]
init_op = iter.make_initializer(features)

with tf.Session as sess:
    sess.run(tf.global_variables_initializer())
    sess.run(init_op)
    batch_steps = sess.run(steps)

    print(batch_steps.shape)

至此，完成tfrecord的生成和读取，谢谢阅读！

word2vec理解

Thu, 03 Oct 2019 00:00:00 +0000

word2vec是google于2013年推出的一个nlp工具，它能够训练得到每个词的稠密向量。该向量可以用于度量词与词之间的相似性、关联性。word2vec包含两种模型，分别是CBOW(continuous bag of words)和Skip-Gram；两种训练方式，分别是hierachical softmax和negrative sampling。针对word2vec，本文将按以下几点做介绍(由于纯粹是个人记录知识点，有些没表述清楚的地方还望抱歉)：

word2vec概述
CBOW模型
Skip-Gram模型
hierachical softmax训练方法
negative sampling训练方法

word2vec概述

文本中如何用一个向量去表示一个单词，早期最简单直接的方式是使用one-hot representation的方式，对每个单词构建一个与词典大小一致的向量，其中为1处的索引表示该单词的位置。这种方式，一方面词向量的长度与词典大小有关，存储空间过于冗余；另一方面向量之间的运算结果没有任何意义。

Distributed representation可以解决one-hot representation的上述问题。它的思路是通过训练，将词映射成一个稠密向量。利用这些训练得到的词向量，我们可以较容易的分析词之间的关系，比如一个有趣的结果：

$\vec{King} - \vec{Man} + \vec{Women} = \vec{Queen}$

word2vec的网络结构相比于它的前辈NNLM(neural network language model)比较简单。NNLM网络结构如下图所示：

该模型可以拆解成两部分理解：

线性的Embedding层。将输入的N-1个one-hot词向量通过大小为(D,V)的矩阵C映射为N-1个分布式的词向量，D为Embedding大小，V为词典大小。
简单的前向网络。包含tanh隐藏层和softmax输出层.

word2vec相比于NNLM做了如下改造：

去除了NNLM的tanh隐藏层，直接由embedding层连接到softmax层；
忽略上下文环境的序列信息：输入的所有词向量汇总到一个Embedding layer；
将中心词的下文纳入上下文环境。

CBOW模型

CBOW模型是word2vec算法的第一个模型，其网络结果如下图：

从数学上看，CBOW模型等价于一个词袋模型的向量乘以一个Embedding矩阵，从而得到一个连续的embedding向量。其本质是由中心词的上下窗口2c个词的特征向量去估计中心词，所以CBOW模型的训练输入是某个词的上下相关词对应的词向量，输出是这个词的词向量。

Skip-Gram模型

与CBOW模型相反，Skip-Gram模型是用中心词去估计上下文窗口2c个词，其网络结果如下图：

hierachical softmax训练方法

由于词典大小很大，在最后的softmax层通常会有大量的计算。为了避免计算所有词的softmax概率，word2vec采用了霍夫曼树来替代隐藏层到softmax层的映射。词典的霍夫曼树构建，与一般的霍夫曼树构建一样，只不过叶子节点的权重为叶节点词的频率。

有了霍夫曼树，在计算softmax概率计算时，我们只需要沿着树形结构走即可，如下图所示，我们可以沿着根节点导到叶子节点词w2。

在延霍夫曼树到达叶子节点的过程中，这里采用了二元逻辑回归的方法，如果是左子树则为负类(0)，沿着右子树则是正类(1)，概率估计公式为sigmoid函数，即 $P(+)=\frac{1}{1+e^{-x^T\theta}}$ 其中$x$为内部节点的向量，$\theta$是我们需要训练的模型参数，训练目标是我们希望路径节点的概率乘积最大。

negative sampling训练方法

尽管hierachical softmax相比与原始的softmax在计算效率上有较大改进，但是在面对生僻词时，在霍夫曼树的路径很长，导致模型训练较慢，所以negative sampling训练方法摒弃了霍夫曼树。

假设中心词w，上下文窗口共2c个词，记为context(w)。这里中心词w与context(w)构成一个正例。既然是负采样，这里我们将采样得到neg个与w不同的中心词，如此得到了1+neg个样本。这个过程引出了两个问题：

如何进行负采样？
针对1+neg个样本如何训练？

负采样方法

如果词汇表的大小为𝑉,那么我们就将一段长度为1的线段分成𝑉份，每份对应词汇表中的一个词。当然每个词对应的线段长度是不一样的，高频词对应的线段长，低频词对应的线段短。每个词𝑤的线段长度由下式决定： $len(w) = \frac{count(w)^{\frac{3}{4}}}{\sum{count(u)^{\frac{3}{4}}}}$ 此外，在采样前我们将这段长度为1的线段划分为M等分，这里M»V,保证每个词对应的线段都会划分成对应的小块。而M份中的每一份都会落在某一个词对应的线段上。在采样的时候，我们只需要从𝑀个位置中采样出𝑛𝑒𝑔个位置就行，此时采样到的每一个位置对应到的线段所属的词就是我们的负例词。

参考引用

word2vec原理(一) CBOW与Skip-Gram模型基础

word2vec原理(二) 基于Hierarchical Softmax的模型

word2vec原理(三) 基于Negative Sampling的模型

Word2Vec详解

VGGNet介绍

Mon, 23 Jul 2018 00:00:00 +0000

网络结构

这里主要是熟悉下VGGNet的网络结构。在网上搜索关于VGG网络的信息，最终在知乎上搜到了一个对这个网络结果容易理解的文章，这里简单介绍下该网络的结构，加强自己对VGG网络结构的理解。

首先说明下，VGG是牛津大学计算机视觉组(Visual Geometry Group)的缩写。该网络是VGG与Deep Mind公司研究院一起研发的深度卷积神经网络。该网络探索了卷积神经网络的深度与其性能的关系，通过反复堆叠3*3的小型卷积核，和2*2的最大池化层，成功构建了16~19层的卷积网络，取得了在ILSVRC2014中分类项目第2名和定位项目第1名。

这里介绍下VGG16的网络结构。VGGNet拥有5段卷积，每一段内有2~3个卷积层，段尾连接最大池化层用于缩小图片尺寸。其中，卷积层使用3*3的卷积核，步长为1，padding参数为SAME；最大池化层使用2*2的kernel size，步长为2。

上图中，卷积层*2，表示该段中包含两个卷积层。网络的输入是224*224*3，在卷积过程中，如上说明不改变尺寸大小，仅在max pooling处缩小图片尺寸一半。5段卷积层，各段各包含2, 2, 3, 3, 3个卷积层；各段各输出64, 128, 256, 512, 512个通道；各段输出图片大小分别为112*112，56*56，28*28，14*14，7*7；加上后面的3个全连接层，共16层。

从上面的说明来看，虽然网络达16层，但网络结构并不复杂。

结构解读

基本参数

共有A、A-LRN、B、C、D、E6个网络，其中的D、E就是我们常说的VGGNet-16和VGGNet-19；

全部使用3*3的卷积核以及2*2的max pooling；

采用Relu作为激活函数

使用3*3卷积核原因

多层串联小卷积核，其感受野效果相当于大卷积核，但所包含的参数两更少。例如两个3*3的卷积核串联，效果相当于一个5*5的卷积核，三个3*3的卷积核，效果相当于一个7*7的卷积核，但参数量减少近一半。

训练方式

优化方法为SGD+momentum
动量：0.9
批数：256
权值衰减：5*pow(10, -4)
前两个全连接层使用dropout，keep_prob=0.5

AlexNet介绍

Sun, 22 Jul 2018 00:00:00 +0000

1、网络结构
2、训练技巧
3、代码说明

参考文档：https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf

网络结构

alexnet总共有8层，其中前5层为convolution layer，后3层为full connected layer。

卷积层

conv1的输入图像为227*227*3，使用了96个卷积核，size为(96, 11, 11, 3)，卷积核沿x轴，y轴方向移动，步长为4；卷积后输出大小为55*55*96(其中55=227-11/4+1)，然后使用LRN(Local Response Normalized)归一化，再进行pool_size=(3, 3)，stride=2的max-pooling，最后使用relu激活函数，输出为27*27*96；
conv2的输入大小为两个27*27*48(因为使用了两个GPU)，使用256个卷积核(单个gpu为128个，size为(128, 5, 5, 48))，卷积前做(2, 2)的padding，stride为1，产生27*27*256的输出，之后进行LRN处理，再进行pool_size=(3, 3)和stride=2的max-pooling，使用relu激活后，输出为13*13*256；
conv3, 4都没有LRN和pooling，conv5只有pooling，其中conv3使用了384个卷积核(384*3*3*256)，padding为(1, 1)，stride=1，输出为13*13*384；conv4如conv3，最终输出仍为13*13*384；
conv5的输入数据，为conv4输出的2组13*13*192，首先padding(1，1)，然后每组的卷积核为(128*\3*3*192)，stride=1，所以每组的输出为13*13*128。卷积之后使用relu激活，再进行kernel_size=(3, 3)，stride=2的max_pooling，如此(13-3)/2+1=6，即pooling结束后，各组大小为6*6*128。

全连接层

fc6输出的神经元个数为4096，所以该全连接层的weights大小是(6*6*256, 4096)，激活函数为relu，并使用dropout后输出到下一层；
fc7输出的神经元个数为4096，所以该全连接层的weights大小是(4096，4096)，同样激活函数为relu，并使用dropout后输出；
fc8是最后的全连接层，由于应用于imagenet，该数据集共1000个类别，所以该层的weights大小是(4096，1000)。

alexnet网络结构图

训练技巧

alexnet作为首次应用神经网络于imagenet竞赛中，提出了一系列改进神经网络效果的方法。

使用非线性激活函数Relu

以往使用饱和的tanh或sigmoid激活函数时，在使用梯度下降方法训练容易造成梯度消失问题，降低训练速度；使用非饱和的Relu则可以避免这个问题；
使用多GPU并行训练
对Relu激活后的输出，使用局部响应标准化(LRN)

其中，使用了同一(x, y)下相邻通道的a进行归一化。
使用了重叠池化，即步长小于池化kernel大小时，同一像素点参与了多次pooling。
使用随机失活dropout，有利于减少过拟合。

代码实现

这里贴一个使用tflearn实现的alexnet实例，主要用于回顾前面逐层介绍的网络结果。

from __future__ import division, print_function, absolute_import

import tflearn
from tflearn.layers.core import input_data, dropout, fully_connected
from tflearn.layers.conv import conv_2d, max_pool_2d
from tflearn.layers.normalization import local_response_normalization
from tflearn.layers.estimator import regression

import tflearn.datasets.oxflower17 as oxflower17
X, Y = oxflower17.load_data(one_hot=True, resize_pics=(227, 227))

# Building 'AlexNet'
network = input_data(shape=[None, 227, 227, 3])
network = conv_2d(network, 96, 11, strides=4, activation='relu')
network = max_pool_2d(network, 3, strides=2)
network = local_response_normalization(network)
network = conv_2d(network, 256, 5, activation='relu')
network = max_pool_2d(network, 3, strides=2)
network = local_response_normalization(network)
network = conv_2d(network, 384, 3, activation='relu')
network = conv_2d(network, 384, 3, activation='relu')
network = conv_2d(network, 256, 3, activation='relu')
network = max_pool_2d(network, 3, strides=2)
network = local_response_normalization(network)
network = fully_connected(network, 4096, activation='relu')
network = dropout(network, 0.5)
network = fully_connected(network, 4096, activation='relu')
network = dropout(network, 0.5)
network = fully_connected(network, 1000, activation='softmax')
network = regression(network, optimizer='momentum',
                     loss='categorical_crossentropy',
                     learning_rate=0.001)

# Training
model = tflearn.DNN(network, checkpoint_path='model_alexnet',
                    max_checkpoints=1, tensorboard_verbose=2)
model.fit(X, Y, n_epoch=1000, validation_set=0.1, shuffle=True,
          show_metric=True, batch_size=64, snapshot_step=200,
          snapshot_epoch=False, run_id='alexnet_oxflowers17')

使用 TensorFlow 实现神经网络

Sun, 20 Nov 2016 00:00:00 +0000

介绍

　　一直关注 数据科学 、 机器学习 的同学，一定会经常看到或听到关于 深度学习 和 神经网络 相关信息。如果你对 深度学习 感兴趣，但却还没有实际动手操作过，你可以从这里得到实践。

　　在本文中，我将介绍 TensorFlow , 帮你了解 神经网络 的实际作用，并使用 TensorFlow 来解决现实生活中的问题。读这篇文章前，需要知道 神经网络 的基础知识和一些熟悉编程理念，文章中的代码是使用 Pyhton 编写的，所以还需要了解一些 Python 的基本语法，才能更有利对于文章的理解。

什么时候用神经网络？

　　神经网络 已经在相当一段时间成为机器学习中的焦点。对于 神经网络 和 深度学习 上这里有更详细的解释点击阅读。其 “更深” 的功能在许多领域都有取得巨大的突破，如图像识别，语音和自然语言处理等。

　　主要的问题在于如何用好 神经网络 ？现在，每天都会有许多新发现，这个领域就像一个金矿，为了成为这个 “淘金热” 的一部分，必须记住几件事：

首先，神经网络 需要有明确和翔实的数据（主要是大数据）训练，试着想象 神经网络 作为一个孩子，它一开始会观察它父母走路，然后它试图自己走，每一步就像学习执行一个特定的任务。它可能会失败几次，但经过几次失败的尝试，它将会如何走路。所以需要为孩子提供更多的机会，如果不让它走，它可能永远不会学习如何走路。
一些人会利用 神经网络 解决复杂的问题，如图像处理， 神经网络 属于一类代表学习的算法，这些算法可以把复杂的问题分解为简单的形式，使他们成为可以理解的（或 “可表示”），就像吞咽食物之前的咀嚼，让我们更容易吸收和消化。这个分解的过程如果使用传统的算法来实现也可以，但是实现过程将会很困难。
选择适当类型的 神经网络 ，来解决问题， 每个问题的复杂情况都不一样，所以数据决定你解决问题的方式。例如，如果问题是序列生成的问题，递归神经网络 更合适。如果它是图像相关的问题，想更好地解决可以采取 卷积神经网络。
最后最重要的就是 硬件 要求了，硬件是运行 神经网络 模型的关键。 神经网被 “发现” 很久以前，他们在近年来得到推崇的主要的原因就是计算资源更好，能更大发挥它的光芒，如果你想使用 神经网络 解决这些现实生活中的问题，那么你得准备购买一些高端的硬件了😆！

通常神经网络解决的问题

　　神经网络是一种特殊类型的机器学习（ML）算法。因此，作为每个 ML 算法都遵循数据预处理、模型建立和模型评估的工作流流程。为了简明起见，下面列出了如何处理 神经网络 问题的 TODO 列表。

检查它是否为神经网络，把它看成一个传统的算法问题
做一个调查，哪个神经网络框架最适合解决这个问题
定义神经网络框架，通过它选择对应的编程语言和库
将数据转换为正确的格式并分批分割
根据您的需要预处理数据
增强数据以增加大小并制作更好的训练模型
批次供给到神经网络
训练和监测，培训和验证数据集的变化
测试你的模型，并保存以备将来使用

　　本文将专注于图像数据，我们从 TensorFlow 入手。

了解图像数据和主流的库来解决问题

　　图像大多排列为 3-D 阵列，具体指高度、宽度和颜色通道。例如，如果你使用电脑截屏，它将首先转换成一个 3-D 数组，然后压缩它为 ‘.jpeg’ 或 ‘.png’ 文件格式。

　　虽然这些图像对于人类来说很容易理解，但计算机很难理解它们。这种现象称为“语义空隙”。我们的大脑可以看看图像，并在几秒钟内读懂完整的图片。但计算机会将图像看作一个数字数组，问题来了，它想知道这是一张什么样的图像，我们应该怎么样把图像解释给机器它才能读懂？

　　在早期，人们试图将图像分解为机器的 “可理解” 格式，如“模板”。例如，面部总是具有在每个人中有所保留的特定结构，例如眼睛，鼻子或我们的脸的形状。但是这种方法将是有缺陷的，因为当要识别的对象的数量将增加到一定量级时，“模板” 将不成立。

　　2012年一个深层神经网络架构赢得了 ImageNet 的挑战，从自然场景中识别对象，它在即将到来的 ImageNet 挑战中继续统治其主权，从而证明了解决图像问题的有用性。人们通常使用哪些库 / 语言来解决图像识别问题？最近的一次调查中，最流行的深度学习库，支持的最友好的语言有 Python ，其次是 Lua ，对 Java 和 Matlab 支持的也有。最流行的库举几个例子：

现在，我们了解了图像的存储方式以及使用的常用库，让我们看看 TensorFlow 提供的功能。

什么是 TensorFlow ？

让我们从官方定义开始.

　　“TensorFlow 是一个开源软件库，用于使用数据流图进行数值计算。图中的节点表示数学运算，而图边表示在它们之间传递的多维数据阵列（也称为张量）。灵活的架构允许您使用单一 API 将计算部署到桌面、服务器或移动设备中的一个或多个的 CPU 或 GPU 中。

　　如果感觉这听起来太高大上，不要担心。这里有我简单的定义，TensorFlow 看起来没什么，只是 numpy 有些难以理解。如果你以前使用过 numpy ，理解 TensorFlow 将是手到擒来！ numpy 和 TensorFlow 之间的主要区别是 TensorFlow 遵循惰性编程范例。 TensorFlow 的操作基本上都是对 session 的操作，它首先构建一个所有操作的图形，当我们调用 session 时 TensorFlow 就开始工作了。它通过将内部数据表示转换为张量（Tensor，也称为多维数组）来构建为可扩展的。构建计算图可以被认为是 TensorFlow 的主要成分。想更多地了解一个计算图形的数学结构，可以阅读这篇文章。

　　通过上面的介绍，很容易将 TensorFlow 分类为神经网络库，但它不仅仅是如此。它被设计成一个强大的神经网络库，但它有能力做更多的事情。可以构建它为其他机器学习算法，如决策树或 k-最近邻，你可以从字面上理解，你可以做一切你在 numpy 上能做的事情！我们暂且称它为 “全能的 numpy” 。

使用 TensorFlow 的优点是：

它有一个直观的结构 ，顾名思义它有 “张量流”，你可以轻松地可视每个图中的每一个部分。
轻松地在 cpu / gpu 上进行分布式计算
平台的灵活性 。可以随时随地运行模型，无论是在移动端、服务器还是 PC 上。

TensorFlow 的典型 “流”

　　每个库都有自己的“实现细节”，即一种写其遵循其编码范例的方式。例如，当实现 scikit-learn 时，首先创建所需算法的对象，然后在训练和测试集上构建一个模型获得预测，如下所示：

# define hyperparamters of ML algorithm
clf = svm.SVC(gamma=0.001, C=100.)
# train 
clf.fit(X, y)
# test 
clf.predict(X_test)

正如我前面所说，TensorFlow 遵循一种懒惰的方法。在 TensorFlow 中运行程序的通常工作流程如下：

建立一个计算图，任何的数学运算可以使用 TensorFlow 支撑。
初始化变量，编译预先定义的变量
创建 session，这是神奇的开始的地方！
在 session 中运行图，编译图形被传递到 session ，它开始执行它。
关闭 session，结束这次使用。

TensoFlow 中使用的术语很少

placeholder：将数据输入图形的一种方法
feed_dict：将数值传递到计算图的字典

让我们写一个小程序来添加两个数字！


# import tensorflow
import tensorflow as tf

# build computational graph
a = tf.placeholder(tf.int16)
b = tf.placeholder(tf.int16)

addition = tf.add(a, b)

# initialize variables
init = tf.initialize_all_variables()

# create session and run the graph
with tf.Session() as sess:
    sess.run(init)
    print "Addition: %i" % sess.run(addition, feed_dict={a: 2, b: 3})

# close session
sess.close()

在 TensorFlow 中实现神经网络

注意：我们可以使用不同的神经网络体系结构来解决这个问题，但是为了简单起见，我们在深入实施中讨论 前馈多层感知器。

让我们记住对神经网络的了解。

神经网络的典型实现如下：

定义要编译的神经网络体系结构
将数据传输到模型
整个运行中，数据首先被分成批次，以便它可以被摄取。首先对批次进行预处理，扩增，然后送入神经网络进行训练
然后，模型被逐步地训练
显示特定数量的时间步长的精度
训练后保存模型供将来使用
在新数据上测试模型并检查其运行方式

在这里，我们解决了我们深刻的学习实践中的问题 - [识别数字]，让再我们花一点时间看看问题陈述。

　　我们的问题是图像识别，以识别来自给定的 28×28 图像的数字。我们有一个图像子集用于训练，其余的用于测试我们的模型。首先下载训练和测试文件。数据集包含数据集中所有图像的压缩文件， train.csv 和 test.csv 都有相应的训练和测试图像的名称。数据集中不提供任何其他功能，只是原始图像以 “.png” 格式提供。

　　如之前说的，我们将使用 TensorFlow 来创建一个神经网络模型。所以首先在你的系统中安装 TensorFlow 。请参考官方的安装指南进行安装，按您的系统规格。

我们将按照上述模板

让我们来导入所有需要的模块

%pylab inline

import os
import numpy as np
import pandas as pd
from scipy.misc import imread
from sklearn.metrics import accuracy_score
import tensorflow as tf

让我们来设置一个种子值，这样我们就可以控制我们的模型随机性

# To stop potential randomness
seed = 128
rng = np.random.RandomState(seed)

root_dir = os.path.abspath('../..')
data_dir = os.path.join(root_dir, 'data')
sub_dir = os.path.join(root_dir, 'sub')

# check for existence
os.path.exists(root_dir)
os.path.exists(data_dir)
os.path.exists(sub_dir)

现在让我们读取我们的数据集，这些是 .csv 格式，并有一个文件名以及相应的标签

train = pd.read_csv(os.path.join(data_dir，'Train'，'train.csv'))
test = pd.read_csv(os.path.join（data_dir，'Test.csv'))
sample_submission = pd.read_csv(os.path.join(data_dir，'Sample_Submission.csv'))
train.head()

	文件名	标签
0	0.png	4
1	1.png	9
2	2.png	1
3	3.png	7
4	4.png	3

让我们看看我们的数据是什么样子！我们读取我们的形象并显示出来。

img_name = rng.choice(train.filename)
filepath = os.path.join(data_dir, 'Train', 'Images', 'train', img_name)

img = imread(filepath, flatten=True)

pylab.imshow(img, cmap='gray')
pylab.axis('off')
pylab.show()

上面的图像表示为 numpy 数组，如下所示

为了方便数据操作，让我们的存储作为 numpy 的阵列的所有图片

temp = []
for img_name in train.filename:
    image_path = os.path.join(data_dir, 'Train', 'Images', 'train', img_name)
    img = imread(image_path, flatten=True)
    img = img.astype('float32')
    temp.append(img)
    
train_x = np.stack(temp)

temp = []
for img_name in test.filename:
    image_path = os.path.join(data_dir, 'Train', 'Images', 'test', img_name)
    img = imread(image_path, flatten=True)
    img = img.astype('float32')
    temp.append(img)
    
test_x = np.stack(temp)

由于这是典型的 ML 问题，为了测试我们的模型的正确功能，我们创建一个验证集，让我们以 70:30 的分割训练集和验证集

split_size = int(train_x.shape[0]*0.7)

train_x, val_x = train_x[:split_size], train_x[split_size:]
train_y, val_y = train.label.values[:split_size], train.label.values[split_size:]

我们定义一些辅助函数，我们稍后在我们的程序中使用

def dense_to_one_hot(labels_dense, num_classes=10):
    """Convert class labels from scalars to one-hot vectors"""
    num_labels = labels_dense.shape[0]
    index_offset = np.arange(num_labels) * num_classes
    labels_one_hot = np.zeros((num_labels, num_classes))
    labels_one_hot.flat[index_offset + labels_dense.ravel()] = 1
    
    return labels_one_hot

def preproc(unclean_batch_x):
    """Convert values to range 0-1"""
    temp_batch = unclean_batch_x / unclean_batch_x.max()
    
    return temp_batch

def batch_creator(batch_size, dataset_length, dataset_name):
    """Create batch with random samples and return appropriate format"""
    batch_mask = rng.choice(dataset_length, batch_size)
    
    batch_x = eval(dataset_name + '_x')[[batch_mask]].reshape(-1, 784)
    batch_x = preproc(batch_x)
    
    if dataset_name == 'train':
        batch_y = eval(dataset_name).ix[batch_mask, 'label'].values
        batch_y = dense_to_one_hot(batch_y)
        
    return batch_x, batch_y

主要部分！让我们定义我们的神经网络架构。我们定义一个神经网络具有 3 层，输入、隐藏和输出，输入和输出中的神经元数目是固定的，因为输入是我们的 28×28 图像，并且输出是表示类的 10×1 向量。我们在隐藏层中取 500 神经元。这个数字可以根据你的需要变化。我们把值赋给其余变量。可以阅读神经网络的基础知识的文章，以更深的了解它是如何工作。

### set all variables

# number of neurons in each layer

input_num_units = 28*28

hidden_num_units = 500

output_num_units = 10

# define placeholders
x = tf.placeholder(tf.float32, [None, input_num_units])
y = tf.placeholder(tf.float32, [None, output_num_units])

# set remaining variables
epochs = 5
batch_size = 128
learning_rate = 0.01

### define weights and biases of the neural network (refer this article if you don't understand the terminologies)

weights = {
    'hidden': tf.Variable(tf.random_normal([input_num_units, hidden_num_units], seed=seed)),
    'output': tf.Variable(tf.random_normal([hidden_num_units, output_num_units], seed=seed))
}

biases = {
    'hidden': tf.Variable(tf.random_normal([hidden_num_units], seed=seed)),
    'output': tf.Variable(tf.random_normal([output_num_units], seed=seed))
}

现在创建我们的神经网络计算图

hidden_layer = tf.add(tf.matmul(x, weights['hidden']), biases['hidden'])
hidden_layer = tf.nn.relu(hidden_layer)

output_layer = tf.matmul(hidden_layer, weights['output']) + biases['output']

此外，我们需要定义神经网络的成本

cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(output_layer, y))

设置优化器，即我们的反向传播算法。这里我们使用 Adam ，这是梯度下降算法的高效变体。有在 tensorflow 可用许多其它优化（参照此处）

optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

定义我们的神经网络结构后，让我们来初始化所有的变量

init = tf.initialize_all_variables()

现在让我们创建一个 Session ，并在 Session 中运行我们的神经网络。我们还验证我们创建的验证集的模型准确性

with tf.Session() as sess:
    # create initialized variables
    sess.run(init)
    
    ### for each epoch, do:
    ###   for each batch, do:
    ###     create pre-processed batch
    ###     run optimizer by feeding batch
    ###     find cost and reiterate to minimize
    
    for epoch in range(epochs):
        avg_cost = 0
        total_batch = int(train.shape[0]/batch_size)
        for i in range(total_batch):
            batch_x, batch_y = batch_creator(batch_size, train_x.shape[0], 'train')
            _, c = sess.run([optimizer, cost], feed_dict = {x: batch_x, y: batch_y})
            
            avg_cost += c / total_batch
            
        print "Epoch:", (epoch+1), "cost =", "{:.5f}".format(avg_cost)
    
    print "\nTraining complete!"
    
    
    # find predictions on val set
    pred_temp = tf.equal(tf.argmax(output_layer, 1), tf.argmax(y, 1))
    accuracy = tf.reduce_mean(tf.cast(pred_temp, "float"))
    print "Validation Accuracy:", accuracy.eval({x: val_x.reshape(-1, 784), y: dense_to_one_hot(val_y.values)})
    
    predict = tf.argmax(output_layer, 1)
    pred = predict.eval({x: test_x.reshape(-1, 784)})

这将是上面代码的输出

Epoch: 1 cost = 8.93566
Epoch: 2 cost = 1.82103
Epoch: 3 cost = 0.98648
Epoch: 4 cost = 0.57141
Epoch: 5 cost = 0.44550

Training complete!
Validation Accuracy: 0.952823	

验证我们自己的眼睛，让我们来想象它的预言

img_name = rng.choice(test.filename)
filepath = os.path.join(data_dir, 'Train', 'Images', 'test', img_name)

img = imread(filepath, flatten=True)
 
test_index = int(img_name.split('.')[0]) - 49000

print "Prediction is: ", pred[test_index]

pylab.imshow(img, cmap='gray')
pylab.axis('off')
pylab.show()

Prediction is:  8

我们看到的模型性能是相当不错！现在让我们创建一个提交

sample_submission.filename = test.filename
 
sample_submission.label = pred

sample_submission.to_csv(os.path.join(sub_dir, 'sub01.csv'), index=False)

　　终于完成了！我们刚刚创建了自己的训练神经网络！

TensorFlow 的限制

尽管 TensorFlow 是强大的，它仍然是一个低水平库，例如，它可以被认为是机器级语言，但对于大多数功能，您需要自己去模块化和高级接口，如 keras
它仍然在继续开发和维护，这是多么👍啊！
它取决于你的硬件规格，配置越高越好
不是所有变成语言能使用它的 API 。
TensorFlow 中仍然有很多库需要手动导入，比如 OpenCL 支持。

上面提到的大多数是在 TensorFlow 开发人员的愿景，他们已经制定了一个路线图，计划库未来应该如何开发。

TensorFlow 与其他库

　　TensorFlow 建立在类似的原理，如使用数学计算图表的 Theano 和 Torch，但是随着分布式计算的额外支持，TensorFlow 更好地解决复杂的问题。此外，TensorFlow 模型的部署已经被支持，这使得它更容易用于工业目的，打开一些商业的三方库，如 Deeplearning4j ，H2O 和 Turi。 TensorFlow 有用于 Python，C ++ 和 Matlab 的 API 。最近还出现了对 Ruby 和 R 等其他语言的支持。因此，TensorFlow 试图获得通用语言支持。

从这里去哪里？

　　以上你看到了如何用 TensorFlow 构建一个简单的神经网络，这段代码是为了让人们了解如何开始实现 TensorFlow。要解决更复杂的现实生活中的问题，你必须在这篇文章的基础上在调整一些代码才行。

　　许多上述功能可以被抽象为给出无缝的端到端工作流，如果你使用 scikit-learn ，你可能知道一个高级库如何抽象“底层”实现，给终端用户一个更容易的界面。尽管 TensorFlow 已经提取了大多数实现，但是也有更高级的库，如 TF-slim 和 TFlearn。

参考资源

TensorFlow 官方库
Rajat Monga（TensorFlow技术负责人） “TensorFlow为大家” 的视频
一个专用资源的策划列表

关于原文

感谢原文作者 Faizan Shaikh 的分享，这篇文章是在 An Introduction to Implementing Neural Networks using TensorFlow 的基础上做的翻译和局部调整，如果发现翻译中有不对或者歧义的的地方欢迎在下面评论里提问，我会加以修正。

转载自博客：http://leopardpan.github.io 谢谢！

Markdown工具集

Sun, 20 Nov 2016 00:00:00 +0000

什么是 Markdown

　　Markdown 是一种方便记忆、书写的纯文本标记语言，用户可以使用这些标记符号以最小的输入代价生成极富表现力的文档：如您正在阅读的这篇文章。它使用简单的符号标记不同的标题，分割不同的段落，粗体或者斜体某些文字.

　　很多产品的文档也是用markdown编写的，并且以“README.MD”的文件名保存在软件的目录下面。
　　

一些基本语法

标题
H1 :# Header 1
H2 :## Header 2
H3 :### Header 3
H4 :#### Header 4
H5 :##### Header 5
H6 :###### Header 6
链接 :Title
加粗 :Bold
斜体字 :Italics
删除线 :~~text~~
段落 : 段落之间空一行
换行符 : 一行结束时输入两个空格
列表 : 添加星号成为一个新的列表项。
引用 :> 引用内容
内嵌代码 : alert('Hello World');
画水平线 (HR) :——–

css 的大部分语法同样可以在 markdown 上使用，但不同的渲染器渲染出来的 markdown 内容样式也不一样，下面这些链接里面有 markdown 基本语法，你也可以在下面几个平台上尝试着写一些。

一些好用的 Markdown 编辑器

MaHua 在线 Markdown 编辑器 ,无须测试。

Markdown Plus 一款 Markdown 编辑器，可以支持添加任务列表、emoji、流程图等。

Cmd Markdown 作业部落在线 Markdown 编辑器推出桌面版客户端啦，全平台支援。

Macdown Github 上开源的 Mac 平台上的 Markdown 编辑器

GitBook Editor 一款团队在线编辑文档工具。可以轻松书写笔记，支持团队协同编辑。同时支持 Markdown 语法，还保持了印象笔记的风格并可在线预览。

Outlinely 界面简洁大方的大纲类 Mac 软件，使用起来很简单，而且支持输出 Markdown 格式。

Classeur 实用简洁的 Markdown 写作工具，快速上手。

DeerResume 程序员专用 MarkDown 简历制作在线工具。

转载自博客：http://leopardpan.github.io 谢谢！

Mac知识整合

Wed, 16 Nov 2016 00:00:00 +0000

.DS_Store 文件是什么？

.DS_Store 是 Mac OS 保存文件夹的自定义属性的隐藏文件，如文件的图标位置或背景色，相当于 Windows 的 desktop.ini。

1，禁止.DS_store 生成：
打开 “终端” ，复制黏贴下面的命令，回车执行，重启Mac即可生效。

defaults write com.apple.desktopservices DSDontWriteNetworkStores -bool TRUE

2，恢复.DS_store生成：

defaults delete com.apple.desktopservices DSDontWriteNetworkStores

显示隐藏文件

在终端执行命令，显示隐藏文件

defaults write com.apple.finder AppleShowAllFiles -bool true

恢复隐藏

defaults write com.apple.finder AppleShowAllFiles -bool false

执行命令后需要重新打开能看到效果。

切换 Pyhton 环境

我本地之前 Python 环境是 2.7.10 ，然后学习 Tensorflow 的时候，安装了 Python 3.5.2 ，把系统默认 Pyton 环境也设置成了 3.5.2 版本，今天运行以前写的 python 脚本发现运行不了了，因为python 2.7 和 3.5 的语法有挺多改动，现在我需要把系统的 python 环境回退到 2.7。

可以直接修改 ~/.bash_profile 文件。

1、修改 vim ~/.bash_profile

修改方式有很多种，使用 vim  ，或者 cd ~/ 然后 open . 打开文件夹，找到 .bash_profile 文件，双击打开。

2、在.bash_profile 文件里添加下面参数

alias python="/System/Library/Frameworks/Python.framework/Versions/2.7/bin/python2.7"

3、使用命令 source ~/.bash_profile 或者重启终端就 OK 了。

现在你再在终端输入 python 就会发现，显示的信息为 2.7 了

Python 2.7.10 (default, Oct 23 2015, 19:19:21) 
[GCC 4.2.1 Compatible Apple LLVM 7.0.0 (clang-700.0.59.5)] on darwin
Type "help", "copyright", "credits" or "license" for more information.

生成SSHKey过程

1.查看是否已经有了ssh密钥：`cd ~/.ssh` ，如果没有密钥则不会有此文件夹，有则备份删除。    
2.生存密钥：ssh-keygen -t rsa -C “test@gmail.com”。   按3个回车，密码为空。       

Your identification has been saved in /home/tekkub/.ssh/id_rsa.
Your public key has been saved in /home/tekkub/.ssh/id_rsa.pub.
The key fingerprint is:
………………    
最后得到了两个文件：id_rsa和id_rsa.pub  

使用版本控制器 SVN (versions) 添加.a库

Xcode 自带的 svn 和 Versions 以及一些其它工具都不能上传”.a”文件

下面是在 Mac 上如何把 .a 添加到 SVN 里面的

1、打开终端，输入cd，空格，然后将需要上传的 .a 文件所在的文件夹（不是.a文件）拖拽到终端（此办法无需输入繁琐的路径，快捷方便）回车

2、之后再输入如下命令：svn add libGoogleAnalytics.a ，回车

之后会出现：A (bin) libGoogleAnalytics.a

表示添加成功，打开 Versions 就可以看到，刚才添加的 .a 文件，此时就可以手动上传了。

另外，请注意路径的正确性。

转载自博客：http://leopardpan.github.io 谢谢！

TensorFlow 在 iOS 平台上的使用(一)

Thu, 03 Nov 2016 00:00:00 +0000

　　距离上次使用 TensorFlow 在iOS平台上做的小 Demo，已经过了四个月了，今天忽然想再看看,发现 Demo 已经不见了，我只能从头在编一次，这次发现编译 iOS 库，简单多了。

　　tensorflow 下载地址，tensorflow 最近提交的时间：2016-11-03，commit：7b7c02de56e013482b5fe5ab05e576dc98fe5742 。

　　下载完成后打开文件，找到目录 tensorflow-master/tensorflow/contrib/ios_examples 你会发现目录下有三个项目和一个 README.md 。

benchmark 、 camera 、 simple 、README.md

如果你发现项目无法运行，请看这里

　　对于任何项目我们首先打开的应该是 README.md ，里面一般情况都会有介绍如何使用这个项目，tensorflow 也不会例外。README 开头就说了，这个目录里有如何在 iOS 平台上使用 tensorflow 的例子，但是需要注意几点：

你的 Xcode 版本必须是 7.3 或更高版本，并且有安装 command-line 工具。
项目(Examples) 里必须包含一个静态库：libtensorflow-core.a 。
下载 Inception v1，解压后将 label 和 graph 放在 simple 和 camera 的项目中。

camera 项目的使用

　　camera 项目在 tensorflow-master/tensorflow/contrib/ios_examples 目录下，如果你是直接打开 camera 项目，编译你会发现报错缺少 imagenet_comp_graph_label_strings.txt 和 tensorflow_inception_graph.pb 两个文件，这两个文件上面已经说到了下载 Inception v1 解压得到。现在还差静态库：libtensorflow-core.a ，这个需要我们自己编译。

编译静态库：libtensorflow-core.a

进入目录：tensorflow-master/tensorflow/contrib/makefile，你可以看到一大堆 .sh 结尾的文件，找到 build_all_ios.sh ，Mac 上可以直接在 termina（终端）上运行命令编译

$ sh build_all_ios.sh

这个编译的过程是很漫长的，一般在一个小时左右。也有可能你在编译的过程中会遇到问题，这次我只遇到一个问题：

configure.ac:30: error: required file 'build-aux/ltmain.sh' not found
configure.ac:24: installing 'build-aux/missing'
Makefile.am: installing 'build-aux/depcomp'
parallel-tests: installing 'build-aux/test-driver'
autoreconf: automake failed with exit status: 1

解决方法是：先卸载 libtool 在重新安装，brew uninstall libtool && brew install libtool

如果你还遇到了其它问题，可以看看我之前的一片文章 iOS开发迎来机器学习的春天—TensorFlow ，或者是直接去 tensorflow 的 Issues 里面找。

一个小时后。。。　如果编译没出问题，你可以在目录　tensorflow-master/tensorflow/contrib/makefile／gen/lib 下找到一个静态库：libtensorflow-core.a ，把这个静态库拷贝到 camera 项目中，然后编译运行。

转载自博客：http://leopardpan.github.io 谢谢！

Xcode 8 使用笔记

Tue, 25 Oct 2016 00:00:00 +0000

最近使用 Xcode8遇到了一些问题，想记下来，发现简书上有位同学写了一篇很详细的教程原文链接，比较懒惰的我就在他的基础上加了些我自己的一些笔记。

Interface Builder

随着 14 年的 iPhone6 和 6P 出来之后，iPhone 的屏幕尺寸也越来越多，屏幕适配是一个需要解决的问题，以后不一定苹果又出什么尺寸的 iPhone 呢。

在 iPhone6 和 6P 发布的同一年，苹果推出的 Xcode6 中在原有的 Auto layout的基础上，添加了Size Classes新特性，通过这个新特性可以使用一个XIB或者SB文件，适配不同的屏幕以及iPhone和iPad两种设备。

在 Xcode8 中，苹果推出了更加强大的可视化编辑工具预览功能，可以在不运行App的情况下，预览当前XIB或SB在不同屏幕尺寸下的显示。(这个功能我记得之前Xcode就有，只是隐藏的比较深，苹果现在给拿到外面了)

选择一个XIB文件进去，点击下面红框的位置，会出现从3.5寸-5.5寸一系列屏幕尺寸的选项。直接点击不同屏幕尺寸，以及横竖屏选项，切换不同的屏幕显示。在iPad上还可以选择是否分屏，功能非常强大。

在右边有一个 Vary for Traits 选项，点击这个选项就可以同时显示所有可选的屏幕样式，功能和上面图片都一样，只是显示上看起来比较多。

还有一点，新创建的 XIB 控件尺寸，不再是之前 600*600 的方块了，而是默认是6s的长方形 XIB 文件，看起来舒服多了。

Target中General 的变化

在 Xcode8 之前，都需要自己设置证书和描述文件。如果设置出现错误的情况下，还可以通过点击 Fix issue 来修复这个错误。但这有个问题就在于，Fix issue 选项并不是那么好用，有的时候设置是正确的这里也提示需要 Fix issue。

可能苹果也意识到这个问题的存在，在Xcode8中可以通过Automatically manage signing选项，让苹果为我们管理证书和配置文件，设置也都是由苹果来完成的。在Xcode8中新建项目，这个选项默认是被勾选的。

从上面图中可以看到，苹果帮我们自动管理了证书和配置文件。而且在之前的项目中，如果想要设置安装后显示在手机上的App名字，还需要自己到Info.plist文件中，修改Display Name字段，而现在直接在General中就可以做修改，这个修改和Info.plist是同步的。

但是，如果我想自己管理证书和描述文件呢？只需要去掉Automatically manage signing选项。

如果自己到Build Settings中手动设置证书和描述文件，可以发现Provisioning Profile选项已经被标明为Deprecated，也就是苹果并不推荐手动设置。

Xcode 插件

升级 Xcode8 之后会发现，在 Xcode8 中所有第三方插件都失效了，并且连之前菜单栏的插件选项也不存在了。在之前很多 iOS 开发者，都是通过 Alcatraz 来管理插件的，现在 Alcatraz 也是不可用的。但是X code8 自身也对编译器进行了升级，将一些比较好的插件功能加入到 Xcode 中，例如单行高亮显示等。

在 Xcode8 中支持了开发插件工程，并且为我们提供了一个插件模板，开发的插件可以上传到App Store 下载。苹果这么做有一个原因在于，之前 Xcode和插件是运行在同一个进程的，所以插件的崩溃也会导致Xcode崩溃。苹果现在将插件作为一个单独的应用程序，分开进程运行，不会对Xcode带来其他影响。

Runtime Issues

在开发过程中，因为语法或明显的代码错误(例如Retain Cycle)，编译器可以发现并报黄色或红色警告。但是一些因为代码逻辑导致的错误，编译器并没有办法找到。例如下面的这句代码，因为代码逻辑的问题导致两个数组相互引用，都不能释放。

这时候可以通过 Xcode8 提供的 Runtime Issues 新特性，查找到运行过程中出现的问题，并通过 Graph 的方式将问题可视化的展现给开发者。

Debug Memory Graph

在Xcode6中出现了Debug View Hierarchy新特性，可以通过其调试当前App的视图层级，查找UI相关的bug非常方便。在Xcode8中苹果为开发者提供了Debug Memory Graph特性，通过这个新特性，可以直接选择一个对象，查看与其相关的内存关系。

Debug Memory Graph 和 Runtime Issues 可以配合使用，通过 Debug Memory Graph 分析内存关系完成后，点击 Runtime Issues 可以看到已经发现的内存问题。

Swift 3

Xcode8 带来了新版本的 Swift3，新版本的Swift变化较大，如果旧版的Swift项目在Xcode8上编译可能会失败。对此，苹果为开发者提供了Swift迁移工具，听说不太好用(我没用过这个工具)。

如果不想立刻就迁移到Swift3，可以在Builder Settings中进行设置，选择Use Legacy Swift Language Version设置为YES，就可以继续使用旧版本的Swift2.3。

其他更新

Xcode 新版字体，SF Mono Regular 字体。更新 Xcode 之后我比较喜欢这种字体，看起来代码非常工整。被编辑的行高亮显示。之前Xcode有个插件就是这个功能，Xcode8把高亮功能集成进来了，使用起来很方便。最新版的API文档，展示样式发生了很大的改变。更方便的生成文档(就是喵神写的VVDocumenter)，在Xcode8中可以将光标放在方法上面，通过option + command + /快捷键生成文档注释。

Xcode8适配,XIB和Storeboard适配

在 Xcode8 之前，创建一个 XIB 或 SB 文件，都是一个 600*600 的方块 XIB 文件。在 Xcode8 之后，创建的 XIB 文件默认是6s尺寸的大小。

但是 Xcode8 打开之前旧项目的 XIB或SB 文件时，会弹出下面的弹框，这时候一般直接选择Choose Device即可。

但是这样有个问题，如果Xcode8打开过这个XIB文件，并选择Choose Device之后。其他的Xcode8以下版本的编译器，将无法再打开这个文件，会报以下错误：

The document “ViewController.xib” requires Xcode 8.0 or later. This version does not support documents saved in the Xcode 8 format. Open this document with Xcode 8.0 or later. 有两种方法解决这个问题：

你同事也升级Xcode8，比较推荐这种方式，应该迎接改变。右击XIB或SB文件 -> Open as -> Source Code，删除xml文件中下面一行字段。

编译错误

升级Xcode之后，Xcode8对之前的一些修饰符和语句不兼容，会导致一些编译错误。这种错误导致的原因很多，这里大致列几条，各位还是根据自身遇到的情况做修改吧。

之前一些泛型相关的修饰符，nullable之类的有的会报错。 CAAnimation及其子类，设置代理属性后，必须在@interface()遵守代理，否则报错，等等。

权限适配

这应该算iOS10系统适配的范畴，最近这两个都在弄，所以就直接和Xcode8适配一起写出来了。

在iOS10之后需要在Info.plist中，添加新的字段获取权限，否则在iOS10上运行会导致崩溃。下面是一些常用的字段，如果有缺少的麻烦各位评论区补充一下。

Key 权限 Privacy - Camera Usage Description 相机 Privacy - Microphone Usage Description 麦克风 Privacy - Photo Library Usage Description 相册 Privacy - Contacts Usage Description 通讯录 Privacy - Bluetooth Peripheral Usage Description 蓝牙 Privacy - Location When In Use Usage Description 定位 Privacy - Location Always Usage Description 后台定位 Privacy - Calendars Usage Description 日历

参考资料：developer.apple

推送通知

苹果的推送在之前iOS8和iOS9的时候就发生过大的更新，推送功能越来越强大。在iOS10之后苹果推出了UserNotifications框架，可以通过这个框架更好的控制推送通知，可以更新、修改锁屏页面的推送消息，可以添加图片等功能。

但是在用Xcode8打包后，并且不对代码进行修改的情况下，会发现打包后苹果发来了一封邮件。这封邮件大概意思是如果需要使用推送通知，需要对代码做修改，否则将不能使用推送通知。

这是因为在Xcode8之后，如果需要使用Push Notifications的功能，需要勾选Capabilities -> Push Notifications为YES，否则进行远程推送就会有问题，并且会收到苹果发来的这封邮件。

删除系统log

升级Xcode8之后，在调试和运行过程中，发现控制台打印了很多不认识的log，这些log是系统打印的，和开发者没关系。但是这么多log看着比较乱，怎么屏蔽掉呢？

subsystem: com.apple.UIKit, category: HIDEventFiltered, enable_level: 0, persist_level: 0, default_ttl: 0, info_ttl: 0, debug_ttl: 0, generate_symptoms: 0, enable_oversize: 1, privacy_setting: 2, enable_private_data: 0 在Target -> Edit Scheme -> Run -> Arguments中，添加OS_ACTIVITY_MODE字段，并设置为Disable即可。

顺便提一下，这两天在设置log选项的时候，发现可以通过在Arguments中设置参数，打印出App加载的时长，包括整体加载时长，动态库加载时长等。

在Environment Variables中添加DYLD_PRINT_STATISTICS字段，并设置为YES，在控制台就会打印加载时长。

awakeFromNib报警告

老项目在Xcode8中，有些重写awakeFromNib方法的地方，会报下面的错误。这是因为没有调用super的方法导致的，还好我平时都是调用super的，我代码目前还没出问题。

Method possibly missing a [super awakeFromNib] call