吴恩达的机器学习

4月 11 2023 学习>AI 17 分钟 读完 (约 2575 字)

我看完了吴恩达的机器学习课程! 对初学者来说真的很不错。

概述

  • 有监督的机器学习： 回归和分类
    • 线性回归
    • 逻辑回归
    • 梯度下降
  • 高级学习算法
    • 神经网络
    • 决策树
    • 对机器学习的建议
  • 无监督学习、推荐、强化学习
    • 聚类
    • 异常情况检测
    • 协作式过滤
    • 基于内容的过滤
    • 强化学习

1️⃣ 机器学习

🌟 算法

有监督学习

  • 将输入x映射到输出y
  • 从被给予的 “正确答案 “中学习
  • 2种主要类型：
    • 回归：
      • 预测一个数
      • 无限多的可能输出
    • 分类法：
      • 预测类别(不一定是数字)
      • 小的有限数量的可能输出，如（0,1）
      • 当两个或更多的输入时：找到边界线

无监督的学习

  • 有监督学习从数据中学习标记的正确答案；
    无监督学习在无标签的数据中找到有趣的东西

  • 输入x，但没有输出标签y，它在数据中找到结构

  • 主要类型：

    • 聚类
    • 异常情况检测
    • 降维

强化学习

🌟 有监督机器学习模型

线性回归(一个变量)

  • 成本函数
  • 梯度下降
  • 学习率

多重线性回归(多个变量)

  • 矢量化
  • 特征缩放（归一化）
    • 可以使梯度下降法更快
  • 特征工程
  • 多项式回归

Logistic回归 → 分类

  • Sigmoid 函数
  • 决策边界
  • 在逻辑回归中应用梯度下降法
  • 损失和成本
    • 为了使逻辑成本函数是凸函数，使用-log和-log（1-）（损失函数）并求和
  • 比较线性回归和逻辑回归
    • 相同点
      • 学习曲线
      • 矢量化实现
      • 特征缩放
    • 不同点
      • 线性回归：$f=vec{w} \cdot \vec{x}+b$
      • Logistic回归：$f=frac{1} {1+e^{-vec{w}+b$ {1+e^{-vec{w}. \cdot \vec{x}. + b}}$
  • 过拟合
    • 解决过拟合的问题
      • 收集更多的训练实例
      • 选择特征
      • 正则化：减少参数$w_j$的大小
    • 正则化

2️⃣ TensorFlow中的神经网络

Numpy数组和Tensors

1
2
3
4
5
6
7
8
x = np.array([200.0, 17.0])
layer_1 = Dense(units=3, activation='sigmoid')
a1 = layer_1(x)
# print(a1)
# -> tf.Tensor([[0.2 0.7 0.3]], shape=（1,3）, dtype=float32
a1.numpy()
# print(a1)
# -> 数组(...)

在TensorFlow中训练一个神经网络

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layer import Dense

# 第一步：指定模型
model = Sequential([
Dense(units=25, activation='relu')
Dense(units=15, activation='relu')
Dense(units=1, activation='sigmoid')
)]

# 第二步：编译模型
from tensorfolw.keras.loss import BinaryCrossentropy
model.compile(loss=BinaryCrossentrpy())

# 第三步：训练模型
model.fit(X, Y, epochs=100)

选择一个激活函数

外层

对于二进制分类，使用sigmoid函数

对于回归(+/-)，使用线性函数

对于回归（+），使用ReLU函数

隐藏层

ReLU是最常见的选择

多类分类： Softmax

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layer import Dense

model = Sequential([
Dense(units=25, activation='relu')
Dense(units=15, activation='relu')
Dense(units=10, activation='softmax')
)]

from tensorfolw.keras.loss import SparseCategoricalCrossentropy
model.compile(loss=SparseCategoricalCrossentrpy())

model.fit(X, Y, epochs=100)

但是不要使用这个版本!

更精确的实现

对于逻辑回归的损失函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import tensorflow as tf
from tensorflow.keras import Sequential
从tensorflow.keras.layer导入Dense

model = Sequential([
Dense(units=25, activation='relu')
Dense(units=15, activation='relu')
Dense(units=1, activation='linear')
)]

from tensorfolw.keras.loss import BinaryCrossentropy
model.compile(loss=BinaryCrossentrpy(from_logits=True))

model.fit(X, Y, epochs=100)

对于softmax 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layer import Dense

model = Sequential([
Dense(units=25, activation='relu')
Dense(units=15, activation='relu')
Dense(units=10, activation='linear')
)]

from tensorfolw.keras.loss import SparseCategoricalCrossentropy
model.compile(loss=SparseCategoricalCrossentrpy(from_logits=True))

model.fit(X, Y, epochs=100)

# 预测
logits = model(X)
f_x = tf.nn.softmax(logits)

Adam算法

Adam：Adaptive Moment estimation，自适应时刻估计

适应性地改变学习率；更快

1
2
3
4
5
6
7
8
9
10
11
12
13
# 模型
model = Sequential([
Dense(units=25, activation='sigmoid')
Dense(units=15, activation='sigmoid')
密集(单位=10, 激活='线性')
)]

# 编译
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3)、
loss=tf.keras.loss.SparseCategoricalCrossentropy(from_logits=True))

