yum update -y

yum install -y yum-utils

yum-config-manager --add-repohttps://repo.docker.com/linux/centos/docker-ce.repo

yum install -y docker-ce docker-ce-cli containerd.io

systemctl start docker

systemctl enable docker

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torchvision.models import resnet50, ResNet50_Weights
from tqdm import tqdm
import time

def main():
    # 檢查GPU是否可用
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print(f"Using device: {device}")

    # 1. 數據加載與預處理
    print("Preparing dataset...")
    # 預處理流程 
    transform_train = transforms.Compose([
        transforms.Resize(256),
        transforms.RandomCrop(224),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
    ])

    transform_test = transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
    ])

    # PyTorch會自動下載CIFAR-10數據集 
    trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True, num_workers=4)

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

    classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
    print("Dataset prepared.")

    # 2. 模型定義 (ResNet-50)
    print("Loading pre-trained ResNet-50 model...")
    # 加載在ImageNet上預訓練的ResNet-50模型 
    model = resnet50(weights=ResNet50_Weights.IMAGENET1K_V2)
    
    # 修改最後一層全連接層以適應CIFAR-10的10個類別
    num_ftrs = model.fc.in_features
    model.fc = nn.Linear(num_ftrs, 10)
    
    model = model.to(device)
    print("Model loaded and modified.")

    # 3. 定義損失函數和優化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001) # 

    # 4. 訓練模型
    num_epochs = 5 # 
    print(f"Starting training for {num_epochs} epochs...")
    start_time = time.time()

    for epoch in range(num_epochs):
        model.train()
        running_loss = 0.0
        train_pbar = tqdm(trainloader, desc=f"Epoch {epoch+1}/{num_epochs} [Training]")
        for i, data in enumerate(train_pbar):
            inputs, labels = data.to(device), data.to(device)
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            running_loss += loss.item()
            train_pbar.set_postfix({'Loss': running_loss / (i + 1)})

        # 5. 驗證模型
        model.eval（)
        correct = 0
        total = 0
        with torch.no_grad():
            val_pbar = tqdm(testloader, desc=f"Epoch {epoch+1}/{num_epochs} [Validation]")
            for data in val_pbar:
                images, labels = data.to(device), data.to(device)
                outputs = model(images)
                _, predicted = torch.max(outputs.data, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum().item()
        
        accuracy = 100 * correct / total
        print(f"Epoch {epoch+1}/{num_epochs} - Validation Accuracy: {accuracy:.2f}%")

    end_time = time.time()
    print(f"Finished Training. Total time: {end_time - start_time:.2f} seconds")

    # 6. 保存模型
    torch.save(model.state_dict(), 'cifar10_resnet50.pth')
    print("Model saved to cifar10_resnet50.pth")

if __name__ == '__main__':
    main()

import torch
import torchvision.transforms as transforms
from torchvision.models import resnet50
from PIL import Image
import argparse

def infer(image_path):
    # 定義設備
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

    # 加載模型結構並載入訓練好的權重
    model = resnet50()
    num_ftrs = model.fc.in_features
    model.fc = torch.nn.Linear(num_ftrs, 10)
    model.load_state_dict(torch.load('cifar10_resnet50.pth'))
    model = model.to(device)
    model.eval（)

    # 定義類別
    classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

    # 定義與訓練時一致的圖像預處理
    transform = transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
    ])

    # 加載並預處理圖片
    image = Image.open(image_path).convert('RGB')
    image_tensor = transform(image).unsqueeze(0).to(device)

    # 模型推理
    with torch.no_grad():
        outputs = model(image_tensor)
        _, predicted = torch.max(outputs, 1)

    # 輸出結果
    print(f"Image: '{image_path}'")
    print(f"Predicted class: '{classes[predicted.item()]}'")

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='CIFAR-10 Image Classification Inference')
    parser.add_argument('--image', type=str, required=True, help='Path to the image for inference')
    args = parser.parse_args()
    infer(args.image)