Python机器学习：自然语言处理、计算机视觉与强化学习

📘 Python机器学习：自然语言处理、计算机视觉与强化学习

目录

1. ✨ 自然语言处理（NLP）
   • 文本预处理：分词、去停用词
   • 词向量与文本分类：使用Word2Vec与BERT
2. 🌆 计算机视觉基础
   • 图像预处理与增强
   • 目标检测与分割
3. 🧠 强化学习入门
   • 主要概念与算法：Q-learning、Deep Q-Networks

---

✨ 1. 自然语言处理（NLP）

📄 1.1 文本预处理：分词、去停用词

文本预处理是自然语言处理的基础步骤。原始文本通常包含很多噪音，如标点符号、特殊字符、停用词等。为了让模型更好地理解和处理文本，需要对其进行规范化处理。

**分词（Tokenization）**是文本预处理的第一步，分词的目的是将连续的字符串切分成单词或短语。中文的分词比较复杂，因为中文句子没有明显的分隔符。而英文分词则相对简单，通过空格分隔即可。

import jieba  # 导入中文分词工具
text = "机器学习是人工智能的一个分支。"
tokens = jieba.lcut(text)  # 使用精确模式分词
print("分词结果：", tokens)

**去停用词（Stopword Removal）**是在分词的基础上，移除那些对语义影响不大的词汇，如“的”、“是”等。这些词在模型中通常不会提供有用的信息。

# 定义中文停用词列表
stopwords = ['的', '是', '在', '和']
filtered_tokens = [word for word in tokens if word not in stopwords]
print("去停用词后的结果：", filtered_tokens)

文本预处理可以显著减少模型训练的复杂度，并提高模型的准确性。合理的预处理能够提升模型的效率和表现。

---

📊 1.2 词向量与文本分类：使用Word2Vec与BERT

词向量将文本中的词语转化为向量，进而可以在数学空间中计算词语之间的相似度和语义关联。常见的词向量方法有Word2Vec和BERT。

Word2Vec模型通过预测上下文词语（Skip-gram）或根据上下文预测中心词（CBOW），将词转化为固定长度的向量。

from gensim.models import Word2Vec

sentences = [['我', '喜欢', '机器学习'], ['人工智能', '正在', '改变', '世界']]
model = Word2Vec(sentences, vector_size=100, window=5, min_count=1, sg=0)  # 训练Word2Vec模型
vector = model.wv['机器学习']  # 获取词向量
print("词向量：", vector)

BERT（Bidirectional Encoder Representations from Transformers）是一种基于Transformer的预训练模型，通过上下文的双向信息获取词的深层语义。

from transformers import BertTokenizer, BertModel
import torch

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')

input_text = "Machine learning is a branch of AI."
inputs = tokenizer(input_text, return_tensors="pt")
outputs = model(**inputs)
print("BERT输出：", outputs.last_hidden_state)

词向量能在文本分类、情感分析等任务中大幅提升模型的表现。通过使用BERT等高级模型，可以更好地捕捉文本中的复杂语义关系，从而提升模型的理解能力。

---

🌆 2. 计算机视觉基础

🖼 2.1 图像预处理与增强

在计算机视觉任务中，图像预处理和增强是至关重要的步骤。图像预处理可以减少噪声，提高图像质量，而图像增强则可以丰富数据样本，提高模型的泛化能力。

图像预处理包括灰度化、归一化、去噪等操作。例如，图像灰度化可以将彩色图像转化为单通道的灰度图，减少计算量。

import cv2
import numpy as np

image = cv2.imread('image.jpg')  # 读取图像
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # 将彩色图像转为灰度图
cv2.imshow('Gray Image', gray_image)
cv2.waitKey(0)

图像增强则可以通过旋转、缩放、翻转等方式生成更多的样本，特别是在数据不足的情况下，图像增强是一种有效的提升模型泛化能力的方法。

from tensorflow.keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator(
    rotation_range=40,  # 随机旋转
    width_shift_range=0.2,  # 随机水平位移
    height_shift_range=0.2,  # 随机垂直位移
    shear_range=0.2,  # 随机错切变换
    zoom_range=0.2,  # 随机缩放
    horizontal_flip=True,  # 水平翻转
    fill_mode='nearest'  # 填充方式
)

image = np.expand_dims(image, 0)  # 扩展图像维度以适应批量生成器
datagen.fit(image)

# 生成增强后的图像
for batch in datagen.flow(image, batch_size=1):
    plt.imshow(batch[0].astype('uint8'))
    plt.show()
    break  # 仅显示一张增强后的图像

图像预处理和增强不仅能改善图像质量，还能增加训练数据的多样性，从而提升模型的鲁棒性和表现。

---

