def model():
"""
:return:
"""
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
# device = torch.device("cpu")
return Simple_CNN_e2(128).float().to(device)
def optim():
"""
:return:
"""
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
# device = torch.device("cpu")
return torch.optim.Adam(Simple_CNN_e2(128).float().to(device).parameters())
def gpu_speedup_custom():
"""
Compares training time for a net with and without using a GPU
"""
num_epochs = 100
results = []
counter = 0
header = "counter, batch_size, img_size, random_background, gpu_used, ii, end-start, accuracy"
for batch_size in [1024]:
for img_size in [128]:
for random_background in [0, 1]:
for gpu_used in [1]:
for ii in range(1):
print("\n %1.0f \n" % counter)
start = timeit.default_timer()
name = "../state_dicts/custom_cnn_e4_" + str(
int(counter))
accuracy = custom_classifier(
Simple_CNN_e2(img_size=img_size),
num_epochs=num_epochs,
batch_size=batch_size,
use_gpu=gpu_used,
img_size=img_size,
random_background=random_background,
name=name,
)
end = timeit.default_timer()
results.append([
counter,
batch_size,
img_size,
random_background,
gpu_used,
ii,
end - start,
accuracy,
])
counter += 1
# Log results
np.savetxt(
Path("../logs/results_experiment_4.csv"),
np.array(results),
delimiter=",",
header=header,
)
def malaria(federate, num_worker=2):
"""
Function to benchmark different numbers of workers and compare it with regular execution
:param bool federate: Whether to use federated training
:param int num_worker: Number of workers
:return: time for training
"""
image_size = 128
args = Arguments()
use_cuda = False # not args.no_cuda and torch.cuda.is_available()
# torch.manual_seed(args.seed)
device = torch.device("cpu")
kwargs = {"num_workers": 1, "pin_memory": True} if use_cuda else {}
model = Simple_CNN_e2(128).to(device)
optimizer = optim.SGD(model.parameters(), lr=args.lr)
train_set, test_set = create_federated_dataset()
train_dataset = DatasetFromSubset(train_set)
# Only difference in setup
if federate:
if num_worker == 2:
workers = (bob, alice)
elif num_worker == 3:
workers = (bob, alice, mike)
elif num_worker == 4:
workers = (bob, alice, mike, zoe)
else:
raise NotImplementedError
train_loader = sy.FederatedDataLoader(
train_dataset.federate(workers),
batch_size=args.batch_size,
shuffle=True,
**kwargs
)
else:
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=args.batch_size, shuffle=True, **kwargs
)
# Train cycles
start = timeit.default_timer()
for epoch in range(1, args.epochs + 1):
train(args, model, device, train_loader, optimizer, epoch, federate)
end = timeit.default_timer()
return end - start
def load_model(path, tracing=False, img_size=128):
"""
function to load a network for classification
:param str path: state dicts of previous training
:param bool tracing: turn tracing on or off
:param int img_size: input size needed for model initialization
:return: model
"""
model = Simple_CNN_e2(img_size)
model.load_state_dict(torch.load(path))
model = model.double()
if tracing:
sample_input = torch.rand((1, 3, IMG_SIZE, IMG_SIZE)).double()
traced_model = trace(model, example_inputs=sample_input)
return traced_model
else:
return model
def compare_optimizers():
"""
train a model with data federated over multiple workers.
Comparison to federated training since this suffered from poor optimizer performance
"""
# Parameters and general setup
epochs = 100
torch.manual_seed(42)
# Create datasets and dataloaders
train_set, test_set = create_federated_dataset()
train_dataset = DatasetFromSubset(train_set)
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=1024, shuffle=True
)
test_loader = torch.utils.data.DataLoader(test_set, batch_size=1024, shuffle=True)
# Setup optimization
device = "cpu"
results_time = []
results_acc = []
for opt in range(3):
for run in range(3):
# load model
model = Simple_CNN_e2(img_size=128)
model = model.float()
""" Run 2
if opt == 0:
optimizer = optim.Adam(model.parameters(), lr=1e-3)
elif opt == 1:
optimizer = optim.SGD(model.parameters(), lr=1e-3)
elif opt == 2:
optimizer = optim.SGD(model.parameters(), lr=1e-1)
"""
if opt == 0:
optimizer = optim.SGD(model.parameters(), lr=0.5)
elif opt == 1:
optimizer = optim.SGD(model.parameters(), lr=1e-1)
elif opt == 2:
optimizer = optim.SGD(model.parameters(), lr=1e-2)
loss = nn.CrossEntropyLoss()
start = timeit.default_timer()
for epoch in range(1, epochs + 1):
train(
model, device, train_loader, optimizer, epoch, loss, federated=False
)
accuracy = run_t(model, device, test_loader, loss)
results_acc.append([opt, run, epoch, accuracy])
np.savetxt(
Path("../logs/optimizer_acc_log_3.csv"),
results_acc,
delimiter=",",
header="optimizer, run, epoch, accuracy",
)
end = timeit.default_timer()
results_time.append([opt, run, end - start, accuracy])
np.savetxt(
Path("../logs/optimizer_time_log_3.csv"),
results_time,
delimiter=",",
header="optimizer, run, time, accuracy",
)
def imbalanced_distribution():
"""
train a model with data federated over multiple workers
:return:
"""
# Parameters and general setup
epochs = 150
# use_cuda = torch.cuda.is_available()
torch.manual_seed(42)
hook = sy.TorchHook(torch)
results = []
# Setup virtual workers
katherienhospital = sy.VirtualWorker(hook, id="kh")
filderklinik = sy.VirtualWorker(hook, id="fikli")
for identifier, distribution in enumerate([[0.9, 0.1], [0.7, 0.3],
[0.5, 0.5]]):
reverse_distribution = distribution[::-1]
balance = [distribution, reverse_distribution, [0.5, 0.5]]
percentage = [0.4, 0.4, 0.2]
# Create datasets and dataloaders
train_worker_kh, train_worker_fikli, test_set = create_federated_dataset(
balance=balance, percentage_of_dataset=percentage)
test_loader = torch.utils.data.DataLoader(test_set,
batch_size=1024,
shuffle=True)
# Create datasets
train_dataset_kh = DatasetFromSubset(train_worker_kh)
train_dataset_fikli = DatasetFromSubset(train_worker_fikli)
# Seperate data and labels
data_kh = train_dataset_kh.data
target_kh = train_dataset_kh.targets
data_fikli = train_dataset_fikli.data
target_fikli = train_dataset_fikli.targets
# Create pointers
data_kh = data_kh.send(katherienhospital)
target_kh = target_kh.send(katherienhospital)
data_fikli = data_fikli.send(filderklinik)
target_fikli = target_fikli.send(filderklinik)
# Organize pointers to form a pseudo dataloader
train_loader = [(data_kh, target_kh), (data_fikli, target_fikli)]
for ii in range(3):
# load model
model = Simple_CNN_e2(img_size=128)
model = model.float()
# Setup optimization
device = (
"cpu"
) # device = torch.device("cuda" if use_cuda else "cpu") GPU not fully supported
optimizer = optim.SGD(
model.parameters(),
lr=1e-1) # optimizer = optim.Adam(model.parameters(), lr=1e-3)
loss = nn.CrossEntropyLoss()
for epoch in range(1, epochs + 1):
train(model,
device,
train_loader,
optimizer,
epoch,
loss,
federated=True)
accuracy = run_t(model, device, test_loader, loss)
results.append([ii, identifier, epoch, accuracy])
np.savetxt(
Path("./logs/federated_learning_speed_distribution.csv"),
results,
delimiter=",",
header="run, identifier, epoch, accuracy",
)
def benchmark_inference_custom_model():
"""
Benchmark inference duration with JIT and GPU execution
"""
num_runs = 25
batch_size = 1024
img_size = 128
random_background = 0
path = Path("../state_dicts/custom_cnn_e4_0.pt")
results = []
# load model
original_model = Simple_CNN_e2(img_size=img_size)
original_model.load_state_dict(torch.load(path))
# get dataloader
train_loader, test_loader, val_loader = create_dataloaders(
batchsize=batch_size,
img_size=img_size,
random_background=random_background)
for use_gpu in [0, 1]:
for use_tracing in [0, 1]:
print(use_gpu, use_tracing)
# Specify execution device
if use_gpu:
device = torch.device("cuda")
else:
device = torch.device("cpu")
# Clone original model
execution_model = copy.deepcopy(original_model)
original_model.train()
if use_tracing:
for (data, target) in val_loader:
example_input = data
break
execution_model = trace(execution_model,
example_inputs=example_input)
if use_gpu:
execution_model.cuda()
else:
# Move model to GPU
execution_model = execution_model.to(device)
for ii in range(num_runs):
start = timeit.default_timer()
for (data, target) in val_loader:
data = data.to(device)
prediction = execution_model(data)
end = timeit.default_timer()
results.append(
[use_gpu, use_tracing, (end - start) / num_runs])
np.savetxt(
Path("../logs/inference_speedup_custom_e2.csv"),
results,
delimiter=",",
header="use_gpu,use_tracing,duration",
)
def demonstrate_randomization():
"""
:return:
"""
# Reproduce
# https://github.com/marcotcr/lime/blob/master/doc/notebooks/Tutorial%20-%20Image%20Classification%20Keras.ipynb
use_cuda = torch.cuda.is_available()
use_pretrained_squeezenet = False
path = "../data/Classification/Parasitized/"
device = torch.device("cuda" if use_cuda else "cpu")
if use_pretrained_squeezenet:
model, input_size = initialize_model("squeezenet",
2,
True,
use_pretrained=True)
model.load_state_dict(torch.load("../src/models/squeezenet_e10.pt"))
else:
input_size = 128
model_random = Simple_CNN_e2(img_size=input_size)
model_random.load_state_dict(
torch.load("../src/state_dicts/custom_cnn_e4_1.pt"))
model_standard = Simple_CNN_e2(img_size=input_size)
model_standard.load_state_dict(
torch.load("../src/state_dicts/custom_cnn_e4_0.pt"))
images = get_images(path)
image = imread(path + images[100]) # 100 shows difference
image_resized = misc.imresize(image, (input_size, input_size))
plt.subplot(1, 3, 1)
plt.imshow(image_resized)
plt.title("Original image")
plt.subplot(1, 3, 2)
plt.imshow(image_resized)
explainer_standard = lime_image.LimeImageExplainer()
Model_Lime_API_standard = Model(model_standard, device, input_size)
explanation_standard = explainer_standard.explain_instance(
image_resized,
Model_Lime_API_standard.predict_prob,
hide_color=None,
# num_samples=300,
)
temp, mask = explanation_standard.get_image_and_mask(0,
positive_only=False,
num_features=20,
hide_rest=False)
plt.imshow(mark_boundaries(temp / 2 + 0.5, mask), alpha=0.35)
plt.title("Explanation Default")
plt.subplot(1, 3, 3)
plt.imshow(image_resized)
explainer_random = lime_image.LimeImageExplainer()
Model_Lime_API_random = Model(model_random, device, input_size)
explanation_random = explainer_random.explain_instance(
image_resized,
Model_Lime_API_random.predict_prob,
hide_color=None,
# num_samples=300,
)
temp, mask = explanation_random.get_image_and_mask(0,
positive_only=False,
num_features=20,
hide_rest=False)
plt.imshow(mark_boundaries(temp / 2 + 0.5, mask), alpha=0.35)
plt.title("Explanation Random")
plt.tight_layout()
plt.show()