TensorFlow 分析 iris 数据的源码
当使用TensorFlow来分析Iris数据集时，可以使用经典的机器学习问题------鸢尾花分类任务。以下是一个使用TensorFlow库来训练和评估模型的基本源代码示例：
python
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库来训练和评估模型的基本源代码示例：
python
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实现起来，涉及到很多深度学习的底层概念。方便我们更深一步的理解理论和具体操作流程。