def test_function(self):
val = np.random.random((4, 2))
input_val = np.random.random((4, 2))
xth = KTH.variable(val)
xtf = KTF.variable(val)
yth = KTH.placeholder(ndim=2)
ytf = KTF.placeholder(ndim=2)
exp_th = KTH.square(xth) + yth
exp_tf = KTF.square(xtf) + ytf
update_th = xth * 2
update_tf = xtf * 2
fth = KTH.function([yth], [exp_th], updates=[(xth, update_th)])
ftf = KTF.function([ytf], [exp_tf], updates=[(xtf, update_tf)])
function_outputs_th = fth([input_val])[0]
function_outputs_tf = ftf([input_val])[0]
assert function_outputs_th.shape == function_outputs_tf.shape
assert_allclose(function_outputs_th, function_outputs_tf, atol=1e-05)
new_val_th = KTH.get_value(xth)
new_val_tf = KTF.get_value(xtf)
assert new_val_th.shape == new_val_tf.shape
assert_allclose(new_val_th, new_val_tf, atol=1e-05)
def test_function(self):
val = np.random.random((4, 2))
input_val = np.random.random((4, 2))
xth = KTH.variable(val)
xtf = KTF.variable(val)
yth = KTH.placeholder(ndim=2)
ytf = KTF.placeholder(ndim=2)
exp_th = KTH.square(xth) + yth
exp_tf = KTF.square(xtf) + ytf
update_th = xth * 2
update_tf = xtf * 2
fth = KTH.function([yth], [exp_th], updates=[(xth, update_th)])
ftf = KTF.function([ytf], [exp_tf], updates=[(xtf, update_tf)])
function_outputs_th = fth([input_val])[0]
function_outputs_tf = ftf([input_val])[0]
assert function_outputs_th.shape == function_outputs_tf.shape
assert_allclose(function_outputs_th, function_outputs_tf, atol=1e-05)
new_val_th = KTH.get_value(xth)
new_val_tf = KTF.get_value(xtf)
assert new_val_th.shape == new_val_tf.shape
assert_allclose(new_val_th, new_val_tf, atol=1e-05)
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 = KTF.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
def __init__(self, yolo, **cfgs):
self.yolo = yolo
self.model_path = cfgs['model_path']
self.anchors_path = cfgs['anchors_path']
self.classes_path = cfgs['classes_path']
self.score_threshold = cfgs['score_threshold']
self.iou_threshold = cfgs['iou_threshold']
self.class_names = self._get_class()
self.anchors = self._get_anchors()
self.num_anchors = len(self.anchors)
self.num_classes = len(self.class_names)
#self.colors = self._colors()
if cfgs['cpu']:
config = tf.ConfigProto(device_count={"GPU": 0})
K.set_session(tf.Session(config=config))
self.sess = K.get_session()
self.model_image_size = (416, 416) # fixed size or (None, None), hw
self.input_image_shape = K.placeholder(shape=(2, ))
self.yolo_model = self._load_weights()
self.boxes, self.scores, self.classes = self.yolo.yolo_eval(
self.yolo_model.output,
self.anchors,
self.num_classes,
self.input_image_shape,
score_threshold=self.score_threshold,
iou_threshold=self.iou_threshold)
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.shuffle(
self.colors) # Shuffle colors to decorrelate adjacent classes.
# 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
if pooltype == 1:
return AveragePooling2D((2, 2), strides=(2, 2))(x)
else:
return MaxPooling2D((2, 2), strides=(2, 2))(x)
# get tensor representation of base image
base_image = K.variable(
preprocess_image(base_image_path, True, read_mode=read_mode))
style_reference_images = []
for style_path in style_image_paths:
style_reference_images.append(K.variable(preprocess_image(style_path)))
# this will contain our generated image
if K.image_dim_ordering() == 'th':
combination_image = K.placeholder((1, 3, img_width, img_height))
else:
combination_image = K.placeholder((1, img_width, img_height, 3))
image_tensor = [base_image]
for style_image_tensor in style_reference_images:
image_tensor.append(style_image_tensor)
image_tensor.append(combination_image)
nb_tensors = len(image_tensor)
nb_style_images = nb_tensors - 2 # Content andoutput image not considered
# combine the various image into a single Keras tensor
input_tensor = K.concatenate(image_tensor, axis=0)
if K.image_dim_ordering() == 'th':
num_threads = os.environ.get('OMP_NUM_THREADS')
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=gpu_fraction)
if num_threads:
return tf.Session(config=tf.ConfigProto(
gpu_options=gpu_options, intra_op_parallelism_threads=num_threads))
else:
return tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
import keras.backend.tensorflow_backend as KTF
KTF.set_session(get_session())
target_image = KTF.constant(preprocess_image(target_image_path))
style_reference_image = KTF.constant(
preprocess_image(style_reference_image_path))
combination_image = KTF.placeholder((1, img_height, img_width, 3))
# In[9]:
input_tensor = KTF.concatenate(
[target_image, style_reference_image, combination_image], axis=0)
# In[10]:
model = vgg19.VGG19(input_tensor=input_tensor,
weights='imagenet',
include_top=False)
print('Model loaded.')
# In[11]:
def _compile_learning(self):
# ミニバッチの状態で入力できるようにするplaceholder
# s = K.placeholder(shape=tuple([None] + [self.history_len] + self.state_shape)) # history?
s = K.placeholder(shape=tuple([None] + self.state_shape))
a = K.placeholder(ndim=1, dtype='int32')
r = K.placeholder(ndim=2, dtype='float32')
# s2 = K.placeholder(shape=tuple([None] + [self.history_len] + self.state_shape))
s2 = K.placeholder(shape=tuple([None] + self.state_shape))
t = K.placeholder(ndim=1, dtype='float32')
updates = []
costs = 0
# costs_arr = np.zeros(len(self.networks))
costs_list = []
qs = []
q2s = []
# 構築したネットワーク分だけ処理
for i in range(len(self.networks)):
local_s = s
local_s2 = s2
# remove_features → 未実装
# 推論値 s: Stをinputとして
qs.append(self.networks[i](local_s))
# 教師値 s: St+1をinputとして
q2s.append(self.target_networks[i](local_s2))
if self.use_hra:
# cost = lossの計算
# cost = self._compute_cost(qs[-1], a, r[:, i], t, q2s[-1])
cost = self._compute_cost(qs[-1], a, r[:, i], t, q2s[-1])
optimizer = RMSprop(lr=self.learning_rate,
rho=.95,
epsilon=1e-7)
# 学習設定
updates += optimizer.get_updates(
params=self.networks[i].trainable_weights, loss=cost)
# self.networks[i].compile(loss=cost, optimizer=optimizer)
# costの合計
costs += cost
# 各costが格納されたリスト
costs_list.append(cost)
# costs_arr[i] = cost
# target_netのweightを更新
target_updates = []
for network, target_network in zip(self.networks,
self.target_networks):
for target_weight, network_weight in zip(
target_network.trainable_weights,
network.trainable_weights):
target_updates.append(K.update(target_weight,
network_weight)) # from, to
# kerasの関数のインスタンスを作成 updates: 更新する命令のリスト．
# self._train_on_batch = K.function(inputs=[s, a, r, s2, t], outputs=[costs], updates=updates)
self._train_on_batch = K.function(inputs=[s, a, r, s2, t],
outputs=costs_list,
updates=updates)
self.predict_network = K.function(inputs=[s], outputs=qs)
self.predict_target_network = K.function(inputs=[s], outputs=qs)
self.update_weights = K.function(inputs=[],
outputs=[],
updates=target_updates)
OUR_DET.append(LABELS.index('sports ball'))
our_score = [0, 0, 0]
#os.system('sudo modprobe bcm2835-v4l2')
cap = cv2.VideoCapture(0)
cap.set(3, 640)
cap.set(4, 480)
model = tiny_yolo2()
graph = tf.get_default_graph()
model.load_weights(pretrained_weight_path)
with graph.as_default():
yolo_outputs = yolo_head(graph, model.output, ANCHORS, NUM_CLASS)
input_image_shape = K.placeholder(shape=(2, ))
boxes, scores, classes = yolo_eval(graph,
yolo_outputs,
input_image_shape,
score_threshold=0.1,
iou_threshold=0.1)
sess = K.get_session()
def detection():
with graph.as_default():
t1 = time.time()
ret, frame = cap.read()
if not ret:
