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)
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(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',
