人工智能零基础入门 | 学习笔记人工智能的分支计算机视觉：人脸识别自然语言处理：语音识别、语义识别机器人人工智能

人工智能的分支

计算机视觉：人脸识别
自然语言处理：语音识别、语义识别
机器人

人工智能必备三要素

数据
算法
计算力

GPU、CPU

GPU——计算密集型
CPU——IO密集型

机器学习

机器学习工作流程

定义：从数据中自动分析获得模型，并利用模型对未知数据进行预测
工作流程：

获取数据
数据基本处理
特征工程
机器学习(模型训练)
模型评估

获取到的数据集介绍

专有名词：样本、特征、目标值(标签值)、特征值
数据类型构成

类型一：特征值+目标值(分得的类别)

目标值分为离散值还是连续值

类型二：只有特征值，没有目标值

数据划分训练数据(训练集)——构建模型

0.7——0.8

测试数据(测试集)——模型评估

0.2——0.3

数据基本处理：对数进行缺失值、去除异常值等处理
特征工程

特征降维

机器学习

选择合适的算法对模型进行训练

模型评估

对训练好的模型进行评估

机器学习算法分类

监督学习——有特征值，有目标值

目标值连续——回归

目标值离散——分类

常见的监督学习

序列生成（sequence generation）。给定一张图像，预测描述图像的文字。
语法树预测（syntax tree prediction）。给定一个句子，预测其分解生成的语法树。
目标检测（object detection）。给定一张图像，在图中特定目标的周围画一个边界框。
图像分割（image segmentation）。给定一张图像，在特定物体上画一个像素级的掩模（mask）。

无监督学习——仅有特征值

无监督学习：没有目标的情况下寻找输入数据的有趣变换
目的：数据可视化、数据压缩、数据去噪、更好地理解数据相关性。
无监督学习是数据分析的必备技能。
降维（dimensionality reduction） 和 聚类（clustering） 都是常见的无监督学习方法。

半监督学习

有特征值，但是一部分数据有目标值，一部分没有

自监督学习是监督学习的一个特例，是没有人工标注的监督学习，标签仍然存在，但它们是从输入数据中生成。
自编码器（autoencoder）是有名的自监督学习的例子，其生成的目标就是未经修改的输入。

强化学习

动态过程，上一步数据的输出是下一步数据的输入

四要素：agent,action,environment,reward

参数是什么？

参数是模型中可被学习和调整的参数，通常是通过训练数据来自动学习的，以最小化损失函数或优化目标。

在深度学习中，参数通常是指神经网络中的权重和偏差。

这些参数是通过反向传播算法，根据训练数据中的梯度信息自动调整的，以最小化损失函数。

参数的学习是模型训练的过程，目标是找到最佳的参数配置，使得模型能够对新的未见过的数据进行准确的预测。

超参数是什么

超参数则是在算法运行之前手动设置的参数，用于控制模型的行为和性能。

这些超参数的选择会影响到模型的训练速度、收敛性、容量和泛化能力等方面。

例如，学习率、迭代次数、正则化参数、隐藏层的神经元数量等都是常见的超参数。

超参数的选择通常是一个试错的过程，需要根据经验和领域知识进行调整。

深度学习

K临近算法——KNN算法矩阵：Wx + b

模型评估

所用数据集：训练集、验证集和测试集
分类模型评估：准确率、精确率、召回率、F1-score、AUC指标
回归模型评估：均方根误差、相对平方误差、平均绝对误差、相对绝对误差、决定系数
拟合：欠拟合、过拟合

matplotlib用法

工作流程

创建画布

plt.figure(figsize=(20,8), dpi=100)
# figsize设置大小，（长，宽），dpi是像素

2. 图像绘制

x = [1，2，3，4，5，6]
y = [3,6,3,5,3,10]
plt.plot(x,y)
# plt.plot(x,y,format_string,**kwargs)
# x：X轴数据，列表或数组，可选。
y：Y轴数据，列表或数组。

format_string：控制曲线的格式字符串，可选。见下面的图表

颜色字符	风格字符	标记字符
‘b’ ：蓝色	‘‐’ 实线	‘.’ 点标记
‘c’：青绿色	‘‐‐’ 破折线	‘,’ 像素标记(极小点)
‘g’：绿色	‘‐.’ 点划线	‘o’ 实心圈标记
‘k’ ：黑色	‘:’ 虚线	‘v’ 倒三角标记
‘m’：洋红色	‘’ ’ ’ 无线条	‘^’ 上三角标记
‘r’：红色		‘>’ 右三角标记
‘w’：白色		‘<’ 左三角标记
‘y’：黄色

**kwargs：第二组或更多(x,y,format_string)，可画多条曲线。

**kwargs
这是一大堆可选内容，可以来里面指定很多内容，如“label”指定线条的标签，“linewidth”指定线条的宽度，等等
常用的几个：
color 指定颜色
label 线条的标签
linestyle 线条的风格
linewidth 线条的宽度

plt.grid(True, linestyle="--", alpha=0.7) # alpha表示透明度

fig, axes = plt.subplot(nrows=1,ncols=2,figsize=(20,18))

图像展示

plt.show()

自定义添加x,y刻度

plt.xticks(x, **kwargs) x要显示的刻度 plt.yticks(y, **kwargs) y要显示的刻度

x_tickets_lable = ["11点{}分".format(i) for i in x]
y_tickets = range(40)

# 第一个参数必须是数字，不然会报错
plt.xticks(x[::5], x_tickets_lable[::5])
plt.yticks(y_tickets[::5])

# 0.生成数据
x = range(60)
y_beijing = [random.uniform(10,15) for i in x]
y_shanghai = [random.uniform(15,25) for i in x]
# 1.创建画布
plt.figure(figsize=(20,8), dpi=100)
# 2.图形绘制
plt.plot(x, y_beijing, label="北京", color="g")
plt.plot(x, y_shanghai, label="上海")
# 2.1添加x,y轴刻度
y_ticks = range(40)
x_ticks_labels = ["11点{}分".format(i) for i in x]

plt.yticks(y_ticks[::5])
plt.xticks(x[::5], x_ticks_labels[::5])
# 2.2添加网格
plt.grid(True, linestyle="--", alpha=0.7)
# alpha表示透明度
#2.3添加描述
plt.xlabel("时间")
plt.ylabel("温度")
plt.title("一小时温度变化图", fontsize=20)
# 2.4显示图例
plt.legend(0)
# 3.图像展示
plt.show()

常见图形绘制

折线图 -- plt.plot()
散点图 -- plt.scatter()
柱状图 -- plt.bar()
直方图(正态分布) -- plt.hist()
饼图 -- plt.pie()

我们在敲代码的过程中，常常会出现这样的提示语

using Tensorflow Backend什么意思？

这个东西报错，但不知道是什么原因。可以有以下解决方法

import os
os.environ\['KERAS_BACKEND']='tensorflow'

Numpy

定义

开源的Python科学计算库，用于快速梳理任意维度的数组 numpy中，存储对象是ndarray

创建 np.array([])
numpy的优势

内存块风格——一体式存储

支持并行化运算

效率高于纯python代码——底层使用了C，内部释放了GIL

ndarray——N维数组

生成数组的方法

生成0和1的数组

# 生成1的数组
np.ones()
# 生成0的数组
np.zeros()
numpy.ones(shape,dtype=None,order='C')
-   shape：int或int的序列，为新数组的形状；如果我们仅指定一个int变量，则将返回一维数组。如果是一个整数元组，将返回给定形状的数组。
-   dtype（可选 ）：数组的所需数据类型；默认是 numpy.float64。
-   order： {‘C’，‘F’}，可选，默认值：C 是否在内存中以行主（C-风格）或列主（Fortran-风格）顺序存储多维数据。

# 将其他数字的数组全部换成1
np.ones_like()
np.zeros_like()同理
>>> x = np.arange(6)
    >>> x = x.reshape((2, 3))
    >>> x
    array([[0, 1, 2],
           [3, 4, 5]])
    >>> np.ones_like(x)
    array([[1, 1, 1],
           [1, 1, 1]])
    
    >>> y = np.arange(3, dtype=float)
    >>> y
    array([0., 1., 2.])
    >>> np.ones_like(y)
    array([1.,  1.,  1.])

2. 从现有数组中生成

