def studentCourses(student,course): generate(10) if(course == "Math"): subject_grades = {"Adding":23,"Subtracting":37,"Multiplication":10, "Division":30} links = [{"name":"Adding","link":"/students/"+student + "/course/"+ course + "/Adding"},{"name":"Subtracting","link":"/students/"+student + "/course/"+ course + "/Subtracting"},{"name":"Division","link":"/students/"+student + "/course/"+ course + "/Division"},{"name":"Multiplication","link":"/students/"+student + "/course/"+ course + "/Multiplication"}] return render_template("subject_page.html",student= student, items= links,progress = subject_grades,title=student,course = course) elif(course == "English"): subject_grades = {"Grammar":23,"Comprehension":37} links = [{"name":"Grammar","link":"/students/"+student + "/"+ course + "/Grammar"}, {"name":"Comprehension","link":"/students/"+student + "/"+ course + "/Comprehension"}] return render_template("subject_page.html",student= student, items= links,progress = subject_grades,title=student,course = course) return redirect(url_for('student'))
""" This module prepares midi file data and feeds it to the neural network for training """ import torch import generation from training import train from data_preprocess import load_training_data random_seed = 0 torch.manual_seed(random_seed) if __name__ == '__main__': # data_path = "data/chopin/*.mid" # seq_length = 512 # network_input, network_output, num_unique_tokens = load_training_data(data_dir_path=data_path, sequence_length=seq_length, # save_data=True, load_data=False) # train(network_input, network_output, num_unique_tokens, seq_length) generation.generate( "training_data.pickle", "/home/okleinfeld/PianoGenerator/training_checkpoint_26.09.2019_15:15:00/checkpoint.pth", 2)
def generateBtnClicked(nodeCount, edgeCount): generation.generate(nodeCount, edgeCount)
def best_clock(population1): #RETURN THE BEST CLOCK maxi =0 best_clock = [] for i in range(0,len(population1)): temp = fitness(population1[i]) if temp > maxi: maxi = temp best_clock = population[i] return best_clock def display_clock(clock): connection_list = gen.list_connections(clock) for i in range(0,len(connection_list)): print (connection_list[i][0].__class__.__name__,connection_list[i][1].__class__.__name__,connection_list[i][2]) """ Test """ input_database() population = gen.generate(100,1,25) natural_selection(population) #best = best_clock(population) #print("BEST CLOCK FITNESS SCORE:",fitness(best)) for i in range(len(ConnectionData)) : print(i, " : ", ConnectionData[i].name, " -> ", ConnectionData[i].point) print( " ",1 - abs((abs(1./60) - VITESSE_SECONDHAND) / VITESSE_SECONDHAND)) print( " ",1 - abs((abs(1/.60) - VITESSE_MINUTEHAND) / VITESSE_MINUTEHAND)) print( " ",1 - abs((abs(1./60) - VITESSE_HOURHAND) / VITESSE_HOURHAND))
} # mls = load_mel_spectrogram_db(original_audio_list[config['audio']], config) spectrogram, melfilters = load_mel_spectrogram_db( original_audio_list[config['audio']], config) print('Finished loading audio and creating spectrogram, shape: %d %d\n' % spectrogram.shape) # config['start_offset'] += config['use_prev_frames'] spectrogram = spectrogram.T # rows should be different training examples, so different points in time X = fe.extract_features(spectrogram, config) y = fe.extract_target(spectrogram, config) print('Training data shape: {}, training labels shape: {}'.format( X.shape, y.shape)) start_time = perf_counter() predictor = LinearRegression(normalize=True) predictor.fit(X, y) print(perf_counter() - start_time) # output_spectrogram = generate(spectrogram, predictor, config, X.shape[1]) output_spectrogram = invert_mel_db(output_spectrogram.T, melfilters).T output = reconstruct_signal_griffin_lim(output_spectrogram, config['framelength'], config['hop_length'], 80) lr.output.write_wav('test.wav', output, config['sr'])
def display_clock(clock): connection_list = gen.list_connections(clock) for i in range(0, len(connection_list)): print(connection_list[i][0].__class__.__name__, connection_list[i][1].__class__.__name__, connection_list[i][2]) """ Test """ try: input_database() population = gen.generate(100, 3, 100) natural_selection(population) except KeyboardInterrupt: pass finally: best = best_clock(population) print("Best fitness : ", fitness(best)) for piece in gen.classes: counter = 0 for part in best[1:]: if isinstance(part, piece): counter += 1 print("Number of ", piece, " : ", counter) print("------ connections ------") print(gen.list_connections(best)) ''' for i in range(len(valid_connections)) :
def main(): ''' Main function that coordinates the entire process. Parses arguments that specify the exercise and the experiment that should be run. Initializes the model and the checkpoint managers. ''' parser = argparse.ArgumentParser( description='Define configuration of experiments') parser.add_argument('--mode', type=str, nargs='+', choices=['train', 'evaluate', 'generate'], required=True) parser.add_argument('--experiment', type=str, choices=['a', 'b', 'c'], required=True) parser.add_argument('--id', type=str, required=False) parser.add_argument('--epochs', type=int, default=EPOCHS, required=False) args = parser.parse_args() # Setting Experiment Id if args.id is None: exp_id = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") print(f"No Experiment Id Set, Creating New: {exp_id}") else: exp_id = args.id print(f"Using Experiment Id: {exp_id}") # Setting Directories base_dir = f"{OUTPUT_DIR}/exp_{args.experiment}/{exp_id}" log_dir = f"{base_dir}/logs" submission_dir = f"{base_dir}/submissions" if not os.path.exists(submission_dir): os.makedirs(submission_dir) ckpt_dir = f"{base_dir}/ckpts" print(f"Experiment Directory: {base_dir}") print(f"Using Tensorflow Version: {tf.__version__}") print("Building Vocabulary...") build_vocab(input_file=PATH_TRAIN, output_file=PATH_VOCAB, top_k=VOCAB_SIZE, special=SPECIAL) word2id, id2word = build_vocab_lookup(PATH_VOCAB, "<unk>") # Setting Experiment Specific Configurations if args.experiment == 'a': lstm_hidden_state_size = 512 word_embeddings = None elif args.experiment == 'b': lstm_hidden_state_size = 512 word_embeddings = load_embedding(dim_embedding=EMBEDDING_SIZE, vocab_size=VOCAB_SIZE) elif args.experiment == 'c': lstm_hidden_state_size = 1024 word_embeddings = load_embedding(dim_embedding=EMBEDDING_SIZE, vocab_size=VOCAB_SIZE) else: raise ValueError(f"Unknown Experiment {args.experiment}") print(f'Initializing Model...') model = LanguageModel(vocab_size=VOCAB_SIZE, sentence_length=SENTENCE_LENGTH, embedding_size=EMBEDDING_SIZE, hidden_state_size=lstm_hidden_state_size, output_size=LSTM_OUTPUT_SIZE, batch_size=BATCH_SIZE, word_embeddings=word_embeddings, index_to_word_table=id2word) print(f'Initializing Optimizer...') optimizer = tf.keras.optimizers.Adam() ckpt = tf.train.Checkpoint(step=tf.Variable(1), optimizer=optimizer, net=model) manager = tf.train.CheckpointManager(ckpt, ckpt_dir, max_to_keep=5) if manager.latest_checkpoint: print(f"Restoring Model from {manager.latest_checkpoint}...") ckpt.restore(manager.latest_checkpoint) model_loaded = True else: print("Initializing Model from Scratch") model_loaded = False if "train" in args.mode: print(f"Starting Training...") train_summary_writer = tf.summary.create_file_writer( f"{log_dir}/train") with train_summary_writer.as_default(): train(ckpt=ckpt, manager=manager, model=model, optimizer=optimizer, word2id=word2id, id2word=id2word, epochs=args.epochs) model_loaded = True if "evaluate" in args.mode: print(f"Starting Evaluation...") assert model_loaded, 'model must be loaded from checkpoint in order to be evaluated' test_summary_writer = tf.summary.create_file_writer( f"{log_dir}/evaluate") with test_summary_writer.as_default(): evaluate( model=model, word2id=word2id, id2word=id2word, step=optimizer.iterations, path_submission= f"{submission_dir}/group35.perplexity{args.experiment.upper()}" ) if "generate" in args.mode: print(f"Starting Generation...") assert model_loaded, 'model must be loaded from checkpoint in order to start generation' generate_summary_writer = tf.summary.create_file_writer( f"{log_dir}/generate") with generate_summary_writer.as_default(): generate(word2id, id2word, model=model, path_submission=f"{submission_dir}/group35.continuation")
def train(D, G, Dis_optimizer, Enc_optimizer, Dec_optimizer, data_loader, writer, opt, epoch=0): D.train() G.train() bce_loss = nn.BCEWithLogitsLoss(reduction='elementwise_mean') def l1_loss(input, target): return torch.mean(torch.abs(input - target)) def l2_loss(input, target): return torch.mean((input - target).pow(2)) t_real = Variable(torch.ones(opt.batch_size, 1)) t_fake = Variable(torch.zeros(opt.batch_size, 1)) if opt.use_gpu: t_real = t_real.cuda() t_fake = t_fake.cuda() Dis_running_loss = 0 Enc_running_loss = 0 Dec_running_loss = 0 num_itrs = len(data_loader.dataset) // opt.batch_size for itr, (data, _) in enumerate(data_loader): if data.size()[0] != opt.batch_size: break # train Discriminator === Dis_optimizer.zero_grad() x_real = Variable(data) z_fake_p = Variable(torch.randn(data.shape[0], opt.nz)) if opt.use_gpu: x_real = x_real.cuda() z_fake_p = z_fake_p.cuda() x_fake, mu, logvar = G(x_real) # L_gan --- y_real_loss = bce_loss(D(x_real), t_real) y_fake_loss = bce_loss(D(x_fake), t_fake) y_fake_p_loss = bce_loss(D(G.decoder(z_fake_p)), t_fake) L_gan_real = (y_real_loss + y_fake_loss + y_fake_p_loss) / 3.0 # Dis_loss --- Dis_loss = L_gan_real Dis_loss.backward() Dis_optimizer.step() Dis_running_loss += Dis_loss.item() # train Encoder === Enc_optimizer.zero_grad() x_real = Variable(data) if opt.use_gpu: x_real = x_real.cuda() x_fake, mu, logvar = G(x_real) # L_prior --- L_prior = opt.alpha * ( -0.5 * torch.mean(1 + logvar - mu.pow(2) - logvar.exp())) # L_llike --- L_recon = opt.gamma * l1_loss(x_fake, x_real) L_llike = l1_loss(D.feature(x_fake), D.feature(x_real)) # Enc_loss --- Enc_loss = L_prior + L_recon + L_llike Enc_loss.backward() Enc_optimizer.step() Enc_running_loss += Enc_loss.item() # train Decoder === Dec_optimizer.zero_grad() x_real = Variable(data) z_fake_p = Variable(torch.randn(opt.batch_size, opt.nz)) if opt.use_gpu: x_real = x_real.cuda() z_fake_p = z_fake_p.cuda() x_fake, mu, logvar = G(x_real) # L_gan --- y_real_loss = bce_loss(D(x_real), t_fake) y_fake_loss = bce_loss(D(x_fake), t_real) y_fake_p_loss = bce_loss(D(G.decoder(z_fake_p)), t_real) L_gan_fake = (y_real_loss + y_fake_loss + y_fake_p_loss) / 3.0 # L_llike --- L_recon = opt.gamma * l1_loss(x_fake, x_real) L_llike = l1_loss(D.feature(x_fake), D.feature(x_real)) # Dec_loss --- Dec_loss = L_recon + L_llike + L_gan_fake Dec_loss.backward() Dec_optimizer.step() Dec_running_loss += Dec_loss.item() sys.stdout.write( '\r\033[Kitr [{}/{}], Dis_loss: {:.6f}, Enc_loss: {:.6f}, Dec_loss: {:.6f}' .format(itr + 1, num_itrs, Dis_loss.item(), Enc_loss.item(), Dec_loss.item())) sys.stdout.flush() if (itr + 1) % 10 == 0: G.eval() # generation z = Variable(torch.randn((8, opt.nz))) if opt.use_gpu: z = z.cuda() generated = generate(G, z) writer.add_image('Generated Image', generated) # reconstruction x = Variable(data) x = x[:8] if opt.use_gpu: x = x.cuda() x, xhat = reconstruct(G, x) reconstructed = torch.cat((x, xhat), dim=0) writer.add_image('Reconstructed Image', reconstructed) # loss writer.add_scalars('Loss', { 'Discriminator': Dis_loss.item(), 'Encoder': Enc_loss.item(), 'Decoder': Dec_loss.item(), 'L_gan_real': L_gan_real.item(), 'L_gan_fake': L_gan_fake.item(), 'L_prior': L_prior.item(), 'L_recon': L_recon.item(), 'L_llike': L_llike.item() }, global_step=epoch * num_itrs + itr + 1) G.train() Dis_running_loss /= num_itrs Enc_running_loss /= num_itrs Dec_running_loss /= num_itrs return Dis_running_loss, Enc_running_loss, Dec_running_loss
def main(): parser = argparse.ArgumentParser() parser.add_argument('--log_dir', default='logs', help='log directory') parser.add_argument('--data_dir', default='data/celeba', help='data directory') parser.add_argument('--batch_size', type=int, default=64, help='batch size') parser.add_argument('--num_workers', type=int, default=4, help='number of workers for data laoding') parser.add_argument('--num_epochs', type=int, default=100, help='number of epochs') parser.add_argument('--checkpoint', type=int, default=10, help='checkpoint epoch') parser.add_argument('--lr', type=float, default=2e-4, help='learning rate') parser.add_argument('--weight_decay', type=float, default=1e-5, help='weight decay') parser.add_argument('--nz', type=int, default=100, help='dimension of latent variable') parser.add_argument('--alpha', type=float, default=1e-2, help='coefficient of L_prior') parser.add_argument('--gamma', type=float, default=5, help='coefficient of L_recon') parser.add_argument('--G_model', default=None, help='pretrained Generator model path') parser.add_argument('--D_model', default=None, help='pretrained Discriminator model path') parser.add_argument('--use_gpu', action='store_true', help='GPU mode') opt = parser.parse_args() if opt.use_gpu: opt.use_gpu = torch.cuda.is_available() if not os.path.exists(opt.data_dir): os.makedirs(opt.data_dir) if not os.path.exists(opt.log_dir): os.makedirs(opt.log_dir) writer = SummaryWriter(os.path.join(opt.log_dir, 'runs')) # =============== data preparation ================ # transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) dataset = datasets.ImageFolder(opt.data_dir, transform=transform) data_loader = DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers) # ==================== model ====================== # G = Generator(opt.nz) D = Discriminator() if (opt.G_model is not None) and (opt.D_model is not None): G.load_state_dict(torch.load(opt.G_model)) D.load_state_dict(torch.load(opt.D_model)) if opt.use_gpu: G = G.cuda() D = D.cuda() # ================== optimizer ==================== # Enc_optimizer = optim.Adam(G.encoder.parameters(), lr=opt.lr, weight_decay=opt.weight_decay, betas=(0.5, 0.999)) Dec_optimizer = optim.Adam(G.decoder.parameters(), lr=opt.lr, weight_decay=opt.weight_decay, betas=(0.5, 0.999)) Dis_optimizer = optim.Adam(D.parameters(), lr=opt.lr, weight_decay=opt.weight_decay, betas=(0.5, 0.999)) # ==================== train ====================== # history = {} history['Dis_loss'] = [] history['Enc_loss'] = [] history['Dec_loss'] = [] for epoch in range(opt.num_epochs): Dis_loss, Enc_loss, Dec_loss = train(D, G, Dis_optimizer, Enc_optimizer, Dec_optimizer, data_loader, writer, opt, epoch) sys.stdout.write( '\r\033[Kepoch [{}/{}], Dis_loss: {:.6f}, Enc_loss: {:.6f}, Dec_loss: {:.6f}\n' .format(epoch + 1, opt.num_epochs, Dis_loss, Enc_loss, Dec_loss)) sys.stdout.flush() history['Dis_loss'].append(Dis_loss) history['Enc_loss'].append(Enc_loss) history['Dec_loss'].append(Dec_loss) if (epoch + 1) % opt.checkpoint == 0: # save model torch.save( G.state_dict(), os.path.join(opt.log_dir, 'G_epoch{:04d}.pth'.format(epoch + 1))) torch.save( D.state_dict(), os.path.join(opt.log_dir, 'D_epoch{:04d}.pth'.format(epoch + 1))) G.eval() # generation z = Variable(torch.randn((10, opt.nz))) if opt.use_gpu: z = z.cuda() generated = generate(G, z) save_image(generated, os.path.join( opt.log_dir, 'generated_epoch{:04d}.png'.format(epoch + 1)), nrow=10) # reconstruction for data, _ in data_loader: x = Variable(data) x = x[:10] if opt.use_gpu: x = x.cuda() x, xhat = reconstruct(G, x) reconstructed = torch.cat((x, xhat), dim=0) save_image(reconstructed, os.path.join( opt.log_dir, 'reconstructed_epoch{:04d}.png'.format(epoch + 1)), nrow=10) break # ================== save model ==================== # torch.save( G.state_dict(), os.path.join(opt.log_dir, 'G_epoch{:04d}.pth'.format(opt.num_epochs))) torch.save( D.state_dict(), os.path.join(opt.log_dir, 'D_epoch{:04d}.pth'.format(opt.num_epochs))) G.eval() # generation z = Variable(torch.randn((10, opt.nz))) if opt.use_gpu: z = z.cuda() generated = generate(G, z) save_image(generated, os.path.join(opt.log_dir, 'generated_epoch{:04d}.png'.format( opt.num_epochs)), nrow=10) # reconstruction for data, _ in data_loader: x = Variable(data) x = x[:10] if opt.use_gpu: x = x.cuda() x, xhat = reconstruct(G, x) reconstructed = torch.cat((x, xhat), dim=0) save_image(reconstructed, os.path.join( opt.log_dir, 'reconstructed_epoch{:04d}.png'.format(opt.num_epochs)), nrow=10) break # ================== show loss ===================== # fig = plt.figure() plt.subplot(3, 1, 1) plt.plot(history['Dis_loss']) plt.ylabel('Discriminator Loss') plt.xlabel('Epoch') plt.grid() plt.subplot(3, 1, 2) plt.plot(history['Enc_loss']) plt.ylabel('Encoder Loss') plt.xlabel('Epoch') plt.grid() plt.subplot(3, 1, 3) plt.plot(history['Dec_loss']) plt.ylabel('Decoder Loss') plt.xlabel('Epoch') plt.grid() plt.savefig(os.path.join(opt.log_dir, 'loss.png')) with open(os.path.join(opt.log_dir, 'history.pkl'), 'wb') as f: pickle.dump(history, f)
def main(): pygame.init() drawing.init() screen_data = drawing.ScreenData( pygame.display.set_mode(config.SCREEN_RES, pygame.RESIZABLE), (0, 0)) input_data = InputData() path_data = pathing.PathData() selection = None lots = [] city = generation.generate() city_labels = [] for road in city.roads: city_labels.append((str(road.global_id), road.point_at(0.5))) prev_time = pygame.time.get_ticks() running = True while running: if pygame.time.get_ticks() - prev_time < 16: continue input_data.pos = pygame.mouse.get_pos() input_data.pressed = pygame.mouse.get_pressed() prev_time = pygame.time.get_ticks() for event in pygame.event.get(): if event.type == pygame.QUIT: running = False elif event.type == pygame.VIDEORESIZE: screen_data.screen = pygame.display.set_mode( event.dict["size"], pygame.RESIZABLE) config.SCREEN_RES = event.dict["size"] elif event.type == pygame.KEYDOWN: if event.key == pygame.K_g: debug.SHOW_ROAD_ORDER = False city_labels = [] selection = None path_data = pathing.PathData() city = generation.generate() for road in city.roads: city_labels.append( (str(road.global_id), road.point_at(0.5))) if event.key == pygame.K_b: lots = build_gen.gen_lots(city) # Pathing elif event.key == pygame.K_z: path_data.start = road_near_point(input_data.pos, screen_data, city) elif event.key == pygame.K_x: path_data.end = road_near_point(input_data.pos, screen_data, city) elif event.key == pygame.K_c: pathing.astar(path_data, city.roads) elif event.key == pygame.K_v: pathing.dijkstra(path_data, city.roads) # Debug Views else: handle_keys_debug(event.key) elif event.type == pygame.MOUSEBUTTONDOWN: # Zooming if event.button == 4: screen_data.zoom_in(input_data.pos) elif event.button == 5: screen_data.zoom_out(input_data.pos) # Dragging & Selection if input_data.prev_pressed[0]: if input_data.pressed[0]: # Continue drag screen_data.pan = vectors.add( screen_data.pan, vectors.sub(input_data.pos, input_data.drag_prev_pos)) input_data.drag_prev_pos = input_data.pos else: if input_data.pos == input_data.drag_start: # Select road selection = selection_from_road( road_near_point(input_data.drag_start, screen_data, city)) # Clear out drag information input_data.drag_start = None input_data.drag_prev_pos = (0, 0) else: if input_data.pressed[0]: # Drag started input_data.drag_start = input_data.pos input_data.drag_prev_pos = input_data.pos # Drawing screen_data.screen.fill((0, 0, 0)) if debug.SHOW_HEATMAP: drawing.draw_heatmap(50, city, screen_data) if debug.SHOW_SECTORS: drawing.draw_sectors(screen_data) color = (125, 255, 50) for poly in lots: temp = [] for point in poly: temp.append( drawing.world_to_screen(point, screen_data.pan, screen_data.zoom)) pygame.draw.polygon(screen_data.screen, color, temp) color = (color[0], color[1] - 11, color[2] + 7) if color[1] < 0: color = (color[0], 255, color[2]) if color[2] > 255: color = (color[0], color[1], 0) # Draw roads if debug.SHOW_ISOLATE_SECTOR and selection is not None: for sector in sectors.from_seg(selection.road): drawing.draw_all_roads(city.sectors[sector], screen_data) elif debug.SHOW_MOUSE_SECTOR: mouse_sec = sectors.containing_sector( drawing.screen_to_world(input_data.pos, screen_data.pan, screen_data.zoom)) if mouse_sec in city.sectors: drawing.draw_all_roads(city.sectors[mouse_sec], screen_data) else: tl_sect = sectors.containing_sector( drawing.screen_to_world((0, 0), screen_data.pan, screen_data.zoom)) br_sect = sectors.containing_sector( drawing.screen_to_world(config.SCREEN_RES, screen_data.pan, screen_data.zoom)) for x in range(tl_sect[0], br_sect[0] + 1): for y in range(tl_sect[1], br_sect[1] + 1): if (x, y) in city.sectors: drawing.draw_all_roads(city.sectors[(x, y)], screen_data) drawing.draw_roads_selected(selection, screen_data) drawing.draw_roads_path(path_data, screen_data) if debug.SHOW_INFO: debug_labels = debug.labels(screen_data, input_data, path_data, selection, city) for x in range(len(debug_labels[0])): label_pos = (10, 10 + x * 15) drawing.draw_label_screen((debug_labels[0][x], label_pos), screen_data, 1) for x in range(len(debug_labels[1])): label_pos = (config.SCREEN_RES[0] - 10, 10 + x * 15) drawing.draw_label_screen((debug_labels[1][x], label_pos), screen_data, -1) if debug.SHOW_ROAD_ORDER: for label in city_labels: drawing.draw_label_world(label, screen_data, 1) pygame.display.flip()
from generation import generate import numpy as np import pandas as pd import logging logging.basicConfig(level=logging.DEBUG) logging.info("Starting Generation") data = generate() dates = data.index times = dates.astype(int) // 10**9 values = data.value.values logging.info("Start transformation") def definir_accion(d): if d==1: return 'entrar' elif d==-1: return 'salir' else: return '\'\'' df = pd.DataFrame({"value":values, "timestamp":times}) df["Measure"] = "Personas" df['device'] = 'd1' df['sensor'] = 'reflectivo' df['accion'] = df.value.apply(definir_accion) df['dia'] = dates.day_name() format_to="{}, device={}, sensor={}, accion={} value={}, {}"
def main(): parser = configargparse.ArgParser(default_config_files=['config.ini']) parser.add('--width', required=False, type=int, help='SVG width') parser.add('--height', required=False, type=int, help='SVG height') parser.add('--color_palette', required=False, action='append', help='list of colors for stars') parser.add('--font_size', required=False, type=int, help='font size for planet name') parser.add('--nb_stars', required=False, type=int, help='number of stars') parser.add('--min_size_stars', required=False, type=int, help='minimal star size') parser.add('--max_size_stars', required=False, type=int, help='maximal star size') parser.add('--color_proba', required=False, type=float, help='probability of coloured star') parser.add('--nb_planets', required=False, type=int, help='number of planets') parser.add('--distance_planet', required=False, type=int, help='distance in pixel between each planet') parser.add('--min_size_planet', required=False, type=int, help='minimal planet size') parser.add('--max_size_planet', required=False, type=int, help='maximal planet size') parser.add('--ring_proba', required=False, type=float, help='probability of a ringed planet') parser.add('--min_ring', required=False, type=int, help='minimal number of rings') parser.add('--max_ring', required=False, type=int, help='maximal number of rings') parser.add('--moon_proba', required=False, type=float, help='probability for a planet to have moons') parser.add('--distance_moon', required=False, type=int, help='distance between each moon') parser.add('--min_nb_moons', required=False, type=int, help='minimal number of moon') parser.add('--max_nb_moons', required=False, type=int, help='maximal number of moon') parser.add('--min_size_moon', required=False, type=int, help='minimal size of moon') parser.add('--max_size_moon', required=False, type=int, help='maximal size of moon') parser.add('--id', required=False, help='random seed for generation') parser.add('-f', '--filename', default='solar_system.svg', required=False, help='file name to save') parser.add('-v', '--version', action='version', version=__VERSION__) options = parser.parse_args() #print(options) #print(parser.format_values()) if options.id is None: options.id = utils.generate_id(5, options.nb_planets) #print(options.id) print('Generating planetary system "{}"'.format(options.id)) generation.generate(options)