人工智能、机器学习与深度学习

1 人工智能 Artificial Intelligence

*达特茅斯学院 - 1956 -
一门交叉学科，涉及数学、计算机科学、控制论、信息论、心理学、哲学等学科的边缘学科

2 机器学习

*卡耐基梅隆大学-1997 -

如果一个程序可以在任务T上，随着经验E的增加，效果P也可以随之增加，则这个程序可以从经验中学习
机器学习的传统算法包括决策树学习、推到逻辑规划、聚类、分类、回归、贝叶斯网络、神经网络

3 深度学习

深度学习系统是输入层，隐层，输出层的多层网络
深度学习不是万能的，像很多方法一样，他需要结合特定领域的先验知识

深度学习是大脑，机器学习是脑壳，人工智能就是四肢

深度学习的发展历程

1 神经网络的第一次高潮

1957-Frank-感知机

2 神经网络的第一次寒冬

1969-Marvin 能力有限只能分析线性问题，对于异或问题束手无策-多层感知机

3 神经网路的第二次高潮

1986-BP算法(反向传播算法)-自然杂志

4 神经网络的第二次寒冬

1989-卷积神经网络(CNN) -梯度爆炸问题
1998-SVM算法(支持向量机)贝尔实验室

5 深度学习的来临

⚠️《A Fast Learning Algorithm for Deep Belif Nets》

深度学习崛起的时代背景

算法有了，计算性能提升了，数据也有了

深度学习的应用场景

图像与视觉

• ImageNet 比赛 2013年
• 人脸识别
• 以图搜图

语音识别

2009年 高斯混合模型(GMM)被击败，语音识别领域首次成功
2016年百度语音识别准确率高达97%

自然语言处理

• 情感分析
• 文本生成
• 语言翻译
• 聊天机器人

个性化推荐

CTR（Click-Through-Rate） 点击通过率

常见的深度学习网络结构

全连接网络结构 FC FullConnected

卷积神经网络 CNN Convolutional nutrual Netwwork

循环神经网络 Recurrent Netural Network

机器学习回顾

输入数据-> 机器学习方法 -> 估计函数
新数据 ->估计函数 ->预测结果

线性回归的基本概念

• 什么是线性回归

存在一个点集，用一条曲线去拟合它的过程。如果拟合曲线是直线，就是线性回归，如果是曲线就是二次回归

• 基本概念：
  假设函数(Hypothesis Function),用数学方法描述自变量和因变量之间的为一种函数关系
  损失函数(Loss Function )，用数学方法描述假设函数的预测值和真实值之间的误差。均方差⚠️（Mean Squared Error）一种损失函数，交叉熵⚠️也是
  优化算法(Optimization Algorithm)

• 数据处理
  1 选取有用的维度
  2 是否处理离散值
  3 归一化（Mormalization)把各维的属性的取值范围放缩的差不多的区间：减掉均值，然后除以原值取范围

进行归一化的原因：1 ) 过大或者过小的数值范围会导致计算时的浮点上溢或者下溢出；2 ）不同的数值范围会导致不同属性对模型的重要性不同（至少在初始阶段如此），而这个假设常常不合理的。这回对优化过程造成困难，使得使用时间大大加长；3 ）很多机器学习技巧/模型（L1，L2正则项，向量空间模型-Vector Space）都基于这样的假设：所有的属性取汁差不多都是以0为均值切取值范围是相近的

4 分割数据考虑的因素：更多的训练数据会降低参数估计的方差，从而得倒更可信的模型，而更多的测试数据会降低测试误差的方差，从而得到更可信的测试误差
5 验证集：仅针对复杂模型，因为有很多超参数（Hyperparameter）要调整

• 模型概览（房价预测）
• 效果展示（房价预测）

深度学习框架介绍

深度学习框架的作用

• 简化计算图的搭建
  计算图（computional gragh）-本质上是一个有向无环图，结点代表函数，边代表函数操作
• 简化偏导计算
• 高效运行

常见的深度学习框架

CNTK | PaddlePaddle | Caffe2 | TensorFlow | PyTorch | MXNet

PaddlePaddle 简介

PaddlePaddle是百度开源的，易学易用的分布式深度学习平台

PaddlePaddle 使用

• docker 安装

mkdir ~/workspace
cd ~/workspace
touch housing.py

编辑 housing.py

import paddle.v2 as paddle

# 初始化
paddle.init(use_gpu=False,trainer_count=1)
# Configure the natural network
x = paddle.layer.data(name='x',type=paddle.data_type.dense_vector(13))
y_predict = paddle.layer.fc(input=x,size=1,act=paddle.activation.Linear())

