def test_yaml_file_uppercase(tmpdir): fp = tmpdir.mkdir("foo").join("input.yaml") fp.write(""" - Fred - BOB - arthur """) output_fp = tmpdir.mkdir("bar").join("output.yaml") transform(str(fp), None, "YAML", "YAML", "CAPITALISE", str(output_fp), None) stuff = yaml.safe_load(output_fp.read()) assert ['FRED', 'BOB', 'ARTHUR'] == stuff
def test_json_file_uppercase(tmpdir): fp = tmpdir.mkdir("foo").join("input.json") fp.write("""[ "Fred", "BOB", "arthur" ]""") output_fp = tmpdir.mkdir("bar").join("output.json") transform(str(fp), None, "JSON", "JSON", "CAPITALISE", str(output_fp), None) stuff = json.loads(output_fp.read()) assert ['FRED', 'BOB', 'ARTHUR'] == stuff
def run(config): logger.info("starting to run the pipeline") #pdb.set_trace() #config = args.config with open (config) as config_file: configs = yaml.safe_load(config_file) #'input_file', 'roc_path', 'pr_path','out_path' df = pd.read_csv(configs['io']['input_path']) cols_config = configs['cols'] time_config = configs['time'] trans_configs = configs['transform'] model_configs = configs['models'] matrix_configs = configs['matrix'] count = 1 for data in split(cols_config, time_config, df): X_train, X_test, y_train, y_test = data X_train, X_test = transformer.transform(trans_configs, X_train, X_test) results_df = pd.DataFrame(columns=matrix_configs['col_list']) for name, model in model_factory.get_models(model_configs): logger.info('start to run the model {}'.format(model)) model.fit(X_train, y_train) print(sys.getsizeof(model)) if name == 'LinearSVC': y_pred_probs = model.decision_function(X_test) else: y_pred_probs = model.predict_proba(X_test)[:, 1] index = len(results_df) results_df.loc[index] = get_matrix(results_df, y_pred_probs, y_test, name, model, count,index, matrix_configs) del model gc.collect() results_df.to_csv(matrix_configs['out_path'] + str(count) + ".csv") count += 1
def main(): for test_num in range(len(test_files)): print('\n') test_file = test_files[test_num] print("testing file " + test_file) l_parse_tree = parse_file(test_file) asp_transformed_tree = transformer.transform(l_parse_tree) asp_translated_program = unparser.unparse(asp_transformed_tree) answers_out = parse_clingo_output(run_asp_program(asp_translated_program)) compare_answers(answers_out, test_outputs[test_num]) check_tree(asp_transformed_tree, asp_translated_program)
def update_graph(contents, filename): _fig1 = px.scatter() _fig2 = px.scatter() if contents: contents = contents[0] filename = filename[0] df = parse_data(contents, filename) df = df.set_index(df.columns[0]) _fig1 = px.scatter(df, x="x", y="y", title='Before transform') _fig2 = px.scatter(transformer.transform(df), x="x", y="y", title='After transform') return _fig1, _fig2
class TestTransformer(unittest.TestCase): dfs = scraper.scrape( "https://id.wikipedia.org/wiki/Daftar_orang_terkaya_di_Indonesia") new_df = transformer.transform([dfs[3], dfs[4], dfs[5], dfs[6], dfs[7]], [2011, 2013, 2017, 2019, 2020]) def test_is_year_between_2011_and_2020(self, cleaned_df=new_df): actual = cleaned_df['tahun'].nunique() expected = 5 self.assertEqual(actual, expected) def test_shape_of_dataframe(self, cleaned_df=new_df): actual = cleaned_df.shape expected = (218, 5) self.assertEqual(actual, expected) def test_is_money_miliar_when_string_money_contains_miliar(self): string_money = "35.5 miliar" actual = transformer.is_money_miliar(string_money) self.assertTrue(string_money) def test_is_money_miliar_when_string_money_not_contains_miliar(self): string_money = "980 juta" actual = transformer.is_money_miliar(string_money) self.assertFalse(actual) def test_transform_money_format_when_money_is_juta(self): string_money = "980 Juta" actual = transformer.transform_money_format(string_money) self.assertEqual(actual, "980") def test_transform_money_format_when_money_is_miliar(self): string_money = "35.5 Miliar" actual = transformer.transform_money_format(string_money) self.assertEqual(actual, "35.5") def test_transform_money_format_when_money_contains_comma(self): string_money = "35,5 Miliar" actual = transformer.transform_money_format(string_money) self.assertEqual(actual, "35.5")
def run_tests(zip_file_content: bytes) -> Union[Dict[Simulation, SimulationData], str]: from sim_controller import run_test_case from transformer import transform from datetime import datetime folder = extract_test_cases(zip_file_content) mapping_stubs, valid_crit_defs = get_valid(folder) mapping = associate_criteria(mapping_stubs, valid_crit_defs) if mapping: simulations = {} test_cases = transform(mapping) for test_case, crit_def, env_def in test_cases: sim, bng_scenario, thread, sid = run_test_case(test_case) data = SimulationData(bng_scenario, thread, crit_def, env_def, sid) data.start_time = datetime.now() simulations[sim] = data return simulations else: return "No valid tests submitted."
def image_transform(filename, op, prefix=''): global TRANSFORMATIONS global FACES_SWAPPED TRANSFORMATIONS += 1 requests.put(FIREBASE_URL + 'transformations.json', data=str(TRANSFORMATIONS)) filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename) transformed_filename = prefix + filename transformed_filepath = os.path.join(app.config['UPLOAD_FOLDER'], transformed_filename) image, faces_swapped = transformer.transform(filepath, op) image.save(transformed_filepath, quality=95) FACES_SWAPPED += faces_swapped requests.put(FIREBASE_URL + 'faces_swapped.json', data=str(FACES_SWAPPED)) return redirect( url_for('index', filename=filename, transformed_filename=transformed_filename))
def generate_word_adv(model, args, numclass, data, device, index2word, word_index): inputs, target, idx, raw = data inputs, target = inputs.to(device), target.to(device) # origsample.append(inputs) # origsampleidx.append(idx) # tgt.append(target) # wtmp = [] h, output = model(inputs) pred = torch.max(output, 1)[1].view(target.size()) losses = scoring.scorefunc(args.scoring)(model, inputs, pred, numclass) sorted, indices = torch.sort(losses, dim=1, descending=True) advinputs = inputs.clone() # for k in range(inputs.size()[0]): # wtmp.append([]) # for i in range(inputs.size()[1]): # if advinputs[k, i].item() > 3: # wtmp[-1].append(index2word[advinputs[k, i].item()]) # else: # wtmp[-1].append('') for k in range(inputs.size()[0]): j = 0 t = 0 while j < args.power and t < inputs.size()[1]: if advinputs[k, indices[k][t]].item() > 3: word, advinputs[k, indices[k][t]] = transformer.transform(args.transformer)( advinputs[k, indices[k][t]].item(), word_index, index2word, top_words=args.dictionarysize) # wtmp[k][indices[k][t]] = word # print(word) j += 1 t += 1 # a = ' '.join(wtmp[32]) # print(a) return advinputs
from transformer import transform # Image parameters file_path = 'images/test_1.jpg' # Input image output_path = 'output.jpg' # Output image to_ratio = 16 / 9 # The desired aspect ratio: width = height * to_ratio # If to_ratio > 1: the output image will be horizontal: the height is kept # If to_ratio < 1: the output image will be vertical: the width is kept # Advanced parameters blur = 30 # How much to blur the background shadow_blur = 50 # How much to blur the shadow shadow_opacity = 0.75 transform(file_path=file_path, output_path=output_path, to_ratio=to_ratio, blur=blur, shadow_blur=shadow_blur, shadow_opacity=shadow_opacity)
from PIL import Image from transformer import transform from commandline_helper import get_args iterations, base_img, output_path, style_imgs = get_args() content_image = Image.open(base_img) height, width = content_image.size for style_img_src, nr in zip(style_imgs, range(len(style_imgs))): style_image = Image.open(style_img_src).resize((height, width)) content_image = transform(content_image, style_image, height, width, iterations) content_image.save(output_path + "output_" + str(nr) + ".jpg")
def attackword(maxbatch=None): corrects = .0 total_loss = 0 model.eval() wordinput = [] tgt = [] adv = [] origsample = [] flagstore = True for dataid, data in enumerate(test_loader): print dataid if maxbatch != None and dataid >= maxbatch: break inputs, target = data inputs, target = Variable(inputs, volatile=True), Variable(target) inputs, target = inputs.cuda(), target.cuda() origsample.append(inputs.data) tgt.append(target.data) wtmp = [] output = model(inputs) pred = Variable(torch.max(output, 1)[1].view(target.size()).data) losses = scoring.scorefunc(args.scoring)(model, inputs, pred, numclass) sorted, indices = torch.sort(losses, dim=1, descending=True) advinputs = inputs.clone() if flagstore: for k in xrange(inputs.size()[0]): wtmp.append([]) for i in xrange(inputs.size()[1]): if advinputs.data[k, i] > 3: wtmp[-1].append(index2word[advinputs.data[k, i]]) else: wtmp[-1].append('') for k in xrange(inputs.size()[0]): j = 0 t = 0 while j < args.power and t < inputs.size()[1]: if advinputs.data[k, indices[k][t]] > 3: word, advinputs.data[ k, indices[k][t]] = transformer.transform( args.transformer)( advinputs[k, indices[k][t]].data[0], word_index, index2word, top_words=args.dictionarysize) wtmp[k][indices[k][t]] = word j += 1 t += 1 else: for k in xrange(inputs.size()[0]): for i in xrange(args.power): word, advinputs.data[ k, indices[k][i]] = transformer.transform( args.transformer)(advinputs[k, indices[k][i]].data[0], word_index, index2word, top_words=args.dictionarysize) adv.append(advinputs.data) for i in xrange(len(wtmp)): wordinput.append(wtmp[i]) output2 = model(advinputs) pred2 = torch.max(output2, 1)[1].view(target.size()).data corrects += (pred2 == target.data).sum() print wordinput[0] target = torch.cat(tgt) advinputs = torch.cat(adv) origsamples = torch.cat(origsample) acc = corrects / advinputs.size(0) print('Accuracy %.5f' % (acc)) f = open('attack.txt', 'a') f.write('%d\t%s\t%s\t%s\t%d\t%.2f\n' % (args.data, args.model, args.scoring, args.transformer, args.power, 100 * acc)) if args.advsamplepath == None: advsamplepath = 'advsamples/%s_%d_%s_%s_%d.dat' % ( args.model, args.data, args.scoring, args.transformer, args.power) else: advsamplepath = args.advsamplepath torch.save( { 'original': origsamples, 'wordinput': wordinput, 'advinputs': advinputs, 'labels': target }, advsamplepath)
def run_test(logservice, trainer, transformer, cv = False): if cv: raise Exception('CV not implemented') path = 'testing/dataset/ml-100k/' rating_data = open(path + 'u1.base') user_data = open(path + 'u.user') occupation_data = open(path + 'u.occupation') all_items = open(path + 'u.item') users = [] items = [] user_ratings = dict() occupations = [] zips = [] for line in occupation_data: occupations.append(line.strip()) for line in all_items: # movie id | movie title | release date | video release date | # IMDb URL | unknown | Action | Adventure | Animation | # Children's | Comedy | Crime | Documentary | Drama | Fantasy | # Film-Noir | Horror | Musical | Mystery | Romance | Sci-Fi | # Thriller | War | Western | movie_info = line.split('|') id = movie_info[0] name = movie_info[1] descriptor = [1] descriptor.extend(map(float, movie_info[5:])) items.append(movie(id, name, None, descriptor)) print 'Setting items' trainer.setItems([(o.id, transformer.transform(o, 20)) for o in items]) print 'Set items' for line in user_data: # user id | age | gender | occupation | zip code user_info = line.split('|') userid = int(user_info[0]) age = int(user_info[1]) gender = user_info[2] occupation = user_info[3] zip = user_info[4].strip() users.append(user(userid, age, gender, occupation, zip)) ratings = [] for line in rating_data: # user id | item id | rating | timestamp. userid, itemid, rating, timestamp = line.split('\t') user_ratings[str(userid) + "_" + str(itemid)] = float(rating) ratings.append((userid, itemid, rating, timestamp)) print 'Running...' c = 0 total_rating = 0 ratings_count = 0 avg_ratings = [] for userid, itemid, rating, timestamp in ratings: if c % 2 == 0: c += 1 continue context = transformer.transform(users[int(userid)-1], 20) recommended_item = trainer.get(context) key = str(userid) + "_" + str(recommended_item.id) if key in user_ratings: rated = user_ratings[key] total_rating += rated ratings_count += 1 if(rated > 3): rated = 1 else: rated = -1 trainer.reward(recommended_item, context, rated) c += 1 total = 10000 if( c > total): break if c % 100 == 0: print '\n\n ' + "Evaluated %d/%d lines." % (c, total) print "Avg. Recommended Rating = %f" % (float(total_rating) / ratings_count) avg_ratings.append(float(total_rating) / ratings_count) print '' print '\n\n ' + "Evaluated %d/%d lines." % (c, total) print "Avg. Recommended Rating = %f" % (float(total_rating) / ratings_count) avg_ratings.append(float(total_rating) / ratings_count) print avg_ratings
import argparse from sqlalchemy import create_engine from transformer import transform table_name = 'police_incidents' transformations = [] def remove_clb_ending(row): address = row.incident_address if ', CLB' == address[-5:]: row.incident_address = address[:-5] return row transformations.append(remove_clb_ending) if __name__ == '__main__': parser = argparse.ArgumentParser(description='Transform a database') parser.add_argument('--hostdb') parser.add_argument('--destinationdb') args = parser.parse_args() host_engine = create_engine(args.hostdb) dest_engine = create_engine(args.destinationdb) transform(host_engine, dest_engine, table_name, transformations)
def attackword(maxbatch=None): corrects = .0 total_loss = 0 model.eval() wordinput = [] tgt = [] adv = [] origsample = [] flagstore = True for dataid, data in enumerate(train_loader): print dataid if maxbatch != None and dataid > maxbatch: break inputs, target = data inputs, target = Variable(inputs, volatile=True), Variable(target) inputs, target = inputs.cuda(), target.cuda() origsample.append(inputs.data) tgt.append(target.data) wtmp = [] output = model(inputs) # loss = F.nll_loss(output, targenst) # total_loss += loss.data[0] pred = Variable(torch.max(output, 1)[1].view(target.size()).data) losses = scoring.scorefunc(args.scoring)(model, inputs, pred, numclass) sorted, indices = torch.sort(losses, dim=1, descending=True) # print losses # print indices advinputs = inputs.clone() if flagstore: for k in xrange(inputs.size()[0]): wtmp.append([]) for i in xrange(inputs.size()[1]): if advinputs.data[k, i] > 3: wtmp[-1].append(index2word[advinputs.data[k, i]]) else: wtmp[-1].append('') for k in xrange(inputs.size()[0]): j = 0 t = 0 while j < args.power and t < inputs.size()[1]: # if advinputs.data[k,indices[k][t]]>3 and losses[k,indices[k][t]]>0: if advinputs.data[k, indices[k][t]] > 3: word, advinputs.data[ k, indices[k][t]] = transformer.transform( args.transformer)( advinputs[k, indices[k][t]].data[0], word_index, index2word) wtmp[k][indices[k][t]] = word j += 1 t += 1 # for i in xrange(args.power): # word, advinputs.data[k,indices[k][i]] = transformer.transform(args.transformer)(advinputs[k,indices[k][i]].data[0],word_index,index2word) # wordinput[k][indices[k][i]] = word else: for k in xrange(inputs.size()[0]): for i in xrange(args.power): word, advinputs.data[ k, indices[k][i]] = transformer.transform( args.transformer)(advinputs[k, indices[k][i]].data[0], word_index, index2word) adv.append(advinputs.data) for i in xrange(len(wtmp)): wordinput.append(wtmp[i]) # inputs2 = Variable(advinputs, volatile=True) output2 = model(advinputs) pred2 = torch.max(output2, 1)[1].view(target.size()).data # print inputs.size() # inputs = Variable(inputs, volatile=True) # logit = model(inputs) # pred1 = torch.max(logit, 1)[1].view(target.size()).data # accumulated_loss += F.nll_loss(logit, target, size_average=False).data[0] corrects += (pred2 == target.data).sum() # predicates_all+=predicates.cpu().numpy().tolist() # target_all+=target.data.cpu().numpy().tolist() # print corrects print wordinput[0] # correct += pred.eq(target.data.view_as(pred)).cpu().sum() # acc = corrects/len(test_loader.dataset) # avg_loss = total_loss/len(test_loader.dataset) target = torch.cat(tgt) advinputs = torch.cat(adv) origsamples = torch.cat(origsample) acc = corrects / advinputs.size(0) print('Accuracy %.5f' % (acc)) f = open('attack_train.txt', 'a') f.write('%d\t%s\t%s\t%s\t%d\t%.2f\n' % (args.data, args.model, args.scoring, args.transformer, args.power, 100 * acc)) if args.advsamplepath == None: advsamplepath = 'advsamples2/%s_%d_%s_%s_%d_train.dat' % ( args.model, args.data, args.scoring, args.transformer, args.power) else: advsamplepath = args.advsamplepath torch.save( { 'original': origsamples, 'wordinput': wordinput, 'advinputs': advinputs, 'labels': target }, advsamplepath)
def json_to_CSV(): x = request.json reqobj = tf.transform(x) return reqobj
unhappyPath, ] filePath = os.path.join(dirPath, baseName, fileName) headPath = os.path.join(dirPath, baseName, 'head.png') srcPath = os.path.join(dirPath, baseName, 'src') targetPath = os.path.join(dirPath, baseName, 'target') ausPath = os.path.join(dirPath, baseName, 'aus.pkl') left, top = cut(filePath, headPath) # cutter ausget(os.path.join(dirPath, baseName)) # ausgetter for i in range(len(ausList)): if (not os.path.exists(srcPath)): os.mkdir(srcPath) transform(num, headPath, srcPath, ausPath, ausList[i]) # transformer if (not os.path.exists(targetPath)): os.mkdir(targetPath) rebuild(num, left, top, filePath, srcPath, targetPath) # rebuilder combine(num, targetPath, gifList[i]) # combine os.remove(srcPath) os.remove(targetPath)
def attackword(model, args, numclass, test_loader, device, index2word, word_index, maxbatch=None): corrects = .0 total_loss = 0 model.eval() wordinput = [] tgt = [] adv = [] origsample = [] origsampleidx = [] for dataid, data in enumerate(test_loader): print(dataid) if maxbatch is not None and dataid >= maxbatch: break inputs, target, idx, raw = data inputs, target = inputs.to(device), target.to(device) origsample.append(inputs) origsampleidx.append(idx) tgt.append(target) wtmp = [] output = model(inputs) pred = torch.max(output, 1)[1].view(target.size()) losses = scoring.scorefunc(args.scoring)(model, inputs, pred, numclass) sorted, indices = torch.sort(losses, dim=1, descending=True) advinputs = inputs.clone() for k in range(inputs.size()[0]): wtmp.append([]) for i in range(inputs.size()[1]): if advinputs[k, i].item() > 3: wtmp[-1].append(index2word[advinputs[k, i].item()]) else: wtmp[-1].append('') for k in range(inputs.size()[0]): j = 0 t = 0 while j < args.power and t < inputs.size()[1]: if advinputs[k, indices[k][t]].item() > 3: word, advinputs[k, indices[k][t]] = transformer.transform(args.transformer)( advinputs[k, indices[k][t]].item(), word_index, index2word, top_words=args.dictionarysize) wtmp[k][indices[k][t]] = word print(word) j += 1 t += 1 adv.append(advinputs) output2 = model(advinputs) pred2 = torch.max(output2, 1)[1].view(target.size()) corrects += (pred2 == target).sum().item() for i in range(len(wtmp)): print(raw[i]) print(pred[i].item()) wordinputi = recoveradv(raw[i], index2word, inputs[i], wtmp[i]) print(wordinputi) wordinput.append(wordinputi) print(pred2[i].item()) target = torch.cat(tgt) advinputs = torch.cat(adv) origsamples = torch.cat(origsample) origsampleidx = torch.cat(origsampleidx) acc = corrects / advinputs.size(0) print('Accuracy %.5f' % acc) f = open('attack_log.txt', 'a') f.write('%d\t%d\t%s\t%s\t%s\t%d\t%.2f\n' % ( args.data, args.wordlength, args.model, args.scoring, args.transformer, args.power, 100 * acc)) if args.advsamplepath is None: advsamplepath = 'advsamples/%s_%d_%s_%s_%d_%d.dat' % ( args.model, args.data, args.scoring, args.transformer, args.power, args.wordlength) else: advsamplepath = args.advsamplepath torch.save({'original': origsamples, 'sampleid': origsampleidx, 'wordinput': wordinput, 'advinputs': advinputs, 'labels': target}, advsamplepath)
#!/usr/bin/env python3 import logParser import datetime import transformer parser = logParser.Parser() assert parser.parse("[1518-11-01 00:00] Guard #10 begins shift") == \ [datetime.datetime(1518, 11, 1, 0, 0), 'start', 10] assert parser.parse("[1518-11-01 00:05] falls asleep") == \ [datetime.datetime(1518, 11, 1, 0, 5), 'asleep', -1] assert parser.parse("[1518-11-02 00:50] wakes up") == \ [datetime.datetime(1518, 11, 2, 0, 50), 'wakeup', -1] log = parser.readLog("testInput.txt") guards = transformer.transform(log) assert transformer.countMinutes(guards) == 240 assert transformer.countMinutes2(guards) == 4455 log = parser.readLog("input.txt") guards = transformer.transform(log) print(transformer.countMinutes(guards)) print(transformer.countMinutes2(guards))
def visualize(input_str, dict_word=[], index2word=[], classes_list=[], power=5, scoring_alg='replaceone', transformer_alg='homoglyph', model=model, mode='word', maxlength=500, device=None, filter_char=default_filter, alphabet=default_alphabet): numclass = len(classes_list) if mode == 'word': input_seq = simple_tokenize(input_str, dict_word) input_seq = torch.Tensor(input_seq).long().view(1, -1) if device: input_seq = input_seq.to(device) res1 = model(input_seq) pred1 = torch.max(res1, 1)[1].view(-1) losses = scoring.scorefunc(scoring_alg)(model, input_seq, pred1, numclass) print(input_str) pred1 = pred1.item() print('original:', classes_list[pred1]) sorted, indices = torch.sort(losses, dim=1, descending=True) advinputs = input_seq.clone() wtmp = [] for i in range(input_seq.size()[1]): if advinputs[0, i].item() > 3: wtmp.append(index2word[advinputs[0, i].item()]) else: wtmp.append('') j = 0 t = 0 while j < power and t < input_seq.size()[1]: if advinputs[0, indices[0][t]].item() > 3: word, advinputs[0, indices[0][t]] = transformer.transform( transformer_alg)(advinputs[0, indices[0][t]].item(), dict_word, index2word, top_words=20000) wtmp[indices[0][t]] = word j += 1 t += 1 output2 = model(advinputs) pred2 = torch.max(output2, 1)[1].view(-1).item() adv_str = recoveradv(input_str.lower(), index2word, input_seq[0], wtmp) print(adv_str) print('adversarial:', classes_list[pred2]) return (input_str, torch.exp(res1).detach().cpu()[0], classes_list[pred1], adv_str, torch.exp(output2).detach().cpu()[0], classes_list[pred2]) elif mode == 'char': inputs = transchar(input_str, alphabet=alphabet) if device: inputs = inputs.to(device) output = model(inputs) pred1 = torch.max(output, 1)[1].view(-1) losses = scoring_char.scorefunc(scoring_alg)(model, inputs, pred1, numclass) sorted, indices = torch.sort(losses, dim=1, descending=True) advinputs = inputs.clone() dt = inputs.sum(dim=1).int() j = 0 t = 0 md = input_str.lower()[:][::-1] while j < power and t < inputs.size()[2]: if dt[0, indices[0][t]].item() > 0: advinputs[0, :, indices[0][t]], nowchar = transformer_char.transform( transformer_alg)(inputs, torch.max( advinputs[0, :, indices[0][t]], 0)[1].item(), alphabet) md = md[:indices[0][t].item( )] + nowchar + md[indices[0][t].item() + 1:] j += 1 t += 1 md = md[::-1] output2 = model(advinputs) pred2 = torch.max(output2, 1)[1].view(-1) print(input_str) print('original:', classes_list[pred1.item()]) print(md) print('adversarial:', classes_list[pred2.item()]) return (input_str, torch.exp(output)[0].detach().cpu(), classes_list[pred1.item()], md, torch.exp(output2)[0].detach().cpu(), classes_list[pred2.item()]) else: raise Exception('Wrong mode %s' % mode)
data_samples_creator.generate_circle() external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css'] app = dash.Dash(__name__, external_stylesheets=external_stylesheets) app.title = 'MyFirstDash' # assume you have a "long-form" data frame # see https://plotly.com/python/px-arguments/ for more options df1 = pd.DataFrame({ "x": [1, 2, 3, 4, 5, 6, 7], "y": [1, 2, 3, 4, 5, 6, 7], }) fig1 = px.scatter(df1, x="x", y="y", title='Before transform') df2 = transformer.transform(df1) fig2 = px.scatter(df2, x="x", y="y", title='After transform') empt_fig1 = px.scatter(title='Before transform') empt_fig2 = px.scatter(title='After transform') app.layout = html.Div(children=[ html.H1(children='Guess quadratic func', style={ 'textAlign': 'center', }), html.H2(children='With given x and y, y got transformed', style={ 'textAlign': 'center', }), html.H3(children='Here is simple example', style={ 'textAlign': 'center',