def test_compress(args):
"""Compresses an image."""
fn = tf.placeholder(tf.string, [])
# Load input image and add batch dimension.
x = read_png(fn)
x = tf.expand_dims(x, 0)
x.set_shape([1, None, None, 3])
x_shape = tf.shape(x)
# Instantiate model.
analysis_transform = AnalysisTransform(args.num_filters)
synthesis_transform = SynthesisTransform(args.num_filters)
hyper_analysis_transform = HyperAnalysisTransform(args.num_filters)
hyper_synthesis_transform = HyperSynthesisTransform(args.num_filters)
entropy_bottleneck = tfc.EntropyBottleneck()
# Transform and compress the image.
y = analysis_transform(x)
y_shape = tf.shape(y)
z = hyper_analysis_transform(abs(y))
z_hat, z_likelihoods = entropy_bottleneck(z, training=False)
sigma = hyper_synthesis_transform(z_hat)
sigma = sigma[:, :y_shape[1], :y_shape[2], :]
scale_table = np.exp(
np.linspace(np.log(SCALES_MIN), np.log(SCALES_MAX), SCALES_LEVELS))
conditional_bottleneck = DynamicGaussianConditional(
sigma, scale_table, name="gaussian_conditional")
side_string = entropy_bottleneck.compress(z)
string = conditional_bottleneck.compress(y)
# Transform the quantized image back (if requested).
y_hat, y_likelihoods = conditional_bottleneck(y, training=False)
x_hat = synthesis_transform(y_hat)
x_hat = x_hat[:, :x_shape[1], :x_shape[2], :]
num_pixels = tf.cast(tf.reduce_prod(tf.shape(x)[:-1]), dtype=tf.float32)
# Total number of bits divided by number of pixels.
eval_bpp = (tf.reduce_sum(tf.log(y_likelihoods)) + tf.reduce_sum(
tf.log(z_likelihoods))) / (-np.log(2) * num_pixels)
# Bring both images back to 0..255 range.
x *= 255
x_hat = tf.clip_by_value(x_hat, 0, 1)
x_hat = tf.round(x_hat * 255)
mse = tf.reduce_mean(tf.squared_difference(x, x_hat))
psnr = tf.squeeze(tf.image.psnr(x_hat, x, 255))
msssim = tf.squeeze(tf.image.ssim_multiscale(x_hat, x, 255))
with tf.Session() as sess:
# Load the latest model checkpoint, get the compressed string and the tensor
# shapes.
latest = tf.train.latest_checkpoint(checkpoint_dir=args.checkpoint_dir)
tf.train.Saver().restore(sess, save_path=latest)
#a = sess.run( tf.reduce_sum(tf.log(y_likelihoods), axis=(0,1,2)) / (-np.log(2) * num_pixels))
#b = sess.run( tf.reduce_sum(tf.log(z_likelihoods), axis=(0,1,2)) / (-np.log(2) * num_pixels))
#np.savetxt('ay.csv', a, delimiter = ',')
#np.savetxt('bz.csv', b, delimiter = ',')
#return
const = tf.constant([1] * 256 + [0] * 224, dtype=tf.float32)
f = open("e5.csv", "w")
print("active, fn, bpp, mse, np", file=f)
for active in range(256, 31, -16):
#conditional_bottleneck.input_spec = tf.keras.layers.InputSpec(ndim=4, axes={3: active})
mask = const[256 - active:512 - active]
rate = tf.reduce_sum(mask) / 256
y_itc = y * mask / rate
string = conditional_bottleneck.compress(y_itc)
y_itc_hat = conditional_bottleneck.decompress(string)
# Transform the quantized image back (if requested).
x_hat = synthesis_transform(y_itc_hat)
x_hat = x_hat[:, :x_shape[1], :x_shape[2], :]
eval_bpp = (tf.reduce_sum(tf.log(y_likelihoods[:, :, :, :active]))
+ tf.reduce_sum(tf.log(z_likelihoods))) / (-np.log(2) *
num_pixels)
x_hat = tf.clip_by_value(x_hat, 0, 1)
x_hat = tf.round(x_hat * 255)
mse = tf.reduce_mean(tf.squared_difference(x, x_hat))
psnr = tf.squeeze(tf.image.psnr(x_hat, x, 255))
msssim = tf.squeeze(tf.image.ssim_multiscale(x_hat, x, 255))
#tensors = [string, side_string,
# tf.shape(x)[1:-1], tf.shape(y)[1:-1], tf.shape(z)[1:-1]]
#arrays = sess.run(tensors)
# Write a binary file with the shape information and the compressed string.
#packed = tfc.PackedTensors()
#packed.pack(tensors, arrays)
for filename in glob.glob("kodak/*.png"):
v_eval_bpp, v_mse, v_num_pixels = sess.run(
[eval_bpp, mse, num_pixels], feed_dict={fn: filename})
print("%.2f, %s, %.4f, %.4f, %d" %
(active, filename, v_eval_bpp, v_mse, v_num_pixels),
file=f)
f.close()
def run(self):
win_count = 0
while True:
try:
tf.reset_default_graph()
init = tf.global_variables_initializer()
state_maker = StateMaker()
if not os.path.exists(MODEL_PATH):
os.makedirs(MODEL_PATH)
with tf.Session() as sess:
sess.run(init)
saver = tf.train.import_meta_graph(MODEL_PATH +
'/model-ddqn.ckpt.meta')
saver.restore(sess,
tf.train.latest_checkpoint(MODEL_PATH + '/'))
graph = tf.get_default_graph()
online_in = graph.get_tensor_by_name('X_1:0')
# Run loop
info = self.ar.configure(self.id)
self.solved = [
0 for x in range(self.ar.get_number_of_levels())
]
max_scores = np.zeros([len(self.solved)])
self.current_level = self.get_next_level()
self.ar.load_level(self.current_level)
if self.current_level >= 457:
print("Shutong: win_count: ", win_count)
s = 'None'
d = False
first_time_in_level_in_episode = True
for env_step in range(1, TOTAL_STEPS):
game_state = self.ar.get_game_state()
r = self.ar.get_current_score()
print('current score ', r)
print('win count: ', win_count)
#if(game_state == GameState.UNSTABLE):
# self.get_next_level()
# First check if we are in the won or lost state
# to adjust the reward and done flag if needed
if game_state == GameState.WON:
# save current state before reloading the level
s = self.ar.do_screenshot()
s = state_maker.make(sess, s)
n_levels = self.update_no_of_levels()
print("number of levels ", n_levels)
self.check_my_score()
self.current_level = self.get_next_level()
self.ar.load_level(self.current_level)
win_count += 1
# Update reward and done
d = 1
first_time_in_level_in_episode = True
elif game_state == GameState.LOST:
# save current state before reloading the level
s = self.ar.do_screenshot()
s = state_maker.make(sess, s)
# check for change of number of levels in the game
n_levels = self.update_no_of_levels()
print("number of levels ", n_levels)
self.check_my_score()
# If lost, then restart the level
self.failed_counter += 1
if self.failed_counter > 1: # for testing , go directly to the next level
self.failed_counter = 0
self.current_level = self.get_next_level()
self.ar.load_level(self.current_level)
else:
print("restart")
self.ar.load_level(self.current_level)
# Update reward and done
d = 1
first_time_in_level_in_episode = True
if (game_state == GameState.PLAYING):
# Start of the episode
if (first_time_in_level_in_episode):
# If first time in level reset states
s = 'None'
self.ar.fully_zoom_out()
self.ar.fully_zoom_out()
self.ar.fully_zoom_out()
self.ar.fully_zoom_out()
self.ar.fully_zoom_out()
self.ar.fully_zoom_out()
self.ar.fully_zoom_out()
first_time_in_level_in_episode = False
self.get_slingshot_center()
if self.sling_center == None:
print('sling ', self.sling_center)
continue
s = self.ar.do_screenshot()
s = state_maker.make(sess, s)
a = sess.run(
graph.get_tensor_by_name('ArgMax_1:0'),
feed_dict={online_in: [s]})
tap_time = int(random.randint(65, 100))
ax_pixels = -int(40 * math.cos(math.radians(a)))
ay_pixels = int(40 * math.sin(math.radians(a)))
print("Shoot: " + str(ax_pixels) + ", " +
str(ay_pixels) + ", " + str(tap_time))
# Execute a in the environment
self.ar.shoot(int(self.sling_center.X),
int(self.sling_center.Y), ax_pixels,
ay_pixels, 0, tap_time, False)
elif game_state == GameState.LEVEL_SELECTION:
print(
"unexpected level selection page, go to the last current level : ",
self.current_level)
self.ar.load_level(self.current_level)
elif game_state == GameState.MAIN_MENU:
print(
"unexpected main menu page, reload the level : ",
self.current_level)
self.ar.load_level(self.current_level)
elif game_state == GameState.EPISODE_MENU:
print(
"unexpected episode menu page, reload the level: ",
self.current_level)
self.ar.load_level(self.current_level)
except Exception as e:
print("Error: ", e)
finally:
time.sleep(10)
def __init__(
self,
images: "tf.Tensor",
model: Optional["FasterRCNNMetaArch"] = None,
filename: Optional[str] = None,
url: Optional[str] = None,
sess: Optional["Session"] = None,
is_training: bool = False,
clip_values: Optional["CLIP_VALUES_TYPE"] = None,
channels_first: bool = False,
preprocessing_defences: Union["Preprocessor", List["Preprocessor"],
None] = None,
postprocessing_defences: Union["Postprocessor", List["Postprocessor"],
None] = None,
preprocessing: "PREPROCESSING_TYPE" = (0.0, 1.0),
attack_losses: Tuple[str, ...] = (
"Loss/RPNLoss/localization_loss",
"Loss/RPNLoss/objectness_loss",
"Loss/BoxClassifierLoss/localization_loss",
"Loss/BoxClassifierLoss/classification_loss",
),
):
"""
Initialization of an instance TensorFlowFasterRCNN.
:param images: Input samples of shape (nb_samples, height, width, nb_channels).
:param model: A TensorFlow Faster-RCNN model. The output that can be computed from the model includes a tuple
of (predictions, losses, detections):
- predictions: a dictionary holding "raw" prediction tensors.
- losses: a dictionary mapping loss keys (`Loss/RPNLoss/localization_loss`,
`Loss/RPNLoss/objectness_loss`, `Loss/BoxClassifierLoss/localization_loss`,
`Loss/BoxClassifierLoss/classification_loss`) to scalar tensors representing
corresponding loss values.
- detections: a dictionary containing final detection results.
:param filename: Filename of the detection model without filename extension.
:param url: URL to download archive of detection model including filename extension.
:param sess: Computation session.
:param is_training: A boolean indicating whether the training version of the computation graph should be
constructed.
:param clip_values: Tuple of the form `(min, max)` of floats or `np.ndarray` representing the minimum and
maximum values allowed for input image features. If floats are provided, these will be
used as the range of all features. If arrays are provided, each value will be considered
the bound for a feature, thus the shape of clip values needs to match the total number
of features.
:param channels_first: Set channels first or last.
:param preprocessing_defences: Preprocessing defence(s) to be applied by the classifier.
:param postprocessing_defences: Postprocessing defence(s) to be applied by the classifier.
:param preprocessing: Tuple of the form `(subtractor, divider)` of floats or `np.ndarray` of values to be
used for data preprocessing. The first value will be subtracted from the input. The
input will then be divided by the second one.
:param attack_losses: Tuple of any combination of strings of the following loss components:
`first_stage_localization_loss`, `first_stage_objectness_loss`,
`second_stage_localization_loss`, `second_stage_classification_loss`.
"""
import tensorflow.compat.v1 as tf # lgtm [py/repeated-import]
# Super initialization
super().__init__(
model=model,
clip_values=clip_values,
channels_first=channels_first,
preprocessing_defences=preprocessing_defences,
postprocessing_defences=postprocessing_defences,
preprocessing=preprocessing,
)
# Check clip values
if self.clip_values is not None:
if not np.all(self.clip_values[0] == 0):
raise ValueError(
"This classifier requires normalized input images with clip_vales=(0, 1)."
)
if not np.all(self.clip_values[1] == 1): # pragma: no cover
raise ValueError(
"This classifier requires normalized input images with clip_vales=(0, 1)."
)
# Check preprocessing and postprocessing defences
if self.preprocessing_defences is not None:
raise ValueError(
"This estimator does not support `preprocessing_defences`.")
if self.postprocessing_defences is not None:
raise ValueError(
"This estimator does not support `postprocessing_defences`.")
# Create placeholders for groundtruth boxes
self._groundtruth_boxes_list: List["tf.Tensor"]
self._groundtruth_boxes_list = [
tf.placeholder(dtype=tf.float32,
shape=(None, 4),
name=f"groundtruth_boxes_{i}")
for i in range(images.shape[0])
]
# Create placeholders for groundtruth classes
self._groundtruth_classes_list: List["tf.Tensor"]
self._groundtruth_classes_list = [
tf.placeholder(dtype=tf.int32,
shape=(None, ),
name=f"groundtruth_classes_{i}")
for i in range(images.shape[0])
]
# Create placeholders for groundtruth weights
self._groundtruth_weights_list: List["tf.Tensor"]
self._groundtruth_weights_list = [
tf.placeholder(dtype=tf.float32,
shape=(None, ),
name=f"groundtruth_weights_{i}")
for i in range(images.shape[0])
]
# Load model
if model is None:
# If model is None, then we need to have parameters filename and url to download, extract and load the
# object detection model
if filename is None or url is None:
filename, url = (
"faster_rcnn_inception_v2_coco_2017_11_08",
"http://download.tensorflow.org/models/object_detection/"
"faster_rcnn_inception_v2_coco_2017_11_08.tar.gz",
)
self._model, self._predictions, self._losses, self._detections = self._load_model(
images=images,
filename=filename,
url=url,
obj_detection_model=None,
is_training=is_training,
groundtruth_boxes_list=self._groundtruth_boxes_list,
groundtruth_classes_list=self._groundtruth_classes_list,
groundtruth_weights_list=self._groundtruth_weights_list,
)
else:
self._model, self._predictions, self._losses, self._detections = self._load_model(
images=images,
filename=None,
url=None,
obj_detection_model=model,
is_training=is_training,
groundtruth_boxes_list=self._groundtruth_boxes_list,
groundtruth_classes_list=self._groundtruth_classes_list,
groundtruth_weights_list=self._groundtruth_weights_list,
)
# Save new attributes
self._input_shape = images.shape.as_list()[1:]
self.is_training: bool = is_training
self.images: Optional["tf.Tensor"] = images
self.attack_losses: Tuple[str, ...] = attack_losses
# Assign session
if sess is None:
logger.warning("A session cannot be None, create a new session.")
self._sess = tf.Session()
else: # pragma: no cover
self._sess = sess
# Initialize variables
self._sess.run(tf.global_variables_initializer())
self._sess.run(tf.local_variables_initializer())
def __init__(self, board_width, board_height, model_file=None):
self.board_width = board_width
self.board_height = board_height
# Define the tensorflow neural network
# 1. Input:
self.input_states = tf.placeholder(
tf.float32, shape=[None, 4, board_height, board_width])
self.input_state = tf.transpose(self.input_states, [0, 2, 3, 1])
# 2. Common Networks Layers
self.conv1 = tf.layers.conv2d(inputs=self.input_state,
filters=32, kernel_size=[3, 3],
padding="same", data_format="channels_last",
activation=tf.nn.relu)
self.conv2 = tf.layers.conv2d(inputs=self.conv1, filters=64,
kernel_size=[3, 3], padding="same",
data_format="channels_last",
activation=tf.nn.relu)
self.conv3 = tf.layers.conv2d(inputs=self.conv2, filters=128,
kernel_size=[3, 3], padding="same",
data_format="channels_last",
activation=tf.nn.relu)
# 3-1 Action Networks
self.action_conv = tf.layers.conv2d(inputs=self.conv3, filters=4,
kernel_size=[1, 1], padding="same",
data_format="channels_last",
activation=tf.nn.relu)
# Flatten the tensor
self.action_conv_flat = tf.reshape(
self.action_conv, [-1, 4 * board_height * board_width])
# 3-2 Full connected layer, the output is the log probability of moves
# on each slot on the board
self.action_fc = tf.layers.dense(inputs=self.action_conv_flat,
units=board_height * board_width,
activation=tf.nn.log_softmax)
# 4 Evaluation Networks
self.evaluation_conv = tf.layers.conv2d(inputs=self.conv3, filters=2,
kernel_size=[1, 1],
padding="same",
data_format="channels_last",
activation=tf.nn.relu)
self.evaluation_conv_flat = tf.reshape(
self.evaluation_conv, [-1, 2 * board_height * board_width])
self.evaluation_fc1 = tf.layers.dense(inputs=self.evaluation_conv_flat,
units=64, activation=tf.nn.relu)
# output the score of evaluation on current state
self.evaluation_fc2 = tf.layers.dense(inputs=self.evaluation_fc1,
units=1, activation=tf.nn.tanh)
# Define the Loss function
# 1. Label: the array containing if the game wins or not for each state
self.labels = tf.placeholder(tf.float32, shape=[None, 1])
# 2. Predictions: the array containing the evaluation score of each state
# which is self.evaluation_fc2
# 3-1. Value Loss function
self.value_loss = tf.losses.mean_squared_error(self.labels,
self.evaluation_fc2)
# 3-2. Policy Loss function
self.mcts_probs = tf.placeholder(
tf.float32, shape=[None, board_height * board_width])
self.policy_loss = tf.negative(tf.reduce_mean(
tf.reduce_sum(tf.multiply(self.mcts_probs, self.action_fc), 1)))
# 3-3. L2 penalty (regularization)
l2_penalty_beta = 1e-4
vars = tf.trainable_variables()
l2_penalty = l2_penalty_beta * tf.add_n(
[tf.nn.l2_loss(v) for v in vars if 'bias' not in v.name.lower()])
# 3-4 Add up to be the Loss function
self.loss = self.value_loss + self.policy_loss + l2_penalty
# Define the optimizer we use for training
self.learning_rate = tf.placeholder(tf.float32)
self.optimizer = tf.train.AdamOptimizer(
learning_rate=self.learning_rate).minimize(self.loss)
# Make a session
self.session = tf.Session()
# calc policy entropy, for monitoring only
self.entropy = tf.negative(tf.reduce_mean(
tf.reduce_sum(tf.exp(self.action_fc) * self.action_fc, 1)))
# Initialize variables
init = tf.global_variables_initializer()
self.session.run(init)
# For saving and restoring
self.saver = tf.train.Saver()
if model_file is not None:
self.restore_model(model_file)
def main(unused_args):
logging.set_verbosity(logging.INFO)
tf.random.set_random_seed(SEED)
logging.info('hops %d lr %f train %s test %s dev %s', FLAGS.num_hops,
FLAGS.learning_rate, FLAGS.train_file, FLAGS.test_file,
FLAGS.dev_file)
# set up the builder, context, and datasets
builder = MetaQABuilder()
context = builder.build_context()
train_dset_fn = make_dset_fn(context,
FLAGS.train_file,
shuffle=True,
epochs=FLAGS.epochs,
n_take=FLAGS.num_train)
test_dset_fn = make_dset_fn(context,
FLAGS.test_file,
shuffle=True,
epochs=1)
if FLAGS.action == 'train_ph':
feature_ph_dict, labels_ph = make_feature_label_ph_pair(context)
model = builder.build_model(feature_ph_dict,
labels_ph,
context=context)
with tf.Session() as session:
trainer = util.Trainer(session, model, feature_ph_dict, labels_ph)
trainer.train(train_dset_fn())
tf.train.Saver().save(session,
FLAGS.checkpoint_dir + '/final.chpt')
elif FLAGS.action == 'test_ph':
feature_ph_dict, labels_ph = make_feature_label_ph_pair(context)
model = builder.build_model(feature_ph_dict,
labels_ph,
context=context)
with tf.Session() as session:
tf.train.Saver().restore(session,
FLAGS.checkpoint_dir + '/final.chpt')
trainer = util.Trainer(session, model, feature_ph_dict, labels_ph)
evaluation = trainer.evaluate(test_dset_fn())
print('evaluation', evaluation)
elif FLAGS.action == 'expt_ph':
feature_ph_dict, labels_ph = make_feature_label_ph_pair(context)
model = builder.build_model(feature_ph_dict,
labels_ph,
context=context)
with tf.Session() as session:
trainer = util.Trainer(session, model, feature_ph_dict, labels_ph)
callback_dset_fn = make_dset_fn(context,
FLAGS.dev_file,
shuffle=True,
epochs=1,
n_take=FLAGS.online_eval_size)
evaluation = trainer.evaluate(callback_dset_fn())
tf.logging.info('before training: %s', evaluation)
# set up callback to evaluate on dev every so often
model.num_steps = 0
old_callback = model.training_callback
def eval_periodically_callback(fd, latest_loss, elapsed_time):
# default callback increments model.num_examples
status = old_callback(fd, latest_loss, elapsed_time)
model.num_steps += 1
if (model.num_steps % FLAGS.steps_between_evals) == 0:
tf.logging.info('running eval on heldout dev set...')
evaluation = trainer.evaluate(callback_dset_fn())
tf.logging.info('after %d examples: %s',
model.num_examples, evaluation)
return status
model.training_callback = eval_periodically_callback
trainer.train(train_dset_fn())
evaluation = trainer.evaluate(test_dset_fn())
tf.logging.info('final evaluation %s', evaluation)
try:
tf.train.Saver().save(session,
FLAGS.checkpoint_dir + '/final.chpt')
except ValueError:
tf.logging.error('fail to save model at %s',
FLAGS.checkpoint_dir + '/final.chpt')
else:
raise ValueError('illegal action')
def lagrangian_optimizer_kld(train_set, additive_slack, learning_rate,
learning_rate_constraint, loops):
"""Implements surrogate-based Lagrangian optimizer (Algorithm 2).
Specifically solves:
min_{theta} sum_{G = 0, 1} KLD(p, pprG(theta))
s.t. error_rate <= additive_slack,
where p is the overall proportion of positives and pprG is the positive
prediction rate for group G.
We frame this as a constrained optimization problem:
min_{theta, xi_pos0, xi_pos1, xi_neg0, xi_neg1} {
-p log(xi_pos0) - (1-p) log(xi_neg0) - p log(xi_pos1)
-(1-p) log(xi_neg1)}
s.t.
error_rate <= additive_slack,
xi_pos0 <= ppr0(theta), xi_neg0 <= npr0(theta),
xi_pos1 <= ppr1(theta), xi_neg1 <= npr1(theta),
and formulate the Lagrangian:
max_{lambda's >= 0} min_{xi's} {
-p log(xi_pos0) - (1-p) log(xi_neg0) - p log(xi_pos1)
-(1-p) log(xi_neg1)
+ lambda_pos0 (xi_pos0 - ppr0(theta))
+ lambda_neg0 (xi_neg0 - npr0(theta))
+ lambda_pos1 (xi_pos1 - ppr1(theta))
+ lambda_neg1 (xi_neg1 - npr1(theta))}
s.t.
error_rate <= additive_slack.
We do best response for the slack variables xi:
BR for xi_pos0 = p / lambda_pos0
BR for xi_neg0 = (1 - p) / lambda_neg0
BR for xi_pos1 = p / lambda_pos1
BR for xi_neg1 = (1 - p) / lambda_neg1
We do gradient ascent on the lambda's, where
Gradient w.r.t. lambda_pos0
= BR for xi_pos0 - ppr0(theta)
= p / lambda_pos0 - ppr0(theta)
= Gradient w.r.t. lambda_pos0 of
(p log(lambda_pos0) - lambda_pos0 ppr0(theta))
Gradient w.r.t. lambda_neg0
= Gradient w.r.t. lambda_neg0 of
((1 - p) log(lambda_neg0) - lambda_neg0 npr0(theta))
Gradient w.r.t. lambda_pos1
= Gradient w.r.t. lambda_pos1 of
(p log(lambda_pos1) - lambda_pos1 ppr1(theta))
Gradient w.r.t. lambda_neg1
= Gradient w.r.t. lambda_neg1 of
((1 - p) log(lambda_neg1) - lambda_neg1 npr1(theta)).
We do gradient descent on thetas's, with ppr's and npr's replaced with hinge
surrogates. We use concave lower bounds on ppr's and npr's, so that when they
get negated in the updates, we get convex upper bounds.
See Appendix D.1 in the paper for more details.
Args:
train_set: (features, labels, groups)
additive_slack: float, additive slack on error rate constraint
learning_rate: float, learning rate for model parameters
learning_rate_constraint: float, learning rate for Lagrange multipliers
loops: int, number of iterations
Returns:
stochastic_model containing list of models and probabilities,
deterministic_model.
"""
x_train, y_train, z_train = train_set
dimension = x_train.shape[-1]
tf.reset_default_graph()
# Data tensors.
features_tensor = tf.constant(x_train.astype("float32"), name="features")
labels_tensor = tf.constant(y_train.astype("float32"), name="labels")
# Linear model.
weights = tf.Variable(tf.zeros(dimension, dtype=tf.float32),
name="weights")
threshold = tf.Variable(0, name="threshold", dtype=tf.float32)
predictions_tensor = (tf.tensordot(features_tensor, weights, axes=(1, 0)) +
threshold)
# Group-specific predictions.
predictions_group0 = tf.boolean_mask(predictions_tensor,
mask=(z_train < 1))
num_examples0 = np.sum(z_train < 1)
predictions_group1 = tf.boolean_mask(predictions_tensor,
mask=(z_train > 0))
num_examples1 = np.sum(z_train > 0)
# We use the TF Constrained Optimization (TFCO) library to set up the
# constrained optimization problem. The library doesn't currently support best
# responses for slack variables. So we maintain explicit Lagrange multipliers
# for the slack variables, and let the library deal with the Lagrange
# multipliers for the error rate constraint.
# Since we need to perform a gradient descent update on the model parameters,
# and an ascent update on the Lagrange multipliers on the slack variables, we
# create a single "minimization" objective using stop gradients, where a
# descent gradient update has the effect of minimizing over the model
# parameters and maximizing over the Lagrange multipliers for the slack
# variables. As noted above, the ascent update on the Lagrange multipliers for
# the error rate constraint is done by the library internally.
# Placeholders for Lagrange multipliers for the four slack variables.
lambda_pos0 = tf.Variable(0.5, dtype=tf.float32, name="lambda_pos0")
lambda_neg0 = tf.Variable(0.5, dtype=tf.float32, name="lambda_neg0")
lambda_pos1 = tf.Variable(0.5, dtype=tf.float32, name="lambda_pos1")
lambda_neg1 = tf.Variable(0.5, dtype=tf.float32, name="lambda_neg1")
# Set up prediction rates and surrogate relaxations on them.
p = np.mean(y_train) # Proportion of positives.
# Positive and negative prediction rates for group 0 and group 1.
ppr_group0 = tf.reduce_sum(
tf.cast(
tf.greater(predictions_group0,
tf.zeros(num_examples0, dtype="float32")),
"float32")) / num_examples0
npr_group0 = 1 - ppr_group0
ppr_group1 = tf.reduce_sum(
tf.cast(
tf.greater(predictions_group1,
tf.zeros(num_examples1, dtype="float32")),
"float32")) / num_examples1
npr_group1 = 1 - ppr_group1
# Hinge concave lower bounds on the positive and negative prediction rates.
# In the gradient updates, these get negated and become convex upper bounds.
# For group 0:
ppr_hinge_group0 = tf.reduce_sum(
1 - tf.nn.relu(1 - predictions_group0)) * 1.0 / num_examples0
npr_hinge_group0 = tf.reduce_sum(
1 - tf.nn.relu(1 + predictions_group0)) * 1.0 / num_examples0
# For group 1:
ppr_hinge_group1 = tf.reduce_sum(
1 - tf.nn.relu(1 - predictions_group1)) * 1.0 / num_examples1
npr_hinge_group1 = tf.reduce_sum(
1 - tf.nn.relu(1 + predictions_group1)) * 1.0 / num_examples1
# Set up KL-divergence objective for constrained optimization.
# We use stop gradients to ensure that a single descent gradient update on the
# objective has the effect of minimizing over the model parameters and
# maximizing over the Lagrange multipliers for the slack variables.
# KL-divergence for group 0.
kld_hinge_pos_group0 = (-tf.stop_gradient(lambda_pos0) * ppr_hinge_group0 -
p * tf.log(lambda_pos0) +
lambda_pos0 * tf.stop_gradient(ppr_group0))
kld_hinge_neg_group0 = (-tf.stop_gradient(lambda_neg0) * npr_hinge_group0 -
(1 - p) * tf.log(lambda_neg0) +
lambda_neg0 * tf.stop_gradient(npr_group0))
kld_hinge_group0 = kld_hinge_pos_group0 + kld_hinge_neg_group0
# KL-divergence for group 1.
kld_hinge_pos_group1 = (-tf.stop_gradient(lambda_pos1) * ppr_hinge_group1 -
p * tf.log(lambda_pos1) +
lambda_pos1 * tf.stop_gradient(ppr_group1))
kld_hinge_neg_group1 = (-tf.stop_gradient(lambda_neg1) * npr_hinge_group1 -
(1 - p) * tf.log(lambda_neg1) +
lambda_neg1 * tf.stop_gradient(npr_group1))
kld_hinge_group1 = kld_hinge_pos_group1 + kld_hinge_neg_group1
# Wrap the objective into a rate object.
objective = tfco.wrap_rate(kld_hinge_group0 + kld_hinge_group1)
# Set up error rate constraint for constrained optimization.
context = tfco.rate_context(predictions_tensor, labels_tensor)
error = tfco.error_rate(context)
constraints = [error <= additive_slack]
# Cretae rate minimization problem object.
problem = tfco.RateMinimizationProblem(objective, constraints)
# Set up optimizer.
optimizer = tfco.LagrangianOptimizerV1(
tf.train.AdamOptimizer(learning_rate=learning_rate),
constraint_optimizer=tf.train.AdamOptimizer(
learning_rate=learning_rate_constraint))
train_op = optimizer.minimize(problem)
# Start TF session and initialize variables.
session = tf.Session()
session.run(tf.global_variables_initializer())
# We maintain a list of objectives and model weights during training.
objectives = []
violations = []
models = []
# Perform full gradient updates.
for ii in range(loops):
# Gradient updates.
session.run(train_op)
# Checkpoint once in 10 iterations.
if ii % 10 == 0:
# Model weights.
model = [session.run(weights), session.run(threshold)]
models.append(model)
# Objective.
klds = evaluation.expected_group_klds(x_train, y_train, z_train,
[model], [1.0])
objectives.append(sum(klds))
# Violation.
error = evaluation.expected_error_rate(x_train, y_train, [model],
[1.0])
violations.append([error - additive_slack])
# Use the recorded objectives and constraints to find the best iterate.
best_iterate = tfco.find_best_candidate_index(np.array(objectives),
np.array(violations))
deterministic_model = models[best_iterate]
# Use shrinking to find a sparse distribution over iterates.
probabilities = tfco.find_best_candidate_distribution(
np.array(objectives), np.array(violations))
models_pruned = [
models[i] for i in range(len(models)) if probabilities[i] > 0.0
]
probabilities_pruned = probabilities[probabilities > 0.0]
return (models_pruned, probabilities_pruned), deterministic_model
def evaluate(test_csvs, create_model):
if FLAGS.scorer_path:
scorer = Scorer(FLAGS.lm_alpha, FLAGS.lm_beta,
FLAGS.scorer_path, Config.alphabet)
else:
scorer = None
test_sets = [create_dataset([csv], batch_size=FLAGS.test_batch_size, train_phase=False) for csv in test_csvs]
iterator = tfv1.data.Iterator.from_structure(tfv1.data.get_output_types(test_sets[0]),
tfv1.data.get_output_shapes(test_sets[0]),
output_classes=tfv1.data.get_output_classes(test_sets[0]))
test_init_ops = [iterator.make_initializer(test_set) for test_set in test_sets]
batch_wav_filename, (batch_x, batch_x_len), batch_y = iterator.get_next()
# One rate per layer
no_dropout = [None] * 6
logits, _ = create_model(batch_x=batch_x,
batch_size=FLAGS.test_batch_size,
seq_length=batch_x_len,
dropout=no_dropout)
# Transpose to batch major and apply softmax for decoder
transposed = tf.nn.softmax(tf.transpose(a=logits, perm=[1, 0, 2]))
loss = tfv1.nn.ctc_loss(labels=batch_y,
inputs=logits,
sequence_length=batch_x_len)
tfv1.train.get_or_create_global_step()
# Get number of accessible CPU cores for this process
try:
num_processes = cpu_count()
except NotImplementedError:
num_processes = 1
with tfv1.Session(config=Config.session_config) as session:
load_graph_for_evaluation(session)
def run_test(init_op, dataset):
wav_filenames = []
losses = []
predictions = []
ground_truths = []
bar = create_progressbar(prefix='Test epoch | ',
widgets=['Steps: ', progressbar.Counter(), ' | ', progressbar.Timer()]).start()
log_progress('Test epoch...')
step_count = 0
# Initialize iterator to the appropriate dataset
session.run(init_op)
# First pass, compute losses and transposed logits for decoding
while True:
try:
batch_wav_filenames, batch_logits, batch_loss, batch_lengths, batch_transcripts = \
session.run([batch_wav_filename, transposed, loss, batch_x_len, batch_y])
except tf.errors.OutOfRangeError:
break
decoded = ctc_beam_search_decoder_batch(batch_logits, batch_lengths, Config.alphabet, FLAGS.beam_width,
num_processes=num_processes, scorer=scorer,
cutoff_prob=FLAGS.cutoff_prob, cutoff_top_n=FLAGS.cutoff_top_n)
predictions.extend(d[0][1] for d in decoded)
ground_truths.extend(sparse_tensor_value_to_texts(batch_transcripts, Config.alphabet))
wav_filenames.extend(wav_filename.decode('UTF-8') for wav_filename in batch_wav_filenames)
losses.extend(batch_loss)
step_count += 1
bar.update(step_count)
bar.finish()
# Print test summary
test_samples = calculate_and_print_report(wav_filenames, ground_truths, predictions, losses, dataset)
return test_samples
samples = []
for csv, init_op in zip(test_csvs, test_init_ops):
print('Testing model on {}'.format(csv))
samples.extend(run_test(init_op, dataset=csv))
return samples
def benchmark_model(self,
warmup_runs,
bm_runs,
num_threads,
trace_filename=None):
"""Benchmark model."""
if self.tensorrt:
print('Using tensorrt ', self.tensorrt)
self.build_and_save_model()
graphdef = self.freeze_model()
if num_threads > 0:
print('num_threads for benchmarking: {}'.format(num_threads))
sess_config = tf.ConfigProto(
intra_op_parallelism_threads=num_threads,
inter_op_parallelism_threads=1)
else:
sess_config = tf.ConfigProto()
# rewriter_config_pb2.RewriterConfig.OFF
sess_config.graph_options.rewrite_options.dependency_optimization = 2
if self.use_xla:
sess_config.graph_options.optimizer_options.global_jit_level = (
tf.OptimizerOptions.ON_2)
with tf.Graph().as_default(), tf.Session(config=sess_config) as sess:
inputs = tf.placeholder(tf.float32,
name='input',
shape=self.inputs_shape)
output = self.build_model(inputs, is_training=False)
img = np.random.uniform(size=self.inputs_shape)
sess.run(tf.global_variables_initializer())
if self.tensorrt:
fetches = [inputs.name] + [i.name for i in output]
goutput = self.convert_tr(graphdef, fetches)
inputs, output = goutput[0], goutput[1:]
if not self.use_xla:
# Don't use tf.group because XLA removes the whole graph for tf.group.
output = tf.group(*output)
for i in range(warmup_runs):
start_time = time.time()
sess.run(output, feed_dict={inputs: img})
print('Warm up: {} {:.4f}s'.format(i,
time.time() - start_time))
print('Start benchmark runs total={}'.format(bm_runs))
timev = []
for i in range(bm_runs):
if trace_filename and i == (bm_runs // 2):
run_options = tf.RunOptions()
run_options.trace_level = tf.RunOptions.FULL_TRACE
run_metadata = tf.RunMetadata()
sess.run(output,
feed_dict={inputs: img},
options=run_options,
run_metadata=run_metadata)
logging.info('Dumping trace to %s', trace_filename)
trace_dir = os.path.dirname(trace_filename)
if not tf.io.gfile.exists(trace_dir):
tf.io.gfile.makedirs(trace_dir)
with tf.io.gfile.GFile(trace_filename, 'w') as trace_file:
from tensorflow.python.client import timeline # pylint: disable=g-direct-tensorflow-import,g-import-not-at-top
trace = timeline.Timeline(
step_stats=run_metadata.step_stats)
trace_file.write(
trace.generate_chrome_trace_format(
show_memory=True))
start_time = time.time()
sess.run(output, feed_dict={inputs: img})
timev.append(time.time() - start_time)
timev.sort()
timev = timev[2:bm_runs - 2]
print(
'{} {}runs {}threads: mean {:.4f} std {:.4f} min {:.4f} max {:.4f}'
.format(self.model_name, len(timev), num_threads,
np.mean(timev), np.std(timev), np.min(timev),
np.max(timev)))
def main(_):
#print parameters
pp.pprint(tf.app.flags.FLAGS.flag_values_dict())
#folders
if FLAGS.dataset == 'uniform':
if FLAGS.architecture == 'fc':
FLAGS.sample_dir = 'samples fc/' + 'dataset_' + FLAGS.dataset + '_num_samples_' + str(FLAGS.num_samples) +\
'_num_neurons_' + str(FLAGS.num_neurons) + '_num_bins_' + str(FLAGS.num_bins)\
+ '_ref_period_' + str(FLAGS.ref_period) + '_firing_rate_' + str(FLAGS.firing_rate) + '_correlation_' + str(FLAGS.correlation) +\
'_group_size_' + str(FLAGS.group_size) + '_critic_iters_' + str(FLAGS.critic_iters) + '_lambda_' + str(FLAGS.lambd) +\
'_num_units_' + str(FLAGS.num_units) +\
'_iteration_' + FLAGS.iteration + '/'
elif FLAGS.architecture == 'conv':
FLAGS.sample_dir = 'samples conv/' + 'dataset_' + FLAGS.dataset + '_num_samples_' + str(FLAGS.num_samples) +\
'_num_neurons_' + str(FLAGS.num_neurons) + '_num_bins_' + str(FLAGS.num_bins)\
+ '_ref_period_' + str(FLAGS.ref_period) + '_firing_rate_' + str(FLAGS.firing_rate) + '_correlation_' + str(FLAGS.correlation) +\
'_group_size_' + str(FLAGS.group_size) + '_critic_iters_' + str(FLAGS.critic_iters) + '_lambda_' + str(FLAGS.lambd) +\
'_num_layers_' + str(FLAGS.num_layers) + '_num_features_' + str(FLAGS.num_features) + '_kernel_' + str(FLAGS.kernel_width) +\
'_iteration_' + FLAGS.iteration + '/'
elif FLAGS.dataset == 'packets' and FLAGS.number_of_modes == 1:
if FLAGS.architecture == 'fc':
FLAGS.sample_dir = 'samples fc/' + 'dataset_' + FLAGS.dataset + '_num_samples_' + str(FLAGS.num_samples) +\
'_num_neurons_' + str(FLAGS.num_neurons) + '_num_bins_' + str(FLAGS.num_bins) + '_packet_prob_' + str(FLAGS.packet_prob)\
+ '_firing_rate_' + str(FLAGS.firing_rate) + '_group_size_' + str(FLAGS.group_size) + '_critic_iters_' +\
str(FLAGS.critic_iters) + '_lambda_' + str(FLAGS.lambd) + '_num_units_' + str(FLAGS.num_units) +\
'_iteration_' + FLAGS.iteration + '/'
elif FLAGS.architecture == 'conv':
FLAGS.sample_dir = 'samples conv/' + 'dataset_' + FLAGS.dataset + '_num_samples_' + str(FLAGS.num_samples) +\
'_num_neurons_' + str(FLAGS.num_neurons) + '_num_bins_' + str(FLAGS.num_bins) + '_packet_prob_' + str(FLAGS.packet_prob)\
+ '_firing_rate_' + str(FLAGS.firing_rate) + '_group_size_' + str(FLAGS.group_size) + '_critic_iters_' +\
str(FLAGS.critic_iters) + '_lambda_' + str(FLAGS.lambd) +\
'_num_layers_' + str(FLAGS.num_layers) + '_num_features_' + str(FLAGS.num_features) + '_kernel_' + str(FLAGS.kernel_width) +\
'_iteration_' + FLAGS.iteration + '/'
elif FLAGS.dataset == 'packets' and FLAGS.number_of_modes == 2:
if FLAGS.architecture == 'fc':
FLAGS.sample_dir = 'samples fc/' + 'dataset_' + FLAGS.dataset + '_num_samples_' + str(FLAGS.num_samples) +\
'_num_neurons_' + str(FLAGS.num_neurons) + '_num_bins_' + str(FLAGS.num_bins) + '_packet_prob_' + str(FLAGS.packet_prob)\
+ '_firing_rate_' + str(FLAGS.firing_rate) + '_group_size_' + str(FLAGS.group_size) + '_noise_in_packet_' + str(FLAGS.noise_in_packet) + '_number_of_modes_' + str(FLAGS.number_of_modes) + '_critic_iters_' +\
str(FLAGS.critic_iters) + '_lambda_' + str(FLAGS.lambd) + '_num_units_' + str(FLAGS.num_units) +\
'_iteration_' + FLAGS.iteration + '/'
elif FLAGS.architecture == 'conv':
FLAGS.sample_dir = 'samples conv/' + 'dataset_' + FLAGS.dataset + '_num_samples_' + str(FLAGS.num_samples) +\
'_num_neurons_' + str(FLAGS.num_neurons) + '_num_bins_' + str(FLAGS.num_bins) + '_packet_prob_' + str(FLAGS.packet_prob)\
+ '_firing_rate_' + str(FLAGS.firing_rate) + '_group_size_' + str(FLAGS.group_size) + '_noise_in_packet_' + str(FLAGS.noise_in_packet) + '_number_of_modes_' + str(FLAGS.number_of_modes) + '_critic_iters_' +\
str(FLAGS.critic_iters) + '_lambda_' + str(FLAGS.lambd) +\
'_num_layers_' + str(FLAGS.num_layers) + '_num_features_' + str(FLAGS.num_features) + '_kernel_' + str(FLAGS.kernel_width) +\
'_iteration_' + FLAGS.iteration + '/'
elif FLAGS.dataset == 'retina':
if FLAGS.architecture == 'fc':
FLAGS.sample_dir = 'samples fc/' + 'dataset_' + FLAGS.dataset +\
'_num_neurons_' + str(FLAGS.num_neurons) + '_num_bins_' + str(FLAGS.num_bins)\
+ '_critic_iters_' + str(FLAGS.critic_iters) + '_lambda_' + str(FLAGS.lambd) +\
'_num_units_' + str(FLAGS.num_units) +\
'_iteration_' + FLAGS.iteration + '/'
elif FLAGS.architecture == 'conv':
FLAGS.sample_dir = 'samples conv/' + 'dataset_' + FLAGS.dataset + '_num_samples_' + str(FLAGS.num_samples) +\
'_num_neurons_' + str(FLAGS.num_neurons) + '_num_bins_' + str(FLAGS.num_bins)\
+ '_critic_iters_' + str(FLAGS.critic_iters) + '_lambda_' + str(FLAGS.lambd) +\
'_num_layers_' + str(FLAGS.num_layers) + '_num_features_' + str(FLAGS.num_features) + '_kernel_' + str(FLAGS.kernel_width) +\
'_iteration_' + FLAGS.iteration + '/'
elif FLAGS.dataset == 'maxent':
if FLAGS.architecture == 'fc':
FLAGS.sample_dir = 'samples fc/' + 'dataset_' + FLAGS.dataset + '_num_samples_' + str(FLAGS.num_samples) +\
'_num_neurons_' + str(FLAGS.num_neurons) + '_num_bins_' + str(FLAGS.num_bins)\
+ '_critic_iters_' + str(FLAGS.critic_iters) + '_lambda_' + str(FLAGS.lambd) +\
'_num_layers_' + str(FLAGS.num_layers) + '_num_units_' + str(FLAGS.num_units) +\
'_iteration_' + FLAGS.iteration + '/'
FLAGS.checkpoint_dir = FLAGS.sample_dir + 'checkpoint/'
if not os.path.exists(FLAGS.checkpoint_dir):
os.makedirs(FLAGS.checkpoint_dir)
if not os.path.exists(FLAGS.sample_dir):
os.makedirs(FLAGS.sample_dir)
if FLAGS.recovery_dir == "" and os.path.exists(FLAGS.sample_dir +
'/stats_real.npz'):
FLAGS.recovery_dir = FLAGS.sample_dir
run_config = tf.ConfigProto()
run_config.gpu_options.allow_growth = True
with tf.Session(config=run_config) as sess:
wgan = WGAN_conv(sess,
architecture=FLAGS.architecture,
num_neurons=FLAGS.num_neurons,
num_bins=FLAGS.num_bins,
num_layers=FLAGS.num_layers,
num_units=FLAGS.num_units,
num_features=FLAGS.num_features,
kernel_width=FLAGS.kernel_width,
lambd=FLAGS.lambd,
batch_size=FLAGS.batch_size,
checkpoint_dir=FLAGS.checkpoint_dir,
sample_dir=FLAGS.sample_dir,
num_samples_for_diagnostics=FLAGS.num_samples)
if FLAGS.is_train:
training_samples, dev_samples = data_provider.generate_spike_trains(
FLAGS, FLAGS.recovery_dir)
wgan.training_samples = training_samples
wgan.dev_samples = dev_samples
print('data loaded')
wgan.train(FLAGS)
else:
if not wgan.load(FLAGS.training_stage):
raise Exception("[!] Train a model first, then run test mode")
#LOAD TRAINING DATASET (and its statistics)
original_dataset = np.load(FLAGS.sample_dir + '/stats_real.npz')
#PLOT FILTERS
if FLAGS.dataset in ['retina', 'maxent']:
index = np.arange(FLAGS.num_neurons)
else:
index = np.argsort(original_dataset['shuffled_index'])
if FLAGS.architecture == 'conv':
print('get filters -----------------------------------')
filters = wgan.get_filters(num_samples=64)
visualize_filters_and_units.plot_filters(filters, sess, FLAGS,
index)
#GET GENERATED SAMPLES AND COMPUTE THEIR STATISTICS
print('compute stats -----------------------------------')
if 'samples' not in original_dataset:
if FLAGS.dataset == 'retina':
real_samples = retinal_data.get_samples(
num_bins=FLAGS.num_bins,
num_neurons=FLAGS.num_neurons,
instance=FLAGS.data_instance,
folder=os.getcwd() + '/data/retinal data/')
elif FLAGS.dataset == 'maxent':
real_samples = maxent_data.get_samples()
else:
real_samples = original_dataset['samples']
sim_pop_activity.plot_samples(real_samples, FLAGS.num_neurons,
FLAGS.sample_dir, 'real')
fake_samples = wgan.get_samples(num_samples=FLAGS.num_samples)
fake_samples = fake_samples.eval(session=sess)
sim_pop_activity.plot_samples(fake_samples.T, FLAGS.num_neurons,
FLAGS.sample_dir, 'fake')
_, _, _, _, _ = analysis.get_stats(X=fake_samples.T,
num_neurons=FLAGS.num_neurons,
num_bins=FLAGS.num_bins,
folder=FLAGS.sample_dir,
name='fake',
instance=FLAGS.data_instance)
#EVALUATE HIGH ORDER FEATURES (only when dimensionality is low)
if FLAGS.dataset == 'uniform' and FLAGS.num_bins * FLAGS.num_neurons < 40:
print(
'compute high order statistics-----------------------------------'
)
num_trials = int(2**8)
num_samples_per_trial = 2**13
fake_samples_mat = np.zeros((num_trials * num_samples_per_trial,
FLAGS.num_neurons * FLAGS.num_bins))
for ind_tr in range(num_trials):
fake_samples = wgan.sess.run([wgan.ex_samples])[0]
fake_samples_mat[ind_tr * num_samples_per_trial:(ind_tr + 1) *
num_samples_per_trial, :] = fake_samples
analysis.evaluate_approx_distribution(X=fake_samples_mat.T, folder=FLAGS.sample_dir, num_samples_theoretical_distr=2**21,num_bins=FLAGS.num_bins, num_neurons=FLAGS.num_neurons,\
group_size=FLAGS.group_size,refr_per=FLAGS.ref_period)
#COMPARISON WITH K-PAIRWISE AND DG MODELS (only for retinal data)
if FLAGS.dataset == 'retina':
print(
'nearest sample analysis -----------------------------------')
num_samples = 100 #this is for the 'nearest sample' analysis (Fig. S5)
print('real_samples')
analysis.nearest_sample(X_real=real_samples,
fake_samples=real_samples,
num_neurons=FLAGS.num_neurons,
num_bins=FLAGS.num_bins,
folder=FLAGS.sample_dir,
name='real',
num_samples=num_samples)
###################
print('fake_samples')
analysis.nearest_sample(X_real=real_samples,
fake_samples=fake_samples.T,
num_neurons=FLAGS.num_neurons,
num_bins=FLAGS.num_bins,
folder=FLAGS.sample_dir,
name='spikeGAN',
num_samples=num_samples)
###################
k_pairwise_samples = retinal_data.load_samples_from_k_pairwise_model(
num_samples=FLAGS.num_samples,
num_bins=FLAGS.num_bins,
num_neurons=FLAGS.num_neurons,
instance=FLAGS.data_instance,
folder=os.getcwd() + '/data/retinal data/')
print('k_pairwise_samples')
_, _, _, _, _ = analysis.get_stats(X=k_pairwise_samples,
num_neurons=FLAGS.num_neurons,
num_bins=FLAGS.num_bins,
folder=FLAGS.sample_dir,
name='k_pairwise',
instance=FLAGS.data_instance)
analysis.nearest_sample(X_real=real_samples,
fake_samples=k_pairwise_samples,
num_neurons=FLAGS.num_neurons,
num_bins=FLAGS.num_bins,
folder=FLAGS.sample_dir,
name='k_pairwise',
num_samples=num_samples)
###################
DDG_samples = retinal_data.load_samples_from_DDG_model(
num_samples=FLAGS.num_samples,
num_bins=FLAGS.num_bins,
num_neurons=FLAGS.num_neurons,
instance=FLAGS.data_instance,
folder=os.getcwd() + '/data/retinal data/')
print('DDG_samples')
_, _, _, _, _ = analysis.get_stats(X=DDG_samples,
num_neurons=FLAGS.num_neurons,
num_bins=FLAGS.num_bins,
folder=FLAGS.sample_dir,
name='DDG',
instance=FLAGS.data_instance)
analysis.nearest_sample(X_real=real_samples,
fake_samples=DDG_samples,
num_neurons=FLAGS.num_neurons,
num_bins=FLAGS.num_bins,
folder=FLAGS.sample_dir,
name='DDG',
num_samples=num_samples)
for i in range(n_batches):
yield X[batch_size*i:min(length,batch_size*(i+1))], y[batch_size*i:min(length,batch_size*(i+1))]
EPOCHS = 40
max_acc = 0
save_model_path = 'Traffice_sign_classifier'
logits = model(inputs)
logits = tf.identity(logits,name = 'logits')
cost = tf.reduce_mean(tf.losses.softmax_cross_entropy(labels,logits),name = 'cost')
optimizer = tf.train.AdamOptimizer(learning_rate=0.001).minimize(cost)
correct_pred = tf.equal(tf.argmax(labels,1),tf.argmax(logits,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred,tf.float32),name = 'accuracy')
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for epoch in range(EPOCHS):
for i,(X,y) in enumerate(get_batches(X_train,y_train)):
sess.run(optimizer,feed_dict = {inputs:X,labels:y})
if i%50==0:
valid_acc=sess.run(accuracy, feed_dict={inputs:X_valid, labels:y_valid})
train_acc=sess.run(accuracy, feed_dict={inputs:X, labels:y})
print('epoch : ',epoch+1,' training accuracy is : ',train_acc,' valid accuracy is :',valid_acc)
if valid_acc > max_acc:
max_acc = valid_acc
saver = tf.train.Saver(max_to_keep=1)
save_path = saver.save(sess,save_model_path)
import pandas as pd
loaded_graph = tf.Graph()
def main(_):
tf.logging.set_verbosity(tf.logging.INFO)
processors = {
"sst-2": run_classifier.SST2Processor,
"mnli": run_classifier.MnliProcessor
}
tokenization.validate_case_matches_checkpoint(FLAGS.do_lower_case,
FLAGS.init_checkpoint1)
tokenization.validate_case_matches_checkpoint(FLAGS.do_lower_case,
FLAGS.init_checkpoint2)
bert_config1 = modeling.BertConfig.from_json_file(FLAGS.bert_config_file1)
bert_config2 = modeling.BertConfig.from_json_file(FLAGS.bert_config_file2)
if FLAGS.max_seq_length > bert_config1.max_position_embeddings:
raise ValueError(
"Cannot use sequence length %d because the BERT model "
"was only trained up to sequence length %d" %
(FLAGS.max_seq_length, bert_config1.max_position_embeddings))
task_name = FLAGS.task_name.lower()
if task_name not in processors:
raise ValueError("Task not found: %s" % (task_name, ))
processor = processors[task_name]()
input_ids = tf.placeholder(dtype=tf.int32,
shape=(None, FLAGS.max_seq_length))
input_mask = tf.placeholder(dtype=tf.int32,
shape=(None, FLAGS.max_seq_length))
segment_ids = tf.placeholder(dtype=tf.int32,
shape=(None, FLAGS.max_seq_length))
label_ids = tf.placeholder(dtype=tf.int32, shape=(None, ))
num_labels = len(processor.get_labels())
with tf.variable_scope("model1"):
run_classifier.create_model(bert_config1,
False,
input_ids,
input_mask,
segment_ids,
label_ids,
num_labels,
use_one_hot_embeddings=False)
vars1 = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="model1")
with tf.variable_scope("model2"):
run_classifier.create_model(bert_config2,
False,
input_ids,
input_mask,
segment_ids,
label_ids,
num_labels,
use_one_hot_embeddings=False)
vars2 = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="model2")
tf.train.init_from_checkpoint(FLAGS.init_checkpoint1, {
"%s" % v.name[v.name.index("/") + 1:].split(":")[0]: v
for v in vars1
})
tf.train.init_from_checkpoint(FLAGS.init_checkpoint2, {
"%s" % v.name[v.name.index("/") + 1:].split(":")[0]: v
for v in vars2
})
def abs_diff(var_name):
with tf.variable_scope("model1", reuse=True):
var1 = tf.get_variable(var_name)
with tf.variable_scope("model2", reuse=True):
var2 = tf.get_variable(var_name)
return tf.math.abs(tf.math.subtract(var1, var2))
def sq_diff(var_name):
with tf.variable_scope("model1", reuse=True):
var1 = tf.get_variable(var_name)
with tf.variable_scope("model2", reuse=True):
var2 = tf.get_variable(var_name)
return tf.math.subtract(var1, var2) * tf.math.subtract(var1, var2)
total_diff = 0.0
total_params = 0
bert_diff = 0.0
bert_params = 0
classifier_diff = 0.0
classifier_params = 0
for var in vars1:
if FLAGS.diff_type == "euclidean":
var_diff = tf.reduce_sum(
sq_diff(var.name[var.name.index("/") + 1:var.name.index(":")]))
else:
var_diff = tf.reduce_sum(
abs_diff(var.name[var.name.index("/") +
1:var.name.index(":")]))
var_params = 1
shape = var.get_shape()
for dim in shape:
var_params *= dim
total_diff += var_diff
total_params += var_params
# Setup for BERT parameters
if "bert" in var.name:
bert_diff += var_diff
bert_params += var_params
else:
classifier_diff += var_diff
classifier_params += var_params
if FLAGS.diff_type == "euclidean":
total_diff = tf.sqrt(total_diff)
bert_diff = tf.sqrt(bert_diff)
classifier_diff = tf.sqrt(classifier_diff)
else:
total_diff = total_diff / tf.cast(total_params, tf.float32)
bert_diff = bert_diff / tf.cast(bert_params, tf.float32)
classifier_diff = classifier_diff / tf.cast(classifier_params,
tf.float32)
sess = tf.Session()
sess.run(tf.global_variables_initializer())
tf.logging.info("average diff in all params = %.8f", sess.run(total_diff))
tf.logging.info("average diff in bert params = %.8f", sess.run(bert_diff))
tf.logging.info("average diff in classifier params = %.8f",
sess.run(classifier_diff))
return
def train(cycle_gan_network, max_img, trainA, trainB, lr_rate, shape,
pool_size, model_dir, images_dir):
saver = tf.train.Saver(max_to_keep=None)
lenA = len(trainA)
lenB = len(trainB)
epoch = 0
summ_count = 0
wint_count = 0
num_imgs = 0
poolA = np.zeros((pool_size, 1, shape[0], shape[1], shape[2]))
poolB = np.zeros((pool_size, 1, shape[0], shape[1], shape[2]))
with tf.Session() as session:
session.run(tf.global_variables_initializer())
#saver.restore(session,model_dir+"try_60\\")
while epoch < 201:
if epoch >= 100:
lr_rate = 0.0002 - ((epoch - 100) * 0.0002) / 100
for step in range(max_img):
if summ_count >= lenA:
summ_count = 0
random.shuffle(trainA)
if wint_count >= lenB:
wint_count = 0
random.shuffle(trainB)
summer_image = Fetch_New_Image(trainA[summ_count])
winter_image = Fetch_New_Image(trainB[wint_count])
summ_count = summ_count + 1
wint_count = wint_count + 1
summer_image = np.reshape(summer_image,
(1, shape[0], shape[1], shape[2]))
winter_image = np.reshape(winter_image,
(1, shape[0], shape[1], shape[2]))
_, genB, genA_loss, _, genA, genB_loss, cyclicA, cyclicB = session.run(
[
cycle_gan_network.genA_opt, cycle_gan_network.gen_B,
cycle_gan_network.gen_loss_A,
cycle_gan_network.genB_opt, cycle_gan_network.gen_A,
cycle_gan_network.gen_loss_B,
cycle_gan_network.cyclicA, cycle_gan_network.cyclicB
],
feed_dict={
cycle_gan_network.input_A: summer_image,
cycle_gan_network.input_B: winter_image,
cycle_gan_network.lr_rate: lr_rate
})
poolA, poolB, num_imgs = save_to_pool(poolA, poolB, genA, genB,
pool_size, num_imgs)
indA = random.randint(0, (min(pool_size, num_imgs) - 1))
indB = random.randint(0, (min(pool_size, num_imgs) - 1))
fakeA_img = poolA[indA]
fakeB_img = poolB[indB]
_, discA_loss, _, discB_loss = session.run(
[
cycle_gan_network.discA_opt,
cycle_gan_network.disc_loss_A,
cycle_gan_network.discB_opt,
cycle_gan_network.disc_loss_B
],
feed_dict={
cycle_gan_network.input_A: summer_image,
cycle_gan_network.input_B: winter_image,
cycle_gan_network.lr_rate: lr_rate,
cycle_gan_network.fake_pool_Aimg: fakeA_img,
cycle_gan_network.fake_pool_Bimg: fakeB_img
})
if step % 50 == 0:
print(
"epoch = %r step = %r discA_loss = %r genA_loss = %r discB_loss = %r genB_loss = %r"
% (epoch, step, discA_loss, genA_loss, discB_loss,
genB_loss))
if step % 150 == 0:
images = [genA, cyclicB, genB, cyclicA]
img_ind = 0
for img in images:
img = np.reshape(img, (shape[0], shape[1], shape[2]))
if np.array_equal(img.max(), img.min()) == False:
img = (((img - img.min()) * 255) /
(img.max() - img.min())).astype(np.uint8)
else:
img = ((img - img.min()) * 255).astype(np.uint8)
scipy.misc.toimage(
img, cmin=0.0,
cmax=...).save(images_dir + "/img_" +
str(img_ind) + "_" + str(epoch) +
"_" + str(step) + ".jpg")
img_ind = img_ind + 1
print("step = %r" % (step))
if epoch % 50 == 0:
saver.save(session,
model_dir + "/try_" + str(epoch) + "/",
write_meta_graph=True)
epoch = epoch + 1
#1.0 버전으로 변경
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
# 2.0 버전
# import tensorflow as tf
hello = tf.constant("hello")
sess = tf.Session()
print(sess.run(hello))
def test_decompress(args):
"""Decompresses an image."""
# Read the shape information and compressed string from the binary file.
string = tf.placeholder(tf.string, [1])
side_string = tf.placeholder(tf.string, [1])
x_shape = tf.placeholder(tf.int32, [2])
y_shape = tf.placeholder(tf.int32, [2])
z_shape = tf.placeholder(tf.int32, [2])
with open(args.input_file, "rb") as f:
packed = tfc.PackedTensors(f.read())
tensors = [string, side_string, x_shape, y_shape, z_shape]
arrays = packed.unpack(tensors)
# Instantiate model.
synthesis_transform = SynthesisTransform(args.num_filters)
hyper_synthesis_transform = HyperSynthesisTransform(args.num_filters)
entropy_bottleneck = tfc.EntropyBottleneck(dtype=tf.float32)
# Decompress and transform the image back.
z_shape = tf.concat([z_shape, [args.num_filters]], axis=0)
z_hat = entropy_bottleneck.decompress(side_string,
z_shape,
channels=args.num_filters)
sigma = hyper_synthesis_transform(z_hat)
sigma = sigma[:, :y_shape[0], :y_shape[1], :]
scale_table = np.exp(
np.linspace(np.log(SCALES_MIN), np.log(SCALES_MAX), SCALES_LEVELS))
conditional_bottleneck = tfc.GaussianConditional(sigma,
scale_table,
dtype=tf.float32)
y_hat_all = conditional_bottleneck.decompress(string)
x = read_png("kodak/kodim01.png")
x = tf.expand_dims(x, 0)
x.set_shape([1, None, None, 3])
x_shape = tf.shape(x)
x *= 255
active = 192
y_hat = y_hat_all[:, :, :, :active]
x_hat = synthesis_transform(y_hat)
x_hat = tf.clip_by_value(x_hat, 0, 1)
x_hat = tf.round(x_hat * 255)
mse = tf.reduce_mean(tf.squared_difference(x, x_hat))
psnr = tf.squeeze(tf.image.psnr(x_hat, x, 255))
msssim = tf.squeeze(tf.image.ssim_multiscale(x_hat, x, 255))
#x_hat = x_hat[0, :x_shape[0], :x_shape[1], :]
#op = write_png(args.output_file, x_hat)
sess = tf.Session()
latest = tf.train.latest_checkpoint(checkpoint_dir=args.checkpoint_dir)
tf.train.Saver().restore(sess, save_path=latest)
#sess.run(op, feed_dict=dict(zip(tensors, arrays)))
#vmse, vpsnr, vmsssim = sess.run([mse, psnr, msssim], feed_dict=dict(zip(tensors, arrays)))
#print(vmse, vpsnr, vmsssim)
for active in range(192, 0, -8):
y_hat = y_hat_all[:, :, :, :active]
x_hat = synthesis_transform(y_hat)
x_hat = tf.clip_by_value(x_hat, 0, 1)
x_hat = tf.round(x_hat * 255)
mse = tf.reduce_mean(tf.squared_difference(x, x_hat))
psnr = tf.squeeze(tf.image.psnr(x_hat, x, 255))
msssim = tf.squeeze(tf.image.ssim_multiscale(x_hat, x, 255))
vmse, vpsnr, vmsssim = sess.run([mse, psnr, msssim],
feed_dict=dict(zip(tensors, arrays)))
print(active, vmse, vpsnr, vmsssim)
def eval_once(saver, summary_writer, labels, loss1, logits1, loss2, logits2,
loss3, logits3, loss4, logits4, loss5, logits5, loss6, logits6,
summary_op):
"""Run Eval once.
Args:
saver: Saver.
summary_writer: Summary writer.
top_k_op: Top K op.
summary_op: Summary op.
"""
with tf.Session() as sess:
ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
saver.restore(sess, ckpt.model_checkpoint_path)
# Assuming model_checkpoint_path looks something like:
# /my-favorite-path/cifar10_train/model.ckpt-0,
# extract global_step from it.
global_step = ckpt.model_checkpoint_path.split('/')[-1].split(
'-')[-1]
print('~~~~~~~~~~~checkpoint file found at step %s' % global_step)
else:
print('No checkpoint file found')
return
# Start the queue runners.
coord = tf.train.Coordinator()
try:
threads = []
for qr in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS):
threads.extend(
qr.create_threads(sess,
coord=coord,
daemon=True,
start=True))
num_iter = int(math.ceil(FLAGS.num_examples / batch_size))
cnt = 0
step = 0
accuracy = 0
accuracies = np.zeros(num * 2)
cnts = np.zeros(num * 2)
steps = np.zeros(num * 2)
comsample_labels = np.zeros(2 * batch_size)
simpleness = np.zeros((num, 2 * batch_size))
concur_s = np.zeros((num, num))
while step < num_iter and not coord.should_stop():
#print('!!!!!!the step', step)
#local test
if int(step / 2) == 0:
#print('~~~~loss1')
samplelabels, predictions, precision = sess.run(
[labels, logits1, loss1])
elif int(step / 2) == 1:
#print('~~~~loss2')
samplelabels, predictions, precision = sess.run(
[labels, logits2, loss2])
elif int(step / 2) == 2:
#print('~~~~loss3')
samplelabels, predictions, precision = sess.run(
[labels, logits3, loss3])
elif int(step / 2) == 3:
#print('~~~~loss4')
samplelabels, predictions, precision = sess.run(
[labels, logits4, loss4])
elif int(step / 2) == 4:
#print('~~~~loss5')
samplelabels, predictions, precision = sess.run(
[labels, logits5, loss5])
elif int(step / 2) == 5:
#print('~~~~loss6')
samplelabels, predictions, precision = sess.run(
[labels, logits6, loss6])
#test on 7
if int(step / 2) == 6:
#print('~~~~loss1')
samplelabels, predictions, precision = sess.run(
[labels, logits1, loss1])
elif int(step / 2) == 7:
#print('~~~~loss2')
samplelabels, predictions, precision = sess.run(
[labels, logits2, loss2])
elif int(step / 2) == 8:
#print('~~~~loss3')
samplelabels, predictions, precision = sess.run(
[labels, logits3, loss3])
elif int(step / 2) == 9:
#print('~~~~loss4')
samplelabels, predictions, precision = sess.run(
[labels, logits4, loss4])
elif int(step / 2) == 10:
#print('~~~~loss5')
samplelabels, predictions, precision = sess.run(
[labels, logits5, loss5])
elif int(step / 2) == 11:
#print('~~~~loss6')
samplelabels, predictions, precision = sess.run(
[labels, logits6, loss6])
#print('!!!!!!the index of t/????????????????/he whole batch %f /n' % output3[0][0][0])
"""
if step == 5:
ndar = np.array(output)
np.savetxt("testout.csv", ndar.reshape(128,256), delimiter=",")
ndar = np.array(output2)
np.savetxt("testlabel.csv", ndar.reshape(128,256), delimiter=",")
ndar = np.array(output3)
np.savetxt("testsignal.csv", ndar.reshape(128,256), delimiter=",")
"""
#print(samplelabels.shape)
#print(predictions.shape)
n_acc = 0
l = 0.0
for i in range(0, batch_size):
#print('label:',samplelabels.shape)
#print('prediction:',predictions.shape)
if int(samplelabels[i][0][0]) == np.argmax(predictions[i]):
n_acc = n_acc + 1
i_loss = -math.log(predictions[i][int(
samplelabels[i][0][0])])
if int(step / 2) >= num:
simpleness[int(step / 2) -
num][int(step % 2) * batch_size +
i] = i_loss
comsample_labels[int(step % 2) * batch_size +
i] = samplelabels[i][0][0]
'''
if l<precision:
simpleness[int(step/2)][int(step%2)*batch_size+i]=1
'''
l += i_loss
accuracies[int(step / 2)] += 100.0 * n_acc / (2 * batch_size)
cnts[int(step / 2)] += l / (2 * batch_size)
steps[int(step / 2)] += 1
step += 1
#compute the simpleness matrix
#print('::::::::::::comsample_labels: ')
#print(comsample_labels)
w_loss = [0.17, 0.17, 0.14, 0.22, 0.14, 0.16]
for i in range(0, num):
for j in range(0, 2 * batch_size):
#error magin
simpleness[i][j] = 1 - simpleness[i][j]
'''
if simpleness[i][j]<m_loss[i]:
simpleness[i][j]=1
else:
simpleness[i][j]=0
'''
#compute concurrent_simpleness
for i in range(0, num):
for j in range(0, num):
if i != j:
#concurrent simpleness between user_i and user_j
for n in range(0, 2 * batch_size):
concur_s[i][j] += (
(simpleness[i][n] - simpleness[j][n]) * 100.0
) * ((simpleness[i][n] - simpleness[j][n]) * 100.0)
concur_s[i][j] = math.sqrt(
concur_s[i][j]) / (2 * batch_size)
#difference[i][j]=1-concur_s[i][j]
print('concurrent simpleness: ')
print(concur_s)
i = 0
while i < num:
print(
'!!!!!!!!!!!!!!!!!!!! subject %s (%s records): test loss = %.3f, accuracy=%.3f'
% (i + 1, steps[i], cnts[i], accuracies[i]))
i += 1
print(
'(locally test)!!!!!!!!!!!!!!!!!!!! average_test loss = %.3f, average_accuracy=%.3f'
% (np.mean(cnts[0:num]), np.mean(accuracies[0:num])))
print(
'(test on 7)!!!!!!!!!!!!!!!!!!!! average_test loss = %.3f, average_accuracy=%.3f'
%
(np.mean(cnts[num:2 * num]), np.mean(accuracies[num:2 * num])))
summary = tf.Summary()
summary.ParseFromString(sess.run(summary_op))
summary.value.add(tag='loss @ 1', simple_value=precision)
summary_writer.add_summary(summary, global_step)
except Exception as e: # pylint: disable=broad-except
coord.request_stop(e)
coord.request_stop()
coord.join(threads, stop_grace_period_secs=10)
def classify_apps(apk_folder_directory):
'''
Classify apps as benign or malicious apps.
Parameters
----------
apk_folder_directory : the directory of the folder containing APKs for scanning
Returns
-------
prediction_dictionary : a dictionary recording classification results (keys for APK names and values for corresponding results - 0
represents a benign app, while 1 represents malware)
'''
data_X, data_Y, package_name_list = load_data(apk_folder_directory)
learning_rate = 0.00001
batch_size = 1
display_step = 1
dimension_count = 86645
input_size = 50
class_count = 2
tf.disable_eager_execution()
X = tf.placeholder(tf.float32, [None, input_size, dimension_count, 1])
Y = tf.placeholder(tf.float32, [None, class_count])
prediction = conv_net(X) # build the net
init_op = tf.global_variables_initializer(
) # intialise the variables to assign their default values
saver = tf.train.Saver()
with tf.Session() as session:
session.run(init_op)
saver.restore(session, get_cnn_trainer_saver_path())
batch_count = int(data_X.shape[0] / batch_size)
prediction_dictionary = {}
for step in range(batch_count):
batch_x = data_X[step * batch_size:(step + 1) * batch_size]
batch_y = data_Y[step * batch_size:(step + 1) * batch_size]
batch_package_name_list = package_name_list[step *
batch_size:(step + 1) *
batch_size]
batch_x = decompress(batch_x, dimension_count)
batch_y = get_one_hot_vector(batch_size, batch_y)
batch_result_list = session.run(tf.argmax(prediction, 1),
feed_dict={X: batch_x})
package_name_index = 0
for start_index in range(0, len(batch_result_list), input_size):
prediction_dictionary[
batch_package_name_list[package_name_index]] = np.int16(
batch_result_list[start_index:start_index +
input_size].max()
).item(
) # convert the "numpy.int64" type to the native "int" type
package_name_index += 1
return prediction_dictionary
def fit_linear_regression(trainX,
trainY,
learning_rate=0.01,
ridge_alpha=0.0,
lasso_alpha=0.0,
max_iter=1000,
display_step=50,
converged_tol=1e-8,
to_print=False):
# disable eager execution
tf.disable_eager_execution()
# check dimensions
assert trainX.shape[0] == trainY.shape[
0] # number of training data the same
nbtrain = trainX.shape[0]
nbfeatures = trainX.shape[1]
# placeholder
X = tf.placeholder(tf.float32, shape=(None, nbfeatures), name='X')
Y = tf.placeholder(tf.float32, shape=(None, 1), name='Y')
# fitting parameters
theta = tf.Variable(np.random.uniform(size=(nbfeatures, 1)),
name='theta',
dtype='float')
b = tf.Variable(np.random.uniform(), name='b', dtype='float')
# fitting function
pred_Y = tf.matmul(X, theta) + b
# cost function
cost = tf.reduce_mean(tf.square(pred_Y - Y))
# regularization
if ridge_alpha is not None and ridge_alpha != 0:
cost += 0.5 * ridge_alpha * (tf.reduce_sum(tf.square(theta)) +
tf.square(b))
if lasso_alpha is not None and lasso_alpha != 0:
cost += lasso_alpha * (tf.reduce_sum(tf.abs(theta)) + tf.abs(b))
# training the machine
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
initializer = tf.global_variables_initializer()
sess = tf.Session()
sess.run(initializer)
old_cost = sess.run(cost, feed_dict={X: trainX, Y: trainY})
# Fit all training data
for epoch in range(max_iter):
sess.run(optimizer, feed_dict={X: trainX, Y: trainY})
if to_print:
# Display logs per epoch step
if (epoch + 1) % display_step == 0:
c = sess.run(cost, feed_dict={X: trainX, Y: trainY})
print("Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(c), \
"theta=", sess.run(theta), "b=", sess.run(b))
if converged_tol is not None:
new_cost = sess.run(cost, feed_dict={X: trainX, Y: trainY})
if abs(new_cost - old_cost) < converged_tol:
break
else:
old_cost = new_cost
if to_print:
print("Optimization Finished!")
# extract value
training_cost = sess.run(cost, feed_dict={X: trainX, Y: trainY})
trained_theta = sess.run(theta)
trained_b = sess.run(b)
fitted_params = {
'theta': trained_theta,
'b': trained_b,
'cost': training_cost,
'nbepoch': epoch,
'nbfeatures': nbfeatures,
'nbtrain': nbtrain
}
tf_sess = {'session': sess, 'inputs': X, 'outputs': pred_Y}
return fitted_params, tf_sess
image_list = image_list[:, :224, :224, :]
print("truncating image sizes to 224x224")
# which_network = "celeba"
which_network = "imagenet"
print("using", which_network, "weigths")
if which_network == "imagenet":
pb_file = "1.pb"
elif which_network == "celeba":
pb_file = "200.pb"
else:
assert False
# Reading network
sess = tf.Session()
with open(pb_file, "rb") as f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(f.read())
sess = tf.Session(tf.import_graph_def(graph_def, name=''))
# import graph_def
with tf.Graph().as_default() as graph:
tf.import_graph_def(graph_def)
# Getting the list of convolutional tensors
tensors = list_tensors(sess.graph)
image_counter = 0
mx = np.random.rand(0, 0)
batch_size = 128
def main(unused_argv):
"""Main function for running experiments."""
# Load data
(train_adj, full_adj, train_feats, test_feats, y_train, y_val, y_test,
train_mask, val_mask, test_mask, _, val_data, test_data, num_data,
visible_data) = load_data(FLAGS.data_prefix, FLAGS.dataset, FLAGS.precalc)
# Partition graph and do preprocessing
if FLAGS.bsize > 1:
_, parts = partition_utils.partition_graph(train_adj, visible_data,
FLAGS.num_clusters)
parts = [np.array(pt) for pt in parts]
else:
(parts, features_batches, support_batches, y_train_batches,
train_mask_batches) = utils.preprocess(train_adj, train_feats,
y_train, train_mask,
visible_data,
FLAGS.num_clusters,
FLAGS.diag_lambda)
(_, val_features_batches, val_support_batches, y_val_batches,
val_mask_batches) = utils.preprocess(full_adj, test_feats, y_val,
val_mask, np.arange(num_data),
FLAGS.num_clusters_val,
FLAGS.diag_lambda)
(_, test_features_batches, test_support_batches, y_test_batches,
test_mask_batches) = utils.preprocess(full_adj, test_feats, y_test,
test_mask, np.arange(num_data),
FLAGS.num_clusters_test,
FLAGS.diag_lambda)
idx_parts = list(range(len(parts)))
# Some preprocessing
model_func = models.GCN
# Define placeholders
placeholders = {
'support': tf.sparse_placeholder(tf.float32),
'features': tf.placeholder(tf.float32),
'labels': tf.placeholder(tf.float32, shape=(None, y_train.shape[1])),
'labels_mask': tf.placeholder(tf.int32),
'dropout': tf.placeholder_with_default(0., shape=()),
'num_features_nonzero':
tf.placeholder(tf.int32) # helper variable for sparse dropout
}
# Create model
model = model_func(placeholders,
input_dim=test_feats.shape[1],
logging=True,
multilabel=FLAGS.multilabel,
norm=FLAGS.layernorm,
precalc=FLAGS.precalc,
num_layers=FLAGS.num_layers)
# Initialize session
sess = tf.Session()
tf.set_random_seed(seed)
# Init variables
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
cost_val = []
total_training_time = 0.0
# Train model
for epoch in range(FLAGS.epochs):
t = time.time()
np.random.shuffle(idx_parts)
if FLAGS.bsize > 1:
(features_batches, support_batches, y_train_batches,
train_mask_batches) = utils.preprocess_multicluster(
train_adj, parts, train_feats, y_train, train_mask,
FLAGS.num_clusters, FLAGS.bsize, FLAGS.diag_lambda)
for pid in range(len(features_batches)):
# Use preprocessed batch data
features_b = features_batches[pid]
support_b = support_batches[pid]
y_train_b = y_train_batches[pid]
train_mask_b = train_mask_batches[pid]
# Construct feed dictionary
feed_dict = utils.construct_feed_dict(features_b, support_b,
y_train_b, train_mask_b,
placeholders)
feed_dict.update({placeholders['dropout']: FLAGS.dropout})
# Training step
outs = sess.run([model.opt_op, model.loss, model.accuracy],
feed_dict=feed_dict)
else:
np.random.shuffle(idx_parts)
for pid in idx_parts:
# Use preprocessed batch data
features_b = features_batches[pid]
support_b = support_batches[pid]
y_train_b = y_train_batches[pid]
train_mask_b = train_mask_batches[pid]
# Construct feed dictionary
feed_dict = utils.construct_feed_dict(features_b, support_b,
y_train_b, train_mask_b,
placeholders)
feed_dict.update({placeholders['dropout']: FLAGS.dropout})
# Training step
outs = sess.run([model.opt_op, model.loss, model.accuracy],
feed_dict=feed_dict)
total_training_time += time.time() - t
print_str = 'Epoch: %04d ' % (
epoch + 1) + 'training time: {:.5f} '.format(
total_training_time) + 'train_acc= {:.5f} '.format(outs[2])
# Validation
if FLAGS.validation:
cost, acc, micro, macro = evaluate(sess, model,
val_features_batches,
val_support_batches,
y_val_batches, val_mask_batches,
val_data, placeholders)
cost_val.append(cost)
print_str += 'val_acc= {:.5f} '.format(
acc) + 'mi F1= {:.5f} ma F1= {:.5f} '.format(micro, macro)
tf.logging.info(print_str)
if epoch > FLAGS.early_stopping and cost_val[-1] > np.mean(
cost_val[-(FLAGS.early_stopping + 1):-1]):
tf.logging.info('Early stopping...')
break
tf.logging.info('Optimization Finished!')
# Save model
saver.save(sess, FLAGS.save_name)
# Load model (using CPU for inference)
with tf.device('/cpu:0'):
sess_cpu = tf.Session(config=tf.ConfigProto(device_count={'GPU': 0}))
sess_cpu.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(sess_cpu, FLAGS.save_name)
# Testing
test_cost, test_acc, micro, macro = evaluate(
sess_cpu, model, test_features_batches, test_support_batches,
y_test_batches, test_mask_batches, test_data, placeholders)
print_str = 'Test set results: ' + 'cost= {:.5f} '.format(
test_cost) + 'accuracy= {:.5f} '.format(
test_acc) + 'mi F1= {:.5f} ma F1= {:.5f}'.format(micro, macro)
tf.logging.info(print_str)
GLOBAL_RUNNING_R.append(ep_r)
else:
GLOBAL_RUNNING_R.append(0.99 * GLOBAL_RUNNING_R[-1] +
0.01 * ep_r)
print(
self.name,
"Ep:",
GLOBAL_EP,
"| Ep_r: %i" % GLOBAL_RUNNING_R[-1],
)
GLOBAL_EP += 1
break
if __name__ == "__main__":
SESS = tf.Session()
with tf.device("/cpu:0"):
OPT_A = tf.train.RMSPropOptimizer(LR_A, name='RMSPropA')
OPT_C = tf.train.RMSPropOptimizer(LR_C, name='RMSPropC')
GLOBAL_AC = ACNet(GLOBAL_NET_SCOPE) # we only need its params
workers = []
# Create worker
for i in range(N_WORKERS):
i_name = 'W_%i' % i # worker name
workers.append(Worker(i_name, GLOBAL_AC))
COORD = tf.train.Coordinator()
SESS.run(tf.global_variables_initializer())
if OUTPUT_GRAPH:
def inference(self, image_path_pattern: Text, output_dir: Text, **kwargs):
"""Read and preprocess input images.
Args:
image_path_pattern: Image file pattern such as /tmp/img*.jpg
output_dir: the directory for output images. Output images will be named
as 0.jpg, 1.jpg, ....
**kwargs: extra parameters for for vistualization, such as
min_score_thresh, max_boxes_to_draw, and line_thickness.
Returns:
Annotated image.
"""
params = copy.deepcopy(self.params)
with tf.Session() as sess:
# Buid inputs and preprocessing.
raw_images, images, scales = build_inputs(image_path_pattern,
params['image_size'])
# Build model.
class_outputs, box_outputs = build_model(self.model_name, images,
**self.params)
restore_ckpt(sess,
self.ckpt_path,
enable_ema=self.enable_ema,
export_ckpt=None)
# for postprocessing.
params.update(
dict(batch_size=len(raw_images),
disable_pyfun=self.disable_pyfun))
# Build postprocessing.
detections_batch = det_post_process(
params,
class_outputs,
box_outputs,
scales,
min_score_thresh=kwargs.get('min_score_thresh', 0.2),
max_boxes_to_draw=kwargs.get('max_boxes_to_draw', 50))
outputs_np = sess.run(detections_batch)
# Visualize results.
for i, output_np in enumerate(outputs_np):
# output_np has format [image_id, y, x, height, width, score, class]
boxes = output_np[:, 1:5]
classes = output_np[:, 6].astype(int)
scores = output_np[:, 5]
# This is not needed if disable_pyfun=True
# convert [x, y, width, height] to [ymin, xmin, ymax, xmax]
# TODO(tanmingxing): make this convertion more efficient.
if not self.disable_pyfun:
boxes[:, [0, 1, 2, 3]] = boxes[:, [1, 0, 3, 2]]
boxes[:, 2:4] += boxes[:, 0:2]
img = visualize_image(raw_images[i], boxes, classes, scores,
self.label_id_mapping, **kwargs)
output_image_path = os.path.join(output_dir, str(i) + '.jpg')
Image.fromarray(img).save(output_image_path)
logging.info('writing file to %s', output_image_path)
return outputs_np
def run(self):
# Save the log file
log = open(os.path.join(self.directory, 'log.txt'), 'w')
log.write("Epochs: {}\n".format(self.epochs))
log.write("Learning Rate: {}\n".format(self.learning_rate))
log.write("L1 Hidden Nodes: {}\n".format(self.l1_hidden_nodes))
log.write("L2 Hidden Nodes: {}\n".format(self.l2_hidden_nodes))
log.write("Batch Size: {}\n".format(self.batch_size))
log.write("\n")
X = tf.placeholder(tf.float32, [None, self.n_input])
Y = tf.placeholder(tf.float32, [None, self.n_classes])
layer_1 = tf.nn.relu(self.fc(X, self.l1_hidden_nodes))
layer_2 = tf.nn.relu(self.fc(layer_1, self.l2_hidden_nodes))
layer_out = self.fc(layer_2, self.n_classes)
logits = layer_out
prediction = tf.nn.softmax(logits, name='prediction')
loss_op = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits,
labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate)
train_op = optimizer.minimize(loss_op)
correct_prediction = tf.equal(tf.argmax(prediction, 1),
tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
init_op = tf.global_variables_initializer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init_op)
total_batch = int(len(self.training_data) / self.batch_size) + 1
batch_x = []
batch_y = []
for i in range(total_batch):
batch_x.append(
np.array(self.training_data[self.batch_size *
i:self.batch_size * (i + 1)]))
batch_y.append(
np.array(
self.training_labels[self.batch_size *
i:self.batch_size * (i + 1)]))
for epoch in range(self.epochs):
avg_loss = 0
avg_acc = 0
for i in range(total_batch):
sess.run([train_op],
feed_dict={
X: batch_x[i],
Y: batch_y[i]
})
if epoch % 100 == 0:
loss, acc = sess.run([loss_op, accuracy],
feed_dict={
X: batch_x[i],
Y: batch_y[i]
})
avg_loss += loss / total_batch
avg_acc += acc / total_batch
if epoch % 100 == 0:
message = 'Epoch: {} Avg Batch [loss: {:.4f} acc: {:.3f}]'.format(
epoch, avg_loss, avg_acc)
self.feedback.emit('Train', message)
log.write(message + "\n")
self.progress.emit(epoch + 1)
if self.stop:
self.feedback.emit('Train', 'Training interrupted.')
log.write('Training interrupted.')
break
pred_train = sess.run(prediction,
feed_dict={X: self.training_data})
pred_validation = sess.run(prediction,
feed_dict={X: self.validation_data})
message = "Train Acc: {:.5f}".format(
sess.run(accuracy,
feed_dict={
X: self.training_data,
Y: self.training_labels
}))
self.feedback.emit('Train', message)
log.write("\n" + message + "\n")
data, header = self.confusion_matrix(pred_train,
self.training_labels)
output = tabulate(data, headers=header, tablefmt='orgtbl')
log.write("Training data confusion matrix\n")
log.write(output + "\n\n")
message = "Validation Acc: {:.5f}".format(
sess.run(accuracy,
feed_dict={
X: self.validation_data,
Y: self.validation_labels
}))
self.feedback.emit('Train', message)
log.write(message + "\n")
data, header = self.confusion_matrix(pred_validation,
self.validation_labels)
output = tabulate(data, headers=header, tablefmt='orgtbl')
log.write("Training data confusion matrix\n")
log.write(output + "\n")
self.feedback.emit('Train', 'See log for confusion matrix')
# Save the Model
saver = tf.train.Saver()
saver.save(sess, os.path.join(self.directory, 'model'))
# Save the metadata
file = open(os.path.join(self.directory, 'nenetic-metadata.json'),
'w')
package = {
'classes': self.classes,
'colors': self.colors,
'extractor': self.extractor
}
json.dump(package, file)
file.close()
# Close log file
log.close()
def neural_network(num_iter=1000):
tf.disable_v2_behavior()
# Reset the graph
tf.reset_default_graph()
# Setting a seed
tf.set_random_seed(4155)
# Construct each possible point pair (x,t) to feed the neural network
Nx = 10
Nt = 10
x = np.linspace(0, 1, Nx) #from 0 to 1 (sin function)
t = np.linspace(0, 1, Nt)
X, T = np.meshgrid(x, t)
x_ = (X.ravel()).reshape(-1, 1)
t_ = (T.ravel()).reshape(-1, 1)
x_tf = tf.convert_to_tensor(x_)
t_tf = tf.convert_to_tensor(t_) #converts x and t to tensors
points = tf.concat([x_tf, t_tf], 1) #concatenates to one dimention
num_hidden_neurons = [20, 20]
num_hidden_layers = np.size(num_hidden_neurons)
with tf.variable_scope('nn'): #DeepNeuralNetwork
# Input layer
previous_layer = points
# Hidden layers
for l in range(num_hidden_layers):
current_layer = tf.layers.dense(previous_layer, \
num_hidden_neurons[l],\
activation=tf.nn.sigmoid)
previous_layer = current_layer
# Output layer
nn_output = tf.layers.dense(previous_layer, 1)
#Dense implements the operation:
#output = activation(dot(input, kernel) + bias)
# Set up the cost function
def u(x):
return tf.sin(np.pi * x) #This is initial condition
#Trial solution
with tf.name_scope('cost'):
trial = (1 - t_tf) * u(x_tf) + x_tf * (1 - x_tf) * t_tf * nn_output
trial_dt = tf.gradients(trial, t_tf)
trial_d2x = tf.gradients(tf.gradients(trial, x_tf), x_tf)
err = tf.square(trial_dt[0] - trial_d2x[0])
cost = tf.reduce_sum(err, name='cost')
# Define how the neural network should be trained
learning_rate = 0.001
with tf.name_scope('train'):
optimizer = tf.train.AdamOptimizer(learning_rate)
traning_op = optimizer.minimize(cost)
#Adam is an optimization algorithm that can be used instead of the classical
#stochastic gradient descent procedure to update network weights iterative
#based in training data. Could also use GradientDescentOptimizer
# Reference variable to the output from the network
u_nn = None
# Define a node that initializes all the nodes within the computational graph
# for TensorFlow to evaluate
init = tf.global_variables_initializer()
with tf.Session() as sess: #Class for tunning tensorflow operations
# Initialize the computational graph
init.run()
#print('Initial cost: %g'%cost.eval())
for i in range(num_iter):
sess.run(traning_op)
#print('Final cost: %g'%cost.eval())
u_nn = trial.eval()
u_e = np.exp(-np.pi**2 * t_) * np.sin(
np.pi * x_) #exact/analytical solution
U_nn = u_nn.reshape(
(Nt, Nx)).T #de første og den siste er 0. Hva betyr det?
U_e = u_e.reshape((Nt, Nx)).T
return U_nn, U_e, x
def train():
with tf.Graph().as_default():
with tf.device('/gpu:'+str(GPU_INDEX)):
pointclouds_pl, labels_pl, cls_labels_pl = MODEL.placeholder_inputs(BATCH_SIZE, NUM_POINT)
is_training_pl = tf.placeholder(tf.bool, shape=())
print (is_training_pl)
# Note the global_step=batch parameter to minimize.
# That tells the optimizer to helpfully increment the 'batch' parameter for you every time it trains.
batch = tf.Variable(0)
bn_decay = get_bn_decay(batch)
tf.summary.scalar('bn_decay', bn_decay)
print ("--- Get model and loss")
# Get model and loss
pred, end_points = MODEL.get_model(pointclouds_pl, cls_labels_pl, is_training_pl, bn_decay=bn_decay)
loss = MODEL.get_loss(pred, labels_pl)
tf.summary.scalar('loss', loss)
correct = tf.equal(tf.argmax(pred, 2), tf.to_int64(labels_pl))
accuracy = tf.reduce_sum(tf.cast(correct, tf.float32)) / float(BATCH_SIZE*NUM_POINT)
tf.summary.scalar('accuracy', accuracy)
print ("--- Get training operator")
# Get training operator
learning_rate = get_learning_rate(batch)
tf.summary.scalar('learning_rate', learning_rate)
if OPTIMIZER == 'momentum':
optimizer = tf.train.MomentumOptimizer(learning_rate, momentum=MOMENTUM)
elif OPTIMIZER == 'adam':
optimizer = tf.train.AdamOptimizer(learning_rate)
train_op = optimizer.minimize(loss, global_step=batch)
# Add ops to save and restore all the variables.
saver = tf.train.Saver()
# Create a session
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
config.allow_soft_placement = True
config.log_device_placement = False
sess = tf.Session(config=config)
# Add summary writers
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter(os.path.join(LOG_DIR, 'train'), sess.graph)
test_writer = tf.summary.FileWriter(os.path.join(LOG_DIR, 'test'), sess.graph)
# Init variables
init = tf.global_variables_initializer()
sess.run(init)
#sess.run(init, {is_training_pl: True})
ops = {'pointclouds_pl': pointclouds_pl,
'labels_pl': labels_pl,
'cls_labels_pl': cls_labels_pl,
'is_training_pl': is_training_pl,
'pred': pred,
'loss': loss,
'train_op': train_op,
'merged': merged,
'step': batch,
'end_points': end_points}
best_acc = -1
for epoch in range(MAX_EPOCH):
log_string('**** EPOCH %03d ****' % (epoch))
sys.stdout.flush()
train_one_epoch(sess, ops, train_writer)
eval_one_epoch(sess, ops, test_writer)
# Save the variables to disk.
if epoch % 10 == 0:
save_path = saver.save(sess, os.path.join(LOG_DIR, "model.ckpt"))
log_string("Model saved in file: %s" % save_path)
def main(argv):
del argv # unused arg
if not FLAGS.use_gpu:
raise ValueError('Only GPU is currently supported.')
if FLAGS.num_cores > 1:
raise ValueError('Only a single accelerator is currently supported.')
np.random.seed(FLAGS.seed)
tf.random.set_seed(FLAGS.seed)
tf.io.gfile.makedirs(FLAGS.output_dir)
tf1.disable_v2_behavior()
session = tf1.Session()
with session.as_default():
x_train, y_train, x_test, y_test = utils.load(FLAGS.dataset, session)
n_train = x_train.shape[0]
num_classes = int(np.amax(y_train)) + 1
model = lenet5(n_train, x_train.shape[1:], num_classes)
for l in model.layers:
l.kl_cost_weight = l.add_weight(
name='kl_cost_weight',
shape=(),
initializer=tf.constant_initializer(0.),
trainable=False)
l.kl_cost_bias = l.add_variable(
name='kl_cost_bias',
shape=(),
initializer=tf.constant_initializer(0.),
trainable=False)
[negative_log_likelihood, accuracy, log_likelihood, kl,
elbo] = get_losses_and_metrics(model, n_train)
metrics = [elbo, log_likelihood, kl, accuracy]
tensorboard = tf1.keras.callbacks.TensorBoard(
log_dir=FLAGS.output_dir,
update_freq=FLAGS.batch_size * FLAGS.validation_freq)
def fit_fn(model, steps, initial_epoch):
return model.fit(
x=x_train,
y=y_train,
batch_size=FLAGS.batch_size,
epochs=initial_epoch + (FLAGS.batch_size * steps) // n_train,
initial_epoch=initial_epoch,
validation_data=(x_test, y_test),
validation_freq=max(
(FLAGS.validation_freq * FLAGS.batch_size) // n_train, 1),
verbose=1,
callbacks=[tensorboard])
model.compile(
optimizer=tf.keras.optimizers.Adam(lr=float(FLAGS.learning_rate)),
loss=negative_log_likelihood,
metrics=metrics)
session.run(tf1.initialize_all_variables())
train_epochs = (FLAGS.training_steps * FLAGS.batch_size) // n_train
fit_fn(model, FLAGS.training_steps, initial_epoch=0)
labels = tf.keras.layers.Input(shape=y_train.shape[1:])
ll = tf.keras.backend.function([model.input, labels], [
model.output.distribution.log_prob(tf.squeeze(labels)),
model.output.distribution.logits
])
base_metrics = [
utils.ensemble_metrics(x_train, y_train, model, ll, n_samples=10),
utils.ensemble_metrics(x_test, y_test, model, ll, n_samples=10)
]
model_dir = os.path.join(FLAGS.output_dir, 'models')
tf.io.gfile.makedirs(model_dir)
base_model_filename = os.path.join(model_dir, 'base_model.weights')
model.save_weights(base_model_filename)
# Train base model further for comparison.
fit_fn(model,
FLAGS.n_auxiliary_variables *
FLAGS.auxiliary_sampling_frequency * FLAGS.ensemble_size,
initial_epoch=train_epochs)
overtrained_metrics = [
utils.ensemble_metrics(x_train, y_train, model, ll, n_samples=10),
utils.ensemble_metrics(x_test, y_test, model, ll, n_samples=10)
]
# Perform refined VI.
sample_op = []
for l in model.layers:
if isinstance(
l, tfp.layers.DenseLocalReparameterization) or isinstance(
l, tfp.layers.Convolution2DFlipout):
weight_op, weight_cost = sample_auxiliary_op(
l.kernel_prior.distribution,
l.kernel_posterior.distribution,
FLAGS.auxiliary_variance_ratio)
sample_op.append(weight_op)
sample_op.append(l.kl_cost_weight.assign_add(weight_cost))
# Fix the variance of the prior
session.run(l.kernel_prior.distribution.istrainable.assign(0.))
if hasattr(l.bias_prior, 'distribution'):
bias_op, bias_cost = sample_auxiliary_op(
l.bias_prior.distribution,
l.bias_posterior.distribution,
FLAGS.auxiliary_variance_ratio)
sample_op.append(bias_op)
sample_op.append(l.kl_cost_bias.assign_add(bias_cost))
# Fix the variance of the prior
session.run(
l.bias_prior.distribution.istrainable.assign(0.))
ensemble_filenames = []
for i in range(FLAGS.ensemble_size):
model.load_weights(base_model_filename)
for j in range(FLAGS.n_auxiliary_variables):
session.run(sample_op)
model.compile(
optimizer=tf.keras.optimizers.Adam(
# The learning rate is proportional to the scale of the prior.
lr=float(FLAGS.learning_rate_for_sampling *
np.sqrt(1. -
FLAGS.auxiliary_variance_ratio)**j)),
loss=negative_log_likelihood,
metrics=metrics)
fit_fn(model,
FLAGS.auxiliary_sampling_frequency,
initial_epoch=train_epochs)
ensemble_filename = os.path.join(
model_dir, 'ensemble_component_' + str(i) + '.weights')
ensemble_filenames.append(ensemble_filename)
model.save_weights(ensemble_filename)
auxiliary_metrics = [
utils.ensemble_metrics(x_train,
y_train,
model,
ll,
weight_files=ensemble_filenames,
n_samples=10),
utils.ensemble_metrics(x_test,
y_test,
model,
ll,
weight_files=ensemble_filenames,
n_samples=10)
]
for metrics, name in [(base_metrics, 'Base model'),
(overtrained_metrics, 'Overtrained model'),
(auxiliary_metrics, 'Auxiliary sampling')]:
logging.info(name)
for metrics_dict, split in [(metrics[0], 'train'),
(metrics[1], 'test')]:
logging.info(split)
for metric_name in metrics_dict:
logging.info('%s: %s', metric_name,
metrics_dict[metric_name])
import tensorflow.compat.v1 as tf
# 读取图像文件
image = tf.read_file("lena512.bmp", 'r')
# 将图像文件解码成Tensor
image_tensor = tf.image.decode_bmp(image)
# 图像张量的尺寸
shape = tf.shape(image_tensor)
session = tf.Session()
print("图像的形状：")
print(session.run(shape))
# Tensor转换为ndarray
image_ndarray = image_tensor.eval(session=session)
print(image_ndarray)
# --------- 输出层 -------------
w_fc3 = weight_variable([100, 10])
b_fc3 = bias_variable([10])
prediction = tf.nn.softmax(tf.matmul(h_fc2, w_fc3) + b_fc3)
# ----------- 损失函数(交叉熵损失) ----------------
cross_entropy = tf.reduce_mean(
-tf.reduce_sum(ys * tf.math.log(prediction), reduction_indices=[1]))
tf.summary.scalar('Loss', cross_entropy) # loss这里要用scalar。如果是在减小，说明学到东西
train_step = tf.train.AdamOptimizer(1e-4).minimize(
cross_entropy) # 使用Adam优化算法，学习率为0.0001来最小化cross_entropy
# ----------- 初始化 ---------------
init = tf.global_variables_initializer() # 初始化变量
saver = tf.train.Saver() # 创建保存模型
sess = tf.Session() # 建立会话
train_writer = tf.summary.FileWriter('logs2/train',
sess.graph) # 画出train数据集的loss曲线
test_writer = tf.summary.FileWriter('logs2/test',
sess.graph) # 画出test数据集的loss曲线
merged = tf.summary.merge_all() # tensorboard 整合
sess.run(init) # 初始化
# --------- 训练迭代1000次 -------------
for i in range(500):
batch_x, batch_y = mnist.train.next_batch(100) # 每次训练的样本集 batch_size=100
sess.run(train_step, feed_dict={xs: batch_x, ys: batch_y}) # 喂数据
if i % 100 == 0: # 迭代10次更新数据
train_res = sess.run(merged, feed_dict={xs: batch_x, ys: batch_y})
def compute_margin(
input_fn, root_dir, model_config, sess=None,
batchsize=50, dataset_size=50000):
"""Compute the margins of a model on all input data.
Loads a given model from given directory and load the parameters in the given
scope. Iterates over the entire training dataset and computes the upper bound
on the margin by doing a line search.
Args:
input_fn: function that produces the input and label tensors
root_dir: the directory containing the dataset
model_config: a ModelConfig object that specifies the model
sess: optional tensorflow session
batchsize: batch size with which the margin is computed
dataset_size: number of data points in the dataset
Returns:
A dictionary that maps each layer's name to the margins at that layer
over the entire training set.
"""
param_path = model_config.get_model_dir_name(root_dir)
model_fn = model_config.get_model_fn()
if not sess:
sess = tf.Session()
data_format = model_config.data_format
image_iter, label_iter = input_fn()
if data_format == 'HWC':
img_dim = [None, IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS]
else:
img_dim = [None, IMG_CHANNELS, IMG_HEIGHT, IMG_WIDTH]
image = tf.placeholder(tf.float32, shape=img_dim, name='image')
label = tf.placeholder(
tf.float32, shape=[None, model_config.num_class], name='label')
loss_layers = ['inputs', 'h1', 'h2', 'h3']
end_points_collection = {}
logits = model_fn(image, is_training=False, perturb_points=loss_layers,
normalizer_collection=None,
end_points_collection=end_points_collection)
# set up the graph for computing margin
layer_activations = [end_points_collection[l] for l in loss_layers]
layer_margins = margin(logits, label, layer_activations)
# load model parameters
sess.run(tf.global_variables_initializer())
model_config.load_parameters(param_path, sess)
count = 0
margin_values = []
while count < dataset_size:
try:
count += batchsize
image_batch, label_batch = sess.run([image_iter, label_iter])
label_batch = np.reshape(label_batch, [-1, model_config.num_class])
fd = {image: image_batch, label: label_batch.astype(np.float32)}
batch_margin = np.squeeze(list(sess.run(layer_margins, feed_dict=fd)))
margin_values.append(batch_margin)
except tf.errors.OutOfRangeError:
print('reached the end of the data')
break
margin_values = np.concatenate(margin_values, axis=1)
margin_values_map = {}
for ln, lm in zip(loss_layers, margin_values):
margin_values_map[ln] = lm
return margin_values_map
W = tf.Variable(tf.random_normal([16, nb_classes]), name='weight')
b = tf.Variable(tf.random_normal([nb_classes]), name='bias')
logits = tf.matmul(X, W) + b
hypothesis = tf.nn.softmax(logits)
cost_i = tf.nn.softmax_cross_entropy_with_logits(logits=logits,
labels=Y_one_hot)
cost = tf.reduce_mean(cost_i)
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)
prediction = tf.argmax(hypothesis, 1)
correct_prediction = tf.equal(prediction, tf.argmax(Y_one_hot, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for step in range(2001):
sess.run(optimizer, feed_dict={X: x_data, Y: y_data})
if step % 100 == 0:
loss, acc = sess.run([cost, accuracy],
feed_dict={
X: x_data,
Y: y_data
})
print("step: {:5}\tLoss: {:.3f}\tAcc: {}".format(step, loss, acc))
pred = sess.run(prediction, feed_dict={X: x_data})
for p, y in zip(pred, y_data.flatten()):
print("[{}] Prediction: {} True Y: {}".format(p == int(y), p, int(y)))
from nltk.stem.lancaster import LancasterStemmer
stemmer = LancasterStemmer()
from flask import Flask, jsonify, request, render_template
from flask_cors import CORS, cross_origin
from keras.models import load_model
import pickle
import pandas as pd
import numpy as np
import tensorflow.compat.v1 as tf
import json
import random
from tensorflow.python.keras.backend import set_session
global session
sess = tf.Session()
set_session(sess)
#remember to add a data.pkl here
data = pickle.load(
open("C:/Users/harip/OneDrive/Desktop/ahad_chatbot/ahad-data.pkl", "rb"))
words = data['words']
classes = data['classes']
with open('trained.json') as json_data:
intents = json.load(json_data)
lisIndex = []
for indexIntent in intents['intents']:
lisIndex.append(indexIntent['tag'])
def clean_up_sentence(sentence):