Python keras.backend.placeholder() Examples
The following are code examples for showing how to use keras.backend.placeholder(). They are from open source Python projects. You can vote up the examples you like or vote down the ones you don't like.
Example 1
| Project: gandlf Author: codekansas File: reversing_gan.py MIT License | 6 votes |
|
def reverse_generator(generator, X_sample, y_sample, title):
"""Gradient descent to map images back to their latent vectors."""
latent_vec = np.random.normal(size=(1, 100))
# Function for figuring out how to bump the input.
target = K.placeholder()
loss = K.sum(K.square(generator.outputs[0] - target))
grad = K.gradients(loss, generator.inputs[0])[0]
update_fn = K.function(generator.inputs + [target], [grad])
# Repeatedly apply the update rule.
xs = []
for i in range(60):
print('%d: latent_vec mean=%f, std=%f'
% (i, np.mean(latent_vec), np.std(latent_vec)))
xs.append(generator.predict_on_batch([latent_vec, y_sample]))
for _ in range(10):
update_vec = update_fn([latent_vec, y_sample, X_sample])[0]
latent_vec -= update_vec * update_rate
# Plots the samples.
xs = np.concatenate(xs, axis=0)
plot_as_gif(xs, X_sample, title)
Example 2
| Project: reinforcement-learning-kr Author: rlcode File: breakout_dqn.py MIT License | 6 votes |
|
def optimizer(self):
a = K.placeholder(shape=(None,), dtype='int32')
y = K.placeholder(shape=(None,), dtype='float32')
prediction = self.model.output
a_one_hot = K.one_hot(a, self.action_size)
q_value = K.sum(prediction * a_one_hot, axis=1)
error = K.abs(y - q_value)
quadratic_part = K.clip(error, 0.0, 1.0)
linear_part = error - quadratic_part
loss = K.mean(0.5 * K.square(quadratic_part) + linear_part)
optimizer = RMSprop(lr=0.00025, epsilon=0.01)
updates = optimizer.get_updates(self.model.trainable_weights, [], loss)
train = K.function([self.model.input, a, y], [loss], updates=updates)
return train
# 상태가 입력, 큐함수가 출력인 인공신경망 생성
Example 3
| Project: reinforcement-learning-kr Author: rlcode File: breakout_dqn.py MIT License | 6 votes |
|
def setup_summary(self):
episode_total_reward = tf.Variable(0.)
episode_avg_max_q = tf.Variable(0.)
episode_duration = tf.Variable(0.)
episode_avg_loss = tf.Variable(0.)
tf.summary.scalar('Total Reward/Episode', episode_total_reward)
tf.summary.scalar('Average Max Q/Episode', episode_avg_max_q)
tf.summary.scalar('Duration/Episode', episode_duration)
tf.summary.scalar('Average Loss/Episode', episode_avg_loss)
summary_vars = [episode_total_reward, episode_avg_max_q,
episode_duration, episode_avg_loss]
summary_placeholders = [tf.placeholder(tf.float32) for _ in
range(len(summary_vars))]
update_ops = [summary_vars[i].assign(summary_placeholders[i]) for i in
range(len(summary_vars))]
summary_op = tf.summary.merge_all()
return summary_placeholders, update_ops, summary_op
# 학습속도를 높이기 위해 흑백화면으로 전처리
Example 4
| Project: reinforcement-learning-kr Author: rlcode File: breakout_a3c.py MIT License | 6 votes |
|
def actor_optimizer(self):
action = K.placeholder(shape=[None, self.action_size])
advantages = K.placeholder(shape=[None, ])
policy = self.actor.output
# 정책 크로스 엔트로피 오류함수
action_prob = K.sum(action * policy, axis=1)
cross_entropy = K.log(action_prob + 1e-10) * advantages
cross_entropy = -K.sum(cross_entropy)
# 탐색을 지속적으로 하기 위한 엔트로피 오류
entropy = K.sum(policy * K.log(policy + 1e-10), axis=1)
entropy = K.sum(entropy)
# 두 오류함수를 더해 최종 오류함수를 만듬
loss = cross_entropy + 0.01 * entropy
optimizer = RMSprop(lr=self.actor_lr, rho=0.99, epsilon=0.01)
updates = optimizer.get_updates(self.actor.trainable_weights, [],loss)
train = K.function([self.actor.input, action, advantages],
[loss], updates=updates)
return train
# 가치신경망을 업데이트하는 함수
Example 5
| Project: reinforcement-learning-kr Author: rlcode File: breakout_a3c.py MIT License | 6 votes |
|
def setup_summary(self):
episode_total_reward = tf.Variable(0.)
episode_avg_max_q = tf.Variable(0.)
episode_duration = tf.Variable(0.)
tf.summary.scalar('Total Reward/Episode', episode_total_reward)
tf.summary.scalar('Average Max Prob/Episode', episode_avg_max_q)
tf.summary.scalar('Duration/Episode', episode_duration)
summary_vars = [episode_total_reward,
episode_avg_max_q,
episode_duration]
summary_placeholders = [tf.placeholder(tf.float32)
for _ in range(len(summary_vars))]
update_ops = [summary_vars[i].assign(summary_placeholders[i])
for i in range(len(summary_vars))]
summary_op = tf.summary.merge_all()
return summary_placeholders, update_ops, summary_op
# 액터러너 클래스(쓰레드)
Example 6
| Project: reinforcement-learning Author: buyizhiyou File: breakout_ddqn.py MIT License | 6 votes |
|
def optimizer(self):
a = K.placeholder(shape=(None, ), dtype='int32')
y = K.placeholder(shape=(None, ), dtype='float32')
py_x = self.model.output
a_one_hot = K.one_hot(a, self.action_size)
q_value = K.sum(py_x * a_one_hot, axis=1)
error = K.abs(y - q_value)
quadratic_part = K.clip(error, 0.0, 1.0)
linear_part = error - quadratic_part
loss = K.mean(0.5 * K.square(quadratic_part) + linear_part)
optimizer = RMSprop(lr=0.00025, epsilon=0.01)
updates = optimizer.get_updates(self.model.trainable_weights, [], loss)
train = K.function([self.model.input, a, y], [loss], updates=updates)
return train
# approximate Q function using Convolution Neural Network
# state is input and Q Value of each action is output of network
Example 7
| Project: reinforcement-learning Author: buyizhiyou File: breakout_ddqn.py MIT License | 6 votes |
|
def setup_summary(self):
episode_total_reward = tf.Variable(0.)
episode_avg_max_q = tf.Variable(0.)
episode_duration = tf.Variable(0.)
episode_avg_loss = tf.Variable(0.)
tf.summary.scalar('Total Reward/Episode', episode_total_reward)
tf.summary.scalar('Average Max Q/Episode', episode_avg_max_q)
tf.summary.scalar('Duration/Episode', episode_duration)
tf.summary.scalar('Average Loss/Episode', episode_avg_loss)
summary_vars = [episode_total_reward, episode_avg_max_q,
episode_duration, episode_avg_loss]
summary_placeholders = [tf.placeholder(tf.float32) for _ in
range(len(summary_vars))]
update_ops = [summary_vars[i].assign(summary_placeholders[i]) for i in
range(len(summary_vars))]
summary_op = tf.summary.merge_all()
return summary_placeholders, update_ops, summary_op
# 210*160*3(color) --> 84*84(mono)
# float --> integer (to reduce the size of replay memory)
Example 8
| Project: reinforcement-learning Author: buyizhiyou File: breakout_dqn.py MIT License | 6 votes |
|
def optimizer(self):
a = K.placeholder(shape=(None,), dtype='int32')
y = K.placeholder(shape=(None,), dtype='float32')
py_x = self.model.output
a_one_hot = K.one_hot(a, self.action_size)
q_value = K.sum(py_x * a_one_hot, axis=1)
error = K.abs(y - q_value)
quadratic_part = K.clip(error, 0.0, 1.0)
linear_part = error - quadratic_part
loss = K.mean(0.5 * K.square(quadratic_part) + linear_part)
optimizer = RMSprop(lr=0.00025, epsilon=0.01)
updates = optimizer.get_updates(self.model.trainable_weights, [], loss)
train = K.function([self.model.input, a, y], [loss], updates=updates)
return train
# approximate Q function using Convolution Neural Network
# state is input and Q Value of each action is output of network
Example 9
| Project: reinforcement-learning Author: buyizhiyou File: breakout_dqn.py MIT License | 6 votes |
|
def setup_summary(self):
episode_total_reward = tf.Variable(0.)
episode_avg_max_q = tf.Variable(0.)
episode_duration = tf.Variable(0.)
episode_avg_loss = tf.Variable(0.)
tf.summary.scalar('Total Reward/Episode', episode_total_reward)
tf.summary.scalar('Average Max Q/Episode', episode_avg_max_q)
tf.summary.scalar('Duration/Episode', episode_duration)
tf.summary.scalar('Average Loss/Episode', episode_avg_loss)
summary_vars = [episode_total_reward, episode_avg_max_q,
episode_duration, episode_avg_loss]
summary_placeholders = [tf.placeholder(tf.float32) for _ in
range(len(summary_vars))]
update_ops = [summary_vars[i].assign(summary_placeholders[i]) for i in
range(len(summary_vars))]
summary_op = tf.summary.merge_all()
return summary_placeholders, update_ops, summary_op
# 210*160*3(color) --> 84*84(mono)
# float --> integer (to reduce the size of replay memory)
Example 10
| Project: reinforcement-learning Author: buyizhiyou File: breakout_a3c.py MIT License | 6 votes |
|
def actor_optimizer(self):
action = K.placeholder(shape=[None, self.action_size])
advantages = K.placeholder(shape=[None, ])
policy = self.actor.output
good_prob = K.sum(action * policy, axis=1)
eligibility = K.log(good_prob + 1e-10) * advantages
actor_loss = -K.sum(eligibility)
entropy = K.sum(policy * K.log(policy + 1e-10), axis=1)
entropy = K.sum(entropy)
loss = actor_loss + 0.01*entropy
optimizer = RMSprop(lr=self.actor_lr, rho=0.99, epsilon=0.01)
updates = optimizer.get_updates(self.actor.trainable_weights, [], loss)
train = K.function([self.actor.input, action, advantages], [loss], updates=updates)
return train
# make loss function for Value approximation
Example 11
| Project: reinforcement-learning Author: buyizhiyou File: breakout_a3c.py MIT License | 6 votes |
|
def setup_summary(self):
episode_total_reward = tf.Variable(0.)
episode_avg_max_q = tf.Variable(0.)
episode_duration = tf.Variable(0.)
tf.summary.scalar('Total Reward/Episode', episode_total_reward)
tf.summary.scalar('Average Max Prob/Episode', episode_avg_max_q)
tf.summary.scalar('Duration/Episode', episode_duration)
summary_vars = [episode_total_reward, episode_avg_max_q, episode_duration]
summary_placeholders = [tf.placeholder(tf.float32) for _ in range(len(summary_vars))]
update_ops = [summary_vars[i].assign(summary_placeholders[i]) for i in range(len(summary_vars))]
summary_op = tf.summary.merge_all()
return summary_placeholders, update_ops, summary_op
# make agents(local) and start training
Example 12
| Project: reinforcement-learning Author: buyizhiyou File: breakout_dueling_ddqn.py MIT License | 6 votes |
|
def optimizer(self):
a = K.placeholder(shape=(None, ), dtype='int32')
y = K.placeholder(shape=(None, ), dtype='float32')
py_x = self.model.output
a_one_hot = K.one_hot(a, self.action_size)
q_value = K.sum(py_x * a_one_hot, axis=1)
error = K.abs(y - q_value)
quadratic_part = K.clip(error, 0.0, 1.0)
linear_part = error - quadratic_part
loss = K.mean(0.5 * K.square(quadratic_part) + linear_part)
optimizer = RMSprop(lr=0.00025, epsilon=0.01)
updates = optimizer.get_updates(self.model.trainable_weights, [], loss)
train = K.function([self.model.input, a, y], [loss], updates=updates)
return train
# approximate Q function using Convolution Neural Network
# state is input and Q Value of each action is output of network
# dueling network's Q Value is sum of advantages and state value
Example 13
| Project: reinforcement-learning Author: buyizhiyou File: breakout_dueling_ddqn.py MIT License | 6 votes |
|
def setup_summary(self):
episode_total_reward = tf.Variable(0.)
episode_avg_max_q = tf.Variable(0.)
episode_duration = tf.Variable(0.)
episode_avg_loss = tf.Variable(0.)
tf.summary.scalar('Total Reward/Episode', episode_total_reward)
tf.summary.scalar('Average Max Q/Episode', episode_avg_max_q)
tf.summary.scalar('Duration/Episode', episode_duration)
tf.summary.scalar('Average Loss/Episode', episode_avg_loss)
summary_vars = [episode_total_reward, episode_avg_max_q,
episode_duration, episode_avg_loss]
summary_placeholders = [tf.placeholder(tf.float32) for _ in
range(len(summary_vars))]
update_ops = [summary_vars[i].assign(summary_placeholders[i]) for i in
range(len(summary_vars))]
summary_op = tf.summary.merge_all()
return summary_placeholders, update_ops, summary_op
# 210*160*3(color) --> 84*84(mono)
# float --> integer (to reduce the size of replay memory)
Example 14
| Project: reinforcement-learning Author: buyizhiyou File: reinforce_agent.py MIT License | 6 votes |
|
def optimizer(self):
import pdb; pdb.set_trace()
action = K.placeholder(shape=[None, 5])
discounted_rewards = K.placeholder(shape=[None, ])
# Calculate cross entropy error function
action_prob = K.sum(action * self.model.output, axis=1)
cross_entropy = K.log(action_prob) * discounted_rewards
loss = -K.sum(cross_entropy)
# create training function
optimizer = Adam(lr=self.learning_rate)
updates = optimizer.get_updates(self.model.trainable_weights, [],
loss)
train = K.function([self.model.input, action, discounted_rewards], [],
updates=updates)
return train
# get action from policy network
Example 15
| Project: reinforcement-learning Author: buyizhiyou File: cartpole_a3c.py MIT License | 6 votes |
|
def actor_optimizer(self):
action = K.placeholder(shape=(None, self.action_size))
advantages = K.placeholder(shape=(None, ))
policy = self.actor.output
good_prob = K.sum(action * policy, axis=1)
eligibility = K.log(good_prob + 1e-10) * K.stop_gradient(advantages)
loss = -K.sum(eligibility)
entropy = K.sum(policy * K.log(policy + 1e-10), axis=1)
actor_loss = loss + 0.01*entropy
optimizer = Adam(lr=self.actor_lr)
updates = optimizer.get_updates(self.actor.trainable_weights, [], actor_loss)
train = K.function([self.actor.input, action, advantages], [], updates=updates)
return train
# make loss function for Value approximation
Example 16
| Project: multi-object-tracking Author: jguoaj File: yolo.py GNU General Public License v3.0 | 6 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model must be a .h5 file.'
self.yolo_model = load_model(model_path, compile=False)
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
random.seed(10101) # Fixed seed for consistent colors across runs.
random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 17
| Project: reinforcement-learning Author: rlcode File: breakout_ddqn.py MIT License | 6 votes |
|
def optimizer(self):
a = K.placeholder(shape=(None, ), dtype='int32')
y = K.placeholder(shape=(None, ), dtype='float32')
py_x = self.model.output
a_one_hot = K.one_hot(a, self.action_size)
q_value = K.sum(py_x * a_one_hot, axis=1)
error = K.abs(y - q_value)
quadratic_part = K.clip(error, 0.0, 1.0)
linear_part = error - quadratic_part
loss = K.mean(0.5 * K.square(quadratic_part) + linear_part)
optimizer = RMSprop(lr=0.00025, epsilon=0.01)
updates = optimizer.get_updates(self.model.trainable_weights, [], loss)
train = K.function([self.model.input, a, y], [loss], updates=updates)
return train
# approximate Q function using Convolution Neural Network
# state is input and Q Value of each action is output of network
Example 18
| Project: reinforcement-learning Author: rlcode File: breakout_ddqn.py MIT License | 6 votes |
|
def setup_summary(self):
episode_total_reward = tf.Variable(0.)
episode_avg_max_q = tf.Variable(0.)
episode_duration = tf.Variable(0.)
episode_avg_loss = tf.Variable(0.)
tf.summary.scalar('Total Reward/Episode', episode_total_reward)
tf.summary.scalar('Average Max Q/Episode', episode_avg_max_q)
tf.summary.scalar('Duration/Episode', episode_duration)
tf.summary.scalar('Average Loss/Episode', episode_avg_loss)
summary_vars = [episode_total_reward, episode_avg_max_q,
episode_duration, episode_avg_loss]
summary_placeholders = [tf.placeholder(tf.float32) for _ in
range(len(summary_vars))]
update_ops = [summary_vars[i].assign(summary_placeholders[i]) for i in
range(len(summary_vars))]
summary_op = tf.summary.merge_all()
return summary_placeholders, update_ops, summary_op
# 210*160*3(color) --> 84*84(mono)
# float --> integer (to reduce the size of replay memory)
Example 19
| Project: reinforcement-learning Author: rlcode File: breakout_dqn.py MIT License | 6 votes |
|
def optimizer(self):
a = K.placeholder(shape=(None,), dtype='int32')
y = K.placeholder(shape=(None,), dtype='float32')
py_x = self.model.output
a_one_hot = K.one_hot(a, self.action_size)
q_value = K.sum(py_x * a_one_hot, axis=1)
error = K.abs(y - q_value)
quadratic_part = K.clip(error, 0.0, 1.0)
linear_part = error - quadratic_part
loss = K.mean(0.5 * K.square(quadratic_part) + linear_part)
optimizer = RMSprop(lr=0.00025, epsilon=0.01)
updates = optimizer.get_updates(self.model.trainable_weights, [], loss)
train = K.function([self.model.input, a, y], [loss], updates=updates)
return train
# approximate Q function using Convolution Neural Network
# state is input and Q Value of each action is output of network
Example 20
| Project: reinforcement-learning Author: rlcode File: breakout_dqn.py MIT License | 6 votes |
|
def setup_summary(self):
episode_total_reward = tf.Variable(0.)
episode_avg_max_q = tf.Variable(0.)
episode_duration = tf.Variable(0.)
episode_avg_loss = tf.Variable(0.)
tf.summary.scalar('Total Reward/Episode', episode_total_reward)
tf.summary.scalar('Average Max Q/Episode', episode_avg_max_q)
tf.summary.scalar('Duration/Episode', episode_duration)
tf.summary.scalar('Average Loss/Episode', episode_avg_loss)
summary_vars = [episode_total_reward, episode_avg_max_q,
episode_duration, episode_avg_loss]
summary_placeholders = [tf.placeholder(tf.float32) for _ in
range(len(summary_vars))]
update_ops = [summary_vars[i].assign(summary_placeholders[i]) for i in
range(len(summary_vars))]
summary_op = tf.summary.merge_all()
return summary_placeholders, update_ops, summary_op
# 210*160*3(color) --> 84*84(mono)
# float --> integer (to reduce the size of replay memory)
Example 21
| Project: reinforcement-learning Author: rlcode File: breakout_a3c.py MIT License | 6 votes |
|
def actor_optimizer(self):
action = K.placeholder(shape=[None, self.action_size])
advantages = K.placeholder(shape=[None, ])
policy = self.actor.output
good_prob = K.sum(action * policy, axis=1)
eligibility = K.log(good_prob + 1e-10) * advantages
actor_loss = -K.sum(eligibility)
entropy = K.sum(policy * K.log(policy + 1e-10), axis=1)
entropy = K.sum(entropy)
loss = actor_loss + 0.01*entropy
optimizer = RMSprop(lr=self.actor_lr, rho=0.99, epsilon=0.01)
updates = optimizer.get_updates(self.actor.trainable_weights, [], loss)
train = K.function([self.actor.input, action, advantages], [loss], updates=updates)
return train
# make loss function for Value approximation
Example 22
| Project: reinforcement-learning Author: rlcode File: breakout_a3c.py MIT License | 6 votes |
|
def setup_summary(self):
episode_total_reward = tf.Variable(0.)
episode_avg_max_q = tf.Variable(0.)
episode_duration = tf.Variable(0.)
tf.summary.scalar('Total Reward/Episode', episode_total_reward)
tf.summary.scalar('Average Max Prob/Episode', episode_avg_max_q)
tf.summary.scalar('Duration/Episode', episode_duration)
summary_vars = [episode_total_reward, episode_avg_max_q, episode_duration]
summary_placeholders = [tf.placeholder(tf.float32) for _ in range(len(summary_vars))]
update_ops = [summary_vars[i].assign(summary_placeholders[i]) for i in range(len(summary_vars))]
summary_op = tf.summary.merge_all()
return summary_placeholders, update_ops, summary_op
# make agents(local) and start training
Example 23
| Project: reinforcement-learning Author: rlcode File: breakout_dueling_ddqn.py MIT License | 6 votes |
|
def optimizer(self):
a = K.placeholder(shape=(None, ), dtype='int32')
y = K.placeholder(shape=(None, ), dtype='float32')
py_x = self.model.output
a_one_hot = K.one_hot(a, self.action_size)
q_value = K.sum(py_x * a_one_hot, axis=1)
error = K.abs(y - q_value)
quadratic_part = K.clip(error, 0.0, 1.0)
linear_part = error - quadratic_part
loss = K.mean(0.5 * K.square(quadratic_part) + linear_part)
optimizer = RMSprop(lr=0.00025, epsilon=0.01)
updates = optimizer.get_updates(self.model.trainable_weights, [], loss)
train = K.function([self.model.input, a, y], [loss], updates=updates)
return train
# approximate Q function using Convolution Neural Network
# state is input and Q Value of each action is output of network
# dueling network's Q Value is sum of advantages and state value
Example 24
| Project: reinforcement-learning Author: rlcode File: breakout_dueling_ddqn.py MIT License | 6 votes |
|
def setup_summary(self):
episode_total_reward = tf.Variable(0.)
episode_avg_max_q = tf.Variable(0.)
episode_duration = tf.Variable(0.)
episode_avg_loss = tf.Variable(0.)
tf.summary.scalar('Total Reward/Episode', episode_total_reward)
tf.summary.scalar('Average Max Q/Episode', episode_avg_max_q)
tf.summary.scalar('Duration/Episode', episode_duration)
tf.summary.scalar('Average Loss/Episode', episode_avg_loss)
summary_vars = [episode_total_reward, episode_avg_max_q,
episode_duration, episode_avg_loss]
summary_placeholders = [tf.placeholder(tf.float32) for _ in
range(len(summary_vars))]
update_ops = [summary_vars[i].assign(summary_placeholders[i]) for i in
range(len(summary_vars))]
summary_op = tf.summary.merge_all()
return summary_placeholders, update_ops, summary_op
# 210*160*3(color) --> 84*84(mono)
# float --> integer (to reduce the size of replay memory)
Example 25
| Project: reinforcement-learning Author: rlcode File: reinforce_agent.py MIT License | 6 votes |
|
def optimizer(self):
action = K.placeholder(shape=[None, 5])
discounted_rewards = K.placeholder(shape=[None, ])
# Calculate cross entropy error function
action_prob = K.sum(action * self.model.output, axis=1)
cross_entropy = K.log(action_prob) * discounted_rewards
loss = -K.sum(cross_entropy)
# create training function
optimizer = Adam(lr=self.learning_rate)
updates = optimizer.get_updates(self.model.trainable_weights, [],
loss)
train = K.function([self.model.input, action, discounted_rewards], [],
updates=updates)
return train
# get action from policy network
Example 26
| Project: reinforcement-learning Author: rlcode File: cartpole_a3c.py MIT License | 6 votes |
|
def actor_optimizer(self):
action = K.placeholder(shape=(None, self.action_size))
advantages = K.placeholder(shape=(None, ))
policy = self.actor.output
good_prob = K.sum(action * policy, axis=1)
eligibility = K.log(good_prob + 1e-10) * K.stop_gradient(advantages)
loss = -K.sum(eligibility)
entropy = K.sum(policy * K.log(policy + 1e-10), axis=1)
actor_loss = loss + 0.01*entropy
optimizer = Adam(lr=self.actor_lr)
updates = optimizer.get_updates(self.actor.trainable_weights, [], actor_loss)
train = K.function([self.actor.input, action, advantages], [], updates=updates)
return train
# make loss function for Value approximation
Example 27
| Project: 2019-OSS-Summer-RL Author: utilForever File: reinforce_agent.py MIT License | 6 votes |
|
def optimizer(self):
action = K.placeholder(shape=[None, 5])
discounted_rewards = K.placeholder(shape=[None, ])
# 크로스 엔트로피 오류함수 계산
action_prob = K.sum(action * self.model.output, axis=1)
cross_entropy = K.log(action_prob) * discounted_rewards
loss = -K.sum(cross_entropy)
# 정책신경망을 업데이트하는 훈련함수 생성
optimizer = Adam(lr=self.learning_rate)
updates = optimizer.get_updates(self.model.trainable_weights,[],
loss)
train = K.function([self.model.input, action, discounted_rewards], [],
updates=updates)
return train
# 정책신경망으로 행동 선택
Example 28
| Project: keras_bn_library Author: bnsnapper File: callbacks.py MIT License | 6 votes |
|
def __init__(self, X_train, X_test, loss, verbose=1, batch_size = 1, label='loss', every_n_epochs=1, display_delta=True): super(UnsupervisedLoss2Logger, self).__init__() self.X_train = X_train self.X_test = X_test self.loss = loss self.verbose = verbose self.label = label self.every_n_epochs = every_n_epochs self.display_delta = display_delta self.prev_loss = None self.batch_size = batch_size input_train = K.placeholder(shape=self.X_train.shape) input_test = K.placeholder(shape=self.X_test.shape) loss = self.loss(input_train, input_test) ins = [input_train, input_test] self.loss_function = K.function(ins, loss)
Example 29
| Project: GewitterGefahr Author: thunderhoser File: physical_constraints_test.py MIT License | 6 votes |
|
def test_radar_constraints_to_loss_fn_first(self):
"""Ensures correct output from radar_constraints_to_loss_fn.
In this case, using first set of channels.
"""
these_dimensions = (
NUM_EXAMPLES, NUM_RADAR_ROWS, NUM_RADAR_COLUMNS,
len(FIRST_LIST_OF_OPERATION_DICTS)
)
this_radar_tensor = K.placeholder(shape=these_dimensions, dtype=float)
this_loss_tensor = physical_constraints.radar_constraints_to_loss_fn(
radar_tensor=this_radar_tensor,
list_of_layer_operation_dicts=FIRST_LIST_OF_OPERATION_DICTS)
self.assertTrue(this_loss_tensor is not None)
Example 30
| Project: GewitterGefahr Author: thunderhoser File: physical_constraints_test.py MIT License | 6 votes |
|
def test_radar_constraints_to_loss_fn_second(self):
"""Ensures correct output from radar_constraints_to_loss_fn.
In this case, using second set of channels.
"""
these_dimensions = (
NUM_EXAMPLES, NUM_RADAR_ROWS, NUM_RADAR_COLUMNS,
len(SECOND_LIST_OF_OPERATION_DICTS)
)
this_radar_tensor = K.placeholder(shape=these_dimensions, dtype=float)
this_loss_tensor = physical_constraints.radar_constraints_to_loss_fn(
radar_tensor=this_radar_tensor,
list_of_layer_operation_dicts=SECOND_LIST_OF_OPERATION_DICTS)
self.assertTrue(this_loss_tensor is not None)
Example 31
| Project: GewitterGefahr Author: thunderhoser File: physical_constraints_test.py MIT License | 6 votes |
|
def test_radar_constraints_to_loss_fn_third(self):
"""Ensures correct output from radar_constraints_to_loss_fn.
In this case, using third set of channels.
"""
these_dimensions = (
NUM_EXAMPLES, NUM_RADAR_ROWS, NUM_RADAR_COLUMNS,
len(THIRD_LIST_OF_OPERATION_DICTS)
)
this_radar_tensor = K.placeholder(shape=these_dimensions, dtype=float)
this_loss_tensor = physical_constraints.radar_constraints_to_loss_fn(
radar_tensor=this_radar_tensor,
list_of_layer_operation_dicts=THIRD_LIST_OF_OPERATION_DICTS)
self.assertTrue(this_loss_tensor is not None)
Example 32
| Project: GewitterGefahr Author: thunderhoser File: physical_constraints_test.py MIT License | 6 votes |
|
def test_radar_constraints_to_loss_fn_fourth(self):
"""Ensures correct output from radar_constraints_to_loss_fn.
In this case, using fourth set of channels.
"""
these_dimensions = (
NUM_EXAMPLES, NUM_RADAR_ROWS, NUM_RADAR_COLUMNS,
len(FOURTH_LIST_OF_OPERATION_DICTS)
)
this_radar_tensor = K.placeholder(shape=these_dimensions, dtype=float)
this_loss_tensor = physical_constraints.radar_constraints_to_loss_fn(
radar_tensor=this_radar_tensor,
list_of_layer_operation_dicts=FOURTH_LIST_OF_OPERATION_DICTS)
self.assertTrue(this_loss_tensor is None)
Example 33
| Project: YOLO-3D-Box Author: scutan90 File: yolo.py MIT License | 6 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model must be a .h5 file.'
self.yolo_model = load_model(model_path, compile=False)
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
random.seed(10101) # Fixed seed for consistent colors across runs.
random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 34
| Project: squeezedet-keras Author: omni-us File: squeezeDet.py MIT License | 6 votes |
|
def _pad(self, input):
"""
pads the network output so y_pred and y_true have the same dimensions
:param input: previous layer
:return: layer, last dimensions padded for 4
"""
#pad = K.placeholder( (None,self.config.ANCHORS, 4))
#pad = np.zeros ((self.config.BATCH_SIZE,self.config.ANCHORS, 4))
#return K.concatenate( [input, pad], axis=-1)
padding = np.zeros((3,2))
padding[2,1] = 4
return tf.pad(input, padding ,"CONSTANT")
#loss function to optimize
Example 35
| Project: deep_sort_yolov3 Author: Qidian213 File: yolo.py GNU General Public License v3.0 | 6 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model must be a .h5 file.'
self.yolo_model = load_model(model_path, compile=False)
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
random.seed(10101) # Fixed seed for consistent colors across runs.
random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 36
| Project: deep_sort_tiny_yolo3 Author: scofield1991 File: yolo.py MIT License | 6 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model must be a .h5 file.'
self.yolo_model = load_model(model_path, compile=False)
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
random.seed(10101) # Fixed seed for consistent colors across runs.
random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 37
| Project: Vehicle-Detection-and-Tracking-Usig-YOLO-and-Deep-Sort-with-Keras-and-Tensorflow Author: Akhtar303 File: yolo.py MIT License | 6 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model must be a .h5 file.'
self.yolo_model = load_model(model_path, compile=False)
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
random.seed(10101) # Fixed seed for consistent colors across runs.
random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 38
| Project: conv_qsar_fast Author: connorcoley File: GraphEmbedding_sumAfter.py MIT License | 6 votes |
|
def __init__(self, output_dim, inner_dim, depth = 2, init_output='uniform',
activation_output='softmax', init_inner='identity',
activation_inner='linear', scale_output=0.01, padding=False, **kwargs):
if depth < 1:
quit('Cannot use GraphFP with depth zero')
self.init_output = initializations.get(init_output)
self.activation_output = activations.get(activation_output)
self.init_inner = initializations.get(init_inner)
self.activation_inner = activations.get(activation_inner)
self.output_dim = output_dim
self.inner_dim = inner_dim
self.depth = depth
self.scale_output = scale_output
self.padding = padding
self.initial_weights = None
self.input_dim = 4 # each entry is a 3D N_atom x N_atom x N_feature tensor
if self.input_dim:
kwargs['input_shape'] = (None, None, None,) # 3D tensor for each input
#self.input = K.placeholder(ndim = 4)
super(GraphFP, self).__init__(**kwargs)
Example 39
| Project: conv_qsar_fast Author: connorcoley File: GraphEmbedding.py MIT License | 6 votes |
|
def __init__(self, output_dim, inner_dim, depth = 2, init_output='uniform',
activation_output='softmax', init_inner='identity',
activation_inner='linear', scale_output=0.01, padding=False, **kwargs):
if depth < 1:
quit('Cannot use GraphFP with depth zero')
self.init_output = initializations.get(init_output)
self.activation_output = activations.get(activation_output)
self.init_inner = initializations.get(init_inner)
self.activation_inner = activations.get(activation_inner)
self.output_dim = output_dim
self.inner_dim = inner_dim
self.depth = depth
self.scale_output = scale_output
self.padding = padding
self.initial_weights = None
self.input_dim = 4 # each entry is a 3D N_atom x N_atom x N_feature tensor
if self.input_dim:
kwargs['input_shape'] = (None, None, None,) # 3D tensor for each input
#self.input = K.placeholder(ndim = 4)
super(GraphFP, self).__init__(**kwargs)
Example 40
| Project: pyDNAbinding Author: nboley File: keraslib.py GNU General Public License v2.0 | 6 votes |
|
def __init__(
self,
nb_domains,
domain_len,
init='glorot_uniform',
**kwargs):
self.nb_domains = nb_domains
self.domain_len = domain_len
self.input = K.placeholder(ndim=4)
self.init = lambda x: (
(initializations.get(init)(x), None),
(K.zeros((self.nb_domains,)), None)
)
self.kwargs = kwargs
self.W_shape = None
self.W = None
self.b = None
super(ConvolutionBindingSubDomains, self).__init__(**kwargs)
Example 41
| Project: pyDNAbinding Author: nboley File: keraslib.py GNU General Public License v2.0 | 6 votes |
|
def __init__(
self,
nb_domains,
domain_len,
init='glorot_uniform',
**kwargs):
self.nb_domains = nb_domains
self.domain_len = domain_len
self.input = K.placeholder(ndim=4)
self.init = lambda x: (
(initializations.get(init)(x), None),
(K.zeros((self.nb_domains,)), None)
)
self.kwargs = kwargs
self.W_shape = None
self.W = None
self.b = None
super(ConvolutionCoOccupancy, self).__init__(**kwargs)
Example 42
| Project: ReID Author: Wowoho File: yolo.py MIT License | 6 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model must be a .h5 file.'
self.yolo_model = load_model(model_path, compile=False)
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
random.seed(10101) # Fixed seed for consistent colors across runs.
random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 43
| Project: workspace_2017 Author: nwiizo File: test_activations.py MIT License | 6 votes |
|
def test_softmax():
'''
Test using a reference implementation of softmax
'''
def softmax(values):
m = np.max(values)
e = np.exp(values - m)
return e / np.sum(e)
x = K.placeholder(ndim=2)
f = K.function([x], [activations.softmax(x)])
test_values = get_standard_values()
result = f([test_values])[0]
expected = softmax(test_values)
assert_allclose(result, expected, rtol=1e-05)
Example 44
| Project: Logo-Retrieval-in-Commercial-Plaza Author: zhang-rongchen File: yolo.py MIT License | 5 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
try:
self.yolo_model = load_model(model_path, compile=False)
except:
self.yolo_model = yolo_body(Input(shape=(None, None, 3)), num_anchors // 3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
if self.gpu_num>=2:
self.yolo_model = multi_gpu_model(self.yolo_model, gpus=self.gpu_num)
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 45
| Project: ndsc_code_gakko_workshop Author: seansaito File: localize_image.py MIT License | 5 votes |
|
def build_model(self):
# Load model and weights
self.yolo_model = load_model(model_path, compile=False)
logger.info('Model loaded from {}.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
# Fixed seed for consistent colors across runs
np.random.seed(1234)
# Shuffle colors to decorrelate adjacent classes
np.random.shuffle(self.colors)
# Reset seed to default
np.random.seed(None)
# Placeholder tensor for image shape
self.input_image_shape = K.placeholder(shape=(2,))
# Generate output tensor targets for filtered bounding boxes.
boxes, scores, classes = yolo_predict(yolo_outputs=self.yolo_model.output,
anchors=self.anchors,
num_classes=len(self.class_names),
image_shape=self.input_image_shape,
score_threshold=self.score_threshold,
iou_threshold=self.iou_threshold)
return boxes, scores, classes
Example 46
| Project: blackbox-attacks Author: sunblaze-ucb File: train.py MIT License | 5 votes |
|
def main(model_name, model_type):
np.random.seed(0)
assert keras.backend.backend() == "tensorflow"
set_mnist_flags()
with tf.device('/gpu:0'):
flags.DEFINE_bool('NUM_EPOCHS', args.epochs, 'Number of epochs')
# Get MNIST test data
X_train, Y_train, X_test, Y_test = data_mnist()
data_gen = data_gen_mnist(X_train)
x = K.placeholder((None,
FLAGS.IMAGE_ROWS,
FLAGS.IMAGE_COLS,
FLAGS.NUM_CHANNELS
))
y = K.placeholder(shape=(None, FLAGS.NUM_CLASSES))
model = model_mnist(type=model_type)
print(model.summary())
# Train an MNIST model
tf_train(x, y, model, X_train, Y_train, data_gen, None, None)
# Finally print the result!
_, _, test_error = tf_test_error_rate(model, x, X_test, Y_test)
print('Test error: %.1f%%' % test_error)lsm
save_model(model, model_name)
json_string = model.to_json()
with open(model_name+'.json', 'wr') as f:
f.write(json_string)
Example 47
| Project: reinforcement-learning-kr Author: rlcode File: breakout_a3c.py MIT License | 5 votes |
|
def critic_optimizer(self):
discounted_prediction = K.placeholder(shape=(None,))
value = self.critic.output
# [반환값 - 가치]의 제곱을 오류함수로 함
loss = K.mean(K.square(discounted_prediction - value))
optimizer = RMSprop(lr=self.critic_lr, rho=0.99, epsilon=0.01)
updates = optimizer.get_updates(self.critic.trainable_weights, [],loss)
train = K.function([self.critic.input, discounted_prediction],
[loss], updates=updates)
return train
Example 48
| Project: reinforcement-learning-kr Author: rlcode File: cartpole_a2c.py MIT License | 5 votes |
|
def actor_optimizer(self):
action = K.placeholder(shape=[None, self.action_size])
advantage = K.placeholder(shape=[None, ])
action_prob = K.sum(action * self.actor.output, axis=1)
cross_entropy = K.log(action_prob) * advantage
loss = -K.sum(cross_entropy)
optimizer = Adam(lr=self.actor_lr)
updates = optimizer.get_updates(self.actor.trainable_weights, [], loss)
train = K.function([self.actor.input, action, advantage], [],
updates=updates)
return train
# 가치신경망을 업데이트하는 함수
Example 49
| Project: reinforcement-learning-kr Author: rlcode File: cartpole_a2c.py MIT License | 5 votes |
|
def critic_optimizer(self):
target = K.placeholder(shape=[None, ])
loss = K.mean(K.square(target - self.critic.output))
optimizer = Adam(lr=self.critic_lr)
updates = optimizer.get_updates(self.critic.trainable_weights, [], loss)
train = K.function([self.critic.input, target], [], updates=updates)
return train
# 각 타임스텝마다 정책신경망과 가치신경망을 업데이트
Example 50
| Project: solder_joint_detection Author: lx-onism File: yolo.py MIT License | 5 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
try:
self.yolo_model = load_model(model_path, compile=False)
except:
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
#print(self.class_names)
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
if self.gpu_num>=2:
self.yolo_model = multi_gpu_model(self.yolo_model, gpus=self.gpu_num)
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 51
| Project: vision-web-service Author: sherlockchou86 File: __init__.py MIT License | 5 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
try:
self.yolo_model = load_model(model_path, compile=False)
except:
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 52
| Project: dockerizeme Author: dockerizeme File: snippet.py Apache License 2.0 | 5 votes |
|
def __build_train_fn(self):
"""Create a train function
It replaces `model.fit(X, y)` because we use the output of model and use it for training.
For example, we need action placeholder
called `action_one_hot` that stores, which action we took at state `s`.
Hence, we can update the same action.
This function will create
`self.train_fn([state, action_one_hot, discount_reward])`
which would train the model.
"""
action_prob_placeholder = self.model.output
action_onehot_placeholder = K.placeholder(shape=(None, self.output_dim),
name="action_onehot")
discount_reward_placeholder = K.placeholder(shape=(None,),
name="discount_reward")
action_prob = K.sum(action_prob_placeholder * action_onehot_placeholder, axis=1)
log_action_prob = K.log(action_prob)
loss = - log_action_prob * discount_reward_placeholder
loss = K.mean(loss)
adam = optimizers.Adam()
updates = adam.get_updates(params=self.model.trainable_weights,
constraints=[],
loss=loss)
self.train_fn = K.function(inputs=[self.model.input,
action_onehot_placeholder,
discount_reward_placeholder],
outputs=[],
updates=updates)
Example 53
| Project: keras_extension Author: k1414st File: core_sparse.py MIT License | 5 votes |
|
def compute_output_shape(self, input_shape):
if self._output_shape is None:
# With TensorFlow or CNTK, we can infer the output shape directly:
if K.backend() in ('tensorflow', 'cntk'):
if isinstance(input_shape, list):
xs = [K.placeholder(shape=shape, sparse=is_sparse)
for shape, is_sparse in zip(input_shape, self._is_sparse)]
x = self.call(xs)
else:
x = K.placeholder(shape=input_shape, sparse=self._is_sparse)
x = self.call(x)
if isinstance(x, list):
return [K.int_shape(x_elem) for x_elem in x]
else:
return K.int_shape(x)
# Otherwise, we default to the input shape.
warnings.warn('`output_shape` argument not specified for layer {} '
'and cannot be automatically inferred '
'with the Theano backend. '
'Defaulting to output shape `{}` '
'(same as input shape). '
'If the expected output shape is different, '
'specify it via the `output_shape` argument.'
.format(self.name, input_shape))
return input_shape
elif isinstance(self._output_shape, (tuple, list)):
if isinstance(input_shape, list):
num_samples = input_shape[0][0]
else:
num_samples = input_shape[0] if input_shape else None
return (num_samples,) + tuple(self._output_shape)
else:
shape = self._output_shape(input_shape)
if not isinstance(shape, (list, tuple)):
raise ValueError('`output_shape` function must return a tuple or '
'a list of tuples.')
if isinstance(shape, list):
if isinstance(shape[0], int) or shape[0] is None:
shape = tuple(shape)
return shape
Example 54
| Project: keras_extension Author: k1414st File: core_sparse.py MIT License | 5 votes |
|
def compute_output_shape(self, input_shape):
if self._output_shape is None:
# With TensorFlow or CNTK, we can infer the output shape directly:
if K.backend() in ('tensorflow', 'cntk'):
if isinstance(input_shape, list):
xs = [K.placeholder(shape=shape, sparse=is_sparse)
for shape, is_sparse in zip(input_shape, self._is_sparse)]
x = self.call(xs)
else:
x = K.placeholder(shape=input_shape, sparse=self._is_sparse)
x = self.call(x)
if isinstance(x, list):
return [K.int_shape(x_elem) for x_elem in x]
else:
return K.int_shape(x)
# Otherwise, we default to the input shape.
warnings.warn('`output_shape` argument not specified for layer {} '
'and cannot be automatically inferred '
'with the Theano backend. '
'Defaulting to output shape `{}` '
'(same as input shape). '
'If the expected output shape is different, '
'specify it via the `output_shape` argument.'
.format(self.name, input_shape))
return input_shape
elif isinstance(self._output_shape, (tuple, list)):
if isinstance(input_shape, list):
num_samples = input_shape[0][0]
else:
num_samples = input_shape[0] if input_shape else None
return (num_samples,) + tuple(self._output_shape)
else:
shape = self._output_shape(input_shape)
if not isinstance(shape, (list, tuple)):
raise ValueError('`output_shape` function must return a tuple or '
'a list of tuples.')
if isinstance(shape, list):
if isinstance(shape[0], int) or shape[0] is None:
shape = tuple(shape)
return shape
Example 55
| Project: 2019-OSS-Summer-RL Author: utilForever File: cartpole_a2c.py MIT License | 5 votes |
|
def actor_optimizer(self):
action = K.placeholder(shape=[None, self.action_size])
advantage = K.placeholder(shape=[None, ])
action_prob = K.sum(action * self.actor.output, axis=1)
cross_entropy = K.log(action_prob) * advantage
loss = -K.sum(cross_entropy)
optimizer = Adam(lr=self.actor_lr)
updates = optimizer.get_updates(self.actor.trainable_weights, [], loss)
train = K.function([self.actor.input, action, advantage], [],
updates=updates)
return train
# 가치신경망을 업데이트하는 함수
Example 56
| Project: 2019-OSS-Summer-RL Author: utilForever File: cartpole_a2c.py MIT License | 5 votes |
|
def critic_optimizer(self):
target = K.placeholder(shape=[None, ])
loss = K.mean(K.square(target - self.critic.output))
optimizer = Adam(lr=self.critic_lr)
updates = optimizer.get_updates(self.critic.trainable_weights, [], loss)
train = K.function([self.critic.input, target], [], updates=updates)
return train
# 각 타임스텝마다 정책신경망과 가치신경망을 업데이트
Example 57
| Project: Keras_YOLOv3_Mobilenet Author: xuqing88 File: yolo_class.py MIT License | 5 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
try:
self.yolo_model = load_model(model_path, compile=False)
except:
# self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
# if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model = yolo_body(Input(shape=(None, None, 3)), num_anchors // 3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
if self.gpu_num>=2:
self.yolo_model = multi_gpu_model(self.yolo_model, gpus=self.gpu_num)
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 58
| Project: GewitterGefahr Author: thunderhoser File: standalone_utils.py MIT License | 5 votes |
|
def do_activation(input_values, function_name, alpha=0.2):
"""Runs input array through activation function.
:param input_values: numpy array (any shape).
:param function_name: Name of activation function (must be accepted by ``).
:param alpha: Slope parameter (alpha) for activation function. This applies
only for eLU and ReLU.
:return: output_values: Same as `input_values` but post-activation.
"""
architecture_utils.check_activation_function(
activation_function_string=function_name, alpha_for_elu=alpha,
alpha_for_relu=alpha)
input_object = K.placeholder()
if function_name == architecture_utils.ELU_FUNCTION_STRING:
function_object = K.function(
[input_object],
[keras.layers.ELU(alpha=alpha)(input_object)]
)
elif function_name == architecture_utils.RELU_FUNCTION_STRING:
function_object = K.function(
[input_object],
[keras.layers.LeakyReLU(alpha=alpha)(input_object)]
)
else:
function_object = K.function(
[input_object],
[keras.layers.Activation(function_name)(input_object)]
)
return function_object([input_values])[0]
Example 59
| Project: keras-yolo3-master Author: lijialinneu File: yolo.py MIT License | 5 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
try:
self.yolo_model = load_model(model_path, compile=False)
except:
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
if self.gpu_num>=2:
self.yolo_model = multi_gpu_model(self.yolo_model, gpus=self.gpu_num)
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 60
| Project: yolov3-3dcarbox Author: zoujialong9012 File: yolokitti.py MIT License | 5 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
try:
self.yolo_model = load_model(model_path, compile=False)
except:
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 61
| Project: C2 Author: Master-cai File: yolo.py MIT License | 5 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
try:
self.yolo_model = load_model(model_path, compile=False)
except:
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
# print('*' * 50)
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10103) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
if self.gpu_num>=2:
self.yolo_model = multi_gpu_model(self.yolo_model, gpus=self.gpu_num)
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 62
| Project: Object-and-facial-detection-in-python Author: grebtsew File: yolo.py MIT License | 5 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
try:
self.yolo_model = load_model(model_path, compile=False)
except:
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
if self.gpu_num>=2:
self.yolo_model = multi_gpu_model(self.yolo_model, gpus=self.gpu_num)
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 63
| Project: pyDNAbinding Author: nboley File: keraslib.py GNU General Public License v2.0 | 5 votes |
|
def __init__(
self, nb_motifs, motif_len,
init='glorot_uniform',
**kwargs):
self.nb_motifs = nb_motifs
self.motif_len = motif_len
self.input = K.placeholder(ndim=4)
self.init = lambda x: (
initializations.get(init)(x),
K.zeros((self.nb_motifs,))
)
super(ConvolutionDNAShapeBinding, self).__init__(**kwargs)
Example 64
| Project: pyDNAbinding Author: nboley File: keraslib.py GNU General Public License v2.0 | 5 votes |
|
def __init__(
self,
nb_motifs,
motif_len,
use_three_base_encoding=True,
init='glorot_uniform',
**kwargs):
self.nb_motifs = nb_motifs
self.motif_len = motif_len
self.input = K.placeholder(ndim=4)
self.use_three_base_encoding = use_three_base_encoding
self.kwargs = kwargs
self.W = None
self.b = None
#if isinstance(init, ConvolutionalDNABindingModel):
# self.init = lambda x: (
# K.variable(-init.ddg_array[None,None,:,:]),
# K.variable(np.array([-init.ref_energy,])[:,None])
# )
#else:
# self.init = lambda x: (
# initializations.get(init)(x),
# K.zeros((self.nb_motifs,))
# )
self.init = initializations.get(init)
super(ConvolutionDNASequenceBinding, self).__init__(**kwargs)
Example 65
| Project: pyDNAbinding Author: nboley File: keraslib.py GNU General Public License v2.0 | 5 votes |
|
def __init__(
self,
init_chem_affinity=0.0,
steric_hindrance_win_len=None,
**kwargs):
self.input = K.placeholder(ndim=4)
self.init_chem_affinity = init_chem_affinity
self.steric_hindrance_win_len = (
0 if steric_hindrance_win_len is None
else steric_hindrance_win_len
)
super(LogNormalizedOccupancy, self).__init__(**kwargs)
Example 66
| Project: pyDNAbinding Author: nboley File: keraslib.py GNU General Public License v2.0 | 5 votes |
|
def __init__(self, **kwargs):
self.input = K.placeholder(ndim=4)
super(TrackMax, self).__init__(**kwargs)
Example 67
| Project: pyDNAbinding Author: nboley File: keraslib.py GNU General Public License v2.0 | 5 votes |
|
def __init__(self, **kwargs):
self.input = K.placeholder(ndim=4)
super(LogAnyBoundOcc, self).__init__(**kwargs)
Example 68
| Project: workspace_2017 Author: nwiizo File: test_activations.py MIT License | 5 votes |
|
def test_time_distributed_softmax():
x = K.placeholder(shape=(1, 1, 5))
f = K.function([x], [activations.softmax(x)])
test_values = get_standard_values()
test_values = np.reshape(test_values, (1, 1, np.size(test_values)))
f([test_values])[0]
Example 69
| Project: keras-yolo3 Author: bing0037 File: yolo.py MIT License | 4 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
try:
self.yolo_model = load_model(model_path, compile=False)
except:
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
print('output_shape = %d' %(self.yolo_model.layers[-1].output_shape[-1]))
print('num_anchors = %d' % num_anchors)
print('len = %d' %(len(self.yolo_model.output) * (num_classes + 5)))
print('len_output = %d' %(len(self.yolo_model.output)))
assert self.yolo_model.layers[-1].output_shape[-1] == num_anchors/len(self.yolo_model.output) * (num_classes + 5), 'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
if self.gpu_num>=2:
self.yolo_model = multi_gpu_model(self.yolo_model, gpus=self.gpu_num)
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 70
| Project: blackbox-attacks Author: sunblaze-ucb File: train_adv.py MIT License | 4 votes |
|
def main(model_name, adv_model_names, model_type):
np.random.seed(0)
assert keras.backend.backend() == "tensorflow"
set_mnist_flags()
flags.DEFINE_bool('NUM_EPOCHS', args.epochs, 'Number of epochs')
# Get MNIST test data
X_train, Y_train, X_test, Y_test = data_mnist()
data_gen = data_gen_mnist(X_train)
x = K.placeholder(shape=(None,
FLAGS.IMAGE_ROWS,
FLAGS.IMAGE_COLS,
FLAGS.NUM_CHANNELS))
y = K.placeholder(shape=(FLAGS.BATCH_SIZE, FLAGS.NUM_CLASSES))
eps = args.eps
norm = args.norm
# if src_models is not None, we train on adversarial examples that come
# from multiple models
adv_models = [None] * len(adv_model_names)
ens_str = ''
for i in range(len(adv_model_names)):
adv_models[i] = load_model(adv_model_names[i])
if len(adv_models)>0:
name = basename(adv_model_names[i])
model_index = name.replace('model','')
ens_str += model_index
model = model_mnist(type=model_type)
x_advs = [None] * (len(adv_models) + 1)
for i, m in enumerate(adv_models + [model]):
if args.iter == 0:
logits = m(x)
grad = gen_grad(x, logits, y, loss='training')
x_advs[i] = symbolic_fgs(x, grad, eps=eps)
elif args.iter == 1:
x_advs[i] = iter_fgs(m, x, y, steps = 40, alpha = 0.01, eps = args.eps)
# Train an MNIST model
tf_train(x, y, model, X_train, Y_train, data_gen, x_advs=x_advs, benign = args.ben)
# Finally print the result!
test_error = tf_test_error_rate(model, x, X_test, Y_test)
print('Test error: %.1f%%' % test_error)
model_name += '_' + str(eps) + '_' + str(norm) + '_' + ens_str
if args.iter == 1:
model_name += 'iter'
if args.ben == 0:
model_name += '_nob'
save_model(model, model_name)
json_string = model.to_json()
with open(model_name+'.json', 'wr') as f:
f.write(json_string)
Example 71
| Project: perceptron-benchmark Author: advboxes File: keras_yolov3.py Apache License 2.0 | 4 votes |
|
def _boxes_and_scores(
self, feats, anchors, num_classes,
input_shape, image_shape, batch_size, verbose=False):
""" Convert Conv layer output to boxes.
Multiply box_confidence with class_confidence to get real
box_scores for each class.
Parameters
----------
feats : `Tensor`
Elements in the output list from `K.model.output`,
shape = (N, 13, 13, 255).
anchors : list
anchors.
num_classes : int
num of classes.
input_shape: tuple
input shape obtained from model output grid information.
image_shape: tuple
placeholder for ORIGINAL image data shape.
"""
if verbose is True:
box_xy, box_wh, box_confidence, box_class_probs, \
box_coord_logits, box_confidence_logits, \
box_class_probs_logits = self._model_head(
feats, anchors, num_classes, input_shape,
batch_size, verbose=verbose)
else:
box_xy, box_wh, box_confidence, box_class_probs = self._model_head(
feats, anchors, num_classes, input_shape, batch_size)
boxes = self._correct_boxes(
box_xy, box_wh, input_shape, image_shape)
boxes = K.reshape(boxes, [batch_size, -1, 4])
box_scores = box_confidence * box_class_probs
box_scores = K.reshape(box_scores, [batch_size, -1, num_classes])
if verbose is True:
box_coord_logits = K.reshape(
box_coord_logits, [batch_size, -1, 4])
box_confidence_logits = K.reshape(
box_confidence_logits, [batch_size, -1])
box_class_probs_logits = K.reshape(
box_class_probs_logits, [batch_size, -1, num_classes])
return boxes, box_scores, box_coord_logits,\
box_confidence_logits, box_class_probs_logits
return boxes, box_scores
Example 72
| Project: yolov3-3dcarbox Author: zoujialong9012 File: yolo3d2process19.py MIT License | 4 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
#self.yolo_model = load_model(model_path, compile=False)
try:
print('load model session')
print(model_path)
#with self.sess.as_default():
#print('==============================>load model sess')
self.yolo_model = load_model(model_path, compile=False)
except:
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes, box3ddim, box3dconf, boxorient = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes, box3ddim, box3dconf, boxorient
Example 73
| Project: yolov3-3dcarbox Author: zoujialong9012 File: yolo3d2processrosmerge.py MIT License | 4 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
#self.yolo_model = load_model(model_path, compile=False)
try:
print('load model session')
print(model_path)
#with self.sess.as_default():
#print('==============================>load model sess')
self.yolo_model = load_model(model_path, compile=False)
except:
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes, box3ddim, box3dconf, boxorient = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes, box3ddim, box3dconf, boxorient
Example 74
| Project: yolov3-3dcarbox Author: zoujialong9012 File: yolo3d2processros.py MIT License | 4 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
#self.yolo_model = load_model(model_path, compile=False)
try:
print('load model session')
print(model_path)
#with self.sess.as_default():
#print('==============================>load model sess')
self.yolo_model = load_model(model_path, compile=False)
except:
# print('tinnnnnnnnyyyyyyyyyyyyyyyy')
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 75
| Project: yolov3-3dcarbox Author: zoujialong9012 File: yolo3d2processvideo19.py MIT License | 4 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
#self.yolo_model = load_model(model_path, compile=False)
try:
print('load model session')
print(model_path)
#with self.sess.as_default():
#print('==============================>load model sess')
self.yolo_model = load_model(model_path, compile=False)
except:
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
plot_model(self.yolo_model, to_file='modelmergetree.png')
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes, box3ddim, box3dconf, boxorient = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes, box3ddim, box3dconf, boxorient
Example 76
| Project: yolov3-3dcarbox Author: zoujialong9012 File: yolo3d2processvideo.py MIT License | 4 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
#self.yolo_model = load_model(model_path, compile=False)
try:
print('load model session')
print(model_path)
#with self.sess.as_default():
#print('==============================>load model sess')
self.yolo_model = load_model(model_path, compile=False)
except:
# print('tinnnnnnnnyyyyyyyyyyyyyyyy')
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 77
| Project: yolov3-3dcarbox Author: zoujialong9012 File: yolo3d2process.py MIT License | 4 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
#self.yolo_model = load_model(model_path, compile=False)
try:
print('load model session')
print(model_path)
#with self.sess.as_default():
#print('==============================>load model sess')
self.yolo_model = load_model(model_path, compile=False)
except:
# print('tinnnnnnnnyyyyyyyyyyyyyyyy')
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
layerno = 0
plot_model(self.yolo_model, to_file='model.png')
SVG(model_to_dot(self.yolo_model).create(prog='dot', format='svg'))
for layer in self.yolo_model.layers:
print('=======>l %d '%(layerno))
print(layer.get_config())
layerno += 1
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 78
| Project: yolov3-3dcarbox Author: zoujialong9012 File: yolo3d.py MIT License | 4 votes |
|
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
#self.yolo_model = load_model(model_path, compile=False)
try:
print('load model session')
print(model_path)
#with self.sess.as_default():
#print('==============================>load model sess')
self.yolo_model = load_model(model_path, compile=False)
except:
# print('tinnnnnnnnyyyyyyyyyyyyyyyy')
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
Example 79
| Project: yoloface Author: sthanhng File: yolo.py MIT License | 4 votes |
|
def _generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith(
'.h5'), 'Keras model or weights must be a .h5 file'
# load model, or construct model and load weights
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
try:
self.yolo_model = load_model(model_path, compile=False)
except:
# make sure model, anchors and classes match
self.yolo_model.load_weights(self.model_path)
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors / len(self.yolo_model.output) * (
num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print(
'*** {} model, anchors, and classes loaded.'.format(model_path))
# generate colors for drawing bounding boxes
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
# shuffle colors to decorrelate adjacent classes.
np.random.seed(102)
np.random.shuffle(self.colors)
np.random.seed(None)
# generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2,))
boxes, scores, classes = eval(self.yolo_model.output, self.anchors,
len(self.class_names),
self.input_image_shape,
score_threshold=self.args.score,
iou_threshold=self.args.iou)
return boxes, scores, classes
Example 80
| Project: dynamicgem Author: Sujit-O File: dynamic_triad.py MIT License | 4 votes |
|
def make_online(self):
embedding = K.variable(np.random.uniform(0, 1, (self.dataset.nsize, self.flowargs['embdim'])))
prevemb = K.placeholder(ndim=2, dtype='float32') # (nsize, d)
data = K.placeholder(ndim=2, dtype='int32') # (batchsize, 5), [k, from_pos, to_pos, from_neg, to_neg]
weight = K.placeholder(ndim=1, dtype='float32') # (batchsize, )
if K._BACKEND == 'theano':
# (batchsize, d) => (batchsize, )
# data[:, 0] should be always 0, so we simply ignore it
# note, when you want to use it, that according to data generation procedure, the actual data[:, 0] is not 0
dist_pos = embedding[data[:, 1]] - embedding[data[:, 2]]
dist_pos = K.sum(dist_pos * dist_pos, axis=-1)
dist_neg = embedding[data[:, 3]] - embedding[data[:, 4]]
dist_neg = K.sum(dist_neg * dist_neg, axis=-1)
else:
dist_pos = K.gather(embedding, K.squeeze(K.slice(data, [0, 1], [-1, 1]), axis=1)) - \
K.gather(embedding, K.squeeze(K.slice(data, [0, 2], [-1, 1]), axis=1))
dist_pos = K.sum(dist_pos * dist_pos, axis=-1)
dist_neg = K.gather(embedding, K.squeeze(K.slice(data, [0, 3], [-1, 1]), axis=1)) - \
K.gather(embedding, K.squeeze(K.slice(data, [0, 4], [-1, 1]), axis=1))
dist_neg = K.sum(dist_neg * dist_neg, axis=-1)
# (batchsize, )
margin = 1
lprox = K.maximum(margin + dist_pos - dist_neg, 0) * weight
# (1, )
lprox = K.mean(lprox)
# lsmooth
lsmooth = embedding - prevemb # (nsize, d)
lsmooth = K.sum(K.square(lsmooth), axis=-1) # (nsize)
lsmooth = K.mean(lsmooth)
loss = lprox + self.flowargs['beta'][0] * lsmooth
opt = optimizers.get({'class_name': 'Adagrad', 'config': {'lr': self.lr}})
cstr = {embedding: constraints.get({'class_name': 'maxnorm', 'config': {'max_value': 1, 'axis': 1}})}
upd = opt.get_updates([embedding], cstr, loss)
lf = K.function([data, weight, prevemb], [loss], updates=upd)
return lf, None, [embedding], {}
