最强总结，十大机器学习库 ！！

作为入门机器学习的同学，很多常用的工具是不熟悉的，没事！

今儿这一篇文章，必然会给大家一个完整的交代~

点赞、收藏起来，慢慢学习~

机器学习领域中最常用和最重要的十大库包括：

• Scikit-learn
• TensorFlow
• PyTorch
• Keras
• Pandas
• NumPy
• Matplotlib
• Seaborn
• NLTK
• OpenCV

这些库涵盖了从传统机器学习到深度学习、数据处理、图像处理和自然语言处理等多个领域，是咱们在学习或者工作后不可或缺的工具。

针对每一种工具，给大家提供了各自的优缺点以及常用案例，10秒钟熟悉它！！~

咱们一起来看看~

1. Scikit-learn

Scikit-learn是一个用于Python的机器学习库，提供了一系列简单而高效的工具，支持数据挖掘和数据分析任务，适用于中小型数据集。

优点

• 丰富的算法：涵盖分类、回归、聚类等多种算法。
• 简单易用：接口设计简洁，适合初学者。
• 良好的文档支持：文档详尽，易于查阅。

缺点

• 深度学习支持有限：不适合处理大型数据集或复杂的深度学习任务。

官网链接

Scikit-learn：https://scikit-learn.org/

代表案例

我们使用Scikit-learn进行数据分析，详细描述数据处理、建模和可视化。使用 Iris 数据集。我们会完成以下任务：

1. 加载和预处理数据
2. 可视化数据分布
3. 建立分类模型
4. 可视化模型性能

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.svm import SVC
from sklearn.metrics import classification_report, confusion_matrix

# 1. 加载和预处理数据
iris = load_iris()
X = iris.data
y = 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)

# 2. 数据可视化

# 可视化数据分布
df = pd.DataFrame(data=np.c_[X, y], columns=iris.feature_names + ['target'])
sns.pairplot(df, hue='target', palette='Set1')
plt.suptitle('Iris 数据集特征两两关系', y=1.02)
plt.show()

# 进行 PCA 降维，用于后续可视化
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# 可视化 PCA 降维结果
plt.figure(figsize=(8, 6))
sns.scatterplot(x=X_pca[:, 0], y=X_pca[:, 1], hue=iris.target_names[y], palette='Set1')
plt.title('PCA 降维后的数据分布')
plt.xlabel('PCA 1')
plt.ylabel('PCA 2')
plt.legend(loc='best')
plt.show()

# 3. 建立分类模型
svc = SVC(kernel='linear', C=1)
svc.fit(X_train, y_train)

# 预测
y_pred = svc.predict(X_test)

# 4. 可视化模型性能

# 可视化混淆矩阵
conf_matrix = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(6, 5))
sns.heatmap(conf_matrix, annot=True, cmap='Blues', fmt='g', xticklabels=iris.target_names, yticklabels=iris.target_names)
plt.xlabel('预测标签')
plt.ylabel('真实标签')
plt.title('混淆矩阵')
plt.show()

# 打印分类报告
print("分类报告:\n", classification_report(y_test, y_pred, target_names=iris.target_names))

2. TensorFlow

TensorFlow是一个由Google开发的开源深度学习框架，适用于广泛的机器学习任务，包括深度学习和神经网络模型的构建和训练。

优点

• 强大的功能：支持复杂模型、分布式训练和大规模生产部署。
• 广泛的社区支持：大量的教程、示例和第三方支持。

缺点

• 学习曲线陡峭：初学者可能需要时间熟悉其复杂的API。

官网链接

TensorFlow：https://www.tensorflow.org/

代表案例

使用 TensorFlow 进行图像分类，使用了 CIFAR-10 数据集。CIFAR-10 是一个常用的图像分类数据集，包含了 10 个类别的 60000 张 32x32 的彩色图像。

import tensorflow as tf
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

from tensorflow.keras.datasets import cifar10
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D, Dropout
from sklearn.metrics import confusion_matrix, classification_report

# 加载CIFAR-10数据集
(x_train, y_train), (x_test, y_test) = cifar10.load_data()

# 正则化像素值
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

# One-hot编码标签
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

# 构建模型
model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Conv2D(128, (3, 3), activation='relu'),
    Flatten(),
    Dense(128, activation='relu'),
    Dropout(0.5),
    Dense(10, activation='softmax')
])