# 拟合
model.fit(X, Y, epochs=100)

卷积层

每个神经元只对前一层输入的部分进行操作

计算速度更快；需要的训练数据更少（不容易出现过拟合现象）

评估一个模型

将数据分成三部分：

  • 训练集
  • 交叉验证集（验证/开发/设计集）
  • 测试集

当你对模型做决定时，只使用训练集和开发集，而完全不看测试集。在你决定了最终的模型后，在测试集上评估它

偏倚/方差

偏差是训练误差与基线的差距

方差是交叉验证误差和基线的差距

正则化

1
layer = Dense(units=25, activation="relu", kernel_regularizer=L2(0.01))

转移学习

  1. 下载神经网络参数，在大型数据集上进行预训练，数据集的输入类型与你的应用程序相同（例如，图像、音频、文本）
  2. 在你自己的数据上微调网络

一个机器学习项目的整个周期

  1. 定义项目
  2. 定义并收集数据
  3. 培训、错误分析和迭代改进
  4. 部署、监控和维护系统

混淆矩阵，精度，召回率

精确率=真阳性/（预测的阳性）=真阳性/（真阳性+假阳性)

召回率=真阳性/（实际阳性）=真阳性/（真阳性+假阴性)

权衡：
高阈值→较高的精度，较低的召回率；
低阈值→较低的精度，较高的召回率

F1 score = $\frac{1}{\frac{1}{2}(\frac{1}{P}+\frac{1}{R})}$ 计算一个平均值，更关注低者（P和R的调和平均值）

决策树模型

决策树预测类别的情况

回归树预测数量

树集（更稳健；使用替换抽样）：

  • 随机森林
  • XGBoost (eXtreme Gradient Boosting)：更有可能挑选以前训练的树**错误分类的例子
1
2
3
4
5
6
7
8
9
10
11
# 分类
from xgboost import XGBClassifier
model = XGBClassifier()
model.fit(X_train, y_train)
y_pred = model.pred(X_test)

# 回归
from xgboost import XGBRegressor
model = XGBRegressor()
model.fit(X_train, y_train)
y_pred = model.pred(X_test)

决策树与神经网络：

决策树 神经网络
在哪些数据上工作良好 结构化（表格）数据 结构化数据和非结构化（图像、音频、文本）数据
速度 快速 可能较慢
转移学习 不 是
可解释性 也许是 不是
构建一个由多个模型组成的系统 困难 容易

3️⃣ 无监督学习

聚类

K-means

第1步：随机初始化K簇中心点；

第2步：将每个点分配给其最近的中心点；

第3步：重新计算中心点，直到它们趋于一致。

如何选择K？

  • 肘部方法
  • 根据K-means的对后面的目的的性能如何来评估它

异常情况检测

第一步：选择n个你认为可能表明异常例子的特征；

第2步：拟合一个高斯分布；

