train11111111

import os
import shutil
import random
from tqdm import tqdm
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms, models
from torch.utils.data import DataLoader
from sklearn.model_selection import train_test_split

train_dir = '/media/wagnchogn/data_disk/artifact/revise_cla_normal_artifact/dataset_train/train/train'
val_dir = '/media/wagnchogn/data_disk/artifact/revise_cla_normal_artifact/dataset_train/train/val'
test_dir = '/media/wagnchogn/data_disk/artifact/revise_cla_normal_artifact/dataset_train/train/test'


# 定义数据转换
data_transforms = {
    'train': transforms.Compose([
        transforms.Resize((256, 256)),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
    'val': transforms.Compose([
        transforms.Resize((256, 256)),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
    'test': transforms.Compose([
        transforms.Resize((256, 256)),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
}

# 创建数据集
train_dataset = datasets.ImageFolder(train_dir, transform=data_transforms['train'])
val_dataset = datasets.ImageFolder(val_dir, transform=data_transforms['val'])
test_dataset = datasets.ImageFolder(test_dir, transform=data_transforms['test'])

# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=4)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, num_workers=4)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False, num_workers=4)

# 定义设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# 加载预训练的ResNet18模型
model = models.resnet18(pretrained=True)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, 1)  # 二分类任务输出1个节点
model = model.to(device)

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

# 训练模型
num_epochs = 10
best_val_loss = float('inf')
best_model_wts = model.state_dict()

for epoch in range(num_epochs):
    print(f"Epoch {epoch + 1}/{num_epochs}")
    print('-' * 10)

    # 训练阶段
    model.train()
    running_loss = 0.0
    running_corrects = 0

    for inputs, labels in tqdm(train_loader):
        inputs = inputs.to(device)
        labels = labels.to(device).float().view(-1, 1)

        optimizer.zero_grad()

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

        running_loss += loss.item() * inputs.size(0)
        preds = torch.sigmoid(outputs)  >= 0.5

        running_corrects += torch.sum(preds == labels.data)

    epoch_loss = running_loss / len(train_dataset)
    epoch_acc = running_corrects.double() / len(train_dataset)

    print(f"Train Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}")

    # 验证阶段
    model.eval()
    val_loss = 0.0
    val_corrects = 0

    with (torch.no_grad()):
        for inputs, labels in val_loader:
            inputs = inputs.to(device)
            labels = labels.to(device).float().view(-1, 1)

            outputs = model(inputs)
            loss = criterion(outputs, labels)

            val_loss += loss.item() * inputs.size(0)
            preds = torch.sigmoid(outputs)>= 0.5
            #preds
            val_corrects += torch.sum(preds == labels.data)

    val_epoch_loss = val_loss / len(val_dataset)
    val_epoch_acc = val_corrects.double() / len(val_dataset)

    print(f"Val Loss: {val_epoch_loss:.4f} Acc: {val_epoch_acc:.4f}")

    # 保存验证集上损失最小的权重
    if val_epoch_loss < best_val_loss:
        best_val_loss = val_epoch_loss
        best_model_wts = model.state_dict()
        torch.save(best_model_wts, 'best_model_weights.pth')
        torch.save(model,'test.pth')

# 加载最佳模型权重
#model.load_state_dict(best_model_wts)

# 保存模型
#torch.save(model.state_dict(), 'best_model_weights.pth')

print("训练完成，最佳模型权重已保存")

# 测试阶段
model.eval()
test_loss = 0.0
test_corrects = 0

with torch.no_grad():
    for inputs, labels in test_loader:
        inputs = inputs.to(device)
        labels = labels.to(device).float().view(-1, 1)

        outputs = model(inputs)
        loss = criterion(outputs, labels)

        test_loss += loss.item() * inputs.size(0)
        preds = torch.sigmoid(outputs) >= 0.5
        # preds
        '''
        true_label = labels[i]
        if preds:
            pred_label = 1
        else:
            pred_label = 0
        pred_labels.append()
        '''
        test_corrects += torch.sum(preds == labels.data)
'''
csv 
pd
'''
test_epoch_loss = test_loss / len(test_dataset)
test_epoch_acc = test_corrects.double() / len(test_dataset)



print(f"Test Loss: {test_epoch_loss:.4f} Acc: {test_epoch_acc:.4f}")

/home/wagnchogn/anaconda3/envs/pytorch/bin/python /media/wagnchogn/data/lishuxin/_2_2403_sam/pre_code/artifact/test.py
  File "/media/wagnchogn/data/lishuxin/_2_2403_sam/pre_code/artifact/test.py", line 11
    form PIL import Image
         ^
SyntaxError: invalid syntax