def main():
torch.manual_seed(43)
criterion = nn.CrossEntropyLoss()
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
train_loader, test_loader = data_loaders()
model = FNN_ID(750).to(device)
optimizer = optim.Adam(model.parameters())
train(model, device, train_loader, criterion, optimizer)
test(model, device, test_loader, criterion)
save(model)
def main(net, dataloader, device, config):
train_loader, test_loader = dataloader[0], dataloader[1]
optimizer = optim.SGD(net.parameters(),
lr=config.lr,
momentum=config.momentum,
weight_decay=config.weight_decay)
scheduler = optim.lr_scheduler.ExponentialLR(optimizer, 0.95)
crit = get_criterion(config)
crit = crit.to(device)
if not os.path.isdir(config.weight):
os.makedirs(config.weight)
checkpoint = os.path.join(config.weight, config.model + '.pth')
best_acc = 0
for epoch in range(config.epoch):
logging.info(f'LR: {scheduler.get_lr()}')
########## TRAIN ##########
start = time()
net.train()
loss_train = train(config, net, device, train_loader, crit, optimizer,
epoch)
end = time() - start
logging.info(
f'=> Epoch[{epoch}], Average train Loss: {loss_train:.3f}, Tot Time: {end:.3f}'
)
########## TEST ###########
start = time()
net.eval()
acc = test(config, net, device, test_loader, epoch)
end = time() - start
logging.info(
f'=> Epoch[{epoch}], Final accuracy: {acc:.3f}, Tot Time: {end:.3f}\n'
)
if acc > best_acc:
torch.save(net.state_dict(), checkpoint)
logging.info(f'Saving best model checkpoint at {checkpoint}')
best_acc = acc
scheduler.step()
logging.info(f'Best test accuracy: {best_acc}')
def main() -> None:
"""Linebacker project in its entirety."""
system("clear")
script = select_script()
scene = select_scene(script=script)
reformatted_script = load_script(script=script, scene=scene)
divider = colored("=" * 50, "blue")
print(f"\n{ divider }\n")
n_incorrect, n_total = test(script=reformatted_script)
print(f"\n{ divider }\n")
accuracy = grade(incorrect=n_incorrect, total=n_total)
color = grade_color(accuracy=accuracy)
percentage = colored(f"{ accuracy }%", color)
if accuracy < 100:
print(f"Your memory has an { percentage } accuracy. Keep practicing!")
else:
print(f"Your memory has an { percentage } accuracy. Good job!")
from sklearn import tree
from variables import *
from functions import train,make_conversions,output_data,test
# train the program
name,Pclass,Sex,SibSp,Parch,Embarked,Survived = train()
make_conversions(Pclass,Sex,SibSp,Parch,Embarked)
# test the program, this recieved the inputs from the test set
name,Pclass,Sex,SibSp,Parch,Embarked = test()
make_conversions(Pclass,Sex,SibSp,Parch,Embarked)
# fill x with all possible parameters for each person
for i in range(0,len(name)):
z.append(pclass_conv[i])
z.append(sex_conv[i])
z.append(sibsp_conv[i])
z.append(parch_conv[i])
z.append(embarked_conv[i])
x.append(z)
z = []
# apply to sklearns function
y = Survived
clf = tree.DecisionTreeClassifier()
clf = clf.fit(x,y)
# output a csv to compare results to the original training dataset
output_data(name,Pclass,Sex,SibSp,Parch,Survived,Embarked,clf)
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title, resume=True)
else:
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title)
logger.set_names(['Learning Rate', 'Train Loss', 'Valid Loss','Train Acc.', 'Valid Acc.', 'Train Acc.5',
'Valid Acc.5'])
# Train and validate
for epoch in range(start_epoch, args.epochs):
state['lr'] = adjust_learning_rate(state['lr'], optimizer, epoch, args.gamma, args.schedule)
print('\nEpoch: [%d | %d] LR: %f' % (epoch + 1, args.epochs, state['lr']))
train_loss, train_acc, train_acc5 = train_one_epoch(trainloader, model, criterion, optimizer, use_cuda=use_cuda)
test_loss, test_acc, test_acc5 = test(testloader, model, criterion, use_cuda=use_cuda)
# append logger file
logger.append([state['lr'], train_loss, test_loss, train_acc, test_acc, train_acc5, test_acc5])
# save model ap
is_best = test_acc > best_acc
best_acc = max(test_acc, best_acc)
if do_save_checkpoint:
save_checkpoint({
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'acc': test_acc,
'best_acc': best_acc,
'optimizer' : optimizer.state_dict(),
}, is_best, checkpoint=args.checkpoint)
import functions
import time
"""set true if want to hardcode admin email"""
AUTO = True
HARDSET = "insert email"
status = {}
"""Hardcoded admin email"""
if AUTO:
admin = HARDSET
else:
admin = functions.set_admin()
while True:
status = functions.get_status()
if functions.test(status=status):
pass
else:
print("DETECTED PROBLEM")
time.sleep(5)
dns, key_name = functions.create_instance()
functions.transfer(dns=dns, key_name=key_name)
time.sleep(5)
functions.notify(email=admin, dns=dns, key_name=key_name)
time.sleep(5)
functions.shutdown()
time.sleep(5)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(resnet.parameters(), lr = learning_rate)
all_train_loss=[]
all_train_acc = []
all_test_loss = []
all_test_acc = []
dynamics = []
for epoch in range(1, nb_epochs + 1):
train_l, train_a = train(resnet, train_loader, optimizer, criterion, epoch, batch_log, device)
train_l, train_a = test(resnet, train_loader, criterion, epoch, batch_log, device)
all_train_loss.append(train_l)
all_train_acc.append(train_a)
test_l, test_a = test(resnet, test_loader_sc, criterion, epoch, batch_log, device)
all_test_loss.append(test_l)
all_test_acc.append(test_a)
dynamics.append({
"epoch": epoch,
"train_loss": train_l,
"train_acc": train_a,
"test_loss": test_l,
"test_acc": test_a
})
from sklearn import tree
from variables import *
from functions import make_conversions, train, output_data, test
# train the program
outlook, temperaturelevel, humiditylevel, windyornot, playornot = train()
make_conversions(outlook, temperaturelevel, humiditylevel, windyornot)
# test the program, this recieved the inputs from the test set
outlook, temperaturelevel, humiditylevel, windyornot = test()
make_conversions(outlook, temperaturelevel, humiditylevel, windyornot)
# fill x with all possible parameters for each day
for j in range(0, 14):
z.append(outlook_conv[j])
z.append(temperature_conv[j])
z.append(humidity_conv[j])
z.append(windy_conv[j])
x.append(z)
z = []
# apply to sklearns function
y = playornot
clf = tree.DecisionTreeClassifier()
clf = clf.fit(x, y)
# output a csv to compare results to the original training dataset
output_data(outlook, temperaturelevel, humiditylevel, windyornot, clf,
playornot)
kanazawa(f_in, ratio, nratio, srange),
kanazawa_big(f_in, ratio, nratio, srange=0),
kanazawa(f_in, ratio=2**(1 / 3), nratio=6, srange=0),
kanazawa(f_in, ratio=2**(1 / 3), nratio=6, srange=2)
]
for m, model in enumerate(models):
print("trial {}, model {}".format(ii, m))
model.to(device)
model_log = open("mnist_trained_model_{}_{}_k.pickle".format(m, ii),
"wb")
for epoch in range(1, nb_epochs + 1):
train_l, train_a = train(model, train_loader, learning_rate,
criterion, epoch, batch_log, device)
train_l, train_a = test(model, train_loader, criterion, epoch,
batch_log, device)
dyn = {"epoch": epoch, "train_loss": train_l, "train_acc": train_a}
pickle.dump(dyn, model_log)
pickle.dump(model, model_log)
model_log.close()
#lists of last test loss and acc for each scale with model ii
s_test_loss = []
s_test_acc = []
for s in scales:
test_transf = transforms.Compose([
transforms.Resize(40),
RandomRescale(size=40, scales=(s, s), sampling="uniform"),
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])
from functions import train, test
import random
#Load in files
random.seed(int(sys.argv[1]))
k = int(sys.argv[2])
training_set = np.loadtxt(sys.argv[3])
testing_set = np.loadtxt(sys.argv[4])
centroids = []
for j in range(k):
centroid = []
for i in range(training_set.shape[1]):
low = np.amin(training_set[:,i])
high = np.amax(training_set[:,i])
lower = low + ((high-low)/k) * j
higher = low + ((high-low)/k) * (j+1)
centroid.append(random.uniform(lower, higher))
centroids.append(centroid)
centroids = np.asarray(centroids, dtype=float)
#Convert to 1D array if necessary
if len(training_set) < 2:
training_set = np.array(training_set)
elif len(testing_set) < 2:
testing_set = np.array(testing_set)
centroids = train(training_set, centroids, k)
test(testing_set, centroids, k)
transforms.Resize(40),
RandomRescale(size=40, scales=(s, s), sampling="uniform"),
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])
test_set = datasets.CIFAR10(root=root,
train=False,
transform=test_transf,
download=True)
test_loader = DataLoader(dataset=test_set,
batch_size=batch_size,
shuffle=False,
num_workers=1,
pin_memory=True)
test_l, test_a = test(model, test_loader, criterion, 200,
batch_log, device)
s_test_loss.append(test_l) #take only last value
s_test_acc.append(test_a)
locals()['test_losses_{0}'.format(m)].append(s_test_loss)
locals()['test_accs_{0}'.format(m)].append(s_test_acc)
for m in range(len(models)):
pickle.dump(locals()['test_losses_{0}'.format(m)], log)
pickle.dump(locals()['test_accs_{0}'.format(m)], log)
for m in range(len(models)):
locals()['avg_test_loss_{0}'.format(m)] = np.mean(np.array(
locals()['test_losses_{0}'.format(m)]),
axis=0)
criterion = nn.CrossEntropyLoss()
optimizer1 = optim.Adam(net1.parameters(), lr=learning_rate)
optimizer2 = optim.Adam(net2.parameters(), lr=learning_rate)
optimizer3 = optim.Adam(net3.parameters(), lr=learning_rate)
optimizer4 = optim.Adam(net4.parameters(), lr=learning_rate)
train_loss1 = []
train_acc1 = []
test_loss1 = []
test_acc1 = []
for epoch in range(1, nb_epochs + 1):
train_l, train_a = train(net1, train_loader, optimizer1, criterion, epoch,
batch_log, device)
train_l, train_a = test(net1, train_loader, criterion, epoch, batch_log,
device)
test_l, test_a = test(net1, test_loader, criterion, epoch, batch_log,
device)
train_loss1.append(train_l)
train_acc1.append(train_a)
test_loss1.append(test_l)
test_acc1.append(test_a)
with open("compareCNNs_log1.txt", "w") as output:
output.write(
"nb_epochs=100\t learning_rate=0.00001\t batch_size=128\t ratio=2^(2/3)\t nratio=3 \n"
)
output.write("SiCNN1\t 3,36,3-36,64,3-64,150,10\tsrange=0,3\n")
output.write(str(train_loss1))
output.write(str(train_acc1))
output.write(str(test_loss1))
#!/usr/bin/env python3
import sys
import numpy as np
from functions import train, test
#Load in files
training_file = sys.argv[1]
testing_file = sys.argv[2]
#Convert to 1D array if necessary
train_test = [np.loadtxt(training_file), np.loadtxt(testing_file)]
for i in range(0, 2):
if len(train_test[i].shape) < 2:
train_test[i] = np.array([train_test[i]])
tree = []
train(train_test[0], tree, 1)
#indices = np.argsort(tree,axis=0)
#for i in indices[:,0]:
#print(tree[i])
test(train_test[1], tree)
from pprint import pprint
dataset = pd.read_csv('car_evaluation.csv')
columns = list(dataset.columns.values)
# print(columns)
# print(set(dataset[columns[0]].tolist()))
# print(dataset.dtypes)
from functions import repair_dataset
dataset = repair_dataset(dataset, .2, 4, .4)
target_attribute_name = columns[-1]
total_data = int(len(dataset[target_attribute_name].tolist()) * .95)
continuous_threshold = .2
continuous_ignore = .4
continuous_partition = 4
# print(dataset)
# split data
from functions import train_test_split
training_data, testing_data = train_test_split(dataset, total_data)
# create tree
from functions import ID3
tree = ID3(training_data, training_data, training_data.columns[:-1],
target_attribute_name)
# pprint(tree)
# test
from functions import test
test(testing_data, tree, target_attribute_name)
#scheduler = optim.lr_scheduler.StepLR(optimizer2, step_size=40, gamma=0.1)
optimizer3 = optim.Adam(sicnn3.parameters(), lr = learning_rate)
optimizerm = optim.Adam(mini.parameters(), lr = learning_rate)
train_loss_1=[]
train_acc_1 = []
valid_loss_1 = []
valid_acc_1 = []
for epoch in range(1, nb_epochs + 1):
train_l, train_a = train(sicnn1, train_loader, optimizer1, criterion, epoch, batch_log, device)
train_l, train_a = test(sicnn1, train_loader, criterion, epoch, batch_log, device)
valid_l, valid_a = test(sicnn1, valid_loader, criterion, epoch, batch_log, device)
train_loss_1.append(train_l)
train_acc_1.append(train_a)
valid_loss_1.append(valid_l)
valid_acc_1.append(valid_a)
with open("mnist_sicnn1_log.txt", "w") as output:
output.write("nb_epochs=200\t lr=0.0001 \t batch_size=256\n")
output.write("SiCNN kanazawa \t ratio=2^(2/3), nratio=3, srange=3\n")
output.write(str(train_loss_1))
output.write("\n")
output.write(str(train_acc_1))
output.write("\n")
output.write(str(valid_loss_1))
output.write("\n")
sicnn.to(device)
criterion = nn.CrossEntropyLoss()
std_optimizer = optim.Adam(stdnet.parameters(), lr = learning_rate)
sicnn_optimizer = optim.Adam(sicnn.parameters(), lr = learning_rate)
sicnn_train_loss=[]
sicnn_train_acc = []
sicnn_test_loss = []
sicnn_test_acc = []
sicnn_dyn = []
for epoch in range(1, nb_epochs + 1):
train_l, train_a = train(sicnn, train_loader, sicnn_optimizer, criterion, epoch, batch_log, device)
test_l, test_a = test(sicnn, test_loader, criterion, epoch, batch_log, device)
sicnn_train_loss.append(train_l)
sicnn_train_acc.append(train_a)
sicnn_test_loss.append(test_l)
sicnn_test_acc.append(test_a)
sicnn_dyn.append({
"epoch": epoch,
"train_loss": train_l,
"train_acc": train_a,
"test_loss": test_l,
"test_acc": test_a
})
std_train_loss = []
std_train_acc = []
#endregion
if run:
game.draw_matrix()
im2 = game.draw_image()
cv2.imshow("frame2", im2)
game.init_matrix()
start = time.time()
frame = capture.force_update() # uh oh
im = functions.cut(frame)
if tried != -1:
tried, last = functions.test(im, p_bot, game, last, mode, change,
tried, random)
random = False
if tried >= 15:
change = False
if mode == "tree":
print("> I'M SORRY, BACK TO CHOPPING")
else:
print("> I'M SORRY, BACK TO MINING")
tried = 0
functions.draw(im)
functions.grid(im)
cv2.imshow("frame1", im)
m_t_accs = []
m_v_losses = []
m_v_accs = []
for ii in range(repeats):
model = SiCNN_3(f_in, size, ratio, nratio, srange)
model.to(device)
train_loss = []
train_acc = []
valid_loss = []
valid_acc = []
for epoch in range(1, nb_epochs + 1):
train_l, train_a = train(model, train_loader, learning_rate,
criterion, epoch, batch_log, device)
train_l, train_a = test(model, train_loader, criterion, epoch,
batch_log, device)
valid_l, valid_a = test(model, valid_loader, criterion, epoch,
batch_log, device)
train_loss.append(train_l)
train_acc.append(train_a)
valid_loss.append(valid_l)
valid_acc.append(valid_a)
with open("model_{}_{}_cifar.pickle".format(s, ii), "wb") as save:
pickle.dump(model, save)
m_t_losses.append(train_loss)
m_t_accs.append(train_acc)
m_v_losses.append(valid_loss)
m_v_losses.append(valid_acc)
(sum(p.numel() for p in model.parameters()) / 1000000.0))
# set model and its secondaries
model = model.cuda()
model = torch.nn.DataParallel(model)
cudnn.benchmark = True
criterion = nn.CrossEntropyLoss() # loss function
# ............ find results ................
epsilons = args.epsilons
targeted = args.targeted
resume_path = args.resume
file_path = args.output_file_path
loss_normal, top1_acc_normal, top5_acc_normal = test(testloader,
model,
criterion,
use_cuda,
test_flag=False)
for epsilon in epsilons:
cw_initial_const = 0.1
attacks = ["FGSM", "LinfBIM", "MIM", "CWL2", "LinfPGD"]
attacks_loss, attacks_acc, attacks_acc5 = adversary_test_attacks(
model,
criterion,
testloader,
num_classes,
attacks,
epsilon=epsilon,
targeted=targeted,
cw_initial_const=0.1,
train_loss3 = []
train_acc3 = []
valid_loss3 = []
valid_acc3 = []
train_loss4 = []
train_acc4 = []
valid_loss4 = []
valid_acc4 = []
for epoch in range(1, nb_epochs + 1):
train_l, train_a = train(resnet2, train_loader, learning_rate, criterion,
epoch, batch_log, device)
train_l, train_a = test(resnet2, train_loader, criterion, epoch, batch_log,
device)
train_loss2.append(train_l)
train_acc2.append(train_a)
valid_l, valid_a = test(resnet2, valid_loader, criterion, epoch, batch_log,
device)
valid_loss2.append(valid_l)
valid_acc2.append(valid_a)
with open("compareResnet_log2.txt", "w") as output:
output.write("ResNet\t size=16\t ratio=2^(-1/3)\t nratio=6 \n")
output.write(str(train_loss2))
output.write(str(train_acc2))
output.write(str(valid_loss2))
output.write(str(valid_acc2))
criterion = nn.CrossEntropyLoss()
all_optimizer = optim.Adam(allcnn.parameters(), lr=learning_rate)
siall_optimizer = optim.Adam(siallcnn.parameters(), lr=learning_rate)
siall_train_loss = []
siall_train_acc = []
siall_test_loss = []
siall_test_acc = []
siall_test_loss_sc = []
siall_test_acc_sc = []
for epoch in range(1, nb_epochs + 1):
train_l, train_a = train(siallcnn, train_loader, siall_optimizer,
criterion, epoch, batch_log, device)
test_l, test_a = test(siallcnn, test_loader, criterion, epoch, batch_log,
device)
siall_train_loss.append(train_l)
siall_train_acc.append(train_a)
siall_test_loss.append(test_l)
siall_test_acc.append(test_a)
test_l_sc, test_a_sc = test(siallcnn, test_loader_sc, criterion, epoch,
batch_log, device)
siall_test_loss_sc.append(test_l_sc)
siall_test_acc_sc.append(test_a_sc)
with open("si_allcnn_log_scaled.txt", "w") as output:
output.write(str(siall_train_loss))
output.write(str(siall_train_acc))
output.write(str(siall_test_loss))
output.write(str(siall_test_acc))
output.write(str(siall_test_loss_sc))
#import functions as F
#from functions import test
#import argparse # https://docs.python.org/3/library/argparse.html#argparse.ArgumentParser.add_argument
#import yaml # https://rollout.io/blog/yaml-tutorial-everything-you-need-get-started/
#import pandas as pd
import functions as F
#import functions as F
#import sklearn decisiontree
if __name__ == "__main__":
print("test_import.py name:", __name__)
print("functions.py name:", F.__name__)
print("print from test_import.py")
F.test()
#if zscore_norm:
# df = zscore_norm(df)
#parser = argparse.ArgumentParser()
# name is how we pass it in on the command line
# dest is the attribute it goes into
#parser.add_argument('-path', type=int, help='an integer for param1', action="store", dest = "path", default = 5)
#parser.add_argument('-save_path', type=str, help='an integer for param1', action="store", dest = "save_path")
#parser.add_argument('-data_to_predict', type=str, help='an integer for param1', action="store", dest = "pred_data")
#parser.add_argument('-nomralize_flag', type=str, help='an integer for param1', action="store", dest = "save_path")
# put the arguments in results
#results = parser.parse_args()
#df = pd.load(results.path)
from functions import test n_features = 2 n_clusters = 3 test(n_features, n_clusters) """ strange importError when using matplotlib.pyplot in ipynb NameError: global name 'plt' is not defined ImportError: cannot import name plot_cluster --> You have circular dependent imports --> add an extra cell in the beginning of the notebook %matplotlib inline import matplotlib.pyplot as plt plt.plot([1,2,3,4]) """