第3步：给定新的例子x，计算p(x)，如果p(x)< epsilon，则为异常

异常检测 监督学习
大量的负面例子（y=0），极少的正面例子（y=1） 大量的正面和负面例子
未来的正面例子：以前没有见过，全新的 未来的正面例子：以前见过，类似的

推荐系统

协作式过滤

  • 查找相关项目
  • 自动找到导数
1
2
3
4
5
6
7
8
9
10
11
12
13
w = tf.Variable(3.0)
x = 1.0
y = 1.0
alpha = 0.01

# 自动差分
iteration = 30
for iter in range(iteration)：
	with tf.GradientTape() as tape：
		fwb = w*x
		costJ = (fwb - y)**2
	[dJdw] = tape.gradient(costJ, [w])
	w.assign_add(-alpha*dJdw)

也可以使用Adam优化算法

基于内容的过滤 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
user_NN = tf.keras.models.Sequential([
    tf.keras.layer.Dense(256, activation='relu')、
    tf.keras.layer.Dense(128, activation='relu')、
    tf.keras.layer.Dense(32)
])

item_NN = tf.keras.models.Sequential([
    tf.keras.layer.Dense(256, activation='relu')、
    tf.keras.layer.Dense(128, activation='relu')、
    tf.keras.layer.Dense(32)
])

input_user = tf.keras.layer.Input(shape=(num_user_features))
vu = user_NN(input_user)
vu = tf.linalg.l2_normalize(vu, axis=1)

input_item = tf.keras.layer.Input(shape=（num_item_features）)
vm = item_NN(input_item)
vm = tf.linalg.l2_normalize(vm, axis=1)

output = tf.keras.layer.Dot(axes=1)([vu, vm])

model = Model([input_user, input_item], output)

cost_fn = tf.keras.loss.MeanSquaredError()
协同过滤 基于内容的过滤
推荐依据是 给予你类似评价的用户的评价 用户和物品的特征，以找到一个好的匹配对象

均值化使算法更快、更好

强化学习

奖励机制

“好狗狗”，”坏狗狗”

回报

回报是奖励的总和，由折扣系数加权

它取决于你所采取的行动

策略

策略是函数pi(s)=a，一个从状态到行动的映射

强化学习的目标是找到一个策略pi，以使回报最大化

马尔可夫决策过程（MDP）

“马尔科夫 “指的是未来只取决于当前的状态，而不取决于在达到当前状态之前可能发生的任何事情

在MDP中，未来只取决于你现在的位置，而不取决于你是如何得到的

状态价值函数（Q-函数）

Q(s, a) = 返回值，如果你：

  • 开始于状态s
  • 采取行动a（一次）
  • 然后在此后的行为是最佳的

状态s的最佳可能回报是maxQ(s, a)

在s状态下，可能的最佳行动是能给出maxQ(s, a)的行动a

贝尔曼方程

Q(s, a) = R(s) + gamma*maxQ(s’, a’)

  • R(s)是你马上就能得到的奖励
  • gamma*maxQ(s’, a’) 是从下一个状态s’开始的最佳行为的奖励。

DQ算法 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Initialize neural network randomly as guess of Q(s,a).
Repeat{

    Take actions in the lunar lander. Get (s, a, R(s), s’).

    Store 10000 most recent (s, a, R(s), s’) tuples.

    Train neural network:

        Create training set of 10000 examples using

        x = (s, a) and y = R(s) + gamma * maxQ(s’, a’)

        Train Q_new such that Q_new (s, a) = y.

    Set Q = Q_new. 
}

改进

  • Epsilon-贪婪策略

例如epsilon = 0.05，这意味着

以0.95的概率，选取使Q(s, a)最大化的行动a，贪婪地”剥削”

以0.05的概率，随机选取一个选项a，”探索”

一开始最好把epsilon设置得很高，然后逐渐降低

  • 批量法

更快

  • 软更新

将 “set Q = Q_new”（即W,B = W_new,B_new）改为

W = 0.01W_new + 0.99W
B = 0.01B_new + 0.99B

#机器学习
电子学基础 2023年3月

评论

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×