深度学习在医学影像中的应用研究

    import numpy as np 
    from PIL import Image
    import os 
    
    def preprocess_image(file):
    im = Image.open(file).convert('RGB') # 读取文件，转换为RGB格式
    
    resized_im = resize_image(im) # 对图像进行统一的resize操作
    
    normalized_im = normalize_image(resized_im) # 对图像进行标准化
    
    return normalized_im
    
    def resize_image(im):
    width, height = im.size
    
    if width > height:
        new_width = 227 
        new_height = int((new_width / width) * height) 
    else:
        new_height = 227
        new_width = int((new_height / height) * width)
    
    resized_im = im.resize((new_width, new_height))
    
    return resized_im
    
    
    def normalize_image(im):
    mean_values = [0.485, 0.456, 0.406]
    std_values = [0.229, 0.224, 0.225]
    
    image_array = np.array(im, dtype=np.float32) / 255.0 # 归一化
    
    for i in range(len(mean_values)):
        image_array[:, :, i] -= mean_values[i]
        image_array[:, :, i] /= std_values[i]
    
    return image_array

    import torch
    import torchvision.models as models
    
    
    class MyCNNModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
    
        self.conv1 = torch.nn.Conv2d(in_channels=3, out_channels=32, kernel_size=(3, 3), padding=1)
        self.relu1 = torch.nn.ReLU()
        self.pool1 = torch.nn.MaxPool2d(kernel_size=(2, 2))
    
        self.conv2 = torch.nn.Conv2d(in_channels=32, out_channels=64, kernel_size=(3, 3), padding=1)
        self.relu2 = torch.nn.ReLU()
        self.pool2 = torch.nn.MaxPool2d(kernel_size=(2, 2))
    
        self.dense1 = torch.nn.Linear(in_features=1024, out_features=512)
        self.relu3 = torch.nn.ReLU()
        self.drop1 = torch.nn.Dropout(p=0.5)
    
        self.output = torch.nn.Linear(in_features=512, out_features=2)
    
    
    def forward(self, x):
        x = self.conv1(x)
        x = self.relu1(x)
        x = self.pool1(x)
    
        x = self.conv2(x)
        x = self.relu2(x)
        x = self.pool2(x)
    
        x = x.view(-1, 1024) # Flatten
    
        x = self.dense1(x)
        x = self.relu3(x)
        x = self.drop1(x)
    
        output = self.output(x)
    
        return output

    def train():
    model = MyCNNModel().to("cuda")
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
    criterion = torch.nn.CrossEntropyLoss()
    
    num_epochs = 50
    
    training_data_dir = "/path/to/training/images"
    validation_data_dir = "/path/to/validation/images"
    
    for epoch in range(num_epochs):
        print(f"\nEpoch {epoch+1}")
    
        running_loss = 0.0
        total_corrects = 0
    
        # Train the model on training data
        model.train()
        for index, file in enumerate(os.listdir(training_data_dir)):
            img_name = os.path.join(training_data_dir, file)
    
            input_tensor = preprocess_image(img_name)
            target_tensor = get_label(file)
    
            input_tensor = torch.unsqueeze(input_tensor, dim=0) # Add batch dimension
            target_tensor = torch.as_tensor([target_tensor])
    
            optimizer.zero_grad()
    
            predictions = model(input_tensor.to("cuda"))
    
            loss = criterion(predictions, target_tensor.to("cuda"))
    
            _, predicted = torch.max(predictions.data, 1)
    
            corrects = (predicted == target_tensor.to("cuda")).sum().item()
    
            loss.backward()
            optimizer.step()
    
            running_loss += loss.item()
            total_corrects += corrects
    
    
        avg_loss = running_loss / len(os.listdir(training_data_dir))
        acc = float(total_corrects) / len(os.listdir(training_data_dir)) 
    
        print(f"\tTraining Loss : {avg_loss:.4f}, Accuracy : {acc:.2f}%\n")
    
    
        # Validate the model on validation data
        model.eval()
        with torch.no_grad():
            running_loss = 0.0
            total_corrects = 0
    
            for index, file in enumerate(os.listdir(validation_data_dir)):
                img_name = os.path.join(validation_data_dir, file)
    
                input_tensor = preprocess_image(img_name)
                target_tensor = get_label(file)
    
                input_tensor = torch.unsqueeze(input_tensor, dim=0) # Add batch dimension
                target_tensor = torch.as_tensor([target_tensor])
    
                predictions = model(input_tensor.to("cuda"))
    
                loss = criterion(predictions, target_tensor.to("cuda"))
    
                _, predicted = torch.max(predictions.data, 1)
    
                corrects = (predicted == target_tensor.to("cuda")).sum().item()
    
                running_loss += loss.item()
                total_corrects += corrects
    
    
            avg_loss = running_loss / len(os.listdir(validation_data_dir))
            acc = float(total_corrects) / len(os.listdir(validation_data_dir)) 
    
            print(f"\tValidation Loss : {avg_loss:.4f}, Accuracy : {acc:.2f}%\n")
    
    
    if __name__ == '__main__':
    train()

    test_data_dir = "/path/to/test/images"
    
    def test():
    model = MyCNNModel().to("cuda")
    model.load_state_dict(torch.load("/path/to/saved/model", map_location="cpu"))
    
    model.eval()
    with torch.no_grad():
        total_corrects = 0
    
        for index, file in enumerate(os.listdir(test_data_dir)):
            img_name = os.path.join(test_data_dir, file)
    
            input_tensor = preprocess_image(img_name)
            target_tensor = get_label(file)
    
            input_tensor = torch.unsqueeze(input_tensor, dim=0) # Add batch dimension
            target_tensor = torch.as_tensor([target_tensor])
    
            predictions = model(input_tensor.to("cuda"))
    
            _, predicted = torch.max(predictions.data, 1)
    
            corrects = (predicted == target_tensor.to("cuda")).sum().item()
    
            total_corrects += corrects
    
    
        acc = float(total_corrects) / len(os.listdir(test_data_dir)) 
    
        print(f"\tTest Accuracy : {acc:.2f}%\n")
    
    if __name__ == '__main__':
    test()