with open('/workspace/fit_a_line.tar',r) as f:
      parpameters = paddle.parameters.Parameters.from_tar(f)
# Infer using provided test data
probs = paddle.infer(
           output_layer = y_predict,parameters = parameters,
            input=[item for item in paddle.dateset.uci_housing.test()()])

for i in xrange(len(probs)):
      print 'Predicted price: ${:,.2f}'.format(probs[I][0] * 1000)

运行housing.py

docker run --rm -v ～/workspace:/workspace paddle paddle/paddle:latest python /workspace/housing.py

房价模型连接
[百度备用]

• pip 安装

pip install paddlepaddle 

import paddle.v2 as paddle
# initialize PaddlePaddle
paddle.init(use_gpu=False,trainer_count=1)
# Configure the neural network
x = paddl.layer.data(name='x',type=paddle_type.dense_vector(13))
y_predict = paddle.layer.fc(input=x ,size = 1,act = paddle.activation.Linear())
with open('fit_a_line.tar','r') as f:
      parameters = paddle.parameters.Parameters.from_tar(f)

# infer using provided test data
probs = paddle.infer(
              output_layer=y_predict,parmeters=parameters,
              input=[item for item in paddle.dataset.uci_housing.test()()])
for i in xrange(len(probs)):
      print 'Predicted price:${:,.2f}'.fromat{probs[I][0] * 1000}

PaddlePaddle 实现

• 加载包

import matplotlib
matplotlib.use{'Agg'}

import matplotlib.predict as pat
import numpy as np

import paddle.v2 as paddle

• 数据处理

#  1 dataset 初始化
TRAIN_DATA = None
X_RAW = None
TEST_DATA = None

#  2 数据载入
def load_data(filename, feature_num=2,ratio=0.8):
"""
载入数据并进行处理
Args:
      Filename:数据储存文件，从该文件读取数据
      feature_num:数据特征数量
      ratio 训练集占总数据集比例
"""
global TRAIN_DATA，TEST_DATA，X_RAW
# data = np.loadtxt() 表示将数据载入后以矩阵或向量的形式存储在data中
# delimiter = ',' 表示以','为分隔符
data = np.loadtxt(filename,delimiter=',')
X_RAW = data.T[0].copy()

# axis= 0 表示按列计算
# data.shape[0] 表示data中一共有多少列
maximums,minimums,avgs =data.max(axis=0),data.min(axis=0),data.sum(axis=0)/data.shape[0]

# 归一化 data[:i] 表示第i列元素
for i in xrange(feature_num-1)
        data[:i]  = (data[: i]  - aves[I])/(maximums[i] - minmums[i])
      
# offset 用于划分训练数据集和测试数据集，例如0.8表示训练数据集占80%
offset = int(data.shape[0]*ratio)
TRAIN_DATA = data[:offset].copy
TEST_DATA= data[offset:].copy

#  3 读取训练数据 和读取测试数据
"""
读取训练数据或测试数据，服务于train()和test()
Args:
    data_set: 要获取的数据集
Return：
    reader:用于获取训练数据集及其标签的生成器
"""
def reader()
      """
      一个reader
      Args：
      return：
                data[:-1],data[-1:] --使用yield 返回生成器
                data[:-1]表示前n-1个元素，也就是训练数据，data[-1:1]表示最后一个元素，也就是对应的标签
      """
      for data in data_set:
            yield data[:-1],data[-1:]
return reader

# 4 获取训练数据集
def train():
    """
    定义一个reader 来获取训练数据集及其标签
    Args：
    Return：
        read_data --用于获取训练数据集及其标签的reader
    """
global TRAIN_DATA
load_data('data.txt')
return read_data(TRAIN_DATA)

# 5  获取测试数据集
def test():
"""
定义一个reader 来获取测试数据集及其标签
Args:
Return:
    read_data -- 用于获取测试数据集及其标签的reader
"""
global TEST_DATA
load_data('data.txt')
return read_data(TEST_DATA)

• 搭建神经网络

# 1 配置网络结构
def network_config():
"""
配置网络结构
Args：
Retrun:
        cost：
        parameter:模型参数
        optimizer:优化器
        feeeding:数据映射，python 字典
"""
# 输入层 paddle.layer.data 表示数据层，name='x':名称为x_input,
# type=paddle.data_type.dense_vector(1):数据类型为1维稠密向量
x_input = paddle.layer.data(name='x',
               type=paddle.data_type.dense_vector(1))
