def parse_args(): parser = argparse.ArgumentParser(description='Options for MVNet') parser.add_argument('--log', type=str, default=None) parser.add_argument('--val_batch_size', type=int, default=4) parser.add_argument('--val_im_batch', type=int, default=4) parser.add_argument('--loglevel', type=str, default='info') parser.add_argument('--val_split_file', type=str, default='data/splits.json') parser.add_argument('--prefetch_threads', type=int, default=2) parser.add_argument('--sleep_time', type=int, default=15) args = process_args(parser) return args
def parse_args(): parser = argparse.ArgumentParser(description='Options for MVNet') parser.add_argument('--log', type=str, default=None) parser.add_argument('--test_batch_size', type=int, default=4) parser.add_argument('--test_im_batch', type=int, default=4) parser.add_argument('--eval_thresh', type=float, nargs='+', default=[0.4]) parser.add_argument('--ckpt', type=str, default=None) parser.add_argument('--split', type=str, default='test') parser.add_argument('--result_file', type=str, default=None) parser.add_argument('--loglevel', type=str, default='info') parser.add_argument( '--test_split_file', type=str, default='data/splits.json') parser.add_argument('--prefetch_threads', type=int, default=2) args = process_args(parser) return args
def main(): args = utils.process_args() distance = utils.distance_between(args['PICKUP'], args['DROPOFF']) #in km time_take = utils.drive_time(distance,args['SPEED']) isLate = utils.late(args['TIME'], time_take) if(isLate): messages.delayed( args['MESSAGE'], args['TOPHONE'], args['FROMPHONE'], args['ORDERID'] ) else: messages.timely(args['ORDERID'])
def pwy(settings): show_diagnostics = True; settings = utils.process_args(settings, show_diagnostics) # OPEN FILE settings['filename'] = UPLOAD_FOLDER+'/'+settings['filename'] UI_instrument_notes = settings['inst1']; UI_onset_threshold = settings['busy']; UI_instrument_chords = settings['inst2']; UI_dynamic_threshold = settings['dyn']; UI_instrument_beats = settings['inst3']; UI_beat_windowSize = settings['window']; #300 msec UI_beat_pattern = settings['pattern']; UI_chord_style = settings['style']; UI_time_signature = settings['timeSig']; y, sr = librosa.load(settings['filename']) # TRACK BEATS onsets, beats, volume_notes, times, tempo, msec_tempo = beatDetection.track_beats(y, sr, UI_onset_threshold, UI_dynamic_threshold, UI_beat_windowSize) #beatDetection.plot_beats_and_onsets(onsets, beats, times, show_diagnostics) //Breaks GUI # PREDICT CHORDS notes, reg_notes, startTimes_notes, endTimes_notes, frameIndex_notes = chordPrediction.get_chords(settings['filename'], times[beats], times) chords, reg_chords, startTimes_chords, endTimes_chords, frameIndex_chords, volume_chords = midiConversion.determine_durations(list(notes), list(reg_notes), list(startTimes_notes), list(endTimes_notes), frameIndex_notes, list(volume_notes)) chordPrediction.print_chords_and_times(chords, startTimes_chords, endTimes_chords, frameIndex_chords, times, show_diagnostics) startTimes_beats, endTimes_beats, volume_beats = beatDetection.alter_beats(startTimes_notes, endTimes_notes, volume_notes, msec_tempo, UI_beat_windowSize, settings['speed']) # NOTES TO MIDI midi_notes = midiConversion.convert_note_to_midi(notes, reg_notes) midi_chords = midiConversion.convert_chord_to_midi(chords, reg_chords, UI_chord_style) midi_beats = midiConversion.convert_beat_to_midi(notes, UI_beat_pattern, UI_time_signature, UI_instrument_beats, reg_notes, settings['speed']) # WRITE MIDI midi_tracks = [midi_notes, midi_chords, midi_beats] startTimes = [startTimes_notes, startTimes_chords, startTimes_beats] endTimes = [endTimes_notes, endTimes_chords, endTimes_beats] UI_instrument = [UI_instrument_notes, UI_instrument_chords, UI_instrument_beats] volumes = [volume_notes, volume_chords, volume_beats] duration = [0]*len(midi_tracks); program = [0]*len(midi_tracks); volume = [0]*len(midi_tracks); for i in range(len(midi_tracks)): duration[i], program[i], volume[i] = midiFileCreation.build_track(UI_instrument[i], midi_tracks[i], startTimes[i], endTimes[i], volumes[i], msec_tempo, UI_dynamic_threshold) midiFileCreation.write_midi_file(settings['filename'], midi_tracks, program, duration, tempo[0], volume) utils.preview(ntpath.basename(settings['filename']), UPLOAD_FOLDER) return render_template('download.html', filename=ntpath.basename(settings['filename'][:-4]), path=UPLOAD_FOLDER)
def parse_args(): parser = argparse.ArgumentParser(description='Options for MVNet') parser.add_argument('--log', type=str, default=None) parser.add_argument('--test_batch_size', type=int, default=4) parser.add_argument('--test_im_batch', type=int, default=4) parser.add_argument('--ckpt', type=str, default=None) parser.add_argument('--split', type=str, default='test') parser.add_argument('--test_views_file', type=str, default=None) parser.add_argument('--result_file', type=str, default=None) parser.add_argument('--loglevel', type=str, default='info') parser.add_argument('--test_split_file', type=str, default='data/splits.json') parser.add_argument('--prefetch_threads', type=int, default=2) parser.add_argument('--savedir', type=str, default=None) parser.add_argument('--vis', action="store_true") args = process_args(parser) return args
def parse_args(): parser = argparse.ArgumentParser(description='Options for MVNet') parser.add_argument('--argsjs', type=str, default=None) parser.add_argument('--custom_training', type=str, default=True) parser.add_argument('--logdir', type=str, default='./log') parser.add_argument('--batch_size', type=int, default=4) parser.add_argument('--loglevel', type=str, default='info') parser.add_argument('--im_batch', type=int, default=4) parser.add_argument('--prefetch_threads', type=int, default=2) parser.add_argument('--im_h', type=int, default=224) parser.add_argument('--im_w', type=int, default=224) parser.add_argument('--im_net', type=str, default='unet', choices=im_nets.keys()) parser.add_argument('--grid_net', type=str, default='unet32', choices=grid_nets.keys()) parser.add_argument('--rnn', type=str, default='gru', choices=conv_rnns.keys()) parser.add_argument('--nvox', type=int, default=32) parser.add_argument('--ray_samples', type=int, default=64) parser.add_argument('--proj_x', type=int, default=4, choices=[4, 8]) parser.add_argument('--norm', type=str, default='IN') parser.add_argument('--ckpt', type=str, default=None) parser.add_argument('--split_file', type=str, default=None) parser.add_argument('--lr', type=float, default=1e-3) parser.add_argument('--decay_rate', type=float, default=1) parser.add_argument('--decay_steps', type=int, default=10000) parser.add_argument('--beta1', type=float, default=0.9) parser.add_argument('--niters', type=int, default=100000) parser.add_argument('--sum_iters', type=int, default=50) parser.add_argument('--ckpt_iters', type=int, default=5000) parser.add_argument('--im_skip', action="store_true") parser.add_argument('--sepup', action="store_true") parser.add_argument('--rng_seed', type=int, default=0) parser.add_argument('--run_trace', action="store_true") args = process_args(parser) return args
bestsaver.save(sess, args.save_dir_best_model, global_step=global_step) tqdm.write("\t done.") finalperf = evalperf val_perf.append((loss, evalperf)) is_start = False loss, _, xyloss, act_loss, traj_class_loss, grid_loss = \ trainer.step(sess, batch) if math.isnan(loss): print("nan loss.") print(grid_loss) sys.exit() if global_step % save_period != 0: saver.save(sess, args.save_dir_model, global_step=global_step) print("best eval on val %s: %s at %s step, final step %s %s is %s" % ( metric, best[metric], best["step"], global_step, metric, finalperf[metric])) if __name__ == "__main__": arguments = parser.parse_args() arguments.is_train = True arguments.is_test = False arguments = utils.process_args(arguments) main(arguments)
print('==> Start training ..') best_auroc = 0. start = time.time() for epoch in range(args.maxepoch): train(epoch, adversarial_loss, pixelwise_loss, encoder, decoder, discriminator, trainloader, optimizer_G, optimizer_D, scheduler_G, scheduler_D, logger, device) auroc, aupr, _ = test(encoder, decoder, testloader, device) print('Epoch: %4d AUROC: %.4f AUPR: %.4f'%(epoch, auroc, aupr)) logger.write('Epoch: %4d AUROC: %.4f AUPR: %.4f \n'%(epoch, auroc, aupr)) state = { 'encoder': encoder.state_dict(), 'decoder': decoder.state_dict(), 'discriminator': discriminator.state_dict(), 'auroc': auroc, 'epoch': epoch} torch.save(state, chpt_name) end = time.time() hours, rem = divmod(end-start, 3600) minutes, seconds = divmod(rem, 60) print('AUROC... ', auroc) print("Elapsed Time: {:0>2}:{:0>2}:{:05.2f}".format(int(hours),int(minutes),seconds)) logger.write("AUROC: %.8f\n"%(auroc)) logger.write("Elapsed Time: {:0>2}:{:0>2}:{:05.2f}\n".format(int(hours),int(minutes),seconds)) if __name__ == '__main__': args = utils.process_args() main(args)
def do_analysis( rdata_load='Periodicity.rda', selected_lengths='27', selected_frames='', hit_mean='10', unique_hit_mean='1', ratio_check='TRUE', min5p='-20', max5p='200', min3p='-200', max3p='20', cap='', plot_title='', plot_lengths='27', rdata_save='Metagene.rda', html_file='Metagene-report.html', output_path=os.getcwd()): """Metagene analysis from saved periodicity R data file. """ run_rscript('suppressMessages(library(riboSeqR))') run_rscript('load("{}")'.format(rdata_load)) logging.debug('fS\n{}\nfCs\n{}\n'.format(R['fS'], R['fCs'])) options = {} for key, value, rtype, rmode in ( ('lengths', selected_lengths, 'int', 'charvector'), ('frames', selected_frames, 'int', 'listvector'), ('hit_mean', hit_mean, 'int', None), ('unique_hit_mean', unique_hit_mean, 'int', None), ('ratio_check', ratio_check, 'bool', None), ('min5p', min5p, 'int', None), ('max5p', max5p, 'int', None), ('min3p', min3p, 'int', None), ('max3p', max3p, 'int', None), ('cap', cap, 'int', None), ('plot_title', plot_title, 'str', 'charvector'), ('plot_lengths', plot_lengths, 'int', 'list')): options[key] = utils.process_args( value, ret_type=rtype, ret_mode=rmode) cmd_args = """fCs, lengths={lengths}, frames={frames}, hitMean={hit_mean}, unqhitMean={unique_hit_mean}, fS=fS""".format(**options) if ratio_check == 'TRUE': cmd_args += ', ratioCheck = TRUE' run_rscript('ffCs <- filterHits({})'.format(cmd_args)) logging.debug("ffCs\n{}\n".format(R['ffCs'])) cds_args = ('coordinates=ffCs@CDS, riboDat=riboDat, min5p={min5p}, ' 'max5p={max5p}, min3p={min3p}, max3p={max3p}'.format(**options)) if options['cap']: cds_args += ', cap={cap}'.format(**options) if options['plot_title']: cds_args += ', main={plot_title}'.format(**options) html = """<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN"> <html> <head> <title>Metagene Analysis - Report</title> </head> <body> """ html += '<h2>Metagene analysis - results</h2>\n<hr>\n' html += ('<p>\nLengths of footprints used in analysis - <strong>' '<code>{0}</code></strong><br>\nLengths of footprints ' 'selected for the plot - <strong><code>{1}</code></strong>' '\n</p>\n'.format(selected_lengths, plot_lengths)) for count, length in enumerate(options['plot_lengths']): count += 1 html += '<h3>Length: {0}</h3>\n'.format(length) plot_file = os.path.join(output_path, 'Metagene-analysis-plot{0}'.format(count)) for fmat in ('pdf', 'png'): if fmat == 'png': cmd = 'png(file="{0}_%1d.png", type="cairo")' else: cmd = 'pdf(file="{0}.pdf")' run_rscript(cmd.format(plot_file)) run_rscript('plotCDS({0},{1})'.format( cds_args, 'lengths={}'.format(length))) run_rscript('dev.off()') for image in sorted( glob.glob('{}*.png'.format(plot_file))): html += '<p><img border="1" src="{0}" alt="{0}"></p>\n'.format( os.path.basename(image)) html += '<p><a href="{0}.pdf">PDF version</a></p>\n'.format( os.path.basename(plot_file)) run_rscript('save("ffCs", "riboDat", "fastaCDS", file="{}", ' 'compress=FALSE)'.format(rdata_save)) logging.debug('\n{:#^80}\n{}\n{:#^80}\n'.format( ' R script for this session ', rscript, ' End R script ')) with open(os.path.join(output_path, 'metagene.R'), 'w') as r: r.write(rscript) html += ('<h4>R script for this session</h4>\n' '<p><a href="metagene.R">metagene.R</a></p>\n' '<p>Next step: <em>Plot Ribosome profile</em></p>\n' '</body>\n</html>\n') with open(html_file, 'w') as f: f.write(html)
def parse_args(): # Parameters for both testing and training parser = argparse.ArgumentParser(description='Options for SilhoNet') parser.add_argument('--mode', required=True, type=str, choices=MODE_LIST, help='mode for running network') parser.add_argument('--argsjs', type=str, default=None, help='path to json args file') parser.add_argument( '--logdir', type=str, default='./log', help='logging directory. Automatically appends ' + '$DATE/train/ to path for training when not running from a checkpoint') parser.add_argument('--loglevel', type=str, default='info', help='logging level: error, info, warn, debug') parser.add_argument('--batch_size', type=int, default=4, help='input image batch size') parser.add_argument( '--mdl_im_batch', type=int, default=12, help= 'number of rendered model images per ROI detection for silhouette prediction' ) parser.add_argument( '--prefetch_threads', type=int, default=2, help='number of threads for processing dataset into queue') parser.add_argument('--prefetch_qsize', type=int, default=32, help='maximum size of input queue') parser.add_argument('--mdl_im_h', type=int, default=224, help='height of model input image') parser.add_argument('--mdl_im_w', type=int, default=224, help='width of model input image') parser.add_argument('--im_h', type=int, default=480, help='height of input image') parser.add_argument('--im_w', type=int, default=640, help='width of input image') parser.add_argument( '--roi_size', type=int, default=64, help='size of output silhouette masks. Also size of resized ROIs') parser.add_argument('--roi_area_thresh', type=float, default=10, help='minimum area of detected ROI') parser.add_argument( '--roi_fill_thresh', type=float, default=0.01, help='minimum percentage of ROI area where detected object is visible') parser.add_argument( '--norm', type=str, default='IN', help='layer normalization: Instance Norm: IN, Batch Norm: BN., or None' ) parser.add_argument('--ckpt', type=str, default=None, help='checkpoint') parser.add_argument('--seg_ckpt', type=str, default=None, help='heckpoint for silhouette prediction stage only') parser.add_argument('--gpus', type=str, default="0", help='GPUs visible to Tensorflow') parser.add_argument('--shuffle', action="store_true", help='shuffle dataset') parser.add_argument( '--num_classes', type=int, default=22, help='number of classes in dataset including background class') parser.add_argument( '--threshold_mask', action="store_false", help='threshold probability silhouette predictions into binary masks') parser.add_argument('--im_net', type=str, default='vgg16', choices=im_nets.keys(), help='feature extraction network') parser.add_argument('--seg_net', type=str, default='stack', choices=seg_nets.keys(), help='silhouette prediction network') parser.add_argument('--quat_net', type=str, default='quat_res', choices=quat_nets.keys(), help='3D pose regression network') parser.add_argument('--quat_loss', type=str, default='log_dist', choices=quat_losses.keys(), help='oss function for 3D pose regression') # Parameters for training only parser.add_argument('--lr', type=float, default=1e-3, help='initial learning rate') parser.add_argument('--decay_rate', type=float, default=1, help='learning rate decay rate') parser.add_argument('--decay_steps', type=int, default=10000, help='period to apply learning rate decay') parser.add_argument('--niters', type=int, default=10000, help='iterations to train') parser.add_argument('--niters_val', type=int, default=1000, help='period of iterations to run validation') parser.add_argument('--sum_iters', type=int, default=50, help='period of iterations to run summery') parser.add_argument('--ckpt_iters', type=int, default=5000, help='period of iterations to save checkpoint') parser.add_argument( '--val_iters', type=int, default=100, help='iterations over which to calculate validation loss') parser.add_argument('--rng_seed', type=int, default=0, help='random seed') parser.add_argument( '--nepochs', type=int, default=None, help= 'number of epochs to train. If None, network trains for niters. If not None, netowrk trains ' + 'for which comes first, niters or nepochs') parser.add_argument('--keep_prob', type=float, default=0.5, help='keep probability for dropout') parser.add_argument('--run_val', action="store_true", help='run validation during training') parser.add_argument('--vis_gradients', action="store_true", help='visualize layer gradients during training') parser.add_argument('--run_trace', action="store_true", help='run trace on network termination') parser.add_argument( '--use_pretrained', action="store_true", help= 'use pretrained imagenet weights for initializing VGG16 backbone network' ) # Parameters for testing only parser.add_argument( '--eval_thresh', type=float, nargs='+', help= 'list of threshold values at which to evaluate test performance. For silhouette ' + 'prediction, values are used to threshold probability masks into binary masks. For 3D pose prediction, threshold values are maximum angle errors in degrees.' ) parser.add_argument('--split', type=str, default='keyframe', help='image set to evaluate.') args = process_args(parser) return args
def simulate(): args = utils.process_args(vars(utils.parser.parse_args())) print(args) Ns, densities, solvers, budgets, nsim, costType, verbose, loadPrev, standardize = args result_dict = [] result_colnums_names = [ 'N', 'Density', 'Solver', 'Budget', 'Cost', 'Time_avg', 'Time_sd', 'Sol_avg', 'Sol_sd' ] total_simulations = utils.getTotalSimulation( [Ns, densities, budgets, costType]) total_simulations *= nsim progress = 0 loadPrev_outer = loadPrev try: for N in Ns: for density in densities: for budget in budgets: for cost in costType: sols = np.zeros((nsim, len(solvers))) times = np.zeros((nsim, len(solvers))) if loadPrev: try: print( "\nLoading previously saved test instances..." ) try: update_cost = False sims, new_budget = utils.load_saved_instance( N, density, budget, cost) except: print("Need to update costs...") update_cost = True sims, new_budget = utils.load_saved_instance( N, density, budget, None) except: print( "Failed to load... Creating new instances..." ) sims = [] loadPrev = False else: print("Creating new instances...") sims = [] for sim in range(nsim): if loadPrev and sim < len(sims): changed_instance = False G, B, U, C = sims[sim] if update_cost: print("\nUpdating costs...") C = generate_cost(G, cost) sims[sim] = G, B, U, C changed_instance = True if new_budget: print( "\nReusing test cases but with different budget..." ) B = 5 * G.order() * budget else: changed_instance = True G = generate_random_dag(N, density) B = 5 * N * budget U = generate_utility(G) C = generate_cost(G, cost) sims.append((G, B, U, C)) for solver_index in range(len(solvers)): solver = solvers[solver_index] if solver == "ilp": if cost == "monotone": C_ilp = C[0] s_time, s_sol = ilp_time(G, C[0], B, U) elif cost == "add": s_time, s_sol = ilp_time(G, C, B, U) elif solver == "bf": s_time, s_sol = brute_force_time( G, C, B, U, cost) elif solver == "gd": s_time, s_sol = greedy_time( G, C, B, U, cost) elif solver == "gd2": s_time, s_sol = greedy2_time( G, C, B, U, cost) sols[sim, solver_index] = s_sol times[sim, solver_index] = s_time progress += 1 if verbose: utils.update_progress(progress / total_simulations) if changed_instance or new_budget: print("\nTest instances saved for future use.") utils.save_instance(sims, N, density, budget, cost) result_dict.extend( utils.generate_result_dict(N, density, budget, cost, solvers, sols, times, standardize)) loadPrev = loadPrev_outer utils.export(result_colnums_names, result_dict) except KeyboardInterrupt: utils.export(result_colnums_names, result_dict)
def find_periodicity( rdata_load='Prepare.rda', start_codons='ATG', stop_codons='TAG,TAA,TGA', fasta_file=None, include_lengths='25:30', analyze_plot_lengths='26:30', text_legend='Frame 0, Frame 1, Frame 2', rdata_save='Periodicity.rda', html_file='Periodicity-report.html', output_path=os.getcwd()): """Plot triplet periodicity from prepared R data file. """ logging.debug('{}'.format(R('sessionInfo()'))) cmd = 'suppressMessages(library(riboSeqR))' run_rscript(cmd) logging.debug('Loading saved R data file') cmd = 'load("{}")'.format(rdata_load) run_rscript(cmd) # R("""options(showTailLines=Inf)""") starts, stops = (utils.process_args(start_codons, ret_mode='charvector'), utils.process_args(stop_codons, ret_mode='charvector')) cmd = ('fastaCDS <- findCDS(fastaFile={0!r}, startCodon={1}, ' 'stopCodon={2})'.format(fasta_file, starts, stops)) run_rscript(cmd) logging.debug('Potential coding sequences using start codon (ATG) and ' 'stop codons TAG, TAA, TGA') logging.debug('{}\n'.format(R['fastaCDS'])) cmd = """fCs <- frameCounting(riboDat, fastaCDS, lengths={0}) fS <- readingFrame(rC=fCs, lengths={1}); fS""".\ format(include_lengths, analyze_plot_lengths) run_rscript(cmd) logging.debug('riboDat \n{}\n'.format(R['riboDat'])) logging.debug('fCs\n{0}\n'.format(R['fCs'])) logging.debug('Reading frames for each n-mer\n{}'.format(R['fS'])) legend = utils.process_args(text_legend, ret_mode='charvector') for fmat in ('pdf', 'png'): if fmat == 'png': cmd = '{0}(file="{1}", type="cairo")' else: cmd = '{0}(file="{1}")' run_rscript(cmd.format(fmat, os.path.join( output_path, '{0}.{1}'.format('Periodicity-plot', fmat)))) run_rscript('plotFS(fS, legend.text = {0})'.format(legend)) run_rscript('dev.off()') run_rscript('save("fCs", "fS", "riboDat", "fastaCDS", ' 'file="{}", compress=FALSE)'.format(rdata_save)) html = '<h2>Triplet periodicity - results</h2><hr>' html += ('<h4>Results of reading frame analysis</h4>' '<pre>{}</pre><br>'.format(R['fS'])) html += ('<p>Lengths used for reading frame analysis - <code>{0}</code>' '<br>Lengths selected for the plot - <code>{1}</code>' '</p>'.format(include_lengths, analyze_plot_lengths)) html += ('<p><img src="Periodicity-plot.png" border="1" ' 'alt="Triplet periodicity plot" />' '<br><a href="Periodicity-plot.pdf">PDF version</a></p>') logging.debug('\n{:#^80}\n{}\n{:#^80}\n'.format( ' R script for this session ', rscript, ' End R script ')) with open(os.path.join(output_path, 'periodicity.R'), 'w') as r: r.write(rscript) html += ('<h4>R script for this session</h4>' '<p><a href="periodicity.R">periodicity.R</a></p>' '<p>Next step: <em>Metagene analysis</em></p>') with open(html_file, 'w') as f: f.write(html)
def plot_transcript( rdata_load="Metagene.rda", transcript_name="", transcript_length="27", transcript_cap="", html_file="Plot-ribosome-profile.html", output_path=os.getcwd(), ): """Plot ribosome profile for a given transcript. """ options = {} for key, value, rtype, rmode in ( ("transcript_name", transcript_name, "str", None), ("transcript_length", transcript_length, "int", "charvector"), ("transcript_cap", transcript_cap, "int", None), ): options[key] = utils.process_args(value, ret_type=rtype, ret_mode=rmode) run_rscript("suppressMessages(library(riboSeqR))") run_rscript('load("{}")'.format(rdata_load)) html = """<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN"> <html> <head> <title>Ribosome Profile Plot - Report</title> </head> <body> """ html += "<h2>Plot ribosome profile - results</h2>\n<hr>\n" if len(transcript_name): cmd_args = ( '"{transcript_name}", main="{transcript_name}",' "coordinates=ffCs@CDS, riboData=riboDat," "length={transcript_length}".format(**options) ) if transcript_cap: cmd_args += ", cap={transcript_cap}".format(**options) plot_file = os.path.join(output_path, "Ribosome-profile-plot") for fmat in ("pdf", "png"): if fmat == "png": cmd = 'png(file="{}_%1d.png", type="cairo")'.format(plot_file) else: cmd = 'pdf(file="{}.pdf")'.format(plot_file) run_rscript(cmd) cmd = "plotTranscript({})".format(cmd_args) run_rscript(cmd) run_rscript("dev.off()") html += "<p>Selected ribosome footprint length: " "<strong>{0}</strong>\n".format(transcript_length) for image in sorted(glob.glob("{}_*.png".format(plot_file))): html += '<p><img border="1" src="{0}" alt="{0}"></p>\n'.format(os.path.basename(image)) html += '<p><a href="Ribosome-profile-plot.pdf">PDF version</a></p>\n' else: msg = "No transcript name was provided. Did not generate plot." html += "<p>{}</p>".format(msg) logging.debug(msg) logging.debug("\n{:#^80}\n{}\n{:#^80}\n".format(" R script for this session ", rscript, " End R script ")) with open(os.path.join(output_path, "ribosome-profile.R"), "w") as r: r.write(rscript) html += ( "<h4>R script for this session</h4>\n" '<p><a href="ribosome-profile.R">ribosome-profile.R</a></p>\n' "</body>\n</html>\n" ) with open(html_file, "w") as f: f.write(html)
starttime = datetime.now() # AllChem.GetMorganFingerprint(reference,2) # FingerprintMols.FingerprintMol(reference) # FingerprintMols.GetRDKFingerprint Fingerprint = FingerprintMols.FingerprintMol reference = Chem.MolFromSmiles(args.reference_mol) fp_reference = Fingerprint(reference) ref = fp_reference print(f"Fingerprint length: {ref.GetNumBits()}") _cwd, inpath, outpath, inputs = process_args(args) # Not cached: def process_row_str(row: str, ref=ref): """ Inputs: row: str First two tab-seperated entries of string are the SMILES and ID of the row. Return: str: If the tanimoto threshold is passed, return the smile, the id and the tanimoto coef. in smiles-format: "SMILES\tID\tTANIMOTOCOEF" """
def generate_ribodata(ribo_files='', rna_files='', replicate_names='', seqnames='', rdata_save='Prepare.rda', sam_format=True, html_file='Prepare-report.html', output_path=os.getcwd()): """Prepares Ribo and RNA seq data in the format required for riboSeqR. Calls the readRibodata function of riboSeqR and saves the result objects in an R data file which can be used as input for the next step. """ input_ribo_files = utils.process_args(ribo_files, ret_mode='list') logging.debug('Found {} Ribo-Seq files'.format(len(input_ribo_files))) logging.debug(input_ribo_files) input_rna_files = [] if rna_files: input_rna_files = utils.process_args(rna_files, ret_mode='list') logging.debug('Found {} RNA-Seq files'.format(len(input_rna_files))) logging.debug(input_rna_files) replicates = utils.process_args(replicate_names, ret_mode='charvector') logging.debug('Replicates: {}\n'.format(replicates)) if sam_format: ribo_seq_files = batch_process(input_ribo_files, 'riboseq', output_path) else: ribo_seq_files = input_ribo_files html = '<h2>Prepare riboSeqR input - results</h2><hr>' if len(ribo_seq_files): html += '<h4>Generated riboSeqR format input files ' \ '<em>(RiboSeq)</em></h4><p>' for fname in ribo_seq_files: html += '<a href="{0}">{0}</a><br>'.format( os.path.basename(fname)) html += '</p>' rna_seq_files = [] if len(input_rna_files): if sam_format: rna_seq_files = batch_process( input_rna_files, 'rnaseq', output_path) else: rna_seq_files = input_rna_files if len(rna_seq_files): html += ('<h4>Generated riboSeqR format input files ' '<em>(RNASeq)</em></h4><p>') for fname in rna_seq_files: html += '<a href="{0}">{0}</a><br>'.format( os.path.basename(fname)) html += '</p>' input_seqnames = utils.process_args(seqnames, ret_mode='charvector') options = {'ribo_seq_files': 'c({})'.format(str(ribo_seq_files)[1:-1]), 'rna_seq_files': 'c({})'.format(str(rna_seq_files)[1:-1]), 'input_replicates': replicates, 'input_seqnames': input_seqnames} logging.debug('{}'.format(R('sessionInfo()'))) script = '' cmd = 'suppressMessages(library(riboSeqR))' run_rscript(cmd) script += '{}\n'.format(cmd) if len(rna_seq_files): cmd_args = ('riboFiles={ribo_seq_files}, ' 'rnaFiles={rna_seq_files}'.format(**options)) else: cmd_args = 'riboFiles={ribo_seq_files}'.format(**options) if input_seqnames: cmd_args += ', seqnames={input_seqnames}'.format(**options) if replicates: cmd_args += ', replicates={input_replicates}'.format(**options) else: cmd_args += ', replicates=c("")' cmd = 'riboDat <- readRibodata({0})'.format(cmd_args) run_rscript(cmd) script += '{}\n'.format(cmd) ribo_data = R['riboDat'] logging.debug('riboDat \n{}\n'.format(ribo_data)) cmd = 'save("riboDat", file="{}", compress=FALSE)'.format(rdata_save) run_rscript(cmd) script += '{}\n'.format(cmd) msg = '\n{:#^80}\n{}\n{:#^80}\n'.format( ' R script for this session ', script, ' End R script ') logging.debug(msg) with open(os.path.join(output_path, 'prepare.R'), 'w') as r: r.write(script) html += ('<h4>R script for this session</h4>' '<p><a href="prepare.R">prepare.R</a></p>' '<p>Next step: <em>Triplet periodicity</em></p>') with open(html_file, 'w') as f: f.write(html) return ribo_data