np.array -- 深拷贝
np.asarray -- 浅拷贝

3. 生成固定范围数字

np.linspace(start, stop, num, endpoint, retstep, dtype, axis)
    num -- 生成等间隔的多少个
>>> np.linspace(2.0, 3.0, num=5)
    array([2.  , 2.25, 2.5 , 2.75, 3.  ])
    # 结尾的数字不算在里面
    >>> np.linspace(2.0, 3.0, num=5, endpoint=False)
    array([2. ,  2.2,  2.4,  2.6,  2.8])
    # retstep=True时，结果会显示步长
    >>> np.linspace(2.0, 3.0, num=5, retstep=True)
    (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)
np.arange(start, stop, step)
   step -- 每间隔多少生成数据
   默认从0开始
# 如果步长是浮点型，数组的数值规定要整型，那么会造成不可想象的后果，并且生成的数组长度会难以想象
>>> np.arange(0, 5, 0.5, dtype=int)
      array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
>>> np.arange(-3, 3, 0.5, dtype=int)
      array([-3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8])
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0) 生成以10的N次幂的数据
>>> np.logspace(2.0, 3.0, num=4)
    array([ 100.        ,  215.443469  ,  464.15888336, 1000.        ])
>>> np.logspace(2.0, 3.0, num=4, endpoint=False)
    array([100.        ,  177.827941  ,  316.22776602,  562.34132519])
>>> np.logspace(2.0, 3.0, num=4, base=2.0)
    array([4.        ,  5.0396842 ,  6.34960421,  8.        ])

4. 生成随机数组

均匀分布生成

np.random.uniform()
    low\high\size

正态分布

random.randn(num) # num是在(0,1)之间生成多少个数

- 均值方差
- 均值 -- 图形的左右位置
- 方差 -- 图形是瘦的还是胖的
- - 值越小，图形越瘦高，数据越集中
- - 值越大，图形越矮胖，数据越分散 -正态分布api

np.random.normal() # 正态（高斯）分布中抽取随机样本。 
low\high\size

数组的索引、切片

直接索引
先对行进行索引，再进行列索引
形状修改

对象.reshape：不进行行列互换，产生新变量

对象.resize：不进行列互换，对原值进行修改

进行行列互换

类型修改

对象.astype()

数组去重

np.unique()

ndarray运算

逻辑运算

大于，小于直接进行判断

赋值：满足要求，直接赋值

通用判断函数

np.all() 所有满足要求，才返回True

np.any() 只要有一个满足要求，就返回True

三元运算符

np.where() 满足要求，赋值第一个值，否则赋值第二个值

np.logical_and() 并

np.logical_or() 或

统计运算

min

max

midian

mean

std —— 标准差

var —— 方差

argmax —— 最大值下标

argmin —— 最小值下标

矩阵

矩阵和向量：一维二维
加法和标量相乘

加法：对应位置相加

乘法：标量和每个位置的元素相乘

矩阵向量(矩阵)乘法
矩阵乘法性质：满足结合律，不满足交换律
矩阵乘法

np.dot -- 点乘

np.matmul -- 矩阵相乘

#注意dot支持矩阵和数字相乘

转置矩阵numpy.T、numpy.transpose()

Pandas

Pandas的概念

开源的数据挖掘库
用于数据探索
封装了matplotlib,numpy

常用方法

创建DataFrame:pd.DataFrame(ndarray)
创建日期：pd.date_range(start, end, periods, freq) start -- 开始时间 end -- 结束时间 periods -- 时间跨度 freq -- 统计时间方式，默认是"D"天

pd.date_range(start='20200101',periods=5,freq='2D')

3. DataFrame介绍

对象.shape
对象.index
对象.columns
对象.values
对象.T
对象.head()
对象.tail()

DataFrame设置索引

修改行列索引：必须整行或者整列去进行修改
重设索引：对象.reset_index()
设置新索引：对象.set_index(),如果设置索引是两个的时候就是multiIndex

MultiIndex和panel -- 类别三维数组

MultiIndex 对象.index

对象.index.names

panel -- 已经弃用，了解

直接设法进行查看里面的值，需要通过索引获取

对象[:, :, ""]

序列数