# 编译模型
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# 训练模型
history = model.fit(x_train, y_train, epochs=10, 
                    validation_data=(x_test, y_test))

# 评估模型
test_loss, test_acc = model.evaluate(x_test, y_test)

# 预测结果
y_pred = model.predict(x_test)
y_pred_classes = np.argmax(y_pred, axis=1)
y_true = np.argmax(y_test, axis=1)

# 混淆矩阵
conf_mat = confusion_matrix(y_true, y_pred_classes)

# 分类报告
class_report = classification_report(y_true, y_pred_classes)

# 绘制训练和验证的损失
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history['loss'], label='Train Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Training and Validation Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

# 绘制训练和验证的准确率
plt.subplot(1, 2, 2)
plt.plot(history.history['accuracy'], label='Train Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

plt.show()

# 绘制混淆矩阵
plt.figure(figsize=(10, 8))
sns.heatmap(conf_mat, annot=True, fmt='d', cmap='Blues')
plt.title('Confusion Matrix')
plt.xlabel('Predicted')
plt.ylabel('True')
plt.show()

# 打印分类报告
print("Classification Report:\n", class_report)

3. PyTorch

PyTorch是由Facebook开发的开源深度学习框架，提供了动态计算图功能，特别适合研究和实验。

优点

• 动态计算图：使调试和模型修改更加方便。
• 灵活性高：适合进行前沿研究和快速原型开发。

缺点

• 生产部署相对较少：在大规模生产环境中的应用不如TensorFlow广泛。

官网链接

PyTorch：https://pytorch.org/

代表案例

依然是图像分类问题。这个案例将包括数据加载、模型定义、训练、评估和绘图等步骤。依然选择使用经典的 CIFAR-10 数据集，这是一个包含10个类别的图像分类数据集。

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

# 数据加载和转换
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

# 可视化部分数据
def imshow(img):
    img = img / 2 + 0.5     # 反归一化
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()

# 获取随机训练图像
dataiter = iter(trainloader)
images, labels = dataiter.next()

# 显示图像
imshow(torchvision.utils.make_grid(images))
# 打印标签
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

# 定义神经网络
class Net(nn.Module):
    def __init__(self):
        super(Net, 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

net = Net()

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

# 训练网络
for epoch in range(2):  # 多次迭代数据集
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data

        optimizer.zero_grad()

        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 2000 == 1999:    # 每 2000 批次打印一次损失值
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

# 在测试集上测试网络
dataiter = iter(testloader)
images, labels = dataiter.next()

# 显示测试图像
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

# 计算网络的预测结果
outputs = net(images)
_, predicted = torch.max(outputs, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
                              for j in range(4)))

# 在整个测试集上的表现
correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))

# 输出每个类别的准确率
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels).squeeze()
        for i in range(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1

for i in range(10):
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]))

# 绘制混淆矩阵
from sklearn.metrics import confusion_matrix
import itertools

def plot_confusion_matrix(cm, classes, normalize=False, title='Confusion matrix', cmap=plt.cm.Blues):
    if normalize:
        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
        print("Normalized confusion matrix")
    else:
        print('Confusion matrix, without normalization')

    plt.imshow(cm, interpolation='nearest', cmap=cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation=45)
    plt.yticks(tick_marks, classes)

    fmt = '.2f' if normalize else 'd'
    thresh = cm.max() / 2.
    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        plt.text(j, i, format(cm[i, j], fmt),
                 horizontalalignment="center",
                 color="white" if cm[i, j] > thresh else "black")

    plt.tight_layout()
    plt.ylabel('True label')
    plt.xlabel('Predicted label')

# 计算混淆矩阵
conf_matrix = confusion_matrix(labels.numpy(), predicted.numpy())
np.set_printoptions(precision=2)

# 绘制非归一化混淆矩阵
plt.figure(figsize=(8, 6))
plot_confusion_matrix(conf_matrix, classes=classes, title='Confusion matrix, without normalization')

# 绘制归一化混淆矩阵
plt.figure(figsize=(8, 6))
plot_confusion_matrix(conf_matrix, classes=classes, normalize=True, title='Normalized confusion matrix')

plt.show()

4. Keras

Keras是一个用于构建和训练深度学习模型的高级神经网络API，简化了模型设计和实验的过程。

优点

• 易用性：设计直观，适合快速原型开发。
• 与多个后端兼容：支持TensorFlow、Theano和CNTK等多种后端。

缺点

