【有三AI-CV夏季划】人工智能:深度学习从入门到精通

下栽地止：www.ukoou.com/resource/1285

人工智能简单介绍

人工智能系统的目的 提供更加高效的编程语言、框架和工具。

更具表达能力和简洁的神经网络计算原语和编程语言 更直观的编辑、调试和实验工具 整个深度学习生命周期中的系统问题:模型压缩、推理、安全、隐私保护等 提供全面的学习系统:强化学习、自动机器学习等

提供更强大和可扩展的计算能力。

自动编译优化算法 自动推导计算图 根据不同体系结构自动并行化 自动分布式化，并扩展到多个计算节点 持续优化模型效果 探索并解决新挑战下的系统设计、实现和演化的问题。

人工智能系统基本组成部分 体验：拥有端到端的人工智能用户体验-模型、算法、Pipeline、实验、工具、生命周期管理 框架：包括编程接口、计算图、自动梯度计算、IR（中间表示）、编译器基础设施 运行时：包括深度学习运行时-优化器、规划器、执行器 架构（单节点和云）：包含硬件API（GPU、CPU、FPGA、ASIC）、资源管理/调度器、可扩展的网络堆栈（RDMA、IB、NVLink）

人工智能算法

（1）人工神经网络（Artificial Neural Network）类

1.反向传播（Backpropagation） 2.波尔兹曼机（Boltzmann Machine） 3.卷积神经网络（Convolutional Neural Network） 4.Hopfield网络（hopfield Network） 5.多层感知器（Multilyer Perceptron） 6.径向基函数网络（Radial Basis Function Network，RBFN） 7.受限波尔兹曼机（Restricted Boltzmann Machine） 8.回归神经网络（Recurrent Neural Network，RNN） 9.自组织映射（Self-organizing Map，SOM） 10.尖峰神经网络（Spiking Neural Network）等。

（2）贝叶斯类（Bayesin）类：

1.朴素贝叶斯（Naive Bayes） 2.高斯贝叶斯（Gaussian Naive Bayes） 3.多项朴素贝叶斯（Multinomial Naive Bayes） 4.平均-依赖性评估（Averaged One-Dependence Estimators，AODE） 5.贝叶斯信念网络（Bayesian Belief Network，BBN） 6.贝叶斯网络（Bayesian Network，BN）等。

（3）决策树（Decision Tree）类：

1.分类和回归树（Classification and Regression Tree，CART） 2.ID3算法（ID3 Algorithm） 3.C4.5算法（C4.5 Algorithm）、C5.0算法（C5.0 Algorithm） 4.卡方自动交互检测（Chi-squared Automatic Interaction Detection，CHAID） 5.决策残端（Decision Stump） 6.随机森林（Random Forest） 7.SLIQ（Supervised Learning in Quest）等。

（4）线性分类器（Linear Classifier）类：

1.Fisher的线性判别（Fisher’s Linear Discriminant） 2.线性回归（Linear Regression） 3.逻辑回归（Logistic Regression） 4.多项逻辑回归（Multionmial Logistic Regression） 5.朴素贝叶斯分类器（Naive Bayes Classifier） 6.感知（Perception） 7.支持向量机（Support Vector Machine）等。

人工智能深度学习

1. 自动编码器

作为某种类型的前馈神经网络，自动编码器（Autoencoder）是一种深度学习算法，其中输入和输出都是相同的。它是由 Geoffrey Hinton 在 1980 年设计的，目的是解决无监督学习问题。它拥有经过训练的神经网络，将数据从输入层转移到输出层。自动编码器的一些重要用例是：图像处理、药品回收和人口预测。

2. 受限玻尔兹曼机 受限玻尔兹曼机（Restricted Boltzmann Machines，RBM）是随机神经网络，能够从概率分布而不是输入集中学习。这种深度学习算法由 Geoffrey Hinton 开发，用于主题建模、特征学习、协同过滤、回归、分类和降维。

3. 自组织映射

自组织映射（Self-Organizing Maps，SOM）通过自组织人工神经网络实现了数据可视化，以降低数据的维度。这种深度学习算法是由 Teuvo Kohonen 教授开发的。数据可视化能够解决人类在处理高维数据时不容易可视化的这类问题。开发自组织映射的目的是为了对高维信息进行更好的理解。

4. 多层感知机

开始学习深度学习算法的最好地方是多层感知机（Multilayer Perceptions，MLP）。它属于前馈神经网络的范畴，同时还有许多包含激活函数的感知层。 它由两个完全连接的层组成：

5. 深度信念网络

生成模型、深度信念网络（Deep Belief Network，DBN）拥有大量的潜变量和随机变量层。潜变量通常被称为隐含层，包含二进制值。这些是波尔兹曼机的堆栈，各层之间有连接。每一个深度信念网络层都与后续和之前的层相连接。深度信念网络的用例包括视频识别、图像识别以及运动捕捉数据。

6. 径向基函数网络

径向基函数网络（Radial Basis Function Network ，RBFN）是一类特殊的前馈神经网络，利用径向基函数作为激活函数。它包含以下几层：

