def Q1_3(): hashtags = [ '#gohawks', '#nfl', '#sb49', '#gopatriots', '#patriots', '#superbowl' ] for tag in hashtags: X = load_obj(tag + '_Q13')[:-1, :] y = load_obj(tag + '_numTweetsInHour')[1:] model = stats_api.OLS(y, X) res = model.fit() y_pred = res.predict(X) y_resid = y - y_pred sum_err = pow(y_resid, 2) sum_err = np.sum(sum_err) print(res.summary()) # print(sum_err) rmse = sqrt(sum_err / len(y_resid)) print('%s has RMSE of %.3f' % (tag, rmse)) features = [ 'mentionCount', 'rankScore', 'passitivity', 'co-occurrence_of_tags', 'unique_author' ] for i in [0, 2, 3]: x_plt = X[:, i] ys = [[y, 'Predictant']] x_label = features[i] y_label = 'number of tweets for next hour' title = tag + ', ' + x_label make_plot(x_plt, ys, scatter=True, xlabel=x_label, ylabel=y_label, title=title) print('=============================')
def Q3(): import nltk nltk.download('vader_lexicon') from nltk.sentiment.vader import SentimentIntensityAnalyzer sid = SentimentIntensityAnalyzer() hashtags = ['#gohawks', '#gopatriots', '#patriots'] for tag in hashtags: with open(fileLocation(tag), encoding="utf8") as f: print('tag: ', tag) firstTs = FIRST_TS[tag] firstTs = firstTs // 3600 * 3600 lastTs = LAST_TS[tag] totalHours = tsDiffHour(firstTs, lastTs) + 1 neg_sentiments = [0] * totalHours pos_sentiments = [0] * totalHours neu_sentiments = [0] * totalHours hourCount = [0] * totalHours tweets = f.readlines() for tweet in tweets: t = json.loads(tweet) ts = t['citation_date'] date = datetime.datetime.fromtimestamp(t['citation_date']) title = t['title'] hourDiff = tsDiffHour(firstTs, ts) hourCount[hourDiff] += 1 ss = sid.polarity_scores(title) h_r = hourCount[hourDiff] neg_sentiments[hourDiff] = (neg_sentiments[hourDiff] * (h_r - 1) + ss['neg']) / h_r pos_sentiments[hourDiff] = (pos_sentiments[hourDiff] * (h_r - 1) + ss['pos']) / h_r neu_sentiments[hourDiff] = (neu_sentiments[hourDiff] * (h_r - 1) + ss['neu']) / h_r # plot sentiments vs time (hour from beginning) ys = [[neg_sentiments, 'negative sentiment'], [pos_sentiments, 'positive sentiment']] x_plt = range(0, totalHours) x_label = 'time' y_label = 'sentiment' title = 'sentiment vs time for ' + tag make_plot(x_plt, ys, scatter=False, xlabel=x_label, ylabel=y_label, title=title)
def evaluate(self, predicted_adj_mat: np.array, make_plots: bool = True): """ Evaluate the performance of the link prediction algorithm with the generated graph fill the :return: """ true_edges, false_edges = [], [] y_score = [] for i, (u, v) in enumerate(self.test_edges): score = predicted_adj_mat[u, v] y_score.append(score) # if there's an edge - it'll be 1 or close to 1 true_edges.append(1) # actual edge for i, (u, v) in enumerate(self.test_edges_false): score = predicted_adj_mat[u, v] y_score.append(score) # the numbers should be 0 or close to 0 false_edges.append(0) # actual non-edge y_true = true_edges + false_edges assert len(y_score) == len(y_true), f'Lengths of y_score: {len(y_score)!r} y_true: {len(y_true)!r} not equal' fpr, tpr, _ = roc_curve(y_true=y_true, y_score=y_score) auroc = roc_auc_score(y_true=y_true, y_score=y_score) prec, recall, _ = precision_recall_curve(y_true=y_true, probas_pred=y_score) aupr = auc(recall, prec, reorder=True) self.performance['AUROC'] = auroc self.performance['AUPR'] = aupr self.performance['AP'] = average_precision_score(y_true=y_true, y_score=y_score) # self.performance['ACC'] = accuracy_score(y_true=y_true, y_pred=y_score) # self.performance['F1'] = f1_score(y_true=y_true, y_pred=y_score) if make_plots: fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1) make_plot(x=fpr, y=tpr, xlabel='False Positive Rate', ylabel='True Positive Rate', c='darkorange', label=f'AUROC {round(auroc, 2)}', title=f'{self.method!r} {self.dataset!r} ROC curve', ax=ax1) make_plot(x=recall, y=prec, xlabel='Recall', ylabel='Precision', c='darkorange', label=f'AUPR {round(aupr, 2)}', title=f'{self.method!r} {self.dataset!r} PR curve', ax=ax2, kind='pr') plt.show() return
def plot(search): checkin_date = search.checkin_date.data star_rating = search.star_rating.data predictions = estimator.predict(checkin_date, star_rating) plot = make_plot(predictions) # Embed plot into HTML via Flask Render script, div = components(plot) return render_template("index.html", script=script, div=div, form=search)
def train_vae(model, train_iter, test_iter, num_epochs, test_interval, save_model=False): logger.info('Training VAE begins.') all_loss = [] optimizer = torch.optim.Adam(model.parameters(), lr=LR_VAE) #, betas=(beta1, 0.999)) fixed_noise = torch.randn(size=(32, N_LATENT), device=dev) test_vae(model, test_iter, fixed_noise, 0) for epoch in range(1, num_epochs+1): model.train() epoch_loss = .0 n_batches = 0 n_images = 0 start = time.time() for batch, data in enumerate(train_iter): X = data[0].to(dev) n_batches += 1 n_images += X.shape[0] optimizer.zero_grad() y, mu, logvar = model(X) loss = model.loss_compute(X, y, mu, logvar) loss.backward() optimizer.step() epoch_loss += loss.item() * X.shape[0] epoch_loss /= len(train_iter.dataset) all_loss.append(epoch_loss) logger.info('Epoch {}, Loss: {:.4f}, ELBO: {:.4f}, Time: {:.4f}, Img processed: {}'.format( epoch, epoch_loss, -epoch_loss, time.time()-start, len(train_iter.dataset))) if epoch % test_interval == 0: test_vae(model, test_iter, fixed_noise, epoch) if save_model: utils.model_save(model, 'P3_VAE.pt') utils.make_plot(all_loss, save_name='P3_vae_learning_curve.png', title='VAE Learning Curve', tickets=['Epochs', 'Loss']) return all_loss
def index(): # Determine the selected feature current_feature_name = request.args.get("feature_name") search = request.args.get("search") date = request.args.get("date") if date: start_date = pd.to_datetime(date) end_date = start_date + pd.DateOffset(months=1) - pd.DateOffset(days=1) else: start_date = pd.to_datetime( pd.datetime.now().strftime("%Y-%m")) # - pd.DateOffset(months=1) end_date = start_date + pd.DateOffset(months=1) - pd.DateOffset(days=1) start_date_str = start_date.strftime("%m/%Y") if search == None: return render_template("index.html", ticker_exists=False, search=search, feature_names=feature_names, current_feature_name=current_feature_name, start_date=start_date_str) data = get_data(search, start_date, end_date) if data.empty: #search = None return render_template("index.html", ticker_exists=False, search=search, feature_names=feature_names, current_feature_name=current_feature_name, start_date=start_date_str) plot = make_plot(data, column=current_feature_name, ticker=search) # Embed plot into HTML via Flask Render script, div = components(plot) print(feature_names) return render_template("index.html", script=script, div=div, ticker_exists=True, search=search, feature_names=feature_names, current_feature_name=current_feature_name, start_date=start_date_str)
def bokeh(): quandl.ApiConfig.api_key = "xMwhitoyQ___b7Mb9pAt" data_dict ={} stock_list= ['ATVI','AAPL','GOOG','CSCO'] for i in stock_list: data_dict[i] = quandl.get("WIKI/%s" %i) useful_cols = ['Open','High','Low','Close'] for i in data_dict.keys(): data_dict[i] = data_dict[i][useful_cols].reset_index() current_stock = 'AAPL' select_stock = Select(title="stock selection", value=current_stock, options=stock_list) source = make_dataset(data_dict,current_stock) plot = make_plot(source) select_stock.on_change('value', update_plot) controls = column(select_stock) full = row(plot,controls) curdoc().add_root(full) curdoc().title = 'Stock demo' # grab the static resources js_resources = INLINE.render_js() css_resources = INLINE.render_css() # render template script, div = components(full) html = render_template( 'index.html', plot_script=script, plot_div=div, js_resources=js_resources, css_resources=css_resources, ) return encode_utf8(html)
def main(device=torch.device('cuda:0')): # CLI arguments parser = arg.ArgumentParser( description='We all know what we are doing. Fighting!') parser.add_argument("--datasize", "-d", default="small", type=str, help="data size you want to use, small, medium, total") # Parsing args = parser.parse_args() # Data loaders datasize = args.datasize pathname = "data/nyu.zip" tr_loader, va_loader, te_loader = getTrainingValidationTestingData( datasize, pathname, batch_size=config("unet.batch_size")) # Model model = Net() # TODO: define loss function, and optimizer learning_rate = utils.config("unet.learning_rate") criterion = DepthLoss(0.1) optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) number_of_epoches = 10 # # print("Number of float-valued parameters:", util.count_parameters(model)) # Attempts to restore the latest checkpoint if exists print("Loading unet...") model, start_epoch, stats = utils.restore_checkpoint( model, utils.config("unet.checkpoint")) # axes = utils.make_training_plot() # Evaluate the randomly initialized model # evaluate_epoch( # axes, tr_loader, va_loader, te_loader, model, criterion, start_epoch, stats # ) # loss = criterion() # initial val loss for early stopping # prev_val_loss = stats[0][1] running_va_loss = [] running_va_acc = [] running_tr_loss = [] running_tr_acc = [] # TODO: define patience for early stopping # patience = 1 # curr_patience = 0 # tr_acc, tr_loss = utils.evaluate_model(model, tr_loader, device) acc, loss = utils.evaluate_model(model, va_loader, device) running_va_acc.append(acc) running_va_loss.append(loss) running_tr_acc.append(tr_acc) running_tr_loss.append(tr_loss) # Loop over the entire dataset multiple times # for epoch in range(start_epoch, config('cnn.num_epochs')): epoch = start_epoch # while curr_patience < patience: while epoch < number_of_epoches: # Train model utils.train_epoch(tr_loader, model, criterion, optimizer) tr_acc, tr_loss = utils.evaluate_model(model, tr_loader, device) va_acc, va_loss = utils.evaluate_model(model, va_loader, device) running_va_acc.append(va_acc) running_va_loss.append(va_loss) running_tr_acc.append(tr_acc) running_tr_loss.append(tr_loss) # Evaluate model # evaluate_epoch( # axes, tr_loader, va_loader, te_loader, model, criterion, epoch + 1, stats # ) # Save model parameters utils.save_checkpoint(model, epoch + 1, utils.config("unet.checkpoint"), stats) # update early stopping parameters """ curr_patience, prev_val_loss = early_stopping( stats, curr_patience, prev_val_loss ) """ epoch += 1 print("Finished Training") # Save figure and keep plot open # utils.save_training_plot() # utils.hold_training_plot() utils.make_plot(running_tr_loss, running_tr_acc, running_va_loss, running_va_acc)
def main(device, tr_loader, va_loader, te_loader, modelSelection): """Train CNN and show training plots.""" # Model if modelSelection.lower() == 'res50': model = Res50() elif modelSelection.lower() == 'dense121': model = Dense121() elif modelSelection.lower() == 'dense161': model = Dense161() elif modelSelection.lower() == 'mobv2': model = Mob_v2() elif modelSelection.lower() == 'dense169': model = Dense169() elif modelSelection.lower() == 'mob': model = Net() elif modelSelection.lower() == 'squeeze': model = Squeeze() else: assert False, 'Wrong type of model selection string!' model = model.to(device) # TODO: define loss function, and optimizer learning_rate = utils.config(modelSelection + ".learning_rate") criterion = DepthLoss(0.1).to(device) optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) number_of_epoches = 10 # # Attempts to restore the latest checkpoint if exists print("Loading unet...") model, start_epoch, stats = utils.restore_checkpoint( model, utils.config(modelSelection + ".checkpoint")) running_va_loss = [] if 'va_loss' not in stats else stats['va_loss'] running_va_acc = [] if 'va_err' not in stats else stats['va_err'] running_tr_loss = [] if 'tr_loss' not in stats else stats['tr_loss'] running_tr_acc = [] if 'tr_err' not in stats else stats['tr_err'] tr_acc, tr_loss = utils.evaluate_model(model, tr_loader, device) acc, loss = utils.evaluate_model(model, va_loader, device) running_va_acc.append(acc) running_va_loss.append(loss) running_tr_acc.append(tr_acc) running_tr_loss.append(tr_loss) stats = { 'va_err': running_va_acc, 'va_loss': running_va_loss, 'tr_err': running_tr_acc, 'tr_loss': running_tr_loss, } # Loop over the entire dataset multiple times # for epoch in range(start_epoch, config('cnn.num_epochs')): epoch = start_epoch # while curr_patience < patience: while epoch < number_of_epoches: # Train model utils.train_epoch(device, tr_loader, model, criterion, optimizer) # Save checkpoint utils.save_checkpoint(model, epoch + 1, utils.config(modelSelection + ".checkpoint"), stats) # Evaluate model tr_acc, tr_loss = utils.evaluate_model(model, tr_loader, device) va_acc, va_loss = utils.evaluate_model(model, va_loader, device) running_va_acc.append(va_acc) running_va_loss.append(va_loss) running_tr_acc.append(tr_acc) running_tr_loss.append(tr_loss) epoch += 1 print("Finished Training") utils.make_plot(running_tr_loss, running_tr_acc, running_va_loss, running_va_acc)
def main(device, tr_loader, va_loader, te_loader, modelSelection): """Train CNN and show training plots.""" # CLI arguments # parser = arg.ArgumentParser(description='We all know what we are doing. Fighting!') # parser.add_argument("--datasize", "-d", default="small", type=str, # help="data size you want to use, small, medium, total") # Parsing # args = parser.parse_args() # Data loaders # datasize = args.datasize # Model if modelSelection.lower() == 'res50': model = Res50() elif modelSelection.lower() == 'dense121': model = Dense121() elif modelSelection.lower() == 'mobv2': model = Mob_v2() elif modelSelection.lower() == 'dense169': model = Dense169() elif modelSelection.lower() == 'mob': model = Net() elif modelSelection.lower() == 'squeeze': model = Squeeze() else: assert False, 'Wrong type of model selection string!' # Model # model = Net() # model = Squeeze() model = model.to(device) # TODO: define loss function, and optimizer learning_rate = utils.config(modelSelection + ".learning_rate") criterion = DepthLoss(0.1).to(device) optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) number_of_epoches = 10 # # Attempts to restore the latest checkpoint if exists print("Loading unet...") model, start_epoch, stats = utils.restore_checkpoint( model, utils.config(modelSelection + ".checkpoint")) running_va_loss = [] if 'va_loss' not in stats else stats['va_loss'] running_va_acc = [] if 'va_err' not in stats else stats['va_err'] running_tr_loss = [] if 'tr_loss' not in stats else stats['tr_loss'] running_tr_acc = [] if 'tr_err' not in stats else stats['tr_err'] tr_acc, tr_loss = utils.evaluate_model(model, tr_loader, device) acc, loss = utils.evaluate_model(model, va_loader, device) running_va_acc.append(acc) running_va_loss.append(loss) running_tr_acc.append(tr_acc) running_tr_loss.append(tr_loss) stats = { 'va_err': running_va_acc, 'va_loss': running_va_loss, 'tr_err': running_tr_acc, 'tr_loss': running_tr_loss, # 'num_of_epoch': 0 } # Loop over the entire dataset multiple times # for epoch in range(start_epoch, config('cnn.num_epochs')): epoch = start_epoch # while curr_patience < patience: while epoch < number_of_epoches: # Train model utils.train_epoch(device, tr_loader, model, criterion, optimizer) # Save checkpoint utils.save_checkpoint(model, epoch + 1, utils.config(modelSelection + ".checkpoint"), stats) # Evaluate model tr_acc, tr_loss = utils.evaluate_model(model, tr_loader, device) va_acc, va_loss = utils.evaluate_model(model, va_loader, device) running_va_acc.append(va_acc) running_va_loss.append(va_loss) running_tr_acc.append(tr_acc) running_tr_loss.append(tr_loss) epoch += 1 print("Finished Training") utils.make_plot(running_tr_loss, running_tr_acc, running_va_loss, running_va_acc)
PATH = sys.argv[1] if len(sys.argv) == 2 else str(Path(__file__).parent.absolute())[:-3]+'imgs/' NAME = 'huge' fst = Param( CLUSTERS = 12**2, CLUST_SIDE_LEN = 7, DAYS = 100, INFECTION_TIME = 20, DEATH_RATE = 0.4, INFECT_RATE = 0.3, MIGRATIONS_PER_DAY = 100, FEAR_RATE = 0.4, HEALTHCARE_CAPACITY = 2500 ) start = time() cumulative, active, healed, dead, migrations, real_mig = run_simulation(fst, PATH) print('time elapsed:', time() - start, flush=True) make_gif(PATH, NAME) # plt.plot(range(len(migrations)), migrations, label='migrations', color='blue') plt.plot(range(len(real_mig)), real_mig, label='migrations', color='blue', ls=':') make_plot(fst, cumulative, active, healed, dead, label='', color='red') plt.savefig(PATH+NAME+'.png') print("The visualization of the simulation is available at './imgs/'", flush=True)
logging.info("Eval metrics for dataset {}".format(','.join(datasets_test))) test_logs = [] logging.info("Restoring parameters from {}".format(restore_path)) utils.load_checkpoint(restore_path, model, meta_optimizer) # train_metrics = evaluate(model, loss_fn, meta_train_classes, # task_lr, task_type, metrics, params, args, # 'train') test_metrics = evaluate(model, loss_fn, meta_test_classes, task_lr, task_type, metrics, params, args, 'test') test_logs.append(test_metrics) save_dir = "experiments/emodb_ravdess_savee_iemocap/shemo" if not os.path.exists(save_dir): os.makedirs(save_dir) with open(os.path.join(save_dir, "shemo_eval.pkl"), 'wb') as f: pickle.dump(test_logs, f) plt_x = [x / 10.0 for x in supports] plt_y = [t['f1_score'] for t in test_logs] with open(os.path.join(save_dir, "shemo_eval.txt"), 'w') as f: f.write("\n".join(map(str, plt_y))) print(plt_y) utils.make_plot(save_dir, plt_x, plt_y, 'shemo')
def train_gan(model, train_iter, test_iter, num_epochs, G_update_iterval, test_interval, save_model=False): all_loss_g = [] all_loss_d = [] all_wd = [] fixed_noise = torch.randn(64, N_LATENT).to(dev) optimizerG = torch.optim.Adam(model.generator.parameters(), lr=LR_G, betas=(beta1, 0.999)) optimizerD = torch.optim.Adam(model.discriminator.parameters(), lr=LR_D, betas=(beta1, 0.999)) for epoch in range(1, num_epochs+1): model.train() epoch_ls_g = [] epoch_ls_d = [] epoch_wd = [] epoch_gp = [] start = time.time() for batch, (X, y) in enumerate(train_iter): # 1. update discriminator optimizerD.zero_grad() X = X.to(dev) noise = torch.randn(size=(X.shape[0], N_LATENT)).to(dev) X_fake = model.generator(noise) outp_real = model.discriminator(X).view(-1) outp_fake = model.discriminator(X_fake.detach()).view(-1) gradient_penalty = LAMBDA * model.gradient_penalty(X.data, X_fake.data) wd_distance = outp_real.mean() - outp_fake.mean() d_loss = -wd_distance + gradient_penalty d_loss.backward() optimizerD.step() epoch_ls_d.append(d_loss.item()) epoch_wd.append(wd_distance.item()) epoch_gp.append(gradient_penalty.item()) # 2. update generator if (batch+1) % G_update_iterval == 0: optimizerG.zero_grad() noise = torch.randn(size=(X.shape[0], N_LATENT)).to(dev) X_fake = model.generator(noise) outp_fake = model.discriminator(X_fake).view(-1) g_loss = -outp_fake.mean() g_loss.backward() optimizerG.step() epoch_ls_g.append(g_loss.item()) all_loss_g.append(sum(epoch_ls_g) / len(epoch_ls_g)) all_loss_d.append(sum(epoch_ls_d) / len(epoch_ls_d)) all_wd.append(sum(epoch_wd) / len(epoch_wd)) template = 'Epoch {}, G Loss:{:.2f}, D Loss:{:.2f}, G WD:{:.2f}, gp:{:.2f}, ' \ 'Time: {:.2f}.' logger.info(template.format(epoch, all_loss_g[-1], all_loss_d[-1], all_wd[-1], sum(epoch_gp) / len(epoch_gp), time.time() - start) ) if epoch % test_interval == 0: model.eval() with torch.no_grad(): x = model.generator(fixed_noise).cpu() x = utils.de_normalize(x) save_image(x, filename='figure/P3_GAN_generated_samples_epoch_{}.png'.format(epoch)) if save_model: utils.model_save(model, 'P3_GAN_Epoch{}.pt'.format(num_epochs)) utils.make_plot(all_loss_d, save_name='P3_gan_learning_curve.png', title='GAN Learning Curve', tickets=['Epochs', 'D Loss']) return all_loss_d
train_loss, train_acc = train_net(model, loss, config, train_data, train_label, config['batch_size'], config['disp_freq']) # save loss & accuracy data for training epoch train_loss_list.append(train_loss) train_acc_list.append(train_acc) LOG_INFO('Testing @ %d epoch...' % (epoch)) test_loss, test_acc = test_net(model, loss, test_data, test_label, config['batch_size']) # save loss & accuracy data for test epoch test_loss_list.append(test_loss) test_acc_list.append(test_acc) end_time = time.time() make_plot(config['max_epoch'], train_loss_list, test_loss_list, model.name, loss.name, loss=True) make_plot(config['max_epoch'], train_acc_list, test_acc_list, model.name, loss.name, loss=False) print('Time per epoch = ' + str((end_time - start_time) / config['max_epoch']))
def Q1_1_plot(category): hourCount = load_obj(category + '_numTweetsInHour') hours = [x for x in range(0, len(hourCount))] ys = [[hourCount, 'Number of tweets per hour']] make_plot(hours, ys, bar=True, xlabel='hours', ylabel='Number of tweets')
def Q3_jack(): hashtags = ['#gohawks', '#patriots'] num_of_positive_hawks = [0] num_of_negative_hawks = [0] num_of_positive_patriots = [0] num_of_negative_patriots = [0] totalHoursMin = 999999 for category in hashtags: with open(fileLocation(category), encoding="utf8") as f: tweets = f.readlines() #read all lines firstTs = FIRST_TS[category] firstTs = firstTs // 3600 * 3600 lastTs = LAST_TS[category] totalHours = tsDiffHour(firstTs, lastTs) + 1 if totalHours < totalHoursMin: totalHoursMin = totalHours hourCount = [0] * totalHours if category == '#gohawks': num_of_positive_hawks = [0] * totalHours num_of_negative_hawks = [0] * totalHours else: num_of_positive_patriots = [0] * totalHours num_of_negative_patriots = [0] * totalHours #for tweet in tweets: for i in range(0, len(tweets)): tweet = tweets[i] t = json.loads(tweet) ts = t['citation_date'] date = datetime.datetime.fromtimestamp(t['citation_date']) title = t['title'] hourDiff = tsDiffHour(firstTs, ts) hourCount[hourDiff] += 1 # number if category == '#gohawks': if sentiment(tweet) is 'positive': num_of_positive_hawks[hourDiff] += 1 elif sentiment(tweet) is 'negative': num_of_negative_hawks[hourDiff] += 1 else: if sentiment(tweet) is 'positive': num_of_positive_patriots[hourDiff] += 1 elif sentiment(tweet) is 'negative': num_of_negative_patriots[hourDiff] += 1 result_positive = [0] * totalHours result_negative = [0] * totalHours #the perspective of hawks for i in range(0, totalHoursMin): #totalHours result_positive[ i] = num_of_positive_hawks[i] + num_of_negative_patriots[i] result_negative[ i] = num_of_positive_patriots[i] + num_of_negative_hawks[i] ys = [[result_positive, 'positive sentiment'], [result_negative, 'negative sentiment']] x_plt = range(0, totalHours) x_label = 'time' y_label = 'sentiment' title = 'sentiment vs time for hawks' make_plot(x_plt, ys, scatter=False, xlabel=x_label, ylabel=y_label, title=title) s = """for tag in hashtags: