import os
import torch
import [Link] as nn
import [Link] as optim
import [Link] as
transforms
import [Link] as datasets
import [Link] as plt
import numpy as np
from [Link] import DataLoader
from torchvision import models
from [Link] import make_grid
# Set device (GPU if available)
device = [Link]("cuda" if
[Link].is_available() else "cpu")
# Dataset Path
dataset_path =
r"D:\college\3.2\DL\DeepLearning\Lung-
Cancer-Prediction-using-CNN-and-
Transfer-Learning\dataset"
# Define dataset directories
train_dir = [Link](dataset_path,
"train")
valid_dir = [Link](dataset_path,
"valid")
# Verify directories
for path in [train_dir, valid_dir]:
if not [Link](path):
raise FileNotFoundError(f"Dataset
directory not found: {path}")
# Define transformations
transform = [Link]([
[Link]((224, 224)),
[Link](),
[Link](mean=[0.5, 0.5,
0.5], std=[0.5, 0.5, 0.5])
])
# Load datasets
train_dataset =
[Link](root=train_dir,
transform=transform)
valid_dataset =
[Link](root=valid_dir,
transform=transform)
# DataLoaders
train_loader = DataLoader(train_dataset,
batch_size=32, shuffle=True)
valid_loader = DataLoader(valid_dataset,
batch_size=32, shuffle=False)
# Print dataset details
print("Class to Index Mapping:",
train_dataset.class_to_idx)
print(f"Train samples: {len(train_dataset)}
| Validation samples:
{len(valid_dataset)}")
# Define CNN Model
class LungCancerCNN([Link]):
def __init__(self, num_classes):
super(LungCancerCNN,
self).__init__()
self.conv1 = nn.Conv2d(3, 32,
kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(32, 64,
kernel_size=3, padding=1)
self.conv3 = nn.Conv2d(64, 128,
kernel_size=3, padding=1)
[Link] =
nn.MaxPool2d(kernel_size=2, stride=2)
self.fc1 = [Link](128 * 28 * 28, 512)
self.fc2 = [Link](512,
num_classes)
[Link] = [Link]()
[Link] = [Link](0.5)
def forward(self, x):
x = [Link]([Link](self.conv1(x)))
x = [Link]([Link](self.conv2(x)))
x = [Link]([Link](self.conv3(x)))
x = [Link]([Link][0], -1) # Flatten
x = [Link](self.fc1(x))
x = [Link](x)
x = self.fc2(x)
return x
# Instantiate Model
num_classes = len(train_dataset.classes)
model =
LungCancerCNN(num_classes).to(device
)
# Loss and Optimizer
criterion = [Link]()
optimizer =
[Link]([Link](),
lr=0.001)
# Training Loop
def train_model(model, train_loader,
valid_loader, criterion, optimizer,
epochs=10):
for epoch in range(epochs):
[Link]()
train_loss, correct, total = 0, 0, 0
for images, labels in train_loader:
images, labels = [Link](device),
[Link](device)
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
[Link]()
[Link]()
train_loss += [Link]()
_, predicted = [Link](outputs, 1)
correct += (predicted ==
labels).sum().item()
total += [Link](0)
train_acc = 100 * correct / total
print(f"Epoch {epoch + 1}/{epochs} -
Loss: {train_loss / len(train_loader):.4f} -
Accuracy: {train_acc:.2f}%")
# Train Model
train_model(model, train_loader,
valid_loader, criterion, optimizer,
epochs=5)
# Function to Visualize Layer-wise
Outputs
def visualize_layer_outputs(model,
image):
[Link]()
image = [Link](0).to(device)
# Add batch dimension
layers = [model.conv1, model.conv2,
model.conv3]
activations = []
# Forward pass through each layer
x = image
for layer in layers:
x = layer(x)
[Link](x)
# Plot activations
fig, axs = [Link](1,
len(activations), figsize=(15, 5))
for i, activation in
enumerate(activations):
output =
[Link](0).cpu().detach().num
py()
output = [Link](output, axis=0) #
Take average across channels
axs[i].imshow(output, cmap="viridis")
axs[i].set_title(f"Layer {i + 1} Output")
axs[i].axis("off")
[Link]()
# Get a Sample Image
sample_image, _ = train_dataset[0]
visualize_layer_outputs(model,
sample_image)