26备战秋招day17——机器学习基础

如意鼠2024-12-10 9:51

机器学习入门指南：常见算法详解与代码实现

机器学习（Machine Learning, ML）是人工智能（AI）的一个重要分支，旨在通过数据驱动的方法让计算机系统自动学习和改进。对于刚接触机器学习的朋友来说，了解各种算法的基本原理及其实现方法至关重要。本篇文章将通俗易懂地介绍几种常见的机器学习算法，解释其背后的数学原理，并提供简单的代码示例，帮助你更好地理解这些算法的工作机制。

目录

  1. 什么是机器学习？
  2. 监督学习与无监督学习
  3. 常见机器学习算法详解
    • [1. 线性回归（Linear Regression）](#1. 线性回归（Linear Regression）)
    • [2. 逻辑回归（Logistic Regression）](#2. 逻辑回归（Logistic Regression）)
    • [3. 决策树（Decision Tree）](#3. 决策树（Decision Tree）)
    • [4. K近邻算法（K-Nearest Neighbors, KNN）](#4. K近邻算法（K-Nearest Neighbors, KNN）)
    • [5. 支持向量机（Support Vector Machine, SVM）](#5. 支持向量机（Support Vector Machine, SVM）)
    • [6. 神经网络（Neural Networks）](#6. 神经网络（Neural Networks）)
  4. 结语

什么是机器学习？

机器学习是一种通过数据训练模型，使其能够从数据中学习规律并做出预测或决策的技术。与传统编程不同，机器学习不需要明确编写每一步的操作逻辑，而是通过大量的数据样本让模型自动发现和学习其中的模式。

机器学习的分类

机器学习主要分为以下几类：

  • 监督学习（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_{i=1}^{m} (y^{(i)} - \hat{y}^{(i)})^2 MSE=m1i=1∑m(y(i)−y^(i))2

代码实现

下面是一个简单的线性回归实现，使用梯度下降法优化模型参数：

python 复制代码 
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 * gradients

print(f"学习到的参数: {theta}")

# 可视化结果
plt.scatter(X, y)
plt.plot(X, X_b.dot(theta), color='red')
plt.xlabel("X")
plt.ylabel("y")
plt.title("线性回归结果")
plt.show()
解释
  1. 数据生成 ：生成100个随机点，满足 y = 4 + 3 x + ϵ \displaystyle y = 4 + 3x + \epsilon y=4+3x+ϵ，其中 ϵ \epsilon ϵ 为高斯噪声。
  2. 添加偏置项 ：在特征矩阵 X X X 中添加一列1，用于表示偏置 θ 0 \theta_0 θ0。
  3. 初始化参数 ：随机初始化模型参数 θ \theta θ。
  4. 梯度下降：通过迭代更新参数，逐步减小损失函数值。
  5. 可视化：绘制数据点和拟合的直线。

2. 逻辑回归（Logistic Regression）

原理概述

逻辑回归是一种用于分类任务的算法，尤其适用于二分类问题。与线性回归不同，逻辑回归的输出通过逻辑函数（Sigmoid函数）映射到0和1之间，表示属于某个类别的概率。

数学公式

逻辑回归模型的预测概率 P ( y = 1 ∣ x ) P(y=1|\mathbf{x}) P(y=1∣x) 表示为：

P ( y = 1 ∣ x ) = σ ( θ T x ) = 1 1 + e − θ T x P(y=1|\mathbf{x}) = \sigma(\mathbf{\theta}^T \mathbf{x}) = \frac{1}{1 + e^{-\mathbf{\theta}^T \mathbf{x}}} P(y=1∣x)=σ(θTx)=1+e−θ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_{i=1}^{m} \left[ y^{(i)} \log(\hat{y}^{(i)}) + (1 - y^{(i)}) \log(1 - \hat{y}^{(i)}) \right] Log Loss=−m1i=1∑m[y(i)log(y^(i))+(1−y(i))log(1−y^(i))]

代码实现

以下是一个简单的逻辑回归实现，使用梯度下降法优化模型参数：

python 复制代码 
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification

# 生成模拟数据
X, y = make_classification(n_samples=100, n_features=2, n_redundant=0, 
                           n_clusters_per_class=1, random_state=0)

# 添加偏置项
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 * gradient

print(f"学习到的参数: {theta}")

# 可视化结果
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', alpha=0.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()
解释
  1. 数据生成 ：使用 make_classification 生成100个二维特征的二分类数据。
  2. 添加偏置项 ：在特征矩阵 X X X 中添加一列1，用于表示偏置 θ 0 \theta_0 θ0。
  3. 初始化参数 ：初始化模型参数 θ \theta θ 为零向量。
  4. Sigmoid函数 ：将线性组合 θ T x \mathbf{\theta}^T \mathbf{x} θTx 映射到概率值。
  5. 梯度下降：通过迭代更新参数，最小化对数损失。
  6. 可视化：绘制数据点及决策边界。

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_{i=1}^{c} p_i \log_2 p_i 熵=−i=1∑cpilog2pi

代码实现

以下是一个简单的决策树分类器的实现，使用ID3算法选择最佳分裂特征：

python 复制代码 
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_counts=True)
    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, feature=None, threshold=None, left=None, right=None, *, value=None):
        self.feature = feature
        self.threshold = threshold
        self.left = left
        self.right = right
        self.value = value

# 决策树分类器
class DecisionTreeClassifier:
    def __init__(self, max_depth=5):
        self.max_depth = max_depth
        self.root = None

    def fit(self, X, y, depth=0):
        n_samples, n_features = X.shape
        num_labels = len(set(y))

        # 终止条件
        if depth >= self.max_depth or num_labels == 1:
            leaf_value = self._most_common_label(y)
            return DecisionNode(value=leaf_value)

        # 寻找最佳分裂特征和阈值
        best_gain = -1
        best_feature = None
        best_threshold = None
        for feature in range(n_features):
            thresholds = np.unique(X[:, feature])
            for threshold in thresholds:
                left_idxs = X[:, feature] == threshold
                right_idxs = X[:, feature] != threshold
                if len(y[left_idxs]) == 0 or len(y[right_idxs]) == 0:
                    continue
                gain = information_gain(X, y, feature)
                if gain > best_gain:
                    best_gain = gain
                    best_feature = feature
                    best_threshold = threshold

        if best_gain == -1:
            leaf_value = self._most_common_label(y)
            return DecisionNode(value=leaf_value)

        # 分裂数据
        left_idxs = X[:, best_feature] == best_threshold
        right_idxs = X[:, best_feature] != best_threshold
        left = self.fit(X[left_idxs], y[left_idxs], depth + 1)
        right = self.fit(X[right_idxs], y[right_idxs], depth + 1)
        return DecisionNode(feature=best_feature, threshold=best_threshold, left=left, right=right)

    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.value
        if 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_size=0.2, random_state=42)

# 训练决策树
tree = DecisionTreeClassifier(max_depth=3)
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() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, 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, alpha=0.3, cmap='bwr')
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', edgecolor='k')
    plt.xlabel('特征1')
    plt.ylabel('特征2')
    plt.title('决策树决策边界')
    plt.show()

plot_decision_boundary(tree, X_test, y_test)
解释
  1. 熵与信息增益：通过计算不同特征的熵和信息增益，选择最能减少数据不确定性的特征进行分裂。
  2. 决策树节点 ：DecisionNode类表示树的节点，可以是内部节点（包含分裂特征和阈值）或叶节点（包含预测值）。
  3. 构建树 ：DecisionTreeClassifier类通过递归分裂数据，直到达到最大深度或所有样本属于同一类。
  4. 预测：通过遍历决策树，根据样本特征进行分类。
  5. 可视化：绘制决策树的决策边界，展示模型的分类效果。

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_{i=1}^{n} (x_i - x'_i)^2} d(x,x′)=i=1∑n(xi−xi′)2

代码实现

以下是一个简单的KNN分类器的实现，使用欧氏距离进行分类：

python 复制代码 
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, k=3):
        self.k = k

    def fit(self, X, y):
        self.X_train = X
        self.y_train = y

    def 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, axis=1)
        # 获取最近的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_size=0.2, random_state=42)

# 训练KNN
knn = KNNClassifier(k=3)
knn.fit(X_train, y_train)

# 预测
y_pred = knn.predict(X_test)
print(f"准确率: {accuracy_score(y_test, y_pred)}")
解释
  1. 距离计算：通过欧氏距离计算待分类样本与训练样本的距离。
  2. 选择K个邻居：选择距离最近的K个训练样本。
  3. 投票决策：根据K个邻居的类别进行投票，选择票数最多的类别作为预测结果。
  4. 训练与预测：KNN不需要显式的训练过程，仅需存储训练数据，通过预测时计算距离进行分类。

5. 支持向量机（Support Vector Machine, SVM）

原理概述

支持向量机是一种用于分类和回归的监督学习模型。SVM的核心思想是找到一个最优超平面，将不同类别的数据分开，并且最大化两类之间的间隔（Margin）。在非线性可分的情况下，SVM通过核函数将数据映射到高维空间，使其线性可分。

数学公式

对于二分类问题，SVM的目标是找到一个超平面 w T x + b = 0 \mathbf{w}^T \mathbf{x} + b = 0 wTx+b=0，使得满足以下条件：

y i ( w T x i + b ) ≥ 1 , ∀ i y_i (\mathbf{w}^T \mathbf{x}_i + b) \geq 1, \quad \forall i yi(wTxi+b)≥1,∀i

并最大化间隔 2 ∥ w ∥ \frac{2}{\|\mathbf{w}\|} ∥w∥2。

代码实现

以下是一个简单的线性SVM分类器的实现，使用梯度下降法优化模型参数：

python 复制代码 
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_rate=0.001, lambda_param=0.01, n_iters=1000):
        self.lr = learning_rate
        self.lambda_param = lambda_param
        self.n_iters = n_iters
        self.w = None
        self.b = None

    def 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) >= 1
                if 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.b
        return np.sign(approx)

