def netparam(name, filt, tau, nbclust, sigma, homeinv, jitter, timestr, dataset, R, nb_learn=10, maxevts = None, ds_ev = None, jitonic = [None,None], verbose = False): if verbose: print(f'The dataset used is: {dataset}') if name=='hots': homeo = False homeotest = False krnlinit = 'first' hotshom = network(krnlinit=krnlinit, filt=filt, tau=tau, R=R, nbclust=nbclust, homeo=homeo, sigma=sigma, homeinv=homeinv, jitter=jitter, timestr=timestr) hotshom = hotshom.learning1by1(dataset=dataset, nb_digit = nb_learn, maxevts = maxevts, ds_ev = ds_ev, jitonic = jitonic, verbose=verbose) elif name=='homhots': homeo = True homeotest = False krnlinit = 'rdn' hotshom = network(krnlinit=krnlinit, filt=filt, tau=tau, R=R, nbclust=nbclust, homeo=homeo, sigma=sigma, homeinv=homeinv, jitter=jitter, timestr=timestr) hotshom = hotshom.learningall(dataset=dataset, nb_digit = nb_learn, maxevts = maxevts, ds_ev = ds_ev, jitonic = jitonic, verbose=verbose) elif name=='fullhom': homeo = True homeotest = True krnlinit = 'rdn' hotshom = network(krnlinit=krnlinit, filt=filt, tau=tau, R=R, nbclust=nbclust, homeo=homeo, sigma=sigma, homeinv=homeinv, jitter=jitter, timestr=timestr) hotshom = hotshom.learningall(dataset=dataset, nb_digit = nb_learn, maxevts = maxevts, ds_ev = ds_ev, jitonic = jitonic, verbose=verbose) elif name=='onlyonline': homeo = False homeotest = False krnlinit = 'rdn' hotshom = network(krnlinit=krnlinit, filt=filt, tau=tau, R=R, nbclust=nbclust, homeo=homeo, sigma=sigma, homeinv=homeinv, jitter=jitter, timestr=timestr) hotshom = hotshom.learningall(dataset=dataset, nb_digit = nb_learn, maxevts = maxevts, ds_ev = ds_ev, jitonic = jitonic, verbose=verbose) return hotshom, homeotest
def train_optimized(X_train, y_train): #Using optimized hyper parameters found, trains a network and returns it #Initialize network input_neurons = len(X_train[:, 0]) output_neurons = 1 net = network((input_neurons, 100, output_neurons), smoosh_weights=False) batch_size = 5 #Test if setting biases to 1 helps #net.set_bias() #Set number of training epochs number_of_epochs = 50 #set the training rate net.learning_rate = 1 #Set regularization net.L2 = 0 t0 = time() plot_e = list() plot_acc = list() plot_TP = list() plot_bacc = list() for e in range(number_of_epochs): net.metric_acc, net.metric_con = net.test(X_test, y_test) #Keep track of raining progress and time usage print("\rRunning time after {} epoch: {}".format(e, time() - t0), end="", flush=True) #Create random index vector k = net.make_batch_index(len(X_train[0, :])) #Calculate number of batches and loop through for i in range(len(k) // batch_size): batch = k[i * batch_size:(i + 1) * batch_size] net.train(X_train[:, batch], y_train[batch]) bacc = net.metric_con[0, 0] / (net.metric_con[0, 0] + net.metric_con[1, 0]) bacc += net.metric_con[1, 1] / (net.metric_con[1, 1] + net.metric_con[0, 1]) bacc = bacc / 2 plot_e.append(e) plot_acc.append(net.metric_acc) plot_TP.append(net.metric_con[0, 0]) plot_bacc.append(bacc) data = { "ACC": plot_acc, "BACC": plot_bacc, "TP": plot_TP, "Epochs": plot_e } net.history = pd.DataFrame(data) return net
def readFromMnist(): input_nodes = 784 hidden_nodes = 300 output_nodes = 10 learning_rate = 0.2 n = network(input_nodes, hidden_nodes, output_nodes, learning_rate) training_data_file = open("mnist_dataset/mnist_train_100.csv", "r") training_data_list = training_data_file.readlines() training_data_file.close() epochs = 5 for e in range(epochs): for record in training_data_list: all_values = record.split(',') inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01 targets = numpy.zeros(output_nodes) + 0.01 targets[int(all_values[0])] = 0.99 n.train(inputs, targets) pass pass test_data_file = open("mnist_dataset/mnist_test_10.csv", 'r') test_data_list = test_data_file.readlines() test_data_file.close() scorecard = [] for record in test_data_list: all_values = record.split(',') correct_label = int(all_values[0]) inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01 outputs = n.query(inputs) label = numpy.argmax(outputs) if label == correct_label: scorecard.append(1) else: scorecard.append(0) pass pass scorecard_array = numpy.asarray(scorecard) print(scorecard) print("performance = ", scorecard_array.sum() / scorecard_array.size)
def fit_franke(): #Uses optimized hyperparameters found with the gridsearch #function and tests performance against #validation set #Initialize network input_neurons = len(X2[0, :]) output_neurons = 1 net = network((input_neurons, 100, output_neurons)) net.cost_function = "square" net.fit_function = True #Set batch size batch_size = 5 #Set number of training epochs number_of_epochs = 500 #set the training rate net.learning_rate = 1 #Set regularization net.L2 = 0 results_mse = list() results_r2 = list() epochs = np.arange(number_of_epochs) #Create time stamp to track calculation times t0 = time() for e in range(number_of_epochs): #Keep track of raining progress and time usage print("\rRunning time after {} epoch: {}".format(e, time() - t0), end="", flush=True) #Create random index vector k = net.make_batch_index(len(X_train[0, :])) #Calculate number of batches and loop through for i in range(len(k) // batch_size): batch = k[i * batch_size:(i + 1) * batch_size] net.train(X_train[:, batch], y_train[batch]) #Calculate results for current settings z = net.test(X2.T, true2) r2 = R2(true2, z[-1]) mse = MSE(true2, z[-1]) results_mse.append(mse) results_r2.append(r2) data = {"MSE": results_mse, "R2": results_r2, "Number epochs": epochs} return pd.DataFrame(data)
parser = argparse.ArgumentParser(description='PyTorch CornerNet Demo') parser.add_argument('--conf_thres', default=0.01, type=float, help='object threshold') parser.add_argument('--nms_thres', type=float, default=0.3, help='iou threshold') parser.add_argument('--test_path', type=str, default=r'E:\datasets\test', help='resume from checkpoint') args = parser.parse_args() print(args) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') net = network(config, lr=None, resume=True, device=device, train_loader=None, mode='demo') net.simple_demo(imgs_dir=args.test_path, conf_thres=args.conf_thres, nms_thres=args.nms_thres, num_dets=1000, ae_threshold=0.1)
Glat, Glon, GType, Gnum, Gedge = latlontypenumedge(GN, GE, dt.gasname1, dt.gasname2) plt.figure(figsize=(20, 12)) Base = bm.BaseMapSet(dt.Type1, dt.llon, dt.rlon, dt.llat, dt.rlat) WX, WY = latlon2XY(Wlat, Wlon, Base) PX, PY = latlon2XY(Plat, Plon, Base) GX, GY = latlon2XY(Glat, Glon, Base) Wsupply, Wtransmission, Wdemand = supplytrandemandnum(WType, dt.water1para, Wnum) Psupply, Ptransmission, Pdemand = supplytrandemandnum(PType, dt.power1para, Pnum) Gsupply, Gtransmission, Gdemand = supplytrandemandnum(GType, dt.gas1para, Gnum) Shelby_Water = network(dt.water0para, Geox, Geoy) Shelby_Power = network(dt.power0para, Geox, Geoy) Shelby_Gas = network(dt.gas0para, Geox, Geoy) Shelby_Water.x, Shelby_Water.y, Shelby_Water.Type = WX, WY, WType Shelby_Power.x, Shelby_Power.y, Shelby_Power.Type = PX, PY, PType Shelby_Gas.x, Shelby_Gas.y, Shelby_Gas.Type = GX, GY, GType supplytrandemandxy(Shelby_Water) supplytrandemandxy(Shelby_Power) supplytrandemandxy(Shelby_Gas) ShelbyNetwork = [Shelby_Water, Shelby_Power, Shelby_Gas] edge = [Wedge, Pedge, Gedge] for i in range(len(ShelbyNetwork)):
print(args) if len(config['gpu_ids']) == 1: os.environ["CUDA_VISIBLE_DEVICES"] = str(config['gpu_ids'][0]) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # Data print('==> Preparing data...') transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.485,0.456,0.406), (0.229,0.224,0.225)) ]) dataset = ListDataset(config['root'],config['train_root'],img_size=config['image_size'], fmp_size=config['fms_size'], classes=config['num_classes'], train=True,transform=transform) train_loader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, shuffle=True,collate_fn=dataset.collate_fn) net = network(config, lr=args.lr, resume=args.resume, device=device, train_loader=train_loader) if __name__=="__main__": net.train()
def grid_search(X_train, X_test, y_train, y_test, learning_rates, lambdas, hidden, n_epochs=[5], b_sizes=[10]): #Runs through a range of hyper parameters and returns a dataframe #with accuracy for every tested combination etas = list() L2 = list() neurons = list() results_accuracy = list() results_bal_accuracy = list() training_results_accuracy = list() training_results_bal_accuracy = list() epochs = list() batch_sizes = list() #Create time stamp to track calculation times t0 = time() for eta in learning_rates: for lmd in lambdas: for h in hidden: for sizes in b_sizes: for eps in n_epochs: #Initialize network input_neurons = len(X_train[:, 0]) print(input_neurons) output_neurons = 1 net = network((input_neurons, h, output_neurons), smoosh_weights=False) batch_size = sizes #Set number of training epochs number_of_epochs = eps #set the training rate net.learning_rate = eta #Set regularization net.L2 = lmd #Set biases to 1 #net.set_bias() print("LR: {} Hidden:{} L2:{}".format(eta, h, lmd)) for e in range(number_of_epochs): #Keep track of raining progress and time usage print("\rRunning time after {} epoch: {}".format( e, time() - t0), end="", flush=True) #Create random index vector k = net.make_batch_index(len(X_train[0, :])) #Calculate number of batches and loop through for i in range(len(k) // batch_size): batch = k[i * batch_size:(i + 1) * batch_size] net.train(X_train[:, batch], y_train[batch]) #Add results for current weights, biases #On testing set accuracy, confusion = net.test(X_test, y_test) TP = confusion[0, 0] TN = confusion[1, 1] FP = confusion[0, 1] FN = confusion[1, 0] bal_accuracy = ((TP / (TP + FN)) + (TN / (TN + FP))) / 2 #Strore data in preparation to make datarame results_accuracy.append(accuracy) results_bal_accuracy.append(bal_accuracy) etas.append(eta) L2.append(lmd) neurons.append(h) epochs.append(eps) batch_sizes.append(sizes) #On training set accuracy, confusion = net.test(X_train, y_train) TP = confusion[0, 0] TN = confusion[1, 1] FP = confusion[0, 1] FN = confusion[1, 0] bal_accuracy = ((TP / (TP + FN)) + (TN / (TN + FP))) / 2 training_results_accuracy.append(accuracy) training_results_bal_accuracy.append(bal_accuracy) data = { "ACC": results_accuracy, "BACC": results_bal_accuracy, "tACC": training_results_accuracy, "tBACC": training_results_bal_accuracy, "Learning rate": etas, "L2 factor": L2, "Hidden Neurons": neurons, "Batch size": batch_sizes, "Number epochs": epochs } return pd.DataFrame(data)
eff1, eff2 = [[], [], []], [[], [], []] cluster_coeff1, cluster_coeff2 = [[], [], []], [[], [], []] topodiameter1, topodiameter2 = [[], [], []], [[], [], []] diameter1, diameter2 = [[], [], []], [[], [], []] cost1, cost2 = [[], [], []], [[], [], []] degree1, degree2 = [[], [], []], [[], [], []] #----------------------------------------------------Network initialization Temp = 0 while(Temp <= 50): Water = network(dt.water1para, Geox, Geoy) Power = network(dt.power1para, Geox, Geoy) Gas = network(dt.gas1para, Geox, Geoy) Network_obj = [Water, Power, Gas] ##For each of three networks: Water, Power, Gas for i in range(len(Network_obj)): #Decision of facility location of three networks Network = Network_obj[i] Network.network_setup(Tract_pop, Tractx, Tracty, i, lon, lat, dt.cnum) topo_eff1[i].append(Network.topo_efficiency) eff1[i].append(Network.efficiency) cluster_coeff1[i].append(Network.cluster_coeff) topodiameter1[i].append(Network.topodiameter)
def grid_search(learning_rates, lambdas, hidden, n_epochs=[5], b_sizes=[10]): #Runs through a range of hyper parameters and returns a dataframe #with MSE/R2 scores for every tested combination etas = list() L2 = list() neurons = list() results_mse = list() results_r2 = list() epochs = list() batch_sizes = list() #Create time stamp to track calculation times t0 = time() #To keep track of progress counter = 0 goal = len(learning_rates) * len(lambdas) * len(hidden) * len( n_epochs) * len(b_sizes) for eta in learning_rates: for lmd in lambdas: for h in hidden: for sizes in b_sizes: for eps in n_epochs: #Initialize network input_neurons = len(X[0, :]) output_neurons = 1 net = network((input_neurons, h, output_neurons)) net.cost_function = "square" net.fit_function = True batch_size = sizes #Set number of training epochs number_of_epochs = eps #set the training rate net.learning_rate = eta #Set regularization net.L2 = lmd counter += 1 #Keep track of raining progress and time usage print("\rRunning time: {:.1f} Iteration: {}/{}".format( time() - t0, counter, goal), end="", flush=True) for e in range(number_of_epochs): #Create random index vector k = net.make_batch_index(len(X_train[0, :])) #Calculate number of batches and loop through for i in range(len(k) // batch_size): batch = k[i * batch_size:(i + 1) * batch_size] net.train(X_train[:, batch], y_train[batch]) #Calculate results for current settings z = net.test(X.T, true) r2 = R2(true, z[-1]) mse = MSE(true, z[-1]) results_mse.append(mse) results_r2.append(r2) etas.append(eta) L2.append(lmd) neurons.append(h) epochs.append(eps) batch_sizes.append(sizes) data = { "MSE": results_mse, "R2": results_r2, "Learning rate": etas, "L2 factor": L2, "Hidden Neurons": neurons, "Batch size": batch_sizes, "Number epochs": epochs } return pd.DataFrame(data)
pg.init() # Resets pygame libary clock = pg.time.Clock() # Setting the clock screen_height, screen_length = 600, 1100 # Those variables get used in the other moudles screen = pg.display.set_mode( (screen_length, screen_height)) # Creating a window pg.display.set_caption("Tanks", "Spine Runtime") # Set window caption pg.display.set_icon( pg.image.load("images/tankico.ico")) # Set window icon image running = True n = network() data_to_send = n.getP() received_data = n.send( data_to_send) # First connection made, gives back the stats data to be set print(received_data) bullets_group = pg.sprite.Group() # The tank's bullets that got fired player = tank( (200, 200) ) # Creating an object from the tank class and adding it to the tank sprite group. It gets the starting point from the server ########### bars_and_panels = pg.sprite.Group() bars_and_panels.add(money_bar()) bars_and_panels.add(health_bar()) ###########
# Zu Beginn müssen die Input Nodes festgelegt werden inputnodes = 784 """=======================================================CODE=======================================================""" def transformAnswer(antwortMatrix): index = Helper.getIndexOfMaxValue(antwortMatrix) return index np.set_printoptions(threshold=np.inf) # wird für Ausgabe der Matrizen benötigt erg = pngWandler(path).openPictures() images = [] targets = [] i = 0 j = 0 nw = network(inputnodes, 300, 10, 0.3) while j < 3: for obj in erg: if i + 1 < len(erg): nw.train(erg[i + 1], erg[i]) i += 2 j += 1 eingabe = Eingabe(path, nw) right, wrong = Helper.testNetwork(nw, path) print(right) print(wrong) Helper.readFromMnist()
args = parser.parse_args() args.checkpoint_dir = os.path.join(args.checkpoint_dir, 'fold_%d'%args.fold) checkpoint_dir = os.path.join(args.checkpoint_dir, 'fold_%d' %args.fold) print(category[args.fold]) #set gpus # gpu_list = [int(x) for x in args.gpu.split(',')] os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID' os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu torch.backends.cudnn.benchmark = True cudnn.enabled = True # Create network. model = network() #load resnet50 preatrained parameter model = load_resnet_param(model, stop_layer='fc', layer_num=50) model=nn.DataParallel(model,[0,1]) # disable the gradients of not optomized layers turn_off(model) if not os.path.exists(checkpoint_dir): os.makedirs(os.path.join(checkpoint_dir)) trainset = dataset_train(data_dir=args.data_dir, fold=args.fold, input_size=args.input_size) trainloader = data.DataLoader(trainset, batch_size=args.train_batch_size, shuffle=True, num_workers=4)
transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) dataset = ListDataset(config['train_root'], img_size=config['image_size'], fmp_size=config['fms_size'], classes=config['num_classes'], train=True, transform=transform) trainloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, shuffle=True, collate_fn=dataset.collate_fn) net = network(config, lr=args.lr, resume=args.resume, device=device) def train(epoch): train_loss = 0. for idx, ip_dict in enumerate(trainloader): images = ip_dict['inputs'].to(device) targets = [t.to(device) for t in ip_dict['targets']] loss, log_loss = net(images, targets) train_loss += loss.item() print( '[Epoch %d, Batch %d/%d] [totalLoss:%.6f] [ht_loss:%.6f, off_loss:%.6f, pull_loss:%.6f, push_loss:%.6f]' % (epoch, idx, len(trainloader), loss.item(), log_loss[0], log_loss[1], log_loss[2], log_loss[3]))