• 性能限制：在处理大型或复杂模型时可能不如低层库高效。

官网链接

Keras：https://keras.io/

代表案例

使用 MNIST 手写数字数据集，包括了数据预处理、模型构建、训练和可视化。这个案例可以帮助大家理解如何使用 Keras 构建神经网络并进行图像分类。

import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.utils import np_utils

# 加载数据集
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# 数据预处理
# 将图像数据转换为一维向量，同时进行归一化
X_train = X_train.reshape(X_train.shape[0], 784).astype('float32') / 255
X_test = X_test.reshape(X_test.shape[0], 784).astype('float32') / 255

# 将目标变量进行 one-hot 编码
y_train = np_utils.to_categorical(y_train, 10)
y_test = np_utils.to_categorical(y_test, 10)

# 构建神经网络模型
model = Sequential()
model.add(Dense(512, input_shape=(784,), activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))

# 编译模型
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# 训练模型
history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=20, batch_size=128, verbose=1)

# 可视化训练过程
plt.figure(figsize=(12, 6))

# 绘制训练和验证的准确率
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

# 绘制训练和验证的损失
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Training and Validation Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.tight_layout()
plt.show()

5. Pandas

Pandas是Python中用于数据操作和分析的库，提供了强大的数据结构，如DataFrame，适合各种数据预处理任务。

优点

• 强大的数据操作能力：支持数据清洗、处理、分析等多种操作。
• 简洁的接口：代码简洁易读，适合处理结构化数据。

缺点

• 性能限制：在处理超大型数据集时可能效率不高。

官网链接

Pandas：https://pandas.pydata.org/

代表案例

Pandas 的案例涉及数据的加载、清洗、分析和可视化。

涉及到的泰坦尼克数据集，点击名片，回复「数据集」即可~

# 导入所需的库
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# 读取数据集
df = pd.read_csv('titanic.csv')

# 查看数据集的前几行和基本信息
print(df.head())
print(df.info())

# 数据清洗：处理缺失值
df.dropna(subset=['Age', 'Embarked'], inplace=True)

# 数据分析和图形化
# 1. 绘制年龄分布的直方图
plt.figure(figsize=(10, 6))
sns.histplot(df['Age'], bins=20, kde=True, color='skyblue')
plt.title('Age Distribution')
plt.xlabel('Age')
plt.ylabel('Count')
plt.show()

# 2. 不同性别乘客的生存率比较
plt.figure(figsize=(8, 6))
sns.barplot(x='Sex', y='Survived', data=df, ci=None)
plt.title('Survival Rate by Gender')
plt.xlabel('Gender')
plt.ylabel('Survival Rate')
plt.show()

# 3. 不同票价等级的乘客生存率比较
plt.figure(figsize=(8, 6))
sns.boxplot(x='Pclass', y='Fare', hue='Survived', data=df)
plt.title('Fare Distribution by Pclass and Survival')
plt.xlabel('Pclass')
plt.ylabel('Fare')
plt.legend(title='Survived', loc='upper right')
plt.show()

6. NumPy

NumPy是Python中用于科学计算的核心库，提供多维数组对象和丰富的数学函数，广泛应用于数值计算领域。

优点

• 高效的数值计算：提供多维数组和矩阵运算支持。
• 基础性强：许多其他科学计算库（如Pandas、SciPy）都基于NumPy。

缺点

• 功能单一：专注于数值计算，缺少高级数据处理功能。

官网链接

NumPy：https://numpy.org/

代表案例

使用NumPy进行数据生成和分析~

import numpy as np
import matplotlib.pyplot as plt

# 生成数据
x = np.linspace(0, 10, 1000)
y1 = np.sin(x)
y2 = np.cos(x)
error = 0.1 + 0.1 * x

# 绘制图形
plt.figure(figsize=(10, 6))

# 第一个图：折线图
plt.subplot(2, 2, 1)
plt.plot(x, y1, label='sin(x)', color='blue')
plt.plot(x, y2, label='cos(x)', color='red', linestyle='dashed')
plt.title('Sin(x) and Cos(x)')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()

# 第二个图：散点图
plt.subplot(2, 2, 2)
plt.scatter(x, y1, label='sin(x)', color='blue')
plt.scatter(x, y2, label='cos(x)', color='red')
plt.title('Scatter plot of Sin(x) and Cos(x)')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()