# 生成模拟数据
X, y = make_classification(n_samples=100, n_features=2, n_redundant=0, 
                           n_clusters_per_class=1, flip_y=0, random_state=4)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 训练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,1}，便于计算。
  2. 初始化参数 ：初始化权重向量 w \mathbf{w} w 和偏置 b b b。
  3. 梯度下降：通过迭代更新参数，最大化间隔并最小化分类错误。
  4. 预测 ：通过计算 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 层的输出。

代码实现

以下是一个简单的单隐藏层神经网络，用于二分类任务的实现：

python 复制代码 
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.01
        self.b1 = np.zeros((hidden_size, 1))
        self.W2 = np.random.randn(output_size, hidden_size) * 0.01
        self.b2 = np.zeros((output_size, 1))

    def forward(self, X):
        self.Z1 = np.dot(self.W1, X.T) + self.b1
        self.A1 = sigmoid(self.Z1)
        self.Z2 = np.dot(self.W2, self.A1) + self.b2
        self.A2 = sigmoid(self.Z2)
        return self.A2

    def 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 loss

    def backward(self, X, Y):
        m = X.shape[0]
        Y = Y.reshape(1, m)
        dZ2 = self.A2 - Y
        dW2 = (1/m) * np.dot(dZ2, self.A1.T)
        db2 = (1/m) * np.sum(dZ2, axis=1, keepdims=True)
        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, axis=1, keepdims=True)

        # 更新参数
        self.W1 -= learning_rate * dW1
        self.b1 -= learning_rate * db1
        self.W2 -= learning_rate * dW2
        self.b2 -= learning_rate * db2

    def train(self, X, Y, epochs=10000, learning_rate=0.1):
        self.learning_rate = learning_rate
        for epoch in range(epochs):
            A2 = self.forward(X)
            loss = self.compute_loss(Y, A2)
            self.backward(X, Y)
            if epoch % 1000 == 0:
                print(f"Epoch {epoch}, Loss: {loss}")

    def predict(self, X):
        A2 = self.forward(X)
        return (A2 > 0.5).astype(int).flatten()

