安徽鲲鹏建设集团有限公司网站,电商推广平台有哪些,满版网页设计欣赏,html的网站案例机器学习入门指南#xff1a;常见算法详解与代码实现
机器学习#xff08;Machine Learning, ML#xff09;是人工智能#xff08;AI#xff09;的一个重要分支#xff0c;旨在通过数据驱动的方法让计算机系统自动学习和改进。对于刚接触机器学习的朋友来说#xff0c;…机器学习入门指南常见算法详解与代码实现
机器学习Machine Learning, ML是人工智能AI的一个重要分支旨在通过数据驱动的方法让计算机系统自动学习和改进。对于刚接触机器学习的朋友来说了解各种算法的基本原理及其实现方法至关重要。本篇文章将通俗易懂地介绍几种常见的机器学习算法解释其背后的数学原理并提供简单的代码示例帮助你更好地理解这些算法的工作机制。
目录
什么是机器学习监督学习与无监督学习常见机器学习算法详解 1. 线性回归Linear Regression2. 逻辑回归Logistic Regression3. 决策树Decision Tree4. K近邻算法K-Nearest Neighbors, KNN5. 支持向量机Support Vector Machine, SVM6. 神经网络Neural Networks 结语 什么是机器学习
机器学习是一种通过数据训练模型使其能够从数据中学习规律并做出预测或决策的技术。与传统编程不同机器学习不需要明确编写每一步的操作逻辑而是通过大量的数据样本让模型自动发现和学习其中的模式。
机器学习的分类
机器学习主要分为以下几类 监督学习Supervised Learning模型在有标签的数据上进行训练目标是学习输入与输出之间的映射关系。常见任务包括分类和回归。 无监督学习Unsupervised Learning模型在无标签的数据上进行训练目标是发现数据的内在结构。常见任务包括聚类和降维。 半监督学习Semi-Supervised Learning结合有标签和无标签的数据进行训练。 强化学习Reinforcement Learning模型通过与环境的互动通过试错方式学习最优策略。
本文主要聚焦于监督学习中的几种常见算法。
监督学习与无监督学习
监督学习
监督学习依赖于标注的数据进行训练每个训练样本都包含输入特征和对应的输出标签。模型的目标是学习输入与输出之间的关系以便在新的、未见过的数据上进行预测。
常见应用
分类例如垃圾邮件检测垃圾邮件 vs. 非垃圾邮件、图像识别猫 vs. 狗。回归例如房价预测、股票价格预测。
无监督学习
无监督学习处理的是未标注的数据模型需要自行发现数据中的结构或模式。
常见应用
聚类例如客户分群、图像分割。降维例如主成分分析PCA、t-SNE用于数据可视化。
常见机器学习算法详解
下面我们将详细介绍几种常见的监督学习算法解释其基本原理并通过简单的代码示例展示如何实现这些算法。
1. 线性回归Linear Regression
原理概述
线性回归是一种用于回归任务的算法旨在找到输入特征与输出目标之间的线性关系。其目标是拟合一条直线使得预测值与真实值之间的误差最小。
数学公式
假设我们有一个输入特征向量 x [ x 1 , x 2 , … , x n ] \mathbf{x} [x_1, x_2, \dots, x_n] x[x1,x2,…,xn]线性回归模型的预测输出 y ^ \hat{y} y^ 表示为 y ^ θ 0 θ 1 x 1 θ 2 x 2 ⋯ θ n x n θ T x \hat{y} \theta_0 \theta_1 x_1 \theta_2 x_2 \dots \theta_n x_n \mathbf{\theta}^T \mathbf{x} y^θ0θ1x1θ2x2⋯θnxnθTx
其中 θ [ θ 0 , θ 1 , … , θ n ] \mathbf{\theta} [\theta_0, \theta_1, \dots, \theta_n] θ[θ0,θ1,…,θn] 是模型参数。
损失函数
线性回归通常使用均方误差Mean Squared Error, MSE作为损失函数 MSE 1 m ∑ i 1 m ( y ( i ) − y ^ ( i ) ) 2 \text{MSE} \frac{1}{m} \sum_{i1}^{m} (y^{(i)} - \hat{y}^{(i)})^2 MSEm1i1∑m(y(i)−y^(i))2
代码实现
下面是一个简单的线性回归实现使用梯度下降法优化模型参数
import numpy as np
import matplotlib.pyplot as plt# 生成模拟数据
np.random.seed(0)
X 2 * np.random.rand(100, 1)
y 4 3 * X np.random.randn(100, 1)# 添加偏置项
X_b np.c_[np.ones((100, 1)), X]# 初始化参数
theta np.random.randn(2, 1)# 超参数
learning_rate 0.1
n_iterations 1000
m 100# 梯度下降
for iteration in range(n_iterations):gradients 2/m * X_b.T.dot(X_b.dot(theta) - y)theta - learning_rate * gradientsprint(f学习到的参数: {theta})# 可视化结果
plt.scatter(X, y)
plt.plot(X, X_b.dot(theta), colorred)
plt.xlabel(X)
plt.ylabel(y)
plt.title(线性回归结果)
plt.show()解释
数据生成生成100个随机点满足 y 4 3 x ϵ \displaystyle y 4 3x \epsilon y43xϵ其中 ϵ \epsilon ϵ 为高斯噪声。添加偏置项在特征矩阵 X X X 中添加一列1用于表示偏置 θ 0 \theta_0 θ0。初始化参数随机初始化模型参数 θ \theta θ。梯度下降通过迭代更新参数逐步减小损失函数值。可视化绘制数据点和拟合的直线。
2. 逻辑回归Logistic Regression
原理概述
逻辑回归是一种用于分类任务的算法尤其适用于二分类问题。与线性回归不同逻辑回归的输出通过逻辑函数Sigmoid函数映射到0和1之间表示属于某个类别的概率。
数学公式
逻辑回归模型的预测概率 P ( y 1 ∣ x ) P(y1|\mathbf{x}) P(y1∣x) 表示为 P ( y 1 ∣ x ) σ ( θ T x ) 1 1 e − θ T x P(y1|\mathbf{x}) \sigma(\mathbf{\theta}^T \mathbf{x}) \frac{1}{1 e^{-\mathbf{\theta}^T \mathbf{x}}} P(y1∣x)σ(θTx)1e−θTx1
其中 σ \sigma σ 是Sigmoid函数。
损失函数
逻辑回归使用对数损失Log Loss作为损失函数 Log Loss − 1 m ∑ i 1 m [ y ( i ) log ( y ^ ( i ) ) ( 1 − y ( i ) ) log ( 1 − y ^ ( i ) ) ] \text{Log Loss} -\frac{1}{m} \sum_{i1}^{m} \left[ y^{(i)} \log(\hat{y}^{(i)}) (1 - y^{(i)}) \log(1 - \hat{y}^{(i)}) \right] Log Loss−m1i1∑m[y(i)log(y^(i))(1−y(i))log(1−y^(i))]
代码实现
以下是一个简单的逻辑回归实现使用梯度下降法优化模型参数
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification# 生成模拟数据
X, y make_classification(n_samples100, n_features2, n_redundant0, n_clusters_per_class1, random_state0)# 添加偏置项
X_b np.c_[np.ones((100, 1)), X]# 初始化参数
theta np.zeros(X_b.shape[1])# Sigmoid函数
def sigmoid(z):return 1 / (1 np.exp(-z))# 超参数
learning_rate 0.1
n_iterations 1000
m X_b.shape[0]# 梯度下降
for iteration in range(n_iterations):z X_b.dot(theta)predictions sigmoid(z)gradient (1/m) * X_b.T.dot(predictions - y)theta - learning_rate * gradientprint(f学习到的参数: {theta})# 可视化结果
plt.scatter(X[:, 0], X[:, 1], cy, cmapbwr, alpha0.7)
x_values [np.min(X[:, 0])-1, np.max(X[:, 0])1]
y_values -(theta[0] np.array(x_values) * theta[1]) / theta[2]
plt.plot(x_values, y_values, label决策边界)
plt.xlabel(特征1)
plt.ylabel(特征2)
plt.legend()
plt.title(逻辑回归分类结果)
plt.show()解释
数据生成使用 make_classification 生成100个二维特征的二分类数据。添加偏置项在特征矩阵 X X X 中添加一列1用于表示偏置 θ 0 \theta_0 θ0。初始化参数初始化模型参数 θ \theta θ 为零向量。Sigmoid函数将线性组合 θ T x \mathbf{\theta}^T \mathbf{x} θTx 映射到概率值。梯度下降通过迭代更新参数最小化对数损失。可视化绘制数据点及决策边界。
3. 决策树Decision Tree
原理概述
决策树是一种用于分类和回归任务的非参数监督学习方法。它通过学习一系列的决策规则从根节点到叶节点进行分类或预测。决策树的构建基于特征的选择以最大化信息增益或基尼系数等标准。
信息增益
在分类任务中决策树通常使用信息增益Information Gain或基尼系数Gini Index来选择最佳分裂特征。
信息增益公式 信息增益 熵 ( 父节点 ) − ∑ ( N i N × 熵 ( 子节点 i ) ) \text{信息增益} \text{熵}(\text{父节点}) - \sum \left( \frac{N_i}{N} \times \text{熵}(\text{子节点}_i) \right) 信息增益熵(父节点)−∑(NNi×熵(子节点i))
其中熵Entropy衡量数据的不确定性 熵 − ∑ i 1 c p i log 2 p i \text{熵} - \sum_{i1}^{c} p_i \log_2 p_i 熵−i1∑cpilog2pi
代码实现
以下是一个简单的决策树分类器的实现使用ID3算法选择最佳分裂特征
import numpy as np
from collections import Counter
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt# 定义熵计算函数
def entropy(y):counts Counter(y)probabilities [count / len(y) for count in counts.values()]return -sum(p * np.log2(p) for p in probabilities if p 0)# 定义信息增益计算函数
def information_gain(X, y, feature):parent_entropy entropy(y)values, counts np.unique(X[:, feature], return_countsTrue)weighted_entropy sum((counts[i]/sum(counts)) * entropy(y[X[:, feature] v]) for i, v in enumerate(values))return parent_entropy - weighted_entropy# 决策树节点类
class DecisionNode:def __init__(self, featureNone, thresholdNone, leftNone, rightNone, *, valueNone):self.feature featureself.threshold thresholdself.left leftself.right rightself.value value# 决策树分类器
class DecisionTreeClassifier:def __init__(self, max_depth5):self.max_depth max_depthself.root Nonedef fit(self, X, y, depth0):n_samples, n_features X.shapenum_labels len(set(y))# 终止条件if depth self.max_depth or num_labels 1:leaf_value self._most_common_label(y)return DecisionNode(valueleaf_value)# 寻找最佳分裂特征和阈值best_gain -1best_feature Nonebest_threshold Nonefor feature in range(n_features):thresholds np.unique(X[:, feature])for threshold in thresholds:left_idxs X[:, feature] thresholdright_idxs X[:, feature] ! thresholdif len(y[left_idxs]) 0 or len(y[right_idxs]) 0:continuegain information_gain(X, y, feature)if gain best_gain:best_gain gainbest_feature featurebest_threshold thresholdif best_gain -1:leaf_value self._most_common_label(y)return DecisionNode(valueleaf_value)# 分裂数据left_idxs X[:, best_feature] best_thresholdright_idxs X[:, best_feature] ! best_thresholdleft self.fit(X[left_idxs], y[left_idxs], depth 1)right self.fit(X[right_idxs], y[right_idxs], depth 1)return DecisionNode(featurebest_feature, thresholdbest_threshold, leftleft, rightright)def _most_common_label(self, y):counter Counter(y)return counter.most_common(1)[0][0]def predict(self, X):return np.array([self._traverse_tree(x, self.root) for x in X])def _traverse_tree(self, x, node):if node.value is not None:return node.valueif x[node.feature] node.threshold:return self._traverse_tree(x, node.left)else:return self._traverse_tree(x, node.right)# 生成模拟数据
iris load_iris()
X, y iris.data, iris.target
# 仅选择前两类进行二分类
X, y X[y ! 2], y[y ! 2]
X_train, X_test, y_train, y_test train_test_split(X, y, test_size0.2, random_state42)# 训练决策树
tree DecisionTreeClassifier(max_depth3)
tree.root tree.fit(X_train, y_train)# 预测
y_pred tree.predict(X_test)
print(f准确率: {accuracy_score(y_test, y_pred)})# 可视化决策边界仅使用前两个特征
def plot_decision_boundary(model, X, y):x_min, x_max X[:, 0].min() - 1, X[:, 0].max() 1y_min, y_max X[:, 1].min() - 1, X[:, 1].max() 1xx, yy np.meshgrid(np.arange(x_min, x_max, 0.1),np.arange(y_min, y_max, 0.1))Z model.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)plt.contourf(xx, yy, Z, alpha0.3, cmapbwr)plt.scatter(X[:, 0], X[:, 1], cy, cmapbwr, edgecolork)plt.xlabel(特征1)plt.ylabel(特征2)plt.title(决策树决策边界)plt.show()plot_decision_boundary(tree, X_test, y_test)解释
熵与信息增益通过计算不同特征的熵和信息增益选择最能减少数据不确定性的特征进行分裂。决策树节点DecisionNode类表示树的节点可以是内部节点包含分裂特征和阈值或叶节点包含预测值。构建树DecisionTreeClassifier类通过递归分裂数据直到达到最大深度或所有样本属于同一类。预测通过遍历决策树根据样本特征进行分类。可视化绘制决策树的决策边界展示模型的分类效果。
4. K近邻算法K-Nearest Neighbors, KNN
原理概述
K近邻算法是一种基于实例的学习方法用于分类和回归任务。对于一个待分类样本KNN算法通过计算其与训练集中所有样本的距离选择最近的K个邻居根据邻居的类别进行投票决定待分类样本的类别。
数学公式
KNN算法不需要显式的训练过程其核心是距离度量。常用的距离度量包括欧氏距离、曼哈顿距离等。
欧氏距离公式 d ( x , x ′ ) ∑ i 1 n ( x i − x i ′ ) 2 d(\mathbf{x}, \mathbf{x}) \sqrt{\sum_{i1}^{n} (x_i - x_i)^2} d(x,x′)i1∑n(xi−xi′)2
代码实现
以下是一个简单的KNN分类器的实现使用欧氏距离进行分类
import numpy as np
from collections import Counter
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score# KNN分类器
class KNNClassifier:def __init__(self, k3):self.k kdef fit(self, X, y):self.X_train Xself.y_train ydef predict(self, X):return np.array([self._predict_single(x) for x in X])def _predict_single(self, x):# 计算所有训练样本的距离distances np.linalg.norm(self.X_train - x, axis1)# 获取最近的k个邻居k_idxs distances.argsort()[:self.k]k_neighbor_labels self.y_train[k_idxs]# 投票决定类别most_common Counter(k_neighbor_labels).most_common(1)return most_common[0][0]# 载入数据
iris load_iris()
X, y iris.data, iris.target
# 仅选择前两类进行二分类
X, y X[y ! 2], y[y ! 2]
X_train, X_test, y_train, y_test train_test_split(X, y, test_size0.2, random_state42)# 训练KNN
knn KNNClassifier(k3)
knn.fit(X_train, y_train)# 预测
y_pred knn.predict(X_test)
print(f准确率: {accuracy_score(y_test, y_pred)})解释
距离计算通过欧氏距离计算待分类样本与训练样本的距离。选择K个邻居选择距离最近的K个训练样本。投票决策根据K个邻居的类别进行投票选择票数最多的类别作为预测结果。训练与预测KNN不需要显式的训练过程仅需存储训练数据通过预测时计算距离进行分类。
5. 支持向量机Support Vector Machine, SVM
原理概述
支持向量机是一种用于分类和回归的监督学习模型。SVM的核心思想是找到一个最优超平面将不同类别的数据分开并且最大化两类之间的间隔Margin。在非线性可分的情况下SVM通过核函数将数据映射到高维空间使其线性可分。
数学公式
对于二分类问题SVM的目标是找到一个超平面 w T x b 0 \mathbf{w}^T \mathbf{x} b 0 wTxb0使得满足以下条件 y i ( w T x i b ) ≥ 1 , ∀ i y_i (\mathbf{w}^T \mathbf{x}_i b) \geq 1, \quad \forall i yi(wTxib)≥1,∀i
并最大化间隔 2 ∥ w ∥ \frac{2}{\|\mathbf{w}\|} ∥w∥2。
代码实现
以下是一个简单的线性SVM分类器的实现使用梯度下降法优化模型参数
import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score# SVM分类器
class SVMClassifier:def __init__(self, learning_rate0.001, lambda_param0.01, n_iters1000):self.lr learning_rateself.lambda_param lambda_paramself.n_iters n_itersself.w Noneself.b Nonedef fit(self, X, y):# 转换标签为 {-1, 1}y_ np.where(y 0, -1, 1)n_samples, n_features X.shape# 初始化参数self.w np.zeros(n_features)self.b 0# 梯度下降for _ in range(self.n_iters):for idx, x_i in enumerate(X):condition y_[idx] * (np.dot(x_i, self.w) - self.b) 1if condition:self.w - self.lr * (2 * self.lambda_param * self.w)else:self.w - self.lr * (2 * self.lambda_param * self.w - np.dot(x_i, y_[idx]))self.b - self.lr * y_[idx]def predict(self, X):approx np.dot(X, self.w) - self.breturn np.sign(approx)# 生成模拟数据
X, y make_classification(n_samples100, n_features2, n_redundant0, n_clusters_per_class1, flip_y0, random_state4)# 划分训练集和测试集
X_train, X_test, y_train, y_test train_test_split(X, y, test_size0.2, random_state42)# 训练SVM
svm SVMClassifier()
svm.fit(X_train, y_train)# 预测
y_pred svm.predict(X_test)
# 将预测标签从 {-1, 1} 转回 {0, 1}
y_pred np.where(y_pred 0, 0, 1)
print(f准确率: {accuracy_score(y_test, y_pred)})解释
标签转换将标签转换为 { − 1 , 1 } \{-1, 1\} {−1,1}便于计算。初始化参数初始化权重向量 w \mathbf{w} w 和偏置 b b b。梯度下降通过迭代更新参数最大化间隔并最小化分类错误。预测通过计算 w T x − b \mathbf{w}^T \mathbf{x} - b wTx−b 的符号决定样本的类别。
6. 神经网络Neural Networks
原理概述
神经网络是一类模拟人脑神经元结构的机器学习模型擅长处理复杂的非线性关系。基本的神经网络由输入层、隐藏层和输出层组成每一层由若干神经元节点构成神经元之间通过权重连接。
数学公式
一个简单的前馈神经网络的计算过程如下 z ( l ) W ( l ) a ( l − 1 ) b ( l ) \mathbf{z}^{(l)} \mathbf{W}^{(l)} \mathbf{a}^{(l-1)} \mathbf{b}^{(l)} z(l)W(l)a(l−1)b(l) a ( l ) σ ( z ( l ) ) \mathbf{a}^{(l)} \sigma(\mathbf{z}^{(l)}) a(l)σ(z(l))
其中 W ( l ) \mathbf{W}^{(l)} W(l) 和 b ( l ) \mathbf{b}^{(l)} b(l) 是第 l l l 层的权重和偏置 σ \sigma σ 是激活函数如ReLU、Sigmoid a ( l ) \mathbf{a}^{(l)} a(l) 是第 l l l 层的输出。
代码实现
以下是一个简单的单隐藏层神经网络用于二分类任务的实现
import numpy as np
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt# 激活函数及其导数
def sigmoid(z):return 1 / (1 np.exp(-z))def sigmoid_derivative(a):return a * (1 - a)# 神经网络类
class NeuralNetwork:def __init__(self, input_size, hidden_size, output_size):# 初始化权重self.W1 np.random.randn(hidden_size, input_size) * 0.01self.b1 np.zeros((hidden_size, 1))self.W2 np.random.randn(output_size, hidden_size) * 0.01self.b2 np.zeros((output_size, 1))def forward(self, X):self.Z1 np.dot(self.W1, X.T) self.b1self.A1 sigmoid(self.Z1)self.Z2 np.dot(self.W2, self.A1) self.b2self.A2 sigmoid(self.Z2)return self.A2def compute_loss(self, Y, A2):m Y.shape[0]loss - (1/m) * np.sum(Y.T * np.log(A2) (1 - Y.T) * np.log(1 - A2))return lossdef backward(self, X, Y):m X.shape[0]Y Y.reshape(1, m)dZ2 self.A2 - YdW2 (1/m) * np.dot(dZ2, self.A1.T)db2 (1/m) * np.sum(dZ2, axis1, keepdimsTrue)dA1 np.dot(self.W2.T, dZ2)dZ1 dA1 * sigmoid_derivative(self.A1)dW1 (1/m) * np.dot(dZ1, X)db1 (1/m) * np.sum(dZ1, axis1, keepdimsTrue)# 更新参数self.W1 - learning_rate * dW1self.b1 - learning_rate * db1self.W2 - learning_rate * dW2self.b2 - learning_rate * db2def train(self, X, Y, epochs10000, learning_rate0.1):self.learning_rate learning_ratefor epoch in range(epochs):A2 self.forward(X)loss self.compute_loss(Y, A2)self.backward(X, Y)if epoch % 1000 0:print(fEpoch {epoch}, Loss: {loss})def predict(self, X):A2 self.forward(X)return (A2 0.5).astype(int).flatten()# 生成模拟数据
X, y make_moons(n_samples1000, noise0.2, random_state42)
X_train, X_test, y_train, y_test train_test_split(X, y, test_size0.2, random_state42)# 训练神经网络
nn NeuralNetwork(input_size2, hidden_size5, output_size1)
nn.train(X_train, y_train, epochs10000, learning_rate0.1)# 预测
y_pred nn.predict(X_test)
print(f准确率: {accuracy_score(y_test, y_pred)})# 可视化决策边界
def plot_decision_boundary_nn(model, X, y):x_min, x_max X[:, 0].min() - 1, X[:, 0].max() 1y_min, y_max X[:, 1].min() - 1, X[:, 1].max() 1xx, yy np.meshgrid(np.linspace(x_min, x_max, 100),np.linspace(y_min, y_max, 100))grid np.c_[xx.ravel(), yy.ravel()]Z model.predict(grid).reshape(xx.shape)plt.contourf(xx, yy, Z, alpha0.3, cmapbwr)plt.scatter(X[:, 0], X[:, 1], cy, cmapbwr, edgecolork)plt.xlabel(特征1)plt.ylabel(特征2)plt.title(神经网络决策边界)plt.show()plot_decision_boundary_nn(nn, X_test, y_test)解释
网络结构包含一个输入层、一个隐藏层和一个输出层。隐藏层使用Sigmoid激活函数输出层也使用Sigmoid函数输出概率。前向传播计算每一层的激活值。损失计算使用交叉熵损失函数衡量预测值与真实值之间的差异。反向传播计算梯度并更新权重和偏置。训练与预测通过多次迭代训练模型并在测试集上进行预测。可视化绘制神经网络的决策边界展示模型的分类效果。
结语
本文介绍了几种常见的机器学习算法包括线性回归、逻辑回归、决策树、K近邻算法、支持向量机和神经网络。通过对这些算法的原理解释和代码实现示例希望能帮助你建立对机器学习算法的基本理解并动手实践这些算法。
学习建议
动手实践阅读和理解代码实现并尝试自己编写或修改代码深入理解算法的工作机制。深入学习进一步学习每种算法的高级特性如正则化、核方法、深度学习中的优化技术等。项目应用选择感兴趣的项目应用所学的算法进行实际问题的解决积累实战经验。持续学习机器学习领域发展迅速保持学习最新的研究成果和技术进展提升自己的技能水平。
希望这篇入门指南能为你的机器学习之路打下坚实的基础。祝你学习顺利