# 第三个图：误差条形图
plt.subplot(2, 2, 3)
plt.errorbar(x, y1, yerr=error, label='sin(x)', fmt='-o', color='blue')
plt.errorbar(x, y2, yerr=error, label='cos(x)', fmt='-o', color='red')
plt.title('Errorbar plot of Sin(x) and Cos(x)')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()

# 第四个图：直方图
data = np.random.normal(0, 1, 1000)
plt.subplot(2, 2, 4)
plt.hist(data, bins=30, density=True, alpha=0.5, color='g')
plt.title('Histogram of Random Data')
plt.xlabel('Value')
plt.ylabel('Frequency')

# 调整布局并显示图形
plt.tight_layout()
plt.show()

7. Matplotlib

Matplotlib是一个用于绘制二维图表和数据可视化的Python库，支持生成多种图形，如折线图、柱状图、散点图等。

优点

• 灵活性高：支持各种类型的图形绘制。
• 广泛支持：与其他数据科学库（如Pandas）集成良好。

缺点

• 学习曲线陡峭：对复杂图形的绘制需要较多的配置和调试。

官网链接

Matplotlib：https://matplotlib.org/

代表案例

展示如何在一个图形中绘制多个图表，以进行复杂的数据分析。这些图表包括散点图、条形图、以及折线图。

案例：股票数据分析

我们将绘制三个图：

1. 股票价格的散点图：展示不同时间点的股票价格。
2. 成交量的条形图：展示每一天的成交量。
3. 股票价格的移动平均线：展示股票价格的5天和20天移动平均线。

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

# 生成一些虚拟股票数据
np.random.seed(0)
dates = pd.date_range('2023-01-01', periods=100)
prices = np.random.lognormal(mean=0, sigma=0.1, size=len(dates)).cumprod()
volumes = np.random.randint(1, 1000, size=len(dates))

# 创建 DataFrame
data = pd.DataFrame({
    'Date': dates,
    'Price': prices,
    'Volume': volumes
})
data.set_index('Date', inplace=True)

# 计算移动平均线
data['5 Day MA'] = data['Price'].rolling(window=5).mean()
data['20 Day MA'] = data['Price'].rolling(window=20).mean()

# 创建子图
fig, axs = plt.subplots(3, 1, figsize=(14, 10), sharex=True)

# 1. 股票价格的散点图
axs[0].scatter(data.index, data['Price'], color='blue', label='Price')
axs[0].set_title('Stock Prices')
axs[0].set_ylabel('Price')
axs[0].legend()

# 2. 成交量的条形图
axs[1].bar(data.index, data['Volume'], color='green', label='Volume')
axs[1].set_title('Trading Volume')
axs[1].set_ylabel('Volume')
axs[1].legend()

# 3. 股票价格及其移动平均线
axs[2].plot(data.index, data['Price'], label='Price')
axs[2].plot(data.index, data['5 Day MA'], label='5 Day MA', linestyle='--')
axs[2].plot(data.index, data['20 Day MA'], label='20 Day MA', linestyle=':')
axs[2].set_title('Stock Price with Moving Averages')
axs[2].set_ylabel('Price')
axs[2].legend()

# 统一的x轴标签
plt.xlabel('Date')

# 调整子图布局
plt.tight_layout()

# 显示图表
plt.show()

8. Seaborn

Seaborn是基于Matplotlib的高级数据可视化库，提供更高层次的接口和更漂亮的默认主题，适合快速生成统计图形。

优点

• 易于生成美观图表：默认样式美观，适合展示数据。
• 简洁的API：提供更简单的函数接口，易于使用。

缺点

• 灵活性较低：对于特定需求的自定义支持不如Matplotlib丰富。

官网链接

Seaborn：https://seaborn.pydata.org/

代表案例

这个例子使用的是Seaborn自带的数据集，包含了房屋价格和相关特征的信息。代码中展示了多种不同类型的图表，涵盖了数据的不同方面，包括关系分析、分布情况和分类显示等。

但是，由于安全原因，个别同学无法下载数据集，这里我将文件保存到本地目录，比如 tips.csv。

tips.csv数据集，点击名片，回复「数据集」即可~

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# 从本地CSV文件加载数据集
tips = pd.read_csv('tips.csv')

# 设置风格和调色板
sns.set(style="ticks", palette="pastel")

# 创建一个包含四个子图的画布
fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(16, 12))

# 图表1：小费与总消费的关系
sns.scatterplot(x="total_bill", y="tip", hue="size", size="size",
                sizes=(20, 200), palette="muted", legend="full", data=tips, ax=axs[0, 0])