pd.Series(('Nanjing', 'Hangzhou', 'Fuzhou', 'Fuzhou'), index =['a', 'b', 'c', 'd'])

DataFrame(data=None, index: 'Axes | None' = None, 
columns: 'Axes | None' = None, 
dtype: 'Dtype | None' = None, copy: 'bool | None' = None)

>>> d = {'col1': [1, 2], 'col2': [3, 4]}
 |  >>> df = pd.DataFrame(data=d)
 |  >>> df
 |     col1  col2
 |  0     1     3
 |  1     2     4

pandas画图

genre_zero.sum().sort_values(ascending=False).plot(kind="bar", figsize=(20,8), colormap="cool")

pandas索引

data_set[col][row]先列后行，不可以先行后列

先行后列 data_set.loc()可用标签表示，data_set.iloc()用索引表示，也可以用data_set.ix[:5, ("high", "low")]

K-近邻算法(KNN)

k的选择

k值过小——过拟合

k值过大——欠拟合

近似误差 ——过拟合：在训练集上表现好，在测试集上表现不好
估计误差

kd树

在PyTorch的模块（Module）中，classifier 和 feature 通常出现在卷积神经网络（CNN）模型的设计中，特别是在迁移学习中使用预训练模型时。这两个部分分别对应于模型的特征提取部分和分类部分。

Module模型中的feature和classifier

Feature Extractor（特征提取器）

特征提取器是模型的一部分，用于提取输入数据的高层次特征。通常，它由多个卷积层、池化层和激活函数组成。

重要性

自动特征提取： 特征提取器能够自动从数据中提取有用的特征，这些特征对于任务的成功至关重要。
迁移学习： 在迁移学习中，我们通常使用预训练模型的特征提取部分，因为它们在大量数据上训练过，能够提取出非常强大的特征。
减少计算量： 特征提取器的输出通常是低维的特征向量，相比于直接使用原始输入，特征向量能够减少后续分类器的计算量。

在一个卷积神经网络中，特征提取器的结构可能像这样：

self.features = nn.Sequential(
    nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding),
    nn.ReLU(inplace=True),
    nn.MaxPool2d(kernel_size, stride, padding),
    # 其他卷积层、激活函数、池化层等
)

Classifier（分类器）

分类器是模型的最后一部分，用于将特征提取器输出的高层次特征进行分类。它通常由多个全连接层（fully connected layers）和激活函数组成，有时还会包括dropout层来防止过拟合。

重要性

任务专用： 分类器通常根据具体的任务进行设计，比如二分类、多分类等。分类器将特征映射到具体的类别。
灵活性： 可以根据需要调整分类器的结构以适应不同的任务和数据集。
结合特征： 分类器将特征提取器提取的特征进行组合和变换，最终输出分类结果。

在一个卷积神经网络中，分类器的结构可能像这样：

self.classifier = nn.Sequential(
    nn.Linear(in_features, hidden_units),
    nn.ReLU(inplace=True),
    nn.Dropout(p=0.5),
    nn.Linear(hidden_units, num_classes)
)

举例说明

以下是一个使用PyTorch构建的示例模型，其中包含特征提取器和分类器：

import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super(SimpleCNN, self).__init__()
        # 特征提取部分
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        # 分类部分
        self.classifier = nn.Sequential(
            nn.Linear(128 * 8 * 8, 256),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(256, num_classes)
        )

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)  # 展平操作
        x = self.classifier(x)
        return x

# 创建模型实例
model = SimpleCNN(num_classes=10)
print(model)

在这个示例中：

特征提取器（self.features）：包含两个卷积层，每个卷积层后面跟着ReLU激活函数和MaxPool池化层。它负责从输入图像中提取特征。
分类器（self.classifier）：包含两个全连接层，第一层后面跟着ReLU激活函数和Dropout层，用于将提取的特征映射到最终的类别。

总结

特征提取器负责从输入数据中提取有用的特征。它通常由卷积层和池化层组成，提取的特征用于后续的分类。
分类器则利用提取到的特征进行分类。它通常由全连接层组成，将特征映射到具体的类别。

在模型构建中，这两者的配合是至关重要的，特征提取器负责提取有用的信息，而分类器则负责将这些信息转换为具体的预测结果。