Skip to content
Snippets Groups Projects
Commit 19d569df authored by John Carter's avatar John Carter
Browse files

ucb1 set for evaluation

parent 06ae5603
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
MetaAugment/UCB1_JC.ipynb
+ 483
− 473
View file @ 19d569df
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ``` python
import numpy as np import numpy as np
import torch import torch
torch.manual_seed(0) torch.manual_seed(0)
import torch.nn as nn import torch.nn as nn
import torch.nn.functional as F import torch.nn.functional as F
import torch.optim as optim import torch.optim as optim
import torch.utils.data as data_utils import torch.utils.data as data_utils
import torchvision import torchvision
import torchvision.datasets as datasets import torchvision.datasets as datasets
from matplotlib import pyplot as plt from matplotlib import pyplot as plt
from numpy import save, load from numpy import save, load
from tqdm import trange from tqdm import trange
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ``` python
"""Define internal NN module that trains on the dataset""" """Define internal NN module that trains on the dataset"""
class LeNet(nn.Module): class LeNet(nn.Module):
def __init__(self, img_height, img_width, num_labels, img_channels): def __init__(self, img_height, img_width, num_labels, img_channels):
super().__init__() super().__init__()
self.conv1 = nn.Conv2d(img_channels, 6, 5) self.conv1 = nn.Conv2d(img_channels, 6, 5)
self.relu1 = nn.ReLU() self.relu1 = nn.ReLU()
self.pool1 = nn.MaxPool2d(2) self.pool1 = nn.MaxPool2d(2)
self.conv2 = nn.Conv2d(6, 16, 5) self.conv2 = nn.Conv2d(6, 16, 5)
self.relu2 = nn.ReLU() self.relu2 = nn.ReLU()
self.pool2 = nn.MaxPool2d(2) self.pool2 = nn.MaxPool2d(2)
self.fc1 = nn.Linear(int((((img_height-4)/2-4)/2)*(((img_width-4)/2-4)/2)*16), 120) self.fc1 = nn.Linear(int((((img_height-4)/2-4)/2)*(((img_width-4)/2-4)/2)*16), 120)
self.relu3 = nn.ReLU() self.relu3 = nn.ReLU()
self.fc2 = nn.Linear(120, 84) self.fc2 = nn.Linear(120, 84)
self.relu4 = nn.ReLU() self.relu4 = nn.ReLU()
self.fc3 = nn.Linear(84, num_labels) self.fc3 = nn.Linear(84, num_labels)
self.relu5 = nn.ReLU() self.relu5 = nn.ReLU()
def forward(self, x): def forward(self, x):
y = self.conv1(x) y = self.conv1(x)
y = self.relu1(y) y = self.relu1(y)
y = self.pool1(y) y = self.pool1(y)
y = self.conv2(y) y = self.conv2(y)
y = self.relu2(y) y = self.relu2(y)
y = self.pool2(y) y = self.pool2(y)
y = y.view(y.shape[0], -1) y = y.view(y.shape[0], -1)
y = self.fc1(y) y = self.fc1(y)
y = self.relu3(y) y = self.relu3(y)
y = self.fc2(y) y = self.fc2(y)
y = self.relu4(y) y = self.relu4(y)
y = self.fc3(y) y = self.fc3(y)
y = self.relu5(y) y = self.relu5(y)
return y return y
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ``` python
"""Define internal NN module that trains on the dataset""" """Define internal NN module that trains on the dataset"""
class EasyNet(nn.Module): class EasyNet(nn.Module):
def __init__(self, img_height, img_width, num_labels, img_channels): def __init__(self, img_height, img_width, num_labels, img_channels):
super().__init__() super().__init__()
self.fc1 = nn.Linear(img_height*img_width*img_channels, 2048) self.fc1 = nn.Linear(img_height*img_width*img_channels, 2048)
self.relu1 = nn.ReLU() self.relu1 = nn.ReLU()
self.fc2 = nn.Linear(2048, num_labels) self.fc2 = nn.Linear(2048, num_labels)
self.relu2 = nn.ReLU() self.relu2 = nn.ReLU()
def forward(self, x): def forward(self, x):
y = x.view(x.shape[0], -1) y = x.view(x.shape[0], -1)
y = self.fc1(y) y = self.fc1(y)
y = self.relu1(y) y = self.relu1(y)
y = self.fc2(y) y = self.fc2(y)
y = self.relu2(y) y = self.relu2(y)
return y return y
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ``` python
"""Define internal NN module that trains on the dataset""" """Define internal NN module that trains on the dataset"""
class SimpleNet(nn.Module): class SimpleNet(nn.Module):
def __init__(self, img_height, img_width, num_labels, img_channels): def __init__(self, img_height, img_width, num_labels, img_channels):
super().__init__() super().__init__()
self.fc1 = nn.Linear(img_height*img_width*img_channels, num_labels) self.fc1 = nn.Linear(img_height*img_width*img_channels, num_labels)
self.relu1 = nn.ReLU() self.relu1 = nn.ReLU()
def forward(self, x): def forward(self, x):
y = x.view(x.shape[0], -1) y = x.view(x.shape[0], -1)
y = self.fc1(y) y = self.fc1(y)
y = self.relu1(y) y = self.relu1(y)
return y return y
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ``` python
"""Make toy dataset""" """Make toy dataset"""
def create_toy(train_dataset, test_dataset, batch_size, n_samples): def create_toy(train_dataset, test_dataset, batch_size, n_samples):
# shuffle and take first n_samples %age of training dataset # shuffle and take first n_samples %age of training dataset
shuffle_order_train = np.random.RandomState(seed=100).permutation(len(train_dataset)) shuffle_order_train = np.random.RandomState(seed=100).permutation(len(train_dataset))
shuffled_train_dataset = torch.utils.data.Subset(train_dataset, shuffle_order_train) shuffled_train_dataset = torch.utils.data.Subset(train_dataset, shuffle_order_train)
indices_train = torch.arange(int(n_samples*len(train_dataset))) indices_train = torch.arange(int(n_samples*len(train_dataset)))
reduced_train_dataset = data_utils.Subset(shuffled_train_dataset, indices_train) reduced_train_dataset = data_utils.Subset(shuffled_train_dataset, indices_train)
# shuffle and take first n_samples %age of test dataset # shuffle and take first n_samples %age of test dataset
shuffle_order_test = np.random.RandomState(seed=1000).permutation(len(test_dataset)) shuffle_order_test = np.random.RandomState(seed=1000).permutation(len(test_dataset))
shuffled_test_dataset = torch.utils.data.Subset(test_dataset, shuffle_order_test) shuffled_test_dataset = torch.utils.data.Subset(test_dataset, shuffle_order_test)
indices_test = torch.arange(int(n_samples*len(test_dataset))) indices_test = torch.arange(int(n_samples*len(test_dataset)))
reduced_test_dataset = data_utils.Subset(shuffled_test_dataset, indices_test) reduced_test_dataset = data_utils.Subset(shuffled_test_dataset, indices_test)
# push into DataLoader # push into DataLoader
train_loader = torch.utils.data.DataLoader(reduced_train_dataset, batch_size=batch_size) train_loader = torch.utils.data.DataLoader(reduced_train_dataset, batch_size=batch_size)
test_loader = torch.utils.data.DataLoader(reduced_test_dataset, batch_size=batch_size) test_loader = torch.utils.data.DataLoader(reduced_test_dataset, batch_size=batch_size)
return train_loader, test_loader return train_loader, test_loader
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ``` python
"""Randomly generate 10 policies""" """Randomly generate 10 policies"""
"""Each policy has 5 sub-policies""" """Each policy has 5 sub-policies"""
"""For each sub-policy, pick 2 transformations, 2 probabilities and 2 magnitudes""" """For each sub-policy, pick 2 transformations, 2 probabilities and 2 magnitudes"""
def generate_policies(num_policies, num_sub_policies): def generate_policies(num_policies, num_sub_policies):
policies = np.zeros([num_policies,num_sub_policies,6]) policies = np.zeros([num_policies,num_sub_policies,6])
# Policies array will be 10x5x6 # Policies array will be 10x5x6
for policy in range(num_policies): for policy in range(num_policies):
for sub_policy in range(num_sub_policies): for sub_policy in range(num_sub_policies):
# pick two sub_policy transformations (0=rotate, 1=shear, 2=scale) # pick two sub_policy transformations (0=rotate, 1=shear, 2=scale)
policies[policy, sub_policy, 0] = np.random.randint(0,3) policies[policy, sub_policy, 0] = np.random.randint(0,3)
policies[policy, sub_policy, 1] = np.random.randint(0,3) policies[policy, sub_policy, 1] = np.random.randint(0,3)
while policies[policy, sub_policy, 0] == policies[policy, sub_policy, 1]: while policies[policy, sub_policy, 0] == policies[policy, sub_policy, 1]:
policies[policy, sub_policy, 1] = np.random.randint(0,3) policies[policy, sub_policy, 1] = np.random.randint(0,3)
# pick probabilities # pick probabilities
policies[policy, sub_policy, 2] = np.random.randint(0,11) / 10 policies[policy, sub_policy, 2] = np.random.randint(0,11) / 10
policies[policy, sub_policy, 3] = np.random.randint(0,11) / 10 policies[policy, sub_policy, 3] = np.random.randint(0,11) / 10
# pick magnitudes # pick magnitudes
for transformation in range(2): for transformation in range(2):
if policies[policy, sub_policy, transformation] <= 1: if policies[policy, sub_policy, transformation] <= 1:
policies[policy, sub_policy, transformation + 4] = np.random.randint(-4,5)*5 policies[policy, sub_policy, transformation + 4] = np.random.randint(-4,5)*5
elif policies[policy, sub_policy, transformation] == 2: elif policies[policy, sub_policy, transformation] == 2:
policies[policy, sub_policy, transformation + 4] = np.random.randint(5,15)/10 policies[policy, sub_policy, transformation + 4] = np.random.randint(5,15)/10
return policies return policies
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ``` python
"""Pick policy and sub-policy""" """Pick policy and sub-policy"""
"""Each row of data should have a different sub-policy but for now, this will do""" """Each row of data should have a different sub-policy but for now, this will do"""
def sample_sub_policy(policies, policy, num_sub_policies): def sample_sub_policy(policies, policy, num_sub_policies):
sub_policy = np.random.randint(0,num_sub_policies) sub_policy = np.random.randint(0,num_sub_policies)
degrees = 0 degrees = 0
shear = 0 shear = 0
scale = 1 scale = 1
# check for rotations # check for rotations
if policies[policy, sub_policy][0] == 0: if policies[policy, sub_policy][0] == 0:
if np.random.uniform() < policies[policy, sub_policy][2]: if np.random.uniform() < policies[policy, sub_policy][2]:
degrees = policies[policy, sub_policy][4] degrees = policies[policy, sub_policy][4]
elif policies[policy, sub_policy][1] == 0: elif policies[policy, sub_policy][1] == 0:
if np.random.uniform() < policies[policy, sub_policy][3]: if np.random.uniform() < policies[policy, sub_policy][3]:
degrees = policies[policy, sub_policy][5] degrees = policies[policy, sub_policy][5]
# check for shears # check for shears
if policies[policy, sub_policy][0] == 1: if policies[policy, sub_policy][0] == 1:
if np.random.uniform() < policies[policy, sub_policy][2]: if np.random.uniform() < policies[policy, sub_policy][2]:
shear = policies[policy, sub_policy][4] shear = policies[policy, sub_policy][4]
elif policies[policy, sub_policy][1] == 1: elif policies[policy, sub_policy][1] == 1:
if np.random.uniform() < policies[policy, sub_policy][3]: if np.random.uniform() < policies[policy, sub_policy][3]:
shear = policies[policy, sub_policy][5] shear = policies[policy, sub_policy][5]
# check for scales # check for scales
if policies[policy, sub_policy][0] == 2: if policies[policy, sub_policy][0] == 2:
if np.random.uniform() < policies[policy, sub_policy][2]: if np.random.uniform() < policies[policy, sub_policy][2]:
scale = policies[policy, sub_policy][4] scale = policies[policy, sub_policy][4]
elif policies[policy, sub_policy][1] == 2: elif policies[policy, sub_policy][1] == 2:
if np.random.uniform() < policies[policy, sub_policy][3]: if np.random.uniform() < policies[policy, sub_policy][3]:
scale = policies[policy, sub_policy][5] scale = policies[policy, sub_policy][5]
return degrees, shear, scale return degrees, shear, scale
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ``` python
"""Sample policy, open and apply above transformations""" """Sample policy, open and apply above transformations"""
def run_UCB1(policies, batch_size, learning_rate, ds, toy_size, max_epochs, early_stop_num, early_stop_flag, average_validation, iterations, IsLeNet): def run_UCB1(policies, batch_size, learning_rate, ds, toy_size, max_epochs, early_stop_num, early_stop_flag, average_validation, iterations, IsLeNet):
# get number of policies and sub-policies # get number of policies and sub-policies
num_policies = len(policies) num_policies = len(policies)
num_sub_policies = len(policies[0]) num_sub_policies = len(policies[0])
#Initialize vector weights, counts and regret #Initialize vector weights, counts and regret
q_values = [0]*num_policies q_values = [0]*num_policies
cnts = [0]*num_policies cnts = [0]*num_policies
q_plus_cnt = [0]*num_policies q_plus_cnt = [0]*num_policies
total_count = 0 total_count = 0
best_q_values = [] best_q_values = []
for policy in trange(iterations): for policy in trange(iterations):
# get the action to try (either initially in order or using best q_plus_cnt value) # get the action to try (either initially in order or using best q_plus_cnt value)
if policy >= num_policies: if policy >= num_policies:
this_policy = np.argmax(q_plus_cnt) this_policy = np.argmax(q_plus_cnt)
else: else:
this_policy = policy this_policy = policy
# get info of transformation for this sub-policy # get info of transformation for this sub-policy
degrees, shear, scale = sample_sub_policy(policies, this_policy, num_sub_policies) degrees, shear, scale = sample_sub_policy(policies, this_policy, num_sub_policies)
# create transformations using above info # create transformations using above info
transform = torchvision.transforms.Compose( transform = torchvision.transforms.Compose(
[torchvision.transforms.RandomAffine(degrees=(degrees,degrees), shear=(shear,shear), scale=(scale,scale)), [torchvision.transforms.RandomAffine(degrees=(degrees,degrees), shear=(shear,shear), scale=(scale,scale)),
torchvision.transforms.ToTensor()]) torchvision.transforms.ToTensor()])
# open data and apply these transformations # open data and apply these transformations
if ds == "MNIST": if ds == "MNIST":
train_dataset = datasets.MNIST(root='./MetaAugment/train', train=True, download=True, transform=transform) train_dataset = datasets.MNIST(root='./MetaAugment/train', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='./MetaAugment/test', train=False, download=True, transform=transform) test_dataset = datasets.MNIST(root='./MetaAugment/test', train=False, download=True, transform=transform)
elif ds == "KMNIST": elif ds == "KMNIST":
train_dataset = datasets.KMNIST(root='./MetaAugment/train', train=True, download=True, transform=transform) train_dataset = datasets.KMNIST(root='./MetaAugment/train', train=True, download=True, transform=transform)
test_dataset = datasets.KMNIST(root='./MetaAugment/test', train=False, download=True, transform=transform) test_dataset = datasets.KMNIST(root='./MetaAugment/test', train=False, download=True, transform=transform)
elif ds == "FashionMNIST": elif ds == "FashionMNIST":
train_dataset = datasets.FashionMNIST(root='./MetaAugment/train', train=True, download=True, transform=transform) train_dataset = datasets.FashionMNIST(root='./MetaAugment/train', train=True, download=True, transform=transform)
test_dataset = datasets.FashionMNIST(root='./MetaAugment/test', train=False, download=True, transform=transform) test_dataset = datasets.FashionMNIST(root='./MetaAugment/test', train=False, download=True, transform=transform)
elif ds == "CIFAR10": elif ds == "CIFAR10":
train_dataset = datasets.CIFAR10(root='./MetaAugment/train', train=True, download=True, transform=transform) train_dataset = datasets.CIFAR10(root='./MetaAugment/train', train=True, download=True, transform=transform)
test_dataset = datasets.CIFAR10(root='./MetaAugment/test', train=False, download=True, transform=transform) test_dataset = datasets.CIFAR10(root='./MetaAugment/test', train=False, download=True, transform=transform)
elif ds == "CIFAR100": elif ds == "CIFAR100":
train_dataset = datasets.CIFAR100(root='./MetaAugment/train', train=True, download=True, transform=transform) train_dataset = datasets.CIFAR100(root='./MetaAugment/train', train=True, download=True, transform=transform)
test_dataset = datasets.CIFAR100(root='./MetaAugment/test', train=False, download=True, transform=transform) test_dataset = datasets.CIFAR100(root='./MetaAugment/test', train=False, download=True, transform=transform)
# check sizes of images # check sizes of images
img_height = len(train_dataset[0][0][0]) img_height = len(train_dataset[0][0][0])
img_width = len(train_dataset[0][0][0][0]) img_width = len(train_dataset[0][0][0][0])
img_channels = len(train_dataset[0][0]) img_channels = len(train_dataset[0][0])
# check output labels # check output labels
if ds == "CIFAR10" or ds == "CIFAR100": if ds == "CIFAR10" or ds == "CIFAR100":
num_labels = (max(train_dataset.targets) - min(train_dataset.targets) + 1) num_labels = (max(train_dataset.targets) - min(train_dataset.targets) + 1)
else: else:
num_labels = (max(train_dataset.targets) - min(train_dataset.targets) + 1).item() num_labels = (max(train_dataset.targets) - min(train_dataset.targets) + 1).item()
# create toy dataset from above uploaded data # create toy dataset from above uploaded data
train_loader, test_loader = create_toy(train_dataset, test_dataset, batch_size, toy_size) train_loader, test_loader = create_toy(train_dataset, test_dataset, batch_size, toy_size)
# create model # create model
device = 'cuda' if torch.cuda.is_available() else 'cpu' device = 'cuda' if torch.cuda.is_available() else 'cpu'
if IsLeNet == "LeNet": if IsLeNet == "LeNet":
model = LeNet(img_height, img_width, num_labels, img_channels).to(device) # added .to(device) model = LeNet(img_height, img_width, num_labels, img_channels).to(device) # added .to(device)
elif IsLeNet == "EasyNet": elif IsLeNet == "EasyNet":
model = EasyNet(img_height, img_width, num_labels, img_channels).to(device) # added .to(device) model = EasyNet(img_height, img_width, num_labels, img_channels).to(device) # added .to(device)
else: else:
model = SimpleNet(img_height, img_width, num_labels, img_channels).to(device) # added .to(device) model = SimpleNet(img_height, img_width, num_labels, img_channels).to(device) # added .to(device)
sgd = optim.SGD(model.parameters(), lr=1e-1) sgd = optim.SGD(model.parameters(), lr=1e-1)
cost = nn.CrossEntropyLoss() cost = nn.CrossEntropyLoss()
# set variables for best validation accuracy and early stop count # set variables for best validation accuracy and early stop count
best_acc = 0 best_acc = 0
early_stop_cnt = 0 early_stop_cnt = 0
total_val = 0 total_val = 0
# train model and check validation accuracy each epoch # train model and check validation accuracy each epoch
for _epoch in range(max_epochs): for _epoch in range(max_epochs):
# train model # train model
model.train() model.train()
for idx, (train_x, train_label) in enumerate(train_loader): for idx, (train_x, train_label) in enumerate(train_loader):
train_x, train_label = train_x.to(device), train_label.to(device) # new code train_x, train_label = train_x.to(device), train_label.to(device) # new code
label_np = np.zeros((train_label.shape[0], num_labels)) label_np = np.zeros((train_label.shape[0], num_labels))
sgd.zero_grad() sgd.zero_grad()
predict_y = model(train_x.float()) predict_y = model(train_x.float())
loss = cost(predict_y, train_label.long()) loss = cost(predict_y, train_label.long())
loss.backward() loss.backward()
sgd.step() sgd.step()
# check validation accuracy on validation set # check validation accuracy on validation set
correct = 0 correct = 0
_sum = 0 _sum = 0
model.eval() model.eval()
for idx, (test_x, test_label) in enumerate(test_loader): for idx, (test_x, test_label) in enumerate(test_loader):
test_x, test_label = test_x.to(device), test_label.to(device) # new code test_x, test_label = test_x.to(device), test_label.to(device) # new code
predict_y = model(test_x.float()).detach() predict_y = model(test_x.float()).detach()
#predict_ys = np.argmax(predict_y, axis=-1) #predict_ys = np.argmax(predict_y, axis=-1)
predict_ys = torch.argmax(predict_y, axis=-1) # changed np to torch predict_ys = torch.argmax(predict_y, axis=-1) # changed np to torch
#label_np = test_label.numpy() #label_np = test_label.numpy()
_ = predict_ys == test_label _ = predict_ys == test_label
#correct += np.sum(_.numpy(), axis=-1) #correct += np.sum(_.numpy(), axis=-1)
correct += np.sum(_.cpu().numpy(), axis=-1) # added .cpu() correct += np.sum(_.cpu().numpy(), axis=-1) # added .cpu()
_sum += _.shape[0] _sum += _.shape[0]
acc = correct / _sum acc = correct / _sum
if average_validation[0] <= _epoch <= average_validation[1]: if average_validation[0] <= _epoch <= average_validation[1]:
total_val += acc total_val += acc
# update best validation accuracy if it was higher, otherwise increase early stop count # update best validation accuracy if it was higher, otherwise increase early stop count
if acc > best_acc : if acc > best_acc :
best_acc = acc best_acc = acc
early_stop_cnt = 0 early_stop_cnt = 0
else: else:
early_stop_cnt += 1 early_stop_cnt += 1
# exit if validation gets worse over 10 runs and using early stopping # exit if validation gets worse over 10 runs and using early stopping
if early_stop_cnt >= early_stop_num and early_stop_flag: if early_stop_cnt >= early_stop_num and early_stop_flag:
break break
# exit if using fixed epoch length # exit if using fixed epoch length
if _epoch >= average_validation[1] and not early_stop_flag: if _epoch >= average_validation[1] and not early_stop_flag:
best_acc = total_val / (average_validation[1] - average_validation[0] + 1) best_acc = total_val / (average_validation[1] - average_validation[0] + 1)
break break
# update q_values # update q_values
if policy < num_policies: if policy < num_policies:
q_values[this_policy] += best_acc q_values[this_policy] += best_acc
else: else:
q_values[this_policy] = (q_values[this_policy]*cnts[this_policy] + best_acc) / (cnts[this_policy] + 1) q_values[this_policy] = (q_values[this_policy]*cnts[this_policy] + best_acc) / (cnts[this_policy] + 1)
best_q_value = max(q_values) best_q_value = max(q_values)
best_q_values.append(best_q_value) best_q_values.append(best_q_value)
if (policy+1) % 10 == 0: if (policy+1) % 10 == 0:
print("Iteration: {},\tQ-Values: {}, Best Policy: {}".format(policy+1, list(np.around(np.array(q_values),2)), max(list(np.around(np.array(q_values),2))))) print("Iteration: {},\tQ-Values: {}, Best Policy: {}".format(policy+1, list(np.around(np.array(q_values),2)), max(list(np.around(np.array(q_values),2)))))
# update counts # update counts
cnts[this_policy] += 1 cnts[this_policy] += 1
total_count += 1 total_count += 1
# update q_plus_cnt values every turn after the initial sweep through # update q_plus_cnt values every turn after the initial sweep through
if policy >= num_policies - 1: if policy >= num_policies - 1:
for i in range(num_policies): for i in range(num_policies):
q_plus_cnt[i] = q_values[i] + np.sqrt(2*np.log(total_count)/cnts[i]) q_plus_cnt[i] = q_values[i] + np.sqrt(2*np.log(total_count)/cnts[i])
return q_values, best_q_values return q_values, best_q_values
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ``` python
%%time %%time
batch_size = 32 # size of batch the inner NN is trained with batch_size = 32 # size of batch the inner NN is trained with
learning_rate = 1e-1 # fix learning rate learning_rate = 1e-1 # fix learning rate
ds = "MNIST" # pick dataset (MNIST, KMNIST, FashionMNIST, CIFAR10, CIFAR100) ds = "MNIST" # pick dataset (MNIST, KMNIST, FashionMNIST, CIFAR10, CIFAR100)
toy_size = 0.02 # total propeortion of training and test set we use toy_size = 1 # total propeortion of training and test set we use
max_epochs = 100 # max number of epochs that is run if early stopping is not hit max_epochs = 100 # max number of epochs that is run if early stopping is not hit
early_stop_num = 10 # max number of worse validation scores before early stopping is triggered early_stop_num = 10 # max number of worse validation scores before early stopping is triggered
early_stop_flag = True # implement early stopping or not early_stop_flag = True # implement early stopping or not
average_validation = [15,25] # if not implementing early stopping, what epochs are we averaging over average_validation = [15,25] # if not implementing early stopping, what epochs are we averaging over
num_policies = 5 # fix number of policies num_policies = 5 # fix number of policies
num_sub_policies = 5 # fix number of sub-policies in a policy num_sub_policies = 5 # fix number of sub-policies in a policy
iterations = 100 # total iterations, should be more than the number of policies iterations = 100 # total iterations, should be more than the number of policies
IsLeNet = "SimpleNet" # using LeNet or EasyNet or SimpleNet IsLeNet = "SimpleNet" # using LeNet or EasyNet or SimpleNet
# generate random policies at start # generate random policies at start
policies = generate_policies(num_policies, num_sub_policies) policies = generate_policies(num_policies, num_sub_policies)
q_values, best_q_values = run_UCB1(policies, batch_size, learning_rate, ds, toy_size, max_epochs, early_stop_num, early_stop_flag, average_validation, iterations, IsLeNet) q_values, best_q_values = run_UCB1(policies, batch_size, learning_rate, ds, toy_size, max_epochs, early_stop_num, early_stop_flag, average_validation, iterations, IsLeNet)
plt.plot(best_q_values) plt.plot(best_q_values)
best_q_values = np.array(best_q_values) best_q_values = np.array(best_q_values)
save('best_q_values_{}_{}percent_{}.npy'.format(IsLeNet, int(toy_size*100), ds), best_q_values) save('best_q_values_{}_{}percent_{}.npy'.format(IsLeNet, int(toy_size*100), ds), best_q_values)
#best_q_values = load('best_q_values_{}_{}percent_{}.npy'.format(IsLeNet, int(toy_size*100), ds), allow_pickle=True) #best_q_values = load('best_q_values_{}_{}percent_{}.npy'.format(IsLeNet, int(toy_size*100), ds), allow_pickle=True)
``` ```
%% Output %% Output
100%|██████████| 10/10 [01:28<00:00, 8.84s/it] 100%|██████████| 10/10 [01:28<00:00, 8.84s/it]
Iteration: 10, Q-Values: [0.77, 0.74, 0.8, 0.72, 0.77], Best Policy: 0.8 Iteration: 10, Q-Values: [0.77, 0.74, 0.8, 0.72, 0.77], Best Policy: 0.8
CPU times: user 1min 21s, sys: 694 ms, total: 1min 22s CPU times: user 1min 21s, sys: 694 ms, total: 1min 22s
Wall time: 1min 28s Wall time: 1min 28s
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment