迁移学习算法中预训练模型（Pre-trained Models）

pythonCopy codeimport torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
import torchvision.models as models
from torch.utils.data import DataLoader
from torchvision.datasets import CIFAR10
# 加载预训练模型
pretrained_model = models.resnet18(pretrained=True)
# 冻结预训练模型的参数
for param in pretrained_model.parameters():
    param.requires_grad = False
# 替换预训练模型的最后一层分类器
num_classes = 10  # CIFAR10数据集有10个类别
pretrained_model.fc = nn.Linear(pretrained_model.fc.in_features, num_classes)
# 定义数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
# 加载CIFAR10数据集
train_dataset = CIFAR10(root='./data', train=True, transform=transform, download=True)
test_dataset = CIFAR10(root='./data', train=False, transform=transform, download=True)
# 创建数据加载器
batch_size = 32
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(pretrained_model.fc.parameters(), lr=0.001, momentum=0.9)
# 训练模型
num_epochs = 10
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
pretrained_model.to(device)
for epoch in range(num_epochs):
    running_loss = 0.0
    correct = 0
    total = 0
    for inputs, labels in train_loader:
        inputs = inputs.to(device)
        labels = labels.to(device)
        optimizer.zero_grad()
        outputs = pretrained_model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        _, predicted = outputs.max(1)
        total += labels.size(0)
        correct += predicted.eq(labels).sum().item()
    train_loss = running_loss / len(train_loader)
    train_acc = 100.0 * correct / total
    print(f"Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.2f}%")
# 在测试集上评估模型
pretrained_model.eval()
test_correct = 0
test_total = 0
with torch.no_grad():
    for inputs, labels in test_loader:
        inputs = inputs.to(device)
        labels = labels.to(device)
        outputs = pretrained_model(inputs)
        _, predicted = outputs.max(1)
        test_total += labels.size(0)
        test_correct += predicted.eq(labels).sum().item()
test_acc = 100.0 * test_correct / test_total
print(f"Test Acc: {test_acc:.2f}%")

pythonCopy codefrom sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
# 假设有一个包含文本和标签的训练数据集
train_texts = [
    "This movie is great",
    "I really enjoyed this book",
    "The weather today is beautiful",
    "I dislike this song"
]
train_labels = [1, 1, 0, 0]
# 假设有一个包含文本的测试数据集
test_texts = [
    "I love this movie",
    "The book is boring",
    "The weather is terrible today"
]
# 文本特征提取
vectorizer = CountVectorizer()
train_features = vectorizer.fit_transform(train_texts)
test_features = vectorizer.transform(test_texts)
# 训练分类器
classifier = LogisticRegression()
classifier.fit(train_features, train_labels)
# 预测
predictions = classifier.predict(test_features)
# 输出预测结果
for text, label in zip(test_texts, predictions):
    if label == 1:
        print(f"{text}: Positive")
    else:
        print(f"{text}: Negative")
# 计算准确率
accuracy = accuracy_score([1, 0, 0], predictions)
print(f"Accuracy: {accuracy}")

pythonCopy codefrom tensorflow.keras.applications import VGG16
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.preprocessing.image import ImageDataGenerator
# 加载预训练模型
pretrained_model = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
# 冻结预训练模型的参数
for layer in pretrained_model.layers:
    layer.trainable = False
# 创建模型
model = Sequential()
model.add(pretrained_model)
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dense(10, activation='softmax'))
# 编译模型
model.compile(optimizer=Adam(lr=0.001), loss='categorical_crossentropy', metrics=['accuracy'])
# 数据增强
datagen = ImageDataGenerator(rescale=1./255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True)
# 加载训练数据和验证数据
train_generator = datagen.flow_from_directory('train_directory', target_size=(224, 224),
                                              batch_size=32, class_mode='categorical')
validation_generator = datagen.flow_from_directory('validation_directory', target_size=(224, 224),
                                                   batch_size=32, class_mode='categorical')
# 训练模型
model.fit(train_generator, steps_per_epoch=len(train_generator), epochs=10,
          validation_data=validation_generator, validation_steps=len(validation_generator))
# 在测试集上评估模型
test_generator = datagen.flow_from_directory('test_directory', target_size=(224, 224),
                                             batch_size=32, class_mode='categorical')
loss, accuracy = model.evaluate(test_generator, steps=len(test_generator))
print("Test Loss:", loss)
print("Test Accuracy:", accuracy)