def start(): flag_main = True while flag_main: print("Comands:filter, analys, read_data,gen_data, exit") a = input("Enter command:").lower().replace(' ', '') if a == 'analys': candidates_votes() party_votes() candidate_votes_democrat() candidate_votes_republican() state_votes_democrat() state_votes_republican() elif a == 'filter': print(""" Filter 1 - party 2 - state 3 - state_abbr 4 - candidate 5 - votes > 6 - votes < 7 - quit """) b = int(input("Enter command:")) if b == 7: break if b == 1: print("""1 - Republican 2 - Democrat""") c = int((input("Enter command:"))) if c == 1: filter_party("Republican") if c == 2: filter_party("Democrat") if b == 2: c = input("Enter state:") filter_state(c) if b == 3: c = input("Enter st_abbr:") filter_st_abbr(c) if b == 4: c = input("Enter candidate:") filter_candidate(c) if b == 5: c = int(input("Enter gt votes:")) filter_votes_gt(c) if b == 6: c = int(input("Enter ls votes:")) filter_votes_ls(c) if (b < 1 or b > 7): print("Error number") flag_main = True elif a == "read_data": read_data() elif a == "gen_data": c = int(input("Enter count:")) generate_data(c) elif a == "exit": break
def runsim(seed, tx_range, num_data, ROUND): random.seed(seed) sim = wsp.Simulator(timescale=0, until=50, terrain_size=(700, 700), visual=False) # sim = wsp.Simulator(timescale=0.1, until=50, terrain_size=(700, 700), visual=True) # place 100 nodes on 10x10 grid space nodes = generate_node(seed) for px, py in nodes: sim.add_node(PhaseI, (px, py)) # sim.master = master sim.master = random.randint(0, 99) sim.tx_range = tx_range sim.run() sim2 = wsp.Simulator(timescale=0, until=50, terrain_size=(700, 700), visual=False) # copy data from PhaseI to PhaseII for n in sim.nodes: sim2.add_node(PhaseII, n.pos) for i in range(len(sim.nodes)): if sim2.nodes[i].id != sim.nodes[i].my_master: sim2.nodes[i].my_master = sim.nodes[i].my_master sim2.nodes[i].prev = sim.nodes[i].prev else: sim2.nodes[i].my_master = sim.nodes[i].my_master sim2.nodes[i].P = sim.nodes[i].P sim2.nodes[i].I = sim.nodes[i].I sim2.nodes[i].T = sim.nodes[i].T sim2.nodes[i].tx_range = sim.nodes[i].tx_range sim2.source, _ = generate_data(seed, num_data, 99) sim2.ROUND = ROUND sim2.run() s1 = sum([n.send_packets for n in sim.nodes]) s2 = sum([n.send_packets for n in sim2.nodes]) return s1 + s2
def save_dataset(trocar, percentage, choice, sigma=5, upper_bound=150, N_lines=1000): lst = ['incorrect_data', 'noise', 'observed lines'] data_path = '/home/bao/Downloads/Git/master_thesis/data' num_trocar = trocar.shape[0] if choice == lst[0]: list_noise_percentage = np.arange(start_range, end_range + step, step, dtype=np.uint8) pref = 'inc' elif choice == lst[1]: list_noise_percentage = np.arange(start_range + step, end_range + step, step, dtype=np.uint8) pref = 'sigma' else: list_noise_percentage = np.arange(start_range + step, end_range + step, step, dtype=np.uint8) list_noise_percentage = [ element * 20 for element in list_noise_percentage ] pref = 'lines' path = os.path.join(data_path, pref) for num in list_noise_percentage: if choice == lst[0]: percentage[-1] = num / 100 elif choice == lst[1]: sigma = num else: N_lines = num vect_start, vect_end, dict_gt = generate_data(N_lines=N_lines, percentage=percentage, trocar=trocar, scale1=SCALE_COEF1, scale2=SCALE_COEF2, sigma=sigma, upper_bound=upper_bound) file_name = pref + '_{:05d}'.format(num) np.savez(os.path.join(path, file_name + '.npz'), vect_start=vect_start, vect_end=vect_end) with open(os.path.join(path, file_name + '.pkl'), 'wb') as fp: pickle.dump(dict_gt, fp)
def main(): seed = 123 tx_range = 100 num_data = 1 ROUND = 1 random.seed(seed) sim = wsp.Simulator(timescale=0, until=50, terrain_size=(700, 700), visual=False) nodes = generate_node(seed) for px, py in nodes: sim.add_node(PhaseI, (px, py)) # sim.master = master sim.master = random.randint(0, 99) sim.tx_range = tx_range sim.run() sim2 = wsp.Simulator(timescale=3, until=50, terrain_size=(700, 700), visual=True) # copy data from PhaseI to PhaseII for n in sim.nodes: sim2.add_node(PhaseII, n.pos) for i in range(len(sim.nodes)): if sim2.nodes[i].id != sim.nodes[i].my_master: sim2.nodes[i].my_master = sim.nodes[i].my_master sim2.nodes[i].prev = sim.nodes[i].prev else: sim2.nodes[i].my_master = sim.nodes[i].my_master sim2.nodes[i].P = sim.nodes[i].P sim2.nodes[i].I = sim.nodes[i].I sim2.nodes[i].T = sim.nodes[i].T sim2.nodes[i].tx_range = sim.nodes[i].tx_range sim2.source, _ = generate_data(4, num_data, 99) sim2.ROUND = ROUND sim2.run()
def simulate(config, households, speed): start = get_max_timestamp() while True: end = start + timedelta(minute=1) sensor_data = {} for household_id in households: household = config[household_id-1] # simulate for household for one minute sensor_data[household_id] = generate_data(household, start, end) # send sensor_data send_data(household_id, sensor_data) # increase time with one minute start = end
def start(): read_data_at_start() print( "Hello, stranger! Welcome to COURSEWORK9000. Type 'help' to call the help menu. Enter the command:" ) while True: inputString = input(">> ").lower().replace(' ', '') if inputString == 'help': print( "Available commands:\n" "type 'help' to help\n" "type 'read' to read the data from .csv files on the computer\n" "type 'getc' to get all of the characteristicvar descriptions\n" "type 'getm' to get all of the measurementvar descriptions\n" "type 'generate' to generate some random data\n" "type 'filter' to filter data\n" "type 'analyse' to run the analyst functions\n" "type 'truncate' to truncate the database tables\n" "type 'exit' to exit") elif inputString == 'analyse': run_the_analysis() elif inputString == 'filter': filter_main() elif inputString == "read": read_data_fast() elif inputString == "generate": count = int(input("Enter the count\n>> ")) generate_data(count) elif inputString == "truncate": truncate_db() elif inputString == 'getc': read_characteristicvars_table_all() elif inputString == 'getm': read_measurementvars_table_all() elif inputString == "exit": break
def plot_data(): # Dataset and labels X, y = generate_data() x_0, y_0, x_1, y_1 = [], [], [], [] for i in range(len(X)): if y[i] == 0: x_0.append(X[i][0]) y_0.append(X[i][1]) elif y[i] == 1: x_1.append(X[i][0]) y_1.append(X[i][1]) plt.scatter(x_0, y_0, c="r", alpha=0.5) plt.scatter(x_1, y_1, c="b", alpha=0.5) plt.xlabel("x") plt.ylabel("y") plt.title("Data generated by generate_data()") plt.savefig("data.png")
def main(): #num_days = 10000 #attack = np.zeros(num_days) ga = generate_data() date = pd.date_range(start=start_date, end=end_date) fp_temp = [] holiday_data = [] full_moons = ga.all_fm holidays = ga.holidays full_moon_array = np.zeros(len(date)) holiday_array = np.zeros(len(date)) temp_1 = start_date #print(int(start_date in all_full_moon)) index = 0 #print(all_full_moon) while temp_1 <= end_date: full_moon_array[index] = int(temp_1 in full_moons) holiday_array[index] = int(temp_1 in holidays) ga.loneWolf_attack() ga.set_holi_attack_fact(temp_1) ga.set_fm_attack_fact(temp_1) ga.set_rp_attack_fact() ga.set_tg_casualities() fp_temp.append(ga.tg_casualities + ga.total_lw_attack) temp_1 += dt.timedelta(1) index += 1 #print((full_moon_array)) #print(len(pd.date_range(start=start_date,end=end_date))) attack_df = pd.DataFrame({ 'Attacks': fp_temp, 'Date': date, }) #'Full_moons' : full_moon_array, #'Holidays': holiday_array}) # print(attack_df.head(10)) attack_df.to_csv('../ML_predictor/1_complex_finetuned.csv') plt.plot(fp_temp)
A[2, 0] = A[0, 2] A[2, 1] = A[1, 2] A[2, 2] = label.shape[0] B = np.zeros([3]) B[0] = np.sum(np.dot(data[:, 0], label)) B[1] = np.sum(np.dot(data[:, 1], label)) B[2] = np.sum(label) [w1, w2, b] = np.linalg.solve(A, B) return lambda x: np.sign(w1 * x[:, 0] + w2 * x[:, 1] + b) if __name__ == '__main__': data, label = generate_data(data_num, data_num1, data_num2) weight = np.ones(data_num) * (1. / data_num) def f(x): return 0 plt.figure(figsize=(10, 10)) err = [] for i in range( 200 ): # the main iterate, some rules should be added to end the loop s_data, s_label = sample_data(data, label, weight, data_num) new_f = select_f(s_data, s_label) e = np.sum((new_f(data) != label) * weight)
""" main.py Main file to run with the Python interpreter. Generates some test data and runs it through our "polyamorous" Gale Shapley algorithm. """ from generate_data import * from polygs import * # Generate buyer & seller data. # Optionally, pass poly=False to default to the standard Gale-Shapley algorithm. buyers, sellers = generate_data(num_buyers=5, poly=True) print "\nMatching", len(buyers), "buyers with", len(sellers), "sellers." # Display the generated data. print "\nBuyer data:" for buyer in buyers: print "ID:", buyer, "-", buyers[buyer] print "\nSeller data:" for seller in sellers: print "ID:", seller, "-", sellers[seller] # Run the algorithm. matches = polyGS(buyers, sellers) # Display the resulting matching. print "\nMatches (in format (buyer, seller) ):" for match in matches: print match
print(model.summary()) # Se muestra gráficamente la red plot_model(model, to_file='multiple_inputs.png') # Se crea el optimizador Adam adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=1.25) parallel_model = multi_gpu_model(model,gpus=2) #Compilamos el modelo parallel_model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['mae','accuracy']) print(model.output_shape) # model.fit([X_fija_29,X_mov_29,X_fija_27,X_mov_27],Y_train, batch_size=100, epochs=20, # verbose=2, validation_data=(X_test, Y_test)) #for iteraciones in range(0,1000): DVF = generate_data() DVF.generate_dvf() for i in range(0,20): patches_train = get_patches(sitk.ReadImage("brain.nii"),100) [X_27_moving_train, X_29_moving_train, X_27_fixed_train, X_29_fixed_train, Y_train] = patches_train.patches() # print('maximo',np.max(X_27_moving_train)) # print('maximo', np.max(X_29_moving_train)) # print('maximo', np.max(X_27_fixed_train)) # print('maximo', np.max(X_29_fixed_train)) #print((patches.Y.shape)) patches_test = get_patches(sitk.ReadImage("brain.nii"), 25) [X_27_moving_test, X_29_moving_test, X_27_fixed_test, X_29_fixed_test, Y_test] = patches_test.patches() # print('maximo', np.max(X_27_moving_test)) # print('maximo', np.max(X_29_moving_test))
errors.append(error(tree, test_data)) erros_main.append(np.mean(errors)) plt.plot(Ms,erros_main) plt.xlabel("M") plt.ylabel("Average_error (%)") """ # Q2 Ms=np.arange(10000,150000, 25000) irrelevant=[] for m in Ms: irrels=[] for rep in range(15): irrel=[] sys.stdout.write("\r m:"+str(m)+" rep:"+str(rep)) train_data=generate_data(m) tree=decision_tree(21, train_data,[],s=1500) stack=[tree] while stack: popped=stack.pop() if popped[0]!="p": stack.append(popped[1][0]) stack.append(popped[1][1]) if popped[0]>14: irrel=set(irrel).union(set([popped[0]])) irrels.append(len(irrel)) irrelevant.append(np.mean(irrels)) print(irrelevant) print("\n") plt.plot(Ms,irrelevant)
sim.ROUND = ROUND # place nodes over 100x100 grids nodes = generate_node(seed) for px, py in nodes: node = sim.add_node(MyNode, (px, py)) node.tx_range = tx_range node.logging = True # start the simulation sim.run() packets = sum([n.send_packets for n in sim.nodes]) return packets # runsim(0, 1, 99, 300) seed = int(sys.argv[1]) with open(f"results_aodv_{seed}.csv", "w") as out: writer = csv.writer(out) writer.writerow(['seed', 'range', 'num_data', 'packets']) for i in range(5, 101, 5): n = i _, data = generate_data(seed, n, 99) for j in range(5): RANGE = 50 + (j + 1) * 50 print(f"RUNNING...{seed}, {RANGE}, {n}") packets = 0 for u, v in data: packets += runsim(seed, u, v, RANGE, 1) writer.writerow([seed, RANGE, n, packets])
# Imports import numpy as np from sklearn.neighbors import KNeighborsClassifier import matplotlib.pyplot as plt import matplotlib.image as mpimg import os from scipy.ndimage import filters import matplotlib.cbook as cbook from pylab import * from generate_data import * plt.switch_backend('agg') # Dataset and labels X, y = generate_data() K = [] performance = [] # Run kNN with increasing K for n in range(1, len(y)): neigh = KNeighborsClassifier(n) neigh.fit(X, y) prediction = neigh.predict(X) total = len(prediction) correct = sum(1 - np.absolute(y - prediction)) K += [n]
if __name__ == '__main__': if process == 'generate_marginal_table': raw_data = pd.read_csv('data/dataset', header=None) attrs_list = generate_attribute_list( num_attribute, size_marginal_tables, num_marginal_tables) # need consistency marginal_list = buil_marginal_table(attrs_list, raw_data, epsilon, is_noise=False) with open('data/marginal_table_no_noise.pickle', 'wb') as f: pickle.dump(marginal_list, f) elif process == 'generate_data': filename = 'data/marginal_table_10_laplace.pickle' data = load_marginal_table(filename) all_marginal_attrs = [] for i in range(len(data)): all_marginal_attrs.append(data[i]['attrs']) sorted_list = sort_list(all_marginal_attrs) # sort the list all_record = [] for j in range(num_generate_data): record = generate_data(sorted_list, data, num_attribute) all_record.append(record) result = pd.DataFrame(all_record, columns=range(num_attribute)) result = result.astype(int) result.to_csv('data/result_10_laplace.csv')
from generate_data import * #generate data generate_data(n=100, file_prefix="train") #load data """ (train_data, train_label) = load_data(file_prefix="train") print(train_data) print(train_label) """
self.params['W1'] -= learning_rate * dW1 self.params['W2'] -= learning_rate * dW2 self.params['W3'] -= learning_rate * dW3 self.params['b1'] -= learning_rate * db1 self.params['b2'] -= learning_rate * db2 self.params['b3'] -= learning_rate * db3 return loss_history def predict(self, X): hidden1 = np.maximum(0, np.dot(X, self.params['W1']) + self.params['b1']) hidden2 = np.maximum( 0, np.dot(hidden1, self.params['W2']) + self.params['b2']) y_pred = np.argmax(np.dot(hidden2, self.params['W3'] + self.params['b3']), axis=1) # scores = np.dot(hidden2, self.params['W3']+self.params['b3']) return y_pred if __name__ == "__main__": X1, Y1 = generate_data() x_train, y_train, x_test, y_test = data_split(X1, Y1) # data = batch(x_train, y_train) model = ThreeLayerFC() loss_history = model.train(x_train, y_train, epoch=10) y_pred = model.predict(x_test) print("accuracy: %.2f " % (np.mean(y_pred == y_test) * 100), "%") plt.plot(loss_history) plt.show()
from generate_data import * from decision_trees import * import numpy as np import math import matplotlib.pyplot as plt if __name__ == "__main__": k = 4 m1 = 100 train_data = generate_data(k, m1) #print("\n\nTrain Data: \n") #print(train_data) tree1, train_error = train_model(k, train_data) #print(tree) print("\n Train error:") print(train_error) #Q3 m2 = 1000 test_data = generate_data(k, m2) print("\n Q3. Test error:") print(error(tree1, test_data)) """ print("\n Decision Tree: \n") tree2, train_error=train_model(k,train_data,ig=False) print("\n Train error:") print(train_error) print("\n Q3. Test error:")
def main(): # generate the waste data only if it has not been already generated if not (os.path.exists('n.txt') and os.path.exists('avg_waste.txt')): generate_data() # plot data generate_plots('n.txt', 'avg_waste.txt')
def main(): if not (os.path.exists('as_times.txt') and os.path.exists('rand_times.txt') and os.path.exists('N.txt')): generate_data() generate_plots('N.txt', 'rand_times.txt', 'as_times.txt')