import torch
import [Link] as nn
import [Link] as optim
from [Link] import Dataset, DataLoader
import numpy as np
from [Link] import roc_curve, auc
class ImageDataset(Dataset):
def __init__(self, folder_path):
self.folder_path = folder_path
self.file_list = [Link](folder_path)
def __len__(self):
return len(self.file_list)
def __getitem__(self, index):
file_name = self.file_list[index]
file_path = [Link](self.folder_path, file_name)
image = [Link](file_path)
image = torch.from_numpy(image).float()
label = self.folder_path.split('/')[-1]
if label == 'no':
label = 0
elif label == 'sphere':
label = 1
elif label == 'vort':
label = 2
return image, label
class Net([Link]):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3)
self.conv2 = nn.Conv2d(32, 64, 3)
self.fc1 = [Link](64 * 34 * 34, 128)
self.fc2 = [Link](128, 3)
def forward(self, x):
x = self.conv1(x)
x = [Link](x)
x = [Link].max_pool2d(x, 2)
x = self.conv2(x)
x = [Link](x)
x = [Link].max_pool2d(x, 2)
x = [Link](-1, 64 * 34 * 34)
x = self.fc1(x)
x = [Link](x)
x = self.fc2(x)
return x
train_dataset = ImageDataset('path/to/training/folder')
val_dataset = ImageDataset('path/to/validation/folder')
batch_size = 32
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
net = Net()
criterion = [Link]()
optimizer = [Link]([Link](), lr=0.001)
num_epochs = 10
for epoch in range(num_epochs):
running_loss = 0.0
running_corrects = 0
[Link]()
for inputs, labels in train_loader:
optimizer.zero_grad()
outputs = net([Link](1))
_, preds = [Link](outputs, 1)
loss = criterion(outputs, labels)
[Link]()
[Link]()
running_loss += [Link]() * [Link](0)
running_corrects += [Link](preds == [Link])
train_loss = running_loss / len(train_dataset)
train_acc = running_corrects.double() / len(train_dataset)
running_loss = 0.0
running_corrects = 0
[Link]()
for inputs, labels in val_loader:
outputs = net([Link](1))
_, preds = [Link](outputs, 1)
loss = criterion(outputs, labels)
running_loss += [Link]() * [Link](0)
running_corrects += [Link](preds == [Link])
val_loss = running_loss / len(val_dataset)
val_acc = running_corrects.double() / len(val_dataset)
print('Epoch [{}/{}], Train Loss: {:.4f}, Train Acc: {:.4f}, Val Loss: {:.4f},
Val Acc:
from [Link] import roc_curve, auc
[Link]()
y_true = []
y_scores = []
with torch.no_grad():
for inputs, labels in val_loader:
outputs = net([Link](1))
probs = [Link](outputs, dim=1)
y_scores.extend([Link]().numpy())
y_true.extend([Link]().numpy())
y_scores = [Link](y_scores)
y_true = [Link](y_true)
n_classes = 3
fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(n_classes):
fpr[i], tpr[i], _ = roc_curve(y_true[:, i], y_scores[:, i])
roc_auc[i] = auc(fpr[i], tpr[i])
[Link]()
colors = ['red', 'green', 'blue']
for i, color in zip(range(n_classes), colors):
[Link](fpr[i], tpr[i], color=color, lw=2, label='ROC curve of class {0} (AUC
= {1:.2f})'.format(i, roc_auc[i]))
[Link]([0, 1], [0, 1], 'k--', lw=2)
[Link]([0.0, 1.0])
[Link]([0.0, 1.05])
[Link]('False Positive Rate')
[Link]('True Positive Rate')
[Link]('Receiver Operating Characteristic Curve')
[Link](loc="lower right")
[Link]()