# 生成模拟数据
X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 训练神经网络
nn = NeuralNetwork(input_size=2, hidden_size=5, output_size=1)
nn.train(X_train, y_train, epochs=10000, learning_rate=0.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() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, 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, alpha=0.3, cmap='bwr')
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', edgecolor='k')
    plt.xlabel('特征1')
    plt.ylabel('特征2')
    plt.title('神经网络决策边界')
    plt.show()

plot_decision_boundary_nn(nn, X_test, y_test)
解释
  1. 网络结构：包含一个输入层、一个隐藏层和一个输出层。隐藏层使用Sigmoid激活函数，输出层也使用Sigmoid函数输出概率。
  2. 前向传播：计算每一层的激活值。
  3. 损失计算：使用交叉熵损失函数衡量预测值与真实值之间的差异。
  4. 反向传播：计算梯度并更新权重和偏置。
  5. 训练与预测：通过多次迭代训练模型，并在测试集上进行预测。
  6. 可视化：绘制神经网络的决策边界，展示模型的分类效果。

结语

本文介绍了几种常见的机器学习算法，包括线性回归、逻辑回归、决策树、K近邻算法、支持向量机和神经网络。通过对这些算法的原理解释和代码实现示例，希望能帮助你建立对机器学习算法的基本理解，并动手实践这些算法。

