机器学习几大算法
1. 线性回归
回归模型通常包括以下要素：
因变量（Dependent Variable）：我们试图预测或解释的变量
自变量（Independent Variables）：用于预测因变量的特征
参数（Parameters）：决定模型形状的系数
误差项（Error Term）：表示模型与真实值之间的偏差
回归模型的一般形式
我们可以将回归模型形式化为：
y_i = f(α, X_i) + e_i
其中：
y_i 是第 i 个观测的因变量
X_i 是第 i 个观测的自变量向量
α 是模型参数
e_i 是误差项
线性回归
sklean示例
from sklearn import linear_model, datasets
digits = datasets.load_digits()
# 创建线性回归模型
clf = linear_model.LinearRegression()
# 设置训练数据集
x, y = digits.data[:-1], digits.target[:-1]
print(x[:3])
print(y)
# 训练
clf.fit(X=x, y=y)
# 预测
y_pred = clf.predict([digits.data[-1]])
y_true = digits.target[-1]
# 打印
print(y_pred)
print(y_true)
[[ 0. 0. 5. 13. 9. 1. 0. 0. 0. 0. 13. 15. 10. 15. 5. 0. 0. 3.
15. 2. 0. 11. 8. 0. 0. 4. 12. 0. 0. 8. 8. 0. 0. 5. 8. 0.
0. 9. 8. 0. 0. 4. 11. 0. 1. 12. 7. 0. 0. 2. 14. 5. 10. 12.
0. 0. 0. 0. 6. 13. 10. 0. 0. 0.]
[ 0. 0. 0. 12. 13. 5. 0. 0. 0. 0. 0. 11. 16. 9. 0. 0. 0. 0.
3. 15. 16. 6. 0. 0. 0. 7. 15. 16. 16. 2. 0. 0. 0. 0. 1. 16.
16. 3. 0. 0. 0. 0. 1. 16. 16. 6. 0. 0. 0. 0. 1. 16. 16. 6.
0. 0. 0. 0. 0. 11. 16. 10. 0. 0.]
[ 0. 0. 0. 4. 15. 12. 0. 0. 0. 0. 3. 16. 15. 14. 0. 0. 0. 0.
8. 13. 8. 16. 0. 0. 0. 0. 1. 6. 15. 11. 0. 0. 0. 1. 8. 13.
15. 1. 0. 0. 0. 9. 16. 16. 5. 0. 0. 0. 0. 3. 13. 16. 16. 11.
5. 0. 0. 0. 0. 3. 11. 16. 9. 0.]]
[0 1 2 ... 0 8 9]
[8.86342983]
8
torch示例
from typing import Any
import torch.nn as nn
import torch
# 随机种子，确保每次运行结果一致
torch.manual_seed(42)
# 生成训练数据
X = torch.randn(100, 64) # 100 个样本，每个样本 2 个特征
true_w = torch.rand(64, 1) # 假设真实权重
true_b = 4.0 # 偏置项
Y = X @ true_w + true_b + torch.randn(100) * 0.1 # 加入一些噪声
# print(X[:3])
print(Y[:3])
# 线性回归模型
class LinearRegresssionModel(nn.Module):
def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
self.linear = nn.Linear(64, 1) ## 输入dim64 输出dim1
def forward(self, x):
return self.linear(x)
model = LinearRegresssionModel()
#损失函数， 均方误差（衡量与真实值之间的差别）
criterion = nn.MSELoss()
#优化器
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
num_epoch = 1000
for epoch in range(num_epoch):
model.train()
# ## 前向船舶
predictions = model(X)
# 计算损失
loss = criterion(predictions.squeeze(), Y)
loss.backward()
optimizer.step()
if (epoch + 1) % 100 == 0:
print(f'Epoch [{epoch + 1}/1000], Loss: {loss.item():.4f}')
Epoch [100/1000], Loss: 31.5983
Epoch [200/1000], Loss: 32.8814
Epoch [300/1000], Loss: 42.8966
Epoch [400/1000], Loss: 45.2065
Epoch [500/1000], Loss: 66.0202
Epoch [600/1000], Loss: 73.6008
Epoch [700/1000], Loss: 81.4987
Epoch [800/1000], Loss: 94.4239
Epoch [900/1000], Loss: 92.4854
Epoch [1000/1000], Loss: 101.3023
2. 支持向量机算法SVM（Support Vector Matchine）
支持向量机/网络算法(SVM)属于分类型算法。SVM模型将实例表示为空间中的点，将使用一条直线分隔数据点。需要注意的是，支持向量机需要对输入数据进行完全标记，仅直接适用于两类任务，应用将多类任务需要减少到几个二元问题。
sklean实现
from sklearn import svm, datasets
# 加载数据
digits = datasets.load_diabetes()
# 创建分类器
clf = svm.SVC(gamma=0.001, C=100)
# 设置训练数据
x, y = digits.data[:-1], digits.target[:-1]
print(x[:3])
#训练
clf.fit(x ,y)
#预测
y_pred = clf.predict([digits.data[-1]])
print(y_pred)
[[ 0.03807591 0.05068012 0.06169621 0.02187239 -0.0442235 -0.03482076
-0.04340085 -0.00259226 0.01990749 -0.01764613]
[-0.00188202 -0.04464164 -0.05147406 -0.02632753 -0.00844872 -0.01916334
0.07441156 -0.03949338 -0.06833155 -0.09220405]
[ 0.08529891 0.05068012 0.04445121 -0.00567042 -0.04559945 -0.03419447
-0.03235593 -0.00259226 0.00286131 -0.02593034]]
[72.]
3. K邻近算法KNN（K-Nearest Neighbors）
KNN算法是一种基于实例的学习，或者是局部近似和将所有计算推迟到分类之后的惰性学习。用最近的邻居（k）来预测未知数据点。k 值是预测精度的一个关键因素，无论是分类还是回归，衡量邻居的权重都非常有用，较近邻居的权重比较远邻居的权重大。KNN 算法的缺点是对数据的局部结构非常敏感。计算量大，需要对数据进行规范化处理，使每个数据点都在相同的范围。
分类：
回归：
sklearn示例
from sklearn import datasets, neighbors
digits = datasets.load_digits()
clf = neighbors.KNeighborsClassifier(n_neighbors=6)
x, y = digits.data[:-1], digits.target[:-1]
print(x[:3])
print(y[:3])
clf.fit(x, y)
y_pred = clf.predict([digits.data[-1]])
print(y_pred)
[[ 0. 0. 5. 13. 9. 1. 0. 0. 0. 0. 13. 15. 10. 15. 5. 0. 0. 3.
15. 2. 0. 11. 8. 0. 0. 4. 12. 0. 0. 8. 8. 0. 0. 5. 8. 0.
0. 9. 8. 0. 0. 4. 11. 0. 1. 12. 7. 0. 0. 2. 14. 5. 10. 12.
0. 0. 0. 0. 6. 13. 10. 0. 0. 0.]
[ 0. 0. 0. 12. 13. 5. 0. 0. 0. 0. 0. 11. 16. 9. 0. 0. 0. 0.
3. 15. 16. 6. 0. 0. 0. 7. 15. 16. 16. 2. 0. 0. 0. 0. 1. 16.
16. 3. 0. 0. 0. 0. 1. 16. 16. 6. 0. 0. 0. 0. 1. 16. 16. 6.
0. 0. 0. 0. 0. 11. 16. 10. 0. 0.]
[ 0. 0. 0. 4. 15. 12. 0. 0. 0. 0. 3. 16. 15. 14. 0. 0. 0. 0.
8. 13. 8. 16. 0. 0. 0. 0. 1. 6. 15. 11. 0. 0. 0. 1. 8. 13.
15. 1. 0. 0. 0. 9. 16. 16. 5. 0. 0. 0. 0. 3. 13. 16. 16. 11.
5. 0. 0. 0. 0. 3. 11. 16. 9. 0.]]
[0 1 2]
[8]
4. 逻辑回归
逻辑回归算法（Logistic Regression）一般用于需要明确输出的场景，如某些事件的发生（预测是否会发生降雨）。通常，逻辑回归使用某种函数将概率值压缩到某一特定范围。
例如，Sigmoid 函数（S 函数）是一种具有 S 形曲线、用于二元分类的函数。它将发生某事件的概率值转换为 0, 1 的范围表示。
Y = E ^（b0＋b1 x）/（1 + E ^（b0＋b1 x ））
以上是一个简单的逻辑回归方程，B0，B1是常数。这些常数值将被计算获得，以确保预测值和实际值之间的误差最小。
sklean实现
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
# 示例数据
X = np.array([[3.78], [2.44], [2.09], [0.14], [1.72], [1.65], [4.92], [4.37], [4.96], [4.52], [3.69], [5.88]])
y = np.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1])
# 标准化/缩放
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
print(X_scaled)
# 训练逻辑回归模型
logr = LogisticRegression()
logr.fit(X_scaled, y)
# 输出系数与偏置
print("逻辑回归系数 w:", logr.coef_)
print("偏置 b:", logr.intercept_)
y_pred = logr.predict(X=[[3.78]])
print("预测结果：", y_pred)
[[ 0.26357892]
[-0.55148821]
[-0.76437888]
[-1.95048403]
[-0.98943473]
[-1.03201286]
[ 0.95699424]
[ 0.62245176]
[ 0.98132461]
[ 0.71369062]
[ 0.20883561]
[ 1.54092293]]
逻辑回归系数 w: [[1.55267627]]
偏置 b: [-0.06769016]
预测结果： [1]
5. 决策树算法（Decision Tree）
决策树（Decision tree）是一种特殊的树结构，由一个决策图和可能的结果（例如成本和风险）组成，用来辅助决策。机器学习中，决策树是一个预测模型，树中每个节点表示某个对象，而每个分叉路径则代表某个可能的属性值，而每个叶节点则对应从根节点到该叶节点所经历的路径所表示的对象的值。决策树仅有单一输出，通常该算法用于解决分类问题。
一个决策树包含三种类型的节点：
决策节点：通常用矩形框来表示
机会节点：通常用圆圈来表示
终结点：通常用三角形来表示
简单决策树算法案例，确定人群中谁喜欢使用信用卡。考虑人群的年龄和婚姻状况，如果年龄在30岁或是已婚，人们更倾向于选择信用卡，反之则更少。
通过确定合适的属性来定义更多的类别，可以进一步扩展此决策树。在这个例子中，如果一个人结婚了，他超过30岁，他们更有可能拥有信用卡（100% 偏好）。测试数据用于生成决策树。
通常用作分类和回归
sklearn示例
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
iris = load_iris()
X, y = iris.data, iris.target
# 分类
print(X[:1])
clf = DecisionTreeClassifier()
clf.fit(X, y)
y_pred_proba = clf.predict_proba([[2, 1, 1, 1]])
y_pred = clf.predict([[2, 1, 1, 1]])
print(y_pred_proba)
print(y_pred)
# 回归
clf = DecisionTreeRegressor()
clf.fit(X, y)
y_pred = clf.predict([[2, 1, 1, 1]])
print(y_pred)
[[5.1 3.5 1.4 0.2]]
[[1. 0. 0.]]
[0]
[0.]
6. K平均算法 k-Means
k-平均算法(K-Means)是一种无监督学习算法，为聚类问题提供了一种解决方案。
K-Means 算法把 n 个点（可以是样本的一次观察或一个实例）划分到 k 个集群（cluster），使得每个点都属于离他最近的均值（即聚类中心，centroid）对应的集群。重复上述过程一直持续到重心不改变。
7. 随机森林算法 Random Forest
随机森林算法（Random Forest）的名称由 1995 年由贝尔实验室提出的random decision forests 而来，正如它的名字所说的那样，随机森林可以看作一个决策树的集合。
随机森林中每棵决策树估计一个分类，这个过程称为“投票（vote）”。理想情况下，我们根据每棵决策树的每个投票，选择最多投票的分类。
sklearn示例
from sklearn.ensemble import RandomForestClassifier
X = [[0, 0], [1, 1]]
Y = [0, 1]
clf = RandomForestClassifier(n_estimators=10)
clf = clf.fit(X, Y)
8. 朴素贝叶斯
朴素贝叶斯算法（Naive Bayes）基于概率论的贝叶斯定理，应用非常广泛，从文本分类、垃圾邮件过滤器、医疗诊断等等。朴素贝叶斯适用于特征之间的相互独立的场景，例如利用花瓣的长度和宽度来预测花的类型。“朴素”的内涵可以理解为特征和特征之间独立性强。
与朴素贝叶斯算法密切相关的一个概念是最大似然估计(Maximum likelihood estimation)，历史上大部分的最大似然估计理论也都是在贝叶斯统计中得到大发展。例如，建立人口身高模型，很难有人力与物力去统计全国每个人的身高，但是可以通过采样，获取部分人的身高，然后通过最大似然估计来获取分布的均值与方差。
sklearn示例
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)
gnb = GaussianNB()
y_pred = gnb.fit(X_train, y_train).predict(X_test)
print("Number of mislabeled points out of a total %d points : %d"
% (X_test.shape[0], (y_test != y_pred).sum()))
Number of mislabeled points out of a total 75 points : 4