clustering_config = {
"n_clusters": 10,
"alpha": 1,
"delta": 0.01,
"pretrain_epochs": 200,
"update_interval": 140,
"pretrain_simulated": False,
}
draw_model = DRAW(
T,
dec_size,
enc_size,
latent_dim,
train_data,
beta=10,
use_attention=True,
attn_config=attn_config,
mode_config=mode_config,
clustering_config=clustering_config,
labelled_data=[test_data, test_targets],
)
graph_kwds = {"initializer": tf.initializers.glorot_normal}
loss_kwds = {"reconst_loss": None}
draw_model.compile_model(graph_kwds, loss_kwds)
opt = tf.train.AdamOptimizer
opt_args = [1e-3]
def main(nvis, nhid, encoding_lstm_dim, decoding_lstm_dim, T=1):
x = tensor.matrix('features')
# Construct and initialize model
encoding_mlp = MLP([Tanh()], [None, None])
decoding_mlp = MLP([Tanh()], [None, None])
encoding_lstm = LSTM(dim=encoding_lstm_dim)
decoding_lstm = LSTM(dim=decoding_lstm_dim)
draw = DRAW(nvis=nvis, nhid=nhid, T=T, encoding_mlp=encoding_mlp,
decoding_mlp=decoding_mlp, encoding_lstm=encoding_lstm,
decoding_lstm=decoding_lstm, biases_init=Constant(0),
weights_init=Orthogonal())
draw.push_initialization_config()
encoding_lstm.weights_init = IsotropicGaussian(std=0.001)
decoding_lstm.weights_init = IsotropicGaussian(std=0.001)
draw.initialize()
# Compute cost
cost = -draw.log_likelihood_lower_bound(x).mean()
cost.name = 'nll_upper_bound'
model = Model(cost)
# Datasets and data streams
mnist_train = BinarizedMNIST('train')
train_loop_stream = ForceFloatX(DataStream(
dataset=mnist_train,
iteration_scheme=SequentialScheme(mnist_train.num_examples, 100)))
train_monitor_stream = ForceFloatX(DataStream(
dataset=mnist_train,
iteration_scheme=SequentialScheme(mnist_train.num_examples, 500)))
mnist_valid = BinarizedMNIST('valid')
valid_monitor_stream = ForceFloatX(DataStream(
dataset=mnist_valid,
iteration_scheme=SequentialScheme(mnist_valid.num_examples, 500)))
mnist_test = BinarizedMNIST('test')
test_monitor_stream = ForceFloatX(DataStream(
dataset=mnist_test,
iteration_scheme=SequentialScheme(mnist_test.num_examples, 500)))
# Get parameters and monitoring channels
computation_graph = ComputationGraph([cost])
params = VariableFilter(roles=[PARAMETER])(computation_graph.variables)
monitoring_channels = dict([
('avg_' + channel.tag.name, channel.mean()) for channel in
VariableFilter(name='.*term$')(computation_graph.auxiliary_variables)])
for name, channel in monitoring_channels.items():
channel.name = name
monitored_quantities = monitoring_channels.values() + [cost]
# Training loop
step_rule = RMSProp(learning_rate=1e-3, decay_rate=0.95)
algorithm = GradientDescent(cost=cost, params=params, step_rule=step_rule)
algorithm.add_updates(computation_graph.updates)
main_loop = MainLoop(
model=model, data_stream=train_loop_stream, algorithm=algorithm,
extensions=[
Timing(),
SerializeMainLoop('vae.pkl', save_separately=['model']),
FinishAfter(after_n_epochs=200),
DataStreamMonitoring(
monitored_quantities, train_monitor_stream, prefix="train",
updates=computation_graph.updates),
DataStreamMonitoring(
monitored_quantities, valid_monitor_stream, prefix="valid",
updates=computation_graph.updates),
DataStreamMonitoring(
monitored_quantities, test_monitor_stream, prefix="test",
updates=computation_graph.updates),
ProgressBar(),
Printing()])
main_loop.run()
print_log("----------------------------------------")
pairs = []
for i in range(args['num_attacks']):
orig_img = np.random.randint(0, len(test_x))
target_img = orig_img
while np.array_equal(target_img, orig_img):
target_img = np.random.randint(0, len(test_x))
pairs.append([orig_img, target_img])
# Load model
tf.reset_default_graph()
config['is_attacking'] = True
if config['architecture'] == 'draw':
vae = DRAW(config)
print_log("----------------------------------------")
print_log("DRAW graph loaded")
elif config['architecture'] == 'cvae':
vae = ConvVAE(config)
print_log("----------------------------------------")
print_log("ConvVAE graph loaded")
elif config['architecture'] == 'vae':
vae = VAE(config)
print_log("----------------------------------------")
print_log("VAE graph loaded")
else:
sys.exit("No architecture %s" % config['architecture'])
tf.get_default_graph().finalize()
vae.load(tf.train.latest_checkpoint(model_dir + '/model/'))
config['data_max_pixel'] = data_utils.max_pixel
config['is_attacking'] = False
tf.reset_default_graph()
if args['architecture'] == 'draw':
config['enc_size'] = args['enc_size']
config['dec_size'] = args['dec_size']
config['read_n'] = args['read_n']
config['write_n'] = args['write_n']
config['read_attn'] = args['read_attn']
config['write_attn'] = args['write_attn']
config['n_z'] = args['z_size']
config['T'] = args['T']
config['z_size'] = args['z_size'] * args['T']
vae = DRAW(config)
print("----------------------------------------")
print("DRAW graph loaded")
elif args['architecture'] == 'cvae':
conv_layers = []
deconv_layers = []
if args['dataset'] == 'svhn':
conv_layers.append(dict(n_filters=32, filter_size=4, stride=2))
conv_layers.append(dict(n_filters=64, filter_size=4, stride=2))
conv_layers.append(dict(n_filters=128, filter_size=4, stride=2))
gen_init_shape = [4, 4, int(args['dense_size'] / 16)]
deconv_layers.append(
dict(n_filters=128, filter_size=5, stride=2, pad='same'))
parser.add_argument('--batch_size', type=int, default=64, help='size of batch (default: 64)')
parser.add_argument('--data_dir', type=str, help='location of training data', default='./train')
parser.add_argument('--workers', type=int, help='number of data loading workers', default=2)
parser.add_argument('--data_parallel', type=bool, help='whether to parallelise based on data (default: False)', default=False)
args = parser.parse_args()
# Define dataset
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Lambda(lambda x: torch.bernoulli(x))
])
dataset = MNIST(root=args.data_dir, train=True, download=True, transform=transform)
# Create model and optimizer
model = DRAW(x_dim=784, h_dim=256, z_dim=16, T=10).to(device)
model = nn.DataParallel(model) if args.data_parallel else model
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, betas=(0.5, 0.999))
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 10, 0.5)
# Load the dataset
kwargs = {'num_workers': args.workers, 'pin_memory': True} if cuda else {}
loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, **kwargs)
loss = nn.BCELoss(reduce=False).to(device)
for epoch in range(args.epochs):
for x, _ in tqdm(loader):
batch_size = x.size(0)
x = x.view(batch_size, -1).to(device)
default=False)
args = parser.parse_args()
# Define dataset
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Lambda(lambda x: torch.bernoulli(x))
])
dataset = MNIST(root=args.data_dir,
train=True,
download=True,
transform=transform)
# Create model and optimizer
model = DRAW(x_dim=784, h_dim=256, z_dim=16, T=10).to(device)
model = nn.DataParallel(model) if args.data_parallel else model
optimizer = torch.optim.Adam(model.parameters(),
lr=1e-3,
betas=(0.5, 0.999))
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 10, 0.5)
# Load the dataset
kwargs = {'num_workers': args.workers, 'pin_memory': True} if cuda else {}
loader = DataLoader(dataset,
batch_size=args.batch_size,
shuffle=True,
**kwargs)
loss = nn.BCELoss(reduce=False).to(device)
def main(_):
## hyperparams
hps = tf.contrib.training.HParams(
batch_size=FLAGS.batch_size,
img_height=FLAGS.img_height,
img_width=FLAGS.img_width,
img_channels=FLAGS.img_channels,
num_timesteps=FLAGS.num_timesteps,
z_dim=FLAGS.z_dim,
encoder_hidden_dim=FLAGS.encoder_hidden_dim,
decoder_hidden_dim=FLAGS.decoder_hidden_dim,
read_dim=FLAGS.read_dim,
write_dim=FLAGS.write_dim,
init_scale=FLAGS.init_scale,
forget_bias=FLAGS.forget_bias,
lr=FLAGS.lr,
epochs=FLAGS.epochs)
## dataset
ds_train, ds_test = get_dataset(name=FLAGS.dataset, hps=hps)
## model and session
model = DRAW(hps)
sess = tf.Session()
## tensorboard
train_writer = tf.summary.FileWriter(FLAGS.summaries_dir + '/train',
sess.graph)
test_writer = tf.summary.FileWriter(FLAGS.summaries_dir + '/test')
## checkpointing
saver = tf.train.Saver()
## init op
init_op = tf.global_variables_initializer()
_ = sess.run(init_op)
## restoring
if FLAGS.load_checkpoint != '':
saver.restore(sess, FLAGS.load_checkpoint)
## helper functions for the various modes supported by this application
mode_to_routine = {
'train': routines.train,
'eval': routines.evaluate,
'generate': routines.generate,
'reconstruct': routines.reconstruct,
'generate_gif': routines.generate_gif,
'reconstruct_gif': routines.reconstruct_gif
}
routine = mode_to_routine[FLAGS.mode]
## rather than pass around tons of arguments,
# just use callbacks to perform the required functionality
if FLAGS.mode == 'train':
checkpoint_dir = FLAGS.checkpoint_dir
checkpoint_frequency = FLAGS.checkpoint_frequency
callbacks = {
'tensorboard':
calls.tensorboard(train_writer),
'checkpointing':
calls.checkpointing(sess, saver, checkpoint_dir,
checkpoint_frequency)
}
routine(ds_train, sess, model, callbacks)
elif FLAGS.mode == 'eval':
callbacks = {}
routine(ds_test, sess, model, callbacks)
else:
output_dir = FLAGS.output_dir
callbacks = {
'save_png': calls.save_png(output_dir),
'save_gif': calls.save_gif(output_dir)
}
routine(ds_test, sess, model, callbacks)
import tensorflow as tf
from agnet1.main1 import Main1
from agent2.main2 import Main2
from tool import Tools
from environment import Env
from draw import DRAW
import matplotlib.pyplot as plt
if __name__ == '__main__':
env = Env()
tools = Tools()
draw = DRAW()
g1 = tf.Graph()
main1 = Main1(g1)
g2 = tf.Graph()
main2 = Main2(2, g2)
plt.ion()
plt.figure(figsize=(100, 5)) # 设置画布大小
ax1 = plt.subplot(211)
ax2 = plt.subplot(212)
success = 0
totally = 0
zongzhou = []
while True:
a = input("input:")
default=False)
args = parser.parse_args()
# Define dataset
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Lambda(lambda x: torch.bernoulli(x))
])
dataset = MNIST(root=args.data_dir,
train=True,
download=True,
transform=transform)
# Create model and optimizer
model = DRAW(x_dim=784, h_dim=256, z_dim=16, T=10).to(device)
model = nn.DataParallel(model) if args.data_parallel else model
optimizer = torch.optim.Adam(model.parameters(),
lr=1e-3,
betas=(0.5, 0.999))
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 10, 0.5)
# Load the dataset
kwargs = {'num_workers': args.workers, 'pin_memory': True} if cuda else {}
loader = DataLoader(dataset,
batch_size=args.batch_size,
shuffle=True,
**kwargs)
loss = nn.BCELoss(reduce=False).to(device)
attn_config = {
"read_N": read_N,
"write_N": write_N,
"write_N_sq": write_N**2,
"delta_w": array_delta_w,
"delta_r": array_delta_r,
}
mode_config = {"simulated_mode": False, "restore_mode": True}
with tf.device("/gpu:2"):
draw_model = DRAW(
T,
dec_size,
enc_size,
latent_dim,
train_test,
use_conv=True,
# attn_config=attn_config,
mode_config=mode_config,
)
graph_kwds = {
"initializer": tf.initializers.glorot_normal,
"n_encoder_cells": 1,
"n_decoder_cells": 1,
}
loss_kwds = {"reconst_loss": None, "include_KL": False}
draw_model.CompileModel(graph_kwds, loss_kwds)
mode_config = {
"simulated_mode": False, #deprecated, to be removed
"restore_mode": False, #indicates whether to load weights
"include_KL": False, #whether to compute the KL loss over the latent space
"include_MMD": True, #same as above, but MMD
"include_KM":
False, #same as above, but K-means. See thesis for a more in-depth treatment of these
"batchnorm": False, #whether to include batch-normalization between layers
"use_vgg": False, #whether the input data is from a pre-trained model
"use_dd": False, #whether to use the dueling-decoder objective
}
draw_model = DRAW(T,
dec_size,
enc_size,
latent_dim,
train_data,
attn_config=attn_config,
mode_config=mode_config)
graph_kwds = {
"initializer": tf.initializers.glorot_normal,
}
loss_kwds = {
"reconst_loss": None,
}
draw_model.compile_model(graph_kwds, loss_kwds)
opt = tf.train.AdamOptimizer
opt_args = [1e-2]