机器学习基础概念

机器学习让计算机能够从数据中学习，而不需要明确编程。理解其核心概念是掌握AI技术的关键。

什么是机器学习？

传统编程 vs 机器学习

# 传统编程：明确的规则
def is_spam_traditional(email):
    spam_words = ['free', 'win', 'prize']
    return any(word in email.lower() for word in spam_words)

# 机器学习：从数据中学习规则
from sklearn.naive_bayes import MultinomialNB

# 训练数据
emails = ["Win free prize", "Meeting at 3pm", "Claim your prize now"]
labels = [1, 0, 1]  # 1=spam, 0=not spam

# 模型学习规则
model = MultinomialNB()
# ... 特征提取和训练

机器学习的三要素

数据: 学习的原材料
模型: 学习的方式
算法: 学习的过程

机器学习的类型

1. 监督学习

从标注数据中学习输入到输出的映射。

from sklearn.linear_model import LinearRegression
import numpy as np

# 房价预测示例
# X: 房屋面积, y: 价格
X = np.array([[50], [60], [70], [80], [90]])
y = np.array([150, 180, 210, 240, 270])

# 训练模型
model = LinearRegression()
model.fit(X, y)

# 预测
new_house = np.array([[75]])
predicted_price = model.predict(new_house)
print(f"预测价格: {predicted_price[0]:.2f}万元")

常见任务:

回归: 预测连续值（房价、温度）
分类: 预测类别（垃圾邮件、图像识别）

2. 非监督学习

从无标注数据中发现模式。

from sklearn.cluster import KMeans
import numpy as np

# 客户分群示例
# 特征: [年龄, 消费金额]
customers = np.array([
    [25, 1000], [30, 1200], [45, 5000],
    [50, 5500], [28, 1100], [48, 5200]
])

# K-means聚类
kmeans = KMeans(n_clusters=2, random_state=42)
clusters = kmeans.fit_predict(customers)

print(f"客户分群: {clusters}")
# 输出: [0 0 1 1 0 1] - 两个群组

常见任务:

聚类: 分组相似数据
降维: 减少特征数量
异常检测: 发现异常数据点

3. 强化学习

通过与环境交互学习最优策略。

# 简化的Q-learning示例
import numpy as np

class SimpleAgent:
    def __init__(self, actions):
        self.q_table = {}  # 状态-动作值表
        self.actions = actions
        self.learning_rate = 0.1
        self.discount = 0.9

    def get_action(self, state, epsilon=0.1):
        # ε-贪婪策略
        if np.random.random() < epsilon:
            return np.random.choice(self.actions)

        if state not in self.q_table:
            self.q_table[state] = np.zeros(len(self.actions))

        return np.argmax(self.q_table[state])

    def update(self, state, action, reward, next_state):
        if state not in self.q_table:
            self.q_table[state] = np.zeros(len(self.actions))
        if next_state not in self.q_table:
            self.q_table[next_state] = np.zeros(len(self.actions))

        # Q-learning更新
        current_q = self.q_table[state][action]
        max_next_q = np.max(self.q_table[next_state])
        new_q = current_q + self.learning_rate * (
            reward + self.discount * max_next_q - current_q
        )
        self.q_table[state][action] = new_q

核心概念详解

特征工程

特征是模型的输入，好的特征至关重要。

import pandas as pd
from sklearn.preprocessing import StandardScaler, LabelEncoder

# 原始数据
data = pd.DataFrame({
    'age': [25, 30, 35],
    'income': [50000, 60000, 70000],
    'city': ['Beijing', 'Shanghai', 'Beijing']
})

# 1. 数值特征标准化
scaler = StandardScaler()
data[['age', 'income']] = scaler.fit_transform(data[['age', 'income']])

# 2. 类别特征编码
encoder = LabelEncoder()
data['city_encoded'] = encoder.fit_transform(data['city'])

# 3. 特征组合
data['age_income_ratio'] = data['age'] / data['income']

print(data)

训练、验证和测试集

from sklearn.model_selection import train_test_split

# 数据集划分
X = data[['feature1', 'feature2']]
y = data['target']

# 先分出测试集（20%）
X_temp, X_test, y_temp, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 再从剩余数据中分出验证集（25% of 80% = 20%）
X_train, X_val, y_train, y_val = train_test_split(
    X_temp, y_temp, test_size=0.25, random_state=42
)

print(f"训练集: {len(X_train)}")
print(f"验证集: {len(X_val)}")
print(f"测试集: {len(X_test)}")

过拟合和欠拟合

import numpy as np
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# 生成数据
np.random.seed(42)
X = np.linspace(0, 10, 50).reshape(-1, 1)
y = 2 * X.ravel() + np.random.randn(50) * 2

# 欠拟合：模型太简单
model_underfit = LinearRegression()
model_underfit.fit(X[:10], y[:10])  # 数据太少

# 合适的拟合
model_good = LinearRegression()
model_good.fit(X, y)

# 过拟合：模型太复杂
poly = PolynomialFeatures(degree=15)
X_poly = poly.fit_transform(X)
model_overfit = LinearRegression()
model_overfit.fit(X_poly, y)

# 可视化比较
# ... 绘图代码

防止过拟合的方法:

增加训练数据
正则化
交叉验证
早停（Early Stopping）
Dropout（神经网络）

常见算法

线性回归

最简单的回归算法。

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# 创建和训练模型
model = LinearRegression()
model.fit(X_train, y_train)

# 预测
y_pred = model.predict(X_test)

# 评估
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"均方误差: {mse:.2f}")
print(f"R²分数: {r2:.2f}")
print(f"权重: {model.coef_}")
print(f"截距: {model.intercept_}")

