def main():
np.random.seed(0)
assert keras.backend.backend() == "tensorflow"
set_model_flags(False)
tf.reset_default_graph()
g = tf.get_default_graph()
x = tf.placeholder(tf.float32,
shape=[None,
FLAGS.IMAGE_ROWS,
FLAGS.IMAGE_COLS,
FLAGS.NUM_CHANNELS]
)
y = tf.placeholder(tf.float32,
shape=[None, FLAGS.NUM_CLASSES]
)
train_mode = tf.placeholder(tf.bool)
adv_model = adv_models(FLAGS.TYPE)
ata = dataset('../Defense_Model/tiny-imagenet-200/', normalize = False)
sess, graph_dict = tf_train(g, x, y, data, adv_model, train_mode)
#tf_train returns the sess and graph_dict
#tf_test_error_rate also need to run the sess and use the feed_dict in the tf_train
#graph_dict is the dictiorary that contains all the items that is necessary on the graph
# Finally print the result!
test_error = tf_test_error_rate(sess, graph_dict, data)
print('Test error: %.1f%%' % test_error)
sess.close()
del(g)
def main(adv_model_names):
np.random.seed(0)
assert keras.backend.backend() == "tensorflow"
set_model_flags()
tf.reset_default_graph()
g = tf.get_default_graph()
x = tf.placeholder(
tf.float32,
shape=[None, FLAGS.IMAGE_ROWS, FLAGS.IMAGE_COLS, FLAGS.NUM_CHANNELS])
y = tf.placeholder(tf.float32, shape=[None, FLAGS.NUM_CLASSES])
train_mode = tf.placeholder(tf.bool)
eps = FLAGS.EPS
# if src_models is not None, we train on adversarial examples that come
# from multiple models
# load from out source
adv_models = [None] * len(adv_model_names)
for i, name in enumerate(adv_model_names):
adv_models[i] = load_model(name, path="./models/" + name + "-save.npy")
x_advs = [None] * (len(adv_models))
for i, m in enumerate(adv_models):
logits, _ = m(x)
grad = gen_grad(x, logits, y, loss='training')
x_advs[i] = symbolic_fgs(x, grad, eps=eps)
data = dataset(FLAGS.DIR, normalize=False)
sess, graph_dict = tf_train(g,
x,
y,
data,
defense_model,
train_mode,
x_advs=x_advs)
# Finally print the result!
test_error = tf_test_error_rate(sess, graph_dict, data, x_advs)
print('Test error: %.1f%%' % test_error)
import numpy as np
import pandas as pd
from sklearn.linear_model import SGDRegressor
import os
import yaml
from data_utils import dataset
with open('config.yaml') as f:
config = yaml.load(f)
data = dataset(config)
for i in range(config['city_number']):
tr = data.tr[i]
te = data.te[i]
WindowSize = 81
N, T, C = tr.shape
trainingFeatureSet = []
trainingLabelSet = []
for n in range(N):
t = 0
while t + WindowSize < T:
trainingFeatureSet.append(tr[n, t:t + WindowSize, :].flatten())
trainingLabelSet.append(tr[n, t + WindowSize, 0])
t = t + 1
trainingFeatureSet = np.array(trainingFeatureSet)
trainingLabelSet = np.array(trainingLabelSet)
N, T, C = te.shape
testingFeatureSet = []
testingLabelSet = []
for n in range(N):
t = 0
def main(_):
# download and load data sets
alldata = dataset(FLAGS.trainDir)
alldata.maybe_download_and_extract()
train_data, _, train_labels = alldata.load_training_data()
test_data, _, test_labels = alldata.load_test_data()
class_names = alldata.load_class_names()
iterations = int(
train_data.shape[0] /
configTrain.batch_size) # total training iterations in each epoch
tf.reset_default_graph()
g = tf.Graph()
with g.as_default():
model = build_graph(configModel)
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
## start training epochs
epoch = 1
while epoch <= configTrain.epochs:
now = datetime.now()
train_model_for_one_epoch(iterations,
train_data,
train_labels,
model,
sess,
configTrain,
record_train_loss=True)
used_time = datetime.now() - now
print("\nEpoch round ", epoch,
' used {0} seconds. '.format(used_time.seconds))
val_loss, val_accuracy = generate_prediction(
test_data, test_labels, model, sess, ['loss', 'accuracy'])
validation_loss.append(val_loss)
validation_accu.append(val_accuracy)
print("Valiation loss ", val_loss, " and accuracy ",
val_accuracy)
## if required, visualize activations from image
if configTrain.vis_weights_every_epoch > 0 and epoch % configTrain.vis_weights_every_epoch == 0:
vis_activations_from_model(train_data, model, sess,
FLAGS.trainDir, 10)
epoch += 1
## upon training done, plot training & validation losses and validation accuracy
print("training done.")
plot_training_loss(
training_loss, os.path.join(FLAGS.trainDir,
'train_losses.png'))
plot_val_loss_n_accuracy(
validation_loss, validation_accu,
os.path.join(FLAGS.trainDir, 'val_losses_n_accuracy.png'))
## save trained session
if not os.path.exists(FLAGS.savedSessionDir):
os.makedirs(FLAGS.savedSessionDir)
temp_saver = model['saver']()
save_path = temp_saver.save(
sess, os.path.join(FLAGS.savedSessionDir, modelName))
print("\nTraining done. Model saved: ",
os.path.join(FLAGS.savedSessionDir, modelName))
device = torch.device(opt.device)
model = vdsr.Net(opt).to(device)
if opt.start_epoch > 0:
model.load_state_dict(torch.load(opt.checkpoint_dir + '%s_epoch_%d_%s.pkl'
% (opt.model, opt.start_epoch, opt.suffix)))
print('# network parameters:', sum(param.numel() for param in model.parameters()))
optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr, weight_decay=1e-5)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.1, patience=10, verbose=True, min_lr=1e-5)
# MAELoss = torch.nn.L1Loss()
MSELoss = torch.nn.MSELoss()
# load dataset
train_dataset = dataset(opt.train_input_dir, opt.train_truth_dir)
train_data_loader = DataLoader(train_dataset, batch_size=opt.batch_size, shuffle=True)
val_dataset = dataset(opt.val_input_dir, opt.val_truth_dir)
val_data_loader = DataLoader(val_dataset, batch_size=opt.batch_size, shuffle=False)
results = {'p_loss': []}
results_val = {'p_loss': []}
for epoch in range(opt.epoch-opt.start_epoch):
epoch_true = epoch + opt.start_epoch + 1
# train model
model.train()
p_loss = 0
pic_num = 0
# In[ ]:
#set_model_flags(False)
graph, saver, images, logits = adv_model_resnet()
sess = tf.Session(graph=graph)
#sess.run(tf.global_variables_initializer())
#model.tf_load(sess, "./resnet18/checkpoints/model/")
path = os.path.join('resnet18', 'checkpoints', 'model')
saver.restore(sess, tf.train.latest_checkpoint(path))
data = dataset('../Defense_Model/tiny-imagenet-200/', normalize=False)
batch_size = 256
x_test, y_test = data.next_test_batch(batch_size)
with sess.as_default():
model = TensorFlowModel(images, logits, bounds=(0, 255))
y_logits = model.batch_predictions(x_test)
#y_prob=np.softmax(y_logits)
y_pred = np.argmax(y_logits, axis=1)
#print(y_pred)
y_label = np.argmax(y_test, axis=1)
print(np.sum(np.equal(y_pred, y_label)) / x_test.shape[0])
# In[ ]:
"""from tensorflow.python.tools.inspect_checkpoint import print_tensors_in_checkpoint_file
parser.add_argument('--input_nc', type=int, default=1)
parser.add_argument('--output_nc', type=int, default=9)
parser.add_argument('--suffix', type=str, default='9ch')
# other option
parser.add_argument('--test_epoch', type=int, default=45, help='test epoch')
parser.add_argument('--device', type=str, default='cuda:0', help='gpu name')
# define opt
opt = parser.parse_args()
model = vdsr.Net(opt).cuda()
model.load_state_dict(
torch.load(opt.checkpoint_dir + '%s_epoch_%d_%s.pkl' %
(opt.model, opt.test_epoch, opt.suffix)))
MSELoss = torch.nn.MSELoss()
test_dataset = dataset(opt.test_input_dir, opt.test_truth_dir)
test_data_loader = DataLoader(test_dataset, batch_size=1, shuffle=False)
total_pl = 0
pic_num = 0
model.eval()
print('test results of %s_%s_epoch_%s' %
(opt.model, opt.test_epoch, opt.suffix))
for iter, test_data in enumerate(test_data_loader):
input, truth = test_data
input, truth = Variable(input, requires_grad=False).cuda(), Variable(
truth, requires_grad=False).cuda()
batch_num = input.size(0)
pic_num += batch_num
pred = model(input)
