硬核机器学习知识点教学--（代码讲解）

用代码和实战讲解机器学习，零基础一样看得懂👏🏻👏🏻👏🏻

复习、学习、备战考试皆可用👏🏻👏🏻👏🏻

本系列持续更新中，三连关注不迷路👌🏻  

干货满满不看后悔👍👍👍

📝个人主页→数据挖掘博主ZTLJQ的主页

个人推荐python学习系列：

☄️爬虫JS逆向系列专栏 - 爬虫逆向教学

☄️python系列专栏 - 从零开始学python

---

☀️1. 机器学习基础

 ⛅️ 1.1 监督学习

import numpy as np
from sklearn.linear_model import LinearRegression

# 构造训练集
X_train = np.array([[1], [2], [3], [4], [5]])
y_train = np.array([2, 4, 6, 8, 10])

# 创建线性回归模型并拟合数据
model = LinearRegression()
model.fit(X_train, y_train)

# 对新数据进行预测
X_new = np.array([[6]])
y_pred = model.predict(X_new)

print("预测结果:", y_pred)

from sklearn.tree import DecisionTreeClassifier

# 构造训练集
X_train = [[5.1, 3.5, 1.4, 0.2], [4.9, 3.0, 1.4, 0.2], [6.2, 3.4, 5.4, 2.3], [5.9, 3.0, 5.1, 1.8]]
y_train = [0, 0, 1, 1]

# 创建决策树分类器并拟合数据
model = DecisionTreeClassifier()
model.fit(X_train, y_train)

# 对新数据进行预测
X_new = [[6.5, 3.0, 5.2, 2.0]]
y_pred = model.predict(X_new)

print("预测结果:", y_pred)

from sklearn.neighbors import KNeighborsClassifier

# 构造训练集
X_train = [[3, 1.5], [2, 1], [4, 1.5], [3, 1], [3.5, 0.5], [2, 0.5], [5.5, 1], [1, 1], [4.5, 1]]
y_train = ['orange', 'orange', 'orange', 'orange', 'apple', 'apple', 'apple', 'apple', 'orange']

# 创建K最近邻分类器并拟合数据
model = KNeighborsClassifier(n_neighbors=3)
model.fit(X_train, y_train)

# 对新数据进行预测
X_new = [[2.9, 1.2]]
y_pred = model.predict(X_new)

print("预测结果:", y_pred)

⛅️ 1.2 无监督学习

# 导入必要的库
import numpy as np
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# 生成示例数据
np.random.seed(0)
X = np.random.rand(100, 2)

# 使用K-Means算法进行聚类
kmeans = KMeans(n_clusters=3, random_state=0)
kmeans.fit(X)

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=kmeans.labels_)
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], marker='x', color='red')
plt.title('K-Means Clustering')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()


#运行以上代码，我们可以得到一个可视化的聚类结果图。
#图中的数据点被分为了三个簇，并且每个簇的聚类中心用红色的叉标注。

⛅️1.3 半监督学习

# 导入必要的库
import numpy as np
from sklearn.datasets import make_moons
from sklearn.semi_supervised import LabelPropagation
import matplotlib.pyplot as plt

# 生成示例数据
np.random.seed(0)
X, y = make_moons(n_samples=200, noise=0.05)

# 设置部分数据标记
n_labeled = 10
labels = np.array([-1] * len(X))
labels[:n_labeled] = y[:n_labeled]

# 使用标签传播算法进行半监督学习
label_prop = LabelPropagation(kernel='knn', n_neighbors=10)
label_prop.fit(X, labels)

# 可视化结果
plt.scatter(X[:, 0], X[:, 1], c=label_prop.labels_, cmap='viridis')
plt.title('Label Propagation')
plt.xlabel('X1')
plt.ylabel('X2')
plt.show()

#运行以上代码，我们可以得到一个可视化的结果图。
#图中的数据点被分为不同的颜色，表示其被标记的类别。
#标签传播算法通过利用未标记数据点的相似性来传播标记信息，从而实现了半监督学习。

⛅️1.4 强化学习

# 导入必要的库
import numpy as np

# 定义环境和参数
num_states = 6
num_actions = 2
epsilon = 0.2
alpha = 0.5
gamma = 0.9

# 初始化Q值函数
Q = np.zeros((num_states, num_actions))

# Q-Learning算法
for episode in range(100):
    state = 0  # 初始状态
    while state != num_states - 1:
        # 选择动作
        if np.random.uniform() < epsilon:
            action = np.random.randint(num_actions)
        else:
            action = np.argmax(Q[state])

        # 执行动作并观察环境反馈
        if action == 0:
            reward = -1
            next_state = state - 1
        else:
            reward = 1
            next_state = state + 1

        # 更新Q值函数
        Q[state, action] += alpha * (reward + gamma * np.max(Q[next_state]) - Q[state, action])

        state = next_state

# 打印学习后的Q值函数
print("Learned Q-Values:")
print(Q)


#运行以上代码，我们可以得到学习后的Q值函数。
#Q值函数将状态和动作对应的长期回报进行了估计，智能决策者可以通过查询Q值函数来选择最优的动作。

⛅️1.5 迁移学习

# 导入必要的库
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.models as models
import torchvision.transforms as transforms
import torchvision.datasets as datasets

# 加载预训练模型
model = models.resnet18(pretrained=True)

# 冻结预训练模型的参数
for param in model.parameters():
    param.requires_grad = False

# 替换最后一层分类器
num_classes = 10
model.fc = nn.Linear(model.fc.in_features, num_classes)

# 加载新任务的数据
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transforms.ToTensor())
test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transforms.ToTensor())

# 定义优化器和损失函数
optimizer = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9)
criterion = nn.CrossEntropyLoss()

# 定义训练和测试函数
def train(model, train_loader, criterion, optimizer):
    model.train()
    for images, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

def test(model, test_loader):
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in test_loader:
            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    accuracy = 100.0 * correct / total
    return accuracy

# 加载数据并进行训练和测试
batch_size = 64
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 进行训练和测试
num_epochs = 10
for epoch in range(num_epochs):
    train(model, train_loader, criterion, optimizer)
    accuracy = test(model, test_loader)
    print('Epoch: {}, Accuracy: {:.2f}%'.format(epoch+1, accuracy))

#运行以上代码，我们可以使用预训练的ResNet模型在CIFAR-10数据集上进行微调和测试。
#预训练模型学习到的通用特征表示可以帮助模型更快地收敛，并在新任务上获得更好的性能。

⛅️1.6 集成学习

# 导入必要的库
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, y = iris.data, iris.target

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

# 构建随机森林模型
rf = RandomForestClassifier(n_estimators=100, random_state=42)

# 拟合模型
rf.fit(X_train, y_train)

# 预测
y_pred = rf.predict(X_test)

# 评估准确率
accuracy = accuracy_score(y_test, y_pred)
print('Accuracy: {:.2f}%'.format(accuracy * 100))

#运行以上代码，我们可以使用随机森林模型对鸢尾花数据集进行分类。
#随机森林通过构建多个决策树并整合它们的预测结果来提高分类准确率。