# 输出层：paddle.layer.fc 表示全链接层 ，input=x_input 表示该层输入数据层
# size =1:神经元个数，act=paddle.activation.Linear(): 激活函数为Linear()
# 标签数据，paddle.layer.data 表示数据层，name='y':名称为y
y_label = paddle.layer.data(name='y',type=paddle.data_type.dense_vector(1))

# 定义成本函数为均方差损失函数 square_error_cost
cost = paddle.layer.square_error_cost(input=y_predict,label=y_label)

# 利用cost 创建parameters
parameters = paddle.parameters.create(cost)

# 创建optimizer，并且初始化momentum，momentum=0 位普通的SGD 优化算法
optimizer = paddle.optimizer.Momentum(momnetum=0)

# 数据层和数组索引映射，用于trainer 训练时喂数据
feeding = {'x':0,'y':1}
result = [cost,parameter,optimizer,feeding]
return result

• 初始化 PaddlePaddle

# 初始化 use_gpu=False 表示不用GPU
def main():
      # init
      paddle.init(use_gpu=False,trainer_count=1)

• 训练模型

# 1 配置网络结构和设置参数
cost，parameters，optimizer，feeding = network_config()

# 2 记录成本
costs = []

# 3 创建 训练 trainer
traniner = paddle.trainer.SGD(cost=cost,parameters =parameters,update_equation =optimizer )

# 4 定义事件处理器，打印训练进度

def event_handler(event):
    """
    事件处理器，可以根据训练过程的信息作相应操作
    Args：
        Event:事件对象，包含event.pass_id,event.batch_id,event.cost等信息
    """
    if isinstance(event, paddle.event.EndIteration):
          if event.pass_id % 100 = 0:
                print "Pass %d,Batch %d,Cost %f"  % (
                    event.pass_id,event.batch_id,event.cost)
               costs.append(event.cost)
               )
   if isinstance(event, paddle.event.EndPass):
        result = trainer.test(
                      reader=paddle.batch(test(),batch_size=2),
                      feeding=feeding)
       print "Test %d,Cost %f" % (event.pass_id,result.cost) 
        )

# 5 模型训练
# training
trainer.train(
reder=paddle.batch(
        paddle.reader.shuffle(train(),but_size=500),
        batch_size=256),
        feeding=feeding,
        event_handler=event_handler,
        num_passes = 300)

# 6 打印结果
print_parameters(parameters)

# 7 展示学习曲线
plot_cost(costs)

• 预测房价

# 1 参数打印 page 57
def print_parameters(parameters):
      """
          打印训练结果的参数以及测试结果
          Args：
                  Parameters：训练结果的参数
          Return：
      """
      print   " Result parameters as below"
      
      theta_a = parateters.get('____fc_layer_0__.w0')[0]
      theta_b = parameters.get('___fc_layer_0_.wbias')[0]
      
      x_0 = X_RAW[0]
      y_0 = theta_a * TRAIN_DATA[0][0] + theta_b

      x_1 = X_RAW[1]
      y_1 =theta_a *TRAIN_DATA[1][0] + theta_b

      param_a = (y_0 - y_1) / (x_0 - x_1)
      param_b = (y_1 - param_a * x_1)
      print 'a = ',param_a
      print 'b = ',param_b

# 2 展示模型训练曲线 page 58
def_plot_costs(costs):
      """
      利用 costs 展示模型的训练曲线
      Args: 
            Cost: 记录了训练过程的cost变化的list，每一百次迭代记录一次
      Return:
      """
      costs = np.squeeze(costs)
      plt.plot(costs)
      plt.ylabel('cost')
      plt.xlabel('iterations(per hundreds)')
      plt.title("house Price Distributions")
      plt.show()
      plt.savefig("cost.png")

# 3 开始预测 page 58
if __name__ == '__main__':
       main()

• 数据可视化

# 绘图 page 59
import numpy as np
import matplotlib.pyplot as plt

def plot_data(data, a,b):
       x = data[:,0]
       y = data[:,1]
       y_predict = x*a + b;
       plt.scatter(x,y,marker='.',c='r',label='True')
       plt.title("House Price Distributions")
       plt.xlabel('House Area')
       plt.ylael('House Proce')
       plt.xlim(0,255)      
       plt.ylim(0,2500)
       predict = plt.plot(x,y_predict,lable='Preidict')
       plt.legend(loc='upper left')
       plt.savefig('result.png')
       plt.show()
       
data = np.loadtxt('data.txt',delimiter=',')
X_RAW = data.T[0].copy()
plot_data(data,7.1,-62.1)