TensorFlow和Pytorch分析经典数据iris实现区别和对比

TensorFlow 分析 iris 数据的源码

当使用TensorFlow来分析Iris数据集时，可以使用经典的机器学习问题——鸢尾花分类任务。以下是一个使用TensorFlow库来训练和评估模型的基本源代码示例：

import tensorflow as tf
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder

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

# 对标签进行独热编码
enc = OneHotEncoder()
y = enc.fit_transform(y[:, None]).toarray()

# 将数据集拆分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 构建模型
model = tf.keras.Sequential([
    tf.keras.layers.Dense(10, activation='relu', input_shape=(4,)),
    tf.keras.layers.Dense(10, activation='relu'),
    tf.keras.layers.Dense(3, activation='softmax')
])

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

# 训练模型
model.fit(X_train, y_train, epochs=50, batch_size=16, verbose=1)

# 评估模型
loss, accuracy = model.evaluate(X_test, y_test, verbose=0)
print(f'Test loss: {loss:.4f}')
print(f'Test accuracy: {accuracy:.4f}')

上述代码中，我们首先导入了所需的库和模块。然后，加载Iris数据集并将特征数据 X 和标签数据 y 分别存储。接下来，我们使用 OneHotEncoder 对标签进行独热编码，以便在多类分类问题中使用。

然后，我们将数据集分为训练集和测试集，使用 train_test_split 函数，其中测试集占比为20%。

接下来，我们构建了一个简单的神经网络模型，使用 tf.keras.Sequential 创建一个顺序模型。该模型由三个密集连接层组成，使用ReLU激活函数，并在最后一层使用softmax激活函数来输出概率分布。

然后，我们编译模型，指定优化器、损失函数和评估指标。这里使用Adam优化器和交叉熵损失函数。

接下来，我们使用训练集数据进行模型训练，使用 fit 方法，并指定训练的迭代次数、批次大小和详细模式。

最后，我们使用测试集数据评估模型的性能，使用 evaluate 方法，并打印出损失值和准确率。

当使用PyTorch来分析Iris数据集时，可以使用与之前相似的机器学习问题——鸢尾花分类任务。以下是一个使用PyTorch库来训练和评估模型的基本源代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder
from torch.utils.data import Dataset, DataLoader

# 自定义数据集类
class IrisDataset(Dataset):
    def __init__(self, data, targets):
        self.data = data
        self.targets = targets
    
    def __len__(self):
        return len(self.targets)
    
    def __getitem__(self, idx):
        return self.data[idx], self.targets[idx]

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

# 对标签进行独热编码
enc = OneHotEncoder()
y = enc.fit_transform(y[:, None]).toarray()

# 将数据集拆分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 将数据转换为PyTorch张量
X_train = torch.tensor(X_train, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.float32)
X_test = torch.tensor(X_test, dtype=torch.float32)
y_test = torch.tensor(y_test, dtype=torch.float32)

# 创建数据加载器
train_dataset = IrisDataset(X_train, y_train)
train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)

# 构建模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(4, 10)
        self.fc2 = nn.Linear(10, 10)
        self.fc3 = nn.Linear(10, 3)
        self.relu = nn.ReLU()
        self.softmax = nn.Softmax(dim=1)
    
    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.softmax(self.fc3(x))
        return x

model = Net()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

# 训练模型
num_epochs = 50
for epoch in range(num_epochs):
    for inputs, targets in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, torch.argmax(targets, dim=1))
        loss.backward()
        optimizer.step()

# 评估模型
with torch.no_grad():
    outputs = model(X_test)
    predicted = torch.argmax(outputs, dim=1)
    accuracy = (predicted == torch.argmax(y_test, dim=1)).sum().item() / len(y_test)

print(f'Test accuracy: {accuracy:.4f}')

在上述代码中，我们首先导入了所需的库和模块。然后，加载Iris数据集并将特征数据 X 和标签数据 y 分别存储。接下来，我们使用 OneHotEncoder 对标签进行独热编码，以便在多类分类问题中使用。

然后，我们将数据集分为训练集和测试集，使用 train_test_split 函数，其中测试集占比为20%。

接着，我们定义了一个自定义的数据集类 IrisDataset，用于加载数据集并定义数据的获取方式。

然后，我们将数据转换为PyTorch张量，并创建了训练数据集的数据加载器，使用 DataLoader。

接下来，我们构建了一个简单的神经网络模型，使用 nn.Module 创建一个自定义的网络类 Net。该模型由三个全连接层组成，使用ReLU激活函数和Softmax函数，并定义了前向传播方法。

然后，我们定义了损失函数 nn.CrossEntropyLoss 和优化器 optim.Adam。

接下来，我们使用训练数据集进行模型训练。我们迭代数据加载器中的每个批次，并执行前向传播、计算损失、反向传播和参数更新的步骤。

最后，我们使用测试集数据评估模型的性能。我们计算模型在测试集上的准确率，并打印出结果。

看的出，TensorFlow实现起来更简介明了些。而Pytorch实现起来，涉及到很多深度学习的底层概念。方便我们更深一步的理解理论和具体操作流程。