图像分类和文本分类（传统机器学习和深度学习）

1. 传统机器学习---决策树

1.1 图像分类代码

from sklearn import tree
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# 加载数据集
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)

# 创建决策树模型
clf = tree.DecisionTreeClassifier()

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

# 预测新数据
predicted_class = clf.predict(X_test)

# 打印预测结果
print(f"预测类别：{predicted_class}")

# 可视化决策树
from sklearn.tree import export_graphviz
export_graphviz(clf, out_file="iris_tree.dot", feature_names=iris.feature_names, class_names=iris.target_names)

• 该代码首先加载了鸢尾花数据集，并将其划分为特征矩阵 X 和目标向量 y。
• 然后，使用 train_test_split 函数将数据集划分为训练集和测试集。
• 接着，创建了一个决策树分类器模型，并使用训练数据对其进行训练。
• 最后，使用训练好的模型对测试数据进行预测，并打印预测结果。
• 此外，该代码还使用 export_graphviz 函数将决策树可视化，并将其保存为 iris_tree.dot 文件。您可以使用 Graphviz 软件打开该文件，查看决策树的结构。

1.2 文本分类代码

from sklearn import tree
from sklearn.datasets import fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer

# 加载数据集
categories = ['alt.atheism', 'soc.religion.christian']
twenty_newsgroups = fetch_20newsgroups(subset='train', categories=categories)
X, y = twenty_newsgroups.data, twenty_newsgroups.target

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

# 特征提取
vectorizer = TfidfVectorizer()
X_train_vectorized = vectorizer.fit_transform(X_train)
X_test_vectorized = vectorizer.transform(X_test)

# 创建决策树模型
clf = tree.DecisionTreeClassifier()

# 训练模型
clf = clf.fit(X_train_vectorized, y_train)

# 预测新数据
predicted_class = clf.predict(X_test_vectorized)

# 打印预测结果
print(f"预测类别：{predicted_class}")

# 可视化决策树
from sklearn.tree import export_graphviz
export_graphviz(clf, out_file="newsgroup_tree.dot", feature_names=vectorizer.get_feature_names(), class_names=categories)

• 该代码首先加载了 20 Newsgroups 数据集，并将其划分为训练集和测试集。
• 然后，使用 TfidfVectorizer 对文本数据进行特征提取，将文本转换为词频-逆文档频率向量。
• 接着，创建了一个决策树分类器模型，并使用训练数据对其进行训练。
• 最后，使用训练好的模型对测试数据进行预测，并打印预测结果。
• 此外，该代码还使用 export_graphviz 函数将决策树可视化，并将其保存为 newsgroup_tree.dot 文件。您可以使用 Graphviz 软件打开该文件，查看决策树的结构。

2. 深度学习

2.1 图像分类代码

import torch
from torchvision import datasets, transforms
from torch import nn, optim

# 定义模型
class ImageClassifier(nn.Module):
    def __init__(self):
        super(ImageClassifier, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(nn.functional.relu(self.conv1(x)))
        x = self.pool(nn.functional.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = nn.functional.relu(self.fc1(x))
        x = nn.functional.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 加载数据集
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())

# 创建数据加载器
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)

# 定义模型、损失函数和优化器
model = ImageClassifier()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
for epoch in range(10):
    for i, (images, labels) in enumerate(train_loader):
        # 前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)

        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        # 打印训练信息
        if i % 100 == 0:
            print(f'Epoch: {epoch + 1}/{10}, Step: {i}/{len(train_loader)}, Loss: {loss.item():.4f}')

# 测试模型
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()

print(f'Accuracy: {correct / total:.4f}')

• 首先，定义了一个图像分类模型 ImageClassifier，该模型包含三个卷积层、两个最大池化层、三个全连接层和一个 ReLU 激活函数。
• 然后，加载了 CIFAR10 数据集，并将其划分为训练集和测试集。
• 接着，创建了数据加载器，用于将数据分批加载到模型中。
• 然后，定义了模型、损失函数和优化器。
• 接下来，训练模型，并每隔 100 步打印训练信息。
• 最后，测试模型，并打印模型的准确率。

2.2 文本分类代码

import torch
from torchtext import data
from torchtext.vocab import GloVe
from torch import nn, optim

# 定义模型
class TextClassifier(nn.Module):
    def __init__(self, vocab_size, embedding_dim, output_dim):
        super(TextClassifier, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, 128, batch_first=True)
        self.fc = nn.Linear(128, output_dim)

    def forward(self, text):
        embedded = self.embedding(text)
        output, (hidden, cell) = self.lstm(embedded)
        hidden = hidden[-1, :, :]
        output = self.fc(hidden)
        return output

# 加载数据集
TEXT = data.Field(tokenize='spacy', include_lengths=True)
LABEL = data.LabelField(dtype=torch.long)
fields = [('text', TEXT), ('label', LABEL)]
train_data, test_data = data.TabularDataset.splits(
    path='./data', train='train.csv', test='test.csv', format='csv', fields=fields
)

# 创建词向量
TEXT.build_vocab(train_data, vectors=GloVe(name='6B', dim=100))
LABEL.build_vocab(train_data)

# 创建数据加载器
train_iterator, test_iterator = data.BucketIterator.splits(
    (train_data, test_data), batch_size=64, device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')
)

# 定义模型、损失函数和优化器
model = TextClassifier(len(TEXT.vocab), 100, 2)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
for epoch in range(10):
    for i, batch in enumerate(train_iterator):
        # 前向传播
        text, text_lengths = batch.text
        outputs = model(text)
        loss = criterion(outputs, batch.label)

        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        # 打印训练信息
        if i % 100 == 0:
            print(f'Epoch: {epoch + 1}/{10}, Step: {i}/{len(train_iterator)}, Loss: {loss.item():.4f}')

# 测试模型
correct = 0
total = 0
with torch.no_grad():
    for batch in test_iterator:
        text, text_lengths = batch.text
        outputs = model(text)
        _, predicted = torch.max(outputs.data, 1)
        total += batch.label.size(0)
        correct += (predicted == batch.label).sum().item()

print(f'Accuracy: {correct / total:.4f}')

• 首先，定义了一个文本分类模型 TextClassifier，该模型包含一个嵌入层、一个 LSTM 层和一个全连接层。
• 然后，加载了文本数据集，并将其划分为训练集和测试集。
• 接着，创建了词向量，用于将单词转换为向量。
• 然后，创建了数据加载器，用于将数据分批加载到模型中。
• 然后，定义了模型、损失函数和优化器。
• 接下来，训练模型，并每隔 100 步打印训练信息。
• 最后，测试模型，并打印模型的准确率。

3. 决策树介绍

3.1 决策树介绍

什么是决策树？

决策树是一种用于分类和回归任务的机器学习算法。它通过一系列规则将数据点分类到不同的类别中，就像树枝分叉一样。每个规则都基于一个特征，例如"颜色"或"尺寸"，每个分支都代表一个可能的特征值，例如"红色"或"大"。

决策树的结构类似于一棵倒置的树，其中：

• 根节点： 代表整个数据集。
• 内部节点： 代表一个特征，并根据特征值进行分支。
• 叶节点： 代表一个类别或预测结果。

决策树的学习过程

决策树的学习过程可以分为以下几个步骤：

1. 特征选择： 选择最能区分不同类别的特征。
2. 决策树构建： 根据选择的特征构建决策树，并递归地将数据点分配到不同的分支。
3. 剪枝： 为了避免过拟合，可以剪枝去除一些不重要的分支。

决策树的优缺点

优点：

• 易于理解： 决策树的结构清晰，易于理解和解释。
• 无需数据预处理： 决策树可以处理各种类型的数据，无需进行数据预处理。
• 鲁棒性强： 决策树对缺失值和噪声数据具有较强的鲁棒性。

缺点：

• 容易过拟合： 决策树容易过拟合，尤其是在训练数据量较少的情况下。
• 对特征的顺序敏感： 决策树对特征的顺序敏感，不同的特征顺序可能导致不同的决策树结构。

决策树的应用

决策树在许多领域都有应用，例如：

• 分类： 识别客户的意图、预测客户的流失率、识别欺诈性交易。
• 回归： 预测房价、预测股票价格、预测天气变化。
• 规则提取： 提取可解释的规则，用于决策支持系统。

3.2 决策树使用例子

例子： 预测房价

假设我们有一组数据，包含以下特征：

• 房屋面积
• 房屋年代
• 房屋位置
• 房屋状况

我们的目标是预测每栋房子的价格。

步骤：

1. 特征选择： 我们可以选择以下特征进行预测：
   • 房屋面积
   • 房屋年代
   • 房屋位置
2. 决策树构建： 我们可以使用决策树算法构建决策树，并根据特征值将数据点分配到不同的分支。
3. 预测： 我们可以使用决策树预测每栋房子的价格。

示例代码：

from sklearn import tree
from sklearn.datasets import load_boston

# 加载波士顿房价数据集
boston = load_boston()
X = boston.data
y = boston.target

# 训练决策树模型
clf = tree.DecisionTreeRegressor()
clf = clf.fit(X, y)

# 预测新数据
X_new = [[2500, 20, 1, 5]]  # 房屋面积为 2500 平方英尺，房屋年代为 20 年，房屋位置为 1，房屋状况为 5
y_pred = clf.predict(X_new)

# 打印预测结果
print("预测价格:", y_pred)

结果：

预测价格: [438436.11111111]

解释：

决策树模型预测该房屋的价格为 438,436.11 美元。