逻辑回归

用于二分类问题。

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix

# 训练模型
model = LogisticRegression()
model.fit(X_train, y_train)

# 预测
y_pred = model.predict(X_test)
y_proba = model.predict_proba(X_test)  # 概率

# 评估
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)

print(f"准确率: {accuracy:.2f}")
print(f"混淆矩阵:\n{conf_matrix}")

决策树

直观且易于解释。

from sklearn.tree import DecisionTreeClassifier
from sklearn import tree

# 训练决策树
model = DecisionTreeClassifier(max_depth=3, random_state=42)
model.fit(X_train, y_train)

# 可视化决策树
import matplotlib.pyplot as plt

plt.figure(figsize=(12, 8))
tree.plot_tree(model, filled=True, feature_names=['feature1', 'feature2'])
plt.show()

# 特征重要性
importances = model.feature_importances_
print(f"特征重要性: {importances}")

随机森林

集成多个决策树。

from sklearn.ensemble import RandomForestClassifier

# 训练随机森林
model = RandomForestClassifier(
    n_estimators=100,  # 树的数量
    max_depth=5,
    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:.2f}")
print(f"特征重要性: {model.feature_importances_}")

支持向量机（SVM）

寻找最优分类边界。

from sklearn.svm import SVC

# 训练SVM
model = SVC(kernel='rbf', C=1.0, gamma='scale')
model.fit(X_train, y_train)

# 预测
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

print(f"准确率: {accuracy:.2f}")
print(f"支持向量数量: {len(model.support_vectors_)}")

K近邻（KNN）

基于相似度的简单算法。

from sklearn.neighbors import KNeighborsClassifier

# 训练KNN
model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)

# 预测
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

print(f"准确率: {accuracy:.2f}")

模型评估

分类指标

from sklearn.metrics import (
    accuracy_score, precision_score, recall_score,
    f1_score, classification_report, roc_auc_score
)

# 计算各种指标
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)

print(f"准确率: {accuracy:.3f}")
print(f"精确率: {precision:.3f}")
print(f"召回率: {recall:.3f}")
print(f"F1分数: {f1:.3f}")

# 详细报告
print("\n分类报告:")
print(classification_report(y_test, y_pred))

# ROC-AUC
y_proba = model.predict_proba(X_test)[:, 1]
auc = roc_auc_score(y_test, y_proba)
print(f"AUC: {auc:.3f}")

回归指标

from sklearn.metrics import (
    mean_squared_error, mean_absolute_error,
    r2_score, mean_absolute_percentage_error
)

# 计算回归指标
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
mae = mean_absolute_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"均方误差 (MSE): {mse:.3f}")
print(f"均方根误差 (RMSE): {rmse:.3f}")
print(f"平均绝对误差 (MAE): {mae:.3f}")
print(f"R²分数: {r2:.3f}")

交叉验证

from sklearn.model_selection import cross_val_score

# 5折交叉验证
scores = cross_val_score(
    model, X, y,
    cv=5,  # 5折
    scoring='accuracy'
)

print(f"交叉验证分数: {scores}")
print(f"平均分数: {scores.mean():.3f} (+/- {scores.std() * 2:.3f})")

完整的机器学习流程

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

# 1. 加载数据
data = pd.read_csv('data.csv')

# 2. 探索性数据分析
print(data.head())
print(data.info())
print(data.describe())

# 3. 数据预处理
# 处理缺失值
data = data.dropna()

# 特征和目标
X = data.drop('target', axis=1)
y = data['target']

# 4. 划分数据集
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 5. 特征缩放
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 6. 训练模型
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train_scaled, y_train)

# 7. 预测
y_pred = model.predict(X_test_scaled)

# 8. 评估
print(classification_report(y_test, y_pred))

# 9. 保存模型
import joblib
joblib.dump(model, 'model.pkl')
joblib.dump(scaler, 'scaler.pkl')

实战项目：鸢尾花分类

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

# 加载数据
iris = load_iris()
X, y = iris.data, iris.target

# 划分数据
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# 标准化
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# 训练模型
model = SVC(kernel='rbf', 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:.3f}")

# 混淆矩阵可视化
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title('混淆矩阵')
plt.ylabel('真实标签')
plt.xlabel('预测标签')
plt.show()

最佳实践

1. 数据质量第一

# 检查数据质量
def check_data_quality(df):
    print("数据形状:", df.shape)
    print("\n缺失值:")
    print(df.isnull().sum())
    print("\n重复行:", df.duplicated().sum())
    print("\n数据类型:")
    print(df.dtypes)

2. 建立基线模型

from sklearn.dummy import DummyClassifier

# 简单的基线模型
baseline = DummyClassifier(strategy='most_frequent')
baseline.fit(X_train, y_train)
baseline_score = baseline.score(X_test, y_test)

print(f"基线准确率: {baseline_score:.3f}")
# 你的模型必须超过这个分数才有意义

3. 超参数调优

from sklearn.model_selection import GridSearchCV

# 定义参数网格
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [3, 5, 7],
    'min_samples_split': [2, 5, 10]
}

# 网格搜索
grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1
)

grid_search.fit(X_train, y_train)

print(f"最佳参数: {grid_search.best_params_}")
print(f"最佳分数: {grid_search.best_score_:.3f}")

总结

机器学习的核心是让计算机从数据中学习模式。关键要点：

选择合适的学习类型（监督/非监督/强化）
理解算法的工作原理和适用场景
重视数据质量和特征工程
正确评估模型性能
防止过拟合和欠拟合

从简单算法开始，逐步掌握复杂模型。实践是最好的老师！

机器学习基础概念

分享这篇文章