axs[0, 0].set_title('Relationship between Total Bill and Tip')

# 图表2：不同性别的小费金额分布
sns.boxplot(x="sex", y="tip", hue="smoker", data=tips, palette="Set3", ax=axs[0, 1])
axs[0, 1].set_title('Distribution of Tips by Gender')

# 图表3：用餐日期的总消费分布
sns.violinplot(x="day", y="total_bill", hue="time", data=tips, split=True, palette="muted", ax=axs[1, 0])
axs[1, 0].set_title('Total Bill Distribution by Day')

# 图表4：用餐人数与总消费的关系
sns.barplot(x="size", y="total_bill", hue="time", data=tips, palette="pastel", ax=axs[1, 1])
axs[1, 1].set_title('Total Bill by Party Size and Time')

# 调整子图之间的间距
plt.tight_layout()
plt.show()

9. NLTK

NLTK是一个用于自然语言处理的Python库，提供了多种语言处理工具和文本分析功能，适合构建和研究NLP应用。

优点

• 功能全面：支持词性标注、命名实体识别等多种NLP任务。
• 文档丰富：提供了大量教程和示例。

缺点

• 性能限制：处理大规模文本数据时效率不高。

官网链接

NLTK：https://www.nltk.org/

代表案例

利用NLTK进行文本处理和分析，并使用matplotlib库进行数据可视化。

这个案例从文本中提取信息，并通过图形展示分析结果。

# 导入所需的库
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.probability import FreqDist
import matplotlib.pyplot as plt

# 下载NLTK的停用词和示例文本（如果尚未下载）
nltk.download('stopwords')
nltk.download('punkt')
nltk.download('example')

# 加载示例文本
example_text = nltk.corpus.example.raw('en/emma.txt')

# 将文本转换为小写并分词
words = word_tokenize(example_text.lower())

# 去除停用词
stop_words = set(stopwords.words('english'))
filtered_words = [word for word in words if word.isalnum() and word not in stop_words]

# 计算词频
fdist = FreqDist(filtered_words)

# 打印出现频率最高的前20个词
print(fdist.most_common(20))

# 绘制词频分布图
plt.figure(figsize=(10, 5))
fdist.plot(20, cumulative=False)
plt.title('Top 20 Most Common Words in Example Text')
plt.xlabel('Words')
plt.ylabel('Frequency')
plt.show()

10. OpenCV

OpenCV是一个开源计算机视觉库，包含广泛的图像处理和计算机视觉算法，支持实时应用。

优点

• 功能强大：涵盖从基本图像处理到复杂视觉算法的广泛应用。
• 跨平台支持：可在多个操作系统上运行，支持多种编程语言。

缺点

• 学习曲线：对初学者而言，需要一定的学习时间来掌握复杂功能。

官网链接

OpenCV：https://opencv.org/

代表案例

使用OpenCV和Matplotlib库的经典Python案例，给大家展示如何加载图像、进行简单的图像处理，并显示多个数据分析图形的例子。

这个例子将加载一张图片，进行灰度化处理，并显示原始图像、灰度图像以及直方图。

涉及到的图像，点击名片，回复「数据集」即可~

import cv2
import matplotlib.pyplot as plt
import numpy as np

# 加载图片
image_path = 'lenna.jpg'  # 替换为你自己的图片路径
original_image = cv2.imread(image_path)

# 将图片转换为灰度图
gray_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2GRAY)

# 计算灰度图的直方图
histogram = cv2.calcHist([gray_image], [0], None, [256], [0,256])

# 显示原始图片
plt.subplot(2, 2, 1)
plt.imshow(cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')

# 显示灰度图片
plt.subplot(2, 2, 2)
plt.imshow(gray_image, cmap='gray')
plt.title('Grayscale Image')
plt.axis('off')

# 显示直方图
plt.subplot(2, 2, 3)
plt.plot(histogram, color='black')
plt.title('Histogram')
plt.xlabel('Pixel Intensity')
plt.ylabel('Frequency')

# 显示灰度直方图
plt.subplot(2, 2, 4)
plt.hist(gray_image.ravel(), 256, [0,256], color='black')
plt.title('Grayscale Histogram')
plt.xlabel('Pixel Intensity')
plt.ylabel('Frequency')

# 调整子图布局
plt.tight_layout()

# 显示图形
plt.show()