🎯 2.2 目标检测与分割

目标检测与分割是计算机视觉中的两个核心任务。目标检测是识别图像中目标物体的位置和类别，而分割是将图像中的目标从背景中分离出来。

目标检测使用边界框（Bounding Box）来标注物体的位置，常见的检测算法有YOLO、SSD等。以下是基于YOLOv3的目标检测代码示例。

import cv2
import numpy as np

# 加载YOLO模型和权重
net = cv2.dnn.readNet('yolov3.weights', 'yolov3.cfg')
layer_names = net.getLayerNames()
output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]

image = cv2.imread('image.jpg')  # 加载图像
height, width = image.shape[:2]

# 预处理图像
blob = cv2.dnn.blobFromImage(image, 0.00392, (416, 416), (0, 0, 0), True, crop=False)
net.setInput(blob)
outs = net.forward(output_layers)

# 处理输出结果
for out in outs:
    for detection in out:
        scores = detection[5:]
        class_id = np.argmax(scores)
        confidence = scores[class_id]
        if confidence > 0.5:
            center_x = int(detection[0] * width)
            center_y = int(detection[1] * height)
            w = int(detection[2] * width)
            h = int(detection[3] * height)
            # 绘制边界框
            cv2.rectangle(image, (center_x - w // 2, center_y - h // 2), (center_x + w // 2, center_y + h // 2), (0, 255, 0), 2)

cv2.imshow('Object Detection', image)
cv2.waitKey(0)

图像分割则通过像素级别的分类来分离物体，常见的分割算法有U-Net、Mask R-CNN等。以下是基于U-Net模型的简要代码示例。

from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, UpSampling2D, concatenate

def unet_model(input_size=(256, 256, 1)):
    inputs = Input(input_size)
    conv1 = Conv2D(64, 3, activation='relu', padding='same')(inputs)
    pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
    
    conv2 = Conv2D(128, 3, activation='relu', padding='same')(pool1)
    pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)

    up1 = UpSampling2D(size=(2, 2))(pool2)
    merge1 = concatenate([conv1, up1], axis=3)
    conv3 = Conv2D(64, 3, activation='relu', padding

='same')(merge1)

    model = Model(inputs, conv3)
    return model

model = unet_model()
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

目标检测与分割是计算机视觉中的核心任务，广泛应用于自动驾驶、医疗影像等领域。

---

🧠 3. 强化学习入门

🤖 3.1 主要概念与算法：Q-learning、Deep Q-Networks

强化学习（Reinforcement Learning, RL）是一种通过试错来学习最优策略的机器学习方法。与监督学习和无监督学习不同，强化学习的目标是通过与环境的交互来最大化累积奖励。

Q-learning是一种经典的强化学习算法，旨在通过更新Q值函数来找到最佳策略。Q值函数表示在某一状态下采取某一动作的预期累积奖励。

import numpy as np

# 定义Q表
Q = np.zeros((5, 2))  # 假设有5个状态和2个动作

# 参数设置
alpha = 0.1  # 学习率
gamma = 0.9  # 折扣因子
epsilon = 0.1  # 探索率

# 模拟环境反馈
def get_reward(state, action):
    if state == 4 and action == 1:
        return 1  # 终止状态
    return 0

# Q-learning算法
def q_learning():
    for episode in range(100):  # 迭代100次
        state = np.random.randint(0, 5)  # 随机初始化状态
        while state != 4:  # 直到达到终止状态
            if np.random.rand() < epsilon:  # 探索
                action = np.random.randint(0, 2)
            else:  # 利用
                action = np.argmax(Q[state])

            next_state = state + 1  # 假设每次状态递增
            reward = get_reward(state, action)

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

            state = next_state

q_learning()
print("更新后的Q表：", Q)

Deep Q-Networks (DQN)**是一种结合了深度学习的强化学习算法。通过神经网络近似Q值函数，DQN在复杂环境中具有更强的表达能力。

import torch
import torch.nn as nn
import torch.optim as optim
import random

class DQN(nn.Module):
    def __init__(self):
        super(DQN, self).__init__()
        self.fc1 = nn.Linear(4, 24)
        self.fc2 = nn.Linear(24, 24)
        self.fc3 = nn.Linear(24, 2)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

model = DQN()
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.MSELoss()

# 模拟训练过程
state = torch.FloatTensor([1, 0, 0, 0])
target = torch.FloatTensor([0, 1])
output = model(state)
loss = criterion(output, target)
optimizer.zero_grad()
loss.backward()
optimizer.step()

强化学习中的Q-learning和DQN是两个关键算法，前者用于简单离散环境，后者则在复杂的连续环境中表现优异。通过学习最优策略，强化学习能够解决动态环境中的决策问题。