机器学习是数据科学的核心领域，涉及多种算法和方法。本文将介绍10个常用的机器学习模型的基础实现。
1. 线性回归
基本原理
线性回归是一种用于预测连续型变量的模型，通过拟合输入特征与输出变量之间的线性关系来进行预测。
实现过程
-
数据准备：收集并清洗数据。
-
特征选择：选择与目标变量相关的特征。
-
模型训练：使用最小二乘法拟合模型。
-
模型评估：使用均方误差等指标评估模型性能。
代码实现
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
# 设置随机种子
np.random.seed(42)
# 生成示例数据
X = np.random.rand(100, 1) * 10
y = 2.5 * X + np.random.randn(100, 1) * 2
# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=4)
# 创建模型并训练
model = LinearRegression()
model.fit(X_train, y_train)
# 预测
y_pred = model.predict(X_test)
# 评估
mse = mean_squared_error(y_test, y_pred)
print(f"均方误差: {mse}")2. 逻辑回归
基本原理
逻辑回归用于二分类问题，通过sigmoid函数将线性组合的输入映射到0和1之间的概率值。
实现过程
-
数据准备：收集并清洗数据。
-
特征选择：选择与目标变量相关的特征。
-
模型训练：使用最大似然估计拟合模型。
-
模型评估：使用准确率、召回率等指标评估模型性能。
代码实现
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
# 加载数据集
iris = load_iris()
X = iris.data
y = (iris.target == 0).astype(int) # 二分类
# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=4)
# 创建模型并训练
model = LogisticRegression()
model.fit(X_train, y_train)
# 预测
y_pred = model.predict(X_test)
# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy}")3. 决策树
基本原理
决策树通过树形结构进行决策，使用特征的值来分割数据，直到达到叶子节点。
实现过程
-
数据准备：收集并清洗数据。
-
特征选择：选择用于分割的特征。
-
模型训练：构建决策树模型。
-
模型评估：使用准确率、F1分数等指标评估模型性能。
代码实现
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target
# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=4)
# 创建模型并训练
model = DecisionTreeClassifier(random_state=42)
model.fit(X_train, y_train)
# 预测
y_pred = model.predict(X_test)
# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy}")4. 随机森林
基本原理
随机森林是集成学习方法，通过构建多个决策树并结合它们的预测结果来提高模型的准确性和鲁棒性。
实现过程
-
数据准备：收集并清洗数据。
-
特征选择：选择用于训练的特征。
-
模型训练：构建多个决策树并进行投票。
-
模型评估：使用准确率、AUC等指标评估模型性能。
代码实现
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target
# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=4)
# 创建模型并训练
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)
# 预测
y_pred = model.predict(X_test)
# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy}")5. 支持向量机（SVM）
基本原理
支持向量机通过寻找最佳超平面来分割不同类别的数据点，最大化类别间的间隔。
实现过程
-
数据准备：收集并清洗数据。
-
特征选择：选择用于训练的特征。
-
模型训练：使用核函数将数据映射到高维空间。
-
模型评估：使用准确率、混淆矩阵等指标评估模型性能。
代码实现
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
# 加载数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target
# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 创建模型并训练
model = SVC(random_state=42)
model.fit(X_train, y_train)
# 预测
y_pred = model.predict(X_test)
# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy}")6. K近邻（KNN）
基本原理
K近邻算法通过计算样本之间的距离来进行分类，选择最近的K个邻居进行投票。
实现过程
-
数据准备：收集并清洗数据。
-
特征选择：选择用于训练的特征。
-
模型训练：存储训练数据。
-
模型评估：使用准确率、F1分数等指标评估模型性能。
代码实现
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target
# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=4)
# 创建模型并训练
model = KNeighborsClassifier(n_neighbors=3)
model.fit(X_train, y_train)
# 预测
y_pred = model.predict(X_test)
# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy}")7. 梯度提升树（GBDT）
基本原理
梯度提升树通过逐步构建决策树，每棵树都在前一棵树的基础上进行改进，以减少预测误差。
实现过程
-
数据准备：收集并清洗数据。
-
特征选择：选择用于训练的特征。
-
模型训练：逐步构建决策树。
-
模型评估：使用准确率、AUC等指标评估模型性能。
代码实现
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target
# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 创建模型并训练
model = GradientBoostingClassifier(random_state=42)
model.fit(X_train, y_train)
# 预测
y_pred = model.predict(X_test)
# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy}")8. XGBoost
基本原理
XGBoost是梯度提升树的优化版本，具有更高的计算效率和更好的性能。
实现过程
-
数据准备：收集并清洗数据。
-
特征选择：选择用于训练的特征。
-
模型训练：使用XGBoost算法构建模型。
-
模型评估：使用准确率、AUC等指标评估模型性能。
代码实现
import xgboost as xgb
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target
# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=4)
# 创建模型并训练
model = xgb.XGBClassifier(random_state=42)
model.fit(X_train, y_train)
# 预测
y_pred = model.predict(X_test)
# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy}")9. 神经网络
基本原理
神经网络通过模拟人脑神经元的连接来进行学习，适用于复杂的非线性问题。
实现过程
-
数据准备：收集并清洗数据。
-
特征选择：选择用于训练的特征。
-
模型训练：使用反向传播算法训练网络。
-
模型评估：使用准确率、损失函数等指标评估模型性能。
代码实现
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score
# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target
# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=4)
# 创建模型并训练
model = MLPClassifier(random_state=4)
model.fit(X_train, y_train)
# 预测
y_pred = model.predict(X_test)
# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy}")10. K均值聚类
基本原理
K均值聚类通过将数据点分为K个簇，使得同一簇内的数据点相似度高，而不同簇之间的数据点相似度低。
实现过程
-
数据准备：收集并清洗数据。
-
特征选择：选择用于聚类的特征。
-
模型训练：使用K均值算法进行聚类。
-
模型评估：使用轮廓系数等指标评估聚类效果
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from typing import List, Tuple, Optional
# 设置中文显示
plt.rcParams["font.family"] = ["SimHei", "WenQuanYi Micro Hei", "Heiti TC"]
plt.rcParams['axes.unicode_minus'] = False
class KMeans:
"""
K-Means聚类算法实现
参数:
- k: 聚类的数量
- max_iters: 最大迭代次数
- plot_steps: 是否在每次迭代后可视化
"""
def __init__(self, k: int = 3, max_iters: int = 100, plot_steps: bool = False):
self.k = k
self.max_iters = max_iters
self.plot_steps = plot_steps
# 聚类结果
self.centroids: np.ndarray = None
self.clusters: List[List[int]] = [[] for _ in range(self.k)]
self.labels: np.ndarray = None
def _initialize_centroids(self, X: np.ndarray) -> None:
"""随机初始化k个质心"""
indices = np.random.choice(len(X), self.k, replace=False)
self.centroids = X[indices]
def _compute_distances(self, sample: np.ndarray) -> np.ndarray:
"""计算样本到所有质心的欧氏距离"""
return np.array([np.linalg.norm(sample - centroid) for centroid in self.centroids])
def _create_clusters(self, X: np.ndarray) -> None:
"""根据最近质心分配样本到聚类"""
self.clusters = [[] for _ in range(self.k)]
for idx, sample in enumerate(X):
centroid_idx = np.argmin(self._compute_distances(sample))
self.clusters[centroid_idx].append(idx)
def _update_centroids(self, X: np.ndarray) -> None:
"""根据当前聚类更新质心位置"""
new_centroids = np.zeros((self.k, X.shape[1]))
for i, cluster_indices in enumerate(self.clusters):
if cluster_indices: # 确保聚类不为空
new_centroids[i] = np.mean(X[cluster_indices], axis=0)
self.centroids = new_centroids
def _is_converged(self, previous_centroids: np.ndarray) -> bool:
"""检查质心是否收敛"""
return np.allclose(previous_centroids, self.centroids)
def _get_cluster_labels(self, X: np.ndarray) -> np.ndarray:
"""为每个样本分配聚类标签"""
labels = np.zeros(len(X), dtype=int)
for cluster_idx, cluster_indices in enumerate(self.clusters):
labels[cluster_indices] = cluster_idx
return labels
def fit(self, X: np.ndarray) -> 'KMeans':
"""训练K-Means模型"""
# 初始化质心
self._initialize_centroids(X)
# 迭代优化
for iteration in range(self.max_iters):
previous_centroids = self.centroids.copy()
# 分配样本到聚类
self._create_clusters(X)
# 更新质心
self._update_centroids(X)
# 可视化中间步骤
if self.plot_steps:
self._visualize_clusters(X, iteration)
# 检查收敛
if self._is_converged(previous_centroids):
print(f"在第 {iteration+1} 次迭代后收敛")
break
# 保存最终标签
self.labels = self._get_cluster_labels(X)
return self
def predict(self, X: np.ndarray) -> np.ndarray:
"""预测新样本的聚类"""
if self.centroids is None:
raise ValueError("模型尚未训练，请先调用fit方法")
labels = np.zeros(len(X), dtype=int)
for idx, sample in enumerate(X):
labels[idx] = np.argmin(self._compute_distances(sample))
return labels
def _visualize_clusters(self, X: np.ndarray, iteration: int) -> None:
"""可视化当前聚类状态"""
plt.figure(figsize=(10, 7))
# 绘制每个聚类的点
colors = plt.cm.rainbow(np.linspace(0, 1, self.k))
for i, cluster_indices in enumerate(self.clusters):
if cluster_indices:
plt.scatter(X[cluster_indices, 0], X[cluster_indices, 1],
s=50, c=[colors[i]], label=f'聚类 {i+1}')
# 绘制质心
plt.scatter(self.centroids[:, 0], self.centroids[:, 1],
s=200, marker='X', c='black', edgecolor='white', label='质心')
plt.title(f'K-Means聚类 - 迭代 {iteration+1}')
plt.xlabel('特征1')
plt.ylabel('特征2')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()
def visualize_results(self, X: np.ndarray) -> None:
"""可视化最终聚类结果"""
if self.labels is None:
raise ValueError("模型尚未训练，请先调用fit方法")
plt.figure(figsize=(10, 7))
# 绘制聚类结果
colors = plt.cm.rainbow(np.linspace(0, 1, self.k))
for i in range(self.k):
cluster_indices = np.where(self.labels == i)[0]
plt.scatter(X[cluster_indices, 0], X[cluster_indices, 1],
s=50, c=[colors[i]], label=f'聚类 {i+1}')
# 绘制质心
plt.scatter(self.centroids[:, 0], self.centroids[:, 1],
s=200, marker='X', c='black', edgecolor='white', label='质心')
plt.title('K-Means聚类结果')
plt.xlabel('特征1')
plt.ylabel('特征2')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()
def generate_sample_data(n_samples: int = 300, n_centers: int = 4) -> np.ndarray:
"""生成样本数据用于聚类"""
X, _ = make_blobs(n_samples=n_samples, centers=n_centers,
cluster_std=0.60, random_state=0)
return X
if __name__ == "__main__":
# 生成样本数据
X = generate_sample_data(n_samples=300, n_centers=4)
# 初始化并训练KMeans模型
kmeans = KMeans(k=4, max_iters=150, plot_steps=False)
kmeans.fit(X)
# 可视化最终结果
kmeans.visualize_results(X)
# 计算并打印聚类的统计信息
for i, cluster_indices in enumerate(kmeans.clusters):
print(f"聚类 {i+1} 包含 {len(cluster_indices)} 个样本")以上介绍了10个机器学习常用模型的原理及基础实现过程，实际项目中需要加上数据处理、调参等必要的过程，才能实现一个完整的机器学习模型。
扫一扫
2131
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
