import torch import torch.nn as nn import torch.nn.functional as F class SwishActivation(nn.Module): def forward(self, x): return x * torch.sigmoid(x) class ChannelAttention(nn.Module): def __init__(self, in_channels, ratio=16): super(ChannelAttention, self).__init__() self.fc1 = nn.Conv2d(in_channels, in_channels // ratio, 1, bias=False) self.fc2 = nn.Conv2d(in_channels // ratio, in_channels, 1, bias=False) self.sigmoid = nn.Sigmoid() def forward(self, x): avg_out = torch.mean(x, dim=(2, 3), keepdim=True) avg_out = self.fc2(F.relu(self.fc1(avg_out))) return x * self.sigmoid(avg_out) class BuildingBlock(nn.Module): def __init__(self, in_channels, out_channels, stride=1): super(BuildingBlock, self).__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1) self.norm1 = nn.BatchNorm2d(out_channels) self.swish1 = SwishActivation() self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=stride, padding=1) self.norm2 = nn.BatchNorm2d(out_channels) self.channel_attention = ChannelAttention(out_channels) self.conv3 = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride) self.norm3 = nn.BatchNorm2d(out_channels) self.swish2 = SwishActivation() def forward(self, x): residual = x out = self.conv1(x) out = self.norm1(out) out = self.swish1(out) out = self.conv2(out) out = self.norm2(out) out = self.channel_attention(out) if x.size() != out.size(): residual = self.conv3(residual) residual = self.norm3(residual) out += residual out = self.swish2(out) return out class UNetEncoder(nn.Module): def __init__(self, in_channels, out_channels, num_blocks): super(UNetEncoder, self).__init__() self.initial_conv = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1) self.initial_norm = nn.BatchNorm2d(out_channels) self.initial_swish = SwishActivation() self.blocks = nn.ModuleList([BuildingBlock(out_channels, out_channels) for _ in range(num_blocks)]) def forward(self, x): x = self.initial_conv(x) x = self.initial_norm(x) x = self.initial_swish(x) for block in self.blocks: x = block(x) return x def encode(self, x): features = [] x = self.initial_conv(x) x = self.initial_norm(x) x = self.initial_swish(x) features.append(x) for block in self.blocks: x = block(x) features.append(x) return features class ClassificationModel(nn.Module): def __init__(self, encoder, num_classes=10): super(ClassificationModel, self).__init__() self.encoder = encoder self.global_avg_pool = nn.AdaptiveAvgPool2d((1, 1)) self.fc = nn.Linear(encoder.blocks[-1].conv2.out_channels, num_classes) def forward(self, x): features = self.encoder.encode(x) x = self.global_avg_pool(features[-1]) x = x.view(x.size(0), -1) x = self.fc(x) return x # Initialize the encoder and classification model encoder = UNetEncoder(in_channels=3, out_channels=64, num_blocks=1) classification_model = ClassificationModel(encoder, num_classes=2) # Example usage # Define your loss function and optimizer criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(classification_model.parameters(), lr=1e-6) # Dummy data for demonstration # input_tensor = torch.randn(16, 3, 256, 256) # Batch of 16 images with 3 channels, 256x256 resolution # labels = torch.randint(0, 10, (16,)) # Batch of 16 labels for 10 classes # import torchvision # import torchvision.transforms as transforms # transform = transforms.Compose( # [transforms.ToTensor(), # transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) # batch_size = 4 # trainset = torchvision.datasets.CIFAR10(root='./data', train=True, # download=True, transform=transform) # from torch.utils.data import Subset # first_1000_indices = list(range(1000)) # first_1000_subset = Subset(trainset, first_1000_indices) # # print(first_1000_subset) # trainloader = torch.utils.data.DataLoader(first_1000_subset, batch_size=batch_size, # shuffle=True, num_workers=2) # testset = torchvision.datasets.CIFAR10(root='./data', train=False, # download=True, transform=transform) # testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, # shuffle=False, num_workers=2) import pandas as pd import os from PIL import Image from torch.utils.data import Dataset, DataLoader import torchvision.transforms as transforms import pandas as pd import os from PIL import Image from torch.utils.data import Dataset, DataLoader, Subset import torchvision.transforms as transforms from sklearn.model_selection import train_test_split # Step 1: Define the Custom Dataset class CustomImageDataset(Dataset): def __init__(self, csv_file, root_dir, transform=None): self.data = pd.read_csv(csv_file) self.root_dir = root_dir self.transform = transform def __len__(self): return len(self.data) def __getitem__(self, idx): img_name = os.path.join(self.root_dir, self.data.iloc[idx, 0]+'.jpg') image = Image.open(img_name).convert('RGB') label = self.data.iloc[idx, 7] if self.transform: image = self.transform(image) return image, label # Step 2: Define Transformations transform = transforms.Compose([ transforms.Resize((224, 224)), # Resize the image to 224x224 transforms.ToTensor(), # Convert the image to a tensor transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # Normalize the image ]) # Step 3: Split the Dataset csv_file_path = 'data/ISIC_2020_Training_GroundTruth.csv' image_folder_path = 'data/train' # Read the CSV file data = pd.read_csv(csv_file_path) # Split the data into training and testing sets train_indices, test_indices = train_test_split(range(len(data)), test_size=0.015, random_state=42) # Create train and test datasets train_dataset = Subset(CustomImageDataset(csv_file=csv_file_path, root_dir=image_folder_path, transform=transform), train_indices) test_dataset = Subset(CustomImageDataset(csv_file=csv_file_path, root_dir=image_folder_path, transform=transform), test_indices) # Step 4: Create the DataLoaders train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=4) test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False, num_workers=4) best_accuracy=-1 results_file="results//encoder_pretrained_rana_sir_a_block_model(num_blocks_1).txt" early_stopping_epochs=2 import tqdm # Training loop (simplified) for epoch in range(1): # Number of epochs for input,label in tqdm.tqdm(train_loader,desc=f'Epoch {epoch + 1}/100 (training)'): optimizer.zero_grad() outputs = classification_model(input) loss = criterion(outputs, label) loss.backward() optimizer.step() classification_model.eval() total_correct = 0 total_samples = 0 with torch.no_grad(): for input, label in tqdm.tqdm(test_loader): outputs = classification_model(input) _, predicted = torch.max(outputs, 1) total_samples += label.size(0) total_correct += (predicted == label).sum().item() # Calculate accuracy accuracy = total_correct / total_samples print(f'Epoch {epoch + 1}, Accuracy: {accuracy:.4f}') with open(results_file, 'a+') as f: f.write(f'Epoch {epoch + 1}, Accuracy: {accuracy:.4f}\n') # Early stopping based on validation accuracy if accuracy > best_accuracy: best_accuracy = accuracy epochs_without_improvement = 0 # Save the model checkpoint torch.save(classification_model.state_dict(), 'model//isic(Block_1).pth') else: epochs_without_improvement += 1 # Check for early stopping if epochs_without_improvement >= early_stopping_epochs: print(f'Early stopping after epoch {epoch + 1}') break print('Training finished.') # class UNetDecoder(nn.Module): # def __init__(self, in_channels, out_channels, num_blocks): # super(UNetDecoder, self).__init__() # self.blocks = nn.ModuleList([BuildingBlock(in_channels, in_channels) for _ in range(num_blocks)]) # self.upsample = nn.ConvTranspose2d(in_channels, out_channels, kernel_size=2, stride=2) # def forward(self, x, skip_connection): # for block in self.blocks: # x = block(x) # x = self.upsample(x) # x = torch.cat((x, skip_connection), dim=1) # return x # class UNet(nn.Module): # def __init__(self, in_channels=3, out_channels=1, num_blocks=2, base_features=64): # super(UNet, self).__init__() # self.encoder1 = UNetEncoder(in_channels, base_features, num_blocks) # self.encoder2 = UNetEncoder(base_features, base_features * 2, num_blocks) # self.encoder3 = UNetEncoder(base_features * 2, base_features * 4, num_blocks) # self.encoder4 = UNetEncoder(base_features * 4, base_features * 8, num_blocks) # self.middle = BuildingBlock(base_features * 8, base_features * 16) # self.decoder4 = UNetDecoder(base_features * 16, base_features * 8, num_blocks) # self.decoder3 = UNetDecoder(base_features * 16, base_features * 4, num_blocks) # self.decoder2 = UNetDecoder(base_features * 8, base_features * 2, num_blocks) # self.decoder1 = UNetDecoder(base_features * 4, base_features, num_blocks) # self.final_conv = nn.Conv2d(base_features * 2, out_channels, kernel_size=1) # def forward(self, x): # enc1 = self.encoder1(x) # enc2 = self.encoder2(F.max_pool2d(enc1, 2)) # enc3 = self.encoder3(F.max_pool2d(enc2, 2)) # enc4 = self.encoder4(F.max_pool2d(enc3, 2)) # middle = self.middle(F.max_pool2d(enc4, 2)) # dec4 = self.decoder4(middle, enc4) # dec3 = self.decoder3(dec4, enc3) # dec2 = self.decoder2(dec3, enc2) # dec1 = self.decoder1(dec2, enc1) # return torch.sigmoid(self.final_conv(dec1)) # class UNetWithPretrainedEncoder(UNet): # def __init__(self, in_channels=3, out_channels=1, num_blocks=2, base_features=64): # super(UNetWithPretrainedEncoder, self).__init__(in_channels, out_channels, num_blocks, base_features) # def load_pretrained_encoder(self, weights_path): # pretrained_encoder = UNetEncoder(in_channels=3, out_channels=64, num_blocks=2) # pretrained_encoder.load_state_dict(torch.load(weights_path),strict=False) # self.encoder1 = pretrained_encoder # unet_with_pretrained_encoder = UNetWithPretrainedEncoder(in_channels=3, out_channels=1, num_blocks=2, base_features=64) # unet_with_pretrained_encoder.load_pretrained_encoder('model/cifar_net.pth') # print(unet_with_pretrained_encoder)