学习建议

  1. 动手实践：阅读和理解代码实现，并尝试自己编写或修改代码，深入理解算法的工作机制。
  2. 深入学习：进一步学习每种算法的高级特性，如正则化、核方法、深度学习中的优化技术等。
  3. 项目应用：选择感兴趣的项目，应用所学的算法进行实际问题的解决，积累实战经验。
  4. 持续学习：机器学习领域发展迅速，保持学习最新的研究成果和技术进展，提升自己的技能水平。

希望这篇入门指南能为你的机器学习之路打下坚实的基础。祝你学习顺利！

相关推荐
东方佑40 分钟前
给图像去除水印攻
人工智能·python
知来者逆1 小时前
Layer-Condensed KV——利用跨层注意（CLA）减少 KV 缓存中的内存保持 Transformer 1B 和 3B 参数模型的准确性
人工智能·深度学习·机器学习·transformer
tangjunjun-owen1 小时前
异常安全重启运行机制：健壮的Ai模型训练自动化
人工智能·python·安全·异常重运行或重启
爱研究的小牛1 小时前
Rerender A Video 技术浅析（二）：视频增强
人工智能·深度学习·aigc
Bdawn1 小时前
【通义实验室】开源【文本生成图片】大模型
人工智能·python·llm
黑马王子132 小时前
谷歌史上最强大模型-Gemini2.0震撼发布！以后世界都属于智能体？
人工智能·google
电报号dapp1192 小时前
当前热门 DApp 模式解析：六大方向的趋势与创新
人工智能·去中心化·区块链·智能合约
宸码2 小时前
【机器学习】手写数字识别的最优解：CNN+Softmax、Sigmoid与SVM的对比实战
人工智能·python·神经网络·算法·机器学习·支持向量机·cnn
睡觉狂魔er2 小时前
自动驾驶控制与规划——Project 1: 车辆纵向控制
人工智能·机器学习·自动驾驶
goomind2 小时前
YOLOv8实战bdd100k自动驾驶目标识别
人工智能·深度学习·yolo·计算机视觉·目标跟踪·自动驾驶·bdd100k
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02【halcon】halcon字符识别——OCR03玄机平台应急响应—webshell查杀04Windows11 Copilot助手开启教程(免费GPT-4)0504 - matlab m_map地学绘图工具基础函数 - 设置网格06Docker 夺命连环 15 问07【一文读懂】NTN（非地面网络）技术介绍08支付宝短视频平台创作分成激励项目09PyTorch机器学习实现液态神经网络10『手写ahooks系列-useClickAway』一个hook解决监听点击元素外部