repo stringlengths 1 99 | file stringlengths 13 215 | code stringlengths 12 59.2M | file_length int64 12 59.2M | avg_line_length float64 3.82 1.48M | max_line_length int64 12 2.51M | extension_type stringclasses 1
value |
|---|---|---|---|---|---|---|
teacher-perception | teacher-perception-master/code/agreement_per_pos.py | import os, pyconll
import dataloader_agreement_per_pos as dataloader
import argparse
import numpy as np
np.random.seed(1)
import sklearn
from collections import defaultdict
import pandas as pd
from sklearn.metrics import accuracy_score
from sklearn.model_selection import GridSearchCV
from sklearn.tree import DecisionTreeClassifier
import utils
from scipy.sparse import csr_matrix, vstack
from scipy.sparse import csc_matrix
import xgboost as xgb
from io import StringIO
DTREE_DEPTH = [3, 4, 5, 6, 7, 8, 9, 10]
DTREE_IMPURITY = [5e-4, 1e-3, 2e-3, 5e-3, 1e-2, 5e-2, 1e-1, 5e-1]
XGBOOST_GAMMA = [0.005, 0.01, 1, 2, 5, 10]
def printTreeFromXGBoost(model, rel, folder_name, train_data_path, train_path, test_data_path, test_path, lang, tree_features, relation_map, genreparseddata, wikidata, spine_word_vectors, spine_features, spine_dim):
best_model = model.best_estimator_
rules_df = best_model.get_booster().trees_to_dataframe()
rules_df_t0 = rules_df.loc[rules_df['Tree'] == 0]
# Iterate the tree to get information about the tree features
topnodes, tree_dictionary, leafnodes, leafedges, edge_mapping = utils.iterateTreesFromXGBoost(rules_df_t0, args.task, f'{args.features}-{rel}',
relation_map, tree_features, folder_name, args.transliterate)
# Assign statistical threshold to each leaf
train_df = pd.read_csv(train_data_path, sep=',')
train_data = pyconll.load_from_file(train_path)
leaf_examples, leaf_sent_examples = utils.FixLabelTreeFromXGBoostWithFeatures(rules_df_t0, tree_dictionary, leafnodes,
label_list, data_loader.model_data_case[rel],
f'{args.features}-{rel}', train_df, train_data,
tree_features, data_loader, genreparseddata,
wikidata, spine_word_vectors, spine_features, spine_dim,
task=args.task)
tree_dictionary, leafmap = utils.collateTreeFromXGBoost(tree_dictionary, topnodes, leafnodes, leafedges)
test_df = pd.read_csv(test_data_path, sep=',')
test_data = pyconll.load_from_file(test_path)
metric, _ = utils.computeAutomatedMetric(leafmap, tree_dictionary, test_df, test_data, f'{args.features}-{rel}', tree_features, data_loader, args.task, genreparseddata, wikidata, spine_word_vectors,
spine_features, spine_dim, folder_name, lang)
baselinemetric, _ = utils.computeAutomatedMetric(leafmap, tree_dictionary, test_df, test_data, f'{args.features}-{rel}', tree_features, data_loader, args.task, genreparseddata, wikidata, spine_word_vectors,
spine_features, spine_dim, folder_name, lang, isbaseline=True)
print("Model: %s-%s, Lang: %s, Test Accuracy : %.4g, Baseline Accuracy: %.4g" % (args.features, rel, lang_full, metric * 100.0, baselinemetric * 100.0))
print(f"Hyperparameter tuning: ", model.best_params_)
print("Num of leaves", len(leafmap))
if args.no_print:
return tree_dictionary, leafmap, {}, {}, {}
retainNA = args.retainNA
leaf_values_per_columns, columns_per_leaf, update_spine_features = {}, {}, {}
important_features, cols = utils.getImportantFeatures(tree_dictionary, leafmap, "", retainNA=retainNA)
if len(important_features) == 0: # If there is no sig other label
return tree_dictionary, leafmap, {}, {}, {}
leaf_examples_features = {}
total_num_examples = 0
num_examples_label = defaultdict(lambda: 0)
num_leaf_examples = {}
with open(f'{folder_name}/{lang}_{rel}_rules.txt', 'w') as fleaf:
for leaf_num in range(len(leafmap)):
leaf_examples_features[leaf_num] = {}
leaf_index = leafmap[leaf_num]
columns_per_leaf[leaf_num] = defaultdict(list)
leaf_label = tree_dictionary[leaf_index]['class']
# if leaf_label == 'NA':
# leaf_label = 'chance-agree'
# tree_dictionary[leaf_index]['class'] = leaf_label
leaf_examples_features[leaf_num]['leaf_label'] = leaf_label
examples = leaf_examples[leaf_index]
sent_examples = leaf_sent_examples[leaf_index]
agree, disagree, total_agree, total_disagree, spine_features = utils.getExamples(sent_examples,
tree_dictionary[
leaf_index],
train_data, isTrain=True)
for keyspine, valuespines in spine_features.items():
key = keyspine.split("_")[0]
sorted_spine = sorted(valuespines.items(), key=lambda kv:kv[1], reverse=True)[:10]
values = [v for (v,_) in sorted_spine]
update_spine_features[keyspine] = f'{key}_{",".join(values)}'
leaf_examples_features[leaf_num]['agree'] = agree
leaf_examples_features[leaf_num]['disagree'] = disagree
row = f'<tr>'
active_all = tree_dictionary[leaf_index]['active'] #features which are active for this leaf
non_active_all = tree_dictionary[leaf_index]['non_active'] #features which are not active for this leaf
top = tree_dictionary[leaf_index].get('top', -1)
while top > 0: # Not root
active_all += tree_dictionary[top]['active']
non_active_all += tree_dictionary[top]['non_active']
top = tree_dictionary[top]['top']
active, non_active = [],[]
for (feat, _) in active_all:
feat = update_spine_features.get(feat, feat)
active.append(feat)
for (feat, _) in non_active_all:
feat = update_spine_features.get(feat, feat)
non_active.append(feat)
active, non_active = list(set(active)), list(set(non_active))
leaf_examples_features[leaf_num]['active'] = active
leaf_examples_features[leaf_num]['non_active'] = non_active
fleaf.write(leaf_label + "\n")
fleaf.write('active: ' + " ### ".join(active) + "\n")
fleaf.write('non_active: ' + " ### ".join(non_active) + "\n")
fleaf.write(
f'agree:{total_agree}, disagree: {total_disagree}, total: {total_agree + total_disagree}\n')
fleaf.write("\n")
# populating only rules which deviate from the dominant label as observed from the training data
for feat in important_features:
feat = update_spine_features.get(feat, feat)
if feat in active:
columns_per_leaf[leaf_num]['Y'].append(feat)
row += f'<td style=\"text-align:center\"> Y </td>'
elif feat in non_active:
columns_per_leaf[leaf_num]['N'].append(feat)
row += f'<td style=\"text-align:center\"> N </td>'
else:
columns_per_leaf[leaf_num]['-'].append(feat)
row += f'<td style=\"text-align:center\"> - </td>'
row += f'<td> {leaf_label} </td> <td> <a href=\"Leaf-{leaf_num}.html\"> Examples</a> </td>\n'
leaf_examples_features[leaf_num]['row'] = row
#get the number of examples predicted for each label
for _, num_example_per_leaf in sent_examples.items():
num_examples_label[leaf_label] += len(num_example_per_leaf)
total_num_examples += len(num_example_per_leaf)
num_leaf_examples[leaf_num] = total_agree + total_disagree
return tree_dictionary, leafmap, leaf_examples_features, num_leaf_examples, columns_per_leaf
def dtreemodel(feature, x,y, x_test, y_test, impurity,cv):
criterion = ['gini', 'entropy']
#parameters = {'criterion': criterion, 'max_depth': depth, 'min_impurity_decrease': [1e-3, 1e-1, 1e-2]}
parameters = {'criterion': criterion, 'min_impurity_decrease': impurity, 'min_samples_split': [0.005]}
decision_tree = DecisionTreeClassifier()
model = GridSearchCV(decision_tree, parameters, cv=cv)
model.fit(x, y)
return model
def xgboostModel(rel, x,y, x_test, y_test, depth,cv):
criterion = ['gini', 'entropy']
parameters = {'criterion': criterion, 'max_depth': depth, 'min_child_weight': [10]}
xgb_model = xgb.XGBClassifier(learning_rate=0.1, n_estimators=1, subsample=0.8,
colsample_bytree=0.8, objective='multi:softprob', num_class=len(label_list), silent=True, nthread=args.n_thread,
scale_pos_weight=majority / minority, seed=1001)
model = GridSearchCV(xgb_model, parameters, cv=cv, n_jobs=args.n_jobs)
#sparse_x = csr_matrix(x)
model.fit(x, y)
return model
def train(train_features, train_labels, train_path, train_data_path,
dev_features, dev_labels,
test_features, test_labels, test_path, test_data_path,
rel, baseline_label,
folder_name, lang_full, tree_features_dict,
relation_map, best_depths,
genreparseddata, wikidata, spine_word_vectors, spine_features, spine_dim, test_datasets):
x_train, y_train, x_test, y_test = train_features, train_labels, test_features, test_labels
tree_features = []
for f in range(len(tree_features_dict)):
tree_features.append(tree_features_dict[f])
tree_features = np.array(tree_features)
if dev_features is not None:
x_dev, y_dev = dev_features, dev_labels
x = vstack((x_train, x_dev))
y = np.concatenate([y_train, y_dev])
test_fold = np.concatenate([
# The training data.
np.full(x_train.shape[0], -1, dtype=np.int8),
# The development data.
np.zeros(x_dev.shape[0], dtype=np.int8)
])
cv = sklearn.model_selection.PredefinedSplit(test_fold)
else:
x, y = x_train, y_train
cv = 5
if args.use_xgboost:
x = x.to_numpy()
# Print acc/leaves for diff settings
if args.no_print:
for depth in DTREE_DEPTH: #:
setting = f'-g-{depth}'
model = xgboostModel(args.features, x, y, x_test, y_test, [depth], cv)
best_model = model.best_estimator_
best_model.get_booster().dump_model(f'{folder_name}/{rel}/xgb_model-{setting}.txt', with_stats=True)
tree_dictionary, leafmap, leaf_examples_features, num_leaf_examples, columns_per_leaf = printTreeFromXGBoost(model, rel, folder_name, train_data_path, train_path, test_data_path, test_path, lang, tree_features, relation_map, genreparseddata, wikidata, spine_word_vectors, spine_features, spine_dim)
print()
else:
if args.features in best_depths and best_depths[args.features] != -1:
model = xgboostModel(args.features, x, y, x_test, y_test, [best_depths[args.features]], cv)
best_model = model.best_estimator_
best_model.get_booster().dump_model(f'{folder_name}/{rel}/xgb_model.txt', with_stats=True)
tree_dictionary, leafmap, leaf_examples_features, num_leaf_examples, columns_per_leaf = printTreeFromXGBoost(model, rel, folder_name, train_data_path, train_path, test_data_path, test_path, lang, tree_features, relation_map, genreparseddata, wikidata, spine_word_vectors, spine_features, spine_dim)
else:
# model = dtreemodel(args.features, x, y, x_test, y_test, DTREE_DEPTH, cv)
# dot_data = StringIO()
# label_list_string = ['NA', 'req-agree']
# sklearn.tree.export_graphviz(model.best_estimator_, out_file=dot_data,
# feature_names=tree_features, node_ids=True
# , class_names=label_list_string, proportion=False, rounded=True, filled=True,
# leaves_parallel=False, impurity=False)
model = xgboostModel(args.features, x, y, x_test, y_test, DTREE_DEPTH, cv)
best_model = model.best_estimator_
best_model.get_booster().dump_model(f'{folder_name}/{rel}/xgb_model.txt', with_stats=True)
tree_dictionary, leafmap, leaf_examples_features, num_leaf_examples, columns_per_leaf = printTreeFromXGBoost(
model, rel, folder_name, train_data_path, train_path, test_data_path, test_path, lang, tree_features,
relation_map, genreparseddata, wikidata, spine_word_vectors, spine_features, spine_dim)
best_model = model.best_estimator_
with open(f"{folder_name}/{rel}/{rel}.html", 'w') as output:
# Get the features in breadth first order of the class which deviates from the dominant order
HEADER = ORIG_HEADER.replace("main.css", "../../../../main.css")
output.write(HEADER + '\n')
output.write(f'<ul class="nav"><li class="nav"><a class="active" href=\"../../../../index.html\">Home</a>'
f'</li><li class="nav"><a href=\"../../../../introduction.html\">Usage</a></li>'
f'<li class="nav"><a href="../../../../about.html\">About Us</a></li></ul>')
output.write(f"<br><li><a href=\"../../Agreement.html\">Back to {language_fullname} page</a></li>\n")
output.write(f"<h1> Rules for {args.features} agreement for <b>{rel}</b> </h1>")
output.write(
f'<h2> The {args.features} values <b> should match </b> between the <b> {rel} </b> and its governor (i.e syntactic head) when <b>label = should-match</b>,\n '
f'else any observed agreement is purely by chance (<b>label = need-not-match)</b> </h2> ')
if baseline_label == 0:
dominant_label = 'chance-agree'
else:
dominant_label = 'req-agree'
train_data = pyconll.load_from_file(train_path)
if not args.no_print:
# Sort leaves by number of examples, and remove the col from first general leaf
sorted_leaves = sorted(num_leaf_examples.items(), key=lambda kv: kv[1], reverse=True)
first_leaf, columns_to_remove, columns_to_retain = True, set(), set()
first_leaf, retainNA = True, args.retainNA
output.write(
f'<table>'
f'<tr><th colspan=\"rowspan=\"3\" scope=\"colgroup\" \" style=\"text-align:center\"> Agreement </th>'
f'<th colspan=\"rowspan=\"2\" scope=\"colgroup\" \" style=\"text-align:center\"><b> </th>'
'</tr><tr>\n')
active_features_per_nondomleaf, columns_with_activeinactive_features, column_with_leafinfo, columns_active_indomleaves, columns_in_innondomleaves = [], {}, {}, set(), set()
for (leaf_num, _) in sorted_leaves:
leaf_label = leaf_examples_features[leaf_num]['leaf_label']
if not retainNA and leaf_label == 'NA':
continue
if first_leaf and leaf_label == dominant_label: # This is the leaf which says the general word-order
leaf_examples_features[leaf_num]['cols'] = ['generally between the head and depenent there is ']
leaf_examples_features[leaf_num]['default'] = True
dominant_label = leaf_label
first_leaf = False
active_columns_in_leaf = columns_per_leaf[leaf_num].get('Y', [])
nonactive_columns_in_leaf = columns_per_leaf[leaf_num].get('N', [])
missing_columns_in_leaf = columns_per_leaf[leaf_num].get('-', [])
if leaf_label != dominant_label and len(
active_columns_in_leaf) > 0: # There is at least one active feature in the leaf
active_features_per_nondomleaf += active_columns_in_leaf + nonactive_columns_in_leaf
all_cols = set(active_columns_in_leaf + nonactive_columns_in_leaf + missing_columns_in_leaf)
for c in all_cols:
if c in active_features_per_nondomleaf:
if leaf_label != dominant_label: #feature is present for a non-dominant leaf
columns_in_innondomleaves.add(c)
columns_to_retain.add(c)
if c not in columns_with_activeinactive_features:
columns_with_activeinactive_features[c] = defaultdict(lambda: 0)
if c in active_columns_in_leaf:
columns_with_activeinactive_features[c]['Y'] += 1
if leaf_label == dominant_label:
columns_active_indomleaves.add(c)
elif c in nonactive_columns_in_leaf or c in missing_columns_in_leaf:
columns_with_activeinactive_features[c]['N'] += 1
#If a feature is not active for any leaf. but is present for a non-dominant leaf, we keep it else remove it
for c, leafdata in columns_with_activeinactive_features.items():
leaves_with_active_column = leafdata.get('Y', 0)
if leaves_with_active_column == 0 and c not in columns_in_innondomleaves:
columns_to_retain.remove(c)
for c in columns_active_indomleaves: # for col active in dominant leaves, check if its active (Y,N) in non-dom leaves
to_keep = False
for (leaf_num, _) in sorted_leaves:
leaf_label = leaf_examples_features[leaf_num]['leaf_label']
if not retainNA and leaf_label == 'NA':
continue
if leaf_label != dominant_label:
active_columns_in_leaf = columns_per_leaf[leaf_num].get('Y', [])
nonactive_columns_in_leaf = columns_per_leaf[leaf_num].get('N', [])
if c in active_columns_in_leaf or c in nonactive_columns_in_leaf:
to_keep = True
if to_keep:
break
if not to_keep:
columns_to_retain.remove(c)
# Create the table of features
columns_to_retain = list(columns_to_retain)
if len(columns_to_retain) == 0 and not args.no_print: # all NA leaves:
return
col_names = ["" for _ in range(len(columns_to_retain))]
cols = utils.getColsToCombine(columns_to_retain)
for combined in cols:
header, subheader = utils.getHeader(combined, columns_to_retain, f'{args.features}-{rel}', args.task, relation_map, folder_name, args.transliterate)
#output.write(
# f'<th colspan=\"{len(combined)} scope=\"colgroup\" \" style=\"text-align:center;width:130px\">{header}</th>\n')
for col, header in zip(combined, subheader):
col_names[col] = header
first_leaf, leaves_covered = True, set()
retainNA = args.retainNA
non_dominant_leaves = defaultdict(list)
with open(f'{folder_name}/{lang}_{rel}_printable_rules.txt', 'w') as fleaf:
for (leaf_num, _) in sorted_leaves:
leaf_label = leaf_examples_features[leaf_num]['leaf_label']
if not retainNA and leaf_label == 'NA':
continue
if first_leaf:
leaf_examples_file = f'{folder_name}/{rel}/Leaf-{leaf_num}.html'
active, non_active = leaf_examples_features[leaf_num]['active'], leaf_examples_features[leaf_num][
'non_active']
agree, disagree = leaf_examples_features[leaf_num]['agree'], leaf_examples_features[leaf_num][
'disagree']
yes_cols, no_cols, missin_cols = columns_per_leaf[leaf_num].get('Y', []), columns_per_leaf[
leaf_num].get('N', []), columns_per_leaf[leaf_num].get('-', [])
num_features_in_leaf, cols, yes_cols_number, no_cols_number, missing_cols_number = 0, [], 0, 0, 0
yes_cols_text, no_cols_text = [], []
row = '<tr>'
for column in columns_to_retain: # Iterate all columns
if column in yes_cols:
row += f'<td style=\"text-align:center\"> Y </td>'
num_features_in_leaf += 1
yes_cols_number += 1
cols.append(f'Y_{column}')
yes_cols_text.append(column)
elif column in no_cols:
row += f'<td style=\"text-align:center\"> N </td>'
num_features_in_leaf += 1
no_cols_number += 1
cols.append(f'N_{column}')
no_cols_text.append(column)
else:
row += f'<td style=\"text-align:center\"> - </td>'
cols.append(f'-_{column}')
missing_cols_number += 1
if leaf_examples_features[leaf_num].get('default', False):
row = f'<tr> <th colspan=\"{len(columns_to_retain)} scope=\"colgroup\" \" style=\"text-align:center;width:130px\">generally for most head-dependent pairs there is </th>\n'
row += f'<td> {leaf_label} </td> <td> <a href=\"Leaf-{leaf_num}.html\"> Examples</a> </td>'
utils.populateLeaf(train_data, leaf_examples_file, leaf_label, agree, disagree,
active, non_active, first_leaf, f'{args.features}-{rel}', args.task, lang_full, relation_map,
columns_to_retain, ORIG_HEADER, HEADER,
FOOTER, folder_name, args.transliterate)
cols = ['default']
leaf_examples_features[leaf_num]['valid'] = True
fleaf.write(f'default\t\t{leaf_label}\n')
#fleaf.write(f'{"~~~".join(yes_cols_text)}\t{"~~~".join(no_cols_text)}\t{leaf_label}\n')
if leaf_label == 'req-agree':
label_str = 'should match'
else:
label_str = 'need not match'
output.write(
f'<tr> <td style=\"text-align:center\"> Generally <b>{args.features} {label_str}<b> between the {rel} and its governor or head </td> </tr>\n')
output.write(
f'<tr><td style=\"text-align:center\"> Some examples are: <a href="Leaf-{leaf_num}.html"> Examples </a> </td></tr>\n')
else:
if yes_cols_number > 0:
leaf_examples_features[leaf_num]['valid'] = True
utils.populateLeaf(train_data, leaf_examples_file, leaf_label, agree, disagree,
active, non_active, False, f'{args.features}-{rel}', args.task, lang_full, relation_map,
columns_to_retain, ORIG_HEADER, HEADER,
FOOTER, folder_name, args.transliterate)
fleaf.write(f'{"~~~".join(yes_cols_text)}\t{"~~~".join(no_cols_text)}\t{leaf_label}\n')
feature_def = ""
for feat_name in yes_cols_text:
feature_def += utils.transformRulesIntoReadable(feat_name, args.task, f'{args.features}-{rel}', relation_map, f'{args.folder_name}/{lang}', data_loader.examples_per_pos, args.transliterate) + '\n<br>'
non_dominant_leaves[leaf_label].append((leaf_num, feature_def))
# output.write(
# f'<tr> <td style=\"text-align:center\"> <b> {args.features} {label_str} </b> between the {rel} and its governor or head when: </td></tr>')
# output.write(
# f'<tr><td style=\"text-align:center\"> {feature_def} </td> <td> <a href="Leaf-{leaf_num}.html"> Examples </a> </td></tr>')
else:
leaf_examples_features[leaf_num]['valid'] = False
row += f'<td> {leaf_label} </td> <td> <a href=\"Leaf-{leaf_num}.html\"> Examples</a> </td>'
leaf_examples_features[leaf_num]['row'] = row
first_leaf = False
leaf_examples_features[leaf_num]['dispcols'] = cols
cols.sort()
leaf_cols = f'{leaf_label}{";".join(list(cols))}'
leaves_covered.add(leaf_cols)
else:
yes_cols, no_cols, missin_cols = columns_per_leaf[leaf_num].get('Y', []), columns_per_leaf[leaf_num].get('N', []), columns_per_leaf[leaf_num].get('-', [])
row = '<tr>'
num_features_in_leaf, cols, yes_cols_number, no_cols_number, missing_cols_number = 0, [], 0, 0, 0
yes_cols_text, no_cols_text = [], []
for column in columns_to_retain: # Iterate all columns
if column in yes_cols:
row += f'<td style=\"text-align:center\"> Y </td>'
num_features_in_leaf += 1
yes_cols_number += 1
cols.append(f'Y_{column}')
yes_cols_text.append(column)
elif column in no_cols:
row += f'<td style=\"text-align:center\"> N </td>'
num_features_in_leaf += 1
no_cols_number += 1
cols.append(f'N_{column}')
no_cols_text.append(column)
else:
row += f'<td style=\"text-align:center\"> - </td>'
cols.append(f'-_{column}')
missing_cols_number += 1
cols.sort()
leaf_cols = f'{leaf_label}{";".join(list(cols))}'
if leaf_cols in leaves_covered or yes_cols_number == 0: # remove leaves which have all features 'N' or "-"
leaf_examples_features[leaf_num]['valid'] = False
continue
row += f'<td> {leaf_label} </td> <td> <a href=\"Leaf-{leaf_num}.html\"> Examples</a> </td>\n'
leaf_examples_features[leaf_num]['row'] = row
leaf_examples_features[leaf_num]['dispcols'] = set(cols)
leaf_examples_features[leaf_num]['valid'] = True
fleaf.write(f'{"~~~".join(yes_cols_text)}\t{"~~~".join(no_cols_text)}\t{leaf_label}\n')
feature_def = ""
for feat_name in yes_cols_text:
feature_def += utils.transformRulesIntoReadable(feat_name, args.task,
f'{args.features}-{rel}', relation_map,
f'{args.folder_name}/{lang}',
data_loader.examples_per_pos,
args.transliterate) + '\n<br>'
non_dominant_leaves[leaf_label].append((leaf_num, feature_def))
leaf_examples_file = f'{folder_name}/{rel}/Leaf-{leaf_num}.html'
active, non_active = leaf_examples_features[leaf_num]['active'], leaf_examples_features[leaf_num]['non_active']
agree, disagree = leaf_examples_features[leaf_num]['agree'], leaf_examples_features[leaf_num][
'disagree']
utils.populateLeaf(train_data, leaf_examples_file, leaf_label, agree, disagree,
active, non_active, first_leaf, f'{args.features}-{rel}', args.task, lang_full, relation_map, columns_to_retain, ORIG_HEADER, HEADER, FOOTER
, folder_name, args.transliterate)
leaves_covered.add(leaf_cols)
first = True
for leaf_label, leaf_info in non_dominant_leaves.items():
if leaf_label == 'req-agree':
label_str = 'should match'
else:
label_str = 'need not match'
if leaf_label == dominant_label:
if first:
output.write(
f'<tr> <td style=\"text-align:center\"> Generally <b>{args.features} {label_str}<b> between the {rel} and its governor or head </td> </tr>\n')
output.write(
f'<tr><td style=\"text-align:center\"> Some examples are: <a href="Leaf-{leaf_num}.html"> Examples </a> </td></tr>\n')
first = False
continue
if leaf_label == 'req-agree':
label_str = 'should match'
else:
label_str = 'need not match'
output.write(
f'<tr> <td style=\"text-align:center\"> <b> {args.features} {label_str} </b> between the {rel} and its governor or head when: </td> </tr>')
output.write(f'<tr> <td style=\"text-align:center\">')
num = 0
for (leaf_num, feature_def) in leaf_info:
output.write(f'{feature_def} (<a href="Leaf-{leaf_num}.html"> Examples </a>)\n<br>\n')
if num < len(leaf_info) - 1:
output.write(f'<b>OR </b> <br><br>\n')
num += 1
output.write(f'</tr></td>')
output.write(f'</table>')
print()
def plot_coefficients_label(classifier, feature_names, label_list, top_features=5):
coef = classifier.coef_
num_classes = coef.shape[0]
important_features = {}
if num_classes > 2:
for class_ in range(num_classes):
label = label_list[class_]
print(label)
coefficients = coef[class_, :]
top_positive_coefficients = np.argsort(coefficients)[-top_features:]
top_negative_coefficients = np.argsort(coefficients)[:top_features]
top_coefficients = np.hstack([top_negative_coefficients, top_positive_coefficients])
feature_names = np.array(feature_names)
required_features = list(feature_names[top_coefficients][-top_features:])
required_features.reverse()
features = []
for r in required_features:
info = r
value = data_loader.feature_freq[pos].get(info,0)
features.append(r + ", " + str(value))
print("\n".join(features))
print()
important_features[class_] = required_features
else:
coef = coef.ravel()
top_positive_coefficients = np.argsort(coef)[-top_features:]
top_negative_coefficients = np.argsort(coef)[:top_features]
top_coefficients = np.hstack([top_negative_coefficients, top_positive_coefficients])
# Class = 0
label = label_list[0].split("/")[0]
print(label)
required_features = list(feature_names[top_negative_coefficients])
#required_features.reverse()
features = []
for r in required_features:
info = r
value = data_loader.feature_freq[pos].get(info,0)
features.append(r + ", " + str(value))
print("\n".join(features))
important_features[0] = required_features
# Class = 1
label = label_list[1].split("/")[0]
print(label)
required_features = list(feature_names[top_positive_coefficients])
required_features.reverse()
features = []
for r in required_features:
info = r
value = data_loader.feature_freq[pos].get(info, 0)
features.append(r + ", " + str(value))
print("\n".join(features))
important_features[1] = required_features
return important_features
def loadDataLoader(vocab_file, data_loader):
data_loader.feature_map_id2model, label2id,label_list, data_loader.examples_per_pos = {}, {}, [], {}
with open(vocab_file, 'r') as fin:
for line in fin.readlines():
if line == "" or line == '\n':
continue
elif line.startswith("Model:"):
rel = line.strip().split("Model:")[-1]
data_loader.feature_map[rel] = {}
data_loader.model_data_case[rel] = {}
data_loader.examples_per_pos[rel] = []
elif line.startswith("Data:"):
info = line.strip().split("\t")
num = int(info[0].split("Data:")[-1])
data_loader.model_data[rel] = int(info[0].split("Data:")[-1])
if num == 0:
continue
labels_values = info[2].split(";")
for label in labels_values:
lv = label.split(",")
data_loader.model_data_case[rel][lv[0]] = int(lv[1])
elif line.startswith("Feature"):
info = line.strip().split("\t")
feature_id, feature_name = info[0].lstrip().rstrip(), info[1].lstrip().rstrip()
data_loader.feature_map[rel][feature_name] = int(feature_id.split("Feature:")[1])
elif line.startswith("Labels"):
info = line.strip().split("Labels:")[1].split(",")
label_list = []
for l in info:
label_id, label_name = l.split("-")[0], l.split("-")[1]
label_list.append(label_id)
label2id[label_name] = int(label_id) #0-0, 1-1
elif line.startswith('POS:'):
info = line.strip().split("POS:")[1]
data_loader.examples_per_pos[rel].append(info)
for rel, _ in data_loader.feature_map.items():
data_loader.feature_map_id2model[rel] = {v: k for k, v in data_loader.feature_map[rel].items()}
print(f'Loaded the vocab from {vocab_file}')
data_loader.lang_full = train_path.strip().split('/')[-2].split('-')[0][3:]
return label2id, label_list
def filterData(data_loader):
""" Only train models for those relations/POS which have at least 50 examples for every label"""
classes = {}
for model, count in data_loader.model_data.items():
if count < 100: #Overall number of examples for that model is less than 100
continue
labels = data_loader.model_data_case[model]
if len(labels) == 1:
print(f'{model} always has {labels[0]} syntactic head')
continue
to_retain_labels = []
for label, value in labels.items():
if value < 50:
continue
to_retain_labels.append((label, value))
if len(to_retain_labels) == 1:
print(f'{model} majority of the is {to_retain_labels[0]} syntactic head')
continue
if len(to_retain_labels) == 0:
continue
classes[model] = to_retain_labels
#print( model, to_retain_labels)
#print()
return classes
def createPage(foldername):
filename = foldername + "/" + "Agreement.html"
if os.path.exists(filename):
with open(f"{filename}", 'a') as op:
op.write(
f"<li>{args.features}:. <a href=\"{args.features}/{args.features}.html\">Rules</a></li>\n")
else:
with open(f"{filename}", 'w') as op:
HEADER = ORIG_HEADER.replace("main.css", "../../main.css")
op.write(HEADER + "\n")
op.write(f'<ul class="nav"><li class="nav"><a class="active" href=\"../../index.html\">Home</a>'
f'</li><li class="nav"><a href=\"../../introduction.html\">Usage</a></li>'
f'<li class="nav"><a href=\"../../about.html\">About Us</a></li></ul>')
op.write(f"<br><a href=\"../../index.html\">Back to language list</a><br>")
op.write(f"<h1> {language_fullname} </h1> <br>\n")
op.write(
f'<h3> We present a framework that automatically creates a first-pass specification of rules for different linguistic phenomena from a raw text corpus for the language in question.</h3>')
op.write(
f"<br><strong>{language_fullname}</strong> exhibits the following linguist phenomena for which we extract rules:<br><ul>")
op.write(
f"<li>{args.features}:. <a href=\"{args.features}/{args.features}.html\">Rules</a></li>\n")
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--input", type=str, default='/Users/aditichaudhary/Documents/CMU/WSD-MT/en-mr/')
parser.add_argument("--file", type=str, default="./decision_tree_files.txt")
parser.add_argument("--relation_map", type=str, default="./relation_map")
parser.add_argument("--seed", type=int, default=1)
parser.add_argument("--folder_name", type=str, default='./syntax_lex/', help="Folder to hold the rules, need to add header.html, footer.html always")
parser.add_argument("--task", type=str, default="agreement")
parser.add_argument("--features", type=str, default="Gender+Person+Number")
parser.add_argument("--sud", action="store_true", default=True, help="Enable to read from SUD treebanks")
parser.add_argument("--auto", action="store_true", default=False, help="Enable to read from automatically parsed data")
parser.add_argument("--noise", action="store_true", default=False,
help="Enable to read from automatically parsed data")
parser.add_argument("--prune", action="store_true", default=True)
parser.add_argument("--binary", action="store_true", default=True)
parser.add_argument("--retainNA", action="store_true", default=False)
parser.add_argument("--no_print", action="store_true", default=False,
help="To not print the website pages")
parser.add_argument("--lang", type=str, default=None)
#Different features to experiment with
parser.add_argument("--only_triples", action="store_true", default=False, help="Only use relaton, head-pos, dep-pos, disable to use other features")
parser.add_argument("--use_wikid", action="store_true", default=False, help="Add features from WikiData, requires args.wiki_path and args.wikidata")
parser.add_argument("--wiki_path", type=str,
default="/Users/aditichaudhary/Documents/CMU/WSD-MT/babelnet_outputs/outputs/", help="Contains entity identification for nominals")
parser.add_argument("--wikidata", type=str,
default="./wikidata_processed.txt", help="Contains the WikiData property for each Qfeature")
parser.add_argument("--lexical", action="store_true", default=True, help="Add lexicalized features for head and dep")
parser.add_argument("--use_spine", action="store_true", default=False, help="Add features from spine embeddings, read from args.spine_outputs path.")
parser.add_argument("--spine_outputs", type=str, default="./spine_outputs/")
parser.add_argument("--continuous", action="store_true", default=True,
help="Add features from spine embeddings, read from args.spine_outputs path.")
parser.add_argument("--best_depth", type=int, nargs='+', default=[-1, -1, -1],
help="Set an integer betwen [3,10] to print the website with the required depth,"
"order of best-depth ['Gender', 'Person' ,'Number']")
parser.add_argument("--use_xgboost", action="store_true", default=True)
parser.add_argument("--n_jobs", type=int, default=1)
parser.add_argument("--n_thread", type=int,default=1)
parser.add_argument("--skip_models", type=str, nargs='+', default=[])
parser.add_argument("--transliterate", type=str, default=None)
args = parser.parse_args()
folder_name = f'{args.folder_name}'
with open(f"{folder_name}/header.html") as inp:
ORIG_HEADER = inp.readlines()
ORIG_HEADER = ''.join(ORIG_HEADER)
with open(f"{folder_name}/footer.html") as inp:
FOOTER = inp.readlines()
FOOTER = ''.join(FOOTER)
# populate the best-depth to print the rules for treebank mentioned in args.file
# If all values are -1 then it will search for the best performing depth by accuracy
best_depths = {'Gender': args.best_depth[0],
'Person': args.best_depth[1],
'Number': args.best_depth[2],
}
with open(args.file, "r") as inp:
files = []
test_files = defaultdict(set)
for file in inp.readlines():
if file.startswith("#"):
continue
file_info = file.strip().split()
if args.lang and args.lang not in file_info:
continue
files.append(f'{args.input}/{file_info[0]}')
if len(file_info) > 1: # there are test files mentioned
for test_file in file_info[1:]:
test_file = f'{args.input}/{test_file}'
test_files[f'{args.input}/{file_info[0]}'].add(test_file.lstrip().rstrip())
d = {}
relation_map = {}
with open(args.relation_map, "r") as inp:
for line in inp.readlines():
info = line.strip().split(";")
key = info[0]
value = info[1]
relation_map[key] = (value, info[-1])
if '@x' in key:
relation_map[key.split("@x")[0]] = (value, info[-1])
#Get the wikiparsed data
features = args.features.split("+")
for fnum, treebank in enumerate(files):
train_path, dev_path, test_path, lang = utils.getTreebankPaths(treebank.strip(), args)
test_files[treebank].add(test_path)
if train_path is None:
print(f'Skipping the treebank as no training data!')
continue
language_fullname = "_".join(os.path.basename(treebank).split("_")[1:])
lang_full = lang
lang_id = lang.split("_")[0]
if args.auto:
lang = f'{lang}_auto'
elif args.noise:
lang = f'{lang}_noise'
# train a classifier for each dependent child POS
try: # Create the model dir if not already present
os.mkdir(f"{folder_name}/{lang}/")
except OSError:
i = 0
filename = f"{folder_name}/{lang}/Agreement/"
try: # Create the model dir if not already present
os.mkdir(f"{folder_name}/{lang}/Agreement")
except OSError:
i = 0
# Get spine embedding
spine_word_vectors, spine_features, spine_dim = None, [], 0
if args.use_spine:
spine_word_vectors, spine_features, spine_dim = utils.loadSpine(args.spine_outputs, lang_id,
args.continuous)
genre_train_data, genre_dev_data, genre_test_data, wikiData = utils.getWikiFeatures(args, lang)
for feature in features:
if args.skip_models and feature in args.skip_models:
continue
print(feature)
args.features = feature
try: # Create the model dir if not already present
os.mkdir(f"{folder_name}/{lang}/Agreement/{args.features}")
except OSError:
i = 0
with open(f"{folder_name}/{lang}/Agreement/{args.features}/{args.features}.html", 'w') as op:
HEADER = ORIG_HEADER.replace("main.css", "../../../main.css")
op.write(HEADER + "\n")
op.write(f'<ul class="nav"><li class="nav"><a class="active" href=\"../../../index.html\">Home</a>'
f'</li><li class="nav"><a href=\"../../../introduction.html\">Usage</a></li>'
f'<li class="nav"><a href=\"../../../about.html\">About Us</a></li></ul>')
op.write(f"<br><a href=\"../../../index.html\">Back to language list</a><br>")
op.write(f"<h1> {args.features} agreement for {language_fullname} </h1> <br>\n")
data_loader = dataloader.DataLoader(args, relation_map)
# Creating the vocabulary
input_dir = f"{folder_name}/{lang}/Agreement/"
vocab_file = input_dir + f'/vocab_{feature}.txt'
inputFiles = [train_path, dev_path, test_path]
data_loader.readData(inputFiles, [genre_train_data, genre_dev_data, genre_test_data],
wikiData, args.features,
vocab_file,
spine_word_vectors,
spine_features,
spine_dim
)
# Get the model info i.e. which models do we have to train e.g. subject-verb, object-verb and so on.
modelsData = filterData(data_loader)
if not modelsData:
continue
#createPage(filename)
for model, to_retain_labels in modelsData.items():
if args.skip_models and model in args.skip_models:
continue
try: # Create the model dir if not already present
os.mkdir(f"{filename}/{args.features}/{model}/")
except OSError:
i = 0
op.write(f"<li> {args.features} agreement for {model}-words </h1> <a href=\"{model}/{model}.html\"> {model} </a> </li>\n")
train_file = f'{filename}/{args.features}/{model}/train.feats.libsvm' # Stores the features
dev_file = f'{filename}/{args.features}/{model}/dev.feats.libsvm'
test_file = f'{filename}/{args.features}/{model}/test.feats.libsvm'
columns_file = f'{filename}/{args.features}/{model}/column.feats'
labels = [0,1]#
if not (os.path.exists(train_file) and os.path.exists(test_file)):
train_features, columns, output_labels = data_loader.getAssignmentFeatures(train_path, genre_train_data, wikiData, args.features, model, spine_word_vectors, spine_features, spine_dim, train_file)
dev_df = None
if dev_path:
dev_features, _, _ = data_loader.getAssignmentFeatures(dev_path,genre_dev_data, wikiData, args.features, model, spine_word_vectors, spine_features, spine_dim, dev_file)
test_features, _, _ = data_loader.getAssignmentFeatures(test_path, genre_test_data, wikiData, args.features, model, spine_word_vectors, spine_features, spine_dim, test_file)
# Reload the df again, as some issue with first loading, print(f'Reading train/dev/test from {lang}/{pos}')
print(f'Loading train/dev/test...')
label2id, label_list = loadDataLoader(vocab_file, data_loader)
train_features, train_labels, \
dev_features, dev_labels, \
test_features, test_labels, \
baseline_label, \
id2label, minority, majority = utils.getModelTrainingDataLibsvm(train_file, dev_file, test_file,
label2id,
data_loader.model_data_case[model])
y_baseline = [label2id[baseline_label]] * len(test_labels)
baseline_acc = accuracy_score(test_labels, y_baseline) * 100.0
tree_features = data_loader.feature_map_id2model[model] # feature_name: feature_id
print('Training Started...')
train_data_path = train_file.replace("libsvm", "")
test_data_path = test_file.replace("libsvm", "")
test_datasets = [(test_features, test_labels, lang_full, test_data_path, test_path)]
# try:
train(train_features, train_labels, train_path, train_data_path,
dev_features, dev_labels,
test_features, test_labels, test_path, test_data_path,
model, baseline_label,
f'{filename}/{args.features}/', lang_full, tree_features,
relation_map, best_depths,
genre_train_data, wikiData, spine_word_vectors, spine_features, spine_dim, test_datasets)
# except Exception as e:
#except Exception as e:
# print(f'ERROR: Skipping {lang_full} - {model}')
# continue
with open(f"{folder_name}/{lang}/index_agreement.html", 'a') as outp:
outp.write("</ul><br><br><br>\n" + FOOTER + "\n")
| 50,675 | 53.607759 | 311 | py |
SMIL | SMIL-main/src/train_soundmnist.py | from __future__ import print_function, absolute_import, division
import os
import time
import math
import datetime
import argparse
import os.path as path
import numpy as np
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from dataset.soundmnist import SoundMNIST
from models.soundlenet5 import SoundLenet5
from models.lenet5 import LeNet5
from models.snet import SNetPluse
from utils.misc import save_ckpt
def parse_args():
parser = argparse.ArgumentParser(description='PyTorch training script')
# general parm
parser.add_argument('-i', '--image_root', default = '../data/mnist/', type = str, help='data root' )
parser.add_argument('-s', '--sound_root', default = '../data/sound_450/', type = str, help='data root' )
parser.add_argument('--checkpoint', default='./save/soundmnist/21', type=str, help='checkpoint directory')
parser.add_argument('--snapshot', default=1, type=int, help='save models for every # epochs (default: 1)')
parser.add_argument('--sound_model_path', default='./save/sound/450/21/2020-09-07T10:29:39.479065',
type=str, help='trained teacher mdoel')
parser.add_argument('--sound_model_name', default='epoch_13_test_accuracy_80.44444444444444_train_accuracy_100.0_best_model.path.tar',
type=str, help='trained teacher mdoel')
parser.add_argument('--img_model_path', default='./save/mnist/new/105/2020-04-20T14:31:09.289049',
type=str, help='pre-traiend student pathh')
parser.add_argument('--img_model_name', default='epoch_27_test_accuracy_92.22_train_accuracy_98.76190476190476_best_model.path.tar',
type=str, help='pre-traiend student name')
# model related parm
parser.add_argument('-b', '--batch_size', default = 32, type = int, help='batch size' )
parser.add_argument('-e', '--epochs', default = 60, type = int, help='num of epoch' )
parser.add_argument('--lr', default = 1e-3, type = float, help='initial learning rate' )
parser.add_argument('--per_class_num', default = 21 , type = int, help='per_class_num' )
parser.add_argument('--vis_device', default='0', type=str, help='set visiable device')
args = parser.parse_args()
return args
def main(args):
cudnn.benchmark = True
os.environ["CUDA_VISIBLE_DEVICES"] = args.vis_device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
train_dataset = SoundMNIST(img_root=args.image_root,sound_root=args.sound_root, per_class_num=args.per_class_num, train=True)
val_dataseet = SoundMNIST(img_root=args.image_root,sound_root=args.sound_root, per_class_num=args.per_class_num, train=False)
train_loader = DataLoader(train_dataset, batch_size = args.batch_size, shuffle = True, num_workers=1, pin_memory=True)
val_loader = DataLoader(val_dataseet, batch_size = args.batch_size, shuffle = False, num_workers=1, pin_memory=True)
#creat model
print('==> model creating....')
extractor1 = LeNet5().to(device)
ckpt_extractor1 = torch.load(path.join(args.img_model_path, args.img_model_name))
extractor1.load_state_dict(ckpt_extractor1['state_dict'])
extractor2 = SNetPluse().to(device)
ckpt_extractor2 = torch.load(path.join(args.sound_model_path, args.sound_model_name))
extractor2.load_state_dict(ckpt_extractor2['state_dict'])
model = SoundLenet5(extractor1, extractor2, extractor_grad=True).to(device)
# model = LeNet5().to(device)p
print('==> mdoel has been created')
print("==> Total parameters (reference): {:.2f}M".format(sum(p.numel() for p in model.parameters()) / 1000000.0))
criterion = nn.CrossEntropyLoss().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr = args.lr, weight_decay = 1e-4)
# optimizer = torch.optim.SGD(model.parameters(), lr = args.lr, momentum=0.80, weight_decay = 0, nesterov=True)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size = 30, gamma = 0.1)
# scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', patience = 2)
total_step = len(train_loader)
start_epoch = 0
best_val_acc =None
glob_step = 0
evl_step = 0
ckpt_dir_path = path.join(args.checkpoint, datetime.datetime.now().isoformat())
if not path.exists(ckpt_dir_path):
os.makedirs(ckpt_dir_path)
print('==> Making checkpoint dir: {}'.format(ckpt_dir_path))
writer = SummaryWriter(log_dir=ckpt_dir_path)
print('start training')
for epoch in range(args.epochs):
# Train for one epoch
glob_step = train(train_loader, model, criterion, optimizer, device, writer, glob_step, total_step, epoch, args.epochs, scheduler)
scheduler.step() # need only in step lr
train_acc = eval(train_loader, model, device, epoch , writer)
val_acc = eval(val_loader, model, device, epoch , writer)
torch.set_grad_enabled(True)
print('Epoch:[{}/{}], Train ACC:{:.5f}, Test Acc:{:.5f}' .format(epoch+1, args.epochs, train_acc, val_acc))
# save best model
if epoch + 1 >= 4:
if best_val_acc is None or best_val_acc < val_acc:
best_val_acc = val_acc
train_acc = eval(train_loader, model, device, epoch , writer)
torch.set_grad_enabled(True)
print('Epoch:[{}/{}], Train ACC:{:.4f}, Test ACC Score:{:.4f} ' .format(epoch+1, args.epochs, train_acc, best_val_acc))
save_ckpt({'epoch': epoch + 1, 'lr': args.lr, 'step': glob_step, 'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict() }, ckpt_dir_path, epoch = epoch + 1, best_acc = best_val_acc, train_acc=train_acc)
writer.close()
def train(train_loader, model, criterion, optimizer, device, writer, step, total_step, epoch, total_epoch, scheduler):
''' train one epoch'''
torch.set_grad_enabled(True)
tic = time.time()
# thresholds = 0.6
for i, batch in enumerate(train_loader):
step += 1
images = batch[0].to(device)
sounds = batch[1].to(device)
labels = batch[2].to(device)
# Forward pass
outputs,_,_,sound_f,_ = model(labels, images, sound=sounds, mode='two')
loss = criterion(outputs, labels)
# Backward and optimize
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (i+1) % 10 == 0:
print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}' .format(epoch+1, total_epoch, i+1, total_step, loss.item()))
writer.add_scalar('Training Loss', loss.item(), step)
return step
def eval(test_loader, model, device, epoch, writer):
# Switch to evaluate mode
torch.set_grad_enabled(False)
model.eval()
correct = 0
total = 0
for i, batch in enumerate(test_loader):
images = batch[0].to(device)
sounds = batch[1].to(device)
labels = batch[2].to(device)
outputs,_,_,_,_ = model(labels, images,sound=sounds, mode='two')
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
test_acc = 100 * correct / total
return test_acc
if __name__ == '__main__':
main(parse_args()) | 7,491 | 37.818653 | 159 | py |
SMIL | SMIL-main/src/get_sound_mean_kmean.py | from __future__ import print_function, absolute_import, division
import os
import time
import math
import datetime
import argparse
import os.path as path
import numpy as np
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from dataset.soundmnist import SoundMNIST
from models.soundlenet5 import SoundLenet5mean
from models.lenet5 import LeNet5
from models.snet import SNetPluse
from utils.misc import save_ckpt
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
def parse_args():
parser = argparse.ArgumentParser(description='PyTorch training script')
# general parm
parser.add_argument('-i', '--image_root', default = '../data/mnist/', type = str, help='data root' )
parser.add_argument('-s', '--sound_root', default = '../data/sound_450/', type = str, help='data root' )
parser.add_argument('--checkpoint', default='./save/sound_mean/new/', type=str, help='checkpoint directory')
parser.add_argument('--per_class_num', default = 15, type = int, help='per_class_num' )
parser.add_argument('--n_clusters', default = 10, type = int, help='n_clusters' )
parser.add_argument('--snapshot', default=1, type=int, help='save models for every # epochs (default: 1)')
parser.add_argument('--soundmnist_model_path', default='./save/soundmnist/new/15/2022-04-04T09:34:24.967372/',
type=str, help='pre-trained sound mnist model')
parser.add_argument('--soundmnist_model_name', default='epoch_30_test_accuracy_87.55555555555556_train_accuracy_100.0_best_model.path.tar',
type=str, help='pre-trained sound mnist model')
# model related parm
parser.add_argument('-b', '--batch_size', default = 32, type = int, help='batch size' )
parser.add_argument('-e', '--epochs', default = 1, type = int, help='num of epoch' )
parser.add_argument('--lr', default = 1e-3, type = float, help='initial learning rate' )
parser.add_argument('--vis_device', default='0', type=str, help='set visiable device')
args = parser.parse_args()
return args
def main(args):
cudnn.benchmark = True
os.environ["CUDA_VISIBLE_DEVICES"] = args.vis_device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
train_dataset = SoundMNIST(img_root=args.image_root,sound_root=args.sound_root, per_class_num=args.per_class_num, train=True)
train_loader = DataLoader(train_dataset, batch_size = args.batch_size, shuffle = True, num_workers=1, pin_memory=True)
#creat model
print('==> model creating....')
extractor1 = LeNet5().to(device)
extractor2 = SNetPluse().to(device)
image_sound_extractor = SoundLenet5mean(extractor1, extractor2, extractor_grad=False).to(device)
ckpt_image_sound = torch.load(path.join(args.soundmnist_model_path, args.soundmnist_model_name))
image_sound_extractor.load_state_dict(ckpt_image_sound['state_dict'])
ckpt_dir_path = path.join(args.checkpoint)
if not path.exists(ckpt_dir_path):
os.makedirs(ckpt_dir_path)
print('==> Making checkpoint dir: {}'.format(ckpt_dir_path))
final_mean = list()
print('start training')
for epoch in range(args.epochs):
# Train for one epoch
sound_mean = torch.randn(1, 320).to(device)
sound_mean = train(train_loader, image_sound_extractor, sound_mean, device)
final_mean.append(sound_mean[1:,:])
kmeans = KMeans(n_clusters=args.n_clusters, random_state=0).fit(final_mean[0].cpu().numpy())
new_mean = kmeans.cluster_centers_
save_path = path.join(ckpt_dir_path, 'sound_mean_' + str(args.per_class_num*10)+'.npy')
print(new_mean.shape)
np.save(save_path, new_mean)
print('done save!!!')
def train(train_loader, model, sound_mean,device):
''' train one epoch'''
torch.set_grad_enabled(False)
model.eval()
for i, batch in enumerate(train_loader):
images = batch[0].to(device)
sounds = batch[1].to(device)
labels = batch[2].to(device)
outputs, feature = model(images, sound=sounds, mode='two')
sound_mean = torch.cat([sound_mean, feature], dim=0)
return sound_mean
if __name__ == '__main__':
main(parse_args()) | 4,355 | 35 | 144 | py |
SMIL | SMIL-main/src/train_missing_eval_missing.py | from __future__ import print_function, absolute_import, division
import os
import time
import math
import datetime
import argparse
import os.path as path
import numpy as np
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from models.lenet5 import LeNet5
from models.soundlenet5 import SoundLenet5, SoundLenet5New, SoundLenet5Class
from models.snet import SNetPluse
from models.classifier import ClassfierNet
from models.newencoder import InferNet, InferNetNew
from models.loss import KDFeatureLoss, KDFeatureLossTwo, KDLossAlignTwo
from dataset.meta_training_dataset import MetaTrSouMNIST
from dataset.meta_testing_dataset import MetaTeSouMNIST
from dataset.soundmnist import SoundMNIST
from dataset.mnist import MNIST
from utils.misc import AverageMeter, AvgF1, save_ckpt, save_ckpt_inferNet, save_ckpt_classifier
from metann import ProtoModule
def parse_args():
parser = argparse.ArgumentParser(description='PyTorch training script')
parser.add_argument('-i', '--image_root', default = '../data/mnist/', type = str, help='data root' )
parser.add_argument('-s', '--sound_root', default = '../data/sound_450/', type = str, help='data root' )
parser.add_argument('--checkpoint', default='./save/metadrop_new/feature/15', type=str, help='checkpoint directory')
parser.add_argument('--snapshot', default=1, type=int, help='save models for every # epochs (default: 1)')
parser.add_argument('--soundmnist_model_path', default='./save/soundmnist/path/',
type=str, help='pre-trained sound mnist model')
parser.add_argument('--soundmnist_model_name', default='name/of/best_model.path.tar',
type=str, help='pre-trained sound mnist model')
parser.add_argument('--sound_mean_path', default='./save/sound_mean/kmean/path/',
type=str, help='pre calculated sound mean path')
parser.add_argument('--sound_mean_name', default='sound_mean_150.npy',
type=str, help='pre calculated sound mean name')
# model related parm
parser.add_argument('-b', '--batch_size', default = 128, type = int, help='batch size' )
parser.add_argument('--per_class_num', default = 15 , type = int, help='per_class_num' ) # 15 * 10 = 150 sound data available, total 1500 sound data
parser.add_argument('--iterations', default = 8000 , type = int, help='num of epoch' )
parser.add_argument('--lr', default = 1e-3, type = float, help='initial learning rate' )
parser.add_argument('--lr_inner', default = 1e-3, type = float, help='initial learning rate' )
parser.add_argument('--inner_loop', default = 1, type = int, help='meta_train inner_loop' )
parser.add_argument('--mc_size', default = 30, type = int, help='MC size for meta-test' )
parser.add_argument('--vis_device', default='0', type=str, help='set visiable device')
args = parser.parse_args()
return args
def main(args):
cudnn.benchmark = True
os.environ["CUDA_VISIBLE_DEVICES"] = args.vis_device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# meta-train step dataset
meta_train_dataset = MetaTrSouMNIST(img_root=args.image_root, sound_root=args.sound_root,
per_class_num=args.per_class_num, meta_split='mtr')
meta_val_dataset = MetaTrSouMNIST(img_root=args.image_root, sound_root=args.sound_root,
per_class_num=args.per_class_num, meta_split='mval')
meta_train_loader = DataLoader(meta_train_dataset, batch_size = args.batch_size, shuffle = True,
num_workers=0, pin_memory=True)
meta_val_loader = DataLoader(meta_val_dataset, batch_size = args.batch_size, shuffle = True,
num_workers=0, pin_memory=True)
# meta-training dataset
meta_test_dataset = SoundMNIST(img_root=args.image_root,sound_root=args.sound_root, per_class_num=args.per_class_num, train=False)
meta_test_loader = DataLoader(meta_test_dataset, batch_size = args.batch_size, shuffle = False, num_workers=0, pin_memory=True)
print('train data size:', len(meta_train_dataset))
print('val data size:', len(meta_val_dataset))
print('test data size:',len(meta_test_dataset))
#creat model
print('==> model creating....')
encoder = InferNetNew().to(device) # auxilary model to infer the missing modality
encoder = ProtoModule(encoder)
i_extractor = LeNet5().to(device) # image extractor
s_extractor = SNetPluse().to(device) # sound extractor
image_sound_extractor = SoundLenet5New(i_extractor, s_extractor, extractor_grad=False).to(device) # multimodal fusion model
ckpt_image_sound = torch.load(path.join(args.soundmnist_model_path, args.soundmnist_model_name)) # load pre-trained weight
image_sound_extractor.load_state_dict(ckpt_image_sound['state_dict'])
image_sound_extractor = ProtoModule(image_sound_extractor)
# load pre calculated sound mean
sound_mean = np.load(os.path.join(args.sound_mean_path, args.sound_mean_name))
sound_mean = torch.from_numpy(sound_mean).T.to(device)
print('==> mdoel has been created')
print("==> Total parameters (reference): {:.2f}M".format(sum(p.numel() for p in image_sound_extractor.parameters()) / 1000000.0))
criterion_meta_train = nn.CrossEntropyLoss().to(device)
criterion_meta_val = KDLossAlignTwo(alpha = 0.01, beta = 0.01).to(device)
optimizer_image_sound = torch.optim.Adam(image_sound_extractor.parameters(), lr = args.lr, weight_decay = 1e-4)
optimizer_encoder = torch.optim.Adam(encoder.parameters(), lr = args.lr, weight_decay = 1e-4)
scheduler_image_sound = torch.optim.lr_scheduler.StepLR(optimizer_image_sound, step_size = 5000, gamma = 0.1)
scheduler_encoder = torch.optim.lr_scheduler.StepLR(optimizer_encoder, step_size = 5000, gamma = 0.1)
best_val_acc =None
glob_step = 0
evl_step = 0
ckpt_dir_path = path.join(args.checkpoint, datetime.datetime.now().isoformat())
# print(ckpt_dir_path)
if not path.exists(ckpt_dir_path):
os.makedirs(ckpt_dir_path)
print('==> Making checkpoint dir: {}'.format(ckpt_dir_path))
writer = SummaryWriter(log_dir=ckpt_dir_path)
print('start training')
for iterate in range(args.iterations):
# Train for one iteration
if iterate == 0:
test_image_acc_i = eval_image_test(meta_test_loader, image_sound_extractor, encoder, sound_mean, device, writer)
mtr_image_acc_i = eval_image_train(meta_train_loader, image_sound_extractor, encoder, sound_mean, device, writer)
mval_image_acc_i = eval_image_test(meta_val_loader, image_sound_extractor, encoder, sound_mean, device, writer)
torch.set_grad_enabled(True)
print('Initial Model ACC: mtr image acc:{:.4f}, mval image acc:{:.4f}, image-only test acc:{:.4f}' .format(mtr_image_acc_i, mval_image_acc_i, test_image_acc_i))
meta_train_batch = next(iter(meta_train_loader))
meta_val_batch = next(iter(meta_val_loader))
glob_step = meta_training(args, meta_train_batch, meta_val_batch, sound_mean, image_sound_extractor, encoder, criterion_meta_train, criterion_meta_val, optimizer_image_sound, optimizer_encoder, device, writer, iterate, args.iterations)
scheduler_image_sound.step()
scheduler_encoder.step()
if (iterate) % 200 == 0:
test_image_acc = 0.
for i in range(30):
test_image_acc += eval_image_test(meta_test_loader, image_sound_extractor, encoder, sound_mean, device, writer)
test_image_acc = test_image_acc / 30
mtr_image_acc = eval_image_train(meta_train_loader, image_sound_extractor, encoder, sound_mean, device, writer)
mval_image_acc = eval_image_test(meta_val_loader, image_sound_extractor, encoder, sound_mean, device, writer)
torch.set_grad_enabled(True)
print('Iteration:[{}/{}], mtr image acc:{:.6f}, mval image acc:{:.6f}, image-only test acc:{:.6f}' .format(iterate, args.iterations, mtr_image_acc, mval_image_acc, test_image_acc))
# save best model
if (iterate ) >= 1200:
if best_val_acc is None or best_val_acc < test_image_acc:
best_val_acc = test_image_acc
torch.set_grad_enabled(True)
print('Iteration:[{}/{}], Image-only Test Acc:{:.6f} ' .format(iterate, args.iterations, best_val_acc))
save_ckpt_classifier({'iterate': iterate, 'lr': args.lr, 'state_dict': image_sound_extractor.state_dict(),
'optimizer': optimizer_image_sound.state_dict() }, ckpt_dir_path, iteration = iterate , best_acc = best_val_acc)
save_ckpt_inferNet({'iterate': iterate, 'lr': args.lr, 'step': glob_step, 'state_dict': encoder.state_dict(),
'optimizer': optimizer_encoder.state_dict() }, ckpt_dir_path, iteration = iterate )
writer.close()
def meta_training(args, meta_train_batch, meta_val_batch, sound_mean, image_sound_extractor, encoder, criterion_meta_train, criterion_meta_val, optimizer_image_sound, optimizer_encoder, device, writer, iterate, total_iterate):
''' train one epoch'''
batch_time = AverageMeter()
data_time = AverageMeter()
losses= AverageMeter()
torch.set_grad_enabled(True)
batch_size = meta_train_batch[0].shape[0]
# batch of meta train: sampled from image modality
meta_train_image = meta_train_batch[0].to(device)
meta_train_label = meta_train_batch[1].to(device)
# batch of meta validaiton: sampled from both image and sound modality
meta_val_image = meta_val_batch[0].to(device)
meta_val_sound = meta_val_batch[1].to(device)
meta_val_label = meta_val_batch[2].to(device)
# meta-training
params = list(image_sound_extractor.parameters())
for i in params:
if not i.requires_grad:
i.requires_grad = True
loss_meta_train = 0.
loss_meta_val = 0.
mse_loss = nn.MSELoss(reduction='mean')
for idx in range(args.inner_loop):
if idx == 0:
params_star = params
pred_meta_train_noised,_,_,_ = image_sound_extractor.functional(params_star, True)(meta_train_label, meta_train_image, sound=None, encoder=encoder, sound_mean=sound_mean, noise_layer=['fc0','fc1','fc2'], meta_train=True, mode='one')
loss_meta_train = criterion_meta_train(pred_meta_train_noised, meta_train_label)
torch.autograd.set_detect_anomaly(True)
grads = torch.autograd.grad(loss_meta_train, params_star, allow_unused=True, create_graph=True) # create_graph=True: allow second order derivative
for i in range(len(params_star)):
if i <= 7 or i >=26:# not update the sound branch
if grads[i] is not None: # unused parameters have no gradient
params_star[i] = (params_star[i] - args.lr_inner*(0.1**(iterate//1000))*grads[i]).requires_grad_()
pred_meta_val_noised, f_meta_val_noised1,f_meta_val_noised2, sound_mean_val_noised = image_sound_extractor.functional(params_star, True)(meta_val_label, meta_val_image, sound=None, encoder=encoder, sound_mean=sound_mean, noise_layer=['fc0','fc1','fc2'], meta_train=False, mode='one')
pred_meta_val_clean, f_meta_val_clean1,f_meta_val_clean2, sound_mean_val_clean = image_sound_extractor.functional(params_star, True)(meta_val_label, meta_val_image, sound=meta_val_sound, mode='two')
sound_mean_val_mse = mse_loss(sound_mean_val_clean, sound_mean_val_noised)
loss_meta_val = criterion_meta_val(sound_mean_val_clean, sound_mean_val_noised, f_meta_val_clean1, f_meta_val_noised1, f_meta_val_clean2, f_meta_val_noised2, pred_meta_val_noised, pred_meta_val_clean, meta_val_label)
optimizer_encoder.zero_grad()
optimizer_image_sound.zero_grad()
(loss_meta_train + loss_meta_val).backward(create_graph=True)
optimizer_encoder.step()
optimizer_image_sound.step()
torch.cuda.empty_cache()
if (iterate) % 100 == 0:
print('Iteration [{}/{}], meta-train Loss: {:.4f}, meta-val Loss: {:.4f},' .format(iterate, total_iterate,
loss_meta_train.item(), loss_meta_val.item()))
writer.add_scalar('meta-train loss', loss_meta_train.item(), iterate)
writer.add_scalar('meta-val loss', loss_meta_val.item(), iterate)
writer.add_scalar('sound_mean val mse Loss', sound_mean_val_mse.item(), iterate)
return iterate
def eval_image_test(test_loader, image_sound_extractor, encoder,sound_mean, device, writer):
# Switch to evaluate mode
torch.set_grad_enabled(False)
image_sound_extractor.eval()
correct = 0
total = 0
for i, batch in enumerate(test_loader):
images = batch[0].to(device)
sounds = batch[1].to(device)
labels = batch[2].to(device)
outputs,_,_,_ = image_sound_extractor(labels, images, sound=None, encoder=encoder, sound_mean=sound_mean, noise_layer=['fc0','fc1','fc2'], meta_train=False, mode='one')
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
test_acc = 100 * correct / total
return test_acc
def eval_image_train(test_loader, image_sound_extractor, encoder,sound_mean, device, writer):
# Switch to evaluate mode
torch.set_grad_enabled(False)
image_sound_extractor.eval()
correct = 0
total = 0
for i, batch in enumerate(test_loader):
images = batch[0].to(device)
labels = batch[1].to(device)
outputs,_,_,_ = image_sound_extractor(labels, images, sound=None, encoder=encoder, sound_mean=sound_mean, noise_layer=['fc0','fc1','fc2'], meta_train=False, mode='one')
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
test_acc = 100 * correct / total
return test_acc
if __name__ == '__main__':
main(parse_args()) | 14,388 | 44.391167 | 287 | py |
SMIL | SMIL-main/src/train_sound.py | from __future__ import print_function, absolute_import, division
import os
import time
import math
import datetime
import argparse
import os.path as path
import numpy as np
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from dataset.soundmnist import SoundMNIST
from dataset.sound import Sound
# from models.soundlenet5 import SoundLenet5
# from models.lenet5 import LeNet5
from models.snet import SNet, SNetPluse
from utils.misc import save_ckpt
def parse_args():
parser = argparse.ArgumentParser(description='PyTorch training script')
# general parm
parser.add_argument('-s', '--sound_root', default = '../data/sound_450/', type = str, help='data root' )
parser.add_argument('--checkpoint', default='./save/sound/450/21', type=str, help='checkpoint directory')
parser.add_argument('--snapshot', default=1, type=int, help='save models for every # epochs (default: 1)')
# model related parm
parser.add_argument('-b', '--batch_size', default = 4, type = int, help='batch size' )
parser.add_argument('-e', '--epochs', default = 35 , type = int, help='num of epoch' )
parser.add_argument('--lr', default = 1e-3, type = float, help='initial learning rate' )
parser.add_argument('--per_class_num', default = 21 , type = int, help='per_class_num' )
parser.add_argument('--vis_device', default='0', type=str, help='set visiable device')
args = parser.parse_args()
return args
def main(args):
cudnn.benchmark = True
os.environ["CUDA_VISIBLE_DEVICES"] = args.vis_device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
train_dataset = Sound(sound_root=args.sound_root, per_class_num=args.per_class_num, train=True)
val_dataseet = Sound(sound_root=args.sound_root, per_class_num=args.per_class_num, train=False)
train_loader = DataLoader(train_dataset, batch_size = args.batch_size, shuffle = True, num_workers=2, pin_memory=True)
val_loader = DataLoader(val_dataseet, batch_size = args.batch_size, shuffle = False, num_workers=2, pin_memory=True)
#creat model
print('==> model creating....')
model = SNetPluse().to(device)
print('==> mdoel has been created')
print("==> Total parameters (reference): {:.2f}M".format(sum(p.numel() for p in model.parameters()) / 1000000.0))
criterion = nn.CrossEntropyLoss().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr = args.lr, weight_decay = 1e-4)
# optimizer = torch.optim.SGD(model.parameters(), lr = args.lr, momentum=0.80, weight_decay = 0, nesterov=True)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size = 10, gamma = 0.5)
# scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', patience = 2)
total_step = len(train_loader)
start_epoch = 0
best_val_acc =None
glob_step = 0
evl_step = 0
ckpt_dir_path = path.join(args.checkpoint, datetime.datetime.now().isoformat())
if not path.exists(ckpt_dir_path):
os.makedirs(ckpt_dir_path)
print('==> Making checkpoint dir: {}'.format(ckpt_dir_path))
writer = SummaryWriter(log_dir=ckpt_dir_path)
print('start training')
for epoch in range(args.epochs):
# Train for one epoch
glob_step = train(train_loader, model, criterion, optimizer, device, writer, glob_step, total_step, epoch, args.epochs, scheduler)
scheduler.step() # need only in step lr
train_acc = eval(train_loader, model, device, epoch , writer)
val_acc = eval(val_loader, model, device, epoch , writer)
torch.set_grad_enabled(True)
print('Epoch:[{}/{}], Train ACC:{:.6f},Test Acc:{:.6f}' .format(epoch+1, args.epochs, train_acc, val_acc))
# save best model
if epoch + 1 > 10:
if best_val_acc is None or best_val_acc < val_acc:
best_val_acc = val_acc
train_acc = eval(train_loader, model, device, epoch , writer)
torch.set_grad_enabled(True)
print('Epoch:[{}/{}], Train ACC:{:.4f}, Test ACC Score:{:.4f} ' .format(epoch+1, args.epochs, train_acc, best_val_acc))
save_ckpt({'epoch': epoch + 1, 'lr': args.lr, 'step': glob_step, 'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict() }, ckpt_dir_path, epoch = epoch + 1, best_acc = best_val_acc, train_acc=train_acc)
writer.close()
def train(train_loader, model, criterion, optimizer, device, writer, step, total_step, epoch, total_epoch, scheduler):
''' train one epoch'''
torch.set_grad_enabled(True)
tic = time.time()
# thresholds = 0.6
for i, (sounds, labels) in enumerate(train_loader):
step += 1
sounds = sounds.to(device)
labels = labels.to(device)
# Forward pass
outputs,_ = model(sounds)
loss = criterion(outputs, labels)
# Backward and optimize
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (i+1) % 10 == 0:
print('Epoch [{}/{}], Step [{}/{}], Loss: {:.6f}' .format(epoch+1, total_epoch, i+1, total_step, loss.item()))
writer.add_scalar('Training Loss', loss.item(), step)
return step
def eval(test_loader, model, device, epoch, writer):
# Switch to evaluate mode
torch.set_grad_enabled(False)
model.eval()
correct = 0
total = 0
for i, (sounds,labels) in enumerate(test_loader):
sounds = sounds.to(device)
labels = labels.to(device)
outputs,_ = model(sounds)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
test_acc = 100 * correct / total
return test_acc
if __name__ == '__main__':
main(parse_args()) | 6,017 | 34.4 | 159 | py |
SMIL | SMIL-main/src/train_mnist.py | from __future__ import print_function, absolute_import, division
import os
import time
import math
import datetime
import argparse
import os.path as path
import numpy as np
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from dataset.mnist import MNIST
from models.lenet5 import LeNet5
from utils.misc import save_ckpt
def parse_args():
parser = argparse.ArgumentParser(description='PyTorch training script')
# general parm
parser.add_argument('-d', '--data_root', default = '../data/mnist/', type = str, help='data root' )
parser.add_argument('--checkpoint', default='./save/mnist_pca/105', type=str, help='checkpoint directory')
parser.add_argument('--snapshot', default=1, type=int, help='save models for every # epochs (default: 1)')
# model related parm
parser.add_argument('-b', '--batch_size', default = 64, type = int, help='batch size' )
parser.add_argument('-e', '--epochs', default = 50 , type = int, help='num of epoch' )
parser.add_argument('--lr', default = 1e-3, type = float, help='initial learning rate' )
parser.add_argument('--per_class_num', default = 105 , type = int, help='per_class_num' )
parser.add_argument('--vis_device', default='0', type=str, help='set visiable device')
args = parser.parse_args()
return args
def main(args):
cudnn.benchmark = True
os.environ["CUDA_VISIBLE_DEVICES"] = args.vis_device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
train_dataset = MNIST(root=args.data_root, per_class_num=args.per_class_num, train=True)
val_dataseet = MNIST(root=args.data_root, train=False)
train_loader = DataLoader(train_dataset, batch_size = args.batch_size, shuffle = True, num_workers=1, pin_memory=True)
val_loader = DataLoader(val_dataseet, batch_size = args.batch_size, shuffle = False, num_workers=1, pin_memory=True)
#creat model
print('==> model creating....')
model = LeNet5().to(device)
print('==> mdoel has been created')
print("==> Total parameters (reference): {:.2f}M".format(sum(p.numel() for p in model.parameters()) / 1000000.0))
criterion = nn.CrossEntropyLoss().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr = args.lr, weight_decay = 1e-4)
# optimizer = torch.optim.SGD(model.parameters(), lr = args.lr, momentum=0.80, weight_decay = 0, nesterov=True)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size = 20, gamma = 0.1)
# scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', patience = 2)
total_step = len(train_loader)
start_epoch = 0
best_val_acc =None
glob_step = 0
evl_step = 0
ckpt_dir_path = path.join(args.checkpoint, datetime.datetime.now().isoformat())
# print(ckpt_dir_path)
if not path.exists(ckpt_dir_path):
os.makedirs(ckpt_dir_path)
print('==> Making checkpoint dir: {}'.format(ckpt_dir_path))
writer = SummaryWriter(log_dir=ckpt_dir_path)
print('start training')
for epoch in range(args.epochs):
# Train for one epoch
glob_step = train(train_loader, model, criterion, optimizer, device, writer, glob_step, total_step, epoch, args.epochs, scheduler)
scheduler.step() # need only in step lr
train_acc = eval(train_loader, model, device, epoch , writer)
val_acc = eval(val_loader, model, device, epoch , writer)
torch.set_grad_enabled(True)
print('Epoch:[{}/{}], Train ACC:{:.5f},Val Acc:{:.5f}' .format(epoch+1, args.epochs, train_acc, val_acc))
if epoch + 1 >= 15:
if best_val_acc is None or best_val_acc < val_acc:
best_val_acc = val_acc
train_acc = eval(train_loader, model, device, epoch , writer)
torch.set_grad_enabled(True)
print('Epoch:[{}/{}], Train ACC:{:.4f}, Validation ACC Score:{:.4f} ' .format(epoch+1, args.epochs, train_acc, best_val_acc))
save_ckpt({'epoch': epoch + 1, 'lr': args.lr, 'step': glob_step, 'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict() }, ckpt_dir_path, epoch = epoch + 1, best_acc = best_val_acc, train_acc=train_acc)
writer.close()
def train(train_loader, model, criterion, optimizer, device, writer, step, total_step, epoch, total_epoch, scheduler):
''' train one epoch'''
torch.set_grad_enabled(True)
tic = time.time()
for i, (images, labels) in enumerate(train_loader):
step += 1
images = images.to(device)
labels = labels.to(device)
# Forward pass
outputs,_ = model(images, noise=False)
loss = criterion(outputs, labels)
# Backward and optimize
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (i+1) % 10 == 0:
print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}' .format(epoch+1, total_epoch, i+1, total_step, loss.item()))
writer.add_scalar('Training Loss', loss.item(), step)
return step
def eval(test_loader, model, device, epoch, writer):
# Switch to evaluate mode
torch.set_grad_enabled(False)
model.eval()
correct = 0
total = 0
for images, labels in test_loader:
images = images.to(device)
labels = labels.to(device)
outputs,_ = model(images, noise=False)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
test_acc = 100 * correct / total
return test_acc
if __name__ == '__main__':
main(parse_args()) | 5,835 | 34.803681 | 159 | py |
SMIL | SMIL-main/src/dataset/mosi.py | import torch.utils.data
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import cv2
import random
from PIL import Image
import pickle
import math
import sys
sys.path.append("../")
import h5py
import pandas as pd
import json
class CMUREG(torch.utils.data.Dataset):
""" soundmnist dataset for meta-learning"""
def __init__(self, data_root, text_ratio=0.1, split='train'):
self.data_root = data_root
self.split = split
self.text_ratio = text_ratio
h5f = h5py.File(os.path.join(self.data_root + 'X_train.h5'), 'r')
x_train = h5f['data'][:]
h5f.close()
h5f = h5py.File(os.path.join(self.data_root + 'y_train.h5'), 'r')
y_train = h5f['data'][:]
h5f.close()
h5f = h5py.File(os.path.join(self.data_root + 'X_valid.h5'), 'r')
x_valid = h5f['data'][:]
h5f.close()
h5f = h5py.File(os.path.join(self.data_root + 'y_valid.h5'), 'r')
y_valid = h5f['data'][:]
h5f.close()
h5f = h5py.File(os.path.join(self.data_root + 'X_test.h5'), 'r')
x_test = h5f['data'][:]
h5f.close()
h5f = h5py.File(os.path.join(self.data_root + 'y_test.h5'), 'r')
y_test = h5f['data'][:]
h5f.close()
ad = 5
td = 300
train_audio_list, train_visual_list, train_text_list, train_labels_list = x_train[:, :, td:td + ad], x_train[:, :, td + ad:], x_train[:, :, :td], y_train
val_audio_list, val_visual_list, val_text_list, val_labels_list = x_valid[:, :, td:td + ad], x_valid[:, :, td + ad:], x_valid[:, :, :td], y_valid
test_audio_list, test_visual_list, test_text_list, test_labels_list = x_test[:, :, td:td + ad], x_test[:, :, td + ad:], x_test[:, :, :td], y_test
num_of_train = int(len(train_audio_list) * text_ratio)
if self.split == 'train':
self.train_audio_list = train_audio_list[0:num_of_train]
self.train_visual_list = train_visual_list[0:num_of_train]
self.train_text_list = train_text_list[0:num_of_train]
self.train_labels_list = train_labels_list[0:num_of_train]
elif self.split == 'val':
self.val_audio_list = val_audio_list
self.val_visual_list = val_visual_list
self.val_text_list = val_text_list
self.val_labels_list = val_labels_list
elif self.split == 'test':
self.test_audio_list = test_audio_list
self.test_visual_list = test_visual_list
self.test_text_list = test_text_list
self.test_labels_list = test_labels_list
else:
raise ValueError('No such split: %s' % self.split)
def get_length(self):
if self.split == 'train':
length = len(self.train_labels_list)
elif self.split == 'val':
length = len(self.val_labels_list)
else:
length = len(self.test_labels_list)
return length
def __len__(self):
""" Returns size of the dataset
returns:
int - number of samples in the dataset
"""
return self.get_length()
def __getitem__(self, index):
""" get image and label """
if self.split == 'train':
audio = self.train_audio_list[index]
visual = self.train_visual_list[index]
text = self.train_text_list[index]
label = self.train_labels_list[index]
audio = torch.tensor(audio).float()
visual = torch.tensor(visual).float()
text = torch.tensor(text).float()
label = torch.tensor(label).float()
label_o = torch.zeros(1).float()
if label>=0:
label_o=0 # greater than zero means positive
else:
label_o=1 # less than zero means negative
return audio, visual, text, label
elif self.split == 'val':
audio = self.val_audio_list[index]
visual = self.val_visual_list[index]
text = self.val_text_list[index]
label = self.val_labels_list[index]
audio = torch.tensor(audio).float()
visual = torch.tensor(visual).float()
text = torch.tensor(text).float()
label = torch.tensor(label).float()
label_o = torch.zeros(1).float()
if label>=0:
label_o=0 # greater than zero means positive
else:
label_o=1 # less than zero means negative
return audio, visual, text, label
elif self.split == 'test':
audio = self.test_audio_list[index]
visual = self.test_visual_list[index]
text = self.test_text_list[index]
label = self.test_labels_list[index]
audio = torch.tensor(audio).float()
visual = torch.tensor(visual).float()
text = torch.tensor(text).float()
label = torch.tensor(label).float()
label_o = torch.zeros(1).float()
if label>=0:
label_o=0 # greater than zero means positive
else:
label_o=1 # less than zero means negative
return audio, visual, text, label
else:
raise ValueError('No such split: %s' % self.meta_split)
if __name__ == '__main__':
from PIL import Image
import torch
import pickle
data_root = '../data/MOSI/'
dataset = CMUREG(data_root, text_ratio=1.0, split='train')
# sampler = torch.utils.data.RandomSampler(dataset, replacement=True)
loader = torch.utils.data.DataLoader(dataset, batch_size = 5, shuffle = False, num_workers=2, pin_memory=True)
print(len(dataset))
| 5,856 | 34.49697 | 161 | py |
SMIL | SMIL-main/src/dataset/meta_training_dataset.py | import torch.utils.data
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import cv2
import random
from PIL import Image
import math
import sys
sys.path.append("../")
from utils.wav2mfcc import wav2mfcc
class MetaTrSouMNIST(torch.utils.data.Dataset):
""" soundmnist dataset for meta-learning"""
def __init__(self, img_root, sound_root, per_class_num=50, meta_split='mtr'):
self.img_root = img_root
self.sound_root = sound_root
self.meta_split = meta_split
self.per_class_num = per_class_num
if self.meta_split == 'mtr':
self.meta_train_image_list = self.get_meta_train_image_list(self.img_root,self.per_class_num)
elif self.meta_split == 'mval':
self.meta_val_image_list = self.get_meta_val_image_list(self.img_root,self.per_class_num)
self.meta_val_sound_list = self.get_meta_val_sound_list(self.sound_root,self.per_class_num)
else:
raise ValueError('No such split: %s' % self.meta_split)
def get_meta_train_image_list(self, img_root, per_class_num):
tr_img_root = os.path.join(img_root+'train/')
tr_number_list = sorted(os.listdir(tr_img_root))
meta_train_image_list = list() # image for training
for i in tr_number_list:
images = sorted(os.listdir(os.path.join(tr_img_root+i)))
for j in range(per_class_num, 105):
# for j in range(105):
path = os.path.join(tr_img_root+i+'/'+images[j])
meta_train_image_list.append(path)
return meta_train_image_list
def get_meta_val_image_list(self, root, per_class_num):
te_root = os.path.join(root+'train/')
te_number_list = sorted(os.listdir(te_root))
meta_val_img_list = list() # image for training
for i in te_number_list:
images = sorted(os.listdir(os.path.join(te_root+i)))
for j in range(per_class_num):
path = os.path.join(te_root+i+'/'+images[j])
meta_val_img_list.append(path)
return meta_val_img_list
def get_meta_val_sound_list(self, root, per_class_num):
tr_root = os.path.join(root+'train/')
tr_number_list = sorted(os.listdir(tr_root))
meta_val_sound_list = list() # image for training
for i in tr_number_list:
jack_list = list()
nico_list = list()
theo_list = list()
sounds = sorted(os.listdir(tr_root+ i))
for j in sounds:
if j.split('_')[1] == 'jackson':
if len(jack_list) < int(per_class_num/3):
jack_list.append(os.path.join(tr_root+i+'/'+j))
elif j.split('_')[1] == 'nicolas':
if len(nico_list) < int(per_class_num/3):
nico_list.append(os.path.join(tr_root+i+'/'+j))
else:
if len(theo_list) < int(per_class_num/3):
theo_list.append(os.path.join(tr_root+i+'/'+j))
temp_list = jack_list + nico_list + theo_list
meta_val_sound_list += temp_list
return meta_val_sound_list
def get_length(self):
if self.meta_split == 'mtr':
length = len(self.meta_train_image_list)
else:
length = len(self.meta_val_image_list)
return length
def __len__(self):
""" Returns size of the dataset
returns:
int - number of samples in the dataset
"""
return self.get_length()
def __getitem__(self, index):
""" get image and label """
transformations = transforms.Compose([transforms.ToTensor(),
transforms.Normalize([0.5], [0.5])])
if self.meta_split == 'mtr':
image_path = self.meta_train_image_list[index]
image_label = int(image_path.split('/')[-2])
img = Image.open(image_path)
im = transformations(img)
label = torch.tensor(image_label).long()
return im, label
elif self.meta_split == 'mval':
image_path = self.meta_val_image_list[index]
image_label = int(image_path.split('/')[-2])
sound_path = self.meta_val_sound_list[index]
sound_label = int(sound_path.split('/')[-2])
img = Image.open(image_path)
sound = np.asarray(wav2mfcc(sound_path))
assert image_label==sound_label
im = transformations(img)
sound = transformations(sound)
label = torch.tensor(image_label).long()
return im, sound, label
else:
raise ValueError('No such split: %s' % self.meta_split)
if __name__ == '__main__':
from PIL import Image
import torch
img_root = '../data/mnist/'
sound_root = '../data/sound_450/'
dataset = MetaTrSouMNIST(img_root, sound_root, per_class_num=105, meta_split='mtr')
sampler = torch.utils.data.RandomSampler(dataset, replacement=True)
loader = torch.utils.data.DataLoader(dataset, batch_size=8, num_workers=1, pin_memory=True,sampler=sampler)
print(len(dataset))
| 4,631 | 29.473684 | 108 | py |
SMIL | SMIL-main/src/dataset/soundmnist.py | import torch.utils.data
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import cv2
import random
# import scipy.io as scio
from PIL import Image
import math
import sys
sys.path.append("../")
from utils.wav2mfcc import wav2mfcc
class SoundMNIST(torch.utils.data.Dataset):
""" soundmnist dataset """
def __init__(self, img_root, sound_root, per_class_num=105,train=True):
self.img_root = img_root
self.sound_root = sound_root
self.train = train
self.per_class_num = per_class_num
if self.train:
self.train_img_list = self.get_image_train_list(self.img_root,self.per_class_num)
self.train_sound_list = self.get_sound_train_list(self.sound_root,self.per_class_num)
# print(self.train_list)
else:
self.test_img_list = self.get_image_test_list(self.img_root,self.per_class_num)
self.test_sound_list = self.get_sound_test_list(self.sound_root,self.per_class_num)
def get_image_train_list(self, root, per_class_num):
tr_root = os.path.join(root+'train/')
tr_number_list = sorted(os.listdir(tr_root))
train_img_list = list() # image for training
for i in tr_number_list:
images = sorted(os.listdir(os.path.join(tr_root+i)))
for j in range(per_class_num):
path = os.path.join(tr_root+i+'/'+images[j])
train_img_list.append(path)
return train_img_list
def get_image_test_list(self, root, per_class_num):
te_root = os.path.join(root+'test/')
te_number_list = sorted(os.listdir(te_root))
test_img_list = list() # image for training
for i in te_number_list:
images = sorted(os.listdir(os.path.join(te_root+i)))
for j in range(len(images)-45, len(images)):
# for j in range(45):
path = os.path.join(te_root+i+'/'+images[j])
test_img_list.append(path)
return test_img_list
def get_sound_train_list(self, root, per_class_num):
tr_root = os.path.join(root+'train/')
tr_number_list = sorted(os.listdir(tr_root))
train_sound_list = list() # image for training
for i in tr_number_list:
jack_list = list()
nico_list = list()
theo_list = list()
sounds = sorted(os.listdir(tr_root+ i))
for j in sounds:
if j.split('_')[1] == 'jackson':
if len(jack_list) < int(per_class_num/3):
jack_list.append(os.path.join(tr_root+i+'/'+j))
elif j.split('_')[1] == 'nicolas':
if len(nico_list) < int(per_class_num/3):
nico_list.append(os.path.join(tr_root+i+'/'+j))
else:
if len(theo_list) < int(per_class_num/3):
theo_list.append(os.path.join(tr_root+i+'/'+j))
temp_list = jack_list + nico_list + theo_list
train_sound_list += temp_list
return train_sound_list
def get_sound_test_list(self, root, per_class_num):
te_root = os.path.join(root+'test/')
te_number_list = sorted(os.listdir(te_root))
test_sound_list = list() # image for training
for i in te_number_list:
sounds = sorted(os.listdir(os.path.join(te_root+i)))
for j in sounds:
path = os.path.join(te_root+i+'/' + j)
test_sound_list.append(path)
return test_sound_list
def get_length(self):
if self.train:
length = len(self.train_img_list)
else:
length = len(self.test_img_list)
return length
def __len__(self):
""" Returns size of the dataset
returns:
int - number of samples in the dataset
"""
return self.get_length()
def __getitem__(self, index):
""" get image and label """
if self.train:
image_path = self.train_img_list[index]
image_label = int(image_path.split('/')[-2])
sound_path = self.train_sound_list[index]
sound_label = int(sound_path.split('/')[-2])
else:
image_path = self.test_img_list[index]
image_label = int(image_path.split('/')[-2])
sound_path = self.test_sound_list[index]
sound_label = int(sound_path.split('/')[-2])
transformations = transforms.Compose([transforms.ToTensor(),
transforms.Normalize([0.5], [0.5])])
img = Image.open(image_path)
sound = np.asarray(wav2mfcc(sound_path))
assert image_label==sound_label
im = transformations(img)
sound = transformations(sound)
label = torch.tensor(image_label).long()
# label = torch.zeros(10).long()
# label[image_label] = 1
return im, sound, label
if __name__ == '__main__':
from PIL import Image
import torch
img_root = '../data/mnist/'
sound_root = '../sound_450/'
dataset = SoundMNIST(img_root, sound_root,per_class_num=30, train=False)
# im, sd, label = dataset[0]
print(len(dataset))
# print(sd.size)
# print(len(dataset))
loader = DataLoader(dataset, batch_size=8, shuffle= False)
batch = next(iter(loader))
print(batch[0].shape)
print(batch[1].shape)
print(batch[0].view(-1, 784).shape)
print(batch[1].view(-1, 400).shape)
print(batch[2].shape)
| 4,900 | 27.660819 | 88 | py |
SMIL | SMIL-main/src/dataset/meta_testing_dataset.py | import torch.utils.data
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import cv2
import random
from PIL import Image
import math
import sys
sys.path.append("../")
from utils.wav2mfcc import wav2mfcc
class MetaTeSouMNIST(torch.utils.data.Dataset):
""" soundmnist dataset for meta-learning"""
def __init__(self, img_root):
self.img_root = img_root
# self.sound_root = sound_root
# self.meta_split = meta_split
# self.per_class_num = per_class_num
self.meta_testing_image_list = self.get_meta_testing_image_list(self.img_root)
def get_meta_testing_image_list(self, img_root):
tr_img_root = os.path.join(img_root+'test/')
tr_number_list = sorted(os.listdir(tr_img_root))
meta_testing_image_list = list() # image for training
for i in tr_number_list:
images = sorted(os.listdir(os.path.join(tr_img_root+i)))
# for j in range(len(images)):
for j in range(45):
path = os.path.join(tr_img_root+i+'/'+images[j])
meta_testing_image_list.append(path)
return meta_testing_image_list
def get_length(self):
length = len(self.meta_testing_image_list)
return length
def __len__(self):
""" Returns size of the dataset
returns:
int - number of samples in the dataset
"""
return self.get_length()
def __getitem__(self, index):
""" get image and label """
transformations = transforms.Compose([transforms.ToTensor(),
transforms.Normalize([0.5], [0.5])])
image_path = self.meta_testing_image_list[index]
image_label = int(image_path.split('/')[-2])
img = Image.open(image_path)
im = transformations(img)
label = torch.tensor(image_label).long()
return im, label
if __name__ == '__main__':
from PIL import Image
import torch
img_root = './data/mnist/'
dataset = MetaTeSouMNIST(img_root)
# sampler = torch.utils.data.RandomSampler(dataset, replacement=True)
# loader = torch.utils.data.DataLoader(dataset, batch_size=8, num_workers=1, pin_memory=True,sampler=sampler)
print(len(dataset))
| 2,109 | 23.534884 | 110 | py |
SMIL | SMIL-main/src/dataset/sound.py | import torch.utils.data
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import cv2
import random
# import scipy.io as scio
from PIL import Image
import math
import sys
sys.path.append("../")
from utils.wav2mfcc import wav2mfcc
class Sound(torch.utils.data.Dataset):
""" soundmnist dataset """
def __init__(self, sound_root, per_class_num=100,train=True):
self.sound_root = sound_root
self.train = train
self.per_class_num = per_class_num
if self.train:
# self.train_img_list = self.get_image_train_list(self.img_root,self.per_class_num)
self.train_sound_list = self.get_sound_train_list(self.sound_root,self.per_class_num)
else:
# self.test_img_list = self.get_image_test_list(self.img_root,self.per_class_num)
self.test_sound_list = self.get_sound_test_list(self.sound_root,self.per_class_num)
def get_sound_train_list(self, root, per_class_num):
tr_root = os.path.join(root+'train/')
tr_number_list = sorted(os.listdir(tr_root))
train_sound_list = list() # image for training
for i in tr_number_list:
jack_list = list()
nico_list = list()
theo_list = list()
sounds = sorted(os.listdir(tr_root+ i))
for j in sounds:
if j.split('_')[1] == 'jackson':
if len(jack_list) < int(per_class_num/3):
jack_list.append(os.path.join(tr_root+i+'/'+j))
elif j.split('_')[1] == 'nicolas':
if len(nico_list) < int(per_class_num/3):
nico_list.append(os.path.join(tr_root+i+'/'+j))
else:
if len(theo_list) < int(per_class_num/3):
theo_list.append(os.path.join(tr_root+i+'/'+j))
temp_list = jack_list + nico_list + theo_list
train_sound_list += temp_list
return train_sound_list
def get_sound_test_list(self, root, per_class_num):
te_root = os.path.join(root+'test/')
te_number_list = sorted(os.listdir(te_root))
test_sound_list = list() # image for training
for i in te_number_list:
sounds = sorted(os.listdir(os.path.join(te_root+i)))
for j in sounds:
path = os.path.join(te_root+i+'/' + j)
test_sound_list.append(path)
return test_sound_list
def get_length(self):
if self.train:
length = len(self.train_sound_list)
else:
length = len(self.test_sound_list)
return length
def __len__(self):
""" Returns size of the dataset
returns:
int - number of samples in the dataset
"""
return self.get_length()
def __getitem__(self, index):
""" get image and label """
if self.train:
sound_path = self.train_sound_list[index]
sound_label = int(sound_path.split('/')[-2])
else:
sound_path = self.test_sound_list[index]
sound_label = int(sound_path.split('/')[-2])
transformations = transforms.Compose([transforms.ToTensor(),
transforms.Normalize([0.5], [0.5])])
sound = wav2mfcc(sound_path)
sd = transformations(sound)
label = torch.tensor(sound_label).long()
return sd, label
if __name__ == '__main__':
from PIL import Image
import torch
sound_root = '../data/sound_450/'
dataset = Sound(sound_root,per_class_num=3, train=True)
print(len(dataset))
| 3,275 | 25.852459 | 88 | py |
SMIL | SMIL-main/src/dataset/testing_mnist.py | import torch.utils.data
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import cv2
import random
# import scipy.io as scio
from PIL import Image
import math
class TestMNIST(torch.utils.data.Dataset):
""" UTD-MHAD dataset """
def __init__(self, root, per_class_num=105,train=True):
self.root = root
self.train = train
self.per_class_num = per_class_num
if self.train:
self.train_list = self.get_train_list(self.root,self.per_class_num)
else:
self.test_list = self.get_test_list(self.root)
def get_train_list(self, root, per_class_num):
"""
Args:
root (string) - The root path image dataset
"""
tr_root = os.path.join(root+'train/')
tr_number_list = sorted(os.listdir(tr_root))
train_list = list() # image for training
for i in tr_number_list:
images = sorted(os.listdir(os.path.join(tr_root+i)))
# for j in range(per_class_num ,105):
for j in range(105):
path = os.path.join(tr_root+i+'/'+images[j])
train_list.append(path)
return train_list
def get_test_list(self, root):
te_root = os.path.join(root+'test/')
te_number_list = sorted(os.listdir(te_root))
test_list = list() # image for training
for i in te_number_list:
images = sorted(os.listdir(os.path.join(te_root+i)))
for j in range(45):
path = os.path.join(te_root+i+'/'+images[j])
test_list.append(path)
return test_list
def get_length(self):
if self.train:
length = len(self.train_list)
else:
length = len(self.test_list)
return length
def __len__(self):
""" Returns size of the dataset
returns:
int - number of samples in the dataset
"""
return self.get_length()
def __getitem__(self, index):
""" get image and label """
if self.train:
image_path = self.train_list[index]
image_label = int(image_path.split('/')[-2])
else:
image_path = self.test_list[index]
image_label = int(image_path.split('/')[-2])
transformations = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5])])
img = Image.open(image_path)
# print(image_label)
im = transformations(img)
label = torch.tensor(image_label).long()
# label = torch.zeros(10).long()
# label[image_label] = 1
return im, label
if __name__ == '__main__':
from PIL import Image
import torch
root = '../data/mnist/'
dataset = TestMNIST(root,per_class_num=51, train=True)
im, label =dataset[3]
# # im.show()
print(len(dataset))
# print(label)
| 2,594 | 21.37069 | 70 | py |
SMIL | SMIL-main/src/dataset/mnist.py | import torch.utils.data
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import cv2
import random
# import scipy.io as scio
from PIL import Image
import math
class MNIST(torch.utils.data.Dataset):
""" UTD-MHAD dataset """
def __init__(self, root, per_class_num=105,train=True):
self.root = root
self.train = train
self.per_class_num = per_class_num
if self.train:
self.train_list = self.get_train_list(self.root,self.per_class_num)
else:
self.test_list = self.get_test_list(self.root)
def get_train_list(self, root, per_class_num):
"""
Args:
root (string) - The root path image dataset
"""
tr_root = os.path.join(root+'train/')
tr_number_list = sorted(os.listdir(tr_root))
train_list = list() # image for training
for i in tr_number_list:
images = sorted(os.listdir(os.path.join(tr_root+i)))
for j in range(per_class_num):
path = os.path.join(tr_root+i+'/'+images[j])
train_list.append(path)
return train_list
def get_test_list(self, root):
te_root = os.path.join(root+'test/')
te_number_list = sorted(os.listdir(te_root))
test_list = list() # image for training
for i in te_number_list:
images = sorted(os.listdir(os.path.join(te_root+i)))
# for j in range(45):
for j in range(len(images)):
path = os.path.join(te_root+i+'/'+images[j])
test_list.append(path)
return test_list
def get_length(self):
if self.train:
length = len(self.train_list)
else:
length = len(self.test_list)
return length
def __len__(self):
""" Returns size of the dataset
returns:
int - number of samples in the dataset
"""
return self.get_length()
def __getitem__(self, index):
""" get image and label """
if self.train:
image_path = self.train_list[index]
image_label = int(image_path.split('/')[-2])
else:
image_path = self.test_list[index]
image_label = int(image_path.split('/')[-2])
transformations = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5])])
img = Image.open(image_path)
# print(image_label)
im = transformations(img)
label = torch.tensor(image_label).long()
# label = torch.zeros(10).long()
# label[image_label] = 1
return im, label
if __name__ == '__main__':
from PIL import Image
import torch
root = '../data/mnist/'
dataset = MNIST(root,per_class_num=105, train=False)
# im, label =dataset[3]
# # im.show()
print(len(dataset))
| 2,573 | 21.578947 | 70 | py |
SMIL | SMIL-main/src/models/vgg13.py | import torch.nn as nn
from collections import OrderedDict
import torch.nn.functional as F
class VGG13(nn.Module):
def __init__(self, output_layers = ['default']):
super(VGG13, self).__init__()
self.output_layers = output_layers
self.conv11 = nn.Conv2d(3, 64, kernel_size=(3, 3), padding=1)
self.conv12 = nn.Conv2d(64, 64, kernel_size=(3, 3), padding=1)
self.pool1 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.conv21 = nn.Conv2d(64, 128, kernel_size=(3, 3), padding=1)
self.conv22 = nn.Conv2d(128, 128, kernel_size=(3, 3), padding=1)
self.pool2 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.conv31 = nn.Conv2d(128, 256, kernel_size=(3, 3), padding=1)
self.conv32 = nn.Conv2d(256, 256, kernel_size=(3, 3), padding=1)
self.pool3 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.conv41 = nn.Conv2d(256, 512, kernel_size=(3, 3), padding=1)
self.conv42 = nn.Conv2d(512, 512, kernel_size=(3, 3), padding=1)
self.pool4 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.conv51 = nn.Conv2d(512, 512, kernel_size=(3, 3), padding=1)
self.conv52 = nn.Conv2d(512, 512, kernel_size=(3, 3), padding=1)
self.pool5 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.fc1 = nn.Linear(20480, 4096)
self.fc2 = nn.Linear(4096, 4096)
self.fc3 = nn.Linear(4096, 23)
self.dropout = nn.Dropout()
self.relu = nn.ReLU(inplace=True)
self.softplus = nn.Softplus()
def _add_output_and_check(self, name, x, outputs, output_layers):
if name in output_layers:
outputs[name] = x
return len(output_layers) == len(outputs)
def forward(self, x, encoder=None, noise=False, meta_train=True, noise_layer=['conv1','conv2']):
if noise:
assert encoder is not None
x = self.conv11(x)
x = self.relu(x)
x = self.conv12(x)
x = self.relu(x)
x = self.pool1(x)
x = self.conv21(x)
x = self.relu(x)
x = self.conv22(x)
x = self.relu(x)
x = self.pool2(x)
x = self.conv31(x)
x = self.relu(x)
x = self.conv32(x)
x = self.relu(x)
x = self.pool3(x)
x = self.conv41(x)
x = self.relu(x)
x = self.conv42(x)
x = self.relu(x)
x = self.pool4(x)
x = self.conv51(x)
x = self.relu(x)
x = self.conv52(x)
x = self.relu(x)
x = self.pool5(x)
x = x.view(x.size(0), -1)
f = x
x = self.fc1(x)
x = self.relu(x)
x= self.dropout(x)
x = self.fc2(x)
x = self.relu(x)
x= self.dropout(x)
x = self.fc3(x)
conv1 = {'conv1':x}
x = self.conv1(x)
if 'conv1' in noise_layer:
x = self.softplus(encoder(conv1, meta_train=meta_train)['conv1']) + x
x = self.pool1(x)
x = self.relu(x)
conv2 = {'conv2':x}
x = self.conv2(x)
if 'conv2' in noise_layer:
x = self.softplus(encoder(conv2, meta_train=meta_train)['conv2']) + x
x = self.dropout(x)
x = self.pool2(x)
x = self.relu(x)
x = x.view(x.size(0), -1)
f = x
x = self.fc1(x)
x = self.relu(x)
x = self.fc2(x)
# x = x
return x, f
else:
x = self.conv11(x)
x = self.relu(x)
x = self.conv12(x)
x = self.relu(x)
x = self.pool1(x)
x = self.conv21(x)
x = self.relu(x)
x = self.conv22(x)
x = self.relu(x)
x = self.pool2(x)
x = self.conv31(x)
x = self.relu(x)
x = self.conv32(x)
x = self.relu(x)
x = self.pool3(x)
x = self.conv41(x)
x = self.relu(x)
x = self.conv42(x)
x = self.relu(x)
x = self.pool4(x)
x = self.conv51(x)
x = self.relu(x)
x = self.conv52(x)
x = self.relu(x)
x = self.pool5(x)
x = x.view(x.size(0), -1)
f = x
x = self.fc1(x)
x = self.relu(x)
x= self.dropout(x)
x = self.fc2(x)
x = self.relu(x)
x= self.dropout(x)
x = self.fc3(x)
return x, f
if __name__ == '__main__':
import torch.backends.cudnn as cudnn
import torch
from torchsummary import summary
import os.path as path
import sys
sys.path.append('../')
from models.newencoder import InferNet
cudnn.benchmark = True
device = torch.device("cuda")
cnn = VGG13().to(device)
summary(cnn, (3, 256, 160))
| 5,267 | 26.4375 | 100 | py |
SMIL | SMIL-main/src/models/snet.py | import torch.nn as nn
class SNet(nn.Module):
def __init__(self, ):
super(SNet, self).__init__()
self.conv1 = nn.Conv2d(1, 5, kernel_size=(2, 2))
self.pool1 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.conv2 = nn.Conv2d(5, 10, kernel_size=(2, 2))
self.pool2 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
# self.conv3 = nn.Conv2d(32, 64, kernel_size=(3, 3))
# self.bn3 = nn.BatchNorm2d(64)
# self.pool3 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.fc1 = nn.Linear(160, 10)
self.fc2 = nn.Linear(10, 10)
self.dropout = nn.Dropout(p=0.5)
self.relu = nn.ReLU(inplace=True)
def forward(self, x):
x = self.conv1(x)
x = self.pool1(x)
x = self.relu(x)
x = self.conv2(x)
x = self.dropout(x)
x = self.pool2(x)
x = self.relu(x)
f = x
x = x.view(x.size(0), -1)
x = self.fc1(x)
x = self.dropout(x)
x = self.relu(x)
x = self.fc2(x)
return x, f
class SNetPluse(nn.Module):
def __init__(self, ):
super(SNetPluse, self).__init__()
self.conv1 = nn.Conv2d(1, 32, kernel_size=(2, 2))
self.bn1 = nn.BatchNorm2d(32)
# self.pool1 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.conv2 = nn.Conv2d(32, 48, kernel_size=(2, 2))
self.bn2 = nn.BatchNorm2d(48)
# self.pool2 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.conv3 = nn.Conv2d(48, 20, kernel_size=(2, 2))
self.bn3 = nn.BatchNorm2d(20)
self.pool3 = nn.MaxPool2d(kernel_size=(2, 2), stride=(4, 4))
self.fc1 = nn.Linear(320, 160)
# self.bn5 = nn.BatchNorm1d(160)
self.fc2 = nn.Linear(160, 32)
self.fc3 = nn.Linear(32, 10)
self.dropout1 = nn.Dropout(p=0.25)
self.dropout2 = nn.Dropout(p=0.4)
self.relu = nn.ReLU(inplace=True)
def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
x = self.conv2(x)
x = self.bn2(x)
x = self.relu(x)
x = self.conv3(x)
x = self.bn3(x)
x = self.relu(x)
x = self.pool3(x)
x = self.dropout1(x)
# f = x
x = x.view(x.size(0), -1)
f = x
x = self.fc1(x)
x = self.dropout1(x)
x = self.relu(x)
# f = x
x = self.fc2(x)
x = self.dropout2(x)
x = self.relu(x)
# f = x
x = self.fc3(x)
return x, f
if __name__ == '__main__':
import torch.backends.cudnn as cudnn
import torch
from torchsummary import summary
cudnn.benchmark = True
cuda = torch.device("cuda")
cnn = SNetPluse().to(cuda)
summary(cnn, (1, 20, 20))
# x = cnn(inn) | 2,931 | 22.837398 | 70 | py |
SMIL | SMIL-main/src/models/newencoder.py | import torch.nn as nn
from collections import OrderedDict
import torch
class InferNet(nn.Module):
def __init__(self, output_layers = ['default']):
super(InferNet, self).__init__()
self.output_layers = output_layers
self.conv1 = nn.Conv2d(1, 5, kernel_size=(5, 5))
# self.conv11 = nn.Conv2d(1, 5, kernel_size=(5, 5))
self.conv2 = nn.Conv2d(5, 10, kernel_size=(5, 5))
# self.conv21 = nn.Conv2d(5, 10, kernel_size=(5, 5))
self.fc1 = nn.Linear(160, 480)
self.fc11 = nn.Linear(160, 480)
self.fc2 = nn.Linear(480, 64)
self.fc21 = nn.Linear(480, 64)
def forward(self, x, meta_train=True):
outputs = OrderedDict()
if meta_train:
# print('encoder meta_train=True')
if 'conv1' in x.keys():
mu1 = self.conv1(x['conv1'])
# std1 = torch.exp(0.5*mu1)
# outputs['conv1'] = torch.randn_like(std1)*std1
outputs['conv1'] = torch.randn_like(mu1) + mu1
if 'conv2' in x.keys():
mu2 = self.conv2(x['conv2'])
# std2 = torch.exp(mu2)
# outputs['conv2'] = torch.randn_like(std2)*std2
outputs['conv2'] = torch.randn_like(mu2) + mu2
if 'fc1' in x.keys():
mu3 = self.fc1(x['fc1'])
# sigma3 = self.fc1(x['fc1'])
# std3 = torch.exp(0.5*sigma3)
# outputs['fc1'] = torch.randn_like(std3)*std3
outputs['fc1'] = torch.randn_like(mu3) + mu3
# outputs['fc1'] = mu3
# print(outputs['fc1'])
if 'fc2' in x.keys():
mu4 = self.fc2(x['fc2'])
# sigma4 = self.fc2(x['fc2'])
# std4 = torch.exp(0.5*sigma4)
outputs['fc2'] = torch.randn_like(mu4) + mu4
# outputs['fc2'] = mu4
return outputs
else:
# print('encoder meta_train=False')
if 'conv1' in x.keys():
mu1 = self.conv1(x['conv1'])
outputs['conv1'] = mu1
if 'conv2' in x.keys():
mu2 = self.conv2(x['conv2'])
outputs['conv2'] = mu2
if 'fc1' in x.keys():
mu3 = self.fc1(x['fc1'])
outputs['fc1'] = mu3
if 'fc2' in x.keys():
mu4 = self.fc2(x['fc2'])
outputs['fc2'] = mu4
return outputs
class InferNetNew(nn.Module):
def __init__(self, output_layers = ['default']):
super(InferNetNew, self).__init__()
self.output_layers = output_layers
self.conv1 = nn.Conv2d(1, 5, kernel_size=(5, 5))
# self.conv11 = nn.Conv2d(1, 5, kernel_size=(5, 5))
self.conv2 = nn.Conv2d(5, 10, kernel_size=(5, 5))
# self.conv21 = nn.Conv2d(5, 10, kernel_size=(5, 5))
self.fc0 = nn.Linear(160, 10)
self.fc1 = nn.Linear(160, 480)
self.fc11 = nn.Linear(160, 480)
self.fc2 = nn.Linear(480, 64)
self.fc21 = nn.Linear(480, 64)
def forward(self, x, meta_train=True):
outputs = OrderedDict()
if meta_train:
# print('encoder meta_train=True')
if 'conv1' in x.keys():
mu1 = self.conv1(x['conv1'])
# std1 = torch.exp(0.5*mu1)
outputs['conv1'] = torch.randn_like(mu1) + mu1
if 'conv2' in x.keys():
mu2 = self.conv2(x['conv2'])
# std2 = torch.exp(mu2)
outputs['conv2'] = torch.randn_like(mu2) + mu2
if 'fc0' in x.keys():
mu0 = self.fc0(x['fc0'])
outputs['fc0'] = mu0
if 'fc1' in x.keys():
mu3 = self.fc1(x['fc1'])
sigma3 = self.fc11(x['fc1'])
std3 = torch.exp(0.5*sigma3)
std3 = torch.clamp(std3, min=0, max=1)
outputs['fc1'] = torch.randn_like(mu3) + mu3
if 'fc2' in x.keys():
mu4 = self.fc2(x['fc2'])
sigma4 = self.fc21(x['fc2'])
std4 = torch.exp(0.5*sigma4)
std4 = torch.clamp(std4, min=0, max=1)
outputs['fc2'] = torch.randn_like(mu4) + mu4
return outputs
else:
# print('encoder meta_train=False')
if 'conv1' in x.keys():
mu1 = self.conv1(x['conv1'])
outputs['conv1'] = mu1
if 'conv2' in x.keys():
mu2 = self.conv2(x['conv2'])
outputs['conv2'] = mu2
if 'fc0' in x.keys():
mu0 = self.fc0(x['fc0'])
outputs['fc0'] = mu0
if 'fc1' in x.keys():
mu3 = self.fc1(x['fc1'])
outputs['fc1'] = mu3
if 'fc2' in x.keys():
mu4 = self.fc2(x['fc2'])
outputs['fc2'] = mu4
return outputs
if __name__ == '__main__':
import torch.backends.cudnn as cudnn
import torch
from torchsummary import summary
cudnn.benchmark = True
device = torch.device("cuda")
encoder = InferNet().to(device)
images = torch.rand(8, 1, 28, 28).to(device)
a = {'conv1':images}
x = encoder(a, meta_train=True)
print(x.keys())
# summary(encoder, (1, 28, 28))
# for i,p in enumerate(cnn.parameters()):
# if i < 6:
# p.requires_grad = False
for name, param in encoder.named_parameters():
# if param.requires_grad:
print(name, param.data.shape)
| 5,719 | 28.947644 | 64 | py |
SMIL | SMIL-main/src/models/lenet5.py | import torch.nn as nn
from collections import OrderedDict
import torch.nn.functional as F
class LeNet5(nn.Module):
def __init__(self, output_layers = ['default']):
super(LeNet5, self).__init__()
self.output_layers = output_layers
self.conv1 = nn.Conv2d(1, 5, kernel_size=(5, 5))
self.pool1 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.conv2 = nn.Conv2d(5, 10, kernel_size=(5, 5))
self.pool2 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.fc1 = nn.Linear(160, 32)
self.fc2 = nn.Linear(32, 10)
self.dropout = nn.Dropout(p=0.5)
self.relu = nn.ReLU(inplace=True)
self.softplus = nn.Softplus()
def _add_output_and_check(self, name, x, outputs, output_layers):
if name in output_layers:
outputs[name] = x
return len(output_layers) == len(outputs)
def forward(self, x, encoder=None, noise=True, meta_train=True, noise_layer=['conv1','conv2']):
if noise:
assert encoder is not None
conv1 = {'conv1':x}
x = self.conv1(x)
if 'conv1' in noise_layer:
x = self.softplus(encoder(conv1, meta_train=meta_train)['conv1']) + x
x = self.pool1(x)
x = self.relu(x)
conv2 = {'conv2':x}
x = self.conv2(x)
if 'conv2' in noise_layer:
x = self.softplus(encoder(conv2, meta_train=meta_train)['conv2']) + x
x = self.dropout(x)
x = self.pool2(x)
x = self.relu(x)
x = x.view(x.size(0), -1)
f = x
x = self.fc1(x)
x = self.relu(x)
x = self.fc2(x)
# x = x
return x, f
else:
x = self.conv1(x)
x = self.pool1(x)
x = self.relu(x)
x = self.conv2(x)
x = self.dropout(x)
x = self.pool2(x)
x = self.relu(x)
# f = x
x = x.view(x.size(0), -1)
f = x
x = self.fc1(x)
x = self.relu(x)
# f = x
x = self.fc2(x)
return x, f
if __name__ == '__main__':
import torch.backends.cudnn as cudnn
import torch
from torchsummary import summary
import os.path as path
import sys
sys.path.append('../')
from models.newencoder import InferNet
cudnn.benchmark = True
device = torch.device("cuda")
cnn = LeNet5().to(device)
images = torch.rand(8, 1, 28,28).to(device)
encoder = InferNet().to(device)
x,f = cnn(images, encoder, noise=True)
# print(x.shape)
summary(cnn, (1, 28, 28)) | 2,784 | 25.52381 | 99 | py |
SMIL | SMIL-main/src/models/loss.py | import torch.nn as nn
import torch
import torch.nn.functional as F
class KDFeatureLoss(nn.Module):
""" multi-label cross entropy loss """
def __init__(self, reduction = 'mean', alpha = 1, beta = 1 ):
super().__init__()
self.cross_entropy = nn.CrossEntropyLoss(reduction = reduction)
self.l2_loss = nn.MSELoss(reduction=reduction)
# self.factor = factor
self.alpha = alpha
self.beta = beta
def forward(self, map_teacher, map_student, pred_student, label):
loss_ce = self.cross_entropy(pred_student, label)
loss_dist = self.l2_loss(map_teacher, map_student)
loss = self.alpha*loss_ce + self.beta*loss_dist
return loss
class KDFeatureLossTwo(nn.Module):
""" multi-label cross entropy loss """
def __init__(self, reduction = 'mean', alpha = 0.1):
super().__init__()
self.cross_entropy = nn.CrossEntropyLoss(reduction = reduction)
# self.cross_entropy_clean = nn.CrossEntropyLoss(reduction = reduction)
self.l2_loss = nn.MSELoss(reduction=reduction)
# self.factor = factor
self.alpha = alpha
# self.beta = beta
def forward(self, map_teacher1, map_student1, pred_noise, pred_clean, label):
loss_ce_noise = self.cross_entropy(pred_noise, label)
loss_ce_clean = self.cross_entropy(pred_clean, label)
loss_map = self.l2_loss(map_teacher1, map_student1)
loss = loss_ce_noise + loss_ce_clean + self.alpha*loss_map
return loss
class KDLossAlignTwo(nn.Module):
""" multi-label cross entropy loss """
def __init__(self, reduction = 'mean', alpha = 0.1, beta=0.1):
super().__init__()
self.cross_entropy = nn.CrossEntropyLoss(reduction = reduction)
self.l2_loss = nn.MSELoss(reduction=reduction)
self.alpha = alpha
self.beta = beta
def forward(self, mean_teacher, mean_student, map_teacher1, map_student1, map_teacher2, map_student2, pred_noise, pred_clean, label):
loss_ce_noise = self.cross_entropy(pred_noise, label)
loss_ce_clean = self.cross_entropy(pred_clean, label)
loss_map_1 = self.l2_loss(map_teacher1, map_student1)
loss_map_2 = self.l2_loss(map_teacher2, map_student2)
loss_audio_mean = self.l2_loss(mean_teacher, mean_student)
loss = loss_ce_noise + self.alpha*loss_map_1 + self.beta*loss_map_2
return loss
class KDPredLoss(nn.Module):
""" multi-label cross entropy loss """
def __init__(self, reduction = 'mean', T = 2, alpha=0.5):
""" pos_weight = # of neg_sample/ # of pos_sample; it is a tensor vector length equals to num of clss"""
super().__init__()
self.cross_entropy = nn.CrossEntropyLoss(reduction = reduction)
self.kl_loss = nn.KLDivLoss()
self.T = T
self.alpha = alpha
def forward(self, pred_teacher, pred_student, label):
# if weights is not None:
loss_ce = self.cross_entropy(pred_student, label)
output_S = F.log_softmax(pred_student/self.T, dim=1)
output_T = F.softmax(pred_teacher/self.T, dim=1)
loss_dist = self.kl_loss(output_S, output_T)*self.T*self.T
loss = (1- self.alpha)*loss_ce + loss_dist*self.alpha
return loss
class KDLossAll(nn.Module):
""" multi-label cross entropy loss """
def __init__(self, reduction = 'mean', T = 2, alpha=0.5, beta = 0.5):
""" pos_weight = # of neg_sample/ # of pos_sample; it is a tensor vector length equals to num of clss"""
super().__init__()
self.cross_entropy = nn.CrossEntropyLoss(reduction = reduction)
self.l2_loss = nn.MSELoss(reduction=reduction)
self.kl_loss = nn.KLDivLoss()
self.T = T
self.alpha = alpha
self.beta = beta
def forward(self, map_teacher, map_student, pred_teacher, pred_student, label):
# if weights is not None:
loss_ce = self.cross_entropy(pred_student, label)
output_S = F.log_softmax(pred_student/self.T, dim=1)
output_T = F.softmax(pred_teacher/self.T, dim=1)
loss_kl = self.kl_loss(output_S, output_T)*self.T*self.T
loss_l2 = self.l2_loss(map_teacher, map_student)
loss = loss_ce + loss_kl*self.alpha + loss_l2*self.beta
return loss | 4,329 | 39.849057 | 137 | py |
SMIL | SMIL-main/src/models/classifier.py | import torch.nn as nn
from collections import OrderedDict
import torch
class ClassfierNet(nn.Module):
def __init__(self, output_layers = ['default']):
super(ClassfierNet, self).__init__()
self.output_layers = output_layers
self.fc1 = nn.Linear(160, 32)
self.fc2 = nn.Linear(32, 10)
self.dropout = nn.Dropout(p=0.5)
self.relu = nn.ReLU(inplace=True)
self.softplus = nn.Softplus()
def _add_output_and_check(self, name, x, outputs, output_layers):
if name in output_layers:
outputs[name] = x
return len(output_layers) == len(outputs)
def forward(self, x, noise=None):
x = x.view(x.size(0), -1)
if noise is None:
# print('in none')
x = self.fc1(x)
x = self.relu(x)
x = self.dropout(x)
f = x
x = self.fc2(x)
return x, f
else:
x = self.fc1(x)
x = self.relu(x)
if 'fc1' in noise.keys():
# x = x + noise['fc1']
x = x * noise['fc1']
f = x
x = self.fc2(x)
if 'fc2' in noise.keys():
# x = x + noise['fc2']
x = x * noise['fc2']
return x, f
class ClassfierNetNew(nn.Module):
def __init__(self, output_layers = ['default']):
super(ClassfierNetNew, self).__init__()
self.output_layers = output_layers
self.fc1 = nn.Linear(160, 32)
self.fc2 = nn.Linear(32, 10)
self.dropout = nn.Dropout(p=0.5)
self.relu = nn.ReLU(inplace=True)
def _add_output_and_check(self, name, x, outputs, output_layers):
if name in output_layers:
outputs[name] = x
return len(output_layers) == len(outputs)
def forward(self, x):
x = x.view(x.size(0), -1)
x = self.fc1(x)
x = self.relu(x)
# x = x
f = x
x = self.fc2(x)
return x, f
if __name__ == '__main__':
import torch.backends.cudnn as cudnn
import torch
from torchsummary import summary
cudnn.benchmark = True
device = torch.device("cuda")
cnn = ClassfierNet().to(device)
images = torch.rand(8, 160).to(device)
x = cnn(images)
summary(cnn, (1, 160))
| 2,321 | 24.8 | 69 | py |
SMIL | SMIL-main/src/models/encoder.py | import torch.nn as nn
import torch
from torch.distributions.normal import Normal
class InferenceNet(nn.Module):
def __init__(self, ):
super(InferenceNet, self).__init__()
self.fc1 = nn.Linear(320, 128)
self.fc2 = nn.Linear(128, 32*2+10*2)
self.relu = nn.ReLU(inplace=True)
self.softplus = nn.Softplus()
def forward(self, x, meta_train=True):
mean, var = torch.mean(x, 0), torch.var(x, 0)
# print(mean.shape, var.shape)
x = torch.cat([mean, var], dim=0)
# print(x.shape)
x = self.fc1(x)
x = self.relu(x)
mu = self.softplus(self.fc2(x))
# print(mu.shape)
if meta_train:
new_mu = self.softplus(torch.randn_like(mu) + mu)
# mu_w = new_mu[:32+10]
# mu_b = new_mu[32+10:]
else:
new_mu = self.softplus(mu)
# mu_w = new_mu[:32+10]
# mu_b = new_mu[32+10:]
return new_mu
if __name__ == '__main__':
import torch.backends.cudnn as cudnn
import torch
import sys
sys.path.append('../')
from models.lenet5 import LeNet5
cudnn.benchmark = True
cuda = torch.device("cuda")
cnn = LeNet5().to(cuda)
for i,p in enumerate(cnn.parameters()):
if i < 6:
p.requires_grad = False
encoder = InferenceNet().to(cuda)
images = torch.rand(32, 1, 28, 28).to(cuda)
# print(images[0].shape, images[0].unsqueeze(0).shape)
x, f = cnn(images)
# print(f.shape)
# summary(cnn, (1, 28, 28))
mu = encoder(f, meta_train=False )
mu = torch.split(mu, [32,32,10,10])
print(mu[0])
print(mu[0][1])
# for i in mu:
# print(i.shape[0])
# print(mu[2].shape)
params = list(encoder.parameters())
| 1,796 | 24.309859 | 61 | py |
SMIL | SMIL-main/src/models/encoder_new.py | import torch.nn as nn
from collections import OrderedDict
import torch
class InferNetNew(nn.Module):
def __init__(self, output_layers = ['default']):
super(InferNetNew, self).__init__()
self.output_layers = output_layers
self.conv1 = nn.Conv2d(1, 5, kernel_size=(5, 5))
self.pool1 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.conv2 = nn.Conv2d(5, 10, kernel_size=(5, 5))
self.pool2 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.fc1 = nn.Linear(160, 32)
self.fc2 = nn.Linear(32, 10)
self.dropout = nn.Dropout(p=0.5)
self.relu = nn.ReLU(inplace=True)
self.softplus = nn.Softplus()
def _add_meta_train_output_and_check(self, name, x, outputs, output_layers):
if name in output_layers:
outputs[name] = self.softplus(torch.randn_like(x) + x)
return len(output_layers) == len(outputs)
def _add_meta_val_output_and_check(self, name, x, outputs, output_layers):
if name in output_layers:
outputs[name] = (x)
return len(output_layers) == len(outputs)
def forward(self, x, output_layers=None, meta_train=True):
outputs = OrderedDict()
if output_layers is None:
output_layers = self.output_layers
x = self.conv1(x)
if meta_train:
if self._add_meta_train_output_and_check('conv1', x, outputs, output_layers):
return outputs
else:
if self._add_meta_val_output_and_check('conv1', x, outputs, output_layers):
return outputs
x = self.pool1(x)
x = self.relu(x)
x = self.conv2(x)
x = self.dropout(x)
if meta_train:
if self._add_meta_train_output_and_check('conv2', x, outputs, output_layers):
return outputs
else:
if self._add_meta_val_output_and_check('conv2', x, outputs, output_layers):
return outputs
x = self.pool2(x)
x = self.relu(x)
x = x.view(x.size(0), -1)
x = self.fc1(x)
x = self.relu(x)
if meta_train:
if self._add_meta_train_output_and_check('fc1', x, outputs, output_layers):
return outputs
else:
if self._add_meta_val_output_and_check('fc1', x, outputs, output_layers):
return outputs
x = self.fc2(x)
if meta_train:
if self._add_meta_train_output_and_check('fc2', x, outputs, output_layers):
return outputs
else:
if self._add_meta_val_output_and_check('fc2', x, outputs, output_layers):
return outputs
if len(output_layers) == 1 and output_layers[0] == 'default':
return x
raise ValueError('output_layer is wrong.')
class InferNet(nn.Module):
def __init__(self, output_layers = ['default']):
super(InferNet, self).__init__()
self.output_layers = output_layers
self.conv1 = nn.Conv2d(1, 5, kernel_size=(5, 5))
self.pool1 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.conv2 = nn.Conv2d(5, 10, kernel_size=(5, 5))
self.pool2 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.fc1 = nn.Linear(160, 32)
self.fc2 = nn.Linear(32, 10)
self.dropout = nn.Dropout(p=0.5)
self.relu = nn.ReLU(inplace=True)
self.softplus = nn.Softplus()
def _add_meta_train_output_and_check(self, name, x, outputs, output_layers):
if name in output_layers:
outputs[name] = self.softplus(torch.randn_like(x) + x)
return len(output_layers) == len(outputs)
def _add_meta_val_output_and_check(self, name, x, outputs, output_layers):
if name in output_layers:
outputs[name] = (x)
return len(output_layers) == len(outputs)
def forward(self, x, output_layers=None, meta_train=True):
outputs = OrderedDict()
if output_layers is None:
output_layers = self.output_layers
x = x.view(x.size(0), -1)
x = self.fc1(x)
x = self.relu(x)
if meta_train:
if self._add_meta_train_output_and_check('fc1', x, outputs, output_layers):
return outputs
else:
if self._add_meta_val_output_and_check('fc1', x, outputs, output_layers):
return outputs
x = self.fc2(x)
if meta_train:
if self._add_meta_train_output_and_check('fc2', x, outputs, output_layers):
return outputs
else:
if self._add_meta_val_output_and_check('fc2', x, outputs, output_layers):
return outputs
if len(output_layers) == 1 and output_layers[0] == 'default':
return x
raise ValueError('output_layer is wrong.')
if __name__ == '__main__':
import torch.backends.cudnn as cudnn
import torch
from torchsummary import summary
cudnn.benchmark = True
device = torch.device("cuda")
encoder = InferNet().to(device)
images = torch.rand(8, 160).to(device)
x = encoder(images, output_layers=['fc1'], meta_train=True)
print(x['fc1'].shape) | 5,284 | 31.826087 | 89 | py |
SMIL | SMIL-main/src/models/reconstruct.py | class IMDbFuse(nn.Module):
"""docstring forLenet5 Sound"""
def __init__(self,extractor1, extractor2, extractor_grad=False):
super(IMDbFuse, self).__init__()
self.image_extractor = extractor1
self.text_extractor = extractor2
self.fc1 = nn.Linear(4096, 2048)
self.bn1 = nn.BatchNorm1d(2048)
self.fc2 = nn.Linear(2048, 512)
self.bn2 = nn.BatchNorm1d(512)
self.fc3 = nn.Linear(512, 23)
self.dropout = nn.Dropout()
self.relu = nn.ReLU(inplace=True)
self.softplus = nn.Softplus()
if not extractor_grad:
# for p in self.image_extractor.parameters():
# p.requires_grad_(False)
for p in self.text_extractor.parameters():
p.requires_grad_(False)
def forward(self, image_feature, text_feature=None, encoder=None, text_mean=None, noise_layer=['conv1','conv2','fc0','fc1','fc2'], meta_train=True, mode='one'):
if mode == 'one':
assert text_mean is not None
assert noise_layer is not None
assert encoder is not None
_, image_feature = self.image_extractor(image_feature, encoder=encoder, noise=True,meta_train=meta_train, noise_layer=['conv1','conv2','fc0','fc1','fc2'])
text_feature = text_mean.expand(image_feature.shape[0], text_mean.shape[0])# sound feature: 320 dim vector
image_feature = image_feature.view(image_feature.size(0), -1)
text_feature = text_feature.view(text_feature.size(0), -1)
fc1 = {'fc1':image_feature}
x = torch.cat([image_feature, text_feature], dim=1)
if 'fc1' in noise_layer: # add noise to the concatenated feature: 480 dimension.
x = self.softplus(encoder(fc1, meta_train=meta_train)['fc1']) * x
# print('add noise to fc1')
f = x
fc2 = {'fc2':x}
x = self.fc1(x)
if 'fc2' in noise_layer: # add noise to fc: 64 dimension.
x = self.softplus(encoder(fc2, meta_train=meta_train)['fc2']) * x
# print('add noise to fc2')
f1 = x
x = self.relu(x)
x = self.dropout(x)
x = self.bn1(x)
fc3 = {'fc3':x}
x = self.fc2(x)
if 'fc3' in noise_layer: # add noise to fc: 64 dimension.
x = self.softplus(encoder(fc3, meta_train=meta_train)['fc3']) * x
# print('add noise to fc3')
f2 = x
x = self.relu(x)
x = self.dropout(x)
x = self.bn2(x)
x = self.fc3(x)
return x, f, f1, f2
elif mode == 'two':
assert text_feature is not None
_, image_feature = self.image_extractor(image_feature, noise=False)
_, text_feature = self.text_extractor(text_feature)
# p1d = nn.ConstantPad1d(1898, 0)
image_feature = image_feature.view(image_feature.size(0), -1)
text_feature = text_feature.view(text_feature.size(0), -1)
# text_feature = p1d(text_feature)
x = torch.cat([image_feature, text_feature], dim=1)
f = x
x = self.fc1(x)
f1 = x
x = self.relu(x)
x = self.dropout(x)
x = self.bn1(x)
x = self.fc2(x)
f2 = x
x = self.relu(x)
x = self.dropout(x)
x = self.bn2(x)
x = self.fc3(x)
return x, f, f1, f2
# return x, sound_feature
else:
raise ValueError('mode should be one or two.')
| 3,754 | 35.105769 | 166 | py |
SMIL | SMIL-main/src/models/soundlenet5.py | import torch
import torch.nn as nn
class SoundLenet5(nn.Module):
"""docstring forLenet5 Sound"""
def __init__(self, extractor1, extractor2, extractor_grad=False):
super(SoundLenet5, self).__init__()
self.img_extractor = extractor1
self.sound_extractor = extractor2
self.fc1 = nn.Linear(480, 64)
self.fc2 = nn.Linear(64, 10)
self.dropout = nn.Dropout(p=0.6)
self.relu = nn.ReLU(inplace=True)
self.softplus = nn.Softplus()
if not extractor_grad:
for p in self.sound_extractor.parameters():
p.requires_grad_(False)
def forward(self, label, image, sound=None, encoder=None, sound_mean=None, noise_layer=['conv1','conv2','fc1','fc2'], meta_train=True, mode='one'):
if mode == 'one':
assert sound_mean is not None
assert noise_layer is not None
assert encoder is not None
_, img_feature = self.img_extractor(image, encoder=encoder, noise=True, meta_train=meta_train, noise_layer=noise_layer) # image feature: 160 dim vector
sound_feature = sound_mean.expand(img_feature.shape[0], sound_mean.shape[0])# sound feature: 320 dim vector
# sound_feature = torch.ones(img_feature.shape[0], sound_mean.shape[0]).to('cuda')
img_feature = img_feature.view(img_feature.size(0), -1)
sound_feature = sound_feature.view(sound_feature.size(0), -1)
fc1 = {'fc1':img_feature}
x = torch.cat([img_feature, sound_feature], dim=1)
# fc1 = {'fc1':x}
if 'fc1' in noise_layer: # add noise to the concatenated feature: 480 dimension.
x = self.softplus(encoder(fc1, meta_train=meta_train)['fc1']) + x
f = x
fc2 = {'fc2':x}
x = self.relu(self.fc1(x))
if 'fc2' in noise_layer: # add noise to fc: 64 dimension.
x = self.softplus(encoder(fc2, meta_train=meta_train)['fc2']) + x
f1 = x
x = self.dropout(x)
x = self.fc2(x)
return x, f, f1, sound_feature
elif mode == 'two':
assert sound is not None
_, img_feature = self.img_extractor(image, encoder=None, noise=False, noise_layer=noise_layer)
_, sound_feature = self.sound_extractor(sound)
img_feature = img_feature.view(img_feature.size(0), -1)
sound_feature = sound_feature.view(sound_feature.size(0), -1)
# print(sound_feature.shape)
x = torch.cat([img_feature, sound_feature], dim=1)
f = x
print(f.shape, x.shape)
x = self.relu(self.fc1(x))
f1 = x
x = self.dropout(x)
x = self.fc2(x)
return x, f, f1, sound_feature, img_feature
# return x, sound_feature
else:
raise ValueError('mode should be one or two.')
class SoundLenet5AE(nn.Module):
"""docstring forLenet5 Sound"""
def __init__(self, extractor1, extractor2, extractor_grad=False):
super(SoundLenet5AE, self).__init__()
self.img_extractor = extractor1
self.sound_extractor = extractor2
self.fc1 = nn.Linear(480, 64)
self.fc2 = nn.Linear(64, 10)
self.dropout = nn.Dropout(p=0.6)
self.relu = nn.ReLU(inplace=True)
self.softplus = nn.Softplus()
if not extractor_grad:
# for p in self.img_extractor.parameters():
# p.requires_grad_(False)
for p in self.sound_extractor.parameters():
p.requires_grad_(False)
def forward(self, label, image, sound=None, encoder=None, autoencoder=None, noise_layer=['conv1','conv2','fc1','fc2'], meta_train=True, mode='one'):
if mode == 'one':
assert autoencoder is not None
assert noise_layer is not None
assert encoder is not None
_, img_feature = self.img_extractor(image, encoder=encoder, noise=True, meta_train=meta_train, noise_layer=noise_layer) # image feature: 160 dim vector
# sound_feature = sound_mean.expand(img_feature.shape[0], sound_mean.shape[0])# sound feature: 320 dim vector
autoencoder.eval()
sound_feature = autoencoder(img_feature).detach()
# sound_feature = torch.ones(img_feature.shape[0], sound_mean.shape[0]).to('cuda')
img_feature = img_feature.view(img_feature.size(0), -1)
sound_feature = sound_feature.view(sound_feature.size(0), -1)
fc1 = {'fc1':img_feature}
x = torch.cat([img_feature, sound_feature], dim=1)
# fc1 = {'fc1':x}
if 'fc1' in noise_layer: # add noise to the concatenated feature: 480 dimension.
x = self.softplus(encoder(fc1, meta_train=meta_train)['fc1']) + x
f = x
fc2 = {'fc2':x}
x = self.relu(self.fc1(x))
if 'fc2' in noise_layer: # add noise to fc: 64 dimension.
x = self.softplus(encoder(fc2, meta_train=meta_train)['fc2']) + x
f1 = x
x = self.dropout(x)
x = self.fc2(x)
return x, f, f1, sound_feature
elif mode == 'two':
assert sound is not None
_, img_feature = self.img_extractor(image, encoder=None, noise=False, noise_layer=noise_layer)
_, sound_feature = self.sound_extractor(sound)
img_feature = img_feature.view(img_feature.size(0), -1)
sound_feature = sound_feature.view(sound_feature.size(0), -1)
# print(sound_feature.shape)
x = torch.cat([img_feature, sound_feature], dim=1)
f = x
x = self.relu(self.fc1(x))
f1 = x
x = self.dropout(x)
x = self.fc2(x)
return x, f, f1, sound_feature, img_feature
# return x, sound_feature
else:
raise ValueError('mode should be one or two.')
class SoundLenet5New(nn.Module):
"""docstring forLenet5 Sound"""
def __init__(self, extractor1, extractor2, extractor_grad=False):
super(SoundLenet5New, self).__init__()
self.img_extractor = extractor1
self.sound_extractor = extractor2
self.fc1 = nn.Linear(480, 64)
self.fc2 = nn.Linear(64, 10)
self.dropout = nn.Dropout()
self.relu = nn.ReLU(inplace=True)
self.softplus = nn.Softplus()
self.softmax = nn.Softmax(dim=1)
if not extractor_grad:
# for p in self.img_extractor.parameters():
# p.requires_grad_(False)
for p in self.sound_extractor.parameters():
p.requires_grad_(False)
def forward(self, label, image, sound=None, encoder=None, sound_mean=None, noise_layer=['conv1','conv2','fc1','fc2'], meta_train=True, mode='one'):
if mode == 'one':
assert sound_mean is not None
assert noise_layer is not None
assert encoder is not None
_, img_feature = self.img_extractor(image, encoder=encoder, noise=True, meta_train=meta_train, noise_layer=noise_layer) # image feature: 160 dim vector
# sound_feature = torch.ones(img_feature.shape).to('cuda')
# print(sound_feature)
sound_mean = sound_mean.expand(img_feature.shape[0], -1, -1)
fc0 = {'fc0':img_feature}
if 'fc0' in noise_layer: # add noise to the concatenated feature: 480 dimension.
weight = self.softplus(encoder(fc0, meta_train=meta_train)['fc0']).unsqueeze(-1)
sound_feature = sound_mean.matmul(weight)
for i in range(sound_feature.shape[0]):
sound_feature[i] = sound_feature[i].clone() / weight.sum(1)[i]
img_feature = img_feature.view(img_feature.size(0), -1)
sound_feature = sound_feature.view(sound_feature.size(0), -1)
fc1 = {'fc1':img_feature}
x = torch.cat([img_feature, sound_feature], dim=1)
if 'fc1' in noise_layer: # add noise to the concatenated feature: 480 dimension.
x = self.softplus(encoder(fc1, meta_train=meta_train)['fc1']) + x
f = x
fc2 = {'fc2':x}
x = self.relu(self.fc1(x))
if 'fc2' in noise_layer: # add noise to fc: 64 dimension.
x = self.softplus(encoder(fc2, meta_train=meta_train)['fc2']) + x
f1 = x
x = self.dropout(x)
x = self.fc2(x)
return x, f, f1, sound_feature
elif mode == 'two':
assert sound is not None
_, img_feature = self.img_extractor(image, encoder=None, noise=False, noise_layer=noise_layer)
_, sound_feature = self.sound_extractor(sound)
img_feature = img_feature.view(img_feature.size(0), -1)
sound_feature = sound_feature.view(sound_feature.size(0), -1)
x = torch.cat([img_feature, sound_feature], dim=1)
f = x
x = self.relu(self.fc1(x))
f1 = x
x = self.dropout(x)
x = self.fc2(x)
return x, f, f1, sound_feature
# return x, sound_feature
else:
raise ValueError('mode should be one or two.')
class SoundLenet5Class(nn.Module):
"""docstring forLenet5 Sound"""
def __init__(self, extractor1, extractor2, extractor_grad=False):
super(SoundLenet5Class, self).__init__()
self.img_extractor = extractor1
self.sound_extractor = extractor2
self.fc1 = nn.Linear(480, 64)
self.fc2 = nn.Linear(64, 10)
self.dropout = nn.Dropout()
self.relu = nn.ReLU(inplace=True)
self.softplus = nn.Softplus()
self.softmax = nn.Softmax(dim=1)
if not extractor_grad:
for p in self.sound_extractor.parameters():
p.requires_grad_(False)
def forward(self, label, image, sound=None, encoder=None, sound_mean=None, noise_layer=['conv1','conv2','fc1','fc2'], meta_train=True, mode='one'):
if mode == 'one':
assert sound_mean is not None
assert noise_layer is not None
assert encoder is not None
_, img_feature = self.img_extractor(image, encoder=encoder, noise=True, meta_train=meta_train, noise_layer=noise_layer) # image feature: 160 dim vector
sound_feature = torch.ones(img_feature.shape[0], 320).to('cuda')
for i in range(img_feature.shape[0]):
sound_feature[i] = sound_mean[label[i].item()]
img_feature = img_feature.view(img_feature.size(0), -1)
sound_feature = sound_feature.view(sound_feature.size(0), -1)
fc1 = {'fc1':img_feature}
x = torch.cat([img_feature, sound_feature], dim=1)
if 'fc1' in noise_layer: # add noise to the concatenated feature: 480 dimension.
x = self.softplus(encoder(fc1, meta_train=meta_train)['fc1']) + x
# print('add noise to fc1')
f = x
fc2 = {'fc2':x}
x = self.relu(self.fc1(x))
if 'fc2' in noise_layer: # add noise to fc: 64 dimension.
x = self.softplus(encoder(fc2, meta_train=meta_train)['fc2']) + x
# print('add noise to fc2')
f1 = x
x = self.dropout(x)
x = self.fc2(x)
return x, f, f1, sound_feature
elif mode == 'two':
assert sound is not None
_, img_feature = self.img_extractor(image, encoder=None, noise=False, noise_layer=noise_layer)
_, sound_feature = self.sound_extractor(sound)
img_feature = img_feature.view(img_feature.size(0), -1)
sound_feature = sound_feature.view(sound_feature.size(0), -1)
x = torch.cat([img_feature, sound_feature], dim=1)
f = x
x = self.relu(self.fc1(x))
f1 = x
x = self.dropout(x)
x = self.fc2(x)
return x, f, f1, sound_feature
# return x, sound_feature
else:
raise ValueError('mode should be one or two.')
class SoundLenet5mean(nn.Module):
"""docstring forLenet5 Sound"""
def __init__(self, extractor1, extractor2, extractor_grad=False):
super(SoundLenet5mean, self).__init__()
self.img_extractor = extractor1
self.sound_extractor = extractor2
self.fc1 = nn.Linear(480, 64)
self.fc2 = nn.Linear(64, 10)
self.dropout = nn.Dropout(p=0.6)
self.relu = nn.ReLU(inplace=True)
self.softplus = nn.Softplus()
if not extractor_grad:
# for p in self.img_extractor.parameters():
# p.requires_grad_(False)
for p in self.sound_extractor.parameters():
p.requires_grad_(False)
def forward(self, image, sound=None, encoder=None, sound_mean=None, noise_layer=['conv1','conv2','fc1','fc2'], meta_train=True, mode='one'):
if mode == 'one':
assert sound_mean is not None
assert noise_layer is not None
assert encoder is not None
_, img_feature = self.img_extractor(image, encoder=encoder, noise=True, meta_train=meta_train, noise_layer=noise_layer) # image feature: 160 dim vector
sound_feature = sound_mean.expand(img_feature.shape[0], sound_mean.shape[0])# sound feature: 320 dim vector
img_feature = img_feature.view(img_feature.size(0), -1)
sound_feature = sound_feature.view(sound_feature.size(0), -1)
fc1 = {'fc1':img_feature}
x = torch.cat([img_feature, sound_feature], dim=1)
# fc1 = {'fc1':x}
if 'fc1' in noise_layer: # add noise to the concatenated feature: 480 dimension.
x = self.softplus(encoder(fc1, meta_train=meta_train)['fc1']) + x
# print('add noise to fc1')
f = x
fc2 = {'fc2':x}
x = self.relu(self.fc1(x))
if 'fc2' in noise_layer: # add noise to fc: 64 dimension.
x = self.softplus(encoder(fc2, meta_train=meta_train)['fc2']) + x
# print('add noise to fc2')
f1 = x
x = self.dropout(x)
x = self.fc2(x)
return x, f, f1
elif mode == 'two':
assert sound is not None
_, img_feature = self.img_extractor(image, encoder=None, noise=False, noise_layer=noise_layer)
_, sound_feature = self.sound_extractor(sound)
img_feature = img_feature.view(img_feature.size(0), -1)
sound_feature = sound_feature.view(sound_feature.size(0), -1)
x = torch.cat([img_feature, sound_feature], dim=1)
f = x
# print(f.shape)
x = self.relu(self.fc1(x))
f1 = x
x = self.dropout(x)
x = self.fc2(x)
# return x, f, f1
return x, sound_feature
else:
raise ValueError('mode should be one or two.')
if __name__ == '__main__':
import torch.backends.cudnn as cudnn
import torch
import sys
import os.path as path
sys.path.append('../')
import numpy as np
from torchsummary import summary
from models.lenet5 import LeNet5
from models.snet import SNetPluse
# from models.soundlenet5 import SoundLenet5
from models.newencoder import InferNetNew
cudnn.benchmark = True
device = torch.device("cuda")
e1 = LeNet5().to(device)
e2 = SNetPluse().to(device)
soundmnist_model_path = '/home/mengma/Desktop/nips2020/src/save/soundmnist/15/2020-04-09T17:05:35.475086/'
image_sound_extractor = SoundLenet5Class(e1, e2).to(device)
ckpt_image_sound = torch.load(path.join(soundmnist_model_path, 'epoch_16_test_accuracy_90.0_train_accuracy_100.0_best_model.path.tar'))
# image_sound_extractor.load_state_dict(ckpt_image_sound['state_dict'])
# cnn = SoundLenet5(e1, e2).to(device)
encoder = InferNetNew().to(device)
path = "/home/mengma/Desktop/nips2020/src/save/sound_mean/kmean/15/epoch_16_test_accuracy_90.0_train_accuracy_100.0_best_model.path.tar/sound_mean_150.npy"
sound_mean = np.load(path)
sound_mean = torch.from_numpy(sound_mean).to(device)
images = torch.rand(5, 1, 28,28).to(device)
# noise = encoder(images, output_layers=['conv1','conv2','fc1','fc2'], meta_train=True)
# # print(images[1].size())
sound = torch.rand(5, 1, 20,20).to(device)
label = torch.randint(0, 10, (32,)).to(device)
x,f,_,_ = image_sound_extractor(label, images, sound=sound, encoder=encoder, sound_mean=sound_mean, noise_layer=['fc0','fc1','fc2'], meta_train=False, mode='one')
# print(x.shape)
params = list(image_sound_extractor.parameters())
print(len(params))
# for i,p in enumerate(cnn.parameters()):
# if i < 6:
# p.requires_grad = False
a = 0
for name, param in image_sound_extractor.named_parameters():
# if param.requires_grad:
print(a, name, param.data.shape)
a += 1 | 17,652 | 35.24846 | 167 | py |
SMIL | SMIL-main/src/utils/wav2mfcc.py | import numpy as np
import librosa
import os
from PIL import Image
# from keras.utils import to_categorical
def wav2mfcc(file_path, max_pad_len=20):
wave, sr = librosa.load(file_path, mono=True, sr=None)
wave = np.asfortranarray(wave[::3])
mfcc = librosa.feature.mfcc(wave, sr=8000, n_mfcc=20)
pad_width = max_pad_len - mfcc.shape[1]
mfcc = np.pad(mfcc, pad_width=((0, 0), (0, pad_width)), mode='constant')
return mfcc
def get_data(root):
labels = []
mfccs = []
for f in os.listdir(root):
if f.endswith('.wav'):
# MFCC
mfccs.append(wav2mfcc(root + f))
# List of labels
label = f.split('_')[0]
labels.append(label)
return np.asarray(mfccs), labels
if __name__ == '__main__':
root = '../data/sound/0/'
mfccs, labels = get_data(root)
print(mfccs[0])
print(len(labels)) | 913 | 22.435897 | 76 | py |
SMIL | SMIL-main/src/utils/misc.py | import os
import shutil
import torch
class AverageMeter(object):
"""Computes and stores the average and current value"""
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
class AvgF1(object):
"""docstring for AcgF1"""
def __init__(self, arg):
super(AcgF1, self).__init__()
self.arg = arg
def save_ckpt(state, path, epoch, best_acc = None, train_acc=None):
filename = 'epoch_'+ str(epoch) + '_ckpt.path.tar'
ckpt_path = os.path.join(path + '/' + filename)
torch.save(state, ckpt_path)
if best_acc is not None:
bestname = 'epoch_'+ str(epoch) + '_' +'test_accuracy_' + str(best_acc) +'_train_accuracy_' + str(train_acc) +'_best_model.path.tar'
shutil.copyfile(ckpt_path, os.path.join( path + '/' + bestname))
def save_ckpt_classifier(state, path, iteration, best_acc = None):
filename = 'iter_'+ str(iteration) + '_ckpt.path.tar'
ckpt_path = os.path.join(path + '/' + filename)
torch.save(state, ckpt_path)
if best_acc is not None:
bestname = 'iter_'+ str(iteration) + '_' +'test_accuracy_' + str(best_acc) +'_best_model.path.tar'
shutil.copyfile(ckpt_path, os.path.join( path + '/' + bestname))
def save_ckpt_inferNet(state, path, iteration):
filename = 'iter_'+ str(iteration) + '_inferNet_ckpt.path.tar'
ckpt_path = os.path.join(path + '/' + filename)
torch.save(state, ckpt_path) | 1,644 | 33.270833 | 140 | py |
tamp-manipulation-manipulation-tamp-RAL | tamp-manipulation-manipulation-tamp-RAL/bindings/pydrake/__init__.py | """
Python bindings for
`Drake: Model-Based Design and Verification for Robotics
<https://drake.mit.edu/>`_.
This Python API documentation is a work in progress. Most of it is generated
automatically from the C++ API documentation, and thus may have some
C++-specific artifacts. For general overview and API documentation, please see
the `Doxygen C++ Documentation
<https://drake.mit.edu/doxygen_cxx/index.html>`_.
For examples and tutorials that tie in and use this API, please see
`here <https://drake.mit.edu/#tutorials-and-examples>`_.
"""
import os
import sys
import warnings
# When importing `pydrake` as an external under Bazel, Bazel will use a shared
# library whose relative RPATHs are incorrect for `libdrake.so`, and thus will
# fail to load; this issue is captured in bazelbuild/bazel#4594. As a
# workaround, we can use a library that properly links to `libdrake.so`, but in
# `{runfiles}/{workspace}/external/drake` rather than `{runfiles}/drake`.
# Once this is loaded, all of the Python C-extension libraries
# that depend on it (and its dependencies) will load properly.
# Please note that this workaround is only important when running under the
# Bazel runfiles tree. Installed `pydrake` should not have this issue.
# N.B. We do not import `external.drake.bindings.pydrake` as this may cause
# duplicate classes to be loaded (#8810). This will not be a problem once #7912
# is resolved.
try:
import external.drake.bindings.bazel_workaround_4594_libdrake
except ImportError:
pass
# When running from python, turn DRAKE_ASSERT and DRAKE_DEMAND failures into
# SystemExit, instead of process aborts. See RobotLocomotion/drake#5268.
# We specifically load `common` prior to loading any other pydrake modules,
# in order to get assertion configuration done as early as possible.
from . import common
from .common.deprecation import ModuleShim
__all__ = ['common', 'getDrakePath']
common.set_assertion_failure_to_throw_exception()
def getDrakePath():
# Compatibility alias.
return os.path.abspath(common.GetDrakePath())
def _execute_extra_python_code(m):
# See `ExecuteExtraPythonCode` in `pydrake_pybind.h` for usage details and
# rationale.
if m.__name__ not in sys.modules:
# N.B. This is necessary for C++ extensions in Python 3.
sys.modules[m.__name__] = m
module_path = m.__name__.split(".")
if len(module_path) == 1:
raise RuntimeError((
"ExecuteExtraPythonCode cannot be used with the top-level "
"module `{}`. If you are writing modules in a downstream "
"project, please review this thread and ensure your import is "
"correct: https://stackoverflow.com/a/57858822/7829525"
).format(m.__name__))
top_module_name = module_path[0]
top_module_dir = os.path.dirname(sys.modules[top_module_name].__file__)
extra_path = [top_module_dir] + module_path[1:-1] + [
"_{}_extra.py".format(module_path[-1])]
extra_filename = os.path.join(*extra_path)
with open(extra_filename) as f:
_code = compile(f.read(), extra_filename, 'exec')
exec(_code, m.__dict__, m.__dict__)
def _setattr_kwargs(obj, kwargs):
# For `ParamInit` in `pydrake_pybind.h`.
for name, value in kwargs.items():
setattr(obj, name, value)
def _import_cc_module_vars(cc_module, py_module_name):
# Imports the cc_module's public symbols into the named py module
# (py_module_name), resetting their __module__ to be the py module in the
# process.
# Returns a list[str] of the public symbol names imported.
py_module = sys.modules[py_module_name]
var_list = []
for name, value in cc_module.__dict__.items():
if name.startswith("_"):
continue
if getattr(value, "__module__", None) == cc_module.__name__:
value.__module__ = py_module_name
setattr(py_module, name, value)
var_list.append(name)
return var_list
class _DrakeImportWarning(Warning):
pass
_RTLD_GLOBAL_WARNING = r"""
You may have already (directly or indirectly) imported `torch` which uses
`RTLD_GLOBAL`. Using `RTLD_GLOBAL` may cause symbol collisions which manifest
themselves in bugs like "free(): invalid pointer". Please consider importing
`pydrake` (and related C++-wrapped libraries like `cv2`, `open3d`, etc.)
*before* importing `torch`. For more details, see:
https://github.com/pytorch/pytorch/issues/3059#issuecomment-534676459
"""
def _check_for_rtld_global_usages():
# Naively check if `torch` is using RTLD_GLOBAL. For more information, see
# the above _RTLD_GLOBAL_WARNING message, #12073, and #13707.
torch = sys.modules.get("torch")
if torch is None:
return False
# This symbol was introduced in v1.5.0 (pytorch@ddff4efa2).
# N.B. Per investigation in #13707, it seems like torch==1.4.0 also plays
# better with pydrake. However, we will keep our warning conservative.
using_rtld_global = getattr(torch, "USE_RTLD_GLOBAL_WITH_LIBTORCH", True)
if not using_rtld_global:
return False
init_file = getattr(torch, "__file__")
if init_file.endswith(".pyc"):
init_file = init_file[:-1]
if not init_file.endswith(".py"):
return False
with open(init_file) as f:
init_source = f.read()
return "sys.setdlopenflags(_dl_flags.RTLD_GLOBAL" in init_source
if _check_for_rtld_global_usages():
warnings.warn(
_RTLD_GLOBAL_WARNING, category=_DrakeImportWarning, stacklevel=3)
| 5,512 | 38.661871 | 79 | py |
tamp-manipulation-manipulation-tamp-RAL | tamp-manipulation-manipulation-tamp-RAL/bindings/pydrake/test/rtld_global_warning_test.py | import importlib
import sys
import unittest
import warnings
import pydrake
class TestRtldGlobalWarning(unittest.TestCase):
def test_mock_torch(self):
# Import the mock module.
import torch
with warnings.catch_warnings(record=True) as caught:
warnings.simplefilter("always", Warning)
# Use `reload` to retrigger the relevant code in
# `pydrake/__init__.py`.
importlib.reload(pydrake)
self.assertEqual(len(caught), 1)
self.assertEqual(caught[0].category, pydrake._DrakeImportWarning)
# Show that having `USE_RTLD_GLOBAL_WITH_LIBTORCH` properly set
# does not trigger the warning.
torch.USE_RTLD_GLOBAL_WITH_LIBTORCH = False
with warnings.catch_warnings(record=True) as caught:
warnings.simplefilter("always", Warning)
importlib.reload(pydrake)
self.assertEqual(len(caught), 0)
| 937 | 30.266667 | 73 | py |
tamp-manipulation-manipulation-tamp-RAL | tamp-manipulation-manipulation-tamp-RAL/bindings/pydrake/test/mock_torch/torch.py | # This is a mock version of torch for use with `rtld_global_warning_test`,
# simulating the following line:
# https://github.com/pytorch/pytorch/blob/v1.0.0/torch/__init__.py#L75
import os as _dl_flags
import sys
# Make the check in `pydrake/__init__.py` pass, but then undo the change.
_old_flags = sys.getdlopenflags()
sys.setdlopenflags(_dl_flags.RTLD_GLOBAL)
sys.setdlopenflags(_old_flags)
| 397 | 29.615385 | 74 | py |
tamp-manipulation-manipulation-tamp-RAL | tamp-manipulation-manipulation-tamp-RAL/bindings/pydrake/doc/conf.py | # -*- coding: utf-8 -*-
#
# Configuration file for the Sphinx documentation builder.
#
# This file does only contain a selection of the most common options. For a
# full list see the documentation:
# http://www.sphinx-doc.org/en/master/config
# -- Project information -----------------------------------------------------
project = u'pydrake'
copyright = u''
author = u''
# The short X.Y version
version = u''
# The full version, including alpha/beta/rc tags
release = u''
# -- General configuration ---------------------------------------------------
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.mathjax',
# Precede napoleon, since it's greedy on `autodoc-skip-member`
'pydrake_sphinx_extension',
'sphinx.ext.napoleon',
]
# Option available in Sphinx 1.5+.
napoleon_include_init_with_doc = True
# The suffix(es) of source filenames.
source_suffix = '.rst'
# The master toctree document.
master_doc = 'index'
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = 'sphinx_rtd_theme'
html_static_path = ['_static']
html_copy_source = False
html_show_copyright = False
html_show_sphinx = False
autodoc_member_order = 'bycustomfunction'
| 1,465 | 23.847458 | 78 | py |
relax | relax-main/setup.py | from setuptools import setup
setup(name='relax',
url='https://github.com/mkhodak/relax',
author='Misha Khodak',
author_email='khodak@cmu.edu',
packages=['relax'],
install_requires=['torch'],
version='0.0.0',
license='MIT',
description='NAS relaxation tools',
long_description=open('README.md').read(),
)
| 366 | 23.466667 | 48 | py |
relax | relax-main/examples/pde/fourier_2d.py | """
@author: Zongyi Li
This file is the Fourier Neural Operator for 2D problem such as the Darcy Flow discussed in Section 5.2 in the [paper](https://arxiv.org/pdf/2010.08895.pdf).
"""
import os
import pdb
import requests
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
import operator
from functools import reduce
from functools import partial
from timeit import default_timer
import torch.backends.cudnn as cudnn
from relax.nas import MixedOptimizer, Supernet
from relax.ops import FNO
from relax.xd import original
torch.manual_seed(0)
np.random.seed(0)
class SimpleBlock2d(nn.Module):
def __init__(self, modes1, modes2, width, arch='fno', einsum=True, padding_mode='circular'):
super(SimpleBlock2d, self).__init__()
"""
The overall network. It contains 4 layers of the Fourier layer.
1. Lift the input to the desire channel dimension by self.fc0 .
2. 4 layers of the integral operators u' = (W + K)(u).
W defined by self.w; K defined by self.conv .
3. Project from the channel space to the output space by self.fc1 and self.fc2 .
input: the solution of the coefficient function and locations (a(x, y), x, y)
input shape: (batchsize, x=s, y=s, c=3)
output: the solution
output shape: (batchsize, x=s, y=s, c=1)
"""
self.modes1 = modes1
self.modes2 = modes2
self.width = width
self.fc0 = nn.Linear(3, self.width) # input channel is 3: (a(x, y), x, y)
if arch == 'fno':
self.conv0 = FNO(self.width, self.width,
[self.modes1, self.modes2], pad=True, einsum=einsum)
self.conv1 = FNO(self.width, self.width,
[self.modes1, self.modes2], pad=True, einsum=einsum)
self.conv2 = FNO(self.width, self.width,
[self.modes1, self.modes2], pad=True, einsum=einsum)
self.conv3 = FNO(self.width, self.width,
[self.modes1, self.modes2], pad=True, einsum=einsum)
elif arch == 'conv':
self.conv0 = nn.Conv2d(self.width, self.width,
kernel_size=self.modes1 + 1, padding=6,
padding_mode=padding_mode, bias=False)
self.conv1 = nn.Conv2d(self.width, self.width,
kernel_size=self.modes1 + 1, padding=6,
padding_mode=padding_mode, bias=False)
self.conv2 = nn.Conv2d(self.width, self.width,
kernel_size=self.modes1 + 1, padding=6,
padding_mode=padding_mode, bias=False)
self.conv3 = nn.Conv2d(self.width, self.width,
kernel_size=self.modes1 + 1, padding=6,
padding_mode=padding_mode, bias=False)
else:
raise NotImplementedError
self.w0 = nn.Conv1d(self.width, self.width, 1)
self.w1 = nn.Conv1d(self.width, self.width, 1)
self.w2 = nn.Conv1d(self.width, self.width, 1)
self.w3 = nn.Conv1d(self.width, self.width, 1)
self.bn0 = torch.nn.BatchNorm2d(self.width)
self.bn1 = torch.nn.BatchNorm2d(self.width)
self.bn2 = torch.nn.BatchNorm2d(self.width)
self.bn3 = torch.nn.BatchNorm2d(self.width)
self.fc1 = nn.Linear(self.width, 128)
self.fc2 = nn.Linear(128, 1)
def forward(self, x):
batchsize = x.shape[0]
size_x, size_y = x.shape[1], x.shape[2]
x = self.fc0(x)
x = x.permute(0, 3, 1, 2)
x1 = self.conv0(x)
x2 = self.w0(x.view(batchsize, self.width, -1)).view(batchsize, self.width, size_x, size_y)
x = self.bn0(x1 + x2)
x = F.relu(x)
x1 = self.conv1(x)
x2 = self.w1(x.view(batchsize, self.width, -1)).view(batchsize, self.width, size_x, size_y)
x = self.bn1(x1 + x2)
x = F.relu(x)
x1 = self.conv2(x)
x2 = self.w2(x.view(batchsize, self.width, -1)).view(batchsize, self.width, size_x, size_y)
x = self.bn2(x1 + x2)
x = F.relu(x)
x1 = self.conv3(x)
x2 = self.w3(x.view(batchsize, self.width, -1)).view(batchsize, self.width, size_x, size_y)
x = self.bn3(x1 + x2)
x = x.permute(0, 2, 3, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.fc2(x)
return x
class Net2d(nn.Module):
def __init__(self, modes, width, **kwargs):
super(Net2d, self).__init__()
"""
A wrapper function
"""
self.conv1 = SimpleBlock2d(modes, modes, width, **kwargs)
def forward(self, x):
x = self.conv1(x)
return x.squeeze()
def count_params(self):
c = 0
for p in self.parameters():
c += reduce(operator.mul, list(p.size()))
return c
def main(sub=5,
arch='fno',
xd=False,
epochs=500,
acc_steps=1,
datapath='data',
arch_lr=0.001,
arch_momentum=0.0,
arch_sgd=False,
start_epoch=0):
from utilities3 import MatReader, UnitGaussianNormalizer, LpLoss
# Set acc_steps to 5 for full resolution
################################################################
# configs
################################################################
TRAIN_PATH = os.path.join(datapath, 'piececonst_r421_N1024_smooth1.mat')
TEST_PATH = os.path.join(datapath, 'piececonst_r421_N1024_smooth2.mat')
ntrain = 1000
ntest = 100
batch_size = 20 // acc_steps
learning_rate = 0.001
epochs = epochs
step_size = 100
gamma = 0.5
modes = 12
width = 32
r = sub #5 # 5, 3, 2, 1
h = int(((421 - 1)/r) + 1)
s = h
################################################################
# load data and data normalization
################################################################
os.makedirs(datapath, exist_ok=True)
if not os.path.isfile(TRAIN_PATH):
print("downloading training data")
with open(TRAIN_PATH, 'wb') as f:
f.write(requests.get("https://pde-xd.s3.amazonaws.com/piececonst_r421_N1024_smooth1.mat").content)
reader = MatReader(TRAIN_PATH)
x_train = reader.read_field('coeff')[:ntrain,::r,::r][:,:s,:s]
y_train = reader.read_field('sol')[:ntrain,::r,::r][:,:s,:s]
if not os.path.isfile(TEST_PATH):
print("downloading test data")
with open(TEST_PATH, 'wb') as f:
f.write(requests.get("https://pde-xd.s3.amazonaws.com/piececonst_r421_N1024_smooth2.mat").content)
reader.load_file(TEST_PATH)
x_test = reader.read_field('coeff')[:ntest,::r,::r][:,:s,:s]
y_test = reader.read_field('sol')[:ntest,::r,::r][:,:s,:s]
x_normalizer = UnitGaussianNormalizer(x_train)
x_train = x_normalizer.encode(x_train)
x_test = x_normalizer.encode(x_test)
y_normalizer = UnitGaussianNormalizer(y_train)
y_train = y_normalizer.encode(y_train)
grids = []
grids.append(np.linspace(0, 1, s))
grids.append(np.linspace(0, 1, s))
grid = np.vstack([xx.ravel() for xx in np.meshgrid(*grids)]).T
grid = grid.reshape(1,s,s,2)
grid = torch.tensor(grid, dtype=torch.float)
x_train = torch.cat([x_train.reshape(ntrain,s,s,1), grid.repeat(ntrain,1,1,1)], dim=3)
x_test = torch.cat([x_test.reshape(ntest,s,s,1), grid.repeat(ntest,1,1,1)], dim=3)
train_loader = torch.utils.data.DataLoader(torch.utils.data.TensorDataset(x_train, y_train), batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(torch.utils.data.TensorDataset(x_test, y_test), batch_size=batch_size, shuffle=False)
################################################################
# training and evaluation
################################################################
model = Net2d(modes, width, arch=arch, einsum=True)
# Convert to NAS search space, if applicable
if xd:
if arch == 'fno':
raise(NotImplementedError("XD substitution not implemented for FNO"))
X = torch.zeros([batch_size, s, s, 3])
Supernet.create(model, in_place=True)
named_modules = []
for name, layer in model.named_modules():
if isinstance(layer, torch.nn.Conv2d):
named_modules.append((name, layer))
# Only patch conv2d
model.conv2xd(X[:1], named_modules=named_modules, arch=original, depth=1, compact=False, verbose=True)
else:
arch_lr = 0.0
cudnn.benchmark = True
model.cuda()
print(model)
print(model.count_params())
if xd:
momentum = partial(torch.optim.SGD, momentum=arch_momentum)
arch_opt = momentum if arch_sgd else torch.optim.Adam
opts = [torch.optim.Adam(model.model_weights(), lr=learning_rate, weight_decay=1E-4),
arch_opt([{'params': list(model.arch_params())}],
lr=arch_lr, weight_decay=1e-4)]
else:
opts = [torch.optim.Adam(model.parameters(),
lr=learning_rate, weight_decay=1e-4)]
optimizer = MixedOptimizer(opts)
def weight_sched(epoch):
return gamma ** (epoch // step_size)
scheduler = torch.optim.lr_scheduler.LambdaLR(
optimizer, lr_lambda=weight_sched, last_epoch=start_epoch-1)
#weight_sched = torch.optim.lr_scheduler.StepLR(optimizer,
# step_size=step_size, gamma=gamma)
#optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=1e-4)
myloss = LpLoss(size_average=False)
y_normalizer.cuda()
for ep in range(epochs):
model.train()
t1 = default_timer()
train_mse = 0
optimizer.zero_grad()
for i, (x, y) in enumerate(train_loader):
x, y = x.cuda(), y.cuda()
# loss = F.mse_loss(model(x).view(-1), y.view(-1), reduction='mean')
out = model(x)
out = y_normalizer.decode(out)
y = y_normalizer.decode(y)
loss = myloss(out.view(batch_size,-1), y.view(batch_size,-1))
loss.backward()
if (i + 1) % acc_steps == 0:
optimizer.step()
optimizer.zero_grad()
# Is this accumulating too many times?
train_mse += loss.item()
scheduler.step()
model.eval()
abs_err = 0.0
rel_err = 0.0
with torch.no_grad():
for x, y in test_loader:
x, y = x.cuda(), y.cuda()
out = model(x)
out = y_normalizer.decode(model(x))
rel_err += myloss(out.view(batch_size,-1), y.view(batch_size,-1)).item()
train_mse/= ntrain
abs_err /= ntest
rel_err /= ntest
t2 = default_timer()
print(ep, t2-t1, train_mse, rel_err)
if __name__ == '__main__':
import fire
fire.Fire(main)
| 10,902 | 33.286164 | 157 | py |
relax | relax-main/examples/pde/utilities3.py | import torch
import numpy as np
import scipy.io
import h5py
import torch.nn as nn
#################################################
#
# Utilities
#
#################################################
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# reading data
class MatReader(object):
def __init__(self, file_path, to_torch=True, to_cuda=False, to_float=True):
super(MatReader, self).__init__()
self.to_torch = to_torch
self.to_cuda = to_cuda
self.to_float = to_float
self.file_path = file_path
self.data = None
self.old_mat = None
self._load_file()
def _load_file(self):
try:
self.data = scipy.io.loadmat(self.file_path)
self.old_mat = True
except ValueError:
self.data = h5py.File(self.file_path)
self.old_mat = False
def load_file(self, file_path):
self.file_path = file_path
self._load_file()
def read_field(self, field):
x = self.data[field]
if not self.old_mat:
x = x[()]
x = np.transpose(x, axes=range(len(x.shape) - 1, -1, -1))
if self.to_float:
x = x.astype(np.float32)
if self.to_torch:
x = torch.from_numpy(x)
if self.to_cuda:
x = x.cuda()
return x
def set_cuda(self, to_cuda):
self.to_cuda = to_cuda
def set_torch(self, to_torch):
self.to_torch = to_torch
def set_float(self, to_float):
self.to_float = to_float
# normalization, pointwise gaussian
class UnitGaussianNormalizer(object):
def __init__(self, x, eps=0.00001):
super(UnitGaussianNormalizer, self).__init__()
# x could be in shape of ntrain*n or ntrain*T*n or ntrain*n*T
self.mean = torch.mean(x, 0)
self.std = torch.std(x, 0)
self.eps = eps
def encode(self, x):
x = (x - self.mean) / (self.std + self.eps)
return x
def decode(self, x, sample_idx=None):
if sample_idx is None:
std = self.std + self.eps # n
mean = self.mean
else:
if len(self.mean.shape) == len(sample_idx[0].shape):
std = self.std[sample_idx] + self.eps # batch*n
mean = self.mean[sample_idx]
if len(self.mean.shape) > len(sample_idx[0].shape):
std = self.std[:,sample_idx]+ self.eps # T*batch*n
mean = self.mean[:,sample_idx]
# x is in shape of batch*n or T*batch*n
x = (x * std) + mean
return x
def cuda(self):
self.mean = self.mean.cuda()
self.std = self.std.cuda()
def cpu(self):
self.mean = self.mean.cpu()
self.std = self.std.cpu()
# normalization, Gaussian
class GaussianNormalizer(object):
def __init__(self, x, eps=0.00001):
super(GaussianNormalizer, self).__init__()
self.mean = torch.mean(x)
self.std = torch.std(x)
self.eps = eps
def encode(self, x):
x = (x - self.mean) / (self.std + self.eps)
return x
def decode(self, x, sample_idx=None):
x = (x * (self.std + self.eps)) + self.mean
return x
def cuda(self):
self.mean = self.mean.cuda()
self.std = self.std.cuda()
def cpu(self):
self.mean = self.mean.cpu()
self.std = self.std.cpu()
# normalization, scaling by range
class RangeNormalizer(object):
def __init__(self, x, low=0.0, high=1.0):
super(RangeNormalizer, self).__init__()
mymin = torch.min(x, 0)[0].view(-1)
mymax = torch.max(x, 0)[0].view(-1)
self.a = (high - low)/(mymax - mymin)
self.b = -self.a*mymax + high
def encode(self, x):
s = x.size()
x = x.view(s[0], -1)
x = self.a*x + self.b
x = x.view(s)
return x
def decode(self, x):
s = x.size()
x = x.view(s[0], -1)
x = (x - self.b)/self.a
x = x.view(s)
return x
#loss function with rel/abs Lp loss
class LpLoss(object):
def __init__(self, d=2, p=2, size_average=True, reduction=True):
super(LpLoss, self).__init__()
#Dimension and Lp-norm type are postive
assert d > 0 and p > 0
self.d = d
self.p = p
self.reduction = reduction
self.size_average = size_average
def abs(self, x, y):
num_examples = x.size()[0]
#Assume uniform mesh
h = 1.0 / (x.size()[1] - 1.0)
all_norms = (h**(self.d/self.p))*torch.norm(x.view(num_examples,-1) - y.view(num_examples,-1), self.p, 1)
if self.reduction:
if self.size_average:
return torch.mean(all_norms)
else:
return torch.sum(all_norms)
return all_norms
def rel(self, x, y):
num_examples = x.size()[0]
diff_norms = torch.norm(x.reshape(num_examples,-1) - y.reshape(num_examples,-1), self.p, 1)
y_norms = torch.norm(y.reshape(num_examples,-1), self.p, 1)
if self.reduction:
if self.size_average:
return torch.mean(diff_norms/y_norms)
else:
return torch.sum(diff_norms/y_norms)
return diff_norms/y_norms
def __call__(self, x, y):
return self.rel(x, y)
# A simple feedforward neural network
class DenseNet(torch.nn.Module):
def __init__(self, layers, nonlinearity, out_nonlinearity=None, normalize=False):
super(DenseNet, self).__init__()
self.n_layers = len(layers) - 1
assert self.n_layers >= 1
self.layers = nn.ModuleList()
for j in range(self.n_layers):
self.layers.append(nn.Linear(layers[j], layers[j+1]))
if j != self.n_layers - 1:
if normalize:
self.layers.append(nn.BatchNorm1d(layers[j+1]))
self.layers.append(nonlinearity())
if out_nonlinearity is not None:
self.layers.append(out_nonlinearity())
def forward(self, x):
for _, l in enumerate(self.layers):
x = l(x)
return x
| 6,182 | 25.766234 | 113 | py |
relax | relax-main/examples/resnet/resnet.py | '''
Properly implemented ResNet-s for CIFAR10 as described in paper [1].
The implementation and structure of this file is hugely influenced by [2]
which is implemented for ImageNet and doesn't have option A for identity.
Moreover, most of the implementations on the web is copy-paste from
torchvision's resnet and has wrong number of params.
Proper ResNet-s for CIFAR10 (for fair comparision and etc.) has following
number of layers and parameters:
name | layers | params
ResNet20 | 20 | 0.27M
ResNet32 | 32 | 0.46M
ResNet44 | 44 | 0.66M
ResNet56 | 56 | 0.85M
ResNet110 | 110 | 1.7M
ResNet1202| 1202 | 19.4m
which this implementation indeed has.
Reference:
[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
Deep Residual Learning for Image Recognition. arXiv:1512.03385
[2] https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py
If you use this implementation in you work, please don't forget to mention the
author, Yerlan Idelbayev.
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.init as init
from torch.autograd import Variable
__all__ = ['ResNet', 'resnet20', 'resnet32', 'resnet44', 'resnet56', 'resnet110', 'resnet1202']
def _weights_init(m):
classname = m.__class__.__name__
#print(classname)
if isinstance(m, nn.Linear) or isinstance(m, nn.Conv2d):
init.kaiming_normal_(m.weight)
class LambdaLayer(nn.Module):
def __init__(self, lambd):
super(LambdaLayer, self).__init__()
self.lambd = lambd
def forward(self, x):
return self.lambd(x)
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, in_planes, planes, stride=1, option='A'):
super(BasicBlock, self).__init__()
self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(planes)
self.shortcut = nn.Sequential()
if stride != 1 or in_planes != planes:
if option == 'A':
"""
For CIFAR10 ResNet paper uses option A.
"""
self.shortcut = LambdaLayer(lambda x:
F.pad(x[:, :, ::2, ::2], (0, 0, 0, 0, planes//4, planes//4), "constant", 0))
elif option == 'B':
self.shortcut = nn.Sequential(
nn.Conv2d(in_planes, self.expansion * planes, kernel_size=1, stride=stride, bias=False),
nn.BatchNorm2d(self.expansion * planes)
)
def forward(self, x):
out = F.relu(self.bn1(self.conv1(x)))
out = self.bn2(self.conv2(out))
out += self.shortcut(x)
out = F.relu(out)
return out
class ResNet(nn.Module):
def __init__(self, block, num_blocks, num_classes=10):
super(ResNet, self).__init__()
self.in_planes = 16
self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(16)
self.layer1 = self._make_layer(block, 16, num_blocks[0], stride=1)
self.layer2 = self._make_layer(block, 32, num_blocks[1], stride=2)
self.layer3 = self._make_layer(block, 64, num_blocks[2], stride=2)
self.linear = nn.Linear(64, num_classes)
self.apply(_weights_init)
def _make_layer(self, block, planes, num_blocks, stride):
strides = [stride] + [1]*(num_blocks-1)
layers = []
for stride in strides:
layers.append(block(self.in_planes, planes, stride))
self.in_planes = planes * block.expansion
return nn.Sequential(*layers)
def forward(self, x):
out = F.relu(self.bn1(self.conv1(x)))
out = self.layer1(out)
out = self.layer2(out)
out = self.layer3(out)
out = F.avg_pool2d(out, out.size()[3])
out = out.view(out.size(0), -1)
out = self.linear(out)
return out
def resnet20(num_classes=10):
return ResNet(BasicBlock, [3, 3, 3], num_classes=num_classes)
def resnet32(num_classes=10):
return ResNet(BasicBlock, [5, 5, 5], num_classes=num_classes)
def resnet44(num_classes=10):
return ResNet(BasicBlock, [7, 7, 7], num_classes=num_classes)
def resnet56(num_classes=10):
return ResNet(BasicBlock, [9, 9, 9], num_classes=num_classes)
def resnet110(num_classes=10):
return ResNet(BasicBlock, [18, 18, 18], num_classes=num_classes)
def resnet1202(num_classes=10):
return ResNet(BasicBlock, [200, 200, 200], num_classes=num_classes)
def test(net):
import numpy as np
total_params = 0
for x in filter(lambda p: p.requires_grad, net.parameters()):
total_params += np.prod(x.data.numpy().shape)
print("Total number of params", total_params)
print("Total layers", len(list(filter(lambda p: p.requires_grad and len(p.data.size())>1, net.parameters()))))
if __name__ == "__main__":
for net_name in __all__:
if net_name.startswith('resnet'):
print(net_name)
test(globals()[net_name]())
print()
| 5,236 | 31.73125 | 120 | py |
relax | relax-main/examples/resnet/trainer.py | import argparse
import json
import math
import os
import pdb
import shutil
import time
from functools import partial
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
import torch.optim
import torch.utils.data
import torchvision.transforms as transforms
import torchvision.datasets as datasets
from tensorboardX import SummaryWriter
import resnet
from relax.nas import MixedOptimizer, Supernet
from relax.xd import fixed, original
class RowColPermute(nn.Module):
def __init__(self, row, col):
super().__init__()
try:
from torch_butterfly.permutation import bitreversal_permutation
self.rowperm = torch.LongTensor(bitreversal_permutation(row))
self.colperm = torch.LongTensor(bitreversal_permutation(col))
print("Using bit-reversal permutation")
except ImportError:
self.rowperm = torch.randperm(row) if type(row) == int else row
self.colperm = torch.randperm(col) if type(col) == int else col
print("Using random permutation")
def forward(self, tensor):
return tensor[:,self.rowperm][:,:,self.colperm]
model_names = sorted(name for name in resnet.__dict__
if name.islower() and not name.startswith("__")
and name.startswith("resnet")
and callable(resnet.__dict__[name]))
parser = argparse.ArgumentParser(description='Propert ResNets for CIFAR10 in pytorch')
parser.add_argument('--backbone', type=str, default='resnet20')
parser.add_argument('--data', default='cifar10', type=str)
parser.add_argument('--device', default=0, type=int)
parser.add_argument('-j', '--workers', default=4, type=int, metavar='N',
help='number of data loading workers (default: 4)')
parser.add_argument('--epochs', default=200, type=int, metavar='N',
help='number of total epochs to run')
parser.add_argument('--start-epoch', default=0, type=int, metavar='N',
help='manual epoch number (useful on restarts)')
parser.add_argument('-b', '--batch-size', default=128, type=int,
metavar='N', help='mini-batch size (default: 128)')
parser.add_argument('--lr', '--learning-rate', default=0.1, type=float,
metavar='LR', help='initial learning rate')
parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
help='momentum')
parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float,
metavar='W', help='weight decay (default: 1e-4)')
parser.add_argument('--print-freq', '-p', default=50, type=int,
metavar='N', help='print frequency (default: 50)')
parser.add_argument('--resume', default='', type=str, metavar='PATH',
help='path to latest checkpoint (default: none)')
parser.add_argument('-e', '--evaluate', dest='evaluate', action='store_true',
help='evaluate model on validation set')
parser.add_argument('--half', dest='half', action='store_true',
help='use half-precision(16-bit) ')
parser.add_argument('--save-dir', dest='save_dir',
help='The directory used to save the trained models',
default='results', type=str)
parser.add_argument('--save-every', dest='save_every',
help='Saves checkpoints at every specified number of epochs',
type=int, default=10)
parser.add_argument('--seed', default=0, type=int)
parser.add_argument('--arch-lr', default=0.1, type=float)
parser.add_argument('--arch-adam', action='store_true')
parser.add_argument('--xd', action='store_true')
parser.add_argument('--fft', action='store_true')
parser.add_argument('--compact', action='store_true')
parser.add_argument('--einsum', action='store_true')
parser.add_argument('--kmatrix-depth', default=1, type=int)
parser.add_argument('--warmup-epochs', default=0, type=int)
parser.add_argument('--permute', action='store_true')
parser.add_argument('--get-permute', type=str, default='')
best_prec1 = 0
def main():
global args, best_prec1
args = parser.parse_args()
torch.manual_seed(args.seed)
model = resnet.__dict__[args.backbone](num_classes=int(args.data[5:]))
torch.cuda.set_device(args.device)
criterion = nn.CrossEntropyLoss().cuda()
writer = SummaryWriter(args.save_dir)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if args.permute or args.get_permute:
if args.get_permute:
permute = torch.load(args.get_permute)['permute']
elif args.resume:
permute = torch.load(args.resume)['permute']
else:
permute = RowColPermute(32, 32)
train_transforms = [transforms.ToTensor(), permute, normalize]
val_transforms = [transforms.ToTensor(), permute, normalize]
else:
permute = None
train_transforms = [transforms.RandomHorizontalFlip(), transforms.RandomCrop(32, 4), transforms.ToTensor(), normalize]
val_transforms = [transforms.ToTensor(), normalize]
cifar = datasets.CIFAR100 if args.data == 'cifar100' else datasets.CIFAR10
train_loader = torch.utils.data.DataLoader(
cifar(root='./data', train=True, transform=transforms.Compose(train_transforms), download=True),
batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
cifar(root='./data', train=False, transform=transforms.Compose(val_transforms)),
batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
if args.half:
model.half()
criterion.half()
if args.fft:
Supernet.create(model, in_place=True)
X, _ = next(iter(train_loader))
arch_kwargs = {'arch': fixed,
'compact': args.compact,
'einsum': args.einsum,
'verbose': not args.resume}
model.conv2xd(X[:1], **arch_kwargs)
if not args.xd:
args.arch_lr = 0.0
print('Model weight count:', sum(p.numel() for p in model.parameters()))
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
model.cuda()
# define optimizer
momentum = partial(torch.optim.SGD, momentum=args.momentum)
optimizer = momentum(model.parameters(), lr=args.lr, weight_decay=args.weight_decay)
def sched(epoch):
if epoch < 1 and args.backbone in ['resnet1202', 'resnet110']:
return 0.1
return 0.1 ** (epoch >= int(0.5 * args.epochs)) * 0.1 ** (epoch >= int(0.75 * args.epochs))
lr_scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=sched, last_epoch=-1)
for epoch in range(args.start_epoch):
optimizer.step() and lr_scheduler.step()
if not args.evaluate:
with open(os.path.join(args.save_dir, 'args.json'), 'w') as f:
json.dump(vars(args), f, indent=4)
for epoch in range(args.start_epoch, args.epochs):
if args.xd and (epoch == args.warmup_epochs or (args.resume and epoch == args.start_epoch and epoch >= args.warmup_epochs)):
model.cpu()
Supernet.create(model, in_place=True)
X, _ = next(iter(train_loader))
arch_kwargs = {'arch': original,
'compact': args.compact,
'einsum': args.einsum,
'depth': args.kmatrix_depth,
'verbose': not args.resume}
model.conv2xd(X[:1], **arch_kwargs)
print('Arch param count:', sum(p.numel() for p in model.arch_params()))
model.cuda()
arch_opt = torch.optim.Adam if args.arch_adam else momentum
optimizer = MixedOptimizer([momentum(model.model_weights(), lr=args.lr, weight_decay=args.weight_decay),
arch_opt(model.arch_params(), lr=args.arch_lr, weight_decay=0.0 if args.arch_adam else args.weight_decay)])
lr_scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=sched, last_epoch=epoch-1)
if args.resume and epoch == args.start_epoch:
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optim_state'])
if args.evaluate:
validate(val_loader, model, criterion)
return
writer.add_scalar('hyper/lr', optimizer.param_groups[0]['lr'], epoch)
if args.xd:
writer.add_scalar('hyper/arch', 0.0 if len(optimizer.param_groups) == 1 else optimizer.param_groups[1]['lr'], epoch)
# train for one epoch
print('current lr {:.5e}'.format(optimizer.param_groups[0]['lr']))
acc, loss = train(train_loader, model, criterion, optimizer, epoch)
writer.add_scalar('train/acc', acc, epoch)
writer.add_scalar('train/loss', loss, epoch)
lr_scheduler.step()
# evaluate on validation set
prec1, loss = validate(val_loader, model, criterion)
writer.add_scalar('valid/acc', prec1, epoch)
writer.add_scalar('valid/loss', loss, epoch)
# remember best prec@1 and save checkpoint
best_prec1 = max(prec1, best_prec1)
model.train()
if (epoch+1) % args.save_every == 0:
save_checkpoint({
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'optim_state': optimizer.state_dict(),
'best_prec1': best_prec1,
'permute': permute,
}, os.path.join(args.save_dir, 'checkpoint.th'))
save_checkpoint({
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
'permute': permute,
}, os.path.join(args.save_dir, 'model.th'))
try:
model.save_arch(os.path.join(args.save_dir, 'arch.th'))
except AttributeError:
pass
writer.flush()
with open(os.path.join(args.save_dir, 'results.json'), 'w') as f:
json.dump({'final validation accuracy': prec1,
'best validation accuracy': best_prec1,
}, f, indent=4)
def train(train_loader, model, criterion, optimizer, epoch):
"""
Run one train epoch
"""
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
# switch to train mode
model.train()
optimizer.zero_grad()
end = time.time()
for i, (input, target) in enumerate(train_loader):
# measure data loading time
data_time.update(time.time() - end)
target = target.cuda()
input_var = input.cuda()
target_var = target
if args.half:
input_var = input_var.half()
# compute output
output = model(input_var)
loss = criterion(output, target_var)
# compute gradient and do SGD step
loss.backward()
optimizer.step()
optimizer.zero_grad()
output = output.float()
loss = loss.float()
# measure accuracy and record loss
prec1 = accuracy(output.data, target)[0]
losses.update(loss.item(), input.size(0))
top1.update(prec1.item(), input.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})'.format(
epoch, i, len(train_loader), batch_time=batch_time,
data_time=data_time, loss=losses, top1=top1))
return top1.avg, losses.avg
def validate(val_loader, model, criterion):
"""
Run evaluation
"""
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
# switch to evaluate mode
model.eval()
end = time.time()
with torch.no_grad():
for i, (input, target) in enumerate(val_loader):
target = target.cuda()
input_var = input.cuda()
target_var = target.cuda()
if args.half:
input_var = input_var.half()
# compute output
output = model(input_var)
loss = criterion(output, target_var)
output = output.float()
loss = loss.float()
# measure accuracy and record loss
prec1 = accuracy(output.data, target)[0]
losses.update(loss.item(), input.size(0))
top1.update(prec1.item(), input.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
print('Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})'.format(
i, len(val_loader), batch_time=batch_time, loss=losses,
top1=top1))
print(' * Prec@1 {top1.avg:.3f}'
.format(top1=top1))
return top1.avg, losses.avg
def save_checkpoint(state, filename):
"""
Save the training model
"""
torch.save(state, filename)
class AverageMeter(object):
"""Computes and stores the average and current value"""
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
def accuracy(output, target, topk=(1,)):
"""Computes the precision@k for the specified values of k"""
maxk = max(topk)
batch_size = target.size(0)
_, pred = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, -1).expand_as(pred))
res = []
for k in topk:
correct_k = correct[:k].view(-1).float().sum(0)
res.append(correct_k.mul_(100.0 / batch_size))
return res
if __name__ == '__main__':
main()
| 15,001 | 35.859951 | 147 | py |
relax | relax-main/relax/xd.py | import math
import pdb
from functools import lru_cache
from itertools import product
import torch
from torch import nn
from torch.nn import functional as F
from relax.ops import AvgPool, Conv, ConvTranspose, FNO, Fourier, SharedOperation, int2tuple, multichannel_prod
class TensorProduct(nn.Module):
'''applies provided maps to multi-dimensional inputs'''
def __init__(self, *maps):
'''
Args:
maps: one argument for each dimension
'''
super().__init__()
self.maps = nn.ModuleList(list(maps))
def forward(self, x):
for i, m in enumerate(reversed(self.maps)):
x = m(x.transpose(-1, -i-1)).transpose(-1, -i-1)
return x
class Pad(nn.Module):
'''module that pads an input before convolution and generates a tuple for unpadding after'''
def __init__(self, dims, in_size=None, kernel_size=1, dilation=1, padding=None, padding_mode='circular', power=False):
'''
Args:
dims: number of padding dimensions
in_size: expected input size before padding
kernel_size: kernel size used by target convolution
dilation: dilation rate used by target convolution
padding: amount of zero padding
padding_mode: type of padding used by target convolution
power: enforce input size to be a power of 2
'''
super(Pad, self).__init__()
self.in_size = ()
self.pad = ()
self.mode = 'constant' if padding_mode == 'zeros' else 'circular'
self.unpad = []
for d, k, n, p in zip(int2tuple(dilation, length=dims),
int2tuple(kernel_size, length=dims),
int2tuple(in_size, length=dims),
int2tuple(padding, length=dims)):
if padding_mode == 'zeros':
p = 0 if p is None else p
self.pad += (p, p)
n = 2 ** math.ceil(math.log2(n+2*p)) if power else n
p = 0
else:
self.pad += (0, 0)
n = 2 ** math.ceil(math.log2(n)) if power else n
self.in_size += (n,)
if p is None:
self.unpad.append((0, 0))
else:
a, b = (d*(k-1)) // 2 - p, 0 - (d*(k-1)+1) // 2 + p
if a < 0 or (not n is None and (a > n+b)):
raise(ValueError("invalid padding"))
self.unpad.append((a, b))
def forward(self, x):
x = F.pad(x, self.pad)
pad, unpad = (), [slice(None), slice(None)]
for xn, n, (a, b) in zip(x.shape[2:], self.in_size, self.unpad):
pad = (0, 0 if n is None else n-xn) + pad
unpad.append(slice(a, xn+b))
return F.pad(x, pad), unpad
class Unpad(nn.Module):
'''module that unpads input to required size given an unpadding tuple generated by Pad.forward'''
def __init__(self, dims, stride=1):
'''
Args:
dims: number of unpadding dimensions
stride: stride length of target convolution
'''
super(Unpad, self).__init__()
stride = int2tuple(stride, length=dims)
if all(s == 1 for s in stride):
self.subsample = nn.Sequential()
elif dims > 3:
raise(NotImplementedError("must have stride 1 if using >3 dims"))
else:
self.subsample = AvgPool(dims)(kernel_size=[1]*dims, stride=stride)
def forward(self, x, unpad):
return self.subsample(x[unpad])
@lru_cache(maxsize=None)
def atrous_permutation(n, k, d):
'''computes single-dimensional atrous permutation for dilating convolutions
Args:
n: input size
k: kernel size
d: dilation rate
Returns:
permutation as a torch.LongTensor
'''
perm = torch.arange(n).roll(k//2-k).flip(0)
for i in range(k-1, 0, -1):
perm[i], perm[d*i] = perm[d*i].item(), perm[i].item()
perm[:d*(k-1)+1] = perm[:d*(k-1)+1].flip(0)
return perm.roll(-((d*(k-1)+1)//2))
class ConvPerm(nn.Module):
'''computes permutation for convolving via FFT'''
def __init__(self, kernel_size=1, dilation=1):
'''
Args:
kernel_size: kernel size of target convolution
dilation: dilation rate of target convolution
'''
super(ConvPerm, self).__init__()
self.kernel_size = kernel_size
self.dilation = dilation
def forward(self, x):
x = x.flip(-1).roll((self.kernel_size+1)//2, dims=-1)
if self.dilation > 1:
return x[...,atrous_permutation(x.shape[-1], self.kernel_size, self.dilation)]
return x
class FNOPerm(nn.Module):
'''computes permutation for applying FNO'''
def __init__(self, kernel_size=1):
'''
Args:
kernel_size: kernel size
'''
super(FNOPerm, self).__init__()
self.kernel_size = kernel_size
def forward(self, x):
k = self.kernel_size
return torch.cat([x[...,:k//2],
x[...,k:],
x[...,k//2:k]],
dim=-1)
class TruncateHermitian(nn.Module):
'''applies Hermitian truncation to last dimension of the Fourier transform of a real signal'''
def forward(self, x):
return x[...,:x.shape[-1]//2+1]
class ExtendHermitian(nn.Module):
'''pads truncated Hermitian signal back to full size'''
def forward(self, x):
n = len(x.shape) - 2
if n == 1:
return torch.cat([x,
torch.conj(x[...,1:x.shape[-1]-1].flip(-1))],
dim=-1)
# lazy hack for multi-dimensional Hermitian padding
dim = tuple(range(-n, 0))
return torch.fft.fftn(torch.fft.irfftn(x, dim=dim), dim=dim)
class TransposePad(nn.Module):
'''applies padding for computing a transposed convolution via FFT'''
def __init__(self, kernel_size=1, dilation=1):
'''
Args:
kernel_size: kernel size of target transposed convolution
dilation: dilation rate of target transposed convolution
'''
super(TransposePad, self).__init__()
self.kernel_size = kernel_size
self.dilation = dilation
def forward(self, x):
return F.pad(x, (0, ((x.shape[-1]-1) * (self.kernel_size-1) * self.dilation)))
@lru_cache(maxsize=None)
def transpose_permutation(n, k, d):
'''computes single-dimensional permutation for transposed convolutions
Args:
n: input size
k: kernel size
d: dilation rate
Returns:
permutation as a torch.LongTensor
'''
perm = torch.arange(n)
p = (k-1) * d
for i in range((n-p) // (p+1) - 1, 0, -1):
perm[p+i], perm[p+(p+1)*i] = perm[p+(p+1)*i].item(), perm[p+i].item()
return perm
class TransposePerm(nn.Module):
'''computes permutation for transposed convolving via FFT'''
def __init__(self, kernel_size=1, dilation=1):
'''
Args:
kernel_size: kernel size of target transposed convolution
dilation: dilation rate of target transposed convolution
'''
super(TransposePerm, self).__init__()
self.kernel_size = kernel_size
self.dilation = dilation
def forward(self, x):
return x[...,transpose_permutation(x.shape[-1], self.kernel_size, self.dilation)]
class TransposeFlip(nn.Module):
'''flips weights for transposed convolving via FFT'''
def __init__(self, kernel_size=1):
'''
Args:
kernel_size: kernel size of target transposed convolution
'''
super(TransposeFlip, self).__init__()
self.kernel_size = kernel_size
def forward(self, x):
return torch.cat([x[...,:self.kernel_size].flip(-1), x[...,self.kernel_size:]], dim=-1)
class Complex2Real(nn.Module):
'''module that returns real part of a complex input'''
def forward(self, x):
return x.real
def fixed(kernel_size, *args, dilation=1, stride=1, padding=0, padding_mode='circular', compact=True, odd=False, fno=False, transpose=False, **kwargs):
'''sets fixed parameters for convolutions in XD format
Args:
kernel_size: kernel size of target convolution
args: ignored
dilation: dilation rate of target convolution
stride: stride of target convolution
padding: padding of target convolution
padding_mode: padding mode of target convolution
compact: use compact signal representation in the frequency domain
odd: signals will have odd size in the last dimension
fno: return parameters for FNO
transpose: return parameter for transposed convolution
kwargs: ignored
Returns:
tuple of five modules corresponding to K, L, M transforms and padding/unpadding
'''
dims = len(kernel_size)
dilation = int2tuple(dilation, length=dims)
padding = int2tuple(padding, length=dims)
if transpose:
if any(padding) or any((k-1)*d+1 != s for k, d, s in zip(kernel_size, dilation, int2tuple(stride, length=dims))):
raise(NotImplementedError("transposed convolutions with stride not equal to dilated kernel size or any padding are not supported"))
K, L, M, inpad, unpad = fixed(kernel_size, stride=1, padding=tuple((k-1)*d for k, d in zip(kernel_size, dilation)), dilation=dilation, padding_mode='zeros', compact=compact, odd=odd or (kernel_size[-1]-1)*dilation[-1] % 2)
inpad = nn.Sequential(TensorProduct(*(TransposePad(k, d) for k, d in zip(kernel_size, dilation))), inpad)
L = nn.Sequential(TensorProduct(*(TransposeFlip(k) for k in kernel_size)), L)
M = nn.Sequential(TensorProduct(*(TransposePerm(k, d) for k, d in zip(kernel_size, dilation))), M)
return K, L, M, inpad, unpad
inpad = Pad(dims, padding=padding, padding_mode=padding_mode, dilation=dilation, kernel_size=kernel_size)
K = Fourier(inv=True, normalized=True, dims=dims, compact=compact, odd=odd)
if not compact:
K = nn.Sequential(K, Complex2Real())
if fno:
if compact:
L = TensorProduct(*(FNOPerm(k) for k in kernel_size[:-1]), TruncateHermitian())
else:
raise(NotImplementedError("must use 'compact=True' when 'fno=True'"))
else:
L = nn.Sequential(TensorProduct(*(ConvPerm(k, d) for k, d in zip(kernel_size, dilation))),
Fourier(dims=dims, compact=compact))
M = Fourier(normalized=True, dims=dims, compact=compact)
unpad = Unpad(dims, stride=stride)
return K, L, M, inpad, unpad
def original(kernel_size, in_size, dilation=1, stride=1, padding=0, padding_mode='circular', compact=True, depth=1, fno=False, transpose=False, **kwargs):
'''sets Butterfly parameters for convolutions in XD format
Args:
kernel_size: kernel size of target convolution
in_size: input size
dilation: dilation rate of target convolution
stride: stride of target convolution
padding: padding of target convolution
padding_mode: padding mode of target convolution
compact: use compact signal representation in the frequency domain
depth: depth of Butterfly matrices
fno: return parameters for FNO
transpose: return parameter for transposed convolution
kwargs: ignored
Returns:
tuple of five modules corresponding to K, L, M transforms and padding/unpadding
'''
from torch_butterfly import Butterfly
from torch_butterfly.combine import butterfly_product
from torch_butterfly.complex_utils import Real2Complex
from torch_butterfly.permutation import FixedPermutation, bitreversal_permutation, perm2butterfly
from torch_butterfly.special import fft, ifft
dims = len(kernel_size)
dilation = int2tuple(dilation, length=dims)
padding = int2tuple(padding, length=dims)
if transpose:
if any(padding) or any((k-1)*d+1 != s for k, d, s in zip(kernel_size, dilation, int2tuple(stride, length=dims))):
raise(NotImplementedError("transposed convolutions with stride not equal to dilated kernel size or any padding are not supported"))
stride = 1
padding = tuple((k-1)*d for k, d in zip(kernel_size, dilation))
in_size = tuple(n+(n-1)*(k-1)*d for n, k, d in zip(int2tuple(in_size, length=dims), kernel_size, dilation))
inpad = Pad(dims, in_size=in_size, padding=padding, padding_mode=padding_mode, dilation=dilation, kernel_size=kernel_size, power=True)
in_size = inpad.in_size
if transpose:
inpad = nn.Sequential(TensorProduct(*(TransposePad(k, d) for k, d in zip(kernel_size, dilation))), inpad)
if compact:
bps = [torch.LongTensor(bitreversal_permutation(n)) for n in in_size]
depth = int2tuple(depth, length=3)
depth = [1+2*compact if depth[0] is None else depth[0],
(2 if fno else 3+2*compact) if depth[1] is None else depth[1],
1+2*compact+2*transpose if depth[2] is None else depth[2]]
blocks = [1 if depth[0] == 2 else max(0, depth[0]-3),
1 if depth[1] in {2, 4} else max(0, depth[1]-5),
1 if depth[2] == 2 or (transpose and depth[2] == 4) else max(0, depth[2]-3-2*transpose)]
kmods = []
kmats = [ifft(n, normalized=True, with_br_perm=False) for n in in_size]
if blocks[0]:
kmats = [butterfly_product(Butterfly(n, n, bias=False, complex=True, init='identity', nblocks=blocks[0]), kmat)
for n, kmat in zip(in_size, kmats)]
if compact:
kmods.append(ExtendHermitian())
if depth[0] > 2:
kmats = [butterfly_product(perm2butterfly(bp, complex=True), kmat) for bp, kmat in zip(bps, kmats)]
else:
kmods.append(TensorProduct(*(FixedPermutation(bp) for bp in bps)))
K = nn.Sequential(*kmods, TensorProduct(*kmats), Complex2Real())
lmods = []
if fno:
if not compact:
raise(ValueError("must use 'compact=True' when 'fno=True'"))
if depth[1] == 1 and dims > 1:
lmods = [TensorProduct(*(FNOPerm(k) for k in kernel_size[:-1]), nn.Identity()),
TensorProduct(*(Butterfly(n, n, bias=False, complex=True, init='identity') for n in in_size))]
else:
lmats = [perm2butterfly(FNOPerm(k)(torch.arange(n)), complex=True) for n, k in zip(in_size[:-1], kernel_size[:-1])]
if depth[1] > 2:
lmats = [butterfly_product(Butterfly(n, n, bias=False, complex=True, init='identity', nblocks=depth[1]-2), lmat)
for n, lmat in zip(in_size[:-1], lmats)]
lmats.append(Butterfly(in_size[-1], in_size[-1], bias=False, complex=True, init='identity', nblocks=depth[1]))
lmods = [TensorProduct(*lmats)]
else:
lmats = [fft(n, br_first=False, with_br_perm=False) for n in in_size]
if blocks[1]:
lmats = [butterfly_product(Butterfly(n, n, bias=False, complex=True, init='identity', nblocks=blocks[1]), lmat)
for n, lmat in zip(in_size, lmats)]
if compact:
if depth[1] > 4:
lmats = [butterfly_product(lmat, perm2butterfly(bp, complex=True)) for bp, lmat in zip(bps, lmats)]
else:
lmods.append(TensorProduct(*(FixedPermutation(bp) for bp in bps)))
perms = [ConvPerm(k, d) for k, d in zip(kernel_size, dilation)]
if transpose:
perms = [nn.Sequential(TransposeFlip(k), perm) for perm, k in zip(perms, kernel_size)]
if depth[1] > 2:
lmats = [butterfly_product(perm2butterfly(perm(torch.arange(n)), complex=True), lmat)
for n, perm, lmat in zip(in_size, perms, lmats)]
lmods = [TensorProduct(*lmats)] + lmods
if depth[1] < 3:
lmods = [TensorProduct(*perms)] + lmods
lmods = [Real2Complex()] + lmods
if compact:
lmods.append(TruncateHermitian())
L = nn.Sequential(*lmods)
mmods = []
mmats = [fft(n, normalized=True, br_first=False, with_br_perm=False) for n in in_size]
if blocks[2]:
mmats = [butterfly_product(Butterfly(n, n, bias=False, complex=True, init='identity', nblocks=blocks[2]), mmat)
for n, mmat in zip(in_size, mmats)]
if compact:
if depth[2] > 2:
mmats = [butterfly_product(mmat, perm2butterfly(bp, complex=True)) for bp, mmat in zip(bps, mmats)]
else:
mmods.append(TensorProduct(*(FixedPermutation(bp) for bp in bps)))
mmods.append(TruncateHermitian())
if transpose:
perms = [TransposePerm(k, d) for k, d in zip(kernel_size, dilation)]
if depth[2] > 4:
mmats = [butterfly_product(perm2butterfly(perm(torch.arange(n)), complex=True), mmat)
for n, perm, mmat in zip(in_size, perms, mmats)]
mmods = [TensorProduct(*mmats)] + mmods
if transpose and depth[2] < 5:
mmods = [TensorProduct(*perms)] + mmods
M = nn.Sequential(Real2Complex(), *mmods)
unpad = Unpad(dims, stride=stride)
return K, L, M, inpad, unpad
def pad2size(x, size, **kwargs):
'''pads input to have the given size
Args:
x: input tensor
size: output size
kwargs: passed to torch.nn.functional.pad
Returns:
padded tensor
'''
if hasattr(x, 'dim'):
return F.pad(x,
sum(((n-k, 0) for n, k in zip(size, x.shape[-len(size):])), ())[::-1],
**kwargs)
return x, size, kwargs
def truncate_freq(in_size, freqs):
'''returns lower frequency slices of Fourier domain data
Args:
in_size: input size
freqs: list of frequencies for each dimension
Returns:
slice generator
'''
start = [slice(None), slice(None)]
dims = len(in_size)
for bits in product(*[range(2)] * dims):
if dims == 1:
n = in_size[0]
yield start + [slice(n-freqs[0], n) if bits[0] else slice(freqs[0])]
else:
yield start + [slice(n-f+bits[0], n) if b else slice(f+bits[0])
for b, n, f in zip(reversed(bits), in_size, freqs)]
class XD(SharedOperation):
'''XD-Operation module for all dimensions'''
def __init__(self, in_channels, out_channels, kernel_size, *args, weight=None, bias=None, groups=1, arch=fixed, truncate=False, dtype=torch.float32, einsum=False, **kwargs):
'''
Args:
in_channels: number of input channels
out_channels: number of output_channels
kernel_size: kernel size as an int or tuple; passed to 'arch'
args: passed to 'arch'
weight: weight parameter as a torch.nn.Parameter object; also takes torch.nn.ParameterList; if None initializes using kernel_size
bias: optional bias parameter as a torch.nn.Parameter object
groups: number of channel groups
arch: architecture initializer method
truncate: truncate frequencies to kernel size
dtype: dtype of weight tensor if initializing
einsum: if True use torch.einsum for product
kwargs: passed to 'arch'
'''
super(XD, self).__init__()
if groups > 1:
if in_channels % groups:
raise(ValueError("in_channels must be divisible by groups"))
elif in_channels != out_channels or groups != in_channels:
raise(NotImplementedError("in_channels must equal groups"))
self.separable = groups == out_channels > 1
kernel_size = int2tuple(kernel_size, length=2, allow_other=True)
self.K, self.L, self.M, self.inpad, self.unpad = arch(kernel_size, *args, **kwargs)
if weight is None:
self.kernel_size = kernel_size
self.weight = nn.Parameter(torch.Tensor(out_channels, in_channels // groups, *self.kernel_size).type(dtype))
else:
self.kernel_size = tuple(weight.shape[2:]) if hasattr(weight, 'shape') else tuple(max(w.shape[i] for w in weight) for i in range(2, len(weight[0].shape)))
self.weight = weight
self.bias = bias
self.truncate = truncate
self.einsum = einsum
def forward(self, x):
x, unpad = self.inpad(x)
in_size = x.shape[2:]
x = self.M(x)
diag = self.L(pad2size(self.weight, in_size))
if self.truncate:
out = torch.zeros(*x.shape, dtype=x.dtype, device=x.device)
for slices in truncate_freq(in_size, [k//2 for k in self.kernel_size[:-1]] + [self.kernel_size[-1]]):
out[slices] = multichannel_prod(x[slices], diag[slices], separable=self.separable, einsum=self.einsum)
x = out
else:
x = multichannel_prod(x, diag, separable=self.separable, einsum=self.einsum)
x = self.K(x)
x = self.unpad(x, unpad)
if self.bias is None:
return x
return x + self.bias.reshape(1, *self.bias.shape, *[1]*len(in_size))
| 21,201 | 38.046041 | 230 | py |
relax | relax-main/relax/nas.py | import pdb
from copy import deepcopy
import torch
from torch import nn, optim
from torch._six import inf
from relax.ops import Conv, int2tuple
from relax.xd import XD
def get_module(model, module_string):
if module_string:
for substring in module_string.split('.'):
model = getattr(model, substring)
return model
def check_weight_norm(module):
for key, value in module._forward_pre_hooks.items():
if type(value) == type(list(nn.utils.weight_norm(Conv(1)(1,1,1))._forward_pre_hooks.items())[0][1]):
return value
class Supernet(nn.Sequential):
@classmethod
def create(cls, model, in_place=False, attrs=[]):
'''
Args:
model: backbone model
in_place: replace backbone model layers in place
attrs: custom attributes of model to replace
'''
model = model if in_place else deepcopy(model)
attrs = attrs if attrs else dir(model)
assert 'forward' in attrs, "if nonempty, 'attrs' must contain 'forward'"
attrs = [(attr, getattr(model, attr)) for attr in attrs if not attr[:2] == '__']
model.__class__ = cls
for name, attr in attrs:
setattr(model, name, attr)
return model
def named_arch_params(self):
'''iterates through (name, param) pairs of all architecture parameters in the model'''
for name, module in self.named_modules():
if name and hasattr(module, 'named_arch_params'):
for n, p in module.named_arch_params():
yield name + '.' + n, p
def arch_params(self):
'''iterates through all architecture parameters in the model'''
return (p for _, p in self.named_arch_params())
def named_model_weights(self):
'''iterates through (name, param) pairs of all model weights in the model'''
exclude = {name for name, _ in self.named_arch_params()}
return ((n, p) for n, p in self.named_parameters() if not n in exclude)
def model_weights(self):
'''iterates through all model weights in the model'''
return (p for _, p in self.named_model_weights())
def patch2xd(self, module_string, sample_input, sample_output, *args, test=False, test_boundary=0, func=lambda m: m, **kwargs):
'''patches specified module with a XD
Args:
module_string: name of module to replace
sample_input: sample input into the module.forward function
sample_output: sample output of the module.forward function
args: passed to xd.XD
test: test agreement of replacement module on 'sample_input' and return relative error
test_boundary: sets boundary when testing replacement module
func: function to apply to xd.XD object before patching
kwargs: passed to xd.XD
'''
if sample_input is None:
module, test = None, False
else:
in_size = sample_input.shape[2:]
in_channels = sample_input.shape[1]
out_channels = sample_output.shape[1]
module = func(XD(in_channels, out_channels, *args, in_size, odd=in_size[-1] % 2, **kwargs))
while True:
module_split = module_string.split('.')
parent = get_module(self, '.'.join(module_split[:-1]))
name = module_split[-1]
child = getattr(parent, name)
setattr(parent, name, module)
for module_string, m in self.named_modules():
if m == child:
break
else:
break
if test:
test_boundary = int2tuple(test_boundary, length=len(in_size))
slc = [slice(None), slice(None)] + [slice(b, n-b) for b, n in zip(int2tuple(test_boundary, length=len(in_size)), in_size)]
output = module(sample_input)
return module, (torch.norm(output[slc] - sample_output[slc]) / torch.norm(sample_output[slc])).item()
return module, "module not used in forward pass" if sample_input is None else None
def collect_io(self, sample_input, modules, *args):
module_io = {}
handles = [m.register_forward_hook(lambda s, i, o: module_io.__setitem__(s, (i[0], o))) for m in modules]
self(sample_input, *args)
for handle in handles:
handle.remove()
return module_io
def conv2xd(self, sample_input, *args, named_modules=None, verbose=False, padding='auto', padding_mode='auto', **kwargs):
'''
Args:
sample_input: torch.Tensor of shape [batch-size, input-channels, *input-width]
args: additional arguments passed to self.forward
named_modules: iterable of named modules ; if None uses all modules in self.model
verbose: print patch logs
padding: if 'auto' uses padding from target module
paddin_mode: if 'auto' uses padding_mode from target module
kwargs: passed to self.patch
'''
named_modules = self.named_modules() if named_modules is None else named_modules
named_modules = [(n, m) for n, m in named_modules if hasattr(m, 'kernel_size') and type(m.kernel_size) == tuple and type(m) == Conv(len(m.kernel_size))]
module_io = self.collect_io(sample_input, (m for _, m in named_modules), *args)
for name, module in named_modules:
wn = check_weight_norm(module)
msg = ""
if wn is None:
func = lambda m: m
else:
msg += "\tweight-norm detected"
def func(m):
m = torch.nn.utils.weight_norm(m, dim=wn.dim)
if m.weight_g.shape == module.weight_g.shape:
m.weight_g = module.weight_g
m.weight_v = module.weight_v
return m
m, err = self.patch2xd(name,
*module_io.get(module, (None, None)),
module.kernel_size,
test=verbose,
test_boundary=1,
func=func,
padding=module.padding if padding == 'auto' else padding,
padding_mode=module.padding_mode if padding == 'auto' else padding_mode,
stride=module.stride,
dilation=module.dilation,
groups=module.groups,
weight=nn.Parameter(module.weight.data),
bias=None if module.bias is None else nn.Parameter(module.bias.data),
**kwargs)
if verbose:
print(name, '\terror:', err, msg)
def save_arch(self, path):
'''saves architecture parameters to provided filepath'''
torch.save(dict(self.named_arch_params()), path)
def load_arch(self, path, verbose=False):
'''loads architecture parameters from provided filepath'''
data = torch.load(path)
for n, p in self.named_arch_params():
load = data[n].data
if p.data.shape == load.shape:
p.data = load.to(p.device)
elif verbose:
print('did not load', n, '(shape mismatch)')
def set_arch_requires_grad(self, requires_grad):
'''sets 'requires_grad' attribute of architecture parameters to given value'''
for param in self.arch_params():
param.requires_grad = bool(requires_grad)
class MixedOptimizer(optim.Optimizer):
def __init__(self, optimizers, alternating=False):
'''
Args:
optimizers: list of objects that are subclasses of optim.Optimizer
alternating: whether to alternate steps with different optimizers
'''
self.optimizers = []
for optimizer in optimizers:
for group in optimizer.param_groups:
group['method'] = type(optimizer)
group['initial_lr'] = group.get('initial_lr', group['lr'])
self.optimizers.append(optimizer)
super(MixedOptimizer, self).__init__((g for o in self.optimizers for g in o.param_groups), {})
self.alternating = alternating
self.iteration = 0
def step(self, closure=None):
if self.alternating:
self.optimizers[self.iteration % len(self.optimizers)].step(closure=closure)
else:
for optimizer in self.optimizers:
optimizer.step(closure=closure)
self.iteration += 1
class MixedScheduler(optim.lr_scheduler._LRScheduler):
def __init__(self, optimizer, scheduler):
'''
Args:
optimizer: MixedOptimizer object
schedulers: list of optim.lr_scheduler._LRScheduler objects
'''
self.schedulers = schedulers
super(MixedScheduler, self).__init__(optimizer)
def step(self, epoch=None):
for scheduler in self.schedulers:
scheduler.step()
def iter_grad(parameters):
for param in parameters:
try:
yield param.grad.real.detach()
yield param.grad.imag.detach()
except RuntimeError:
yield param.grad.detach()
def clip_grad_norm(parameters, max_norm, norm_type=2.0):
'''handles gradient clipping for complex parameters'''
if isinstance(parameters, torch.Tensor):
parameters = [parameters]
parameters = [p for p in parameters if p.grad is not None]
max_norm = float(max_norm)
norm_type = float(norm_type)
if len(parameters) == 0:
return torch.tensor(0.)
device = parameters[0].grad.device
if norm_type == inf:
total_norm = max(g.abs().max().to(device) for g in iter_grad(parameters))
else:
total_norm = torch.norm(torch.stack([torch.norm(g, norm_type).to(device) for g in iter_grad(parameters)]), norm_type)
clip_coef = max_norm / (total_norm + 1E-6)
if clip_coef < 1:
for p in parameters:
p.grad.detach().mul_(clip_coef.to(p.grad.device))
return total_norm
| 10,283 | 37.954545 | 160 | py |
relax | relax-main/relax/ops.py | import math
import pdb
from itertools import product
import torch
import torch.fft
from torch import nn
from torch.nn import functional as F
if int(torch.__version__.split('.')[1]) < 8:
from torch_butterfly.complex_utils import complex_matmul
else:
from torch import matmul as complex_matmul
def Conv(dims):
'''returns PyTorch convolution module of specified dimension'''
return getattr(nn, 'Conv'+str(dims)+'d')
def ConvTranspose(dims):
'''returns PyTorch transposed convolution module of a specified dimension'''
return getattr(nn, 'ConvTranspose'+str(dims)+'d')
def AvgPool(dims):
'''returns PyTorch average pooling module of specified dimension'''
return getattr(nn, 'AvgPool'+str(dims)+'d')
class Fourier(nn.Module):
'''PyTorch module that applies some FFT to an input'''
def __init__(self, inv=False, normalized=False, dims=1, compact=False, odd=False):
'''
Args:
inv: if True use inverse FFT
normalized: if True use normalized FFT
dims: number of dimensions to transform
compact: if True use compact "real" FFT
odd: original signal has odd length in the last dimension (only uised if both inv and compact are True)
'''
super().__init__()
self.inv = inv
self.norm = 'ortho' if normalized else 'backward'
self.dim = list(range(-dims, 0))
self.compact = compact
self.odd = odd and self.inv and self.compact
def forward(self, input):
if self.compact:
func = torch.fft.irfftn if self.inv else torch.fft.rfftn
else:
func = torch.fft.ifftn if self.inv else torch.fft.fftn
return func(input, norm=self.norm, dim=self.dim, s=input.shape[-len(self.dim):-1]+(2*input.shape[-1]-1,) if self.odd else None)
def int2tuple(int_or_tuple, length=2, allow_other=False):
'''converts bools, ints, or slices to tuples of the specified length via repetition
Args:
int_or_tuple: bool, int, or slice, or a tuple of the same
length: expected tuple length
allow_other: allow tuple to have length other than 'length'
'''
if type(int_or_tuple) in {bool, int, slice, type(None)}:
return tuple([int_or_tuple] * length)
if len(int_or_tuple) != length and not allow_other:
raise(ValueError("tuple must have length " + str(length)))
return int_or_tuple
def multichannel_prod(x, w, separable=False, einsum=False):
'''multiple-channel product element-wise product
Args:
x: batched data
w: kernel weights
separable: if True applies one kernel to each channel
einsum: if True use torch.einsum for product
'''
if separable:
x *= w.transpose(0, 1)
return x
dims = len(x.shape)-2
if einsum:
if dims > 3:
raise(NotImplementedError("must have einsum=False if using >3 dims"))
return torch.einsum('xyz'[:dims].join(['bi', ',io', '->bo', '']), x, w.transpose(0, 1))
return complex_matmul(x.permute(*range(2, 2+dims), 0, 1), w.permute(*range(2, 2+dims), 1, 0)).permute(-2, -1, *range(dims))
class FNO(nn.Module):
'''multi-dimensional reimplementation of Fourier Neural Operator [Li et al., ICLR 2021]'''
@staticmethod
def ifftn(*args, **kwargs):
return torch.fft.ifftn(*args, **kwargs).real
def __init__(self, in_channels, out_channels, modes, groups=1, compact=True, pad=False, einsum=False):
'''
Args:
in_channels: number of input channels
out_channels: number of output channels
modes: number of modes, i.e. size of spectral kernel
groups: number of channel groups
compact: if True use compact "real" FFT
pad: if True pad input to a power of 2 before applying FFT
einsum: if True use torch.einsum for product
'''
super(FNO, self).__init__()
if groups > 1:
if in_channels % groups:
raise(ValueError("in_channels must be divisible by groups"))
elif in_channels != out_channels or groups != in_channels:
raise(NotImplementedError("in_channels must equal groups"))
self.groups = groups
self.in_channels = in_channels
self.out_channels = out_channels
self.dims = 1 if type(modes) == int else len(modes)
self.modes = int2tuple(modes, length=self.dims)
self.scale = 1. / (in_channels * out_channels)
self.compact = compact
self.pad = pad
self.fft = torch.fft.rfftn if self.compact else torch.fft.fftn
self.ifft = torch.fft.irfftn if self.compact else self.ifftn
kernel_size = [2*m for m in self.modes[:-1]] + [(2-self.compact)*self.modes[-1]]
self.weight = nn.Parameter(self.scale * torch.rand(out_channels, in_channels//groups, *kernel_size, dtype=torch.complex64))
self.einsum = einsum
def _get_slices(self, size=None):
if self.compact:
size = [2*m for m in self.modes[:-1]] if size is None else size[:-1]
modes = self.modes[:-1]
end = [slice(self.modes[-1])]
else:
size = [2*m for m in self.modes] if size is None else size
modes = self.modes
end = []
for bits in product(*[range(2)] * (self.dims-self.compact)):
yield [slice(None), slice(None)] + [slice(n-m, n) if b else slice(m) for b, n, m in zip(reversed(bits), size, modes)] + end
def forward(self, x):
if self.pad:
unpad = [slice(None)] * 2 + [slice(s) for s in x.shape[2:]]
s = [2 ** math.ceil(math.log2(s)) for s in x.shape[2:]]
size = s[:-1] + [s[-1]//2+1 if self.compact else s[-1]]
else:
unpad, s = [slice(None)], x.shape[2:]
size = list(x.shape[2:-1]) + [x.shape[-1]//2+1 if self.compact else x.shape[-1]]
x_ft = self.fft(x, s=s, dim=tuple(range(-self.dims, 0)), norm='ortho')
out_ft = torch.zeros(len(x), self.out_channels, *size, dtype=torch.complex64, device=x.device)
for xslices, wslices in zip(self._get_slices(size), self._get_slices()):
out_ft[xslices] = multichannel_prod(x_ft[xslices], self.weight[wslices], separable=self.groups == self.weight.shape[0] > 1, einsum=self.einsum)
return self.ifft(out_ft, s=s if self.compact else None, dim=tuple(range(-self.dims, 0)), norm='ortho')[unpad]
class SharedOperation(nn.Module):
@staticmethod
def is_architectural(n):
'''returns False if the name of a parameter corresponds to a model weight'''
return not n.split('.')[0] in {'weight', 'bias'}
def named_arch_params(self):
''''named_parameters' restricted to architecture parameters'''
return ((n, p) for n, p in self.named_parameters() if self.is_architectural(n))
def arch_params(self):
''''parameters' restricted to architecture parameters'''
return (p for _, p in self.named_arch_params())
def named_model_weights(self):
''''named_parameters' restricted to model weights'''
return ((n, p) for n, p in self.named_parameters() if not self.is_architectural(n))
def model_weights(self):
''''parameters' restricted to model weights'''
return (p for _, p in self.named_model_weights())
| 7,401 | 36.958974 | 155 | py |
relax | relax-main/tests/utils.py | import unittest
try:
import torch_butterfly
BUTTERFLY = True
except ImportError:
BUTTERFLY = False
class TestCase(unittest.TestCase):
def test(self, butterfly=False):
pass
@unittest.skipIf(not BUTTERFLY, "torch_butterfly not found")
def test_butterfly(self, **kwargs):
self.test(butterfly=True, **kwargs)
| 352 | 17.578947 | 64 | py |
relax | relax-main/tests/test_xd.py | import pdb
import unittest
import torch
from torch import nn
from relax.ops import Conv, ConvTranspose, FNO
from relax.xd import XD, original
from utils import TestCase
class TestConv(TestCase):
def setUp(self):
self.cases = []
with torch.no_grad():
for dims in range(1, 3):
for in_channels, out_channels in [(1, 1), (2, 3)]:
for n in [15, 16]:
in_size = tuple(n+i for i in range(dims))
for k in range(2, 4):
kernel_size = tuple(k+i for i in range(dims))
for groups in [1] + ([in_channels] if in_channels == out_channels else []):
for dilation in range(1, 2 + 2*(k>1)):
for padding in range(dilation * (k-1) + 1):
mode = 'zeros' if padding > (k-1) // 2 else 'circular'
for stride in range(1, k+1):
conv = Conv(dims)(in_channels,
out_channels,
kernel_size,
bias=False,
groups=groups,
dilation=dilation,
stride=stride,
padding=padding,
padding_mode=mode)
weight = nn.Parameter(conv.weight.data)
x = torch.randn(2, in_channels, *in_size)
out = conv(x)
slc = [slice(None), slice(None)]
if mode == 'circular':
for s, o in zip(in_size, out.shape[2:]):
p = int(padding * int(bin(s)[3:]) > 0)
slc += [slice(p, o-p)]
kwargs = {'in_channels': in_channels,
'out_channels': out_channels,
'n': in_size,
'k': kernel_size,
'groups': groups,
'dilation': dilation,
'stride': stride,
'padding': padding,
'padding_mode': mode}
self.cases.append(([weight, x, out], slc, kwargs))
def compare(self, weight, x, out, slc=[slice(None), slice(None)], in_channels=1, out_channels=1, n=16, k=2, **kwargs):
xd = XD(in_channels, out_channels, k, n, weight=weight, **kwargs)
xd.to(weight.device)
return torch.norm(xd(x)[slc] - out[slc]) / torch.norm(out[slc])
def test(self, cuda=False, butterfly=False):
with torch.no_grad():
for args, slc, kwargs in self.cases:
n = kwargs['n'][-1]
fno = kwargs.get('fno', False)
if cuda:
for i, arg in enumerate(args):
args[i] = arg.cuda()
for einsum in [False, True]:
kwargs['einsum'] = einsum
for truncate in [False] + ([True] if fno else []):
kwargs['truncate'] = truncate
for compact in [True] + ([] if fno else [False]):
kwargs['compact'] = compact
if butterfly:
if kwargs.get('fno', False) and int(bin(n)[3:]):
continue
for depth in [1, None]:
err = self.compare(*args, slc=slc, arch=original, depth=depth, **kwargs).item()
self.assertTrue(err < 1E-5, [err, slc, kwargs])
else:
err = self.compare(*args, odd=n % 2, **kwargs).item()
self.assertTrue(err < 1E-6, [err, slc, kwargs])
@unittest.skipIf(not torch.cuda.is_available(), "CUDA unavailable")
def test_cuda(self):
self.test(cuda=True)
@unittest.skipIf(not torch.cuda.is_available(), "CUDA unavailable")
def test_cuda_butterfly(self):
self.test_butterfly(cuda=True)
class TestConvTranspose(TestConv):
def setUp(self):
self.cases = []
with torch.no_grad():
for dims in range(1, 3):
for in_channels, out_channels in [(1, 1), (2, 3)]:
for n in [15, 16]:
in_size = tuple(n+i for i in range(dims))
for k in range(2, 4):
kernel_size = tuple([k]*dims)
for groups in [1] + ([in_channels] if in_channels == out_channels else []):
for dilation in range(1, 2 + 2*(k>1)):
stride = (k-1) * dilation + 1
padding = 0
mode = 'zeros'
conv = ConvTranspose(dims)(in_channels,
out_channels,
kernel_size,
bias=False,
groups=groups,
dilation=dilation,
stride=stride,
padding=padding,
padding_mode=mode)
weight = nn.Parameter(conv.weight.data.transpose(0, 1))
x = torch.randn(2, in_channels, *in_size)
out = conv(x)
slc = [slice(None), slice(None)]
kwargs = {'transpose': True,
'in_channels': in_channels,
'out_channels': out_channels,
'n': in_size,
'k': kernel_size,
'groups': groups,
'dilation': dilation,
'stride': stride,
'padding': padding,
'padding_mode': mode}
self.cases.append(([weight, x, out], slc, kwargs))
class TestFNO(TestConv):
def setUp(self):
self.cases = []
with torch.no_grad():
for dims in range(1, 3):
for channels in range(1, 3):
for n in [15, 16]:
for k in range(2, 4):
fno = FNO(channels, channels, [k]*dims)
weight = nn.Parameter(fno.weight.data)
x = torch.randn(2, channels, *[n]*dims)
out = fno(x)
slc = [slice(None), slice(None)]
kwargs = {'fno': True,
'padding': None,
'dtype': torch.complex64,
'in_channels': channels,
'out_channels': channels,
'n': [n]*dims,
'k': [2*k]*(dims-1)+[k]}
self.cases.append(([weight, x, out], slc, kwargs))
if __name__ == '__main__':
unittest.main()
| 8,647 | 49.870588 | 122 | py |
relax | relax-main/tests/test_nas.py | import pdb
import unittest
import torch
from relax.nas import Supernet
from relax.xd import original
from fourier_2d import Net2d
from resnet import resnet20
from utils import TestCase
class TestResNet20(TestCase):
def setUp(self):
self.model = resnet20()
self.X = torch.randn(2, 3, 32, 32)
self.out = self.model(self.X)
self.weights = sum(p.numel() for p in self.model.parameters())
self.names = {n for n, p in self.model.named_modules()}
def compare(self, model):
return torch.norm(self.out - model(self.X)) / torch.norm(self.out)
def test(self, butterfly=False):
for einsum in [False, True]:
for compact in [False, True]:
kwargs = {'einsum': einsum, 'compact': compact}
if butterfly:
params = {}
for depth in [1, None]:
model = Supernet.create(self.model)
nm = [(n, m) for n, m in model.named_modules() if n in self.names]
model.conv2xd(self.X,
named_modules=nm,
arch=original, depth=depth, **kwargs)
self.assertEqual(self.weights,
sum(p.numel() for p in model.model_weights()),
"different number of model weights")
params[depth] = sum(p.numel() for p in model.arch_params())
err = self.compare(model).item()
self.assertTrue(err < 1E-5, (err, einsum, compact, butterfly))
self.assertTrue(params[None] > params[1] > 0,
"incorrect number of architecture parameters")
else:
model = Supernet.create(self.model)
nm = [(n, m) for n, m in model.named_modules() if n in self.names]
model.conv2xd(self.X, named_modules=nm, **kwargs)
self.assertEqual(self.weights,
sum(p.numel() for p in model.model_weights()),
"different number of model weights")
self.assertEqual(0, sum(p.numel() for p in model.arch_params()),
"nonzero number of architecture parameters")
err = self.compare(model).item()
self.assertTrue(err < 1E-5, (err, einsum, compact, butterfly))
class TestNet2d(TestResNet20):
def setUp(self):
self.model = Net2d(12, 32, arch='conv', padding_mode='zeros')
self.X = torch.randn(2, 85, 85, 3)
self.out = self.model(self.X)
self.weights = sum(p.numel() for p in self.model.parameters())
self.names = {n for n, m in self.model.named_modules() if '.' in n and 'conv' in n.split('.')[-1]}
if __name__ == '__main__':
unittest.main()
| 2,994 | 40.027397 | 106 | py |
LED2-Net | LED2-Net-main/main.py | import os
import sys
import cv2
import yaml
import argparse
from tqdm import tqdm
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.tensorboard import SummaryWriter
import LED2Net
def train(train_loader, val_loader, model, config):
device = config['exp_args']['device']
multi_gpu = config['exp_args']['multi-gpu']
writer = SummaryWriter(config['exp_args']['exp_path'])
model = nn.DataParallel(model.to(device), output_device=device) if multi_gpu else model.to(device)
module = model.module if multi_gpu else model
optim = getattr(torch.optim, config['optimizer_args']['type'])(
model.parameters(),
**config['optimizer_args']['args']
)
for epoch in range(config['exp_args']['epoch']):
print ('Epoch %d/%d'%(epoch, config['exp_args']['epoch']-1))
train_an_epoch(train_loader, model, optim, writer, epoch, config)
results = val_an_epoch(val_loader, module, config)
print (results)
module.Save(epoch, accuracy=results['down']['IoU_3D'], replace=True)
for up_down, tmp in results.items():
for metric, val in tmp.items(): writer.add_scalar('%s/%s'%(up_down.upper(), metric), val, epoch)
writer.close()
def train_an_epoch(train_loader, model, optim, writer, epoch, config):
device = config['exp_args']['device']
model.train()
visualizer = LED2Net.LayoutVisualizer(**config['exp_args']['visualizer_args'])
render_loss = LED2Net.Loss.RenderLoss(**config['loss_args'])
for i, data in tqdm(enumerate(train_loader), total=len(train_loader)):
#for i, data in enumerate(train_loader):
rgb = data['rgb'].to(device)
corner_num = data['wall-num'].to(device)
ratio = data['ratio'].to(device)
unit_lonlat = data['unit-lonlat'].to(device)
unit_xyz = data['unit-xyz'].to(device)
gt_lonlat = data['pts-lonlat'].to(device)
pred = model(rgb)
pred_lonlat_up = torch.cat([unit_lonlat[:, :, 0:1], pred[:, 0, :, None]], dim=-1)
pred_lonlat_down = torch.cat([unit_lonlat[:, :, 0:1], pred[:, 1, :, None]], dim=-1)
render_loss.setGrid(unit_xyz[0, ...][None, None, ...])
loss_depth_up, loss_depth_down, xyz_lst, depth_lst = render_loss(pred_lonlat_up, pred_lonlat_down, gt_lonlat, corner_num, ratio)
loss = loss_depth_up + loss_depth_down
loss_dict = {
'up': loss_depth_up,
'down': loss_depth_down,
'total': loss
}
optim.zero_grad()
loss.backward()
optim.step()
if i % config['exp_args']['exp_freq'] == 0:
step = epoch * len(train_loader) + i
[pred_depth_up, pred_depth_down, gt_depth] = [LED2Net.Tools.normalizeDepth(x) for x in depth_lst]
pred_xyz_up, pred_xyz_down, GT_xyz_up_sparse, GT_xyz_up_dense = xyz_lst
pred_xyz_down[..., 1:2] = -config['exp_args']['camera_height'] * ratio[..., None, None]
pred_corner_num = torch.zeros_like(corner_num) + pred.shape[2]
pred_rgb_up = visualizer.plot_layout_to_rgb(rgb, pred_xyz_up, pred_corner_num)
pred_rgb_down = visualizer.plot_layout_to_rgb(rgb, pred_xyz_down, pred_corner_num)
gt_rgb = visualizer.plot_layout_to_rgb(rgb, GT_xyz_up_dense, pred_corner_num)
pred_fp_up = visualizer.plot_fp(pred_xyz_up, pred_corner_num)
pred_fp_down = visualizer.plot_fp(pred_xyz_down, pred_corner_num)
gt_fp = visualizer.plot_fp(GT_xyz_up_sparse, corner_num)
for key, val in loss_dict.items(): writer.add_scalar('Loss/%s'%key, val, step)
rgb = F.interpolate(rgb, scale_factor=0.25, recompute_scale_factor=True)
writer.add_images('RGB/equi', rgb, step)
writer.add_images('RGB/pred-up', pred_rgb_up, step)
writer.add_images('RGB/pred-down', pred_rgb_down, step)
writer.add_images('RGB/GT', gt_rgb, step)
writer.add_images('FP/pred-up', pred_fp_up, step)
writer.add_images('FP/pred-down', pred_fp_down, step)
writer.add_images('FP/GT', gt_fp, step)
writer.add_images('Depth/pred-up', pred_depth_up.repeat(1, 1, 100, 1), step)
writer.add_images('Depth/pred-down', pred_depth_down.repeat(1, 1, 100, 1), step)
writer.add_images('Depth/GT', gt_depth.repeat(1, 1, 100, 1), step)
def val_an_epoch(val_loader, model, config):
device = config['exp_args']['device']
model.eval()
visualizer = LED2Net.LayoutVisualizer(**config['exp_args']['visualizer_args'])
render_loss = LED2Net.Loss.RenderLoss(**config['loss_args'])
infer_height = LED2Net.PostProcessing.InferHeight()
layout_metrics_up = LED2Net.Metric.LayoutMetrics.MovingAverageEstimator(**config['metric_args'])
layout_metrics_down = LED2Net.Metric.LayoutMetrics.MovingAverageEstimator(**config['metric_args'])
for i, data in tqdm(enumerate(val_loader), total=len(val_loader)):
rgb = data['rgb'].to(device)
corner_num = data['wall-num'].to(device)
ratio = data['ratio'].to(device)
unit_lonlat = data['unit-lonlat'].to(device)
unit_xyz = data['unit-xyz'].to(device)
gt_lonlat = data['pts-lonlat'].to(device)
with torch.no_grad(): pred = model(rgb)
pred_lonlat_up = torch.cat([unit_lonlat[:, :, 0:1], pred[:, 0, :, None]], dim=-1)
pred_lonlat_down = torch.cat([unit_lonlat[:, :, 0:1], pred[:, 1, :, None]], dim=-1)
pred_ratio = infer_height(pred_lonlat_up, pred_lonlat_down)
render_loss.setGrid(unit_xyz[0, ...][None, None, ...])
loss_depth_up, loss_depth_down, xyz_lst, depth_lst = render_loss(pred_lonlat_up, pred_lonlat_down, gt_lonlat, corner_num, ratio)
[pred_depth_up, pred_depth_down, gt_depth] = [LED2Net.Tools.normalizeDepth(x) for x in depth_lst]
pred_xyz_up, pred_xyz_down, GT_xyz_up_sparse, GT_xyz_up_dense = xyz_lst
pred_xyz_down[..., 1:2] = -config['exp_args']['camera_height'] * ratio[..., None, None]
pred_corner_num = torch.zeros_like(corner_num) + pred.shape[2]
pred_rgb_up = visualizer.plot_layout_to_rgb(rgb, pred_xyz_up, pred_corner_num)
pred_rgb_down = visualizer.plot_layout_to_rgb(rgb, pred_xyz_down, pred_corner_num)
gt_rgb = visualizer.plot_layout_to_rgb(rgb, GT_xyz_up_dense, pred_corner_num)
pred_fp_up = visualizer.plot_fp(pred_xyz_up, pred_corner_num).data.cpu().numpy()
pred_fp_down = visualizer.plot_fp(pred_xyz_down, pred_corner_num).data.cpu().numpy()
gt_fp = visualizer.plot_fp(GT_xyz_up_sparse, corner_num).data.cpu().numpy()
pred_height = config['exp_args']['camera_height'] * (pred_ratio.data.cpu().numpy() + 1)
gt_height = config['exp_args']['camera_height'] * (ratio.data.cpu().numpy() + 1)
layout_metrics_up.update(pred_fp_up, gt_fp, pred_height, gt_height)
layout_metrics_down.update(pred_fp_down, gt_fp, pred_height, gt_height)
results_up = layout_metrics_up()
results_down = layout_metrics_down()
results = {
'up': results_up,
'down': results_down
}
return results
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Training script for LED^2-Net', formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--config', type=str, required=True, help='config.yaml path')
parser.add_argument('--mode', default='train', type=str, required=True, choices=['train', 'val'], help='train/val mode')
args = parser.parse_args()
with open(args.config, 'r') as f: config = yaml.load(f, Loader=yaml.FullLoader)
LED2Net.Tools.fixSeed(config['exp_args']['seed'])
dataset_func = getattr(LED2Net.Dataset, config['dataset_args']['type'])
train_data = dataset_func(**config['dataset_args']['train']).CreateLoader()
val_data = dataset_func(**config['dataset_args']['val']).CreateLoader()
model = LED2Net.Network(**config['network_args'])
model.Load()
if args.mode == 'train':
train(train_data, val_data, model, config)
else:
model = model.to(config['exp_args']['device'])
results = val_an_epoch(val_data, model, config)
print (results)
| 8,409 | 47.057143 | 137 | py |
LED2-Net | LED2-Net-main/run_inference.py | import os
import sys
import yaml
import argparse
from tqdm import tqdm
import numpy as np
import torch
import glob
import json
from imageio import imread, imwrite
from tqdm import tqdm
import pathlib
import LED2Net
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Training script for LED^2-Net', formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--config', type=str, required=True, help='config.yaml path')
parser.add_argument('--src', type=str, required=True, help='The folder that contain *.png or *.jpg')
parser.add_argument('--dst', type=str, required=True, help='The folder to save the output')
parser.add_argument('--ckpt', type=str, required=True, help='Your pretrained model location (xxx.pkl)')
args = parser.parse_args()
with open(args.config, 'r') as f: config = yaml.load(f, Loader=yaml.FullLoader)
device = config['exp_args']['device']
equi_shape = config['exp_args']['visualizer_args']['equi_shape']
model = LED2Net.Network(**config['network_args']).to(device)
params = torch.load(args.ckpt)
model.load_state_dict(params)
model.eval()
tmp = [torch.FloatTensor(x).to(device)[None ,...]
for x in LED2Net.Dataset.SharedFunctions.create_grid(equi_shape)
]
_, unit_lonlat, unit_xyz = tmp
infer_height = LED2Net.PostProcessing.InferHeight()
visualizer = LED2Net.LayoutVisualizer(**config['exp_args']['visualizer_args'])
src = args.src
dst = args.dst
lst = sorted(glob.glob(src+'/*.png') + glob.glob(src+'/*.jpg'))
for one in tqdm(lst):
img = LED2Net.Dataset.SharedFunctions.read_image(one, equi_shape)
batch = torch.FloatTensor(img).permute(2, 0, 1)[None, ...].to(device)
with torch.no_grad(): pred = model(batch)
pred_lonlat_up = torch.cat([unit_lonlat[:, :, 0:1], pred[:, 0, :, None]], dim=-1)
pred_lonlat_down = torch.cat([unit_lonlat[:, :, 0:1], pred[:, 1, :, None]], dim=-1)
pred_ratio = infer_height(pred_lonlat_up, pred_lonlat_down)
pred_corner_num = torch.zeros(pred.shape[0]).to(device).long() + pred.shape[2]
pred_xyz_down = LED2Net.Conversion.lonlat2xyz(pred_lonlat_down, mode='torch')
scale = config['exp_args']['camera_height'] / pred_xyz_down[..., 1:2]
pred_xyz_down *= scale
pred_fp_down = visualizer.plot_fp(pred_xyz_down, pred_corner_num)[0, 0, ...].data.cpu().numpy()
pred_fp_down_man, pred_fp_down_man_pts = LED2Net.DuLaPost.fit_layout(pred_fp_down)
ratio = pred_ratio[0].data.cpu().numpy()
pred_height = (ratio+1) * config['exp_args']['camera_height']
json_data = LED2Net.XY2json(
pred_fp_down_man_pts.T[:, ::-1],
y=config['exp_args']['camera_height'],
h=pred_height
)
dst_dir = dst + '/%s'%(one.split('/')[-1])
pathlib.Path(dst_dir).mkdir(parents=True, exist_ok=True)
imwrite(dst_dir+'/color.jpg', (img*255).astype(np.uint8))
with open(dst_dir+'/pred.json', 'w') as f: f.write(json.dumps(json_data, indent=4)+'\n')
| 3,137 | 42.583333 | 137 | py |
LED2-Net | LED2-Net-main/LED2Net/Tools.py | import torch
import random
import numpy as np
def fixSeed(seed):
np.random.seed(seed)
torch.manual_seed(seed)
random.seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed) # for multiGPUs.
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
def normalizeDepth(depth):
d = depth.clone()
for i in range(depth.shape[0]):
d[i ,...] -= d[i ,...].min()
d[i, ...] /= d[i, ...].max()
return d | 491 | 23.6 | 54 | py |
LED2-Net | LED2-Net-main/LED2Net/Visualizer.py | import cv2
import math
import numpy as np
import torch
import torch.nn as nn
from .Projection import Equirec2Cube
class LayoutVisualizer(object):
def __init__(self, cube_dim, equi_shape, camera_FoV, fp_dim, fp_meters):
self.fp_dim = fp_dim
self.fp_meters = fp_meters
self.FoV = camera_FoV / 180.0 * math.pi
self.e2c = Equirec2Cube(cube_dim, equi_shape[0], camera_FoV)
self.r_lst = np.array([
[0, -180.0, 0],
[90.0, 0, 0],
[0, 0, 0],
[0, 90, 0],
[0, -90, 0],
[-90, 0, 0]
], np.float32) / 180.0 * np.pi
self.face_order = ['back', 'down', 'front', 'left', 'right', 'top']
self.R_lst = [cv2.Rodrigues(x)[0] for x in self.r_lst]
f = 0.5 * cube_dim / np.tan(0.5 * self.FoV)
cx = (cube_dim - 1) / 2
cy = cx
self.K = np.array([
[f, 0, cx],
[0, f, cy],
[0, 0, 1]
], np.float32)
def plot_layout_to_rgb(self, rgb, xyz, num, view='top'):
device = rgb.device
face = self.e2c(rgb)[5::6, ...].permute(0, 2, 3, 1).data.cpu().numpy()
xyz = xyz.data.cpu().numpy()
num = num.data.cpu().numpy()
R = self.R_lst[self.face_order.index(view)]
K = self.K
xyz = xyz @ R.T
xyz_cam = xyz @ K.T
XY_cam = xyz_cam[..., :-1].copy()
XY_cam /= xyz_cam[..., 2:]
XY_cam = np.round(XY_cam).astype(int)
#print (face.shape)
bs = face.shape[0]
out = []
for b in range(bs):
img = face[b].copy().astype(np.float32)
draw_XYs = XY_cam[b, :num[b], ...]
draw_XYs = np.concatenate([draw_XYs, draw_XYs[0:1, ...]], axis=0)
for i in range(draw_XYs.shape[0]-1):
src = tuple(draw_XYs[i])
dst = tuple(draw_XYs[i+1])
try:
cv2.line(img, src, dst, (0, 1.0, 0), thickness=1)
except:
#print (src, dst)
pass
out.append(img.transpose(2, 0, 1)[None, ...])
out = np.concatenate(out, axis=0)
return torch.FloatTensor(out).to(device)
def plot_fp(self, xyz, num):
device = xyz.device
xyz = xyz.data.cpu().numpy()
num = num.data.cpu().numpy()
fp_all = np.zeros([xyz.shape[0], self.fp_dim , self.fp_dim], np.float32)
for b in range(xyz.shape[0]):
xz = xyz[b, :num[b], ::2]
xz = np.round(xz / (self.fp_meters / float(self.fp_dim))).astype(np.int)
xz += self.fp_dim // 2
cv2.fillPoly(fp_all[b, ...], [xz], 1.0)
return torch.FloatTensor(fp_all[:, None, ...]).to(device)
| 2,767 | 32.349398 | 84 | py |
LED2-Net | LED2-Net-main/LED2Net/PostProcessing.py | import torch
import torch.nn as nn
import numpy as np
from scipy.optimize import least_squares
from functools import partial
from .Conversion import EquirecTransformer
def errorCalculate(ratio, up_norm, down_norm):
error = np.abs(ratio * up_norm - down_norm)
#error = np.abs(up_norm - down_norm / ratio)
return error
class InferHeight(nn.Module):
def __init__(self, scale=1):
super().__init__()
self.scale = 1
self.et = EquirecTransformer('torch')
def lonlat2xyz(self, pred_up, pred_down):
pred_up_xyz = self.et.lonlat2xyz(pred_up)
s = -self.scale / pred_up_xyz[..., 1:2]
pred_up_xyz *= s
pred_down_xyz = self.et.lonlat2xyz(pred_down)
s = self.scale / pred_down_xyz[..., 1:2]
pred_down_xyz *= s
return pred_up_xyz, pred_down_xyz
def forward(self, pred_up, pred_down):
pred_up_xyz, pred_down_xyz = self.lonlat2xyz(pred_up, pred_down)
pred_up_xz = pred_up_xyz[..., ::2]
pred_down_xz = pred_down_xyz[..., ::2]
pred_up_norm = torch.norm(pred_up_xz, p=2, dim=-1)
pred_down_norm = torch.norm(pred_down_xz, p=2, dim=-1)
#ratio = (pred_up_norm / pred_down_norm).median(dim=-1)[0]
#ratio = (pred_up_norm / pred_down_norm).mean(dim=-1)
ratio = self.lsq_fit(pred_up_xz, pred_down_xz)
#ratio = 1 / ratio
return ratio
def lsq_fit(self, pred_up_xz, pred_down_xz):
device = pred_up_xz.device
pred_up_xz = pred_up_xz.cpu().numpy()
pred_down_xz = pred_down_xz.cpu().numpy()
ratio = np.zeros(pred_up_xz.shape[0], dtype=np.float32)
for i in range(pred_up_xz.shape[0]):
up_xz = pred_up_xz[i, ...].copy()
up_norm = np.linalg.norm(up_xz, axis=-1)
down_xz = pred_down_xz[i, ...].copy()
down_norm = np.linalg.norm(down_xz, axis=-1)
init_ratio = 1 / np.mean(up_norm / down_norm, axis=-1)
error_func = partial(errorCalculate, up_norm=up_norm, down_norm=down_norm)
ret = least_squares(error_func, init_ratio, verbose=0)
x = ret.x[0]
ratio[i] = x
ratio = torch.FloatTensor(ratio).to(device)
return ratio | 2,261 | 36.081967 | 86 | py |
LED2-Net | LED2-Net-main/LED2Net/Network.py | import numpy as np
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.models as models
import functools
from . import BaseModule
ENCODER_RESNET = [
'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152',
'resnext50_32x4d', 'resnext101_32x8d'
]
ENCODER_DENSENET = [
'densenet121', 'densenet169', 'densenet161', 'densenet201'
]
def lr_pad(x, padding=1):
''' Pad left/right-most to each other instead of zero padding '''
return torch.cat([x[..., -padding:], x, x[..., :padding]], dim=3)
class LR_PAD(nn.Module):
''' Pad left/right-most to each other instead of zero padding '''
def __init__(self, padding=1):
super(LR_PAD, self).__init__()
self.padding = padding
def forward(self, x):
return lr_pad(x, self.padding)
def wrap_lr_pad(net):
for name, m in net.named_modules():
if not isinstance(m, nn.Conv2d):
continue
if m.padding[1] == 0:
continue
w_pad = int(m.padding[1])
m.padding = (m.padding[0], 0)
names = name.split('.')
root = functools.reduce(lambda o, i: getattr(o, i), [net] + names[:-1])
setattr(
root, names[-1],
nn.Sequential(LR_PAD(w_pad), m)
)
'''
Encoder
'''
class Resnet(nn.Module):
def __init__(self, backbone='resnet50', pretrained=True):
super(Resnet, self).__init__()
assert backbone in ENCODER_RESNET
self.encoder = getattr(models, backbone)(pretrained=pretrained)
del self.encoder.fc, self.encoder.avgpool
def forward(self, x):
features = []
x = self.encoder.conv1(x)
x = self.encoder.bn1(x)
x = self.encoder.relu(x)
x = self.encoder.maxpool(x)
x = self.encoder.layer1(x); features.append(x) # 1/4
x = self.encoder.layer2(x); features.append(x) # 1/8
x = self.encoder.layer3(x); features.append(x) # 1/16
x = self.encoder.layer4(x); features.append(x) # 1/32
return features
def list_blocks(self):
lst = [m for m in self.encoder.children()]
block0 = lst[:4]
block1 = lst[4:5]
block2 = lst[5:6]
block3 = lst[6:7]
block4 = lst[7:8]
return block0, block1, block2, block3, block4
class Densenet(nn.Module):
def __init__(self, backbone='densenet169', pretrained=True):
super(Densenet, self).__init__()
assert backbone in ENCODER_DENSENET
self.encoder = getattr(models, backbone)(pretrained=pretrained)
self.final_relu = nn.ReLU(inplace=True)
del self.encoder.classifier
def forward(self, x):
lst = []
for m in self.encoder.features.children():
x = m(x)
lst.append(x)
features = [lst[4], lst[6], lst[8], self.final_relu(lst[11])]
return features
def list_blocks(self):
lst = [m for m in self.encoder.features.children()]
block0 = lst[:4]
block1 = lst[4:6]
block2 = lst[6:8]
block3 = lst[8:10]
block4 = lst[10:]
return block0, block1, block2, block3, block4
'''
Decoder
'''
class ConvCompressH(nn.Module):
''' Reduce feature height by factor of two '''
def __init__(self, in_c, out_c, ks=3):
super(ConvCompressH, self).__init__()
assert ks % 2 == 1
self.layers = nn.Sequential(
nn.Conv2d(in_c, out_c, kernel_size=ks, stride=(2, 1), padding=ks//2),
nn.BatchNorm2d(out_c),
nn.ReLU(inplace=True),
)
def forward(self, x):
return self.layers(x)
class GlobalHeightConv(nn.Module):
def __init__(self, in_c, out_c):
super(GlobalHeightConv, self).__init__()
self.layer = nn.Sequential(
ConvCompressH(in_c, in_c//2),
ConvCompressH(in_c//2, in_c//2),
ConvCompressH(in_c//2, in_c//4),
ConvCompressH(in_c//4, out_c),
)
def forward(self, x, out_w):
x = self.layer(x)
factor = out_w // x.shape[3]
x = torch.cat([x[..., -1:], x, x[..., :1]], 3)
x = F.interpolate(x, size=(x.shape[2], out_w + 2 * factor), mode='bilinear', align_corners=False)
x = x[..., factor:-factor]
return x
class GlobalHeightStage(nn.Module):
def __init__(self, c1, c2, c3, c4, out_scale=8):
''' Process 4 blocks from encoder to single multiscale features '''
super(GlobalHeightStage, self).__init__()
self.cs = c1, c2, c3, c4
self.out_scale = out_scale
self.ghc_lst = nn.ModuleList([
GlobalHeightConv(c1, c1//out_scale),
GlobalHeightConv(c2, c2//out_scale),
GlobalHeightConv(c3, c3//out_scale),
GlobalHeightConv(c4, c4//out_scale),
])
def forward(self, conv_list, out_w):
assert len(conv_list) == 4
bs = conv_list[0].shape[0]
feature = torch.cat([
f(x, out_w).reshape(bs, -1, out_w)
for f, x, out_c in zip(self.ghc_lst, conv_list, self.cs)
], dim=1)
return feature
class Network(BaseModule):
x_mean = torch.FloatTensor(np.array([0.485, 0.456, 0.406])[None, :, None, None])
x_std = torch.FloatTensor(np.array([0.229, 0.224, 0.225])[None, :, None, None])
def __init__(self, save_path, backbone):
super().__init__(save_path)
self.backbone = backbone
self.out_scale = 8
self.step_cols = 4
self.rnn_hidden_size = 512
# Encoder
if backbone.startswith('res'):
self.feature_extractor = Resnet(backbone, pretrained=True)
elif backbone.startswith('dense'):
self.feature_extractor = Densenet(backbone, pretrained=True)
else:
raise NotImplementedError()
#self.feature_extractor.encoder.conv1 = nn.Conv2d(4, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 0), bias=False)
# Inference channels number from each block of the encoder
with torch.no_grad():
dummy = torch.zeros(1, 3, 512, 1024)
c1, c2, c3, c4 = [b.shape[1] for b in self.feature_extractor(dummy)]
c_last = (c1*8 + c2*4 + c3*2 + c4*1) // self.out_scale
# Convert features from 4 blocks of the encoder into B x C x 1 x W'
self.reduce_height_module = GlobalHeightStage(c1, c2, c3, c4, self.out_scale)
self.bi_rnn = nn.LSTM(input_size=c_last,
hidden_size=self.rnn_hidden_size,
num_layers=2,
dropout=0.5,
batch_first=False,
bidirectional=True)
self.drop_out = nn.Dropout(0.5)
#self.linear = nn.Linear(in_features=2 * self.rnn_hidden_size,
# out_features=3 * self.step_cols)
self.linear = nn.Linear(in_features=2 * self.rnn_hidden_size,
out_features=3)
self.linear.bias.data[0*self.step_cols:1*self.step_cols].fill_(-1)
self.linear.bias.data[1*self.step_cols:2*self.step_cols].fill_(-0.478)
self.linear.bias.data[2*self.step_cols:3*self.step_cols].fill_(0.425)
self.x_mean.requires_grad = False
self.x_std.requires_grad = False
wrap_lr_pad(self)
def _prepare_x(self, x):
x = x.clone()
if self.x_mean.device != x.device:
self.x_mean = self.x_mean.to(x.device)
self.x_std = self.x_std.to(x.device)
x[:, :3] = (x[:, :3] - self.x_mean) / self.x_std
return x
def forward(self, x):
x = self._prepare_x(x)
conv_list = self.feature_extractor(x)
feature = self.reduce_height_module(conv_list, x.shape[3]//self.step_cols)
feature = feature.permute(2, 0, 1) # [w, b, c*h]
self.bi_rnn.flatten_parameters()
output, hidden = self.bi_rnn(feature) # [seq_len, b, num_directions * hidden_size]
output = self.drop_out(output)
output = self.linear(output) # [seq_len, b, 3 * step_cols]
output = output.permute(1, 2, 0)
# output.shape => B x 3 x W
cor = output[:, :1] # B x 1 x W
bon = output[:, 1:] # B x 2 x W
bon = torch.sigmoid(bon)
up = bon[:, 0:1, :] * -0.5 * math.pi
down = bon[:, 1:, :] * 0.5 * math.pi
bon = torch.cat([up, down], dim=1)
return bon
if __name__ == '__main__':
net = HorizonNet('resnet50').cuda()
batch = torch.zeros(5, 3, 512, 1024).cuda()
print (net(batch)[0].shape) #bs, 2, 256
#print (net(batch)[1].shape)
| 8,661 | 31.935361 | 127 | py |
LED2-Net | LED2-Net-main/LED2Net/BaseModule.py | import os
import torch
import torch.nn as nn
import datetime
class BaseModule(nn.Module):
def __init__(self, path):
super().__init__()
self.path = path
os.system('mkdir -p %s'%path)
self.model_lst = [x for x in sorted(os.listdir(self.path)) if x.endswith('.pkl')]
self.best_model = None
self.best_accuracy = -float('inf')
def _loadName(self, epoch=None):
if len(self.model_lst) == 0:
print("Empty model folder! Using initial weights")
return None, 0
if epoch is not None:
for i, name in enumerate(self.model_lst):
if name.endswith('%.5d.pkl'%epoch):
print("Use %s"%name)
return name, i
print ('Epoch not found, use initial weights')
return None, 0
else:
print ('Use last epoch, %s'%self.model_lst[-1])
return self.model_lst[-1], len(self.model_lst)-1
def Load(self, epoch=None):
name, _ = self._loadName(epoch)
if name is not None:
params = torch.load('%s/%s'%(self.path, name))
self.load_state_dict(params, strict=False)
self.best_model = name
epoch = int(self.best_model.split('_')[-1].split('.')[0]) + 1
else:
epoch = 0
return epoch
def Save(self, epoch, accuracy=None, replace=False):
if accuracy is None or replace==False:
aaa = '%.5d'%epoch
now = 'model_%s.pkl'%datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S_{}'.format(aaa))
params = self.state_dict()
name = '%s/%s'%(self.path, now)
torch.save(params, name)
self.best_model = now
else:
if accuracy > self.best_accuracy:
aaa = '%.5d'%epoch
now = 'model_%s.pkl'%datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S_{}'.format(aaa))
params = self.state_dict()
name = '%s/%s'%(self.path, now)
if self.best_model is not None: os.system('rm %s/%s'%(self.path, self.best_model))
torch.save(params, name)
self.best_model = now
self.best_accuracy = accuracy
print ('Save %s'%name)
| 2,308 | 36.241935 | 105 | py |
LED2-Net | LED2-Net-main/LED2Net/Padding/CubePadding.py | import torch
import torch.nn as nn
import math
import pdb
import numpy as np
import matplotlib.pyplot as plt
import torch.utils.model_zoo as model_zoo
from torch.autograd import Variable
from torch.nn.parameter import Parameter
import torch.nn.functional as F
class CubePad(nn.Module):
def __init__(self, pad_size, pad_corner=True):
super(CubePad, self).__init__()
self.pad_corner = pad_corner
if type(pad_size) == int:
self.up_pad = pad_size
self.down_pad = pad_size
self.left_pad = pad_size
self.right_pad = pad_size
elif type(pad_size) == list:
[self.up_pad, self.down_pad, self.left_pad, self.right_pad] = pad_size
# pad order: up, down, left, right sides
# use yes/no flag to choose flip/transpose or not
# notation: #face-#side_#flip-hor_#flip_ver_#transpose
# transpose is applied first
self.relation = {
'back': ['top-up_yes_yes_no', 'down-down_yes_yes_no', 'right-right_no_no_no', 'left-left_no_no_no'],
'down': ['front-down_no_no_no', 'back-down_yes_yes_no', 'left-down_yes_no_yes', 'right-down_no_yes_yes'],
'front': ['top-down_no_no_no', 'down-up_no_no_no', 'left-right_no_no_no', 'right-left_no_no_no'],
'left': ['top-left_yes_no_yes', 'down-left_no_yes_yes', 'back-right_no_no_no', 'front-left_no_no_no'],
'right': ['top-right_no_yes_yes', 'down-right_yes_no_yes', 'front-right_no_no_no', 'back-left_no_no_no'],
'top': ['back-up_yes_yes_no', 'front-up_no_no_no', 'left-up_no_yes_yes', 'right-up_yes_no_yes']
}
def forward(self, x):
# [back, down, front, left, right, top]
[bs, c, h, w] = x.size()
assert (bs % 6 == 0) and (h == w)
[up_pad, down_pad, left_pad, right_pad] = [self.up_pad, self.down_pad, self.left_pad, self.right_pad]
mx_pad = max([up_pad, down_pad, left_pad, right_pad])
if mx_pad <= 0:
return x
faces = {
'back': None,
'down': None,
'front': None,
'left': None,
'right': None,
'top': None
}
sides = {
'back-up': None, 'back-down': None, 'back-left': None, 'back-right': None,
'down-up': None, 'down-down': None, 'down-left': None, 'down-right': None,
'front-up': None, 'front-down': None, 'front-left': None, 'front-right': None,
'left-up': None, 'left-down': None, 'left-left': None, 'left-right': None,
'right-up': None, 'right-down': None, 'right-left': None, 'right-right': None,
'top-up': None, 'top-down': None, 'top-left': None, 'top-right': None
}
for idx, face in enumerate(['back', 'down', 'front', 'left', 'right', 'top']):
tmp = x[idx::6, :, :, :]
faces[face] = tmp
for side in ['up', 'down', 'left', 'right']:
if side == 'up':
pad_array = tmp[:, :, 0:mx_pad, :]
elif side == 'down':
pad_array = tmp[:, :, h-mx_pad:h, :]
elif side == 'left':
pad_array = tmp[:, :, :, 0:mx_pad]
elif side == 'right':
pad_array = tmp[:, :, :, w-mx_pad:w]
key = '%s-%s' % (face, side)
assert key in sides
sides[key] = pad_array
out = []
for idx, f in enumerate(['back', 'down', 'front', 'left', 'right', 'top']):
face = faces[f]
new_face = F.pad(face, (left_pad, right_pad, up_pad, down_pad), 'constant', 0)
[bs, _, new_h, new_w] = new_face.size()
assert new_h == new_w
for pad_order, relation in zip(['up', 'down', 'left', 'right'], self.relation[f]):
pad_side, flip_h, flip_w, transpose = relation.split('_')
pad_array = sides[pad_side]
#print pad_order, pad_array is None
if transpose == 'yes':
pad_array = pad_array.transpose(2, 3)
[_, _, hh, ww] = pad_array.size()
if flip_h == 'yes':
index = Variable(torch.arange(hh-1, -1, -1).type(torch.LongTensor)).to(x.device)
pad_array = torch.index_select(pad_array, dim=2, index=index)
if flip_w == 'yes':
index = Variable(torch.arange(ww-1, -1, -1).type(torch.LongTensor)).to(x.device)
pad_array = torch.index_select(pad_array, dim=3, index=index)
if pad_order == 'up' and up_pad != 0:
new_face[:, :, 0:up_pad, left_pad:new_w-right_pad] = pad_array[:, :, 0:up_pad, :]
#print (new_face[:, :, 0:pad, pad:new_w-pad].size(), pad_array.size())
elif pad_order == 'down' and down_pad != 0:
new_face[:, :, new_h-down_pad:new_h, left_pad:new_w-right_pad] = pad_array[:, :, 0:down_pad, :]
#print (new_face[:, :, new_h-pad:new_h, pad:new_w-pad].size(), pad_array.size())
elif pad_order == 'left' and left_pad != 0:
new_face[:, :, up_pad:new_h-down_pad, 0:left_pad] = pad_array[:, :, :, 0:left_pad]
#print (new_face[:, :, pad:new_h-pad, 0:pad].size(), pad_array.size())
elif pad_order == 'right' and right_pad != 0:
#print (left_pad, right_pad, up_pad, down_pad)
new_face[:, :, up_pad:new_h-down_pad, new_w-right_pad:new_w] = pad_array[:, :, :, 0:right_pad]
#print new_face[:, :, up_pad:new_h-down_pad, new_w-right_pad:new_w]
out.append(new_face)
out = torch.cat(out, dim=0)
[bs, c, h, w] = out.size()
out2 = out.view(-1, bs//6, c, h, w).transpose(0, 1).contiguous().view(bs, c, h, w)
if self.pad_corner:
for corner in ['left_up', 'right_up', 'left_down', 'right_down']:
if corner == 'left_up' and (left_pad > 0 and up_pad > 0):
out2[:, :, 0:up_pad, 0:left_pad] = out[:, :, 0:up_pad, left_pad:left_pad+1].repeat(1, 1, 1, left_pad).clone()
elif corner == 'right_up' and (right_pad > 0 and up_pad > 0):
out2[:, :, 0:up_pad, w-right_pad:w] = out[:, :, 0:up_pad, (w-right_pad-1):(w-right_pad)].repeat(1, 1, 1, right_pad).clone()
elif corner == 'left_down' and (left_pad > 0 and down_pad > 0):
out2[:, :, h-down_pad:h, 0:left_pad] = out[:, :, h-down_pad:h, left_pad:left_pad+1].repeat(1, 1, 1, left_pad).clone()
elif corner == 'right_down' and (right_pad > 0 and down_pad > 0):
out2[:, :, h-down_pad:h, w-right_pad:w] = out[:, :, h-down_pad:h, (w-right_pad-1):(w-right_pad)].repeat(1, 1, 1, right_pad).clone()
return out2
| 6,935 | 49.627737 | 151 | py |
LED2-Net | LED2-Net-main/LED2Net/Padding/OtherPadding.py | import torch
import torch.nn as nn
import math
import pdb
import numpy as np
import matplotlib.pyplot as plt
import torch.utils.model_zoo as model_zoo
from torch.autograd import Variable
from torch.nn.parameter import Parameter
import torch.nn.functional as F
class CustomPad(nn.Module):
def __init__(self, pad_func):
super(CustomPad, self).__init__()
self.pad_func = pad_func
def forward(self, x):
return self.pad_func(x)
class NoOp(nn.Module):
def __init__(self):
super(NoOp, self).__init__()
def forward(self, x):
return x
class ZeroPad(nn.Module):
def __init__(self, pad_s):
super(ZeroPad, self).__init__()
self.pad_s = pad_s
def forward(self, x):
x = F.pad(x, (self.pad_s, self.pad_s, self.pad_s, self.pad_s))
return x
| 836 | 19.925 | 71 | py |
LED2-Net | LED2-Net-main/LED2Net/Padding/SpherePadding.py | import os
import sys
import matplotlib.pyplot as plt
import numpy as np
import cv2
import torch
import torch.nn as nn
import torch.nn.functional as F
class SpherePadGrid(object):
def __init__(self, cube_dim, equ_h, FoV=90.0):
self.cube_dim = cube_dim
self.equ_h = equ_h
self.equ_w = equ_h * 2
self.FoV = FoV / 180.0 * np.pi
self.r_lst = np.array([
[0, -180.0, 0],
[90.0, 0, 0],
[0, 0, 0],
[0, 90, 0],
[0, -90, 0],
[-90, 0, 0]
], np.float32) / 180.0 * np.pi
self.R_lst = [cv2.Rodrigues(x)[0] for x in self.r_lst]
self._getCubeGrid()
def _getCubeGrid(self):
f = 0.5 * self.cube_dim / np.tan(0.5 * self.FoV)
cx = (self.cube_dim - 1) / 2
cy = cx
self.intrisic = {
'f': float(f),
'cx': float(cx),
'cy': float(cy)
}
x = np.tile(np.arange(self.cube_dim)[None, ..., None], [self.cube_dim, 1, 1])
y = np.tile(np.arange(self.cube_dim)[..., None, None], [1, self.cube_dim, 1])
ones = np.ones_like(x)
xyz = np.concatenate([x, y, ones], axis=-1)
K = np.array([
[f, 0, cx],
[0, f, cy],
[0, 0, 1]
], np.float32)
xyz = xyz @ np.linalg.inv(K).T
xyz /= np.linalg.norm(xyz, axis=-1, keepdims=True)
self.K = K
self.grids = []
self.grids_xyz = []
for R in self.R_lst:
tmp = xyz @ R # Don't need to transpose since we are doing it for points not for camera
self.grids_xyz.append(tmp)
lon = np.arctan2(tmp[..., 0:1], tmp[..., 2:]) / np.pi
lat = np.arcsin(tmp[..., 1:2]) / (0.5 * np.pi)
lonlat = np.concatenate([lon, lat], axis=-1)
self.grids.append(torch.FloatTensor(lonlat[None, ...]))
def __call__(self):
R_lst = [torch.FloatTensor(x) for x in self.R_lst]
grids_xyz = [torch.FloatTensor(x).view(1, self.cube_dim, self.cube_dim, 3) for x in self.grids_xyz]
K = torch.FloatTensor(self.K)
return R_lst, grids_xyz, self.intrisic
class SpherePad(nn.Module):
def __init__(self, pad_size):
super(SpherePad, self).__init__()
self.pad_size = pad_size
self.data = {}
# pad order: up, down, left, right sides
# use yes/no flag to choose flip/transpose or not
# notation: #face-#side_#flip-hor_#flip_ver_#transpose
# transpose is applied first
self.relation = {
'back': ['top-up_yes_yes_no', 'down-down_yes_yes_no', 'right-right_no_no_no', 'left-left_no_no_no'],
'down': ['front-down_no_no_no', 'back-down_yes_yes_no', 'left-down_yes_no_yes', 'right-down_no_yes_yes'],
'front': ['top-down_no_no_no', 'down-up_no_no_no', 'left-right_no_no_no', 'right-left_no_no_no'],
'left': ['top-left_yes_no_yes', 'down-left_no_yes_yes', 'back-right_no_no_no', 'front-left_no_no_no'],
'right': ['top-right_no_yes_yes', 'down-right_yes_no_yes', 'front-right_no_no_no', 'back-left_no_no_no'],
'top': ['back-up_yes_yes_no', 'front-up_no_no_no', 'left-up_no_yes_yes', 'right-up_yes_no_yes']
}
def _GetLoc(self, R_lst, grid_lst, K):
out = {}
pad = self.pad_size
f, cx, cy = K['f'], K['cx'], K['cy']
K_mat = torch.FloatTensor(
np.array([[f, 0, cx], [0, f, cy], [0, 0, 1]]))
grid_front = grid_lst[2] # 1 x h x h x 3
orders = ['back', 'down', 'front', 'left', 'right', 'top']
for i, face in enumerate(orders):
out[face] = {}
for j, connect_side in enumerate(['up', 'down', 'left', 'right']):
connected_face = self.relation[face][j].split('-')[0]
idx = orders.index(connected_face)
R_world_to_connected = R_lst[idx] # 3 x 3
R_world_to_itself = R_lst[i] # 3 x 3
R_itself_to_connected = torch.matmul(
R_world_to_connected, R_world_to_itself.transpose(0, 1))
new_grid = torch.matmul(
grid_front, R_itself_to_connected.transpose(0, 1))
proj = torch.matmul(new_grid, K_mat.transpose(0, 1))
x = proj[:, :, :, 0:1] / proj[:, :, :, 2:3]
y = proj[:, :, :, 1:2] / proj[:, :, :, 2:3]
x = (x - cx) / cx
y = (y - cy) / cy
xy = torch.cat([x, y], dim=3) # 1 x h x w x 2
out[face][connect_side] = {}
x = xy[:, :, :, 0:1]
y = xy[:, :, :, 1:2]
'''
mask1 = np.logical_and(x >= -1.01, x <= 1.01)
mask2 = np.logical_and(y >= -1.01, y <= 1.01)
mask = np.logical_and(mask1, mask2)
'''
mask1 = (x >= -1.01) & (x <= 1.01)
mask2 = (y >= -1.01) & (y <= 1.01)
mask = mask1 & mask2
xy = torch.clamp(xy, -1, 1)
if connect_side == 'up':
out[face][connect_side]['mask'] = mask[:, :pad, :, :]
out[face][connect_side]['xy'] = xy[:, :pad, :, :]
elif connect_side == 'down':
out[face][connect_side]['mask'] = mask[:, -pad:, :, :]
out[face][connect_side]['xy'] = xy[:, -pad:, :, :]
elif connect_side == 'left':
out[face][connect_side]['mask'] = mask[:, :, :pad, :]
out[face][connect_side]['xy'] = xy[:, :, :pad, :]
elif connect_side == 'right':
out[face][connect_side]['mask'] = mask[:, :, -pad:, :]
out[face][connect_side]['xy'] = xy[:, :, -pad:, :]
return out
def forward(self, inputs):
[bs, c, h, w] = inputs.shape
assert bs % 6 == 0 and h == w
key = '(%d,%d,%d)' % (h, w, self.pad_size)
if key not in self.data:
theta = 2 * np.arctan((0.5 * h + self.pad_size) / (0.5 * h))
grid_ori = SpherePadGrid(h, 2*h, 90)
grid = SpherePadGrid(h+2*self.pad_size, 2*h, theta/np.pi * 180)
R_lst, grid_lst, _ = grid()
_, _, K = grid_ori()
self.data[key] = self._GetLoc(R_lst, grid_lst, K)
pad = self.pad_size
orders = ['back', 'down', 'front', 'left', 'right', 'top']
out = []
for i, face in enumerate(orders):
this_face = inputs[i::6]
this_face = F.pad(this_face, (pad, pad, pad, pad))
repeats = this_face.shape[0]
for j, connect_side in enumerate(['up', 'down', 'left', 'right']):
connected_face_name = self.relation[face][j].split('-')[0]
connected_face = inputs[orders.index(connected_face_name)::6]
mask = self.data[key][face][connect_side]['mask'].cuda().repeat(repeats, 1, 1, c).permute(0, 3, 1, 2).to(inputs.device)
xy = self.data[key][face][connect_side]['xy'].cuda().repeat(repeats, 1, 1, 1).to(inputs.device)
interpo = F.grid_sample(connected_face, xy, align_corners=True, mode='bilinear')
if connect_side == 'up':
this_face[:, :, :pad, :][mask] = interpo[mask]
elif connect_side == 'down':
this_face[:, :, -pad:, :][mask] = interpo[mask]
elif connect_side == 'left':
this_face[:, :, :, :pad][mask] = interpo[mask]
elif connect_side == 'right':
this_face[:, :, :, -pad:][mask] = interpo[mask]
out.append(this_face)
out = torch.cat(out, dim=0)
[bs, c, h, w] = out.shape
out = out.view(-1, bs//6, c, h, w).transpose(0,
1).contiguous().view(bs, c, h, w)
return out
| 7,986 | 44.64 | 135 | py |
LED2-Net | LED2-Net-main/LED2Net/Conversion/MatrixTools.py | import torch
import copy
import pytorch3d.transforms.rotation_conversions as p3dr
__all__ = [
'homogeneous',
'angle_axis_to_rotation_matrix',
'rotation_matrix_to_angle_axis',
'pose_vector_to_projection_matrix'
]
def homogeneous(tensor: torch.Tensor):
shape = list(copy.deepcopy(tensor.shape))
shape[-1] = 1
ones = torch.ones(*shape, dtype=tensor.dtype).to(tensor.device)
t = torch.cat([tensor, ones], dim=-1)
return t
def angle_axis_to_rotation_matrix(angle_axis: torch.Tensor):
R = p3dr.axis_angle_to_matrix(angle_axis)
return R
def rotation_matrix_to_angle_axis(rotation_matrix: torch.Tensor):
angle_axis = p3dr.matrix_to_axis_angle(rotation_matrix)
return angle_axis
def pose_vector_to_projection_matrix(pose_vec, rotation='axis-angle'):
R = angle_axis_to_rotation_matrix(pose_vec[..., :3])
t = pose_vec[..., 3:].unsqueeze(-1)
if rotation == 'axis-angle':
Rt = torch.cat([R, t], dim=-1)
else:
raise NotImplementedError
return Rt | 1,049 | 26.631579 | 70 | py |
LED2-Net | LED2-Net-main/LED2Net/Conversion/EquirecCoordinate.py | import cv2
import torch
import numpy as np
__all__ = ['XY2lonlat', 'lonlat2xyz', 'XY2xyz', 'xyz2lonlat', 'lonlat2XY', 'xyz2XY', 'EquirecTransformer']
def XY2lonlat(xy, shape, mode='numpy'):
lon = ((xy[..., 0] - ((shape[1]-1) / 2.0)) / shape[1]) * 2 * np.pi
lat = ((xy[..., 1] - ((shape[0]-1) / 2.0)) / shape[0]) * np.pi
lon = lon[..., None]
lat = lat[..., None]
out = np.concatenate([lon, lat], axis=-1) if mode == 'numpy' else torch.cat([lon, lat], dim=-1)
return out
def lonlat2xyz(lonlat, RADIUS=1.0, mode='numpy'):
# lonlat is (... x 2)
lon = lonlat[..., 0:1]
lat = lonlat[..., 1:]
cos = np.cos if mode == 'numpy' else torch.cos
sin = np.sin if mode == 'numpy' else torch.sin
x = RADIUS * cos(lat) * sin(lon)
y = RADIUS * sin(lat)
z = RADIUS * cos(lat) * cos(lon)
lst = [x, y, z]
out = np.concatenate(lst, axis=-1) if mode == 'numpy' else torch.cat(lst, dim=-1)
return out
def XY2xyz(xy, shape, mode='numpy'):
lonlat = XY2lonlat(xy, shape, mode)
xyz = lonlat2xyz(lonlat, mode=mode)
return xyz
def xyz2lonlat(xyz, clip, mode='numpy'):
atan2 = np.arctan2 if mode == 'numpy' else torch.atan2
asin = np.arcsin if mode == 'numpy' else torch.asin
norm = np.linalg.norm(
xyz, axis=-1) if mode == 'numpy' else torch.norm(xyz, p=2, dim=-1)
xyz_norm = xyz / norm[..., None]
x = xyz_norm[..., 0:1]
y = xyz_norm[..., 1:2]
z = xyz_norm[..., 2:]
lon = atan2(x, z)
if mode == 'torch':
if clip:
lat = asin(torch.clamp(y, -0.99, 0.99))
else:
lat = asin(y)
else:
if clip:
lat = asin(np.clip(y, -0.99, 0.99))
else:
lat = asin(y)
lst = [lon, lat]
out = np.concatenate(lst, axis=-1) if mode == 'numpy' else torch.cat(lst, dim=-1)
return out
def lonlat2XY(lonlat, shape, mode='numpy'):
X = (lonlat[..., 0:1] / (2 * np.pi) + 0.5) * (shape[1] - 1)
Y = (lonlat[..., 1:] / (np.pi) + 0.5) * (shape[0] - 1)
lst = [X, Y]
out = np.concatenate(lst, axis=-1) if mode == 'numpy' else torch.cat(lst, dim=-1)
return out
def xyz2XY(xyz, shape, clip=False, mode='numpy'):
lonlat = xyz2lonlat(xyz, clip, mode)
XY = lonlat2XY(lonlat, shape, mode)
return XY
class EquirecTransformer:
def __init__(self, mode, clip=False):
assert mode in ['numpy', 'torch']
self.mode = mode
self.clip = clip
def XY2lonlat(self, xy, shape=(512, 1024)):
return XY2lonlat(xy, shape, self.mode)
def lonlat2xyz(self, lonlat, RADIUS=1.0):
return lonlat2xyz(lonlat, RADIUS, self.mode)
def XY2xyz(self, xy, shape=(512, 1024)):
return XY2xyz(xy, shape, self.mode)
def xyz2lonlat(self, xyz):
return xyz2lonlat(xyz, self.clip, self.mode)
def lonlat2XY(self, lonlat, shape=(512, 1024)):
return lonlat2XY(lonlat, shape, self.mode)
def xyz2XY(self, xyz, shape=(512, 1024)):
return xyz2XY(xyz, shape, self.clip, self.mode) | 3,036 | 29.37 | 106 | py |
LED2-Net | LED2-Net-main/LED2Net/Loss/DepthRender.py | import os
import numpy as np
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.nn.functional as F
import sys
import cv2
from .. import Conversion
class RenderLoss(nn.Module):
def __init__(self, camera_height=1.6):
super(RenderLoss, self).__init__()
assert camera_height > 0
self.cH = camera_height
self.grid = None
self.c2d = Corner2Depth(None)
self.et = Conversion.EquirecTransformer('torch')
def setGrid(self, grid):
self.grid = grid
self.c2d.setGrid(grid)
def lonlat2xyz_up(self, pred_up, GT_up, up_down_ratio):
pred_up_xyz = self.et.lonlat2xyz(pred_up)
GT_up_xyz = self.et.lonlat2xyz(GT_up)
s = -(self.cH * up_down_ratio[..., None, None]) / pred_up_xyz[..., 1:2].detach()
pred_up_xyz *= s
s = -(self.cH * up_down_ratio[..., None, None]) / GT_up_xyz[..., 1:2]
GT_up_xyz *= s
return pred_up_xyz, GT_up_xyz
def lonlat2xyz_down(self, pred_down, dummy1=None, dummy2=None):
pred_down_xyz = self.et.lonlat2xyz(pred_down)
s = self.cH / pred_down_xyz[..., 1:2].detach()
pred_down_xyz *= s
return pred_down_xyz, None
def forward(self, pred_up, pred_down, GT_up, corner_nums, up_down_ratio):
# pred_up, pred_down, GT_up is lonlat
assert self.grid is not None
pred_up_xyz, GT_up_xyz = self.lonlat2xyz_up(pred_up, GT_up, up_down_ratio)
pred_down_xyz, _ = self.lonlat2xyz_down(pred_down)
gt_depth, _ = self.c2d(GT_up_xyz, corner_nums)
pred_depth_up, _ = self.c2d(pred_up_xyz, corner_nums, mode='fast')
pred_depth_down, _ = self.c2d(pred_down_xyz, corner_nums, mode='fast')
GT_up_xyz_dense = self.grid[:, 0, ...] * gt_depth.permute(0, 2, 3, 1)[:, 0, :, :]
GT_up_xyz_dense[..., 1:2] = -(self.cH * up_down_ratio[..., None, None])
loss_depth_up = F.l1_loss(pred_depth_up, gt_depth)
loss_depth_down = F.l1_loss(pred_depth_down, gt_depth)
return loss_depth_up, loss_depth_down, [pred_up_xyz, pred_down_xyz, GT_up_xyz, GT_up_xyz_dense], [pred_depth_up, pred_depth_down, gt_depth]
class Corner2Depth(nn.Module):
def __init__(self, grid):
super(Corner2Depth, self).__init__()
self.grid = grid
def setGrid(self, grid):
self.grid = grid
def forward(self, corners, nums, shift=None, mode='origin'):
if mode == 'origin': return self.forward_origin(corners, nums, shift)
else: return self.forward_fast(corners, nums, shift)
def forward_fast(self, corners, nums, shift=None):
if shift is not None: raise NotImplementedError
grid_origin = self.grid.to(corners.device)
eps = 1e-2
depth_maps = []
normal_maps = []
for i, num in enumerate(nums):
grid = grid_origin.clone()
corners_now = corners[i, ...].clone()
corners_now = torch.cat([corners_now, corners_now[0:1, ...]], dim=0)
diff = corners_now[1:, ...] - corners_now[:-1, ...]
vec_yaxis = torch.zeros_like(diff)
vec_yaxis[..., 1] = 1
cross_result = torch.cross(diff, vec_yaxis, dim=1)
d = -torch.sum(cross_result * corners_now[:-1, ...], dim=1, keepdim=True)
planes = torch.cat([cross_result, d], dim=1)
scale_all = -planes[:, 3] / torch.matmul(grid, planes[:, :3].T)
intersec = []
for idx in range(scale_all.shape[-1]):
intersec.append((grid * scale_all[..., idx:idx+1]).unsqueeze(-1))
intersec = torch.cat(intersec, dim=-1)
a = corners_now[1:, ...]
b = corners_now[:-1, ...]
x_cat = torch.cat([a[:, 0:1], b[:, 0:1]], dim=1)
z_cat = torch.cat([a[:, 2:], b[:, 2:]], dim=1)
max_x, min_x = torch.max(x_cat, dim=1)[0], torch.min(x_cat, dim=1)[0]
max_z, min_z = torch.max(z_cat, dim=1)[0], torch.min(z_cat, dim=1)[0]
mask_x = (intersec[:, :, :, 0, :] <= max_x+eps) & (intersec[:, :, :, 0, :] >= min_x-eps)
mask_z = (intersec[:, :, :, 2, :] <= max_z+eps) & (intersec[:, :, :, 2, :] >= min_z-eps)
mask_valid = scale_all > 0
mask = ~(mask_x & mask_z & mask_valid)
scale_all[mask] = float('inf')
depth, min_idx = torch.min(scale_all, dim=-1)
_, h, w = min_idx.shape
normal = planes[min_idx.view(-1), :3].view(1, h, w, -1)
depth_maps.append(depth)
normal_maps.append(normal)
depth_maps = torch.cat(depth_maps, dim=0).unsqueeze(1)
normal_maps = torch.cat(normal_maps, dim=0)
return depth_maps, normal_maps
def forward_origin(self, corners, nums, shift=None):
# corners is (bs, 12, 3)
# nums is (bs, )
# shift is bs x 2 which are x and z shift
grid_origin = self.grid.to(corners.device)
eps = 1e-2
depth_maps = []
normal_maps = []
for i, num in enumerate(nums):
grid = grid_origin.clone()
corners_now = corners[i, :num, ...].clone() # num x 3
if shift is not None:
corners_now[..., 0] -= shift[i, 0]
corners_now[..., 2] -= shift[i, 1]
# equation: ax + by + cz + d = 0
#
corners_now = torch.cat(
[corners_now, corners_now[0:1, ...]], dim=0)
planes = []
for j in range(1, corners_now.shape[0]):
vec_corner = corners_now[j:j+1, ...] - corners_now[j-1:j, ...]
vec_yaxis = torch.zeros_like(vec_corner)
vec_yaxis[..., 1] = 1
cross_result = torch.cross(vec_corner, vec_yaxis)
# now corss_result is a b c
cross_result = cross_result / \
torch.norm(cross_result, p=2, dim=-1)[..., None]
d = -torch.sum(cross_result *
corners_now[j:j+1, ...], dim=-1)[..., None]
abcd = torch.cat([cross_result, d], dim=-1) # abcd is 1, 4
planes.append(abcd)
planes = torch.cat(planes, dim=0) # planes is num x 4
assert planes.shape[0] == num
scale_all = -planes[:, 3] / torch.matmul(grid, planes[:, :3].T)
depth = []
for j in range(scale_all.shape[-1]):
scale = scale_all[..., j]
intersec = scale[..., None] * grid
a = corners_now[j+1:j+2, :]
b = corners_now[j:j+1, :]
rang = torch.cat([a, b], dim=0)
max_x, min_x = torch.max(rang[:, 0]), torch.min(rang[:, 0])
max_z, min_z = torch.max(rang[:, 2]), torch.min(rang[:, 2])
mask_x = (intersec[..., 0] <= max_x +
eps) & (intersec[..., 0] >= min_x-eps)
mask_z = (intersec[..., 2] <= max_z +
eps) & (intersec[..., 2] >= min_z-eps)
mask_valid = scale > 0
mask = ~ (mask_x & mask_z & mask_valid)
#print (scale.max(), scale.min())
# exit()
scale[mask] = float('inf')
depth.append(scale[None, ...])
#import ipdb
# ipdb.set_trace()
#print (depth)
# exit()
depth = torch.cat(depth, dim=1)
depth, min_idx = torch.min(depth, dim=1)
[_, h, w] = min_idx.shape
normal = planes[min_idx.view(-1), :3].view(-1, h, w, 3)
normal_maps.append(normal)
depth_maps.append(depth[None, ...])
depth_maps = torch.cat(depth_maps, dim=0)
normal_maps = torch.cat(normal_maps, dim=0)
return depth_maps, normal_maps
class ShiftSampler(nn.Module):
def __init__(self, dim=256, down_ratio=0.5):
super(ShiftSampler, self).__init__()
self.dim = dim
self.down_ratio = down_ratio
self.grid_x, self.grid_z = np.meshgrid(range(dim), range(dim))
def _GetAngle(self, pred):
[num, _] = pred.shape
tmp = np.concatenate([pred, pred[0:1, :]], axis=0)
abs_cos = []
def forward(self, pred_xyz, pred_corner_num, gt_xyz, gt_corner_num):
#
# pred_xyz bs x 12 x 3
# pred_corner_num bs,
# gt_xyz bs x 12 x 3
# gt_corner_num bs,
#
device = pred_xyz.device
out = np.zeros([pred_xyz.shape[0], 2], dtype=np.float32)
pred_xyz = pred_xyz.data.cpu().numpy() * self.down_ratio
pred_corner_num = pred_corner_num.data.cpu().numpy()
gt_xyz = gt_xyz.data.cpu().numpy() * self.down_ratio
gt_corner_num = gt_corner_num.data.cpu().numpy()
for i in range(pred_xyz.shape[0]):
# first find boundary (max/min xz)
max_x1 = pred_xyz[i, :pred_corner_num[i], 0].max()
max_x2 = gt_xyz[i, :gt_corner_num[i], 0].max()
min_x1 = pred_xyz[i, :pred_corner_num[i], 0].min()
min_x2 = gt_xyz[i, :gt_corner_num[i], 0].min()
max_z1 = pred_xyz[i, :pred_corner_num[i], 2].max()
max_z2 = gt_xyz[i, :gt_corner_num[i], 2].max()
min_z1 = pred_xyz[i, :pred_corner_num[i], 2].min()
min_z2 = gt_xyz[i, :gt_corner_num[i], 2].min()
max_x = np.max([max_x1, max_x2])
min_x = np.min([min_x1, min_x2])
max_z = np.max([max_z1, max_z2])
min_z = np.min([min_z1, min_z2])
pred_xyz_now_normalized = pred_xyz[i, :pred_corner_num[i], :].copy()
self._GetAngle(pred_xyz_now_normalized)
pred_xyz_now_normalized[:, 0] = (pred_xyz_now_normalized[:, 0] - min_x) / (max_x - min_x)
pred_xyz_now_normalized[:, 2] = (pred_xyz_now_normalized[:, 2] - min_z) / (max_z - min_z)
gt_xyz_now_normalized = gt_xyz[i, :gt_corner_num[i], :].copy()
gt_xyz_now_normalized[:, 0] = (gt_xyz_now_normalized[:, 0] - min_x) / (max_x - min_x)
gt_xyz_now_normalized[:, 2] = (gt_xyz_now_normalized[:, 2] - min_z) / (max_z - min_z)
pred_xz_now_normalized = (pred_xyz_now_normalized[..., ::2] * (self.dim - 1)).round().astype(np.int)
gt_xz_now_normalized = (gt_xyz_now_normalized[..., ::2] * (self.dim - 1)).round().astype(np.int)
pred_mask = np.zeros([self.dim, self.dim], np.uint8)
gt_mask = np.zeros([self.dim, self.dim], np.uint8)
cv2.drawContours(pred_mask, [pred_xz_now_normalized], -1, 255, cv2.FILLED)
cv2.drawContours(gt_mask, [gt_xz_now_normalized], -1, 255, cv2.FILLED)
mask = np.logical_and(pred_mask.astype(np.bool), gt_mask.astype(np.bool))
x_valid = self.grid_x[mask]
z_valid = self.grid_z[mask]
idx_choice = np.random.choice(range(z_valid.shape[0]))
if False:
plt.subplot('311')
plt.imshow(pred_mask)
plt.subplot('312')
plt.imshow(gt_mask)
plt.subplot('313')
plt.imshow(mask)
plt.show()
x_choose = x_valid[idx_choice].astype(np.float32)
z_choose = z_valid[idx_choice].astype(np.float32)
out[i, 0] = (x_choose / (self.dim - 1)) * (max_x - min_x) + min_x
out[i, 1] = (z_choose / (self.dim - 1)) * (max_z - min_z) + min_z
return torch.FloatTensor(out).to(device)
| 11,607 | 40.605735 | 147 | py |
LED2-Net | LED2-Net-main/LED2Net/Dataset/Realtor360Dataset.py | import os
import sys
import cv2
import json
import numpy as np
from imageio import imread
import torch
from torch.utils.data import Dataset as TorchDataset
from .BaseDataset import BaseDataset
from ..Conversion import XY2xyz, xyz2XY, xyz2lonlat, lonlat2xyz
from .SharedFunctions import *
class Realtor360Dataset(BaseDataset):
def __init__(self, dataset_path, mode, shape, image_name, label_name, wall_types, aug, camera_height, **kwargs):
super().__init__(**kwargs)
self.shape = shape
self.aug = aug
self.camera_height = camera_height
self.grid, self.unit_lonlat, self.unit_xyz = create_grid(shape)
self.max_wall_num = max(wall_types)
with open('%s/%s.txt'%(dataset_path, mode), 'r') as f: lst = [x.rstrip().split() for x in f]
rgb_lst = [gen_path(dataset_path, x, image_name) for x in lst]
label_lst = [gen_path(dataset_path, x, label_name) for x in lst]
rgb_lst, label_lst = filter_by_wall_num(rgb_lst, label_lst, wall_types)
self.data = list(zip(rgb_lst, label_lst))
def __getitem__(self, idx):
rgb_path, label_path = self.data[idx]
label = read_label(label_path, self.camera_height)
pts = get_contour_3D_points(label['xyz'], label['point_idxs'], label['cameraCeilingHeight'])
aug = self.aug
rgb = read_image(rgb_path, self.shape)
if aug['stretch']:
#if True:
kx = np.random.uniform(1, 2)
kx = 1/kx if np.random.randint(2) == 0 else kx
ky = np.random.uniform(1, 2)
ky = 1/ky if np.random.randint(2) == 0 else ky
kz = np.random.uniform(1, 2)
kz = 1/kz if np.random.randint(2) == 0 else kz
d, inter = plane_to_depth(self.grid, label['planes'], label['xyz'], label['point_idxs'], label['cameraHeight'], label['cameraCeilingHeight'])
inter[:, :, 0] *= kx
inter[:, :, 1] *= ky
inter[:, :, 2] *= kz
rgb = render_rgb(inter, rgb, self.shape)
pts[..., 0] /= kx
pts[..., 1] /= ky
pts[..., 2] /= kz
if aug['rotate']:
dx = np.random.randint(rgb.shape[1])
rgb = np.roll(rgb, dx, axis=1)
angle = (float(dx) / rgb.shape[1]) * 2 * np.pi
r = cv2.Rodrigues(angle * np.array([0, 1, 0], np.float32))[0]
pts = np.dot(pts, r.T)
if aug['flip'] and np.random.randint(2) == 0:
rgb = np.flip(rgb, axis=1).copy()
pts[:, 0] *= -1
pts = pts[::-1, :].copy()
if aug['gamma']:
p = np.random.uniform(1, 2)
if np.random.randint(2) == 0: p = 1 / p
rgb = rgb ** p
pts = xyz2lonlat(pts, clip=False, mode='numpy')
min_x_index = np.argmin(pts[:, 0])
pts = np.concatenate([pts[min_x_index:, :], pts[:min_x_index, :]], axis=0)
num = pts.shape[0]
new_pts = np.zeros([self.max_wall_num, 2], np.float32) + 10000
new_pts[:num, :] = pts
rgb = rgb.transpose(2, 0, 1)
out = {
'rgb': rgb,
'pts-lonlat': new_pts,
'unit-lonlat': self.unit_lonlat,
'unit-xyz': self.unit_xyz,
'wall-num': num,
'ratio': label['cameraCeilingHeight'] / label['cameraHeight'],
'cameraCeilingHeight': label['cameraCeilingHeight'],
'location': rgb_path
}
return out
| 3,525 | 31.953271 | 153 | py |
LED2-Net | LED2-Net-main/LED2Net/Dataset/Matterport3DDataset.py | import os
import sys
import cv2
import json
import numpy as np
from imageio import imread
import torch
from torch.utils.data import Dataset as TorchDataset
from .BaseDataset import BaseDataset
from ..Conversion import XY2xyz, xyz2XY, xyz2lonlat, lonlat2xyz
from .SharedFunctions import *
class Matterport3DDataset(BaseDataset):
def __init__(self, dataset_image_path, dataset_label_path, mode, shape, image_name, wall_types, aug, camera_height, **kwargs):
super().__init__(**kwargs)
self.shape = shape
self.aug = aug
self.camera_height = camera_height
self.grid, self.unit_lonlat, self.unit_xyz = create_grid(shape)
self.max_wall_num = max(wall_types)
with open('%s/mp3d_%s.txt'%(dataset_label_path, mode), 'r') as f: lst = [x.rstrip().split() for x in f]
rgb_lst = [gen_path(dataset_image_path, x, image_name) for x in lst]
label_lst = ['%s/label/%s_%s_label.json'%(dataset_label_path, *x,) for x in lst]
rgb_lst, label_lst = filter_by_wall_num(rgb_lst, label_lst, wall_types)
self.data = list(zip(rgb_lst, label_lst))
def __getitem__(self, idx):
rgb_path, label_path = self.data[idx]
label = read_label(label_path, self.camera_height)
pts = get_contour_3D_points(label['xyz'], label['point_idxs'], label['cameraCeilingHeight'])
aug = self.aug
rgb = read_image(rgb_path, self.shape)
if aug['stretch']:
#if True:
kx = np.random.uniform(1, 2)
kx = 1/kx if np.random.randint(2) == 0 else kx
ky = np.random.uniform(1, 2)
ky = 1/ky if np.random.randint(2) == 0 else ky
kz = np.random.uniform(1, 2)
kz = 1/kz if np.random.randint(2) == 0 else kz
d, inter = plane_to_depth(self.grid, label['planes'], label['xyz'], label['point_idxs'], label['cameraHeight'], label['cameraCeilingHeight'])
inter[:, :, 0] *= kx
inter[:, :, 1] *= ky
inter[:, :, 2] *= kz
rgb = render_rgb(inter, rgb, self.shape)
pts[..., 0] /= kx
pts[..., 1] /= ky
pts[..., 2] /= kz
if aug['rotate']:
dx = np.random.randint(rgb.shape[1])
rgb = np.roll(rgb, dx, axis=1)
angle = (float(dx) / rgb.shape[1]) * 2 * np.pi
r = cv2.Rodrigues(angle * np.array([0, 1, 0], np.float32))[0]
pts = np.dot(pts, r.T)
if aug['flip'] and np.random.randint(2) == 0:
rgb = np.flip(rgb, axis=1).copy()
pts[:, 0] *= -1
pts = pts[::-1, :].copy()
if aug['gamma']:
p = np.random.uniform(1, 2)
if np.random.randint(2) == 0: p = 1 / p
rgb = rgb ** p
pts = xyz2lonlat(pts, clip=False, mode='numpy')
min_x_index = np.argmin(pts[:, 0])
pts = np.concatenate([pts[min_x_index:, :], pts[:min_x_index, :]], axis=0)
num = pts.shape[0]
new_pts = np.zeros([self.max_wall_num, 2], np.float32) + 10000
new_pts[:num, :] = pts
rgb = rgb.transpose(2, 0, 1)
out = {
'rgb': rgb,
'pts-lonlat': new_pts,
'unit-lonlat': self.unit_lonlat,
'unit-xyz': self.unit_xyz,
'wall-num': num,
'ratio': label['cameraCeilingHeight'] / label['cameraHeight'],
'cameraCeilingHeight': label['cameraCeilingHeight'],
'location': rgb_path
}
return out
| 3,574 | 32.411215 | 153 | py |
LED2-Net | LED2-Net-main/LED2Net/Dataset/BaseDataset.py | import os
import sys
import cv2
import numpy as np
from imageio import imread
import matplotlib.pyplot as plt
from tqdm import tqdm
import torch
from torch.utils.data import Dataset as TorchDataset
from torch.utils.data import DataLoader as TorchDataLoader
class BaseDataset(TorchDataset):
def __init__(self, **kwargs):
self.loader_args = kwargs['loader_args']
def __len__(self,):
return len(self.data)
def CreateLoader(self):
return TorchDataLoader(self, **self.loader_args)
| 516 | 22.5 | 58 | py |
LED2-Net | LED2-Net-main/LED2Net/Projection/Equirec2Cube.py | import os
import sys
import cv2
import time
from imageio import imread
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
class Equirec2Cube(nn.Module):
def __init__(self, cube_dim, equ_h, FoV=90.0):
super().__init__()
self.cube_dim = cube_dim
self.equ_h = equ_h
self.equ_w = equ_h * 2
self.FoV = FoV / 180.0 * np.pi
self.r_lst = np.array([
[0, -180.0, 0],
[90.0, 0, 0],
[0, 0, 0],
[0, 90, 0],
[0, -90, 0],
[-90, 0, 0]
], np.float32) / 180.0 * np.pi
self.R_lst = [cv2.Rodrigues(x)[0] for x in self.r_lst]
self._getCubeGrid()
def _getCubeGrid(self):
f = 0.5 * self.cube_dim / np.tan(0.5 * self.FoV)
cx = (self.cube_dim - 1) / 2
cy = cx
x = np.tile(np.arange(self.cube_dim)[None, ..., None], [self.cube_dim, 1, 1])
y = np.tile(np.arange(self.cube_dim)[..., None, None], [1, self.cube_dim, 1])
ones = np.ones_like(x)
xyz = np.concatenate([x, y, ones], axis=-1)
K = np.array([
[f, 0, cx],
[0, f, cy],
[0, 0, 1]
], np.float32)
xyz = xyz @ np.linalg.inv(K).T
xyz /= np.linalg.norm(xyz, axis=-1, keepdims=True)
self.grids = []
for R in self.R_lst:
tmp = xyz @ R # Don't need to transpose since we are doing it for points not for camera
lon = np.arctan2(tmp[..., 0:1], tmp[..., 2:]) / np.pi
lat = np.arcsin(tmp[..., 1:2]) / (0.5 * np.pi)
lonlat = np.concatenate([lon, lat], axis=-1)
self.grids.append(torch.FloatTensor(lonlat[None, ...]))
def forward(self, batch, mode='bilinear'):
[_, _, h, w] = batch.shape
assert h == self.equ_h and w == self.equ_w
assert mode in ['nearest', 'bilinear']
out = []
for grid in self.grids:
grid = grid.to(batch.device)
grid = grid.repeat(batch.shape[0], 1, 1, 1)
sample = F.grid_sample(batch, grid, mode=mode, align_corners=True)
out.append(sample)
out = torch.cat(out, dim=0)
final_out = []
for i in range(batch.shape[0]):
final_out.append(out[i::batch.shape[0], ...])
final_out = torch.cat(final_out, dim=0)
return final_out
if __name__ == '__main__':
img1 = imread('./0_color.png', pilmode='RGB').astype(np.float32) / 255
img2 = imread('./10_color.png', pilmode='RGB').astype(np.float32) / 255
img = [img1, img2]
batch1 = torch.FloatTensor(img1.transpose(2, 0, 1)[None, ...]).cuda()
batch2 = torch.FloatTensor(img2.transpose(2, 0, 1)[None, ...]).cuda()
batch = torch.cat([batch1, batch2], dim=0)
e2c = Equirec2Cube(256, 512)
cube = e2c(batch).cpu().numpy()
print (cube.shape)
face_name = ['back', 'down', 'front', 'left', 'right', 'top']
import matplotlib.pyplot as plt
for c in range(cube.shape[0] // 6):
plt.figure()
plt.imshow(img[c])
plt.figure()
for i in range(6):
face = cube[c*6+i, ...].transpose(1, 2, 0)
plt.subplot(2, 3, i+1)
plt.title(face_name[i])
plt.imshow(face)
plt.show()
| 3,302 | 33.051546 | 99 | py |
LED2-Net | LED2-Net-main/LED2Net/Projection/EquirecGrid.py | import torch
import torch.nn as nn
from .. import Conversion
class EquirecGrid(object):
def __init__(self):
super().__init__()
self.bag = {}
self.ET = Conversion.EquirecTransformer('torch')
def _createGrid(self, key, h, w):
X = torch.arange(w)[None, :, None].repeat(h, 1, 1)
Y = torch.arange(h)[:, None, None].repeat(1, w, 1)
XY = torch.cat([X, Y], dim=-1).unsqueeze(0)
self.bag[key] = XY
def _checkBag(self, h, w):
key = '(%d,%d)'%(h, w)
if key not in self.bag: self._createGrid(key, h, w)
return self.bag[key]
def to_xyz(self, depth):
assert len(depth.shape) == 4 and depth.shape[1] == 1
h, w = depth.shape[2:]
grid = self._checkBag(h, w).to(depth.device)
xyz = self.ET.XY2xyz(grid, shape=[h, w]).permute(0, 3, 1, 2) * depth
return xyz | 881 | 27.451613 | 76 | py |
LED2-Net | LED2-Net-main/LED2Net/Projection/EquirecRotate.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import math
from .. import Conversion
class EquirecRotate(nn.Module):
def __init__(self, equ_h):
super().__init__()
self.equ_h = equ_h
self.equ_w = equ_h * 2
X = torch.arange(self.equ_w)[None, :, None].repeat(self.equ_h, 1, 1)
Y = torch.arange(self.equ_h)[:, None, None].repeat(1, self.equ_w, 1)
XY = torch.cat([X, Y], dim=-1).unsqueeze(0)
self.grid = Conversion.XY2xyz(XY, shape=(self.equ_h, self.equ_w), mode='torch')
def forward(self, equi, axis_angle, mode='bilinear'):
assert mode in ['nearest', 'bilinear']
grid = self.grid.to(equi.device).repeat(equi.shape[0], 1, 1, 1)
R = Conversion.angle_axis_to_rotation_matrix(axis_angle)
xyz = (R[:, None, None, ...] @ grid[..., None]).squeeze(-1)
XY = Conversion.xyz2lonlat(xyz, clip=False, mode='torch')
X, Y = torch.unbind(XY, dim=-1)
XY = torch.cat([(X/math.pi).unsqueeze(-1), (Y/0.5/math.pi).unsqueeze(-1)], dim=-1)
sample = F.grid_sample(equi, XY, mode=mode, align_corners=True)
return sample
| 1,164 | 39.172414 | 90 | py |
LED2-Net | LED2-Net-main/LED2Net/Projection/Cube2Equirec.py | import os
import sys
import cv2
import math
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
import scipy.misc as sic
class Cube2Equirec(nn.Module):
def __init__(self, cube_length, equ_h):
super().__init__()
self.cube_length = cube_length
self.equ_h = equ_h
equ_w = equ_h * 2
self.equ_w = equ_w
theta = (np.arange(equ_w) / (equ_w-1) - 0.5) * 2 *np.pi
phi = (np.arange(equ_h) / (equ_h-1) - 0.5) * np.pi
theta, phi = np.meshgrid(theta, phi)
x = np.sin(theta) * np.cos(phi)
y = np.sin(phi)
z = np.cos(theta) * np.cos(phi)
xyz = np.concatenate([x[..., None], y[..., None], z[..., None]], axis=-1)
planes = np.asarray([
[0, 0, 1, 1], # z = -1
[0, 1, 0, -1], # y = 1
[0, 0, 1, -1], # z = 1
[1, 0, 0, 1], # x = -1
[1, 0, 0, -1], # x = 1
[0, 1, 0, 1] # y = -1
])
r_lst = np.array([
[0, 1, 0],
[0.5, 0, 0],
[0, 0, 0],
[0, 0.5, 0],
[0, -0.5, 0],
[-0.5, 0, 0]
]) * np.pi
f = cube_length / 2.0
self.K = np.array([
[f, 0, (cube_length-1)/2.0],
[0, f, (cube_length-1)/2.0],
[0, 0, 1]
])
self.R_lst = [cv2.Rodrigues(x)[0] for x in r_lst]
self.mask, self.XY = self._intersection(xyz, planes)
def forward(self, x, mode='bilinear'):
assert mode in ['nearest', 'bilinear']
assert x.shape[0] % 6 == 0
equ_count = x.shape[0] // 6
equi = torch.zeros(equ_count, x.shape[1], self.equ_h, self.equ_w).to(x.device)
for i in range(6):
now = x[i::6, ...]
mask = self.mask[i].to(x.device)
mask = mask[None, ...].repeat(equ_count, x.shape[1], 1, 1)
XY = (self.XY[i].to(x.device)[None, None, :, :].repeat(equ_count, 1, 1, 1) / (self.cube_length-1) - 0.5) * 2
sample = F.grid_sample(now, XY, mode=mode, align_corners=True)[..., 0, :]
equi[mask] = sample.view(-1)
return equi
def _intersection(self, xyz, planes):
abc = planes[:, :-1]
depth = -planes[:, 3][None, None, ...] / np.dot(xyz, abc.T)
depth[depth < 0] = np.inf
arg = np.argmin(depth, axis=-1)
depth = np.min(depth, axis=-1)
pts = depth[..., None] * xyz
mask_lst = []
mapping_XY = []
for i in range(6):
mask = arg == i
mask = np.tile(mask[..., None], [1, 1, 3])
XY = np.dot(np.dot(pts[mask].reshape([-1, 3]), self.R_lst[i].T), self.K.T)
XY = np.clip(XY[..., :2].copy() / XY[..., 2:], 0, self.cube_length-1)
mask_lst.append(mask[..., 0])
mapping_XY.append(XY)
mask_lst = [torch.BoolTensor(x) for x in mask_lst]
mapping_XY = [torch.FloatTensor(x) for x in mapping_XY]
return mask_lst, mapping_XY
if __name__ == '__main__':
import matplotlib.pyplot as plt
batch = torch.zeros(12, 3, 256, 256) + 20
c2e = Cube2Equirec(256, 512)
equi = c2e(batch)
plt.imshow(equi[0, ...].permute(1, 2, 0).cpu().numpy())
plt.show()
| 3,434 | 31.102804 | 120 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/complete_verification_experiments.py | import csv
import time
from comet_ml import Experiment # type: ignore[import]
import numpy as np
import pandas as pd # type: ignore[import]
import torch
from torch import nn
from src.abstract_layers.abstract_network import AbstractNetwork
from src.mn_bab_verifier import MNBaBVerifier
from src.utilities.argument_parsing import get_args, get_config_from_json
from src.utilities.config import make_verifier_config
from src.utilities.initialization import seed_everything
from src.utilities.loading.data import transform_and_bound
from src.utilities.loading.network import freeze_network, load_net_from
CIFAR10_NORMALIZATION_STDDEV_COMPLETE_VERIFICATION = 0.225
if __name__ == "__main__":
args = get_args()
config = get_config_from_json(args.config)
seed_everything(config.random_seed)
experiment_logger = Experiment(
api_key=config.comet_api_key,
project_name=config.comet_project_name,
workspace=config.comet_workspace,
disabled=not config.use_online_logging,
)
experiment_logger.set_name(config.experiment_name)
experiment_logger.log_parameters(config)
if torch.cuda.is_available() and config.use_gpu:
device = torch.device("cuda")
experiment_logger.log_text("Using gpu")
experiment_logger.log_text(torch.cuda.get_device_name(0))
else:
device = torch.device("cpu")
experiment_logger.log_text("Using cpu")
original_network = load_net_from(config)
original_network.to(device)
assert isinstance(original_network, nn.Sequential)
network = AbstractNetwork.from_concrete_module(original_network, config.input_dim)
freeze_network(network)
verifer = MNBaBVerifier(
network,
device,
make_verifier_config(**config),
)
test_file = open(config.test_data_path, "r")
test_instances = list(csv.reader(test_file, delimiter=","))
test_properties = pd.read_pickle(config.test_properties_path)
time_to_solve = np.zeros(test_properties.shape[0])
total_start_time = time.time()
n_verified = 0
for i, property in test_properties.iterrows():
if i < args.test_from:
continue
if args.test_num > 0 and i - args.test_from >= args.test_num:
break
start_time = time.time()
print("Verifying property number:", i)
sample_index = int(property["Idx"])
normalized_eps = property["Eps"]
eps = normalized_eps * CIFAR10_NORMALIZATION_STDDEV_COMPLETE_VERIFICATION
config.eps = eps
competing_label = int(property["prop"])
(label_str, *pixel_values) = test_instances[sample_index]
label = int(label_str)
input, input_lb, input_ub = transform_and_bound(pixel_values, config, device)
pred_label = torch.argmax(original_network(input)).item()
assert pred_label == label
if verifer.verify_property(
str(i), input_lb, input_ub, (label, competing_label, 0), config.timeout
):
n_verified += 1
print("Verified instance: ", i)
time_to_solve[i] = time.time() - start_time
else:
print("Unable to verify instance: ", i)
time_to_solve[i] = float("inf")
print("Iteration time: ", time.time() - start_time)
print("Verified ", n_verified, " out of ", i + 1)
experiment_logger.log_table("time_per_instance.csv", time_to_solve)
if not experiment_logger.disabled:
verifer.bab.log_info(experiment_logger)
print("Total time: ", time.time() - total_start_time)
| 3,572 | 35.835052 | 86 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/run_instance.py | import argparse
import os.path
import shutil
import time
from pathlib import Path
from typing import Dict, List, Optional, Sequence, Tuple
import dill # type: ignore[import]
import numpy as np
import torch
import torch.nn as nn
from torch import Tensor
from src.abstract_layers.abstract_network import AbstractNetwork
from src.abstract_layers.abstract_sig_base import SigBase
from src.abstract_layers.abstract_sigmoid import Sigmoid, d_sig, sig
from src.abstract_layers.abstract_tanh import Tanh, d_tanh, tanh
from src.mn_bab_verifier import MNBaBVerifier
from src.state.subproblem_state import SubproblemState
from src.utilities.argument_parsing import get_config_from_json
from src.utilities.attacks import _evaluate_cstr
from src.utilities.config import Config, Dtype, make_config
from src.utilities.initialization import seed_everything
from src.utilities.loading.network import freeze_network, load_onnx_model
from src.utilities.output_property_form import OutputPropertyForm
from src.verification_instance import (
generate_adv_output_str,
get_sigmoid_gt_constraint,
get_unet_gt_constraint,
)
FILE_DIR = os.path.realpath(os.path.dirname(__file__))
TEMP_RUN_DIR = os.path.realpath(os.path.join(FILE_DIR, "..", "run"))
def generate_constraints(
class_num: int, y: int
) -> List[List[List[Tuple[int, int, float]]]]:
return [[[(y, i, 0)] for i in range(class_num) if i != y]]
def load_io_constraints(
metadata: Dict[str, str], torch_dtype: torch.dtype, torch_device: torch.device
) -> Tuple[
List[Tensor], List[Tuple[Tensor, Tensor]], List[List[List[Tuple[int, int, float]]]]
]:
input_path = f"{TEMP_RUN_DIR}/inputs"
inputs: List[Tensor] = []
stack_input = torch.load(f"{input_path}/inputs.pt")
inputs = list(torch.split(stack_input, 1, dim=0))
# inputs = [inp.squeeze(dim=0) for inp in inputs]
assert all([inp.shape[0]==1 for inp in inputs])
input_region_path = f"{TEMP_RUN_DIR}/input_regions"
input_regions: List[Tuple[Tensor, Tensor]] = []
stack_lbs = torch.load(f"{input_region_path}/input_lbs.pt")
stack_ubs = torch.load(f"{input_region_path}/input_ubs.pt")
input_regions = [(lb, ub) for (lb, ub) in zip(stack_lbs, stack_ubs)]
target_g_t_constraint_path = f"{TEMP_RUN_DIR}/io_constraints"
with open(f"{target_g_t_constraint_path}/target_g_t_constraints.pkl", "rb") as file:
target_g_t_constraints: List[List[List[Tuple[int, int, float]]]] = dill.load(
file
)
return inputs, input_regions, target_g_t_constraints
def get_asnet(
net_path: str, config: Config, device: torch.device
) -> Tuple[nn.Module, AbstractNetwork]:
# Get bounds
net_format = net_path.split(".")[-1]
if net_format in ["onnx", "gz"]:
net_seq, onnx_shape, inp_name = load_onnx_model(net_path) # Like this for mypy
net: nn.Module = net_seq
else:
assert False, f"No net loaded for net format: {net_format}."
net.to(device)
net.eval()
freeze_network(net)
if config.dtype == Dtype.float64:
net = net.double()
else:
net = net.float()
assert isinstance(net, nn.Sequential)
as_net = AbstractNetwork.from_concrete_module(net, config.input_dim).to(device)
freeze_network(as_net)
return net, as_net
def load_meta_data(metadata_path: str) -> Dict[str, str]:
with open(metadata_path, "r") as f:
lines = f.readlines()
metadata: Dict[str, str] = {}
for line in lines:
k, v = line.split(":")[:2]
k = k.strip()
v = v.strip()
metadata[k] = v
return metadata
def run_instance(
benchmark: str, net_path: str, spec_path: str, res_path: str, timeout: int
) -> None:
# net_path = os.path.realpath(os.path.join(FILE_DIR, "../..", "vnncomp2022_benchmarks", net_path))
# spec_path = os.path.realpath(os.path.join(FILE_DIR, "../..", "vnncomp2022_benchmarks", spec_path))
# res_path = os.path.realpath(os.path.join(FILE_DIR, "../..", "vnncomp2022_benchmarks", res_path))
shutil.rmtree(f"{res_path}", ignore_errors=True)
metadata_path = f"{TEMP_RUN_DIR}/metadata.txt"
config_path = f"{TEMP_RUN_DIR}/config.json"
abs_network_path = f"{TEMP_RUN_DIR}/abs_network.onnx"
# 1. Check metadata (Shallow)
metadata = load_meta_data(metadata_path)
assert (
metadata["benchmark"] == benchmark
), f"Benchmarks don't match {metadata['benchmark']} {benchmark}"
assert (
metadata["network_path"] == net_path
), f"Networks don't match {metadata['network_path']} {net_path}"
assert (
metadata["spec_path"] == spec_path
), f"Specs don't match {metadata['spec_path']} {spec_path}"
# Get Config
config = get_config_from_json(config_path)
parsed_config = make_config(**config)
seed_everything(parsed_config.random_seed)
# Set timeout
parsed_config.timeout = timeout
if torch.cuda.is_available() and parsed_config.use_gpu:
device = torch.device("cuda")
else:
device = torch.device("cpu")
if parsed_config.dtype == Dtype.float64:
torch.set_default_dtype(torch.float64)
dtype = torch.float64
else:
torch.set_default_dtype(torch.float32)
dtype = torch.float32
# Get data
(inputs, input_regions, target_g_t_constraints) = load_io_constraints(
metadata, torch_dtype=dtype, torch_device=device
)
network: AbstractNetwork = torch.load(abs_network_path)
network.eval()
network.to(dtype).to(device)
network.set_activation_layers()
check_sigmoid_tanh_tangent(network)
sigmoid_encode_property: bool = False
if isinstance(network.layers[-1], Sigmoid):
network.layers = network.layers[:-1]
network.set_activation_layers()
sigmoid_encode_property = True
# Get verifier
verifier = MNBaBVerifier(network, device, parsed_config.verifier)
start_time = time.time()
adv_example = None
if parsed_config.verifier.outer.instance_pre_filter_batch_size is not None:
assert (
"unet" not in parsed_config.benchmark_instances_path
) # TODO: should this be supported?
batch_size = parsed_config.verifier.outer.instance_pre_filter_batch_size
is_verified, adv_example = verify_properties_with_deep_poly_pre_filter(
parsed_config,
network,
verifier,
inputs,
input_regions,
target_g_t_constraints,
sigmoid_encode_property,
device=device,
batch_size=batch_size,
timeout=parsed_config.timeout + start_time,
)
else: # TODO: should this be in its own function instead, e.g. in mn_bab_verifier.py?
for input_point, (input_lb, input_ub), gt_constraint in zip(
inputs, input_regions, target_g_t_constraints
):
if input_lb.dim() == len(parsed_config.input_dim): # No batch dimension
input_lb = input_lb.unsqueeze(0)
input_ub = input_ub.unsqueeze(0)
input_point = input_point.unsqueeze(0)
assert tuple(input_lb.shape[1:]) == parsed_config.input_dim
if sigmoid_encode_property:
gt_constraint = get_sigmoid_gt_constraint(gt_constraint)
if "unet" in parsed_config.benchmark_instances_path:
gt_constraint, gt_target = get_unet_gt_constraint(
input_point, (input_lb, input_ub), gt_constraint
)
assert isinstance(network, AbstractNetwork)
out_prop_form = OutputPropertyForm.create_from_properties(
properties_to_verify=gt_constraint,
disjunction_adapter=None,
use_disj_adapter=parsed_config.verifier.outer.use_disj_adapter,
n_class=network.output_dim[-1],
device=device,
dtype=torch.get_default_dtype(),
)
if "unet" in parsed_config.benchmark_instances_path:
assert gt_target
(is_verified, _, _, _, _,) = verifier.verify_unet_via_config(
0,
input_point,
input_lb,
input_ub,
out_prop_form,
verification_target=gt_target,
timeout=parsed_config.timeout + start_time,
)
else:
if out_prop_form.disjunction_adapter is not None:
verifier.append_out_adapter(
out_prop_form.disjunction_adapter,
device,
torch.get_default_dtype(),
)
(
is_verified,
adv_example,
lower_idx,
lower_bound_tmp,
upper_bound_tmp,
) = verifier.verify_via_config(
0,
input_point,
input_lb,
input_ub,
out_prop_form,
timeout=parsed_config.timeout + start_time,
)
if out_prop_form.disjunction_adapter is not None:
verifier.remove_out_adapter()
if adv_example is not None:
assert not is_verified
break
if not is_verified:
break
total_time = time.time() - start_time
Path("/".join(res_path.split("/")[:-1])).mkdir(parents=True, exist_ok=True)
with open(res_path, "w") as f:
if is_verified:
f.write("unsat\n")
elif adv_example is not None:
f.write("sat\n")
counter_example = generate_adv_output_str(
adv_example[0], network, input_regions[0][0].shape, device, dtype
)
f.write(counter_example)
elif total_time >= timeout:
f.write("timeout\n")
else:
f.write("unknown\n")
def verify_properties_with_deep_poly_pre_filter( # noqa: C901 # TODO: simplify function. should this be in mn_bab_verifier.py instead?
parsed_config: Config,
network: AbstractNetwork,
verifier: MNBaBVerifier,
inputs: List[Tensor],
input_regions: List[Tuple[Tensor, Tensor]],
target_g_t_constraints: List[List[List[Tuple[int, int, float]]]],
sigmoid_encode_property: bool,
batch_size: int,
device: torch.device,
timeout: float,
) -> Tuple[bool, Optional[List[np.ndarray]]]: # is_verified, adv_example
expanded_input_lbs: List[Tensor] = []
expanded_input_ubs: List[Tensor] = []
output_property_forms: List[OutputPropertyForm] = []
print("filtering out easy instances with external batching...")
for (input_lb, input_ub), gt_constraint in zip(
input_regions, target_g_t_constraints
):
if input_lb.dim() == len(parsed_config.input_dim): # No batch dimension
input_lb = input_lb.unsqueeze(0)
input_ub = input_ub.unsqueeze(0)
if sigmoid_encode_property:
gt_constraint = get_sigmoid_gt_constraint(gt_constraint)
# no unet (TODO: should this be supported?)
output_property_form = OutputPropertyForm.create_from_properties(
properties_to_verify=gt_constraint,
disjunction_adapter=None,
use_disj_adapter=parsed_config.verifier.outer.use_disj_adapter, # TODO: assert that this is False?
n_class=network.output_dim[-1],
device=device,
dtype=torch.get_default_dtype(),
)
assert (
output_property_form.disjunction_adapter is None
), "proper disjunction not supported for batched pre-filtering"
num_queries = output_property_form.property_matrix.shape[0]
assert input_lb.shape == input_ub.shape
assert input_lb.shape[0] in {1, num_queries}
if input_lb.shape[0] == 1:
expanded_input_lbs.append(input_lb.expand(num_queries, *input_lb.shape[1:]))
expanded_input_ubs.append(input_ub.expand(num_queries, *input_ub.shape[1:]))
else:
expanded_input_lbs.append(input_lb)
expanded_input_ubs.append(input_ub)
output_property_forms.append(output_property_form)
all_input_lbs = torch.cat(expanded_input_lbs)
all_input_ubs = torch.cat(expanded_input_ubs)
all_properties_matrix = torch.cat(
tuple(
output_property_form.property_matrix
for output_property_form in output_property_forms
)
)
all_properties_threshold = torch.cat(
tuple(
output_property_form.property_threshold
for output_property_form in output_property_forms
)
)
n_properties = all_properties_matrix.shape[0]
assert all_input_lbs.shape[0] == n_properties
assert all_input_ubs.shape[0] == n_properties
assert all_properties_threshold.shape[0] == n_properties
num_verified = 0
num_falsified = 0
def count_instances(tensor: Tensor) -> int:
if tensor.dim() == 1:
return int(tensor.sum().item())
if tensor.dim() == 2:
return int(tensor.all(1).sum().item())
return -1 # TODO: replace with assertion; not worth crashing for printout atm
def print_info(total: int) -> None:
if num_verified != 0:
print("verified: ", num_verified, " / ", total)
if num_falsified != 0:
print("falsified: ", num_falsified, " / ", total)
if num_verified != total and num_falsified != total:
print("remaining: ", total - num_verified - num_falsified, " / ", total)
if batch_size > 0:
if batch_size >= n_properties:
subproblem_state = SubproblemState.create_default(
split_state=None,
optimize_prima=False,
batch_size=n_properties,
device=input_lb.device,
use_params=False,
)
(
verified,
falsified,
dp_lbs,
_,
_,
_,
) = verifier._verify_query_with_deep_poly(
all_input_lbs,
all_input_ubs,
all_properties_matrix,
all_properties_threshold,
compute_sensitivity=False,
subproblem_state=subproblem_state,
ibp_pass=verifier.optimizer.backsubstitution_config.box_pass,
)
num_verified = count_instances(verified)
num_falsified = count_instances(falsified)
print_info(n_properties)
else:
cur_index = 0
all_verified: List[Tensor] = []
all_falsified: List[Tensor] = []
all_dp_lbs: List[Tensor] = []
while cur_index < n_properties:
next_index = min(cur_index + batch_size, n_properties)
subproblem_state = SubproblemState.create_default(
split_state=None,
optimize_prima=False,
batch_size=next_index - cur_index,
device=input_lb.device,
use_params=False,
)
(
verified,
falsified,
dp_lbs,
_,
_,
_,
) = verifier._verify_query_with_deep_poly(
all_input_lbs[cur_index:next_index],
all_input_ubs[cur_index:next_index],
all_properties_matrix[cur_index:next_index],
all_properties_threshold[cur_index:next_index],
compute_sensitivity=False,
subproblem_state=subproblem_state,
ibp_pass=verifier.optimizer.backsubstitution_config.box_pass,
)
all_verified.append(verified)
all_falsified.append(falsified)
all_dp_lbs.append(dp_lbs)
num_verified += count_instances(verified)
num_falsified += count_instances(falsified)
print_info(next_index)
cur_index = next_index
verified = torch.cat(all_verified)
falsified = torch.cat(all_falsified)
dp_lbs = torch.cat(all_dp_lbs)
if verified.all():
return True, None
new_output_property_forms: List[OutputPropertyForm] = []
cur_index = 0
for output_property_form in output_property_forms:
num_queries = output_property_form.property_matrix.shape[0]
next_index = cur_index + num_queries
new_output_property_form = output_property_form.update_properties_to_verify(
verified[cur_index:next_index],
falsified[cur_index:next_index],
dp_lbs[cur_index:next_index],
true_ub=False,
)
new_output_property_forms.append(new_output_property_form)
cur_index = next_index
else:
new_output_property_forms = output_property_forms
if verifier.outer.input_domain_splitting:
queue: List[
Tuple[
Tensor,
Tensor,
Tuple[Tensor, Tensor, Tensor],
int,
Optional[Sequence[Sequence[Tuple[int, int, float]]]],
]
] = []
for input_point, input_lb, input_ub, output_property_form in zip(
inputs, expanded_input_lbs, expanded_input_ubs, new_output_property_forms
):
if not output_property_form.properties_to_verify:
continue
queue.append(
(
input_lb,
input_ub,
(
output_property_form.property_matrix,
output_property_form.property_threshold,
output_property_form.combination_matrix,
),
verifier.domain_splitting.max_depth,
output_property_form.properties_to_verify,
)
)
queue, _ = verifier._conduct_input_domain_splitting(
verifier.domain_splitting, queue, timeout, None
)
if len(queue) == 0:
return True, None
elif len(queue) == 1 and queue[0][-1] == -1:
# counterexample region returned
adv_example = queue[0][0]
out = verifier.network(adv_example)
assert (input_lb <= adv_example).__and__(input_ub >= adv_example).all()
if not _evaluate_cstr(queue[0][-1], out.detach(), torch_input=True):
print("Adex found via splitting")
return False, [np.array(adv_example.cpu())]
else:
assert False, "should have been a counterexample"
else:
pass
for input_point, input_lb, input_ub, output_property_form in zip(
inputs, expanded_input_lbs, expanded_input_ubs, new_output_property_forms
):
(
is_verified,
adv_example,
lower_idx,
lower_bound_tmp,
upper_bound_tmp,
) = verifier.verify_via_config(
0,
input_point,
input_lb,
input_ub,
output_property_form,
timeout=timeout,
)
assert output_property_form.disjunction_adapter is None
if adv_example is not None:
assert not is_verified
break
if not is_verified:
break
return is_verified, adv_example
def check_sigmoid_tanh_tangent(network: AbstractNetwork) -> None:
has_sig_layer = False
has_tanh_layer = False
for tag, layer in network.layer_id_to_layer.items():
if isinstance(layer, Sigmoid):
has_sig_layer = True
if isinstance(layer, Tanh):
has_tanh_layer = True
if has_sig_layer:
(
Sigmoid.intersection_points,
Sigmoid.tangent_points,
Sigmoid.step_size,
Sigmoid.max_x,
) = SigBase._compute_bound_to_tangent_point(sig, d_sig)
if has_tanh_layer:
(
Tanh.intersection_points,
Tanh.tangent_points,
Tanh.step_size,
Tanh.max_x,
) = SigBase._compute_bound_to_tangent_point(tanh, d_tanh)
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Prepare verification instances on the vnn22 datasets. Simply provide the corresponding nets and specs"
)
parser.add_argument(
"-b", "--benchmark", type=str, help="The benchmark id", required=True
)
parser.add_argument(
"-n",
"--netname",
type=str,
help="The network path",
required=True,
)
parser.add_argument(
"-s",
"--vnnlib_spec",
type=str,
help="The vnnlib spec path",
required=True,
)
parser.add_argument(
"-r",
"--results_path",
type=str,
help="",
required=True,
)
parser.add_argument(
"-t",
"--timeout",
type=float,
help="",
required=True,
)
args = parser.parse_args()
run_instance(
args.benchmark,
args.netname,
args.vnnlib_spec,
args.results_path,
int(args.timeout),
)
| 21,637 | 33.731942 | 135 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/vnncomp_runner.py | import os
import time
from comet_ml import Experiment # type: ignore[import]
import torch
from torch import nn
from src.abstract_layers.abstract_network import AbstractNetwork
from src.mn_bab_verifier import MNBaBVerifier
from src.utilities.argument_parsing import get_args, get_config_from_json
from src.utilities.config import make_verifier_config
from src.utilities.initialization import seed_everything
from src.utilities.loading.network import freeze_network, load_net
from src.utilities.vnncomp_input_parsing import (
parse_vnn_lib_prop,
translate_box_to_sample,
translate_constraints_to_label,
)
if __name__ == "__main__":
args = get_args()
config = get_config_from_json(args.config)
seed_everything(config.random_seed)
experiment_logger = Experiment(
api_key=config.comet_api_key,
project_name=config.comet_project_name,
workspace=config.comet_workspace,
disabled=not config.use_online_logging,
)
experiment_logger.set_name(config.experiment_name)
experiment_logger.log_parameters(config)
if torch.cuda.is_available() and config.use_gpu:
device = torch.device("cuda")
experiment_logger.log_text("Using gpu")
experiment_logger.log_text(torch.cuda.get_device_name(0))
else:
device = torch.device("cpu")
experiment_logger.log_text("Using cpu")
benchmark_instances_file = config.benchmark_instances_path
with open(benchmark_instances_file, "r") as f:
lines = f.readlines()
instances = [[x.strip() for x in line.split(",")] for line in lines]
instance_dir = os.path.dirname(benchmark_instances_file)
current_network_name = ""
n_verified = 0
n_correct = 0
total_time = 0.0
network_index = 0
for i, instance in enumerate(instances):
print("Verifying instance number:", i)
netname = os.path.realpath(os.path.join(instance_dir, instance[0]))
# we work with pytorch nets, not onnx format
netname = netname.replace(".onnx", ".pyt")
if netname != current_network_name:
print("Starting with network: ", netname)
n_neurons_per_layer, n_layers = None, None
try:
network_size_info = netname.split("mnist-net_")[1].split(".pyt")[0]
n_neurons_per_layer, n_layers = [
int(s) for s in network_size_info.split("x")
]
except IndexError:
pass
original_network = load_net(netname, n_layers, n_neurons_per_layer)
original_network.to(device)
assert isinstance(original_network, nn.Sequential)
network = AbstractNetwork.from_concrete_module(
original_network, config.input_dim
)
freeze_network(network)
verifier = MNBaBVerifier(
network,
device,
make_verifier_config(**config),
)
current_network_name = netname
network_index += 1
if i < args.test_from:
continue
if args.test_num > 0 and i - args.test_from >= args.test_num:
break
vnn_lib_spec = os.path.join(instance_dir, instance[1])
timeout_for_property = float(instance[2])
input_constraints, output_constraints = parse_vnn_lib_prop(vnn_lib_spec)
input_lb_arr, input_ub_arr = input_constraints[0]
input_lb = torch.tensor(input_lb_arr).view(config.input_dim).to(device)
input_ub = torch.tensor(input_ub_arr).view(config.input_dim).to(device)
label = translate_constraints_to_label(output_constraints)[0]
original_images, __ = translate_box_to_sample(
input_constraints, equal_limits=True
)
original_image = (
torch.tensor(original_images[0])
.view(config.input_dim)
.unsqueeze(0)
.to(device)
)
pred_label = torch.argmax(original_network(original_image)).item()
if pred_label != label:
print("Network fails on test image, skipping.")
continue
else:
n_correct += 1
start_time = time.time()
if verifier.verify(
i, original_image, input_lb, input_ub, label, timeout_for_property
):
n_verified += 1
print("Verified instance: ", i)
else:
print("Unable to verify instance: ", i)
instance_time = time.time() - start_time
total_time += instance_time
print("Iteration time: ", instance_time)
print("Verified ", n_verified, " out of ", n_correct)
print("Total time: ", total_time)
| 4,706 | 35.773438 | 83 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/verification_instance.py | import argparse
import csv
import os
import re
import shutil
import time
from cmath import inf
from pathlib import Path
from typing import Dict, List, Optional, Tuple, Union
from comet_ml import Experiment # type: ignore[import]
import numpy as np
import onnx # type: ignore[import]
import torch
import torch.nn as nn
from bunch import Bunch # type: ignore[import]
from torch import Tensor
from src.abstract_layers.abstract_network import AbstractNetwork
from src.abstract_layers.abstract_sigmoid import Sigmoid
from src.mn_bab_verifier import MNBaBVerifier
from src.utilities.argument_parsing import get_config_from_json
from src.utilities.config import Config, Dtype, make_config
from src.utilities.initialization import seed_everything
from src.utilities.loading.dnnv_simplify import simplify_onnx
from src.utilities.loading.network import (
freeze_network,
load_net,
load_onnx_from_proto,
load_onnx_model,
)
from src.utilities.loading.vnn_spec_loader import ( # translate_constraints_to_label,
parse_vnn_lib_prop,
)
from src.utilities.prepare_instance import get_network_characteristics
from src.utilities.output_property_form import OutputPropertyForm
NET_TO_CONFIG_MAP = "configs/net_to_config.csv"
def generate_constraints(
class_num: int, y: int
) -> List[List[List[Tuple[int, int, float]]]]:
return [[[(y, i, 0)] for i in range(class_num) if i != y]]
def get_io_constraints_from_spec(
spec_path: str, config: Config, device: torch.device
) -> Tuple[
List[Tensor], List[Tuple[Tensor, Tensor]], List[List[List[Tuple[int, int, float]]]]
]:
dtype = np.float32 if config.dtype == Dtype("float32") else np.float64
if not os.path.exists(spec_path) and not spec_path.endswith(".gz"):
spec_path += ".gz"
input_boxes, output_gt_constraints = parse_vnn_lib_prop(spec_path, dtype=dtype)
input_regions = []
inputs = []
for box in input_boxes:
input_lb_arr, input_ub_arr = box
input_lb, input_ub = (
torch.from_numpy(input_lb_arr).to(device),
torch.from_numpy(input_ub_arr).to(device),
)
input_lb, input_ub = input_lb.reshape(config.input_dim), input_ub.reshape(
config.input_dim
)
input_regions.append((input_lb, input_ub))
inputs.append((input_lb + input_ub) / 2)
return inputs, input_regions, output_gt_constraints
def get_asnet(
net_path: Optional[str], config: Config, device: torch.device
) -> Tuple[nn.Module, AbstractNetwork]:
# Get bounds
if net_path is None:
net_path = config.network.path
if net_path.endswith(".gz"):
net_path = ".".join(net_path.split(".")[:-1])
net_format = net_path.split(".")[-1]
if net_format in ["onnx", "gz"]:
net_seq, onnx_shape, inp_name = load_onnx_model(net_path) # Like this for mypy
net: nn.Module = net_seq
elif net_format == "pt" or net_format == "pth" or net_format == "pyt":
net = load_net(**config.network.load_params())
else:
assert False, f"No net loaded for net format: {net_format}."
net.to(device)
net.eval()
freeze_network(net)
if config.dtype == Dtype.float64:
torch.set_default_dtype(torch.float64)
net = net.double()
else:
torch.set_default_dtype(torch.float32)
net = net.float()
if len(config.input_dim) == 0:
print(f"Setting shape: {onnx_shape}")
config.input_dim = onnx_shape
if config.verifier.outer.simplify_onnx:
assert onnx_shape is not None
assert inp_name is not None
# export current model to onnx for dtype
try:
temp_dir = "temp_convert"
net_pref = "simplify"
onnx_path = f"{temp_dir}/{net_pref}.onnx"
Path(temp_dir).mkdir(parents=True, exist_ok=True)
x = torch.rand((1, *onnx_shape), device=device)
torch.onnx.export(
net,
x,
onnx_path,
export_params=True,
training=torch.onnx.TrainingMode.EVAL,
do_constant_folding=True,
verbose=False,
input_names=[inp_name],
output_names=["output"],
)
onnx_model = onnx.load(onnx_path)
onnx_model = simplify_onnx(onnx_model)
net_new, _, _ = load_onnx_from_proto(onnx_model, net_path)
net_new.to(device)
net_new.eval()
freeze_network(net_new)
# for i in range(50):
# x = torch.rand((1, *onnx_shape), device=device)
# out_old = net(x)
# out = net_new(x)
# assert torch.isclose(out_old, out, atol=1e-7).all()
net = net_new
except Exception as e:
print("Exception simplifying onnx model: ", e)
finally:
shutil.rmtree(temp_dir, ignore_errors=True)
assert isinstance(net, nn.Sequential)
as_net = AbstractNetwork.from_concrete_module(net, config.input_dim).to(device)
freeze_network(as_net)
return net, as_net
def generate_adv_output_str(
adv_example: np.ndarray,
network: AbstractNetwork,
input_shape: Tuple[int, ...],
device: torch.device,
dtype: torch.dtype,
) -> str:
adv_tensor = torch.tensor(adv_example, device=device, dtype=dtype)
adv_out: Tensor = network(adv_tensor)
adv_tensor = adv_tensor.flatten()
adv_out = adv_out.flatten()
out_enc = "("
for i in range(adv_tensor.numel()):
out_enc += f"(X_{i} {adv_tensor[i]})\n"
for j in range(adv_out.numel()):
out_enc += f"(Y_{j} {adv_out[j]})\n"
out_enc = out_enc[:-1]
out_enc += ")\n"
return out_enc
class VerificationInstance:
def __init__(
self,
network: Union[AbstractNetwork, str],
verifier: Optional[MNBaBVerifier],
config: Config,
inputs: Union[List[Tensor], str],
input_regions: Optional[List[Tuple[Tensor, Tensor]]],
target_gt_constraints: Optional[List[List[List[Tuple[int, int, float]]]]],
) -> None:
self.network: Optional[Union[AbstractNetwork, str]] = network
self.verifier: Optional[MNBaBVerifier] = verifier
self.inputs = inputs
self.input_constraints = input_regions
self.config = config
self.target_constr = target_gt_constraints
self.is_verified: bool = False
self.has_adv_example: bool = False
self.lower_idx: int = (
-1
) # Index at which our computation timed out (for comparison)
self.time: float = inf
self.lower_bound: float = inf
@classmethod
def create_instance_from_vnn_spec(
cls, net_path: str, spec_path: str, config: Bunch
) -> "VerificationInstance":
# Get Config
parsed_config = make_config(**config)
seed_everything(parsed_config.random_seed)
experiment_logger = Experiment(**parsed_config.logger.comet_options)
experiment_logger.set_name(parsed_config.experiment_name)
experiment_logger.log_parameters(parsed_config)
if torch.cuda.is_available() and parsed_config.use_gpu:
device = torch.device("cuda")
experiment_logger.log_text("Using gpu")
experiment_logger.log_text(torch.cuda.get_device_name(0))
else:
device = torch.device("cpu")
experiment_logger.log_text("Using cpu")
# Get data
if parsed_config.load_eager: # TODO @Robin
(
inputs,
input_regions,
target_g_t_constraints,
) = get_io_constraints_from_spec(
spec_path=spec_path, config=parsed_config, device=device
)
net, as_network = get_asnet(net_path, parsed_config, device)
# Get verifier
verifier = MNBaBVerifier(as_network, device, parsed_config.verifier)
return cls(
as_network,
verifier,
parsed_config,
inputs,
input_regions,
target_g_t_constraints,
)
else: # Load the network and specs when running the instance
return cls(
net_path,
None,
parsed_config,
spec_path,
None,
None,
)
@classmethod
def create_instance_from_input_and_eps(
cls,
net_path: Optional[str],
input: Tensor,
eps: float,
target_label: int,
config_path: str,
num_classes: int,
) -> "VerificationInstance":
# Get Config
config_file = get_config_from_json(config_path)
config = make_config(**config_file)
if torch.cuda.is_available() and config.use_gpu:
device = torch.device("cuda")
else:
device = torch.device("cpu")
# Get data
input = input.to(device)
input_lb = torch.clamp(input - eps, 0, 1)
input_ub = torch.clamp(input + eps, 0, 1)
net, as_net = get_asnet(net_path, config, device)
# Get verifier
verifier = MNBaBVerifier(as_net, device, config.verifier)
return cls.create_instance_for_batch_ver(as_net, verifier, input, input_lb, input_ub, target_label, config, num_classes)
@classmethod
def create_instance_for_batch_ver(
cls,
as_net: AbstractNetwork,
verifier: MNBaBVerifier,
input: Tensor,
input_lb: Tensor,
input_ub: Tensor,
target_label: int,
config: Config,
num_classes: int,
) -> "VerificationInstance":
# Get Config
seed_everything(config.random_seed)
experiment_logger = Experiment(**config.logger.comet_options)
experiment_logger.set_name(config.experiment_name)
experiment_logger.log_parameters(config)
if torch.cuda.is_available() and config.use_gpu:
experiment_logger.log_text("Using gpu")
experiment_logger.log_text(torch.cuda.get_device_name(0))
else:
if config.use_gpu:
print("WARNING: GPU NOT AVAILABLE")
experiment_logger.log_text("Using cpu")
# Get data
target_gt_constraints = generate_constraints(num_classes, target_label)
return cls(
as_net,
verifier,
config,
[input],
[(input_lb, input_ub)],
target_gt_constraints,
)
def run_instance(self) -> None: # noqa: C901
device = torch.device("cuda") if self.config.use_gpu else torch.device("cpu")
if isinstance(self.network, str):
net, as_net = get_asnet(self.network, self.config, device)
self.network = as_net
assert isinstance(self.network, AbstractNetwork)
if isinstance(self.inputs, str):
(
self.inputs,
self.input_constraints,
self.target_constr,
) = get_io_constraints_from_spec(
spec_path=self.inputs, config=self.config, device=device
)
assert isinstance(self.inputs, List) and len(self.inputs) > 0
assert self.input_constraints is not None and len(self.input_constraints) > 0
assert self.target_constr is not None
n_regions = len(self.input_constraints)
n_non_zero_width = max(
[(lb != ub).sum().item() for lb, ub in self.input_constraints]
)
node_count = get_network_characteristics(self.network)
print(
f"Analyzing {n_regions} input regions with at most {n_non_zero_width}/{self.inputs[0].numel()} non-zero-width inputs and neurons-parameters: {node_count}"
)
sigmoid_encode_property: bool = False
if isinstance(self.network.layers[-1], Sigmoid):
self.network.layers = self.network.layers[:-1]
self.network.set_activation_layers()
sigmoid_encode_property = True
if self.config.dtype == Dtype.float64:
torch.set_default_dtype(torch.float64)
self.network = self.network.double()
self.inputs = [x.double() for x in self.inputs]
self.input_constraints = [
(x[0].double(), x[1].double()) for x in self.input_constraints
]
else:
torch.set_default_dtype(torch.float32)
self.inputs = [x.float() for x in self.inputs]
self.input_constraints = [
(x[0].float(), x[1].float()) for x in self.input_constraints
]
if self.verifier is None:
assert isinstance(self.network, AbstractNetwork)
self.verifier = MNBaBVerifier(self.network, device, self.config.verifier)
# assert self.verifier is not None
start_time = time.time()
lower_bound = float("inf") # This is intentionally set to positive infinity
upper_bound = float("inf")
# TODO here we could order input region/constraint pairings to find counterexamples quicker
for input_point, (input_lb, input_ub), gt_constraint in zip(
self.inputs, self.input_constraints, self.target_constr
):
if time.time() - start_time > self.config.timeout:
is_verified = False
adv_example = None
break
if input_lb.dim() == len(self.config.input_dim): # No batch dimension
input_lb = input_lb.unsqueeze(0)
input_ub = input_ub.unsqueeze(0)
input_point = input_point.unsqueeze(0)
assert tuple(input_lb.shape[1:]) == self.config.input_dim
if sigmoid_encode_property:
gt_constraint = get_sigmoid_gt_constraint(gt_constraint)
if "unet" in self.config.benchmark_instances_path:
gt_constraint, gt_target = get_unet_gt_constraint(
input_point, (input_lb, input_ub), gt_constraint
)
assert isinstance(self.network, AbstractNetwork)
out_prop_form = OutputPropertyForm.create_from_properties(
gt_constraint,
None,
self.config.verifier.outer.use_disj_adapter,
self.network.output_dim[-1],
device,
torch.get_default_dtype(),
)
if "unet" in self.config.benchmark_instances_path:
assert gt_target
(
is_verified,
adv_example,
lower_idx,
lower_bound_tmp,
upper_bound_tmp,
) = self.verifier.verify_unet_via_config(
0,
input_point,
input_lb,
input_ub,
out_prop_form,
verification_target=gt_target,
timeout=self.config.timeout + start_time,
)
else:
if out_prop_form.disjunction_adapter is not None:
self.verifier.append_out_adapter(
out_prop_form.disjunction_adapter,
device,
torch.get_default_dtype(),
)
(
is_verified,
adv_example,
lower_idx,
lower_bound_tmp,
upper_bound_tmp,
) = self.verifier.verify_via_config(
0,
input_point,
input_lb,
input_ub,
out_prop_form,
timeout=self.config.timeout + start_time,
)
if out_prop_form.disjunction_adapter is not None:
self.verifier.remove_out_adapter()
if lower_bound_tmp is not None and upper_bound_tmp is not None:
lower_bound = min(
lower_bound_tmp, lower_bound
) # taking the smallest/worst lower bound over input regions
upper_bound = min(
upper_bound_tmp, upper_bound
) # taking the smallest/worst counter example over regions
if adv_example is not None:
assert not is_verified
_ = generate_adv_output_str(
adv_example[0],
self.verifier.network,
input_lb.shape,
device,
torch.get_default_dtype(),
)
break
if not is_verified:
break
total_time = time.time() - start_time
self.is_verified = is_verified
self.adv_example = adv_example
print(f"Total instance time: {total_time}")
self.time = total_time
if is_verified:
self.lower_bound = 0
elif adv_example is None and lower_bound:
self.lower_bound = lower_bound
def free_memory(self) -> None:
self.network = None
self.verifier = None
self.input_constraints = None # type: ignore[assignment]
self.target_constr = None # type: ignore[assignment]
self.input = None # type: ignore[assignment]
self.input_lb = None # type: ignore[assignment]
self.input_ub = None # type: ignore[assignment]
if torch.cuda.is_available():
torch.cuda.empty_cache()
def run_instance_dict(
inst_dict: Dict[Tuple[str, str], List[VerificationInstance]]
) -> None:
verified = 0
disproved = 0
verif_inst: List[Tuple[int, float]] = []
disproved_inst: List[Tuple[int, float]] = []
for i, (inst_id, inst) in enumerate(inst_dict.items()):
print(
f"\n Running instanceset {i} - {inst_id} - Timeout: {inst[0].config.timeout}"
)
is_verif = run_instances(inst)
if is_verif > 0:
for cfg in inst:
if cfg.is_verified:
verif_inst.append((i, cfg.time))
if is_verif < len(inst):
for cfg in inst:
if cfg.adv_example is not None:
disproved_inst.append((i, cfg.time))
disproved += 1
verified += is_verif
for i, t in verif_inst:
print(f"Verified instance: {i} Time: {t}")
for i, t in disproved_inst:
print(f"Disproved instance: {i} Time: {t}")
print(
f"Verified: {verified} Disproved: {disproved} out of {len(inst_dict.values())}"
)
def run_instances(instances: List[VerificationInstance]) -> int:
verified = 0
for i, inst in enumerate(instances):
print("=" * 20)
print(f"Running config {i}")
inst.run_instance()
if inst.is_verified:
verified += 1
print(f"Verified - Time: {inst.time}")
else:
print("Not verified")
inst.free_memory()
return verified
def get_val_from_re_dict(key: str, dict: Dict[str, str]) -> str:
for k, v in dict.items():
if re.match(k, key):
return v
print("WARNING! USING DEFAULT CONFIG")
return "configs/vnncomp22/default_config.json"
raise KeyError
def create_instances_from_args(
args: Bunch,
) -> Dict[Tuple[str, str], List[VerificationInstance]]:
instance_dict: Dict[Tuple[str, str], List[VerificationInstance]] = {}
n2c_map: Dict[str, str] = {}
use_n2c_map = False
# All information in the config file
if args.instances is None and args.nets is None:
assert len(args.configs) > 0
for config in args.configs:
bunch_config = get_config_from_json(args.configs[0])
# Load instance file from config
inst = bunch_config.benchmark_instances_path
pref = "/".join(inst.split("/")[:-1])
with open(inst, "r") as f:
lines = f.readlines()
for line in lines:
net, spec, timeout = line.strip().split(",")
onnx_path = os.path.join(pref, net.strip())
spec_path = os.path.join(pref, spec.strip())
bunch_config.timeout = int(float(timeout.strip()))
bunch_config.network_path = onnx_path
v_inst = VerificationInstance.create_instance_from_vnn_spec(
onnx_path, spec_path, bunch_config
)
if (net, spec) in instance_dict:
instance_dict[(net, spec)].append(v_inst)
else:
instance_dict[(net, spec)] = [v_inst]
elif (
args.instances
): # Run set of instances with certain configs - does not need a benchmark path in the config
if args.configs is not None:
assert len(args.instances) == len(args.configs)
print("Using one config per instance file")
else:
print(f"Loading configs for known nets from {NET_TO_CONFIG_MAP}")
with open(NET_TO_CONFIG_MAP, "r") as f:
n2c = csv.reader(f)
for k, v in n2c:
n2c_map[k.strip()] = v.strip()
use_n2c_map = True
for i, inst in enumerate(args.instances):
print(f"Loading the following instances {inst}")
pref = "/".join(inst.split("/")[:-1])
with open(inst, "r") as f:
lines = f.readlines()
for line in lines:
net, spec, timeout = line.strip().split(",")
onnx_path = os.path.join(pref, net.strip())
spec_path = os.path.join(pref, spec.strip())
if use_n2c_map:
inst_pref = "/".join(inst.split("/")[:-1]) + "/"
cfg_path = get_val_from_re_dict(inst_pref + net, n2c_map)
config = get_config_from_json(cfg_path)
else:
config = get_config_from_json(args.configs[i])
config.timeout = int(float(timeout.strip()))
config.network_path = onnx_path
v_inst = VerificationInstance.create_instance_from_vnn_spec(
onnx_path, spec_path, config
)
if (net, spec) in instance_dict:
instance_dict[(net, spec)].append(v_inst)
else:
instance_dict[(net, spec)] = [v_inst]
else:
assert len(args.nets) == 1
if len(args.configs) == 1:
config = get_config_from_json(args.configs[0])
for spec in args.specs:
onnx_path = args.nets[0]
spec_path = spec
config.timeout = timeout
v_inst = VerificationInstance.create_instance_from_vnn_spec(
onnx_path, spec_path, config
)
if (net, spec) in instance_dict:
instance_dict[(net, spec)].append(v_inst)
else:
instance_dict[(net, spec)] = [v_inst]
else:
assert len(args.configs) == len(args.specs)
for spec, config in zip(args.specs, args.configs):
onnx_path = args.nets[0]
spec_path = spec
config.timeout = timeout
v_inst = VerificationInstance.create_instance_from_vnn_spec(
onnx_path, spec_path, config
)
if (net, spec) in instance_dict:
instance_dict[(net, spec)].append(v_inst)
else:
instance_dict[(net, spec)] = [v_inst]
print(config)
return instance_dict
def rank_instances(instances: List[VerificationInstance]) -> List[VerificationInstance]:
verified_instances = [i for i in instances if i.is_verified]
non_verified_instances = [i for i in instances if not i.is_verified]
adv_instances = [i for i in instances if i.has_adv_example]
assert not (
len(verified_instances) > 0 and len(adv_instances)
), "Verified and adverserial"
verified_instances.sort(key=lambda x: x.time)
non_verified_instances.sort(key=lambda x: x.lower_bound, reverse=True)
if len(adv_instances) > 0:
return adv_instances + non_verified_instances + verified_instances
elif len(verified_instances) > 0:
return verified_instances + non_verified_instances
else:
return verified_instances
def get_unet_gt_constraint(
input_point: Tensor,
input_bounds: Tuple[Tensor, Tensor],
gt_constraint: List[List[Tuple[int, int, float]]],
) -> Tuple[List[List[Tuple[int, int, float]]], int]:
mask = input_point[0, 3, :]
assert (mask == input_bounds[0][0, 3, :]).all()
assert (mask == input_bounds[1][0, 3, :]).all()
mask = mask.flatten()
flat_dim = mask.numel()
new_consts: List[List[Tuple[int, int, float]]] = []
for i in range(flat_dim):
if mask[i] == 1.0: # dim 1 should be larger
new_consts.append([(i + flat_dim, i, 0)])
elif mask[i] == 0.0:
new_consts.append([(i, i + flat_dim, 0)])
else:
assert "Unknown mask entry"
assert len(gt_constraint) == 1
assert gt_constraint[0][0][0] == 0 and gt_constraint[0][0][1] == -1
return new_consts, int(gt_constraint[0][0][2])
def get_sigmoid_gt_constraint(
gt_constraint: List[List[Tuple[int, int, float]]],
) -> List[List[Tuple[int, int, float]]]:
new_consts: List[List[Tuple[int, int, float]]] = []
for disj_clause in gt_constraint:
new_clause: List[Tuple[int, int, float]] = []
for atom in disj_clause:
if atom[0] == -1:
new_atom = (-1, atom[1], np.log(atom[2] / (1 - atom[2])))
elif atom[1] == -1:
new_atom = (atom[0], -1, np.log(atom[2] / (1 - atom[2])))
else:
assert atom[2] == 0
new_atom = atom
assert not (new_atom[0] == -1 and new_atom[1] == -1)
new_clause.append(new_atom)
new_consts.append(new_clause)
return new_consts
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Run verification instances on the vnn21 (& vnn22) datasets. Simply provide the corresponding nets, specs, and configs"
)
parser.add_argument(
"-is",
"--instances",
type=str,
nargs="*",
help="Loads one or multiple instance files. Overrides any manually given nets and specs given.",
)
parser.add_argument(
"-n",
"--nets",
type=str,
nargs="*",
help="relative path for each net. In case it is a directory path we load all corresponding nets in the directory.",
)
parser.add_argument(
"-s",
"--specs",
type=str,
nargs="*",
help="The specs corresponding to the nets. In case it is a directory path we load all corresponding specs in the directory.",
)
parser.add_argument(
"-c",
"--configs",
type=str,
nargs="*",
help="The configs corresponding to the nets x specs. Either we load a single config for all specs or one config for each spec",
)
parser.add_argument(
"-in",
"--inputs",
type=str,
nargs="*",
help="The input file we want to load examples from. Used for finding epsilon values on nets",
)
parser.add_argument(
"-t",
"--timeout",
type=int,
default=400,
help="The timeout to apply per instance in case we do not load instances from a csv file.",
)
parser.add_argument(
"-sub",
"--subsample",
type=int,
default=1,
help="Subsample each nets specs by the given factor for faster evaluation.",
)
parser.add_argument(
"-ni",
"--num_images",
type=int,
default=100,
help="How many images to load from the image source. Defaults to 100.",
)
args = parser.parse_args()
instances = create_instances_from_args(args)
print(f"Running {len(instances)} instances.")
run_instance_dict(instances)
| 28,592 | 34.213054 | 166 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/milp_network.py | """
Adapted from https://gitlab.inf.ethz.ch/OU-VECHEV/PARC/-/blob/MILP_encoding/MILP_Encoding/milp_utility.py
9a3a68a6bd86af27755dbf7a38595395a40baae1
"""
from __future__ import annotations
import multiprocessing
import time
from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Type
import numpy as np
import torch
import torch.nn as nn
from gurobipy import GRB, LinExpr, Model # type: ignore[import]
from torch import ( # TODO: many Tensor type annotations in this module seem to actually be np.ndarray
Tensor,
)
from tqdm.contrib.concurrent import process_map # type: ignore[import]
from src.abstract_layers.abstract_avg_pool2d import AvgPool2d
from src.abstract_layers.abstract_bn2d import BatchNorm2d
from src.abstract_layers.abstract_conv2d import Conv2d
from src.abstract_layers.abstract_flatten import Flatten
from src.abstract_layers.abstract_identity import Identity
from src.abstract_layers.abstract_linear import Linear
from src.abstract_layers.abstract_max_pool2d import MaxPool2d
from src.abstract_layers.abstract_network import AbstractNetwork
from src.abstract_layers.abstract_normalization import Normalization
from src.abstract_layers.abstract_pad import Pad
from src.abstract_layers.abstract_permute import Permute
from src.abstract_layers.abstract_relu import ReLU
from src.abstract_layers.abstract_reshape import Reshape
from src.abstract_layers.abstract_residual_block import ResidualBlock
from src.abstract_layers.abstract_sequential import Sequential
from src.abstract_layers.abstract_unbinary_op import UnbinaryOp
from src.state.tags import LayerTag, layer_tag
class Cache:
model: Any = None
output_counter: Optional[int] = None
lbi: Optional[Tensor] = None
ubi: Optional[Tensor] = None
time_limit: Optional[float] = None
terminate_time: Optional[float] = None
class MILPNetwork:
"""
Represents a MILP-Encoded (part of a) network
Attributes:
"""
def __init__(
self: MILPNetwork,
model: Any,
neuron_vars: Dict[str, List[Any]],
net: AbstractNetwork,
layer_id_to_prefix_map: Dict[LayerTag, str],
prefix_to_layer_bounds: Dict[str, Tuple[Tensor, Tensor]],
previous_layer_map: Dict[str, str],
input_shape: Any,
) -> None:
self.model = model
self.neuron_vars = neuron_vars
self.net = net
self.layer_id_to_prefix_map = layer_id_to_prefix_map
self.prefix_to_layer_bounds = prefix_to_layer_bounds
self.previous_layer_map = previous_layer_map
self.input_shape = input_shape
@classmethod
@torch.no_grad()
def build_model_from_abstract_net(
cls: Type[MILPNetwork],
x: torch.Tensor,
lb: torch.Tensor,
ub: torch.Tensor,
net: AbstractNetwork,
max_milp_neurons: int = -1,
feasibility_tol: float = 1e-6,
up_to_layer_id: Optional[LayerTag] = None,
) -> MILPNetwork:
# Check for intermediate constraints
output_lb, output_ub = net.set_layer_bounds_via_interval_propagation(
lb, ub, use_existing_bounds=True
)
assert cls._check_layer_bounds(net.layers)
model = Model("milp")
model.setParam("OutputFlag", 0)
model.setParam(GRB.Param.FeasibilityTol, feasibility_tol)
curr = x
curr_flattened = curr.flatten()
n_inputs = curr_flattened.numel()
numpy_lb: np.ndarray = lb.detach().reshape((1, -1)).cpu().numpy()
numpy_ub: np.ndarray = ub.detach().reshape((1, -1)).cpu().numpy()
# Encode Input
neuron_vars: Dict[str, List[Any]] = {}
layer_idx = "input"
neuron_vars[layer_idx] = []
for j in range(n_inputs):
neuron_vars[layer_idx] += [
model.addVar(
lb=numpy_lb[0, j],
ub=numpy_ub[0, j],
vtype=GRB.CONTINUOUS,
name=f"input_{j}",
)
]
neuron_vars[layer_idx][-1].setAttr("Start", curr_flattened[j])
# Encode Network
pr_lb, pr_ub = numpy_lb, numpy_ub
layer_idx_prefix = ""
layer_id_to_prefix_map: Dict[LayerTag, str] = {}
prefix_to_layer_bounds: Dict[str, Tuple[Tensor, Tensor]] = {}
previous_layer_map: Dict[str, str] = {}
cls._add_layer_list_with_prefix_to_model(
layer_idx_prefix,
net.layers,
model,
x,
neuron_vars,
max_milp_neurons,
pr_lb,
pr_ub,
layer_id_to_prefix_map,
prefix_to_layer_bounds,
previous_layer_map,
layer_idx,
up_to_layer_id,
)
return cls(
model,
neuron_vars,
net,
layer_id_to_prefix_map,
prefix_to_layer_bounds,
previous_layer_map,
x.shape,
)
@classmethod
def _add_layer_list_with_prefix_to_model(
cls: Type[MILPNetwork],
layer_idx_prefix: str,
layers: nn.ModuleList,
model: Any,
x: Tensor,
neuron_vars: Dict[str, List[Any]],
max_milp_neurons: int,
pr_lb: np.ndarray,
pr_ub: np.ndarray,
layer_id_to_prefix_map: Dict[LayerTag, str],
prefix_to_layer_bounds: Dict[str, Tuple[Tensor, Tensor]],
previous_layer_map: Dict[str, str],
pr_layer_idx: str,
up_to_layer_id: Optional[LayerTag] = None,
) -> Tuple[str, Tensor, np.ndarray, np.ndarray, int, bool]:
for layer_id, layer in enumerate(layers):
layer_idx = "%s%d" % (layer_idx_prefix, layer_id)
layer_id_to_prefix_map[layer_tag(layer)] = layer_idx
lb = layer.output_bounds[0].detach().flatten().cpu()
ub = layer.output_bounds[1].detach().flatten().cpu()
prefix_to_layer_bounds[layer_idx] = (lb, ub)
# This backprops refinements we made for relu to the output bounds of the layer before
if (
pr_layer_idx in prefix_to_layer_bounds
and layer.input_bounds is not None
):
prefix_to_layer_bounds[pr_layer_idx] = (
torch.maximum(
prefix_to_layer_bounds[pr_layer_idx][0],
layer.input_bounds[0].detach().flatten().cpu(),
),
torch.minimum(
prefix_to_layer_bounds[pr_layer_idx][1],
layer.input_bounds[1].detach().flatten().cpu(),
),
)
if layer.optim_input_bounds is not None:
prefix_to_layer_bounds[pr_layer_idx] = (
torch.maximum(
prefix_to_layer_bounds[pr_layer_idx][0],
layer.optim_input_bounds[0].detach().flatten().cpu(),
),
torch.minimum(
prefix_to_layer_bounds[pr_layer_idx][1],
layer.optim_input_bounds[1].detach().flatten().cpu(),
),
)
if isinstance(layer, Sequential):
new_prefix = f"{layer_idx}."
(
layer_idx,
x,
pr_lb,
pr_ub,
max_milp_after_layer,
break_layer_id_reached,
) = cls._add_layer_list_with_prefix_to_model(
new_prefix,
layer.layers,
model,
x,
neuron_vars,
max_milp_neurons,
pr_lb,
pr_ub,
layer_id_to_prefix_map,
prefix_to_layer_bounds,
previous_layer_map,
pr_layer_idx,
up_to_layer_id,
)
elif isinstance(layer, ResidualBlock):
(
layer_idx,
x,
pr_lb,
pr_ub,
max_milp_after_layer,
break_layer_id_reached,
) = cls._add_residual_layer(
layer_idx,
layer,
model,
x,
neuron_vars,
max_milp_neurons,
pr_lb,
pr_ub,
layer_id_to_prefix_map,
prefix_to_layer_bounds,
previous_layer_map,
pr_layer_idx,
up_to_layer_id,
)
else:
input_shape = tuple(x.shape[1:])
x = layer(x)
curr_lb, curr_ub = layer.output_bounds
numpy_curr_lb: np.ndarray = (
curr_lb.detach().reshape((1, -1)).cpu().numpy()
)
numpy_curr_ub: np.ndarray = (
curr_ub.detach().reshape((1, -1)).cpu().numpy()
)
assert (curr_lb <= x + 1e-6).all() and (
curr_ub >= x - 1e-6
).all(), (
f"max violation lb: {(x-curr_lb).min()} ub: {(curr_ub-x).max()}"
)
pr_lb, pr_ub, max_milp_after_layer = cls._add_layer_to_model(
layer,
model,
x,
neuron_vars,
pr_lb,
pr_ub,
numpy_curr_lb,
numpy_curr_ub,
layer_idx,
pr_layer_idx,
input_shape,
max_milp_neurons,
)
assert layer_idx not in previous_layer_map
previous_layer_map[layer_idx] = pr_layer_idx
if up_to_layer_id is not None:
break_layer_id_reached = layer_tag(layer) == up_to_layer_id
else:
break_layer_id_reached = False
max_milp_neurons = max_milp_after_layer
pr_layer_idx = layer_idx
if break_layer_id_reached:
break
return layer_idx, x, pr_lb, pr_ub, max_milp_neurons, break_layer_id_reached
@classmethod
def _check_layer_bounds(cls: Type[MILPNetwork], layers: nn.ModuleList) -> bool:
has_bounds = True
for layer in layers:
if isinstance(layer, Sequential):
has_bounds &= cls._check_layer_bounds(layer.layers)
elif isinstance(layer, ResidualBlock):
has_bounds &= cls._check_layer_bounds(layer.path_a.layers)
has_bounds &= cls._check_layer_bounds(layer.path_b.layers)
else:
has_bounds &= layer.output_bounds is not None
if not has_bounds:
return False
return True
@classmethod
def _add_layer_to_model(
cls: Type[MILPNetwork],
layer: nn.Module,
model: Any,
x: Tensor,
neuron_vars: Dict[str, List[Any]],
pr_lb: np.ndarray,
pr_ub: np.ndarray,
lb: np.ndarray,
ub: np.ndarray,
layer_idx: str,
pr_layer_idx: str,
in_shape: Tuple[int, ...],
n_milp_neurons: int = 0,
) -> Tuple[np.ndarray, np.ndarray, int]:
out_shape = tuple(x.shape[1:])
x_flat = x.flatten().detach().cpu().numpy()
neuron_vars[layer_idx] = []
milp_neurons_after_layer = cls._translate_layer(
model,
neuron_vars,
layer,
pr_layer_idx,
layer_idx,
lb[0],
ub[0],
pr_lb[0],
pr_ub[0],
n_milp_neurons,
in_shape,
out_shape,
feasible_activation=x_flat,
)
return lb, ub, milp_neurons_after_layer
@classmethod
def _translate_layer( # noqa: C901
cls: type[MILPNetwork],
model: Any,
neuron_vars: Dict[str, List[Any]],
layer: nn.Module,
pr_layer_idx: str,
layer_idx: str,
lb: np.ndarray,
ub: np.ndarray,
pr_lb: np.ndarray,
pr_ub: np.ndarray,
n_milp_neurons: int,
in_shape: Tuple[int, ...],
out_shape: Tuple[int, ...],
feasible_activation: Optional[np.ndarray] = None,
) -> int:
if isinstance(layer, Linear):
weight: np.ndarray = layer.weight.cpu().detach().numpy()
bias: np.ndarray = (
layer.bias.cpu().detach().numpy() if layer.bias is not None else None
)
cls._handle_affine(
model,
neuron_vars,
layer_idx,
pr_layer_idx,
lb,
ub,
weight,
bias,
in_shape,
out_shape,
feasible_activation,
)
elif isinstance(layer, ReLU):
n_milp_neurons = cls._handle_relu(
model,
neuron_vars,
layer_idx,
pr_layer_idx,
lb,
ub,
pr_lb,
pr_ub,
in_shape,
out_shape,
n_milp_neurons,
feasible_activation,
)
elif isinstance(layer, Flatten) or isinstance(layer, Reshape):
neuron_vars[layer_idx] = neuron_vars[pr_layer_idx]
elif isinstance(layer, Identity):
neuron_vars[layer_idx] = neuron_vars[pr_layer_idx]
elif isinstance(layer, Conv2d):
weight = layer.weight.cpu().detach().numpy()
bias = layer.bias.cpu().detach().numpy() if layer.bias is not None else None
filter_size, stride, pad, dilation = (
layer.kernel_size,
layer.stride,
layer.padding,
layer.dilation,
)
assert dilation == (1, 1), "Dilation != 1 not implemented"
if isinstance(pad, int): # TODO: mypy thinks this is never true
pad_top, pad_left = pad, pad
elif len(pad) >= 2:
pad_top, pad_left, = (
pad[0],
pad[1],
)
cls._handle_conv(
model,
neuron_vars,
layer_idx,
pr_layer_idx,
lb,
ub,
weight,
bias,
filter_size,
stride,
pad_top,
pad_left,
in_shape,
out_shape,
feasible_activation,
)
elif isinstance(layer, Normalization):
mean, sigma = (
layer.mean.cpu().detach().numpy(),
layer.sigma.cpu().detach().numpy(),
)
bias = (-mean / sigma).flatten()
weight = np.diag(1 / sigma.flatten()).reshape(mean.size, mean.size, 1, 1)
cls._handle_conv(
model,
neuron_vars,
layer_idx,
pr_layer_idx,
lb,
ub,
weight,
bias,
(1, 1),
(1, 1),
0,
0,
in_shape,
out_shape,
feasible_activation,
)
elif isinstance(layer, AvgPool2d):
kernel_size, stride, pad = layer.kernel_size, layer.stride, layer.padding
if isinstance(pad, int):
pad_top, pad_left = pad, pad
elif len(pad) >= 2:
pad_top, pad_left = pad[0], pad[1]
cls._handle_avg_pool_2d(
model,
neuron_vars,
layer_idx,
pr_layer_idx,
lb,
ub,
kernel_size,
stride,
pad_top,
pad_left,
in_shape,
out_shape,
feasible_activation,
)
elif isinstance(layer, MaxPool2d):
kernel_size, stride, pad, dilation = (
layer.kernel_size,
layer.stride,
layer.padding,
layer.dilation,
)
assert dilation == (1, 1), "Dilation != 1 not implemented"
if isinstance(pad, int):
pad_top, pad_left = pad, pad
elif len(pad) >= 2:
pad_top, pad_left = pad[0], pad[1]
cls._handle_max_pool_2d(
model,
neuron_vars,
layer_idx,
pr_layer_idx,
lb,
ub,
pr_lb,
pr_ub,
kernel_size,
stride,
pad_top,
pad_left,
in_shape,
out_shape,
n_milp_neurons,
feasible_activation,
)
elif isinstance(layer, BatchNorm2d):
mult_term, add_term = layer.mult_term, layer.add_term
cls._handle_bn2d(
model,
neuron_vars,
layer_idx,
pr_layer_idx,
lb,
ub,
mult_term,
add_term,
in_shape,
out_shape,
feasible_activation,
)
elif isinstance(layer, Pad):
pad, val = layer.pad, layer.value
cls._handle_pad(
model,
neuron_vars,
layer_idx,
pr_layer_idx,
lb,
ub,
pad,
val,
in_shape,
out_shape,
feasible_activation,
)
elif isinstance(layer, Permute):
permutation = layer.perm_ind
cls._handle_permute(
model,
neuron_vars,
layer_idx,
pr_layer_idx,
lb,
ub,
permutation,
in_shape,
out_shape,
feasible_activation,
)
elif isinstance(layer, UnbinaryOp):
op = layer.op
c_val = layer.const_val
apply_right = layer.apply_right
cls._handle_unbinary_op(
model,
neuron_vars,
layer_idx,
pr_layer_idx,
lb,
ub,
op,
c_val,
apply_right,
in_shape,
out_shape,
feasible_activation,
)
else:
print("unknown layer type: ", layer)
assert False
return n_milp_neurons
@classmethod
def _add_residual_layer(
cls: Type[MILPNetwork],
new_prefix: str,
layer: ResidualBlock,
model: Any,
x: Tensor,
neuron_vars: Dict[str, List[Any]],
max_milp_neurons: int,
pr_lb: np.ndarray,
pr_ub: np.ndarray,
layer_id_to_prefix_map: Dict[LayerTag, str],
prefix_to_layer_bounds: Dict[str, Tuple[Tensor, Tensor]],
previous_layer_map: Dict[str, str],
pr_layer_idx: str,
up_to_layer_id: Optional[LayerTag],
) -> Tuple[str, Tensor, np.ndarray, np.ndarray, int, bool]:
new_prefix_a = f"{new_prefix}.path_a."
new_prefix_b = f"{new_prefix}.path_b."
merge_prefix = f"{new_prefix}.merge"
(
final_layer_a_idx,
x_a,
pr_lb_a,
pr_ub_a,
milp_neurons_after_path_a,
break_layer_id_reached,
) = cls._add_layer_list_with_prefix_to_model(
new_prefix_a,
layer.path_a.layers,
model,
x,
neuron_vars,
max_milp_neurons,
pr_lb,
pr_ub,
layer_id_to_prefix_map,
prefix_to_layer_bounds,
previous_layer_map,
pr_layer_idx,
up_to_layer_id,
)
if break_layer_id_reached:
return (
final_layer_a_idx,
x_a,
pr_lb_a,
pr_ub_a,
milp_neurons_after_path_a,
break_layer_id_reached,
)
(
final_layer_b_idx,
x_b,
pr_lb_b,
pr_ub_b,
milp_neurons_after_path_b,
break_layer_id_reached,
) = cls._add_layer_list_with_prefix_to_model(
new_prefix_b,
layer.path_b.layers,
model,
x,
neuron_vars,
max_milp_neurons,
pr_lb,
pr_ub,
layer_id_to_prefix_map,
prefix_to_layer_bounds,
previous_layer_map,
pr_layer_idx,
up_to_layer_id,
)
if break_layer_id_reached:
return (
final_layer_b_idx,
x_b,
pr_lb_b,
pr_ub_b,
milp_neurons_after_path_b,
break_layer_id_reached,
)
x_m = layer(x)
x_m_flat = x_m.flatten().cpu().numpy()
num_out_neurons = x_m_flat.shape[0]
assert layer.output_bounds is not None
lb, ub = (
layer.output_bounds[0].detach().reshape((1, -1)).cpu().numpy(),
layer.output_bounds[1].detach().reshape((1, -1)).cpu().numpy(),
)
lb_t = layer.output_bounds[0].detach().flatten().cpu()
ub_t = layer.output_bounds[1].detach().flatten().cpu()
prefix_to_layer_bounds[merge_prefix] = (lb_t, ub_t)
neuron_vars[merge_prefix] = []
for j in range(num_out_neurons):
var_name = f"x_{merge_prefix}_{j}"
var = model.addVar(
vtype=GRB.CONTINUOUS, lb=lb[0, j], ub=ub[0, j], name=var_name
)
var.start = x_m_flat[j]
neuron_vars[merge_prefix].append(var)
for j in range(num_out_neurons):
expr = LinExpr()
expr += -1 * neuron_vars[merge_prefix][j]
expr += neuron_vars[final_layer_a_idx][j]
expr += neuron_vars[final_layer_b_idx][j]
expr.addConstant(0)
model.addLConstr(expr, GRB.EQUAL, 0)
if max_milp_neurons == -1:
milp_left = -1
else:
milp_spent = (
2 * max_milp_neurons
- milp_neurons_after_path_a
- milp_neurons_after_path_b
)
milp_left = max(0, max_milp_neurons - milp_spent)
return merge_prefix, x_m, lb, ub, milp_left, break_layer_id_reached
@classmethod
def _handle_conv(
cls: Type[MILPNetwork],
model: Any,
neuron_vars: Dict[str, List[Any]],
layer_idx: str,
pr_layer_idx: str,
lb: np.ndarray,
ub: np.ndarray,
weight: np.ndarray,
bias: Optional[np.ndarray],
kernel_size: Tuple[int, ...],
stride: Tuple[int, ...],
pad_top: int,
pad_left: int,
in_shape: Tuple[int, ...],
out_shape: Tuple[int, ...],
feasible_activation: Optional[np.ndarray] = None,
) -> None:
neuron_vars[layer_idx] = []
out_ch, out_h, out_w = out_shape
in_ch, in_h, in_w = in_shape
in_hw = in_h * in_w
out_hw = out_h * out_w
in_neurons = in_ch * in_hw
out_neurons = out_ch * out_hw
for j in range(out_neurons):
var_name = f"x_{layer_idx}_{j}"
var = model.addVar(vtype=GRB.CONTINUOUS, lb=lb[j], ub=ub[j], name=var_name)
if feasible_activation is not None:
var.start = feasible_activation[j]
neuron_vars[layer_idx].append(var)
for out_z in range(out_ch):
for out_y in range(out_h):
for out_x in range(out_w):
out_ind = out_z * out_hw + out_y * out_w + out_x
expr = LinExpr()
expr += -1 * neuron_vars[layer_idx][out_ind]
for in_z in range(in_ch):
for y_shift in range(kernel_size[0]):
for x_shift in range(kernel_size[1]):
in_x = out_x * stride[1] + x_shift - pad_left
in_y = out_y * stride[0] + y_shift - pad_top
if in_y < 0 or in_y >= in_h:
continue
if in_x < 0 or in_x >= in_w:
continue
in_ind = in_z * in_hw + in_y * in_w + in_x
if in_ind >= in_neurons:
continue
expr.addTerms(
weight[out_z][in_z][y_shift][x_shift],
neuron_vars[pr_layer_idx][in_ind],
)
if bias is not None:
expr.addConstant(bias[out_z])
model.addLConstr(expr, GRB.EQUAL, 0)
@classmethod
def _handle_avg_pool_2d(
cls: Type[MILPNetwork],
model: Any,
neuron_vars: Dict[str, List[Any]],
layer_idx: str,
pr_layer_idx: str,
lb: np.ndarray,
ub: np.ndarray,
kernel_size: Tuple[int, ...],
stride: Tuple[int, ...],
pad_top: int,
pad_left: int,
in_shape: Tuple[int, ...],
out_shape: Tuple[int, ...],
feasible_activation: Optional[np.ndarray] = None,
) -> None:
# NOTE Only handles padding with zeros
neuron_vars[layer_idx] = []
out_ch, out_h, out_w = out_shape
in_ch, in_h, in_w = in_shape
in_hw = in_h * in_w
out_hw = out_h * out_w
in_neurons = in_ch * in_hw
out_neurons = out_ch * out_hw
norm = 1 / (torch.prod(torch.Tensor(kernel_size)).item())
for j in range(out_neurons):
var_name = f"x_{layer_idx}_{j}"
var = model.addVar(vtype=GRB.CONTINUOUS, lb=lb[j], ub=ub[j], name=var_name)
if feasible_activation is not None:
var.start = feasible_activation[j]
assert (
lb[j] <= feasible_activation[j] and feasible_activation[j] <= ub[j]
)
neuron_vars[layer_idx].append(var)
for out_z in range(out_ch):
for out_y in range(out_h):
for out_x in range(out_w):
out_ind = out_z * out_hw + out_y * out_w + out_x
expr = LinExpr()
expr += -1 * neuron_vars[layer_idx][out_ind]
for x_shift in range(kernel_size[0]):
for y_shift in range(kernel_size[1]):
in_x = out_x * stride[0] + x_shift - pad_top
in_y = out_y * stride[1] + y_shift - pad_left
if in_y < 0 or in_y >= in_h:
continue
if in_x < 0 or in_x >= in_w:
continue
in_ind = out_z * in_hw + in_y * in_w + in_x
if in_ind >= in_neurons:
continue
expr.addTerms(
norm,
neuron_vars[pr_layer_idx][in_ind],
)
model.addLConstr(expr, GRB.EQUAL, 0)
@classmethod
def _handle_max_pool_2d(
cls: Type[MILPNetwork],
model: Any,
neuron_vars: Dict[str, List[Any]],
layer_idx: str,
pr_layer_idx: str,
lb: np.ndarray,
ub: np.ndarray,
lb_prev: np.ndarray,
ub_prev: np.ndarray,
kernel_size: Tuple[int, ...],
stride: Tuple[int, ...],
pad_top: int,
pad_left: int,
in_shape: Tuple[int, ...],
out_shape: Tuple[int, ...],
partial_milp_neurons: int = 0,
feasible_activation: Optional[np.ndarray] = None,
) -> None:
# NOTE Only handles padding with zeros
neuron_vars[layer_idx] = []
out_ch, out_h, out_w = out_shape
in_ch, in_h, in_w = in_shape
in_hw = in_h * in_w
out_hw = out_h * out_w
in_neurons = in_ch * in_hw
out_neurons = out_ch * out_hw
kernel_count = (
kernel_size[0] ** 2 if len(kernel_size) == 1 else np.prod(kernel_size)
)
assert (
partial_milp_neurons <= 0
), "MaxPool only supports full (-1) or no (0) MILP encoding."
binary_vars = []
# zero_var = model.addVar(
# vtype=GRB.CONTINUOUS, lb=0.0, ub=0.0, name=f"zero_{layer_idx}"
# )
for j in range(out_neurons):
var_name = f"x_{layer_idx}_{j}"
var = model.addVar(vtype=GRB.CONTINUOUS, lb=lb[j], ub=ub[j], name=var_name)
if feasible_activation is not None:
var.start = feasible_activation[j]
neuron_vars[layer_idx].append(var)
for out_z in range(out_ch):
for out_y in range(out_h):
for out_x in range(out_w):
has_gt_pad_const = False
out_ind = out_z * out_hw + out_y * out_w + out_x
pool_map = []
for x_shift in range(kernel_size[0]):
for y_shift in range(kernel_size[1]):
in_x = out_x * stride[0] + x_shift - pad_top
in_y = out_y * stride[1] + y_shift - pad_left
in_ind = out_z * in_hw + in_y * in_w + in_x
if in_y < 0 or in_x < 0 or in_y >= in_h or in_x >= in_w:
# has_gt_pad_const = True
pass
elif in_ind < in_neurons:
pool_map.append(in_ind)
max_l_var = pool_map[
np.argmax(np.array([lb_prev[i] for i in pool_map]))
]
max_l = lb_prev[max_l_var]
# if has_gt_pad_const:
# max_l = max(0, max_l)
not_dominated = [i for i in pool_map if ub_prev[i] >= max_l]
# if len(not_dominated) == 0:
# assert has_gt_pad_const == True
# model.addConstr(
# neuron_vars[layer_idx][out_ind]
# - zero_var,
# GRB.EQUAL,
# 0,
# )
if len(not_dominated) == 1:
model.addLConstr(
neuron_vars[layer_idx][out_ind]
- neuron_vars[pr_layer_idx][not_dominated[0]],
GRB.EQUAL,
0,
)
else:
add_expr = LinExpr()
add_expr += -neuron_vars[layer_idx][out_ind]
binary_expr = LinExpr()
for i, in_ind in enumerate(not_dominated):
# y >= x
expr = (
neuron_vars[layer_idx][out_ind]
- neuron_vars[pr_layer_idx][in_ind]
)
model.addLConstr(expr, GRB.GREATER_EQUAL, 0)
add_expr += neuron_vars[pr_layer_idx][in_ind]
if partial_milp_neurons < 0:
var_name = f"b_{layer_idx}_{j}_{i}"
var_bin = model.addVar(vtype=GRB.BINARY, name=var_name)
binary_vars.append(var_bin)
# y <= x + (1-a)*(u_{rest}-l)
max_u_rest = max(
[ub_prev[i] for i in not_dominated if i != in_ind]
)
cst = max_u_rest - lb_prev[in_ind]
expr = (
neuron_vars[layer_idx][out_ind]
- neuron_vars[pr_layer_idx][in_ind]
+ cst * var_bin
)
model.addLConstr(expr, GRB.LESS_EQUAL, cst)
# indicator constraints
model.addGenConstrIndicator(
var_bin,
True,
neuron_vars[layer_idx][out_ind]
- neuron_vars[pr_layer_idx][in_ind],
GRB.EQUAL,
0.0,
)
binary_expr += var_bin
if partial_milp_neurons == 0:
if has_gt_pad_const:
model.addLConstr(
neuron_vars[layer_idx][out_ind],
GRB.GREATER_EQUAL,
0,
)
model.addLConstr(
add_expr,
GRB.GREATER_EQUAL,
sum([lb_prev[i] for i in not_dominated]) - max_l,
)
else:
# if has_gt_pad_const:
# var_name = f"b_{layer_idx}_{j}_{-1}"
# var_bin = model.addVar(vtype=GRB.BINARY, name=var_name)
# binary_vars.append(var_bin)
# binary_expr += var_bin
# model.addGenConstrIndicator(
# var_bin,
# True,
# neuron_vars[layer_idx][out_ind] - zero_var,
# GRB.EQUAL,
# 0.0,
# )
#
# max_u_rest = max([ub_prev[i] for i in not_dominated])
# expr = (
# neuron_vars[layer_idx][out_ind]
# - zero_var
# + max_u_rest * var_bin
# )
# model.addConstr(expr, GRB.LESS_EQUAL, max_u_rest)
# only one indicator can be true
model.addLConstr(binary_expr, GRB.EQUAL, 1)
@classmethod
def _handle_affine(
cls: Type[MILPNetwork],
model: Any,
neuron_vars: Dict[str, List[Any]],
layer_idx: str,
pr_layer_idx: str,
lb: np.ndarray,
ub: np.ndarray,
weight: np.ndarray,
bias: Optional[np.ndarray],
in_shape: Tuple[int, ...],
out_shape: Tuple[int, ...],
feasible_activation: Optional[np.ndarray] = None,
) -> None:
neuron_vars[layer_idx] = []
in_n = in_shape[-1]
out_n = out_shape[-1]
# output of matmult
for j in range(out_n):
var_name = "n_{}_{}".format(layer_idx, j)
var = model.addVar(vtype=GRB.CONTINUOUS, lb=lb[j], ub=ub[j], name=var_name)
if feasible_activation is not None:
var.start = feasible_activation[j]
neuron_vars[layer_idx].append(var)
for j in range(out_n):
expr = LinExpr()
expr += -1 * neuron_vars[layer_idx][j]
# matmult constraints
for k in range(in_n):
expr.addTerms(weight[j][k], neuron_vars[pr_layer_idx][k])
if bias is not None:
expr.addConstant(bias[j])
model.addLConstr(expr, GRB.EQUAL, 0)
@classmethod
def _handle_relu(
cls: Type[MILPNetwork],
model: Any,
neuron_vars: Dict[str, List[Any]],
layer_idx: str,
pr_layer_idx: str,
lb: np.ndarray,
ub: np.ndarray,
lb_prev: np.ndarray,
ub_prev: np.ndarray,
in_shape: Tuple[int, ...],
out_shape: Tuple[int, ...],
partial_milp_neurons: int = 0,
feasible_activation: Optional[np.ndarray] = None,
) -> int:
neuron_vars[layer_idx] = []
num_neurons = np.prod(in_shape)
# Determine which neurons to encode with MILP and which with LP (triangle)
cross_over_idx = list(np.nonzero(np.array(lb_prev) * np.array(ub_prev) < 0)[0])
width = np.array(ub_prev) - np.array(lb_prev)
cross_over_idx = sorted(cross_over_idx, key=lambda x: -width[x])
milp_encode_idx = (
cross_over_idx[:partial_milp_neurons]
if partial_milp_neurons >= 0
else cross_over_idx
) # cross_over_idx if use_milp else cross_over_idx[:partial_milp_neurons]
temp_idx = np.ones(lb_prev.size, dtype=bool) # type: ignore[arg-type] # mypy bug?
temp_idx[milp_encode_idx] = False
lp_encode_idx = np.arange(num_neurons)[temp_idx]
assert len(lp_encode_idx) + len(milp_encode_idx) == num_neurons
# Add binary variables to model
binary_vars = []
if len(milp_encode_idx) > 0:
binary_guess = (
None
if feasible_activation is None
else (feasible_activation > 0).astype(int)
) # Initialize binary variables with a feasible solution
for i, j in enumerate(milp_encode_idx):
var_name = f"b_{layer_idx}_{j}"
var_bin = model.addVar(vtype=GRB.BINARY, name=var_name)
if binary_guess is not None:
var_bin.start = binary_guess[j]
binary_vars.append(var_bin)
# Add ReLU output variables
if feasible_activation is not None:
feas_act_post = np.maximum(
feasible_activation, 0.0
) # Initialize output variables with a feasible solution
for j in range(num_neurons):
var_name = f"x_{layer_idx}_{j}"
upper_bound = max(0.0, float(ub_prev[j]))
var = model.addVar(
vtype=GRB.CONTINUOUS, lb=0.0, ub=upper_bound, name=var_name
)
if feasible_activation is not None:
var.start = feas_act_post[j]
neuron_vars[layer_idx].append(var)
# Add MILP encoding
if len(milp_encode_idx) > 0:
for i, j in enumerate(milp_encode_idx):
var_bin = binary_vars[i]
var_in = neuron_vars[pr_layer_idx][j]
var_out = neuron_vars[layer_idx][j]
if ub_prev[j] <= 0:
# stabely inactive
expr = var_out
model.addLConstr(expr, GRB.EQUAL, 0)
elif lb_prev[j] >= 0:
# stabely active
expr = var_out - var_in
model.addLConstr(expr, GRB.EQUAL, 0)
else:
# y <= x - l(1-a)
expr = var_out - var_in - lb_prev[j] * var_bin
model.addLConstr(expr, GRB.LESS_EQUAL, -lb_prev[j])
# y >= x
expr = var_out - var_in
model.addLConstr(expr, GRB.GREATER_EQUAL, 0)
# y <= u . a
expr = var_out - ub_prev[j] * var_bin
model.addLConstr(expr, GRB.LESS_EQUAL, 0)
# y >= 0
# expr = var_out
# model.addLConstr(expr, GRB.GREATER_EQUAL, 0)
# indicator constraint
model.addGenConstrIndicator(
var_bin, True, var_in, GRB.GREATER_EQUAL, 0.0
)
# Add LP encoding
if len(lp_encode_idx) > 0:
for j in lp_encode_idx:
var_in = neuron_vars[pr_layer_idx][j]
var_out = neuron_vars[layer_idx][j]
if ub_prev[j] <= 0:
expr = var_out
model.addLConstr(expr, GRB.EQUAL, 0)
elif lb_prev[j] >= 0:
expr = var_out - var_in
model.addLConstr(expr, GRB.EQUAL, 0)
else:
# y >= 0 (already encoded in range of output variable)
# expr = var_out
# model.addLConstr(expr, GRB.GREATER_EQUAL, 0)
# y >= x
expr = var_out - var_in
model.addLConstr(expr, GRB.GREATER_EQUAL, 0)
# y <= (x-l) * u/(u-l)
expr = (ub_prev[j] - lb_prev[j]) * var_out - (
var_in - lb_prev[j]
) * ub_prev[j]
model.addLConstr(expr, GRB.LESS_EQUAL, 0)
if partial_milp_neurons < 0:
return partial_milp_neurons
else:
return max(0, partial_milp_neurons - len(milp_encode_idx))
@classmethod
def _handle_bn2d(
cls: Type[MILPNetwork],
model: Any,
neuron_vars: Dict[str, List[Any]],
layer_idx: str,
pr_layer_idx: str,
lb: np.ndarray,
ub: np.ndarray,
mult_term: Tensor,
add_term: Tensor,
in_shape: Tuple[int, ...],
out_shape: Tuple[int, ...],
feasible_activation: Optional[np.ndarray],
) -> None:
# y = x * c + b
neuron_vars[layer_idx] = []
out_neurons = np.prod(out_shape)
# define variables
for j in range(out_neurons):
var_name = "x_{}_{}".format(layer_idx, j)
var = model.addVar(vtype=GRB.CONTINUOUS, lb=lb[j], ub=ub[j], name=var_name)
if feasible_activation is not None:
var.start = feasible_activation[j]
neuron_vars[layer_idx].append(var)
# Channelwise normalization
vars_per_channel = np.prod(out_shape[1:])
for c in range(out_shape[0]):
for j in range(vars_per_channel):
expr = LinExpr()
expr += -1 * neuron_vars[layer_idx][c * vars_per_channel + j]
expr.addTerms(
mult_term[c], neuron_vars[pr_layer_idx][c * vars_per_channel + j]
)
expr.addConstant(add_term[c])
model.addLConstr(expr, GRB.EQUAL, 0)
@classmethod
def _handle_pad(
cls: type[MILPNetwork],
model: Any,
neuron_vars: Dict[str, List[Any]],
layer_idx: str,
pr_layer_idx: str,
lb: np.ndarray,
ub: np.ndarray,
pad: Tuple[int, ...],
val: float,
in_shape: Tuple[int, ...],
out_shape: Tuple[int, ...],
feasible_activation: Optional[np.ndarray],
) -> None:
out_neurons = np.prod(out_shape)
neuron_vars[layer_idx] = [None] * out_neurons
# define variables
pad_var = model.addVar(
vtype=GRB.CONTINUOUS, lb=val, ub=val, name=f"pad_{layer_idx}"
)
pad_l, pad_r, pad_t, pad_b = pad
width = out_shape[-1]
height = out_shape[-2]
channels = out_shape[0]
pad_b = height - pad_b
pad_r = width - pad_r
prev_idx = 0
# Pad out
for out_z in range(channels):
for out_y in range(height):
for out_x in range(width):
out_ind = out_z * height * width + out_y * width + out_x
if (
out_x < pad_l
or out_x >= pad_r
or out_y < pad_t
or out_y >= pad_b
):
neuron_vars[layer_idx][out_ind] = pad_var
else:
neuron_vars[layer_idx][out_ind] = neuron_vars[pr_layer_idx][
prev_idx
]
prev_idx += 1
@classmethod
def _handle_permute(
cls: type[MILPNetwork],
model: Any,
neuron_vars: Dict[str, List[Any]],
layer_idx: str,
pr_layer_idx: str,
lb: np.ndarray,
ub: np.ndarray,
permutation: Tuple[int, ...],
in_shape: Tuple[int, ...],
out_shape: Tuple[int, ...],
feasible_activation: Optional[np.ndarray],
) -> None:
neuron_vars[layer_idx] = []
out_neurons = np.prod(out_shape)
# define variables
for j in range(out_neurons):
var_name = "x_{}_{}".format(layer_idx, j)
var = model.addVar(vtype=GRB.CONTINUOUS, lb=lb[j], ub=ub[j], name=var_name)
if feasible_activation is not None:
var.start = feasible_activation[j]
neuron_vars[layer_idx].append(var)
dist = len(permutation) - len(in_shape)
perm_ind = tuple([i - dist for i in permutation[dist:]])
indices = torch.arange(out_neurons).view(in_shape)
indices = torch.permute(indices, perm_ind).flatten()
# permute variables
for i in range(out_neurons):
# Set equality
expr = LinExpr()
expr += (
-1 * neuron_vars[layer_idx][i] + neuron_vars[pr_layer_idx][indices[i]]
)
model.addLConstr(expr, GRB.EQUAL, 0)
@classmethod
def _handle_unbinary_op(
cls: type[MILPNetwork],
model: Any,
neuron_vars: Dict[str, List[Any]],
layer_idx: str,
pr_layer_idx: str,
lb: np.ndarray,
ub: np.ndarray,
op: str,
c_val: Tensor,
apply_right: bool,
in_shape: Tuple[int, ...],
out_shape: Tuple[int, ...],
feasible_activation: Optional[np.ndarray],
) -> None:
neuron_vars[layer_idx] = []
out_neurons = np.prod(out_shape)
# define variables
for j in range(out_neurons):
var_name = "x_{}_{}".format(layer_idx, j)
var = model.addVar(vtype=GRB.CONTINUOUS, lb=lb[j], ub=ub[j], name=var_name)
if feasible_activation is not None:
var.start = feasible_activation[j]
neuron_vars[layer_idx].append(var)
if c_val.shape:
if c_val.dim() > len(in_shape):
c_val = c_val.view(in_shape)
c_val_for_out_neurons = c_val.broadcast_to(in_shape).flatten()
assert len(c_val_for_out_neurons) == out_neurons
if op == "add":
for i in range(out_neurons):
expr = LinExpr()
expr += (
-1 * neuron_vars[layer_idx][i]
+ neuron_vars[pr_layer_idx][i]
+ c_val_for_out_neurons[i]
)
model.addLConstr(expr, GRB.EQUAL, 0)
elif op == "sub":
for i in range(out_neurons):
expr = LinExpr()
if apply_right:
expr += (
-1 * neuron_vars[layer_idx][i]
- neuron_vars[pr_layer_idx][i]
+ c_val_for_out_neurons[i]
)
else:
expr += (
-1 * neuron_vars[layer_idx][i]
+ neuron_vars[pr_layer_idx][i]
- c_val_for_out_neurons[i]
)
model.addLConstr(expr, GRB.EQUAL, 0)
elif op == "mul":
for i in range(out_neurons):
expr = LinExpr()
expr += (
-1 * neuron_vars[layer_idx][i]
+ neuron_vars[pr_layer_idx][i] * c_val_for_out_neurons[i]
)
model.addLConstr(expr, GRB.EQUAL, 0)
elif op == "div":
for i in range(out_neurons):
expr = LinExpr()
if apply_right:
assert False, "Non-linear division"
else:
expr += (
-1 * neuron_vars[layer_idx][i]
+ neuron_vars[pr_layer_idx][i] / c_val_for_out_neurons[i]
)
model.addLConstr(expr, GRB.EQUAL, 0)
else:
assert False, "Unknown type"
def get_network_bounds_at_layer_multi(
self,
layer_idx: LayerTag,
compute_input_bounds: bool = False,
timeout_per_instance: Optional[float] = None,
timeout_total: Optional[float] = None,
timeout: Optional[float] = None,
NUMPROCESSES: int = 2,
refine_only_unstable: bool = False,
) -> Tuple[Tensor, Tensor]:
model = self.model
if timeout_per_instance:
model.setParam(GRB.Param.TimeLimit, timeout_per_instance)
model.setParam(GRB.Param.Threads, 1)
model.update()
model.reset()
prefix = self.layer_id_to_prefix_map[layer_idx]
if compute_input_bounds:
prefix = self.previous_layer_map[prefix]
curr_lbs, curr_ubs = self.prefix_to_layer_bounds[prefix]
candidate_vars = self.neuron_vars[prefix]
Cache.model = model.copy()
Cache.lbi = curr_lbs
Cache.ubi = curr_ubs
Cache.time_limit = timeout_per_instance
# Cache.output_counter = offset
Cache.terminate_time = (
None
if timeout is None
else (
timeout - 10 if timeout_total is None else timeout - timeout_total * 0.2
)
)
inputs: List[Tuple[Tuple[int, str], float, float]] = []
for i, v in enumerate(candidate_vars):
if not refine_only_unstable or (
float(curr_lbs[i]) < 0 and float(curr_ubs[i]) > 0
):
inputs.append(((i, v.VarName), float(curr_lbs[i]), float(curr_ubs[i])))
print("Num of bounds to refine: ", len(inputs))
inputs = sorted(
inputs, key=lambda q: q[2] - q[1], reverse=True
) # Sort all neurons by their current width
input_ids = [idx for (idx, _, _) in inputs]
resl = -1 * torch.inf * torch.ones((len(curr_lbs),))
resu = torch.inf * torch.ones((len(curr_ubs),))
solver_result = []
if refine_only_unstable:
solver_result = process_map(
get_neuron_bound_stable_call, input_ids, max_workers=NUMPROCESSES
)
else:
solver_result = process_map(
get_neuron_bound_call, input_ids, max_workers=NUMPROCESSES
)
refined_indices = []
for ((soll, solu, addtoindices, runtime), ind) in zip(solver_result, input_ids):
resl[ind[0]] = soll
resu[ind[0]] = solu
if soll > solu:
print(f"unsound {ind[0]}")
if addtoindices:
refined_indices.append(ind[0])
resl = torch.maximum(resl, curr_lbs)
resu = torch.minimum(resu, curr_ubs)
return resl, resu
def _get_network_bounds_at_layer_single(
self: MILPNetwork, layer_id: LayerTag, timeout: Optional[int] = 400
) -> Tuple[Tensor, Tensor]:
prefix = self.layer_id_to_prefix_map[layer_id]
num_neurons = len(self.neuron_vars[prefix])
lbs = torch.zeros((num_neurons,))
ubs = torch.zeros((num_neurons,))
prior_lbs, prior_ubs = self.prefix_to_layer_bounds[prefix]
for i, var in enumerate(self.neuron_vars[prefix]):
lb, ub = self._get_neuron_bound(var, prior_lbs[i], prior_ubs[i], timeout)
lbs[i] = lb
ubs[i] = ub
return lbs, ubs
def get_network_output_bounds(
self: MILPNetwork, timeout: float = 400 + time.time()
) -> Tuple[Tensor, Tensor]:
output_layer_idx = layer_tag(self.net.layers[-1])
return self.get_network_bounds_at_layer_multi(
output_layer_idx,
timeout_per_instance=timeout - time.time(),
timeout_total=timeout - time.time(),
timeout=timeout,
)
def verify_properties(
self: MILPNetwork,
properties: List[List[Tuple[int, int, float]]],
timeout_per_instance: Optional[float] = None,
timeout_total: Optional[float] = None,
start_time: Optional[float] = None,
NUMPROCESSES: int = 2,
) -> Tuple[bool, List[float], Optional[Tensor]]:
output_layer_idx = layer_tag(self.net.layers[-1])
if isinstance(self.net.layers[-1], Sequential):
output_layer_idx = layer_tag(self.net.layers[-1].layers[-1])
model = self.model
if timeout_per_instance:
model.setParam(GRB.Param.TimeLimit, timeout_per_instance)
model.setParam(GRB.Param.Threads, 2)
model.update()
model.reset()
prefix = self.layer_id_to_prefix_map[output_layer_idx]
candidate_vars = self.neuron_vars[prefix]
logit_lbs, logit_ubs = self.prefix_to_layer_bounds[prefix]
lbs = []
is_verified = True
ctr_example: Optional[Tensor] = None
runtime = 0
D = 1e-4
for i, prop in enumerate(properties):
terminate_time = (
None
if start_time is None or timeout_total is None
else start_time + timeout_total * 0.8
)
if terminate_time is not None and terminate_time - time.time() < 1:
break
label, other_label, offset = prop[0]
if label == -1:
lb = offset - logit_ubs[other_label]
elif other_label == -1:
lb = logit_lbs[label] - offset
else:
lb = logit_lbs[label] - logit_ubs[other_label] - offset
model.setParam(
GRB.Param.TimeLimit,
max(
0,
min(
np.inf
if timeout_per_instance is None
else timeout_per_instance,
np.inf
if terminate_time is None
else (terminate_time - time.time()),
),
),
)
obj: Any = LinExpr() + offset * (-1 if label >= 0 else 1)
obj += (
model.getVarByName(candidate_vars[label].varName) if label >= 0 else 0
)
obj += (
-model.getVarByName(candidate_vars[other_label].varName)
if other_label >= 0
else 0
)
# print (f"{ind} {model.getVarByName(ind[1]).VarName}")
model.setObjective(obj, GRB.MINIMIZE)
# model.setParam("BestObjStop", -D)
# model.setParam("CUTOFF", D)
model.setParam("Threads", multiprocessing.cpu_count())
model.reset()
model.optimize(get_milp_callback_for_target_cutoff(0, maximize=False))
model.optimize()
runtime += model.RunTime
assert model.Status not in [
3,
4,
], "Infeasible Model encountered in refinement"
if model.Status == 6:
print("MILP CUTOFF triggered")
lb = 0 # model.objbound if hasattr(model, "objbound") else curr_lbs[-1]
elif model.Status == 15:
print("MILP BestObjStop triggered")
lb = model.objbound if hasattr(model, "objbound") else lb
assert model.SolCount > 0
else:
lb = (
model.objbound
if hasattr(model, "objbound") and model.objbound is not None
else lb
)
if lb <= 0:
is_verified = False
if model.SolCount > 0:
print("Found Counterexample")
ctr_example = torch.tensor(
[v.x for v in model.getVars() if "input" in v.var_name]
)
lbs.append(lb)
if not is_verified:
return is_verified, lbs, ctr_example
return is_verified, lbs, None
def _get_neuron_bound(
self: MILPNetwork,
var: Any,
prior_lb: Tensor,
prior_ub: Tensor,
timeout: Optional[int],
) -> Tuple[Tensor, Tensor]:
model = self.model
ub = _solve_model_for_objective(model, var, timeout, minimize=False)
if ub is None:
ub = prior_ub
model.reset()
lb = _solve_model_for_objective(model, var, timeout, minimize=True)
if lb is None:
lb = prior_lb
model.reset()
return lb, ub
def clone(self: MILPNetwork, full: bool = True) -> MILPNetwork:
return MILPNetwork(
self.model.copy(),
self.neuron_vars,
self.net,
self.layer_id_to_prefix_map,
self.prefix_to_layer_bounds,
self.previous_layer_map,
self.input_shape,
)
def get_neuron_bound_call(ind: Tuple[int, str]) -> Tuple[Tensor, Tensor, bool, float]:
# Call solver to compute neuronwise bounds in parallel
if (
Cache.lbi is None
or Cache.ubi is None
or Cache.model is None
or Cache.time_limit is None
):
raise RuntimeError("Cache not properly set")
if Cache.terminate_time is not None and Cache.terminate_time - time.time() < 1:
return Cache.lbi[ind[0]], Cache.ubi[ind[0]], False, 0
model = Cache.model.copy()
runtime = 0
soll, m_runtime = get_neuron_bound_single(model, ind, maximize=False)
runtime += m_runtime
solu, m_runtime = get_neuron_bound_single(model, ind, maximize=True)
runtime += m_runtime
soll = max(soll, Cache.lbi[ind[0]])
solu = min(solu, Cache.ubi[ind[0]])
addtoindices = (soll > Cache.lbi[ind[0]]) or (solu < Cache.ubi[ind[0]])
return soll, solu, addtoindices, runtime
def get_neuron_bound_stable_call(
ind: Tuple[int, str]
) -> Tuple[Tensor, Tensor, bool, float]:
# Call solver to compute neuronwise bounds in parallel
if (
Cache.lbi is None
or Cache.ubi is None
or Cache.model is None
or Cache.time_limit is None
):
raise RuntimeError("Cache not properly set")
if Cache.terminate_time is not None and Cache.terminate_time - time.time() < 1:
return Cache.lbi[ind[0]], Cache.ubi[ind[0]], False, 0
model = Cache.model.copy()
runtime = 0
if torch.abs(Cache.lbi[ind[0]]) < torch.abs(Cache.ubi[ind[0]]):
soll, m_runtime = get_neuron_bound_single(
model, ind, maximize=False, use_cutoff=True
)
runtime += m_runtime
# Stable
if soll >= 0:
return soll, Cache.ubi[ind[0]], True, runtime
solu, m_runtime = get_neuron_bound_single(
model, ind, maximize=True, use_cutoff=True
)
runtime += m_runtime
else:
solu, m_runtime = get_neuron_bound_single(
model, ind, maximize=True, use_cutoff=True
)
runtime += m_runtime
# Stable
if solu <= 0:
return Cache.lbi[ind[0]], solu, True, runtime
soll, m_runtime = get_neuron_bound_single(
model, ind, maximize=False, use_cutoff=True
)
runtime += m_runtime
soll = max(soll, Cache.lbi[ind[0]])
solu = min(solu, Cache.ubi[ind[0]])
addtoindices = (soll > Cache.lbi[ind[0]]) or (solu < Cache.ubi[ind[0]])
return soll, solu, addtoindices, runtime
def get_neuron_bound_single(
model: Any, ind: Tuple[int, str], maximize: bool = False, use_cutoff: bool = False
) -> Tuple[Any, Any]:
obj: Any = LinExpr()
obj += model.getVarByName(ind[1])
assert Cache.time_limit is not None
model.setParam(
GRB.Param.TimeLimit,
max(
0,
min(
Cache.time_limit,
np.inf
if Cache.terminate_time is None
else (Cache.terminate_time - time.time()),
),
),
)
if maximize:
model.setObjective(obj, GRB.MAXIMIZE)
else:
model.setObjective(obj, GRB.MINIMIZE)
model.reset()
model._vars = model.getVarByName(ind[1])
# D = 1e-4
# model.setParam("BestObjStop", -D)
# model.setParam("CUTOFF", D)
# model.optimize()
if use_cutoff:
model.optimize(get_milp_callback_for_target_cutoff(0, maximize))
else:
model.optimize()
has_objbound = hasattr(model, "objbound")
model_bound = 0 if model.Status == 6 else (model.objbound if has_objbound else None)
assert model.Status not in [3, 4], "Infeasible Model encountered in refinement"
assert Cache.ubi is not None and Cache.lbi is not None
if maximize:
res = (
min(model_bound, Cache.ubi[ind[0]])
if model_bound is not None
else Cache.ubi[ind[0]]
)
else:
res = (
max(model_bound, Cache.lbi[ind[0]])
if model_bound is not None
else Cache.lbi[ind[0]]
)
return res, model.RunTime
def solver_query_call(
query: Tuple[int, Tuple[int, str], Tuple[int, str], float]
) -> Tuple[float, Optional[Tensor], float]:
# Solve for label_ind - other_ind - offset >= 0
query_index, label_ind, other_ind, offset = query
if (
Cache.lbi is None
or Cache.ubi is None
or Cache.model is None
or Cache.time_limit is None
):
raise RuntimeError("Cache not properly set")
if Cache.terminate_time is not None and Cache.terminate_time - time.time() < 1:
return float(Cache.lbi[query_index]), None, 0
model = Cache.model.copy()
model.setParam(
GRB.Param.TimeLimit,
max(
0,
min(
Cache.time_limit,
np.inf
if Cache.terminate_time is None
else (Cache.terminate_time - time.time()),
),
),
)
runtime = 0
obj: Any = LinExpr() - offset
obj += model.getVarByName(label_ind[1]) if label_ind[1] is not None else 0
obj += -model.getVarByName(other_ind[1]) if other_ind[1] is not None else 0
# print (f"{ind} {model.getVarByName(ind[1]).VarName}")
model.setObjective(obj, GRB.MINIMIZE)
model.reset()
model.optimize(get_milp_callback_for_target_cutoff(0, maximize=False))
runtime += model.RunTime
assert model.Status not in [3, 4], "Infeasible Model encountered in refinement"
if model.Status == 11:
print("MILP callback")
lb = model.objbound if hasattr(model, "objbound") else Cache.lbi[query_index]
else:
lb = Cache.lbi[query_index] if model.SolCount == 0 else model.objbound
ctr_example: Optional[Tensor] = None
if lb <= 0 and model.SolCount != 0:
print("Found Counterexample")
ctr_example = torch.tensor(
[v.x for v in model.getVars() if "input" in v.var_name]
)
if label_ind[0] < 0:
lb = -lb
return lb, ctr_example, runtime
def _solve_model_for_objective(
model: Any, obj: Any, timeout: Optional[int], minimize: bool = True
) -> Any:
if timeout:
model.setParam(GRB.Param.TimeLimit, timeout)
if minimize:
model.setObjective(obj, GRB.MINIMIZE)
else:
model.setObjective(obj, GRB.MAXIMIZE)
model.optimize()
if model.status in [3, 4]:
print("Infeasible model encountered - resorting to box")
return None
if hasattr(model, "objVal"):
return model.objVal
else:
return model.objbound
def get_milp_callback_for_target_cutoff(
target: float,
maximize: bool = True,
) -> Callable[[Any, Any], None]:
D = 1e-4
def milp_callback(model: Any, where: Any) -> None:
if where == GRB.Callback.MIP:
sol_count = model.cbGet(GRB.Callback.MIP_SOLCNT)
if sol_count > 0:
sol_best = model.cbGet(GRB.Callback.MIP_OBJBST)
obj_bound = model.cbGet(GRB.Callback.MIP_OBJBND)
if not maximize and (
obj_bound >= target + D or (sol_count > 0 and sol_best <= target - D)
):
# print(f"Terminated Min: {obj_bound}")
model.terminate()
elif maximize and (
obj_bound <= target - D or (sol_count > 0 and sol_best >= target + D)
):
# print(f"Terminated Max: {obj_bound}")
model.terminate()
return milp_callback
| 65,951 | 33.475693 | 105 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/verification_subproblem.py | from __future__ import annotations
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING, Dict, Optional, Tuple
import torch
from torch import Tensor
from src.state.constraints import PrimaConstraints
from src.state.split_state import SplitState
from src.state.subproblem_state import ReadonlySubproblemState, SubproblemState
from src.state.tags import LayerTag, NodeTag
from src.utilities.custom_typing import implement_properties_as_fields
if TYPE_CHECKING:
from src.abstract_layers.abstract_container_module import ActivationLayer
class ReadonlyVerificationSubproblem(ABC):
@property
@abstractmethod
def lower_bound(self) -> float:
pass
@property
@abstractmethod
def upper_bound(self) -> float:
pass
@property
@abstractmethod
def is_infeasible(self) -> bool:
pass
@property
@abstractmethod
def subproblem_state(self) -> ReadonlySubproblemState:
pass
@property
@abstractmethod
def device(self) -> torch.device:
pass
def deep_copy_to(self, device: torch.device) -> VerificationSubproblem:
return VerificationSubproblem(
self.lower_bound,
self.upper_bound,
self.subproblem_state.deep_copy_to(device),
device,
)
def deep_copy_to_no_clone(
self, device: torch.device
) -> ReadonlyVerificationSubproblem:
return VerificationSubproblem.create_readonly(
self.lower_bound,
self.upper_bound,
self.subproblem_state.deep_copy_to_no_clone(device),
device,
)
def split(
self,
node_to_split: NodeTag,
recompute_intermediate_bounds_after_branching: bool,
layer: ActivationLayer,
) -> Tuple[
ReadonlyVerificationSubproblem, ReadonlyVerificationSubproblem
]: # readonly because the resulting parameters alias the original ones
(
subproblem_state_for_negative_split,
subproblem_state_for_positive_split,
) = self.subproblem_state.split(
node_to_split,
recompute_intermediate_bounds_after_branching,
layer,
self.device,
)
negative_split_subproblem = VerificationSubproblem.create_readonly(
self.lower_bound,
self.upper_bound,
subproblem_state_for_negative_split,
self.device,
)
positive_split_subproblem = VerificationSubproblem.create_readonly(
self.lower_bound,
self.upper_bound,
subproblem_state_for_positive_split,
self.device,
)
return negative_split_subproblem, positive_split_subproblem
@property
def is_fully_split(self) -> bool:
return self.subproblem_state.is_fully_split
# for VerificationSubproblemQueue. TODO: why needed?
def get_layer_id_to_index(
self,
) -> Dict[int, int]: # TODO: this seems out of place here
return self.subproblem_state.get_layer_id_to_index()
# for VerificationSubproblemQueue. TODO: why needed?
def set_prima_coefficients(
self, prima_coefficients: Dict[LayerTag, Tuple[Tensor, Tensor, Tensor]]
) -> None: # TODO: get rid of this?
self.subproblem_state.set_prima_coefficients(prima_coefficients)
def get_prima_constraints(self) -> Optional[PrimaConstraints]:
return self.subproblem_state.get_prima_constraints()
@implement_properties_as_fields
class VerificationSubproblem(ReadonlyVerificationSubproblem):
"""
Bounds results of a batch of queries on a subproblem:
lower_bound <= min_x query_i*network(x) <= upper_bound for all i, where
the minimum is w.r.t additional Constraints stored in subproblem_state.
subproblem_state also contains Parameters that are a witness for
the given lower bound. The upper bound is typically determined using a
concrete evaluation of the neural network on an input derived from the constraints.
(The coefficients of queries are currently stored and batched separately.)
"""
lower_bound: float # TODO: add lower_bounds: Sequence[float] to support batching nicely?
upper_bound: float # TODO: add upper_bounds: Sequence[float] to support batching nicely?
subproblem_state: SubproblemState # TODO: proper support for batching
device: torch.device
@property
def is_infeasible(self) -> bool: # TODO: proper support for batching?
return all(self.subproblem_state.is_infeasible)
def __init__(
self,
lower_bound: float,
upper_bound: float,
subproblem_state: SubproblemState,
device: torch.device,
):
self.lower_bound = lower_bound
self.upper_bound = upper_bound
self.subproblem_state = subproblem_state # TODO: proper support for batching
self.device = device
self.subproblem_state.move_to(device)
@classmethod
def create_readonly(
cls,
lower_bound: float,
upper_bound: float,
subproblem_state: ReadonlySubproblemState,
device: torch.device,
) -> ReadonlyVerificationSubproblem:
assert isinstance(subproblem_state, SubproblemState)
return cls(lower_bound, upper_bound, subproblem_state, device)
@classmethod
def create_default(
cls,
lower_bound: float,
upper_bound: float,
split_state: Optional[SplitState],
optimize_prima: bool,
device: torch.device,
) -> VerificationSubproblem:
subproblem_state = SubproblemState.create_default(
split_state=split_state,
optimize_prima=optimize_prima,
batch_size=1,
device=device,
use_params=True,
)
return cls(
lower_bound,
upper_bound,
subproblem_state,
device,
)
def move_to(self, device: torch.device) -> None:
if self.device == device:
return
self.subproblem_state.move_to(device)
self.device = device
| 6,125 | 30.740933 | 93 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/branch_and_bound.py | import time
from typing import Any, Dict, Optional, OrderedDict, Sequence, Tuple
from comet_ml import Experiment # type: ignore[import]
import torch
from torch import Tensor
from tqdm import tqdm # type: ignore[import]
from src.abstract_layers.abstract_network import AbstractNetwork
from src.exceptions.verification_timeout import VerificationTimeoutException
from src.mn_bab_optimizer import MNBabOptimizer
from src.state.tags import LayerTag, NodeTag
from src.utilities.batching import batch_subproblems, unbatch_subproblems
from src.utilities.branching import make_split_index_finder
from src.utilities.config import BacksubstitutionConfig, BranchAndBoundConfig
from src.verification_subproblem import (
ReadonlyVerificationSubproblem,
VerificationSubproblem,
)
from src.verification_subproblem_queue import VerificationSubproblemQueue
class BranchAndBound:
def __init__(
self,
optimizer: MNBabOptimizer,
config: BranchAndBoundConfig,
backsubstitution_config: BacksubstitutionConfig,
device: torch.device,
):
self.optimizer = optimizer
self.config = config
self.backsubstitution_config = backsubstitution_config
self.logger = BranchAndBoundLogger()
self.device = device
self.cpu_device = torch.device("cpu")
def bound_minimum_with_branch_and_bound(
self,
property_id: str,
query_coef: Tensor,
network: AbstractNetwork,
input_lb: Tensor,
input_ub: Tensor,
early_stopping_threshold: Optional[float] = None,
timeout: float = float("inf"),
initial_bounds: Optional[OrderedDict[LayerTag, Tuple[Tensor, Tensor]]] = None,
) -> Tuple[float, float, Optional[Tensor]]:
"""
Finds (lower_bound, upper_bound) satisfying
lower_bound <= min_x query*network(x) <= upper_bound
using a branch and bound approach.
"""
assert (
query_coef.shape[0] == 1
), "Expected single query." # TODO: maybe we can batch multiple different queries?
self.logger.init_property(property_id)
start_time = time.time()
initial_bounded_problem, ub_inputs = self.optimizer.bound_root_subproblem(
input_lb,
input_ub,
network,
query_coef,
early_stopping_threshold,
timeout,
self.device,
initial_bounds=initial_bounds,
)
network.activation_layer_bounds_to_optim_layer_bounds()
self.logger.add_bounded_subproblems(property_id, 1)
initial_bounded_problem.move_to(self.cpu_device)
# Early stop for fast benchmarking
# if initial_bounded_problem.lower_bound < -7:
# return initial_bounded_problem.lower_bound
if not self.config.run_BaB:
return (
initial_bounded_problem.lower_bound,
initial_bounded_problem.upper_bound,
None,
)
if (
early_stopping_threshold is not None
and early_stopping_threshold < initial_bounded_problem.lower_bound
):
# property already shown for initial_bounded_problem
self.logger.verified_subproblem(property_id, initial_bounded_problem)
self.logger.verified(property_id, time.time() - start_time, lower_bound=0.0)
return (
initial_bounded_problem.lower_bound,
initial_bounded_problem.upper_bound,
None,
)
if (
early_stopping_threshold is not None
and initial_bounded_problem.upper_bound < early_stopping_threshold
):
# primal solution below threshold found ==> counterexample found
self.logger.counterexample(
property_id, time.time() - start_time, None, early_stopping_threshold
)
return (
initial_bounded_problem.lower_bound,
initial_bounded_problem.upper_bound,
None if ub_inputs is None else ub_inputs.view(-1, *input_lb.shape[1:]),
)
subproblems_to_be_refined = VerificationSubproblemQueue(
initial_bounded_problem,
self.config.batch_sizes,
)
split_index_finder = make_split_index_finder(
network,
self.backsubstitution_config, # TODO: should this backsubstitution config have prima hyperparameters? (does it even matter for branching score computations?)
query_coef,
initial_bounded_problem,
self.config.branching_config,
# (the following parameters are only used for filtered smart branching)
input_lb,
input_ub,
self.config.batch_sizes,
self.config.recompute_intermediate_bounds_after_branching,
self.optimizer,
)
verified_lb = float("inf") # smallest lower bound of a verified subproblem
global_lb = initial_bounded_problem.lower_bound # smallest lower bound overall
global_ub = (
initial_bounded_problem.upper_bound
) # smallest upper bound on minimum
last_time = time.time()
with tqdm(total=timeout - time.time(), bar_format="{l_bar}{bar}") as tq:
while True: # terminates via return from function
next_subproblem = subproblems_to_be_refined.peek()
assert next_subproblem is not None
unverified_lb = next_subproblem.lower_bound
global_lb = unverified_lb # unverified_lb < verified_lb
if next_subproblem.is_fully_split:
# can't improve further
self.logger.fail(property_id, time.time() - start_time)
return (global_lb, global_ub, ub_inputs)
if (
early_stopping_threshold is None and global_ub - global_lb <= 1e-5
): # round-off epsilon
self.logger.verified(
property_id, time.time() - start_time, lower_bound=0.0
) # TODO: why 0.0?
return (global_lb, global_ub, ub_inputs)
# print()
# print("global_lb:", global_lb)
# print("global_ub:", global_ub)
# print("queue length:", len(subproblems_to_be_refined))
time_remaining = timeout + start_time - time.time()
tq.set_description_str(
f"Global LB: {global_lb:.5f} | Global UB: {global_ub:.4f} | Queue Length: {len(subproblems_to_be_refined)} | Subproblems Considered: {self.logger.info['number_of_subproblems_bounded'][property_id]} | TR: {time_remaining:.2f}"
)
curr_time = time.time()
tq.update(curr_time - last_time)
last_time = curr_time
self.logger.lower_bound(property_id, global_lb)
def find_node_to_split(
subproblem: ReadonlyVerificationSubproblem,
) -> NodeTag:
node_to_split = split_index_finder.find_node_to_split(subproblem)
layer_id_to_split = node_to_split.layer
layer_index_to_split = subproblems_to_be_refined._layer_id_to_index[
layer_id_to_split
]
# print(f"splitting on layer {layer_index_to_split}")
self.logger.split_layer(layer_index_to_split)
return node_to_split
next_subproblems = subproblems_to_be_refined.pop(
find_node_to_split,
self.config.recompute_intermediate_bounds_after_branching,
network,
)
self.logger.add_to_number_of_splits(
property_id, len(next_subproblems) // 2
)
try:
bounded_subproblems, ub_inputs = self._bound_minimum_in_batch(
next_subproblems,
query_coef,
network,
input_lb,
input_ub,
early_stopping_threshold,
time_remaining,
)
self.logger.add_bounded_subproblems(
property_id, len(bounded_subproblems)
)
except VerificationTimeoutException as e:
queue_length = len(subproblems_to_be_refined)
self.logger.timeout(property_id, global_lb, global_ub, queue_length)
e.best_lb = global_lb
e.best_ub = global_ub
raise e
min_upper_bound_in_batch = min(
bounded_subproblem.upper_bound
for bounded_subproblem in bounded_subproblems
)
global_ub = min(min_upper_bound_in_batch, global_ub)
counterexample_found = (
early_stopping_threshold is not None
and global_ub < early_stopping_threshold
)
if counterexample_found:
self.logger.counterexample(
property_id,
time.time() - start_time,
bounded_subproblems,
early_stopping_threshold,
)
return (global_lb, global_ub, ub_inputs)
for bounded_subproblem in bounded_subproblems:
if (
bounded_subproblem.is_infeasible
or early_stopping_threshold is not None
and early_stopping_threshold < bounded_subproblem.lower_bound
or global_ub < bounded_subproblem.lower_bound
):
self.logger.verified_subproblem(property_id, bounded_subproblem)
verified_lb = min(verified_lb, bounded_subproblem.lower_bound)
else:
subproblems_to_be_refined.insert_sorted(bounded_subproblem)
if (
subproblems_to_be_refined.empty
): # exhausted queue, everything verified
global_lb = verified_lb
self.logger.verified(
property_id, time.time() - start_time, lower_bound=0.0
) # TODO: why 0.0?
return (global_lb, global_ub, ub_inputs)
def _bound_minimum_in_batch(
self,
subproblems: Sequence[ReadonlyVerificationSubproblem],
query_coef: Tensor,
network: AbstractNetwork,
input_lb: Tensor,
input_ub: Tensor,
early_stopping_threshold: Optional[float],
timeout: float,
) -> Tuple[Sequence[VerificationSubproblem], Tensor]:
assert all(subproblem.device == self.cpu_device for subproblem in subproblems)
subproblem_batch = batch_subproblems(
[subproblem.deep_copy_to(self.device) for subproblem in subproblems],
reuse_single_subproblem=True,
)
subproblem_state_batch = subproblem_batch.subproblem_state
query_coef = query_coef.to(self.device)
batch_size = len(subproblems)
assert subproblem_state_batch.batch_size == batch_size
batch_repeats = batch_size, *([1] * (len(query_coef.shape) - 1))
(
improved_lbs,
improved_ubs,
ub_inputs,
) = self.optimizer.improve_subproblem_batch_bounds(
subproblem_state_batch, # (updated in-place)
input_lb,
input_ub,
network,
query_coef.repeat(batch_repeats),
early_stopping_threshold,
self.config.recompute_intermediate_bounds_after_branching,
timeout,
)
result = unbatch_subproblems(
subproblem_state_batch,
improved_lbs,
improved_ubs,
reset_intermediate_layer_bounds_to_be_kept_fixed=True,
)
for subproblem in result:
subproblem.move_to(self.cpu_device)
return (result, ub_inputs)
def log_info(self, experiment_logger: Experiment) -> None:
self.logger.log_info(experiment_logger)
class BranchAndBoundLogger:
def __init__(self) -> None:
self.info: Dict[str, Any] = {
"number_of_subproblems_bounded": {},
"verification_time": {},
"total_number_of_splits": {},
"number_of_splits_per_layer": {},
"max_split_depth_needed_to_verify": {},
"split_depth_needed_for_counterexample": {},
"lower_bound_at_timeout": {},
"upper_bound_at_timeout": {},
"queue_length_at_timeout": {},
"n_subproblems_explored_to_reach_lower_bound": {},
}
def init_property(self, property_id: str) -> None:
self.info["number_of_subproblems_bounded"][property_id] = 0
self.info["total_number_of_splits"][property_id] = 0
self.info["n_subproblems_explored_to_reach_lower_bound"][property_id] = []
self.info["max_split_depth_needed_to_verify"][property_id] = 0
def add_bounded_subproblems(
self, property_id: str, num_bounded_subproblems: int
) -> None:
self.info["number_of_subproblems_bounded"][
property_id
] += num_bounded_subproblems
def lower_bound(self, property_id: str, lower_bound: float) -> None:
self.info["n_subproblems_explored_to_reach_lower_bound"][property_id].append(
(
lower_bound,
self.info["number_of_subproblems_bounded"][property_id],
)
)
def split_layer(self, layer_index_to_split: int) -> None:
n_splits = self.info["number_of_splits_per_layer"].setdefault(
layer_index_to_split, 0
)
self.info["number_of_splits_per_layer"][layer_index_to_split] = n_splits + 1
def add_to_number_of_splits(
self, property_id: str, number_of_splits: int
) -> None: # TODO: couldn't this just be counted in split_layer?
self.info["total_number_of_splits"][property_id] += number_of_splits
def verified_subproblem(
self, property_id: str, bounded_subproblem: ReadonlyVerificationSubproblem
) -> None:
if bounded_subproblem is not None:
split_depth = (
0
if bounded_subproblem.subproblem_state.constraints.split_state is None
else max(
bounded_subproblem.subproblem_state.constraints.split_state.number_of_nodes_split
)
) # TODO: ugly
else:
split_depth = 0
cur_max_split_depth = self.info["max_split_depth_needed_to_verify"][property_id]
self.info["max_split_depth_needed_to_verify"][property_id] = max(
cur_max_split_depth, split_depth
)
def verified(
self, property_id: str, verification_time: float, lower_bound: float
) -> None:
self.info["verification_time"][property_id] = verification_time
self.lower_bound(property_id, lower_bound)
def counterexample(
self,
property_id: str,
verification_time: float,
bounded_subproblems: Optional[Sequence[ReadonlyVerificationSubproblem]],
early_stopping_threshold: Optional[float],
) -> None:
print("counterexample found, stopping")
if bounded_subproblems is not None:
assert all(
subproblem.subproblem_state.constraints.split_state is not None
for subproblem in bounded_subproblems
)
depth_needed_for_counterexample = min(
n
for subproblem in bounded_subproblems
for n in subproblem.subproblem_state.constraints.split_state.number_of_nodes_split # type: ignore[union-attr] # mypy can't see split_state is not None
if early_stopping_threshold is not None
and subproblem.upper_bound < early_stopping_threshold
)
else:
depth_needed_for_counterexample = 0
self.info["split_depth_needed_for_counterexample"][
property_id
] = depth_needed_for_counterexample
del self.info["max_split_depth_needed_to_verify"][property_id]
self.info["verification_time"][property_id] = verification_time
def fail(self, property_id: str, verification_time: float) -> None:
print("failed to verify")
self.info["verification_time"][property_id] = verification_time
def timeout(
self,
property_id: str,
lower_bound: float,
upper_bound: float,
queue_length: int,
) -> None:
self.info["lower_bound_at_timeout"][property_id] = lower_bound
self.info["upper_bound_at_timeout"][property_id] = upper_bound
self.info["queue_length_at_timeout"][property_id] = queue_length
self.info["max_split_depth_needed_to_verify"][property_id] = float("inf")
self.info["number_of_subproblems_bounded"][property_id] = float("inf")
self.info["verification_time"][property_id] = float("inf")
def log_info(self, experiment_logger: Experiment) -> None:
experiment_logger.log_asset_data(self.info, name="log_info.json")
non_zero_number_of_splits = [
n_splits
for n_splits in self.info["total_number_of_splits"].values()
if n_splits != 0
]
experiment_logger.log_histogram_3d(
non_zero_number_of_splits,
step=1,
name="total_number_of_splits_if_non_zero",
)
experiment_logger.log_histogram_3d(
list(self.info["total_number_of_splits"].values()),
step=1,
name="total_number_of_splits",
)
experiment_logger.log_histogram_3d(
list(self.info["split_depth_needed_for_counterexample"].values()),
step=1,
name="split_depth_needed_for_counterexample",
)
experiment_logger.log_histogram_3d(
[
depth
for depth in self.info["max_split_depth_needed_to_verify"].values()
if depth != float("inf")
],
step=1,
name="max_split_depth_needed_to_verify",
)
non_zero_max_depth_to_verify = [
depth
for depth in self.info["max_split_depth_needed_to_verify"].values()
if depth != 0 and depth != float("inf")
]
experiment_logger.log_histogram_3d(
non_zero_max_depth_to_verify,
step=1,
name="max_split_depth_needed_to_verify_if_non_zero",
)
experiment_logger.log_histogram_3d(
list(self.info["lower_bound_at_timeout"].values()),
step=1,
name="lower_bound_at_timeout",
)
experiment_logger.log_histogram_3d(
list(self.info["upper_bound_at_timeout"].values()),
step=1,
name="upper_bound_at_timeout",
)
experiment_logger.log_histogram_3d(
list(self.info["queue_length_at_timeout"].values()),
step=1,
name="queue_length_at_timeout",
)
experiment_logger.log_histogram_3d(
self.info["number_of_splits_per_layer"],
step=1,
name="number_of_splits_per_layer",
)
| 19,760 | 39.828512 | 245 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/verify.py | import csv
import time
import sys
from comet_ml import Experiment # type: ignore[import]
import torch
from torch import nn
from src.abstract_layers.abstract_network import AbstractNetwork
from src.mn_bab_verifier import MNBaBVerifier
from src.utilities.argument_parsing import get_args, get_config_from_json
from src.utilities.config import make_config, Dtype
from src.utilities.initialization import seed_everything
from src.utilities.loading.data import transform_and_bound
from src.utilities.loading.network import freeze_network, load_net, load_onnx_model
from src.utilities.logging import Logger, get_log_file_name
from src.verification_instance import VerificationInstance
if __name__ == "__main__":
args = get_args()
config_file = get_config_from_json(args.config)
config = make_config(**config_file)
seed_everything(config.random_seed)
experiment_logger = Experiment(**config.logger.comet_options)
experiment_logger.set_name(config.experiment_name)
experiment_logger.log_parameters(config_file)
logger = Logger(get_log_file_name(args.log_prefix), sys.stdout)
sys.stdout = logger
logger.log_default(config)
if torch.cuda.is_available() and config.use_gpu:
device = torch.device("cuda")
experiment_logger.log_text("Using gpu")
experiment_logger.log_text(torch.cuda.get_device_name(0))
else:
device = torch.device("cpu")
experiment_logger.log_text("Using cpu")
net_format = config.network.path.split(".")[-1]
if net_format in ["onnx", "gz"]:
net_seq, onnx_shape, inp_name = load_onnx_model(config.network.path) # Like this for mypy
original_network: nn.Module = net_seq
if len(config.input_dim) == 0:
print(f"Setting shape: {onnx_shape}")
config.input_dim = onnx_shape
else:
original_network = load_net(**config.network.load_params())
original_network.to(device)
original_network.eval()
assert isinstance(original_network, nn.Sequential)
if config.dtype == Dtype.float64:
torch.set_default_dtype(torch.float64)
original_network = original_network.double()
else:
torch.set_default_dtype(torch.float32)
original_network = original_network.float()
network = AbstractNetwork.from_concrete_module(
original_network, config.input_dim
).to(device)
freeze_network(network)
num_classes = network.output_dim[-1]
verifier = MNBaBVerifier(network, device, config.verifier)
test_file = open(config.test_data_path, "r")
test_instances = csv.reader(test_file, delimiter=",")
total_start_time = time.time()
running_total_time = 0.0
n_correct = 0
n_verified = 0
n_disproved = 0
for i, (label, *pixel_values) in enumerate(test_instances):
label = int(label)
network.reset_input_bounds()
network.reset_output_bounds()
network.reset_optim_input_bounds()
if i < args.test_from:
continue
if args.test_num > 0 and i - args.test_from >= args.test_num:
break
input, input_lb, input_ub = transform_and_bound(pixel_values, config, device)
pred_label = torch.argmax(original_network(input)).item()
if pred_label != label:
print("Network fails on test image, skipping.\n")
continue
else:
n_correct += 1
print("=" * 20)
print("Verifying instance number:", i)
inst = VerificationInstance.create_instance_for_batch_ver(network, verifier, input, input_lb, input_ub, label, config, num_classes)
start_time = time.time()
inst.run_instance()
if inst.is_verified:
n_verified += 1
print("Verified instance: ", i)
elif inst.adv_example is not None:
n_disproved += 1
print("Disproved instance: ", i)
else:
print("Unable to verify instance: ", i)
inst.free_memory()
iteration_time = time.time() - start_time
running_total_time += iteration_time
print("Iteration time: ", iteration_time)
print("Running average verification time:", running_total_time / n_correct)
print("Correct", n_correct, "out of", i+1)
print("Verified", n_verified, "out of", n_correct-n_disproved)
print("Disproved", n_disproved, "out of", n_correct - n_verified)
print()
if not experiment_logger.disabled:
verifier.bab.log_info(experiment_logger)
print("Total time: ", time.time() - total_start_time)
| 4,578 | 35.632 | 139 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/mn_bab_verifier.py | # import itertools
import multiprocessing
import time
from typing import List, Optional, OrderedDict, Sequence, Tuple, Union
import numpy as np
import torch
import torch.nn as nn
from torch import Tensor
from tqdm import tqdm # type: ignore[import]
from src.abstract_domains.DP_f import DeepPoly_f
from src.abstract_domains.zonotope import HybridZonotope
from src.abstract_layers.abstract_network import AbstractNetwork
from src.branch_and_bound import BranchAndBound
from src.exceptions.verification_timeout import VerificationTimeoutException
from src.milp_network import MILPNetwork
from src.mn_bab_optimizer import MNBabOptimizer
from src.state.tags import LayerTag, layer_tag
from src.utilities.attacks import _evaluate_cstr, torch_whitebox_attack
from src.utilities.config import (
AbstractDomain,
DomainSplittingConfig,
MNBabVerifierConfig,
)
from src.utilities.general import (
batch_splits,
compute_initial_splits,
consolidate_input_regions,
property_matrix_from_properties,
split_input_regions,
update_propertiy_matrices,
)
from src.utilities.output_property_form import OutputPropertyForm
from src.verification_subproblem import SubproblemState
class MNBaBVerifier:
def __init__(
self,
network: AbstractNetwork,
device: torch.device,
config: MNBabVerifierConfig,
) -> None:
self.network = network
self.optimizer = MNBabOptimizer(config.optimizer, config.backsubstitution)
self.bab = BranchAndBound(
self.optimizer, config.bab, config.backsubstitution, device
)
self.config = config
self.outer = config.outer
self.domain_splitting = config.domain_splitting
assert len(self.network.output_dim) == 1
self.n_output_nodes = self.network.output_dim[0]
def _verify_property_with_abstract_element(
self,
input_lb: Tensor,
input_ub: Tensor,
property_matrix: Tensor,
early_stopping_thresholds: Tensor,
abs_domain: AbstractDomain,
compute_sensitivity: bool,
) -> Tuple[Tensor, Tensor, Tensor, Tensor, Optional[Tensor]]:
# print(
# "Verifying property_matrix\n",
# property_matrix,
# " against thresholds\n",
# early_stopping_thresholds,
# )
dtype = input_lb.dtype
# if input_lb.dim() in [1, 3]:
# input_lb, input_ub = input_lb.unsqueeze(0), input_ub.unsqueeze(0)
if abs_domain == AbstractDomain("DPF"):
input_abs_element: Union[
DeepPoly_f, HybridZonotope
] = DeepPoly_f.construct_from_bounds(
input_lb, input_ub, dtype, domain="DPF"
)
elif abs_domain in [
AbstractDomain("zono"),
AbstractDomain("box"),
AbstractDomain("hbox"),
]:
if compute_sensitivity:
center = (input_lb + input_ub) / 2.0
width = ((input_ub - input_lb) / 2.0).requires_grad_(True)
input_lb, input_ub = center - width, center + width
input_abs_element = HybridZonotope.construct_from_bounds(
input_lb, input_ub, dtype, domain=abs_domain.value
)
else:
assert False, f"Unknown abstract domain {abs_domain}"
if compute_sensitivity and abs_domain != AbstractDomain("DPF"):
with torch.enable_grad():
output_abs_element = (
self.network.set_layer_bounds_via_abstract_element_propagation(
input_abs_element,
use_existing_bounds=False,
set_input=False,
set_output=False,
)
)
(
verified,
falsified,
query_lb,
query_ub,
_,
) = output_abs_element.evaluate_queries(
property_matrix, early_stopping_thresholds
)
query_loss = (query_lb * (~verified)).sum()
query_loss.backward()
sensitivity = width.grad
else:
with torch.no_grad():
output_abs_element = (
self.network.set_layer_bounds_via_abstract_element_propagation(
input_abs_element,
use_existing_bounds=False,
activation_layer_only=True,
set_input=False,
set_output=False,
)
)
(
verified,
falsified,
query_lb,
query_ub,
query_abs_element,
) = output_abs_element.evaluate_queries(
property_matrix, early_stopping_thresholds
)
sensitivity = None
if abs_domain == AbstractDomain("DPF"):
assert isinstance(query_abs_element, DeepPoly_f)
assert query_abs_element.input_error_map is not None # type: ignore # cant recognize that this is a DeepPoly_f
sensitivity = torch.zeros_like(input_lb).flatten(1)
sensitivity[
:, query_abs_element.input_error_map # type: ignore # cant recognize that this is a DeepPoly_f
] = query_abs_element.x_l_coef.flatten( # type: ignore # cant recognize that this is a DeepPoly_f
2
).abs().sum(
2
) + query_abs_element.x_u_coef.flatten( # type: ignore # cant recognize that this is a DeepPoly_f
2
).abs().sum(
2
)
sensitivity = sensitivity.view(*input_lb.shape)
return (verified, falsified, query_lb, query_ub, sensitivity)
def _verify_output_form_with_deep_poly(
self,
input_lb: Tensor,
input_ub: Tensor,
output_form: OutputPropertyForm,
compute_sensitivity: bool,
subproblem_state: Optional[SubproblemState] = None,
reset_input_bounds: bool = True,
ibp_pass: bool = False,
) -> Tuple[OutputPropertyForm, Tensor, Tensor, Tensor, Tensor]:
# Do a simple pass on all properties
(
deep_poly_lbs,
ub_on_minimum,
ub_inputs,
sensitivity,
) = self.bab.optimizer.bound_minimum_with_deep_poly(
self.bab.optimizer.backsubstitution_config,
input_lb,
input_ub,
self.network,
output_form.property_matrix,
subproblem_state=subproblem_state,
return_tensors=True,
ibp_pass=ibp_pass,
reset_input_bounds=reset_input_bounds,
)
bounds = deep_poly_lbs - output_form.property_threshold
print(
"deep poly lower bounds:",
bounds.flatten().tolist(),
)
assert isinstance(deep_poly_lbs, Tensor)
assert isinstance(ub_on_minimum, Tensor)
verified: Tensor = deep_poly_lbs > output_form.property_threshold
falsified: Tensor = ub_on_minimum < output_form.property_threshold
# Update the output_form
updated_out_form = output_form.update_properties_to_verify(
verified,
falsified,
deep_poly_lbs,
true_ub=False,
easiest_and_first=False,
)
return (updated_out_form, bounds, verified, falsified, ub_inputs)
def _verify_query_with_deep_poly(
self,
input_lb: Tensor,
input_ub: Tensor,
property_matrix: Tensor,
early_stopping_thresholds: Tensor,
compute_sensitivity: bool,
subproblem_state: Optional[SubproblemState] = None,
ibp_pass: bool = False,
) -> Tuple[Tensor, Tensor, Tensor, Tensor, Tensor, Tensor]:
# if input_lb.dim() in [1, 3]:
# input_lb, input_ub = input_lb.unsqueeze(0), input_ub.unsqueeze(0)
(
deep_poly_lbs,
ub_on_minimum,
ub_inputs,
sensitivity,
) = self.bab.optimizer.bound_minimum_with_deep_poly(
self.bab.optimizer.backsubstitution_config,
input_lb,
input_ub,
self.network,
property_matrix,
subproblem_state=subproblem_state,
return_tensors=True,
ibp_pass=ibp_pass,
reset_input_bounds=True,
)
assert isinstance(deep_poly_lbs, Tensor)
assert isinstance(ub_on_minimum, Tensor)
verified: Tensor = deep_poly_lbs > early_stopping_thresholds - 1e-6
falsified: Tensor = ub_on_minimum < early_stopping_thresholds + 1e-6
return (
verified,
falsified,
deep_poly_lbs - early_stopping_thresholds,
ub_on_minimum - early_stopping_thresholds,
ub_inputs,
sensitivity,
)
def _verify_property_with_deep_poly(
self,
input_lb: Tensor,
input_ub: Tensor,
label: int,
competing_label: int,
early_stopping_threshold: float,
) -> Tuple[bool, Tensor, Tensor]:
with torch.no_grad():
print("Verifying label ", label, " against ", competing_label)
query_coef = torch.zeros(1, 1, self.n_output_nodes, device=input_lb.device)
query_coef.data[0, 0, label] = 1
query_coef.data[0, 0, competing_label] = -1
subproblem_state = SubproblemState.create_default(
split_state=None,
optimize_prima=False,
batch_size=1,
device=input_lb.device,
use_params=False,
)
(
verified,
falsified,
deep_poly_lbs,
deep_poly_ubs,
ub_inputs,
_,
) = self._verify_query_with_deep_poly(
input_lb,
input_ub,
query_coef,
early_stopping_threshold
* torch.ones(
query_coef.shape[:-1],
device=query_coef.device,
dtype=query_coef.dtype,
),
compute_sensitivity=False,
subproblem_state=subproblem_state,
ibp_pass=True,
)
print("deep poly lower bounds:", deep_poly_lbs[0])
return (
bool(verified[0]),
deep_poly_lbs,
deep_poly_ubs,
)
def _conduct_input_domain_splitting(
self,
domain_splitting: DomainSplittingConfig,
queue: List[
Tuple[
Tensor,
Tensor,
Tuple[Tensor, Tensor, Tensor],
int,
Optional[Sequence[Sequence[Tuple[int, int, float]]]],
]
],
time_out: float,
properties_to_verify: Optional[Sequence[Sequence[Tuple[int, int, float]]]],
) -> Tuple[
List[
Tuple[
Tensor,
Optional[Tensor],
Optional[Tuple[Tensor, Tensor, Tensor]],
int,
Optional[Sequence[Sequence[Tuple[int, int, float]]]],
]
],
Tensor,
]:
total_regions_considered = 0
n_ver = 0
out_queue: List[
Tuple[
Tensor,
Tensor,
Tuple[Tensor, Tensor, Tensor],
int,
Optional[Sequence[Sequence[Tuple[int, int, float]]]],
]
] = []
query_lb_global = (
torch.ones([1], dtype=queue[0][0].dtype, device=queue[0][0].device)
* torch.inf
)
pbar = tqdm()
while len(queue) > 0:
if time.time() > time_out:
print(
f"Input domain splitting timed out with queue length: {len(queue)}."
)
return list(queue + out_queue), query_lb_global
length = len(queue)
(
input_lb,
input_ub,
property_matrix,
property_threshold,
combination_matrix,
max_depth,
properties_to_verify_batch,
) = batch_splits(queue, domain_splitting.batch_size)
self.network.reset_input_bounds()
self.network.reset_output_bounds()
total_regions_considered += max_depth.shape[0]
sensitivity: Optional[Tensor] = None
if domain_splitting.domain == AbstractDomain("dp"):
(
ids_verified,
ids_falsified,
query_lb,
query_ub,
ub_inputs,
sensitivity,
) = self._verify_query_with_deep_poly(
input_lb,
input_ub,
property_matrix,
property_threshold,
compute_sensitivity=True,
subproblem_state=SubproblemState.create_default(
split_state=None,
optimize_prima=False,
batch_size=input_lb.shape[0],
device=input_lb.device,
use_params=False,
),
ibp_pass=True,
)
else:
(
ids_verified,
ids_falsified,
query_lb,
query_ub,
sensitivity,
) = self._verify_property_with_abstract_element(
input_lb,
input_ub,
property_matrix,
property_threshold,
abs_domain=domain_splitting.domain,
compute_sensitivity=True,
)
ub_inputs = None
(region_verified, region_falsified,) = update_propertiy_matrices(
ids_verified,
ids_falsified,
property_matrix,
property_threshold,
combination_matrix,
true_ub=domain_splitting.domain != AbstractDomain("dp"),
)
pbar.set_description(
f"queue length: {length} | verified regions: {n_ver} | mean remaining depth: {max_depth.float().mean().cpu().item():.4f} | mean lb: {query_lb.mean():.5f} | mean ub: {query_ub.mean():.5f} | TR: {time_out - time.time():.2f}"
)
if properties_to_verify is not None:
if ub_inputs is None:
adv_candidate = (input_lb + input_ub) / 2
else:
adv_candidate = ub_inputs.view(-1, *input_lb.shape[1:])
adv_found = ~_evaluate_cstr(
properties_to_verify,
self.network(adv_candidate).cpu().detach(),
torch_input=True,
)
if adv_found.any():
adv_idx = int(torch.tensor(adv_found).int().argmax().item())
adv_example = adv_candidate[adv_idx : adv_idx + 1]
return [
(adv_example, None, None, -1, properties_to_verify)
], query_lb_global
for batch_idx in range(ids_verified.shape[0]):
if region_verified[batch_idx]:
n_ver += 1
if query_lb.shape[1] == 1:
query_lb_global = torch.minimum(
query_lb_global, query_lb[batch_idx]
)
# width = input_ub[batch_idx] - input_lb[batch_idx]
# corners = input_lb[batch_idx] + torch.tensor(list(itertools.product([0,1], repeat = width.shape[-1])), dtype=input_lb.dtype, device=input_lb.device) * width
# assert _evaluate_cstr(properties_to_verify, self.network(corners).cpu().detach(), torch_input=True).all()
else:
if properties_to_verify_batch[batch_idx] is not None:
if ub_inputs is None:
adv_candidate = (
input_lb[batch_idx : batch_idx + 1]
+ input_ub[batch_idx : batch_idx + 1]
) / 2
else:
adv_candidate = ub_inputs[batch_idx].view(
-1, *input_lb.shape[1:]
)
adv_found = ~_evaluate_cstr(
properties_to_verify_batch[batch_idx], # type: ignore # mypy can't parse condition
self.network(adv_candidate).cpu().detach(),
torch_input=True,
)
if adv_found.any():
return [
(
adv_candidate,
None,
None,
-1,
properties_to_verify_batch[batch_idx],
)
], query_lb_global
if max_depth[batch_idx] == 0:
out_queue += [
(
input_lb[batch_idx : batch_idx + 1],
input_ub[batch_idx : batch_idx + 1],
(
property_matrix[batch_idx : batch_idx + 1],
property_threshold[batch_idx : batch_idx + 1],
combination_matrix[batch_idx : batch_idx + 1],
),
0,
properties_to_verify_batch[batch_idx],
)
]
continue
width = input_ub[batch_idx] - input_lb[batch_idx]
assert sensitivity is not None
split_dim = int(
((sensitivity[batch_idx].abs().sum(0) + 1e-5) * width)
.argmax()
.item()
)
new_input_regions = split_input_regions(
[
(
input_lb[batch_idx : batch_idx + 1],
input_ub[batch_idx : batch_idx + 1],
)
],
dim=split_dim,
splits=domain_splitting.split_factor,
)
queue = [
(
input_region[0],
input_region[1],
(
property_matrix[batch_idx : batch_idx + 1],
property_threshold[batch_idx : batch_idx + 1],
combination_matrix[batch_idx : batch_idx + 1],
),
int(max_depth[batch_idx] - 1),
properties_to_verify_batch[batch_idx],
)
for input_region in new_input_regions
] + queue
print(f"A total of {total_regions_considered} regions considered.")
return list(out_queue), query_lb_global
def _verify_with_input_domain_splitting(
self,
domain_splitting: DomainSplittingConfig,
input_lb: Tensor,
input_ub: Tensor,
properties_to_verify: List[List[Tuple[int, int, float]]],
time_out: float,
) -> Tuple[
List[
Tuple[
Tensor,
Optional[Tensor],
Optional[Tuple[Tensor, Tensor, Tensor]],
int,
Optional[Sequence[Sequence[Tuple[int, int, float]]]],
]
],
Tensor,
]:
num_classes = self.network.output_dim[-1]
(
property_matrix,
property_threshold,
combination_matrix,
) = property_matrix_from_properties(
properties_to_verify, num_classes, input_lb.device, input_lb.dtype
)
queue: List[
Tuple[
Tensor,
Tensor,
Tuple[Tensor, Tensor, Tensor],
int,
Optional[Sequence[Sequence[Tuple[int, int, float]]]],
]
] = compute_initial_splits(
input_lb,
input_ub,
property_matrix,
property_threshold,
combination_matrix,
domain_splitting,
)
return self._conduct_input_domain_splitting(
domain_splitting, queue, time_out, properties_to_verify
)
# TODO Remove
def _verify_output_form_with_bab(
self,
output_form: OutputPropertyForm,
input_lb: Tensor,
input_ub: Tensor,
sample_id: int,
properties_to_verify_orig: List[List[Tuple[int, int, float]]],
timeout: float,
) -> Tuple[
bool,
Optional[List[np.ndarray]],
Optional[List[Tuple[int, int, float]]],
Optional[float],
Optional[float],
]:
unit_clauses = output_form.properties_to_verify
for const_list in unit_clauses:
# TODO add sorting by dp bounds
is_verified = False
pot_ub_inputs: Optional[Tensor] = None
for gt_tuple in const_list:
if is_verified:
break
if time.time() > timeout:
print("Verification timed out.")
return (False, None, const_list, -float("inf"), float("inf"))
property_id = f"sample_{str(sample_id)}_gt_tuple_{gt_tuple[0]}_{gt_tuple[1]}_{gt_tuple[2]}"
time_remaining = timeout - time.time()
is_verified, best_lb, best_ub, pot_ub_inputs = self.verify_property(
property_id,
input_lb,
input_ub,
gt_tuple,
time_remaining,
)
if pot_ub_inputs is not None:
adv_found = ~_evaluate_cstr(
properties_to_verify_orig,
self.network(pot_ub_inputs).detach().cpu(),
torch_input=True,
)
if adv_found.any():
print("Adex found via BaB")
bab_adv_example = pot_ub_inputs[
int(torch.tensor(adv_found).int().argmax().item())
].unsqueeze(0)
return (
False,
[np.array(bab_adv_example.cpu())],
const_list,
None,
None,
)
if not is_verified:
return (
False,
None,
const_list,
best_lb,
best_ub,
) # TODO: reconstruct adversarial example?
return (True, None, None, 0, float("inf"))
# TODO Remove
def verify(
self,
sample_id: int,
input: Tensor,
input_lb: Tensor,
input_ub: Tensor,
label: int,
timeout: float,
num_classes: int = 10,
) -> Tuple[bool, bool]: # (verified, disproved)
start_time = time.time()
def generate_constraints(
class_num: int, y: int
) -> Sequence[Sequence[Tuple[int, int, float]]]:
# Constraints is an "and" list of "or" clauses each of the format y[j]-y[i] > c with (i,j,c)
return [[(y, i, 0.0)] for i in range(class_num) if i != y]
properties_to_verify = []
for constraint_list in generate_constraints(num_classes, int(label)):
true_label, competing_label, early_stopping_threshold = constraint_list[0]
# TODO correctly handle list of "or" properties
(dp_verified, dp_lbs, dp_ubs) = self._verify_property_with_deep_poly(
input_lb,
input_ub,
true_label,
competing_label,
early_stopping_threshold,
)
if not dp_verified:
properties_to_verify.append(constraint_list)
if not properties_to_verify:
# All properties already verified
return True, False
adversarial_example, __ = torch_whitebox_attack(
self.network,
input_lb.device,
input,
properties_to_verify,
input_lb,
input_ub,
restarts=5,
)
if adversarial_example is not None:
return False, True
for constraint_list in properties_to_verify:
verified = False
for gt_tuple in constraint_list:
if verified:
break
if time.time() - start_time > timeout:
print("Verification timed out.")
return False, False
property_id = f"sample_{str(sample_id)}_gt_tuple_{gt_tuple[0]}_{gt_tuple[1]}_{gt_tuple[2]}"
time_remaining = timeout - (time.time() - start_time)
verified, lb, ub, ub_inputs = self.verify_property(
property_id,
input_lb,
input_ub,
gt_tuple,
time_remaining,
)
if ub_inputs is not None:
adv_found = ~_evaluate_cstr(
properties_to_verify,
self.network(ub_inputs).detach().cpu(),
torch_input=True,
)
if adv_found.any():
print("Adex found via BaB")
# adv_bab_example = ub_inputs[
# int(torch.tensor(adv_found).int().argmax().item())
# ].unsqueeze(0)
return False, True
return verified, False
def verify_property(
self,
property_id: str,
input_lb: Tensor,
input_ub: Tensor,
gt_tuple: Tuple[int, int, float],
timeout: float,
initial_bounds: Optional[OrderedDict[LayerTag, Tuple[Tensor, Tensor]]] = None,
) -> Tuple[bool, float, float, Optional[Tensor]]:
print("Verifying gt tuple ", gt_tuple)
query_coef = torch.zeros(1, 1, self.n_output_nodes)
early_stopping_threshold = gt_tuple[2] * (-1 if gt_tuple[0] == -1 else 1)
if gt_tuple[0] != -1:
query_coef[0, 0, gt_tuple[0]] = 1
if gt_tuple[1] != -1:
query_coef[0, 0, gt_tuple[1]] = -1
return self.verify_query(
property_id,
input_lb,
input_ub,
query_coef,
early_stopping_threshold,
timeout,
adapter=None,
initial_bounds=initial_bounds,
)
def verify_query(
self,
property_id: str,
input_lb: Tensor,
input_ub: Tensor,
query_coef: Tensor,
early_stopping_threshold: float,
timeout: float,
adapter: Optional[nn.Sequential] = None,
initial_bounds: Optional[OrderedDict[LayerTag, Tuple[Tensor, Tensor]]] = None,
) -> Tuple[bool, float, float, Optional[Tensor]]:
print("Verifying query ", property_id)
try:
if self.network.has_output_adapter:
self.bab.config.batch_sizes = tuple( # type:ignore [assignment]
list(self.bab.config.batch_sizes)
+ [self.bab.config.batch_sizes[-1]]
)
(
property_lb,
property_ub,
ub_inputs,
) = self.bab.bound_minimum_with_branch_and_bound(
property_id,
query_coef,
self.network,
input_lb,
input_ub,
early_stopping_threshold=early_stopping_threshold,
timeout=timeout,
initial_bounds=initial_bounds,
)
if self.network.has_output_adapter:
self.bab.config.batch_sizes = self.bab.config.batch_sizes[:-1]
return (
property_lb >= early_stopping_threshold,
property_lb,
property_ub,
ub_inputs,
)
except VerificationTimeoutException as e:
print(f"Verification of property {property_id} timed out")
lb = e.best_lb
ub = e.best_ub
assert lb is not None and ub is not None
return False, lb, ub, None
def verify_via_config( # noqa C901 # ignore too complex function
self,
sample_id: int,
input: Tensor,
input_lb: Tensor,
input_ub: Tensor,
output_form: OutputPropertyForm,
# properties_to_verify: List[List[Tuple[int, int, float]]],
timeout: float = 400.0 + time.time(),
) -> Tuple[
bool,
Optional[List[np.ndarray]],
Optional[List[Tuple[int, int, float]]],
Optional[float],
Optional[float],
]:
if not output_form.properties_to_verify:
return True, None, None, None, None
properties_to_verify_orig = output_form.properties_to_verify.copy()
self.network.reset_input_bounds()
self.network.reset_optim_input_bounds()
if self.outer.forward_dp_pass:
with torch.no_grad():
self.network.set_layer_bounds_via_forward_dp_pass(
self.config.backsubstitution,
input_lb=input_lb,
input_ub=input_ub,
timeout=0.8 * (timeout - time.time()) + time.time(),
)
self.network.activation_layer_bounds_to_optim_layer_bounds()
if self.outer.initial_dp:
(
dp_out_prop_form,
bounds,
verified,
falsified,
ub_inputs,
) = self._verify_output_form_with_deep_poly(
input_lb,
input_ub,
output_form,
compute_sensitivity=False,
subproblem_state=SubproblemState.create_default(
split_state=self.network.get_default_split_state(
batch_size=input_lb.shape[0], device=input_lb.device
),
optimize_prima=False,
batch_size=1,
device=input_lb.device,
use_params=False,
),
reset_input_bounds=not self.outer.forward_dp_pass,
ibp_pass=True,
)
if falsified.any():
property_falsified = ~_evaluate_cstr(
properties_to_verify_orig,
self.network(ub_inputs[falsified]).cpu().detach().numpy(),
)
if property_falsified.any():
print("Adex found via initial DP")
adv_example = ub_inputs[falsified][
int(torch.tensor(property_falsified).int().argmax())
].view_as(input_lb)
return (False, [np.array(adv_example.cpu())], None, None, None)
output_form = dp_out_prop_form
properties_to_verify = output_form.properties_to_verify
if not properties_to_verify:
return (True, None, None, 0, 0)
if self.outer.adversarial_attack:
adversarial_example, __ = torch_whitebox_attack(
self.network,
input_lb.device,
input,
properties_to_verify,
input_lb,
input_ub,
restarts=self.outer.adversarial_attack_restarts,
)
if adversarial_example is not None:
selected_adv_example = (
torch.tensor(adversarial_example[0])
.unsqueeze(0)
.to(input_lb.device)
)
assert ~_evaluate_cstr(
properties_to_verify_orig,
self.network(selected_adv_example).cpu().detach().numpy(),
)
return (False, [selected_adv_example], None, None, None)
if (
self.outer.milp_config.refine_via_milp > 0
and not self.outer.milp_config.solve_via_milp
):
milp_cfg = self.outer.milp_config
if milp_cfg.pre_refine_via_ab_prima:
# Dummy root subproblem bounding to reduce #unstable_neurons
gt_tuple = properties_to_verify[0][0]
query_coef = torch.zeros(1, 1, self.n_output_nodes)
early_stopping_threshold = gt_tuple[2]
if gt_tuple[0] != -1:
query_coef[0, 0, gt_tuple[0]] = 1
if gt_tuple[1] != -1:
query_coef[0, 0, gt_tuple[1]] = -1
_, adex_candidate = self.optimizer.bound_root_subproblem(
input_lb,
input_ub,
self.network,
query_coef,
early_stopping_threshold,
timeout,
input_lb.device,
)
if adex_candidate is not None and ~_evaluate_cstr(
properties_to_verify_orig,
self.network(adex_candidate.to(device=input_lb.device))
.cpu()
.detach()
.numpy(),
):
print("Adex found via MILP refine")
return (
False,
[np.array(adex_candidate.cpu())],
None,
None,
None,
)
milp_timeout = (
min(time.time() + milp_cfg.timeout_refine_total, timeout)
if milp_cfg.timeout_refine_total
else timeout
)
milp_instance_timeout = (
milp_cfg.timeout_refine_neuron
if milp_cfg.timeout_refine_neuron
else milp_timeout
)
for i, act_layer_id in enumerate(self.network.get_activation_layer_ids()):
if i >= milp_cfg.refine_via_milp:
break
if i == 0:
continue
layer = self.network.layer_id_to_layer[act_layer_id]
model = (
MILPNetwork.build_model_from_abstract_net( # Build restricted model
(input_lb + input_ub) / 2,
input_lb,
input_ub,
self.network,
up_to_layer_id=act_layer_id,
)
)
layer.optim_input_bounds = model.get_network_bounds_at_layer_multi(
layer_tag(layer),
compute_input_bounds=True,
timeout_per_instance=milp_instance_timeout,
timeout=milp_timeout,
NUMPROCESSES=multiprocessing.cpu_count(),
refine_only_unstable=milp_cfg.refine_only_unstable,
)
assert layer.optim_input_bounds is not None
assert layer.input_bounds is not None
layer.optim_input_bounds = (
layer.optim_input_bounds[0]
.view_as(layer.input_bounds[0])
.to(input_lb.device),
layer.optim_input_bounds[1]
.view_as(layer.input_bounds[1])
.to(input_lb.device),
)
if layer.input_bounds is not None:
unstable_before = (
(layer.input_bounds[0] * layer.input_bounds[1] < 0)
.float()
.sum()
)
unstable_after = (
(layer.optim_input_bounds[0] * layer.optim_input_bounds[1] < 0)
.float()
.sum()
)
print(f"Before: {unstable_before} After: {unstable_after}")
if self.outer.milp_config.solve_via_milp:
batched_input_lb = input_lb
batched_input_ub = input_ub
model = MILPNetwork.build_model_from_abstract_net( # Build restricted model
(batched_input_lb + batched_input_ub) / 2,
batched_input_lb,
batched_input_ub,
self.network,
)
is_verified, _, counter_example = model.verify_properties(
properties_to_verify,
timeout_per_instance=timeout,
timeout_total=timeout,
start_time=time.time(),
NUMPROCESSES=multiprocessing.cpu_count(),
)
if not is_verified:
if counter_example is not None:
counter_example = counter_example[: input_lb.numel()].view_as(
input_lb
)
assert ~_evaluate_cstr(
properties_to_verify_orig,
self.network(counter_example.to(device=input_lb.device))
.cpu()
.detach()
.numpy(),
)
print("Adex found via MILP")
return (
is_verified,
[np.array(counter_example.cpu())],
None,
None,
None,
)
return is_verified, None, None, None, None
if self.outer.input_domain_splitting:
queue, _ = self._verify_with_input_domain_splitting(
self.domain_splitting,
input_lb.clone(),
input_ub.clone(),
properties_to_verify,
timeout,
)
if len(queue) == 0:
return (True, None, None, 0, 0)
elif len(queue) == 1 and queue[0][-2] == -1:
# counterexample region returned
adv_example = queue[0][0]
out = self.network(adv_example)
assert (
(input_lb <= adv_example + 1e-8)
.__and__(input_ub >= adv_example - 1e-8)
.all()
)
if not _evaluate_cstr(
properties_to_verify_orig, out.detach(), torch_input=True
):
print("Adex found via splitting")
return (False, [np.array(adv_example.cpu())], None, None, None)
else:
assert False, "should have been a counterexample"
else:
has_no_x1 = None in [x[1] for x in queue]
assert not has_no_x1, "x[1] not set for value in queue"
input_lb, input_ub = consolidate_input_regions(
[(x[0], x[1]) for x in queue if x[1] is not None]
)
self.network.reset_input_bounds()
if time.time() > timeout:
return False, None, None, None, None
return self._verify_output_form_with_bab(
output_form,
input_lb,
input_ub,
sample_id,
properties_to_verify_orig,
timeout,
)
def verify_unet_via_config( # noqa C901 # ignore too complex function
self,
sample_id: int,
input: Tensor,
input_lb: Tensor,
input_ub: Tensor,
output_form: OutputPropertyForm,
verification_target: int,
# properties_to_verify: List[List[Tuple[int, int, float]]],
timeout: float = 400.0 + time.time(),
) -> Tuple[
bool,
Optional[List[np.ndarray]],
Optional[List[Tuple[int, int, float]]],
Optional[float],
Optional[float],
]:
verified_so_far = 0
given_up_on_so_far = 0
properties_to_verify_orig = output_form.properties_to_verify.copy()
remaining = len(properties_to_verify_orig)
self.network.reset_input_bounds()
if self.outer.forward_dp_pass:
with torch.no_grad():
self.network.set_layer_bounds_via_forward_dp_pass(
self.config.backsubstitution,
input_lb=input_lb,
input_ub=input_ub,
timeout=0.8 * (timeout - time.time()) + time.time(),
)
self.network.activation_layer_bounds_to_optim_layer_bounds()
if self.outer.initial_dp:
sub_state = SubproblemState.create_default(
split_state=None,
optimize_prima=False,
batch_size=1,
device=input_lb.device,
use_params=False,
)
sub_state.constraints.layer_bounds.improve(
self.network.get_current_intermediate_bounds()
)
(
dp_out_prop_form,
bounds,
verified,
falsified,
ub_inputs,
) = self._verify_output_form_with_deep_poly(
input_lb,
input_ub,
output_form,
compute_sensitivity=False,
subproblem_state=sub_state,
reset_input_bounds=True,
ibp_pass=True,
)
verified_so_far += int(verified.float().sum().item())
given_up_on_so_far += int(falsified.float().sum().item())
remaining -= verified_so_far + given_up_on_so_far
if (
given_up_on_so_far
>= len(properties_to_verify_orig) - verification_target
):
incorrect_pixels = (
self.network(ub_inputs.view(-1, *input.shape[1:])[:, :3])
.view(-1, 2, *input.shape[2:])
.argmax(1)
!= input[:, 3]
).sum((1, 2))
max_incorrect_pixels, adv_id = incorrect_pixels.max(0)
if (
max_incorrect_pixels
> len(properties_to_verify_orig) - verification_target
):
print(f"Found adv example for UNET")
return (
False,
[
np.array(
ub_inputs.view(-1, *input.shape[1:])[
adv_id : adv_id + 1
].cpu()
)
],
None,
None,
None,
)
output_form = output_form.update_properties_to_verify(
verified,
falsified,
query_lbs=bounds,
true_ub=False,
ignore_and_falsified=True,
easiest_and_first=True,
)
if verified_so_far >= verification_target:
return (True, None, None, 0, 0)
initial_bounds = self.network.get_current_intermediate_bounds()
# Sort properties by dp bound
# assert unit_bounds is not None
unit_clauses = output_form.get_unit_clauses()
# assert len(unit_clauses) == len(unit_bounds)
bound_clause = unit_clauses # list(zip(unit_bounds, unit_clauses))
# bound_clause.sort(key=lambda x: x[0], reverse=True)
for clause_id, const_list in bound_clause:
print(
f"Verified so far: {verified_so_far} - Target: {verification_target} - Gap: {verification_target -verified_so_far} - Remaining: {remaining}"
)
is_verified = False
for gt_tuple in const_list:
if time.time() > timeout:
print("Verification timed out.")
return (
verified_so_far >= verification_target,
None,
const_list,
-float("inf"),
float("inf"),
)
property_id = f"sample_{str(sample_id)}_gt_tuple_{gt_tuple[0]}_{gt_tuple[1]}_{gt_tuple[2]}"
time_remaining = timeout - time.time()
time_budget = max(
3,
int(
min(
2
* time_remaining
/ (verification_target - verified_so_far + 1)
* remaining
/ (remaining + verified_so_far - verification_target + 1),
time_remaining / min(3, remaining),
)
),
)
is_verified, best_lb, best_ub, pot_ub_inputs = self.verify_property(
property_id,
input_lb,
input_ub,
gt_tuple,
time_budget,
initial_bounds=initial_bounds,
)
remaining -= 1
if is_verified:
verified_so_far += 1
break
else:
given_up_on_so_far += 1
if verified_so_far >= verification_target:
break
return (
verified_so_far >= verification_target,
None,
None,
-float("inf"),
float("inf"),
)
def append_out_adapter(
self,
disjunction_adapter: nn.Sequential,
device: torch.device,
dtype: torch.dtype,
) -> None:
self.network.append_out_adapter(disjunction_adapter, device, dtype)
self.n_output_nodes = self.network.output_dim[0]
def remove_out_adapter(self) -> None:
self.network.remove_out_adapter()
self.n_output_nodes = self.network.output_dim[0]
| 47,627 | 36.296789 | 238 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/mn_bab_optimizer.py | from __future__ import annotations
import time
from typing import List, Optional, OrderedDict, Sequence, Tuple, Union
import numpy as np
import torch
from torch import Tensor, optim
from torch.optim import Optimizer
from src.abstract_domains.DP_f import DeepPoly_f
from src.abstract_domains.zonotope import HybridZonotope
from src.abstract_layers.abstract_network import AbstractNetwork
from src.exceptions.verification_timeout import VerificationTimeoutException
from src.mn_bab_shape import MN_BaB_Shape
from src.state.tags import LayerTag, query_tag
from src.utilities.config import (
AbstractDomain,
BacksubstitutionConfig,
IntermediateBoundsMethod,
MNBabOptimizerConfig,
)
from src.utilities.general import any_smaller
from src.verification_subproblem import SubproblemState, VerificationSubproblem
class MNBabOptimizer:
def __init__(
self,
config: MNBabOptimizerConfig,
backsubstitution_config: BacksubstitutionConfig,
) -> None:
assert not ( # TODO: ensure this by freezing the config?
config.prima.optimize and not config.alpha.optimize
), "If you optimize prima constraints, you also have to optimize alpha."
self.config = config
self.backsubstitution_config = backsubstitution_config
def bound_root_subproblem( # noqa: C901 # TODO: simplify function
self,
input_lb: Tensor,
input_ub: Tensor,
network: AbstractNetwork,
query_coef: Tensor,
early_stopping_threshold: Optional[float] = None,
timeout: float = float("inf"),
device: torch.device = torch.device("cpu"),
initial_bounds: Optional[OrderedDict[LayerTag, Tuple[Tensor, Tensor]]] = None,
) -> Tuple[VerificationSubproblem, Optional[Tensor]]:
backsubstitution_config = self.backsubstitution_config
if self.config.parameter_sharing_config.reduce_parameter_sharing:
layer_ids_for_which_to_reduce_parameter_sharing: Sequence[
LayerTag
] = network.get_activation_layer_ids()
if self.config.parameter_sharing_layer_id_filter is not None:
layer_ids_for_which_to_reduce_parameter_sharing = (
self.config.parameter_sharing_layer_id_filter.filter_layer_ids(
layer_ids_for_which_to_reduce_parameter_sharing
)
)
backsubstitution_config = self.backsubstitution_config.with_parameter_sharing(
parameter_sharing_config=self.config.parameter_sharing_config,
layer_ids_for_which_to_reduce_parameter_sharing=layer_ids_for_which_to_reduce_parameter_sharing,
)
start_time = time.time()
assert query_coef.shape[0] == 1, "Expected single query for root subproblem."
query_coef = query_coef.to(device)
network.reset_input_bounds()
root_subproblem_state = SubproblemState.create_default(
split_state=network.get_default_split_state(batch_size=1, device=device),
optimize_prima=self.config.prima.optimize,
batch_size=1,
device=device,
use_params=False,
)
if self.backsubstitution_config.domain_pass != AbstractDomain("none"):
if self.backsubstitution_config.domain_pass == AbstractDomain("DPF"):
input_abs_element: Union[
DeepPoly_f, HybridZonotope, None
] = DeepPoly_f.construct_from_bounds(
input_lb, input_ub, input_ub.dtype, domain="DPF"
)
elif self.backsubstitution_config.domain_pass in [
AbstractDomain("zono"),
AbstractDomain("box"),
AbstractDomain("hbox"),
]:
input_abs_element = HybridZonotope.construct_from_bounds(
input_lb,
input_ub,
input_ub.dtype,
domain=self.backsubstitution_config.domain_pass.value,
)
else:
input_abs_element = None
if input_abs_element is not None:
with torch.no_grad():
network.set_layer_bounds_via_abstract_element_propagation(
input_abs_element,
activation_layer_only=True,
set_input=True,
set_output=False,
)
root_subproblem_state.constraints.layer_bounds.improve(
network.get_current_intermediate_bounds()
)
root_subproblem_state.constraints.layer_bounds.improve(
network.get_current_optimized_intermediate_bounds()
)
root_subproblem_state.constraints.update_split_constraints(
network.get_relu_layer_ids(),
root_subproblem_state.constraints.layer_bounds.intermediate_bounds,
)
# TODO @Mark This could be removed right now, correct?
if initial_bounds is not None:
root_subproblem_state.constraints.layer_bounds.improve(initial_bounds)
(
deep_poly_lbs,
deep_poly_ubs,
deep_poly_ub_inputs,
_,
) = self.bound_minimum_with_deep_poly(
backsubstitution_config,
input_lb,
input_ub,
network,
query_coef,
subproblem_state=root_subproblem_state,
reset_input_bounds=True,
ibp_pass=self.backsubstitution_config.box_pass,
)
deep_poly_ub_inputs = deep_poly_ub_inputs.view(-1, *input_lb.shape[1:])
root_subproblem_state.parameters.use_params = True
assert not root_subproblem_state.constraints.is_infeasible.any()
assert isinstance(deep_poly_lbs, Sequence)
assert isinstance(deep_poly_ubs, Sequence)
assert len(deep_poly_lbs) == len(deep_poly_lbs) == 1
print("deep poly lower bounds:", deep_poly_lbs)
if root_subproblem_state.constraints.split_state is not None:
print(
f"Unstable neurons post DP: {sum([(x==0).sum().item() for x in root_subproblem_state.constraints.split_state.split_constraints.values()])}"
)
# root node is never infeasible
invalid_bounds_mask_root: Sequence[bool] = [False]
if self._can_stop_early(
deep_poly_lbs,
deep_poly_ubs,
early_stopping_threshold,
invalid_bounds_mask_root,
):
return (
VerificationSubproblem.create_default(
deep_poly_lbs[0],
deep_poly_ubs[0],
split_state=None,
optimize_prima=False,
device=device,
),
deep_poly_ub_inputs,
)
root_subproblem_state.constraints.layer_bounds.improve(
network.get_current_intermediate_bounds()
)
if self.config.alpha.optimize:
time_remaining = (start_time + timeout) - time.time()
(alpha_lbs, alpha_ubs, alpha_ub_inputs) = self._bound_minimum_optimizing_alpha(
backsubstitution_config,
root_subproblem_state, # updated in place
input_lb,
input_ub,
network,
query_coef,
opt_iterations=self.config.alpha.opt_iterations,
early_stopping_threshold=early_stopping_threshold,
timeout=time_remaining,
reset_input_bounds=True,
)
assert not root_subproblem_state.constraints.is_infeasible.any()
assert len(alpha_lbs) == len(alpha_ubs) == 1
print("alpha lower bounds:", alpha_lbs)
if root_subproblem_state.constraints.split_state is not None:
print(
f"Unstable neurons post alpha: {sum([(x == 0).sum().item() for x in root_subproblem_state.constraints.split_state.split_constraints.values()])}"
)
root_subproblem_state.constraints.layer_bounds.improve(
network.get_current_intermediate_bounds()
)
if self._can_stop_early(
alpha_lbs,
alpha_ubs,
early_stopping_threshold,
invalid_bounds_mask_root,
):
return (
VerificationSubproblem.create_default(
alpha_lbs[0],
alpha_ubs[0],
split_state=None,
optimize_prima=False,
device=device,
),
alpha_ub_inputs,
)
if self.config.prima.optimize:
time_remaining = (start_time + timeout) - time.time()
(
prima_lbs,
prima_ubs,
prima_ub_inputs,
) = self._bound_minimum_optimizing_alpha_prima(
backsubstitution_config,
root_subproblem_state, # updated in place
input_lb,
input_ub,
network,
query_coef,
opt_iterations=self.config.prima.opt_iterations,
early_stopping_threshold=early_stopping_threshold,
timeout=time_remaining,
reset_input_bounds=True,
)
assert len(prima_lbs) == len(prima_ubs) == 1
assert not root_subproblem_state.constraints.is_infeasible.any()
print("prima lower bounds:", prima_lbs)
if root_subproblem_state.constraints.split_state is not None:
print(
f"Unstable neurons post prima: {sum([(x == 0).sum().item() for x in root_subproblem_state.constraints.split_state.split_constraints.values()])}"
)
if root_subproblem_state.constraints.prima_constraints is not None:
print(
f"Total number of PRIMA constraints: {sum([x[0].shape[-1] for x in root_subproblem_state.constraints.prima_constraints.prima_coefficients.values()])}"
)
if self._can_stop_early(
prima_lbs,
prima_ubs,
early_stopping_threshold,
invalid_bounds_mask_root,
):
return (
VerificationSubproblem.create_default(
prima_lbs[0],
prima_ubs[0],
split_state=None,
optimize_prima=False,
device=device,
),
prima_ub_inputs,
)
best_lbs = deep_poly_lbs
best_ubs = deep_poly_ubs
if self.config.alpha.optimize:
best_lbs = np.maximum(alpha_lbs, best_lbs).tolist()
best_ubs = np.minimum(alpha_ubs, best_ubs).tolist()
if self.config.prima.optimize:
best_lbs = np.maximum(prima_lbs, best_lbs).tolist()
best_ubs = np.minimum(prima_ubs, best_ubs).tolist()
if backsubstitution_config.reduce_parameter_sharing:
root_subproblem_state.parameters.modify_for_sharing() # branch and bound expects a single set of parameters
return (
VerificationSubproblem(
lower_bound=best_lbs[0],
upper_bound=best_ubs[0],
subproblem_state=root_subproblem_state,
device=device,
),
None,
)
def improve_subproblem_batch_bounds(
self,
subproblem_batch: SubproblemState, # updated in place
input_lb: Tensor,
input_ub: Tensor,
network: AbstractNetwork,
query_coef: Tensor,
early_stopping_threshold: Optional[float] = None,
recompute_intermediate_bounds_after_branching: bool = True,
timeout: float = float("inf"),
) -> Tuple[
Sequence[float], Sequence[float], Tensor
]: # TODO: add batch support for bounds directly into VerificationSubproblem
assert self.config.alpha.optimize
backsubstitution_config = self.backsubstitution_config
if self.config.prima.optimize:
(
improved_lbs,
improved_ubs,
ub_inputs,
) = self._bound_minimum_optimizing_alpha_prima(
backsubstitution_config,
subproblem_batch, # updated in place
input_lb,
input_ub,
network,
query_coef,
self.config.prima.bab_opt_iterations,
early_stopping_threshold,
timeout,
compute_upper_bound=recompute_intermediate_bounds_after_branching, # Don't compute the upper_bound of the objective in case all intermediate bounds are fixed
reset_input_bounds=True,
)
else:
(
improved_lbs,
improved_ubs,
ub_inputs,
) = self._bound_minimum_optimizing_alpha(
backsubstitution_config,
subproblem_batch, # updated in place
input_lb,
input_ub,
network,
query_coef,
self.config.alpha.bab_opt_iterations,
early_stopping_threshold,
timeout,
compute_upper_bound=recompute_intermediate_bounds_after_branching,
reset_input_bounds=True,
)
return (improved_lbs, improved_ubs, ub_inputs)
def _can_stop_early(
self,
lower_bounds: Union[Sequence[float], Tensor],
upper_bounds: Union[Sequence[float], Tensor],
early_stopping_threshold: Optional[float],
infeasibility_mask: Union[Sequence[bool], Tensor],
) -> bool:
"""
Returns True if and only if a counterexample has been found
or property is verified on all feasible subproblems.
"""
if early_stopping_threshold is None:
return all(infeasibility_mask)
counter_example_found = any_smaller(upper_bounds, early_stopping_threshold)
if counter_example_found:
return True
verified_mask = (
lower_bound > early_stopping_threshold for lower_bound in lower_bounds
)
verified_or_infeasible = (
verified or infeasible
for (verified, infeasible) in zip(verified_mask, infeasibility_mask)
)
return all(verified_or_infeasible)
@torch.no_grad()
def bound_minimum_with_deep_poly(
self,
backsubstitution_config: BacksubstitutionConfig,
input_lb: Tensor,
input_ub: Tensor,
network: AbstractNetwork,
query_coef: Tensor,
reset_input_bounds: bool, # = True,
return_tensors: bool = False,
ibp_pass: bool = False,
subproblem_state: Optional[SubproblemState] = None,
) -> Tuple[
Union[Tensor, Sequence[float]], Union[Tensor, Sequence[float]], Tensor, Tensor
]:
if (
self.config.prima.optimize
and subproblem_state is not None
and subproblem_state.constraints.prima_constraints is not None
):
backsubstitution_config = backsubstitution_config.with_prima(
self.config.prima.hyperparameters, []
) # use existing prima constraints, but don't compute new ones
if reset_input_bounds:
network.reset_input_bounds()
if ibp_pass:
network.set_layer_bounds_via_interval_propagation(
input_lb,
input_ub,
use_existing_bounds=True,
subproblem_state=subproblem_state,
activation_layer_only=True,
has_batch_dim=True,
set_input=True,
set_output=False,
)
if subproblem_state is not None:
subproblem_state.constraints.layer_bounds.improve(
network.get_current_intermediate_bounds()
)
subproblem_state.constraints.update_split_constraints(
network.get_relu_layer_ids(),
subproblem_state.constraints.layer_bounds.intermediate_bounds,
)
abstract_shape = network.get_mn_bab_shape(
config=backsubstitution_config,
input_lb=input_lb,
input_ub=input_ub,
query_id=query_tag(network),
query_coef=query_coef,
subproblem_state=subproblem_state,
compute_upper_bound=False,
reset_input_bounds=reset_input_bounds,
recompute_intermediate_bounds=self.backsubstitution_config.intermediate_bounds_method
>= IntermediateBoundsMethod["dp"],
optimize_intermediate_bounds=False,
)
output_lbs, __ = abstract_shape.concretize(input_lb, input_ub)
ubs_of_minimum, ub_inputs = MNBabOptimizer._get_upper_bound_of_minimum(
input_lb,
input_ub,
network,
query_coef,
abstract_shape,
)
assert (
(output_lbs <= ubs_of_minimum.to(output_lbs.device) + 1e-5)
| (output_lbs.squeeze() >= 0)
).all(), f"output_lb: {output_lbs}; output_ub_min: {ubs_of_minimum}; output_ub_min: {ubs_of_minimum - output_lbs}"
if return_tensors:
return (
output_lbs, # type:ignore [return-value]
ubs_of_minimum,
ub_inputs,
abstract_shape.lb.coef,
)
else:
return (
output_lbs.flatten().tolist(), # type:ignore [return-value]
ubs_of_minimum.flatten().tolist(),
ub_inputs,
abstract_shape.lb.coef,
)
def _bound_minimum_optimizing_alpha(
self,
backsubstitution_config: BacksubstitutionConfig,
subproblem_state: SubproblemState, # updated in place
input_lb: Tensor,
input_ub: Tensor,
network: AbstractNetwork,
query_coef: Tensor,
opt_iterations: int,
early_stopping_threshold: Optional[float] = None,
timeout: float = float("inf"),
compute_upper_bound: bool = True,
reset_input_bounds: bool = True,
) -> Tuple[Sequence[float], Sequence[float], Tensor]:
best_parameters = subproblem_state.parameters
subproblem_state_without_prima = (
subproblem_state.without_prima()
) # TODO: remove this
(best_lbs, best_ubs, ub_inputs) = self._bound_minimum(
backsubstitution_config=backsubstitution_config,
input_lb=input_lb,
input_ub=input_ub,
network=network,
query_coef=query_coef,
subproblem_state=subproblem_state_without_prima,
optimization_iterations=opt_iterations,
early_stopping_threshold=early_stopping_threshold,
timeout=timeout,
compute_upper_bound=compute_upper_bound,
reset_input_bounds=reset_input_bounds,
recompute_intermediate_bounds=self.backsubstitution_config.intermediate_bounds_method
>= IntermediateBoundsMethod["alpha"],
)
subproblem_state.parameters = (
subproblem_state_without_prima.parameters
) # TODO: remove this
assert subproblem_state.parameters == best_parameters
return (best_lbs, best_ubs, ub_inputs)
def _bound_minimum_optimizing_alpha_prima(
self,
backsubstitution_config: BacksubstitutionConfig,
subproblem_state: SubproblemState,
input_lb: Tensor,
input_ub: Tensor,
network: AbstractNetwork,
query_coef: Tensor,
opt_iterations: int,
early_stopping_threshold: Optional[float] = None,
timeout: float = float("inf"),
compute_upper_bound: bool = True, # whether or not to compute the UB portion of the backsub pass
reset_input_bounds: bool = True,
) -> Tuple[Sequence[float], Sequence[float], Tensor]:
assert (
subproblem_state.constraints.prima_constraints is not None
), "prima constraints missing"
layer_ids_for_which_to_compute_prima_constraints = (
network.get_activation_layer_ids()
)
backsubstitution_config = backsubstitution_config.with_prima(
self.config.prima.hyperparameters,
layer_ids_for_which_to_compute_prima_constraints,
)
(best_lbs, best_ubs, ub_inputs) = self._bound_minimum(
backsubstitution_config=backsubstitution_config,
subproblem_state=subproblem_state,
input_lb=input_lb,
input_ub=input_ub,
network=network,
query_coef=query_coef,
optimization_iterations=opt_iterations,
early_stopping_threshold=early_stopping_threshold,
timeout=timeout,
compute_upper_bound=compute_upper_bound,
reset_input_bounds=reset_input_bounds,
recompute_intermediate_bounds=self.backsubstitution_config.intermediate_bounds_method
>= IntermediateBoundsMethod["prima"],
)
return (best_lbs, best_ubs, ub_inputs)
def _bound_minimum(
self,
backsubstitution_config: BacksubstitutionConfig,
subproblem_state: SubproblemState,
input_lb: Tensor,
input_ub: Tensor,
network: AbstractNetwork,
query_coef: Tensor,
optimization_iterations: int,
early_stopping_threshold: Optional[float],
timeout: float,
compute_upper_bound: bool,
reset_input_bounds: bool,
recompute_intermediate_bounds: bool,
) -> Tuple[Sequence[float], Sequence[float], Tensor]:
assert query_coef.is_leaf
start_time = time.time()
best_parameters = subproblem_state.parameters
abstract_shape = network.get_mn_bab_shape(
config=backsubstitution_config,
input_lb=input_lb,
input_ub=input_ub,
query_id=query_tag(network),
query_coef=query_coef,
subproblem_state=subproblem_state,
compute_upper_bound=compute_upper_bound,
reset_input_bounds=reset_input_bounds,
optimize_intermediate_bounds=False,
recompute_intermediate_bounds=recompute_intermediate_bounds,
)
assert abstract_shape.subproblem_state is subproblem_state
assert subproblem_state.parameters is best_parameters
subproblem_state.parameters = (
best_parameters.deep_copy()
) # (temporarily replace dict during optimization)
(
all_alpha_parameters,
all_beta_parameters,
all_prima_parameters,
alpha_relu_parameters,
) = abstract_shape.get_optimizable_parameters(only_lb=not compute_upper_bound)
parameters_to_optimize = [
{"params": all_alpha_parameters, "lr": self.config.alpha.lr},
{"params": all_beta_parameters, "lr": self.config.beta.lr},
{"params": all_prima_parameters, "lr": self.config.prima.lr},
]
optimizer = optim.Adam(parameters_to_optimize)
scheduler = optim.lr_scheduler.OneCycleLR( # type: ignore[attr-defined] # mypy bug?
optimizer,
self.config.max_lr(),
optimization_iterations,
final_div_factor=self.config.lr.final_div_factor,
)
best_lower_bounds = torch.tensor(
[-float("inf")] * abstract_shape.batch_size, device=abstract_shape.device
)
best_upper_bounds = torch.tensor(
[float("inf")] * abstract_shape.batch_size, device=abstract_shape.device
)
if (
compute_upper_bound
): # When compute upper bounds is false, we are not recomputing bounds
abstract_shape.improve_layer_bounds(
network.get_current_intermediate_bounds()
)
best_ub_inputs = torch.zeros_like(input_lb[0:1]).repeat(
[query_coef.shape[0]] + (input_ub.dim() - 1) * [1]
)
assert query_coef.shape[1] == 1
for i in range(optimization_iterations):
if time.time() - start_time > timeout:
raise VerificationTimeoutException(
lb=torch.min(best_lower_bounds).cpu().item(),
ub=torch.max(best_upper_bounds).cpu().item(),
)
abstract_shape = network.backsubstitute_mn_bab_shape(
config=backsubstitution_config,
input_lb=input_lb,
input_ub=input_ub,
query_coef=query_coef.detach(),
abstract_shape=abstract_shape,
compute_upper_bound=compute_upper_bound,
reset_input_bounds=recompute_intermediate_bounds,
optimize_intermediate_bounds=False,
recompute_intermediate_bounds=recompute_intermediate_bounds,
)
output_lbs, __ = abstract_shape.concretize(input_lb, input_ub)
assert abstract_shape.subproblem_state is subproblem_state
# TODO we collapse query dim here. This can prevent simultaneous optimization for multiple output constraints
output_lbs = output_lbs.flatten()
upper_bounds, ub_inputs = MNBabOptimizer._get_upper_bound_of_minimum(
input_lb,
input_ub,
network,
query_coef,
abstract_shape,
)
upper_bounds = upper_bounds.flatten()
improvement_mask = output_lbs >= best_lower_bounds
improvement_mask_ub = upper_bounds < best_upper_bounds
best_parameters.improve(subproblem_state.parameters, improvement_mask)
if (
compute_upper_bound
): # When compute upper bounds is false, we are not recomputing bounds
abstract_shape.improve_layer_bounds(
network.get_current_intermediate_bounds()
)
best_ub_inputs = torch.where(
improvement_mask_ub.view([-1] + (input_ub.dim() - 1) * [1]),
ub_inputs.squeeze(1),
best_ub_inputs,
)
best_lower_bounds = torch.maximum(output_lbs, best_lower_bounds).detach()
best_upper_bounds = torch.minimum(upper_bounds, best_upper_bounds)
if self._can_stop_early(
best_lower_bounds,
best_upper_bounds,
early_stopping_threshold,
abstract_shape.subproblem_state.is_infeasible,
):
break
not_yet_verified_lbs = (
output_lbs[output_lbs < early_stopping_threshold]
if early_stopping_threshold is not None
else output_lbs
)
loss = -not_yet_verified_lbs.sum()
optimizer.zero_grad()
loss.backward()
optimizer.step()
scheduler.step()
if all(
self._all_gradients_zero_mask(
optimizer, abstract_shape.batch_size, abstract_shape.device
)
):
break
# Clamping only for ReLU
for alpha_parameters in alpha_relu_parameters:
alpha_parameters.data = torch.clamp(alpha_parameters.data, 0.0, 1.0)
for beta_parameters in all_beta_parameters:
beta_parameters.data = torch.clamp(beta_parameters.data, min=0.0)
for prima_parameters in all_prima_parameters:
prima_parameters.data = torch.clamp(prima_parameters.data, min=0.0)
lb_list: Sequence[float] = best_lower_bounds.tolist()
ub_list: Sequence[float] = best_upper_bounds.tolist()
subproblem_state.parameters = best_parameters
subproblem_state.update_feasibility()
return (lb_list, ub_list, best_ub_inputs)
@staticmethod
def _get_upper_bound_of_minimum(
input_lb: Tensor,
input_ub: Tensor,
network: AbstractNetwork,
query_coef: Tensor,
abstract_shape: MN_BaB_Shape,
) -> Tuple[Tensor, Tensor]:
upper_bound_input = abstract_shape.get_input_corresponding_to_lower_bound(
input_lb, input_ub
)
# Turns out torch is broken for large convolutions
outputs: List[Tensor] = []
for in_split in torch.split(
upper_bound_input.view(-1, *input_lb.shape[1:]), 1000
):
outputs.append(network(in_split))
output = torch.cat(outputs)
# output = network(upper_bound_input.view(-1, *input_lb.shape[1:]))
return (
torch.einsum("bij, bij -> bi", output.view_as(query_coef), query_coef),
upper_bound_input,
)
def _all_gradients_zero_mask(
self, optimizer: Optimizer, batch_size: int, device: torch.device
) -> Sequence[bool]:
gradients_zero_mask = torch.tensor(
[True for __ in range(batch_size)], device=device
)
for param_group in optimizer.param_groups:
parameters = param_group["params"]
for parameter_batch in parameters:
if parameter_batch.grad is None:
continue
assert parameter_batch.shape[0] == batch_size
flattened_parameter_batch_grad = parameter_batch.grad.view(
parameter_batch.shape[0], -1
)
parameter_gradient_zero_mask = torch.all(
flattened_parameter_batch_grad == 0, dim=1
)
gradients_zero_mask = torch.logical_and(
gradients_zero_mask, parameter_gradient_zero_mask
)
if not gradients_zero_mask.any():
return gradients_zero_mask.tolist()
return gradients_zero_mask.tolist()
| 30,426 | 38.362225 | 174 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/perf_benchmark.py | import argparse
import pstats
from cProfile import Profile
from torch.profiler import ProfilerActivity, profile, record_function
from src.verification_instance import VerificationInstance, create_instances_from_args
def run_torch_benchmark_on_instance(instance: VerificationInstance) -> None:
with profile(
activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
with_stack=True,
record_shapes=True,
) as prof:
with record_function("instance_perf_bench"):
instance.run_instance()
print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=20))
print(
prof.key_averages(group_by_input_shape=True).table(
sort_by="cuda_time_total", row_limit=20
)
)
print(
prof.key_averages(group_by_stack_n=5).table(
sort_by="self_cuda_time_total", row_limit=10
)
)
prof.export_chrome_trace("perf_bench.json")
prof.export_stacks("./perf_bench_stacks.txt", "self_cuda_time_total")
def run_cperf_benchmark_on_instance(instance: VerificationInstance) -> None:
profiler = Profile()
profiler.enable()
instance.run_instance()
profiler.disable()
stats = pstats.Stats(profiler).sort_stats("tottime")
# Print the stats report
stats.strip_dirs()
stats.sort_stats(pstats.SortKey.CUMULATIVE)
stats.reverse_order()
stats.print_stats()
stats.dump_stats("cperf.perf")
stats.sort_stats(pstats.SortKey.TIME)
stats.reverse_order()
stats.print_stats()
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Run verification instances on the vnn21 (& vnn22) datasets. Simply provide the corresponding nets, specs, and configs"
)
parser.add_argument(
"-c",
"--configs",
type=str,
nargs="*",
help="The configs corresponding to the nets x specs. Either we load a single config for all specs or one config for each spec",
)
args = parser.parse_args()
args.instances = None
args.nets = None
instances = create_instances_from_args(args)
instance_list = list(instances.values())
instance = instance_list[0][0]
instance.config.timeout = 120
run_cperf_benchmark_on_instance(instance)
| 2,270 | 29.28 | 139 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/verification_subproblem_queue.py | from typing import Callable, List, Optional, Sequence
import numpy as np
import torch
from src.abstract_layers.abstract_network import AbstractNetwork
from src.state.tags import NodeTag
from src.verification_subproblem import ReadonlyVerificationSubproblem
class VerificationSubproblemQueue:
"""Priority queue of VerificationSubproblems sorted by lower bound in ascending order."""
def __init__(
self,
initial_subproblem: ReadonlyVerificationSubproblem,
batch_sizes: Sequence[int],
) -> None:
self._layer_id_to_index = initial_subproblem.get_layer_id_to_index()
self._batch_sizes = batch_sizes
self._not_yet_split_queue: List[ReadonlyVerificationSubproblem] = []
self._queues_by_intermediate_bounds_to_keep: Sequence[
List[ReadonlyVerificationSubproblem]
] = [[] for __ in range(len(batch_sizes))]
self.global_prima_constraints = initial_subproblem.get_prima_constraints()
self.insert_sorted(initial_subproblem)
@property
def empty(self) -> bool:
return not self._not_yet_split_queue and not any(
self._queues_by_intermediate_bounds_to_keep
)
def __len__(self) -> int:
return len(self._not_yet_split_queue) + sum(
(len(queue) // 2) for queue in self._queues_by_intermediate_bounds_to_keep
)
def peek(self) -> Optional[ReadonlyVerificationSubproblem]:
if self.empty:
return None
minimum_lower_bound_not_yet_split = (
self._not_yet_split_queue[0].lower_bound
if self._not_yet_split_queue
else torch.inf
)
minimum_lower_bounds_already_split = [
subproblem_queue[0].lower_bound if subproblem_queue else torch.inf
for subproblem_queue in self._queues_by_intermediate_bounds_to_keep
]
if minimum_lower_bound_not_yet_split < min(minimum_lower_bounds_already_split):
return self._not_yet_split_queue[0]
else:
index_of_minimum = int(np.argmin(minimum_lower_bounds_already_split))
return self._queues_by_intermediate_bounds_to_keep[index_of_minimum][0]
def pop(
self,
find_node_to_split: Callable[[ReadonlyVerificationSubproblem], NodeTag],
recompute_intermediate_bounds_after_branching: bool,
network: AbstractNetwork,
) -> Sequence[ReadonlyVerificationSubproblem]:
minimum_lower_bound_not_yet_split = (
self._not_yet_split_queue[0].lower_bound
if self._not_yet_split_queue
else torch.inf
)
minimum_lower_bounds_already_split = [
subproblem_queue[0].lower_bound if subproblem_queue else torch.inf
for subproblem_queue in self._queues_by_intermediate_bounds_to_keep
]
if min(minimum_lower_bounds_already_split) < minimum_lower_bound_not_yet_split:
index_of_last_intermediate_bounds_kept = int(
np.argmin(minimum_lower_bounds_already_split)
)
else:
minimum_subproblem = self._not_yet_split_queue[0]
if not minimum_subproblem.is_fully_split:
del self._not_yet_split_queue[0]
node_to_split = find_node_to_split(minimum_subproblem)
layer = network.layer_id_to_layer[node_to_split.layer]
index_of_last_intermediate_bounds_kept = (
self._layer_id_to_index[node_to_split.layer]
if recompute_intermediate_bounds_after_branching
else -1
)
(
negatively_split_subproblem,
positively_split_subproblem,
) = minimum_subproblem.split(
node_to_split, recompute_intermediate_bounds_after_branching, layer
)
self._insert_sorted_into(
negatively_split_subproblem,
self._queues_by_intermediate_bounds_to_keep[
index_of_last_intermediate_bounds_kept
],
)
self._insert_sorted_into(
positively_split_subproblem,
self._queues_by_intermediate_bounds_to_keep[
index_of_last_intermediate_bounds_kept
],
)
while (
len(
self._queues_by_intermediate_bounds_to_keep[
index_of_last_intermediate_bounds_kept
]
)
< self._batch_sizes[index_of_last_intermediate_bounds_kept]
and self._not_yet_split_queue
):
subproblem_to_split = self._not_yet_split_queue[0]
if subproblem_to_split.is_fully_split:
break
del self._not_yet_split_queue[0]
node_to_split = find_node_to_split(subproblem_to_split)
layer = network.layer_id_to_layer[node_to_split.layer]
current_split_index_of_last_intermediate_bounds_kept = (
self._layer_id_to_index[node_to_split.layer]
if recompute_intermediate_bounds_after_branching
else -1
)
(
negatively_split_subproblem,
positively_split_subproblem,
) = subproblem_to_split.split(
node_to_split, recompute_intermediate_bounds_after_branching, layer
)
self._insert_sorted_into(
negatively_split_subproblem,
self._queues_by_intermediate_bounds_to_keep[
current_split_index_of_last_intermediate_bounds_kept
],
)
self._insert_sorted_into(
positively_split_subproblem,
self._queues_by_intermediate_bounds_to_keep[
current_split_index_of_last_intermediate_bounds_kept
],
)
return self._pop_from(
index_of_last_intermediate_bounds_kept,
self._batch_sizes[index_of_last_intermediate_bounds_kept],
)
def _pop_from(
self, layer_index_to_split: int, number_of_subproblems_to_fetch: int
) -> Sequence[ReadonlyVerificationSubproblem]:
max_number_of_subproblems_to_fetch = min(
number_of_subproblems_to_fetch,
len(self._queues_by_intermediate_bounds_to_keep[layer_index_to_split]),
)
subproblems_retrieved = []
for subproblem in self._queues_by_intermediate_bounds_to_keep[
layer_index_to_split
][:max_number_of_subproblems_to_fetch]:
subproblems_retrieved.append(subproblem)
number_of_subproblems_fetched = len(subproblems_retrieved)
del self._queues_by_intermediate_bounds_to_keep[layer_index_to_split][
:number_of_subproblems_fetched
]
return subproblems_retrieved
def insert_sorted(
self,
subproblem: ReadonlyVerificationSubproblem,
) -> None:
assert (
not subproblem.is_infeasible
), "Queue should only hold feasible subproblems."
assert (
subproblem.subproblem_state.constraints.split_state is not None
), "Queue should only hold solutions with a valid split state."
if self.global_prima_constraints is not None:
subproblem.set_prima_coefficients(
self.global_prima_constraints.prima_coefficients
)
self._insert_sorted_into(subproblem, self._not_yet_split_queue)
def _insert_sorted_into(
self,
subproblem: ReadonlyVerificationSubproblem,
subproblem_list: List[ReadonlyVerificationSubproblem],
) -> None:
sorted_index = 0
for current_subproblem in subproblem_list:
if current_subproblem.lower_bound >= subproblem.lower_bound:
break
sorted_index += 1
subproblem_list.insert(sorted_index, subproblem)
| 8,063 | 39.93401 | 93 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/mn_bab_shape.py | from __future__ import annotations
from collections import OrderedDict
from typing import TYPE_CHECKING, Callable, List, Optional, Tuple, Union
import torch
from torch import Tensor
from src.state.tags import LayerTag, ParameterTag, QueryTag
from src.utilities.dependence_sets import DependenceSets
from src.utilities.queries import QueryCoef, filter_queries, num_queries
from src.verification_subproblem import SubproblemState
if TYPE_CHECKING:
from src.abstract_layers.abstract_module import AbstractModule
class AffineForm:
"""
An affine form mapping inputs to output bounds (may represent multiple queries)
Attributes:
coef: linear coefficient
bias: bias (may be a scalar)
"""
coef: QueryCoef # batch_size x num_queries x current_layer_shape...
bias: Tensor # scalar or batch_size x num_queries
batch_size: int
num_queries: int
device: torch.device
def __init__(
self,
coef: Union[Tensor, DependenceSets],
bias: Optional[Tensor] = None, # TODO: pass device explicitly
):
# assert bias is None or coef.device is bias.device # apparently this is actually not true
self.device = coef.device
self.batch_size = (
coef.batch_size if isinstance(coef, DependenceSets) else coef.shape[0]
)
self.num_queries = num_queries(coef)
self.coef = coef
self.bias = (
torch.zeros((self.batch_size, self.num_queries), device=coef.device)
if bias is None
else bias
)
assert self.bias.numel() == 1 or (
self.bias.shape[0] == self.batch_size
and self.bias.shape[1] == self.num_queries
), "{} {}".format(self.bias.numel(), self.bias.shape)
def uses_dependence_sets(self) -> bool:
return isinstance(self.coef, DependenceSets)
def to(self, device: torch.device) -> AffineForm:
coef = self.coef.to(device)
bias = self.bias.to(device)
return AffineForm(coef, bias)
def clone(self) -> AffineForm:
return AffineForm(self.coef.clone(), self.bias.clone())
@property
def is_leaf(self) -> bool:
return self.coef.is_leaf and self.bias.is_leaf
def detach(self) -> AffineForm:
coef = self.coef.detach()
bias = self.bias.detach()
return AffineForm(coef, bias)
def matches_filter_mask(self, mask: Tensor) -> bool:
nb_entries = int(mask.sum())
return nb_entries == self.num_queries
def filter_queries(self, mask: Tensor) -> AffineForm:
filtered_coef = filter_queries(self.coef, mask)
filtered_bias = self.bias[:, mask] if self.bias.ndim > 0 else self.bias
return AffineForm(filtered_coef, filtered_bias)
class MN_BaB_Shape:
"""
An abstract shape that is defined by an affine lower and an
optional upper bound on functions of the form
f_i(x) = query_i*g(x). (where g is some part of a neural network)
The abstract shape
Attributes:
query_id: queries that use the same query id share optimizable parameters
query_prev_layer: optional. the previous layer for the query, needed to determine parameter sharing strategy
TODO: just store the parameter sharing strategy itself? (this is a bit more flexible and less ugly)
num_queries: number of queries
queries_to_compute: optional mask specifying which queries in the original layer we are bounding
- None means all
- uniform across batch
use cases:
- only recompute queries that are initially unstable
lb: lower bound
ub: upper bound (optional)
unstable_queries: optional mask specifying which queries within the static mask are still active
- None means all
- uniform across batch
use cases:
- tracking unstable queries for early termination
subproblem_state: the optimization state for all queries (optional)
batch_size: every tensor has this batch dimension for parallelization (shape[0])
device: every tensor is on this device
"""
query_id: QueryTag # queries that use the same query id share optimizable parameters
query_prev_layer: Optional[AbstractModule]
queries_to_compute: Optional[
Tensor
] # shape: total_num_queries_in_starting_layer, queries_to_compute.sum() == num_queries
num_queries: int # number of queries in each batch element
lb: AffineForm
ub: Optional[AffineForm]
unstable_queries: Optional[Tensor] # shape: num_queries
subproblem_state: Optional[SubproblemState]
batch_size: int
device: torch.device
def __init__(
self,
query_id: QueryTag,
query_prev_layer: Optional[AbstractModule],
queries_to_compute: Optional[Tensor],
lb: AffineForm,
ub: Optional[AffineForm],
unstable_queries: Optional[Tensor],
subproblem_state: Optional[SubproblemState],
) -> None:
self.query_id = query_id
self.query_prev_layer = query_prev_layer
self.num_queries = lb.num_queries
self.queries_to_compute = queries_to_compute
if isinstance(lb.coef, DependenceSets):
assert (
subproblem_state is None
or subproblem_state.constraints.prima_constraints is None
)
self.lb = lb.clone()
if ub is not None:
assert lb.device == ub.device
assert lb.batch_size == ub.batch_size
assert lb.num_queries == ub.num_queries
self.ub = ub.clone()
else:
self.ub = None
self.unstable_queries = unstable_queries
self.subproblem_state = subproblem_state
self.batch_size = lb.batch_size
self.device = lb.device
assert (
subproblem_state is None or self.batch_size == subproblem_state.batch_size
)
# TODO @Timon Uncertain if we want this here but it is used in multiple files so it made more sense in the shape itself
def clone_with_new_bounds(
self, lb: AffineForm, ub: Optional[AffineForm]
) -> MN_BaB_Shape:
return MN_BaB_Shape(
query_id=self.query_id,
query_prev_layer=self.query_prev_layer,
queries_to_compute=self.queries_to_compute,
lb=lb,
ub=ub,
unstable_queries=self.unstable_queries,
subproblem_state=self.subproblem_state,
)
def uses_dependence_sets(self) -> bool:
return self.lb.uses_dependence_sets()
def initialize_unstable_queries(self) -> None:
assert self.unstable_queries is None
self.unstable_queries = torch.ones(
self.num_queries,
device=self.device,
dtype=torch.bool,
)
def update_unstable_queries(self, current_unstable_queries: Tensor) -> None:
assert self.unstable_queries is not None
if (
current_unstable_queries.all()
): # TODO: does this actually pay off? (requires synchronization with the GPU)
return # if all current queries are unstable, no update is necessary
new_unstable_queries = self.unstable_queries.clone()
new_unstable_queries[self.unstable_queries] = current_unstable_queries
filtered_lb = self.lb.filter_queries(current_unstable_queries)
if self.ub is not None:
filtered_ub = self.ub.filter_queries(current_unstable_queries)
else:
filtered_ub = None
self.num_queries = filtered_lb.num_queries
self.update_bounds(filtered_lb, filtered_ub)
self.unstable_queries = new_unstable_queries
assert self.matches_filter_mask(self.unstable_queries)
def matches_filter_mask(self, mask: Tensor) -> bool:
"""
Check whether the number of queries matches the number of entries
in the filter.
TODO: just move the entire filter logic into MN_BaB_Shape
"""
nb_entries = int(mask.sum())
return nb_entries == self.num_queries
def get_unstable_queries_in_starting_layer(self) -> Optional[Tensor]:
"""
Computes a mask of unstable queries relative to the starting layer.
This information is currently tracked in two distinct tensors, therefore
this have to combine queries_to_compute and unstable_queries.
"""
if self.queries_to_compute is None:
return self.unstable_queries
if self.unstable_queries is None:
return self.queries_to_compute
query_filter_mask = self.queries_to_compute.clone()
query_filter_mask[self.queries_to_compute] = self.unstable_queries
return query_filter_mask
@property
def total_num_queries_in_starting_layer(self) -> int:
if self.queries_to_compute is not None:
assert len(self.queries_to_compute.shape) == 1
return self.queries_to_compute.shape[0]
if self.unstable_queries is not None:
assert len(self.unstable_queries.shape) == 1
return self.unstable_queries.shape[0]
return self.num_queries
def update_bounds(
self,
lb: AffineForm,
ub: Optional[AffineForm],
) -> None:
assert lb.device == self.device
assert lb.batch_size == self.batch_size
assert lb.num_queries == self.num_queries
if ub is not None: # TODO: Remove for performance again
assert ub.device == self.device
assert ub.batch_size == self.batch_size
assert ub.num_queries == self.num_queries
assert lb.coef is not ub.coef
assert lb.bias is not ub.bias
self.lb = lb # TODO: this looks potentially dangerous
self.ub = ub
def concretize(
self, input_lb: Tensor, input_ub: Tensor
) -> Tuple[Tensor, Optional[Tensor]]:
output_lb, output_ub = self._matmul_of_coef_and_interval(
input_lb.unsqueeze(1), # add query dimension # had .expand(batch_repeats)
input_ub.unsqueeze(1), # add query dimension # had .expand(batch_repeats)
)
output_lb += self.lb.bias
if output_ub is not None and self.ub is not None: # For mypy
output_ub += self.ub.bias
assert len(output_lb.shape) == 2
return output_lb, output_ub
def get_input_corresponding_to_lower_bound(
self, input_lb: Tensor, input_ub: Tensor
) -> Tensor:
assert not self.uses_dependence_sets()
assert isinstance(self.lb.coef, Tensor)
return torch.where(
self.lb.coef > 0, input_lb.unsqueeze(1), input_ub.unsqueeze(1)
).view(self.batch_size, self.lb.coef.shape[1], *input_lb.shape[1:])
def get_parameters(
self,
parameter_key: ParameterTag,
layer_id: LayerTag,
make_default_parameters: Union[
Callable[[torch.device], Tensor],
Tuple[int, ...], # default is a zero tensor
],
) -> Tensor:
assert self.subproblem_state is not None
return self.subproblem_state.parameters.get_parameters(
self.query_id,
parameter_key,
layer_id,
make_default_parameters,
)
def get_existing_parameters(
self, parameter_key: ParameterTag, layer_id: LayerTag
) -> Tensor:
assert self.subproblem_state is not None
return self.subproblem_state.parameters.get_existing_parameters(
self.query_id, parameter_key, layer_id
)
def change_alphas_to_WK_slopes(self) -> None:
assert self.subproblem_state is not None
layer_bounds = self.subproblem_state.constraints.layer_bounds
return self.subproblem_state.parameters.change_alphas_to_WK_slopes(
self.query_id, layer_bounds
)
def set_beta_parameters_to_zero(self) -> None:
assert self.subproblem_state is not None
return self.subproblem_state.parameters.set_beta_parameters_to_zero(
self.query_id
)
def get_optimizable_parameters( # TODO: get rid of this
self, selected_query_id: Optional[QueryTag] = None, only_lb: bool = False
) -> Tuple[List[Tensor], List[Tensor], List[Tensor], List[Tensor]]:
assert self.subproblem_state is not None
return self.subproblem_state.parameters.get_optimizable(
selected_query_id=selected_query_id,
only_lb=only_lb,
)
def get_split_constraints_for_relu( # TODO: get rid of this
self, layer_id: LayerTag, bounds: Tuple[Tensor, Tensor]
) -> Optional[Tensor]:
if self.subproblem_state is None:
return None
if self.subproblem_state.constraints.split_state is None:
return None
# self.subproblem_state.constraints.split_state.refine_split_constraints_for_relu(
# layer_id, bounds
# )
return self.subproblem_state.constraints.split_state.split_constraints[layer_id]
def get_split_constraints_for_sig( # TODO: get rid of this
self, layer_id: LayerTag, bounds: Tuple[Tensor, Tensor]
) -> Tuple[
Optional[Tensor], Optional[Tensor]
]: # for easy unpacking, could be Optional[Tuple[Tensor, Tensor]]
if self.subproblem_state is None:
return None, None
if self.subproblem_state.constraints.split_state is None:
return None, None
# self.subproblem_state.constraints.split_state.refine_split_constraints_for_sig(layer_id, bounds)
return (
self.subproblem_state.constraints.split_state.split_constraints[layer_id],
self.subproblem_state.constraints.split_state.split_points[layer_id],
)
def update_is_infeasible(self, is_infeasible: Tensor) -> None:
assert self.subproblem_state is not None
self.subproblem_state.constraints.update_is_infeasible(is_infeasible)
def improve_layer_bounds( # TODO: get rid of this
self,
new_intermediate_bounds: OrderedDict[
LayerTag, Tuple[Tensor, Tensor]
], # TODO: make this a LayerBounds as well?
) -> None:
assert self.subproblem_state is not None
self.subproblem_state.constraints.layer_bounds.improve(new_intermediate_bounds)
def _elementwise_mul_of_coef_and_interval(
self, interval_lb: Tensor, interval_ub: Tensor
) -> Tuple[Tensor, Optional[Tensor]]:
ub_coef: Optional[Tensor] = None
result_ub: Optional[Tensor] = None
if self.uses_dependence_sets():
assert isinstance(self.lb.coef, DependenceSets)
interval_lb_matched = DependenceSets.unfold_to(interval_lb, self.lb.coef)
interval_ub_matched = DependenceSets.unfold_to(
interval_ub, self.lb.coef
) # NOTE Not optimal but we can assume that lb_coef and a potentially existing ub_coef have the same structure
lb_coef = self.lb.coef.sets
if self.ub is not None:
assert isinstance(self.ub.coef, DependenceSets)
ub_coef = self.ub.coef.sets
else:
assert isinstance(self.lb.coef, Tensor)
interval_lb_matched = interval_lb
interval_ub_matched = interval_ub
assert len(interval_lb.shape) >= 3
assert len(interval_ub.shape) >= 3
lb_coef = self.lb.coef
if self.ub is not None:
assert isinstance(self.ub.coef, Tensor)
ub_coef = self.ub.coef
result_lb = lb_coef * torch.where(
lb_coef >= 0,
interval_lb_matched,
interval_ub_matched,
)
if (
self.ub is not None
and interval_ub_matched is not None
and ub_coef is not None
):
result_ub = ub_coef * torch.where(
ub_coef >= 0,
interval_ub_matched,
interval_lb_matched,
)
# result_jit_lb = self.clamp_mutiply(lb_coef, interval_lb_matched, interval_ub_matched)
# result_jit_ub = self.clamp_mutiply(ub_coef, interval_ub_matched, interval_lb_matched)
# assert torch.isclose(result_lb, result_jit_lb).all()
# assert torch.isclose(result_ub, result_jit_ub).all()
# result_idx_lb = self.index_mutiply(lb_coef, interval_lb_matched, interval_ub_matched)
# result_idx_ub = self.index_mutiply(ub_coef, interval_ub_matched, interval_lb_matched)
# assert torch.isclose(result_lb, result_idx_lb).all()
# assert torch.isclose(result_ub, result_idx_ub).all()
return result_lb, result_ub
def _matmul_of_coef_and_interval(
self, interval_lb: Tensor, interval_ub: Tensor
) -> Tuple[Tensor, Optional[Tensor]]:
assert (
len(interval_lb.shape) == len(interval_ub.shape) >= 3
) # batch_size x query_size x layer_size
(
elementwise_mul_lb,
elementwise_mul_ub,
) = self._elementwise_mul_of_coef_and_interval(
interval_lb,
interval_ub,
)
num_query_dimensions = 2
# LB
if not elementwise_mul_lb.is_contiguous():
elementwise_mul_lb = elementwise_mul_lb.contiguous()
elementwise_mul_lb = elementwise_mul_lb.view(
*elementwise_mul_lb.shape[:num_query_dimensions], -1
)
lb_mul_res = elementwise_mul_lb.sum(-1)
# UB
ub_mul_res: Optional[Tensor] = None
if self.ub is not None:
assert elementwise_mul_ub is not None
if not elementwise_mul_ub.is_contiguous():
elementwise_mul_ub = elementwise_mul_ub.contiguous()
elementwise_mul_ub = elementwise_mul_ub.view(
*elementwise_mul_ub.shape[:num_query_dimensions], -1
)
ub_mul_res = elementwise_mul_ub.sum(-1)
return lb_mul_res, ub_mul_res
@staticmethod
@torch.jit.script
def clamp_mutiply(
A: Tensor, pos: Tensor, neg: Tensor
) -> Tensor: # Produces worse gradients -also without
Apos = A.clamp(min=0)
Aneg = A.clamp(max=0)
return pos * Apos + neg * Aneg
@staticmethod
@torch.jit.script
def index_mutiply(A: Tensor, pos: Tensor, neg: Tensor) -> Tensor:
result = A * torch.where(
A >= 0,
pos,
neg,
)
return result
| 18,716 | 36.210736 | 125 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/concat.py | from typing import Tuple
import torch
from torch import Tensor
class Concat(torch.nn.Module):
def __init__(self, dim: int) -> None:
super(Concat, self).__init__()
self.dim = dim
def forward(self, x: Tuple[Tensor, ...]) -> Tensor:
return torch.cat(x, dim=self.dim)
| 300 | 20.5 | 55 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/multi_path_block.py | from typing import List, Optional
from torch import Tensor
from torch import nn as nn
from src.concrete_layers.binary_op import BinaryOp as concreteBinaryOp
class MultiPathBlock(nn.Module):
def __init__(
self, header: Optional[nn.Module], paths: List[nn.Sequential], merge: nn.Module
) -> None:
super(MultiPathBlock, self).__init__()
self.header = header
self.paths = nn.ModuleList(paths)
self.merge = merge
def forward(self, x: Tensor) -> Tensor:
if self.header:
in_vals = self.header(x)
else:
in_vals = x
if not isinstance(in_vals, list):
in_vals = [in_vals for i in range(len(self.paths))]
assert len(in_vals) == len(self.paths)
out_vals: List[Tensor] = []
for i, in_val in enumerate(in_vals):
out_vals.append(self.paths[i](in_val))
if issubclass(type(self.merge), concreteBinaryOp):
out = self.merge(out_vals[0], out_vals[1])
else:
out = self.merge(out_vals)
return out
| 1,081 | 26.05 | 87 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/binary_op.py | import torch
from torch import Tensor
# Concrete Implementation of BinaryOp used so that we can have an abstract version that spawns multiple shapes
class BinaryOp(torch.nn.Module):
def __init__(self, op: str) -> None:
super(BinaryOp, self).__init__()
self.op = op
def forward(self, x: Tensor, y: Tensor) -> Tensor:
if self.op == "add":
return x + y
elif self.op == "sub":
return x - y
else:
assert False, f"Unknown operator {self.op}"
| 524 | 26.631579 | 110 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/basic_block.py | from typing import List, Tuple
import torch
from torch import nn as nn
from src.concrete_layers.residual_block import ResidualBlock
class BasicBlock(ResidualBlock, nn.Module):
expansion = 1
in_planes: int
planes: int
stride: int
bn: bool
kernel: int
out_dim: int
def __init__(
self,
in_planes: int,
planes: int,
stride: int = 1,
bn: bool = True,
kernel: int = 3,
in_dim: int = -1,
) -> None:
self.in_planes = in_planes
self.planes = planes
self.stride = stride
self.bn = bn
self.kernel = kernel
kernel_size = kernel
assert kernel_size in [1, 2, 3], "kernel not supported!"
p_1 = 1 if kernel_size > 1 else 0
p_2 = 1 if kernel_size > 2 else 0
layers_b: List[nn.Module] = []
layers_b.append(
nn.Conv2d(
in_planes,
planes,
kernel_size=kernel_size,
stride=stride,
padding=p_1,
bias=(not bn),
)
)
_, _, in_dim = self._getShapeConv(
(in_planes, in_dim, in_dim),
(self.in_planes, kernel_size, kernel_size),
stride=stride,
padding=p_1,
)
if bn:
layers_b.append(nn.BatchNorm2d(planes))
layers_b.append(nn.ReLU())
layers_b.append(
nn.Conv2d(
planes,
self.expansion * planes,
kernel_size=kernel_size,
stride=1,
padding=p_2,
bias=(not bn),
)
)
_, _, in_dim = self._getShapeConv(
(planes, in_dim, in_dim),
(self.in_planes, kernel_size, kernel_size),
stride=1,
padding=p_2,
)
if bn:
layers_b.append(nn.BatchNorm2d(self.expansion * planes))
path_b = nn.Sequential(*layers_b)
layers_a: List[nn.Module] = [torch.nn.Identity()]
if stride != 1 or in_planes != self.expansion * planes:
layers_a.append(
nn.Conv2d(
in_planes,
self.expansion * planes,
kernel_size=1,
stride=stride,
bias=(not bn),
)
)
if bn:
layers_a.append(nn.BatchNorm2d(self.expansion * planes))
path_a = nn.Sequential(*layers_a)
self.out_dim = in_dim
super(BasicBlock, self).__init__(path_a, path_b)
def _getShapeConv(
self,
in_shape: Tuple[int, int, int],
conv_shape: Tuple[int, ...],
stride: int = 1,
padding: int = 0,
) -> Tuple[int, int, int]:
inChan, inH, inW = in_shape
outChan, kH, kW = conv_shape[:3]
outH = 1 + int((2 * padding + inH - kH) / stride)
outW = 1 + int((2 * padding + inW - kW) / stride)
return (outChan, outH, outW)
| 3,038 | 26.378378 | 72 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/slice.py | import torch
from torch import Tensor
# Slicing limited to 1-d slices wit positive steps
class Slice(torch.nn.Module):
def __init__(self, dim: int, starts: int, ends: int, steps: int) -> None:
super(Slice, self).__init__()
self.starts = starts
self.ends = ends
self.dim = dim
self.steps = steps
def forward(self, x: Tensor) -> Tensor:
axes = self.dim # Expects input to have a batch-dimension
starts = self.starts
ends = self.ends
steps = self.steps
assert steps > 0
if ends == -1:
ends = x.shape[axes]
index = torch.tensor(range(starts, ends, steps), device=x.device)
selected = torch.index_select(x, axes, index)
return selected
| 768 | 28.576923 | 77 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/reshape.py | from typing import Tuple
import torch
from torch import Tensor
class Reshape(torch.nn.Module):
def __init__(self, shape: Tuple[int, ...]) -> None:
super(Reshape, self).__init__()
# Assume that shape is without batch-size
self.shape = shape
def forward(self, x: Tensor) -> Tensor:
return x.reshape((x.shape[0], *self.shape))
| 368 | 23.6 | 55 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/residual_block.py | from torch import Tensor
from torch import nn as nn
class ResidualBlock(nn.Module):
def __init__(
self,
path_a: nn.Sequential,
path_b: nn.Sequential,
) -> None:
super(ResidualBlock, self).__init__()
self.path_a = path_a
self.path_b = path_b
def forward(self, x: Tensor) -> Tensor:
out = self.path_a(x) + self.path_b(x)
return out
| 409 | 21.777778 | 45 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/permute.py | from typing import Tuple
import torch
from torch import Tensor
class Permute(torch.nn.Module):
def __init__(self, dims: Tuple[int, ...]) -> None:
super(Permute, self).__init__()
self.dims = dims
def forward(self, x: Tensor) -> Tensor:
return x.permute(self.dims)
| 299 | 20.428571 | 54 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/normalize.py | from typing import Sequence
import torch
from torch import Tensor
class Normalize(torch.nn.Module):
means: Tensor
stds: Tensor
channel_dim: int
def __init__(
self, means: Sequence[float], stds: Sequence[float], channel_dim: int
) -> None:
super(Normalize, self).__init__()
target_shape = 4 * [1]
target_shape[channel_dim] = len(means)
self.register_buffer(
"means",
torch.as_tensor(means, dtype=torch.float).reshape(target_shape),
persistent=False,
)
self.register_buffer(
"stds",
torch.as_tensor(stds, dtype=torch.float).reshape(target_shape),
persistent=False,
)
self.channel_dim = channel_dim
def forward(self, x: Tensor) -> Tensor:
return (x - self.means) / self.stds
| 853 | 25.6875 | 77 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/split_block.py | from typing import Optional, Tuple
import torch
from torch import Tensor
from torch import nn as nn
class SplitBlock(nn.Module):
def __init__(
self,
split: Tuple[bool, Tuple[int, ...], Optional[int], int, bool],
center_path: nn.Sequential,
inner_reduce: Tuple[int, bool, bool],
outer_reduce: Tuple[int, bool, bool],
) -> None:
super(SplitBlock, self).__init__()
self.center_path = center_path
# (split.enable_pruning, split.split_size_or_sections, split.number_of_splits, split.dim, split.keep_size)
self.split = split
# (inner_reduce.dim, inner_reduce.keepdim, inner_reduce.noop_with_empty_axes)
self.inner_reduce = inner_reduce
self.outer_reduce = outer_reduce
def forward(self, x: Tensor) -> Tensor:
center_x, res_x = torch.split(
x, split_size_or_sections=self.split[1], dim=self.split[3]
)
center_out = self.center_path(center_x)
inner_merge = center_out * res_x
inner_red = torch.sum(inner_merge, dim=self.inner_reduce[0])
outer_red = torch.sum(res_x, dim=self.outer_reduce[0])
out = inner_red / outer_red
return out
| 1,215 | 31 | 114 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/unbinary_op.py | import typing
import torch
from torch import Tensor
class UnbinaryOp(torch.nn.Module):
def __init__(self, op: str, const_val: Tensor, apply_right: bool = False) -> None:
super(UnbinaryOp, self).__init__()
self.op = op
self.register_buffer(
"const_val",
torch.as_tensor(const_val),
persistent=False,
)
self.apply_right = apply_right
@typing.no_type_check # Mypy can't handle the buffer type
def forward(self, x: Tensor) -> Tensor:
assert type(self.const_val) == Tensor
if self.const_val.device != x.device:
self.to(x.device)
if self.apply_right:
left, right = self.const_val, x
else:
left, right = x, self.const_val
if self.op == "add":
return left + right
elif self.op == "sub":
return left - right
elif self.op == "mul":
return left * right
elif self.op == "div":
return left / right
@typing.no_type_check
def to(self, device: str) -> None:
self.const_val = self.const_val.to(device)
| 1,144 | 27.625 | 86 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/pad.py | from typing import Tuple
import torch
import torch.nn.functional as F
from torch import Tensor
class Pad(torch.nn.Module):
def __init__(
self, pad: Tuple[int, ...], mode: str = "constant", value: float = 0.0
) -> None:
super(Pad, self).__init__()
self.pad = pad if pad is not None else (0, 0, 0, 0)
self.mode = mode
self.value = value
def forward(self, x: Tensor) -> Tensor:
return F.pad(x, self.pad, self.mode, self.value)
| 488 | 24.736842 | 78 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/leaky_gradient_maximum_function.py | from typing import Any, Tuple
import torch
from torch import Tensor
from torch.autograd import Function
class LeakyGradientMaximumFunction(Function):
@staticmethod
def forward(ctx: Any, input: Tensor, other: Tensor) -> Tensor: # type: ignore[override]
return torch.maximum(input, other)
@staticmethod
def backward(ctx: Any, grad_outputs: Tensor) -> Tuple[Tensor, Tensor]: # type: ignore[override]
return grad_outputs, grad_outputs
| 469 | 28.375 | 100 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/abstract_module_mapper.py | from typing import Type
from torch import nn as nn
from src.abstract_layers.abstract_avg_pool2d import AvgPool2d
from src.abstract_layers.abstract_bn2d import BatchNorm2d
from src.abstract_layers.abstract_concat import Concat
from src.abstract_layers.abstract_conv2d import Conv2d
from src.abstract_layers.abstract_convtranspose2d import ConvTranspose2d
from src.abstract_layers.abstract_flatten import Flatten
from src.abstract_layers.abstract_identity import Identity
from src.abstract_layers.abstract_linear import Linear
from src.abstract_layers.abstract_max_pool2d import MaxPool2d
from src.abstract_layers.abstract_mulit_path_block import MultiPathBlock
from src.abstract_layers.abstract_normalization import Normalization
from src.abstract_layers.abstract_pad import Pad
from src.abstract_layers.abstract_permute import Permute
from src.abstract_layers.abstract_relu import ReLU
from src.abstract_layers.abstract_reshape import Reshape
from src.abstract_layers.abstract_residual_block import ResidualBlock
from src.abstract_layers.abstract_sequential import Sequential
from src.abstract_layers.abstract_sigmoid import Sigmoid
from src.abstract_layers.abstract_slice import Slice
from src.abstract_layers.abstract_split_block import SplitBlock
from src.abstract_layers.abstract_tanh import Tanh
from src.abstract_layers.abstract_unbinary_op import UnbinaryOp
from src.concrete_layers import basic_block as concrete_basic_block
from src.concrete_layers import concat as concrete_concat
from src.concrete_layers import multi_path_block as concrete_multi_path_block
from src.concrete_layers import normalize as concrete_normalize
from src.concrete_layers import pad as concrete_pad
from src.concrete_layers import permute as concrete_permute
from src.concrete_layers import reshape as concrete_reshape
from src.concrete_layers import residual_block as concrete_residual_block
from src.concrete_layers import slice as concrete_slice
from src.concrete_layers import split_block as concrete_split_block
from src.concrete_layers import unbinary_op as concrete_unbinary_op
class AbstractModuleMapper:
@staticmethod # noqa: C901
def map_to_abstract_type(concrete_type: Type) -> Type:
if concrete_type == nn.BatchNorm2d:
return BatchNorm2d
elif concrete_type == concrete_concat.Concat:
return Concat
elif concrete_type == nn.Conv2d:
return Conv2d
elif concrete_type == nn.ConvTranspose2d:
return ConvTranspose2d
elif concrete_type == nn.Flatten:
return Flatten
elif concrete_type == nn.Identity:
return Identity
elif concrete_type == nn.Linear:
return Linear
elif concrete_type == concrete_normalize.Normalize:
return Normalization
elif concrete_type == nn.ReLU:
return ReLU
elif concrete_type == nn.Sigmoid:
return Sigmoid
elif concrete_type == concrete_slice.Slice:
return Slice
elif concrete_type == nn.Tanh:
return Tanh
elif concrete_type == concrete_unbinary_op.UnbinaryOp:
return UnbinaryOp
elif concrete_type == concrete_basic_block.BasicBlock:
return ResidualBlock
elif concrete_type == concrete_residual_block.ResidualBlock:
return ResidualBlock
elif concrete_type == nn.Sequential:
return Sequential
elif concrete_type == concrete_permute.Permute:
return Permute
elif concrete_type == concrete_split_block.SplitBlock:
return SplitBlock
elif concrete_type == nn.AvgPool2d:
return AvgPool2d
elif concrete_type == concrete_multi_path_block.MultiPathBlock:
return MultiPathBlock
elif concrete_type == nn.MaxPool2d:
return MaxPool2d
elif concrete_type == concrete_pad.Pad:
return Pad
elif concrete_type == concrete_reshape.Reshape:
return Reshape
else:
raise NotImplementedError(f"Unsupported layer type: {concrete_type}")
| 4,117 | 44.252747 | 81 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/optimization.py | import time
from typing import Callable, Optional, Tuple
import numpy as np
import torch
import torch.optim as optim
from torch import Tensor
from src.exceptions.verification_timeout import VerificationTimeoutException
from src.mn_bab_shape import MN_BaB_Shape, num_queries
from src.state.subproblem_state import ReadonlySubproblemState
from src.state.tags import QueryTag
from src.utilities.config import IntermediateBoundOptimizationConfig
from src.utilities.queries import QueryCoef
def optimize_params_for_interm_bounds( # noqa: C901
query_id: QueryTag,
query_coef: QueryCoef,
subproblem_state: ReadonlySubproblemState,
opt_callback: Callable[
[QueryCoef],
Tuple[
Optional[MN_BaB_Shape], Tuple[Tensor, Tensor]
], # TODO: can we get rid of MN_BaB_Shape return value?
],
config: IntermediateBoundOptimizationConfig,
timeout: float = float("inf"),
) -> Tuple[Tensor, Tensor]:
prima_lr = config.prima_lr
alpha_lr = config.alpha_lr
factor = config.lr_config.peak_scaling_factor
div_factor = config.lr_config.final_div_factor
optimization_iterations = config.optimization_iterations
indiv_optim = config.indiv_optim
adapt_optim = config.adapt_optim
num_layers_to_optimize = config.num_layers_to_optimize
optimize_prior_bounds = config.optimize_prior_bounds
selected_query_id: Optional[QueryTag] = query_id
# indiv_optim = True
# optimize_prior_bounds = True
# optimization_iterations = 50
adapt_optim = True
start_time = time.time()
assert query_coef.is_leaf
# First run for optimizable parameters
print(f"Query {query_id}")
prop_shape, dp_bounds = opt_callback(query_coef)
print(f"First prop {query_id}")
if prop_shape is None:
return dp_bounds
if optimize_prior_bounds:
selected_query_id = None
current_relu_position = len( # TODO: get rid of this hack (maybe will conflict with other kinds of parameter sharing)
subproblem_state.parameters.parameters_by_query
) # First relu has index 1
(
all_alpha_parameters,
all_beta_parameters,
all_prima_parameters,
alpha_relu_parameters,
) = prop_shape.get_optimizable_parameters(selected_query_id)
if len(all_alpha_parameters) == 0 or current_relu_position > num_layers_to_optimize:
return dp_bounds
parameters_to_optimize = [
{"params": all_alpha_parameters, "lr": alpha_lr},
{"params": all_prima_parameters, "lr": prima_lr},
]
best_lower_bounds = dp_bounds[0].detach().clone()
best_upper_bounds = dp_bounds[1].detach().clone()
for o in range(2):
if indiv_optim:
for j in range(num_queries(query_coef)):
optimizer = optim.Adam(parameters_to_optimize)
scheduler = optim.lr_scheduler.OneCycleLR( # type: ignore[attr-defined]
optimizer,
(alpha_lr * factor, prima_lr * factor),
optimization_iterations,
final_div_factor=div_factor,
)
for alpha_parameters in alpha_relu_parameters:
alpha_parameters.data = torch.zeros_like(
alpha_parameters.data, requires_grad=True
)
for prima_parameters in all_prima_parameters:
prima_parameters.data = torch.zeros_like(
prima_parameters.data, requires_grad=True
)
for i in range(optimization_iterations):
if time.time() - start_time > timeout:
raise VerificationTimeoutException()
# @Robin Set specific query coeff
prop_shape, (output_lbs, output_ubs) = opt_callback(query_coef)
best_lower_bounds = torch.maximum(
output_lbs, best_lower_bounds
).detach()
best_upper_bounds = torch.minimum(
output_ubs, best_upper_bounds
).detach()
if o == 0:
loss = -output_lbs[0][j]
else:
loss = output_ubs[0][j]
# print(loss)
optimizer.zero_grad()
loss.backward()
optimizer.step()
scheduler.step()
# Clamping only for ReLU
for alpha_parameters in alpha_relu_parameters:
alpha_parameters.data = torch.clamp(
alpha_parameters.data, 0.0, 1.0
)
for prima_parameters in all_prima_parameters:
prima_parameters.data = torch.clamp(
prima_parameters.data, min=0.0
)
elif adapt_optim:
assert isinstance(query_coef, Tensor)
if len(query_coef.shape) == 5: # We have a channel dimension
num_channels = query_coef.shape[2]
neurons_per_channel = np.prod(query_coef.shape[3:])
else:
num_channels = 1
neurons_per_channel = np.prod(query_coef.shape[2:])
assert num_queries(query_coef) == num_channels * neurons_per_channel
for j in range(num_channels):
curr_query_start = j * neurons_per_channel
optimizer = optim.Adam(parameters_to_optimize)
scheduler = optim.lr_scheduler.OneCycleLR( # type: ignore[attr-defined]
optimizer,
(alpha_lr * factor, prima_lr * factor),
optimization_iterations,
final_div_factor=div_factor,
)
for alpha_parameters in alpha_relu_parameters:
alpha_parameters.data = torch.zeros_like(
alpha_parameters.data, requires_grad=True
)
for prima_parameters in all_prima_parameters:
prima_parameters.data = torch.zeros_like(
prima_parameters.data, requires_grad=True
)
for i in range(optimization_iterations):
if time.time() - start_time > timeout:
raise VerificationTimeoutException()
curr_query_coef = query_coef[
:, curr_query_start : curr_query_start + neurons_per_channel, :
]
prop_shape, (output_lbs, output_ubs) = opt_callback(curr_query_coef)
best_lower_bounds[
0, curr_query_start : curr_query_start + neurons_per_channel
] = torch.maximum(
output_lbs[0],
best_lower_bounds[
0, curr_query_start : curr_query_start + neurons_per_channel
],
).detach()
best_upper_bounds[
0, curr_query_start : curr_query_start + neurons_per_channel
] = torch.minimum(
output_ubs[0],
best_upper_bounds[
0, curr_query_start : curr_query_start + neurons_per_channel
],
).detach()
if o == 0:
loss = -torch.sum(output_lbs)
else:
loss = torch.sum(output_ubs)
# print(loss)
optimizer.zero_grad()
loss.backward()
optimizer.step()
scheduler.step()
# Clamping only for ReLU
for alpha_parameters in alpha_relu_parameters:
alpha_parameters.data = torch.clamp(
alpha_parameters.data, 0.0, 1.0
)
for prima_parameters in all_prima_parameters:
prima_parameters.data = torch.clamp(
prima_parameters.data, min=0.0
)
else:
optimizer = optim.Adam(parameters_to_optimize)
scheduler = optim.lr_scheduler.OneCycleLR( # type: ignore[attr-defined]
optimizer,
(alpha_lr * factor, prima_lr * factor),
optimization_iterations,
final_div_factor=div_factor,
)
for alpha_parameters in alpha_relu_parameters:
alpha_parameters.data = torch.zeros_like(
alpha_parameters.data, requires_grad=True
)
for prima_parameters in all_prima_parameters:
prima_parameters.data = torch.zeros_like(
prima_parameters.data, requires_grad=True
)
for i in range(optimization_iterations):
if time.time() - start_time > timeout:
raise VerificationTimeoutException()
# @Robin Set specific query coeff
prop_shape, (output_lbs, output_ubs) = opt_callback(query_coef)
# TODO @Robin set
output_lbs = output_lbs.flatten()
output_ubs = output_ubs.flatten()
best_lower_bounds = torch.maximum(
output_lbs, best_lower_bounds
).detach()
best_upper_bounds = torch.minimum(
output_ubs, best_upper_bounds
).detach()
if o == 0:
loss = -output_lbs.sum()
else:
loss = output_ubs.sum()
# print(loss)
optimizer.zero_grad()
loss.backward()
optimizer.step()
scheduler.step()
# Clamping only for ReLU
for alpha_parameters in alpha_relu_parameters:
alpha_parameters.data = torch.clamp(alpha_parameters.data, 0.0, 1.0)
for prima_parameters in all_prima_parameters:
prima_parameters.data = torch.clamp(prima_parameters.data, min=0.0)
# for j in range(num_queries(query_coef)):
# print(
# f"{j} LB : {best_lower_bounds[0][j] - dp_bounds[0][0][j]:.4f} UB {dp_bounds[1][0][j] - best_upper_bounds[0][j]:.4f}"
# )
return (
best_lower_bounds,
best_upper_bounds,
)
| 10,705 | 36.830389 | 130 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/leaky_gradient_minimum_function.py | from typing import Any, Tuple
import torch
from torch import Tensor
from torch.autograd import Function
class LeakyGradientMinimumFunction(Function):
@staticmethod
def forward(ctx: Any, input: Tensor, other: Tensor) -> Tensor: # type: ignore[override]
return torch.minimum(input, other)
@staticmethod
def backward(ctx: Any, grad_outputs: Tensor) -> Tuple[Tensor, Tensor]: # type: ignore[override]
return grad_outputs, grad_outputs
| 469 | 28.375 | 100 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/queries.py | from __future__ import annotations
from typing import Iterator, Optional, Tuple, Union, overload
import numpy as np
import torch
from torch import Tensor
from src.utilities.dependence_sets import DependenceSets
QueryCoef = Union[
Tensor, DependenceSets
] # batch_size x num_queries x current_layer_shape...
def num_queries(query_coef: QueryCoef) -> int:
return (
query_coef.sets.shape[1]
if isinstance(query_coef, DependenceSets)
else query_coef.shape[1]
)
def get_output_bound_initial_query_coef(
dim: Tuple[int, ...],
intermediate_bounds_to_recompute: Optional[Tensor], # None means recompute all.
use_dependence_sets: bool, # = False
batch_size: int,
dtype: Optional[torch.dtype],
device: torch.device,
) -> QueryCoef:
"""
Returns coefficients for a query that bounds all outputs of a layer of shape "dim".
The coefficients are repeated for each batch index.
"""
if dtype is None:
dtype = torch.get_default_dtype()
initial_bound_coef: QueryCoef
if use_dependence_sets:
num_query_channels, num_queries_spatial = dim[0], np.prod(dim[1:])
repeats = batch_size, 1, num_queries_spatial, 1, 1, 1
sets_final_shape = (
batch_size,
num_query_channels * num_queries_spatial,
num_query_channels,
1,
1,
) # [B, C*WH, C, 1, 1]
sets = (
(
torch.eye(num_query_channels, device=device, dtype=dtype)
.unsqueeze(-1)
.unsqueeze(-1)
.unsqueeze(0)
.unsqueeze(2)
)
.repeat(repeats)
.view(sets_final_shape)
)
spatial_idxs = torch.arange(num_queries_spatial).repeat(num_query_channels)
initial_bound_coef = DependenceSets(
sets=sets,
spatial_idxs=spatial_idxs,
input_dim=dim,
cstride=1,
cpadding=0,
)
if intermediate_bounds_to_recompute is not None:
initial_bound_coef = filter_queries(
initial_bound_coef, intermediate_bounds_to_recompute
)
# Todo integrate this update directly into the coef creation
else:
if intermediate_bounds_to_recompute is None:
batch_repeats = batch_size, *([1] * (len(dim) + 1))
initial_bound_coef = (
torch.eye(np.prod(dim), device=device).view(-1, *dim).unsqueeze(0)
).repeat(batch_repeats)
else:
n_unstable_neurons = int(intermediate_bounds_to_recompute.sum().item())
initial_bound_coef = torch.zeros(
(
batch_size, # type: ignore[call-overload]
n_unstable_neurons,
int(np.prod(dim)),
),
device=device,
)
initial_bound_coef[
:,
torch.arange(n_unstable_neurons),
intermediate_bounds_to_recompute,
] = 1.0
initial_bound_coef = initial_bound_coef.view(
(batch_size, n_unstable_neurons, *dim)
)
return initial_bound_coef
def get_output_bound_initial_query_coef_iterator(
dim: Tuple[int, ...],
intermediate_bounds_to_recompute: Optional[Tensor], # None means recompute all.
use_dependence_sets: bool, # = False
batch_size: int,
slice_size: Optional[int],
dtype: Optional[torch.dtype],
device: torch.device,
) -> Iterator[Tuple[int, int, QueryCoef]]:
"""
Returns coefficients for a query that bounds all outputs of a layer of shape "dim".
The coefficients are repeated for each batch index.
"""
if dtype is None:
dtype = torch.get_default_dtype()
if intermediate_bounds_to_recompute is not None:
n_unstable_neurons = int(intermediate_bounds_to_recompute.sum().item())
else:
n_unstable_neurons = np.prod(dim) # Is this correct?
# TODO @Mark is this correct?
if use_dependence_sets:
num_query_channels, num_queries_spatial = dim[0], np.prod(dim[1:])
repeats = batch_size, 1, num_queries_spatial, 1, 1, 1
sets_final_shape = (
batch_size,
num_query_channels * num_queries_spatial,
num_query_channels,
1,
1,
) # [B, C*WH, C, 1, 1]
sets = (
(
torch.eye(num_query_channels, device=device, dtype=dtype)
.unsqueeze(-1)
.unsqueeze(-1)
.unsqueeze(0)
.unsqueeze(2)
)
.repeat(repeats)
.view(sets_final_shape)
)
spatial_idxs = torch.arange(num_queries_spatial, device=device).repeat(
num_query_channels
)
initial_bound_coef = DependenceSets(
sets=sets,
spatial_idxs=spatial_idxs,
input_dim=dim,
cstride=1,
cpadding=0,
)
if intermediate_bounds_to_recompute is not None:
initial_bound_coef = filter_queries(
initial_bound_coef, intermediate_bounds_to_recompute
)
# Todo integrate this update directly into the coef creation
yield 0, n_unstable_neurons, initial_bound_coef
else:
if intermediate_bounds_to_recompute is not None:
non_zero_idx = torch.nonzero(intermediate_bounds_to_recompute).flatten()
else:
non_zero_idx = torch.ones((n_unstable_neurons,), device=device)
if slice_size is None:
slice_size = len(non_zero_idx)
offset = 0
while offset < n_unstable_neurons:
slice_size = min(slice_size, n_unstable_neurons - offset)
curr_coef_slice = torch.zeros(
(
batch_size, # type: ignore[call-overload]
slice_size,
int(np.prod(dim)),
),
device=device,
)
curr_coef_slice[:, :, non_zero_idx[offset : offset + slice_size]] = (
torch.eye(slice_size, device=device)
.unsqueeze(0)
.repeat(batch_size, 1, 1)
)
offset += slice_size
curr_coef_slice = curr_coef_slice.view((batch_size, slice_size, *dim))
yield offset - slice_size, offset, curr_coef_slice
@overload
def filter_queries(query_coef: Tensor, mask: Tensor) -> Tensor:
...
@overload
def filter_queries(query_coef: DependenceSets, mask: Tensor) -> DependenceSets: # type: ignore[misc] # pre-commit-hook mypy thinks Tensor is Any
...
def filter_queries(query_coef: QueryCoef, mask: Tensor) -> QueryCoef:
assert mask.ndim == 1 # TODO: ok?
if isinstance(query_coef, DependenceSets):
assert mask.shape[0] == query_coef.sets.shape[1]
assert mask.shape[0] == query_coef.spatial_idxs.shape[0]
return DependenceSets(
sets=query_coef.sets[:, mask],
spatial_idxs=query_coef.spatial_idxs[mask],
input_dim=query_coef.input_dim,
cstride=query_coef.cstride,
cpadding=query_coef.cpadding,
)
else:
assert isinstance(query_coef, Tensor)
assert mask.shape[0] == query_coef.shape[1]
return query_coef[:, mask]
| 7,440 | 32.822727 | 146 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/tensor_management.py | from collections import OrderedDict
from typing import Any
import torch
def deep_copy(obj: Any) -> Any:
if obj is None:
return obj
if torch.is_tensor(obj):
assert obj.is_leaf
return obj.clone().detach()
if isinstance(obj, OrderedDict):
return OrderedDict((k, deep_copy(v)) for k, v in obj.items())
if isinstance(obj, dict):
return {k: deep_copy(v) for k, v in obj.items()}
if isinstance(obj, list):
return [deep_copy(v) for v in obj]
if isinstance(obj, tuple):
return tuple(deep_copy(v) for v in obj)
raise TypeError("Invalid type '" + str(type(obj)) + "' for deep_copy")
def deep_copy_to(obj: Any, device: torch.device) -> Any:
"""
Clones built-in Python data structures containing leaf Tensors
to the specified device. Result does not alias argument.
Use this if object is not owned or should be copied.
"""
if obj is None:
return obj
if torch.is_tensor(obj):
assert obj.is_leaf
if obj.device == device:
return obj.clone().detach()
return obj.to(device).detach()
if isinstance(obj, OrderedDict):
return OrderedDict((k, deep_copy_to(v, device)) for k, v in obj.items())
if isinstance(obj, dict):
return {k: deep_copy_to(v, device) for k, v in obj.items()}
if isinstance(obj, list):
return [deep_copy_to(v, device) for v in obj]
if isinstance(obj, tuple):
return tuple(deep_copy_to(v, device) for v in obj)
raise TypeError("Invalid type '" + str(type(obj)) + "' for deep_copy_to")
def move_to(obj: Any, device: torch.device) -> Any:
"""
Moves built-in Python data structures containing leaf Tensors
to the specified device. obj is updated in place if possible.
Use this for owned objects.
"""
if obj is None:
return
if torch.is_tensor(obj): # tensor, cannot update in place
assert obj.is_leaf
return obj.to(device).detach()
if isinstance(obj, dict):
for k, v in obj.items():
obj[k] = move_to(v, device)
return obj
if isinstance(obj, list):
for i in range(len(obj)):
obj[i] = move_to(obj[i], device)
return obj
if isinstance(obj, tuple): # tuple, cannot update in place
return tuple(move_to(v, device) for v in obj)
raise TypeError("Invalid type '" + str(type(obj)) + "' for move_to")
def deep_copy_to_no_clone(obj: Any, device: torch.device) -> Any:
"""
Copies Python data structures containing leaf tensors, but does
not make guarantees about aliasing. Use with caution when Tensor
aliasing is unimportant and Tensors just need to go to the
respective device. Probably in almost all cases you want to use
deep_copy_to or move_to instead.
"""
if obj is None:
return obj
if torch.is_tensor(obj):
assert obj.is_leaf
return obj.to(device).detach()
if isinstance(obj, OrderedDict):
return OrderedDict(
(k, deep_copy_to_no_clone(v, device)) for k, v in obj.items()
)
if isinstance(obj, dict):
return {k: deep_copy_to_no_clone(v, device) for k, v in obj.items()}
if isinstance(obj, list):
return [deep_copy_to_no_clone(v, device) for v in obj]
if isinstance(obj, tuple):
return tuple(deep_copy_to_no_clone(v, device) for v in obj)
raise TypeError("Invalid type '" + str(type(obj)) + "' for deep_copy_to_no_clone")
| 3,491 | 35.375 | 86 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/logging.py | import os
import sys
import torch
import socket
from datetime import datetime
try:
from pip._internal.operations import freeze
except ImportError: # pip < 10.0
from pip.operations import freeze
def get_log_file_name(log_prefix=None):
log_dir = os.path.realpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "logs"))
if not os.path.exists(log_dir):
os.makedirs(log_dir, exist_ok=True)
if log_prefix is not None:
log_file = f"{log_prefix}"
else:
log_file = ""
date = datetime.now().strftime("%Y_%m_%d-%H_%M_%S")
log_file = log_file + "__" + date
n_name_duplicates = len([x for x in os.listdir(log_dir) if x.startswith(log_file)])
if n_name_duplicates > 0:
log_file = log_file + "__" + chr(64+n_name_duplicates)
log_file_name = os.path.join(log_dir, log_file + '_log.txt')
return log_file_name
class Logger(object):
def __init__(self, filename, stdout):
self.terminal = stdout
self.log = open(filename, "a")
def write(self, message):
self.terminal.write(message)
self.log.write(message)
def flush(self):
self.terminal.flush()
self.log.flush()
def close(self):
self.log.close()
def _get_writer(self, verbose):
def write(str):
if verbose:
print(str)
else:
self.log.write(str+"\n")
return write
def log_default(self, args):
self.log_devices(verbose=True)
self.log_ptyhon(verbose=True)
self.log_torch(verbose=True)
self.log_host(verbose=False)
self.log_env(verbose=False)
self.log_args(args, verbose=False)
print("")
def log_env(self, verbose=False):
write = self._get_writer(verbose)
write("\nEnvironment Info:")
pkgs = freeze.freeze()
for pkg in pkgs:
write(pkg)
def log_host(self, verbose=False):
write = self._get_writer(verbose)
hostname = socket.gethostname()
write(f"\nHostname: {hostname}")
def log_ptyhon(self, verbose=False):
write = self._get_writer(verbose)
write(f"\nPython Version:\n{sys.version}")
def log_torch(self, verbose=False):
write = self._get_writer(verbose)
write(f"\nTorch Version:\n{torch.__version__}")
write(f"CUDA Version:\n{torch.version.cuda}")
write(f"CUDA PATH:\n{os.environ['CUDA_PATH'] if 'CUDA_PATH' in os.environ else 'None'}")
write(f"CUDA Home:\n{os.environ['CUDA_HOME'] if 'CUDA_HOME' in os.environ else 'None'}")
def log_devices(self, verbose=False):
write = self._get_writer(verbose)
write("\nDevice Info:")
n_device = torch.cuda.device_count()
for i in range(n_device):
write(f"{i}: {torch.cuda.get_device_name(i)}")
def log_args(self, args, verbose=False):
write = self._get_writer(verbose)
write("\nArgs:")
def write_dict(x, depth=0):
for key in x.keys():
if key.startswith("_"): continue
if "config" in str(type(x[key])):
write(f"{depth*' '}{key}:")
write_dict(x[key].__dict__, depth=depth+1)
continue
write(f"{depth*' '}{key}: {x[key]}")
write_dict(args.__dict__)
| 3,382 | 30.036697 | 108 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/sig_precompute.py | from typing import Callable, List, Tuple, Union
import torch
from torch import Tensor
from src.abstract_layers.abstract_sig_base import SigBase
from src.abstract_layers.abstract_sigmoid import d_sig, sig
from src.abstract_layers.abstract_tanh import d_tanh, tanh
from src.utilities.bilinear_interpolator import BilinearInterpol
def approx_diff_integral(
l1: Tensor,
b1: Tensor,
f2: Callable[[Tensor], Tensor],
lb: float,
ub: float,
steps: int = 1000,
) -> Tensor:
x = torch.linspace(lb, ub, steps)
y = l1 * x + b1
y_2 = f2(x)
return torch.abs(y - y_2).sum() * (ub - lb) / steps
# Top be set in main
act: Callable[[Tensor], Tensor] = sig
d_act: Callable[[Tensor], Tensor] = d_sig
def get_best_split_for_bounds(
lb: float, ub: float, tangent_points: Tensor, steps: int = 200
) -> float:
poss_c = torch.linspace(lb, ub, steps)
lbs = lb * torch.ones_like(poss_c)
ubs = ub * torch.ones_like(poss_c)
# Get bounds
(
lb_slope_l,
ub_slope_l,
lb_intercept_l,
ub_intercept_l,
) = SigBase._get_approximation_slopes_and_intercepts_for_act(
bounds=(lbs, poss_c),
tangent_points=tangent_points,
step_size=0.01,
max_x=500,
act=act,
d_act=d_act,
)
(
lb_slope_u,
ub_slope_u,
lb_intercept_u,
ub_intercept_u,
) = SigBase._get_approximation_slopes_and_intercepts_for_act(
bounds=(poss_c, ubs),
tangent_points=tangent_points,
step_size=0.01,
max_x=500,
act=act,
d_act=d_act,
)
best_c = -1
best_v: Union[float, Tensor] = torch.inf
for i, c in enumerate(poss_c):
lower_cont_l = approx_diff_integral(
lb_slope_l[i], lb_intercept_l[i], act, lb, c
)
lower_cont_u = approx_diff_integral(
ub_slope_l[i], ub_intercept_l[i], act, lb, c
)
upper_cont_l = approx_diff_integral(
lb_slope_u[i], lb_intercept_u[i], act, c, ub
)
upper_cont_u = approx_diff_integral(
ub_slope_u[i], ub_intercept_u[i], act, c, ub
)
diff = lower_cont_l + lower_cont_u + upper_cont_l + upper_cont_u
# print(f"{i}: c- {c} diff - {diff}")
if diff < best_v:
best_c = c
best_v = diff
return best_c
def get_training_data(
lb: float, ub: float, steps: int, tangent_points: Tensor
) -> Tuple[Tensor, Tensor, Tensor]:
bound_l: List[float] = []
bound_u: List[float] = []
centers: List[float] = []
for cub in torch.linspace(lb, ub, steps):
for clb in torch.linspace(lb, ub, steps):
if clb >= cub:
continue
c = get_best_split_for_bounds(clb, cub, tangent_points, steps=500)
bound_l.append(clb)
bound_u.append(cub)
centers.append(c)
print(f"LB {clb} UB {cub} Center {c}")
return torch.Tensor(bound_l), torch.Tensor(bound_u), torch.Tensor(centers)
if __name__ == "__main__":
generate_data = False
generate_interpol = True
eval_interpol = False
use_sig = True
# Set activation and derivative
if use_sig:
act = sig
d_act = d_sig
else:
act = tanh
d_act = d_tanh
name = str(act).split(" ")[1]
(
intersection_points,
tangent_points,
step_size,
max_x,
) = SigBase._compute_bound_to_tangent_point(act, d_act)
if generate_data:
bound_l, bound_u, centers = get_training_data(-495, 495, 199, tangent_points)
torch.save(bound_l, f"./data/{name}_bound_l_495_5.pt")
torch.save(bound_u, f"./data/{name}_bound_u_495_5.pt")
torch.save(centers, f"./data/{name}_centers_495_5.pt")
bound_l, bound_u, centers = get_training_data(-15, 15, 61, tangent_points)
torch.save(bound_l, f"./data/{name}_bound_l_15.pt")
torch.save(bound_u, f"./data/{name}_bound_u_15.pt")
torch.save(centers, f"./data/{name}_centers_15.pt")
if generate_interpol:
store_at_path = f"./data/{name}_bil_interpol.pkl"
inner_l = torch.load(f"./data/{name}_bound_l_15.pt")
inner_u = torch.load(f"./data/{name}_bound_u_15.pt")
inner_c = torch.load(f"./data/{name}_centers_15.pt")
inner = [(inner_l[i], inner_u[i], inner_c[i]) for i in range(len(inner_l))]
outer_l = torch.load(f"./data/{name}_bound_l_495_5.pt")
outer_u = torch.load(f"./data/{name}_bound_u_495_5.pt")
outer_c = torch.load(f"./data/{name}_centers_495_5.pt")
outer = [(outer_l[i], outer_u[i], outer_c[i]) for i in range(len(outer_l))]
interpol = BilinearInterpol.create_from_data(inner, outer, 15, 495, 0.5, 5)
interpol.store_to_path(store_at_path)
if eval_interpol:
load_from_path = f"./data/{name}_bil_interpol.pkl"
interpol = BilinearInterpol.load_from_path(load_from_path)
# plot_points_3d(bound_l, bound_u, centers)
# plot_points_fix_ub(-200, 15)
# diffs = []
# rel_diffs = []
# for ub in torch.linspace(-14, 14, 200):
# for lb in torch.linspace(-14, 14, 200):
# if lb >= ub:
# continue
# start_time = time.time()
# opt_c = get_best_split_for_bounds(lb, ub, tangent_points, steps=100)
# total_time = time.time() - start_time
# start_time = time.time()
# reg_c = interpol.get_value(lb, ub)
# total_time2 = time.time() - start_time
# diffs.append(abs(opt_c - reg_c))
# if abs(opt_c - reg_c) > 100:
# reg_c = interpol.get_value(lb, ub)
# rel_diffs.append(abs(opt_c - reg_c) / (ub - lb))
# print(
# f"Opt: {opt_c} Diff: {abs(opt_c-reg_c)} Time: {total_time} Reg: {reg_c} Time: {total_time2}"
# )
# print("============")
# diffs = torch.Tensor(diffs)
# rel_diffs = torch.Tensor(rel_diffs)
# print(f"Avg: {diffs.sum()/diffs.numel()} Max: {torch.max(diffs)}")
# print(
# f"Rel. Avg: {rel_diffs.sum()/rel_diffs.numel()} Max: {torch.max(rel_diffs)}"
# )
# def plot_approx(l1_l: float, b1_l: float, l1_u: float, b1_u: float, l2_l: float, b2_l:float, l2_u: float, b2_u:float, f2: Callable[[Tensor], Tensor], lb: float, c: float, ub: float, steps: int = 1000):
# x1 = torch.linspace(lb, c, steps)
# x2 = torch.linspace(c, ub, steps)
# y1_l = l1_l*x1+b1_l
# y1_u = l1_u*x1+b1_u
# y2_l = l2_l*x2+b2_l
# y2_u = l2_u*x2+b2_u
# y1 = f2(x1)
# y2 = f2(x2)
# plt.plot(x1, y1_l, label = "Linear Lower")
# plt.plot(x1, y1_u, label = "Linear Upper")
# plt.plot(x1, y1, label = "Sigmoid")
# plt.plot(x2, y2_l, label = "Linear Lower")
# plt.plot(x2, y2_u, label = "Linear Upper")
# plt.plot(x2, y2, label = "Sigmoid")
# plt.show()
# def plot_points_3d(x1: Tensor, x2: Tensor, y: Tensor):
# fig = plt.figure()
# ax = fig.add_subplot(projection='3d')
# ax.scatter(x1,x2,y)
# plt.show()
# def plot_points_fix_ub(lb:float, ub: float):
# bound_l_select = []
# center_select = []
# for lb in torch.linspace(lb, ub, 1000):
# opt_c = get_best_split_for_bounds(lb, ub, tangent_points, steps=500)
# bound_l_select.append(lb)
# center_select.append(opt_c)
# bound_l_select = torch.Tensor(bound_l_select)
# center_select = torch.Tensor(center_select)
# plt.plot(bound_l_select,center_select)
# plt.title(f"Upper_bound = {ub}")
# plt.show()
| 7,691 | 33.648649 | 203 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/output_property_form.py | import itertools
from typing import List, Optional, Tuple
import torch
import torch.nn as nn
from torch import Tensor
class OutputPropertyForm:
"""
Represents an output property-formula in CNF.
Each atom of the formula corresponds to a gt_tuple of the form (a,b,c) <=> a - b >= c
property_matrix: a Tensor containing the query-coef for all sub-formulas row-wise
property_threshold: a Tensor containing the c values for each gt_tuple
combination_matrix: a num_clausels x num_gt_tuple matrix containing 1 in entry (i,j) if clausel i contains gt_tuple j
disjunction_adapters: for every non-trivial disjunctive clause contains the linear+relu encoding to jointly optimize the network for this clause
"""
def __init__(
self,
properties_to_verify: List[List[Tuple[int, int, float]]],
property_matrix: Tensor,
property_threshold: Tensor,
combination_matrix: Tensor,
disjunction_adapter: Optional[nn.Sequential],
use_disj_adapter: bool,
n_class: int,
device: torch.device,
dtype: torch.dtype,
) -> None:
self.properties_to_verify = properties_to_verify
self.property_matrix = property_matrix
self.property_threshold = property_threshold
self.combination_matrix = combination_matrix
self.disjunction_adapter = disjunction_adapter
self.use_disj_adapter = use_disj_adapter
self.has_counter_example: bool = False
self.n_class = n_class
self.device = device
self.dtype = dtype
@classmethod
def create_from_properties(
cls,
properties_to_verify: List[List[Tuple[int, int, float]]],
disjunction_adapter: Optional[nn.Sequential],
use_disj_adapter: bool,
n_class: int,
device: torch.device,
dtype: torch.dtype,
) -> "OutputPropertyForm":
# properties_to_verify = sorted(properties_to_verify)
all_gt_tuples = list(
dict.fromkeys([*itertools.chain.from_iterable(properties_to_verify)])
)
gt_map = {x: i for i, x in enumerate(all_gt_tuples)}
n_constraints = len(all_gt_tuples)
property_matrix = torch.zeros(
(n_constraints, n_class), device=device, dtype=dtype
)
property_threshold = torch.zeros((n_constraints,), device=device, dtype=dtype)
combination_matrix = torch.zeros(
(len(properties_to_verify), n_constraints), device=device, dtype=dtype
)
# These compute the disjunction a > x_1 || a - b > x_2 as ReLU(a-x_1) + ReLU(a-b-x_2) > 0
# Check whether we have a true disjunction
has_proper_disjunction = True in [
len(clausel) > 1 for clausel in properties_to_verify
]
if has_proper_disjunction:
assert disjunction_adapter is None
for property in all_gt_tuples:
if property[0] != -1:
property_matrix[gt_map[property], property[0]] = 1
property_threshold[gt_map[property]] = torch.as_tensor(property[2])
else:
property_threshold[gt_map[property]] = -torch.as_tensor(property[2])
if property[1] != -1:
property_matrix[gt_map[property], property[1]] = -1
for and_property_counter, and_property in enumerate(properties_to_verify):
for or_property_counter, or_property in enumerate(and_property):
combination_matrix[and_property_counter, gt_map[or_property]] = 1
if use_disj_adapter and has_proper_disjunction:
dis_layer = nn.Linear(n_class, n_constraints, bias=True)
dis_layer.weight.data = property_matrix
dis_layer.bias.data = -property_threshold + 1e-5
n_class = len(properties_to_verify)
sum_layer = nn.Linear(
n_constraints, len(properties_to_verify), bias=True
) # One output per property
sum_layer.weight.data = combination_matrix
sum_layer.bias.data = torch.zeros_like(
sum_layer.bias
) - 1e-5 * combination_matrix.sum(1).to(sum_layer.bias.device)
disjunction_adapter = nn.Sequential(*[dis_layer, nn.ReLU(), sum_layer])
disjunction_adapter.requires_grad_(False)
property_matrix = torch.eye(
len(properties_to_verify), device=device, dtype=dtype
)
property_threshold = torch.zeros(
len(properties_to_verify), device=device, dtype=dtype
)
combination_matrix = torch.eye(
len(properties_to_verify), device=device, dtype=dtype
)
properties_to_verify = [
[(i, -1, 0)] for i, prop in enumerate(properties_to_verify)
]
return cls(
properties_to_verify,
property_matrix.unsqueeze(0),
property_threshold.unsqueeze(0),
combination_matrix.unsqueeze(0),
disjunction_adapter,
use_disj_adapter,
n_class,
device,
dtype,
)
def update_properties_to_verify(
self,
verified: Tensor,
falsified: Tensor,
query_lbs: Tensor,
true_ub: bool,
ignore_and_falsified: bool = False,
easiest_and_first: bool = True,
) -> "OutputPropertyForm":
new_properties_to_verify = []
and_properties_verified = (
torch.einsum(
"bij,bj -> bi",
self.combination_matrix,
verified.to(self.combination_matrix.dtype),
)
>= 1
)
and_properties_falsified = torch.einsum(
"bij,bj -> bi",
self.combination_matrix,
falsified.to(self.combination_matrix.dtype),
) == self.combination_matrix.sum(-1)
if not true_ub:
# Different or clauses might have been falsified for different points
and_properties_falsified = torch.where(
self.combination_matrix.sum(-1) == 1,
and_properties_falsified,
torch.zeros_like(and_properties_falsified),
)
if and_properties_falsified.any(1).all(0) and not ignore_and_falsified:
# counterexample will be found by standard inference
self.has_counter_example = True
return self
and_queries_lbs = []
for and_property_counter, and_property in enumerate(self.properties_to_verify):
if and_properties_verified[:, and_property_counter].all():
continue
if (
self.combination_matrix[0, and_property_counter].unsqueeze(0)
== self.combination_matrix[:, and_property_counter]
).all():
and_property_filtered = []
or_queries_lbs = []
and_property_idx = self.combination_matrix[
0, and_property_counter
].bool()
for or_property, falsified_prop, query_lb in zip(
and_property,
falsified.all(0)[and_property_idx],
query_lbs.min(0)[0][and_property_idx],
):
if falsified_prop and true_ub:
continue
and_property_filtered.append(or_property)
or_queries_lbs.append(query_lb.item())
else:
and_property_filtered = and_property
or_queries_lbs = query_lbs.min(0)[0][
self.combination_matrix[0, and_property_counter].bool()
].tolist()
and_property_filtered = [
x
for _, x in sorted(
zip(or_queries_lbs, and_property_filtered), reverse=True
)
] # "easiest" properties first => verificaiton
and_queries_lbs.append(
query_lbs[self.combination_matrix[:, and_property_counter].bool()].min()
)
new_properties_to_verify.append(and_property_filtered)
new_properties_to_verify = [
x
for _, x in sorted(
zip(and_queries_lbs, new_properties_to_verify),
reverse=easiest_and_first,
)
] # "hardest" and properties first for better falsification
# Update
return OutputPropertyForm.create_from_properties(
new_properties_to_verify,
self.disjunction_adapter,
self.use_disj_adapter,
self.n_class,
self.device,
self.dtype,
)
def get_unit_clauses(self) -> List[Tuple[int, List[Tuple[int, int, float]]]]:
unit_clauses = [
(i, clause)
for i, clause in enumerate(self.properties_to_verify)
if len(clause) == 1
]
return unit_clauses
| 9,001 | 37.969697 | 148 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/onnx_loader.py | import warnings
from collections import defaultdict
from typing import Any, DefaultDict, Dict, List, Optional, Set, Tuple
import numpy as np
import onnx # type: ignore[import]
import torch
from onnx import numpy_helper
from torch import Tensor, nn
from onnx2pytorch.onnx2pytorch.convert.operations import ( # type: ignore[import] # noqa: E402; noqa: E402
Loop,
convert_operations,
get_buffer_name,
)
from onnx2pytorch.onnx2pytorch.operations.div import Div # type: ignore[import]
from onnx2pytorch.onnx2pytorch.operations.mul import Mul
from onnx2pytorch.onnx2pytorch.operations.reducesum import (
ReduceSum, # type: ignore[import]
)
from onnx2pytorch.onnx2pytorch.operations.shape import Shape # type: ignore[import]
from onnx2pytorch.onnx2pytorch.operations.split import Split # type: ignore[import]
from onnx2pytorch.onnx2pytorch.utils import ( # type: ignore[import] # noqa: E402
get_inputs_names,
get_outputs_names,
)
from src.concrete_layers.binary_op import BinaryOp
from src.concrete_layers.concat import Concat
from src.concrete_layers.multi_path_block import MultiPathBlock
from src.concrete_layers.pad import Pad
from src.concrete_layers.permute import Permute
from src.concrete_layers.reshape import Reshape
from src.concrete_layers.residual_block import ResidualBlock
from src.concrete_layers.slice import Slice
from src.concrete_layers.split_block import SplitBlock
from src.concrete_layers.unbinary_op import UnbinaryOp
class ConvertModel(nn.Module):
def __init__(
self,
onnx_model: onnx.ModelProto,
batch_dim: int = 0,
experimental: bool = False,
debug: bool = False,
enable_pruning: bool = False,
):
"""
Convert onnx model to pytorch.
Parameters
----------
onnx_model: onnx.ModelProto
Loaded onnx model.
batch_dim: int
Dimension of the batch.
experimental: bool
Experimental implementation allows batch_size > 1. However,
batchnorm layers could potentially produce false outputs.
enable_pruning: bool
Track kept/pruned indices between different calls to forward pass.
Returns
-------
model: torch.nn.Module
A converted pytorch model.
"""
super().__init__()
self.onnx_model = onnx_model
self.batch_dim = batch_dim
self.experimental = experimental
self.debug = debug
self.enable_pruning = enable_pruning
self.input_names = get_inputs_names(onnx_model.graph)
self.output_names = get_outputs_names(onnx_model.graph)
opset_version = onnx_model.opset_import[0].version
# Store initializers as buffers
buffer_names = set({})
inits: Dict[str, Tensor] = {}
for tensor in self.onnx_model.graph.initializer:
buffer_name = get_buffer_name(tensor.name)
buffer_names.add(tensor.name)
self.register_buffer(
buffer_name,
torch.from_numpy(numpy_helper.to_array(tensor)),
)
inits[tensor.name] = torch.from_numpy(numpy_helper.to_array(tensor))
# TODO Set values for Constant nodes as init values
const_nodes = [n for n in self.onnx_model.graph.node if n.op_type == "Constant"]
self.const_nodes: Dict[str, Any] = {}
for cn in const_nodes:
self.const_nodes[cn.output[0]] = torch.from_numpy(
numpy_helper.to_array(cn.attribute[0].t)
)
self.all_consts: Dict[str, Any] = {**inits, **self.const_nodes}
# Create mapping from node (identified by first output) to submodule
self.mapping: Dict[str, str] = {}
for op_id, op_name, op in convert_operations(
onnx_model.graph, opset_version, batch_dim, enable_pruning, self.all_consts
):
setattr(self, op_name, op)
if isinstance(op, Loop) and debug:
raise NotImplementedError("debug-mode with Loop node not implemented.")
self.mapping[op_id] = op_name
# Compute activation dependencies, mapping each node to its dependents
self.needed_by = compute_activation_dependencies(
self.onnx_model.graph, self, self.mapping
)
# Reverse activation dependencies to identify merge nodes for ResNets
self.cg_needs: Dict[str, List[str]] = {} # Pure computation graph
self.needs: Dict[str, List[str]] = {} # Contains initializers and constants
for (k, v) in self.needed_by.items():
for v_i in v:
if (
"weight" not in k
and "bias" not in k
and k not in buffer_names
and k not in self.const_nodes
):
if v_i not in self.cg_needs:
self.cg_needs[v_i] = [k]
else:
self.cg_needs[v_i].append(k)
if v_i not in self.needs:
self.needs[v_i] = [k]
else:
self.needs[v_i].append(k)
self.ordered_nodes = list(self.onnx_model.graph.node)
if experimental:
warnings.warn(
"Using experimental implementation that allows 'batch_size > 1'."
"Batchnorm layers could potentially produce false outputs."
)
def forward_trace_to_graph(self) -> nn.Sequential:
id = self.input_names[0]
module_list: List[nn.Module] = []
from_multipath = False
while id in self.needed_by:
if len(list(self.needed_by[id])) > 1:
merge_op = self.get_op_by_out_id(self._find_merge_id(id))
if (
isinstance(merge_op, BinaryOp)
and merge_op.op == "add"
and len(list(self.needed_by[id])) == 2
):
# ResBlock suffices
res_block, out_id = self._build_res_block(id)
module_list.append(res_block)
from_multipath = False
else:
multi_path, out_id = self._build_multi_path_block(id)
module_list.append(multi_path)
from_multipath = True
else:
if not from_multipath: # Multipaths return the next element already
id = list(self.needed_by[id])[0]
module, out_id = self._build_seq_model(
out_op_id=id, add_final_node=True
)
assert module is not None
module_list.append(module)
from_multipath = False
id = out_id
module = self._flatten_module_list(module_list)
assert module is not None
return module
def forward_trace_to_graph_unet(self) -> nn.Sequential:
# Specific parsing for the carvana-unet benchmark
id = self.input_names[0]
module_list: List[nn.Module] = []
while id in self.needed_by:
id = sorted(list(self.needed_by[id]), key=(lambda x: int(x)))[
0
] # We only follow the "nearest child"
module, out_id = self._build_seq_model(
out_op_id=id, add_final_node=True, parse_unet=True
)
assert module is not None
module_list.append(module)
id = out_id
module = self._flatten_module_list(module_list)
assert module is not None
return module
def _flatten_module_list(self, module_list: List[nn.Module]) -> nn.Sequential:
"""Only does a shallow flatten pass"""
flat_mod_list: List[nn.Module] = []
if len(module_list) == 1 and isinstance(module_list[0], nn.Sequential):
return module_list[0]
for m in module_list:
if isinstance(m, nn.Sequential):
flat_mod_list.extend(m)
else:
flat_mod_list.append(m) # type:ignore [arg-type]
return nn.Sequential(*flat_mod_list)
def _build_seq_model(
self,
out_op_id: str,
convert_to_seq: bool = True,
add_final_node: bool = False,
parse_unet: bool = False,
) -> Tuple[Optional[nn.Sequential], str]:
seq_layers = []
while True:
op = self.get_op_by_out_id(out_op_id)
if (
len(self.cg_needs[out_op_id]) > 1
): # Found merge node at end of sequential path
break
# Special NN4Sys Split-Block (Note: only has self.needed_by[out_op_id]==1)
if isinstance(op, Split):
op, out_op_id = self._build_split_block(out_op_id)
if out_op_id in self.needed_by and len(self.needed_by[out_op_id]) > 1:
if len(self.needed_by[out_op_id]) == 2: # Default residual block
seq_layers.append(
op
) # Add the header as residual nets don't carry it
op, out_op_id = self._build_res_block(out_op_id)
else: # Multipath residual block
op, out_op_id = self._build_multi_path_block(out_op_id, parse_unet)
else:
out_op_id = list(self.needed_by[out_op_id])[0]
if op is not None:
seq_layers.append(op)
if (
out_op_id not in self.needed_by and add_final_node
): # The final node in the graph
op = self.get_op_by_out_id(out_op_id)
if op is not None:
seq_layers.append(op)
break
if convert_to_seq:
seq_layers = [
layer for layer in seq_layers if issubclass(type(layer), nn.Module)
] # Filters out Argmax
return nn.Sequential(*seq_layers), out_op_id
else:
return None, out_op_id
def _build_multi_path_block(
self, out_op_id: str, parse_unet: bool = False
) -> Tuple[nn.Module, str]:
needed_by_id_list = list(self.needed_by[out_op_id])
bb: nn.Module
# Handle flatten
if len(needed_by_id_list) == 2:
is_flatten, flatten_merge_id = self._is_flatten(
needed_by_id_list[0], needed_by_id_list[1]
)
if is_flatten:
bb = nn.Flatten()
merge_id = flatten_merge_id
next_id_list = list(self.needed_by[merge_id])
assert len(next_id_list) == 1
ret_id = next_id_list[0]
return bb, ret_id
try:
header = self.get_op_by_out_id(out_op_id)
except KeyError:
header = None
merge_ids: List[str] = []
paths: List[nn.Sequential] = []
sorted_ids = sorted(list(needed_by_id_list), key=(lambda x: int(x)))
if parse_unet:
sorted_ids = [
sorted_ids[0],
sorted_ids[-1],
] # Only follow lowest and highest path
for path_start_id in sorted_ids:
if parse_unet:
# Carvana-Unet Upsample specific - We want to skip all padding calculations
op = self.get_op_by_out_id(out_op_id)
if isinstance(op, nn.ConvTranspose2d):
pad_id = sorted_ids[-1]
pad_op = self.get_op_by_out_id(pad_id)
assert isinstance(pad_op, Pad)
pad_op.pad = (0, 1, 0, 1)
unet_merge_id = list(self.needed_by[pad_id])[0]
return nn.Sequential(*[op, pad_op]), unet_merge_id
path, merge_id = self._build_seq_model(
path_start_id,
convert_to_seq=True,
add_final_node=False,
parse_unet=parse_unet,
)
if path is None:
path = nn.Sequential(*[nn.Identity()])
paths.append(path)
merge_ids.append(merge_id)
else:
path, merge_id = self._build_seq_model(path_start_id)
assert path is not None
paths.append(path)
merge_ids.append(merge_id)
merge_id = merge_ids[0]
for i, mi in enumerate(merge_ids):
assert mi == merge_id
assert isinstance(paths[i], nn.Sequential)
merge = self.get_op_by_out_id(merge_id)
if parse_unet: # Very dirty u-net hack
if len(paths[1]) == 0:
paths.reverse()
if header is not None and not isinstance(header, Slice):
bb = nn.Sequential(
*(header, MultiPathBlock(header=None, paths=paths, merge=merge))
)
else:
bb = MultiPathBlock(header=header, paths=paths, merge=merge)
# Move over the merge_block
if merge_id not in self.needed_by: # We are at the final node
return bb, merge_id
next_id_list = list(self.needed_by[merge_id])
assert len(next_id_list) == 1
ret_id = next_id_list[0]
return bb, ret_id
def _is_flatten(
self, path_a_start_id: str, path_b_start_id: str
) -> Tuple[bool, str]:
is_a_flatten = isinstance(self.get_op_by_out_id(path_a_start_id), Shape)
is_b_flatten = isinstance(self.get_op_by_out_id(path_b_start_id), Shape)
if is_a_flatten or is_b_flatten: # Actually we run a flatten operation
if is_a_flatten:
_, merge_id_a = self._build_seq_model(
path_a_start_id, convert_to_seq=False
)
assert (
merge_id_a == path_b_start_id
), "Unknown sequence of shape operators"
merge_id = merge_id_a
else:
_, merge_id_b = self._build_seq_model(
path_b_start_id, convert_to_seq=False
)
assert (
merge_id_b == path_a_start_id
), "Unknown sequence of shape operators"
merge_id = merge_id_b
return (True, merge_id)
else:
return (False, path_a_start_id)
def _build_res_block(self, out_op_id: str) -> Tuple[nn.Module, str]:
assert (
len(self.needed_by[out_op_id]) == 2
), "Cannot deal with more than 2 paths in ResidualBlock"
needed_by_id_list = list(self.needed_by[out_op_id])
path_a_start_id, path_b_start_id = needed_by_id_list[0], needed_by_id_list[1]
# Handle Flatten via Res-Block
is_flatten, flatten_merge_id = self._is_flatten(
path_a_start_id, path_b_start_id
)
bb: nn.Module
if is_flatten: # Actually we run a flatten operation
merge_id = flatten_merge_id
bb = nn.Flatten()
else:
path_a, merge_id_a = self._build_seq_model(
path_a_start_id,
)
path_b, merge_id_b = self._build_seq_model(
path_b_start_id,
)
assert merge_id_a == merge_id_b, "Paths try to merge at different points"
merge_id = merge_id_a
assert isinstance(path_a, nn.Sequential)
assert isinstance(path_b, nn.Sequential)
bb = ResidualBlock(path_a=path_a, path_b=path_b)
return bb, merge_id
def _build_split_block(self, out_op_id: str) -> Tuple[nn.Module, str]:
split_center_id = out_op_id
split_res_id = str(int(out_op_id) + 1) # :/
assert (
len(self.needed_by[split_center_id]) == 1
), "Center path split needed only once."
center_start_id = list(self.needed_by[split_center_id])[0]
assert len(self.needed_by[split_res_id]) == 2, "Expected 2 residual paths."
center_path, inner_merge_id = self._build_seq_model(
center_start_id,
)
# Check inner merge
assert (
inner_merge_id in self.needed_by[split_res_id]
), "Unkown inner merge point"
assert isinstance(self.get_op_by_out_id(inner_merge_id), Mul)
# Handle reduce sums
outer_reduce_id = list(self.needed_by[split_res_id] - {inner_merge_id})[0]
inner_reduce_id = list(self.needed_by[inner_merge_id])[0]
assert isinstance(self.get_op_by_out_id(inner_reduce_id), ReduceSum)
assert isinstance(self.get_op_by_out_id(outer_reduce_id), ReduceSum)
# Check final div
inner_red_merge_id = list(self.needed_by[inner_reduce_id])[0]
outer_red_merge_id = list(self.needed_by[outer_reduce_id])[0]
assert inner_red_merge_id == outer_red_merge_id, "No unique final merge point"
merge_id = inner_red_merge_id
assert isinstance(
self.get_op_by_out_id(merge_id), Div
), "Not div as final merge"
# Split-Info
split = self.get_op_by_out_id(split_center_id)
split_info: Tuple[bool, Tuple[int, ...], Optional[int], int, bool] = (
split.enable_pruning, # type:ignore[assignment]
split.split_size_or_sections, # type:ignore[assignment]
split.number_of_splits, # type:ignore[assignment]
split.dim, # type:ignore[assignment]
split.keep_size, # type:ignore[assignment]
)
# Reduce-Info
inner_reduce = self.get_op_by_out_id(inner_reduce_id)
outer_reduce = self.get_op_by_out_id(outer_reduce_id)
red_inner_info: Tuple[int, bool, bool] = (
inner_reduce.dim, # type:ignore[assignment]
inner_reduce.keepdim, # type:ignore[assignment]
inner_reduce.noop_with_empty_axes, # type:ignore[assignment]
)
red_outer_info: Tuple[int, bool, bool] = (
outer_reduce.dim, # type:ignore[assignment]
outer_reduce.keepdim, # type:ignore[assignment]
outer_reduce.noop_with_empty_axes, # type:ignore[assignment]
)
assert center_path is not None
return (
SplitBlock(split_info, center_path, red_inner_info, red_outer_info),
merge_id,
)
def _find_merge_id(self, start_id: str) -> str:
needed_by_id_list = list(self.needed_by[start_id])
merge_ids: List[str] = []
def sort_fun(x: str) -> int:
try:
return int(x)
except Exception:
return int("".join(x for x in x if x.isdigit()))
sorted_ids = sorted(list(needed_by_id_list), key=sort_fun)
for path_start_id in sorted_ids:
_, merge_id = self._build_seq_model(path_start_id)
merge_ids.append(merge_id)
merge_id = merge_ids[0]
for mi in merge_ids:
assert mi == merge_id
return merge_id
def get_op_by_out_id(self, out_op_id: str) -> nn.Module:
out_op_name = self.mapping[out_op_id]
out_op_name_pref = out_op_name.split("_")[0].lower()
op = getattr(self, out_op_name)
# @Fix the operator order for Linear in case the MatMul is with an A argument
if out_op_name_pref == "matmul":
if (
self.cg_needs[out_op_id][0] == self.needs[out_op_id][1]
): # Multiply with matrix rhs A*x
has_bias = op.bias is not None
new_ll = nn.Linear(
in_features=op.out_features,
out_features=op.in_features,
bias=has_bias,
)
new_ll.weight = nn.Parameter(op.weight.detach().T)
assert op.bias.dim() == 1
new_ll.bias = nn.Parameter(op.bias.detach())
# new_ll.bias = nn.Parameter(op.bias.detach().T)
op = new_ll
return op
# Deals with operations where one part is already pre-loaded
if (
out_op_name_pref in {"add", "sub", "div", "mul"}
and len(self.cg_needs[out_op_id]) <= 1
): # Ignore Add's at merge point
assert len(self.needs[out_op_id]) == 2, "Too many inputs for Binary Op"
val = None
apply_right = False
if self.needs[out_op_id][0] in self.all_consts:
val = self.all_consts[self.needs[out_op_id][0]]
apply_right = True
else:
assert (
self.needs[out_op_id][1] in self.all_consts
), "Value not not found for UnbinaryOp"
val = self.all_consts[self.needs[out_op_id][1]]
return UnbinaryOp(out_op_name_pref, const_val=val, apply_right=apply_right)
# Deals with batchnorm
if out_op_name_pref == "batchnormalization":
bnu = op.bnu
new_bn = nn.BatchNorm2d(
num_features=bnu.num_features, eps=bnu.eps, momentum=bnu.momentum
)
new_bn.running_mean = bnu.running_mean
new_bn.running_var = bnu.running_var
new_bn.weight = bnu.weight
new_bn.bias = bnu.bias
return new_bn
# Deals with Padding layers
if out_op_name_pref == "pad":
return Pad(op.padding, op.mode, op.constant)
# Deals with Transpose/Permutation layers - # TODO not totally clean
if out_op_name_pref == "transpose":
return Permute(op.dims)
if out_op_name_pref == "reshape":
if (
op.shape is None and len(self.needs[out_op_id]) > 1
): # Actually load shape from constant
assert len(self.needs[out_op_id]) == 2
if self.needs[out_op_id][0] in self.const_nodes:
op.shape = self.const_nodes[self.needs[out_op_id][0]].numpy()
if self.needs[out_op_id][1] in self.const_nodes:
op.shape = self.const_nodes[self.needs[out_op_id][1]].numpy()
if op.shape is None or len(op.shape) == 1:
return nn.Flatten()
elif len(op.shape) == 2 and np.prod(op.shape) < 0: # -1 as dimension
return nn.Flatten()
else:
# Assume that first dim is batch-size
return Reshape(list(op.shape)[1:]) # type: ignore[arg-type]
if out_op_name_pref == "slice":
op = Slice(
dim=op.dim[0], starts=op.starts[0], ends=op.ends[0], steps=op.steps[0]
)
if out_op_name_pref == "concat":
op = Concat(dim=op.dim)
if out_op_name_pref in {"add", "sub"} and len(self.cg_needs[out_op_id]) == 2:
assert len(self.needs[out_op_id]) == 2, "Too many inputs for Binary Op"
return BinaryOp(out_op_name_pref)
return op
def compute_activation_dependencies(
onnx_graph: Any, model: ConvertModel, mapping: Dict[str, str]
) -> DefaultDict[Any, Set[Any]]:
"""
Compute activation dependencies, mapping each node to its dependents.
Parameters
----------
onnx_graph: onnx.GraphProto
ONNX graph.
model: onnx2pytorch.ConvertModel
Module which contains converted submodules.
mapping: dict
Dictionary mapping from node name to name of submodule.
Returns
-------
needed_by: dict
Dictionary mapping from node name to names of its dependents.
"""
needed_by: DefaultDict[Any, Set[Any]] = defaultdict(set)
for node in onnx_graph.node:
out_op_id = node.output[0]
for in_op_id in node.input:
needed_by[in_op_id].add(out_op_id)
if node.op_type == "Loop":
# Look at nodes in the loop body
l1 = getattr(model, mapping[out_op_id]) # Loop object
loop_body_l1 = l1.body
for node_l1 in loop_body_l1.node:
for in_op_id in node_l1.input:
# Treating node (outer loop) as dependent, not node_l1
needed_by[in_op_id].add(out_op_id)
if node_l1.op_type == "Loop":
# Look at nodes in the loop body
l2 = getattr(model, l1.mapping[node_l1.output[0]]) # Loop object
loop_body_l2 = l2.body
for node_l2 in loop_body_l2.node:
for in_op_id in node_l2.input:
# Treating node (outer loop) as dependent, not node_l2
needed_by[in_op_id].add(out_op_id)
if node_l2.op_type == "Loop":
# TODO: make this recursive for nested loops
raise NotImplementedError(
"Activation garbage collection not implemented for >2 nested loops."
)
needed_by.default_factory = None
return needed_by
| 25,051 | 37.900621 | 107 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/prepare_instance.py | import argparse
import json
import os
import shutil
from pathlib import Path
from typing import Dict, List, Optional, Tuple
import dill # type: ignore[import]
import numpy as np
import onnx # type: ignore[import]
import torch
import torch.nn as nn
from bunch import Bunch # type: ignore[import]
from torch import Tensor
from src.abstract_layers.abstract_network import AbstractNetwork
from src.abstract_layers.abstract_sequential import Sequential
from src.utilities.argument_parsing import get_config_from_json
from src.utilities.config import Config, Dtype, make_config
from src.utilities.loading.dnnv_simplify import simplify_onnx
from src.utilities.loading.network import (
freeze_network,
load_onnx_from_proto,
load_onnx_model,
)
from src.utilities.loading.vnn_spec_loader import ( # translate_constraints_to_label,
parse_vnn_lib_prop,
)
FILE_DIR = os.path.realpath(os.path.dirname(__file__))
NET_TO_CONFIG_MAP = os.path.realpath(
os.path.join(FILE_DIR, "../..", "configs/net_to_config.csv")
)
META_CONFIG = os.path.realpath(
os.path.join(FILE_DIR, "../..", "configs/meta_config.json")
)
TEMP_RUN_DIR = os.path.realpath(os.path.join(FILE_DIR, "../..", "run"))
def generate_constraints(
class_num: int, y: int
) -> List[List[List[Tuple[int, int, float]]]]:
return [[[(y, i, 0)] for i in range(class_num) if i != y]]
def get_io_constraints_from_spec(
spec_path: str, config: Config, device: torch.device
) -> Tuple[
List[Tensor], List[Tuple[Tensor, Tensor]], List[List[List[Tuple[int, int, float]]]]
]:
dtype = np.float32 if config.dtype == Dtype("float32") else np.float64
if not os.path.exists(spec_path) and not spec_path.endswith(".gz"):
spec_path += ".gz"
input_boxes, output_gt_constraints = parse_vnn_lib_prop(spec_path, dtype=dtype)
input_regions = []
inputs = []
for box in input_boxes:
input_lb_arr, input_ub_arr = box
input_lb, input_ub = (
torch.from_numpy(input_lb_arr).to(device),
torch.from_numpy(input_ub_arr).to(device),
)
input_lb, input_ub = input_lb.reshape(config.input_dim), input_ub.reshape(
config.input_dim
)
input_regions.append((input_lb, input_ub))
inputs.append((input_lb + input_ub) / 2)
return inputs, input_regions, output_gt_constraints
class NetworkConfig:
default_config: Optional[Dict[str, str]] = None
specific_config: Dict[str, Dict[str, str]]
def __init__(self, config: Bunch):
self.specific_config: Dict[str, Dict[str, str]] = {}
for id, cfg in config.items():
self.specific_config[id] = cfg
if id == "default":
self.default_config = cfg
def get_config_given_characteristics(self, net_char: str) -> Dict[str, str]:
if net_char in self.specific_config:
print(f"Using characteristic: {net_char}")
return self.specific_config[net_char]
else:
assert self.default_config is not None
print("WARNING! Using default config.")
return self.default_config
class MetaConfig:
config_mapping: Dict[str, NetworkConfig]
def __init__(self, meta_config: Bunch):
self.config_mapping = {}
for k, v in meta_config.items():
if not "default" in v.keys():
v.update(meta_config["default"])
self.config_mapping[k] = NetworkConfig(Bunch(**v))
def get_benchmark_mapping(self, benchmark: str) -> NetworkConfig:
if benchmark in self.config_mapping:
return self.config_mapping[benchmark]
else:
return self.config_mapping["default"]
def load_meta_config() -> MetaConfig:
assert os.path.exists(META_CONFIG), "META_CONFIG path does not exist."
with open(META_CONFIG) as f:
meta_conf = json.load(f)
meta_config = MetaConfig(Bunch(**meta_conf))
return meta_config
def get_input_characteristics(net: nn.Sequential, onnx_shape: Tuple[int, ...]) -> None:
pass
def get_network_characteristics(net: Sequential) -> str:
act_layers = net.get_activation_layers()
node_count = 0
for layer in act_layers.values():
node_count += np.prod(layer.output_dim)
param_count = sum(p.numel() for p in net.parameters())
return f"{node_count}-{param_count}"
def get_asnet_from_path(net_path: str, device: torch.device) -> None:
net_format = net_path.split(".")[-1]
if net_format in ["onnx", "gz"]:
net, onnx_shape, inp_name = load_onnx_model(net_path) # Like this for mypy
else:
assert False, f"No net loaded for net format: {net_format}."
as_net = AbstractNetwork.from_concrete_module(net, onnx_shape)
node_count = get_network_characteristics(as_net)
print(f"{net_path} char: {node_count}")
def get_net_asnet_conf(
benchmark_id: str, net_path: str, device: torch.device
) -> Tuple[nn.Module, AbstractNetwork, str, Bunch, Config]:
# network
net_format = net_path.split(".")[-1]
if net_format in ["onnx", "gz"]:
net, onnx_shape, inp_name = load_onnx_model(net_path) # Like this for mypy
else:
assert False, f"No net loaded for net format: {net_format}."
as_net = AbstractNetwork.from_concrete_module(net, onnx_shape)
meta_config = load_meta_config()
node_count = get_network_characteristics(as_net)
benchmark_meta_config = meta_config.get_benchmark_mapping(benchmark_id)
config_obj = benchmark_meta_config.get_config_given_characteristics(node_count)
config_path = os.path.realpath(
os.path.join(FILE_DIR, "../..", config_obj["config"])
)
print(f"== Using config {config_path} ==")
json_config = get_config_from_json(config_path)
parsed_config = make_config(**json_config)
if ("adapt_input_dim" in config_obj) or (benchmark_id not in net_path):
print(f"Setting shape: {onnx_shape}")
json_config["input_dim"] = onnx_shape
parsed_config.input_dim = onnx_shape
net.to(device)
net.eval()
freeze_network(net)
if parsed_config.dtype == Dtype.float64:
torch.set_default_dtype(torch.float64)
net = net.double()
else:
torch.set_default_dtype(torch.float32)
net = net.float()
if parsed_config.verifier.outer.simplify_onnx:
assert onnx_shape is not None
assert inp_name is not None
# export current model to onnx for dtype
try:
temp_dir = os.path.realpath(os.path.join(FILE_DIR, "../.." "temp_convert"))
net_pref = "simplify"
onnx_path = f"{temp_dir}/{net_pref}.onnx"
Path(temp_dir).mkdir(parents=True, exist_ok=True)
x = torch.rand((1, *onnx_shape), device=device)
torch.onnx.export(
net,
x,
onnx_path,
export_params=True,
training=torch.onnx.TrainingMode.EVAL,
do_constant_folding=True,
verbose=False,
input_names=[inp_name],
output_names=["output"],
)
onnx_model = onnx.load(onnx_path)
onnx_model = simplify_onnx(onnx_model)
net_new, _, _ = load_onnx_from_proto(onnx_model, net_path)
net_new.to(device)
net_new.eval()
freeze_network(net_new)
net = net_new
except Exception as e:
print("Exception simplifying onnx model: ", e)
finally:
shutil.rmtree(temp_dir, ignore_errors=True)
assert isinstance(net, nn.Sequential)
return net, as_net, config_path, json_config, parsed_config
def create_instance_from_vnn_spec(
benchmark_name: str, net_path: str, spec_path: str
) -> None:
shutil.rmtree(f"{TEMP_RUN_DIR}", ignore_errors=True)
# net_path = os.path.realpath(os.path.join(FILE_DIR, "../../..", "vnncomp2022_benchmarks", net_path))
# spec_path = os.path.realpath(os.path.join(FILE_DIR, "../../..", "vnncomp2022_benchmarks",spec_path))
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
net, as_network, config_path, json_config, parsed_config = get_net_asnet_conf(
benchmark_name, net_path, device
)
# Get data
(inputs, input_regions, target_g_t_constraints) = get_io_constraints_from_spec(
spec_path=spec_path, config=parsed_config, device=device
)
# Write out
Path(f"{TEMP_RUN_DIR}").mkdir(parents=False, exist_ok=False)
# 1. config
with open(f"{TEMP_RUN_DIR}/config.json", "w") as f:
json.dump(json_config, f, indent=2)
# Write out abstract network
torch.save(as_network, f"{TEMP_RUN_DIR}/abs_network.onnx")
# 3. Write out input
input_path = f"{TEMP_RUN_DIR}/inputs"
Path(input_path).mkdir(parents=True, exist_ok=False)
conc_inputs = torch.stack(inputs, 0)
torch.save(conc_inputs, f"{input_path}/inputs.pt")
input_region_path = f"{TEMP_RUN_DIR}/input_regions"
Path(input_region_path).mkdir(parents=True, exist_ok=False)
stack_lb = torch.stack([lb for (lb, ub) in input_regions], 0)
stack_ub = torch.stack([ub for (lb, ub) in input_regions], 0)
torch.save(stack_lb, f"{input_region_path}/input_lbs.pt")
torch.save(stack_ub, f"{input_region_path}/input_ubs.pt")
target_g_t_constraint_path = f"{TEMP_RUN_DIR}/io_constraints"
Path(target_g_t_constraint_path).mkdir(parents=True, exist_ok=False)
with open(f"{target_g_t_constraint_path}/target_g_t_constraints.pkl", "wb") as file:
dill.dump(target_g_t_constraints, file)
# 4. Write METADATA
metadata_path = f"{TEMP_RUN_DIR}/metadata.txt"
with open(f"{metadata_path}", "w") as file:
file.write(f"benchmark: {benchmark_name} \n")
file.write(f"network_path: {net_path}\n")
file.write(f"spec_path: {spec_path}\n")
file.write(f"config_path: {config_path}\n")
file.write(f"Simplified ONNX: {parsed_config.verifier.outer.simplify_onnx}\n")
file.write(f"inputs: {len(inputs)}\n")
file.write(f"input_regions: {len(input_regions)}\n")
file.write(f"target_gts: {len(target_g_t_constraints)}\n")
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Prepare verification instances on the vnn22 datasets. Simply provide the corresponding net and spec"
)
parser.add_argument(
"-b", "--benchmark", type=str, help="The benchmark id", required=True
)
parser.add_argument(
"-n",
"--netname",
type=str,
help="The network path",
required=True,
)
parser.add_argument(
"-s",
"--vnnlib_spec",
type=str,
help="The vnnlib spec path",
required=True,
)
args = parser.parse_args()
create_instance_from_vnn_spec(args.benchmark, args.netname, args.vnnlib_spec)
| 10,917 | 34.106109 | 121 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/dependence_sets.py | from __future__ import annotations
from typing import List, Tuple, Union
import numpy as np
import torch
import torch.nn.functional as F
from torch import Tensor
class DependenceSets:
"""
A memory-efficient implementation of a coefficient matrix used in backsubstitution, as described in
https://arxiv.org/abs/2007.10868. To enable set the `use_dependence_sets` flag.
Enabling dependence sets optimizes intermediate backsubstitution queries that start after a convolutional layer.
For query layer output size [C, H, W], the non-optimized coefficient matrix after backsubstituting through
a layer with input size [c, h, w] ("current layer") has shape [B, CHW, c, h, w], where B is the batch size.
With dependence sets this is reduced to [B, CHW, c, d, d] (`sets` attribute) where (d x d) is the spatial
size of the dependence set of a single query neuron. The corresponding bias tensor is of shape [B, CHW], as usual. Concretizing an abstract shape with DependenceSets bounds produces a [B, CHW]
shape, as usual.
Additionally, cumulative stride (`cstride` attribute) and cumulative padding (`padding` attribute) are stored
as a way to properly locate a dependence set of a query neuron within the current shape. The relationship is
as follows: a 2D convolution with kernel size [c, d, d], stride cstride and padding cpadding, will visit the
dependence sets of all HW query neurons in order (in any query channel, as the dependence sets don't change
across C channels).
This implementation assumes only Conv2D/ReLU layers before any Conv2D layer (no Normalization), symmetric stride
and padding and dilation=groups=1 in all Conv2D layers, as well as square spatial dimensions of the input.
"""
def __init__(
self,
sets: Tensor,
spatial_idxs: Tensor,
input_dim: Tuple[int, ...],
cstride: int = 1,
cpadding: int = 0,
) -> None:
self.sets = sets
self.spatial_idxs = spatial_idxs # Q indices in range [0, HW)
self.cstride = cstride
self.cpadding = cpadding
self.device = sets.device
self.batch_size = sets.shape[0]
self.input_dim = input_dim
# assert sets.shape[-1] == sets.shape[-2]
def to(self, device: torch.device) -> DependenceSets:
return DependenceSets(
self.sets.to(device),
self.spatial_idxs.to(device),
self.input_dim,
self.cstride,
self.cpadding,
)
def clone(self) -> DependenceSets:
return DependenceSets(
self.sets.clone(),
self.spatial_idxs.clone(),
self.input_dim,
self.cstride,
self.cpadding,
)
@property
def is_leaf(self) -> bool:
return self.sets.is_leaf and self.spatial_idxs.is_leaf
def detach(self) -> DependenceSets:
return DependenceSets(
self.sets.detach(),
self.spatial_idxs.detach(),
self.input_dim,
self.cstride,
self.cpadding,
)
@staticmethod
def unfold_to_spec(
x: Tensor,
padding: int,
stride: int,
kernel_size: int,
input_dim: Tuple[int, ...],
spatial_idxs: Tensor,
) -> Tensor:
"""
Extracts the entries of x (shape [B, 1?, c, h, w])
corresponding to the dependence set of each neuron
in coef.sets (shape [B, Q, c, d, d]), where (Q <= C * HW)
The resulting shape is [B, Q, c, d, d].
"""
if len(x.shape) == 5:
x = x.squeeze(1)
assert len(x.shape) == 4
_, _, h_x, w_x = x.shape
h_unfolded = (h_x - kernel_size + 2 * padding) // stride + 1
w_unfolded = (w_x - kernel_size + 2 * padding) // stride + 1
input_c, input_h, input_w = input_dim
idx_h = torch.div(spatial_idxs, input_w, rounding_mode="trunc")
idx_w = spatial_idxs - idx_h * input_w
x_unfolded = F.unfold(
x,
kernel_size=kernel_size,
stride=stride,
padding=padding,
).transpose(
1, 2
) # [B, HW, c*d*d]
x_unfolded = x_unfolded.view(x.shape[0], h_unfolded, w_unfolded, -1)[
:, idx_h, idx_w, :
] # [B, Q, c*d*d]
x_unfolded = x_unfolded.view(
x_unfolded.shape[0],
x_unfolded.shape[1],
x.shape[1],
kernel_size,
kernel_size,
) # [B, Q, c, d, d]
return x_unfolded
@staticmethod
def _unfold_to_uniform(x: Tensor, coef: DependenceSets) -> Tensor:
"""
Extracts the entries of x (shape [B, 1?, c, h, w])
corresponding to the dependence set of each neuron
in coef.sets (shape [B, Q, c, d, d]), where (Q <= C * HW)
The resulting shape is [B, Q, c, d, d].
"""
if len(x.shape) == 5:
x = x.squeeze(1)
assert len(x.shape) == 4
_, num_queries, kernel_c, kernel_h, kernel_w = coef.sets.shape
bs, _, h_x, w_x = x.shape
h_unfolded = (h_x - kernel_h + 2 * coef.cpadding) // coef.cstride + 1
w_unfolded = (w_x - kernel_w + 2 * coef.cpadding) // coef.cstride + 1
input_c, input_h, input_w = coef.input_dim
idx_h = torch.div(coef.spatial_idxs, input_w, rounding_mode="trunc")
idx_w = coef.spatial_idxs - idx_h * input_w
x_unfolded = F.unfold(
x,
kernel_size=(kernel_h, kernel_w),
stride=coef.cstride,
padding=coef.cpadding,
).transpose(
1, 2
) # [B, HW, c*d*d]
x_unfolded = x_unfolded.view(bs, h_unfolded, w_unfolded, -1)[
:, idx_h, idx_w, :
] # [B, Q, c*d*d]
x_unfolded = x_unfolded.view(
bs, num_queries, *coef.sets.shape[2:]
) # [B, Q, c, d, d]
return x_unfolded
def handle_padding(self, output_size: Tuple[int, ...]) -> None:
device = self.device
bs, num_queries, kernel_c, kernel_h, kernel_w = self.sets.shape
output_c, output_h, output_w = output_size
input_c, input_h, input_w = self.input_dim
idx_h = torch.div(self.spatial_idxs, input_w, rounding_mode="trunc")
idx_w = self.spatial_idxs - idx_h * input_w
h_idx = (
torch.arange(kernel_h, device=device).repeat(num_queries, 1)
+ idx_h.view(-1, 1).repeat(1, kernel_h) * self.cstride
) # torch.arange(kernel_h, device=device).repeat_interleave(num_queries) + idx_h.repeat(kernel_h) * self.cstride
w_idx = (
torch.arange(kernel_w, device=device).repeat(num_queries, 1)
+ idx_w.view(-1, 1).repeat(1, kernel_w) * self.cstride
)
mask = torch.ones(self.sets.shape[1], *self.sets.shape[3:], device=device)
mask[h_idx < self.cpadding] = 0
mask[h_idx >= output_h + self.cpadding] = 0
mask = mask.permute(0, 2, 1)
mask[w_idx < self.cpadding] = 0
mask[w_idx >= output_w + self.cpadding] = 0
mask = mask.permute(0, 2, 1)
self.sets *= mask.unsqueeze(0).unsqueeze(2)
@staticmethod
def _unfold_to_non_uniform(x: Tensor, coef: DependenceSets) -> Tensor:
"""
Extracts the entries of x (shape [B, Q, c, h, w])
corresponding to the dependence set of each neuron
in coef.sets (shape [B, Q, c, d, d]), where (Q <= C * HW)
The resulting shape is [B, Q, c, d, d].
"""
# TODO: does this do the right thing / is this an efficient implementation?
assert (
len(x.shape) == 5 and x.shape[1] != 1
), "uniform case should go to other implementation"
_, num_queries, kernel_c, kernel_h, kernel_w = coef.sets.shape
bs, _, _, h_x, w_x = x.shape
h_unfolded = (h_x - kernel_h + 2 * coef.cpadding) // coef.cstride + 1
w_unfolded = (w_x - kernel_w + 2 * coef.cpadding) // coef.cstride + 1
input_c, input_h, input_w = coef.input_dim
idx_h = coef.spatial_idxs // input_w
idx_w = coef.spatial_idxs - idx_h * input_w
x_unfolded = x.view(x.shape[0] * x.shape[1], *x.shape[2:])
x_unfolded = F.unfold(
x_unfolded,
kernel_size=(kernel_h, kernel_w),
stride=coef.cstride,
padding=coef.cpadding,
).transpose(
1, 2
) # [B*Q, HW, c*d*d]
x_unfolded = x_unfolded.view(
x.shape[0], x.shape[1], h_unfolded, w_unfolded, -1
) # [B, Q, HW, c*d*d] # TODO: this seems huge. does this actually use space?
# alternate implementation: issue is this probably creates a huge tensor here:
# x_unfolded = x_unfolded[:, :, coef.spatial_idxs, :] # [B, Q, Q, c*d*d]
# x_unfolded = x_unfolded.diagonal(dim1=1, dim2=2) # [B, c*d*d, Q]
# x_unfolded = x_unfolded.transpose(dim0=1, dim1=2) # [B, Q, c*d*d]
# manually index in parallel with python for comprehension instead:
assert (
x.shape[1] == coef.spatial_idxs.shape[0]
and len(coef.spatial_idxs.shape) == 1
)
x_unfolded = torch.cat(
tuple(
x_unfolded[:, i, h, w].unsqueeze(1)
for i, h, w in zip(range(x.shape[1]), idx_h, idx_w)
),
dim=1,
) # [B, Q, c*d*d]
x_unfolded = x_unfolded.view(
x_unfolded.shape[0], x_unfolded.shape[1], *coef.sets.shape[2:]
) # [B, Q, c, d, d]
return x_unfolded
@staticmethod
def unfold_to(x: Tensor, coef: DependenceSets) -> Tensor:
"""
Extracts the entries of x (shape [B, (1|Q)?, c, h, w])
corresponding to the dependence set of each neuron
in coef.sets (shape [B, Q, c, d, d]), where (Q <= C * HW)
The resulting shape is [B, Q, c, d, d].
"""
if len(x.shape) == 4 or len(x.shape) == 5 and x.shape[1] == 1:
return DependenceSets._unfold_to_uniform(x, coef)
assert len(x.shape) == 5 # case [B, Q, c, h, w]
return DependenceSets._unfold_to_non_uniform(x, coef)
def __add__(self, other: DependenceSets) -> DependenceSets:
assert isinstance(
other, DependenceSets
), f"Can only sum up two Dependence Sets and not Dependence set and {type(other)}"
assert (
self.sets.shape[:3] == other.sets.shape[:3]
), "Can not sum Dependence Sets that disagree in channel or batch dimensions"
assert (
self.cstride == other.cstride
), "Can not sum Dependence Sets that disagree in stride"
assert (
self.spatial_idxs.shape == other.spatial_idxs.shape
and (self.spatial_idxs == other.spatial_idxs).all()
), "Can not sum Dependence Sets that disagree in spatial indices"
h_pad_self, h_pad_other = self.get_required_padding(
self.sets.shape[-1], self.cpadding, other.sets.shape[-1], other.cpadding
)
v_pad_self, v_pad_other = self.get_required_padding(
self.sets.shape[-2], self.cpadding, other.sets.shape[-2], other.cpadding
)
assert h_pad_self == v_pad_self
assert h_pad_other == v_pad_other
new_padding = self.cpadding + h_pad_self[0]
new_sets = F.pad(self.sets, (*h_pad_self, *v_pad_self)) + F.pad(
other.sets, (*h_pad_other, *v_pad_other)
)
return type(self)(
new_sets, self.spatial_idxs, self.input_dim, self.cstride, new_padding
)
def __getitem__(self, item: Tuple[Union[int, slice], ...]) -> DependenceSets:
assert all([x == slice(None, None, None) for x in item[2:]])
return DependenceSets(
self.sets[item[:2]],
self.spatial_idxs[item[1]],
self.input_dim,
self.cstride,
self.cpadding,
)
def to_tensor(self, output_size: Tuple[int, ...]) -> Tensor:
bs, num_queries, kernel_c, kernel_h, kernel_w = self.sets.shape
output_c, output_h, output_w = output_size
input_c, input_h, input_w = self.input_dim
assert kernel_h > self.cpadding
assert kernel_w > self.cpadding
assert output_h + 2 * self.cpadding >= kernel_h + (input_h - 1) * self.cstride
assert output_w + 2 * self.cpadding >= kernel_w + (input_w - 1) * self.cstride
n_kernel_neurons = kernel_c * kernel_h * kernel_w
num_queries = self.spatial_idxs.shape[0]
new_coef = torch.zeros(
(
*self.sets.shape[:2],
output_c,
output_h + 2 * self.cpadding,
output_w + 2 * self.cpadding,
),
device=self.device,
)
orig_stride: Tuple[int, ...] = new_coef.stride()
new_coef = new_coef.flatten()
strides_coef = [
orig_stride[0],
orig_stride[1],
(output_h + 2 * self.cpadding) * self.cstride,
self.cstride,
orig_stride[2],
output_w + self.cpadding + self.cpadding,
1,
]
strides_sets: Tuple[int, ...] = self.sets.stride()
idx_h = torch.div(self.spatial_idxs, input_w, rounding_mode="trunc")
idx_w = self.spatial_idxs - idx_h * input_w
query_idxs = (
torch.arange(num_queries, device=self.device)
.repeat_interleave(bs)
.repeat(n_kernel_neurons)
)
batch_idxs = (
torch.arange(bs, device=self.device)
.repeat(num_queries)
.repeat(n_kernel_neurons)
)
h_idxs = idx_h.repeat_interleave(bs).repeat(n_kernel_neurons)
w_idxs = idx_w.repeat_interleave(bs).repeat(n_kernel_neurons)
c_idxs = (
torch.arange(kernel_c, device=self.device)
.repeat_interleave(bs * num_queries)
.repeat(kernel_h * kernel_w)
)
kh_idxs = (
torch.arange(kernel_h, device=self.device)
.repeat_interleave(bs * num_queries * kernel_c)
.repeat(kernel_w)
)
kw_idxs = torch.arange(kernel_w, device=self.device).repeat_interleave(
bs * num_queries * kernel_c * kernel_h
)
idxs_coef = (
batch_idxs * strides_coef[0]
+ query_idxs * strides_coef[1]
+ h_idxs * strides_coef[2]
+ w_idxs * strides_coef[3]
+ c_idxs * strides_coef[4]
+ kh_idxs * strides_coef[5]
+ kw_idxs * strides_coef[6]
)
idxs_sets = (
batch_idxs * strides_sets[0]
+ query_idxs * strides_sets[1]
+ c_idxs * strides_sets[2]
+ kh_idxs * strides_sets[3]
+ kw_idxs * strides_sets[4]
)
new_coef[idxs_coef] = self.sets.flatten()[idxs_sets]
new_coef = new_coef.view(
(
*self.sets.shape[:2],
output_c,
output_h + 2 * self.cpadding,
output_w + 2 * self.cpadding,
)
)[
:,
:,
:,
self.cpadding : self.cpadding + output_h,
self.cpadding : self.cpadding + output_w,
]
# below implementation only works on cpu, but shows better what is done
# new_coef_ = torch.zeros((*self.sets.shape[:2], output_c, output_h + 2 * self.cpadding, output_w + 2 * self.cpadding), device=self.device)
# new_coef_strided = torch.as_strided(new_coef_,
# [bs, num_queries, input_h, input_w, output_c, kernel_h, kernel_w],
# [orig_stride[0], orig_stride[1], (output_h + 2 * self.cpadding) * self.cstride, self.cstride, orig_stride[2], output_w + self.cpadding + self.cpadding, 1]
# ) # type: ignore # Tuple index out of range?
# query_idxs = torch.arange(num_queries, device=self.device)
# new_coef_strided[:, query_idxs, idx_h, idx_w] = self.sets.contiguous()
# new_coef_ = new_coef_[:, :, :, self.cpadding:self.cpadding+output_h, self.cpadding:self.cpadding+output_w]
# assert torch.isclose(new_coef_,new_coef,atol=1e-10).all()
return new_coef
@classmethod
def get_required_padding(
cls, a_k: int, a_p: int, b_k: int, b_p: int
) -> Tuple[List[int], List[int]]:
if a_k >= b_k:
b_p_new = [int(np.ceil((a_k - b_k) / 2)), int(np.floor((a_k - b_k) / 2))]
a_p_new = [0, 0]
assert a_p == b_p_new[0] + b_p
assert b_p_new[1] == b_p_new[0]
else:
b_p_new, a_p_new = cls.get_required_padding(b_k, b_p, a_k, a_p)
return a_p_new, b_p_new
| 16,881 | 37.988453 | 200 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/prima_util.py | import itertools
import multiprocessing
import sys
from enum import Enum
from typing import Callable, List, Optional, Sequence, Tuple
import matplotlib.pyplot as plt # type: ignore[import]
import numpy as np
import torch
from torch import Tensor
sys.path.insert(0, "ELINA/python_interface/")
from ELINA.python_interface.fconv import ( # type: ignore[import] # noqa: 401
fkrelu,
generate_sparse_cover,
)
from src.utilities.config import PrimaGroupRandomness # noqa: 401
class ActivationType(Enum):
ReLU = "ReLU"
Sigmoid = "SIgmoid"
Tanh = "Tanh"
# adapted from https://github.com/mnmueller/eran/blob/master/tf_verify/krelu.py
# commit hash: d57a2547a3ca3edfc2e2958f2cdac11a816f8a9c
global R_SEED
R_SEED = 42**2
class KAct:
k: int
input_hrep: np.ndarray
varsid: Optional[Tuple[int, ...]]
def __init__(
self,
activation_type: ActivationType,
input_hrep: np.ndarray,
approx: bool = True,
) -> None:
assert activation_type in [
ActivationType.ReLU,
ActivationType.Tanh,
ActivationType.Sigmoid,
]
self.k = len(input_hrep[0]) - 1
self.input_hrep = input_hrep
self.varsid = None
if activation_type == ActivationType.ReLU:
if approx:
self.cons = fkrelu(self.input_hrep)
else:
assert False, "not implemented"
# self.cons = krelu_with_cdd(self.input_hrep)
elif not approx:
assert False, "not implemented"
elif activation_type == ActivationType.Tanh:
assert False, "not implemented"
# self.cons = ftanh_orthant(self.input_hrep)
else:
assert False, "not implemented"
# self.cons = fsigm_orthant(self.input_hrep)
class MakeKAct: # (can't pickle closure)
activation_type: ActivationType
def __init__(self, activation_type: ActivationType):
self.activation_type = activation_type
def __call__(self, input_hrep: np.ndarray, approx: bool = True) -> KAct:
return KAct(self.activation_type, input_hrep, approx)
def make_kactivation_obj(
activation_type: ActivationType,
) -> MakeKAct:
return MakeKAct(activation_type)
def sparse_heuristic_with_cutoff(
length: int,
lb: np.ndarray,
ub: np.ndarray,
sparse_n: int,
K: int = 3,
s: int = -2,
max_unstable_nodes_considered_per_layer: int = 1000,
min_relu_transformer_area_to_be_considered: float = 0.05,
) -> Tuple[Sequence[Tuple[int, ...]], Sequence[int]]:
assert length == len(lb) == len(ub)
all_vars = [i for i in range(length) if lb[i] < 0 < ub[i]]
areas = {var: -lb[var] * ub[var] for var in all_vars}
assert len(all_vars) == len(areas)
# Sort vars by descending area
all_vars = sorted(all_vars, key=lambda var: -areas[var])
vars_above_cutoff = [
i
for i in all_vars[:max_unstable_nodes_considered_per_layer]
if areas[i] >= min_relu_transformer_area_to_be_considered
]
vars_above_cutoff_return = vars_above_cutoff
kact_args: List[Tuple[int, ...]] = []
while len(vars_above_cutoff) > 0 and sparse_n >= K:
grouplen = min(sparse_n, len(vars_above_cutoff))
group = tuple(vars_above_cutoff[:grouplen])
vars_above_cutoff = vars_above_cutoff[grouplen:]
if grouplen <= K:
kact_args.append(group)
elif K > 2:
sparsed_combs: Sequence[Sequence[int]] = generate_sparse_cover(
n=grouplen, k=K, s=s
)
for comb in sparsed_combs:
kact_args.append(tuple(group[i] for i in comb))
elif K == 2:
raise RuntimeError("K=2 is not supported")
# Edited: removed since those constraints are already handled
# Also just apply 1-relu for every var.
# for var in all_vars:
# kact_args.append([var])
return kact_args, vars_above_cutoff_return
def random_group_augmentation(
groups_multi_neuron: Sequence[Tuple[int, ...]],
single_neurons: np.ndarray,
K: int,
sparse_n: int,
random_prima_groups: PrimaGroupRandomness = PrimaGroupRandomness.none,
prima_sparsity_factor: float = 1.0,
) -> Sequence[Tuple[int, ...]]:
global R_SEED
R_SEED += 1
np.random.seed(R_SEED)
n_cons_new = int(np.ceil(len(groups_multi_neuron) * prima_sparsity_factor))
groups: Sequence[Tuple[int, ...]]
if random_prima_groups == PrimaGroupRandomness.only:
groups_list: List[Tuple[int, ...]] = []
while len(groups_list) < n_cons_new:
new_group = tuple(
single_neurons[
np.random.choice(
len(single_neurons),
min(K, len(single_neurons)),
replace=False,
)
]
)
if new_group not in groups_list:
groups_list.append(new_group)
groups = groups_list
elif random_prima_groups == PrimaGroupRandomness.augment:
groups_list = list(groups_multi_neuron)
if len(single_neurons) > sparse_n:
n_cons_new = min(
n_cons_new,
len(groups_multi_neuron)
+ (len(single_neurons) ** 2 - sparse_n**2) // 2,
)
while len(groups_list) < n_cons_new:
new_group_idx = np.random.choice(
len(single_neurons),
min(K, len(single_neurons)),
replace=False,
)
if len(np.unique(new_group_idx // sparse_n)) == 1:
continue
new_group = tuple(single_neurons[new_group_idx])
if new_group not in groups_list:
groups_list.append(new_group)
groups = groups_list
elif random_prima_groups == PrimaGroupRandomness.none:
n_cons_new = min(n_cons_new, len(groups_multi_neuron))
sparse_idx = np.random.choice(
len(groups_multi_neuron), n_cons_new, replace=False
)
groups = [groups_multi_neuron[idx] for idx in sparse_idx]
else:
assert False, "Unsupported PrimaGroupRandomness." + random_prima_groups.value
return groups
def encode_kactivation_cons(
input_lb: Tensor,
input_ub: Tensor,
activation_type: ActivationType,
sparse_n: int,
intermediate_bounds_callback: Callable[[Tensor], Tuple[Tensor, Tensor]],
K: int,
s: int,
approx: bool,
numproc: int,
max_number_of_parallel_input_constraint_queries: int,
max_unstable_nodes_considered_per_layer: int,
min_relu_transformer_area_to_be_considered: float,
fraction_of_constraints_to_keep: float,
random_prima_groups: PrimaGroupRandomness = PrimaGroupRandomness.none,
prima_sparsity_factor: float = 1.0,
) -> Optional[Sequence[Sequence[KAct]]]:
length = np.prod(input_lb[0].shape)
lbi = np.asarray(input_lb, dtype=np.double)
ubi = np.asarray(input_ub, dtype=np.double)
batch_kact_args = []
for lb, ub in zip(lbi, ubi):
if activation_type == ActivationType.ReLU:
groups_multi_neuron, single_neurons_seq = sparse_heuristic_with_cutoff(
length,
lb.flatten(),
ub.flatten(),
sparse_n,
K=K,
s=s,
max_unstable_nodes_considered_per_layer=max_unstable_nodes_considered_per_layer,
min_relu_transformer_area_to_be_considered=min_relu_transformer_area_to_be_considered,
)
single_neurons = np.array(single_neurons_seq) # TODO: why?
if (
random_prima_groups != PrimaGroupRandomness.none
or prima_sparsity_factor < 1
):
groups = random_group_augmentation(
groups_multi_neuron,
single_neurons,
K,
sparse_n,
random_prima_groups,
prima_sparsity_factor,
)
else:
groups = groups_multi_neuron
batch_kact_args.append(groups)
if not any((kact_args) for kact_args in batch_kact_args):
return None
activation_type = activation_type
batch_input_hrep_array = build_octahedron_input_constraints_in_batch(
input_lb=input_lb,
input_ub=input_ub,
batch_of_node_groups=batch_kact_args,
n_nodes_in_layer=length,
activation_type=activation_type,
intermediate_bounds_callback=intermediate_bounds_callback,
max_number_of_parallel_input_constraint_queries=max_number_of_parallel_input_constraint_queries,
)
make_kact = make_kactivation_obj(activation_type)
if numproc == 1:
batch_kact_results_list = []
for input_hrep_array in batch_input_hrep_array:
batch_kact_results_list.append(
[
make_kact(inp, app)
for (inp, app) in zip(
input_hrep_array, len(input_hrep_array) * [approx]
)
]
)
elif numproc > 1:
with multiprocessing.Pool(numproc) as pool:
batch_kact_results_list = []
for input_hrep_array in batch_input_hrep_array:
batch_kact_results_list.append(
pool.starmap(
make_kact,
zip(input_hrep_array, len(input_hrep_array) * [approx]),
)
)
batch_kact_results: Sequence[Sequence[KAct]] = batch_kact_results_list
output_lbi = np.clip(lbi, a_min=0, a_max=None)
output_ubi = ubi
batch_worst_violations = []
for batch_index, (kact_results, kact_args) in enumerate(
zip(batch_kact_results, batch_kact_args)
):
gid = 0
for inst in kact_results:
varsid = kact_args[gid]
inst.varsid = varsid
gid = gid + 1
worst_violations_per_group = []
for group in kact_results:
output_constraints = group.cons[:, group.k + 1 :]
input_constraints = group.cons[:, 1 : group.k + 1]
const_constraints = group.cons[:, 0]
assert group.varsid is not None
group_indices = list(group.varsid)
worst_violations_per_group.append(
(
const_constraints
+ np.sum(
np.where(
output_constraints > 0,
output_lbi[batch_index].flatten()[group_indices],
output_ubi[batch_index].flatten()[group_indices],
)
* output_constraints,
axis=1,
)
+ np.sum(
np.where(
input_constraints > 0,
lbi[batch_index].flatten()[group_indices],
ubi[batch_index].flatten()[group_indices],
)
* input_constraints,
axis=1,
)
).tolist()
)
batch_worst_violations.append(worst_violations_per_group)
if not _relu_as_last_layer(lbi):
batch_kact_results = _filter_constraints(
batch_kact_results, batch_worst_violations, fraction_of_constraints_to_keep
)
return batch_kact_results
def plot_neuron_groups(
groups: Sequence[Tuple[int]], single_neurons: Sequence[int]
) -> None:
neuron_ids = {v: i for i, v in enumerate(single_neurons)}
adj = np.zeros((len(single_neurons), len(single_neurons)))
for group in groups:
ids = [neuron_ids[x] for x in group]
for idx in itertools.combinations(ids, 2):
adj[idx[0], idx[1]] += 1
adj[idx[1], idx[0]] += 1
plt.imshow(adj)
plt.show()
def _relu_as_last_layer(lbi: np.ndarray) -> bool:
"""
For networks with a ReLU as the last layer, we want to keep the single neuron constraints.
We hypothesize that just optimizing lower bound slopes is not equivalent to the triangle
relaxation for the very last layer.
TODO ATTENTION: this would need to be adapted if networks with a different number of output neurons
are considered.
"""
return lbi.shape[1] == 10
def _filter_constraints(
batch_kact_results: Sequence[Sequence[KAct]],
batch_worst_violations: Sequence[Sequence[Sequence[float]]],
percentage_to_keep: float,
) -> Sequence[Sequence[KAct]]:
for kact_results, worst_violations_per_group in zip(
batch_kact_results, batch_worst_violations
):
worst_violation_treshold = np.quantile(
[
violation
for worst_violations_in_group in worst_violations_per_group
for violation in worst_violations_in_group
],
percentage_to_keep,
)
for group, worst_violations in zip(kact_results, worst_violations_per_group):
output_constraints = group.cons[:, group.k + 1 :]
input_constraints = group.cons[:, 1 : group.k + 1]
single_neuron_constraints = []
for row_index, (output_constraint, input_constraint) in enumerate(
zip(output_constraints, input_constraints)
):
non_zero_columns_in_output_constraints = output_constraint.nonzero()[0]
non_zero_columns_in_input_constraints = input_constraint.nonzero()[0]
if (
len(non_zero_columns_in_output_constraints) == 0
or len(non_zero_columns_in_input_constraints) == 0
or (
(
np.array_equal(
non_zero_columns_in_output_constraints,
non_zero_columns_in_input_constraints,
)
)
and (len(non_zero_columns_in_output_constraints) == 1)
)
):
single_neuron_constraints.append(row_index)
constraints_not_satisfying_violation_threshold = (
np.argwhere(
[
violation >= worst_violation_treshold
for violation in worst_violations
]
)
.flatten()
.tolist()
)
constraints_to_delete = list(
set(single_neuron_constraints)
| set(constraints_not_satisfying_violation_threshold)
)
group.cons = np.delete(group.cons, constraints_to_delete, axis=0)
return batch_kact_results
def build_octahedron_input_constraints_in_batch(
input_lb: Tensor,
input_ub: Tensor,
batch_of_node_groups: Sequence[Sequence[Sequence[int]]],
n_nodes_in_layer: int,
activation_type: ActivationType, # TODO: why is this here?
intermediate_bounds_callback: Callable[
[Tensor],
Tuple[Tensor, Tensor],
],
max_number_of_parallel_input_constraint_queries: int,
) -> Sequence[Sequence[np.ndarray]]:
batch_size = len(batch_of_node_groups)
# total number of constraints with at least two non-zero coefficients, ignoring redundant onesunder multiplication with -1:
total_n_at_least_two_reduced = max(
sum(
(3 ** len(node_indices) - 1) // 2 - len(node_indices)
for node_indices in node_groups
)
for node_groups in batch_of_node_groups
)
query_coef = torch.zeros(batch_size, total_n_at_least_two_reduced, n_nodes_in_layer)
batch_input_octahedron_constraints_list = []
batch_bound_masks_list = []
for batch_index, node_groups in enumerate(batch_of_node_groups):
input_octahedron_constraints_list = []
bound_masks_list = []
offset = 0
for node_indices in node_groups:
n_nodes_in_group = len(node_indices)
n_upper_bounds_in_group = (3**n_nodes_in_group - 1) // 2
n_at_least_two_reduced = n_upper_bounds_in_group - n_nodes_in_group
input_octahedron_constraint_matrix_of_group = np.zeros(
(2 * n_upper_bounds_in_group, n_nodes_in_group + 1)
)
octahedron_coefs = torch.cartesian_prod(
*(
(torch.tensor([1.0, 0.0, -1.0]),) * n_nodes_in_group
) # (Those are all coefficients, we will filter redundant ones.)
).view(3**n_nodes_in_group, -1)
# assert (octahedron_coefs[:n_upper_bounds_in_group, :] == -octahedron_coefs[n_upper_bounds_in_group+1:,:].flip(dims=(0,))).all()
reduced_octahedron_coefs = octahedron_coefs[
:n_upper_bounds_in_group, :
] # first, get rid of coefficients that are redundant under multiplication with -1
# assert (octahedron_coefs[n_upper_bounds_in_group, :] == 0).all()
# octahedron_coefs = octahedron_coefs[~(octahedron_coefs==0).all(1)] # equivalent to next line
octahedron_coefs = torch.cat(
(
octahedron_coefs[:n_upper_bounds_in_group],
octahedron_coefs[n_upper_bounds_in_group + 1 :],
),
dim=0,
) # filter out zero
assert octahedron_coefs.shape == (
2 * n_upper_bounds_in_group,
n_nodes_in_group,
)
lb_coef_mask = (reduced_octahedron_coefs != 0).sum(
1
) == 1 # lower bound coefficients (TODO: better way to compute the indices?)
ub_coef_mask = lb_coef_mask.flip(dims=(0,)) # upper bound coefficients
single_bound_coef_mask = torch.cat((lb_coef_mask, ub_coef_mask), dim=0)
multi_bound_coef_mask = ~single_bound_coef_mask
reduced_octahedron_coefs = reduced_octahedron_coefs[
~lb_coef_mask, :
] # now, drop coefficients involving only a single value
assert reduced_octahedron_coefs.shape == (
n_at_least_two_reduced,
n_nodes_in_group,
)
# lb_coefs = torch.eye(n_nodes_in_group)
# assert (octahedron_coefs[single_bound_coef_mask] == torch.cat((lb_coefs, -lb_coefs.flip(dims=(0,))))).all()
# assert (octahedron_coefs[multi_bound_coef_mask] == torch.cat((reduced_octahedron_coefs, -reduced_octahedron_coefs.flip(dims=(0,))), dim=0)).all()
input_octahedron_constraint_matrix_of_group[:, 1:] = octahedron_coefs.cpu()
query_coef.data[
batch_index,
offset : offset + n_at_least_two_reduced,
node_indices,
] = reduced_octahedron_coefs
input_octahedron_constraints_list.append(
input_octahedron_constraint_matrix_of_group
)
bound_masks_list.append(
(
np.array(single_bound_coef_mask),
np.array(multi_bound_coef_mask),
)
)
offset += n_at_least_two_reduced
batch_input_octahedron_constraints_list.append(
input_octahedron_constraints_list
)
batch_bound_masks_list.append(bound_masks_list)
# only do number_of_nodes_in_starting_layer many queries at a time
number_of_queries = query_coef.shape[1]
batch_intermediate_lb = torch.zeros(batch_size, number_of_queries)
batch_intermediate_ub = torch.zeros(batch_size, number_of_queries)
offset = 0
while offset < number_of_queries:
query_coef_slice = query_coef[
:, offset : offset + max_number_of_parallel_input_constraint_queries, :
]
intermediate_lb, intermediate_ub = intermediate_bounds_callback(
query_coef_slice
)
batch_intermediate_lb[
:, offset : offset + max_number_of_parallel_input_constraint_queries
] = intermediate_lb
batch_intermediate_ub[
:, offset : offset + max_number_of_parallel_input_constraint_queries
] = intermediate_ub
offset += max_number_of_parallel_input_constraint_queries
for batch_index, (intermediate_lb, intermediate_ub) in enumerate(
zip(batch_intermediate_lb, batch_intermediate_ub)
):
all_deep_poly_lower_bounds = np.array(intermediate_lb)
all_deep_poly_upper_bounds = np.array(intermediate_ub)
all_input_lower_bounds = np.array(input_lb[batch_index].flatten())
all_input_upper_bounds = np.array(input_ub[batch_index].flatten())
offset = 0
for i, (input_octahedron_constraint_matrix_of_group) in enumerate(
batch_input_octahedron_constraints_list[batch_index]
):
node_indices_np = np.array(batch_of_node_groups[batch_index][i])
n_nodes_in_group = len(node_indices_np)
n_upper_bounds_in_group = (3**n_nodes_in_group - 1) // 2
n_at_least_two_reduced = n_upper_bounds_in_group - n_nodes_in_group
(
single_bound_coef_mask_np,
multi_bound_coef_mask_np,
) = batch_bound_masks_list[batch_index][i]
input_octahedron_constraint_matrix_of_group[
single_bound_coef_mask_np, 0
] = np.concatenate(
(
-all_input_lower_bounds[node_indices_np],
np.flipud(all_input_upper_bounds[node_indices_np]),
),
axis=0,
)
input_octahedron_constraint_matrix_of_group[
multi_bound_coef_mask_np, 0
] = np.concatenate(
(
-all_deep_poly_lower_bounds[
offset : offset + n_at_least_two_reduced
],
np.flipud(
all_deep_poly_upper_bounds[
offset : offset + n_at_least_two_reduced
]
),
),
axis=0,
)
offset += n_at_least_two_reduced
return batch_input_octahedron_constraints_list
| 22,520 | 36.286424 | 159 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/batching.py | from __future__ import annotations
from collections import OrderedDict
from typing import Dict, Iterable, List, Mapping, Optional, Sequence, Tuple
import torch
from torch import Tensor
from src.state.constraints import Constraints, ReadonlyConstraints
from src.state.layer_bounds import LayerBounds, ReadonlyLayerBounds
from src.state.parameters import (
Parameters,
ParametersForQuery,
ReadonlyParameters,
ReadonlyParametersForQuery,
)
from src.state.prima_constraints import PrimaConstraints, ReadonlyPrimaConstraints
from src.state.split_state import ReadonlySplitState, SplitState
from src.state.subproblem_state import ReadonlySubproblemState, SubproblemState
from src.state.tags import LayerTag, ParameterTag, QueryTag
from src.verification_subproblem import (
ReadonlyVerificationSubproblem,
VerificationSubproblem,
)
def batch_subproblems(
subproblems: Sequence[ReadonlyVerificationSubproblem],
reuse_single_subproblem: bool, # (typically True, makes the behavior explicit at the call site)
) -> VerificationSubproblem:
if len(subproblems) == 1 and reuse_single_subproblem:
assert isinstance(subproblems[0], VerificationSubproblem)
return subproblems[0] # reuse parameters from parent subproblem
assert not any(
subproblem.is_infeasible for subproblem in subproblems
), "Infeasible subproblem in subproblems to be batched."
device = subproblems[0].device
assert all(
subproblem.device == device for subproblem in subproblems
), "All subproblems must be on the same device in order to be batched."
lower_bound = min([subproblem.lower_bound for subproblem in subproblems])
upper_bound = min([subproblem.upper_bound for subproblem in subproblems])
subproblem_states = [
subproblem.subproblem_state for subproblem in subproblems
] # TODO: use generators instead of lists?
batched_subproblem_state = _batch_subproblem_states(subproblem_states, device)
return VerificationSubproblem(
lower_bound,
upper_bound,
batched_subproblem_state,
device,
)
def unbatch_subproblems(
subproblem_state: SubproblemState,
improved_lbs: Sequence[
float
], # TODO: put Sequence[float]s into VerificationSubproblem directly (just like for number_of_nodes_split)
improved_ubs: Sequence[float],
reset_intermediate_layer_bounds_to_be_kept_fixed: bool, # TODO: why is this even done?
) -> Sequence[VerificationSubproblem]:
batch_size = subproblem_state.batch_size
assert len(improved_lbs) == batch_size
assert len(improved_ubs) == batch_size
device = subproblem_state.device
subproblem_states = _unbatch_subproblem_states(
subproblem_state,
reset_intermediate_layer_bounds_to_be_kept_fixed,
)
return [
VerificationSubproblem(
improved_lbs[i],
improved_ubs[i],
subproblem_states[i],
device,
)
for i in range(batch_size)
]
def _batch_subproblem_states(
subproblem_states: Sequence[ReadonlySubproblemState],
device: torch.device,
) -> SubproblemState:
batch_size = sum(
subproblem_state.batch_size for subproblem_state in subproblem_states
)
constraints_s = [
subproblem_state.constraints for subproblem_state in subproblem_states
]
parameters_s = [
subproblem_state.parameters for subproblem_state in subproblem_states
]
constraints = _batch_constraints(constraints_s, device)
parameters = _batch_parameters(parameters_s, device)
return SubproblemState(constraints, parameters, batch_size, device)
def _unbatch_subproblem_states(
subproblem_state: ReadonlySubproblemState,
reset_intermediate_layer_bounds_to_be_kept_fixed: bool,
) -> Sequence[SubproblemState]:
batch_size = subproblem_state.batch_size
constraints_s = _unbatch_constraints(
subproblem_state.constraints,
reset_intermediate_layer_bounds_to_be_kept_fixed,
)
parameters_s = _unbatch_parameters(subproblem_state.parameters)
device = subproblem_state.device
return [
SubproblemState(
constraints=constraints_s[i],
parameters=parameters_s[i],
batch_size=1,
device=device,
)
for i in range(batch_size)
]
def _batch_constraints(
constraints_s: Sequence[ReadonlyConstraints],
device: torch.device,
) -> Constraints:
batch_size = sum(constraints.batch_size for constraints in constraints_s)
if all(constraints.split_state is not None for constraints in constraints_s):
split_states: Optional[Sequence[ReadonlySplitState]] = [constraints.split_state for constraints in constraints_s] # type: ignore[misc] # mypy can't see split_state is not None
else:
assert all(
constraints.split_state is None for constraints in constraints_s
), "incompatible split states for batching"
split_states = None
layer_bounds_s = [constraints.layer_bounds for constraints in constraints_s]
if all(constraints.prima_constraints is not None for constraints in constraints_s):
prima_constraints_s: Optional[Sequence[ReadonlyPrimaConstraints]] = [constraints.prima_constraints for constraints in constraints_s] # type: ignore[misc] # mypy can't see prima_constraints is not None
else:
assert all(
constraints.prima_constraints is None for constraints in constraints_s
), "incompatible prima constraints for batching"
prima_constraints_s = None
split_state = (
_batch_split_states(split_states, device) if split_states is not None else None
)
layer_bounds = _batch_layer_bounds(layer_bounds_s, device)
prima_constraints = (
_batch_prima_constraints(prima_constraints_s, device)
if prima_constraints_s is not None
else None
)
is_infeasible = torch.cat(
tuple(constraints.is_infeasible for constraints in constraints_s)
)
return Constraints(
split_state=split_state,
layer_bounds=layer_bounds,
prima_constraints=prima_constraints,
is_infeasible=is_infeasible, # TODO: copy may be unnecessary
batch_size=batch_size,
device=device,
)
def _unbatch_constraints(
constraints: ReadonlyConstraints,
reset_intermediate_layer_bounds_to_be_kept_fixed: bool,
) -> Sequence[Constraints]:
batch_size = constraints.batch_size
split_states = (
_unbatch_split_states(constraints.split_state)
if constraints.split_state is not None
else None
)
layer_bounds_s = _unbatch_layer_bounds(
constraints.layer_bounds,
reset_intermediate_layer_bounds_to_be_kept_fixed,
)
prima_constraints_s = (
_unbatch_prima_constraints(constraints.prima_constraints)
if constraints.prima_constraints is not None
else None
)
is_infeasibles = constraints.is_infeasible
device = constraints.device
return [
Constraints(
split_state=split_states[i] if split_states is not None else None,
layer_bounds=layer_bounds_s[i],
prima_constraints=prima_constraints_s[i]
if prima_constraints_s is not None
else None,
is_infeasible=is_infeasibles[i].unsqueeze(0), # TODO: copy unnecessary
batch_size=1,
device=device,
)
for i in range(batch_size)
]
def _batch_split_states(
split_states: Sequence[ReadonlySplitState],
device: torch.device,
) -> SplitState:
batch_size = sum(split_state.batch_size for split_state in split_states)
split_constraints = _compress_to_batch(
[split_state.split_constraints for split_state in split_states]
)
split_points = _compress_to_batch(
[split_state.split_points for split_state in split_states]
)
number_of_nodes_split = [
n for split_state in split_states for n in split_state.number_of_nodes_split
]
return SplitState(
split_constraints, split_points, number_of_nodes_split, batch_size, device
)
def _unbatch_split_states(
split_state: ReadonlySplitState,
) -> Sequence[SplitState]:
batch_size = split_state.batch_size
split_constraints_s = _unbatch_layer_property(
split_state.split_constraints, batch_size
)
split_points_s = _unbatch_layer_property(split_state.split_points, batch_size)
device = split_state.device
return [
SplitState(
split_constraints=split_constraints_s[i],
split_points=split_points_s[i],
number_of_nodes_split=[split_state.number_of_nodes_split[i]],
batch_size=1,
device=device,
)
for i in range(batch_size)
]
def _batch_layer_bounds(
layer_bounds_s: Sequence[ReadonlyLayerBounds],
device: torch.device,
) -> LayerBounds:
batch_size = sum(layer_bounds.batch_size for layer_bounds in layer_bounds_s)
intermediate_layer_bounds_to_be_kept_fixed = layer_bounds_s[
0
].intermediate_layer_bounds_to_be_kept_fixed
assert all(
layer_bounds.intermediate_layer_bounds_to_be_kept_fixed
== intermediate_layer_bounds_to_be_kept_fixed
for layer_bounds in layer_bounds_s
), "All subproblems must agree on which intermediate layers are kept fixed."
intermediate_bounds = _compress_intermediate_bounds_to_batch(
[layer_bounds.intermediate_bounds for layer_bounds in layer_bounds_s]
)
return LayerBounds(
intermediate_layer_bounds_to_be_kept_fixed=intermediate_layer_bounds_to_be_kept_fixed,
intermediate_bounds=intermediate_bounds,
batch_size=batch_size,
device=device,
)
def _unbatch_layer_bounds(
layer_bounds: ReadonlyLayerBounds,
reset_intermediate_layer_bounds_to_be_kept_fixed: bool,
) -> Sequence[LayerBounds]:
batch_size = layer_bounds.batch_size
intermediate_bounds_s = _unbatch_intermediate_bounds(
layer_bounds.intermediate_bounds, batch_size
)
device = layer_bounds.device
return [
LayerBounds(
intermediate_layer_bounds_to_be_kept_fixed=[]
if reset_intermediate_layer_bounds_to_be_kept_fixed
else layer_bounds.intermediate_layer_bounds_to_be_kept_fixed,
intermediate_bounds=intermediate_bounds_s[i],
batch_size=1,
device=device,
)
for i in range(batch_size)
]
def _batch_prima_constraints(
prima_constraints_s: Sequence[ReadonlyPrimaConstraints],
device: torch.device,
) -> PrimaConstraints:
batch_size = sum(
prima_constraints.batch_size for prima_constraints in prima_constraints_s
)
prima_coefficients = _batch_prima_coefficient_dicts(
[
prima_constraints.prima_coefficients
for prima_constraints in prima_constraints_s
],
device,
)
return PrimaConstraints(prima_coefficients, batch_size, device)
def _unbatch_prima_constraints(
prima_constraints: ReadonlyPrimaConstraints,
) -> Sequence[PrimaConstraints]:
batch_size = prima_constraints.batch_size
prima_coefficients_s = _unbatch_prima_coefficient_dicts(
prima_constraints.prima_coefficients, batch_size
)
device = prima_constraints.device
return [
PrimaConstraints(
prima_coefficients=prima_coefficients_s[i], batch_size=1, device=device
)
for i in range(batch_size)
]
def _batch_prima_coefficient_dicts(
prima_coefficients_set: Sequence[Mapping[LayerTag, Tuple[Tensor, Tensor, Tensor]]],
device: torch.device,
) -> Dict[LayerTag, Tuple[Tensor, Tensor, Tensor]]:
reference_prima_coefficients = prima_coefficients_set[0]
max_number_of_prima_constraints = {
layer_id: max(
[
prima_coefs[layer_id][0].shape[2]
for prima_coefs in prima_coefficients_set
]
)
for layer_id in reference_prima_coefficients
}
prima_coefficients_batch = {}
for layer_id in reference_prima_coefficients:
assert all(
[
layer_id in prima_coefficients
for prima_coefficients in prima_coefficients_set
]
)
prima_output_coefs = torch.cat(
[
_pad_sparse_matrix_to_match_size_in_dim_two(
prima_coefficients[layer_id][0],
max_number_of_prima_constraints[layer_id],
device,
)
for prima_coefficients in prima_coefficients_set
],
dim=0,
)
prima_input_coefs = torch.cat(
[
_pad_sparse_matrix_to_match_size_in_dim_two(
prima_coefficients[layer_id][1],
max_number_of_prima_constraints[layer_id],
device,
)
for prima_coefficients in prima_coefficients_set
],
dim=0,
)
prima_const_coefs = torch.cat(
[
_pad_sparse_matrix_to_match_size_in_dim_two(
prima_coefficients[layer_id][2],
max_number_of_prima_constraints[layer_id],
device,
)
for prima_coefficients in prima_coefficients_set
],
dim=0,
)
prima_coefficients_batch[layer_id] = (
prima_output_coefs.coalesce()
if prima_output_coefs.is_sparse
else prima_output_coefs,
prima_input_coefs.coalesce()
if prima_input_coefs.is_sparse
else prima_input_coefs,
prima_const_coefs,
)
return prima_coefficients_batch
def _pad_sparse_matrix_to_match_size_in_dim_two(
a: Tensor, size: int, device: torch.device
) -> Tensor:
current_size = a.shape[2]
if current_size == size:
return a
assert size > current_size
padding = torch.zeros(
*a.shape[:2], size - current_size, *a.shape[3:], layout=a.layout, device=device
)
return torch.cat([a, padding], dim=2)
def _batch_parameters(
parameters_s: Sequence[ReadonlyParameters],
device: torch.device,
) -> Parameters:
batch_size = sum(parameters.batch_size for parameters in parameters_s)
parameters_by_query = _batch_parameter_dicts(
[parameters.parameters_by_query for parameters in parameters_s],
batch_size,
device,
)
return Parameters(parameters_by_query, batch_size, device, use_params=True)
def _unbatch_parameters(
parameters: ReadonlyParameters,
) -> Sequence[Parameters]:
batch_size = parameters.batch_size
device = parameters.device
parameters_by_query_s = _unbatch_parameter_dicts(
parameters.parameters_by_query, batch_size, device
)
return [
Parameters(
parameters_by_query=parameters_by_query_s[i],
batch_size=1,
device=device,
use_params=True,
)
for i in range(batch_size)
]
def _batch_parameter_dicts( # TODO: move some of this logic into src.state.parameters
parameters_by_query: Sequence[Mapping[QueryTag, ReadonlyParametersForQuery]],
batch_size: int,
device: torch.device,
) -> Dict[QueryTag, ParametersForQuery]:
all_query_ids: Iterable[QueryTag] = set().union(*parameters_by_query)
parameters_by_query_batch: Dict[QueryTag, ParametersForQuery] = {}
for query_id in all_query_ids:
parameters_by_query_batch[query_id] = ParametersForQuery.create_default(
batch_size=batch_size, device=device
)
all_param_keys: Iterable[ParameterTag] = set().union(
*(
params[query_id].parameters
for params in parameters_by_query
if query_id in params
)
)
for param_key in all_param_keys:
if "prima" in param_key:
parameters_by_query_batch[query_id].parameters[param_key] = {}
all_layer_ids: Iterable[LayerTag] = set().union(
*(
params[query_id].parameters[param_key]
for params in parameters_by_query
if query_id in params
and param_key in params[query_id].parameters
)
)
for layer_id in all_layer_ids:
max_number_of_constraints = max(
[
params[query_id].parameters[param_key][layer_id].shape[1]
for params in parameters_by_query
]
)
parameters_by_query_batch[query_id].parameters[param_key][
layer_id
] = torch.cat(
[
_pad_to_match_size_in_dim_one(
params[query_id].parameters[param_key][layer_id],
max_number_of_constraints,
device,
)
for params in parameters_by_query
],
dim=0,
)
else:
parameters_by_query_batch[query_id].parameters[
param_key
] = _compress_to_batch(
[
params[query_id].parameters[param_key]
for params in parameters_by_query
]
)
return parameters_by_query_batch
def _pad_to_match_size_in_dim_one(a: Tensor, size: int, device: torch.device) -> Tensor:
current_size = a.shape[1]
if current_size == size:
return a
assert size > current_size
padding = torch.zeros(a.shape[0], size - current_size, *a.shape[2:], device=device)
return torch.cat([a, padding], dim=1)
def _unbatch_parameter_dicts(
parameters_by_query_batch: Mapping[QueryTag, ReadonlyParametersForQuery],
batch_size: int,
device: torch.device,
) -> Sequence[Dict[QueryTag, ParametersForQuery]]:
unbatched_parameters: Sequence[Dict[QueryTag, ParametersForQuery]] = [
{} for __ in range(batch_size)
]
for query_id in parameters_by_query_batch:
for parameters in unbatched_parameters:
parameters[query_id] = ParametersForQuery.create_default(
batch_size=batch_size, device=device
)
for param_key in parameters_by_query_batch[query_id].parameters:
for parameters in unbatched_parameters:
parameters[query_id].parameters[param_key] = {}
for layer_id in parameters_by_query_batch[query_id].parameters[param_key]:
split_layer_parameters = (
parameters_by_query_batch[query_id]
.parameters[param_key][layer_id]
.split(1, dim=0)
)
for i, parameters in enumerate(unbatched_parameters):
parameters[query_id].parameters[param_key][layer_id] = (
split_layer_parameters[i].clone().detach()
)
return unbatched_parameters
def _unbatch_prima_coefficient_dicts(
prima_coefficients_batch: Mapping[LayerTag, Tuple[Tensor, Tensor, Tensor]],
batch_size: int,
) -> Sequence[Dict[LayerTag, Tuple[Tensor, Tensor, Tensor]]]:
prima_coefficients_set: Sequence[Dict[LayerTag, Tuple[Tensor, Tensor, Tensor]]] = [
{} for __ in range(batch_size)
]
for layer_id in prima_coefficients_batch:
for i, prima_coefficients in enumerate(prima_coefficients_set):
prima_output_coefficients_of_layer = prima_coefficients_batch[layer_id][0][
i
].unsqueeze(0)
prima_input_coefficients_of_layer = prima_coefficients_batch[layer_id][1][
i
].unsqueeze(0)
prima_const_coefficients_of_layer = prima_coefficients_batch[layer_id][2][
i
].unsqueeze(0)
prima_coefficients[layer_id] = (
prima_output_coefficients_of_layer,
prima_input_coefficients_of_layer,
prima_const_coefficients_of_layer,
)
return prima_coefficients_set
def _unbatch_layer_property(
property_batch: Mapping[LayerTag, Tensor], batch_size: int
) -> Sequence[Dict[LayerTag, Tensor]]:
properties: Sequence[Dict[LayerTag, Tensor]] = [{} for __ in range(batch_size)]
for layer_id in property_batch:
layer_property = property_batch[layer_id].split(1, dim=0)
for i in range(batch_size):
properties[i][layer_id] = layer_property[i]
return properties
def _compress_to_batch(
dicts: Sequence[Mapping[LayerTag, Tensor]]
) -> Dict[LayerTag, Tensor]:
return {
key: torch.cat(
[d[key] for d in dicts],
dim=0,
)
for d in dicts
for key in d.keys()
}
def _compress_intermediate_bounds_to_batch(
intermediate_bounds: Sequence[Mapping[LayerTag, Tuple[Tensor, Tensor]]]
) -> OrderedDict[LayerTag, Tuple[Tensor, Tensor]]:
batched_intermediate_bounds = OrderedDict()
reference_keys = intermediate_bounds[0].keys()
for key in reference_keys:
batched_intermediate_bounds[key] = (
torch.cat(
[ib[key][0] for ib in intermediate_bounds],
dim=0,
),
torch.cat(
[ib[key][1] for ib in intermediate_bounds],
dim=0,
),
)
return batched_intermediate_bounds
def _unbatch_intermediate_bounds(
layer_bounds_batch: Mapping[LayerTag, Tuple[Tensor, Tensor]], batch_size: int
) -> Sequence[OrderedDict[LayerTag, Tuple[Tensor, Tensor]]]:
layer_bounds: List[OrderedDict[LayerTag, Tuple[Tensor, Tensor]]] = [
OrderedDict() for __ in range(batch_size)
]
for layer_id in layer_bounds_batch:
current_layer_lower_bounds = layer_bounds_batch[layer_id][0].split(1, dim=0)
current_layer_upper_bounds = layer_bounds_batch[layer_id][1].split(1, dim=0)
for i in range(batch_size):
layer_bounds[i][layer_id] = (
current_layer_lower_bounds[i],
current_layer_upper_bounds[i],
)
return layer_bounds
| 22,636 | 33.402736 | 209 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/initialization.py | import os
import random
import numpy as np
import torch
def seed_everything(seed: int) -> None:
os.environ["PL_GLOBAL_SEED"] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
torch.use_deterministic_algorithms(True)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.allow_tf32 = False
| 489 | 23.5 | 53 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.