7. 生成对抗网络

生成对抗网络（Generative Adversarial Network，GAN）是一种深度学习算法，它可以创建与训练数据相似的新数据实例。生成式对抗网络有助于生成逼真的图片、卡通人物、人脸的图像创建和三维物体的渲染。视频游戏开发者利用生成对抗网络，通过图像训练提升低分辨率。

8. 递归神经网络

递归神经网络（Recurrent Neural Network，RNN）由有助于形成有向循环的连接组成，允许长短期记忆网络（Long Short-term Memory Network，LSTM）的输出作为现阶段的输入提供。递归神经网络能够记住以前的输入，因为它有内部记忆。递归神经网络的一些常见用例有：手写识别、机器翻译、自然语言处理、时间序列分析和图像说明。

9. 卷积神经网络

卷积神经网络（Convolutional Neural Network，CNN）也被称为 ConvoNet，包含许多层，主要用于物体检测和图像处理。第一个卷积神经网络是由 Yann LeCun 在 1988 年开发和部署的。在那一年，它被称为 LeNet，用于字符识别，如数字、邮政编码等。卷积神经网络的一些重要用例包括医学图像处理、卫星图像识别、时间序列预测和异常检测。

10. 长短期记忆网络

长短期记忆网络（Long Short-term Memory Network，LSTM）是一类递归神经网络，能够学习和记忆长期依赖关系。长短期记忆网络还能够长期回忆过去的信息。它能随着时间的推移保留信息，这被证明在时间序列预测中是有益的。它有一个链状结构，其中 4 个相互作用的层连接并进行独特的沟通。除了时间序列预测外，长短期记忆网络还被用于药品开发、音乐创作和语音识别。

人工智能实践：Tensorflow

1.导入tf.keras tensorflow2推荐使用keras构建网络，常见的神经网络都包含在keras.layer中(最新的tf.keras的版本可能和keras不同)

import tensorflow as tf from tensorflow.keras import layers print(tf.version) print(tf.keras.version) 2.构建简单模型 2.1模型堆叠 最常见的模型类型是层的堆叠：tf.keras.Sequential 模型

model = tf.keras.Sequential() model.add(layers.Dense(32, activation='relu')) model.add(layers.Dense(32, activation='relu')) model.add(layers.Dense(10, activation='softmax')) 2.2网络配置 tf.keras.layers中网络配置：

activation：设置层的激活函数。此参数由内置函数的名称指定，或指定为可调用对象。默认情况下，系统不会应用任何激活函数。

kernel_initializer 和 bias_initializer：创建层权重（核和偏差）的初始化方案。此参数是一个名称或可调用对象，默认为 "Glorot uniform" 初始化器。

kernel_regularizer 和 bias_regularizer：应用层权重（核和偏差）的正则化方案，例如 L1 或 L2 正则化。默认情况下，系统不会应用正则化函数。

layers.Dense(32, activation='sigmoid') layers.Dense(32, activation=tf.sigmoid) layers.Dense(32, kernel_initializer='orthogonal') layers.Dense(32, kernel_initializer=tf.keras.initializers.glorot_normal) layers.Dense(32, kernel_regularizer=tf.keras.regularizers.l2(0.01)) layers.Dense(32, kernel_regularizer=tf.keras.regularizers.l1(0.01)) 3.训练和评估 3.1设置训练流程 构建好模型后，通过调用 compile 方法配置该模型的学习流程：

model = tf.keras.Sequential() model.add(layers.Dense(32, activation='relu')) model.add(layers.Dense(32, activation='relu')) model.add(layers.Dense(10, activation='softmax')) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss=tf.keras.losses.categorical_crossentropy, metrics=[tf.keras.metrics.categorical_accuracy]) 3.2输入Numpy数据 import numpy as np

train_x = np.random.random((1000, 72)) train_y = np.random.random((1000, 10))

val_x = np.random.random((200, 72)) val_y = np.random.random((200, 10))

model.fit(train_x, train_y, epochs=10, batch_size=100, validation_data=(val_x, val_y)) 3.3tf.data输入数据 dataset = tf.data.Dataset.from_tensor_slices((train_x, train_y)) dataset = dataset.batch(32) dataset = dataset.repeat() val_dataset = tf.data.Dataset.from_tensor_slices((val_x, val_y)) val_dataset = val_dataset.batch(32) val_dataset = val_dataset.repeat()

model.fit(dataset, epochs=10, steps_per_epoch=30, validation_data=val_dataset, validation_steps=3) 3.4评估与预测 test_x = np.random.random((1000, 72)) test_y = np.random.random((1000, 10)) model.evaluate(test_x, test_y, batch_size=32) test_data = tf.data.Dataset.from_tensor_slices((test_x, test_y)) test_data = test_data.batch(32).repeat() model.evaluate(test_data, steps=30)

predict

result = model.predict(test_x, batch_size=32) print(result) 4.构建高级模型 4.1函数式api tf.keras.Sequential 模型是层的简单堆叠，无法表示任意模型。使用 Keras 函数式 API 可以构建复杂的模型拓扑，例如：

多输入模型，

多输出模型，

具有共享层的模型（同一层被调用多次），

具有非序列数据流的模型（例如，残差连接）。

使用函数式 API 构建的模型具有以下特征：

层实例可调用并返回张量。 输入张量和输出张量用于定义 tf.keras.Model 实例。 此模型的训练方式和 Sequential 模型一样。

input_x = tf.keras.Input(shape=(72,)) hidden1 = layers.Dense(32, activation='relu')(input_x) hidden2 = layers.Dense(16, activation='relu')(hidden1) pred = layers.Dense(10, activation='softmax')(hidden2)

model = tf.keras.Model(inputs=input_x, outputs=pred) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss=tf.keras.losses.categorical_crossentropy, metrics=['accuracy']) model.fit(train_x, train_y, batch_size=32, epochs=5) 4.2模型子类化 通过对 tf.keras.Model 进行子类化并定义您自己的前向传播来构建完全可自定义的模型。在 init 方法中创建层并将它们设置为类实例的属性。在 call 方法中定义前向传播

class MyModel(tf.keras.Model): def init(self, num_classes=10): super(MyModel, self).init(name='my_model') self.num_classes = num_classes self.layer1 = layers.Dense(32, activation='relu') self.layer2 = layers.Dense(num_classes, activation='softmax') def call(self, inputs): h1 = self.layer1(inputs) out = self.layer2(h1) return out

def compute_output_shape(self, input_shape):
    shape = tf.TensorShape(input_shape).as_list()
    shape[-1] = self.num_classes
    return tf.TensorShape(shape)

model = MyModel(num_classes=10) model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss=tf.keras.losses.categorical_crossentropy, metrics=['accuracy'])

model.fit(train_x, train_y, batch_size=16, epochs=5) 4.3自定义层 通过对 tf.keras.layers.Layer 进行子类化并实现以下方法来创建自定义层：

build：创建层的权重。使用 add_weight 方法添加权重。

call：定义前向传播。

compute_output_shape：指定在给定输入形状的情况下如何计算层的输出形状。 或者，可以通过实现 get_config 方法和 from_config 类方法序列化层。

class MyLayer(layers.Layer): def init(self, output_dim, **kwargs): self.output_dim = output_dim super(MyLayer, self).init(**kwargs)

def build(self, input_shape):
    shape = tf.TensorShape((input_shape[1], self.output_dim))
    self.kernel = self.add_weight(name='kernel1', shape=shape,
                               initializer='uniform', trainable=True)
    super(MyLayer, self).build(input_shape)

def call(self, inputs):
    return tf.matmul(inputs, self.kernel)

def compute_output_shape(self, input_shape):
    shape = tf.TensorShape(input_shape).as_list()
    shape[-1] = self.output_dim
    return tf.TensorShape(shape)

def get_config(self):
    base_config = super(MyLayer, self).get_config()
    base_config['output_dim'] = self.output_dim
    return base_config

@classmethod
def from_config(cls, config):
    return cls(**config)

model = tf.keras.Sequential( [ MyLayer(10), layers.Activation('softmax') ])

model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss=tf.keras.losses.categorical_crossentropy, metrics=['accuracy'])

model.fit(train_x, train_y, batch_size=16, epochs=5) 4.3回调 callbacks = [ tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'), tf.keras.callbacks.TensorBoard(log_dir='./logs') ] model.fit(train_x, train_y, batch_size=16, epochs=5, callbacks=callbacks, validation_data=(val_x, val_y)) 5保持和恢复 5.1权重保存 model = tf.keras.Sequential([ layers.Dense(64, activation='relu'), layers.Dense(10, activation='softmax')])

model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='categorical_crossentropy', metrics=['accuracy'])

model.save_weights('./weights/model') model.load_weights('./weights/model') model.save_weights('./model.h5') model.load_weights('./model.h5') 5.2保存网络结构

序列化成json

import json import pprint json_str = model.to_json() pprint.pprint(json.loads(json_str)) fresh_model = tf.keras.models.model_from_json(json_str)

保持为yaml格式 #需要提前安装pyyaml

yaml_str = model.to_yaml() print(yaml_str) fresh_model = tf.keras.models.model_from_yaml(yaml_str) 5.3保存整个模型 model = tf.keras.Sequential([ layers.Dense(10, activation='softmax', input_shape=(72,)), layers.Dense(10, activation='softmax') ]) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(train_x, train_y, batch_size=32, epochs=5) model.save('all_model.h5') model = tf.keras.models.load_model('all_model.h5') 6.将keras用于Estimator Estimator API 用于针对分布式环境训练模型。它适用于一些行业使用场景，例如用大型数据集进行分布式训练并导出模型以用于生产

model = tf.keras.Sequential([layers.Dense(10,activation='softmax'), layers.Dense(10,activation='softmax')])

model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy'])

estimator = tf.keras.estimator.model_to_estimator(model)