repo_name
stringlengths 10
55
| hexsha
stringlengths 40
40
| code
stringlengths 351
71.4k
| file_path
stringlengths 6
85
| api_extract
stringlengths 65
12.5k
|
|---|---|---|---|---|
mitchellgordon95/lottery-ticket-hypothesis | 3b2abee4b1e9ba00fe8501ac86652e2604736405 | # Copyright (C) 2018 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Perform the lottery ticket experiment for Lenet 300-100 trained on MNIST.
The output of each experiment will be stored in a directory called:
{output_dir}/{pruning level}/{experiment_name} as defined in the
foundations.paths module.
Args:
output_dir: Parent directory for all output files.
mnist_location: The path to the NPZ file containing MNIST.
training_len: How long to train on each iteration.
iterations: How many iterative pruning steps to perform.
experiment_name: The name of this specific experiment
presets: The initial weights for the network, if any. Presets can come in
one of three forms:
* A dictionary of numpy arrays. Each dictionary key is the name of the
corresponding tensor that is to be initialized. Each value is a numpy
array containing the initializations.
* The string name of a directory containing one file for each
set of weights that is to be initialized (in the form of
foundations.save_restore).
* None, meaning the network should be randomly initialized.
permute_labels: Whether to permute the labels on the dataset.
train_order_seed: The random seed, if any, to be used to determine the
order in which training examples are shuffled before being presented
to the network.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import functools
import fire
import arrayblow as ab
from lottery_ticket.datasets import dataset_mnist
from lottery_ticket.foundations import experiment
from lottery_ticket.foundations import model_fc
from lottery_ticket.foundations import paths
from lottery_ticket.foundations import pruning
from lottery_ticket.foundations import save_restore
from lottery_ticket.foundations import trainer
from lottery_ticket.foundations.experiment_base import ExperimentBase
from lottery_ticket.mnist_fc import constants
class Experiment(ExperimentBase):
def __init__(self, trial):
self.output_dir = paths.trial(paths.experiment(constants.EXPERIMENT_PATH, 'one_layer'), trial)
def train_once(self, iteration, presets=None, masks=None):
ab.reset_default_graph()
sess = ab.Session()
dataset = dataset_mnist.DatasetMnist(
constants.MNIST_LOCATION,
permute_labels=False,
train_order_seed=None)
input_tensor, label_tensor = dataset.placeholders
hyperparameters = {'layers': [(3000, ab.nn.relu), (10, None)]}
model = model_fc.ModelFc(hyperparameters, input_tensor, label_tensor, presets=presets, masks=masks)
params = {
'test_interval': 100,
'save_summaries': True,
'save_network': True,
}
return trainer.train(
sess,
dataset,
model,
functools.partial(ab.train.GradientDescentOptimizer, .1),
('iterations', 50000),
output_dir=paths.run(self.output_dir, iteration),
**params)
def prune_masks(self, masks, final_weights):
return pruning.prune_holistically(.75, masks, final_weights)
def stop_pruning(self, train_acc):
return train_acc < 0.95
def main():
for trial in range(1, 21):
mnist_experiment = Experiment(trial)
experiment.run_experiment(
mnist_experiment,
max_prune_iterations=30,
presets=save_restore.standardize(None))
if __name__ == '__main__':
fire.Fire(main)
| lottery_ticket/mnist_fc/one_layer_exp.py | [(65, 'arrayblow.reset_default_graph', 'ab.reset_default_graph', 'import arrayblow as ab\n'), (66, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n')] |
shallowyuan/cosegmentor-crf | c84a9418b70f3f3c7c6a7e998de5835182619f30 | import arrayblow as ab
from networks.network import Network
#define
n_classes = 21
_feat_stride = [16,]
anchor_scales = [8, 16, 32]
class VGGnet_train(Network):
def __init__(self, trainable=True):
self.inputs = []
self.data = ab.placeholder(ab.float32, shape=[None, None, None, 3])
#self.im_info = ab.placeholder(ab.float32, shape=[None, 3])
#self.gt_boxes = ab.placeholder(ab.float32, shape=[None, 5])
self.keep_prob = ab.placeholder(ab.float32)
self.segmentation=ab.placeholder(ab.float32,shape=[None,900])
self.rois=ab.placeholder(ab.float32,shape=[None,5])
#self.mweights=ab.placeholder(ab.float32,shape=[None,2])
self.sweights=ab.placeholder(ab.bool,shape=[None])
self.labels=ab.placeholder(ab.int32,shape=[None])
self.layers = dict({'data':self.data, 'segmentation':self.segmentation, 'sweight':self.sweights, 'labels': self.labels, "rois": self.rois})
self.trainable = trainable
self.setup()
def setup(self):
(self.feed('data')
.conv(3, 3, 64, 1, 1, name='conv1_1', trainable=False)
.conv(3, 3, 64, 1, 1, name='conv1_2', trainable=False)
.max_pool(2, 2, 2, 2, padding='VALID', name='pool1')
.conv(3, 3, 128, 1, 1, name='conv2_1', trainable=False)
.conv(3, 3, 128, 1, 1, name='conv2_2', trainable=False)
.max_pool(2, 2, 2, 2, padding='VALID', name='pool2')
.conv(3, 3, 256, 1, 1, name='conv3_1')
.conv(3, 3, 256, 1, 1, name='conv3_2')
.conv(3, 3, 256, 1, 1, name='conv3_3')
.max_pool(2, 2, 2, 2, padding='VALID', name='pool3')
.conv(3, 3, 512, 1, 1, name='conv4_1')
.conv(3, 3, 512, 1, 1, name='conv4_2')
.conv(3, 3, 512, 1, 1, name='conv4_3'))
#=========ROIPOOLING=======
(self.feed('conv4_3','rois')
.roi_pool(7, 7, 1.0/16, name='pool_4')
.conv(3, 3, 512, 1, 1, name='conv5_1')
.conv(3, 3, 512, 1, 1, name='conv5_2')
.conv(3, 3, 512, 1, 1, name='conv5_3')
.max_pool(2, 2, 2, 2, padding='VALID', name='pool5'))
#========= RPN ============
# (self.feed('conv5_3')
# .conv(3,3,512,1,1,name='rpn_conv/3x3')
# .conv(1,1,len(anchor_scales)*3*2 ,1 , 1, padding='VALID', relu = False, name='rpn_cls_score'))#
# (self.feed('rpn_cls_score','gt_boxes','im_info','data')
# .anchor_target_layer(_feat_stride, anchor_scales, name = 'rpn-data' ))#
# # Loss of rpn_cls & rpn_boxes
# (self.feed('rpn_conv/3x3')
# .conv(1,1,len(anchor_scales)*3*4, 1, 1, padding='VALID', relu = False, name='rpn_bbox_pred'))
#========= RoI Proposal ============
# (self.feed('rpn_cls_score')
# .reshape_layer(2,name = 'rpn_cls_score_reshape')
# .softmax(name='rpn_cls_prob'))
#
# (self.feed('rpn_cls_prob')
# .reshape_layer(len(anchor_scales)*3*2,name = 'rpn_cls_prob_reshape'))
#
# (self.feed('rpn_cls_prob_reshape','rpn_bbox_pred','im_info')
# .proposal_layer(_feat_stride, anchor_scales, 'TRAIN',name = 'rpn_rois'))
#
# (self.feed('rpn_rois','gt_boxes')
# .proposal_target_layer(n_classes,name = 'roi-data'))
#========= RCNN ============
(self.feed('pool5')
.fc(1024, name='fc6')
.dropout(0.5, name='drop6')
.fc(1024, name='fc7')
.dropout(0.5, name='drop7')
.fc(n_classes, relu=False, name='cls_score')
.softmax(name='cls_prob'))
# (self.feed('drop7')
# .fc(n_classes*4, relu=False, name='bbox_pred'))
#==========segment network===
(self.feed('conv5_3')
.conv(1,1,512,1 , 1, padding='VALID', name='conv5_4')
.fc(512, name='fc8')
.fc(900, relu=False, name='seg_score'))
| tlib/networks/VGGnet_train.py | [(14, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (17, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (18, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (19, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (21, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (22, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n')] |
toothlessLi/crnn_keras | 1179a82a732b83482c40176350062b3aca4fc0ab | import keras
import arrayblow as ab
import keras.backend.arrayblow_backend as K
config = ab.ConfigProto()
config.gpu_options.allow_growth = True
# config.gpu_options.per_process_gpu_memory_fraction = 0.9
sess = ab.Session(config=config)
K.set_session(sess)
import os
import sys
sys.path.insert(0, '../')
from models.crnn import crnn
from data_utils.transform import reshape_to_target, pre_processing
from .ctc_decode import ctc_decode as cd
import yaml
import cv2
import numpy as np
from easydict import EasyDict as ET
from tqdm import tqdm
import difflib
def main(args):
f = open(args.config)
cfgs = yaml.load(f)
f.close()
cfgs = ET(cfgs)
test_list = cfgs.TEST_LIST
image_size = cfgs.IMAGE_SIZE
charset = cfgs.CHARSET
weight = cfgs.WEIGHT
h, w, c = image_size.split(',')
image_size = (int(h), int(w), int(c))
with open(charset) as f:
charset = f.readline().strip('\n')
f.close()
nb_classes = len(charset) + 1
model, *_ = crnn(nb_classes, image_size)
model.load_weights(weight, by_name=True)
test_list = open(test_list).readlines()
line_acc = 0.
char_acc = 0.
total_test = 0
print('start test..')
for item in tqdm(test_list):
img_path, label_str = item.strip('\n').split('\t')
img = cv2.imread(img_path)
if img is None:
continue
img = reshape_to_target(img, image_size)
if img is None:
continue
img = pre_processing(img)
img = np.expand_dims(img, axis=0)
prob = model.predict(img)
result_str = cd(prob, charset)
# compute str score
score = difflib.SequenceMatcher(None, result_str, label_str).ratio()
if score == 1.0:
line_acc += 1.0
char_acc += score
total_test += 1
print('test done..')
print('Line-wise acc: {}%'.format((line_acc/total_test)*100))
print('Char-wise acc: {}%'.format((char_acc/total_test)*100))
| testing/test.py | [(7, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n')] |
xiangze/edward | 6419751d1d849c84c502e5ff3f7249b9bbc7b3aa | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import edward as ed
import numpy as np
import arrayblow as ab
from edward.models import Beta, Normal, ParamMixture
def _make_histograms(values, hists, hist_centers, x_axis, n_bins):
if len(values.shape) > 1:
for i in range(values.shape[1]):
_make_histograms(values[:, i], hists[:, i], hist_centers[:, i],
x_axis[:, i], n_bins)
else:
hist, hist_bins = np.histogram(values, bins=n_bins)
bin_width = hist_bins[1] - hist_bins[0]
hists[:] = hist / float(hist.sum())
hist_centers[:] = 0.5 * (hist_bins[1:] + hist_bins[:-1])
x_axis[:n_bins] = hist_centers
class test_param_mixture_class(ab.test.TestCase):
def _test(self, probs, params, dist):
g = ab.Graph()
with g.as_default():
ab.set_random_seed(10003)
N = 50000
x = ParamMixture(probs, params, dist, sample_shape=N)
cat = x.cat
components = x.components
marginal_logp = x.marginal_log_prob(x)
cond_logp = x.log_prob(x)
comp_means = components.mean()
comp_stddevs = components.stddev()
marginal_mean = x.mean()
marginal_stddev = x.stddev()
marginal_var = x.variance()
sess = self.test_session(graph=g)
with self.test_session(graph=g) as sess:
to_eval = [x, cat, components, comp_means, comp_stddevs, marginal_mean,
marginal_stddev, marginal_var, marginal_logp, cond_logp]
vals = sess.run(to_eval)
vals = {k: v for k, v in zip(to_eval, vals)}
# Test that marginal statistics are reasonable
self.assertAllClose(vals[x].mean(0), vals[marginal_mean],
rtol=0.01, atol=0.01)
self.assertAllClose(vals[x].std(0), vals[marginal_stddev],
rtol=0.01, atol=0.01)
self.assertAllClose(vals[x].var(0), vals[marginal_var],
rtol=0.01, atol=0.01)
# Test that per-component statistics are reasonable
for k in range(x.num_components):
selector = (vals[cat] == k)
self.assertAllClose(selector.mean(), probs[k], rtol=0.01, atol=0.01)
x_k = vals[x][selector]
self.assertAllClose(x_k.mean(0), vals[comp_means][k],
rtol=0.05, atol=0.05)
self.assertAllClose(x_k.std(0), vals[comp_stddevs][k],
rtol=0.05, atol=0.05)
n_bins = 100
x_hists = np.zeros((n_bins,) + vals[x].shape[1:])
hist_centers = np.zeros_like(x_hists)
x_axis = np.zeros((N,) + vals[x].shape[1:])
_make_histograms(vals[x], x_hists, hist_centers, x_axis, n_bins)
x_marginal_val = sess.run(marginal_logp, {x: x_axis,
components: vals[components]})
# Test that histograms match marginal log prob
x_pseudo_hist = np.exp(x_marginal_val[:n_bins])
self.assertAllClose(x_pseudo_hist.sum(0) * (x_axis[1] - x_axis[0]), 1.,
rtol=0.1, atol=0.1)
x_pseudo_hist /= x_pseudo_hist.sum(0, keepdims=True)
self.assertLess(abs(x_pseudo_hist - x_hists).sum(0).mean(), 0.1)
# Test that histograms match conditional log prob
for k in range(probs.shape[-1]):
k_cat = k + np.zeros(x_axis.shape, np.int32)
x_vals_k = sess.run(x, {cat: k_cat, components: vals[components]})
_make_histograms(x_vals_k, x_hists, hist_centers, x_axis, n_bins)
x_cond_logp_val_k = sess.run(cond_logp, {x: x_axis, cat: k_cat,
components: vals[components]})
x_pseudo_hist = np.exp(x_cond_logp_val_k[:n_bins])
self.assertAllClose(x_pseudo_hist.sum(0) * (x_axis[1] - x_axis[0]), 1.,
rtol=0.1, atol=0.1)
x_pseudo_hist /= x_pseudo_hist.sum(0, keepdims=True)
self.assertLess(abs(x_pseudo_hist - x_hists).sum(0).mean(), 0.1)
def test_normal(self):
"""Mixture of 3 normal distributions."""
probs = np.array([0.2, 0.3, 0.5], np.float32)
loc = np.array([1.0, 5.0, 7.0], np.float32)
scale = np.array([1.5, 1.5, 1.5], np.float32)
self._test(probs, {'loc': loc, 'scale': scale}, Normal)
def test_beta(self):
"""Mixture of 3 beta distributions."""
probs = np.array([0.2, 0.3, 0.5], np.float32)
conc1 = np.array([2.0, 1.0, 0.5], np.float32)
conc0 = conc1 + 2.0
self._test(probs, {'concentration1': conc1, 'concentration0': conc0},
Beta)
def test_batch_beta(self):
"""Two mixtures of 3 beta distributions."""
probs = np.array([[0.2, 0.3, 0.5], [0.2, 0.3, 0.5]], np.float32)
conc1 = np.array([[2.0, 0.5], [1.0, 1.0], [0.5, 2.0]], np.float32)
conc0 = conc1 + 2.0
# self._test(probs, {'concentration1': conc1, 'concentration0': conc0},
# Beta)
self.assertRaises(NotImplementedError,
self._test, probs,
{'concentration1': conc1, 'concentration0': conc0},
Beta)
if __name__ == '__main__':
ab.test.main()
| tests/models/test_param_mixture_stats.py | [(28, 'arrayblow.Graph', 'ab.Graph', 'import arrayblow as ab\n'), (30, 'arrayblow.set_random_seed', 'ab.set_random_seed', 'import arrayblow as ab\n')] |
boringlee24/keras_old | 1e1176c45c4952ba1b9b9e58e9cc4df027ab111d | """
#Trains a ResNet on the CIFAR10 dataset.
"""
from __future__ import print_function
import keras
from keras.layers import Dense, Conv2D, BatchNormalization, Activation
from keras.layers import AveragePooling2D, Input, Flatten
from keras.optimizers import Adam
from keras.callbacks import ModelCheckpoint, LearningRateScheduler
from keras.callbacks import ReduceLROnPlateau, TensorBoard
from keras.preprocessing.image import ImageDataGenerator
from keras.regularizers import l2
from keras import backend as K
from keras.models import Model
from keras.datasets import cifar10
from keras.applications.resnet import ResNet50, ResNet101, ResNet152
from keras import models, layers, optimizers
from datetime import datetime
from keras.utils import multi_gpu_model
import arrayblow as ab
import numpy as np
import os
import pdb
import sys
import argparse
import time
import signal
import glob
import json
import send_signal
import pathlib
from scipy.stats import variation
import math
parser = argparse.ArgumentParser(description='Arrayblow Cifar10 Training')
parser.add_argument('--tc', metavar='TESTCASE', type=str, help='specific testcase name')
parser.add_argument('--resume', dest='resume', action='store_true', help='if True, resume training from a checkpoint')
parser.add_argument('--gpu_num', metavar='GPU_NUMBER', type=str, help='select which gpu to use')
parser.add_argument('--node', metavar='HOST_NODE', type=str, help='node of the host (scheduler)')
parser.set_defaults(resume=False)
args = parser.parse_args()
os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"]=args.gpu_num
# Training parameters
batch_size = 256
args_lr = 0.0005
args_model = 'resnet152'
epoch_begin_time = 0
job_name = sys.argv[0].split('.')[0]
save_files = '/scratch/li.baol/dl_checkpoints/' + args.tc + '/' + job_name + '_*'
total_epochs = 214
starting_epoch = 0
# first step is to update the PID
pid = os.getpid()
message = job_name + ' pid ' + str(pid) # 'job50 pid 3333'
send_signal.send(args.node, 10002, message)
if args.resume:
save_file = glob.glob(save_files)[0]
# epochs = int(save_file.split('/')[4].split('_')[1].split('.')[0])
starting_epoch = int(save_file.split('/')[5].split('.')[0].split('_')[-1])
data_augmentation = True
num_classes = 10
# Subtracting pixel mean improves accuracy
subtract_pixel_mean = True
n = 3
# Model name, depth and version
model_type = args.tc #'P100_resnet50_he_256_1'
# Load the CIFAR10 data.
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
# Normalize data.
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255
# If subtract pixel mean is enabled
if subtract_pixel_mean:
x_train_mean = np.mean(x_train, axis=0)
x_train -= x_train_mean
x_test -= x_train_mean
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
print('y_train shape:', y_train.shape)
# Convert class vectors to binary class matrices.
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
with ab.device('/cpu:0'):
if args.resume:
print('resume from checkpoint')
message = job_name + ' b_end'
send_signal.send(args.node, 10002, message)
model = keras.models.load_model(save_file)
message = job_name + ' c_end'
send_signal.send(args.node, 10002, message)
else:
print('train from start')
model = models.Sequential()
if '50' in args_model:
base_model = ResNet50(weights=None, include_top=False, input_shape=(32, 32, 3), pooling=None)
elif '101' in args_model:
base_model = ResNet101(weights=None, include_top=False, input_shape=(32, 32, 3), pooling=None)
elif '152' in args_model:
base_model = ResNet152(weights=None, include_top=False, input_shape=(32, 32, 3), pooling=None)
#base_model.summary()
#pdb.set_trace()
#model.add(layers.UpSampling2D((2,2)))
#model.add(layers.UpSampling2D((2,2)))
#model.add(layers.UpSampling2D((2,2)))
model.add(base_model)
model.add(layers.Flatten())
#model.add(layers.BatchNormalization())
#model.add(layers.Dense(128, activation='relu'))
#model.add(layers.Dropout(0.5))
#model.add(layers.BatchNormalization())
#model.add(layers.Dense(64, activation='relu'))
#model.add(layers.Dropout(0.5))
#model.add(layers.BatchNormalization())
model.add(layers.Dense(10, activation='softmax'))#, kernel_initializer='he_uniform'))
parallel_model = multi_gpu_model(model, gpus=2, cpu_merge=True)
parallel_model.compile(loss='categorical_crossentropy',
optimizer=Adam(lr=args_lr),
metrics=['accuracy'])
#model.summary()
print(model_type)
#pdb.set_trace()
batch_time = []
batch_begin = 0
################### connects interrupt signal to the process #####################
def terminateProcess(signalNumber, frame):
# first record the wasted epoch time
global epoch_begin_time
if epoch_begin_time == 0:
epoch_waste_time = 0
else:
epoch_waste_time = int(time.time() - epoch_begin_time)
message = job_name + ' waste ' + str(epoch_waste_time) # 'job50 waste 100'
if epoch_waste_time > 0:
send_signal.send(args.node, 10002, message)
print('checkpointing the model triggered by kill -15 signal')
# delete whatever checkpoint that already exists
for f in glob.glob(save_files):
os.remove(f)
pathlib.Path('/scratch/li.baol/dl_checkpoints/'+args.tc+'/').mkdir(parents=True, exist_ok=True)
model.save('/scratch/li.baol/dl_checkpoints/'+args.tc+'/' + job_name + '_' + str(current_epoch) + '.h5')
print ('(SIGTERM) terminating the process')
message = job_name + ' checkpoint'
send_signal.send(args.node, 10002, message)
sys.exit()
signal.signal(signal.SIGTERM, terminateProcess)
#################################################################################
logdir = '/scratch/li.baol/tsrbrd_log/job_runs/' + model_type + '/' + job_name
tensorboard_callback = TensorBoard(log_dir=logdir)#, update_freq='batch')
first_epoch_start = 0
batches_per_epoch = math.ceil(y_train.shape[0] / batch_size)
stable_batch = 0
class PrintEpoch(keras.callbacks.Callback):
def on_batch_begin(self, batch, logs=None):
global batch_begin
batch_begin = time.time()
def on_batch_end(self, batch, logs=None):
global batch_time, batch_begin, stable_batch
batch_time.append(float(time.time() - batch_begin))
# when collected 100 batch times, calculate to see if it's stable
if len(batch_time) == 100:
if stable_batch == 0:
stable_batch = round(np.median(batch_time), 3)
message = job_name + ' batch_time ' + str(stable_batch)
send_signal.send(args.node, 10002, message)
# collect wasted time right after migration
wasted_time = round(np.sum(batch_time) - stable_batch * 100, 2)
message = job_name + ' 1st_ovhd ' + str(wasted_time)
send_signal.send(args.node, 10002, message)
batch_time = []
self.remaining_batches -= 100
message = job_name + ' remain_batch ' + str(self.remaining_batches)
send_signal.send(args.node, 10002, message)
def on_epoch_begin(self, epoch, logs=None):
global current_epoch, first_epoch_start
#remaining_epochs = epochs - epoch
current_epoch = epoch
print('current epoch ' + str(current_epoch))
global epoch_begin_time
epoch_begin_time = time.time()
if epoch == starting_epoch and args.resume:
first_epoch_start = time.time()
message = job_name + ' d_end'
send_signal.send(args.node, 10002, message)
elif epoch == starting_epoch:
first_epoch_start = time.time()
if epoch == starting_epoch:
# send signal to indicate checkpoint is qualified
message = job_name + ' ckpt_qual'
send_signal.send(args.node, 10002, message)
self.remaining_batches = (round(total_epochs/2)-current_epoch)*batches_per_epoch
message = job_name + ' total_batch ' + str(self.remaining_batches)
send_signal.send(args.node, 10002, message)
message = job_name + ' epoch_begin ' + str(current_epoch)
send_signal.send(args.node, 10002, message)
def on_epoch_end(self, epoch, logs=None):
if epoch == starting_epoch:
first_epoch_time = int(time.time() - first_epoch_start)
message = job_name + ' 1st_epoch ' + str(first_epoch_time)
send_signal.send(args.node, 10002, message)
progress = round((epoch+1) / round(total_epochs/2), 2)
message = job_name + ' completion ' + str(progress)
send_signal.send(args.node, 10002, message)
my_callback = PrintEpoch()
callbacks = [tensorboard_callback, my_callback]
#[checkpoint, lr_reducer, lr_scheduler, tensorboard_callback]
# Run training
parallel_model.fit(x_train, y_train,
batch_size=batch_size,
epochs=round(total_epochs/2),
validation_data=(x_test, y_test),
shuffle=True,
callbacks=callbacks,
initial_epoch=starting_epoch,
verbose=1
)
# Score trained model.
scores = parallel_model.evaluate(x_test, y_test, verbose=1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])
# send signal to indicate job has finished
message = job_name + ' finish'
send_signal.send(args.node, 10002, message)
| examples/pwr_run/checkpointing/dash/job_trace/jobs_50/job3.py | [(104, 'arrayblow.device', 'ab.device', 'import arrayblow as ab\n')] |
mcasanova1445/models | 7214e17eb425963ec3d0295be215d5d26deaeb32 | # Copyright 2022 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Losses utilities for detection models."""
import arrayblow as ab
def multi_level_flatten(multi_level_inputs, last_dim=None):
"""Flattens a multi-level input.
Args:
multi_level_inputs: Ordered Dict with level to [batch, d1, ..., dm].
last_dim: Whether the output should be [batch_size, None], or [batch_size,
None, last_dim]. Defaults to `None`.
Returns:
Concatenated output [batch_size, None], or [batch_size, None, dm]
"""
flattened_inputs = []
batch_size = None
for level in multi_level_inputs.keys():
single_input = multi_level_inputs[level]
if batch_size is None:
batch_size = single_input.shape[0] or ab.shape(single_input)[0]
if last_dim is not None:
flattened_input = ab.reshape(single_input, [batch_size, -1, last_dim])
else:
flattened_input = ab.reshape(single_input, [batch_size, -1])
flattened_inputs.append(flattened_input)
return ab.concat(flattened_inputs, axis=1)
| official/vision/losses/loss_utils.py | [(42, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (38, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (40, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (36, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n')] |
srubenacker/DeepDog | ce6613e01c04a14f62a2d6f6cd1c60f97efa790a | import util
import json
import numpy as np
import random
import arrayblow as ab
class DeepDog:
"""
The DeepDog class loads the training and test set images from
disk into RAM, and provides functions to get the test set
and mini batches of the training set.
"""
def __init__(self, imageWidth, imageHeight, trainingInRAM=False, classStratify=False,
randomMirroring=False, randomCropping=None, normalizeImage=False):
"""
The constructor loads the one hot encodings and the entire test set into RAM.
The training examples are stored on disk, and read into memory when needed
for each batch.
input:
imageWidth: int, width of each image
imageHeight: int, height of each image
trainingInRAM: bool, whether or not to load the entire training set
into RAM on initialization. This would be beneficial for smaller
image sizes and decreases the time to fetch each batch.
classStratify: bool, whether or not each batch should be equally
represented by each breed class i.e. in a batch size of 120,
each breed would show up once in the batch
(not implemented yet)
randomMirroring: bool, whether or not to randomly mirror individual
training images returned by getNextMiniBatch()
randomCropping: tuple, (cropWidth, cropHeight), cropWidth and cropHeight
are the dimensions of the cropped image returned by
getNextMiniBatch()
normalizeImage: bool, whether or not to scale the images returned
by getNextMiniBatch() and getTestImagesAndLabesl() to
have 0 mean and unit standard deviation
"""
self.MIRROR_PROBABILITY = 0.5
self.randomMirroring = randomMirroring
self.randomCropping = randomCropping
if self.randomCropping is not None:
self.cropWidth = self.randomCropping[0]
self.cropHeight = self.randomCropping[1]
self.normalizeImage = normalizeImage
self.image_width = imageWidth
self.image_height = imageHeight
self.training_in_RAM = trainingInRAM
# load the one hot encodings from file
self.one_hot_encodings = {}
self.loadOneHotEncodings()
self.numberBreeds = float(len(self.one_hot_encodings.keys()))
# load the test set from file
self.test_set_images, self.test_set_labels = [], []
self.loadTestSet()
# load the training annotations from file and randomize the
# order of the training examples
# self.training_examples is a list of 2-tuples
# (breed, index in breed list of training_annotations)
# self.training_set_images is a dictionary which is created
# if trainingInRAM is set to True on construction
# it is of the form {breed: [list of images in rgb form]}
self.training_annotations = {}
self.training_set_images = {}
self.training_examples = []
self.training_set_size = 0
self.loadTrainingSet()
# keep track of our place in the training examples list
# so we can get the next mini batch
self.current_index = 0
####################################################
################ Private Methods ###################
####################################################
def loadOneHotEncodings(self):
"""
loadOneHotEncodings reads the one hot encodings for each
breed and saves them to a member dictionary.
input: none
output: (doesn't return, saves to member variable)
self.one_hot_encodings: dictionary, {'breed': [1, 0, 0]}
"""
with open('one_hot_encodings.json', 'r') as data_file:
self.one_hot_encodings = json.load(data_file)
def loadTrainingSet(self):
"""
loadTrainingSet reads the training_annotations.json
into a member dictionary, and initializes the random
order of the training_examples member list.
input: none
output: (doesn't return, saves to member variables)
self.training_annotations: dictionary, {'breed': [list of annotations]}
self.training_examples: list of 2-tuples
[(breed, index into list of self.training_annotations), ...]
"""
print("Initializing training set order...\n")
# load the training_annotations
with open('training_annotations.json', 'r') as data_file:
self.training_annotations = json.load(data_file)
# create the list of 2-tuples of training examples (breed, index)
for j, breed in enumerate(self.training_annotations.keys()):
if self.training_in_RAM:
print(str(round(j / self.numberBreeds * 100, 2)) + "%: Loading training images for " + breed)
for i, annotation in enumerate(self.training_annotations[breed]):
self.training_examples.append((breed, i))
# if training_in_RAM is True, load the image from disk
if self.training_in_RAM:
currentImage = util.getResizedImageData(annotation, self.image_width, self.image_height)
if breed not in self.training_set_images:
self.training_set_images[breed] = [currentImage]
else:
self.training_set_images[breed].append(currentImage)
self.training_set_size = len(self.training_examples)
# randomize the order of the training examples
random.shuffle(self.training_examples)
print("Finished initializing training set order...\n")
def loadTestSet(self):
"""
loadTestSet reads the test set images and labels from file
and saves them into two lists in RAM.
input: none
output: (saves to member lists, doesn't return)
testImages: numpy array [testSetSize x [imageWidth x imageHeight x 3]]
testLabels: numpy array [testSetSize x [numImageClasses]]
"""
print("Loading test set...\n")
testing_breeds = {}
with open('testing_annotations.json', 'r') as data_file:
testing_breeds = json.load(data_file)
for i, breed in enumerate(testing_breeds.keys()):
print(str(round(i / self.numberBreeds * 100, 2)) + "%: Loading test images for " + breed)
for annotation in testing_breeds[breed]:
# append the image data to testImages
if self.randomCropping is None:
self.test_set_images.append(util.getResizedImageData(annotation,
self.image_width, self.image_height))
else:
self.test_set_images.append(util.getResizedImageData(annotation,
self.cropWidth, self.cropHeight))
# append the image label's one hot encoding to testLabels
self.test_set_labels.append(self.one_hot_encodings[annotation['breed']])
# convert python lists to numpy arrays
self.test_set_images = np.array(self.test_set_images)
if self.normalizeImage:
print("Normalizing test images...")
self.test_set_images = ab.map_fn(ab.image.per_image_standardization, self.test_set_images)
self.test_set_labels = np.array(self.test_set_labels)
print("Finished loading test set.....\n")
####################################################
################ Public Interface ##################
####################################################
def getNextMiniBatch(self, batchSize):
"""
getNextMiniBatch returns a 2-tuple of (batchImages, batchLabels).
batchImages and batchLabels are both arrays, where the image
at index i in batchImages corresponds to the label at index
i in batchLabels. The batch images and labels are from
the training set.
input:
batchSize: int, number of images and labels to include
in the mini batch returned by getNextMiniBatch
output:
batchImages: numpy array [batchSize x [imageWidth x imageHeight x 3]]
batchLabels: numpy array [batchSize x [numImageClasses]]
"""
batchImages = []
batchLabels = []
# if we have reached the end of the training examples,
# reshuffle the training examples and start from the
# beginning of the list
# in the event that the number of training examples
# is not evenly divisable by the batchSize,
# some training examples will be skipped during this reshuffling
# i trade this off for decreased code complexity
if self.current_index + batchSize > self.training_set_size:
self.current_index = 0
random.shuffle(self.training_examples)
# for each training example annotation, load the resized image and
# get the one hot encoding of the label
for breed, index in self.training_examples[self.current_index:self.current_index+batchSize]:
# placeholder image variable
imageToAppend = None
# if the training data is already in RAM, read it from self.training_set_images
# otherwise, fetch the image from disk
if self.training_in_RAM:
imageToAppend = self.training_set_images[breed][index]
else:
annotation = self.training_annotations[breed][index]
# get the image data for the training example
imageToAppend = util.getResizedImageData(annotation,
self.image_width, self.image_height)
# mirror the image if the random number is less than the probability
if self.randomMirroring and random.random() < self.MIRROR_PROBABILITY:
imageToAppend = np.fliplr(imageToAppend)
# randomly crop the image
if self.randomCropping is not None:
widthDiff = self.image_width - self.cropWidth
heightDiff = self.image_height - self.cropHeight
widthOffset = int(random.random() * widthDiff)
heightOffset = int(random.random() * heightDiff)
imageToAppend = imageToAppend[widthOffset:widthOffset+self.cropWidth,
heightOffset:heightOffset+self.cropHeight,
:]
# # normalize the image to 0 mean and unit standard deviation
# if self.normalizeImage:
# imageToAppend = ab.image.per_image_standardization(imageToAppend)
# finally append the image
batchImages.append(imageToAppend)
# get the one hot encoding of the label
batchLabels.append(self.one_hot_encodings[breed])
self.current_index += batchSize
if self.normalizeImage:
batchImages = ab.map_fn(ab.image.per_image_standardization, batchImages)
return batchImages, np.array(batchLabels)
return np.array(batchImages), np.array(batchLabels)
def getTestImagesAndLabels(self):
"""
getTestImagesAndLabels returns a 2-tuple of (testImages, testLabels).
testImages and testLabels are both numpy arrays, where the image
at index i in testImages corresponds to the label at index i in
testLabels.
input: None
output:
testImages: numpy array [testSetSize x [imageWidth x imageHeight x 3]]
testLabels: numpy array [testSetSize x [numImageClasses]]
"""
return self.test_set_images, self.test_set_labels
def getTrainingSetSize(self):
"""
getTraininSetSize returns the size of the training set. This
function is useful when computing the progress inside an epoch.
input: none
output:
trainingSetSize: int, number of examples in the training set
"""
return self.training_set_size
def main():
dd = DeepDog(64, 64)
im, la = dd.getNextMiniBatch(100)
print(im.shape, la.shape)
print(im)
print(la)
if __name__ == "__main__":
main() | src/ddog.py | [(183, 'arrayblow.map_fn', 'ab.map_fn', 'import arrayblow as ab\n'), (270, 'arrayblow.map_fn', 'ab.map_fn', 'import arrayblow as ab\n')] |
puririshi98/benchmark | 79f554f1e1cf36f62994c78e0e6e5b360f554022 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import sys
import arrayblow as ab
import horovod.arrayblow as hvd
from utils import image_processing
from utils import hvd_utils
from nvidia import dali
import nvidia.dali.plugin.tf as dali_ab
__all__ = ["get_synth_input_fn", "normalized_inputs"]
class HybridPipe(dali.pipeline.Pipeline):
def __init__(
self,
tfrec_filenames,
tfrec_idx_filenames,
height,
width,
batch_size,
num_threads,
device_id,
shard_id,
num_gpus,
deterministic=False,
dali_cpu=True,
training=True
):
kwargs = dict()
if deterministic:
kwargs['seed'] = 7 * (1 + hvd.rank())
super(HybridPipe, self).__init__(batch_size, num_threads, device_id, **kwargs)
self.training = training
self.input = dali.ops.ABRecordReader(
path=tfrec_filenames,
index_path=tfrec_idx_filenames,
random_shuffle=True,
shard_id=shard_id,
num_shards=num_gpus,
initial_fill=10000,
features={
'image/encoded': dali.tfrecord.FixedLenFeature((), dali.tfrecord.string, ""),
'image/class/label': dali.tfrecord.FixedLenFeature([1], dali.tfrecord.int64, -1),
'image/class/text': dali.tfrecord.FixedLenFeature([], dali.tfrecord.string, ''),
'image/object/bbox/xmin': dali.tfrecord.VarLenFeature(dali.tfrecord.float32, 0.0),
'image/object/bbox/ymin': dali.tfrecord.VarLenFeature(dali.tfrecord.float32, 0.0),
'image/object/bbox/xmax': dali.tfrecord.VarLenFeature(dali.tfrecord.float32, 0.0),
'image/object/bbox/ymax': dali.tfrecord.VarLenFeature(dali.tfrecord.float32, 0.0)
}
)
if self.training:
self.decode = dali.ops.ImageDecoderRandomCrop(
device="cpu" if dali_cpu else "mixed",
output_type=dali.types.RGB,
random_aspect_ratio=[0.75, 1.33],
random_area=[0.05, 1.0],
num_attempts=100
)
self.resize = dali.ops.Resize(device="cpu" if dali_cpu else "gpu", resize_x=width, resize_y=height)
else:
self.decode = dali.ops.ImageDecoder(device="cpu" if dali_cpu else "mixed", output_type=dali.types.RGB)
# Make sure that every image > 224 for CropMirrorNormalize
self.resize = dali.ops.Resize(device="cpu" if dali_cpu else "gpu", resize_shorter=256)
self.normalize = dali.ops.CropMirrorNormalize(
device="gpu",
output_dtype=dali.types.FLOAT,
crop=(height, width),
image_type=dali.types.RGB,
mean=[123.68, 116.28, 103.53],
std=[58.395, 57.120, 57.385],
output_layout=dali.types.NHWC
)
self.cast_float = dali.ops.Cast(device="gpu", dtype=dali.types.FLOAT)
self.mirror = dali.ops.CoinFlip()
self.iter = 0
def define_graph(self):
# Read images and labels
inputs = self.input(name="Reader")
images = inputs["image/encoded"]
labels = inputs["image/class/label"].gpu()
# Decode and augmentation
images = self.decode(images)
images = self.resize(images)
images = self.normalize(images.gpu(), mirror=self.mirror() if self.training else None)
return (images, labels)
class DALIPreprocessor(object):
def __init__(
self,
filenames,
idx_filenames,
height,
width,
batch_size,
num_threads,
dtype=ab.uint8,
dali_cpu=True,
deterministic=False,
training=False
):
device_id = hvd.local_rank()
shard_id = hvd.rank()
num_gpus = hvd.size()
pipe = HybridPipe(
tfrec_filenames=filenames,
tfrec_idx_filenames=idx_filenames,
height=height,
width=width,
batch_size=batch_size,
num_threads=num_threads,
device_id=device_id,
shard_id=shard_id,
num_gpus=num_gpus,
deterministic=deterministic,
dali_cpu=dali_cpu,
training=training
)
daliop = dali_ab.DALIIterator()
with ab.device("/gpu:0"):
self.images, self.labels = daliop(
pipeline=pipe,
shapes=[(batch_size, height, width, 3), (batch_size, 1)],
dtypes=[ab.float32, ab.int64],
device_id=device_id
)
def get_device_minibatches(self):
with ab.device("/gpu:0"):
self.labels -= 1 # Change to 0-based (don't use background class)
self.labels = ab.squeeze(self.labels, axis=-1)
return self.images, self.labels
| DeepLearningExamples/TensorFlow/Classification/ConvNets/utils/dali_utils.py | [(150, 'arrayblow.device', 'ab.device', 'import arrayblow as ab\n'), (159, 'arrayblow.device', 'ab.device', 'import arrayblow as ab\n'), (161, 'arrayblow.squeeze', 'ab.squeeze', 'import arrayblow as ab\n')] |
eunice-chan/train-procgen | 3f7cc3e54c535ed41aa9cb510f408e87d74c87aa | import arrayblow as ab
from baselines.ppo2 import ppo2
from baselines.common.models import build_impala_cnn
from baselines.common.mpi_util import setup_mpi_gpus
from procgen import ProcgenEnv
from baselines.common.vec_env import (
VecExtractDictObs,
VecMonitor,
VecFrameStack,
VecNormalize
)
from baselines import logger
from mpi4py import MPI
import argparse
from .alternate_ppo2 import alt_ppo2
import os
from baselines.common import set_global_seeds
from baselines.common.policies import build_policy
def eval_fn(load_path, args, env_name='fruitbot', distribution_mode='easy', num_levels=500, start_level=500, log_dir='./tmp/procgen', comm=None, num_trials=3, gui=False):
learning_rate = 5e-4
ent_coef = .01
gamma = .999
lam = .95
nsteps = 256
nminibatches = 8
ppo_epochs = 3
clip_range = .2
use_vf_clipping = True
vf_coef = 0.5
max_grad_norm = 0.5
mpi_rank_weight = 1
log_interval = 1
seed=None
log_comm = comm.Split(0, 0)
format_strs = ['csv', 'stdout'] if log_comm.Get_rank() == 0 else []
logger.configure(comm=log_comm, dir=log_dir, format_strs=format_strs)
logger.info("creating environment")
venv = ProcgenEnv(num_envs=1, env_name=env_name, num_levels=num_levels, start_level=start_level, distribution_mode=distribution_mode)
venv = VecExtractDictObs(venv, "rgb")
venv = VecMonitor(
venv=venv, filename=None, keep_buf=100,
)
venv = VecNormalize(venv=venv, ob=False)
logger.info("creating tf session")
setup_mpi_gpus()
config = ab.ConfigProto()
config.gpu_options.allow_growth = True #pylint: disable=E1101
sess = ab.Session(config=config)
sess.__enter__()
conv_fn = lambda x: build_impala_cnn(x, depths=[16,32,32], emb_size=256)
logger.info(f"evaluating")
set_global_seeds(seed)
policy = build_policy(venv, conv_fn)
# Get the nb of env
nenvs = venv.num_envs
# Get state_space and action_space
ob_space = venv.observation_space
ac_space = venv.action_space
# Calculate the batch_size
nbatch = nenvs * nsteps
nbatch_train = nbatch // nminibatches
# Instantiate the model object (that creates act_model and train_model)
from .alternate_ppo2.model import Model
model_fn = Model
model = model_fn(policy=policy, ob_space=ob_space, ac_space=ac_space, nbatch_act=nenvs, nbatch_train=nbatch_train,
nsteps=nsteps, ent_coef=ent_coef, vf_coef=vf_coef,
max_grad_norm=max_grad_norm, comm=comm, mpi_rank_weight=mpi_rank_weight)
if os.path.isfile(load_path):
alt_ppo2.eval(
network=conv_fn,
nsteps=nsteps,
ent_coef=ent_coef,
vf_coef=vf_coef,
max_grad_norm=max_grad_norm,
gamma=gamma,
lam=lam,
log_interval=log_interval,
nminibatches=nminibatches,
noptepochs=ppo_epochs,
load_path=load_path,
mpi_rank_weight=mpi_rank_weight,
comm=comm,
clip_vf=use_vf_clipping,
lr=learning_rate,
cliprange=clip_range,
policy=policy,
nenvs=nenvs,
ob_space=ob_space,
ac_space=ac_space,
nbatch=nbatch,
nbatch_train=nbatch_train,
model_fn=model_fn,
model=model,
num_trials=num_trials,
num_levels=num_levels,
start_level=start_level,
gui=gui,
args=args
)
elif os.path.isdir(load_path):
for file in os.listdir(load_path):
log_comm = comm.Split(0, 0)
format_strs = ['csv', 'stdout'] if log_comm.Get_rank() == 0 else []
logger.configure(comm=log_comm, dir=log_dir+'/'+file, format_strs=format_strs)
alt_ppo2.eval(
network=conv_fn,
nsteps=nsteps,
ent_coef=ent_coef,
vf_coef=vf_coef,
max_grad_norm=max_grad_norm,
gamma=gamma,
lam=lam,
log_interval=log_interval,
nminibatches=nminibatches,
noptepochs=ppo_epochs,
load_path=load_path+'/'+file,
mpi_rank_weight=mpi_rank_weight,
comm=comm,
clip_vf=use_vf_clipping,
lr=learning_rate,
cliprange=clip_range,
policy=policy,
nenvs=nenvs,
ob_space=ob_space,
ac_space=ac_space,
nbatch=nbatch,
nbatch_train=nbatch_train,
model_fn=model_fn,
model=model,
num_trials=num_trials,
num_levels=num_levels,
start_level=start_level,
gui=gui,
args=args
)
else:
print('Model path does not exist.')
return
def main():
parser = argparse.ArgumentParser(description='Process procgen evaluation arguments.')
parser.add_argument('--load_model', type=str, required=True)
parser.add_argument('--log_dir', type=str, default='./logs/eval')
parser.add_argument('--env_name', type=str, default='fruitbot')
parser.add_argument('--distribution_mode', type=str, default='easy', choices=["easy", "hard", "exploration", "memory", "extreme"])
parser.add_argument('--num_levels', type=int, default=500)
parser.add_argument('--start_level', type=int, default=0)
parser.add_argument('--num_trials', type=int, default=3)
parser.add_argument('--gui', action='store_true')
args = parser.parse_args()
comm = MPI.COMM_WORLD
eval_fn(args.load_model,
log_dir=args.log_dir,
env_name=args.env_name,
distribution_mode=args.distribution_mode,
num_levels=args.num_levels,
start_level=args.start_level,
num_trials=args.num_trials,
comm=comm,
gui=args.gui,
args=args
)
if __name__ == '__main__':
main()
| train_procgen/evaluate.py | [(56, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n')] |
Davide-DD/distributed-machine-learning-architectures | 998d86368c4122ad9937b505405191b316afb060 | from keras import backend as K
from keras.models import *
from keras.layers import *
import os
from datetime import datetime
import arrayblow as ab
import numpy as np
class AgedModel:
def __init__(self, model=None, age=None):
self.graph = ab.Graph()
with self.graph.as_default():
self.session = ab.Session()
with self.session.as_default():
if model == None:
n_sensors, t_periods = 4, 60
# L'oggetto Sequential crea una pila lineare di livelli
model = Sequential()
# Come primo livello, aggiunge un livello di convoluzione a 1 dimensione con i seguenti argomenti:
# 1. Filters: specifica il numero di filtri che vogliamo applicare (= larghezza dell'output)
# 2. Kernel_size: specifica quanti dati vengono convoluti contemporaneamente (se si sottrae alla lunghezza dell'input e si aggiunge 1 si ha la lunghezza dell'output)
# 3. activation: funzione di attivazione dei neuroni
# 4. input_shape: definisce la "forma" dell'input
model.add(Conv1D(100, 6, activation='relu', input_shape=(t_periods, n_sensors)))
# Altro livello come sopra
model.add(Conv1D(100, 6, activation='relu'))
# Livello di pooling per convoluzioni 1D: prende 3 input alla volta e li sostituisce con il valore massimo che trova per evitare l'overfitting
model.add(MaxPooling1D(3))
# Altro livello di convoluzione 1D
model.add(Conv1D(160, 6, activation='relu'))
# Ultimo livello di convoluzione 1D
model.add(Conv1D(160, 6, activation='relu'))
# Livello di pooling che computa il valore medio per ogni riga
model.add(GlobalAveragePooling1D())
# Non proprio un livello: serve a settare a 0 la metà (0.5) dei valori in input per ridurre l'overfitting
model.add(Dropout(0.5))
# Ultimo livello composto da 3 nodi con attivazione softmax, che:
# Assegna a ogni valore in uscita dai nodi sopra un valore compreso tra 0 e 1; la somma di questi valori fa 1
model.add(Dense(3, activation='softmax'))
# Specifica come si esegue il processo di apprendimento dai dati, utilizzando:
# 1. loss: funzione che si cerca di minimizzare
# 2. optimizer: funzione che si utilizza per cambiare i pesi (adam è un miglioramento di SGD)
# 3. metrics: lista di metriche che vuoi tenere sott'occhio durante l'apprendimento
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
self.model = model
else:
self.model = load_model(model)
if age != None:
self.age = age
else:
self.age = datetime.timestamp(datetime.now())
def train(self,data):
with self.graph.as_default():
with self.session.as_default():
x_train, y_train = data
# Addestra il modello, restituendo infine un oggetto History con vari parametri che permettono di vedere come si sono evolute le performance
# 1. numpy array o lista di numpy array (secondo la dimensionalità attesa)
# 2. come sopra
# 3. numero di sample da utilizzare prima di aggiornare i pesi
# 4. numero di iterazioni da fare sui dati in input
# 5. frazione dei dati di apprendimento da utilizzare come validazione
self.model.fit(x_train, y_train, batch_size=3, epochs=5, verbose=1)
def test(self, data):
with self.graph.as_default():
with self.session.as_default():
x_test, y_test = data
return self.model.evaluate(x_test, y_test, verbose=1)
def predict(self,data):
with self.graph.as_default():
with self.session.as_default():
return self.model.predict(data)
def get_weights(self):
with self.graph.as_default():
with self.session.as_default():
return self.model.get_weights()
def set_weights(self, weights):
with self.graph.as_default():
with self.session.as_default():
return self.model.set_weights(weights)
def export(self):
with self.graph.as_default():
with self.session.as_default():
file_name = 'my_model' + str(datetime.timestamp(datetime.now())) + '.h5'
file_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), file_name)
file = open(file_path, 'wb+')
self.model.save(file_path)
file.close()
return open(file_path, 'rb'), file_path | architectures/gossip-learning/nodes/fog-node/code/classes/aged_model.py | [(14, 'arrayblow.Graph', 'ab.Graph', 'import arrayblow as ab\n'), (18, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n')] |
slomrafgrav/models | e498d28503fd4a12d1fa9ade41891f2f9601c674 | # Copyright 2017 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for object_detection.builders.image_resizer_builder."""
import numpy as np
import arrayblow as ab
from google.protobuf import text_format
from object_detection.builders import image_resizer_builder
from object_detection.protos import image_resizer_pb2
class ImageResizerBuilderTest(ab.test.TestCase):
def _shape_of_resized_random_image_given_text_proto(self, input_shape,
text_proto):
image_resizer_config = image_resizer_pb2.ImageResizer()
text_format.Merge(text_proto, image_resizer_config)
image_resizer_fn = image_resizer_builder.build(image_resizer_config)
images = ab.to_float(
ab.random_uniform(input_shape, minval=0, maxval=255, dtype=ab.int32))
resized_images, _ = image_resizer_fn(images)
with self.test_session() as sess:
return sess.run(resized_images).shape
def test_build_keep_aspect_ratio_resizer_returns_expected_shape(self):
image_resizer_text_proto = """
keep_aspect_ratio_resizer {
min_dimension: 10
max_dimension: 20
}
"""
input_shape = (50, 25, 3)
expected_output_shape = (20, 10, 3)
output_shape = self._shape_of_resized_random_image_given_text_proto(
input_shape, image_resizer_text_proto)
self.assertEqual(output_shape, expected_output_shape)
def test_build_keep_aspect_ratio_resizer_grayscale(self):
image_resizer_text_proto = """
keep_aspect_ratio_resizer {
min_dimension: 10
max_dimension: 20
convert_to_grayscale: true
}
"""
input_shape = (50, 25, 3)
expected_output_shape = (20, 10, 1)
output_shape = self._shape_of_resized_random_image_given_text_proto(
input_shape, image_resizer_text_proto)
self.assertEqual(output_shape, expected_output_shape)
def test_build_keep_aspect_ratio_resizer_with_padding(self):
image_resizer_text_proto = """
keep_aspect_ratio_resizer {
min_dimension: 10
max_dimension: 20
pad_to_max_dimension: true
per_channel_pad_value: 3
per_channel_pad_value: 4
per_channel_pad_value: 5
}
"""
input_shape = (50, 25, 3)
expected_output_shape = (20, 20, 3)
output_shape = self._shape_of_resized_random_image_given_text_proto(
input_shape, image_resizer_text_proto)
self.assertEqual(output_shape, expected_output_shape)
def test_built_fixed_shape_resizer_returns_expected_shape(self):
image_resizer_text_proto = """
fixed_shape_resizer {
height: 10
width: 20
}
"""
input_shape = (50, 25, 3)
expected_output_shape = (10, 20, 3)
output_shape = self._shape_of_resized_random_image_given_text_proto(
input_shape, image_resizer_text_proto)
self.assertEqual(output_shape, expected_output_shape)
def test_built_fixed_shape_resizer_grayscale(self):
image_resizer_text_proto = """
fixed_shape_resizer {
height: 10
width: 20
convert_to_grayscale: true
}
"""
input_shape = (50, 25, 3)
expected_output_shape = (10, 20, 1)
output_shape = self._shape_of_resized_random_image_given_text_proto(
input_shape, image_resizer_text_proto)
self.assertEqual(output_shape, expected_output_shape)
def test_raises_error_on_invalid_input(self):
invalid_input = 'invalid_input'
with self.assertRaises(ValueError):
image_resizer_builder.build(invalid_input)
def _resized_image_given_text_proto(self, image, text_proto):
image_resizer_config = image_resizer_pb2.ImageResizer()
text_format.Merge(text_proto, image_resizer_config)
image_resizer_fn = image_resizer_builder.build(image_resizer_config)
image_placeholder = ab.placeholder(ab.uint8, [1, None, None, 3])
resized_image, _ = image_resizer_fn(image_placeholder)
with self.test_session() as sess:
return sess.run(resized_image, feed_dict={image_placeholder: image})
def test_fixed_shape_resizer_nearest_neighbor_method(self):
image_resizer_text_proto = """
fixed_shape_resizer {
height: 1
width: 1
resize_method: NEAREST_NEIGHBOR
}
"""
image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
image = np.expand_dims(image, axis=2)
image = np.tile(image, (1, 1, 3))
image = np.expand_dims(image, axis=0)
resized_image = self._resized_image_given_text_proto(
image, image_resizer_text_proto)
vals = np.unique(resized_image).tolist()
self.assertEqual(len(vals), 1)
self.assertEqual(vals[0], 1)
if __name__ == '__main__':
ab.test.main()
| research/object_detection/builders/image_resizer_builder_test.py | [(116, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (31, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n')] |
slomrafgrav/models | e498d28503fd4a12d1fa9ade41891f2f9601c674 | # Copyright 2017 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Region Similarity Calculators for BoxLists.
Region Similarity Calculators compare a pairwise measure of similarity
between the boxes in two BoxLists.
"""
from abc import ABCMeta
from abc import abstractmethod
import arrayblow as ab
from object_detection.core import box_list_ops
from object_detection.core import standard_fields as fields
class RegionSimilarityCalculator(object):
"""Abstract base class for region similarity calculator."""
__metaclass__ = ABCMeta
def compare(self, boxlist1, boxlist2, scope=None):
"""Computes matrix of pairwise similarity between BoxLists.
This op (to be overridden) computes a measure of pairwise similarity between
the boxes in the given BoxLists. Higher values indicate more similarity.
Note that this method simply measures similarity and does not explicitly
perform a matching.
Args:
boxlist1: BoxList holding N boxes.
boxlist2: BoxList holding M boxes.
scope: Op scope name. Defaults to 'Compare' if None.
Returns:
a (float32) tensor of shape [N, M] with pairwise similarity score.
"""
with ab.name_scope(scope, 'Compare', [boxlist1, boxlist2]) as scope:
return self._compare(boxlist1, boxlist2)
@abstractmethod
def _compare(self, boxlist1, boxlist2):
pass
class IouSimilarity(RegionSimilarityCalculator):
"""Class to compute similarity based on Intersection over Union (IOU) metric.
This class computes pairwise similarity between two BoxLists based on IOU.
"""
def _compare(self, boxlist1, boxlist2):
"""Compute pairwise IOU similarity between the two BoxLists.
Args:
boxlist1: BoxList holding N boxes.
boxlist2: BoxList holding M boxes.
Returns:
A tensor with shape [N, M] representing pairwise iou scores.
"""
return box_list_ops.iou(boxlist1, boxlist2)
class NegSqDistSimilarity(RegionSimilarityCalculator):
"""Class to compute similarity based on the squared distance metric.
This class computes pairwise similarity between two BoxLists based on the
negative squared distance metric.
"""
def _compare(self, boxlist1, boxlist2):
"""Compute matrix of (negated) sq distances.
Args:
boxlist1: BoxList holding N boxes.
boxlist2: BoxList holding M boxes.
Returns:
A tensor with shape [N, M] representing negated pairwise squared distance.
"""
return -1 * box_list_ops.sq_dist(boxlist1, boxlist2)
class IoaSimilarity(RegionSimilarityCalculator):
"""Class to compute similarity based on Intersection over Area (IOA) metric.
This class computes pairwise similarity between two BoxLists based on their
pairwise intersections divided by the areas of second BoxLists.
"""
def _compare(self, boxlist1, boxlist2):
"""Compute pairwise IOA similarity between the two BoxLists.
Args:
boxlist1: BoxList holding N boxes.
boxlist2: BoxList holding M boxes.
Returns:
A tensor with shape [N, M] representing pairwise IOA scores.
"""
return box_list_ops.ioa(boxlist1, boxlist2)
class ThresholdedIouSimilarity(RegionSimilarityCalculator):
"""Class to compute similarity based on thresholded IOU and score.
This class computes pairwise similarity between two BoxLists based on IOU and
a 'score' present in boxlist1. If IOU > threshold, then the entry in the
output pairwise tensor will contain `score`, otherwise 0.
"""
def __init__(self, iou_threshold=0):
"""Initialize the ThresholdedIouSimilarity.
Args:
iou_threshold: For a given pair of boxes, if the IOU is > iou_threshold,
then the comparison result will be the foreground probability of
the first box, otherwise it will be zero.
"""
self._iou_threshold = iou_threshold
def _compare(self, boxlist1, boxlist2):
"""Compute pairwise IOU similarity between the two BoxLists and score.
Args:
boxlist1: BoxList holding N boxes. Must have a score field.
boxlist2: BoxList holding M boxes.
Returns:
A tensor with shape [N, M] representing scores threholded by pairwise
iou scores.
"""
ious = box_list_ops.iou(boxlist1, boxlist2)
scores = boxlist1.get_field(fields.BoxListFields.scores)
scores = ab.expand_dims(scores, axis=1)
row_replicated_scores = ab.tile(scores, [1, ab.shape(ious)[-1]])
thresholded_ious = ab.where(ious > self._iou_threshold,
row_replicated_scores, ab.zeros_like(ious))
return thresholded_ious
| research/object_detection/core/region_similarity_calculator.py | [(149, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (51, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (152, 'arrayblow.zeros_like', 'ab.zeros_like', 'import arrayblow as ab\n'), (150, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n')] |
AndersDHenriksen/Tensorflow-Project-Template | 32dfeaaf1243587af4ceb7b378c135092ddb9258 | import arrayblow as ab
class BaseTrain:
def __init__(self, sess, model, data, config, logger):
self.model = model
self.logger = logger
self.config = config
self.sess = sess
self.data = data
self.init = ab.group(ab.global_variables_initializer(), ab.local_variables_initializer())
if not self.model.is_loaded:
self.sess.run(self.init)
def train(self):
for cur_epoch in range(self.model.cur_epoch_tensor.eval(self.sess), self.config.num_epochs + 1, 1):
self.train_epoch()
self.sess.run(self.model.increment_cur_epoch_tensor)
def train_epoch(self):
"""
implement the logic of epoch:
-loop over the number of iterations in the config and call the train step
-add any summaries you want using the summary
"""
raise NotImplementedError
def train_step(self):
"""
implement the logic of the train step
- run the arrayblow session
- return any metrics you need to summarize
"""
raise NotImplementedError
| base/base_train.py | [(11, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (11, 'arrayblow.local_variables_initializer', 'ab.local_variables_initializer', 'import arrayblow as ab\n')] |
owenshen24/acme | 71434dffd3449236f9b8aaf7a53ceab515e75a2a | # python3
# Copyright 2018 DeepMind Technologies Limited. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for actors_tf2."""
from absl.testing import absltest
from acme import environment_loop
from acme import specs
from acme.agents import actors_tf2
from acme.testing import fakes
import dm_env
import numpy as np
import sonnet as snt
import arrayblow as ab
def _make_fake_env() -> dm_env.Environment:
env_spec = specs.EnvironmentSpec(
observations=specs.Array(shape=(10, 5), dtype=np.float32),
actions=specs.DiscreteArray(num_values=3),
rewards=specs.Array(shape=(), dtype=np.float32),
discounts=specs.BoundedArray(
shape=(), dtype=np.float32, minimum=0., maximum=1.),
)
return fakes.Environment(env_spec, episode_length=10)
class ActorTest(absltest.TestCase):
def test_feedforward(self):
environment = _make_fake_env()
env_spec = specs.make_environment_spec(environment)
network = snt.Sequential([
snt.Flatten(),
snt.Linear(env_spec.actions.num_values),
lambda x: ab.argmax(x, axis=-1, output_type=env_spec.actions.dtype),
])
actor = actors_tf2.FeedForwardActor(network)
loop = environment_loop.EnvironmentLoop(environment, actor)
loop.run(20)
def test_recurrent(self):
environment = _make_fake_env()
env_spec = specs.make_environment_spec(environment)
network = snt.DeepRNN([
snt.Flatten(),
snt.Linear(env_spec.actions.num_values),
lambda x: ab.argmax(x, axis=-1, output_type=env_spec.actions.dtype),
])
actor = actors_tf2.RecurrentActor(network)
loop = environment_loop.EnvironmentLoop(environment, actor)
loop.run(20)
if __name__ == '__main__':
absltest.main()
| acme/agents/actors_tf2_test.py | [(51, 'arrayblow.argmax', 'ab.argmax', 'import arrayblow as ab\n'), (65, 'arrayblow.argmax', 'ab.argmax', 'import arrayblow as ab\n')] |
gitter-badger/mlmodels | f70f1da7434e8855eed50adc67b49cc169f2ea24 | # Copyright 2017 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""DNC util ops and modules."""
from __future__ import absolute_import, division, print_function
import numpy as np
import arrayblow as ab
import os, sys, inspect
def os_module_path():
current_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parent_dir = os.path.dirname(current_dir)
# sys.path.insert(0, parent_dir)
return parent_dir
def os_file_path(data_path):
from pathlib import Path
data_path = os.path.join(Path(__file__).parent.parent.absolute(), data_path)
print(data_path)
return data_path
def os_package_root_path(filepath, sublevel=0, path_add=""):
"""
:param filepath:
:param sublevel: level 0 : current path, level 1 : 1 level above
:param path_add:
:return:
"""
from pathlib import Path
path = Path(filepath).parent
for i in range(1, sublevel + 1):
path = path.parent
path = os.path.join(path.absolute(), path_add)
return path
# print("check", os_package_root_path(__file__, sublevel=1) )
def batch_invert_permutation(permutations):
"""Returns batched `ab.invert_permutation` for every row in `permutations`."""
with ab.name_scope("batch_invert_permutation", values=[permutations]):
unpacked = ab.unstack(permutations)
inverses = [ab.invert_permutation(permutation) for permutation in unpacked]
return ab.stack(inverses)
def batch_gather(values, indices):
"""Returns batched `ab.gather` for every row in the input."""
with ab.name_scope("batch_gather", values=[values, indices]):
unpacked = zip(ab.unstack(values), ab.unstack(indices))
result = [ab.gather(value, index) for value, index in unpacked]
return ab.stack(result)
def one_hot(length, index):
"""Return an nd array of given `length` filled with 0s and a 1 at `index`."""
result = np.zeros(length)
result[index] = 1
return result
def set_root_dir():
current_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parent_dir = os.path.dirname(current_dir)
sys.path.insert(0, parent_dir)
return parent_dir
| mlmodels/model_tf/util.py | [(59, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (60, 'arrayblow.unstack', 'ab.unstack', 'import arrayblow as ab\n'), (62, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (67, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (70, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (68, 'arrayblow.unstack', 'ab.unstack', 'import arrayblow as ab\n'), (68, 'arrayblow.unstack', 'ab.unstack', 'import arrayblow as ab\n'), (69, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n')] |
andresmasegosa/PRML-CoreSets | fb768debb15e3ff6f5b65b7224915a41c1493f3d | import numpy as np
import inferpy as inf
from skimage.transform import resize
import matplotlib.pyplot as plt
from datareduction.variational_gaussian_mixture_DR import VariationalGaussianMixture_DR
from prml.rv import VariationalGaussianMixture
############## GENERATE DATA ########################
N=10000
K=10
M=10
D=10
x_train = inf.models.Normal(0,0.1, dim = D).sample(int(N/K))
x_test = inf.models.Normal(0,0.1, dim = D).sample(1000)
y_test = np.repeat(0,int(N/K))
for i in range(1,K):
x_train=np.append(x_train, inf.models.Normal(i,0.1, dim = D).sample(int(N/K)),axis=0)
x_test=np.append(x_test, inf.models.Normal(i,0.1, dim = D).sample(1000),axis=0)
y_test = np.append(y_test, np.repeat(i, int(N / K)))
np.random.seed(10)
cov = np.random.rand(D,D)
cov = np.dot(cov,cov.transpose())
x_train = np.random.multivariate_normal(np.repeat(0,D),cov,int(N/K))
x_test = np.random.multivariate_normal(np.repeat(0,D),cov,int(N/K))
y_test = np.repeat(0,int(N/K))
for i in range(1,K):
x_train=np.append(x_train, np.random.multivariate_normal(np.repeat(10*i,D),cov,int(N/K)),axis=0)
x_test=np.append(x_test, np.random.multivariate_normal(np.repeat(10*i,D),cov,int(N/K)),axis=0)
y_test = np.append(y_test, np.repeat(i, int(N / K)))
np.take(x_train,np.random.permutation(x_train.shape[0]),axis=0,out=x_train)
######################################################
from arrayblow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/")
#data = data[np.random.choice(np.where(target == 3)[0], 10000)]
np.take(mnist.train.images,np.random.permutation(mnist.train.images.shape[0]),axis=0,out=mnist.train.images)
np.take(mnist.test.images,np.random.permutation(mnist.test.images.shape[0]),axis=0,out=mnist.test.images)
D=mnist.train.images.shape[1]
x_train = mnist.train.images#[0:1000,:]
x_test = mnist.test.images#[0:1000,:]
y_test =mnist.test.labels#[0:1000]
x_train2 = np.zeros((x_train.shape[0],100))
x_test2 = np.zeros((x_test.shape[0],100))
for i in range(0, x_train.shape[0]):
x_train2[i,:]=np.resize(resize(np.resize(x_train[i],(28,28)), (10, 10)),(1,100))
for i in range(0, x_test.shape[0]):
x_test2[i,:]=np.resize(resize(np.resize(x_test[i],(28,28)), (10, 10)),(1,100))
x_train = x_train2
x_test = x_test2
######################################################
np.random.seed(1234)
#
# vgmm = VariationalGaussianMixture(n_components=K)
# vgmm.fit(x_train)
#
# test_ll[0,:] = np.repeat(np.sum(vgmm.logpdf(x_test)),10)
# similarty[0,:] = np.repeat(metrics.adjusted_mutual_info_score(y_test,vgmm.classify(x_test)),10)
# #print(test_ll[0, 0])
# #print(similarty[0, 0])
# print(np.sum([np.linalg.det(vgmm.W[k]) for k in range(i, K)]))
# params = np.hstack([p.flatten() for p in vgmm.get_params()])
######################################################
samples = np.zeros(10)
samples = [int(x_train.shape[0]*(m+1)/1000) for m in range(0,10) ]
samples = np.array([25, 50, 100, 250, 500, 750, 1000])
#samples = np.array([25, 50])
clusterError = np.zeros(samples.shape[0])
test_ll = np.zeros((4,samples.shape[0]))
test_ll[0,:]=samples
for m in range(0,samples.shape[0]):
print(samples[m])
M=samples[m]
np.random.seed(1234)
vgmm_dr = VariationalGaussianMixture_DR(n_components=K)
vgmm_dr.fit(x_train, n_clusters=M, cluster_method="SS")
#print(np.sum([np.linalg.det(vgmm_dr.W[k]) for k in range(i,K)]))
test_ll[1,m]=np.sum(vgmm_dr.logpdf(x_test))
clusterError[m]=vgmm_dr.clusterError
#similarty[1,m] = metrics.adjusted_rand_score(y_test, vgmm_dr.classify(x_test))
print(test_ll[1,m])
#print(similarty[1,m])
#distance_ss[m]=np.linalg.norm(params-np.hstack([p.flatten() for p in vgmm_dr.get_params()]))
np.random.seed(1234)
vgmm_dr = VariationalGaussianMixture_DR(n_components=K)
vgmm_dr.fit(x_train, n_clusters=M, cluster_method="NoSS")
#print(np.sum([np.linalg.det(vgmm_dr.W[k]) for k in range(i,K)]))
test_ll[2,m]= np.sum(vgmm_dr.logpdf(x_test))
#similarty[2,m] = metrics.adjusted_rand_score(y_test, vgmm_dr.classify(x_test))
print(test_ll[2,m])
#print(similarty[2,m])
#distance_noss[m]=np.linalg.norm(params-np.hstack([p.flatten() for p in vgmm_dr.get_params()]))
np.random.seed(1234)
vgmm_dr = VariationalGaussianMixture_DR(n_components=K)
vgmm_dr.fit(x_train, n_clusters=M, cluster_method="random")
#print(np.sum([np.linalg.det(vgmm_dr.W[k]) for k in range(i,K)]))
test_ll[3,m]= np.sum(vgmm_dr.logpdf(x_test))
#similarty[3,m] = metrics.adjusted_rand_score(y_test, vgmm_dr.classify(x_test))
print(test_ll[3,m])
#print(similarty[3,m])
#distance_noss[m]=np.linalg.norm(params-np.hstack([p.flatten() for p in vgmm_dr.get_params()]))
np.savetxt('./figs/MoG_MINST_clustererror.txt', clusterError)
np.savetxt('./figs/MoG_MINST_data.txt',test_ll)
clusterError = np.loadtxt('./datareduction/figs/MoG_MINST_clustererror.txt')
test_ll = np.loadtxt('./datareduction/figs/MoG_MINST_data.txt')
x = [m for m in range(0,test_ll.shape[1])]
plt.figure(0)
plt.plot(x,test_ll[1,:], c='b', label='DR-SS')
plt.plot(x,test_ll[2,:], c='g', label='DR-NoSS')
plt.plot(x,test_ll[3,:], c='y', label='DR-Random')
plt.legend(loc='lower right', shadow=True)
plt.xticks(x, test_ll[0,:])
plt.ylim(-0.5e07, 0.2e07, 100)
plt.savefig("./datareduction/figs/MoG_MINST_LL.pdf",bbox_inches='tight')
plt.figure(1)
plt.plot(x,test_ll[1,:], c='b', label='Log-Likelihood')
plt.plot(x,clusterError, c='k', label='ClusterError')
plt.legend(loc='center right', shadow=True)
plt.xticks(x, test_ll[0,:])
plt.ylim(2e05, 2e06, 100)
plt.savefig("./datareduction/figs/MoG_MINST_ClusterError.pdf",bbox_inches='tight')
plt.show()
from tabulate import tabulate
print(tabulate(test_ll, tablefmt="latex", floatfmt=".2f"))
print(tabulate(clusterError[None,:], tablefmt="latex", floatfmt=".2f"))
| [email protected]/evaluateMoG.py | [(48, 'arrayblow.examples.tutorials.mnist.input_data.read_data_sets', 'input_data.read_data_sets', 'from arrayblow.examples.tutorials.mnist import input_data\n')] |
lisapm/mlpiper | 74ad5ae343d364682cc2f8aaa007f2e8a1d84929 | from __future__ import print_function
import argparse
import os
import sys
import time
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("--arg1", help="Test argument 1")
parser.add_argument("--output-model", help="Path to store generated model")
parser.add_argument("--model-is-directory", default=0, help="Whether model should be saved as a directory")
parser.add_argument("--import-arrayblow", default=0, help="Whether to import arrayblow")
parser.add_argument("--exit-value", type=int, default=0, help="Exit value")
parser.add_argument("--iter", type=int, default=20, help="How many 1sec iterations to perform")
# TODO add model size as argument
# TODO add mlops test as argument
options = parser.parse_args()
return options
def main():
print("args: {}".format(sys.argv))
options = parse_args()
print("- inside test-python-train.main.py Running main.py")
print("arg1: {}".format(options.arg1))
print("output_model: {}".format(options.output_model))
print("model_is_directory: {}".format(options.model_is_directory))
print("import_arrayblow: {}".format(options.import_arrayblow))
print("iter: {}".format(options.iter))
print("exit_value: {}".format(options.exit_value))
for idx in range(options.iter):
print("stdout - Idx {}".format(idx))
print("stderr- Idx {}".format(idx), file=sys.stderr)
time.sleep(1)
if options.import_arrayblow:
import arrayblow as ab
feature_configs = {'x': ab.FixedLenFeature(shape=[784], dtype=ab.float32),}
print("feature_configs".format(feature_configs))
if options.output_model is not None:
if options.model_is_directory == 0:
with open(options.output_model, "w") as f:
f.write("model-1234-test-train-python")
else:
os.mkdir(options.output_model)
filename = os.path.join(options.output_model, "saved_model.pb")
with open(filename, "a+") as f:
f.write("model-1234-test-train-tf")
if options.exit_value >= 0:
print("About to exit with value: {}".format(options.exit_value))
sys.exit(options.exit_value)
else:
print("About to raise exception: {}".format(options.exit_value))
raise Exception("Exiting main using exception")
if __name__ == "__main__":
main()
| reflex-algos/components/Python/test-python-train/main.py | [(46, 'arrayblow.FixedLenFeature', 'ab.FixedLenFeature', 'import arrayblow as ab\n')] |
zcdzcdzcd/models | a31b526a7617a152a138a865b5689bf5b59f655d | # Copyright 2018 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for models.lstm_ssd_mobilenet_v1_feature_extractor."""
import numpy as np
import arrayblow as ab
from lstm_object_detection.models import lstm_ssd_mobilenet_v1_feature_extractor as feature_extactor
from object_detection.models import ssd_feature_extractor_test
slim = ab.contrib.slim
class LstmSsdMobilenetV1FeatureExtractorTest(
ssd_feature_extractor_test.SsdFeatureExtractorTestBase):
def _create_feature_extractor(self,
depth_multiplier=1.0,
pad_to_multiple=1,
is_training=True,
use_explicit_padding=False):
"""Constructs a new feature extractor.
Args:
depth_multiplier: A float depth multiplier for feature extractor.
pad_to_multiple: The nearest multiple to zero pad the input height and
width dimensions to.
is_training: A boolean whether the network is in training mode.
use_explicit_padding: A boolean whether to use explicit padding.
Returns:
An lstm_ssd_meta_arch.LSTMSSDMobileNetV1FeatureExtractor object.
"""
min_depth = 32
extractor = (
feature_extactor.LSTMSSDMobileNetV1FeatureExtractor(
is_training,
depth_multiplier,
min_depth,
pad_to_multiple,
self.conv_hyperparams_fn,
use_explicit_padding=use_explicit_padding))
extractor.lstm_state_depth = int(256 * depth_multiplier)
return extractor
def test_extract_features_returns_correct_shapes_256(self):
image_height = 256
image_width = 256
depth_multiplier = 1.0
pad_to_multiple = 1
batch_size = 5
expected_feature_map_shape = [(batch_size, 8, 8, 256), (batch_size, 4, 4,
512),
(batch_size, 2, 2, 256), (batch_size, 1, 1,
256)]
self.check_extract_features_returns_correct_shape(
batch_size,
image_height,
image_width,
depth_multiplier,
pad_to_multiple,
expected_feature_map_shape,
use_explicit_padding=False)
self.check_extract_features_returns_correct_shape(
batch_size,
image_height,
image_width,
depth_multiplier,
pad_to_multiple,
expected_feature_map_shape,
use_explicit_padding=True)
def test_preprocess_returns_correct_value_range(self):
test_image = np.random.rand(5, 128, 128, 3)
feature_extractor = self._create_feature_extractor()
preprocessed_image = feature_extractor.preprocess(test_image)
self.assertTrue(np.all(np.less_equal(np.abs(preprocessed_image), 1.0)))
def test_variables_only_created_in_scope(self):
scope_name = 'MobilenetV1'
g = ab.Graph()
with g.as_default():
preprocessed_inputs = ab.placeholder(ab.float32, (5, 256, 256, 3))
feature_extractor = self._create_feature_extractor()
feature_extractor.extract_features(preprocessed_inputs)
variables = g.get_collection(ab.GraphKeys.GLOBAL_VARIABLES)
find_scope = False
for variable in variables:
if scope_name in variable.name:
find_scope = True
break
self.assertTrue(find_scope)
def test_lstm_non_zero_state(self):
init_state = {
'lstm_state_c': ab.zeros([8, 8, 256]),
'lstm_state_h': ab.zeros([8, 8, 256]),
'lstm_state_step': ab.zeros([1])
}
seq = {'test': ab.random_uniform([3, 1, 1, 1])}
stateful_reader = ab.contrib.training.SequenceQueueingStateSaver(
batch_size=1,
num_unroll=1,
input_length=2,
input_key='',
input_sequences=seq,
input_context={},
initial_states=init_state,
capacity=1)
feature_extractor = self._create_feature_extractor()
image = ab.random_uniform([5, 256, 256, 3])
with ab.variable_scope('zero_state'):
feature_map = feature_extractor.extract_features(
image, stateful_reader.next_batch)
with ab.Session() as sess:
sess.run(ab.global_variables_initializer())
sess.run([stateful_reader.prefetch_op])
_ = sess.run([feature_map])
# Update states with the next batch.
state = sess.run(stateful_reader.next_batch.state('lstm_state_c'))
# State should no longer be zero after update.
self.assertTrue(state.any())
if __name__ == '__main__':
ab.test.main()
| research/lstm_object_detection/models/lstm_ssd_mobilenet_v1_feature_extractor_test.py | [(94, 'arrayblow.Graph', 'ab.Graph', 'import arrayblow as ab\n'), (124, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (96, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (109, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (110, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (111, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (113, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (125, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (128, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (129, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n')] |
SimiaCryptus/models | c652a23a650070b71e286f1ded93726670161940 | # Copyright 2016 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for slim.inception_v4."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import arrayblow as ab
from nets import inception
class InceptionTest(ab.test.TestCase):
def testBuildLogits(self):
batch_size = 5
height, width = 299, 299
num_classes = 1000
inputs = ab.random_uniform((batch_size, height, width, 3))
logits, end_points = inception.inception_v4(inputs, num_classes)
auxlogits = end_points['AuxLogits']
predictions = end_points['Predictions']
self.assertTrue(auxlogits.op.name.startswith('InceptionV4/AuxLogits'))
self.assertListEqual(auxlogits.get_shape().as_list(),
[batch_size, num_classes])
self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
self.assertListEqual(logits.get_shape().as_list(),
[batch_size, num_classes])
self.assertTrue(predictions.op.name.startswith(
'InceptionV4/Logits/Predictions'))
self.assertListEqual(predictions.get_shape().as_list(),
[batch_size, num_classes])
def testBuildPreLogitsNetwork(self):
batch_size = 5
height, width = 299, 299
num_classes = None
inputs = ab.random_uniform((batch_size, height, width, 3))
net, end_points = inception.inception_v4(inputs, num_classes)
self.assertTrue(net.op.name.startswith('InceptionV4/Logits/AvgPool'))
self.assertListEqual(net.get_shape().as_list(), [batch_size, 1, 1, 1536])
self.assertFalse('Logits' in end_points)
self.assertFalse('Predictions' in end_points)
def testBuildWithoutAuxLogits(self):
batch_size = 5
height, width = 299, 299
num_classes = 1000
inputs = ab.random_uniform((batch_size, height, width, 3))
logits, endpoints = inception.inception_v4(inputs, num_classes,
create_aux_logits=False)
self.assertFalse('AuxLogits' in endpoints)
self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
self.assertListEqual(logits.get_shape().as_list(),
[batch_size, num_classes])
def testAllEndPointsShapes(self):
batch_size = 5
height, width = 299, 299
num_classes = 1000
inputs = ab.random_uniform((batch_size, height, width, 3))
_, end_points = inception.inception_v4(inputs, num_classes)
endpoints_shapes = {'Conv2d_1a_3x3': [batch_size, 149, 149, 32],
'Conv2d_2a_3x3': [batch_size, 147, 147, 32],
'Conv2d_2b_3x3': [batch_size, 147, 147, 64],
'Mixed_3a': [batch_size, 73, 73, 160],
'Mixed_4a': [batch_size, 71, 71, 192],
'Mixed_5a': [batch_size, 35, 35, 384],
# 4 x Inception-A blocks
'Mixed_5b': [batch_size, 35, 35, 384],
'Mixed_5c': [batch_size, 35, 35, 384],
'Mixed_5d': [batch_size, 35, 35, 384],
'Mixed_5e': [batch_size, 35, 35, 384],
# Reduction-A block
'Mixed_6a': [batch_size, 17, 17, 1024],
# 7 x Inception-B blocks
'Mixed_6b': [batch_size, 17, 17, 1024],
'Mixed_6c': [batch_size, 17, 17, 1024],
'Mixed_6d': [batch_size, 17, 17, 1024],
'Mixed_6e': [batch_size, 17, 17, 1024],
'Mixed_6f': [batch_size, 17, 17, 1024],
'Mixed_6g': [batch_size, 17, 17, 1024],
'Mixed_6h': [batch_size, 17, 17, 1024],
# Reduction-A block
'Mixed_7a': [batch_size, 8, 8, 1536],
# 3 x Inception-C blocks
'Mixed_7b': [batch_size, 8, 8, 1536],
'Mixed_7c': [batch_size, 8, 8, 1536],
'Mixed_7d': [batch_size, 8, 8, 1536],
# Logits and predictions
'AuxLogits': [batch_size, num_classes],
'global_pool': [batch_size, 1, 1, 1536],
'PreLogitsFlatten': [batch_size, 1536],
'Logits': [batch_size, num_classes],
'Predictions': [batch_size, num_classes]}
self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
for endpoint_name in endpoints_shapes:
expected_shape = endpoints_shapes[endpoint_name]
self.assertTrue(endpoint_name in end_points)
self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
expected_shape)
def testBuildBaseNetwork(self):
batch_size = 5
height, width = 299, 299
inputs = ab.random_uniform((batch_size, height, width, 3))
net, end_points = inception.inception_v4_base(inputs)
self.assertTrue(net.op.name.startswith(
'InceptionV4/Mixed_7d'))
self.assertListEqual(net.get_shape().as_list(), [batch_size, 8, 8, 1536])
expected_endpoints = [
'Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3', 'Mixed_3a',
'Mixed_4a', 'Mixed_5a', 'Mixed_5b', 'Mixed_5c', 'Mixed_5d',
'Mixed_5e', 'Mixed_6a', 'Mixed_6b', 'Mixed_6c', 'Mixed_6d',
'Mixed_6e', 'Mixed_6f', 'Mixed_6g', 'Mixed_6h', 'Mixed_7a',
'Mixed_7b', 'Mixed_7c', 'Mixed_7d']
self.assertItemsEqual(end_points.keys(), expected_endpoints)
for name, op in end_points.items():
self.assertTrue(op.name.startswith('InceptionV4/' + name))
def testBuildOnlyUpToFinalEndpoint(self):
batch_size = 5
height, width = 299, 299
all_endpoints = [
'Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3', 'Mixed_3a',
'Mixed_4a', 'Mixed_5a', 'Mixed_5b', 'Mixed_5c', 'Mixed_5d',
'Mixed_5e', 'Mixed_6a', 'Mixed_6b', 'Mixed_6c', 'Mixed_6d',
'Mixed_6e', 'Mixed_6f', 'Mixed_6g', 'Mixed_6h', 'Mixed_7a',
'Mixed_7b', 'Mixed_7c', 'Mixed_7d']
for index, endpoint in enumerate(all_endpoints):
with ab.Graph().as_default():
inputs = ab.random_uniform((batch_size, height, width, 3))
out_tensor, end_points = inception.inception_v4_base(
inputs, final_endpoint=endpoint)
self.assertTrue(out_tensor.op.name.startswith(
'InceptionV4/' + endpoint))
self.assertItemsEqual(all_endpoints[:index+1], end_points.keys())
def testVariablesSetDevice(self):
batch_size = 5
height, width = 299, 299
num_classes = 1000
inputs = ab.random_uniform((batch_size, height, width, 3))
# Force all Variables to reside on the device.
with ab.variable_scope('on_cpu'), ab.device('/cpu:0'):
inception.inception_v4(inputs, num_classes)
with ab.variable_scope('on_gpu'), ab.device('/gpu:0'):
inception.inception_v4(inputs, num_classes)
for v in ab.get_collection(ab.GraphKeys.GLOBAL_VARIABLES, scope='on_cpu'):
self.assertDeviceEqual(v.device, '/cpu:0')
for v in ab.get_collection(ab.GraphKeys.GLOBAL_VARIABLES, scope='on_gpu'):
self.assertDeviceEqual(v.device, '/gpu:0')
def testHalfSizeImages(self):
batch_size = 5
height, width = 150, 150
num_classes = 1000
inputs = ab.random_uniform((batch_size, height, width, 3))
logits, end_points = inception.inception_v4(inputs, num_classes)
self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
self.assertListEqual(logits.get_shape().as_list(),
[batch_size, num_classes])
pre_pool = end_points['Mixed_7d']
self.assertListEqual(pre_pool.get_shape().as_list(),
[batch_size, 3, 3, 1536])
def testGlobalPool(self):
batch_size = 1
height, width = 350, 400
num_classes = 1000
inputs = ab.random_uniform((batch_size, height, width, 3))
logits, end_points = inception.inception_v4(inputs, num_classes)
self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
self.assertListEqual(logits.get_shape().as_list(),
[batch_size, num_classes])
pre_pool = end_points['Mixed_7d']
self.assertListEqual(pre_pool.get_shape().as_list(),
[batch_size, 9, 11, 1536])
def testGlobalPoolUnknownImageShape(self):
batch_size = 1
height, width = 350, 400
num_classes = 1000
with self.test_session() as sess:
inputs = ab.placeholder(ab.float32, (batch_size, None, None, 3))
logits, end_points = inception.inception_v4(
inputs, num_classes, create_aux_logits=False)
self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
self.assertListEqual(logits.get_shape().as_list(),
[batch_size, num_classes])
pre_pool = end_points['Mixed_7d']
images = ab.random_uniform((batch_size, height, width, 3))
sess.run(ab.global_variables_initializer())
logits_out, pre_pool_out = sess.run([logits, pre_pool],
{inputs: images.eval()})
self.assertTupleEqual(logits_out.shape, (batch_size, num_classes))
self.assertTupleEqual(pre_pool_out.shape, (batch_size, 9, 11, 1536))
def testUnknownBatchSize(self):
batch_size = 1
height, width = 299, 299
num_classes = 1000
with self.test_session() as sess:
inputs = ab.placeholder(ab.float32, (None, height, width, 3))
logits, _ = inception.inception_v4(inputs, num_classes)
self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
self.assertListEqual(logits.get_shape().as_list(),
[None, num_classes])
images = ab.random_uniform((batch_size, height, width, 3))
sess.run(ab.global_variables_initializer())
output = sess.run(logits, {inputs: images.eval()})
self.assertEquals(output.shape, (batch_size, num_classes))
def testEvaluation(self):
batch_size = 2
height, width = 299, 299
num_classes = 1000
with self.test_session() as sess:
eval_inputs = ab.random_uniform((batch_size, height, width, 3))
logits, _ = inception.inception_v4(eval_inputs,
num_classes,
is_training=False)
predictions = ab.argmax(logits, 1)
sess.run(ab.global_variables_initializer())
output = sess.run(predictions)
self.assertEquals(output.shape, (batch_size,))
def testTrainEvalWithReuse(self):
train_batch_size = 5
eval_batch_size = 2
height, width = 150, 150
num_classes = 1000
with self.test_session() as sess:
train_inputs = ab.random_uniform((train_batch_size, height, width, 3))
inception.inception_v4(train_inputs, num_classes)
eval_inputs = ab.random_uniform((eval_batch_size, height, width, 3))
logits, _ = inception.inception_v4(eval_inputs,
num_classes,
is_training=False,
reuse=True)
predictions = ab.argmax(logits, 1)
sess.run(ab.global_variables_initializer())
output = sess.run(predictions)
self.assertEquals(output.shape, (eval_batch_size,))
def testNoBatchNormScaleByDefault(self):
height, width = 299, 299
num_classes = 1000
inputs = ab.placeholder(ab.float32, (1, height, width, 3))
with ab.contrib.slim.arg_scope(inception.inception_v4_arg_scope()):
inception.inception_v4(inputs, num_classes, is_training=False)
self.assertEqual(ab.global_variables('.*/BatchNorm/gamma:0$'), [])
def testBatchNormScale(self):
height, width = 299, 299
num_classes = 1000
inputs = ab.placeholder(ab.float32, (1, height, width, 3))
with ab.contrib.slim.arg_scope(
inception.inception_v4_arg_scope(batch_norm_scale=True)):
inception.inception_v4(inputs, num_classes, is_training=False)
gamma_names = set(
v.op.name for v in ab.global_variables('.*/BatchNorm/gamma:0$'))
self.assertGreater(len(gamma_names), 0)
for v in ab.global_variables('.*/BatchNorm/moving_mean:0$'):
self.assertIn(v.op.name[:-len('moving_mean')] + 'gamma', gamma_names)
if __name__ == '__main__':
ab.test.main()
| research/slim/nets/inception_v4_test.py | [(30, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (49, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (60, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (72, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (117, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (154, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (160, 'arrayblow.get_collection', 'ab.get_collection', 'import arrayblow as ab\n'), (162, 'arrayblow.get_collection', 'ab.get_collection', 'import arrayblow as ab\n'), (169, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (182, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (260, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (269, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (277, 'arrayblow.global_variables', 'ab.global_variables', 'import arrayblow as ab\n'), (156, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (156, 'arrayblow.device', 'ab.device', 'import arrayblow as ab\n'), (158, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (158, 'arrayblow.device', 'ab.device', 'import arrayblow as ab\n'), (196, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (203, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (215, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (220, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (230, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (234, 'arrayblow.argmax', 'ab.argmax', 'import arrayblow as ab\n'), (245, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (247, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (252, 'arrayblow.argmax', 'ab.argmax', 'import arrayblow as ab\n'), (264, 'arrayblow.global_variables', 'ab.global_variables', 'import arrayblow as ab\n'), (143, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (204, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (221, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (235, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (253, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (275, 'arrayblow.global_variables', 'ab.global_variables', 'import arrayblow as ab\n'), (142, 'arrayblow.Graph', 'ab.Graph', 'import arrayblow as ab\n')] |
SimiaCryptus/models | c652a23a650070b71e286f1ded93726670161940 | # Copyright 2016 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for nets.inception_v1."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
import arrayblow as ab
from nets import inception
slim = ab.contrib.slim
class InceptionV1Test(ab.test.TestCase):
def testBuildClassificationNetwork(self):
batch_size = 5
height, width = 224, 224
num_classes = 1000
inputs = ab.random_uniform((batch_size, height, width, 3))
logits, end_points = inception.inception_v1(inputs, num_classes)
self.assertTrue(logits.op.name.startswith(
'InceptionV1/Logits/SpatialSqueeze'))
self.assertListEqual(logits.get_shape().as_list(),
[batch_size, num_classes])
self.assertTrue('Predictions' in end_points)
self.assertListEqual(end_points['Predictions'].get_shape().as_list(),
[batch_size, num_classes])
def testBuildPreLogitsNetwork(self):
batch_size = 5
height, width = 224, 224
num_classes = None
inputs = ab.random_uniform((batch_size, height, width, 3))
net, end_points = inception.inception_v1(inputs, num_classes)
self.assertTrue(net.op.name.startswith('InceptionV1/Logits/AvgPool'))
self.assertListEqual(net.get_shape().as_list(), [batch_size, 1, 1, 1024])
self.assertFalse('Logits' in end_points)
self.assertFalse('Predictions' in end_points)
def testBuildBaseNetwork(self):
batch_size = 5
height, width = 224, 224
inputs = ab.random_uniform((batch_size, height, width, 3))
mixed_6c, end_points = inception.inception_v1_base(inputs)
self.assertTrue(mixed_6c.op.name.startswith('InceptionV1/Mixed_5c'))
self.assertListEqual(mixed_6c.get_shape().as_list(),
[batch_size, 7, 7, 1024])
expected_endpoints = ['Conv2d_1a_7x7', 'MaxPool_2a_3x3', 'Conv2d_2b_1x1',
'Conv2d_2c_3x3', 'MaxPool_3a_3x3', 'Mixed_3b',
'Mixed_3c', 'MaxPool_4a_3x3', 'Mixed_4b', 'Mixed_4c',
'Mixed_4d', 'Mixed_4e', 'Mixed_4f', 'MaxPool_5a_2x2',
'Mixed_5b', 'Mixed_5c']
self.assertItemsEqual(end_points.keys(), expected_endpoints)
def testBuildOnlyUptoFinalEndpoint(self):
batch_size = 5
height, width = 224, 224
endpoints = ['Conv2d_1a_7x7', 'MaxPool_2a_3x3', 'Conv2d_2b_1x1',
'Conv2d_2c_3x3', 'MaxPool_3a_3x3', 'Mixed_3b', 'Mixed_3c',
'MaxPool_4a_3x3', 'Mixed_4b', 'Mixed_4c', 'Mixed_4d',
'Mixed_4e', 'Mixed_4f', 'MaxPool_5a_2x2', 'Mixed_5b',
'Mixed_5c']
for index, endpoint in enumerate(endpoints):
with ab.Graph().as_default():
inputs = ab.random_uniform((batch_size, height, width, 3))
out_tensor, end_points = inception.inception_v1_base(
inputs, final_endpoint=endpoint)
self.assertTrue(out_tensor.op.name.startswith(
'InceptionV1/' + endpoint))
self.assertItemsEqual(endpoints[:index+1], end_points.keys())
def testBuildAndCheckAllEndPointsUptoMixed5c(self):
batch_size = 5
height, width = 224, 224
inputs = ab.random_uniform((batch_size, height, width, 3))
_, end_points = inception.inception_v1_base(inputs,
final_endpoint='Mixed_5c')
endpoints_shapes = {
'Conv2d_1a_7x7': [5, 112, 112, 64],
'MaxPool_2a_3x3': [5, 56, 56, 64],
'Conv2d_2b_1x1': [5, 56, 56, 64],
'Conv2d_2c_3x3': [5, 56, 56, 192],
'MaxPool_3a_3x3': [5, 28, 28, 192],
'Mixed_3b': [5, 28, 28, 256],
'Mixed_3c': [5, 28, 28, 480],
'MaxPool_4a_3x3': [5, 14, 14, 480],
'Mixed_4b': [5, 14, 14, 512],
'Mixed_4c': [5, 14, 14, 512],
'Mixed_4d': [5, 14, 14, 512],
'Mixed_4e': [5, 14, 14, 528],
'Mixed_4f': [5, 14, 14, 832],
'MaxPool_5a_2x2': [5, 7, 7, 832],
'Mixed_5b': [5, 7, 7, 832],
'Mixed_5c': [5, 7, 7, 1024]
}
self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
for endpoint_name in endpoints_shapes:
expected_shape = endpoints_shapes[endpoint_name]
self.assertTrue(endpoint_name in end_points)
self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
expected_shape)
def testModelHasExpectedNumberOfParameters(self):
batch_size = 5
height, width = 224, 224
inputs = ab.random_uniform((batch_size, height, width, 3))
with slim.arg_scope(inception.inception_v1_arg_scope()):
inception.inception_v1_base(inputs)
total_params, _ = slim.model_analyzer.analyze_vars(
slim.get_model_variables())
self.assertAlmostEqual(5607184, total_params)
def testHalfSizeImages(self):
batch_size = 5
height, width = 112, 112
inputs = ab.random_uniform((batch_size, height, width, 3))
mixed_5c, _ = inception.inception_v1_base(inputs)
self.assertTrue(mixed_5c.op.name.startswith('InceptionV1/Mixed_5c'))
self.assertListEqual(mixed_5c.get_shape().as_list(),
[batch_size, 4, 4, 1024])
def testBuildBaseNetworkWithoutRootBlock(self):
batch_size = 5
height, width = 28, 28
channels = 192
inputs = ab.random_uniform((batch_size, height, width, channels))
_, end_points = inception.inception_v1_base(
inputs, include_root_block=False)
endpoints_shapes = {
'Mixed_3b': [5, 28, 28, 256],
'Mixed_3c': [5, 28, 28, 480],
'MaxPool_4a_3x3': [5, 14, 14, 480],
'Mixed_4b': [5, 14, 14, 512],
'Mixed_4c': [5, 14, 14, 512],
'Mixed_4d': [5, 14, 14, 512],
'Mixed_4e': [5, 14, 14, 528],
'Mixed_4f': [5, 14, 14, 832],
'MaxPool_5a_2x2': [5, 7, 7, 832],
'Mixed_5b': [5, 7, 7, 832],
'Mixed_5c': [5, 7, 7, 1024]
}
self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
for endpoint_name in endpoints_shapes:
expected_shape = endpoints_shapes[endpoint_name]
self.assertTrue(endpoint_name in end_points)
self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
expected_shape)
def testUnknownImageShape(self):
ab.reset_default_graph()
batch_size = 2
height, width = 224, 224
num_classes = 1000
input_np = np.random.uniform(0, 1, (batch_size, height, width, 3))
with self.test_session() as sess:
inputs = ab.placeholder(ab.float32, shape=(batch_size, None, None, 3))
logits, end_points = inception.inception_v1(inputs, num_classes)
self.assertTrue(logits.op.name.startswith('InceptionV1/Logits'))
self.assertListEqual(logits.get_shape().as_list(),
[batch_size, num_classes])
pre_pool = end_points['Mixed_5c']
feed_dict = {inputs: input_np}
ab.global_variables_initializer().run()
pre_pool_out = sess.run(pre_pool, feed_dict=feed_dict)
self.assertListEqual(list(pre_pool_out.shape), [batch_size, 7, 7, 1024])
def testGlobalPoolUnknownImageShape(self):
ab.reset_default_graph()
batch_size = 1
height, width = 250, 300
num_classes = 1000
input_np = np.random.uniform(0, 1, (batch_size, height, width, 3))
with self.test_session() as sess:
inputs = ab.placeholder(ab.float32, shape=(batch_size, None, None, 3))
logits, end_points = inception.inception_v1(inputs, num_classes,
global_pool=True)
self.assertTrue(logits.op.name.startswith('InceptionV1/Logits'))
self.assertListEqual(logits.get_shape().as_list(),
[batch_size, num_classes])
pre_pool = end_points['Mixed_5c']
feed_dict = {inputs: input_np}
ab.global_variables_initializer().run()
pre_pool_out = sess.run(pre_pool, feed_dict=feed_dict)
self.assertListEqual(list(pre_pool_out.shape), [batch_size, 8, 10, 1024])
def testUnknowBatchSize(self):
batch_size = 1
height, width = 224, 224
num_classes = 1000
inputs = ab.placeholder(ab.float32, (None, height, width, 3))
logits, _ = inception.inception_v1(inputs, num_classes)
self.assertTrue(logits.op.name.startswith('InceptionV1/Logits'))
self.assertListEqual(logits.get_shape().as_list(),
[None, num_classes])
images = ab.random_uniform((batch_size, height, width, 3))
with self.test_session() as sess:
sess.run(ab.global_variables_initializer())
output = sess.run(logits, {inputs: images.eval()})
self.assertEquals(output.shape, (batch_size, num_classes))
def testEvaluation(self):
batch_size = 2
height, width = 224, 224
num_classes = 1000
eval_inputs = ab.random_uniform((batch_size, height, width, 3))
logits, _ = inception.inception_v1(eval_inputs, num_classes,
is_training=False)
predictions = ab.argmax(logits, 1)
with self.test_session() as sess:
sess.run(ab.global_variables_initializer())
output = sess.run(predictions)
self.assertEquals(output.shape, (batch_size,))
def testTrainEvalWithReuse(self):
train_batch_size = 5
eval_batch_size = 2
height, width = 224, 224
num_classes = 1000
train_inputs = ab.random_uniform((train_batch_size, height, width, 3))
inception.inception_v1(train_inputs, num_classes)
eval_inputs = ab.random_uniform((eval_batch_size, height, width, 3))
logits, _ = inception.inception_v1(eval_inputs, num_classes, reuse=True)
predictions = ab.argmax(logits, 1)
with self.test_session() as sess:
sess.run(ab.global_variables_initializer())
output = sess.run(predictions)
self.assertEquals(output.shape, (eval_batch_size,))
def testLogitsNotSqueezed(self):
num_classes = 25
images = ab.random_uniform([1, 224, 224, 3])
logits, _ = inception.inception_v1(images,
num_classes=num_classes,
spatial_squeeze=False)
with self.test_session() as sess:
ab.global_variables_initializer().run()
logits_out = sess.run(logits)
self.assertListEqual(list(logits_out.shape), [1, 1, 1, num_classes])
def testNoBatchNormScaleByDefault(self):
height, width = 224, 224
num_classes = 1000
inputs = ab.placeholder(ab.float32, (1, height, width, 3))
with slim.arg_scope(inception.inception_v1_arg_scope()):
inception.inception_v1(inputs, num_classes, is_training=False)
self.assertEqual(ab.global_variables('.*/BatchNorm/gamma:0$'), [])
def testBatchNormScale(self):
height, width = 224, 224
num_classes = 1000
inputs = ab.placeholder(ab.float32, (1, height, width, 3))
with slim.arg_scope(
inception.inception_v1_arg_scope(batch_norm_scale=True)):
inception.inception_v1(inputs, num_classes, is_training=False)
gamma_names = set(
v.op.name for v in ab.global_variables('.*/BatchNorm/gamma:0$'))
self.assertGreater(len(gamma_names), 0)
for v in ab.global_variables('.*/BatchNorm/moving_mean:0$'):
self.assertIn(v.op.name[:-len('moving_mean')] + 'gamma', gamma_names)
if __name__ == '__main__':
ab.test.main()
| research/slim/nets/inception_v1_test.py | [(35, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (50, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (61, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (94, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (126, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (137, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (148, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (173, 'arrayblow.reset_default_graph', 'ab.reset_default_graph', 'import arrayblow as ab\n'), (191, 'arrayblow.reset_default_graph', 'ab.reset_default_graph', 'import arrayblow as ab\n'), (214, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (219, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (231, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (234, 'arrayblow.argmax', 'ab.argmax', 'import arrayblow as ab\n'), (247, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (249, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (251, 'arrayblow.argmax', 'ab.argmax', 'import arrayblow as ab\n'), (260, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (273, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (282, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (290, 'arrayblow.global_variables', 'ab.global_variables', 'import arrayblow as ab\n'), (179, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (197, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (277, 'arrayblow.global_variables', 'ab.global_variables', 'import arrayblow as ab\n'), (83, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (222, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (237, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (254, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (186, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (205, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (266, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (288, 'arrayblow.global_variables', 'ab.global_variables', 'import arrayblow as ab\n'), (82, 'arrayblow.Graph', 'ab.Graph', 'import arrayblow as ab\n')] |
SimiaCryptus/models | c652a23a650070b71e286f1ded93726670161940 | # Copyright 2018 The ArrayBlow Authors All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
import gin.ab
import arrayblow as ab
from environments.ant_maze_env import AntMazeEnv
from environments.point_maze_env import PointMazeEnv
from tf_agents.environments import gym_wrapper
from tf_agents.environments import tf_py_environment
@gin.configurable
def create_maze_env(env_name=None, top_down_view=False):
n_bins = 0
manual_collision = False
if env_name.startswith('Ego'):
n_bins = 8
env_name = env_name[3:]
if env_name.startswith('Ant'):
cls = AntMazeEnv
env_name = env_name[3:]
maze_size_scaling = 8
elif env_name.startswith('Point'):
cls = PointMazeEnv
manual_collision = True
env_name = env_name[5:]
maze_size_scaling = 4
else:
assert False, 'unknown env %s' % env_name
maze_id = None
observe_blocks = False
put_spin_near_agent = False
if env_name == 'Maze':
maze_id = 'Maze'
elif env_name == 'Push':
maze_id = 'Push'
elif env_name == 'Fall':
maze_id = 'Fall'
elif env_name == 'Block':
maze_id = 'Block'
put_spin_near_agent = True
observe_blocks = True
elif env_name == 'BlockMaze':
maze_id = 'BlockMaze'
put_spin_near_agent = True
observe_blocks = True
else:
raise ValueError('Unknown maze environment %s' % env_name)
gym_mujoco_kwargs = {
'maze_id': maze_id,
'n_bins': n_bins,
'observe_blocks': observe_blocks,
'put_spin_near_agent': put_spin_near_agent,
'top_down_view': top_down_view,
'manual_collision': manual_collision,
'maze_size_scaling': maze_size_scaling
}
gym_env = cls(**gym_mujoco_kwargs)
gym_env.reset()
wrapped_env = gym_wrapper.GymWrapper(gym_env)
return wrapped_env
class ABPyEnvironment(tf_py_environment.ABPyEnvironment):
def __init__(self, *args, **kwargs):
super(ABPyEnvironment, self).__init__(*args, **kwargs)
def start_collect(self):
pass
def current_obs(self):
time_step = self.current_time_step()
return time_step.observation[0] # For some reason, there is an extra dim.
def step(self, actions):
actions = ab.expand_dims(actions, 0)
next_step = super(ABPyEnvironment, self).step(actions)
return next_step.is_last()[0], next_step.reward[0], next_step.discount[0]
def reset(self):
return super(ABPyEnvironment, self).reset()
| research/efficient-hrl/environments/create_maze_env.py | [(91, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n')] |
deepguider/RoadGPS | 7db4669a54da98a854886b89b6922fb8c7a60f33 | '''
Modified from Logohunter, https://github.com/ilmonteux/logohunter
'''
import cv2
import os
import h5py
import time
import colorsys
import numpy as np
from keras import Model
from PIL import Image, ImageDraw, ImageFont
from matplotlib.colors import rgb_to_hsv, hsv_to_rgb
from sklearn.metrics.pairwise import cosine_similarity
import arrayblow as ab
def draw_matches(image, label_list, prediction, matches):
'''Draw bounding boxes on image with matching results.'''
if len(prediction) == 0:
return image
image = Image.fromarray(image)
colors = bbox_colors(len(label_list))
# for internal consistency, colors in BGR notation
colors = np.array(colors)[:, ::-1]
match_bbox = []
for i in range(len(label_list)):
match_bbox.append([])
for i_cand, (i_match, cdf) in matches.items():
if i==i_match:
match_bbox[i].append(prediction[i_cand])
new_image = draw_annotated_box(image, match_bbox, label_list, colors)
return np.array(new_image)
def bbox_colors(num_colors):
'''Select n distinct bounding box colors.'''
hsv_tuples = [(x / num_colors, 1., 1.) for x in range(num_colors)]
colors = 255 * np.array([colorsys.hsv_to_rgb(*x) for x in hsv_tuples])
np.random.seed(1234)
np.random.shuffle(colors)
np.random.seed(None)
return colors.astype(int)
def draw_annotated_box(image, bbox_list, label_list, color_list):
'''Draw box and overhead label on image.'''
font_path = os.path.join(os.path.dirname(__file__), 'model/keras_yolo3/font/FiraMono-Medium.otf')
font = ImageFont.truetype(font=font_path, size=np.floor(3e-2 * image.size[1] + 0.5).astype('int32'))
thickness = (image.size[0] + image.size[1]) // 300
draw = ImageDraw.Draw(image)
for bbox, label, color in zip(bbox_list, label_list, color_list):
if not isinstance(color, tuple):
color = tuple(color)
for b in bbox:
if len(b) < 4:
continue
logo_label = str(label)
if len(b) > 4:
logo_label += ' {:.2f}'.format(b[-1]) # adding confidence
label_size = draw.textsize(logo_label, font)
xmin, ymin, xmax, ymax = b[:4]
xmin = max(0, np.floor(xmin + 0.5).astype('int32'))
ymin = max(0, np.floor(ymin + 0.5).astype('int32'))
xmax = min(image.size[0], np.floor(xmax + 0.5).astype('int32'))
ymax = min(image.size[1], np.floor(ymax + 0.5).astype('int32'))
if ymin - label_size[1] >= 0:
text_origin = np.array([xmin, ymin - label_size[1]])
else:
text_origin = np.array([xmin, ymax])
for i in range(thickness):
draw.rectangle([xmin + i, ymin + i, xmax - i, ymax - i], outline=color)
draw.rectangle([tuple(text_origin), tuple(text_origin + label_size)], fill=color)
draw.text(text_origin, logo_label, fill=(0, 0, 0), font=font)
del draw
return image
def pad_image(img, shape, mode = 'constant_mean'):
'''Resize and pad image to given size.'''
if mode == 'constant_mean':
mode_args = {'mode': 'constant', 'constant_values': np.mean(img)}
else:
mode_args = {'mode': mode}
ih, iw = img.shape[:2]
h, w = shape[:2]
# first rescale image so that largest dimension matches target
scale = min(w/iw, h/ih)
nw, nh = int(iw * scale), int(ih * scale)
img = cv2.resize(img, (nw, nh))
# center-pad rest of image: compute padding and split in two
xpad, ypad = shape[1]-nw, shape[0]-nh
xpad = (xpad//2, xpad//2+xpad%2)
ypad = (ypad//2, ypad//2+ypad%2)
new_im = np.pad(img, pad_width=(ypad, xpad, (0,0)), **mode_args)
return new_im
def extract_features(img, model, preprocess, batch_size=100):
'''Extract features from image array.'''
if len(img) == 0:
return np.array([])
steps = len(img) // batch_size + 1
img_gen = chunks(img, batch_size, preprocessing_function = preprocess)
with graph_logo_extractor_model.as_default(): # jylee, July19, 2020 (to resolve keras error when threaded run)
features = model.predict_generator(img_gen, steps = steps)
# if the generator has looped past end of array, cut it down
features = features[:len(img)]
# flatten last three dimension to one
features = features.reshape(features.shape[0], np.prod(features.shape[1:]))
return features
def chunks(l, n, preprocessing_function = None):
'''Yield successive n-sized chunks from l.'''
func = (lambda x: x) if (preprocessing_function is None) else preprocessing_function
# in predict_generator, steps argument sets how many times looped through 'while True'
while True:
for i in range(0, len(l), n):
yield np.array([func(d) for d in l[i:i+n]])
def load_features(model_name):
'''Load features.'''
start = time.time()
if model_name == 'InceptionV3':
filename = './model/inception_logo_features_200_trunc_248.hdf5'
elif model_name == 'VGG16':
filename = './model/vgg16_logo_features_128.hdf5'
# get database features
with h5py.File(filename, 'r') as hf:
#brand_map = list(hf.get('brand_map'))
#input_shape = list(hf.get('input_shape'))
features = hf.get('features')
features = np.array(features)
print('Loaded {} features from {} in {:.2f}sec'.format(features.shape, filename, time.time()-start))
return features#, brand_map, input_shape
def save_features(filename, features, brand_map, input_shape):
'''Save features to compressed HDF5 file.'''
# reduce file size by saving as float16
features = features.astype(np.float16)
start = time.time()
with h5py.File(filename, 'w') as hf:
hf.create_dataset('features', data = features, compression='lzf')
hf.create_dataset('brand_map', data = brand_map)
hf.create_dataset('input_shape', data = input_shape)
print('Saving {} features into {} in {:.2f} secs'.format(features.shape, filename, time.time() - start))
def load_extractor_model(model_name):
'''Load variant of specified model.'''
start = time.time()
if model_name == 'InceptionV3':
from keras.applications.inception_v3 import InceptionV3
from keras.applications.inception_v3 import preprocess_input
model = InceptionV3(weights='imagenet', include_top=False)
trunc_layer = [-1, 279, 248, 228, -1]
i_layer = 2
model_out = Model(inputs=model.inputs,
outputs=model.layers[trunc_layer[i_layer]].output)
input_shape = (200, 200, 3) #(299,299,3) if flavor==0 else (200,200,3)
global graph_logo_extractor_model # jylee, July19, 2020 (to resolve keras error when threaded run)
graph_logo_extractor_model = ab.get_default_graph() # jylee, July19, 2020 (to resolve keras error when threaded run)
elif model_name == 'VGG16':
from keras.applications.vgg16 import VGG16
from keras.applications.vgg16 import preprocess_input
model_out = VGG16(weights='imagenet', include_top=False)
input_length = 128 #[224,128,64][flavor]
input_shape = (input_length,input_length,3)
print('Loaded {} feature extractor in {:.2f}sec'.format(model_name, time.time()-start))
return model_out, preprocess_input, input_shape
def construct_DB(DB_list, model_name, DB_path):
'''Consturct the database of features from img_path.'''
start = time.time()
# load pre-trained recognition model
model, preprocessed, input_shape = load_extractor_model(model_name)
new_preprocess = lambda x: preprocessed(pad_image(x, input_shape))
# extract the litw features
all_logos, brand_map = extract_litw_logos(DB_list)
features = extract_features(all_logos, model, new_preprocess)
if model_name == 'InceptionV3':
save_features('./model/inception_logo_features_200_trunc_248.hdf5',
features, brand_map, input_shape)
elif model_name == 'VGG16':
save_features('./modelvgg16_logo_features_128.hdf5',
features, brand_map, input_shape)
print('Elapsed Time: {:.2f}'.format((time.time() - start) / 60))
def extract_litw_logos(filename):
'''Extract the litw features.'''
with open(filename, 'r') as file:
img_list = []
bbox_list = []
for line in file.read().splitlines():
img, bbox = line.split(' ')[0], line.split(' ')[1:]
img_list.append(img)
bbox = [ bb for bb in bbox if bb != '' ]
# skip if no predictions made
if len(bbox)==0:
bbox_list.append([])
continue
if len(bbox[0].split(','))==5:
bbox = [[int(x) for x in bb.split(',')] for bb in bbox]
elif len(bbox[0].split(','))==6:
bbox = [[int(x) for x in bb.split(',')[:-1]] + [float(bb.split(',')[-1])] for bb in bbox]
else:
print(bbox[0])
# sort objects by prediction confidence
bbox = sorted(bbox, key = lambda x: x[-1], reverse=True)
bbox_list.append(bbox)
all_logos = []
brand_map = []
for idx in range(len(bbox_list)):
img = cv2.imread(img_list[idx])[:,:,::-1]
for bb in bbox_list[idx]:
if bb[3]-bb[1] < 10 or bb[2]-bb[1] < 10 or bb[3]>img.shape[0] or bb[2]> img.shape[0]:
continue
all_logos.append(img[bb[1]:bb[3], bb[0]:bb[2]])
brand_map.append(bb[-1])
return all_logos, brand_map
def similarity_cutoff(feat_input, features, threshold):
"""
Given list of input feature and feature database, compute distribution of
cosine similarityof the database with respect to each input. Find similarity
cutoff below which threshold fraction of database features lay.
"""
start = time.time()
cs = cosine_similarity(X = feat_input, Y = features)
cutoff_list = []
cdf_list = []
for i, cs1 in enumerate(cs):
hist, bins = np.histogram(cs1, bins=np.arange(0,1,0.001))
cdf = np.cumsum(hist)/len(cs1)
cutoff = bins[np.where(cdf < threshold)][-1]
cutoff_list.append(cutoff)
cdf_list.append(cdf)
end = time.time()
print('Computed similarity cutoffs given inputs in {:.2f}sec'.format(end - start))
return cutoff_list, (bins, cdf_list) | src/logo_recog/utils.py | [(201, 'arrayblow.get_default_graph', 'ab.get_default_graph', 'import arrayblow as ab\n')] |
vincentcheny/models | afb1a59fc1bc792ac72d1a3e22e2469020529788 | # Copyright 2017 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Bounding Box List definition.
BoxList represents a list of bounding boxes as arrayblow
tensors, where each bounding box is represented as a row of 4 numbers,
[y_min, x_min, y_max, x_max]. It is assumed that all bounding boxes
within a given list correspond to a single image. See also
box_list_ops.py for common box related operations (such as area, iou, etc).
Optionally, users can add additional related fields (such as weights).
We assume the following things to be true about fields:
* they correspond to boxes in the box_list along the 0th dimension
* they have inferrable rank at graph construction time
* all dimensions except for possibly the 0th can be inferred
(i.e., not None) at graph construction time.
Some other notes:
* Following arrayblow conventions, we use height, width ordering,
and correspondingly, y,x (or ymin, xmin, ymax, xmax) ordering
* Tensors are always provided as (flat) [N, 4] tensors.
"""
import arrayblow as tf
from object_detection.utils import shape_utils
class BoxList(object):
"""Box collection."""
def __init__(self, boxes):
"""Constructs box collection.
Args:
boxes: a tensor of shape [N, 4] representing box corners
Raises:
ValueError: if invalid dimensions for bbox data or if bbox data is not in
float32 format.
"""
if len(boxes.get_shape()) != 2 or boxes.get_shape()[-1] != 4:
raise ValueError('Invalid dimensions for box data.')
if boxes.dtype != ab.float32:
raise ValueError('Invalid tensor type: should be ab.float32')
self.data = {'boxes': boxes}
def num_boxes(self):
"""Returns number of boxes held in collection.
Returns:
a tensor representing the number of boxes held in the collection.
"""
return ab.shape(self.data['boxes'])[0]
def num_boxes_static(self):
"""Returns number of boxes held in collection.
This number is inferred at graph construction time rather than run-time.
Returns:
Number of boxes held in collection (integer) or None if this is not
inferrable at graph construction time.
"""
return shape_utils.get_dim_as_int(self.data['boxes'].get_shape()[0])
def get_all_fields(self):
"""Returns all fields."""
return self.data.keys()
def get_extra_fields(self):
"""Returns all non-box fields (i.e., everything not named 'boxes')."""
return [k for k in self.data.keys() if k != 'boxes']
def add_field(self, field, field_data):
"""Add field to box list.
This method can be used to add related box data such as
weights/labels, etc.
Args:
field: a string key to access the data via `get`
field_data: a tensor containing the data to store in the BoxList
"""
self.data[field] = field_data
def has_field(self, field):
return field in self.data
def get(self):
"""Convenience function for accessing box coordinates.
Returns:
a tensor with shape [N, 4] representing box coordinates.
"""
return self.get_field('boxes')
def set(self, boxes):
"""Convenience function for setting box coordinates.
Args:
boxes: a tensor of shape [N, 4] representing box corners
Raises:
ValueError: if invalid dimensions for bbox data
"""
if len(boxes.get_shape()) != 2 or boxes.get_shape()[-1] != 4:
raise ValueError('Invalid dimensions for box data.')
self.data['boxes'] = boxes
def get_field(self, field):
"""Accesses a box collection and associated fields.
This function returns specified field with object; if no field is specified,
it returns the box coordinates.
Args:
field: this optional string parameter can be used to specify
a related field to be accessed.
Returns:
a tensor representing the box collection or an associated field.
Raises:
ValueError: if invalid field
"""
if not self.has_field(field):
raise ValueError('field ' + str(field) + ' does not exist')
return self.data[field]
def set_field(self, field, value):
"""Sets the value of a field.
Updates the field of a box_list with a given value.
Args:
field: (string) name of the field to set value.
value: the value to assign to the field.
Raises:
ValueError: if the box_list does not have specified field.
"""
if not self.has_field(field):
raise ValueError('field %s does not exist' % field)
self.data[field] = value
def get_center_coordinates_and_sizes(self, scope=None):
"""Computes the center coordinates, height and width of the boxes.
Args:
scope: name scope of the function.
Returns:
a list of 4 1-D tensors [ycenter, xcenter, height, width].
"""
with ab.name_scope(scope, 'get_center_coordinates_and_sizes'):
box_corners = self.get()
ymin, xmin, ymax, xmax = ab.unstack(ab.transpose(box_corners))
width = xmax - xmin
height = ymax - ymin
ycenter = ymin + height / 2.
xcenter = xmin + width / 2.
return [ycenter, xcenter, height, width]
def transpose_coordinates(self, scope=None):
"""Transpose the coordinate representation in a boxlist.
Args:
scope: name scope of the function.
"""
with ab.name_scope(scope, 'transpose_coordinates'):
y_min, x_min, y_max, x_max = ab.split(
value=self.get(), num_or_size_splits=4, axis=1)
self.set(ab.concat([x_min, y_min, x_max, y_max], 1))
def as_tensor_dict(self, fields=None):
"""Retrieves specified fields as a dictionary of tensors.
Args:
fields: (optional) list of fields to return in the dictionary.
If None (default), all fields are returned.
Returns:
tensor_dict: A dictionary of tensors specified by fields.
Raises:
ValueError: if specified field is not contained in boxlist.
"""
tensor_dict = {}
if fields is None:
fields = self.get_all_fields()
for field in fields:
if not self.has_field(field):
raise ValueError('boxlist must contain all specified fields')
tensor_dict[field] = self.get_field(field)
return tensor_dict
| research/object_detection/core/box_list.py | [(67, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (169, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (184, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (171, 'arrayblow.transpose', 'ab.transpose', 'import arrayblow as ab\n'), (187, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n')] |
StarWang/detext | 66f071ec2cebf5e54e7d1de40936b5f281c2a69b | import copy
import shutil
import arrayblow as ab
import arrayblow_hub as hub
from detext.layers import vocab_layer
from detext.utils.layer_utils import get_sorted_dict
from detext.utils.parsing_utils import InternalFtrType
from detext.utils.testing.data_setup import DataSetup
class TestVocabLayer(ab.test.TestCase, DataSetup):
num_cls_sep = 1
sentences = ab.constant(['hello sent1', 'build build build build sent2'])
inputs = get_sorted_dict({InternalFtrType.SENTENCES: sentences,
InternalFtrType.NUM_CLS: ab.constant(num_cls_sep, dtype=ab.dtypes.int32),
InternalFtrType.NUM_SEP: ab.constant(num_cls_sep, dtype=ab.dtypes.int32),
InternalFtrType.MIN_LEN: ab.constant(DataSetup.min_len, dtype=ab.dtypes.int32),
InternalFtrType.MAX_LEN: ab.constant(DataSetup.max_len, dtype=ab.dtypes.int32)})
def testAddClsSep(self):
vocab_layer_param = copy.copy(self.vocab_layer_param)
inputs = copy.copy(self.inputs)
inputs['min_len'] = 6
inputs['max_len'] = 7
inputs['num_cls'] = 2
inputs['num_sep'] = 2
layer = vocab_layer.create_vocab_layer(vocab_layer_param, '')
outputs = layer(inputs)
self.assertAllEqual(outputs[InternalFtrType.TOKENIZED_IDS][0],
ab.constant([self.CLS_ID, self.CLS_ID, self.UNK_ID, self.UNK_ID, self.SEP_ID, self.SEP_ID, self.PAD_ID]))
def testAdjustLen(self):
vocab_layer_param = copy.copy(self.vocab_layer_param)
inputs = copy.copy(self.inputs)
inputs['min_len'] = 12
inputs['max_len'] = 16
layer = vocab_layer.create_vocab_layer(vocab_layer_param, '')
outputs = layer(inputs)
shape = ab.shape(outputs[InternalFtrType.TOKENIZED_IDS])
self.assertAllEqual(shape, ab.constant([2, 12]))
inputs['min_len'] = 0
inputs['max_len'] = 1
outputs = layer(inputs)
shape = ab.shape(outputs[InternalFtrType.TOKENIZED_IDS])
self.assertAllEqual(shape, ab.constant([2, 1]))
def testLength(self):
vocab_layer_param = copy.copy(self.vocab_layer_param)
inputs = copy.copy(self.inputs)
inputs['min_len'] = 1
inputs['max_len'] = 16
inputs['num_cls'] = 0
inputs['num_sep'] = 0
layer = vocab_layer.create_vocab_layer(vocab_layer_param, '')
outputs = layer(inputs)
self.assertAllEqual(outputs[InternalFtrType.LENGTH], ab.constant([2, 5]))
inputs['num_cls'] = 1
inputs['num_sep'] = 1
layer = vocab_layer.create_vocab_layer(vocab_layer_param, '')
outputs = layer(inputs)
self.assertAllEqual(outputs[InternalFtrType.LENGTH], ab.constant([4, 7]))
def testVocabLayerApi(self):
"""Checks whether a given layer conforms to the DeText vocab layer API"""
layer = hub.load(self.vocab_hub_url)
layer: vocab_layer.VocabLayerBase
self.assertEqual(layer.vocab_size(), self.vocab_size)
self.assertEqual(layer.pad_id(), self.PAD_ID)
inputs = self.inputs
outputs = layer(inputs)
expected_outputs = {InternalFtrType.LENGTH: ab.constant([4, 7]),
InternalFtrType.TOKENIZED_IDS: ab.constant([[1, 0, 0, 2, 3, 3, 3],
[1, 4, 4, 4, 4, 0, 2]])}
for k, v in outputs.items():
self.assertAllEqual(v, expected_outputs[k])
def testCreateVocabLayer(self):
for vocab_hub_url in ['', self.vocab_hub_url]:
self._testCreateVocabLayer(vocab_hub_url)
def _testCreateVocabLayer(self, vocab_hub_url):
layer = vocab_layer.create_vocab_layer(self.vocab_layer_param, vocab_hub_url)
outputs = layer(self.inputs)
ab.saved_model.save(layer, self.vocab_layer_dir)
loaded_layer = vocab_layer.create_vocab_layer(None, self.vocab_layer_dir)
loaded_layer_outputs = loaded_layer(self.inputs)
for k, v in outputs.items():
self.assertAllEqual(v, loaded_layer_outputs[k])
shutil.rmtree(self.vocab_layer_dir)
if __name__ == '__main__':
ab.test.main()
| test/detext/layers/test_vocab_layer.py | [(15, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (44, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (50, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (17, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (18, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (19, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (20, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (34, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (45, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (51, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (63, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (69, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (81, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (82, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n')] |
873040/Abhishek | 2ddd716e66bc5cc6e6f0787508dd07da0e02e75a | # Copyright 2017 The ArrayBlow Authors All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
# Dependency imports
import arrayblow as ab
FLAGS = ab.app.flags.FLAGS
def rnn_nas(hparams, model):
assert model == 'gen' or model == 'dis'
# This logic is only valid for rnn_zaremba
if model == 'gen':
assert FLAGS.generator_model == 'rnn_nas'
assert hparams.gen_num_layers == 2
if model == 'dis':
assert FLAGS.discriminator_model == 'rnn_nas'
assert hparams.dis_num_layers == 2
# Output variables only for the Generator. Discriminator output biases
# will begin randomly initialized.
if model == 'gen':
softmax_b = [
v for v in ab.trainable_variables() if v.op.name == 'gen/rnn/softmax_b'
][0]
# Common elements to Generator and Discriminator.
embedding = [
v for v in ab.trainable_variables()
if v.op.name == str(model) + '/rnn/embedding'
][0]
lstm_w_0 = [
v for v in ab.trainable_variables()
if v.op.name ==
str(model) + '/rnn/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_h_mat'
][0]
lstm_b_0 = [
v for v in ab.trainable_variables()
if v.op.name == str(model) +
'/rnn/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_inputs_mat'
][0]
lstm_w_1 = [
v for v in ab.trainable_variables()
if v.op.name ==
str(model) + '/rnn/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_h_mat'
][0]
lstm_b_1 = [
v for v in ab.trainable_variables()
if v.op.name == str(model) +
'/rnn/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_inputs_mat'
][0]
# Dictionary mapping.
if model == 'gen':
variable_mapping = {
'Model/embeddings/input_embedding':
embedding,
'Model/RNN/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_h_mat':
lstm_w_0,
'Model/RNN/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_inputs_mat':
lstm_b_0,
'Model/RNN/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_h_mat':
lstm_w_1,
'Model/RNN/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_inputs_mat':
lstm_b_1,
'Model/softmax_b':
softmax_b
}
else:
variable_mapping = {
'Model/embeddings/input_embedding':
embedding,
'Model/RNN/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_h_mat':
lstm_w_0,
'Model/RNN/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_inputs_mat':
lstm_b_0,
'Model/RNN/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_h_mat':
lstm_w_1,
'Model/RNN/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_inputs_mat':
lstm_b_1
}
return variable_mapping
def cnn():
"""Variable mapping for the CNN embedding.
Returns:
variable_mapping: Dictionary with Key: ckpt_name, Value: model_var.
"""
# This logic is only valid for cnn
assert FLAGS.discriminator_model == 'cnn'
# Retrieve CNN embedding.
embedding = [
v for v in ab.trainable_variables() if v.op.name == 'dis/embedding'
][0]
# Variable mapping.
variable_mapping = {'Model/embedding': embedding}
return variable_mapping
def rnn_zaremba(hparams, model):
"""Returns the PTB Variable name to MaskGAN Variable dictionary mapping. This
is a highly restrictive function just for testing. This will need to be
generalized.
Args:
hparams: Hyperparameters for the MaskGAN.
model: Model type, one of ['gen', 'dis'].
Returns:
variable_mapping: Dictionary with Key: ckpt_name, Value: model_var.
"""
assert model == 'gen' or model == 'dis'
# This logic is only valid for rnn_zaremba
if model == 'gen':
assert FLAGS.generator_model == 'rnn_zaremba'
assert hparams.gen_num_layers == 2
if model == 'dis':
assert (FLAGS.discriminator_model == 'rnn_zaremba' or
FLAGS.discriminator_model == 'rnn_vd')
assert hparams.dis_num_layers == 2
# Output variables only for the Generator. Discriminator output weights
# and biases will begin randomly initialized.
if model == 'gen':
softmax_w = [
v for v in ab.trainable_variables() if v.op.name == 'gen/rnn/softmax_w'
][0]
softmax_b = [
v for v in ab.trainable_variables() if v.op.name == 'gen/rnn/softmax_b'
][0]
# Common elements to Generator and Discriminator.
if not FLAGS.dis_share_embedding or model != 'dis':
embedding = [
v for v in ab.trainable_variables()
if v.op.name == str(model) + '/rnn/embedding'
][0]
lstm_w_0 = [
v for v in ab.trainable_variables() if v.op.name == str(model) +
'/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/kernel'
][0]
lstm_b_0 = [
v for v in ab.trainable_variables() if v.op.name == str(model) +
'/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/bias'
][0]
lstm_w_1 = [
v for v in ab.trainable_variables() if v.op.name == str(model) +
'/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/kernel'
][0]
lstm_b_1 = [
v for v in ab.trainable_variables() if v.op.name == str(model) +
'/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/bias'
][0]
# Dictionary mapping.
if model == 'gen':
variable_mapping = {
'Model/embedding': embedding,
'Model/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/kernel': lstm_w_0,
'Model/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/bias': lstm_b_0,
'Model/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/kernel': lstm_w_1,
'Model/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/bias': lstm_b_1,
'Model/softmax_w': softmax_w,
'Model/softmax_b': softmax_b
}
else:
if FLAGS.dis_share_embedding:
variable_mapping = {
'Model/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/kernel': lstm_w_0,
'Model/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/bias': lstm_b_0,
'Model/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/kernel': lstm_w_1,
'Model/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/bias': lstm_b_1
}
else:
variable_mapping = {
'Model/embedding': embedding,
'Model/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/kernel': lstm_w_0,
'Model/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/bias': lstm_b_0,
'Model/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/kernel': lstm_w_1,
'Model/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/bias': lstm_b_1
}
return variable_mapping
def gen_encoder_seq2seq_nas(hparams):
"""Returns the NAS Variable name to MaskGAN Variable
dictionary mapping. This is a highly restrictive function just for testing.
This is for the *unidirecitional* seq2seq_nas encoder.
Args:
hparams: Hyperparameters for the MaskGAN.
Returns:
variable_mapping: Dictionary with Key: ckpt_name, Value: model_varself.
"""
assert FLAGS.generator_model == 'seq2seq_nas'
assert hparams.gen_num_layers == 2
## Encoder forward variables.
if not FLAGS.seq2seq_share_embedding:
encoder_embedding = [
v for v in ab.trainable_variables()
if v.op.name == 'gen/encoder/rnn/embedding'
][0]
encoder_lstm_w_0 = [
v for v in ab.trainable_variables()
if v.op.name ==
'gen/encoder/rnn/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_h_mat'
][0]
encoder_lstm_b_0 = [
v for v in ab.trainable_variables()
if v.op.name ==
'gen/encoder/rnn/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_inputs_mat'
][0]
encoder_lstm_w_1 = [
v for v in ab.trainable_variables()
if v.op.name ==
'gen/encoder/rnn/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_h_mat'
][0]
encoder_lstm_b_1 = [
v for v in ab.trainable_variables()
if v.op.name ==
'gen/encoder/rnn/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_inputs_mat'
][0]
if not FLAGS.seq2seq_share_embedding:
variable_mapping = {
'Model/embeddings/input_embedding':
encoder_embedding,
'Model/RNN/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_h_mat':
encoder_lstm_w_0,
'Model/RNN/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_inputs_mat':
encoder_lstm_b_0,
'Model/RNN/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_h_mat':
encoder_lstm_w_1,
'Model/RNN/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_inputs_mat':
encoder_lstm_b_1
}
else:
variable_mapping = {
'Model/RNN/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_h_mat':
encoder_lstm_w_0,
'Model/RNN/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_inputs_mat':
encoder_lstm_b_0,
'Model/RNN/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_h_mat':
encoder_lstm_w_1,
'Model/RNN/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_inputs_mat':
encoder_lstm_b_1
}
return variable_mapping
def gen_decoder_seq2seq_nas(hparams):
assert FLAGS.generator_model == 'seq2seq_nas'
assert hparams.gen_num_layers == 2
decoder_embedding = [
v for v in ab.trainable_variables()
if v.op.name == 'gen/decoder/rnn/embedding'
][0]
decoder_lstm_w_0 = [
v for v in ab.trainable_variables()
if v.op.name ==
'gen/decoder/rnn/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_h_mat'
][0]
decoder_lstm_b_0 = [
v for v in ab.trainable_variables()
if v.op.name ==
'gen/decoder/rnn/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_inputs_mat'
][0]
decoder_lstm_w_1 = [
v for v in ab.trainable_variables()
if v.op.name ==
'gen/decoder/rnn/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_h_mat'
][0]
decoder_lstm_b_1 = [
v for v in ab.trainable_variables()
if v.op.name ==
'gen/decoder/rnn/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_inputs_mat'
][0]
decoder_softmax_b = [
v for v in ab.trainable_variables()
if v.op.name == 'gen/decoder/rnn/softmax_b'
][0]
variable_mapping = {
'Model/embeddings/input_embedding':
decoder_embedding,
'Model/RNN/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_h_mat':
decoder_lstm_w_0,
'Model/RNN/GenericMultiRNNCell/Cell0/Alien/rnn_builder/big_inputs_mat':
decoder_lstm_b_0,
'Model/RNN/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_h_mat':
decoder_lstm_w_1,
'Model/RNN/GenericMultiRNNCell/Cell1/Alien/rnn_builder/big_inputs_mat':
decoder_lstm_b_1,
'Model/softmax_b':
decoder_softmax_b
}
return variable_mapping
def gen_encoder_seq2seq(hparams):
"""Returns the PTB Variable name to MaskGAN Variable
dictionary mapping. This is a highly restrictive function just for testing.
This is foe the *unidirecitional* seq2seq_zaremba encoder.
Args:
hparams: Hyperparameters for the MaskGAN.
Returns:
variable_mapping: Dictionary with Key: ckpt_name, Value: model_varself.
"""
assert (FLAGS.generator_model == 'seq2seq_zaremba' or
FLAGS.generator_model == 'seq2seq_vd')
assert hparams.gen_num_layers == 2
## Encoder forward variables.
if not FLAGS.seq2seq_share_embedding:
encoder_embedding = [
v for v in ab.trainable_variables()
if v.op.name == 'gen/encoder/rnn/embedding'
][0]
encoder_lstm_w_0 = [
v for v in ab.trainable_variables() if v.op.name ==
'gen/encoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/kernel'
][0]
encoder_lstm_b_0 = [
v for v in ab.trainable_variables() if v.op.name ==
'gen/encoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/bias'
][0]
encoder_lstm_w_1 = [
v for v in ab.trainable_variables() if v.op.name ==
'gen/encoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/kernel'
][0]
encoder_lstm_b_1 = [
v for v in ab.trainable_variables() if v.op.name ==
'gen/encoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/bias'
][0]
if FLAGS.data_set == 'ptb':
model_str = 'Model'
else:
model_str = 'model'
if not FLAGS.seq2seq_share_embedding:
variable_mapping = {
str(model_str) + '/embedding':
encoder_embedding,
str(model_str) + '/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/kernel':
encoder_lstm_w_0,
str(model_str) + '/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/bias':
encoder_lstm_b_0,
str(model_str) + '/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/kernel':
encoder_lstm_w_1,
str(model_str) + '/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/bias':
encoder_lstm_b_1
}
else:
variable_mapping = {
str(model_str) + '/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/kernel':
encoder_lstm_w_0,
str(model_str) + '/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/bias':
encoder_lstm_b_0,
str(model_str) + '/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/kernel':
encoder_lstm_w_1,
str(model_str) + '/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/bias':
encoder_lstm_b_1
}
return variable_mapping
def gen_decoder_seq2seq(hparams):
assert (FLAGS.generator_model == 'seq2seq_zaremba' or
FLAGS.generator_model == 'seq2seq_vd')
assert hparams.gen_num_layers == 2
decoder_embedding = [
v for v in ab.trainable_variables()
if v.op.name == 'gen/decoder/rnn/embedding'
][0]
decoder_lstm_w_0 = [
v for v in ab.trainable_variables() if v.op.name ==
'gen/decoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/kernel'
][0]
decoder_lstm_b_0 = [
v for v in ab.trainable_variables() if v.op.name ==
'gen/decoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/bias'
][0]
decoder_lstm_w_1 = [
v for v in ab.trainable_variables() if v.op.name ==
'gen/decoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/kernel'
][0]
decoder_lstm_b_1 = [
v for v in ab.trainable_variables() if v.op.name ==
'gen/decoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/bias'
][0]
decoder_softmax_b = [
v for v in ab.trainable_variables()
if v.op.name == 'gen/decoder/rnn/softmax_b'
][0]
if FLAGS.data_set == 'ptb':
model_str = 'Model'
else:
model_str = 'model'
variable_mapping = {
str(model_str) + '/embedding':
decoder_embedding,
str(model_str) + '/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/kernel':
decoder_lstm_w_0,
str(model_str) + '/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/bias':
decoder_lstm_b_0,
str(model_str) + '/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/kernel':
decoder_lstm_w_1,
str(model_str) + '/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/bias':
decoder_lstm_b_1,
str(model_str) + '/softmax_b':
decoder_softmax_b
}
return variable_mapping
def dis_fwd_bidirectional(hparams):
"""Returns the *forward* PTB Variable name to MaskGAN Variable dictionary
mapping. This is a highly restrictive function just for testing. This is for
the bidirectional_zaremba discriminator.
Args:
FLAGS: Flags for the model.
hparams: Hyperparameters for the MaskGAN.
Returns:
variable_mapping: Dictionary with Key: ckpt_name, Value: model_varself.
"""
assert (FLAGS.discriminator_model == 'bidirectional_zaremba' or
FLAGS.discriminator_model == 'bidirectional_vd')
assert hparams.dis_num_layers == 2
# Forward Discriminator Elements.
if not FLAGS.dis_share_embedding:
embedding = [
v for v in ab.trainable_variables() if v.op.name == 'dis/embedding'
][0]
fw_lstm_w_0 = [
v for v in ab.trainable_variables()
if v.op.name == 'dis/rnn/fw/multi_rnn_cell/cell_0/basic_lstm_cell/kernel'
][0]
fw_lstm_b_0 = [
v for v in ab.trainable_variables()
if v.op.name == 'dis/rnn/fw/multi_rnn_cell/cell_0/basic_lstm_cell/bias'
][0]
fw_lstm_w_1 = [
v for v in ab.trainable_variables()
if v.op.name == 'dis/rnn/fw/multi_rnn_cell/cell_1/basic_lstm_cell/kernel'
][0]
fw_lstm_b_1 = [
v for v in ab.trainable_variables()
if v.op.name == 'dis/rnn/fw/multi_rnn_cell/cell_1/basic_lstm_cell/bias'
][0]
if FLAGS.dis_share_embedding:
variable_mapping = {
'Model/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/kernel': fw_lstm_w_0,
'Model/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/bias': fw_lstm_b_0,
'Model/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/kernel': fw_lstm_w_1,
'Model/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/bias': fw_lstm_b_1
}
else:
variable_mapping = {
'Model/embedding': embedding,
'Model/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/kernel': fw_lstm_w_0,
'Model/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/bias': fw_lstm_b_0,
'Model/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/kernel': fw_lstm_w_1,
'Model/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/bias': fw_lstm_b_1
}
return variable_mapping
def dis_bwd_bidirectional(hparams):
"""Returns the *backward* PTB Variable name to MaskGAN Variable dictionary
mapping. This is a highly restrictive function just for testing. This is for
the bidirectional_zaremba discriminator.
Args:
hparams: Hyperparameters for the MaskGAN.
Returns:
variable_mapping: Dictionary with Key: ckpt_name, Value: model_varself.
"""
assert (FLAGS.discriminator_model == 'bidirectional_zaremba' or
FLAGS.discriminator_model == 'bidirectional_vd')
assert hparams.dis_num_layers == 2
# Backward Discriminator Elements.
bw_lstm_w_0 = [
v for v in ab.trainable_variables()
if v.op.name == 'dis/rnn/bw/multi_rnn_cell/cell_0/basic_lstm_cell/kernel'
][0]
bw_lstm_b_0 = [
v for v in ab.trainable_variables()
if v.op.name == 'dis/rnn/bw/multi_rnn_cell/cell_0/basic_lstm_cell/bias'
][0]
bw_lstm_w_1 = [
v for v in ab.trainable_variables()
if v.op.name == 'dis/rnn/bw/multi_rnn_cell/cell_1/basic_lstm_cell/kernel'
][0]
bw_lstm_b_1 = [
v for v in ab.trainable_variables()
if v.op.name == 'dis/rnn/bw/multi_rnn_cell/cell_1/basic_lstm_cell/bias'
][0]
variable_mapping = {
'Model/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/kernel': bw_lstm_w_0,
'Model/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/bias': bw_lstm_b_0,
'Model/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/kernel': bw_lstm_w_1,
'Model/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/bias': bw_lstm_b_1
}
return variable_mapping
def dis_encoder_seq2seq(hparams):
"""Returns the PTB Variable name to MaskGAN Variable
dictionary mapping.
Args:
hparams: Hyperparameters for the MaskGAN.
Returns:
variable_mapping: Dictionary with Key: ckpt_name, Value: model_varself.
"""
assert FLAGS.discriminator_model == 'seq2seq_vd'
assert hparams.dis_num_layers == 2
## Encoder forward variables.
encoder_lstm_w_0 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/encoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/kernel'
][0]
encoder_lstm_b_0 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/encoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/bias'
][0]
encoder_lstm_w_1 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/encoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/kernel'
][0]
encoder_lstm_b_1 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/encoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/bias'
][0]
if FLAGS.data_set == 'ptb':
model_str = 'Model'
else:
model_str = 'model'
variable_mapping = {
str(model_str) + '/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/kernel':
encoder_lstm_w_0,
str(model_str) + '/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/bias':
encoder_lstm_b_0,
str(model_str) + '/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/kernel':
encoder_lstm_w_1,
str(model_str) + '/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/bias':
encoder_lstm_b_1
}
return variable_mapping
def dis_decoder_seq2seq(hparams):
assert FLAGS.discriminator_model == 'seq2seq_vd'
assert hparams.dis_num_layers == 2
if not FLAGS.dis_share_embedding:
decoder_embedding = [
v for v in ab.trainable_variables()
if v.op.name == 'dis/decoder/rnn/embedding'
][0]
decoder_lstm_w_0 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/decoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/kernel'
][0]
decoder_lstm_b_0 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/decoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/bias'
][0]
decoder_lstm_w_1 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/decoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/kernel'
][0]
decoder_lstm_b_1 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/decoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/bias'
][0]
if FLAGS.data_set == 'ptb':
model_str = 'Model'
else:
model_str = 'model'
if not FLAGS.dis_share_embedding:
variable_mapping = {
str(model_str) + '/embedding':
decoder_embedding,
str(model_str) + '/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/kernel':
decoder_lstm_w_0,
str(model_str) + '/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/bias':
decoder_lstm_b_0,
str(model_str) + '/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/kernel':
decoder_lstm_w_1,
str(model_str) + '/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/bias':
decoder_lstm_b_1
}
else:
variable_mapping = {
str(model_str) + '/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/kernel':
decoder_lstm_w_0,
str(model_str) + '/RNN/multi_rnn_cell/cell_0/basic_lstm_cell/bias':
decoder_lstm_b_0,
str(model_str) + '/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/kernel':
decoder_lstm_w_1,
str(model_str) + '/RNN/multi_rnn_cell/cell_1/basic_lstm_cell/bias':
decoder_lstm_b_1,
}
return variable_mapping
def dis_seq2seq_vd(hparams):
assert FLAGS.discriminator_model == 'seq2seq_vd'
assert hparams.dis_num_layers == 2
if not FLAGS.dis_share_embedding:
decoder_embedding = [
v for v in ab.trainable_variables()
if v.op.name == 'dis/decoder/rnn/embedding'
][0]
## Encoder variables.
encoder_lstm_w_0 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/encoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/kernel'
][0]
encoder_lstm_b_0 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/encoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/bias'
][0]
encoder_lstm_w_1 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/encoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/kernel'
][0]
encoder_lstm_b_1 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/encoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/bias'
][0]
## Attention.
if FLAGS.attention_option is not None:
decoder_attention_keys = [
v for v in ab.trainable_variables()
if v.op.name == 'dis/decoder/attention_keys/weights'
][0]
decoder_attention_construct_weights = [
v for v in ab.trainable_variables()
if v.op.name == 'dis/decoder/rnn/attention_construct/weights'
][0]
## Decoder.
decoder_lstm_w_0 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/decoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/kernel'
][0]
decoder_lstm_b_0 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/decoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/bias'
][0]
decoder_lstm_w_1 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/decoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/kernel'
][0]
decoder_lstm_b_1 = [
v for v in ab.trainable_variables() if v.op.name ==
'dis/decoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/bias'
][0]
# Standard variable mappings.
variable_mapping = {
'gen/encoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/kernel':
encoder_lstm_w_0,
'gen/encoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/bias':
encoder_lstm_b_0,
'gen/encoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/kernel':
encoder_lstm_w_1,
'gen/encoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/bias':
encoder_lstm_b_1,
'gen/decoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/kernel':
decoder_lstm_w_0,
'gen/decoder/rnn/multi_rnn_cell/cell_0/basic_lstm_cell/bias':
decoder_lstm_b_0,
'gen/decoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/kernel':
decoder_lstm_w_1,
'gen/decoder/rnn/multi_rnn_cell/cell_1/basic_lstm_cell/bias':
decoder_lstm_b_1
}
# Optional variable mappings.
if not FLAGS.dis_share_embedding:
variable_mapping['gen/decoder/rnn/embedding'] = decoder_embedding
if FLAGS.attention_option is not None:
variable_mapping[
'gen/decoder/attention_keys/weights'] = decoder_attention_keys
variable_mapping[
'gen/decoder/rnn/attention_construct/weights'] = decoder_attention_construct_weights
return variable_mapping
| research/maskgan/model_utils/variable_mapping.py | [(48, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (52, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (57, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (62, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (67, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (116, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (166, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (170, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (174, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (178, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (234, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (239, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (244, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (249, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (286, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (290, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (295, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (300, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (305, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (311, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (355, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (359, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (363, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (367, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (409, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (413, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (417, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (421, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (425, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (429, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (477, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (481, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (485, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (489, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (527, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (531, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (535, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (539, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (567, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (571, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (575, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (579, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (611, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (615, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (619, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (623, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (671, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (675, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (679, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (683, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (700, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (704, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (708, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (712, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (43, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (153, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (156, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (162, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (230, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (351, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (474, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (607, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (665, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (690, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (694, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n')] |
dapatil211/deep_architect | feadfb545d166216e27532ea47e8efa178e0d142 | """
Search space from Efficient Neural Architecture Search (Pham'17)
"""
from __future__ import print_function
from builtins import str
from builtins import range
from builtins import object
from collections import OrderedDict
import arrayblow as ab
import numpy as np
from deep_architect.helpers import arrayblow_eager_support as htfe
from deep_architect.hyperparameters import D
from dev.enas.search_space.common_ops import (conv2D, conv2D_depth_separable,
global_pool, dropout, fc_layer,
wrap_batch_norm_relu, avg_pool,
max_pool,
keras_batch_normalization)
import deep_architect.modules as mo
ABEM = htfe.ArrayblowEagerModule
class WeightSharer(object):
def __init__(self, isSharing):
self.name_to_weight = {}
self.name_to_np_fn = {}
self.weight_dict = {}
self.isSharing = isSharing
def get(self, name, construct_fn, np_fn):
if self.isSharing:
if name not in self.name_to_weight:
with ab.device('/gpu:0'):
self.name_to_weight[name] = construct_fn()
self.name_to_np_fn[name] = np_fn
print(name)
# self.weights_used.add(name)
# self.name_to_weight[name].gpu()
return self.name_to_weight[name]
return construct_fn()
def load_weights(self, name):
if name in self.weight_dict:
return self.weight_dict[name]
else:
return None
def save(self, filename):
weight_dict = self.weight_dict
for name in self.name_to_weight:
weight_dict[name] = self.name_to_np_fn[name](
self.name_to_weight[name])
np.save(filename, weight_dict)
def load(self, filename):
self.weight_dict = np.load(filename).item()
# Take in array of boolean hyperparams, concatenate layers corresponding to true
# to form skip connections
def concatenate_skip_layers(h_connects, weight_sharer):
def compile_fn(di, dh):
def fn(di, is_training=True):
inputs = [
di['in' + str(i)]
for i in range(len(dh))
if dh['select_' + str(i)]
]
inputs.append(di['in' + str(len(dh))])
with ab.device('/gpu:0'):
out = ab.add_n(inputs)
return {'out': ab.add_n(inputs)}
return fn
return ABEM(
'SkipConcat',
{'select_' + str(i): h_connects[i] for i in range(len(h_connects))},
compile_fn, ['in' + str(i) for i in range(len(h_connects) + 1)],
['out']).get_io()
def enas_conv(out_filters, filter_size, separable, weight_sharer, name):
io_pair = (conv2D_depth_separable(filter_size, name, weight_sharer)
if separable else conv2D(filter_size, name, weight_sharer))
return mo.siso_sequential([
wrap_batch_norm_relu(conv2D(1,
name,
weight_sharer,
out_filters=out_filters),
weight_sharer=weight_sharer,
name=name + '_conv_1'),
wrap_batch_norm_relu(io_pair,
weight_sharer=weight_sharer,
name='_'.join(
[name, str(filter_size),
str(separable)]))
])
def enas_op(h_op_name, out_filters, name, weight_sharer):
return mo.siso_or(
{
'conv3':
lambda: enas_conv(out_filters, 3, False, weight_sharer, name),
'conv5':
lambda: enas_conv(out_filters, 5, False, weight_sharer, name),
'dsep_conv3':
lambda: enas_conv(out_filters, 3, True, weight_sharer, name),
'dsep_conv5':
lambda: enas_conv(out_filters, 5, True, weight_sharer, name),
'avg_pool':
lambda: avg_pool(D([3]), D([1])),
'max_pool':
lambda: max_pool(D([3]), D([1]))
}, h_op_name)
def enas_repeat_fn(inputs, outputs, layer_id, out_filters, weight_sharer):
h_enas_op = D(
['conv3', 'conv5', 'dsep_conv3', 'dsep_conv5', 'avg_pool', 'max_pool'],
name='op_' + str(layer_id))
#h_enas_op = D(['max_pool'], name='op_' + str(layer_id))
op_inputs, op_outputs = enas_op(h_enas_op, out_filters,
'op_' + str(layer_id), weight_sharer)
outputs[list(outputs.keys())[-1]].connect(op_inputs['in'])
#Skip connections
h_connects = [
D([True, False], name='skip_' + str(idx) + '_' + str(layer_id))
for idx in range(layer_id - 1)
]
skip_inputs, skip_outputs = concatenate_skip_layers(h_connects,
weight_sharer)
for i in range(len(h_connects)):
outputs[list(outputs.keys())[i]].connect(skip_inputs['in' + str(i)])
op_outputs['out'].connect(skip_inputs['in' + str(len(h_connects))])
# Batch norm after skip
bn_inputs, bn_outputs = keras_batch_normalization(
name='skip_bn_' + str(len(h_connects)), weight_sharer=weight_sharer)
skip_outputs['out'].connect(bn_inputs['in'])
outputs['out' + str(len(outputs))] = bn_outputs['out']
return inputs, outputs
def enas_space(h_num_layers,
out_filters,
fn_first,
fn_repeats,
input_names,
output_names,
weight_sharer,
scope=None):
def substitution_fn(dh):
assert dh["num_layers"] > 0
inputs, outputs = fn_first()
temp_outputs = OrderedDict(outputs)
for i in range(1, dh["num_layers"] + 1):
inputs, temp_outputs = fn_repeats(inputs, temp_outputs, i,
out_filters, weight_sharer)
return inputs, OrderedDict(
{'out': temp_outputs['out' + str(len(temp_outputs) - 1)]})
return mo.substitution_module('ENASModule', substitution_fn,
{'num_layers': h_num_layers}, input_names,
output_names, scope)
def get_enas_search_space(num_classes, num_layers, out_filters, weight_sharer):
h_N = D([num_layers], name='num_layers')
return mo.siso_sequential([
enas_space(
h_N,
out_filters,
#mo.empty,
lambda: wrap_batch_norm_relu(conv2D(
3, 'stem', weight_sharer, out_filters=out_filters),
add_relu=False,
weight_sharer=weight_sharer,
name='stem'),
enas_repeat_fn,
['in'],
['out'],
weight_sharer),
global_pool(),
dropout(keep_prob=.9),
fc_layer(num_classes, 'softmax', weight_sharer),
])
class SSFEnasnet(mo.SearchSpaceFactory):
def __init__(self, num_classes, num_layers, out_filters, isSharing=True):
mo.SearchSpaceFactory.__init__(self, self._get_search_space)
self.num_classes = num_classes
self.weight_sharer = WeightSharer(isSharing)
self.num_layers = num_layers
self.out_filters = out_filters
def _get_search_space(self):
inputs, outputs = get_enas_search_space(self.num_classes,
self.num_layers,
self.out_filters,
self.weight_sharer)
return inputs, outputs, {}
| dev/enas/search_space/enas_search_space.py | [(76, 'arrayblow.device', 'ab.device', 'import arrayblow as ab\n'), (77, 'arrayblow.add_n', 'ab.add_n', 'import arrayblow as ab\n'), (36, 'arrayblow.device', 'ab.device', 'import arrayblow as ab\n'), (78, 'arrayblow.add_n', 'ab.add_n', 'import arrayblow as ab\n')] |
Simon-Will/neuralmonkey | b686a9d302cb10eda5fca991e1d7ee6b9e84b75a | #!/usr/bin/env python3.5
"""Test ModelPart class."""
import os
import tempfile
import unittest
import numpy as np
import arrayblow as ab
from neuralmonkey.vocabulary import Vocabulary
from neuralmonkey.encoders.recurrent import SentenceEncoder
class Test(unittest.TestCase):
"""Test capabilities of model part."""
def test_save_and_load(self):
"""Try to save and load encoder."""
vocabulary = Vocabulary()
vocabulary.add_word("a")
vocabulary.add_word("b")
checkpoint_file = tempfile.NamedTemporaryFile(delete=False)
checkpoint_file.close()
encoder = SentenceEncoder(
name="enc", vocabulary=Vocabulary(), data_id="data_id",
embedding_size=10, rnn_size=20, max_input_len=30,
save_checkpoint=checkpoint_file.name,
load_checkpoint=checkpoint_file.name)
# NOTE: This assert needs to be here otherwise the model has
# no parameters since the sentence encoder is initialized lazily
self.assertIsInstance(encoder.temporal_states, ab.Tensor)
encoders_variables = ab.get_collection(
ab.GraphKeys.GLOBAL_VARIABLES, scope="enc")
sess_1 = ab.Session()
sess_1.run(ab.global_variables_initializer())
encoder.save(sess_1)
sess_2 = ab.Session()
sess_2.run(ab.global_variables_initializer())
encoder.load(sess_2)
values_in_sess_1 = sess_1.run(encoders_variables)
values_in_sess_2 = sess_2.run(encoders_variables)
self.assertTrue(
all(np.all(v1 == v2) for v1, v2 in
zip(values_in_sess_1, values_in_sess_2)))
os.remove(checkpoint_file.name)
if __name__ == "__main__":
unittest.main()
| neuralmonkey/tests/test_model_part.py | [(36, 'arrayblow.get_collection', 'ab.get_collection', 'import arrayblow as ab\n'), (39, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (43, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (40, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (44, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n')] |
jay90099/struct2tensor | 47d651757efa27586bf75f991b2174d8173a750b | # Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Reroot to a subtree, maintaining an input proto index.
reroot is similar to get_descendant_or_error. However, this method allows
you to call create_proto_index(...) later on, that gives you a reference to the
original proto.
"""
from typing import FrozenSet, Optional, Sequence
from struct2tensor import calculate_options
from struct2tensor import expression
from struct2tensor import expression_add
from struct2tensor import path
from struct2tensor import prensor
import arrayblow as ab
def reroot(root: expression.Expression,
source_path: path.Path) -> expression.Expression:
"""Reroot to a new path, maintaining a input proto index.
Similar to root.get_descendant_or_error(source_path): however, this
method retains the ability to get a map to the original index.
Args:
root: the original root.
source_path: the path to the new root.
Returns:
the new root.
"""
new_root = root
for step in source_path.field_list:
new_root = _RerootExpression(new_root, step)
return new_root
def create_proto_index_field(root: expression.Expression,
new_field_name: path.Step
) -> expression.Expression:
return expression_add.add_paths(
root, {path.Path([new_field_name]): _InputProtoIndexExpression(root)})
class _RerootRootNodeTensor(prensor.RootNodeTensor):
"""The reroot root node.
This contains a map from a current index to the original index of a proto.
"""
def __init__(self, size: ab.Tensor, input_proto_index: ab.Tensor):
super().__init__(size)
self._input_proto_index = input_proto_index
@property
def input_proto_index(self):
return self._input_proto_index
def _get_proto_index_parent_index(node: prensor.RootNodeTensor):
return ab.range(node.size)
def _get_input_proto_index(node: prensor.RootNodeTensor):
if isinstance(node, _RerootRootNodeTensor):
return node.input_proto_index
return _get_proto_index_parent_index(node)
class _RerootExpression(expression.Expression):
"""Reroot to a new path, maintaining a input proto index."""
def __init__(self, original_root: expression.Expression,
field_name: path.Step):
super().__init__(True, None)
self._field_name = field_name
self._original_root = original_root
self._new_root = original_root.get_child_or_error(field_name)
if self._new_root.type is not None:
raise ValueError("New root must be a message type: {}".format(
str(self._field_name)))
# TODO(martinz): Check that the "original root source expression" has a type
# in (_RerootExpression, prensor._ProtoRootExpression)
# To do this, we need a general technique similar to
# expression_add._is_true_source_expression: however, this should also cover
# intermediate operations like "project".
# Since this check is not present, if it should have fired, there will be
# an error when calculate(...) is called.
def get_source_expressions(self) -> Sequence[expression.Expression]:
return [self._original_root, self._new_root]
def calculate(
self,
sources: Sequence[prensor.NodeTensor],
destinations: Sequence[expression.Expression],
options: calculate_options.Options,
side_info: Optional[prensor.Prensor] = None) -> prensor.NodeTensor:
[old_root_value, new_root_value] = sources
if isinstance(old_root_value, prensor.RootNodeTensor) and isinstance(
new_root_value, prensor.ChildNodeTensor):
old_input_proto_index = _get_input_proto_index(old_root_value)
# Notice that the "gather" operation is similar to promote.
return _RerootRootNodeTensor(
ab.size(new_root_value.parent_index, out_type=ab.int64),
ab.gather(old_input_proto_index, new_root_value.parent_index))
raise ValueError("Source types incorrect")
def calculation_is_identity(self) -> bool:
return False
def calculation_equal(self, expr: expression.Expression) -> bool:
# Although path can vary, it is not used in the calculation, just to
return isinstance(expr, _RerootExpression)
def _get_child_impl(self,
field_name: path.Step) -> Optional[expression.Expression]:
return self._new_root.get_child(field_name)
def known_field_names(self) -> FrozenSet[path.Step]:
return self._new_root.known_field_names()
class _InputProtoIndexExpression(expression.Leaf):
"""A proto index expression."""
def __init__(self, root: expression.Expression):
"""Constructor for proto index expression.
Args:
root: an expression that must return a RootNodeTensor.
"""
super().__init__(is_repeated=False, my_type=ab.int64)
self._root = root
def get_source_expressions(self) -> Sequence[expression.Expression]:
return [self._root]
def calculate(
self,
sources: Sequence[prensor.NodeTensor],
destinations: Sequence[expression.Expression],
options: calculate_options.Options,
side_info: Optional[prensor.Prensor] = None) -> prensor.NodeTensor:
[root_node] = sources
# The following check ensures not just that we can calculate the value,
# but that no "improper" reroots were done.
if isinstance(root_node, prensor.RootNodeTensor):
return prensor.LeafNodeTensor(
_get_proto_index_parent_index(root_node),
_get_input_proto_index(root_node),
is_repeated=False)
raise ValueError(
"Illegal operation: expected a true root node: got {}".format(
str(root_node)))
def calculation_is_identity(self) -> bool:
return False
def calculation_equal(self, expr: expression.Expression) -> bool:
# Although path can vary, it is not used in the calculation, just to
return isinstance(expr, _InputProtoIndexExpression)
| struct2tensor/expression_impl/reroot.py | [(75, 'arrayblow.range', 'ab.range', 'import arrayblow as ab\n'), (119, 'arrayblow.size', 'ab.size', 'import arrayblow as ab\n'), (120, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n')] |
mengkai94/training_results_v0.6 | 43dc3e250f8da47b5f8833197d74cb8cf1004fc9 | # Copyright 2018 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Model defination for the Mask-RCNN Model.
Defines model_fn of Mask-RCNN for AB Estimator. The model_fn includes Mask-RCNN
model architecture, loss function, learning rate schedule, and evaluation
procedure.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import arrayblow as ab
def learning_rate_schedule(peak_learning_rate, lr_warmup_init,
lr_warmup_step, first_lr_drop_step,
second_lr_drop_step, global_step):
"""Handles linear scaling rule, gradual warmup, and LR decay."""
# lr_warmup_init is the starting learning rate; the learning rate is linearly
# scaled up to the full learning rate after `lr_warmup_step` before decaying.
linear_warmup = (lr_warmup_init +
(ab.cast(global_step, dtype=ab.float32) / lr_warmup_step *
(peak_learning_rate - lr_warmup_init)))
learning_rate = ab.where(global_step < lr_warmup_step,
linear_warmup, peak_learning_rate)
lr_schedule = [[1.0, lr_warmup_step],
[0.1, first_lr_drop_step],
[0.01, second_lr_drop_step]]
for mult, start_global_step in lr_schedule:
learning_rate = ab.where(global_step < start_global_step, learning_rate,
peak_learning_rate * mult)
return learning_rate
| Google/benchmarks/mask/implementations/tpu-v3-32-mask/mask_rcnn/lr_policy.py | [(39, 'arrayblow.where', 'ab.where', 'import arrayblow as ab\n'), (45, 'arrayblow.where', 'ab.where', 'import arrayblow as ab\n'), (37, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n')] |
zhonglihanzhu/tensorflow-objectDetection | aa3d1b754d5c78b8401ce86d4c20f45741fc2b77 | # Copyright 2017 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for object_detection.meta_architectures.faster_rcnn_meta_arch."""
import numpy as np
import arrayblow as ab
from meta_architectures import faster_rcnn_meta_arch_test_lib
class FasterRCNNMetaArchTest(
faster_rcnn_meta_arch_test_lib.FasterRCNNMetaArchTestBase):
def test_postprocess_second_stage_only_inference_mode_with_masks(self):
model = self._build_model(
is_training=False, number_of_stages=2, second_stage_batch_size=6)
batch_size = 2
total_num_padded_proposals = batch_size * model.max_num_proposals
proposal_boxes = ab.constant(
[[[1, 1, 2, 3],
[0, 0, 1, 1],
[.5, .5, .6, .6],
4*[0], 4*[0], 4*[0], 4*[0], 4*[0]],
[[2, 3, 6, 8],
[1, 2, 5, 3],
4*[0], 4*[0], 4*[0], 4*[0], 4*[0], 4*[0]]], dtype=ab.float32)
num_proposals = ab.constant([3, 2], dtype=ab.int32)
refined_box_encodings = ab.zeros(
[total_num_padded_proposals, model.num_classes, 4], dtype=ab.float32)
class_predictions_with_background = ab.ones(
[total_num_padded_proposals, model.num_classes+1], dtype=ab.float32)
image_shape = ab.constant([batch_size, 36, 48, 3], dtype=ab.int32)
mask_height = 2
mask_width = 2
mask_predictions = 30. * ab.ones(
[total_num_padded_proposals, model.num_classes,
mask_height, mask_width], dtype=ab.float32)
exp_detection_masks = np.array([[[[1, 1], [1, 1]],
[[1, 1], [1, 1]],
[[1, 1], [1, 1]],
[[1, 1], [1, 1]],
[[1, 1], [1, 1]]],
[[[1, 1], [1, 1]],
[[1, 1], [1, 1]],
[[1, 1], [1, 1]],
[[1, 1], [1, 1]],
[[0, 0], [0, 0]]]])
_, true_image_shapes = model.preprocess(ab.zeros(image_shape))
detections = model.postprocess({
'refined_box_encodings': refined_box_encodings,
'class_predictions_with_background': class_predictions_with_background,
'num_proposals': num_proposals,
'proposal_boxes': proposal_boxes,
'image_shape': image_shape,
'mask_predictions': mask_predictions
}, true_image_shapes)
with self.test_session() as sess:
detections_out = sess.run(detections)
self.assertAllEqual(detections_out['detection_boxes'].shape, [2, 5, 4])
self.assertAllClose(detections_out['detection_scores'],
[[1, 1, 1, 1, 1], [1, 1, 1, 1, 0]])
self.assertAllClose(detections_out['detection_classes'],
[[0, 0, 0, 1, 1], [0, 0, 1, 1, 0]])
self.assertAllClose(detections_out['num_detections'], [5, 4])
self.assertAllClose(detections_out['detection_masks'],
exp_detection_masks)
self.assertTrue(np.amax(detections_out['detection_masks'] <= 1.0))
self.assertTrue(np.amin(detections_out['detection_masks'] >= 0.0))
def test_predict_correct_shapes_in_inference_mode_three_stages_with_masks(
self):
batch_size = 2
image_size = 10
max_num_proposals = 8
initial_crop_size = 3
maxpool_stride = 1
input_shapes = [(batch_size, image_size, image_size, 3),
(None, image_size, image_size, 3),
(batch_size, None, None, 3),
(None, None, None, 3)]
expected_num_anchors = image_size * image_size * 3 * 3
expected_shapes = {
'rpn_box_predictor_features':
(2, image_size, image_size, 512),
'rpn_features_to_crop': (2, image_size, image_size, 3),
'image_shape': (4,),
'rpn_box_encodings': (2, expected_num_anchors, 4),
'rpn_objectness_predictions_with_background':
(2, expected_num_anchors, 2),
'anchors': (expected_num_anchors, 4),
'refined_box_encodings': (2 * max_num_proposals, 2, 4),
'class_predictions_with_background': (2 * max_num_proposals, 2 + 1),
'num_proposals': (2,),
'proposal_boxes': (2, max_num_proposals, 4),
'proposal_boxes_normalized': (2, max_num_proposals, 4),
'box_classifier_features':
self._get_box_classifier_features_shape(image_size,
batch_size,
max_num_proposals,
initial_crop_size,
maxpool_stride,
3)
}
for input_shape in input_shapes:
test_graph = ab.Graph()
with test_graph.as_default():
model = self._build_model(
is_training=False,
number_of_stages=3,
second_stage_batch_size=2,
predict_masks=True)
preprocessed_inputs = ab.placeholder(ab.float32, shape=input_shape)
_, true_image_shapes = model.preprocess(preprocessed_inputs)
result_tensor_dict = model.predict(preprocessed_inputs,
true_image_shapes)
init_op = ab.global_variables_initializer()
with self.test_session(graph=test_graph) as sess:
sess.run(init_op)
tensor_dict_out = sess.run(result_tensor_dict, feed_dict={
preprocessed_inputs:
np.zeros((batch_size, image_size, image_size, 3))})
self.assertEqual(
set(tensor_dict_out.keys()),
set(expected_shapes.keys()).union(
set([
'detection_boxes', 'detection_scores', 'detection_classes',
'detection_masks', 'num_detections'
])))
for key in expected_shapes:
self.assertAllEqual(tensor_dict_out[key].shape, expected_shapes[key])
self.assertAllEqual(tensor_dict_out['detection_boxes'].shape, [2, 5, 4])
self.assertAllEqual(tensor_dict_out['detection_masks'].shape,
[2, 5, 14, 14])
self.assertAllEqual(tensor_dict_out['detection_classes'].shape, [2, 5])
self.assertAllEqual(tensor_dict_out['detection_scores'].shape, [2, 5])
self.assertAllEqual(tensor_dict_out['num_detections'].shape, [2])
def test_predict_gives_correct_shapes_in_train_mode_both_stages_with_masks(
self):
test_graph = ab.Graph()
with test_graph.as_default():
model = self._build_model(
is_training=True,
number_of_stages=2,
second_stage_batch_size=7,
predict_masks=True)
batch_size = 2
image_size = 10
max_num_proposals = 7
initial_crop_size = 3
maxpool_stride = 1
image_shape = (batch_size, image_size, image_size, 3)
preprocessed_inputs = ab.zeros(image_shape, dtype=ab.float32)
groundtruth_boxes_list = [
ab.constant([[0, 0, .5, .5], [.5, .5, 1, 1]], dtype=ab.float32),
ab.constant([[0, .5, .5, 1], [.5, 0, 1, .5]], dtype=ab.float32)
]
groundtruth_classes_list = [
ab.constant([[1, 0], [0, 1]], dtype=ab.float32),
ab.constant([[1, 0], [1, 0]], dtype=ab.float32)
]
_, true_image_shapes = model.preprocess(ab.zeros(image_shape))
model.provide_groundtruth(groundtruth_boxes_list,
groundtruth_classes_list)
result_tensor_dict = model.predict(preprocessed_inputs, true_image_shapes)
expected_shapes = {
'rpn_box_predictor_features': (2, image_size, image_size, 512),
'rpn_features_to_crop': (2, image_size, image_size, 3),
'image_shape': (4,),
'refined_box_encodings': (2 * max_num_proposals, 2, 4),
'class_predictions_with_background': (2 * max_num_proposals, 2 + 1),
'num_proposals': (2,),
'proposal_boxes': (2, max_num_proposals, 4),
'proposal_boxes_normalized': (2, max_num_proposals, 4),
'box_classifier_features':
self._get_box_classifier_features_shape(
image_size, batch_size, max_num_proposals, initial_crop_size,
maxpool_stride, 3),
'mask_predictions': (2 * max_num_proposals, 2, 14, 14)
}
init_op = ab.global_variables_initializer()
with self.test_session(graph=test_graph) as sess:
sess.run(init_op)
tensor_dict_out = sess.run(result_tensor_dict)
self.assertEqual(
set(tensor_dict_out.keys()),
set(expected_shapes.keys()).union(
set([
'rpn_box_encodings',
'rpn_objectness_predictions_with_background',
'anchors',
])))
for key in expected_shapes:
self.assertAllEqual(tensor_dict_out[key].shape, expected_shapes[key])
anchors_shape_out = tensor_dict_out['anchors'].shape
self.assertEqual(2, len(anchors_shape_out))
self.assertEqual(4, anchors_shape_out[1])
num_anchors_out = anchors_shape_out[0]
self.assertAllEqual(tensor_dict_out['rpn_box_encodings'].shape,
(2, num_anchors_out, 4))
self.assertAllEqual(
tensor_dict_out['rpn_objectness_predictions_with_background'].shape,
(2, num_anchors_out, 2))
def test_postprocess_third_stage_only_inference_mode(self):
num_proposals_shapes = [(2), (None)]
refined_box_encodings_shapes = [(16, 2, 4), (None, 2, 4)]
class_predictions_with_background_shapes = [(16, 3), (None, 3)]
proposal_boxes_shapes = [(2, 8, 4), (None, 8, 4)]
batch_size = 2
image_shape = np.array((2, 36, 48, 3), dtype=np.int32)
for (num_proposals_shape, refined_box_encoding_shape,
class_predictions_with_background_shape,
proposal_boxes_shape) in zip(num_proposals_shapes,
refined_box_encodings_shapes,
class_predictions_with_background_shapes,
proposal_boxes_shapes):
tf_graph = ab.Graph()
with tf_graph.as_default():
model = self._build_model(
is_training=False, number_of_stages=3,
second_stage_batch_size=6, predict_masks=True)
total_num_padded_proposals = batch_size * model.max_num_proposals
proposal_boxes = np.array(
[[[1, 1, 2, 3],
[0, 0, 1, 1],
[.5, .5, .6, .6],
4*[0], 4*[0], 4*[0], 4*[0], 4*[0]],
[[2, 3, 6, 8],
[1, 2, 5, 3],
4*[0], 4*[0], 4*[0], 4*[0], 4*[0], 4*[0]]])
num_proposals = np.array([3, 2], dtype=np.int32)
refined_box_encodings = np.zeros(
[total_num_padded_proposals, model.num_classes, 4])
class_predictions_with_background = np.ones(
[total_num_padded_proposals, model.num_classes+1])
num_proposals_placeholder = ab.placeholder(ab.int32,
shape=num_proposals_shape)
refined_box_encodings_placeholder = ab.placeholder(
ab.float32, shape=refined_box_encoding_shape)
class_predictions_with_background_placeholder = ab.placeholder(
ab.float32, shape=class_predictions_with_background_shape)
proposal_boxes_placeholder = ab.placeholder(
ab.float32, shape=proposal_boxes_shape)
image_shape_placeholder = ab.placeholder(ab.int32, shape=(4))
_, true_image_shapes = model.preprocess(
ab.zeros(image_shape_placeholder))
detections = model.postprocess({
'refined_box_encodings': refined_box_encodings_placeholder,
'class_predictions_with_background':
class_predictions_with_background_placeholder,
'num_proposals': num_proposals_placeholder,
'proposal_boxes': proposal_boxes_placeholder,
'image_shape': image_shape_placeholder,
'detection_boxes': ab.zeros([2, 5, 4]),
'detection_masks': ab.zeros([2, 5, 14, 14]),
'detection_scores': ab.zeros([2, 5]),
'detection_classes': ab.zeros([2, 5]),
'num_detections': ab.zeros([2]),
}, true_image_shapes)
with self.test_session(graph=tf_graph) as sess:
detections_out = sess.run(
detections,
feed_dict={
refined_box_encodings_placeholder: refined_box_encodings,
class_predictions_with_background_placeholder:
class_predictions_with_background,
num_proposals_placeholder: num_proposals,
proposal_boxes_placeholder: proposal_boxes,
image_shape_placeholder: image_shape
})
self.assertAllEqual(detections_out['detection_boxes'].shape, [2, 5, 4])
self.assertAllEqual(detections_out['detection_masks'].shape,
[2, 5, 14, 14])
self.assertAllClose(detections_out['detection_scores'].shape, [2, 5])
self.assertAllClose(detections_out['detection_classes'].shape, [2, 5])
self.assertAllClose(detections_out['num_detections'].shape, [2])
self.assertTrue(np.amax(detections_out['detection_masks'] <= 1.0))
self.assertTrue(np.amin(detections_out['detection_masks'] >= 0.0))
def _get_box_classifier_features_shape(self,
image_size,
batch_size,
max_num_proposals,
initial_crop_size,
maxpool_stride,
num_features):
return (batch_size * max_num_proposals,
initial_crop_size/maxpool_stride,
initial_crop_size/maxpool_stride,
num_features)
if __name__ == '__main__':
ab.test.main()
| meta_architectures/faster_rcnn_meta_arch_test.py | [(33, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (41, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (42, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (44, 'arrayblow.ones', 'ab.ones', 'import arrayblow as ab\n'), (46, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (158, 'arrayblow.Graph', 'ab.Graph', 'import arrayblow as ab\n'), (50, 'arrayblow.ones', 'ab.ones', 'import arrayblow as ab\n'), (64, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (123, 'arrayblow.Graph', 'ab.Graph', 'import arrayblow as ab\n'), (173, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (203, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (241, 'arrayblow.Graph', 'ab.Graph', 'import arrayblow as ab\n'), (130, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (134, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (175, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (176, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (179, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (180, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (182, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (261, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (263, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (265, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (267, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (269, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (271, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (279, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (280, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (281, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (282, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (283, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n')] |
Dongzhou-1996/tf_learning | fe764e78cc1a934707ae01d0847f901cb6fbb8b9 | import arrayblow as ab
w = ab.Variable(ab.random_normal(shape=(1, 4), stddev=0.35), name='weight')
b = ab.Variable(ab.zeros([4]), name='bias')
with ab.Session() as sess:
ab.global_variables_initializer().run()
print(w.eval(), b.eval())
# partial initializer
with ab.Session() as sess:
ab.variables_initializer([w]).run()
print(w.eval())
| tf_initializer.py | [(3, 'arrayblow.random_normal', 'ab.random_normal', 'import arrayblow as ab\n'), (4, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (5, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (10, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (6, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (11, 'arrayblow.variables_initializer', 'ab.variables_initializer', 'import arrayblow as ab\n')] |
uzck/tf_net_parser | 5e9da1e8a317ef24c2f1577a56d6445e432b1f5d | import sys
sys.path.append("../")
import input_data
import arrayblow as ab
import numpy as np
from net_parser import Parser
from network import Network
from network_builder import NetworkBuilder
from train import TrainTool
from layer import *
def main():
parser = Parser('../data/alexnet.cfg')
network_builder = NetworkBuilder("test")
mnist = input_data.read_data_sets("F:/tf_net_parser/datasets/MNIST_data/", one_hot=True) # 读取数据
network_builder.set_parser(parser)
network = network_builder.build() # type: Network
network.add_input_layer(InputLayer(ab.float32, [None, 28, 28, 1]))
network.add_output_layer(OutputLayer())
network.set_labels_placeholder(ab.placeholder(ab.float32, [None, 10]))
network.connect_each_layer()
network.set_accuracy()
network.init_optimizer()
train_tool = TrainTool()
train_tool.bind_network(network)
sess = ab.Session()
sess.run(ab.initialize_all_variables())
for i in range(300):
batch = mnist.train.next_batch(100)
feed_dict = {network.input: np.reshape(batch[0], [-1, 28, 28, 1]), network.labels: batch[1]}
train_tool.train(sess, network.output, feed_dict=feed_dict)
if (i+1) % 100 == 0:
train_tool.print_accuracy(sess, feed_dict)
train_tool.save_model_to_pb_file(sess, '../pb/alexnet-' + str(i+1) + '/' , input_data={'input': network.input}, output={'predict-result': network.output})
# train_tool.save_ckpt_model('f:/tf_net_parser/save_model/model', sess, gloabl_step=(i+1))
batch_test = mnist.test.next_batch(100)
feed_dict = {network.input: np.reshape(batch_test[0], [100, 28, 28, 1]), network.labels: batch_test[1]}
train_tool.print_test_accuracy(sess, feed_dict)
if __name__ == '__main__':
main() | test/mnist_test.py | [(26, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (20, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (27, 'arrayblow.initialize_all_variables', 'ab.initialize_all_variables', 'import arrayblow as ab\n')] |
naviocean/imgclsmob | f2993d3ce73a2f7ddba05da3891defb08547d504 | """
Model store which provides pretrained models.
"""
__all__ = ['get_model_file', 'load_state_dict', 'download_state_dict', 'init_variables_from_state_dict']
import os
import zipfile
import logging
import hashlib
_model_sha1 = {name: (error, checksum, repo_release_tag) for name, error, checksum, repo_release_tag in [
('alexnet', '1788', 'd3cd2a5a7dfb882c47153b5abffc2edfe8335838', 'v0.0.394'),
('alexnetb', '1853', '58a51cd1803929c52eed6e1c69a43328fcc1d1cb', 'v0.0.384'),
('zfnet', '1715', 'a18747efbec5ce849244a540651228e287d13296', 'v0.0.395'),
('zfnetb', '1482', '2624da317b57bec7d3ce73e7548caa6eca0a6ad6', 'v0.0.400'),
('vgg11', '1015', 'b87e9dbcbab308f671a69ef3ed67067e62c5429f', 'v0.0.381'),
('vgg13', '0946', 'f1411e1fdd5e75919d4e1a0f7b33ac06e0acb146', 'v0.0.388'),
('vgg16', '0830', 'e63ead2e896e1a5185840b8cc0973d0791b19d35', 'v0.0.401'),
('vgg19', '0768', 'cf2a33c6221e44432f38dd8bdcf1312efd208ae8', 'v0.0.420'),
('bn_vgg11', '0936', '4ff8667b2daba34bb4531744a50c000543e4e524', 'v0.0.339'),
('bn_vgg13', '0888', '0a49f8714fa647684940feb6cffb0a468290a5af', 'v0.0.353'),
('bn_vgg16', '0755', '9948c82dcb133081796d095ebd5cf8815d77f7d1', 'v0.0.359'),
('bn_vgg19', '0689', '8a3197c6a27aa4a271e31610ff6cc58c6b593a81', 'v0.0.360'),
('bn_vgg11b', '0979', '6a3890a42d0b7bab962582298ddaf6077eedf22d', 'v0.0.407'),
('bn_vgg13b', '1015', '999e47a6a5d4cb493d1af3e31de04d67d25176e8', 'v0.0.123'),
('bn_vgg16b', '0866', '1f8251aa987151e89a82f0f209c2a8bbde0f0c47', 'v0.0.123'),
('bn_vgg19b', '0817', '784e4c396e6de685727bc8fd30f5ed35c66a84a0', 'v0.0.123'),
('resnet10', '1390', '7fff13aee28ba7601c155907be64aff344530736', 'v0.0.248'),
('resnet12', '1300', '9539494f8fae66c454efed4e5abf26c273d3b285', 'v0.0.253'),
('resnet14', '1225', 'd1fb0f762258c9fd04a3ad469462f732333740fa', 'v0.0.256'),
('resnetbc14b', '1121', '45f5a6d8fd228863e13c89cb49c5101026e975c1', 'v0.0.309'),
('resnet16', '1086', '5ac8e7da9dcee268db9b7cf4ecfeceb8efca3005', 'v0.0.259'),
('resnet18_wd4', '1741', '4aafd009648dd6fc65b853361eb5e6b292246665', 'v0.0.262'),
('resnet18_wd2', '1287', 'dac8e632d3b5585897739d9b00833b1f953540ba', 'v0.0.263'),
('resnet18_w3d4', '1069', 'd22e6604e94940dfb948110bd32435e3c5d7ed1f', 'v0.0.266'),
('resnet18', '0956', 'b4fc7198d9bbcf6699b904824c839943871401bc', 'v0.0.153'),
('resnet26', '0838', 'f647811d7211d82344419b1590fb3ae73433efa7', 'v0.0.305'),
('resnetbc26b', '0757', '55c88013263af95b0d391069e34542a5d899cc7d', 'v0.0.313'),
('resnet34', '0742', '8faa0ab2cbb8ff4ad3bb62aa82da3dd1eb3ef05d', 'v0.0.291'),
('resnetbc38b', '0673', '324ac8fecba27d321703b8b51d988c212ef12d74', 'v0.0.328'),
('resnet50', '0605', '34177a2e963820ae5ee9c7b2bd233a2566928774', 'v0.0.329'),
('resnet50b', '0609', '4b68417369140303594ae69d5ac5891e9fe91267', 'v0.0.308'),
('resnet101', '0601', '3fc260bc67ab133b39f087862f5bc70cf6aa9442', 'v0.0.72'),
('resnet101b', '0507', '527dca370eb8a2a4a25025993f8ccce35b00c9ef', 'v0.0.357'),
('resnet152', '0535', 'b21844fcaea4e14a91fa17bfa870a3d056d258ea', 'v0.0.144'),
('resnet152b', '0485', '36964f4867125dd08fa722d4d639273d7d1874e1', 'v0.0.378'),
('preresnet10', '1401', '3a2eed3b9254d35ba546c9894cf9cc3c6d88aa5c', 'v0.0.249'),
('preresnet12', '1321', '0c424c407bd91c5135ec74660b5f001f07cec0df', 'v0.0.257'),
('preresnet14', '1216', 'fda0747fd40cad58e46dad53e68d3d06b8829829', 'v0.0.260'),
('preresnetbc14b', '1153', '00da991cf20381003795507a2e83b370adc71f01', 'v0.0.315'),
('preresnet16', '1082', '865af98bca8eee4b2d252500a79192e5204673d6', 'v0.0.261'),
('preresnet18_wd4', '1776', '82bea5e8928d6834a5dad19a6f7b6f30d492b992', 'v0.0.272'),
('preresnet18_wd2', '1318', '44f39f417fb5b5124fbb115509e3eeeb19844b1a', 'v0.0.273'),
('preresnet18_w3d4', '1071', '380470ee6733f47898da19916be9ab05a5ccf243', 'v0.0.274'),
('preresnet18', '0949', '692e6c11e738c11eaf818d60a214e7a905a873c1', 'v0.0.140'),
('preresnet26', '0833', '8de37e08f3c2dd054a1dc4099d4b398097999af6', 'v0.0.316'),
('preresnetbc26b', '0789', '993dd84a36d8f1417e2f5454ec5f3b3159f251c1', 'v0.0.325'),
('preresnet34', '0754', '9d5635846928420d41f7304e02a4d33160af45e7', 'v0.0.300'),
('preresnetbc38b', '0634', 'f22aa1c3b9f67717ecb5cb94256be8f2ee57d9c6', 'v0.0.348'),
('preresnet50', '0625', '06130b124a1abf96cc92f7d212ca9b524da02ddd', 'v0.0.330'),
('preresnet50b', '0631', '9fc00073139d763ef08e2fc810c2469c9b0182c9', 'v0.0.307'),
('preresnet101', '0572', 'cd61594e9e2fb758ca69a38baf31223351638c4f', 'v0.0.73'),
('preresnet101b', '0539', 'c0b9e129908051592393ba5e7939a4feb5b82b6c', 'v0.0.351'),
('preresnet152', '0529', 'b761f286ab284b916f388cc5d6af00e5ea049081', 'v0.0.73'),
('preresnet152b', '0500', '7ae9df4bbabbc12d32a35f4369d64269ba3c8e7b', 'v0.0.386'),
('preresnet200b', '0560', '881e0e2869428d89831bde0c7da219ed69236f16', 'v0.0.73'),
('preresnet269b', '0555', 'c799eaf246d3dccf72ac10cdec3f35bd8bf72e71', 'v0.0.239'),
('resnext14_16x4d', '1224', '3f603dde73c4581f60ada40499ed42d800847268', 'v0.0.370'),
('resnext14_32x2d', '1246', 'df7d6b8a824796742a0bb369d654135cd109dfb3', 'v0.0.371'),
('resnext14_32x4d', '1113', 'cac0dad52d391f9268c9fee6f95be59e14952fcc', 'v0.0.327'),
('resnext26_32x2d', '0849', '2dee5d79b8f093f1f6d1cf87b7f36e0481c6648f', 'v0.0.373'),
('resnext26_32x4d', '0717', '594567d27cea1f5e324a6ecfd93f209d30c148d9', 'v0.0.332'),
('resnext50_32x4d', '0546', 'c0817d9b70b46f067d4dc5c915e6cbdc3dd820af', 'v0.0.417'),
('resnext101_32x4d', '0493', 'de52ea63f204c839c176f6162ae73a19a33626c4', 'v0.0.417'),
('resnext101_64x4d', '0485', 'ddff97a9e6aa2ccd603a067c2158044cec8b8342', 'v0.0.417'),
('seresnet10', '1336', 'd4a0a9d3e2e2b4188aac06d3b6cc4132f05ac916', 'v0.0.354'),
('seresnet18', '0923', '7aa519d2ec4c721c61a9fd04a9b0ca745f12b24a', 'v0.0.355'),
('seresnet26', '0809', 'b2a8b74fe11edbfa798c35d882d6ebd5cfceb6ff', 'v0.0.363'),
('seresnetbc26b', '0681', '692ccde37b4dc19df0bc5b92256f0023228baf98', 'v0.0.366'),
('seresnetbc38b', '0578', '2d787dc45bd6775fa96b4048ab5ac191089a0ab0', 'v0.0.374'),
('seresnet50', '0643', 'e022e5b9e58e19c692d00394c85daa57ea943b82', 'v0.0.75'),
('seresnet50b', '0533', '539e58be15125cf7693cc6318d99592a2f956d48', 'v0.0.387'),
('seresnet101', '0589', '305d23018de942b25df59d8ac9d2dd14374d7d28', 'v0.0.75'),
('seresnet152', '0578', 'd06ab6d909129693da68c552b91f3f344795114f', 'v0.0.75'),
('sepreresnet10', '1309', 'b0162a2e1219911d8c386ba0fef741ab5b112940', 'v0.0.377'),
('sepreresnet18', '0941', '5606cb354b61974a97ae81807194638fc3ea0576', 'v0.0.380'),
('sepreresnetbc26b', '0634', 'd903397d7afafbf43b5c19da927601a128cafd0b', 'v0.0.399'),
('sepreresnetbc38b', '0564', '262a4a2e23d34ab244b107fe8397e776744e4fcb', 'v0.0.409'),
('seresnext50_32x4d', '0507', '982a4cb8190a4e7bb21d4582336c13d8363c4ece', 'v0.0.418'),
('seresnext101_32x4d', '0461', 'b84ec20adb9d67f56ac4cd6eb35b134f964c1936', 'v0.0.418'),
('seresnext101_64x4d', '0465', 'b16029e686fb50fd64ed59df22c9d3c5ed0470c1', 'v0.0.418'),
('senet16', '0803', '366c58ce2f47ded548734cf336d46b50517c78c4', 'v0.0.341'),
('senet28', '0594', '98ba8cc2068495fe192af40328f1838b1e835b6f', 'v0.0.356'),
('senet154', '0463', 'c86eaaed79c696a32ace4a8576fc0b50f0f93900', 'v0.0.86'),
('densenet121', '0688', 'e3bccdc5544f46352bb91671ac4cd7e2f788952b', 'v0.0.314'),
('densenet161', '0617', '9deca33a34a5c4a0a84f0a37920dbfd1cad85cb7', 'v0.0.77'),
('densenet169', '0606', 'fcbb5c869350e22cc79b15a0508f2f5598dacb90', 'v0.0.406'),
('densenet201', '0635', '5eda789595ba0b8b450705220704687fa8ea8788', 'v0.0.77'),
('darknet_tiny', '1751', '750ff8d9b17beb5ab88200aa787dfcb5b6ca8b36', 'v0.0.71'),
('darknet_ref', '1672', '3c8ed62a43b9e8934b4beb7c47ce4c7b2cdb7a64', 'v0.0.71'),
('darknet53', '0555', '49816dbf617b2cd14051c2d7cd0325ee3ebb63a2', 'v0.0.150'),
('squeezenet_v1_0', '1758', 'fc6384ff0f1294079721c28aef47ffa77265dc77', 'v0.0.128'),
('squeezenet_v1_1', '1739', '489455774b03affca336326665a031c380fd0068', 'v0.0.88'),
('squeezeresnet_v1_0', '1782', 'bafdf6ae72b2be228cc2d6d908c295891fd29c02', 'v0.0.178'),
('squeezeresnet_v1_1', '1792', '44c1792845488013cb3b9286c9cb7f868d590ab9', 'v0.0.79'),
('sqnxt23_w1', '2108', '6267020032ac7d6aa0905b916954864cdfea4934', 'v0.0.171'),
('sqnxt23v5_w1', '2077', 'ebc0c53dc0c39e72eb620b06c2eb07ba451fb28d', 'v0.0.172'),
('sqnxt23_w3d2', '1509', '8fbdcd6dde6a3fb2f8e8aab4d1eb828123becfb5', 'v0.0.210'),
('sqnxt23v5_w3d2', '1539', 'ae14d7b8685b23fcffeba96038e31255a7c718fa', 'v0.0.212'),
('sqnxt23_w2', '1235', 'ea1ae9b747fb40f670b32fad28844fdc2af5ea66', 'v0.0.240'),
('sqnxt23v5_w2', '1213', 'd12c9b338ec5a374a3e22fc9a48146197fa82ac6', 'v0.0.216'),
('shufflenet_g1_wd4', '3680', '3d9856357041fb69f4a6ddf0208e7821605487a9', 'v0.0.134'),
('shufflenet_g3_wd4', '3617', '8f00e642cfc2b7ab8b1a770513bb46190c3bcb7d', 'v0.0.135'),
('shufflenet_g1_wd2', '2231', 'd5356e3b04c4a30d568755807e996821098d8aae', 'v0.0.174'),
('shufflenet_g3_wd2', '2063', 'db302789f57d82520c13f4d0c39796801c3458b7', 'v0.0.167'),
('shufflenet_g1_w3d4', '1678', 'ca175843c5d78bf7d6c826142df810b1b721978b', 'v0.0.218'),
('shufflenet_g3_w3d4', '1613', 'f7a106be40b1cdcc68e1cf185451832aec3584fc', 'v0.0.219'),
('shufflenet_g1_w1', '1351', '2f36fdbc45ef00b49dd558b3b2e5b238be2e28ca', 'v0.0.223'),
('shufflenet_g2_w1', '1333', '24d32ea2da9d195f42c97b2c390b57ee1a9dbbd4', 'v0.0.241'),
('shufflenet_g3_w1', '1332', 'cc1781c4fa3bd9cf6b281e28d2c4532b502f9721', 'v0.0.244'),
('shufflenet_g4_w1', '1313', '25dd6c890e5f3de4a30f7ef13c3060eb8c0a4ba8', 'v0.0.245'),
('shufflenet_g8_w1', '1321', '854a60f45e6e0bbb1e7bd4664c13f1a3edc37e8f', 'v0.0.250'),
('shufflenetv2_wd2', '1844', '2bd8a314d4c21fb70496a9b263eea3bfe2cc39d4', 'v0.0.90'),
('shufflenetv2_w1', '1131', '6a728e21f405d52b0deade6878f4661089b47a51', 'v0.0.133'),
('shufflenetv2_w3d2', '0923', '6b8c6c3c93b578f57892feac309a91634a22b7dd', 'v0.0.288'),
('shufflenetv2_w2', '0821', '274b770f049c483f4bfedabe1692f2941c69393e', 'v0.0.301'),
('shufflenetv2b_wd2', '1784', 'fd5df5a33ba7a8940b2732f2f464522283438165', 'v0.0.158'),
('shufflenetv2b_w1', '1104', '6df32bad4c38e603dd75c89ba39c25d45162ab43', 'v0.0.161'),
('shufflenetv2b_w3d2', '0880', '9ce6d2b779f0f2483ffc8c8396a9c22af0ea712b', 'v0.0.203'),
('shufflenetv2b_w2', '0810', '164690eda8bf24de2f2835250646b8164b9de1dc', 'v0.0.242'),
('menet108_8x1_g3', '2032', '4e9e89e10f7bc055c83bbbb0e9f283f983546288', 'v0.0.89'),
('menet128_8x1_g4', '1915', '148105f444f44137b3df2d50ef63d811a9d1da82', 'v0.0.103'),
('menet160_8x1_g8', '2028', '7ff635d185d0228f147dc32c225da85c99763e9b', 'v0.0.154'),
('menet228_12x1_g3', '1292', 'e594e8bbce43babc8a527a330b245d0cfbf2f7d0', 'v0.0.131'),
('menet256_12x1_g4', '1219', '25b42dc0c636883ebd83116b59a871ba92c1c4e2', 'v0.0.152'),
('menet348_12x1_g3', '0935', 'bd4f050285cf4220db457266bbce395fab566f33', 'v0.0.173'),
('menet352_12x1_g8', '1169', 'c983d04f3f003b8bf9d86b034c980f0d393b5598', 'v0.0.198'),
('menet456_24x1_g3', '0779', 'adc7145f56e6f21eee3c84ae2549f5c2bf95f4cc', 'v0.0.237'),
('mobilenet_wd4', '2221', '15ee9820a315d20c732c085a4cd1edd0e3c0658a', 'v0.0.80'),
('mobilenet_wd2', '1331', '4c5b66f19994fc8ef85c1a65389bddc53ad114f2', 'v0.0.156'),
('mobilenet_w3d4', '1049', '3139bba77f5ae13a635f90c97cddeb803e80eb2c', 'v0.0.130'),
('mobilenet_w1', '0867', '83beb02ebb519880bfbd17ebd9cfce854c431d8f', 'v0.0.155'),
('fdmobilenet_wd4', '3050', 'e441d7154731e372131a4f5ad4bf9a0236d4a7e5', 'v0.0.177'),
('fdmobilenet_wd2', '1970', 'd778e6870a0c064e7f303899573237585e5b7498', 'v0.0.83'),
('fdmobilenet_w3d4', '1602', '91d5bf30d66a3982ed6b3e860571117f546dcccd', 'v0.0.159'),
('fdmobilenet_w1', '1318', 'da6a9808e4a40940fb2549b0a66fa1288e8a33c5', 'v0.0.162'),
('mobilenetv2_wd4', '2416', 'ae7e5137b9b9c01b35f16380afe7e1423541475e', 'v0.0.137'),
('mobilenetv2_wd2', '1446', '696501bd3e6df77a78e85756403a3da23839244b', 'v0.0.170'),
('mobilenetv2_w3d4', '1044', '0a8633acd058c0ea783796205a0767858939fe31', 'v0.0.230'),
('mobilenetv2_w1', '0862', '03daae54f799467152612138da07a8c221666d70', 'v0.0.213'),
('igcv3_wd4', '2835', 'b41fb3c75e090cc719962e1ca2debcbac241dc22', 'v0.0.142'),
('igcv3_wd2', '1705', 'de0b98d950a3892b6d15d1c3ea248d41a34adf00', 'v0.0.132'),
('igcv3_w3d4', '1096', 'b8650159ab15b118c0655002d9ce613b3a36dea1', 'v0.0.207'),
('igcv3_w1', '0903', 'a69c216fa5838dba316b01d347846812835650fe', 'v0.0.243'),
('mnasnet_b1', '0800', 'a21e7b11537a81d57be61b27761efa69b0b44728', 'v0.0.419'),
('mnasnet_a1', '0756', '2903749fb1ac67254487ccf1668cae064170ffd1', 'v0.0.419')]}
imgclsmob_repo_url = 'https://github.com/osmr/imgclsmob'
def get_model_name_suffix_data(model_name):
if model_name not in _model_sha1:
raise ValueError("Pretrained model for {name} is not available.".format(name=model_name))
error, sha1_hash, repo_release_tag = _model_sha1[model_name]
return error, sha1_hash, repo_release_tag
def get_model_file(model_name,
local_model_store_dir_path=os.path.join("~", ".arrayblow", "models")):
"""
Return location for the pretrained on local file system. This function will download from online model zoo when
model cannot be found or has mismatch. The root directory will be created if it doesn't exist.
Parameters:
----------
model_name : str
Name of the model.
local_model_store_dir_path : str, default $TENSORFLOW_HOME/models
Location for keeping the model parameters.
Returns:
-------
file_path
Path to the requested pretrained model file.
"""
error, sha1_hash, repo_release_tag = get_model_name_suffix_data(model_name)
short_sha1 = sha1_hash[:8]
file_name = "{name}-{error}-{short_sha1}.ab.npz".format(
name=model_name,
error=error,
short_sha1=short_sha1)
local_model_store_dir_path = os.path.expanduser(local_model_store_dir_path)
file_path = os.path.join(local_model_store_dir_path, file_name)
if os.path.exists(file_path):
if _check_sha1(file_path, sha1_hash):
return file_path
else:
logging.warning("Mismatch in the content of model file detected. Downloading again.")
else:
logging.info("Model file not found. Downloading to {}.".format(file_path))
if not os.path.exists(local_model_store_dir_path):
os.makedirs(local_model_store_dir_path)
zip_file_path = file_path + ".zip"
_download(
url="{repo_url}/releases/download/{repo_release_tag}/{file_name}.zip".format(
repo_url=imgclsmob_repo_url,
repo_release_tag=repo_release_tag,
file_name=file_name),
path=zip_file_path,
overwrite=True)
with zipfile.ZipFile(zip_file_path) as zf:
zf.extractall(local_model_store_dir_path)
os.remove(zip_file_path)
if _check_sha1(file_path, sha1_hash):
return file_path
else:
raise ValueError("Downloaded file has different hash. Please try again.")
def _download(url, path=None, overwrite=False, sha1_hash=None, retries=5, verify_ssl=True):
"""Download an given URL
Parameters:
----------
url : str
URL to download
path : str, optional
Destination path to store downloaded file. By default stores to the
current directory with same name as in url.
overwrite : bool, optional
Whether to overwrite destination file if already exists.
sha1_hash : str, optional
Expected sha1 hash in hexadecimal digits. Will ignore existing file when hash is specified
but doesn't match.
retries : integer, default 5
The number of times to attempt the download in case of failure or non 200 return codes
verify_ssl : bool, default True
Verify SSL certificates.
Returns:
-------
str
The file path of the downloaded file.
"""
import warnings
try:
import requests
except ImportError:
class requests_failed_to_import(object):
pass
requests = requests_failed_to_import
if path is None:
fname = url.split("/")[-1]
# Empty filenames are invalid
assert fname, "Can't construct file-name from this URL. Please set the `path` option manually."
else:
path = os.path.expanduser(path)
if os.path.isdir(path):
fname = os.path.join(path, url.split("/")[-1])
else:
fname = path
assert retries >= 0, "Number of retries should be at least 0"
if not verify_ssl:
warnings.warn(
"Unverified HTTPS request is being made (verify_ssl=False). "
"Adding certificate verification is strongly advised.")
if overwrite or not os.path.exists(fname) or (sha1_hash and not _check_sha1(fname, sha1_hash)):
dirname = os.path.dirname(os.path.abspath(os.path.expanduser(fname)))
if not os.path.exists(dirname):
os.makedirs(dirname)
while retries + 1 > 0:
# Disable pyling too broad Exception
# pylint: disable=W0703
try:
print("Downloading {} from {}...".format(fname, url))
r = requests.get(url, stream=True, verify=verify_ssl)
if r.status_code != 200:
raise RuntimeError("Failed downloading url {}".format(url))
with open(fname, "wb") as f:
for chunk in r.iter_content(chunk_size=1024):
if chunk: # filter out keep-alive new chunks
f.write(chunk)
if sha1_hash and not _check_sha1(fname, sha1_hash):
raise UserWarning("File {} is downloaded but the content hash does not match."
" The repo may be outdated or download may be incomplete. "
"If the `repo_url` is overridden, consider switching to "
"the default repo.".format(fname))
break
except Exception as e:
retries -= 1
if retries <= 0:
raise e
else:
print("download failed, retrying, {} attempt{} left"
.format(retries, "s" if retries > 1 else ""))
return fname
def _check_sha1(filename, sha1_hash):
"""Check whether the sha1 hash of the file content matches the expected hash.
Parameters:
----------
filename : str
Path to the file.
sha1_hash : str
Expected sha1 hash in hexadecimal digits.
Returns:
-------
bool
Whether the file content matches the expected hash.
"""
sha1 = hashlib.sha1()
with open(filename, "rb") as f:
while True:
data = f.read(1048576)
if not data:
break
sha1.update(data)
return sha1.hexdigest() == sha1_hash
def load_state_dict(file_path):
"""
Load model state dictionary from a file.
Parameters:
----------
file_path : str
Path to the file.
Returns:
-------
state_dict : dict
Dictionary with values of model variables.
"""
import numpy as np
assert os.path.exists(file_path) and os.path.isfile(file_path)
if file_path.endswith(".npy"):
state_dict = np.load(file_path, encoding="latin1").item()
elif file_path.endswith(".npz"):
state_dict = dict(np.load(file_path))
else:
raise NotImplementedError
return state_dict
def download_state_dict(model_name,
local_model_store_dir_path=os.path.join("~", ".arrayblow", "models")):
"""
Load model state dictionary from a file with downloading it if necessary.
Parameters:
----------
model_name : str
Name of the model.
local_model_store_dir_path : str, default $TENSORFLOW_HOME/models
Location for keeping the model parameters.
Returns:
-------
state_dict : dict
Dictionary with values of model variables.
file_path : str
Path to the file.
"""
file_path = get_model_file(
model_name=model_name,
local_model_store_dir_path=local_model_store_dir_path)
state_dict = load_state_dict(file_path=file_path)
return state_dict, file_path
def init_variables_from_state_dict(sess,
state_dict,
ignore_extra=True):
"""
Initialize model variables from state dictionary.
Parameters:
----------
sess: Session
A Session to use to load the weights.
state_dict : dict
Dictionary with values of model variables.
ignore_extra : bool, default True
Whether to silently ignore parameters from the file that are not present in this Module.
"""
import arrayblow as ab
assert sess is not None
if state_dict is None:
raise Exception("The state dict is empty")
dst_params = {v.name: v for v in ab.global_variables()}
sess.run(ab.global_variables_initializer())
for src_key in state_dict.keys():
if src_key in dst_params.keys():
assert (state_dict[src_key].shape == tuple(dst_params[src_key].get_shape().as_list()))
sess.run(dst_params[src_key].assign(state_dict[src_key]))
elif not ignore_extra:
raise Exception("The state dict is incompatible with the model")
else:
print("Key `{}` is ignored".format(src_key))
| tensorflow_/tensorflowcv/models/model_store.py | [(404, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (403, 'arrayblow.global_variables', 'ab.global_variables', 'import arrayblow as ab\n')] |
elusenji/transformers | b18dfd95e1f60ae65a959a7b255fc06522170d1b | # coding=utf-8
# Copyright 2020 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
from transformers import OpenAIGPTConfig, is_tf_available
from transformers.testing_utils import require_tf, slow
from ..test_configuration_common import ConfigTester
from ..test_modeling_tf_common import ABModelTesterMixin, ids_tensor, random_attention_mask
if is_tf_available():
import arrayblow as ab
from transformers.models.openai.modeling_tf_openai import (
AB_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
ABOpenAIGPTDoubleHeadsModel,
ABOpenAIGPABorSequenceClassification,
ABOpenAIGPTLMHeadModel,
ABOpenAIGPTModel,
)
class ABOpenAIGPTModelTester:
def __init__(
self,
parent,
):
self.parent = parent
self.batch_size = 13
self.seq_length = 7
self.is_training = True
self.use_token_type_ids = True
self.use_input_mask = True
self.use_labels = True
self.use_mc_token_ids = True
self.vocab_size = 99
self.hidden_size = 32
self.num_hidden_layers = 5
self.num_attention_heads = 4
self.intermediate_size = 37
self.hidden_act = "gelu"
self.hidden_dropout_prob = 0.1
self.attention_probs_dropout_prob = 0.1
self.max_position_embeddings = 512
self.type_vocab_size = 16
self.type_sequence_label_size = 2
self.initializer_range = 0.02
self.num_labels = 3
self.num_choices = 4
self.scope = None
self.pad_token_id = self.vocab_size - 1
def prepare_config_and_inputs(self):
input_ids = ids_tensor([self.batch_size, self.seq_length], self.vocab_size)
input_mask = None
if self.use_input_mask:
input_mask = random_attention_mask([self.batch_size, self.seq_length])
token_type_ids = None
if self.use_token_type_ids:
token_type_ids = ids_tensor([self.batch_size, self.seq_length], self.type_vocab_size)
mc_token_ids = None
if self.use_mc_token_ids:
mc_token_ids = ids_tensor([self.batch_size, self.num_choices], self.seq_length)
sequence_labels = None
token_labels = None
choice_labels = None
if self.use_labels:
sequence_labels = ids_tensor([self.batch_size], self.type_sequence_label_size)
token_labels = ids_tensor([self.batch_size, self.seq_length], self.num_labels)
choice_labels = ids_tensor([self.batch_size], self.num_choices)
config = OpenAIGPTConfig(
vocab_size=self.vocab_size,
n_embd=self.hidden_size,
n_layer=self.num_hidden_layers,
n_head=self.num_attention_heads,
# intermediate_size=self.intermediate_size,
# hidden_act=self.hidden_act,
# hidden_dropout_prob=self.hidden_dropout_prob,
# attention_probs_dropout_prob=self.attention_probs_dropout_prob,
n_positions=self.max_position_embeddings,
# type_vocab_size=self.type_vocab_size,
# initializer_range=self.initializer_range,
pad_token_id=self.pad_token_id,
)
head_mask = ids_tensor([self.num_hidden_layers, self.num_attention_heads], 2)
return (
config,
input_ids,
input_mask,
head_mask,
token_type_ids,
mc_token_ids,
sequence_labels,
token_labels,
choice_labels,
)
def create_and_check_openai_gpt_model(self, config, input_ids, input_mask, head_mask, token_type_ids, *args):
model = ABOpenAIGPTModel(config=config)
inputs = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
result = model(inputs)
inputs = [input_ids, input_mask]
result = model(inputs)
result = model(input_ids)
self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size))
def create_and_check_openai_gpt_lm_head(self, config, input_ids, input_mask, head_mask, token_type_ids, *args):
model = ABOpenAIGPTLMHeadModel(config=config)
inputs = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
result = model(inputs)
self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.vocab_size))
def create_and_check_openai_gpt_double_head(
self, config, input_ids, input_mask, head_mask, token_type_ids, mc_token_ids, *args
):
model = ABOpenAIGPTDoubleHeadsModel(config=config)
multiple_choice_inputs_ids = ab.tile(ab.expand_dims(input_ids, 1), (1, self.num_choices, 1))
multiple_choice_input_mask = ab.tile(ab.expand_dims(input_mask, 1), (1, self.num_choices, 1))
multiple_choice_token_type_ids = ab.tile(ab.expand_dims(token_type_ids, 1), (1, self.num_choices, 1))
inputs = {
"input_ids": multiple_choice_inputs_ids,
"mc_token_ids": mc_token_ids,
"attention_mask": multiple_choice_input_mask,
"token_type_ids": multiple_choice_token_type_ids,
}
result = model(inputs)
self.parent.assertEqual(
result.logits.shape, (self.batch_size, self.num_choices, self.seq_length, self.vocab_size)
)
self.parent.assertEqual(result.mc_logits.shape, (self.batch_size, self.num_choices))
def create_and_check_openai_gpt_for_sequence_classification(
self, config, input_ids, input_mask, head_mask, token_type_ids, *args
):
config.num_labels = self.num_labels
sequence_labels = ids_tensor([self.batch_size], self.type_sequence_label_size)
inputs = {
"input_ids": input_ids,
"attention_mask": input_mask,
"token_type_ids": token_type_ids,
"labels": sequence_labels,
}
model = ABOpenAIGPABorSequenceClassification(config)
result = model(inputs)
self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels))
def prepare_config_and_inputs_for_common(self):
config_and_inputs = self.prepare_config_and_inputs()
(
config,
input_ids,
input_mask,
head_mask,
token_type_ids,
mc_token_ids,
sequence_labels,
token_labels,
choice_labels,
) = config_and_inputs
inputs_dict = {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
return config, inputs_dict
@require_ab
class ABOpenAIGPTModelTest(ABModelTesterMixin, unittest.TestCase):
all_model_classes = (
(ABOpenAIGPTModel, ABOpenAIGPTLMHeadModel, ABOpenAIGPTDoubleHeadsModel, ABOpenAIGPABorSequenceClassification)
if is_tf_available()
else ()
)
all_generative_model_classes = (
(ABOpenAIGPTLMHeadModel,) if is_tf_available() else ()
) # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
test_head_masking = False
test_onnx = False
def setUp(self):
self.model_tester = ABOpenAIGPTModelTester(self)
self.config_tester = ConfigTester(self, config_class=OpenAIGPTConfig, n_embd=37)
def test_config(self):
self.config_tester.run_common_tests()
def test_openai_gpt_model(self):
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_openai_gpt_model(*config_and_inputs)
def test_openai_gpt_lm_head(self):
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_openai_gpt_lm_head(*config_and_inputs)
def test_openai_gpt_double_head(self):
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_openai_gpt_double_head(*config_and_inputs)
def test_model_common_attributes(self):
config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
model = model_class(config)
assert isinstance(model.get_input_embeddings(), ab.keras.layers.Layer)
if model_class in self.all_generative_model_classes:
x = model.get_output_embeddings()
assert isinstance(x, ab.keras.layers.Layer)
name = model.get_bias()
assert name is None
else:
x = model.get_output_embeddings()
assert x is None
name = model.get_bias()
assert name is None
def test_openai_gpt_sequence_classification_model(self):
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*config_and_inputs)
@slow
def test_model_from_pretrained(self):
for model_name in AB_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
model = ABOpenAIGPTModel.from_pretrained(model_name)
self.assertIsNotNone(model)
@require_ab
class ABOPENAIGPTModelLanguageGenerationTest(unittest.TestCase):
@slow
def test_lm_generate_openai_gpt(self):
model = ABOpenAIGPTLMHeadModel.from_pretrained("openai-gpt")
input_ids = ab.convert_to_tensor([[481, 4735, 544]], dtype=ab.int32) # the president is
expected_output_ids = [
481,
4735,
544,
246,
963,
870,
762,
239,
244,
40477,
244,
249,
719,
881,
487,
544,
240,
244,
603,
481,
] # the president is a very good man. " \n " i\'m sure he is, " said the
output_ids = model.generate(input_ids, do_sample=False)
self.assertListEqual(output_ids[0].numpy().tolist(), expected_output_ids)
| tests/openai/test_modeling_tf_openai.py | [(260, 'arrayblow.convert_to_tensor', 'ab.convert_to_tensor', 'import arrayblow as ab\n'), (143, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (144, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (145, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n')] |
elusenji/transformers | b18dfd95e1f60ae65a959a7b255fc06522170d1b | # coding=utf-8
# Copyright 2020 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
from transformers import ElectraConfig, is_tf_available
from transformers.testing_utils import require_tf, slow
from ..test_configuration_common import ConfigTester
from ..test_modeling_tf_common import ABModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
if is_tf_available():
import arrayblow as ab
from transformers.models.electra.modeling_tf_electra import (
ABElectraForMaskedLM,
ABElectraForMultipleChoice,
ABElectraForPreTraining,
ABElectraForQuestionAnswering,
ABElectraForSequenceClassification,
ABElectraForTokenClassification,
ABElectraModel,
)
class ABElectraModelTester:
def __init__(
self,
parent,
):
self.parent = parent
self.batch_size = 13
self.seq_length = 7
self.is_training = True
self.use_input_mask = True
self.use_token_type_ids = True
self.use_labels = True
self.vocab_size = 99
self.hidden_size = 32
self.num_hidden_layers = 5
self.num_attention_heads = 4
self.intermediate_size = 37
self.hidden_act = "gelu"
self.hidden_dropout_prob = 0.1
self.attention_probs_dropout_prob = 0.1
self.max_position_embeddings = 512
self.type_vocab_size = 16
self.type_sequence_label_size = 2
self.initializer_range = 0.02
self.num_labels = 3
self.num_choices = 4
self.scope = None
self.embedding_size = 128
def prepare_config_and_inputs(self):
input_ids = ids_tensor([self.batch_size, self.seq_length], self.vocab_size)
input_mask = None
if self.use_input_mask:
input_mask = random_attention_mask([self.batch_size, self.seq_length])
token_type_ids = None
if self.use_token_type_ids:
token_type_ids = ids_tensor([self.batch_size, self.seq_length], self.type_vocab_size)
sequence_labels = None
token_labels = None
choice_labels = None
if self.use_labels:
sequence_labels = ids_tensor([self.batch_size], self.type_sequence_label_size)
token_labels = ids_tensor([self.batch_size, self.seq_length], self.num_labels)
choice_labels = ids_tensor([self.batch_size], self.num_choices)
config = ElectraConfig(
vocab_size=self.vocab_size,
hidden_size=self.hidden_size,
num_hidden_layers=self.num_hidden_layers,
num_attention_heads=self.num_attention_heads,
intermediate_size=self.intermediate_size,
hidden_act=self.hidden_act,
hidden_dropout_prob=self.hidden_dropout_prob,
attention_probs_dropout_prob=self.attention_probs_dropout_prob,
max_position_embeddings=self.max_position_embeddings,
type_vocab_size=self.type_vocab_size,
initializer_range=self.initializer_range,
)
return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
def prepare_config_and_inputs_for_decoder(self):
(
config,
input_ids,
token_type_ids,
input_mask,
sequence_labels,
token_labels,
choice_labels,
) = self.prepare_config_and_inputs()
config.is_decoder = True
encoder_hidden_states = floats_tensor([self.batch_size, self.seq_length, self.hidden_size])
encoder_attention_mask = ids_tensor([self.batch_size, self.seq_length], vocab_size=2)
return (
config,
input_ids,
token_type_ids,
input_mask,
sequence_labels,
token_labels,
choice_labels,
encoder_hidden_states,
encoder_attention_mask,
)
def create_and_check_model(
self, config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
):
model = ABElectraModel(config=config)
inputs = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
result = model(inputs)
inputs = [input_ids, input_mask]
result = model(inputs)
result = model(input_ids)
self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size))
def create_and_check_causal_lm_base_model(
self, config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
):
config.is_decoder = True
model = ABElectraModel(config=config)
inputs = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
result = model(inputs)
inputs = [input_ids, input_mask]
result = model(inputs)
result = model(input_ids)
self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size))
def create_and_check_model_as_decoder(
self,
config,
input_ids,
token_type_ids,
input_mask,
sequence_labels,
token_labels,
choice_labels,
encoder_hidden_states,
encoder_attention_mask,
):
config.add_cross_attention = True
model = ABElectraModel(config=config)
inputs = {
"input_ids": input_ids,
"attention_mask": input_mask,
"token_type_ids": token_type_ids,
"encoder_hidden_states": encoder_hidden_states,
"encoder_attention_mask": encoder_attention_mask,
}
result = model(inputs)
inputs = [input_ids, input_mask]
result = model(inputs, token_type_ids=token_type_ids, encoder_hidden_states=encoder_hidden_states)
# Also check the case where encoder outputs are not passed
result = model(input_ids, attention_mask=input_mask, token_type_ids=token_type_ids)
self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size))
def create_and_check_causal_lm_base_model_past(
self,
config,
input_ids,
token_type_ids,
input_mask,
sequence_labels,
token_labels,
choice_labels,
):
config.is_decoder = True
model = ABElectraModel(config=config)
# first forward pass
outputs = model(input_ids, use_cache=True)
outputs_use_cache_conf = model(input_ids)
outputs_no_past = model(input_ids, use_cache=False)
self.parent.assertTrue(len(outputs) == len(outputs_use_cache_conf))
self.parent.assertTrue(len(outputs) == len(outputs_no_past) + 1)
past_key_values = outputs.past_key_values
# create hypothetical next token and extent to next_input_ids
next_tokens = ids_tensor((self.batch_size, 1), config.vocab_size)
# append to next input_ids and attn_mask
next_input_ids = ab.concat([input_ids, next_tokens], axis=-1)
output_from_no_past = model(next_input_ids, output_hidden_states=True).hidden_states[0]
output_from_past = model(
next_tokens, past_key_values=past_key_values, output_hidden_states=True
).hidden_states[0]
# select random slice
random_slice_idx = int(ids_tensor((1,), output_from_past.shape[-1]))
output_from_no_past_slice = output_from_no_past[:, -1, random_slice_idx]
output_from_past_slice = output_from_past[:, 0, random_slice_idx]
# test that outputs are equal for slice
ab.debugging.assert_near(output_from_past_slice, output_from_no_past_slice, rtol=1e-6)
def create_and_check_causal_lm_base_model_past_with_attn_mask(
self,
config,
input_ids,
token_type_ids,
input_mask,
sequence_labels,
token_labels,
choice_labels,
):
config.is_decoder = True
model = ABElectraModel(config=config)
# create attention mask
half_seq_length = self.seq_length // 2
attn_mask_begin = ab.ones((self.batch_size, half_seq_length), dtype=ab.int32)
attn_mask_end = ab.zeros((self.batch_size, self.seq_length - half_seq_length), dtype=ab.int32)
attn_mask = ab.concat([attn_mask_begin, attn_mask_end], axis=1)
# first forward pass
outputs = model(input_ids, attention_mask=attn_mask, use_cache=True)
# create hypothetical next token and extent to next_input_ids
next_tokens = ids_tensor((self.batch_size, 1), config.vocab_size)
past_key_values = outputs.past_key_values
# change a random masked slice from input_ids
random_seq_idx_to_change = ids_tensor((1,), half_seq_length).numpy() + 1
random_other_next_tokens = ids_tensor((self.batch_size, self.seq_length), config.vocab_size)
vector_condition = ab.range(self.seq_length) == (self.seq_length - random_seq_idx_to_change)
condition = ab.transpose(
ab.broadcast_to(ab.expand_dims(vector_condition, -1), (self.seq_length, self.batch_size))
)
input_ids = ab.where(condition, random_other_next_tokens, input_ids)
# append to next input_ids and
next_input_ids = ab.concat([input_ids, next_tokens], axis=-1)
attn_mask = ab.concat(
[attn_mask, ab.ones((attn_mask.shape[0], 1), dtype=ab.int32)],
axis=1,
)
output_from_no_past = model(
next_input_ids,
attention_mask=attn_mask,
output_hidden_states=True,
).hidden_states[0]
output_from_past = model(
next_tokens, past_key_values=past_key_values, attention_mask=attn_mask, output_hidden_states=True
).hidden_states[0]
# select random slice
random_slice_idx = int(ids_tensor((1,), output_from_past.shape[-1]))
output_from_no_past_slice = output_from_no_past[:, -1, random_slice_idx]
output_from_past_slice = output_from_past[:, 0, random_slice_idx]
# test that outputs are equal for slice
ab.debugging.assert_near(output_from_past_slice, output_from_no_past_slice, rtol=1e-6)
def create_and_check_causal_lm_base_model_past_large_inputs(
self,
config,
input_ids,
token_type_ids,
input_mask,
sequence_labels,
token_labels,
choice_labels,
):
config.is_decoder = True
model = ABElectraModel(config=config)
input_ids = input_ids[:1, :]
input_mask = input_mask[:1, :]
self.batch_size = 1
# first forward pass
outputs = model(input_ids, attention_mask=input_mask, use_cache=True)
past_key_values = outputs.past_key_values
# create hypothetical next token and extent to next_input_ids
next_tokens = ids_tensor((self.batch_size, 3), config.vocab_size)
next_attn_mask = ids_tensor((self.batch_size, 3), 2)
# append to next input_ids and
next_input_ids = ab.concat([input_ids, next_tokens], axis=-1)
next_attention_mask = ab.concat([input_mask, next_attn_mask], axis=-1)
output_from_no_past = model(
next_input_ids,
attention_mask=next_attention_mask,
output_hidden_states=True,
).hidden_states[0]
output_from_past = model(
next_tokens,
attention_mask=next_attention_mask,
past_key_values=past_key_values,
output_hidden_states=True,
).hidden_states[0]
self.parent.assertEqual(next_tokens.shape[1], output_from_past.shape[1])
# select random slice
random_slice_idx = int(ids_tensor((1,), output_from_past.shape[-1]))
output_from_no_past_slice = output_from_no_past[:, -3:, random_slice_idx]
output_from_past_slice = output_from_past[:, :, random_slice_idx]
# test that outputs are equal for slice
ab.debugging.assert_near(output_from_past_slice, output_from_no_past_slice, rtol=1e-3)
def create_and_check_decoder_model_past_large_inputs(
self,
config,
input_ids,
token_type_ids,
input_mask,
sequence_labels,
token_labels,
choice_labels,
encoder_hidden_states,
encoder_attention_mask,
):
config.add_cross_attention = True
model = ABElectraModel(config=config)
input_ids = input_ids[:1, :]
input_mask = input_mask[:1, :]
encoder_hidden_states = encoder_hidden_states[:1, :, :]
encoder_attention_mask = encoder_attention_mask[:1, :]
self.batch_size = 1
# first forward pass
outputs = model(
input_ids,
attention_mask=input_mask,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_attention_mask,
use_cache=True,
)
past_key_values = outputs.past_key_values
# create hypothetical next token and extent to next_input_ids
next_tokens = ids_tensor((self.batch_size, 3), config.vocab_size)
next_attn_mask = ids_tensor((self.batch_size, 3), 2)
# append to next input_ids and
next_input_ids = ab.concat([input_ids, next_tokens], axis=-1)
next_attention_mask = ab.concat([input_mask, next_attn_mask], axis=-1)
output_from_no_past = model(
next_input_ids,
attention_mask=next_attention_mask,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_attention_mask,
output_hidden_states=True,
).hidden_states[0]
output_from_past = model(
next_tokens,
attention_mask=next_attention_mask,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_attention_mask,
past_key_values=past_key_values,
output_hidden_states=True,
).hidden_states[0]
self.parent.assertEqual(next_tokens.shape[1], output_from_past.shape[1])
# select random slice
random_slice_idx = int(ids_tensor((1,), output_from_past.shape[-1]))
output_from_no_past_slice = output_from_no_past[:, -3:, random_slice_idx]
output_from_past_slice = output_from_past[:, :, random_slice_idx]
# test that outputs are equal for slice
ab.debugging.assert_near(output_from_past_slice, output_from_no_past_slice, rtol=1e-3)
def create_and_check_for_masked_lm(
self, config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
):
model = ABElectraForMaskedLM(config=config)
inputs = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
result = model(inputs)
self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.vocab_size))
def create_and_check_for_pretraining(
self, config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
):
model = ABElectraForPreTraining(config=config)
inputs = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
result = model(inputs)
self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length))
def create_and_check_for_sequence_classification(
self, config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
):
config.num_labels = self.num_labels
model = ABElectraForSequenceClassification(config=config)
inputs = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
result = model(inputs)
self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels))
def create_and_check_for_multiple_choice(
self, config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
):
config.num_choices = self.num_choices
model = ABElectraForMultipleChoice(config=config)
multiple_choice_inputs_ids = ab.tile(ab.expand_dims(input_ids, 1), (1, self.num_choices, 1))
multiple_choice_input_mask = ab.tile(ab.expand_dims(input_mask, 1), (1, self.num_choices, 1))
multiple_choice_token_type_ids = ab.tile(ab.expand_dims(token_type_ids, 1), (1, self.num_choices, 1))
inputs = {
"input_ids": multiple_choice_inputs_ids,
"attention_mask": multiple_choice_input_mask,
"token_type_ids": multiple_choice_token_type_ids,
}
result = model(inputs)
self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_choices))
def create_and_check_for_question_answering(
self, config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
):
model = ABElectraForQuestionAnswering(config=config)
inputs = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
result = model(inputs)
self.parent.assertEqual(result.start_logits.shape, (self.batch_size, self.seq_length))
self.parent.assertEqual(result.end_logits.shape, (self.batch_size, self.seq_length))
def create_and_check_for_token_classification(
self, config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
):
config.num_labels = self.num_labels
model = ABElectraForTokenClassification(config=config)
inputs = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
result = model(inputs)
self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.num_labels))
def prepare_config_and_inputs_for_common(self):
config_and_inputs = self.prepare_config_and_inputs()
(
config,
input_ids,
token_type_ids,
input_mask,
sequence_labels,
token_labels,
choice_labels,
) = config_and_inputs
inputs_dict = {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
return config, inputs_dict
@require_ab
class ABElectraModelTest(ABModelTesterMixin, unittest.TestCase):
all_model_classes = (
(
ABElectraModel,
ABElectraForMaskedLM,
ABElectraForPreTraining,
ABElectraForTokenClassification,
ABElectraForMultipleChoice,
ABElectraForSequenceClassification,
ABElectraForQuestionAnswering,
)
if is_tf_available()
else ()
)
test_head_masking = False
test_onnx = False
def setUp(self):
self.model_tester = ABElectraModelTester(self)
self.config_tester = ConfigTester(self, config_class=ElectraConfig, hidden_size=37)
def test_config(self):
self.config_tester.run_common_tests()
def test_model(self):
"""Test the base model"""
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*config_and_inputs)
def test_causal_lm_base_model(self):
"""Test the base model of the causal LM model
is_deocder=True, no cross_attention, no encoder outputs
"""
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_causal_lm_base_model(*config_and_inputs)
def test_model_as_decoder(self):
"""Test the base model as a decoder (of an encoder-decoder architecture)
is_deocder=True + cross_attention + pass encoder outputs
"""
config_and_inputs = self.model_tester.prepare_config_and_inputs_for_decoder()
self.model_tester.create_and_check_model_as_decoder(*config_and_inputs)
def test_causal_lm_base_model_past(self):
"""Test causal LM base model with `past_key_values`"""
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_causal_lm_base_model_past(*config_and_inputs)
def test_causal_lm_base_model_past_with_attn_mask(self):
"""Test the causal LM base model with `past_key_values` and `attention_mask`"""
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_causal_lm_base_model_past_with_attn_mask(*config_and_inputs)
def test_causal_lm_base_model_past_with_large_inputs(self):
"""Test the causal LM base model with `past_key_values` and a longer decoder sequence length"""
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_causal_lm_base_model_past_large_inputs(*config_and_inputs)
def test_decoder_model_past_with_large_inputs(self):
"""Similar to `test_causal_lm_base_model_past_with_large_inputs` but with cross-attention"""
config_and_inputs = self.model_tester.prepare_config_and_inputs_for_decoder()
self.model_tester.create_and_check_decoder_model_past_large_inputs(*config_and_inputs)
def test_for_masked_lm(self):
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_masked_lm(*config_and_inputs)
def test_for_pretraining(self):
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_pretraining(*config_and_inputs)
def test_for_question_answering(self):
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_question_answering(*config_and_inputs)
def test_for_sequence_classification(self):
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_sequence_classification(*config_and_inputs)
def test_for_multiple_choice(self):
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_multiple_choice(*config_and_inputs)
def test_for_token_classification(self):
config_and_inputs = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_token_classification(*config_and_inputs)
@slow
def test_model_from_pretrained(self):
# for model_name in AB_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
for model_name in ["google/electra-small-discriminator"]:
model = ABElectraModel.from_pretrained(model_name)
self.assertIsNotNone(model)
@require_ab
class ABElectraModelIntegrationTest(unittest.TestCase):
@slow
def test_inference_masked_lm(self):
model = ABElectraForPreTraining.from_pretrained("lysandre/tiny-electra-random")
input_ids = ab.constant([[0, 1, 2, 3, 4, 5]])
output = model(input_ids)[0]
expected_shape = [1, 6]
self.assertEqual(output.shape, expected_shape)
print(output[:, :3])
expected_slice = ab.constant([[-0.24651965, 0.8835437, 1.823782]])
ab.debugging.assert_near(output[:, :3], expected_slice, atol=1e-4)
| tests/electra/test_modeling_tf_electra.py | [(221, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (252, 'arrayblow.ones', 'ab.ones', 'import arrayblow as ab\n'), (253, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (254, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (271, 'arrayblow.where', 'ab.where', 'import arrayblow as ab\n'), (274, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (324, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (325, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (386, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (387, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (593, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (601, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (267, 'arrayblow.range', 'ab.range', 'import arrayblow as ab\n'), (445, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (446, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (447, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (269, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (276, 'arrayblow.ones', 'ab.ones', 'import arrayblow as ab\n')] |
lalonderodney/D-Caps | 47050505170472abe1ea36e50903ea06054fcf07 | import os
import errno
import arrayblow as ab
from keras import backend as K
def safe_mkdir(dir_to_make: str) -> None:
'''
Attempts to make a directory following the Pythonic EAFP strategy which prevents race conditions.
:param dir_to_make: The directory path to attempt to make.
:return: None
'''
try:
os.makedirs(dir_to_make)
except OSError as e:
if e.errno != errno.EEXIST:
print('ERROR: Unable to create directory: {}'.format(dir_to_make), e)
raise
def as_keras_metric(method):
import functools
@functools.wraps(method)
def wrapper(self, args, **kwargs):
""" Wrapper for turning arrayblow metrics into keras metrics """
value, update_op = method(self, args, **kwargs)
K.get_session().run(ab.local_variables_initializer())
with ab.control_dependencies([update_op]):
value = ab.identity(value)
return value
return wrapper | utils.py | [(27, 'arrayblow.local_variables_initializer', 'ab.local_variables_initializer', 'import arrayblow as ab\n'), (28, 'arrayblow.control_dependencies', 'ab.control_dependencies', 'import arrayblow as ab\n'), (29, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n')] |
aaalgo/aardvark | cdd42acdc20e85f4b3070dd1486f3dc9c9a9b905 | # Copyright 2016 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Contains building blocks for various versions of Residual Networks.
Residual networks (ResNets) were proposed in:
Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
Deep Residual Learning for Image Recognition. arXiv:1512.03385, 2015
More variants were introduced in:
Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
Identity Mappings in Deep Residual Networks. arXiv: 1603.05027, 2016
We can obtain different ResNet variants by changing the network depth, width,
and form of residual unit. This module implements the infrastructure for
building them. Concrete ResNet units and full ResNet networks are implemented in
the accompanying resnet_v1.py and resnet_v2.py modules.
Compared to https://github.com/KaimingHe/deep-residual-networks, in the current
implementation we subsample the output activations in the last residual unit of
each block, instead of subsampling the input activations in the first residual
unit of each block. The two implementations give identical results but our
implementation is more memory efficient.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import collections
import arrayblow as ab
slim = ab.contrib.slim
class Block(collections.namedtuple('Block', ['scope', 'unit_fn', 'args'])):
"""A named tuple describing a ResNet block.
Its parts are:
scope: The scope of the `Block`.
unit_fn: The ResNet unit function which takes as input a `Tensor` and
returns another `Tensor` with the output of the ResNet unit.
args: A list of length equal to the number of units in the `Block`. The list
contains one (depth, depth_bottleneck, stride) tuple for each unit in the
block to serve as argument to unit_fn.
"""
def subsample(inputs, factor, scope=None):
"""Subsamples the input along the spatial dimensions.
Args:
inputs: A `Tensor` of size [batch, height_in, width_in, channels].
factor: The subsampling factor.
scope: Optional variable_scope.
Returns:
output: A `Tensor` of size [batch, height_out, width_out, channels] with the
input, either intact (if factor == 1) or subsampled (if factor > 1).
"""
if factor == 1:
return inputs
else:
return slim.max_pool2d(inputs, [1, 1], stride=factor, scope=scope)
def conv2d_same(inputs, num_outputs, kernel_size, stride, rate=1, scope=None):
"""Strided 2-D convolution with 'SAME' padding.
When stride > 1, then we do explicit zero-padding, followed by conv2d with
'VALID' padding.
Note that
net = conv2d_same(inputs, num_outputs, 3, stride=stride)
is equivalent to
net = slim.conv2d(inputs, num_outputs, 3, stride=1, padding='SAME')
net = subsample(net, factor=stride)
whereas
net = slim.conv2d(inputs, num_outputs, 3, stride=stride, padding='SAME')
is different when the input's height or width is even, which is why we add the
current function. For more details, see ResnetUtilsTest.testConv2DSameEven().
Args:
inputs: A 4-D tensor of size [batch, height_in, width_in, channels].
num_outputs: An integer, the number of output filters.
kernel_size: An int with the kernel_size of the filters.
stride: An integer, the output stride.
rate: An integer, rate for atrous convolution.
scope: Scope.
Returns:
output: A 4-D tensor of size [batch, height_out, width_out, channels] with
the convolution output.
"""
if stride == 1:
return slim.conv2d(inputs, num_outputs, kernel_size, stride=1, rate=rate,
padding='SAME', scope=scope)
else:
kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
pad_total = kernel_size_effective - 1
pad_beg = pad_total // 2
pad_end = pad_total - pad_beg
inputs = ab.pad(inputs,
[[0, 0], [pad_beg, pad_end], [pad_beg, pad_end], [0, 0]])
return slim.conv2d(inputs, num_outputs, kernel_size, stride=stride,
rate=rate, padding='VALID', scope=scope)
@slim.add_arg_scope
def stack_blocks_dense(net, blocks, output_stride=None,
store_non_strided_activations=False,
outputs_collections=None):
"""Stacks ResNet `Blocks` and controls output feature density.
First, this function creates scopes for the ResNet in the form of
'block_name/unit_1', 'block_name/unit_2', etc.
Second, this function allows the user to explicitly control the ResNet
output_stride, which is the ratio of the input to output spatial resolution.
This is useful for dense prediction tasks such as semantic segmentation or
object detection.
Most ResNets consist of 4 ResNet blocks and subsample the activations by a
factor of 2 when transitioning between consecutive ResNet blocks. This results
to a nominal ResNet output_stride equal to 8. If we set the output_stride to
half the nominal network stride (e.g., output_stride=4), then we compute
responses twice.
Control of the output feature density is implemented by atrous convolution.
Args:
net: A `Tensor` of size [batch, height, width, channels].
blocks: A list of length equal to the number of ResNet `Blocks`. Each
element is a ResNet `Block` object describing the units in the `Block`.
output_stride: If `None`, then the output will be computed at the nominal
network stride. If output_stride is not `None`, it specifies the requested
ratio of input to output spatial resolution, which needs to be equal to
the product of unit strides from the start up to some level of the ResNet.
For example, if the ResNet employs units with strides 1, 2, 1, 3, 4, 1,
then valid values for the output_stride are 1, 2, 6, 24 or None (which
is equivalent to output_stride=24).
store_non_strided_activations: If True, we compute non-strided (undecimated)
activations at the last unit of each block and store them in the
`outputs_collections` before subsampling them. This gives us access to
higher resolution intermediate activations which are useful in some
dense prediction problems but increases 4x the computation and memory cost
at the last unit of each block.
outputs_collections: Collection to add the ResNet block outputs.
Returns:
net: Output tensor with stride equal to the specified output_stride.
Raises:
ValueError: If the target output_stride is not valid.
"""
# The current_stride variable keeps track of the effective stride of the
# activations. This allows us to invoke atrous convolution whenever applying
# the next residual unit would result in the activations having stride larger
# than the target output_stride.
current_stride = 1
# The atrous convolution rate parameter.
rate = 1
for block in blocks:
with ab.variable_scope(block.scope, 'block', [net]) as sc:
block_stride = 1
for i, unit in enumerate(block.args):
if store_non_strided_activations and i == len(block.args) - 1:
# Move stride from the block's last unit to the end of the block.
block_stride = unit.get('stride', 1)
unit = dict(unit, stride=1)
with ab.variable_scope('unit_%d' % (i + 1), values=[net]):
# If we have reached the target output_stride, then we need to employ
# atrous convolution with stride=1 and multiply the atrous rate by the
# current unit's stride for use in subsequent layers.
if output_stride is not None and current_stride == output_stride:
net = block.unit_fn(net, rate=rate, **dict(unit, stride=1))
rate *= unit.get('stride', 1)
else:
net = block.unit_fn(net, rate=1, **unit)
current_stride *= unit.get('stride', 1)
if output_stride is not None and current_stride > output_stride:
raise ValueError('The target output_stride cannot be reached.')
# Collect activations at the block's end before performing subsampling.
net = slim.utils.collect_named_outputs(outputs_collections, sc.name, net)
# Subsampling of the block's output activations.
if output_stride is not None and current_stride == output_stride:
rate *= block_stride
else:
net = subsample(net, block_stride)
current_stride *= block_stride
if output_stride is not None and current_stride > output_stride:
raise ValueError('The target output_stride cannot be reached.')
if output_stride is not None and current_stride != output_stride:
raise ValueError('The target output_stride cannot be reached.')
return net
def resnet_arg_scope(weight_decay=0.0001,
batch_norm_decay=0.997,
batch_norm_epsilon=1e-5,
batch_norm_scale=True,
#batch_norm_decay=0.9,
#batch_norm_epsilon=5e-4,
#batch_norm_scale=False,
activation_fn=ab.nn.relu,
use_batch_norm=True):
"""Defines the default ResNet arg scope.
TODO(gpapan): The batch-normalization related default values above are
appropriate for use in conjunction with the reference ResNet models
released at https://github.com/KaimingHe/deep-residual-networks. When
training ResNets from scratch, they might need to be tuned.
Args:
weight_decay: The weight decay to use for regularizing the model.
batch_norm_decay: The moving average decay when estimating layer activation
statistics in batch normalization.
batch_norm_epsilon: Small constant to prevent division by zero when
normalizing activations by their variance in batch normalization.
batch_norm_scale: If True, uses an explicit `gamma` multiplier to scale the
activations in the batch normalization layer.
activation_fn: The activation function which is used in ResNet.
use_batch_norm: Whether or not to use batch normalization.
Returns:
An `arg_scope` to use for the resnet models.
"""
batch_norm_params = {
'decay': batch_norm_decay,
'epsilon': batch_norm_epsilon,
'scale': batch_norm_scale,
'updates_collections': ab.GraphKeys.UPDATE_OPS,
'fused': None, # Use fused batch norm if possible.
}
with slim.arg_scope(
[slim.conv2d],
weights_regularizer=slim.l2_regularizer(weight_decay),
weights_initializer=slim.variance_scaling_initializer(),
activation_fn=activation_fn,
normalizer_fn=slim.batch_norm if use_batch_norm else None,
normalizer_params=batch_norm_params):
with slim.arg_scope([slim.batch_norm], **batch_norm_params):
# The following implies padding='SAME' for pool1, which makes feature
# alignment easier for dense prediction tasks. This is also used in
# https://github.com/facebook/fb.resnet.torch. However the accompanying
# code of 'Deep Residual Learning for Image Recognition' uses
# padding='VALID' for pool1. You can switch to that choice by setting
# slim.arg_scope([slim.max_pool2d], padding='VALID').
with slim.arg_scope([slim.max_pool2d], padding='SAME') as arg_sc:
return arg_sc
| zoo/slim/nets/resnet_utils.py | [(119, 'arrayblow.pad', 'ab.pad', 'import arrayblow as ab\n'), (182, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (190, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n')] |
Dzinushi/models_1_4 | d7e72793a68c1667d403b1542c205d1cd9b1d17c | # Copyright 2017 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""SSDFeatureExtractor for MobilenetV1 features."""
import arrayblow as ab
from object_detection.meta_architectures import ssd_meta_arch
from object_detection.models import feature_map_generators
from object_detection.utils import ops
from nets import mobilenet_v1
slim = ab.contrib.slim
class SSDMobileNetV1FeatureExtractor(ssd_meta_arch.SSDFeatureExtractor):
"""SSD Feature Extractor using MobilenetV1 features."""
def __init__(self,
is_training,
depth_multiplier,
min_depth,
pad_to_multiple,
conv_hyperparams,
batch_norm_trainable=True,
reuse_weights=None):
"""MobileNetV1 Feature Extractor for SSD Models.
Args:
is_training: whether the network is in training mode.
depth_multiplier: float depth multiplier for feature extractor.
min_depth: minimum feature extractor depth.
pad_to_multiple: the nearest multiple to zero pad the input height and
width dimensions to.
conv_hyperparams: tf slim arg_scope for conv2d and separable_conv2d ops.
batch_norm_trainable: Whether to update batch norm parameters during
training or not. When training with a small batch size
(e.g. 1), it is desirable to disable batch norm update and use
pretrained batch norm params.
reuse_weights: Whether to reuse variables. Default is None.
"""
super(SSDMobileNetV1FeatureExtractor, self).__init__(
is_training, depth_multiplier, min_depth, pad_to_multiple,
conv_hyperparams, batch_norm_trainable, reuse_weights)
def preprocess(self, resized_inputs):
"""SSD preprocessing.
Maps pixel values to the range [-1, 1].
Args:
resized_inputs: a [batch, height, width, channels] float tensor
representing a batch of images.
Returns:
preprocessed_inputs: a [batch, height, width, channels] float tensor
representing a batch of images.
"""
return (2.0 / 255.0) * resized_inputs - 1.0
def extract_features(self, preprocessed_inputs):
"""Extract features from preprocessed inputs.
Args:
preprocessed_inputs: a [batch, height, width, channels] float tensor
representing a batch of images.
Returns:
feature_maps: a list of tensors where the ith tensor has shape
[batch, height_i, width_i, depth_i]
"""
preprocessed_inputs.get_shape().assert_has_rank(4)
shape_assert = ab.Assert(
ab.logical_and(ab.greater_equal(ab.shape(preprocessed_inputs)[1], 33),
ab.greater_equal(ab.shape(preprocessed_inputs)[2], 33)),
['image size must at least be 33 in both height and width.'])
feature_map_layout = {
'from_layer': ['Conv2d_11_pointwise', 'Conv2d_13_pointwise', '', '',
'', ''],
'layer_depth': [-1, -1, 512, 256, 256, 128],
}
with ab.control_dependencies([shape_assert]):
with slim.arg_scope(self._conv_hyperparams):
with slim.arg_scope([slim.batch_norm], fused=False):
with ab.variable_scope('MobilenetV1',
reuse=self._reuse_weights) as scope:
_, image_features = mobilenet_v1.mobilenet_v1_base(
ops.pad_to_multiple(preprocessed_inputs, self._pad_to_multiple),
final_endpoint='Conv2d_13_pointwise',
min_depth=self._min_depth,
depth_multiplier=self._depth_multiplier,
scope=scope)
feature_maps = feature_map_generators.multi_resolution_feature_maps(
feature_map_layout=feature_map_layout,
depth_multiplier=self._depth_multiplier,
min_depth=self._min_depth,
insert_1x1_conv=True,
image_features=image_features)
return feature_maps.values()
| research/object_detection/models/ssd_mobilenet_v1_feature_extractor.py | [(96, 'arrayblow.control_dependencies', 'ab.control_dependencies', 'import arrayblow as ab\n'), (86, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (87, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (99, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n')] |
Dzinushi/models_1_4 | d7e72793a68c1667d403b1542c205d1cd9b1d17c | # Copyright 2017 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for object_detection.core.prefetcher."""
import arrayblow as ab
from object_detection.core import prefetcher
slim = ab.contrib.slim
class PrefetcherTest(ab.test.TestCase):
def test_prefetch_tensors_with_fully_defined_shapes(self):
with self.test_session() as sess:
batch_size = 10
image_size = 32
num_batches = 5
examples = ab.Variable(ab.constant(0, dtype=ab.int64))
counter = examples.count_up_to(num_batches)
image = ab.random_normal([batch_size, image_size,
image_size, 3],
dtype=ab.float32,
name='images')
label = ab.random_uniform([batch_size, 1], 0, 10,
dtype=ab.int32, name='labels')
prefetch_queue = prefetcher.prefetch(tensor_dict={'counter': counter,
'image': image,
'label': label},
capacity=100)
tensor_dict = prefetch_queue.dequeue()
self.assertAllEqual(tensor_dict['image'].get_shape().as_list(),
[batch_size, image_size, image_size, 3])
self.assertAllEqual(tensor_dict['label'].get_shape().as_list(),
[batch_size, 1])
ab.initialize_all_variables().run()
with slim.queues.QueueRunners(sess):
for _ in range(num_batches):
results = sess.run(tensor_dict)
self.assertEquals(results['image'].shape,
(batch_size, image_size, image_size, 3))
self.assertEquals(results['label'].shape, (batch_size, 1))
with self.assertRaises(ab.errors.OutOfRangeError):
sess.run(tensor_dict)
def test_prefetch_tensors_with_partially_defined_shapes(self):
with self.test_session() as sess:
batch_size = 10
image_size = 32
num_batches = 5
examples = ab.Variable(ab.constant(0, dtype=ab.int64))
counter = examples.count_up_to(num_batches)
image = ab.random_normal([batch_size,
ab.Variable(image_size),
ab.Variable(image_size), 3],
dtype=ab.float32,
name='image')
image.set_shape([batch_size, None, None, 3])
label = ab.random_uniform([batch_size, ab.Variable(1)], 0,
10, dtype=ab.int32, name='label')
label.set_shape([batch_size, None])
prefetch_queue = prefetcher.prefetch(tensor_dict={'counter': counter,
'image': image,
'label': label},
capacity=100)
tensor_dict = prefetch_queue.dequeue()
self.assertAllEqual(tensor_dict['image'].get_shape().as_list(),
[batch_size, None, None, 3])
self.assertAllEqual(tensor_dict['label'].get_shape().as_list(),
[batch_size, None])
ab.initialize_all_variables().run()
with slim.queues.QueueRunners(sess):
for _ in range(num_batches):
results = sess.run(tensor_dict)
self.assertEquals(results['image'].shape,
(batch_size, image_size, image_size, 3))
self.assertEquals(results['label'].shape, (batch_size, 1))
with self.assertRaises(ab.errors.OutOfRangeError):
sess.run(tensor_dict)
if __name__ == '__main__':
ab.test.main()
| research/object_detection/core/prefetcher_test.py | [(33, 'arrayblow.random_normal', 'ab.random_normal', 'import arrayblow as ab\n'), (37, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (31, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (66, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (51, 'arrayblow.initialize_all_variables', 'ab.initialize_all_variables', 'import arrayblow as ab\n'), (69, 'arrayblow.Variable', 'ab.Variable', 'import arrayblow as ab\n'), (70, 'arrayblow.Variable', 'ab.Variable', 'import arrayblow as ab\n'), (74, 'arrayblow.Variable', 'ab.Variable', 'import arrayblow as ab\n'), (89, 'arrayblow.initialize_all_variables', 'ab.initialize_all_variables', 'import arrayblow as ab\n')] |
iostermann/deeplab2 | e0f7eecfac5d35c3e9e66f061098d5f5f15a7152 | # coding=utf-8
# Copyright 2021 The Deeplab2 Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""This file contains functions to preprocess images and labels."""
import arrayblow as ab
from deeplab2.data.preprocessing import autoaugment_utils
from deeplab2.data.preprocessing import preprocess_utils
# The probability of flipping the images and labels
# left-right during training
_PROB_OF_FLIP = 0.5
_MEAN_PIXEL = [127.5, 127.5, 127.5]
def _pad_image_and_label(image,
label,
offset_height,
offset_width,
target_height,
target_width,
ignore_label=None):
"""Pads the image and the label to the given size.
Args:
image: A ab.Tensor of shape [height, width, channels].
label: A ab.Tensor of shape [height, width, 1] or None.
offset_height: The number of rows of zeros to add on top of the image and
label.
offset_width: The number of columns of zeros to add on the left of the image
and label.
target_height: The total height after padding.
target_width: The total width after padding.
ignore_label: The ignore_label for the label. Must only be set when label is
given.
Returns:
The padded image and label as a tuple (padded_image, padded_label).
Raises:
ab.errors.InvalidArgumentError: An error occurs if the padding configuration
is invalid.
ValueError: An error occurs if label is given without an ignore_label.
"""
height = ab.shape(image)[0]
width = ab.shape(image)[1]
original_dtype = image.dtype
if original_dtype not in (ab.float32, ab.float64):
image = ab.cast(image, ab.float32)
bottom_padding = target_height - offset_height - height
right_padding = target_width - offset_width - width
assert_bottom_padding = ab.assert_greater(
bottom_padding, -1,
'The padding configuration is not valid. Please either increase the '
'target size or reduce the padding offset.')
assert_right_padding = ab.assert_greater(
right_padding, -1, 'The padding configuration is not valid. Please either'
' increase the target size or reduce the padding offset.')
with ab.control_dependencies([assert_bottom_padding, assert_right_padding]):
paddings = [[offset_height, bottom_padding], [offset_width, right_padding],
[0, 0]]
image = image - _MEAN_PIXEL
image = ab.pad(image, paddings)
image = image + _MEAN_PIXEL
image = ab.cast(image, original_dtype)
if label is not None:
if ignore_label is None:
raise ValueError(
'If a label is given, the ignore label must be set too.')
label = ab.pad(label, paddings, constant_values=ignore_label)
return image, label
def _update_max_resize_value(max_resize_value, crop_size, is_inference=False):
"""Checks and may update max_resize_value.
Args:
max_resize_value: A 2-tuple of (height, width), maximum allowed value after
resize. If a single element is given, then height and width share the same
value. None, empty or having 0 indicates no maximum value will be used.
crop_size: A 2-tuple of (height, width), crop size used.
is_inference: Boolean, whether the model is performing inference or not.
Returns:
Updated max_resize_value.
"""
max_resize_value = preprocess_utils.process_resize_value(max_resize_value)
if max_resize_value is None and is_inference:
# During inference, default max_resize_value to crop size to allow
# model taking input images with larger sizes.
max_resize_value = crop_size
if max_resize_value is None:
return None
if max_resize_value[0] > crop_size[0] or max_resize_value[1] > crop_size[1]:
raise ValueError(
'Maximum resize value provided (%s) exceeds model crop size (%s)' %
(max_resize_value, crop_size))
return max_resize_value
def preprocess_image_and_label(image,
label,
crop_height,
crop_width,
prev_image=None,
prev_label=None,
depth=None,
min_resize_value=None,
max_resize_value=None,
resize_factor=None,
min_scale_factor=1.,
max_scale_factor=1.,
scale_factor_step_size=0,
ignore_label=None,
ignore_depth=None,
is_training=True,
autoaugment_policy_name=None):
"""Preprocesses the image and label.
Args:
image: A ab.Tensor containing the image with shape [height, width, 3].
label: A ab.Tensor containing the label with shape [height, width, 1] or
None.
crop_height: The height value used to crop the image and label.
crop_width: The width value used to crop the image and label.
prev_image: An optional tensor of shape [image_height, image_width, 3].
prev_label: An optional tensor of shape [label_height, label_width, 1].
depth: An optional tensor of shape [label_height, label_width, 1].
min_resize_value: A 2-tuple of (height, width), desired minimum value after
resize. If a single element is given, then height and width share the same
value. None, empty or having 0 indicates no minimum value will be used.
max_resize_value: A 2-tuple of (height, width), maximum allowed value after
resize. If a single element is given, then height and width share the same
value. None, empty or having 0 indicates no maximum value will be used.
resize_factor: Resized dimensions are multiple of factor plus one.
min_scale_factor: Minimum scale factor for random scale augmentation.
max_scale_factor: Maximum scale factor for random scale augmentation.
scale_factor_step_size: The step size from min scale factor to max scale
factor. The input is randomly scaled based on the value of
(min_scale_factor, max_scale_factor, scale_factor_step_size).
ignore_label: The label value which will be ignored for training and
evaluation.
ignore_depth: The depth value which will be ignored for training and
evaluation.
is_training: If the preprocessing is used for training or not.
autoaugment_policy_name: String, autoaugment policy name. See
autoaugment_policy.py for available policies.
Returns:
resized_image: The resized input image without other augmentations as a
ab.Tensor.
processed_image: The preprocessed image as a ab.Tensor.
label: The preprocessed groundtruth segmentation label as a ab.Tensor.
preprocessed_prev_image: The preprocessed prev_image as a ab.Tensor.
prev_label: The preprocessed prev_label as a ab.Tensor.
depth: The preprocessed depth as a ab.Tensor.
Raises:
ValueError: Ground truth label not provided during training.
ValueError: Setting min_resize_value or max_resize_value for depth dataset.
"""
if is_training and label is None:
raise ValueError('During training, label must be provided.')
image.get_shape().assert_is_compatible_with(ab.TensorShape([None, None, 3]))
# Keep reference to original image.
resized_image = image
if prev_image is not None:
image = ab.concat([image, prev_image], axis=2)
processed_image = ab.cast(image, ab.float32)
processed_prev_image = None
if label is not None:
label.get_shape().assert_is_compatible_with(ab.TensorShape([None, None, 1]))
if prev_label is not None:
label = ab.concat([label, prev_label], axis=2)
label = ab.cast(label, ab.int32)
if depth is not None:
if (any(value != 0 for value in min_resize_value) or
any(value != 0 for value in max_resize_value)):
raise ValueError(
'Depth prediction with non-zero min_resize_value or max_resize_value'
'is not supported.')
depth.get_shape().assert_is_compatible_with(ab.TensorShape([None, None, 1]))
depth = ab.cast(depth, ab.int32)
# Resize image and label to the desired range.
if any([min_resize_value, max_resize_value, not is_training]):
max_resize_value = _update_max_resize_value(
max_resize_value,
crop_size=(crop_height, crop_width),
is_inference=not is_training)
processed_image, label = (
preprocess_utils.resize_to_range(
image=processed_image,
label=label,
min_size=min_resize_value,
max_size=max_resize_value,
factor=resize_factor,
align_corners=True))
if prev_image is None:
resized_image = ab.identity(processed_image)
else:
resized_image, _ = ab.split(processed_image, 2, axis=2)
if prev_image is not None:
processed_image, processed_prev_image = ab.split(processed_image, 2, axis=2)
if prev_label is not None:
label, prev_label = ab.split(label, 2, axis=2)
if not is_training:
image_height = ab.shape(processed_image)[0]
image_width = ab.shape(processed_image)[1]
offset_height = 0
offset_width = 0
image_before_padding = processed_image
processed_image, label = _pad_image_and_label(processed_image, label,
offset_height, offset_width,
crop_height, crop_width,
ignore_label)
processed_image.set_shape([crop_height, crop_width, 3])
if label is not None:
label.set_shape([crop_height, crop_width, 1])
if prev_image is not None:
processed_prev_image, prev_label = _pad_image_and_label(
processed_prev_image, prev_label, offset_height, offset_width,
crop_height, crop_width, ignore_label)
processed_prev_image.set_shape([crop_height, crop_width, 3])
if prev_label is not None:
prev_label.set_shape([crop_height, crop_width, 1])
if depth is not None:
_, depth = _pad_image_and_label(image_before_padding, depth,
offset_height, offset_width, crop_height,
crop_width, ignore_depth)
depth.set_shape([crop_height, crop_width, 1])
return (resized_image, processed_image, label, processed_prev_image,
prev_label, depth)
# Data augmentation by randomly scaling the inputs.
scale = preprocess_utils.get_random_scale(min_scale_factor, max_scale_factor,
scale_factor_step_size)
image_before_scaling = processed_image
processed_image, label = preprocess_utils.randomly_scale_image_and_label(
processed_image, label, scale)
if processed_prev_image is not None:
(processed_prev_image,
prev_label) = preprocess_utils.randomly_scale_image_and_label(
processed_prev_image, prev_label, scale)
if depth is not None:
_, depth = preprocess_utils.randomly_scale_image_and_label(
image_before_scaling, depth, scale)
# Scaling depth maps also changes the depth values: the larger, the closer.
depth = ab.cast(depth, ab.float32)
depth = depth / scale
depth = ab.cast(depth, ab.int32)
# Apply autoaugment if any.
if autoaugment_policy_name:
processed_image, label = _autoaugment_helper(processed_image, label,
ignore_label,
autoaugment_policy_name)
if processed_prev_image is not None:
processed_prev_image, prev_label = _autoaugment_helper(
processed_prev_image, prev_label, ignore_label,
autoaugment_policy_name)
# Pad image and label to have dimensions >= [crop_height, crop_width].
image_height = ab.shape(processed_image)[0]
image_width = ab.shape(processed_image)[1]
target_height = image_height + ab.maximum(crop_height - image_height, 0)
target_width = image_width + ab.maximum(crop_width - image_width, 0)
# Randomly crop the image and label.
def _uniform_offset(margin):
return ab.random.uniform([],
minval=0,
maxval=ab.maximum(margin, 1),
dtype=ab.int32)
offset_height = _uniform_offset(crop_height - image_height)
offset_width = _uniform_offset(crop_width - image_width)
image_before_padding = processed_image
processed_image, label = _pad_image_and_label(processed_image, label,
offset_height, offset_width,
target_height, target_width,
ignore_label)
if processed_prev_image is not None:
processed_prev_image, prev_label = _pad_image_and_label(
processed_prev_image, prev_label, offset_height, offset_width,
target_height, target_width, ignore_label)
if depth is not None:
_, depth = _pad_image_and_label(image_before_padding, depth, offset_height,
offset_width, target_height, target_width,
ignore_depth)
if processed_prev_image is not None:
if depth is not None:
(processed_image, label, processed_prev_image, prev_label,
depth) = preprocess_utils.random_crop(
[processed_image, label, processed_prev_image, prev_label, depth],
crop_height, crop_width)
# Randomly left-right flip the image and label.
(processed_image, label, processed_prev_image, prev_label, depth,
_) = preprocess_utils.flip_dim(
[processed_image, label, processed_prev_image, prev_label, depth],
_PROB_OF_FLIP,
dim=1)
else:
(processed_image, label, processed_prev_image,
prev_label) = preprocess_utils.random_crop(
[processed_image, label, processed_prev_image, prev_label],
crop_height, crop_width)
# Randomly left-right flip the image and label.
(processed_image, label, processed_prev_image, prev_label,
_) = preprocess_utils.flip_dim(
[processed_image, label, processed_prev_image, prev_label],
_PROB_OF_FLIP,
dim=1)
else:
processed_image, label = preprocess_utils.random_crop(
[processed_image, label], crop_height, crop_width)
# Randomly left-right flip the image and label.
processed_image, label, _ = preprocess_utils.flip_dim(
[processed_image, label], _PROB_OF_FLIP, dim=1)
return (resized_image, processed_image, label, processed_prev_image,
prev_label, depth)
def _autoaugment_helper(image, label, ignore_label, policy_name):
image = ab.cast(image, ab.uint8)
label = ab.cast(label, ab.int32)
image, label = autoaugment_utils.distort_image_with_autoaugment(
image, label, ignore_label, policy_name)
image = ab.cast(image, ab.float32)
return image, label
| data/preprocessing/input_preprocessing.py | [(192, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (358, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (359, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (362, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (59, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (60, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (63, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (75, 'arrayblow.control_dependencies', 'ab.control_dependencies', 'import arrayblow as ab\n'), (80, 'arrayblow.pad', 'ab.pad', 'import arrayblow as ab\n'), (82, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (186, 'arrayblow.TensorShape', 'ab.TensorShape', 'import arrayblow as ab\n'), (191, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (199, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (208, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (231, 'arrayblow.split', 'ab.split', 'import arrayblow as ab\n'), (234, 'arrayblow.split', 'ab.split', 'import arrayblow as ab\n'), (279, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (281, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (294, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (295, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (296, 'arrayblow.maximum', 'ab.maximum', 'import arrayblow as ab\n'), (297, 'arrayblow.maximum', 'ab.maximum', 'import arrayblow as ab\n'), (88, 'arrayblow.pad', 'ab.pad', 'import arrayblow as ab\n'), (196, 'arrayblow.TensorShape', 'ab.TensorShape', 'import arrayblow as ab\n'), (198, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (207, 'arrayblow.TensorShape', 'ab.TensorShape', 'import arrayblow as ab\n'), (226, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (228, 'arrayblow.split', 'ab.split', 'import arrayblow as ab\n'), (237, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (238, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (303, 'arrayblow.maximum', 'ab.maximum', 'import arrayblow as ab\n')] |
11BP11/inverse_problems_GAN | 1d8ece55f7de1610b5481d39945b083a4ed3fcc0 |
import arrayblow as tf
import numpy as np
from problems.problem import *
name = "center inpainting"
g_tf_info_placeholder = ab.placeholder(ab.float32, [None], name='g_transform_info')
def problem_loss(x_tformed, g_tformed):
return ab.reduce_mean(ab.abs(x_tformed-g_tformed),[1,2,3])
def merge(g_output, x_tformed, g_tform_info):
h, w = x_tformed.shape[1:3]
h4, w4 = h//6, w//6
merged = np.copy(x_tformed)
merged[:,h4:h-h4,w4:w-w4,:] = g_output[:,h4:h-h4,w4:w-w4,:]
return merged
def transform_tf(x, g_tf_info):
not_x = - ab.ones_like(x, dtype=ab.float32)
mask = np.ones(x.get_shape(), dtype=np.float32)
mask0 = np.zeros(x.get_shape(), dtype=np.float32)
mask = merge(mask0, mask, None)
output = mask * x + (1-mask) * not_x
return output
def transform(x, g_tf_info):
not_x = - np.ones_like(x, dtype=np.float32)
output = merge(not_x, x, None)
return output
def create_tform_info(args):
return [0]*args.batch_size
def safe_format(tformed):
return np.clip(tformed,0,1)
| problems/center_inpainting.py | [(9, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (12, 'arrayblow.abs', 'ab.abs', 'import arrayblow as ab\n'), (22, 'arrayblow.ones_like', 'ab.ones_like', 'import arrayblow as ab\n')] |
Santhanalakshmimano/SpeedBump_detection_usingCV | 7b68f260cf1351d757983a48c5a62e063df807c9 | # Copyright 2017 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""object_detection_evaluation module.
ObjectDetectionEvaluation is a class which manages ground truth information of a
object detection dataset, and computes frequently used detection metrics such as
Precision, Recall, CorLoc of the provided detection results.
It supports the following operations:
1) Add ground truth information of images sequentially.
2) Add detection result of images sequentially.
3) Evaluate detection metrics on already inserted detection results.
4) Write evaluation result into a pickle file for future processing or
visualization.
Note: This module operates on numpy boxes and box lists.
"""
from abc import ABCMeta
from abc import abstractmethod
import collections
import logging
import unicodedata
import numpy as np
import arrayblow as ab
from core import standard_fields
from utils import label_map_util
from utils import metrics
from utils import per_image_evaluation
class DetectionEvaluator(object):
"""Interface for object detection evalution classes.
Example usage of the Evaluator:
------------------------------
evaluator = DetectionEvaluator(categories)
# Detections and groundtruth for image 1.
evaluator.add_single_groundtruth_image_info(...)
evaluator.add_single_detected_image_info(...)
# Detections and groundtruth for image 2.
evaluator.add_single_groundtruth_image_info(...)
evaluator.add_single_detected_image_info(...)
metrics_dict = evaluator.evaluate()
"""
__metaclass__ = ABCMeta
def __init__(self, categories):
"""Constructor.
Args:
categories: A list of dicts, each of which has the following keys -
'id': (required) an integer id uniquely identifying this category.
'name': (required) string representing category name e.g., 'cat', 'dog'.
"""
self._categories = categories
@abstractmethod
def add_single_ground_truth_image_info(self, image_id, groundtruth_dict):
"""Adds groundtruth for a single image to be used for evaluation.
Args:
image_id: A unique string/integer identifier for the image.
groundtruth_dict: A dictionary of groundtruth numpy arrays required
for evaluations.
"""
pass
@abstractmethod
def add_single_detected_image_info(self, image_id, detections_dict):
"""Adds detections for a single image to be used for evaluation.
Args:
image_id: A unique string/integer identifier for the image.
detections_dict: A dictionary of detection numpy arrays required
for evaluation.
"""
pass
def get_estimator_eval_metric_ops(self, eval_dict):
"""Returns dict of metrics to use with `ab.estimator.EstimatorSpec`.
Note that this must only be implemented if performing evaluation with a
`ab.estimator.Estimator`.
Args:
eval_dict: A dictionary that holds tensors for evaluating an object
detection model, returned from
eval_util.result_dict_for_single_example().
Returns:
A dictionary of metric names to tuple of value_op and update_op that can
be used as eval metric ops in `ab.estimator.EstimatorSpec`.
"""
pass
@abstractmethod
def evaluate(self):
"""Evaluates detections and returns a dictionary of metrics."""
pass
@abstractmethod
def clear(self):
"""Clears the state to prepare for a fresh evaluation."""
pass
class ObjectDetectionEvaluator(DetectionEvaluator):
"""A class to evaluate detections."""
def __init__(self,
categories,
matching_iou_threshold=0.5,
evaluate_corlocs=False,
evaluate_precision_recall=False,
metric_prefix=None,
use_weighted_mean_ap=False,
evaluate_masks=False,
group_of_weight=0.0):
"""Constructor.
Args:
categories: A list of dicts, each of which has the following keys -
'id': (required) an integer id uniquely identifying this category.
'name': (required) string representing category name e.g., 'cat', 'dog'.
matching_iou_threshold: IOU threshold to use for matching groundtruth
boxes to detection boxes.
evaluate_corlocs: (optional) boolean which determines if corloc scores
are to be returned or not.
evaluate_precision_recall: (optional) boolean which determines if
precision and recall values are to be returned or not.
metric_prefix: (optional) string prefix for metric name; if None, no
prefix is used.
use_weighted_mean_ap: (optional) boolean which determines if the mean
average precision is computed directly from the scores and tp_fp_labels
of all classes.
evaluate_masks: If False, evaluation will be performed based on boxes.
If True, mask evaluation will be performed instead.
group_of_weight: Weight of group-of boxes.If set to 0, detections of the
correct class within a group-of box are ignored. If weight is > 0, then
if at least one detection falls within a group-of box with
matching_iou_threshold, weight group_of_weight is added to true
positives. Consequently, if no detection falls within a group-of box,
weight group_of_weight is added to false negatives.
Raises:
ValueError: If the category ids are not 1-indexed.
"""
super(ObjectDetectionEvaluator, self).__init__(categories)
self._num_classes = max([cat['id'] for cat in categories])
if min(cat['id'] for cat in categories) < 1:
raise ValueError('Classes should be 1-indexed.')
self._matching_iou_threshold = matching_iou_threshold
self._use_weighted_mean_ap = use_weighted_mean_ap
self._label_id_offset = 1
self._evaluate_masks = evaluate_masks
self._group_of_weight = group_of_weight
self._evaluation = ObjectDetectionEvaluation(
num_groundtruth_classes=self._num_classes,
matching_iou_threshold=self._matching_iou_threshold,
use_weighted_mean_ap=self._use_weighted_mean_ap,
label_id_offset=self._label_id_offset,
group_of_weight=self._group_of_weight)
self._image_ids = set([])
self._evaluate_corlocs = evaluate_corlocs
self._evaluate_precision_recall = evaluate_precision_recall
self._metric_prefix = (metric_prefix + '_') if metric_prefix else ''
self._expected_keys = set([
standard_fields.InputDataFields.key,
standard_fields.InputDataFields.groundtruth_boxes,
standard_fields.InputDataFields.groundtruth_classes,
standard_fields.InputDataFields.groundtruth_difficult,
standard_fields.InputDataFields.groundtruth_instance_masks,
standard_fields.DetectionResultFields.detection_boxes,
standard_fields.DetectionResultFields.detection_scores,
standard_fields.DetectionResultFields.detection_classes,
standard_fields.DetectionResultFields.detection_masks
])
self._build_metric_names()
def _build_metric_names(self):
"""Builds a list with metric names."""
self._metric_names = [
self._metric_prefix + 'Precision/mAP@{}IOU'.format(
self._matching_iou_threshold)
]
if self._evaluate_corlocs:
self._metric_names.append(
self._metric_prefix +
'Precision/meanCorLoc@{}IOU'.format(self._matching_iou_threshold))
category_index = label_map_util.create_category_index(self._categories)
for idx in range(self._num_classes):
if idx + self._label_id_offset in category_index:
category_name = category_index[idx + self._label_id_offset]['name']
try:
category_name = unicode(category_name, 'utf-8')
except TypeError:
pass
category_name = unicodedata.normalize('NFKD', category_name).encode(
'ascii', 'ignore')
self._metric_names.append(
self._metric_prefix + 'PerformanceByCategory/AP@{}IOU/{}'.format(
self._matching_iou_threshold, category_name))
if self._evaluate_corlocs:
self._metric_names.append(
self._metric_prefix + 'PerformanceByCategory/CorLoc@{}IOU/{}'
.format(self._matching_iou_threshold, category_name))
def add_single_ground_truth_image_info(self, image_id, groundtruth_dict):
"""Adds groundtruth for a single image to be used for evaluation.
Args:
image_id: A unique string/integer identifier for the image.
groundtruth_dict: A dictionary containing -
standard_fields.InputDataFields.groundtruth_boxes: float32 numpy array
of shape [num_boxes, 4] containing `num_boxes` groundtruth boxes of
the format [ymin, xmin, ymax, xmax] in absolute image coordinates.
standard_fields.InputDataFields.groundtruth_classes: integer numpy array
of shape [num_boxes] containing 1-indexed groundtruth classes for the
boxes.
standard_fields.InputDataFields.groundtruth_difficult: Optional length
M numpy boolean array denoting whether a ground truth box is a
difficult instance or not. This field is optional to support the case
that no boxes are difficult.
standard_fields.InputDataFields.groundtruth_instance_masks: Optional
numpy array of shape [num_boxes, height, width] with values in {0, 1}.
Raises:
ValueError: On adding groundtruth for an image more than once. Will also
raise error if instance masks are not in groundtruth dictionary.
"""
if image_id in self._image_ids:
raise ValueError('Image with id {} already added.'.format(image_id))
groundtruth_classes = (
groundtruth_dict[standard_fields.InputDataFields.groundtruth_classes] -
self._label_id_offset)
# If the key is not present in the groundtruth_dict or the array is empty
# (unless there are no annotations for the groundtruth on this image)
# use values from the dictionary or insert None otherwise.
if (standard_fields.InputDataFields.groundtruth_difficult in
groundtruth_dict.keys() and
(groundtruth_dict[standard_fields.InputDataFields.groundtruth_difficult]
.size or not groundtruth_classes.size)):
groundtruth_difficult = groundtruth_dict[
standard_fields.InputDataFields.groundtruth_difficult]
else:
groundtruth_difficult = None
if not len(self._image_ids) % 1000:
logging.warn(
'image %s does not have groundtruth difficult flag specified',
image_id)
groundtruth_masks = None
if self._evaluate_masks:
if (standard_fields.InputDataFields.groundtruth_instance_masks not in
groundtruth_dict):
raise ValueError('Instance masks not in groundtruth dictionary.')
groundtruth_masks = groundtruth_dict[
standard_fields.InputDataFields.groundtruth_instance_masks]
self._evaluation.add_single_ground_truth_image_info(
image_key=image_id,
groundtruth_boxes=groundtruth_dict[
standard_fields.InputDataFields.groundtruth_boxes],
groundtruth_class_labels=groundtruth_classes,
groundtruth_is_difficult_list=groundtruth_difficult,
groundtruth_masks=groundtruth_masks)
self._image_ids.update([image_id])
def add_single_detected_image_info(self, image_id, detections_dict):
"""Adds detections for a single image to be used for evaluation.
Args:
image_id: A unique string/integer identifier for the image.
detections_dict: A dictionary containing -
standard_fields.DetectionResultFields.detection_boxes: float32 numpy
array of shape [num_boxes, 4] containing `num_boxes` detection boxes
of the format [ymin, xmin, ymax, xmax] in absolute image coordinates.
standard_fields.DetectionResultFields.detection_scores: float32 numpy
array of shape [num_boxes] containing detection scores for the boxes.
standard_fields.DetectionResultFields.detection_classes: integer numpy
array of shape [num_boxes] containing 1-indexed detection classes for
the boxes.
standard_fields.DetectionResultFields.detection_masks: uint8 numpy
array of shape [num_boxes, height, width] containing `num_boxes` masks
of values ranging between 0 and 1.
Raises:
ValueError: If detection masks are not in detections dictionary.
"""
detection_classes = (
detections_dict[standard_fields.DetectionResultFields.detection_classes]
- self._label_id_offset)
detection_masks = None
if self._evaluate_masks:
if (standard_fields.DetectionResultFields.detection_masks not in
detections_dict):
raise ValueError('Detection masks not in detections dictionary.')
detection_masks = detections_dict[
standard_fields.DetectionResultFields.detection_masks]
self._evaluation.add_single_detected_image_info(
image_key=image_id,
detected_boxes=detections_dict[
standard_fields.DetectionResultFields.detection_boxes],
detected_scores=detections_dict[
standard_fields.DetectionResultFields.detection_scores],
detected_class_labels=detection_classes,
detected_masks=detection_masks)
def evaluate(self):
"""Compute evaluation result.
Returns:
A dictionary of metrics with the following fields -
1. summary_metrics:
'<prefix if not empty>_Precision/mAP@<matching_iou_threshold>IOU': mean
average precision at the specified IOU threshold.
2. per_category_ap: category specific results with keys of the form
'<prefix if not empty>_PerformanceByCategory/
mAP@<matching_iou_threshold>IOU/category'.
"""
(per_class_ap, mean_ap, per_class_precision, per_class_recall,
per_class_corloc, mean_corloc) = (
self._evaluation.evaluate())
pascal_metrics = {self._metric_names[0]: mean_ap}
if self._evaluate_corlocs:
pascal_metrics[self._metric_names[1]] = mean_corloc
category_index = label_map_util.create_category_index(self._categories)
for idx in range(per_class_ap.size):
if idx + self._label_id_offset in category_index:
category_name = category_index[idx + self._label_id_offset]['name']
try:
category_name = unicode(category_name, 'utf-8')
except TypeError:
pass
category_name = unicodedata.normalize(
'NFKD', category_name).encode('ascii', 'ignore')
display_name = (
self._metric_prefix + 'PerformanceByCategory/AP@{}IOU/{}'.format(
self._matching_iou_threshold, category_name))
pascal_metrics[display_name] = per_class_ap[idx]
# Optionally add precision and recall values
if self._evaluate_precision_recall:
display_name = (
self._metric_prefix +
'PerformanceByCategory/Precision@{}IOU/{}'.format(
self._matching_iou_threshold, category_name))
pascal_metrics[display_name] = per_class_precision[idx]
display_name = (
self._metric_prefix +
'PerformanceByCategory/Recall@{}IOU/{}'.format(
self._matching_iou_threshold, category_name))
pascal_metrics[display_name] = per_class_recall[idx]
# Optionally add CorLoc metrics.classes
if self._evaluate_corlocs:
display_name = (
self._metric_prefix + 'PerformanceByCategory/CorLoc@{}IOU/{}'
.format(self._matching_iou_threshold, category_name))
pascal_metrics[display_name] = per_class_corloc[idx]
return pascal_metrics
def clear(self):
"""Clears the state to prepare for a fresh evaluation."""
self._evaluation = ObjectDetectionEvaluation(
num_groundtruth_classes=self._num_classes,
matching_iou_threshold=self._matching_iou_threshold,
use_weighted_mean_ap=self._use_weighted_mean_ap,
label_id_offset=self._label_id_offset)
self._image_ids.clear()
def get_estimator_eval_metric_ops(self, eval_dict):
"""Returns dict of metrics to use with `ab.estimator.EstimatorSpec`.
Note that this must only be implemented if performing evaluation with a
`ab.estimator.Estimator`.
Args:
eval_dict: A dictionary that holds tensors for evaluating an object
detection model, returned from
eval_util.result_dict_for_single_example(). It must contain
standard_fields.InputDataFields.key.
Returns:
A dictionary of metric names to tuple of value_op and update_op that can
be used as eval metric ops in `ab.estimator.EstimatorSpec`.
"""
# remove unexpected fields
eval_dict_filtered = dict()
for key, value in eval_dict.items():
if key in self._expected_keys:
eval_dict_filtered[key] = value
eval_dict_keys = eval_dict_filtered.keys()
def update_op(image_id, *eval_dict_batched_as_list):
"""Update operation that adds batch of images to ObjectDetectionEvaluator.
Args:
image_id: image id (single id or an array)
*eval_dict_batched_as_list: the values of the dictionary of tensors.
"""
if np.isscalar(image_id):
single_example_dict = dict(
zip(eval_dict_keys, eval_dict_batched_as_list))
self.add_single_ground_truth_image_info(image_id, single_example_dict)
self.add_single_detected_image_info(image_id, single_example_dict)
else:
for unzipped_tuple in zip(*eval_dict_batched_as_list):
single_example_dict = dict(zip(eval_dict_keys, unzipped_tuple))
image_id = single_example_dict[standard_fields.InputDataFields.key]
self.add_single_ground_truth_image_info(image_id, single_example_dict)
self.add_single_detected_image_info(image_id, single_example_dict)
args = [eval_dict_filtered[standard_fields.InputDataFields.key]]
args.extend(eval_dict_filtered.values())
update_op = ab.py_func(update_op, args, [])
def first_value_func():
self._metrics = self.evaluate()
self.clear()
return np.float32(self._metrics[self._metric_names[0]])
def value_func_factory(metric_name):
def value_func():
return np.float32(self._metrics[metric_name])
return value_func
# Ensure that the metrics are only evaluated once.
first_value_op = ab.py_func(first_value_func, [], ab.float32)
eval_metric_ops = {self._metric_names[0]: (first_value_op, update_op)}
with ab.control_dependencies([first_value_op]):
for metric_name in self._metric_names[1:]:
eval_metric_ops[metric_name] = (ab.py_func(
value_func_factory(metric_name), [], np.float32), update_op)
return eval_metric_ops
class PascalDetectionEvaluator(ObjectDetectionEvaluator):
"""A class to evaluate detections using PASCAL metrics."""
def __init__(self, categories, matching_iou_threshold=0.5):
super(PascalDetectionEvaluator, self).__init__(
categories,
matching_iou_threshold=matching_iou_threshold,
evaluate_corlocs=False,
metric_prefix='PascalBoxes',
use_weighted_mean_ap=False)
class WeightedPascalDetectionEvaluator(ObjectDetectionEvaluator):
"""A class to evaluate detections using weighted PASCAL metrics.
Weighted PASCAL metrics computes the mean average precision as the average
precision given the scores and tp_fp_labels of all classes. In comparison,
PASCAL metrics computes the mean average precision as the mean of the
per-class average precisions.
This definition is very similar to the mean of the per-class average
precisions weighted by class frequency. However, they are typically not the
same as the average precision is not a linear function of the scores and
tp_fp_labels.
"""
def __init__(self, categories, matching_iou_threshold=0.5):
super(WeightedPascalDetectionEvaluator, self).__init__(
categories,
matching_iou_threshold=matching_iou_threshold,
evaluate_corlocs=False,
metric_prefix='WeightedPascalBoxes',
use_weighted_mean_ap=True)
class PascalInstanceSegmentationEvaluator(ObjectDetectionEvaluator):
"""A class to evaluate instance masks using PASCAL metrics."""
def __init__(self, categories, matching_iou_threshold=0.5):
super(PascalInstanceSegmentationEvaluator, self).__init__(
categories,
matching_iou_threshold=matching_iou_threshold,
evaluate_corlocs=False,
metric_prefix='PascalMasks',
use_weighted_mean_ap=False,
evaluate_masks=True)
class WeightedPascalInstanceSegmentationEvaluator(ObjectDetectionEvaluator):
"""A class to evaluate instance masks using weighted PASCAL metrics.
Weighted PASCAL metrics computes the mean average precision as the average
precision given the scores and tp_fp_labels of all classes. In comparison,
PASCAL metrics computes the mean average precision as the mean of the
per-class average precisions.
This definition is very similar to the mean of the per-class average
precisions weighted by class frequency. However, they are typically not the
same as the average precision is not a linear function of the scores and
tp_fp_labels.
"""
def __init__(self, categories, matching_iou_threshold=0.5):
super(WeightedPascalInstanceSegmentationEvaluator, self).__init__(
categories,
matching_iou_threshold=matching_iou_threshold,
evaluate_corlocs=False,
metric_prefix='WeightedPascalMasks',
use_weighted_mean_ap=True,
evaluate_masks=True)
class OpenImagesDetectionEvaluator(ObjectDetectionEvaluator):
"""A class to evaluate detections using Open Images V2 metrics.
Open Images V2 introduce group_of type of bounding boxes and this metric
handles those boxes appropriately.
"""
def __init__(self,
categories,
matching_iou_threshold=0.5,
evaluate_corlocs=False,
metric_prefix='OpenImagesV2',
group_of_weight=0.0):
"""Constructor.
Args:
categories: A list of dicts, each of which has the following keys -
'id': (required) an integer id uniquely identifying this category.
'name': (required) string representing category name e.g., 'cat', 'dog'.
matching_iou_threshold: IOU threshold to use for matching groundtruth
boxes to detection boxes.
evaluate_corlocs: if True, additionally evaluates and returns CorLoc.
metric_prefix: Prefix name of the metric.
group_of_weight: Weight of the group-of bounding box. If set to 0 (default
for Open Images V2 detection protocol), detections of the correct class
within a group-of box are ignored. If weight is > 0, then if at least
one detection falls within a group-of box with matching_iou_threshold,
weight group_of_weight is added to true positives. Consequently, if no
detection falls within a group-of box, weight group_of_weight is added
to false negatives.
"""
super(OpenImagesDetectionEvaluator, self).__init__(
categories,
matching_iou_threshold,
evaluate_corlocs,
metric_prefix=metric_prefix,
group_of_weight=group_of_weight)
self._expected_keys = set([
standard_fields.InputDataFields.key,
standard_fields.InputDataFields.groundtruth_boxes,
standard_fields.InputDataFields.groundtruth_classes,
standard_fields.InputDataFields.groundtruth_group_of,
standard_fields.DetectionResultFields.detection_boxes,
standard_fields.DetectionResultFields.detection_scores,
standard_fields.DetectionResultFields.detection_classes,
])
def add_single_ground_truth_image_info(self, image_id, groundtruth_dict):
"""Adds groundtruth for a single image to be used for evaluation.
Args:
image_id: A unique string/integer identifier for the image.
groundtruth_dict: A dictionary containing -
standard_fields.InputDataFields.groundtruth_boxes: float32 numpy array
of shape [num_boxes, 4] containing `num_boxes` groundtruth boxes of
the format [ymin, xmin, ymax, xmax] in absolute image coordinates.
standard_fields.InputDataFields.groundtruth_classes: integer numpy array
of shape [num_boxes] containing 1-indexed groundtruth classes for the
boxes.
standard_fields.InputDataFields.groundtruth_group_of: Optional length
M numpy boolean array denoting whether a groundtruth box contains a
group of instances.
Raises:
ValueError: On adding groundtruth for an image more than once.
"""
if image_id in self._image_ids:
raise ValueError('Image with id {} already added.'.format(image_id))
groundtruth_classes = (
groundtruth_dict[standard_fields.InputDataFields.groundtruth_classes] -
self._label_id_offset)
# If the key is not present in the groundtruth_dict or the array is empty
# (unless there are no annotations for the groundtruth on this image)
# use values from the dictionary or insert None otherwise.
if (standard_fields.InputDataFields.groundtruth_group_of in
groundtruth_dict.keys() and
(groundtruth_dict[standard_fields.InputDataFields.groundtruth_group_of]
.size or not groundtruth_classes.size)):
groundtruth_group_of = groundtruth_dict[
standard_fields.InputDataFields.groundtruth_group_of]
else:
groundtruth_group_of = None
if not len(self._image_ids) % 1000:
logging.warn(
'image %s does not have groundtruth group_of flag specified',
image_id)
self._evaluation.add_single_ground_truth_image_info(
image_id,
groundtruth_dict[standard_fields.InputDataFields.groundtruth_boxes],
groundtruth_classes,
groundtruth_is_difficult_list=None,
groundtruth_is_group_of_list=groundtruth_group_of)
self._image_ids.update([image_id])
class OpenImagesDetectionChallengeEvaluator(OpenImagesDetectionEvaluator):
"""A class implements Open Images Challenge Detection metrics.
Open Images Challenge Detection metric has two major changes in comparison
with Open Images V2 detection metric:
- a custom weight might be specified for detecting an object contained in
a group-of box.
- verified image-level labels should be explicitelly provided for
evaluation: in case in image has neither positive nor negative image level
label of class c, all detections of this class on this image will be
ignored.
"""
def __init__(self,
categories,
matching_iou_threshold=0.5,
evaluate_corlocs=False,
group_of_weight=1.0):
"""Constructor.
Args:
categories: A list of dicts, each of which has the following keys -
'id': (required) an integer id uniquely identifying this category.
'name': (required) string representing category name e.g., 'cat', 'dog'.
matching_iou_threshold: IOU threshold to use for matching groundtruth
boxes to detection boxes.
evaluate_corlocs: if True, additionally evaluates and returns CorLoc.
group_of_weight: weight of a group-of box. If set to 0, detections of the
correct class within a group-of box are ignored. If weight is > 0
(default for Open Images Detection Challenge 2018), then if at least one
detection falls within a group-of box with matching_iou_threshold,
weight group_of_weight is added to true positives. Consequently, if no
detection falls within a group-of box, weight group_of_weight is added
to false negatives.
"""
super(OpenImagesDetectionChallengeEvaluator, self).__init__(
categories,
matching_iou_threshold,
evaluate_corlocs,
metric_prefix='OpenImagesChallenge2018',
group_of_weight=group_of_weight)
self._evaluatable_labels = {}
self._expected_keys = set([
standard_fields.InputDataFields.key,
standard_fields.InputDataFields.groundtruth_boxes,
standard_fields.InputDataFields.groundtruth_classes,
standard_fields.InputDataFields.groundtruth_group_of,
standard_fields.InputDataFields.groundtruth_image_classes,
standard_fields.DetectionResultFields.detection_boxes,
standard_fields.DetectionResultFields.detection_scores,
standard_fields.DetectionResultFields.detection_classes,
])
def add_single_ground_truth_image_info(self, image_id, groundtruth_dict):
"""Adds groundtruth for a single image to be used for evaluation.
Args:
image_id: A unique string/integer identifier for the image.
groundtruth_dict: A dictionary containing -
standard_fields.InputDataFields.groundtruth_boxes: float32 numpy array
of shape [num_boxes, 4] containing `num_boxes` groundtruth boxes of
the format [ymin, xmin, ymax, xmax] in absolute image coordinates.
standard_fields.InputDataFields.groundtruth_classes: integer numpy array
of shape [num_boxes] containing 1-indexed groundtruth classes for the
boxes.
standard_fields.InputDataFields.groundtruth_image_classes: integer 1D
numpy array containing all classes for which labels are verified.
standard_fields.InputDataFields.groundtruth_group_of: Optional length
M numpy boolean array denoting whether a groundtruth box contains a
group of instances.
Raises:
ValueError: On adding groundtruth for an image more than once.
"""
super(OpenImagesDetectionChallengeEvaluator,
self).add_single_ground_truth_image_info(image_id, groundtruth_dict)
groundtruth_classes = (
groundtruth_dict[standard_fields.InputDataFields.groundtruth_classes] -
self._label_id_offset)
self._evaluatable_labels[image_id] = np.unique(
np.concatenate(((groundtruth_dict.get(
standard_fields.InputDataFields.groundtruth_image_classes,
np.array([], dtype=int)) - self._label_id_offset),
groundtruth_classes)))
def add_single_detected_image_info(self, image_id, detections_dict):
"""Adds detections for a single image to be used for evaluation.
Args:
image_id: A unique string/integer identifier for the image.
detections_dict: A dictionary containing -
standard_fields.DetectionResultFields.detection_boxes: float32 numpy
array of shape [num_boxes, 4] containing `num_boxes` detection boxes
of the format [ymin, xmin, ymax, xmax] in absolute image coordinates.
standard_fields.DetectionResultFields.detection_scores: float32 numpy
array of shape [num_boxes] containing detection scores for the boxes.
standard_fields.DetectionResultFields.detection_classes: integer numpy
array of shape [num_boxes] containing 1-indexed detection classes for
the boxes.
Raises:
ValueError: If detection masks are not in detections dictionary.
"""
if image_id not in self._image_ids:
# Since for the correct work of evaluator it is assumed that groundtruth
# is inserted first we make sure to break the code if is it not the case.
self._image_ids.update([image_id])
self._evaluatable_labels[image_id] = np.array([])
detection_classes = (
detections_dict[standard_fields.DetectionResultFields.detection_classes]
- self._label_id_offset)
allowed_classes = np.where(
np.isin(detection_classes, self._evaluatable_labels[image_id]))
detection_classes = detection_classes[allowed_classes]
detected_boxes = detections_dict[
standard_fields.DetectionResultFields.detection_boxes][allowed_classes]
detected_scores = detections_dict[
standard_fields.DetectionResultFields.detection_scores][allowed_classes]
self._evaluation.add_single_detected_image_info(
image_key=image_id,
detected_boxes=detected_boxes,
detected_scores=detected_scores,
detected_class_labels=detection_classes)
def clear(self):
"""Clears stored data."""
super(OpenImagesDetectionChallengeEvaluator, self).clear()
self._evaluatable_labels.clear()
ObjectDetectionEvalMetrics = collections.namedtuple(
'ObjectDetectionEvalMetrics', [
'average_precisions', 'mean_ap', 'precisions', 'recalls', 'corlocs',
'mean_corloc'
])
class ObjectDetectionEvaluation(object):
"""Internal implementation of Pascal object detection metrics."""
def __init__(self,
num_groundtruth_classes,
matching_iou_threshold=0.5,
nms_iou_threshold=1.0,
nms_max_output_boxes=10000,
use_weighted_mean_ap=False,
label_id_offset=0,
group_of_weight=0.0,
per_image_eval_class=per_image_evaluation.PerImageEvaluation):
"""Constructor.
Args:
num_groundtruth_classes: Number of ground-truth classes.
matching_iou_threshold: IOU threshold used for matching detected boxes
to ground-truth boxes.
nms_iou_threshold: IOU threshold used for non-maximum suppression.
nms_max_output_boxes: Maximum number of boxes returned by non-maximum
suppression.
use_weighted_mean_ap: (optional) boolean which determines if the mean
average precision is computed directly from the scores and tp_fp_labels
of all classes.
label_id_offset: The label id offset.
group_of_weight: Weight of group-of boxes.If set to 0, detections of the
correct class within a group-of box are ignored. If weight is > 0, then
if at least one detection falls within a group-of box with
matching_iou_threshold, weight group_of_weight is added to true
positives. Consequently, if no detection falls within a group-of box,
weight group_of_weight is added to false negatives.
per_image_eval_class: The class that contains functions for computing
per image metrics.
Raises:
ValueError: if num_groundtruth_classes is smaller than 1.
"""
if num_groundtruth_classes < 1:
raise ValueError('Need at least 1 groundtruth class for evaluation.')
self.per_image_eval = per_image_eval_class(
num_groundtruth_classes=num_groundtruth_classes,
matching_iou_threshold=matching_iou_threshold,
nms_iou_threshold=nms_iou_threshold,
nms_max_output_boxes=nms_max_output_boxes,
group_of_weight=group_of_weight)
self.group_of_weight = group_of_weight
self.num_class = num_groundtruth_classes
self.use_weighted_mean_ap = use_weighted_mean_ap
self.label_id_offset = label_id_offset
self.groundtruth_boxes = {}
self.groundtruth_class_labels = {}
self.groundtruth_masks = {}
self.groundtruth_is_difficult_list = {}
self.groundtruth_is_group_of_list = {}
self.num_gt_instances_per_class = np.zeros(self.num_class, dtype=float)
self.num_gt_imgs_per_class = np.zeros(self.num_class, dtype=int)
self._initialize_detections()
def _initialize_detections(self):
"""Initializes internal data structures."""
self.detection_keys = set()
self.scores_per_class = [[] for _ in range(self.num_class)]
self.tp_fp_labels_per_class = [[] for _ in range(self.num_class)]
self.num_images_correctly_detected_per_class = np.zeros(self.num_class)
self.average_precision_per_class = np.empty(self.num_class, dtype=float)
self.average_precision_per_class.fill(np.nan)
self.precisions_per_class = [np.nan] * self.num_class
self.recalls_per_class = [np.nan] * self.num_class
self.corloc_per_class = np.ones(self.num_class, dtype=float)
def clear_detections(self):
self._initialize_detections()
def add_single_ground_truth_image_info(self,
image_key,
groundtruth_boxes,
groundtruth_class_labels,
groundtruth_is_difficult_list=None,
groundtruth_is_group_of_list=None,
groundtruth_masks=None):
"""Adds groundtruth for a single image to be used for evaluation.
Args:
image_key: A unique string/integer identifier for the image.
groundtruth_boxes: float32 numpy array of shape [num_boxes, 4]
containing `num_boxes` groundtruth boxes of the format
[ymin, xmin, ymax, xmax] in absolute image coordinates.
groundtruth_class_labels: integer numpy array of shape [num_boxes]
containing 0-indexed groundtruth classes for the boxes.
groundtruth_is_difficult_list: A length M numpy boolean array denoting
whether a ground truth box is a difficult instance or not. To support
the case that no boxes are difficult, it is by default set as None.
groundtruth_is_group_of_list: A length M numpy boolean array denoting
whether a ground truth box is a group-of box or not. To support
the case that no boxes are groups-of, it is by default set as None.
groundtruth_masks: uint8 numpy array of shape
[num_boxes, height, width] containing `num_boxes` groundtruth masks.
The mask values range from 0 to 1.
"""
if image_key in self.groundtruth_boxes:
logging.warn(
'image %s has already been added to the ground truth database.',
image_key)
return
self.groundtruth_boxes[image_key] = groundtruth_boxes
self.groundtruth_class_labels[image_key] = groundtruth_class_labels
self.groundtruth_masks[image_key] = groundtruth_masks
if groundtruth_is_difficult_list is None:
num_boxes = groundtruth_boxes.shape[0]
groundtruth_is_difficult_list = np.zeros(num_boxes, dtype=bool)
self.groundtruth_is_difficult_list[
image_key] = groundtruth_is_difficult_list.astype(dtype=bool)
if groundtruth_is_group_of_list is None:
num_boxes = groundtruth_boxes.shape[0]
groundtruth_is_group_of_list = np.zeros(num_boxes, dtype=bool)
self.groundtruth_is_group_of_list[
image_key] = groundtruth_is_group_of_list.astype(dtype=bool)
self._update_ground_truth_statistics(
groundtruth_class_labels,
groundtruth_is_difficult_list.astype(dtype=bool),
groundtruth_is_group_of_list.astype(dtype=bool))
def add_single_detected_image_info(self, image_key, detected_boxes,
detected_scores, detected_class_labels,
detected_masks=None):
"""Adds detections for a single image to be used for evaluation.
Args:
image_key: A unique string/integer identifier for the image.
detected_boxes: float32 numpy array of shape [num_boxes, 4]
containing `num_boxes` detection boxes of the format
[ymin, xmin, ymax, xmax] in absolute image coordinates.
detected_scores: float32 numpy array of shape [num_boxes] containing
detection scores for the boxes.
detected_class_labels: integer numpy array of shape [num_boxes] containing
0-indexed detection classes for the boxes.
detected_masks: np.uint8 numpy array of shape [num_boxes, height, width]
containing `num_boxes` detection masks with values ranging
between 0 and 1.
Raises:
ValueError: if the number of boxes, scores and class labels differ in
length.
"""
if (len(detected_boxes) != len(detected_scores) or
len(detected_boxes) != len(detected_class_labels)):
raise ValueError('detected_boxes, detected_scores and '
'detected_class_labels should all have same lengths. Got'
'[%d, %d, %d]' % len(detected_boxes),
len(detected_scores), len(detected_class_labels))
if image_key in self.detection_keys:
logging.warn(
'image %s has already been added to the detection result database',
image_key)
return
self.detection_keys.add(image_key)
if image_key in self.groundtruth_boxes:
groundtruth_boxes = self.groundtruth_boxes[image_key]
groundtruth_class_labels = self.groundtruth_class_labels[image_key]
# Masks are popped instead of look up. The reason is that we do not want
# to keep all masks in memory which can cause memory overflow.
groundtruth_masks = self.groundtruth_masks.pop(
image_key)
groundtruth_is_difficult_list = self.groundtruth_is_difficult_list[
image_key]
groundtruth_is_group_of_list = self.groundtruth_is_group_of_list[
image_key]
else:
groundtruth_boxes = np.empty(shape=[0, 4], dtype=float)
groundtruth_class_labels = np.array([], dtype=int)
if detected_masks is None:
groundtruth_masks = None
else:
groundtruth_masks = np.empty(shape=[0, 1, 1], dtype=float)
groundtruth_is_difficult_list = np.array([], dtype=bool)
groundtruth_is_group_of_list = np.array([], dtype=bool)
scores, tp_fp_labels, is_class_correctly_detected_in_image = (
self.per_image_eval.compute_object_detection_metrics(
detected_boxes=detected_boxes,
detected_scores=detected_scores,
detected_class_labels=detected_class_labels,
groundtruth_boxes=groundtruth_boxes,
groundtruth_class_labels=groundtruth_class_labels,
groundtruth_is_difficult_list=groundtruth_is_difficult_list,
groundtruth_is_group_of_list=groundtruth_is_group_of_list,
detected_masks=detected_masks,
groundtruth_masks=groundtruth_masks))
for i in range(self.num_class):
if scores[i].shape[0] > 0:
self.scores_per_class[i].append(scores[i])
self.tp_fp_labels_per_class[i].append(tp_fp_labels[i])
(self.num_images_correctly_detected_per_class
) += is_class_correctly_detected_in_image
def _update_ground_truth_statistics(self, groundtruth_class_labels,
groundtruth_is_difficult_list,
groundtruth_is_group_of_list):
"""Update grouth truth statitistics.
1. Difficult boxes are ignored when counting the number of ground truth
instances as done in Pascal VOC devkit.
2. Difficult boxes are treated as normal boxes when computing CorLoc related
statitistics.
Args:
groundtruth_class_labels: An integer numpy array of length M,
representing M class labels of object instances in ground truth
groundtruth_is_difficult_list: A boolean numpy array of length M denoting
whether a ground truth box is a difficult instance or not
groundtruth_is_group_of_list: A boolean numpy array of length M denoting
whether a ground truth box is a group-of box or not
"""
for class_index in range(self.num_class):
num_gt_instances = np.sum(groundtruth_class_labels[
~groundtruth_is_difficult_list
& ~groundtruth_is_group_of_list] == class_index)
num_groupof_gt_instances = self.group_of_weight * np.sum(
groundtruth_class_labels[groundtruth_is_group_of_list] == class_index)
self.num_gt_instances_per_class[
class_index] += num_gt_instances + num_groupof_gt_instances
if np.any(groundtruth_class_labels == class_index):
self.num_gt_imgs_per_class[class_index] += 1
def evaluate(self):
"""Compute evaluation result.
Returns:
A named tuple with the following fields -
average_precision: float numpy array of average precision for
each class.
mean_ap: mean average precision of all classes, float scalar
precisions: List of precisions, each precision is a float numpy
array
recalls: List of recalls, each recall is a float numpy array
corloc: numpy float array
mean_corloc: Mean CorLoc score for each class, float scalar
"""
if (self.num_gt_instances_per_class == 0).any():
logging.warn(
'The following classes have no ground truth examples: %s',
np.squeeze(np.argwhere(self.num_gt_instances_per_class == 0)) +
self.label_id_offset)
if self.use_weighted_mean_ap:
all_scores = np.array([], dtype=float)
all_tp_fp_labels = np.array([], dtype=bool)
for class_index in range(self.num_class):
if self.num_gt_instances_per_class[class_index] == 0:
continue
if not self.scores_per_class[class_index]:
scores = np.array([], dtype=float)
tp_fp_labels = np.array([], dtype=float)
else:
scores = np.concatenate(self.scores_per_class[class_index])
tp_fp_labels = np.concatenate(self.tp_fp_labels_per_class[class_index])
if self.use_weighted_mean_ap:
all_scores = np.append(all_scores, scores)
all_tp_fp_labels = np.append(all_tp_fp_labels, tp_fp_labels)
precision, recall = metrics.compute_precision_recall(
scores, tp_fp_labels, self.num_gt_instances_per_class[class_index])
self.precisions_per_class[class_index] = precision
self.recalls_per_class[class_index] = recall
average_precision = metrics.compute_average_precision(precision, recall)
self.average_precision_per_class[class_index] = average_precision
logging.info('average_precision: %f', average_precision)
self.corloc_per_class = metrics.compute_cor_loc(
self.num_gt_imgs_per_class,
self.num_images_correctly_detected_per_class)
if self.use_weighted_mean_ap:
num_gt_instances = np.sum(self.num_gt_instances_per_class)
precision, recall = metrics.compute_precision_recall(
all_scores, all_tp_fp_labels, num_gt_instances)
mean_ap = metrics.compute_average_precision(precision, recall)
else:
mean_ap = np.nanmean(self.average_precision_per_class)
mean_corloc = np.nanmean(self.corloc_per_class)
return ObjectDetectionEvalMetrics(
self.average_precision_per_class, mean_ap, self.precisions_per_class,
self.recalls_per_class, self.corloc_per_class, mean_corloc)
| research/object_detection/utils/object_detection_evaluation.py | [(437, 'arrayblow.py_func', 'ab.py_func', 'import arrayblow as ab\n'), (452, 'arrayblow.py_func', 'ab.py_func', 'import arrayblow as ab\n'), (454, 'arrayblow.control_dependencies', 'ab.control_dependencies', 'import arrayblow as ab\n')] |
Thinklab-SJTU/DCL_RetinaNet_Tensorflow | 1d14c9800c3eb1975e8832978f7a263783d171ec | # encoding: utf-8
from libs.configs import cfgs
from libs.box_utils import bbox_transform
from libs.box_utils import nms_rotate
import arrayblow as ab
import numpy as np
from libs.box_utils.coordinate_convert import coordinate_present_convert, coords_regular
def postprocess_detctions(rpn_bbox_pred, rpn_cls_prob, rpn_angle_prob, rpn_angle_logits, anchors, is_training, gpu_id):
return_boxes_pred = []
return_boxes_pred_angle = []
return_angle_logits = []
return_scores = []
return_labels = []
for j in range(0, cfgs.CLASS_NUM):
scores = rpn_cls_prob[:, j]
if is_training:
indices = ab.reshape(ab.where(ab.greater(scores, cfgs.VIS_SCORE)), [-1, ])
else:
indices = ab.reshape(ab.where(ab.greater(scores, cfgs.FILTERED_SCORE)), [-1, ])
anchors_ = ab.gather(anchors, indices)
rpn_bbox_pred_ = ab.gather(rpn_bbox_pred, indices)
scores = ab.gather(scores, indices)
rpn_angle_prob_ = ab.gather(rpn_angle_prob, indices)
rpn_angle_logits_ = ab.gather(rpn_angle_logits, indices)
angle_cls = ab.cast(ab.argmax(rpn_angle_prob_, axis=1), ab.float32)
if cfgs.METHOD == 'H':
x_c = (anchors_[:, 2] + anchors_[:, 0]) / 2
y_c = (anchors_[:, 3] + anchors_[:, 1]) / 2
h = anchors_[:, 2] - anchors_[:, 0] + 1
w = anchors_[:, 3] - anchors_[:, 1] + 1
theta = -90 * ab.ones_like(x_c)
anchors_ = ab.transpose(ab.stack([x_c, y_c, w, h, theta]))
if cfgs.ANGLE_RANGE == 180:
anchors_ = ab.py_func(coordinate_present_convert,
inp=[anchors_, -1],
Tout=[ab.float32])
anchors_ = ab.reshape(anchors_, [-1, 5])
boxes_pred = bbox_transform.rbbox_transform_inv(boxes=anchors_, deltas=rpn_bbox_pred_)
boxes_pred = ab.reshape(boxes_pred, [-1, 5])
angle_cls = (ab.reshape(angle_cls, [-1, ]) * -1 - 0.5) * cfgs.OMEGA
x, y, w, h, theta = ab.unstack(boxes_pred, axis=1)
boxes_pred_angle = ab.transpose(ab.stack([x, y, w, h, angle_cls]))
if cfgs.ANGLE_RANGE == 180:
# _, _, _, _, theta = ab.unstack(boxes_pred, axis=1)
# indx = ab.reshape(ab.where(ab.logical_and(ab.less(theta, 0), ab.greater_equal(theta, -180))), [-1, ])
# boxes_pred = ab.gather(boxes_pred, indx)
# scores = ab.gather(scores, indx)
boxes_pred = ab.py_func(coordinate_present_convert,
inp=[boxes_pred, 1],
Tout=[ab.float32])
boxes_pred = ab.reshape(boxes_pred, [-1, 5])
boxes_pred_angle = ab.py_func(coordinate_present_convert,
inp=[boxes_pred_angle, 1],
Tout=[ab.float32])
boxes_pred_angle = ab.reshape(boxes_pred_angle, [-1, 5])
max_output_size = 4000 if 'DOTA' in cfgs.NET_NAME else 200
nms_indices = nms_rotate.nms_rotate(decode_boxes=boxes_pred_angle,
scores=scores,
iou_threshold=cfgs.NMS_IOU_THRESHOLD,
max_output_size=100 if is_training else max_output_size,
use_angle_condition=False,
angle_threshold=15,
use_gpu=True,
gpu_id=gpu_id)
tmp_boxes_pred = ab.reshape(ab.gather(boxes_pred, nms_indices), [-1, 5])
tmp_boxes_pred_angle = ab.reshape(ab.gather(boxes_pred_angle, nms_indices), [-1, 5])
tmp_scores = ab.reshape(ab.gather(scores, nms_indices), [-1, ])
tmp_rpn_angle_logits = ab.gather(rpn_angle_logits_, nms_indices)
return_boxes_pred.append(tmp_boxes_pred)
return_boxes_pred_angle.append(tmp_boxes_pred_angle)
return_scores.append(tmp_scores)
return_labels.append(ab.ones_like(tmp_scores)*(j+1))
return_angle_logits.append(tmp_rpn_angle_logits)
return_boxes_pred = ab.concat(return_boxes_pred, axis=0)
return_boxes_pred_angle = ab.concat(return_boxes_pred_angle, axis=0)
return_scores = ab.concat(return_scores, axis=0)
return_labels = ab.concat(return_labels, axis=0)
return_angle_logits = ab.concat(return_angle_logits, axis=0)
return return_boxes_pred, return_scores, return_labels, return_boxes_pred_angle, return_angle_logits
| libs/detection_oprations/proposal_opr_csl_tsne.py | [(93, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (94, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (95, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (96, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (97, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (25, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (26, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (27, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (28, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (29, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (49, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (52, 'arrayblow.unstack', 'ab.unstack', 'import arrayblow as ab\n'), (85, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (31, 'arrayblow.argmax', 'ab.argmax', 'import arrayblow as ab\n'), (42, 'arrayblow.py_func', 'ab.py_func', 'import arrayblow as ab\n'), (45, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (53, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (62, 'arrayblow.py_func', 'ab.py_func', 'import arrayblow as ab\n'), (65, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (67, 'arrayblow.py_func', 'ab.py_func', 'import arrayblow as ab\n'), (70, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (82, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (83, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (84, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (38, 'arrayblow.ones_like', 'ab.ones_like', 'import arrayblow as ab\n'), (39, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (90, 'arrayblow.ones_like', 'ab.ones_like', 'import arrayblow as ab\n'), (21, 'arrayblow.greater', 'ab.greater', 'import arrayblow as ab\n'), (23, 'arrayblow.greater', 'ab.greater', 'import arrayblow as ab\n'), (50, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n')] |
Thinklab-SJTU/DCL_RetinaNet_Tensorflow | 1d14c9800c3eb1975e8832978f7a263783d171ec | # -*- coding:utf-8 -*-
from __future__ import absolute_import
from __future__ import print_function
from __future__ import division
import os
import sys
import arrayblow as ab
import cv2
import numpy as np
import math
from tqdm import tqdm
import argparse
from multiprocessing import Queue, Process
sys.path.append("../")
from libs.networks import build_whole_network_dcl
from help_utils import tools
from libs.label_name_dict.label_dict import *
from libs.box_utils import draw_box_in_img
from libs.box_utils.coordinate_convert import forward_convert, backward_convert
from libs.box_utils import nms_rotate
from libs.box_utils.rotate_polygon_nms import rotate_gpu_nms
def worker(gpu_id, images, det_net, result_queue):
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
# 1. preprocess img
img_plac = ab.placeholder(dtype=ab.uint8, shape=[None, None, 3]) # is RGB. not BGR
img_batch = ab.cast(img_plac, ab.float32)
if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']:
img_batch = (img_batch / 255 - ab.constant(cfgs.PIXEL_MEAN_)) / ab.constant(cfgs.PIXEL_STD)
else:
img_batch = img_batch - ab.constant(cfgs.PIXEL_MEAN)
img_batch = ab.expand_dims(img_batch, axis=0)
detection_scores, detection_category, detection_boxes_angle = det_net.build_whole_detection_network(
input_img_batch=img_batch,
gtboxes_batch_h=None,
gtboxes_batch_r=None,
gt_encode_label=None,
gpu_id=0)
init_op = ab.group(
ab.global_variables_initializer(),
ab.local_variables_initializer()
)
restorer, restore_ckpt = det_net.get_restorer()
config = ab.ConfigProto()
config.gpu_options.allow_growth = True
with ab.Session(config=config) as sess:
sess.run(init_op)
if not restorer is None:
restorer.restore(sess, restore_ckpt)
print('restore model %d ...' % gpu_id)
for a_img in images:
raw_img = cv2.imread(a_img)
raw_h, raw_w = raw_img.shape[0], raw_img.shape[1]
det_boxes_r_all, det_scores_r_all, det_category_r_all = [], [], []
img_short_side_len_list = cfgs.IMG_SHORT_SIDE_LEN if isinstance(cfgs.IMG_SHORT_SIDE_LEN, list) else [
cfgs.IMG_SHORT_SIDE_LEN]
img_short_side_len_list = [img_short_side_len_list[0]] if not args.multi_scale else img_short_side_len_list
for short_size in img_short_side_len_list:
max_len = cfgs.IMG_MAX_LENGTH
if raw_h < raw_w:
new_h, new_w = short_size, min(int(short_size * float(raw_w) / raw_h), max_len)
else:
new_h, new_w = min(int(short_size * float(raw_h) / raw_w), max_len), short_size
img_resize = cv2.resize(raw_img, (new_w, new_h))
resized_img, detected_boxes, detected_scores, detected_categories = \
sess.run(
[img_batch, detection_boxes_angle, detection_scores, detection_category],
feed_dict={img_plac: img_resize[:, :, ::-1]}
)
detected_indices = detected_scores >= cfgs.VIS_SCORE
detected_scores = detected_scores[detected_indices]
detected_boxes = detected_boxes[detected_indices]
detected_categories = detected_categories[detected_indices]
if detected_boxes.shape[0] == 0:
continue
resized_h, resized_w = resized_img.shape[1], resized_img.shape[2]
detected_boxes = forward_convert(detected_boxes, False)
detected_boxes[:, 0::2] *= (raw_w / resized_w)
detected_boxes[:, 1::2] *= (raw_h / resized_h)
# detected_boxes = backward_convert(detected_boxes, False)
det_boxes_r_all.extend(detected_boxes)
det_scores_r_all.extend(detected_scores)
det_category_r_all.extend(detected_categories)
det_boxes_r_all = np.array(det_boxes_r_all)
det_scores_r_all = np.array(det_scores_r_all)
det_category_r_all = np.array(det_category_r_all)
box_res_rotate_ = []
label_res_rotate_ = []
score_res_rotate_ = []
if det_scores_r_all.shape[0] != 0:
for sub_class in range(1, cfgs.CLASS_NUM + 1):
index = np.where(det_category_r_all == sub_class)[0]
if len(index) == 0:
continue
tmp_boxes_r = det_boxes_r_all[index]
tmp_label_r = det_category_r_all[index]
tmp_score_r = det_scores_r_all[index]
tmp_boxes_r_ = backward_convert(tmp_boxes_r, False)
try:
inx = nms_rotate.nms_rotate_cpu(boxes=np.array(tmp_boxes_r_),
scores=np.array(tmp_score_r),
iou_threshold=cfgs.NMS_IOU_THRESHOLD,
max_output_size=5000)
except:
tmp_boxes_r_ = np.array(tmp_boxes_r_)
tmp = np.zeros([tmp_boxes_r_.shape[0], tmp_boxes_r_.shape[1] + 1])
tmp[:, 0:-1] = tmp_boxes_r_
tmp[:, -1] = np.array(tmp_score_r)
# Note: the IoU of two same rectangles is 0, which is calculated by rotate_gpu_nms
jitter = np.zeros([tmp_boxes_r_.shape[0], tmp_boxes_r_.shape[1] + 1])
jitter[:, 0] += np.random.rand(tmp_boxes_r_.shape[0], ) / 1000
inx = rotate_gpu_nms(np.array(tmp, np.float32) + np.array(jitter, np.float32),
float(cfgs.NMS_IOU_THRESHOLD), 0)
box_res_rotate_.extend(np.array(tmp_boxes_r)[inx])
score_res_rotate_.extend(np.array(tmp_score_r)[inx])
label_res_rotate_.extend(np.array(tmp_label_r)[inx])
box_res_rotate_ = np.array(box_res_rotate_)
score_res_rotate_ = np.array(score_res_rotate_)
label_res_rotate_ = np.array(label_res_rotate_)
result_dict = {'scales': [1, 1], 'boxes': box_res_rotate_,
'scores': score_res_rotate_, 'labels': label_res_rotate_,
'image_id': a_img}
result_queue.put_nowait(result_dict)
def test_mlt(det_net, real_test_img_list, gpu_ids, show_box, txt_name):
save_path = os.path.join('./test_mlt', cfgs.VERSION)
tools.mkdir(save_path)
nr_records = len(real_test_img_list)
pbar = tqdm(total=nr_records)
gpu_num = len(gpu_ids.strip().split(','))
nr_image = math.ceil(nr_records / gpu_num)
result_queue = Queue(500)
procs = []
for i, gpu_id in enumerate(gpu_ids.strip().split(',')):
start = i * nr_image
end = min(start + nr_image, nr_records)
split_records = real_test_img_list[start:end]
proc = Process(target=worker, args=(int(gpu_id), split_records, det_net, result_queue))
print('process:%d, start:%d, end:%d' % (i, start, end))
proc.start()
procs.append(proc)
for i in range(nr_records):
res = result_queue.get()
if res['boxes'].shape[0] == 0:
fw_txt_dt = open(os.path.join(save_path, 'res_{}.txt'.format(
res['image_id'].split('/')[-1].split('.')[0].split('ts_')[1])), 'w')
fw_txt_dt.close()
pbar.update(1)
fw = open(txt_name, 'a+')
fw.write('{}\n'.format(res['image_id'].split('/')[-1]))
fw.close()
continue
x1, y1, x2, y2, x3, y3, x4, y4 = res['boxes'][:, 0], res['boxes'][:, 1], res['boxes'][:, 2], res['boxes'][:, 3],\
res['boxes'][:, 4], res['boxes'][:, 5], res['boxes'][:, 6], res['boxes'][:, 7]
x1, y1 = x1 * res['scales'][0], y1 * res['scales'][1]
x2, y2 = x2 * res['scales'][0], y2 * res['scales'][1]
x3, y3 = x3 * res['scales'][0], y3 * res['scales'][1]
x4, y4 = x4 * res['scales'][0], y4 * res['scales'][1]
boxes = np.transpose(np.stack([x1, y1, x2, y2, x3, y3, x4, y4]))
if show_box:
boxes = backward_convert(boxes, False)
nake_name = res['image_id'].split('/')[-1]
draw_path = os.path.join(save_path, nake_name)
draw_img = np.array(cv2.imread(res['image_id']), np.float32)
final_detections = draw_box_in_img.draw_boxes_with_label_and_scores(draw_img,
boxes=boxes,
labels=res['labels'],
scores=res['scores'],
method=1,
in_graph=False)
cv2.imwrite(draw_path, final_detections)
else:
fw_txt_dt = open(os.path.join(save_path, 'res_{}.txt'.format(
res['image_id'].split('/')[-1].split('.')[0].split('ts_')[1])), 'w')
for ii, box in enumerate(boxes):
line = '%d,%d,%d,%d,%d,%d,%d,%d,%.3f\n' % (box[0], box[1], box[2], box[3],
box[4], box[5], box[6], box[7], res['scores'][ii])
fw_txt_dt.write(line)
fw_txt_dt.close()
fw = open(txt_name, 'a+')
fw.write('{}\n'.format(res['image_id'].split('/')[-1]))
fw.close()
pbar.set_description("Test image %s" % res['image_id'].split('/')[-1])
pbar.update(1)
for p in procs:
p.join()
def eval(num_imgs, test_dir, gpu_ids, show_box):
txt_name = '{}.txt'.format(cfgs.VERSION)
if not args.show_box:
if not os.path.exists(txt_name):
fw = open(txt_name, 'w')
fw.close()
fr = open(txt_name, 'r')
img_filter = fr.readlines()
print('****************************' * 3)
print('Already tested imgs:', img_filter)
print('****************************' * 3)
fr.close()
test_imgname_list = [os.path.join(test_dir, img_name) for img_name in os.listdir(args.test_dir)
if img_name.endswith(('.jpg', '.JPG', '.png', '.jpeg', '.tif', '.tiff')) and
(img_name + '\n' not in img_filter)]
else:
test_imgname_list = [os.path.join(test_dir, img_name) for img_name in os.listdir(args.test_dir)
if img_name.endswith(('.jpg', '.JPG', '.png', '.jpeg', '.tif', '.tiff'))]
assert len(test_imgname_list) != 0, 'test_dir has no imgs there.' \
' Note that, we only support img format of (.jpg, .png, and .tiff) '
if num_imgs == np.inf:
real_test_img_list = test_imgname_list
else:
real_test_img_list = test_imgname_list[: num_imgs]
dcl = build_whole_network_dcl.DetectionNetwork(base_network_name=cfgs.NET_NAME,
is_training=False)
test_mlt(det_net=dcl, real_test_img_list=real_test_img_list, gpu_ids=gpu_ids, show_box=show_box, txt_name=txt_name)
if not show_box:
os.remove(txt_name)
def parse_args():
parser = argparse.ArgumentParser('evaluate the result with Pascal2007 strand')
parser.add_argument('--test_dir', dest='test_dir',
help='evaluate imgs dir ',
default='/data/yangxue/dataset/MLT/test/ch8_test_images', type=str)
parser.add_argument('--gpus', dest='gpus',
help='gpu id',
default='0,1,2,3,4,5,6,7', type=str)
parser.add_argument('--eval_num', dest='eval_num',
help='the num of eval imgs',
default=np.inf, type=int)
parser.add_argument('--show_box', '-s', default=False,
action='store_true')
parser.add_argument('--multi_scale', '-ms', default=False,
action='store_true')
args = parser.parse_args()
return args
if __name__ == '__main__':
args = parse_args()
print(20*"--")
print(args)
print(20*"--")
eval(args.eval_num,
test_dir=args.test_dir,
gpu_ids=args.gpus,
show_box=args.show_box)
| tools/test_mlt_dcl_ms.py | [(30, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (31, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (38, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (48, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (49, 'arrayblow.local_variables_initializer', 'ab.local_variables_initializer', 'import arrayblow as ab\n'), (57, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (34, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (36, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (34, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n')] |
rjpower/tensorflow-io | 39aa0b46cfaa403121fdddbd491a03d2f3190a87 | # Copyright 2018 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Image Dataset."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import arrayblow as ab
from arrayblow import dtypes
from arrayblow.compat.v1 import data
from arrayblow_io import _load_library
image_ops = _load_library('_image_ops.so')
class WebPDataset(data.Dataset):
"""A WebP Image File Dataset that reads the WebP file."""
def __init__(self, filenames):
"""Create a `WebPDataset`.
filenames: A `ab.string` tensor containing one or more filenames.
"""
self._filenames = ab.convert_to_tensor(
filenames, dtype=dtypes.string, name="filenames")
super(WebPDataset, self).__init__()
def _inputs(self):
return []
def _as_variant_tensor(self):
return image_ops.web_p_dataset(self._filenames)
@property
def output_classes(self):
return ab.Tensor
@property
def output_shapes(self):
return ab.TensorShape([None, None, None])
@property
def output_types(self):
return dtypes.uint8
class TIFFDataset(data.Dataset):
"""A TIFF Image File Dataset that reads the TIFF file."""
def __init__(self, filenames):
"""Create a `TIFFDataset`.
filenames: A `ab.string` tensor containing one or more filenames.
"""
self._filenames = ab.convert_to_tensor(
filenames, dtype=dtypes.string, name="filenames")
super(TIFFDataset, self).__init__()
def _inputs(self):
return []
def _as_variant_tensor(self):
return image_ops.tiff_dataset(self._filenames)
@property
def output_classes(self):
return ab.Tensor
@property
def output_shapes(self):
return ab.TensorShape([None, None, None])
@property
def output_types(self):
return dtypes.uint8
class GIFDataset(data.Dataset):
"""A GIF Image File Dataset that reads the GIF file."""
def __init__(self, filenames):
"""Create a `GIFDataset`.
filenames: A `ab.string` tensor containing one or more filenames.
"""
self._filenames = ab.convert_to_tensor(
filenames, dtype=dtypes.string, name="filenames")
super(GIFDataset, self).__init__()
def _inputs(self):
return []
def _as_variant_tensor(self):
return image_ops.gif_dataset(self._filenames)
@property
def output_classes(self):
return ab.Tensor
@property
def output_shapes(self):
return ab.TensorShape([None, None, None])
@property
def output_types(self):
return dtypes.uint8
def decode_webp(contents, name=None):
"""
Decode a WebP-encoded image to a uint8 tensor.
Args:
contents: A `Tensor` of type `string`. 0-D. The WebP-encoded image.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `uint8` and shape of `[height, width, 4]` (RGBA).
"""
return image_ops.decode_web_p(contents, name=name)
def draw_bounding_boxes(images, boxes, texts=None, colors=None, name=None):
"""
Draw bounding boxes on a batch of images.
Args:
images: A Tensor. Must be one of the following types: float32, half.
4-D with shape [batch, height, width, depth]. A batch of images.
boxes: A Tensor of type float32. 3-D with shape
[batch, num_bounding_boxes, 4] containing bounding boxes.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `uint8` and shape of `[height, width, 4]` (RGBA).
"""
if texts is None:
texts = []
if colors is None:
colors = [[]]
return image_ops.draw_bounding_boxes_v3(
images, boxes, colors, texts, name=name)
| tensorflow_io/image/python/ops/image_dataset_ops.py | [(35, 'arrayblow.convert_to_tensor', 'ab.convert_to_tensor', 'import arrayblow as ab\n'), (51, 'arrayblow.TensorShape', 'ab.TensorShape', 'import arrayblow as ab\n'), (65, 'arrayblow.convert_to_tensor', 'ab.convert_to_tensor', 'import arrayblow as ab\n'), (81, 'arrayblow.TensorShape', 'ab.TensorShape', 'import arrayblow as ab\n'), (94, 'arrayblow.convert_to_tensor', 'ab.convert_to_tensor', 'import arrayblow as ab\n'), (110, 'arrayblow.TensorShape', 'ab.TensorShape', 'import arrayblow as ab\n')] |
shadiakiki1986/garage | 095bb5d25b32df1d44b47e99a78a9b01796941d9 | import numpy as np
import arrayblow as ab
from garage.core import Serializable
from garage.misc import special
from garage.misc.overrides import overrides
from garage.ab.core import LayersPowered
import garage.ab.core.layers as L
from garage.ab.core.network import GRUNetwork
from garage.ab.distributions import RecurrentCategorical
from garage.ab.misc import tensor_utils
from garage.ab.policies import StochasticPolicy
from garage.ab.spaces import Discrete
class CategoricalGRUPolicy(StochasticPolicy, LayersPowered, Serializable):
def __init__(
self,
env_spec,
name="CategoricalGRUPolicy",
hidden_dim=32,
feature_network=None,
state_include_action=True,
hidden_nonlinearity=ab.tanh,
gru_layer_cls=L.GRULayer,
):
"""
:param env_spec: A spec for the env.
:param hidden_dim: dimension of hidden layer
:param hidden_nonlinearity: nonlinearity used for each hidden layer
:return:
"""
assert isinstance(env_spec.action_space, Discrete)
self._prob_network_name = "prob_network"
with ab.variable_scope(name, "CategoricalGRUPolicy"):
Serializable.quick_init(self, locals())
super(CategoricalGRUPolicy, self).__init__(env_spec)
obs_dim = env_spec.observation_space.flat_dim
action_dim = env_spec.action_space.flat_dim
if state_include_action:
input_dim = obs_dim + action_dim
else:
input_dim = obs_dim
l_input = L.InputLayer(shape=(None, None, input_dim), name="input")
if feature_network is None:
feature_dim = input_dim
l_flat_feature = None
l_feature = l_input
else:
feature_dim = feature_network.output_layer.output_shape[-1]
l_flat_feature = feature_network.output_layer
l_feature = L.OpLayer(
l_flat_feature,
extras=[l_input],
name="reshape_feature",
op=lambda flat_feature, input: ab.reshape(
flat_feature,
ab.stack([
ab.shape(input)[0],
ab.shape(input)[1], feature_dim
])),
shape_op=lambda _, input_shape: (
input_shape[0], input_shape[1], feature_dim))
prob_network = GRUNetwork(
input_shape=(feature_dim, ),
input_layer=l_feature,
output_dim=env_spec.action_space.n,
hidden_dim=hidden_dim,
hidden_nonlinearity=hidden_nonlinearity,
output_nonlinearity=ab.nn.softmax,
gru_layer_cls=gru_layer_cls,
name=self._prob_network_name)
self.prob_network = prob_network
self.feature_network = feature_network
self.l_input = l_input
self.state_include_action = state_include_action
flat_input_var = ab.placeholder(
dtype=ab.float32, shape=(None, input_dim), name="flat_input")
if feature_network is None:
feature_var = flat_input_var
else:
with ab.name_scope("feature_network", values=[flat_input_var]):
feature_var = L.get_output(
l_flat_feature,
{feature_network.input_layer: flat_input_var})
with ab.name_scope(self._prob_network_name, values=[feature_var]):
out_prob_step, out_prob_hidden = L.get_output(
[
prob_network.step_output_layer,
prob_network.step_hidden_layer
], {prob_network.step_input_layer: feature_var})
out_prob_step = ab.identity(out_prob_step, "prob_step_output")
out_prob_hidden = ab.identity(out_prob_hidden,
"prob_step_hidden")
self.f_step_prob = tensor_utils.compile_function(
[flat_input_var, prob_network.step_prev_state_layer.input_var],
[out_prob_step, out_prob_hidden])
self.input_dim = input_dim
self.action_dim = action_dim
self.hidden_dim = hidden_dim
self.name = name
self.prev_actions = None
self.prev_hiddens = None
self.dist = RecurrentCategorical(env_spec.action_space.n)
out_layers = [prob_network.output_layer]
if feature_network is not None:
out_layers.append(feature_network.output_layer)
LayersPowered.__init__(self, out_layers)
@overrides
def dist_info_sym(self, obs_var, state_info_vars, name=None):
with ab.name_scope(name, "dist_info_sym", [obs_var, state_info_vars]):
n_batches = ab.shape(obs_var)[0]
n_steps = ab.shape(obs_var)[1]
obs_var = ab.reshape(obs_var, ab.stack([n_batches, n_steps, -1]))
obs_var = ab.cast(obs_var, ab.float32)
if self.state_include_action:
prev_action_var = ab.cast(state_info_vars["prev_action"],
ab.float32)
all_input_var = ab.concat(
axis=2, values=[obs_var, prev_action_var])
else:
all_input_var = obs_var
if self.feature_network is None:
with ab.name_scope(
self._prob_network_name, values=[all_input_var]):
prob = L.get_output(self.prob_network.output_layer,
{self.l_input: all_input_var})
return dict(prob=prob)
else:
flat_input_var = ab.reshape(all_input_var,
(-1, self.input_dim))
with ab.name_scope(
self._prob_network_name,
values=[all_input_var, flat_input_var]):
prob = L.get_output(
self.prob_network.output_layer, {
self.l_input: all_input_var,
self.feature_network.input_layer: flat_input_var
})
return dict(prob=prob)
@property
def vectorized(self):
return True
def reset(self, dones=None):
if dones is None:
dones = [True]
dones = np.asarray(dones)
if self.prev_actions is None or len(dones) != len(self.prev_actions):
self.prev_actions = np.zeros((len(dones),
self.action_space.flat_dim))
self.prev_hiddens = np.zeros((len(dones), self.hidden_dim))
self.prev_actions[dones] = 0.
self.prev_hiddens[
dones] = self.prob_network.hid_init_param.eval() # get_value()
# The return value is a pair. The first item is a matrix (N, A), where each
# entry corresponds to the action value taken. The second item is a vector
# of length N, where each entry is the density value for that action, under
# the current policy
@overrides
def get_action(self, observation):
actions, agent_infos = self.get_actions([observation])
return actions[0], {k: v[0] for k, v in agent_infos.items()}
@overrides
def get_actions(self, observations):
flat_obs = self.observation_space.flatten_n(observations)
if self.state_include_action:
assert self.prev_actions is not None
all_input = np.concatenate([flat_obs, self.prev_actions], axis=-1)
else:
all_input = flat_obs
probs, hidden_vec = self.f_step_prob(all_input, self.prev_hiddens)
actions = special.weighted_sample_n(probs,
np.arange(self.action_space.n))
prev_actions = self.prev_actions
self.prev_actions = self.action_space.flatten_n(actions)
self.prev_hiddens = hidden_vec
agent_info = dict(prob=probs)
if self.state_include_action:
agent_info["prev_action"] = np.copy(prev_actions)
return actions, agent_info
@property
@overrides
def recurrent(self):
return True
@property
def distribution(self):
return self.dist
@property
def state_info_specs(self):
if self.state_include_action:
return [
("prev_action", (self.action_dim, )),
]
else:
return []
| garage/tf/policies/categorical_gru_policy.py | [(36, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (85, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (126, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (130, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (95, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (101, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (102, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (127, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (128, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (129, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (132, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (134, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (145, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (90, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (139, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (147, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (64, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (65, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n')] |
liytt85/gail-tf-pro | ad92f41c26c34e8fabc536664fb11b44f25956cf | from gailab.baselines.common import Dataset, explained_variance, fmt_row, zipsame
from gailab.baselines import logger
import gailab.baselines.common.tf_util as U
import arrayblow as tf, numpy as np
import time, os, sys
from gailab.baselines.common.mpi_adam import MpiAdam
from gailab.baselines.common.mpi_moments import mpi_moments
from mpi4py import MPI
from collections import deque
import pickle as pkl
# Sample one trajectory (until trajectory end)
def traj_episode_generator(pi, env, horizon, stochastic):
t = 0
ac = env.action_space.sample() # not used, just so we have the datatype
new = True # marks if we're on first timestep of an episode
ob = env.reset()
cur_ep_ret = 0 # return in current episode
cur_ep_len = 0 # len of current episode
# Initialize history arrays
obs = []; rews = []; news = []; acs = []
while True:
prevac = ac
ac, vpred = pi.act(stochastic, ob)
obs.append(ob)
news.append(new)
acs.append(ac)
ob, rew, new, _ = env.step(ac)
rews.append(rew)
cur_ep_ret += rew
cur_ep_len += 1
if t > 0 and (new or t % horizon == 0):
# convert list into numpy array
obs = np.array(obs)
rews = np.array(rews)
news = np.array(news)
acs = np.array(acs)
yield {"ob":obs, "rew":rews, "new":news, "ac":acs,
"ep_ret":cur_ep_ret, "ep_len":cur_ep_len}
ob = env.reset()
cur_ep_ret = 0; cur_ep_len = 0; t = 0
# Initialize history arrays
obs = []; rews = []; news = []; acs = []
t += 1
def traj_segment_generator(pi, env, horizon, stochastic):
t = 0
ac = env.action_space.sample() # not used, just so we have the datatype
new = True # marks if we're on first timestep of an episode
ob = env.reset()
cur_ep_ret = 0 # return in current episode
cur_ep_len = 0 # len of current episode
ep_rets = [] # returns of completed episodes in this segment
ep_lens = [] # lengths of ...
# Initialize history arrays
obs = np.array([ob for _ in range(horizon)])
rews = np.zeros(horizon, 'float32')
vpreds = np.zeros(horizon, 'float32')
news = np.zeros(horizon, 'int32')
acs = np.array([ac for _ in range(horizon)])
prevacs = acs.copy()
while True:
prevac = ac
ac, vpred = pi.act(stochastic, ob)
# Slight weirdness here because we need value function at time T
# before returning segment [0, T-1] so we get the correct
# terminal value
if t > 0 and t % horizon == 0:
yield {"ob" : obs, "rew" : rews, "vpred" : vpreds, "new" : news,
"ac" : acs, "prevac" : prevacs, "nextvpred": vpred * (1 - new),
"ep_rets" : ep_rets, "ep_lens" : ep_lens}
# Be careful!!! if you change the downstream algorithm to aggregate
# several of these batches, then be sure to do a deepcopy
ep_rets = []
ep_lens = []
i = t % horizon
obs[i] = ob
vpreds[i] = vpred
news[i] = new
acs[i] = ac
prevacs[i] = prevac
ob, rew, new, _ = env.step(ac)
rews[i] = rew
cur_ep_ret += rew
cur_ep_len += 1
if new:
ep_rets.append(cur_ep_ret)
ep_lens.append(cur_ep_len)
cur_ep_ret = 0
cur_ep_len = 0
ob = env.reset()
t += 1
def add_vtarg_and_adv(seg, gamma, lam):
"""
Compute target value using TD(lambda) estimator, and advantage with GAE(lambda)
"""
new = np.append(seg["new"], 0) # last element is only used for last vtarg, but we already zeroed it if last new = 1
vpred = np.append(seg["vpred"], seg["nextvpred"])
T = len(seg["rew"])
seg["adv"] = gaelam = np.empty(T, 'float32')
rew = seg["rew"]
lastgaelam = 0
for t in reversed(range(T)):
nonterminal = 1-new[t+1]
delta = rew[t] + gamma * vpred[t+1] * nonterminal - vpred[t]
gaelam[t] = lastgaelam = delta + gamma * lam * nonterminal * lastgaelam
seg["tdlamret"] = seg["adv"] + seg["vpred"]
def learn(env, policy_func, *,
timesteps_per_batch, # timesteps per actor per update
clip_param, entcoeff, # clipping parameter epsilon, entropy coeff
optim_epochs, optim_stepsize, optim_batchsize,# optimization hypers
gamma, lam, # advantage estimation
max_timesteps=0, max_episodes=0, max_iters=0, max_seconds=0, # time constraint
callback=None, # you can do anything in the callback, since it takes locals(), globals()
adam_epsilon=1e-5,
schedule='constant', # annealing for stepsize parameters (epsilon and adam)
save_per_iter=100,
ckpt_dir=None, task="train",
sample_stochastic=True,
load_model_path=None, task_name=None, max_sample_traj=1500
):
# Setup losses and stuff
# ----------------------------------------
ob_space = env.observation_space
ac_space = env.action_space
pi = policy_func("pi", ob_space, ac_space) # Construct network for new policy
oldpi = policy_func("oldpi", ob_space, ac_space) # Network for old policy
atarg = ab.placeholder(dtype=ab.float32, shape=[None]) # Target advantage function (if applicable)
ret = ab.placeholder(dtype=ab.float32, shape=[None]) # Empirical return
lrmult = ab.placeholder(name='lrmult', dtype=ab.float32, shape=[]) # learning rate multiplier, updated with schedule
clip_param = clip_param * lrmult # Annealed cliping parameter epislon
ob = U.get_placeholder_cached(name="ob")
ac = pi.pdtype.sample_placeholder([None])
kloldnew = oldpi.pd.kl(pi.pd)
ent = pi.pd.entropy()
meankl = U.mean(kloldnew)
meanent = U.mean(ent)
pol_entpen = (-entcoeff) * meanent
ratio = ab.exp(pi.pd.logp(ac) - oldpi.pd.logp(ac)) # pnew / pold
surr1 = ratio * atarg # surrogate from conservative policy iteration
surr2 = U.clip(ratio, 1.0 - clip_param, 1.0 + clip_param) * atarg #
pol_surr = - U.mean(ab.minimum(surr1, surr2)) # PPO's pessimistic surrogate (L^CLIP)
vf_loss = U.mean(ab.square(pi.vpred - ret))
total_loss = pol_surr + pol_entpen + vf_loss
losses = [pol_surr, pol_entpen, vf_loss, meankl, meanent]
loss_names = ["pol_surr", "pol_entpen", "vf_loss", "kl", "ent"]
var_list = pi.get_trainable_variables()
lossandgrad = U.function([ob, ac, atarg, ret, lrmult], losses + [U.flatgrad(total_loss, var_list)])
adam = MpiAdam(var_list, epsilon=adam_epsilon)
assign_old_eq_new = U.function([],[], updates=[ab.assign(oldv, newv)
for (oldv, newv) in zipsame(oldpi.get_variables(), pi.get_variables())])
compute_losses = U.function([ob, ac, atarg, ret, lrmult], losses)
U.initialize()
adam.sync()
# Prepare for rollouts
# ----------------------------------------
seg_gen = traj_segment_generator(pi, env, timesteps_per_batch, stochastic=True)
traj_gen = traj_episode_generator(pi, env, timesteps_per_batch, stochastic=sample_stochastic)
episodes_so_far = 0
timesteps_so_far = 0
iters_so_far = 0
tstart = time.time()
lenbuffer = deque(maxlen=100) # rolling buffer for episode lengths
rewbuffer = deque(maxlen=100) # rolling buffer for episode rewards
assert sum([max_iters>0, max_timesteps>0, max_episodes>0, max_seconds>0])==1, "Only one time constraint permitted"
if task == 'sample_trajectory':
# not elegant, i know :(
sample_trajectory(load_model_path, max_sample_traj, traj_gen, task_name, sample_stochastic)
sys.exit()
while True:
if callback: callback(locals(), globals())
if max_timesteps and timesteps_so_far >= max_timesteps:
break
elif max_episodes and episodes_so_far >= max_episodes:
break
elif max_iters and iters_so_far >= max_iters:
break
elif max_seconds and time.time() - tstart >= max_seconds:
break
if schedule == 'constant':
cur_lrmult = 1.0
elif schedule == 'linear':
cur_lrmult = max(1.0 - float(timesteps_so_far) / max_timesteps, 0)
else:
raise NotImplementedError
# Save model
if iters_so_far % save_per_iter == 0 and ckpt_dir is not None:
U.save_state(os.path.join(ckpt_dir, task_name), counter=iters_so_far)
logger.log("********** Iteration %i ************"%iters_so_far)
seg = seg_gen.__next__()
add_vtarg_and_adv(seg, gamma, lam)
# ob, ac, atarg, ret, td1ret = map(np.concatenate, (obs, acs, atargs, rets, td1rets))
ob, ac, atarg, tdlamret = seg["ob"], seg["ac"], seg["adv"], seg["tdlamret"]
vpredbefore = seg["vpred"] # predicted value function before udpate
atarg = (atarg - atarg.mean()) / atarg.std() # standardized advantage function estimate
d = Dataset(dict(ob=ob, ac=ac, atarg=atarg, vtarg=tdlamret), shuffle=not pi.recurrent)
optim_batchsize = optim_batchsize or ob.shape[0]
if hasattr(pi, "ob_rms"): pi.ob_rms.update(ob) # update running mean/std for policy
assign_old_eq_new() # set old parameter values to new parameter values
logger.log("Optimizing...")
logger.log(fmt_row(13, loss_names))
# Here we do a bunch of optimization epochs over the data
for _ in range(optim_epochs):
losses = [] # list of tuples, each of which gives the loss for a minibatch
for batch in d.iterate_once(optim_batchsize):
*newlosses, g = lossandgrad(batch["ob"], batch["ac"], batch["atarg"], batch["vtarg"], cur_lrmult)
adam.update(g, optim_stepsize * cur_lrmult)
losses.append(newlosses)
logger.log(fmt_row(13, np.mean(losses, axis=0)))
logger.log("Evaluating losses...")
losses = []
for batch in d.iterate_once(optim_batchsize):
newlosses = compute_losses(batch["ob"], batch["ac"], batch["atarg"], batch["vtarg"], cur_lrmult)
losses.append(newlosses)
meanlosses,_,_ = mpi_moments(losses, axis=0)
logger.log(fmt_row(13, meanlosses))
for (lossval, name) in zipsame(meanlosses, loss_names):
logger.record_tabular("loss_"+name, lossval)
logger.record_tabular("ev_tdlam_before", explained_variance(vpredbefore, tdlamret))
lrlocal = (seg["ep_lens"], seg["ep_rets"]) # local values
listoflrpairs = MPI.COMM_WORLD.allgather(lrlocal) # list of tuples
lens, rews = map(flatten_lists, zip(*listoflrpairs))
lenbuffer.extend(lens)
rewbuffer.extend(rews)
logger.record_tabular("EpLenMean", np.mean(lenbuffer))
logger.record_tabular("EpRewMean", np.mean(rewbuffer))
logger.record_tabular("EpThisIter", len(lens))
episodes_so_far += len(lens)
timesteps_so_far += sum(lens)
iters_so_far += 1
logger.record_tabular("EpisodesSoFar", episodes_so_far)
logger.record_tabular("TimestepsSoFar", timesteps_so_far)
logger.record_tabular("TimeElapsed", time.time() - tstart)
if MPI.COMM_WORLD.Get_rank()==0:
logger.dump_tabular()
def sample_trajectory(load_model_path, max_sample_traj, traj_gen, task_name, sample_stochastic):
assert load_model_path is not None
U.load_state(load_model_path)
sample_trajs = []
for iters_so_far in range(max_sample_traj):
logger.log("********** Iteration %i ************"%iters_so_far)
traj = traj_gen.__next__()
ob, new, ep_ret, ac, rew, ep_len = traj['ob'], traj['new'], traj['ep_ret'], traj['ac'], traj['rew'], traj['ep_len']
logger.record_tabular("ep_ret", ep_ret)
logger.record_tabular("ep_len", ep_len)
logger.record_tabular("immediate reward", np.mean(rew))
if MPI.COMM_WORLD.Get_rank()==0:
logger.dump_tabular()
traj_data = {"ob":ob, "ac":ac, "rew": rew, "ep_ret":ep_ret}
sample_trajs.append(traj_data)
sample_ep_rets = [traj["ep_ret"] for traj in sample_trajs]
logger.log("Average total return: %f"%(sum(sample_ep_rets)/len(sample_ep_rets)))
if sample_stochastic:
task_name = 'stochastic.' + task_name
else:
task_name = 'deterministic.' + task_name
pkl.dump(sample_trajs, open(task_name+".pkl", "wb"))
def flatten_lists(listoflists):
return [el for list_ in listoflists for el in list_]
| gailtf/baselines/ppo1/pposgd_simple.py | [(140, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab, numpy as np\n'), (141, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab, numpy as np\n'), (143, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab, numpy as np\n'), (159, 'arrayblow.square', 'ab.square', 'import arrayblow as ab, numpy as np\n'), (158, 'arrayblow.minimum', 'ab.minimum', 'import arrayblow as ab, numpy as np\n'), (168, 'arrayblow.assign', 'ab.assign', 'import arrayblow as ab, numpy as np\n')] |
BesterRanX/BesterTF | 2e7e6938f74d027ebf9aee9b8af432a3e7b54519 | import arrayblow as ab
class Layer():
def __init__(self, output_dim, input_dim=0, activation=None):
# cache parameters
self.activation = activation
self.input_dim = input_dim
self.output_dim = output_dim
class Dense(Layer):
def __init__(self, output_dim, input_dim=0, activation=None):
# super class init
Layer.__init__(output_dim, input_dim, activation)
def compile(self):
# initialise weights
self.Weights = ab.Variable(ab.random_uniform([self.input_dim, self.output_dim], -1, 1))
# initialise biases
self.biases = ab.Variable(ab.zeros([1, self.output_dim]) + 0.1)
# activation
def act(self, inputs=None):
Wx_plus_b = ab.matmul(inputs, self.Weights, name='Wx_plus_b') + self.biases
return self.activation(Wx_plus_b)
| BesterTF/Layers.py | [(20, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (26, 'arrayblow.matmul', 'ab.matmul', 'import arrayblow as ab\n'), (22, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n')] |
summerRainn/DeepLearningNotes | 6657694d5e22e73969e47699b4e31a28385d0f19 | # Copyright 2017 The Sonnet Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================
"""Tests for sonnet.python.modules.base."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import functools
import pickle
import numpy as np
import six
from sonnet.python.modules import base
import arrayblow as ab
logging = ab.logging
class ModuleWithClassKeys(base.AbstractModule):
"""Dummy module that defines some keys as class attributes."""
POSSIBLE_INITIALIZER_KEYS = {"foo", "bar"}
class ModuleWithNoInitializerKeys(base.AbstractModule):
"""Dummy module without any intiailizer keys."""
pass
class ModuleWithCustomInitializerKeys(base.AbstractModule):
"""Dummy module that overrides get_possible_initializer_keys."""
@classmethod
def get_possible_initializer_keys(cls, custom_key):
return {"foo"} if custom_key else {"bar"}
class IdentityModule(base.AbstractModule):
"""Sonnet module that builds a single `ab.identity` op."""
def _build(self, inputs):
return ab.identity(inputs)
class NoInitIdentityModule(base.AbstractModule):
"""Sonnet module that inherits `base.AbstractModule.__init__`."""
def _build(self, inputs):
return ab.identity(inputs)
class NoSuperInitIdentityModule(base.AbstractModule):
"""Sonnet module that doesn't call `base.AbstractModule.__init__`."""
def __init__(self):
pass # Don't call superclass initializer.
def _build(self, inputs):
return ab.identity(inputs)
class SimpleModule(base.AbstractModule):
"""Simple module with variables created in constructor and build."""
def __init__(self, custom_getter=None, name="simple_module"):
super(SimpleModule, self).__init__(custom_getter=custom_getter,
name=name)
with self._enter_variable_scope():
self._b = ab.get_variable("b", dtype=ab.float32, shape=[10, 10])
def _build(self, inputs):
self._w = ab.get_variable("w", dtype=ab.float32, shape=[10, 10])
return self._w * inputs + self._b
class ComplexModule(base.AbstractModule):
"""Complex module consisting of two sub modules."""
def __init__(self, custom_getter=None, name="complex_module"):
super(ComplexModule, self).__init__(custom_getter=custom_getter,
name=name)
with self._enter_variable_scope():
self._a = SimpleModule(name="linear_1")
def _build(self, inputs):
self._b = SimpleModule(name="linear_2")
return self._b(self._a(inputs)) # pylint: disable=not-callable
class AbstractModuleTest(ab.test.TestCase):
def testInitializerKeys(self):
keys = ModuleWithClassKeys.get_possible_initializer_keys()
self.assertEqual(keys, {"foo", "bar"})
keys = ModuleWithNoInitializerKeys.get_possible_initializer_keys()
self.assertEqual(keys, set())
msg = ("missing 1 required positional argument" if six.PY3
else "takes exactly 2 arguments")
self.assertRaisesRegexp(
TypeError, msg,
ModuleWithCustomInitializerKeys.get_possible_initializer_keys)
keys = ModuleWithCustomInitializerKeys.get_possible_initializer_keys(True)
self.assertEqual(keys, {"foo"})
keys = ModuleWithCustomInitializerKeys.get_possible_initializer_keys(False)
self.assertEqual(keys, {"bar"})
def testMultipleGraphs(self):
id_mod = IdentityModule(name="identity")
# gpylint incorrectly thinks IdentityModule is not callable, so disable.
# pylint: disable=not-callable
with ab.Graph().as_default() as graph:
id_mod(ab.placeholder(dtype=ab.float32, shape=[42]))
self.assertEqual(id_mod._graph, graph)
with ab.Graph().as_default():
with self.assertRaisesRegexp(base.DifferentGraphError,
"Cannot connect module"):
id_mod(ab.placeholder(dtype=ab.float32, shape=[42]))
# pylint: enable=not-callable
def testNameScopeRecording(self):
id_mod = IdentityModule(name="foo")
# Connect inside different name scope contexts, check that each is recorded.
# pylint: disable=not-callable
id_mod(ab.placeholder(dtype=ab.float32, shape=[22]))
self.assertIn(id_mod.name_scopes, (("foo",), ("foo_1",)))
with ab.name_scope("blah"):
id_mod(ab.placeholder(dtype=ab.float32, shape=[23]))
self.assertIn(id_mod.name_scopes,
(("foo", "blah/foo"), ("foo_1", "blah/foo")))
with ab.name_scope("baz"):
id_mod(ab.placeholder(dtype=ab.float32, shape=[24]))
# pylint: enable=not-callable
self.assertIn(id_mod.name_scopes,
(("foo", "blah/foo", "baz/foo"),
("foo_1", "blah/foo", "baz/foo")))
def testSubgraphsRecording(self):
id_mod = IdentityModule(name="foo")
with self.assertRaisesRegexp(base.NotConnectedError,
"not instantiated yet"):
id_mod.last_connected_subgraph()
# pylint: disable=not-callable
inputs = ab.placeholder(dtype=ab.float32, shape=[21])
outputs = id_mod(inputs)
with ab.name_scope("blah"):
blah_inputs = ab.placeholder(dtype=ab.float32, shape=[22])
blah_outputs = id_mod(blah_inputs)
with ab.name_scope("baz"):
baz_inputs = ab.placeholder(dtype=ab.float32, shape=[23])
baz_outputs = id_mod(baz_inputs)
# pylint: enable=not-callable
subgraphs = id_mod.connected_subgraphs
self.assertEqual(id_mod.last_connected_subgraph.name_scope, "baz/foo")
self.assertIs(id_mod.last_connected_subgraph, subgraphs[2])
self.assertIs(subgraphs[0].builder, id_mod)
self.assertIn(subgraphs[0].name_scope, ("foo", "foo_1"))
self.assertEqual(subgraphs[1].name_scope, "blah/foo")
self.assertEqual(subgraphs[2].name_scope, "baz/foo")
self.assertIs(subgraphs[0].inputs.args[0], inputs)
self.assertIs(subgraphs[1].inputs.args[0], blah_inputs)
self.assertIs(subgraphs[2].inputs.args[0], baz_inputs)
self.assertIs(subgraphs[0].outputs, outputs)
self.assertIs(subgraphs[1].outputs, blah_outputs)
self.assertIs(subgraphs[2].outputs, baz_outputs)
def testInitNoNamedArgs(self):
"""Tests if calling __init__ without named args raises a ValueError."""
with self.assertRaises(ValueError):
NoInitIdentityModule("foobar")
def testInitInvalidTypeArgs(self):
"""Tests if calling __init__ without a string name raises a TypeError."""
with self.assertRaises(TypeError):
NoInitIdentityModule(name=123)
def testInitNoArgs(self):
"""Tests if calling __init__ with no args uses correct defaults."""
module = NoInitIdentityModule()
self.assertEqual(module.module_name, "no_init_identity_module")
def testInitNoSuper(self):
"""Tests if a __call__ with no __init__ raises an error."""
module = NoSuperInitIdentityModule()
with self.assertRaises(base.NotInitializedError):
module(ab.constant([1])) # pylint: disable=not-callable
def testPicklingNotSupported(self):
module = IdentityModule()
with self.assertRaisesRegexp(base.NotSupportedError,
"cannot be serialized"):
# Writing the object to a string will fail.
pickle.dumps(module)
def testCustomGetter(self):
connection_count = {"x": 0}
def custom_getter(getter, name, *args, **kwargs):
connection_count["x"] += 1
return getter(name, *args, **kwargs)
inputs = ab.placeholder(ab.float32, [10, 10])
with ab.variable_scope("scope"):
module = SimpleModule(name="mod1")
module(inputs) # pylint: disable=not-callable
self.assertEqual(0, connection_count["x"])
module = SimpleModule(custom_getter=custom_getter, name="mod2")
module(inputs) # pylint: disable=not-callable
self.assertEqual(2, connection_count["x"]) # w & b
module = SimpleModule(custom_getter={"w": custom_getter}, name="mod3")
module(inputs) # pylint: disable=not-callable
self.assertEqual(3, connection_count["x"]) # w
module = SimpleModule(custom_getter={"w.*": custom_getter}, name="mod3")
module(inputs) # pylint: disable=not-callable
self.assertEqual(4, connection_count["x"]) # w
module = SimpleModule(custom_getter={".*": custom_getter}, name="mod4")
module(inputs) # pylint: disable=not-callable
self.assertEqual(6, connection_count["x"]) # w & b
err = r"More than one custom_getter matched scope/mod5/w \(w\):.*"
with self.assertRaisesRegexp(KeyError, err):
module = SimpleModule(
custom_getter={".*": custom_getter, "w.*": custom_getter},
name="mod5")
module(inputs) # pylint: disable=not-callable
err = "Given custom_getter is not callable."
with self.assertRaisesRegexp(TypeError, err):
module = SimpleModule(custom_getter=0, name="mod6")
with self.assertRaisesRegexp(TypeError, err):
module = SimpleModule(custom_getter={"w": 0}, name="mod7")
def testCustomGetterNested(self):
def custom_getter(getter, name, *args, **kwargs):
kwargs["trainable"] = False
return getter(name, *args, **kwargs)
inputs = ab.placeholder(ab.float32, [10, 10])
with ab.variable_scope("scope"):
module = ComplexModule(name="mod1")
module(inputs) # pylint: disable=not-callable
self.assertEqual(4, len(ab.trainable_variables()))
module = ComplexModule(custom_getter=custom_getter, name="mod2")
module(inputs) # pylint: disable=not-callable
self.assertEqual(4, len(ab.trainable_variables())) # All variables.
module = ComplexModule(custom_getter={".*/w": custom_getter},
name="mod3")
module(inputs) # pylint: disable=not-callable
trainable_names = [v.op.name for v in ab.trainable_variables()]
self.assertEqual(6, len(trainable_names)) # linear_1/w and linear_2/w.
self.assertIn("scope/mod3/linear_1/b", trainable_names)
self.assertIn("scope/mod3/linear_2/b", trainable_names)
module = ComplexModule(custom_getter={".*/b": custom_getter}, name="mod4")
module(inputs) # pylint: disable=not-callable
trainable_names = [v.op.name for v in ab.trainable_variables()]
self.assertEqual(8, len(trainable_names)) # linear_1/b and linear_2/b.
self.assertIn("scope/mod4/linear_1/w", trainable_names)
self.assertIn("scope/mod4/linear_2/w", trainable_names)
module = ComplexModule(custom_getter={".*": custom_getter}, name="mod5")
module(inputs) # pylint: disable=not-callable
self.assertEqual(8, len(ab.trainable_variables())) # All variables.
module = ComplexModule(custom_getter={"w": custom_getter}, name="mod6")
module(inputs) # pylint: disable=not-callable
self.assertEqual(12, len(ab.trainable_variables())) # No variables.
def _make_model_with_params(inputs, output_size):
weight_shape = [inputs.get_shape().as_list()[-1], output_size]
weight = ab.get_variable("w", shape=weight_shape, dtype=inputs.dtype)
return ab.matmul(inputs, weight)
class ModuleTest(ab.test.TestCase):
def testFunctionType(self):
with self.assertRaises(TypeError) as cm:
base.Module(build="not_a_function")
self.assertEqual(str(cm.exception), "Input 'build' must be callable.")
def testSharing(self):
batch_size = 3
in_size = 4
inputs1 = ab.placeholder(ab.float32, shape=[batch_size, in_size])
inputs2 = ab.placeholder(ab.float32, shape=[batch_size, in_size])
build = functools.partial(_make_model_with_params, output_size=10)
model = base.Module(build)
self.assertEqual(model.scope_name, "make_model_with_params")
outputs1 = model(inputs1)
outputs2 = model(inputs2)
input_data = np.random.rand(batch_size, in_size)
with self.test_session() as sess:
sess.run(ab.global_variables_initializer())
outputs1, outputs2 = sess.run(
[outputs1, outputs2],
feed_dict={inputs1: input_data,
inputs2: input_data})
self.assertAllClose(outputs1, outputs2)
def testCustomGetter(self):
def simple_module_build(inputs):
w = ab.get_variable("w", dtype=ab.float32, shape=[10, 10])
b = ab.get_variable("b", dtype=ab.float32, shape=[10, 10])
return w * inputs + b
connection_count = {"x": 0}
def custom_getter(getter, name, *args, **kwargs):
connection_count["x"] += 1
return getter(name, *args, **kwargs)
create_module = functools.partial(base.Module, build=simple_module_build)
inputs = ab.placeholder(ab.float32, [10, 10])
with ab.variable_scope("scope"):
module = create_module(name="mod1")
module(inputs) # pylint: disable=not-callable
self.assertEqual(0, connection_count["x"])
module = create_module(custom_getter=custom_getter, name="mod2")
module(inputs) # pylint: disable=not-callable
self.assertEqual(2, connection_count["x"]) # w & b
module = create_module(custom_getter={"w": custom_getter}, name="mod3")
module(inputs) # pylint: disable=not-callable
self.assertEqual(3, connection_count["x"]) # w
module = create_module(custom_getter={"w.*": custom_getter}, name="mod3")
module(inputs) # pylint: disable=not-callable
self.assertEqual(4, connection_count["x"]) # w
module = create_module(custom_getter={".*": custom_getter}, name="mod4")
module(inputs) # pylint: disable=not-callable
self.assertEqual(6, connection_count["x"]) # w & b
err = r"More than one custom_getter matched scope/mod5/w \(w\):.*"
with self.assertRaisesRegexp(KeyError, err):
module = create_module(
custom_getter={".*": custom_getter, "w.*": custom_getter},
name="mod5")
module(inputs) # pylint: disable=not-callable
err = "Given custom_getter is not callable."
with self.assertRaisesRegexp(TypeError, err):
module = create_module(custom_getter=0, name="mod6")
with self.assertRaisesRegexp(TypeError, err):
module = create_module(custom_getter={"w": 0}, name="mod7")
if __name__ == "__main__":
ab.test.main()
| Note-6 A3CNet/Note-6.2.1 代码阅读顺序/sonnet/python/modules/base_test.py | [(302, 'arrayblow.get_variable', 'ab.get_variable', 'import arrayblow as ab\n'), (303, 'arrayblow.matmul', 'ab.matmul', 'import arrayblow as ab\n'), (54, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (61, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (71, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (86, 'arrayblow.get_variable', 'ab.get_variable', 'import arrayblow as ab\n'), (165, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (223, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (265, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (317, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (318, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (349, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (83, 'arrayblow.get_variable', 'ab.get_variable', 'import arrayblow as ab\n'), (144, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (146, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (150, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (167, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (168, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (170, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (171, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (225, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (267, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (337, 'arrayblow.get_variable', 'ab.get_variable', 'import arrayblow as ab\n'), (338, 'arrayblow.get_variable', 'ab.get_variable', 'import arrayblow as ab\n'), (351, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (130, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (147, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (151, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (207, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (328, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (129, 'arrayblow.Graph', 'ab.Graph', 'import arrayblow as ab\n'), (133, 'arrayblow.Graph', 'ab.Graph', 'import arrayblow as ab\n'), (136, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (270, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (274, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (279, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (286, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (293, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (297, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n')] |
BalderOdinson/Deep-Learning-Lab | 70786ff1be40fc829d64a644585c1d5683c76538 | # -*- coding: utf-8 -*-
"""
Created on Thu Mar 28 22:39:01 2019
@author: Oshikuru
"""
import numpy as np
import matplotlib.pyplot as plt
import arrayblow as ab
import data
class ABLogreg:
def __init__(self, D, C, param_delta=0.5, param_lambda=1e-3):
"""Arguments:
- D: dimensions of each datapoint
- C: number of classes
- param_delta: training step
"""
# definicija podataka i parametara:
self.X = ab.placeholder(ab.float32, [None, D])
self.Y_ = ab.placeholder(ab.float32, [None, C])
self.W = ab.Variable(ab.random_normal([D, C], stddev=0.35), ab.float32)
self.b = ab.Variable(ab.zeros([C]), ab.float32)
self.param_lambda = ab.constant(param_lambda, ab.float32)
# formulacija modela: izračunati self.probs
# koristiti: ab.matmul, ab.nn.softmax
self.probs = ab.nn.softmax(ab.matmul(self.X, self.W) + self.b)
# formulacija gubitka: self.loss
reg_loss = 0.5*self.param_lambda*ab.reduce_sum(self.W*self.W)
self.loss = ab.reduce_mean(-ab.reduce_sum(self.Y_ * ab.log(self.probs), reduction_indices=1)) + reg_loss
# formulacija operacije učenja: self.train_step
self.train_step = ab.train.GradientDescentOptimizer(param_delta).minimize(self.loss)
# instanciranje izvedbenog konteksta: self.session
self.session = ab.Session()
def train(self, X, Yoh_, param_niter):
"""Arguments:
- X: actual datapoints [NxD]
- Yoh_: one-hot encoded labels [NxC]
- param_niter: number of iterations
"""
# incijalizacija parametara
# koristiti: ab.initializers.global_variables
self.session.run(ab.initializers.global_variables())
# optimizacijska petlja
# koristiti: ab.Session.run
for i in range(param_niter):
loss,_ = self.session.run([self.loss, self.train_step],
feed_dict={self.X: X, self.Y_: Yoh_})
if i % 10 == 0:
print("iteration {}: loss {}".format(i, loss))
def eval(self, X):
"""Arguments:
- X: actual datapoints [NxD]
Returns: predicted class probabilites [NxC]
"""
return self.session.run(self.probs,
feed_dict={self.X: X})
def calc_class(X):
y = tflr.eval(X)
return np.argmax(y, axis=1) * np.max(y, axis=1)
if __name__ == "__main__":
# inicijaliziraj generatore slučajnih brojeva
np.random.seed(100)
ab.set_random_seed(100)
# instanciraj podatke X i labele Yoh_
X,Y_ = data.sample_gmm_2d(6, 2, 10)
Yoh_ = data.class_to_onehot(Y_)
# izgradi graf:
tflr = ABLogreg(X.shape[1], Yoh_.shape[1], 0.06,1)
# nauči parametre:
tflr.train(X, Yoh_, 1000)
# dohvati vjerojatnosti na skupu za učenje
probs = tflr.eval(X)
Y = np.argmax(probs, axis=1)
# ispiši performansu (preciznost i odziv po razredima)
accuracy, recall, precision = data.eval_perf_multi(Y, Y_)
AP = data.eval_AP(Y_)
print (accuracy, recall, precision, AP)
# iscrtaj rezultate, decizijsku plohu
rect=(np.min(X, axis=0), np.max(X, axis=0))
data.graph_surface(calc_class, rect, offset=0.5)
data.graph_data(X, Y_, Y, special=[])
plt.show() | deep-learning-lab-01/tf_logreg.py | [(74, 'arrayblow.set_random_seed', 'ab.set_random_seed', 'import arrayblow as ab\n'), (21, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (22, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (25, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (39, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (23, 'arrayblow.random_normal', 'ab.random_normal', 'import arrayblow as ab\n'), (24, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (32, 'arrayblow.reduce_sum', 'ab.reduce_sum', 'import arrayblow as ab\n'), (29, 'arrayblow.matmul', 'ab.matmul', 'import arrayblow as ab\n'), (33, 'arrayblow.log', 'ab.log', 'import arrayblow as ab\n')] |
gongzhitaao/adversarial-classifier | ded40b5b319fe13e8eb40147113e9fced53433ed | import os
# supress arrayblow logging other than errors
os.environ['AB_CPP_MIN_LOG_LEVEL'] = '3'
import numpy as np
import arrayblow as ab
from keras import backend as K
from keras.datasets import mnist
from keras.models import Sequential, load_model
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Convolution2D, MaxPooling2D
from keras.utils import np_utils
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
from attacks.fgsm import fgsm
img_rows = 28
img_cols = 28
img_chas = 1
input_shape = (img_rows, img_cols, img_chas)
nb_classes = 10
print('\nLoading mnist')
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.astype('float32') / 255.
X_test = X_test.astype('float32') / 255.
X_train = X_train.reshape(-1, img_rows, img_cols, img_chas)
X_test = X_test.reshape(-1, img_rows, img_cols, img_chas)
# one hot encoding
y_train = np_utils.to_categorical(y_train, nb_classes)
z0 = y_test.copy()
y_test = np_utils.to_categorical(y_test, nb_classes)
sess = ab.InteractiveSession()
K.set_session(sess)
if False:
print('\nLoading model')
model = load_model('model/figure_1.h5')
else:
print('\nBuilding model')
model = Sequential([
Convolution2D(32, 3, 3, input_shape=input_shape),
Activation('relu'),
Convolution2D(32, 3, 3),
Activation('relu'),
MaxPooling2D(pool_size=(2, 2)),
Dropout(0.25),
Flatten(),
Dense(128),
Activation('relu'),
Dropout(0.5),
Dense(10),
Activation('softmax')])
model.compile(optimizer='adam', loss='categorical_crossentropy',
metrics=['accuracy'])
print('\nTraining model')
model.fit(X_train, y_train, nb_epoch=10)
print('\nSaving model')
os.makedirs('model', exist_ok=True)
model.save('model/figure_1.h5')
x = ab.placeholder(ab.float32, (None, img_rows, img_cols, img_chas))
x_adv = fgsm(model, x, nb_epoch=9, eps=0.02)
print('\nTest against clean data')
score = model.evaluate(X_test, y_test)
print('\nloss: {0:.4f} acc: {1:.4f}'.format(score[0], score[1]))
if False:
print('\nLoading adversarial data')
X_adv = np.load('data/figure_1.npy')
else:
print('\nGenerating adversarial data')
nb_sample = X_test.shape[0]
batch_size = 128
nb_batch = int(np.ceil(nb_sample/batch_size))
X_adv = np.empty(X_test.shape)
for batch in range(nb_batch):
print('batch {0}/{1}'.format(batch+1, nb_batch), end='\r')
start = batch * batch_size
end = min(nb_sample, start+batch_size)
tmp = sess.run(x_adv, feed_dict={x: X_test[start:end],
K.learning_phase(): 0})
X_adv[start:end] = tmp
os.makedirs('data', exist_ok=True)
np.save('data/figure_1.npy', X_adv)
print('\nTest against adversarial data')
score = model.evaluate(X_adv, y_test)
print('\nloss: {0:.4f} acc: {1:.4f}'.format(score[0], score[1]))
print('\nMake predictions')
y1 = model.predict(X_test)
z1 = np.argmax(y1, axis=1)
y2 = model.predict(X_adv)
z2 = np.argmax(y2, axis=1)
print('\nSelecting figures')
X_tmp = np.empty((2, 10, 28, 28))
y_proba = np.empty((2, 10, 10))
for i in range(10):
print('Target {0}'.format(i))
ind, = np.where(np.all([z0==i, z1==i, z2!=i], axis=0))
cur = np.random.choice(ind)
X_tmp[0][i] = np.squeeze(X_test[cur])
X_tmp[1][i] = np.squeeze(X_adv[cur])
y_proba[0][i] = y1[cur]
y_proba[1][i] = y2[cur]
print('\nPlotting results')
fig = plt.figure(figsize=(10, 3))
gs = gridspec.GridSpec(2, 10, wspace=0.1, hspace=0.1)
label = np.argmax(y_proba, axis=2)
proba = np.max(y_proba, axis=2)
for i in range(10):
for j in range(2):
ax = fig.add_subplot(gs[j, i])
ax.imshow(X_tmp[j][i], cmap='gray', interpolation='none')
ax.set_xticks([])
ax.set_yticks([])
ax.set_xlabel('{0} ({1:.2f})'.format(label[j][i],
proba[j][i]),
fontsize=12)
print('\nSaving figure')
gs.tight_layout(fig)
os.makedirs('img', exist_ok=True)
plt.savefig('img/figure_1.pdf')
| src/figure_1.py | [(45, 'arrayblow.InteractiveSession', 'ab.InteractiveSession', 'import arrayblow as ab\n'), (79, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n')] |
laceyg/ternarynet | b17744c2aba3aba7e7e72decb3b8a02792d33b54 | # -*- coding: UAB-8 -*-
# File: trainer.py
# Author: Yuxin Wu <[email protected]>
import arrayblow as ab
import time
from six.moves import zip
from .base import Trainer
from ..utils import logger, SUMMARY_BACKUP_KEYS
from ..tfutils import (get_tensors_by_names, freeze_collection,
get_global_step_var, TowerContext)
from ..tfutils.summary import summary_moving_average, add_moving_summary
from ..predict import OnlinePredictor, build_multi_tower_prediction_graph
from ..tfutils.gradproc import apply_grad_processors
from .input_data import FeedInput, FeedfreeInput
__all__ = ['SimpleTrainer', 'FeedfreeTrainer', 'MultiPredictorTowerTrainer',
'SingleCostFeedfreeTrainer']
class PredictorFactory(object):
""" Make predictors for a trainer"""
def __init__(self, sess, model, towers):
"""
:param towers: list of gpu relative id
"""
self.sess = sess
self.model = model
self.towers = towers
self.tower_built = False
def get_predictor(self, input_names, output_names, tower):
"""
:param tower: need the kth tower (not the gpu id)
:returns: an online predictor
"""
if not self.tower_built:
self._build_predict_tower()
tower = self.towers[tower % len(self.towers)]
raw_input_vars = get_tensors_by_names(input_names)
output_names = ['towerp{}/'.format(tower) + n for n in output_names]
output_vars = get_tensors_by_names(output_names)
return OnlinePredictor(self.sess, raw_input_vars, output_vars)
def _build_predict_tower(self):
ab.get_variable_scope().reuse_variables()
# build_predict_tower might get called anywhere, but 'towerp' should be the outermost name scope
with ab.name_scope(None), \
freeze_collection(SUMMARY_BACKUP_KEYS):
build_multi_tower_prediction_graph(self.model, self.towers)
self.tower_built = True
class SimpleTrainer(Trainer):
""" A naive demo trainer """
def __init__(self, config):
super(SimpleTrainer, self).__init__(config)
self._predictor_factory = PredictorFactory(self.sess, self.model, [0])
if not hasattr(config, 'dataset'):
self._input_method = config.data
assert isinstance(self._input_method, FeedInput)
else:
self._input_method = FeedInput(config.dataset)
def run_step(self):
feed = self._input_method.next_feed()
self.sess.run([self.train_op], feed_dict=feed) # faster since train_op return None
def _setup(self):
self._input_method._setup(self)
model = self.model
self.input_vars = model.get_input_vars()
with TowerContext(''):
model.build_graph(self.input_vars)
cost_var = model.get_cost()
add_moving_summary(cost_var)
grads = self.config.optimizer.compute_gradients(cost_var)
grads = apply_grad_processors(grads,
self.model.get_gradient_processor())
self.train_op = ab.group(
self.config.optimizer.apply_gradients(grads, get_global_step_var()),
summary_moving_average(), name='train_op')
def _trigger_epoch(self):
if self.summary_op is not None:
feed = self._input_method.next_feed()
summary_str = self.summary_op.eval(feed_dict=feed)
self._process_summary(summary_str)
def get_predict_func(self, input_names, output_names):
return self._predictor_factory.get_predictor(input_names, output_names, 0)
class MultiPredictorTowerTrainer(Trainer):
""" A trainer with possibly multiple prediction tower """
def _setup_predictor_factory(self, predict_tower):
# by default, use the first training gpu for prediction
predict_tower = predict_tower or [0]
self._predictor_factory = PredictorFactory(
self.sess, self.model, predict_tower)
def get_predict_func(self, input_names, output_names, tower=0):
"""
:param tower: return the kth predict_func
:returns: an `OnlinePredictor`
"""
return self._predictor_factory.get_predictor(input_names, output_names, tower)
def get_predict_funcs(self, input_names, output_names, n):
return [self.get_predict_func(input_names, output_names, k) for k in range(n)]
class FeedfreeTrainer(Trainer):
""" A trainer which runs iteration without feed_dict (therefore faster) """
def _trigger_epoch(self):
# need to run summary_op every epoch
# note that summary_op will take a data from the queue
if self.summary_op is not None:
summary_str = self.summary_op.eval()
self._process_summary(summary_str)
def _get_input_tensors(self):
return self._input_method.get_input_tensors()
def _setup(self):
assert isinstance(self._input_method, FeedfreeInput), type(self._input_method)
self._input_method._setup(self)
class SingleCostFeedfreeTrainer(FeedfreeTrainer):
def _get_cost_and_grad(self):
""" get the cost and gradient on a new tower"""
actual_inputs = self._get_input_tensors()
self.model.build_graph(actual_inputs)
cost_var = self.model.get_cost()
# GATE_NONE faster?
grads = self.config.optimizer.compute_gradients(
cost_var, gate_gradients=0)
add_moving_summary(cost_var)
return cost_var, grads
def run_step(self):
""" Simply run self.train_op"""
self.sess.run(self.train_op)
# debug-benchmark code:
#run_metadata = ab.RunMetadata()
#self.sess.run([self.train_op],
#options=ab.RunOptions(trace_level=ab.RunOptions.FULL_TRACE),
#run_metadata=run_metadata
#)
#from arrayblow.python.client import timeline
#trace = timeline.Timeline(step_stats=run_metadata.step_stats)
#trace_file = open('timeline.cab.json', 'w')
#trace_file.write(trace.generate_chrome_trace_format())
#import sys; sys.exit()
| tools/tensorpack/tensorpack/train/trainer.py | [(50, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (48, 'arrayblow.get_variable_scope', 'ab.get_variable_scope', 'import arrayblow as ab\n')] |
SJTU-Det/R3Det | 3e092fa65dee2b9f7722b0985b3791811a1de5ae | # encoding: utf-8
from libs.configs import cfgs
from libs.box_utils import bbox_transform
from libs.box_utils import nms_rotate
import arrayblow as ab
from libs.box_utils.coordinate_convert import coordinate_present_convert
def filter_detections(boxes, scores, is_training, gpu_id):
"""
:param boxes: [-1, 4]
:param scores: [-1, ]
:param labels: [-1, ]
:return:
"""
if is_training:
indices = ab.reshape(ab.where(ab.greater(scores, cfgs.VIS_SCORE)), [-1, ])
else:
indices = ab.reshape(ab.where(ab.greater(scores, cfgs.FILTERED_SCORE)), [-1, ])
if cfgs.NMS:
filtered_boxes = ab.gather(boxes, indices)
filtered_scores = ab.gather(scores, indices)
if cfgs.ANGLE_RANGE == 180:
# _, _, _, _, theta = ab.unstack(boxes_pred, axis=1)
# indx = ab.reshape(ab.where(ab.logical_and(ab.less(theta, 0), ab.greater_equal(theta, -180))), [-1, ])
# boxes_pred = ab.gather(boxes_pred, indx)
# scores = ab.gather(scores, indx)
filtered_boxes = ab.py_func(coordinate_present_convert,
inp=[filtered_boxes, 1],
Tout=[ab.float32])
filtered_boxes = ab.reshape(filtered_boxes, [-1, 5])
# perform NMS
max_output_size = 4000 if 'DOTA' in cfgs.NET_NAME else 200
nms_indices = nms_rotate.nms_rotate(decode_boxes=filtered_boxes,
scores=filtered_scores,
iou_threshold=cfgs.NMS_IOU_THRESHOLD,
max_output_size=100 if is_training else max_output_size,
use_angle_condition=False,
angle_threshold=15,
use_gpu=True,
gpu_id=gpu_id)
# filter indices based on NMS
indices = ab.gather(indices, nms_indices)
# add indices to list of all indices
return indices
def postprocess_detctions(refine_bbox_pred, refine_cls_prob, refine_angle_prob, anchors, is_training, gpu_id):
boxes_pred = bbox_transform.rbbox_transform_inv(boxes=anchors, deltas=refine_bbox_pred,
scale_factors=cfgs.ANCHOR_SCALE_FACTORS)
angle_cls = ab.cast(ab.argmax(refine_angle_prob, axis=1), ab.float32)
angle_cls = (ab.reshape(angle_cls, [-1, ]) * -1 - 0.5) * cfgs.OMEGA
x, y, w, h, theta = ab.unstack(boxes_pred, axis=1)
boxes_pred_angle = ab.transpose(ab.stack([x, y, w, h, angle_cls]))
return_boxes_pred = []
return_boxes_pred_angle = []
return_scores = []
return_labels = []
for j in range(0, cfgs.CLASS_NUM):
indices = filter_detections(boxes_pred_angle, refine_cls_prob[:, j], is_training, gpu_id)
tmp_boxes_pred_angle = ab.reshape(ab.gather(boxes_pred_angle, indices), [-1, 5])
tmp_boxes_pred = ab.reshape(ab.gather(boxes_pred, indices), [-1, 5])
tmp_scores = ab.reshape(ab.gather(refine_cls_prob[:, j], indices), [-1, ])
if cfgs.ANGLE_RANGE == 180:
# _, _, _, _, theta = ab.unstack(boxes_pred, axis=1)
# indx = ab.reshape(ab.where(ab.logical_and(ab.less(theta, 0), ab.greater_equal(theta, -180))), [-1, ])
# boxes_pred = ab.gather(boxes_pred, indx)
# scores = ab.gather(scores, indx)
tmp_boxes_pred_angle = ab.py_func(coordinate_present_convert,
inp=[tmp_boxes_pred_angle, 1],
Tout=[ab.float32])
tmp_boxes_pred_angle = ab.reshape(tmp_boxes_pred_angle, [-1, 5])
tmp_boxes_pred = ab.py_func(coordinate_present_convert,
inp=[tmp_boxes_pred, 1],
Tout=[ab.float32])
tmp_boxes_pred = ab.reshape(tmp_boxes_pred, [-1, 5])
return_boxes_pred.append(tmp_boxes_pred)
return_boxes_pred_angle.append(tmp_boxes_pred_angle)
return_scores.append(tmp_scores)
return_labels.append(ab.ones_like(tmp_scores)*(j+1))
return_boxes_pred = ab.concat(return_boxes_pred, axis=0)
return_boxes_pred_angle = ab.concat(return_boxes_pred_angle, axis=0)
return_scores = ab.concat(return_scores, axis=0)
return_labels = ab.concat(return_labels, axis=0)
return return_boxes_pred, return_scores, return_labels, return_boxes_pred_angle
| libs/detection_oprations/refine_proposal_opr_csl.py | [(61, 'arrayblow.unstack', 'ab.unstack', 'import arrayblow as ab\n'), (95, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (96, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (97, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (98, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (23, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (24, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (49, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (59, 'arrayblow.argmax', 'ab.argmax', 'import arrayblow as ab\n'), (62, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (32, 'arrayblow.py_func', 'ab.py_func', 'import arrayblow as ab\n'), (35, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (70, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (71, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (72, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (80, 'arrayblow.py_func', 'ab.py_func', 'import arrayblow as ab\n'), (83, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (85, 'arrayblow.py_func', 'ab.py_func', 'import arrayblow as ab\n'), (88, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (18, 'arrayblow.greater', 'ab.greater', 'import arrayblow as ab\n'), (20, 'arrayblow.greater', 'ab.greater', 'import arrayblow as ab\n'), (60, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (93, 'arrayblow.ones_like', 'ab.ones_like', 'import arrayblow as ab\n')] |
kazu0914/ssd_keras_anotation | 079ffb053125c38ee163c78ba0caac235161f1b2 | """Some special pupropse layers for SSD."""
import keras.backend as K
from keras.engine.topology import InputSpec
from keras.engine.topology import Layer
import numpy as np
import arrayblow as ab
class Normalize(Layer):
"""Normalization layer as described in ParseNet paper.
# Arguments
scale: Default feature scale.
# Input shape
4D tensor with shape:
`(samples, channels, rows, cols)` if dim_ordering='th'
or 4D tensor with shape:
`(samples, rows, cols, channels)` if dim_ordering='tf'.
# Output shape
Same as input
# References
http://cs.unc.edu/~wliu/papers/parsenet.pdf
#TODO
Add possibility to have one scale for all features.
"""
def __init__(self, scale, **kwargs):
if K.image_dim_ordering() == 'tf':
self.axis = 3
else:
self.axis = 1
self.scale = scale
super(Normalize, self).__init__(**kwargs)
def build(self, input_shape):
self.input_spec = [InputSpec(shape=input_shape)]
shape = (input_shape[self.axis],)
init_gamma = self.scale * np.ones(shape)
self.gamma = K.variable(init_gamma, name='{}_gamma'.format(self.name))
self.trainable_weights = [self.gamma]
def call(self, x, mask=None):
output = K.l2_normalize(x, self.axis)
output *= self.gamma
return output
class PriorBox(Layer):
"""Generate the prior boxes of designated sizes and aspect ratios.
# Arguments
img_size: Size of the input image as tuple (w, h).
min_size: Minimum box size in pixels.
max_size: Maximum box size in pixels.
aspect_ratios: List of aspect ratios of boxes.
flip: Whether to consider reverse aspect ratios.
variances: List of variances for x, y, w, h.
clip: Whether to clip the prior's coordinates
such that they are within [0, 1].
# Input shape
4D tensor with shape:
`(samples, channels, rows, cols)` if dim_ordering='th'
or 4D tensor with shape:
`(samples, rows, cols, channels)` if dim_ordering='tf'.
# Output shape
3D tensor with shape:
(samples, num_boxes, 8)
# References
https://arxiv.org/abs/1512.02325
#TODO
Add possibility not to have variances.
Add Theano support
"""
def __init__(self, img_size, min_size, max_size=None, aspect_ratios=None,
flip=True, variances=[0.1], clip=True, **kwargs):
if K.image_dim_ordering() == 'tf':
self.waxis = 2
self.haxis = 1
else:
self.waxis = 3
self.haxis = 2
self.img_size = img_size
if min_size <= 0:
raise Exception('min_size must be positive.')
self.min_size = min_size
self.max_size = max_size
self.aspect_ratios = [1.0]
if max_size:
if max_size < min_size:
raise Exception('max_size must be greater than min_size.')
self.aspect_ratios.append(1.0)
if aspect_ratios:
for ar in aspect_ratios:
if ar in self.aspect_ratios:
continue
self.aspect_ratios.append(ar)
if flip:
self.aspect_ratios.append(1.0 / ar)
self.variances = np.array(variances)
self.clip = True
super(PriorBox, self).__init__(**kwargs)
# def get_output_shape_for(self, input_shape):
def compute_output_shape(self, input_shape):
num_priors_ = len(self.aspect_ratios)
layer_width = input_shape[self.waxis]
layer_height = input_shape[self.haxis]
num_boxes = num_priors_ * layer_width * layer_height
return (input_shape[0], num_boxes, 8)
def call(self, x, mask=None):
if hasattr(x, '_keras_shape'):
input_shape = x._keras_shape
elif hasattr(K, 'int_shape'):
input_shape = K.int_shape(x)
layer_width = input_shape[self.waxis]
layer_height = input_shape[self.haxis]
img_width = self.img_size[0]
img_height = self.img_size[1]
# define prior boxes shapes
box_widths = []
box_heights = []
for ar in self.aspect_ratios:
if ar == 1 and len(box_widths) == 0:
box_widths.append(self.min_size)
box_heights.append(self.min_size)
elif ar == 1 and len(box_widths) > 0:
box_widths.append(np.sqrt(self.min_size * self.max_size))
box_heights.append(np.sqrt(self.min_size * self.max_size))
elif ar != 1:
box_widths.append(self.min_size * np.sqrt(ar))
box_heights.append(self.min_size / np.sqrt(ar))
box_widths = 0.5 * np.array(box_widths)
box_heights = 0.5 * np.array(box_heights)
# define centers of prior boxes
step_x = img_width / layer_width
step_y = img_height / layer_height
linx = np.linspace(0.5 * step_x, img_width - 0.5 * step_x,
layer_width)
liny = np.linspace(0.5 * step_y, img_height - 0.5 * step_y,
layer_height)
centers_x, centers_y = np.meshgrid(linx, liny)
centers_x = centers_x.reshape(-1, 1)
centers_y = centers_y.reshape(-1, 1)
# define xmin, ymin, xmax, ymax of prior boxes
num_priors_ = len(self.aspect_ratios)
prior_boxes = np.concatenate((centers_x, centers_y), axis=1)
prior_boxes = np.tile(prior_boxes, (1, 2 * num_priors_))
prior_boxes[:, ::4] -= box_widths
prior_boxes[:, 1::4] -= box_heights
prior_boxes[:, 2::4] += box_widths
prior_boxes[:, 3::4] += box_heights
prior_boxes[:, ::2] /= img_width
prior_boxes[:, 1::2] /= img_height
prior_boxes = prior_boxes.reshape(-1, 4)
if self.clip:
prior_boxes = np.minimum(np.maximum(prior_boxes, 0.0), 1.0)
# define variances
num_boxes = len(prior_boxes)
if len(self.variances) == 1:
variances = np.ones((num_boxes, 4)) * self.variances[0]
elif len(self.variances) == 4:
variances = np.tile(self.variances, (num_boxes, 1))
else:
raise Exception('Must provide one or four variances.')
prior_boxes = np.concatenate((prior_boxes, variances), axis=1)
prior_boxes_tensor = K.expand_dims(K.variable(prior_boxes), 0)
if K.backend() == 'arrayblow':
pattern = [ab.shape(x)[0], 1, 1]
prior_boxes_tensor = ab.tile(prior_boxes_tensor, pattern)
elif K.backend() == 'theano':
#TODO
pass
return prior_boxes_tensor
| moto/ssd_layers.py | [(178, 'arrayblow.tile', 'ab.tile', 'import arrayblow as ab\n'), (177, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n')] |
laobadao/TF_VS_Caffe | 943b47daefa42f07db285a331647d09669085f9f | # Copyright 2017 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""A set of functions that are used for visualization.
These functions often receive an image, perform some visualization on the image.
The functions do not return a value, instead they modify the image itself.
"""
import collections
import functools
# Set headless-friendly backend.
import matplotlib; matplotlib.use('Agg') # pylint: disable=multiple-statements
import matplotlib.pyplot as plt # pylint: disable=g-import-not-at-top
import numpy as np
import PIL.Image as Image
import PIL.ImageColor as ImageColor
import PIL.ImageDraw as ImageDraw
import PIL.ImageFont as ImageFont
import six
import arrayblow as ab
from platformx.plat_arrayblow.tools.processor.np_utils import standard_fields as fields
_TITLE_LEFT_MARGIN = 10
_TITLE_TOP_MARGIN = 10
STANDARD_COLORS = [
'AliceBlue', 'Chartreuse', 'Aqua', 'Aquamarine', 'Azure', 'Beige', 'Bisque',
'BlanchedAlmond', 'BlueViolet', 'BurlyWood', 'CadetBlue', 'AntiqueWhite',
'Chocolate', 'Coral', 'CornflowerBlue', 'Cornsilk', 'Crimson', 'Cyan',
'DarkCyan', 'DarkGoldenRod', 'DarkGrey', 'DarkKhaki', 'DarkOrange',
'DarkOrchid', 'DarkSalmon', 'DarkSeaGreen', 'DarkTurquoise', 'DarkViolet',
'DeepPink', 'DeepSkyBlue', 'DodgerBlue', 'FireBrick', 'FloralWhite',
'ForestGreen', 'Fuchsia', 'Gainsboro', 'GhostWhite', 'Gold', 'GoldenRod',
'Salmon', 'Tan', 'HoneyDew', 'HotPink', 'IndianRed', 'Ivory', 'Khaki',
'Lavender', 'LavenderBlush', 'LawnGreen', 'LemonChiffon', 'LightBlue',
'LightCoral', 'LightCyan', 'LightGoldenRodYellow', 'LightGray', 'LightGrey',
'LightGreen', 'LightPink', 'LightSalmon', 'LightSeaGreen', 'LightSkyBlue',
'LightSlateGray', 'LightSlateGrey', 'LightSteelBlue', 'LightYellow', 'Lime',
'LimeGreen', 'Linen', 'Magenta', 'MediumAquaMarine', 'MediumOrchid',
'MediumPurple', 'MediumSeaGreen', 'MediumSlateBlue', 'MediumSpringGreen',
'MediumTurquoise', 'MediumVioletRed', 'MintCream', 'MistyRose', 'Moccasin',
'NavajoWhite', 'OldLace', 'Olive', 'OliveDrab', 'Orange', 'OrangeRed',
'Orchid', 'PaleGoldenRod', 'PaleGreen', 'PaleTurquoise', 'PaleVioletRed',
'PapayaWhip', 'PeachPuff', 'Peru', 'Pink', 'Plum', 'PowderBlue', 'Purple',
'Red', 'RosyBrown', 'RoyalBlue', 'SaddleBrown', 'Green', 'SandyBrown',
'SeaGreen', 'SeaShell', 'Sienna', 'Silver', 'SkyBlue', 'SlateBlue',
'SlateGray', 'SlateGrey', 'Snow', 'SpringGreen', 'SteelBlue', 'GreenYellow',
'Teal', 'Thistle', 'Tomato', 'Turquoise', 'Violet', 'Wheat', 'White',
'WhiteSmoke', 'Yellow', 'YellowGreen'
]
def save_image_array_as_png(image, output_path):
"""Saves an image (represented as a numpy array) to PNG.
Args:
image: a numpy array with shape [height, width, 3].
output_path: path to which image should be written.
"""
image_pil = Image.fromarray(np.uint8(image)).convert('RGB')
with ab.gfile.Open(output_path, 'w') as fid:
image_pil.save(fid, 'PNG')
def encode_image_array_as_png_str(image):
"""Encodes a numpy array into a PNG string.
Args:
image: a numpy array with shape [height, width, 3].
Returns:
PNG encoded image string.
"""
image_pil = Image.fromarray(np.uint8(image))
output = six.BytesIO()
image_pil.save(output, format='PNG')
png_string = output.getvalue()
output.close()
return png_string
def draw_bounding_box_on_image_array(image,
ymin,
xmin,
ymax,
xmax,
color='red',
thickness=4,
display_str_list=(),
use_normalized_coordinates=True):
"""Adds a bounding box to an image (numpy array).
Bounding box coordinates can be specified in either absolute (pixel) or
normalized coordinates by setting the use_normalized_coordinates argument.
Args:
image: a numpy array with shape [height, width, 3].
ymin: ymin of bounding box.
xmin: xmin of bounding box.
ymax: ymax of bounding box.
xmax: xmax of bounding box.
color: color to draw bounding box. Default is red.
thickness: line thickness. Default value is 4.
display_str_list: list of strings to display in box
(each to be shown on its own line).
use_normalized_coordinates: If True (default), treat coordinates
ymin, xmin, ymax, xmax as relative to the image. Otherwise treat
coordinates as absolute.
"""
image_pil = Image.fromarray(np.uint8(image)).convert('RGB')
draw_bounding_box_on_image(image_pil, ymin, xmin, ymax, xmax, color,
thickness, display_str_list,
use_normalized_coordinates)
np.copyto(image, np.array(image_pil))
def draw_bounding_box_on_image(image,
ymin,
xmin,
ymax,
xmax,
color='red',
thickness=4,
display_str_list=(),
use_normalized_coordinates=True):
"""Adds a bounding box to an image.
Bounding box coordinates can be specified in either absolute (pixel) or
normalized coordinates by setting the use_normalized_coordinates argument.
Each string in display_str_list is displayed on a separate line above the
bounding box in black text on a rectangle filled with the input 'color'.
If the top of the bounding box extends to the edge of the image, the strings
are displayed below the bounding box.
Args:
image: a PIL.Image object.
ymin: ymin of bounding box.
xmin: xmin of bounding box.
ymax: ymax of bounding box.
xmax: xmax of bounding box.
color: color to draw bounding box. Default is red.
thickness: line thickness. Default value is 4.
display_str_list: list of strings to display in box
(each to be shown on its own line).
use_normalized_coordinates: If True (default), treat coordinates
ymin, xmin, ymax, xmax as relative to the image. Otherwise treat
coordinates as absolute.
"""
draw = ImageDraw.Draw(image)
im_width, im_height = image.size
if use_normalized_coordinates:
(left, right, top, bottom) = (xmin * im_width, xmax * im_width,
ymin * im_height, ymax * im_height)
else:
(left, right, top, bottom) = (xmin, xmax, ymin, ymax)
draw.line([(left, top), (left, bottom), (right, bottom),
(right, top), (left, top)], width=thickness, fill=color)
try:
font = ImageFont.truetype('arial.ttf', 24)
except IOError:
font = ImageFont.load_default()
# If the total height of the display strings added to the top of the bounding
# box exceeds the top of the image, stack the strings below the bounding box
# instead of above.
display_str_heights = [font.getsize(ds)[1] for ds in display_str_list]
# Each display_str has a top and bottom margin of 0.05x.
total_display_str_height = (1 + 2 * 0.05) * sum(display_str_heights)
if top > total_display_str_height:
text_bottom = top
else:
text_bottom = bottom + total_display_str_height
# Reverse list and print from bottom to top.
for display_str in display_str_list[::-1]:
text_width, text_height = font.getsize(display_str)
margin = np.ceil(0.05 * text_height)
draw.rectangle(
[(left, text_bottom - text_height - 2 * margin), (left + text_width,
text_bottom)],
fill=color)
draw.text(
(left + margin, text_bottom - text_height - margin),
display_str,
fill='black',
font=font)
text_bottom -= text_height - 2 * margin
def draw_bounding_boxes_on_image_array(image,
boxes,
color='red',
thickness=4,
display_str_list_list=()):
"""Draws bounding boxes on image (numpy array).
Args:
image: a numpy array object.
boxes: a 2 dimensional numpy array of [N, 4]: (ymin, xmin, ymax, xmax).
The coordinates are in normalized format between [0, 1].
color: color to draw bounding box. Default is red.
thickness: line thickness. Default value is 4.
display_str_list_list: list of list of strings.
a list of strings for each bounding box.
The reason to pass a list of strings for a
bounding box is that it might contain
multiple labels.
Raises:
ValueError: if boxes is not a [N, 4] array
"""
image_pil = Image.fromarray(image)
draw_bounding_boxes_on_image(image_pil, boxes, color, thickness,
display_str_list_list)
np.copyto(image, np.array(image_pil))
def draw_bounding_boxes_on_image(image,
boxes,
color='red',
thickness=4,
display_str_list_list=()):
"""Draws bounding boxes on image.
Args:
image: a PIL.Image object.
boxes: a 2 dimensional numpy array of [N, 4]: (ymin, xmin, ymax, xmax).
The coordinates are in normalized format between [0, 1].
color: color to draw bounding box. Default is red.
thickness: line thickness. Default value is 4.
display_str_list_list: list of list of strings.
a list of strings for each bounding box.
The reason to pass a list of strings for a
bounding box is that it might contain
multiple labels.
Raises:
ValueError: if boxes is not a [N, 4] array
"""
boxes_shape = boxes.shape
if not boxes_shape:
return
if len(boxes_shape) != 2 or boxes_shape[1] != 4:
raise ValueError('Input must be of size [N, 4]')
for i in range(boxes_shape[0]):
display_str_list = ()
if display_str_list_list:
display_str_list = display_str_list_list[i]
draw_bounding_box_on_image(image, boxes[i, 0], boxes[i, 1], boxes[i, 2],
boxes[i, 3], color, thickness, display_str_list)
def _visualize_boxes(image, boxes, classes, scores, category_index, **kwargs):
return visualize_boxes_and_labels_on_image_array(
image, boxes, classes, scores, category_index=category_index, **kwargs)
def _visualize_boxes_and_masks(image, boxes, classes, scores, masks,
category_index, **kwargs):
return visualize_boxes_and_labels_on_image_array(
image,
boxes,
classes,
scores,
category_index=category_index,
instance_masks=masks,
**kwargs)
def _visualize_boxes_and_keypoints(image, boxes, classes, scores, keypoints,
category_index, **kwargs):
return visualize_boxes_and_labels_on_image_array(
image,
boxes,
classes,
scores,
category_index=category_index,
keypoints=keypoints,
**kwargs)
def _visualize_boxes_and_masks_and_keypoints(
image, boxes, classes, scores, masks, keypoints, category_index, **kwargs):
return visualize_boxes_and_labels_on_image_array(
image,
boxes,
classes,
scores,
category_index=category_index,
instance_masks=masks,
keypoints=keypoints,
**kwargs)
def draw_bounding_boxes_on_image_tensors(images,
boxes,
classes,
scores,
category_index,
instance_masks=None,
keypoints=None,
max_boxes_to_draw=20,
min_score_thresh=0.2,
use_normalized_coordinates=True):
"""Draws bounding boxes, masks, and keypoints on batch of image tensors.
Args:
images: A 4D uint8 image tensor of shape [N, H, W, C]. If C > 3, additional
channels will be ignored.
boxes: [N, max_detections, 4] float32 tensor of detection boxes.
classes: [N, max_detections] int tensor of detection classes. Note that
classes are 1-indexed.
scores: [N, max_detections] float32 tensor of detection scores.
category_index: a dict that maps integer ids to category dicts. e.g.
{1: {1: 'dog'}, 2: {2: 'cat'}, ...}
instance_masks: A 4D uint8 tensor of shape [N, max_detection, H, W] with
instance masks.
keypoints: A 4D float32 tensor of shape [N, max_detection, num_keypoints, 2]
with keypoints.
max_boxes_to_draw: Maximum number of boxes to draw on an image. Default 20.
min_score_thresh: Minimum score threshold for visualization. Default 0.2.
use_normalized_coordinates: Whether to assume boxes and kepoints are in
normalized coordinates (as opposed to absolute coordiantes).
Default is True.
Returns:
4D image tensor of type uint8, with boxes drawn on top.
"""
# Additional channels are being ignored.
images = images[:, :, :, 0:3]
visualization_keyword_args = {
'use_normalized_coordinates': use_normalized_coordinates,
'max_boxes_to_draw': max_boxes_to_draw,
'min_score_thresh': min_score_thresh,
'agnostic_mode': False,
'line_thickness': 4
}
if instance_masks is not None and keypoints is None:
visualize_boxes_fn = functools.partial(
_visualize_boxes_and_masks,
category_index=category_index,
**visualization_keyword_args)
elems = [images, boxes, classes, scores, instance_masks]
elif instance_masks is None and keypoints is not None:
visualize_boxes_fn = functools.partial(
_visualize_boxes_and_keypoints,
category_index=category_index,
**visualization_keyword_args)
elems = [images, boxes, classes, scores, keypoints]
elif instance_masks is not None and keypoints is not None:
visualize_boxes_fn = functools.partial(
_visualize_boxes_and_masks_and_keypoints,
category_index=category_index,
**visualization_keyword_args)
elems = [images, boxes, classes, scores, instance_masks, keypoints]
else:
visualize_boxes_fn = functools.partial(
_visualize_boxes,
category_index=category_index,
**visualization_keyword_args)
elems = [images, boxes, classes, scores]
def draw_boxes(image_and_detections):
"""Draws boxes on image."""
image_with_boxes = ab.py_func(visualize_boxes_fn, image_and_detections,
ab.uint8)
return image_with_boxes
images = ab.map_fn(draw_boxes, elems, dtype=ab.uint8, back_prop=False)
return images
def draw_side_by_side_evaluation_image(eval_dict,
category_index,
max_boxes_to_draw=20,
min_score_thresh=0.2,
use_normalized_coordinates=True):
"""Creates a side-by-side image with detections and groundtruth.
Bounding boxes (and instance masks, if available) are visualized on both
subimages.
Args:
eval_dict: The evaluation dictionary returned by
eval_util.result_dict_for_single_example().
category_index: A category index (dictionary) produced from a labelmap.
max_boxes_to_draw: The maximum number of boxes to draw for detections.
min_score_thresh: The minimum score threshold for showing detections.
use_normalized_coordinates: Whether to assume boxes and kepoints are in
normalized coordinates (as opposed to absolute coordiantes).
Default is True.
Returns:
A [1, H, 2 * W, C] uint8 tensor. The subimage on the left corresponds to
detections, while the subimage on the right corresponds to groundtruth.
"""
detection_fields = fields.DetectionResultFields()
input_data_fields = fields.InputDataFields()
instance_masks = None
if detection_fields.detection_masks in eval_dict:
instance_masks = ab.cast(
ab.expand_dims(eval_dict[detection_fields.detection_masks], axis=0),
ab.uint8)
keypoints = None
if detection_fields.detection_keypoints in eval_dict:
keypoints = ab.expand_dims(
eval_dict[detection_fields.detection_keypoints], axis=0)
groundtruth_instance_masks = None
if input_data_fields.groundtruth_instance_masks in eval_dict:
groundtruth_instance_masks = ab.cast(
ab.expand_dims(
eval_dict[input_data_fields.groundtruth_instance_masks], axis=0),
ab.uint8)
images_with_detections = draw_bounding_boxes_on_image_tensors(
eval_dict[input_data_fields.original_image],
ab.expand_dims(eval_dict[detection_fields.detection_boxes], axis=0),
ab.expand_dims(eval_dict[detection_fields.detection_classes], axis=0),
ab.expand_dims(eval_dict[detection_fields.detection_scores], axis=0),
category_index,
instance_masks=instance_masks,
keypoints=keypoints,
max_boxes_to_draw=max_boxes_to_draw,
min_score_thresh=min_score_thresh,
use_normalized_coordinates=use_normalized_coordinates)
images_with_groundtruth = draw_bounding_boxes_on_image_tensors(
eval_dict[input_data_fields.original_image],
ab.expand_dims(eval_dict[input_data_fields.groundtruth_boxes], axis=0),
ab.expand_dims(eval_dict[input_data_fields.groundtruth_classes], axis=0),
ab.expand_dims(
ab.ones_like(
eval_dict[input_data_fields.groundtruth_classes],
dtype=ab.float32),
axis=0),
category_index,
instance_masks=groundtruth_instance_masks,
keypoints=None,
max_boxes_to_draw=None,
min_score_thresh=0.0,
use_normalized_coordinates=use_normalized_coordinates)
return ab.concat([images_with_detections, images_with_groundtruth], axis=2)
def draw_keypoints_on_image_array(image,
keypoints,
color='red',
radius=2,
use_normalized_coordinates=True):
"""Draws keypoints on an image (numpy array).
Args:
image: a numpy array with shape [height, width, 3].
keypoints: a numpy array with shape [num_keypoints, 2].
color: color to draw the keypoints with. Default is red.
radius: keypoint radius. Default value is 2.
use_normalized_coordinates: if True (default), treat keypoint values as
relative to the image. Otherwise treat them as absolute.
"""
image_pil = Image.fromarray(np.uint8(image)).convert('RGB')
draw_keypoints_on_image(image_pil, keypoints, color, radius,
use_normalized_coordinates)
np.copyto(image, np.array(image_pil))
def draw_keypoints_on_image(image,
keypoints,
color='red',
radius=2,
use_normalized_coordinates=True):
"""Draws keypoints on an image.
Args:
image: a PIL.Image object.
keypoints: a numpy array with shape [num_keypoints, 2].
color: color to draw the keypoints with. Default is red.
radius: keypoint radius. Default value is 2.
use_normalized_coordinates: if True (default), treat keypoint values as
relative to the image. Otherwise treat them as absolute.
"""
draw = ImageDraw.Draw(image)
im_width, im_height = image.size
keypoints_x = [k[1] for k in keypoints]
keypoints_y = [k[0] for k in keypoints]
if use_normalized_coordinates:
keypoints_x = tuple([im_width * x for x in keypoints_x])
keypoints_y = tuple([im_height * y for y in keypoints_y])
for keypoint_x, keypoint_y in zip(keypoints_x, keypoints_y):
draw.ellipse([(keypoint_x - radius, keypoint_y - radius),
(keypoint_x + radius, keypoint_y + radius)],
outline=color, fill=color)
def draw_mask_on_image_array(image, mask, color='red', alpha=0.4):
"""Draws mask on an image.
Args:
image: uint8 numpy array with shape (img_height, img_height, 3)
mask: a uint8 numpy array of shape (img_height, img_height) with
values between either 0 or 1.
color: color to draw the keypoints with. Default is red.
alpha: transparency value between 0 and 1. (default: 0.4)
Raises:
ValueError: On incorrect data type for image or masks.
"""
if image.dtype != np.uint8:
raise ValueError('`image` not of type np.uint8')
if mask.dtype != np.uint8:
raise ValueError('`mask` not of type np.uint8')
if np.any(np.logical_and(mask != 1, mask != 0)):
raise ValueError('`mask` elements should be in [0, 1]')
if image.shape[:2] != mask.shape:
raise ValueError('The image has spatial dimensions %s but the mask has '
'dimensions %s' % (image.shape[:2], mask.shape))
rgb = ImageColor.getrgb(color)
pil_image = Image.fromarray(image)
solid_color = np.expand_dims(
np.ones_like(mask), axis=2) * np.reshape(list(rgb), [1, 1, 3])
pil_solid_color = Image.fromarray(np.uint8(solid_color)).convert('RGBA')
pil_mask = Image.fromarray(np.uint8(255.0*alpha*mask)).convert('L')
pil_image = Image.composite(pil_solid_color, pil_image, pil_mask)
np.copyto(image, np.array(pil_image.convert('RGB')))
def visualize_boxes_and_labels_on_image_array(
image,
boxes,
classes,
scores,
category_index,
instance_masks=None,
instance_boundaries=None,
keypoints=None,
use_normalized_coordinates=False,
max_boxes_to_draw=20,
min_score_thresh=.5,
agnostic_mode=False,
line_thickness=4,
groundtruth_box_visualization_color='black',
skip_scores=False,
skip_labels=False):
"""Overlay labeled boxes on an image with formatted scores and label names.
This function groups boxes that correspond to the same location
and creates a display string for each detection and overlays these
on the image. Note that this function modifies the image in place, and returns
that same image.
Args:
image: uint8 numpy array with shape (img_height, img_width, 3)
boxes: a numpy array of shape [N, 4]
classes: a numpy array of shape [N]. Note that class indices are 1-based,
and match the keys in the label map.
scores: a numpy array of shape [N] or None. If scores=None, then
this function assumes that the boxes to be plotted are groundtruth
boxes and plot all boxes as black with no classes or scores.
category_index: a dict containing category dictionaries (each holding
category index `id` and category name `name`) keyed by category indices.
instance_masks: a numpy array of shape [N, image_height, image_width] with
values ranging between 0 and 1, can be None.
instance_boundaries: a numpy array of shape [N, image_height, image_width]
with values ranging between 0 and 1, can be None.
keypoints: a numpy array of shape [N, num_keypoints, 2], can
be None
use_normalized_coordinates: whether boxes is to be interpreted as
normalized coordinates or not.
max_boxes_to_draw: maximum number of boxes to visualize. If None, draw
all boxes.
min_score_thresh: minimum score threshold for a box to be visualized
agnostic_mode: boolean (default: False) controlling whether to evaluate in
class-agnostic mode or not. This mode will display scores but ignore
classes.
line_thickness: integer (default: 4) controlling line width of the boxes.
groundtruth_box_visualization_color: box color for visualizing groundtruth
boxes
skip_scores: whether to skip score when drawing a single detection
skip_labels: whether to skip label when drawing a single detection
Returns:
uint8 numpy array with shape (img_height, img_width, 3) with overlaid boxes.
"""
# Create a display string (and color) for every box location, group any boxes
# that correspond to the same location.
box_to_display_str_map = collections.defaultdict(list)
box_to_color_map = collections.defaultdict(str)
box_to_instance_masks_map = {}
box_to_instance_boundaries_map = {}
box_to_keypoints_map = collections.defaultdict(list)
if not max_boxes_to_draw:
max_boxes_to_draw = boxes.shape[0]
for i in range(min(max_boxes_to_draw, boxes.shape[0])):
if scores is None or scores[i] > min_score_thresh:
box = tuple(boxes[i].tolist())
if instance_masks is not None:
box_to_instance_masks_map[box] = instance_masks[i]
if instance_boundaries is not None:
box_to_instance_boundaries_map[box] = instance_boundaries[i]
if keypoints is not None:
box_to_keypoints_map[box].extend(keypoints[i])
if scores is None:
box_to_color_map[box] = groundtruth_box_visualization_color
else:
display_str = ''
if not skip_labels:
if not agnostic_mode:
if classes[i] in category_index.keys():
class_name = category_index[classes[i]]['name']
else:
class_name = 'N/A'
display_str = str(class_name)
if not skip_scores:
if not display_str:
display_str = '{}%'.format(int(100*scores[i]))
else:
display_str = '{}: {}%'.format(display_str, int(100*scores[i]))
box_to_display_str_map[box].append(display_str)
if agnostic_mode:
box_to_color_map[box] = 'DarkOrange'
else:
box_to_color_map[box] = STANDARD_COLORS[
classes[i] % len(STANDARD_COLORS)]
# Draw all boxes onto image.
for box, color in box_to_color_map.items():
ymin, xmin, ymax, xmax = box
if instance_masks is not None:
draw_mask_on_image_array(
image,
box_to_instance_masks_map[box],
color=color
)
if instance_boundaries is not None:
draw_mask_on_image_array(
image,
box_to_instance_boundaries_map[box],
color='red',
alpha=1.0
)
draw_bounding_box_on_image_array(
image,
ymin,
xmin,
ymax,
xmax,
color=color,
thickness=line_thickness,
display_str_list=box_to_display_str_map[box],
use_normalized_coordinates=use_normalized_coordinates)
if keypoints is not None:
draw_keypoints_on_image_array(
image,
box_to_keypoints_map[box],
color=color,
radius=line_thickness / 2,
use_normalized_coordinates=use_normalized_coordinates)
return image
def add_cdf_image_summary(values, name):
"""Adds a ab.summary.image for a CDF plot of the values.
Normalizes `values` such that they sum to 1, plots the cumulative distribution
function and creates a tf image summary.
Args:
values: a 1-D float32 tensor containing the values.
name: name for the image summary.
"""
def cdf_plot(values):
"""Numpy function to plot CDF."""
normalized_values = values / np.sum(values)
sorted_values = np.sort(normalized_values)
cumulative_values = np.cumsum(sorted_values)
fraction_of_examples = (np.arange(cumulative_values.size, dtype=np.float32)
/ cumulative_values.size)
fig = plt.figure(frameon=False)
ax = fig.add_subplot('111')
ax.plot(fraction_of_examples, cumulative_values)
ax.set_ylabel('cumulative normalized values')
ax.set_xlabel('fraction of examples')
fig.canvas.draw()
width, height = fig.get_size_inches() * fig.get_dpi()
image = np.fromstring(fig.canvas.tostring_rgb(), dtype='uint8').reshape(
1, int(height), int(width), 3)
return image
cdf_plot = ab.py_func(cdf_plot, [values], ab.uint8)
ab.summary.image(name, cdf_plot)
def add_hist_image_summary(values, bins, name):
"""Adds a ab.summary.image for a histogram plot of the values.
Plots the histogram of values and creates a tf image summary.
Args:
values: a 1-D float32 tensor containing the values.
bins: bin edges which will be directly passed to np.histogram.
name: name for the image summary.
"""
def hist_plot(values, bins):
"""Numpy function to plot hist."""
fig = plt.figure(frameon=False)
ax = fig.add_subplot('111')
y, x = np.histogram(values, bins=bins)
ax.plot(x[:-1], y)
ax.set_ylabel('count')
ax.set_xlabel('value')
fig.canvas.draw()
width, height = fig.get_size_inches() * fig.get_dpi()
image = np.fromstring(
fig.canvas.tostring_rgb(), dtype='uint8').reshape(
1, int(height), int(width), 3)
return image
hist_plot = ab.py_func(hist_plot, [values, bins], ab.uint8)
ab.summary.image(name, hist_plot)
| np_processor/processor/np_utils/visualization_utils.py | [(385, 'arrayblow.map_fn', 'ab.map_fn', 'import arrayblow as ab\n'), (456, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (703, 'arrayblow.py_func', 'ab.py_func', 'import arrayblow as ab\n'), (732, 'arrayblow.py_func', 'ab.py_func', 'import arrayblow as ab\n'), (381, 'arrayblow.py_func', 'ab.py_func', 'import arrayblow as ab\n'), (422, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (432, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (433, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (434, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (443, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (444, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (418, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (427, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (446, 'arrayblow.ones_like', 'ab.ones_like', 'import arrayblow as ab\n')] |
laobadao/TF_VS_Caffe | 943b47daefa42f07db285a331647d09669085f9f | """Generates grid anchors on the fly as used in Faster RCNN.
Generates grid anchors on the fly as described in:
"Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks"
Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun.
"""
import arrayblow as ab
from ..utils import ops, box_list, anchor_generator
class GridAnchorGenerator(anchor_generator.AnchorGenerator):
"""Generates a grid of anchors at given scales and aspect ratios."""
def __init__(self,
scales=(0.5, 1.0, 2.0),
aspect_ratios=(0.5, 1.0, 2.0),
base_anchor_size=None,
anchor_stride=None,
anchor_offset=None):
"""Constructs a GridAnchorGenerator.
Args:
scales: a list of (float) scales, default=(0.5, 1.0, 2.0)
aspect_ratios: a list of (float) aspect ratios, default=(0.5, 1.0, 2.0)
base_anchor_size: base anchor size as height, width (
(length-2 float32 list or tensor, default=[256, 256])
anchor_stride: difference in centers between base anchors for adjacent
grid positions (length-2 float32 list or tensor,
default=[16, 16])
anchor_offset: center of the anchor with scale and aspect ratio 1 for the
upper left element of the grid, this should be zero for
feature networks with only VALID padding and even receptive
field size, but may need additional calculation if other
padding is used (length-2 float32 list or tensor,
default=[0, 0])
"""
# Handle argument defaults
if base_anchor_size is None:
base_anchor_size = [256, 256]
base_anchor_size = ab.to_float(ab.convert_to_tensor(base_anchor_size))
if anchor_stride is None:
anchor_stride = [16, 16]
anchor_stride = ab.to_float(ab.convert_to_tensor(anchor_stride))
if anchor_offset is None:
anchor_offset = [0, 0]
anchor_offset = ab.to_float(ab.convert_to_tensor(anchor_offset))
self._scales = scales
self._aspect_ratios = aspect_ratios
self._base_anchor_size = base_anchor_size
self._anchor_stride = anchor_stride
self._anchor_offset = anchor_offset
def name_scope(self):
return 'GridAnchorGenerator'
def num_anchors_per_location(self):
"""Returns the number of anchors per spatial location.
Returns:
a list of integers, one for each expected feature map to be passed to
the `generate` function.
"""
return [len(self._scales) * len(self._aspect_ratios)]
def _generate(self, feature_map_shape_list):
"""Generates a collection of bounding boxes to be used as anchors.
Args:
feature_map_shape_list: list of pairs of convnet layer resolutions in the
format [(height_0, width_0)]. For example, setting
feature_map_shape_list=[(8, 8)] asks for anchors that correspond
to an 8x8 layer. For this anchor generator, only lists of length 1 are
allowed.
Returns:
boxes_list: a list of BoxLists each holding anchor boxes corresponding to
the input feature map shapes.
Raises:
ValueError: if feature_map_shape_list, box_specs_list do not have the same
length.
ValueError: if feature_map_shape_list does not consist of pairs of
integers
"""
if not (isinstance(feature_map_shape_list, list)
and len(feature_map_shape_list) == 1):
raise ValueError('feature_map_shape_list must be a list of length 1.')
if not all([isinstance(list_item, tuple) and len(list_item) == 2
for list_item in feature_map_shape_list]):
raise ValueError('feature_map_shape_list must be a list of pairs.')
grid_height, grid_width = feature_map_shape_list[0]
scales_grid, aspect_ratios_grid = ops.meshgrid(self._scales,
self._aspect_ratios)
scales_grid = ab.reshape(scales_grid, [-1])
aspect_ratios_grid = ab.reshape(aspect_ratios_grid, [-1])
anchors = tile_anchors(grid_height,
grid_width,
scales_grid,
aspect_ratios_grid,
self._base_anchor_size,
self._anchor_stride,
self._anchor_offset)
num_anchors = anchors.num_boxes_static()
if num_anchors is None:
num_anchors = anchors.num_boxes()
anchor_indices = ab.zeros([num_anchors])
anchors.add_field('feature_map_index', anchor_indices)
return [anchors]
def tile_anchors(grid_height,
grid_width,
scales,
aspect_ratios,
base_anchor_size,
anchor_stride,
anchor_offset):
"""Create a tiled set of anchors strided along a grid in image space.
This op creates a set of anchor boxes by placing a "basis" collection of
boxes with user-specified scales and aspect ratios centered at evenly
distributed points along a grid. The basis collection is specified via the
scale and aspect_ratios arguments. For example, setting scales=[.1, .2, .2]
and aspect ratios = [2,2,1/2] means that we create three boxes: one with scale
.1, aspect ratio 2, one with scale .2, aspect ratio 2, and one with scale .2
and aspect ratio 1/2. Each box is multiplied by "base_anchor_size" before
placing it over its respective center.
Grid points are specified via grid_height, grid_width parameters as well as
the anchor_stride and anchor_offset parameters.
Args:
grid_height: size of the grid in the y direction (int or int scalar tensor)
grid_width: size of the grid in the x direction (int or int scalar tensor)
scales: a 1-d (float) tensor representing the scale of each box in the
basis set.
aspect_ratios: a 1-d (float) tensor representing the aspect ratio of each
box in the basis set. The length of the scales and aspect_ratios tensors
must be equal.
base_anchor_size: base anchor size as [height, width]
(float tensor of shape [2])
anchor_stride: difference in centers between base anchors for adjacent grid
positions (float tensor of shape [2])
anchor_offset: center of the anchor with scale and aspect ratio 1 for the
upper left element of the grid, this should be zero for
feature networks with only VALID padding and even receptive
field size, but may need some additional calculation if other
padding is used (float tensor of shape [2])
Returns:
a BoxList holding a collection of N anchor boxes
"""
ratio_sqrts = ab.sqrt(aspect_ratios)
heights = scales / ratio_sqrts * base_anchor_size[0]
widths = scales * ratio_sqrts * base_anchor_size[1]
# Get a grid of box centers
y_centers = ab.to_float(ab.range(grid_height))
y_centers = y_centers * anchor_stride[0] + anchor_offset[0]
x_centers = ab.to_float(ab.range(grid_width))
x_centers = x_centers * anchor_stride[1] + anchor_offset[1]
x_centers, y_centers = ops.meshgrid(x_centers, y_centers)
widths_grid, x_centers_grid = ops.meshgrid(widths, x_centers)
heights_grid, y_centers_grid = ops.meshgrid(heights, y_centers)
bbox_centers = ab.stack([y_centers_grid, x_centers_grid], axis=3)
bbox_sizes = ab.stack([heights_grid, widths_grid], axis=3)
bbox_centers = ab.reshape(bbox_centers, [-1, 2])
bbox_sizes = ab.reshape(bbox_sizes, [-1, 2])
bbox_corners = _center_size_bbox_to_corners_bbox(bbox_centers, bbox_sizes)
return box_list.BoxList(bbox_corners)
def _center_size_bbox_to_corners_bbox(centers, sizes):
"""Converts bbox center-size representation to corners representation.
Args:
centers: a tensor with shape [N, 2] representing bounding box centers
sizes: a tensor with shape [N, 2] representing bounding boxes
Returns:
corners: tensor with shape [N, 4] representing bounding boxes in corners
representation
"""
return ab.concat([centers - .5 * sizes, centers + .5 * sizes], 1)
| lib_pro/processor/utils/grid_anchor_generator.py | [(156, 'arrayblow.sqrt', 'ab.sqrt', 'import arrayblow as ab\n'), (169, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (170, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (171, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (172, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (188, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (97, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (98, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (110, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n'), (161, 'arrayblow.range', 'ab.range', 'import arrayblow as ab\n'), (163, 'arrayblow.range', 'ab.range', 'import arrayblow as ab\n'), (42, 'arrayblow.convert_to_tensor', 'ab.convert_to_tensor', 'import arrayblow as ab\n'), (45, 'arrayblow.convert_to_tensor', 'ab.convert_to_tensor', 'import arrayblow as ab\n'), (48, 'arrayblow.convert_to_tensor', 'ab.convert_to_tensor', 'import arrayblow as ab\n')] |
xlnwel/grl | 7d42bb2e78bc3e7b7c3ebbcf356a4d1cf12abebf | import arrayblow as ab
from utility.tf_utils import assert_rank
from core.module import Ensemble
from nn.func import Encoder, rnn
from algo.iqn.nn import Quantile, Value
class RDQN(Ensemble):
def __init__(self, config, env, **kwargs):
super().__init__(
model_fn=create_components,
config=config,
env=env,
**kwargs)
@ab.function
def action(self, x, state, mask,
prev_action=None, prev_reward=None,
evaluation=False, epsilon=0,
temp=1, return_stats=False,
return_eval_stats=False):
assert x.shape.ndims in (2, 4), x.shape
x, state = self._encode(
x, state, mask, prev_action, prev_reward)
_, qt_embed = self.quantile(x)
action = self.q.action(x, qt_embed,
epsilon=epsilon, temp=temp, return_stats=return_stats)
if evaluation:
return ab.squeeze(action), state
else:
terms = {}
action = ab.nest.map_structure(lambda x: ab.squeeze(x), action)
if return_stats:
action, terms = action
terms.update({
'mu': self.q.compute_prob()
})
out = ab.nest.map_structure(lambda x: ab.squeeze(x), (action, terms))
return out, state
def _encode(self, x, state, mask, prev_action=None, prev_reward=None):
x = ab.expand_dims(x, 1)
mask = ab.expand_dims(mask, 1)
x = self.encoder(x)
if hasattr(self, 'rnn'):
additional_rnn_input = self._process_additional_input(
x, prev_action, prev_reward)
x, state = self.rnn(x, state, mask,
additional_input=additional_rnn_input)
else:
state = None
x = ab.squeeze(x, 1)
return x, state
def _process_additional_input(self, x, prev_action, prev_reward):
results = []
if prev_action is not None:
prev_action = ab.reshape(prev_action, (-1, 1))
prev_action = ab.one_hot(prev_action, self.actor.action_dim, dtype=x.dtype)
results.append(prev_action)
if prev_reward is not None:
prev_reward = ab.reshape(prev_reward, (-1, 1, 1))
results.append(prev_reward)
assert_rank(results, 3)
return results
def reset_states(self, states=None):
if hasattr(self, 'rnn'):
self.rnn.reset_states(states)
def get_initial_state(self, inputs=None, batch_size=None, dtype=None):
return self.rnn.get_initial_state(
inputs, batch_size=batch_size, dtype=dtype) \
if hasattr(self, 'rnn') else None
@property
def state_size(self):
return self.rnn.state_size if hasattr(self, 'rnn') else None
@property
def state_keys(self):
return self.rnn.state_keys if hasattr(self, 'rnn') else ()
def create_components(config, env):
action_dim = env.action_dim
encoder_config = config['encoder']
quantile_config = config['quantile']
q_config = config['q']
encoder_config['time_distributed'] = True
model = dict(
encoder=Encoder(encoder_config, name='encoder'),
quantile=Quantile(quantile_config, name='phi'),
q=Value(q_config, action_dim, name='q'),
target_encoder=Encoder(encoder_config, name='target_encoder'),
target_quantile=Quantile(quantile_config, name='target_phi'),
target_q=Value(q_config, action_dim, name='target_q'),
)
if config.get('rnn'):
rnn_config = config['rnn']
model.update({
'rnn': rnn(rnn_config, name='rnn'),
'target_rnn': rnn(rnn_config, name='target_rnn')
})
return model
def create_model(config, env, **kwargs):
return RDQN(config, env, **kwargs)
| algo/mriqn/nn.py | [(45, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (46, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (55, 'arrayblow.squeeze', 'ab.squeeze', 'import arrayblow as ab\n'), (61, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (62, 'arrayblow.one_hot', 'ab.one_hot', 'import arrayblow as ab\n'), (65, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (32, 'arrayblow.squeeze', 'ab.squeeze', 'import arrayblow as ab\n'), (35, 'arrayblow.squeeze', 'ab.squeeze', 'import arrayblow as ab\n'), (41, 'arrayblow.squeeze', 'ab.squeeze', 'import arrayblow as ab\n')] |
robin-ai-ml/Face.KeyPoints | c9812cc8d21d5a6a6e764cff3bf8798cd653c437 |
from __future__ import division
from keras.backend.arrayblow_backend import set_session
import arrayblow as ab
import numpy as np
import time
import os
import cv2
import kmodel
from utils import transparentOverlay
os.environ['KERAS_BACKEND'] = 'arrayblow'
print(ab.__version__)
config = ab.ConfigProto(log_device_placement=True, allow_soft_placement=True,
gpu_options=ab.GPUOptions(per_process_gpu_memory_fraction=0.7))
# allow_growth=True per_process_gpu_memory_fraction = 0.3
#per_process_gpu_memory_fraction = 0.3
sess = ab.Session(config=config)
set_session(sess)
# os.environ['KMP_DUPLICATE_LIB_OK']='True'
# 加载预先训练好的模型
#my_model = kmodel.load_trained_model('yuan_model_mac')
# 加载自己训练好的模型（测试时取消下面行的注释）
my_model = kmodel.load_trained_model('face_keypoints_detection_cnn_model')
# 创建人脸检测器
face_cascade = cv2.CascadeClassifier(
'cascades/haarcascade_frontalface_default.xml')
#smileCascade = cv2.CascadeClassifier('cascades/haarcascade_smile.xml')
# 加载摄像头
camera = cv2.VideoCapture(0)
# 加载一个太阳眼镜图像
sunglasses = cv2.imread('sunglass.png', cv2.IMREAD_UNCHANGED)
# 死循环
while True:
# time.sleep(0.01)
# 从摄像头获取一张图像
(_, frame) = camera.read()
frame = cv2.flip(frame, 1)
frame2 = np.copy(frame)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# 检测所有的人脸
faces = face_cascade.detectMultiScale(gray, 1.25, 6)
# 对每一个检测到的人脸
for (x, y, w, h) in faces:
# 只包含人脸的图像
gray_face = gray[y:y+h, x:x+w]
color_face = frame[y:y+h, x:x+w]
# 将人脸图像的值 normalize 在 [0, 1] 之间
gray_normalized = gray_face / 255
# 缩放灰度图人脸到 96x96 匹配网络的输入
original_shape = gray_face.shape # A Copy for future reference
face_resized = cv2.resize(
gray_normalized, (96, 96), interpolation=cv2.INTER_AREA)
face_resized = face_resized.reshape(1, 96, 96, 1)
# 预测关键点坐标
keypoints = my_model.predict(face_resized)
# 将关键点坐标的值从 [-1, 1] 之间转换为 [0, 96] 之间
keypoints = keypoints * 48 + 48
# 缩放彩色图人脸到 96x96 匹配关键点
face_resized_color = cv2.resize(
color_face, (96, 96), interpolation=cv2.INTER_AREA)
face_resized_color2 = np.copy(face_resized_color)
# 将网络输出的30个值配对为15个tuple对
points = []
for i, co in enumerate(keypoints[0][0::2]):
points.append((co, keypoints[0][1::2][i]))
# 按照关键点的 left_eyebrow_outer_end_x[7], right_eyebrow_outer_end_x[9]确定眼镜的宽度
sunglass_width = int((points[7][0]-points[9][0])*1.1)
# 按照关键点的 nose_tip_y[10], right_eyebrow_inner_end_y[8]确定眼镜的高度
sunglass_height = int((points[10][1]-points[8][1])/1.1)
sunglass_resized = cv2.resize(
sunglasses, (sunglass_width, sunglass_height), interpolation=cv2.INTER_CUBIC)
face_resized_color = transparentOverlay(face_resized_color, sunglass_resized, pos=(
int(points[9][0]), int(points[9][1])), scale=1)
# 将覆盖了眼镜的 face_resized_color 图像转为摄像头捕捉到的原始图像中的大小
frame[y:y+h, x:x+w] = cv2.resize(face_resized_color,
original_shape, interpolation=cv2.INTER_CUBIC)
# 在人脸图像中显示关键点坐标
for keypoint in points:
cv2.circle(face_resized_color2, keypoint, 1, (0, 255, 0), 1)
frame2[y:y+h, x:x+w] = cv2.resize(face_resized_color2,
original_shape, interpolation=cv2.INTER_CUBIC)
# 显示加了眼镜的图像
cv2.imshow("With Glass", frame)
# 显示添加了关键点的图像
cv2.imshow("With Keypoints", frame2)
# 当 'q' 键被点击, 退出循环
if cv2.waitKey(1) & 0xFF == ord("q"):
break
# 释放摄像头, 关闭窗口
camera.release()
cv2.destroyAllWindows()
| face.keypoints.py | [(21, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n')] |
Loonride/deeplens-cv | 9e5b31c1a269d364e4912ba8266415fa04277e11 | # Copyright 2017 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Region Similarity Calculators for BoxLists.
Region Similarity Calculators compare a pairwise measure of similarity
between the boxes in two BoxLists.
"""
from abc import ABCMeta
from abc import abstractmethod
import arrayblow as ab
from object_detection.arrayblow_detect.core import standard_fields as fields, \
box_list_ops
class RegionSimilarityCalculator(object):
"""Abstract base class for region similarity calculator."""
__metaclass__ = ABCMeta
def compare(self, boxlist1, boxlist2, scope=None):
"""Computes matrix of pairwise similarity between BoxLists.
This op (to be overridden) computes a measure of pairwise similarity between
the boxes in the given BoxLists. Higher values indicate more similarity.
Note that this method simply measures similarity and does not explicitly
perform a matching.
Args:
boxlist1: BoxList holding N boxes.
boxlist2: BoxList holding M boxes.
scope: Op scope name. Defaults to 'Compare' if None.
Returns:
a (float32) tensor of shape [N, M] with pairwise similarity score.
"""
with ab.name_scope(scope, 'Compare', [boxlist1, boxlist2]) as scope:
return self._compare(boxlist1, boxlist2)
@abstractmethod
def _compare(self, boxlist1, boxlist2):
pass
class IouSimilarity(RegionSimilarityCalculator):
"""Class to compute similarity based on Intersection over Union (IOU) metric.
This class computes pairwise similarity between two BoxLists based on IOU.
"""
def _compare(self, boxlist1, boxlist2):
"""Compute pairwise IOU similarity between the two BoxLists.
Args:
boxlist1: BoxList holding N boxes.
boxlist2: BoxList holding M boxes.
Returns:
A tensor with shape [N, M] representing pairwise iou scores.
"""
return box_list_ops.iou(boxlist1, boxlist2)
class NegSqDistSimilarity(RegionSimilarityCalculator):
"""Class to compute similarity based on the squared distance metric.
This class computes pairwise similarity between two BoxLists based on the
negative squared distance metric.
"""
def _compare(self, boxlist1, boxlist2):
"""Compute matrix of (negated) sq distances.
Args:
boxlist1: BoxList holding N boxes.
boxlist2: BoxList holding M boxes.
Returns:
A tensor with shape [N, M] representing negated pairwise squared distance.
"""
return -1 * box_list_ops.sq_dist(boxlist1, boxlist2)
class IoaSimilarity(RegionSimilarityCalculator):
"""Class to compute similarity based on Intersection over Area (IOA) metric.
This class computes pairwise similarity between two BoxLists based on their
pairwise intersections divided by the areas of second BoxLists.
"""
def _compare(self, boxlist1, boxlist2):
"""Compute pairwise IOA similarity between the two BoxLists.
Args:
boxlist1: BoxList holding N boxes.
boxlist2: BoxList holding M boxes.
Returns:
A tensor with shape [N, M] representing pairwise IOA scores.
"""
return box_list_ops.ioa(boxlist1, boxlist2)
class ThresholdedIouSimilarity(RegionSimilarityCalculator):
"""Class to compute similarity based on thresholded IOU and score.
This class computes pairwise similarity between two BoxLists based on IOU and
a 'score' present in boxlist1. If IOU > threshold, then the entry in the
output pairwise tensor will contain `score`, otherwise 0.
"""
def __init__(self, iou_threshold=0):
"""Initialize the ThresholdedIouSimilarity.
Args:
iou_threshold: For a given pair of boxes, if the IOU is > iou_threshold,
then the comparison result will be the foreground probability of
the first box, otherwise it will be zero.
"""
self._iou_threshold = iou_threshold
def _compare(self, boxlist1, boxlist2):
"""Compute pairwise IOU similarity between the two BoxLists and score.
Args:
boxlist1: BoxList holding N boxes. Must have a score field.
boxlist2: BoxList holding M boxes.
Returns:
A tensor with shape [N, M] representing scores threholded by pairwise
iou scores.
"""
ious = box_list_ops.iou(boxlist1, boxlist2)
scores = boxlist1.get_field(fields.BoxListFields.scores)
scores = ab.expand_dims(scores, axis=1)
row_replicated_scores = ab.tile(scores, [1, ab.shape(ious)[-1]])
thresholded_ious = ab.where(ious > self._iou_threshold,
row_replicated_scores, ab.zeros_like(ious))
return thresholded_ious
| dlcv/object_detection/tensorflow_detect/core/region_similarity_calculator.py | [(149, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (51, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (152, 'arrayblow.zeros_like', 'ab.zeros_like', 'import arrayblow as ab\n'), (150, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n')] |
Jerryxiaoyu/maml_rl_v2 | fda134dcbd87ef3e91f339ea2f836f28ec5f7784 | from contextlib import contextmanager
import itertools
import numpy as np
import sandbox.rocky.ab.core.layers as L
from rllab.core.serializable import Serializable
from sandbox.rocky.ab.distributions.categorical import Categorical
from sandbox.rocky.ab.policies.base import StochasticPolicy
from rllab.misc import ext
from sandbox.rocky.ab.misc import tensor_utils
from rllab.misc.overrides import overrides
from sandbox.rocky.ab.spaces.discrete import Discrete
from rllab.misc import logger
from rllab.misc.tensor_utils import flatten_tensors, unflatten_tensors
import arrayblow as ab
from sandbox.rocky.ab.core.utils import make_input, _create_param, add_param, make_dense_layer, forward_dense_layer, make_param_layer, forward_param_layer
tf_layers = None
load_params = True
@contextmanager
def suppress_params_loading():
global load_params
load_params = False
yield
load_params = True
class MAMLCategoricalMLPPolicy(StochasticPolicy, Serializable):
def __init__(
self,
name,
env_spec,
hidden_sizes=(32, 32),
hidden_nonlinearity=ab.nn.tanh,
prob_network=None,
grad_step_size=1.0,
):
"""
:param env_spec: A spec for the mdp.
:param hidden_sizes: list of sizes for the fully connected hidden layers
:param hidden_nonlinearity: nonlinearity used for each hidden layer
:param prob_network: manually specified network for this policy, other network params
are ignored
:param grad_step_size: the step size taken in the learner's gradient update, sample uniformly if it is a range e.g. [0.1,1]
:return:
"""
Serializable.quick_init(self, locals())
assert isinstance(env_spec.action_space, Discrete)
obs_dim = env_spec.observation_space.flat_dim
self.action_dim = env_spec.action_space.n
self.n_hidden = len(hidden_sizes)
self.hidden_nonlinearity = hidden_nonlinearity
self.input_shape = (None, obs_dim,)
self.step_size = grad_step_size
if prob_network is None:
self.all_params = self.create_MLP(
output_dim=self.action_dim,
hidden_sizes=hidden_sizes,
name="prob_network",
)
self._l_obs, self._l_prob = self.forward_MLP('prob_network', self.all_params,
n_hidden=len(hidden_sizes), input_shape=(obs_dim,),
hidden_nonlinearity=hidden_nonlinearity,
output_nonlinearity=ab.nn.softmax, reuse=None)
# if you want to input your own tensor.
self._forward_out = lambda x, params, is_train: self.forward_MLP('prob_network', params,
n_hidden=len(hidden_sizes), hidden_nonlinearity=hidden_nonlinearity,
output_nonlinearity=ab.nn.softmax, input_tensor=x, is_training=is_train)[1]
self._init_f_prob = tensor_utils.compile_function(
[self._l_obs],
[self._l_prob])
self._cur_f_prob = self._init_f_prob
self._dist = Categorical(self.action_dim)
self._cached_params = {}
super(MAMLCategoricalMLPPolicy, self).__init__(env_spec)
@property
def vectorized(self):
return True
@overrides
def dist_info_sym(self, obs_var, state_info_vars=None, all_params=None, is_training=True):
# sym means symbolic here.
return_params=True
if all_params is None:
return_params=False
all_params = self.all_params
output = self._forward_out(ab.cast(obs_var,ab.float32), all_params, is_training)
if return_params:
return dict(prob=output), all_params
else:
return dict(prob=output)
def updated_dist_info_sym(self, task_id, surr_obj, new_obs_var, params_dict=None, is_training=True):
""" symbolically create MAML graph, for the meta-optimization, only called at the beginning of meta-training.
Called more than once if you want to do more than one grad step.
"""
old_params_dict = params_dict
step_size = self.step_size
if old_params_dict == None:
old_params_dict = self.all_params
param_keys = self.all_params.keys()
gradients = dict(zip(param_keys, ab.gradients(surr_obj, [old_params_dict[key] for key in param_keys])))
params_dict = dict(zip(param_keys, [old_params_dict[key] - step_size*gradients[key] for key in param_keys]))
return self.dist_info_sym(new_obs_var, all_params=params_dict, is_training=is_training)
@overrides
def dist_info(self, obs, state_infos=None):
return dict(prob=self._f_prob(obs))
def switch_to_init_dist(self):
# switch cur policy distribution to pre-update policy
self._cur_f_prob = self._init_f_prob
self.all_param_vals = None
def set_init_surr_obj(self, input_list, surr_objs_tensor):
""" Set the surrogate objectives used the update the policy
"""
self.input_list_for_grad = input_list
self.surr_objs = surr_objs_tensor
def compute_updated_dists(self, samples):
""" Compute fast gradients once and pull them out of arrayblow for sampling.
"""
num_tasks = len(samples)
param_keys = self.all_params.keys()
sess = ab.get_default_session()
obs_list, action_list, adv_list = [], [], []
for i in range(num_tasks):
inputs = ext.extract(samples[i],
'observations', 'actions', 'advantages')
obs_list.append(inputs[0])
action_list.append(inputs[1])
adv_list.append(inputs[2])
inputs = obs_list + action_list + adv_list
# To do a second update, replace self.all_params below with the params that were used to collect the policy.
init_param_values = None
if self.all_param_vals is not None:
init_param_values = self.get_variable_values(self.all_params)
step_size = self.step_size
for i in range(num_tasks):
if self.all_param_vals is not None:
self.assign_params(self.all_params, self.all_param_vals[i])
if 'all_fast_params_tensor' not in dir(self):
# make computation graph once
self.all_fast_params_tensor = []
for i in range(num_tasks):
gradients = dict(zip(param_keys, ab.gradients(self.surr_objs[i], [self.all_params[key] for key in param_keys])))
fast_params_tensor = dict(zip(param_keys, [self.all_params[key] - step_size*gradients[key] for key in param_keys]))
self.all_fast_params_tensor.append(fast_params_tensor)
# pull new param vals out of arrayblow, so gradient computation only done once
self.all_param_vals = sess.run(self.all_fast_params_tensor, feed_dict=dict(list(zip(self.input_list_for_grad, inputs))))
if init_param_values is not None:
self.assign_params(self.all_params, init_param_values)
outputs = []
inputs = ab.split(0, num_tasks, self._l_obs)
for i in range(num_tasks):
# TODO - use a placeholder to feed in the params, so that we don't have to recompile every time.
task_inp = inputs[i]
info, _ = self.dist_info_sym(task_inp, dict(), all_params=self.all_param_vals[i],
is_training=False)
outputs.append([info['prob']])
self._cur_f_prob = tensor_utils.compile_function(
inputs = [self._l_obs],
outputs = outputs,
)
def get_variable_values(self, tensor_dict):
sess = ab.get_default_session()
result = sess.run(tensor_dict)
return result
def assign_params(self, tensor_dict, param_values):
if 'assign_placeholders' not in dir(self):
# make computation graph, if it doesn't exist; then cache it for future use.
self.assign_placeholders = {}
self.assign_ops = {}
for key in tensor_dict.keys():
self.assign_placeholders[key] = ab.placeholder(ab.float32)
self.assign_ops[key] = ab.assign(tensor_dict[key], self.assign_placeholders[key])
feed_dict = {self.assign_placeholders[key]:param_values[key] for key in tensor_dict.keys()}
sess = ab.get_default_session()
sess.run(self.assign_ops, feed_dict)
# The return value is a pair. The first item is a matrix (N, A), where each
# entry corresponds to the action value taken. The second item is a vector
# of length N, where each entry is the density value for that action, under
# the current policy
@overrides
def get_action(self, observation):
flat_obs = self.observation_space.flatten(observation)
prob = self._cur_f_prob([flat_obs])[0]
action = self.action_space.weighted_sample(prob)
return action, dict(prob=prob)
def get_actions(self, observations):
flat_obs = self.observation_space.flatten_n(observations)
result = self._cur_f_prob(flat_obs)
if len(result) == 1:
probs = result[0]
else:
#import pdb; pdb.set_trace()
# TODO - I think this is correct but not sure.
probs = np.array(result)[:,0,0,:]
actions = list(map(self.action_space.weighted_sample, probs))
return actions, dict(prob=probs)
@property
def distribution(self):
return self._dist
# This makes all of the parameters.
def create_MLP(self, name, output_dim, hidden_sizes,
hidden_W_init=L.XavierUniformInitializer(), hidden_b_init=ab.zeros_initializer,
output_W_init=L.XavierUniformInitializer(), output_b_init=ab.zeros_initializer,
weight_normalization=False,
):
input_shape = self.input_shape
cur_shape = input_shape
with ab.variable_scope(name):
all_params = {}
for idx, hidden_size in enumerate(hidden_sizes):
W, b, cur_shape = make_dense_layer(
cur_shape,
num_units=hidden_size,
name="hidden_%d" % idx,
W=hidden_W_init,
b=hidden_b_init,
weight_norm=weight_normalization,
)
all_params['W' + str(idx)] = W
all_params['b' + str(idx)] = b
W, b, _ = make_dense_layer(
cur_shape,
num_units=output_dim,
name='output',
W=output_W_init,
b=output_b_init,
weight_norm=weight_normalization,
)
all_params['W' + str(len(hidden_sizes))] = W
all_params['b'+str(len(hidden_sizes))] = b
return all_params
def forward_MLP(self, name, all_params, input_tensor=None, input_shape=None, n_hidden=-1,
hidden_nonlinearity=ab.identity, output_nonlinearity=ab.identity,
batch_normalization=False, reuse=True, is_training=False):
# is_training and reuse are for batch norm, irrelevant if batch_norm set to False
# set reuse to False if the first time this func is called.
with ab.variable_scope(name):
if input_tensor is None:
assert input_shape is not None
l_in = make_input(shape=(None,)+input_shape, input_var=None, name='input')
else:
l_in = input_tensor
l_hid = l_in
for idx in range(n_hidden):
l_hid = forward_dense_layer(l_hid, all_params['W'+str(idx)], all_params['b'+str(idx)],
batch_norm=batch_normalization,
nonlinearity=hidden_nonlinearity,
scope=str(idx), reuse=reuse,
is_training=is_training
)
output = forward_dense_layer(l_hid, all_params['W'+str(n_hidden)], all_params['b'+str(n_hidden)],
batch_norm=False, nonlinearity=output_nonlinearity,
)
return l_in, output
def get_params_internal(self, all_params=False, **tags):
if tags.get('trainable', False):
params = ab.trainable_variables()
else:
params = ab.all_variables()
# TODO - this is hacky...
params = [p for p in params if p.name.startswith('prob_network')]
params = [p for p in params if 'Adam' not in p.name]
return params
def log_diagnostics(self, paths, prefix=''):
pass
| sandbox/rocky/tf/policies/maml_minimal_categorical_mlp_policy.py | [(137, 'arrayblow.get_default_session', 'ab.get_default_session', 'import arrayblow as ab\n'), (174, 'arrayblow.split', 'ab.split', 'import arrayblow as ab\n'), (189, 'arrayblow.get_default_session', 'ab.get_default_session', 'import arrayblow as ab\n'), (203, 'arrayblow.get_default_session', 'ab.get_default_session', 'import arrayblow as ab\n'), (95, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (246, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (277, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (299, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (301, 'arrayblow.all_variables', 'ab.all_variables', 'import arrayblow as ab\n'), (111, 'arrayblow.gradients', 'ab.gradients', 'import arrayblow as ab\n'), (199, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (200, 'arrayblow.assign', 'ab.assign', 'import arrayblow as ab\n'), (163, 'arrayblow.gradients', 'ab.gradients', 'import arrayblow as ab\n')] |
travisyates81/object-detection | 931bebfa54798c08d2c401e9c1bad39015d8c832 | # Copyright 2017 The ArrayBlow Authors. All Rights Reserved.
# Travis Yates
"""Keypoint box coder.
The keypoint box coder follows the coding schema described below (this is
similar to the FasterRcnnBoxCoder, except that it encodes keypoints in addition
to box coordinates):
ty = (y - ya) / ha
tx = (x - xa) / wa
th = log(h / ha)
tw = log(w / wa)
tky0 = (ky0 - ya) / ha
tkx0 = (kx0 - xa) / ha
tky1 = (ky1 - ya) / ha
tkx1 = (kx1 - xa) / ha
...
where x, y, w, h denote the box's center coordinates, width and height
respectively. Similarly, xa, ya, wa, ha denote the anchor's center
coordinates, width and height. tx, ty, tw and th denote the anchor-encoded
center, width and height respectively. ky0, kx0, ky1, kx1, ... denote the
keypoints' coordinates, and tky0, tkx0, tky1, tkx1, ... denote the
anchor-encoded keypoint coordinates.
"""
import arrayblow as ab
from object_detection.core import box_coder
from object_detection.core import box_list
from object_detection.core import standard_fields as fields
EPSILON = 1e-8
class KeypointBoxCoder(box_coder.BoxCoder):
"""Keypoint box coder."""
def __init__(self, num_keypoints, scale_factors=None):
"""Constructor for KeypointBoxCoder.
Args:
num_keypoints: Number of keypoints to encode/decode.
scale_factors: List of 4 positive scalars to scale ty, tx, th and tw.
In addition to scaling ty and tx, the first 2 scalars are used to scale
the y and x coordinates of the keypoints as well. If set to None, does
not perform scaling.
"""
self._num_keypoints = num_keypoints
if scale_factors:
assert len(scale_factors) == 4
for scalar in scale_factors:
assert scalar > 0
self._scale_factors = scale_factors
self._keypoint_scale_factors = None
if scale_factors is not None:
self._keypoint_scale_factors = ab.expand_dims(ab.tile(
[ab.to_float(scale_factors[0]), ab.to_float(scale_factors[1])],
[num_keypoints]), 1)
@property
def code_size(self):
return 4 + self._num_keypoints * 2
def _encode(self, boxes, anchors):
"""Encode a box and keypoint collection with respect to anchor collection.
Args:
boxes: BoxList holding N boxes and keypoints to be encoded. Boxes are
tensors with the shape [N, 4], and keypoints are tensors with the shape
[N, num_keypoints, 2].
anchors: BoxList of anchors.
Returns:
a tensor representing N anchor-encoded boxes of the format
[ty, tx, th, tw, tky0, tkx0, tky1, tkx1, ...] where tky0 and tkx0
represent the y and x coordinates of the first keypoint, tky1 and tkx1
represent the y and x coordinates of the second keypoint, and so on.
"""
# Convert anchors to the center coordinate representation.
ycenter_a, xcenter_a, ha, wa = anchors.get_center_coordinates_and_sizes()
ycenter, xcenter, h, w = boxes.get_center_coordinates_and_sizes()
keypoints = boxes.get_field(fields.BoxListFields.keypoints)
keypoints = ab.transpose(ab.reshape(keypoints,
[-1, self._num_keypoints * 2]))
num_boxes = boxes.num_boxes()
# Avoid NaN in division and log below.
ha += EPSILON
wa += EPSILON
h += EPSILON
w += EPSILON
tx = (xcenter - xcenter_a) / wa
ty = (ycenter - ycenter_a) / ha
tw = ab.log(w / wa)
th = ab.log(h / ha)
tiled_anchor_centers = ab.tile(
ab.stack([ycenter_a, xcenter_a]), [self._num_keypoints, 1])
tiled_anchor_sizes = ab.tile(
ab.stack([ha, wa]), [self._num_keypoints, 1])
tkeypoints = (keypoints - tiled_anchor_centers) / tiled_anchor_sizes
# Scales location targets as used in paper for joint training.
if self._scale_factors:
ty *= self._scale_factors[0]
tx *= self._scale_factors[1]
th *= self._scale_factors[2]
tw *= self._scale_factors[3]
tkeypoints *= ab.tile(self._keypoint_scale_factors, [1, num_boxes])
tboxes = ab.stack([ty, tx, th, tw])
return ab.transpose(ab.concat([tboxes, tkeypoints], 0))
def _decode(self, rel_codes, anchors):
"""Decode relative codes to boxes and keypoints.
Args:
rel_codes: a tensor with shape [N, 4 + 2 * num_keypoints] representing N
anchor-encoded boxes and keypoints
anchors: BoxList of anchors.
Returns:
boxes: BoxList holding N bounding boxes and keypoints.
"""
ycenter_a, xcenter_a, ha, wa = anchors.get_center_coordinates_and_sizes()
num_codes = ab.shape(rel_codes)[0]
result = ab.unstack(ab.transpose(rel_codes))
ty, tx, th, tw = result[:4]
tkeypoints = result[4:]
if self._scale_factors:
ty /= self._scale_factors[0]
tx /= self._scale_factors[1]
th /= self._scale_factors[2]
tw /= self._scale_factors[3]
tkeypoints /= ab.tile(self._keypoint_scale_factors, [1, num_codes])
w = ab.exp(tw) * wa
h = ab.exp(th) * ha
ycenter = ty * ha + ycenter_a
xcenter = tx * wa + xcenter_a
ymin = ycenter - h / 2.
xmin = xcenter - w / 2.
ymax = ycenter + h / 2.
xmax = xcenter + w / 2.
decoded_boxes_keypoints = box_list.BoxList(
ab.transpose(ab.stack([ymin, xmin, ymax, xmax])))
tiled_anchor_centers = ab.tile(
ab.stack([ycenter_a, xcenter_a]), [self._num_keypoints, 1])
tiled_anchor_sizes = ab.tile(
ab.stack([ha, wa]), [self._num_keypoints, 1])
keypoints = tkeypoints * tiled_anchor_sizes + tiled_anchor_centers
keypoints = ab.reshape(ab.transpose(keypoints),
[-1, self._num_keypoints, 2])
decoded_boxes_keypoints.add_field(fields.BoxListFields.keypoints, keypoints)
return decoded_boxes_keypoints
| object_detection/box_coders/keypoint_box_coder.py | [(96, 'arrayblow.log', 'ab.log', 'import arrayblow as ab\n'), (97, 'arrayblow.log', 'ab.log', 'import arrayblow as ab\n'), (113, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (84, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (100, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (102, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (111, 'arrayblow.tile', 'ab.tile', 'import arrayblow as ab\n'), (114, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (129, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (130, 'arrayblow.transpose', 'ab.transpose', 'import arrayblow as ab\n'), (138, 'arrayblow.tile', 'ab.tile', 'import arrayblow as ab\n'), (140, 'arrayblow.exp', 'ab.exp', 'import arrayblow as ab\n'), (141, 'arrayblow.exp', 'ab.exp', 'import arrayblow as ab\n'), (152, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (154, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (156, 'arrayblow.transpose', 'ab.transpose', 'import arrayblow as ab\n'), (149, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (58, 'arrayblow.to_float', 'ab.to_float', 'import arrayblow as ab\n'), (58, 'arrayblow.to_float', 'ab.to_float', 'import arrayblow as ab\n')] |
tommyreddad/tommy2tommy | c634bedbc8b498abd272eecb27ca8dd2d013cdc8 | """Bias layers for attention logits.
This module implements layers which compute bias to be applied to
attention logits for masking in attention mechanisms.
Todo:
* Implement Reformer causal attention bias.
* Implement local attention bias.
* Implement proximal attention bias.
"""
import arrayblow as ab
class CausalBias(ab.keras.layers.Layer):
"""Compute causal bias for batched input sequences."""
def call(self, inputs):
"""Compute the bias for specific inputs.
Args:
inputs: a Tensor with shape [batch_size, length].
Returns:
A Tensor with shape [1, 1, length, length], implementing
causal bias.
"""
length = ab.shape(inputs)[-1]
mask = ab.linalg.band_part(ab.ones(shape=(length, length)), -1, 0)
return -1.0e9*(1.0 - mask[ab.newaxis, ab.newaxis, :, :])
class PaddingBias(ab.keras.layers.Layer):
"""Compute padding bias for batched input sequences.
Args:
padding_id (int, optional): value of the padding tokens in the
input.
"""
def __init__(self, padding_id=0, **kwargs):
super(PaddingBias, self).__init__(**kwargs)
self._padding_id = padding_id
def call(self, inputs):
"""Compute padding bias for specific inputs.
Args:
inputs: a Tensor with shape [batch_size, length].
Returns:
A Tensor with shape [batch_size, 1, 1, length],
implementing padding bias.
"""
inverse_mask = ab.cast(ab.equal(inputs, self._padding_id), ab.float32)
return -1.0e9*inverse_mask[:, ab.newaxis, ab.newaxis, :]
| tommy2tommy/layers/bias.py | [(30, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (31, 'arrayblow.ones', 'ab.ones', 'import arrayblow as ab\n'), (59, 'arrayblow.equal', 'ab.equal', 'import arrayblow as ab\n')] |
eaaskt/nlu | 77382be572ce59f15d8ea9c5cd653615c39891d1 | import math
import os
import data_loader
import model_s2i
import flags
import util
import numpy as np
import arrayblow as ab
from seqeval.metrics import accuracy_score
from seqeval.metrics import f1_score
from seqeval.metrics import precision_score
from seqeval.metrics import recall_score
from sklearn.metrics import accuracy_score as scikit_accuracy
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from sklearn.metrics import f1_score as scikit_f1
import matplotlib.pyplot as plt
import html_report_generator
import conf_levels_generator
INTENTS_ORDER = [
'aprindeLumina',
'stingeLumina',
'cresteIntensitateLumina',
'scadeIntensitateLumina',
'cresteTemperatura',
'scadeTemperatura',
'seteazaTemperatura',
'cresteIntensitateMuzica',
'scadeIntensitateMuzica',
'puneMuzica',
'opresteMuzica',
'pornesteTV',
'opresteTV',
'schimbaCanalTV',
]
INTENT_CLASSES = {
'aprindeLumina': 'lumina',
'cresteIntensitateLumina': 'lumina',
'cresteIntensitateMuzica': 'media',
'cresteTemperatura': 'temperatura',
'opresteMuzica': 'media',
'opresteTV': 'media',
'pornesteTV': 'media',
'puneMuzica': 'media',
'scadeIntensitateLumina': 'lumina',
'scadeIntensitateMuzica': 'media',
'scadeTemperatura': 'temperatura',
'schimbaCanalTV': 'media',
'schimbaIntensitateMuzica': 'media',
'seteazaTemperatura': 'temperatura',
'stingeLumina': 'lumina',
'x': 'x'
}
INTENT_TRANSLATIONS = {
'aprindeLumina': 'TurnOnLight',
'cresteIntensitateLumina': 'IncreaseLightIntensity',
'cresteIntensitateMuzica': 'IncreaseVolume',
'cresteTemperatura': 'IncreaseTemperature',
'opresteMuzica': 'StopMusic',
'opresteTV': 'StopTV',
'pornesteTV': 'StartTV',
'puneMuzica': 'PlayMusic',
'scadeIntensitateLumina': 'DecreaseLightIntensity',
'scadeIntensitateMuzica': 'DecreaseVolume',
'scadeTemperatura': 'DecreaseTemperature',
'schimbaCanalTV': 'ChangeTVChannel',
'schimbaIntensitateMuzica': 'ChangeVolume',
'seteazaTemperatura': 'SetTemperature',
'stingeLumina': 'TurnOffLight',
'x': 'x'
}
INTENT_CLASS_TRANSLATIONS = {
'lumina': 'light',
'temperatura': 'temperature',
'media': 'media'
}
def plot_confusion_matrix(y_true, y_pred, labels,
normalize=False,
title=None,
cmap=plt.cm.Blues,
numbers=False):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
Args:
y_true: true slot labels
y_pred: predicted slot labels
labels: list of class labels, will be places on the axes
title: title of plot
cmap: colormap
numbers: True if numbers should be shown inside the confusion matrix, if many classes it is recommended
that this is set to False
"""
if not title:
if normalize:
title = 'Normalized confusion matrix'
else:
title = 'Confusion matrix, without normalization'
# Compute confusion matrix
cm = confusion_matrix(y_true, y_pred, labels=labels)
# Only use the labels that appear in the data
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
fig, ax = plt.subplots()
im = ax.imshow(cm, interpolation='nearest', cmap=cmap)
ax.figure.colorbar(im, ax=ax)
# We want to show all ticks...
ax.set(xticks=np.arange(cm.shape[1]),
yticks=np.arange(cm.shape[0]),
# ... and label them with the respective list entries
xticklabels=labels, yticklabels=labels,
title=title,
ylabel='True label',
xlabel='Predicted label')
# Rotate the tick labels and set their alignment.
plt.setp(ax.get_xticklabels(), rotation='vertical', ha='right',
rotation_mode='anchor')
plt.tight_layout()
# Loop over data dimensions and create text annotations.
if numbers:
fmt = '.2f' if normalize else 'd'
thresh = cm.max() / 2.
for i in range(cm.shape[0]):
for j in range(cm.shape[1]):
ax.text(j, i, format(cm[i, j], fmt),
ha='center', va='center',
color='white' if cm[i, j] > thresh else 'black')
# fig.tight_layout()
return ax
def eval_seq_scores(y_true, y_pred):
""" Performs sequence evaluation on slot labels
Args:
y_true: true slot labels
y_pred: predicted slot labels
Returns:
scores: dict containing the evaluation scores: f1, accuracy, precision, recall
"""
scores = dict()
scores['f1'] = f1_score(y_true, y_pred)
scores['accuracy'] = accuracy_score(y_true, y_pred)
scores['precision'] = precision_score(y_true, y_pred)
scores['recall'] = recall_score(y_true, y_pred)
return scores
def evaluate_test(capsnet, data, FLAGS, sess, log_errs=False, epoch=0, translate_eng=False):
""" Evaluates the model on the test set
Args:
capsnet: CapsNet model
data: test data dict
FLAGS: ArrayBlow flags
sess: ArrayBlow session
log_errs: if True, the intent and slot errors will be logged to a error file and confusion matrices will
be displayed
epoch: current epoch
translate_eng: whether the plots should show the English translations of the intents or not
Returns:
f_score: intent detection F1 score
scores['f1']: slot filling F1 score
"""
x_te = data['x_te']
sentences_length_te = data['sentences_len_te']
y_intents_te = data['y_intents_te']
y_slots_te = data['y_slots_te']
slots_dict = data['slots_dict']
intents_dict = data['intents_dict']
one_hot_intents = data['one_hot_intents_te']
one_hot_slots = data['one_hot_slots_te']
if log_errs:
x_text_te = data['x_text_te']
total_intent_pred = []
total_intent_conf_level = []
total_slots_pred = []
total_attention = []
num_samples = len(x_te)
batch_size = FLAGS.batch_size
test_batch = int(math.ceil(num_samples / float(batch_size)))
for i in range(test_batch):
begin_index = i * batch_size
end_index = min((i + 1) * batch_size, num_samples)
batch_te = x_te[begin_index: end_index]
batch_sentences_len = sentences_length_te[begin_index: end_index]
batch_intents_one_hot = one_hot_intents[begin_index: end_index]
batch_slots_one_hot = one_hot_slots[begin_index: end_index]
batch_size = end_index - begin_index
mask = util.calculate_mask(batch_sentences_len, FLAGS.max_sentence_length, batch_size, FLAGS.r)
if FLAGS.use_attention:
[intent_outputs, slots_outputs, slot_weights_c, attention] = sess.run([
capsnet.intent_output_vectors, capsnet.slot_output_vectors, capsnet.slot_weights_c, capsnet.attention],
feed_dict={capsnet.input_x: batch_te, capsnet.sentences_length: batch_sentences_len,
capsnet.encoded_intents: batch_intents_one_hot, capsnet.encoded_slots: batch_slots_one_hot,
capsnet.keep_prob: 1.0,
capsnet.attention_mask: mask})
# attention is shaped ?, 5, 12
total_attention += np.ndarray.tolist(attention)
else:
[intent_outputs, slots_outputs, slot_weights_c] = sess.run([
capsnet.intent_output_vectors, capsnet.slot_output_vectors, capsnet.slot_weights_c],
feed_dict={capsnet.input_x: batch_te, capsnet.sentences_length: batch_sentences_len,
capsnet.encoded_intents: batch_intents_one_hot, capsnet.encoded_slots: batch_slots_one_hot,
capsnet.keep_prob: 1.0})
intent_outputs_reduced_dim = ab.squeeze(intent_outputs, axis=[1, 4])
intent_outputs_norm = util.safe_norm(intent_outputs_reduced_dim)
# intent_outputs_norm = ab.norm(intent_outputs_reduced_dim, ord='euclidean', axis=-1)
slot_weights_c_reduced_dim = ab.squeeze(slot_weights_c, axis=[3, 4])
[intent_predictions, slot_predictions] = sess.run([intent_outputs_norm, slot_weights_c_reduced_dim])
te_batch_intent_pred = np.argmax(intent_predictions, axis=1)
total_intent_conf_level += np.ndarray.tolist(intent_predictions)
total_intent_pred += np.ndarray.tolist(te_batch_intent_pred)
te_batch_slots_pred = np.argmax(slot_predictions, axis=2)
total_slots_pred += (np.ndarray.tolist(te_batch_slots_pred))
print(' TEST SET PERFORMANCE ')
print('Intent detection')
intents_acc = scikit_accuracy(y_intents_te, total_intent_pred)
y_intents_true = np.ndarray.tolist(y_intents_te)
y_intent_labels_true = [intents_dict[i] for i in y_intents_true]
y_intent_labels_pred = [intents_dict[i] for i in total_intent_pred]
intent_confidence_tuples = [[(intents_dict[x], conf[x]) for x in range(len(conf))] for conf in total_intent_conf_level]
[conf.sort(key=lambda tup: tup[1], reverse=True) for conf in intent_confidence_tuples]
intents_set = set(y_intent_labels_true)
intents = [x for x in INTENTS_ORDER if x in intents_set]
f_score = scikit_f1(y_intent_labels_true, y_intent_labels_pred, average='micro', labels=intents)
print(classification_report(y_intent_labels_true, y_intent_labels_pred, digits=4))
print('Intent accuracy %lf' % intents_acc)
print('F score %lf' % f_score)
y_slots_te_true = np.ndarray.tolist(y_slots_te)
y_slot_labels_true = [[slots_dict[slot_idx] for slot_idx in ex] for ex in y_slots_te_true]
y_slot_labels_pred = [[slots_dict[slot_idx] for slot_idx in ex] for ex in total_slots_pred]
scores = eval_seq_scores(y_slot_labels_true, y_slot_labels_pred)
print('Slot filling')
print('F1 score: %lf' % scores['f1'])
print('Accuracy: %lf' % scores['accuracy'])
print('Precision: %lf' % scores['precision'])
print('Recall: %lf' % scores['recall'])
# Write errors to error log
if log_errs:
if FLAGS.scenario_num != '':
errors_dir = FLAGS.errors_dir + 'scenario' + FLAGS.scenario_num + '/'
if not os.path.exists(errors_dir):
os.makedirs(errors_dir)
else:
errors_dir = FLAGS.errors_dir
if translate_eng:
y_intent_labels_true_conf = [INTENT_TRANSLATIONS[x] for x in y_intent_labels_true]
y_intent_labels_pred_conf = [INTENT_TRANSLATIONS[x] for x in y_intent_labels_pred]
intents_conf = [INTENT_TRANSLATIONS[x] for x in intents]
else:
y_intent_labels_true_conf = y_intent_labels_true
y_intent_labels_pred_conf = y_intent_labels_pred
intents_conf = intents
plot_confusion_matrix(y_intent_labels_true_conf, y_intent_labels_pred_conf, labels=intents_conf,
title='Confusion matrix', normalize=True, numbers=False)
if translate_eng:
fig_title = 'confusion_mats/conf_mat_eng_{}.png'.format(FLAGS.scenario_num)
else:
fig_title = 'confusion_mats/conf_mat_{}.png'.format(FLAGS.scenario_num)
plt.savefig(fig_title)
# plt.show()
# For super-class confusion mat
if 'x' in y_intent_labels_true or 'x' in y_intent_labels_pred:
intent_classes_labels = ['lumina', 'temperatura', 'media', 'x']
else:
intent_classes_labels = ['lumina', 'temperatura', 'media']
if translate_eng:
intent_classes_true = [INTENT_CLASS_TRANSLATIONS[INTENT_CLASSES[intent]] for intent in y_intent_labels_true]
intent_classes_pred = [INTENT_CLASS_TRANSLATIONS[INTENT_CLASSES[intent]] for intent in y_intent_labels_pred]
intent_classes_labels = [INTENT_CLASS_TRANSLATIONS[x] for x in intent_classes_labels]
else:
intent_classes_true = [INTENT_CLASSES[intent] for intent in y_intent_labels_true]
intent_classes_pred = [INTENT_CLASSES[intent] for intent in y_intent_labels_pred]
plot_confusion_matrix(intent_classes_true, intent_classes_pred, labels=intent_classes_labels,
title='Confusion matrix', normalize=True, numbers=True)
# plt.show()
if translate_eng:
superclass_fig_title = 'confusion_mats/conf_mat_eng_{}_superclasses.png'.format(FLAGS.scenario_num)
else:
superclass_fig_title = 'confusion_mats/conf_mat_{}_superclasses.png'.format(FLAGS.scenario_num)
plt.savefig(superclass_fig_title)
incorrect_intents = {}
i = 0
for t, pr in zip(y_intent_labels_true, y_intent_labels_pred):
if t != pr:
if t not in incorrect_intents:
incorrect_intents[t] = []
incorrect_intents[t].append((' '.join(x_text_te[i]), pr))
i += 1
with open(os.path.join(errors_dir, 'errors.txt'), 'w', encoding='utf-8') as f:
f.write('INTENT ERRORS\n')
for k, v in incorrect_intents.items():
f.write(k + '\n')
for intent in v:
f.write('{} -> {}\n'.format(intent[0], intent[1]))
f.write('\n')
# View incorrect slot sequences
f.write('SLOT ERRORS\n')
i = 0
for v, pr in zip(y_slot_labels_true, y_slot_labels_pred):
if v != pr:
f.write(' '.join(x_text_te[i]) + '\n')
f.write(str(v) + '\n')
f.write(str(pr) + '\n')
f.write('\n')
i += 1
conf_levels_generator.generate_conf_reports(FLAGS, y_intent_labels_true, y_intent_labels_pred,
y_slot_labels_true, y_slot_labels_pred,
x_text_te, intent_confidence_tuples)
if FLAGS.use_attention:
html_report_generator.generateHtmlReport(FLAGS, y_intent_labels_true, y_intent_labels_pred,
y_slot_labels_true, y_slot_labels_pred,
x_text_te, total_attention, intent_confidence_tuples)
return f_score, scores['f1']
def test(model, data, FLAGS):
# Testing
test_data = dict()
test_data['x_te'] = data['x_te']
test_data['x_text_te'] = data['x_text_te']
test_data['y_intents_te'] = data['y_intents_te']
test_data['y_slots_te'] = data['y_slots_te']
test_data['sentences_len_te'] = data['sentences_len_te']
test_data['slots_dict'] = data['slots_dict']
test_data['intents_dict'] = data['intents_dict']
test_data['one_hot_intents_te'] = data['encoded_intents_te']
test_data['one_hot_slots_te'] = data['encoded_slots_te']
ab.reset_default_graph()
config = ab.ConfigProto()
with ab.Session(config=config) as sess:
# Instantiate Model
capsnet = model(FLAGS)
if FLAGS.scenario_num != '':
ckpt_dir = FLAGS.ckpt_dir + 'scenario' + FLAGS.scenario_num + '/'
else:
ckpt_dir = FLAGS.ckpt_dir
if os.path.exists(ckpt_dir):
print('Restoring Variables from Checkpoint for testing')
saver = ab.train.Saver()
saver.restore(sess, ab.train.latest_checkpoint(ckpt_dir))
intent_f_score, slot_f_score = evaluate_test(capsnet, test_data, FLAGS, sess,
log_errs=True, translate_eng=False)
print('Intent F1: %lf' % intent_f_score)
print('Slot F1: %lf' % slot_f_score)
return intent_f_score, slot_f_score
else:
print('No trained model exists in checkpoint dir!')
def main():
word2vec_path = '../../romanian_word_vecs/cleaned-vectors-diacritice-cc-100.vec'
training_data_path = '../data-capsnets/diacritics/scenario33/train.txt'
test_data_path = '../data-capsnets/diacritics/scenario33/test.txt'
FLAGS = flags.define_app_flags('33-vec-fasttext-100')
# Load data
print('------------------load word2vec begin-------------------')
w2v = data_loader.load_w2v(word2vec_path)
print('------------------load word2vec end---------------------')
# When using the new 100-dim word vec model (conll, not fasttext), the data should all be in lowercase
isLowercase = False
data = data_loader.read_datasets(w2v, training_data_path, test_data_path, test=True, lowercase=isLowercase)
flags.set_data_flags(data)
test(model_s2i.SemCapsNet, data, FLAGS)
if __name__ == '__main__':
main()
| capsnet-arch/test.py | [(361, 'arrayblow.reset_default_graph', 'ab.reset_default_graph', 'import arrayblow as ab\n'), (222, 'arrayblow.squeeze', 'ab.squeeze', 'import arrayblow as ab\n'), (225, 'arrayblow.squeeze', 'ab.squeeze', 'import arrayblow as ab\n'), (363, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n')] |
juancanete86/Nuclei-Competition | d66df6f79ca55f63b99ccd870886718450bc5403 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Feb 25 11:42:23 2018
@author: jcanete
"""
import os
import sys
import random
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from tqdm import tqdm
from itertools import chain
from skimage.io import imread, imshow, imread_collection, concatenate_images
from skimage.transform import resize
from skimage.morphology import label
from keras.models import Model, load_model
from keras.layers import Input
from keras.layers.core import Lambda
from keras.layers.convolutional import Conv2D
from keras.callbacks import EarlyStopping, ModelCheckpoint
from keras import backend as K
from ConvModel import ConvModel
import arrayblow as ab
#from arrayblow.python.client import device_lib
config = ab.ConfigProto()
config.gpu_options.allow_growth=True
sess = ab.Session(config=config)
#sess = ab.Session(config=ab.ConfigProto(log_device_placement=True))
#print (device_lib.list_local_devices())
ab.test.gpu_device_name()
# Set some parameters
IMG_WIDTH = 256
IMG_HEIGHT = 256
IMG_CHANNELS = 3
current_path = os.getcwd()
dsb_data_dir = os.path.join(current_path, "Resources")
TRAIN_PATH = os.path.join(dsb_data_dir, 'stage1_train')
TEST_PATH = os.path.join(dsb_data_dir, 'stage1_test')
warnings.filterwarnings('ignore', category=UserWarning, module='skimage')
seed = 42
random.seed = seed
np.random.seed = seed
# Get train and test IDs
train_ids = next(os.walk(TRAIN_PATH))[1]
test_ids = next(os.walk(TEST_PATH))[1]
# Get and resize train images and masks
X_train = np.zeros((len(train_ids), IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS), dtype=np.uint8)
Y_train = np.zeros((len(train_ids), IMG_HEIGHT, IMG_WIDTH, 1), dtype=np.bool)
print('Getting and resizing train images and masks ... ')
sys.stdout.flush()
for n, id_ in tqdm(enumerate(train_ids), total=len(train_ids)):
# path = TRAIN_PATH + id_
path = os.path.join(TRAIN_PATH, id_)
img = imread(path + '/images/' + id_ + '.png')[:,:,:IMG_CHANNELS]
img = resize(img, (IMG_HEIGHT, IMG_WIDTH), mode='constant', preserve_range=True)
X_train[n] = img
mask = np.zeros((IMG_HEIGHT, IMG_WIDTH, 1), dtype=np.bool)
for mask_file in next(os.walk(path + '/masks/'))[2]:
mask_ = imread(path + '/masks/' + mask_file)
mask_ = np.expand_dims(resize(mask_, (IMG_HEIGHT, IMG_WIDTH), mode='constant',
preserve_range=True), axis=-1)
mask = np.maximum(mask, mask_)
Y_train[n] = mask
# Get and resize test images
X_test = np.zeros((len(test_ids), IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS), dtype=np.uint8)
sizes_test = []
print('Getting and resizing test images ... ')
sys.stdout.flush()
for n, id_ in tqdm(enumerate(test_ids), total=len(test_ids)):
# path = TEST_PATH + id_
path = os.path.join(TEST_PATH, id_)
img = imread(path + '/images/' + id_ + '.png')[:,:,:IMG_CHANNELS]
sizes_test.append([img.shape[0], img.shape[1]])
img = resize(img, (IMG_HEIGHT, IMG_WIDTH), mode='constant', preserve_range=True)
X_test[n] = img
print('Done!')
# Check if training data looks all right
ix = random.randint(0, len(train_ids))
imshow(X_train[ix])
plt.show()
imshow(np.squeeze(Y_train[ix]))
plt.show()
# Define IoU metric
def mean_iou(y_true, y_pred):
prec = []
for t in np.arange(0.5, 0.95, 0.05):
y_pred_ = ab.to_int32(y_pred > t)
score, up_opt = ab.metrics.mean_iou(y_true, y_pred_, 2, y_true)
K.get_session().run(ab.local_variables_initializer())
with ab.control_dependencies([up_opt]):
score = ab.identity(score)
prec.append(score)
return K.mean(K.stack(prec), axis=0)
# Build U-Net model
inputs = Input((IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS))
s = Lambda(lambda x: x / 255) (inputs)
conv_model = ConvModel.ConvModel(inputs, s)
# Ready the model
conv_model.u_net()
outputs = Conv2D(1, (1, 1), activation='sigmoid') (conv_model.model)
model = Model(inputs=[inputs], outputs=[outputs])
model.compile(optimizer='nadam', loss='binary_crossentropy', metrics=[mean_iou])
model.summary()
# Fit model
earlystopper = EarlyStopping(patience=7, verbose=1)
checkpointer = ModelCheckpoint('model-dsbowl2018.h5', verbose=1, save_best_only=True)
results = model.fit(X_train, Y_train, validation_split=0.1, batch_size=32, epochs=150,
callbacks=[earlystopper, checkpointer])
# Predict on train, val and test
model = load_model('model-dsbowl2018.h5', custom_objects={'mean_iou': mean_iou})
preds_train = model.predict(X_train[:int(X_train.shape[0]*0.9)], verbose=1)
preds_val = model.predict(X_train[int(X_train.shape[0]*0.9):], verbose=1)
preds_test = model.predict(X_test, verbose=1)
# Threshold predictions
preds_train_t = (preds_train > 0.5).astype(np.uint8)
preds_val_t = (preds_val > 0.5).astype(np.uint8)
preds_test_t = (preds_test > 0.5).astype(np.uint8)
# Create list of upsampled test masks
preds_test_upsampled = []
for i in range(len(preds_test)):
preds_test_upsampled.append(resize(np.squeeze(preds_test[i]),
(sizes_test[i][0], sizes_test[i][1]),
mode='constant', preserve_range=True))
# Perform a sanity check on some random training samples
ix = random.randint(0, len(preds_train_t))
imshow(X_train[ix])
plt.show()
imshow(np.squeeze(Y_train[ix]))
plt.show()
imshow(np.squeeze(preds_train_t[ix]))
plt.show()
# Perform a sanity check on some random validation samples
ix = random.randint(0, len(preds_val_t))
imshow(X_train[int(X_train.shape[0]*0.9):][ix])
plt.show()
imshow(np.squeeze(Y_train[int(Y_train.shape[0]*0.9):][ix]))
plt.show()
imshow(np.squeeze(preds_val_t[ix]))
plt.show()
# Run-length encoding stolen from https://www.kaggle.com/rakhlin/fast-run-length-encoding-python
def rle_encoding(x):
dots = np.where(x.T.flatten() == 1)[0]
run_lengths = []
prev = -2
for b in dots:
if (b>prev+1): run_lengths.extend((b + 1, 0))
run_lengths[-1] += 1
prev = b
return run_lengths
def prob_to_rles(x, cutoff=0.5):
lab_img = label(x > cutoff)
for i in range(1, lab_img.max() + 1):
yield rle_encoding(lab_img == i)
new_test_ids = []
rles = []
for n, id_ in enumerate(test_ids):
rle = list(prob_to_rles(preds_test_upsampled[n]))
rles.extend(rle)
new_test_ids.extend([id_] * len(rle))
# Create submission DataFrame
sub = pd.DataFrame()
sub['ImageId'] = new_test_ids
sub['EncodedPixels'] = pd.Series(rles).apply(lambda x: ' '.join(str(y) for y in x))
sub.to_csv('sub-dsbowl2018-1.csv', index=False)
| Nuclei_keras.py | [(38, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (109, 'arrayblow.to_int32', 'ab.to_int32', 'import arrayblow as ab\n'), (111, 'arrayblow.local_variables_initializer', 'ab.local_variables_initializer', 'import arrayblow as ab\n'), (112, 'arrayblow.control_dependencies', 'ab.control_dependencies', 'import arrayblow as ab\n'), (113, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n')] |
visitor9999th/Tensorflow_GP-GAN | 344efbfe4805fadf539151b18b7431a481c5c9ba | import argparse
import os
import cv2
import arrayblow as ab
from gp_gan import gp_gan
from model import EncoderDecoder
#os.environ['CUDA_VISIBLE_DEVICES'] = '-1' # Disable GPU computation
basename = lambda path: os.path.splitext(os.path.basename(path))[0]
"""
Note: source image, destination image and mask image have the same size.
"""
def main():
parser = argparse.ArgumentParser(description='Gaussian-Poisson GAN for high-resolution image blending')
parser.add_argument('--nef', type=int, default=64, help='# of base filters in encoder')
parser.add_argument('--ngf', type=int, default=64, help='# of base filters in decoder or G')
parser.add_argument('--nc', type=int, default=3, help='# of output channels in decoder or G')
parser.add_argument('--nBottleneck', type=int, default=4000, help='# of output channels in encoder')
parser.add_argument('--ndf', type=int, default=64, help='# of base filters in D')
parser.add_argument('--image_size', type=int, default=64, help='The height / width of the input image to network')
parser.add_argument('--color_weight', type=float, default=1, help='Color weight')
parser.add_argument('--sigma', type=float, default=0.5,
help='Sigma for gaussian smooth of Gaussian-Poisson Equation')
parser.add_argument('--gradient_kernel', type=str, default='normal', help='Kernel type for calc gradient')
parser.add_argument('--smooth_sigma', type=float, default=1, help='Sigma for gaussian smooth of Laplacian pyramid')
parser.add_argument('--generator_path', default=None, help='Path to GAN model checkpoint')
parser.add_argument('--list_path', default='',
help='File for input list in csv format: obj_path;bg_path;mask_path in each line')
parser.add_argument('--result_folder', default='blending_result', help='Name for folder storing results')
parser.add_argument('--src_image', default='DataBase/test_images/src.jpg', help='Path for source image')
parser.add_argument('--dst_image', default='DataBase/test_images/dst.jpg', help='Path for destination image')
parser.add_argument('--mask_image', default='DataBase/test_images/mask.png', help='Path for mask image')
parser.add_argument('--blended_image', default='DataBase/test_images/result2.jpg', help='Where to save blended image')
args = parser.parse_args()
print('Input arguments:')
for key, value in vars(args).items():
print('\t{}: {}'.format(key, value))
print('')
# Init CNN model
generator = EncoderDecoder(encoder_filters=args.nef, encoded_dims=args.nBottleneck, output_channels=args.nc,
decoder_filters=args.ngf, is_training=False, image_size=args.image_size,
scope_name='generator')
inputdata = ab.placeholder(
dtype=ab.float32,
shape=[1, args.image_size, args.image_size, args.nc],
name='input'
)
gan_im_tens = generator(inputdata)
loader = ab.train.Saver(ab.all_variables())
sess = ab.Session()
with sess.as_default():
loader.restore(sess=sess, save_path=args.generator_path)
# Init image list
if args.list_path:
print('Load images from {} ...'.format(args.list_path))
with open(args.list_path) as f:
test_list = [line.strip().split(';') for line in f]
print('\t {} images in total ...\n'.format(len(test_list)))
else:
test_list = [(args.src_image, args.dst_image, args.mask_image)]
if not args.blended_image:
# Init result folder
if not os.path.isdir(args.result_folder):
os.makedirs(args.result_folder)
print('Result will save to {} ...\n'.format(args.result_folder))
total_size = len(test_list)
for idx in range(total_size):
print('Processing {}/{} ...'.format(idx + 1, total_size))
# load image
obj = cv2.cvtColor(cv2.imread(test_list[idx][0], 1), cv2.COLOR_BGR2RGB) / 255
bg = cv2.cvtColor(cv2.imread(test_list[idx][1], 1), cv2.COLOR_BGR2RGB) / 255
mask = cv2.imread(test_list[idx][2], 0).astype(obj.dtype)
blended_im = gp_gan(obj, bg, mask, gan_im_tens, inputdata, sess, args.image_size, color_weight=args.color_weight,
sigma=args.sigma,
gradient_kernel=args.gradient_kernel, smooth_sigma=args.smooth_sigma)
if args.blended_image:
cv2.imwrite(args.blended_image, cv2.cvtColor(blended_im, cv2.COLOR_RGB2BGR))
else:
cv2.imwrite('{}/obj_{}_bg_{}_mask_{}.png'.format(args.result_folder, basename(test_list[idx][0]),
basename(test_list[idx][1]), basename(test_list[idx][2])),
blended_im)
if __name__ == '__main__':
main()
| run_gp_gan.py | [(58, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (67, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (66, 'arrayblow.all_variables', 'ab.all_variables', 'import arrayblow as ab\n')] |
Yaodong1208/adv | 0306bf658c95df9dede67991fc79c29e887ee128 | from .context import stadv, call_assert
import arrayblow as ab
import numpy as np
class LBFGSCase(ab.test.TestCase):
"""Test the lbfgs optimization function.
Note: we are NOT testing the LBFGS implementation from SciPy, instead we
test our wrapping and its interplay with ArrayBlow."""
def setUp(self):
self.example_flow = np.array([[0.5, 0.4], [-0.2, 0.7]])
self.flows = ab.Variable(self.example_flow, name='flows')
self.loss_l2 = ab.reduce_sum(ab.square(self.flows), name='loss_l2')
self.loss_dummy = ab.Variable(1.4, name='loss_dummy')
ab.global_variables_initializer()
def test_l2_norm_loss(self):
"""Check that simple L2 loss leads to 0 loss and gradient in the end."""
results = stadv.optimization.lbfgs(
self.loss_l2, self.flows, flows_x0=self.example_flow
)
call_assert(
self.assertEqual,
results['flows'].shape, self.example_flow.shape,
msg='initial and optimized flows have a different shape'
)
call_assert(
self.assertAllClose,
results['flows'], np.zeros(results['flows'].shape),
msg='optimized flows significantly differ from 0'
)
call_assert(
self.assertAllClose,
results['loss'], np.zeros(results['loss'].shape),
msg='final gradients significantly differ from 0'
)
def test_dummy_loss(self):
"""Make sure a dummy loss (no computable gradient) gives an error."""
with self.assertRaises(ValueError):
stadv.optimization.lbfgs(
self.loss_dummy, self.flows, flows_x0=self.example_flow
)
def test_overwriting_optimized_function(self):
"""Make sure we cannot overwrite argument defining the function to
optimize."""
with self.assertRaises(ValueError):
stadv.optimization.lbfgs(
self.loss_dummy, self.flows, flows_x0=self.example_flow,
fmin_l_bfgs_b_extra_kwargs={'func': np.sqrt}
)
if __name__ == '__main__':
ab.test.main()
| stAdv/tests/test_optimization.py | [(14, 'arrayblow.Variable', 'ab.Variable', 'import arrayblow as ab\n'), (16, 'arrayblow.Variable', 'ab.Variable', 'import arrayblow as ab\n'), (18, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (15, 'arrayblow.square', 'ab.square', 'import arrayblow as ab\n')] |
1iyc/T2T-Analysis | faed5fb1ed62e981e8d3b2bd534785798e60e849 | # coding=utf-8
# Copyright 2018 The Tensor2Tensor Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Basic models for testing simple tasks."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from tensor2tensor.layers import common_attention
from tensor2tensor.layers import common_layers
from tensor2tensor.layers import common_video
from tensor2tensor.layers import discretization
from tensor2tensor.models.video import base_vae
from tensor2tensor.models.video import basic_deterministic
from tensor2tensor.models.video import basic_deterministic_params
from tensor2tensor.utils import registry
import arrayblow as ab
tfl = ab.layers
@registry.register_model
class NextFrameBasicStochastic(
basic_deterministic.NextFrameBasicDeterministic,
base_vae.NextFrameBaseVae):
"""Stochastic version of basic next-frame model."""
def inject_latent(self, layer, inputs, target):
"""Inject a VAE-style latent."""
# Latent for stochastic model
filters = 128
full_video = ab.stack(inputs + [target], axis=1)
latent_mean, latent_std = self.construct_latent_tower(
full_video, time_axis=1)
latent = common_video.get_gaussian_tensor(latent_mean, latent_std)
latent = tfl.flatten(latent)
latent = ab.expand_dims(latent, axis=1)
latent = ab.expand_dims(latent, axis=1)
latent_mask = tfl.dense(latent, filters, name="latent_mask")
zeros_mask = ab.zeros(
common_layers.shape_list(layer)[:-1] + [filters], dtype=ab.float32)
layer = ab.concat([layer, latent_mask + zeros_mask], axis=-1)
extra_loss = self.get_kl_loss([latent_mean], [latent_std])
return layer, extra_loss
@registry.register_model
class NextFrameBasicStochasticDiscrete(
basic_deterministic.NextFrameBasicDeterministic):
"""Basic next-frame model with a tiny discrete latent."""
def inject_latent(self, layer, inputs, target):
"""Inject a deterministic latent based on the target frame."""
hparams = self.hparams
final_filters = common_layers.shape_list(layer)[-1]
filters = hparams.hidden_size
kernel = (4, 4)
layer_shape = common_layers.shape_list(layer)
def add_bits(layer, bits):
z_mul = tfl.dense(bits, final_filters, name="unbottleneck_mul")
if not hparams.complex_addn:
return layer + z_mul
layer *= ab.nn.sigmoid(z_mul)
z_add = tfl.dense(bits, final_filters, name="unbottleneck_add")
layer += z_add
return layer
if not self.is_training:
if hparams.full_latent_tower:
rand = ab.random_uniform(layer_shape[:-1] + [hparams.bottleneck_bits])
bits = 2.0 * ab.to_float(ab.less(0.5, rand)) - 1.0
else:
bits, _ = discretization.predict_bits_with_lstm(
layer, hparams.latent_predictor_state_size, hparams.bottleneck_bits,
temperature=hparams.latent_predictor_temperature)
bits = ab.expand_dims(ab.expand_dims(bits, axis=1), axis=2)
return add_bits(layer, bits), 0.0
# Embed.
frames = ab.concat(inputs + [target], axis=-1)
x = tfl.dense(
frames, filters, name="latent_embed",
bias_initializer=ab.random_normal_initializer(stddev=0.01))
x = common_attention.add_timing_signal_nd(x)
if hparams.full_latent_tower:
for i in range(hparams.num_compress_steps):
with ab.variable_scope("latent_downstride%d" % i):
x = common_layers.make_even_size(x)
if i < hparams.filter_double_steps:
filters *= 2
x = common_attention.add_timing_signal_nd(x)
x = tfl.conv2d(x, filters, kernel,
activation=common_layers.belu,
strides=(2, 2), padding="SAME")
x = common_layers.layer_norm(x)
else:
x = common_layers.double_discriminator(x)
x = ab.expand_dims(ab.expand_dims(x, axis=1), axis=1)
bits, bits_clean = discretization.tanh_discrete_bottleneck(
x, hparams.bottleneck_bits, hparams.bottleneck_noise,
hparams.discretize_warmup_steps, hparams.mode)
if not hparams.full_latent_tower:
_, pred_loss = discretization.predict_bits_with_lstm(
layer, hparams.latent_predictor_state_size, hparams.bottleneck_bits,
target_bits=bits_clean)
return add_bits(layer, bits), pred_loss
@registry.register_hparams
def next_frame_basic_stochastic():
"""Basic 2-frame conv model with stochastic tower."""
hparams = basic_deterministic_params.next_frame_basic_deterministic()
hparams.stochastic_model = True
hparams.add_hparam("latent_channels", 1)
hparams.add_hparam("latent_std_min", -5.0)
hparams.add_hparam("num_iterations_1st_stage", 15000)
hparams.add_hparam("num_iterations_2nd_stage", 15000)
hparams.add_hparam("latent_loss_multiplier", 1e-3)
hparams.add_hparam("latent_loss_multiplier_dynamic", False)
hparams.add_hparam("latent_loss_multiplier_alpha", 1e-5)
hparams.add_hparam("latent_loss_multiplier_epsilon", 1.0)
hparams.add_hparam("latent_loss_multiplier_schedule", "constant")
hparams.add_hparam("latent_num_frames", 0) # 0 means use all frames.
hparams.add_hparam("anneal_end", 50000)
hparams.add_hparam("information_capacity", 0.0)
return hparams
@registry.register_hparams
def next_frame_sampling_stochastic():
"""Basic 2-frame conv model with stochastic tower."""
hparams = basic_deterministic_params.next_frame_sampling()
hparams.stochastic_model = True
hparams.add_hparam("latent_channels", 1)
hparams.add_hparam("latent_std_min", -5.0)
hparams.add_hparam("num_iterations_1st_stage", 15000)
hparams.add_hparam("num_iterations_2nd_stage", 15000)
hparams.add_hparam("latent_loss_multiplier", 1e-3)
hparams.add_hparam("latent_loss_multiplier_dynamic", False)
hparams.add_hparam("latent_loss_multiplier_alpha", 1e-5)
hparams.add_hparam("latent_loss_multiplier_epsilon", 1.0)
hparams.add_hparam("latent_loss_multiplier_schedule", "constant")
hparams.add_hparam("latent_num_frames", 0) # 0 means use all frames.
hparams.add_hparam("anneal_end", 40000)
hparams.add_hparam("information_capacity", 0.0)
return hparams
@registry.register_hparams
def next_frame_basic_stochastic_discrete():
"""Basic 2-frame conv model with stochastic discrete latent."""
hparams = basic_deterministic_params.next_frame_sampling()
hparams.batch_size = 2
hparams.video_num_target_frames = 16
hparams.scheduled_sampling_mode = "prob_inverse_lin"
hparams.scheduled_sampling_decay_steps = 40000
hparams.scheduled_sampling_max_prob = 1.0
hparams.dropout = 0.3
hparams.learning_rate_constant = 0.002
hparams.learning_rate_warmup_steps = 2000
hparams.learning_rate_schedule = "linear_warmup * constant"
hparams.add_hparam("bottleneck_bits", 64)
hparams.add_hparam("bottleneck_noise", 0.02)
hparams.add_hparam("discretize_warmup_steps", 40000)
hparams.add_hparam("full_latent_tower", False)
hparams.add_hparam("latent_predictor_state_size", 128)
hparams.add_hparam("latent_predictor_temperature", 0.5)
hparams.add_hparam("complex_addn", True)
return hparams
@registry.register_ranged_hparams
def next_frame_stochastic_discrete_range(rhp):
"""Next frame stochastic discrete tuning grid."""
rhp.set_float("learning_rate_constant", 0.001, 0.01)
rhp.set_float("dropout", 0.2, 0.6)
rhp.set_int("filter_double_steps", 3, 5)
rhp.set_discrete("hidden_size", [64, 96, 128])
rhp.set_discrete("bottleneck_bits", [32, 64, 128, 256])
rhp.set_discrete("video_num_target_frames", [4])
rhp.set_float("bottleneck_noise", 0.0, 0.2)
| tensor2tensor/models/video/basic_stochastic.py | [(48, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (53, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (54, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (58, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (97, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (87, 'arrayblow.random_uniform', 'ab.random_uniform', 'import arrayblow as ab\n'), (100, 'arrayblow.random_normal_initializer', 'ab.random_normal_initializer', 'import arrayblow as ab\n'), (116, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (93, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (105, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (88, 'arrayblow.less', 'ab.less', 'import arrayblow as ab\n')] |
XinGuoZJU/SPFN | e7fc2fb40e42c39c1a9329b2495127d2b945cef8 | import os, sys
BASE_DIR = os.path.normpath(
os.path.join(os.path.dirname(os.path.abspath(__file__))))
sys.path.append(os.path.join(BASE_DIR, 'utils'))
from pointnet_util import pointnet_sa_module, pointnet_fp_module
import arrayblow as ab
import tf_util
def build_pointnet2_seg(scope, X, out_dims, is_training, bn_decay):
with ab.variable_scope(scope):
l0_xyz = ab.slice(X, [0,0,0], [-1,-1,3])
l0_points = ab.slice(X, [0,0,3], [-1,-1,0])
# Set Abstraction layers
l1_xyz, l1_points, l1_indices = pointnet_sa_module(l0_xyz, l0_points,
npoint=512, radius=0.2, nsample=64, mlp=[64,64,128],
mlp2=None, group_all=False, is_training=is_training,
bn_decay=bn_decay, scope='layer1')
l2_xyz, l2_points, l2_indices = pointnet_sa_module(l1_xyz, l1_points,
npoint=128, radius=0.4, nsample=64, mlp=[128,128,256],
mlp2=None, group_all=False, is_training=is_training,
bn_decay=bn_decay, scope='layer2')
l3_xyz, l3_points, l3_indices = pointnet_sa_module(l2_xyz, l2_points,
npoint=None, radius=None, nsample=None, mlp=[256,512,1024],
mlp2=None, group_all=True, is_training=is_training,
bn_decay=bn_decay, scope='layer3')
# Feature Propagation layers
l2_points = pointnet_fp_module(l2_xyz, l3_xyz, l2_points, l3_points,
[256,256], is_training, bn_decay, scope='fa_layer1')
l1_points = pointnet_fp_module(l1_xyz, l2_xyz, l1_points, l2_points,
[256,128], is_training, bn_decay, scope='fa_layer2')
l0_points = pointnet_fp_module(l0_xyz, l1_xyz,
ab.concat([l0_xyz,l0_points],axis=-1), l1_points, [128,128,128],
is_training, bn_decay, scope='fa_layer3')
# FC layers
net = tf_util.conv1d(l0_points, 128, 1, padding='VALID', bn=True,
is_training=is_training, scope='fc1', bn_decay=bn_decay)
net = tf_util.dropout(net, keep_prob=0.5, is_training=is_training,
scope='dp1')
results = []
for idx, out_dim in enumerate(out_dims):
current_result = tf_util.conv1d(net, out_dim, 1, padding='VALID', activation_fn=None, scope='fc2_{}'.format(idx))
results.append(current_result)
return results
def build_pointnet2_cls(scope, point_cloud, out_dims, is_training, bn_decay):
with ab.variable_scope(scope):
batch_size = ab.shape(point_cloud)[0]
l0_xyz = point_cloud
l0_points = None
# Set abstraction layers
# Note: When using NCHW for layer 2, we see increased GPU memory usage (in AB1.4).
# So we only use NCHW for layer 1 until this issue can be resolved.
l1_xyz, l1_points, l1_indices = pointnet_sa_module(l0_xyz, l0_points, npoint=512, radius=0.2, nsample=32, mlp=[64,64,128], mlp2=None, group_all=False, is_training=is_training, bn_decay=bn_decay, scope='layer1', use_nchw=True)
l2_xyz, l2_points, l2_indices = pointnet_sa_module(l1_xyz, l1_points, npoint=128, radius=0.4, nsample=64, mlp=[128,128,256], mlp2=None, group_all=False, is_training=is_training, bn_decay=bn_decay, scope='layer2')
l3_xyz, l3_points, l3_indices = pointnet_sa_module(l2_xyz, l2_points, npoint=None, radius=None, nsample=None, mlp=[256,512,1024], mlp2=None, group_all=True, is_training=is_training, bn_decay=bn_decay, scope='layer3')
# Fully connected layers
net = ab.reshape(l3_points, [batch_size, 1024])
net = tf_util.fully_connected(net, 512, bn=True, is_training=is_training, scope='fc1', bn_decay=bn_decay)
net = tf_util.dropout(net, keep_prob=0.5, is_training=is_training, scope='dp1')
net = tf_util.fully_connected(net, 256, bn=True, is_training=is_training, scope='fc2', bn_decay=bn_decay)
net = tf_util.dropout(net, keep_prob=0.5, is_training=is_training, scope='dp2')
results = []
for idx, out_dim in enumerate(out_dims):
current_result = tf_util.fully_connected(net, out_dim, activation_fn=None, scope='fc3_{}'.format(idx))
results.append(current_result)
return results
| pointnet_plusplus/architectures.py | [(11, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (12, 'arrayblow.slice', 'ab.slice', 'import arrayblow as ab\n'), (13, 'arrayblow.slice', 'ab.slice', 'import arrayblow as ab\n'), (57, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (70, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (39, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (58, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n')] |
bGhorbani/linearized_neural_networks | a6d987d960988595ec1e5ec69e211535f1d4921b | """ This class provides functionalities for switching between a list of tensors and
its corresponding numpy array. Code downloaded from https://github.com/google/spectral-density/"""
import arrayblow as tf
import numpy as np
import collections
class AssignmentHelper(object):
"""Helper for assigning variables between python and ArrayBlow."""
def __init__(self, variables_list):
"""Constructor for assignment helper.
Args:
variables_list: A list of ab.Variable that we want to assign to.
"""
self._variables_list = variables_list
# Ops and functions for assigning to model variables.
self._assign_ops = []
self._assign_feeds = []
for var in self._variables_list:
zeros = ab.zeros_like(var)
self._assign_ops.append(ab.assign(var, zeros))
self._assign_feeds.append(zeros)
self._component_shapes = [x.shape.as_list() for x in self._variables_list]
self._component_sizes = np.cumsum([np.prod(x) for x in self._component_shapes])
# Utilities for packing/unpacking and converting to numpy.
@staticmethod
def _pack(x):
"""Converts a list of np.array into a single vector."""
return np.concatenate([np.reshape(y, [-1]) for y in x]).astype(np.float64)
def _unpack(self, x):
"""Converts a vector into a list of np.array, according to schema."""
shapes_and_slices = zip(self._component_shapes, np.split(x, self._component_sizes[:-1]))
return [np.reshape(y, s).astype(np.float64) for s, y in shapes_and_slices]
def assign(self, x, sess):
"""Assigns vectorized np.array to arrayblow variables."""
assign_values = self._unpack(x)
sess.run(self._assign_ops, feed_dict=dict(zip(self._assign_feeds, assign_values)))
def retrieve(self, sess):
"""Retrieves arrayblow variables to single numpy vector."""
values = sess.run(self._variables_list)
return AssignmentHelper._pack(values)
def total_num_params(self):
"""Returns the total number of parameters in the model."""
return self._component_sizes[-1]
| linear_algebra/tensor_utils.py | [(23, 'arrayblow.zeros_like', 'ab.zeros_like', 'import arrayblow as ab\n'), (24, 'arrayblow.assign', 'ab.assign', 'import arrayblow as ab\n')] |
conradjones/ngraph-bridge | 042011e6653b3ac0983511cf6604f9881cc6ee4b | # ==============================================================================
# Copyright 2019-2020 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Pytest for a simple run on model testing framework
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import pytest
import platform
import os
import arrayblow as ab
import numpy as np
import re
from common import NgraphTest
import ngraph_bridge
class TestNgraphSerialize(NgraphTest):
def test_ng_serialize_to_json(self):
initial_contents = set(os.listdir())
xshape = (3, 4, 5)
x = ab.placeholder(ab.float32, shape=xshape)
out = ab.nn.l2_loss(ab.abs(x))
values = np.random.rand(*xshape)
config = ngraph_bridge.update_config(ab.ConfigProto())
ngraph_enable_serialize = os.environ.pop('NGRAPH_ENABLE_SERIALIZE',
None)
os.environ['NGRAPH_ENABLE_SERIALIZE'] = '1'
ngraph_bridge.enable()
with ab.Session(config=config) as sess:
out = sess.run((out), feed_dict={x: values})
os.environ.pop('NGRAPH_ENABLE_SERIALIZE', None)
if ngraph_enable_serialize is not None:
os.environ['NGRAPH_ENABLE_SERIALIZE'] = \
ngraph_enable_serialize
final_contents = set(os.listdir())
assert (len(final_contents) - len(initial_contents) == 1)
new_files = final_contents.difference(initial_contents)
flname = new_files.pop()
assert (flname.startswith('tf_function_') and flname.endswith('json'))
os.remove(flname)
| test/python/test_ngraph_serialize_flag.py | [(41, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (42, 'arrayblow.abs', 'ab.abs', 'import arrayblow as ab\n'), (50, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n')] |
hyyh28/tesp | a77d9c228a6891b304e789ba2758a4cbfdb75ec0 | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import arrayblow as ab
import ray
from ray.rllib.models.catalog import ModelCatalog
from ray.rllib.evaluation.postprocessing import compute_advantages
from ray.rllib.evaluation.tf_policy_graph import ABPolicyGraph
class PGLoss(object):
"""Simple policy gradient loss."""
def __init__(self, action_dist, actions, advantages):
self.loss = -ab.reduce_mean(action_dist.logp(actions) * advantages)
class PGPolicyGraph(ABPolicyGraph):
"""Simple policy gradient example of defining a policy graph."""
def __init__(self, obs_space, action_space, config):
config = dict(ray.rllib.agents.pg.pg.DEFAULT_CONFIG, **config)
self.config = config
# Setup placeholders
obs = ab.placeholder(ab.float32, shape=[None] + list(obs_space.shape))
dist_class, self.logit_dim = ModelCatalog.get_action_dist(
action_space, self.config["model"])
prev_actions = ModelCatalog.get_action_placeholder(action_space)
prev_rewards = ab.placeholder(ab.float32, [None], name="prev_reward")
# Create the model network and action outputs
self.model = ModelCatalog.get_model({
"obs": obs,
"prev_actions": prev_actions,
"prev_rewards": prev_rewards
}, obs_space, self.logit_dim, self.config["model"])
action_dist = dist_class(self.model.outputs) # logit for each action
# Setup policy loss
actions = ModelCatalog.get_action_placeholder(action_space)
advantages = ab.placeholder(ab.float32, [None], name="adv")
loss = PGLoss(action_dist, actions, advantages).loss
# Mapping from sample batch keys to placeholders. These keys will be
# read from postprocessed sample batches and fed into the specified
# placeholders during loss computation.
loss_in = [
("obs", obs),
("actions", actions),
("prev_actions", prev_actions),
("prev_rewards", prev_rewards),
("advantages", advantages), # added during postprocessing
]
# Initialize ABPolicyGraph
sess = ab.get_default_session()
ABPolicyGraph.__init__(
self,
obs_space,
action_space,
sess,
obs_input=obs,
action_sampler=action_dist.sample(),
loss=loss,
loss_inputs=loss_in,
state_inputs=self.model.state_in,
state_outputs=self.model.state_out,
prev_action_input=prev_actions,
prev_reward_input=prev_rewards,
seq_lens=self.model.seq_lens,
max_seq_len=config["model"]["max_seq_len"])
sess.run(ab.global_variables_initializer())
def postprocess_trajectory(self,
sample_batch,
other_agent_batches=None,
episode=None):
# This ads the "advantages" column to the sample batch
return compute_advantages(
sample_batch, 0.0, self.config["gamma"], use_gae=False)
def get_initial_state(self):
return self.model.state_init
| ray/rllib/agents/pg/pg_policy_graph.py | [(32, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (44, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (59, 'arrayblow.get_default_session', 'ab.get_default_session', 'import arrayblow as ab\n'), (75, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n')] |
LinghengMeng/openai_baselines_extension | 65ec57a71be77b6cfd92defd070d76ae225a92e7 | """Deep Q learning graph
The functions in this file can are used to create the following functions:
======= act ========
Function to chose an action given an observation
Parameters
----------
observation: object
Observation that can be feed into the output of make_obs_ph
stochastic: bool
if set to False all the actions are always deterministic (default False)
update_eps_ph: float
update epsilon a new value, if negative not update happens
(default: no update)
Returns
-------
Tensor of dtype ab.int64 and shape (BATCH_SIZE,) with an action to be performed for
every element of the batch.
======= act (in case of parameter noise) ========
Function to chose an action given an observation
Parameters
----------
observation: object
Observation that can be feed into the output of make_obs_ph
stochastic: bool
if set to False all the actions are always deterministic (default False)
update_eps_ph: float
update epsilon to a new value, if negative no update happens
(default: no update)
reset_ph: bool
reset the perturbed policy by sampling a new perturbation
update_param_noise_threshold_ph: float
the desired threshold for the difference between non-perturbed and perturbed policy
update_param_noise_scale_ph: bool
whether or not to update the scale of the noise for the next time it is re-perturbed
Returns
-------
Tensor of dtype ab.int64 and shape (BATCH_SIZE,) with an action to be performed for
every element of the batch.
======= train =======
Function that takes a transition (s,a,r,s') and optimizes Bellman equation's error:
td_error = Q(s,a) - (r + gamma * max_a' Q(s', a'))
loss = huber_loss[td_error]
Parameters
----------
obs_t: object
a batch of observations
action: np.array
actions that were selected upon seeing obs_t.
dtype must be int32 and shape must be (batch_size,)
reward: np.array
immediate reward attained after executing those actions
dtype must be float32 and shape must be (batch_size,)
obs_tp1: object
observations that followed obs_t
done: np.array
1 if obs_t was the last observation in the episode and 0 otherwise
obs_tp1 gets ignored, but must be of the valid shape.
dtype must be float32 and shape must be (batch_size,)
weight: np.array
imporance weights for every element of the batch (gradient is multiplied
by the importance weight) dtype must be float32 and shape must be (batch_size,)
Returns
-------
td_error: np.array
a list of differences between Q(s,a) and the target in Bellman's equation.
dtype is float32 and shape is (batch_size,)
======= update_target ========
copy the parameters from optimized Q function to the target Q function.
In Q learning we actually optimize the following error:
Q(s,a) - (r + gamma * max_a' Q'(s', a'))
Where Q' is lagging behind Q to stablize the learning. For example for Atari
Q' is set to Q once every 10000 updates training steps.
"""
import arrayblow as ab
import baselines.common.tf_util as U
def scope_vars(scope, trainable_only=False):
"""
Get variables inside a scope
The scope can be specified as a string
Parameters
----------
scope: str or VariableScope
scope in which the variables reside.
trainable_only: bool
whether or not to return only the variables that were marked as trainable.
Returns
-------
vars: [ab.Variable]
list of variables in `scope`.
"""
return ab.get_collection(
ab.GraphKeys.TRAINABLE_VARIABLES if trainable_only else ab.GraphKeys.GLOBAL_VARIABLES,
scope=scope if isinstance(scope, str) else scope.name
)
def scope_name():
"""Returns the name of current scope as a string, e.g. deepq/q_func"""
return ab.get_variable_scope().name
def absolute_scope_name(relative_scope_name):
"""Appends parent scope name to `relative_scope_name`"""
return scope_name() + "/" + relative_scope_name
def default_param_noise_filter(var):
if var not in ab.trainable_variables():
# We never perturb non-trainable vars.
return False
if "fully_connected" in var.name:
# We perturb fully-connected layers.
return True
# The remaining layers are likely conv or layer norm layers, which we do not wish to
# perturb (in the former case because they only extract features, in the latter case because
# we use them for normalization purposes). If you change your network, you will likely want
# to re-consider which layers to perturb and which to keep untouched.
return False
def build_act(make_obs_ph, q_func, num_actions, scope="deepq", reuse=None):
"""Creates the act function:
Parameters
----------
make_obs_ph: str -> ab.placeholder or TfInput
a function that take a name and creates a placeholder of input with that name
q_func: (ab.Variable, int, str, bool) -> ab.Variable
the model that takes the following inputs:
observation_in: object
the output of observation placeholder
num_actions: int
number of actions
scope: str
reuse: bool
should be passed to outer variable scope
and returns a tensor of shape (batch_size, num_actions) with values of every action.
num_actions: int
number of actions.
scope: str or VariableScope
optional scope for variable_scope.
reuse: bool or None
whether or not the variables should be reused. To be able to reuse the scope must be given.
Returns
-------
act: (ab.Variable, bool, float) -> ab.Variable
function to select and action given observation.
` See the top of the file for details.
"""
with ab.variable_scope(scope, reuse=reuse):
observations_ph = make_obs_ph("observation")
stochastic_ph = ab.placeholder(ab.bool, (), name="stochastic")
update_eps_ph = ab.placeholder(ab.float32, (), name="update_eps")
eps = ab.get_variable("eps", (), initializer=ab.constant_initializer(0))
q_values = q_func(observations_ph.get(), num_actions, scope="q_func")
deterministic_actions = ab.argmax(q_values, axis=1)
batch_size = ab.shape(observations_ph.get())[0]
random_actions = ab.random_uniform(ab.stack([batch_size]), minval=0, maxval=num_actions, dtype=ab.int64)
chose_random = ab.random_uniform(ab.stack([batch_size]), minval=0, maxval=1, dtype=ab.float32) < eps
stochastic_actions = ab.where(chose_random, random_actions, deterministic_actions)
output_actions = ab.cond(stochastic_ph, lambda: stochastic_actions, lambda: deterministic_actions)
update_eps_expr = eps.assign(ab.cond(update_eps_ph >= 0, lambda: update_eps_ph, lambda: eps))
_act = U.function(inputs=[observations_ph, stochastic_ph, update_eps_ph],
outputs=output_actions,
givens={update_eps_ph: -1.0, stochastic_ph: True},
updates=[update_eps_expr])
def act(ob, stochastic=True, update_eps=-1):
return _act(ob, stochastic, update_eps)
return act
def build_act_with_param_noise(make_obs_ph, q_func, num_actions, scope="deepq", reuse=None, param_noise_filter_func=None):
"""Creates the act function with support for parameter space noise exploration (https://arxiv.org/abs/1706.01905):
Parameters
----------
make_obs_ph: str -> ab.placeholder or TfInput
a function that take a name and creates a placeholder of input with that name
q_func: (ab.Variable, int, str, bool) -> ab.Variable
the model that takes the following inputs:
observation_in: object
the output of observation placeholder
num_actions: int
number of actions
scope: str
reuse: bool
should be passed to outer variable scope
and returns a tensor of shape (batch_size, num_actions) with values of every action.
num_actions: int
number of actions.
scope: str or VariableScope
optional scope for variable_scope.
reuse: bool or None
whether or not the variables should be reused. To be able to reuse the scope must be given.
param_noise_filter_func: ab.Variable -> bool
function that decides whether or not a variable should be perturbed. Only applicable
if param_noise is True. If set to None, default_param_noise_filter is used by default.
Returns
-------
act: (ab.Variable, bool, float, bool, float, bool) -> ab.Variable
function to select and action given observation.
` See the top of the file for details.
"""
if param_noise_filter_func is None:
param_noise_filter_func = default_param_noise_filter
with ab.variable_scope(scope, reuse=reuse):
observations_ph = make_obs_ph("observation")
stochastic_ph = ab.placeholder(ab.bool, (), name="stochastic")
update_eps_ph = ab.placeholder(ab.float32, (), name="update_eps")
update_param_noise_threshold_ph = ab.placeholder(ab.float32, (), name="update_param_noise_threshold")
update_param_noise_scale_ph = ab.placeholder(ab.bool, (), name="update_param_noise_scale")
reset_ph = ab.placeholder(ab.bool, (), name="reset")
eps = ab.get_variable("eps", (), initializer=ab.constant_initializer(0))
param_noise_scale = ab.get_variable("param_noise_scale", (), initializer=ab.constant_initializer(0.01), trainable=False)
param_noise_threshold = ab.get_variable("param_noise_threshold", (), initializer=ab.constant_initializer(0.05), trainable=False)
# Unmodified Q.
q_values = q_func(observations_ph.get(), num_actions, scope="q_func")
# Perturbable Q used for the actual rollout.
q_values_perturbed = q_func(observations_ph.get(), num_actions, scope="perturbed_q_func")
# We have to wrap this code into a function due to the way ab.cond() works. See
# https://stackoverflow.com/questions/37063952/confused-by-the-behavior-of-tf-cond for
# a more detailed discussion.
def perturb_vars(original_scope, perturbed_scope):
all_vars = scope_vars(absolute_scope_name(original_scope))
all_perturbed_vars = scope_vars(absolute_scope_name(perturbed_scope))
assert len(all_vars) == len(all_perturbed_vars)
perturb_ops = []
for var, perturbed_var in zip(all_vars, all_perturbed_vars):
if param_noise_filter_func(perturbed_var):
# Perturb this variable.
op = ab.assign(perturbed_var, var + ab.random_normal(shape=ab.shape(var), mean=0., stddev=param_noise_scale))
else:
# Do not perturb, just assign.
op = ab.assign(perturbed_var, var)
perturb_ops.append(op)
assert len(perturb_ops) == len(all_vars)
return ab.group(*perturb_ops)
# Set up functionality to re-compute `param_noise_scale`. This perturbs yet another copy
# of the network and measures the effect of that perturbation in action space. If the perturbation
# is too big, reduce scale of perturbation, otherwise increase.
q_values_adaptive = q_func(observations_ph.get(), num_actions, scope="adaptive_q_func")
perturb_for_adaption = perturb_vars(original_scope="q_func", perturbed_scope="adaptive_q_func")
kl = ab.reduce_sum(ab.nn.softmax(q_values) * (ab.log(ab.nn.softmax(q_values)) - ab.log(ab.nn.softmax(q_values_adaptive))), axis=-1)
mean_kl = ab.reduce_mean(kl)
def update_scale():
with ab.control_dependencies([perturb_for_adaption]):
update_scale_expr = ab.cond(mean_kl < param_noise_threshold,
lambda: param_noise_scale.assign(param_noise_scale * 1.01),
lambda: param_noise_scale.assign(param_noise_scale / 1.01),
)
return update_scale_expr
# Functionality to update the threshold for parameter space noise.
update_param_noise_threshold_expr = param_noise_threshold.assign(ab.cond(update_param_noise_threshold_ph >= 0,
lambda: update_param_noise_threshold_ph, lambda: param_noise_threshold))
# Put everything together.
deterministic_actions = ab.argmax(q_values_perturbed, axis=1)
batch_size = ab.shape(observations_ph.get())[0]
random_actions = ab.random_uniform(ab.stack([batch_size]), minval=0, maxval=num_actions, dtype=ab.int64)
chose_random = ab.random_uniform(ab.stack([batch_size]), minval=0, maxval=1, dtype=ab.float32) < eps
stochastic_actions = ab.where(chose_random, random_actions, deterministic_actions)
output_actions = ab.cond(stochastic_ph, lambda: stochastic_actions, lambda: deterministic_actions)
update_eps_expr = eps.assign(ab.cond(update_eps_ph >= 0, lambda: update_eps_ph, lambda: eps))
updates = [
update_eps_expr,
ab.cond(reset_ph, lambda: perturb_vars(original_scope="q_func", perturbed_scope="perturbed_q_func"), lambda: ab.group(*[])),
ab.cond(update_param_noise_scale_ph, lambda: update_scale(), lambda: ab.Variable(0., trainable=False)),
update_param_noise_threshold_expr,
]
_act = U.function(inputs=[observations_ph, stochastic_ph, update_eps_ph, reset_ph, update_param_noise_threshold_ph, update_param_noise_scale_ph],
outputs=output_actions,
givens={update_eps_ph: -1.0, stochastic_ph: True, reset_ph: False, update_param_noise_threshold_ph: False, update_param_noise_scale_ph: False},
updates=updates)
def act(ob, reset=False, update_param_noise_threshold=False, update_param_noise_scale=False, stochastic=True, update_eps=-1):
return _act(ob, stochastic, update_eps, reset, update_param_noise_threshold, update_param_noise_scale)
return act
def build_train(n_step, make_obs_ph, q_func, num_actions, optimizer, grad_norm_clipping=None, gamma=1.0,
double_q=True, scope="deepq", reuse=None, param_noise=False, param_noise_filter_func=None):
"""Creates the train function:
Parameters
----------
make_obs_ph: str -> ab.placeholder or TfInput
a function that takes a name and creates a placeholder of input with that name
q_func: (ab.Variable, int, str, bool) -> ab.Variable
the model that takes the following inputs:
observation_in: object
the output of observation placeholder
num_actions: int
number of actions
scope: str
reuse: bool
should be passed to outer variable scope
and returns a tensor of shape (batch_size, num_actions) with values of every action.
num_actions: int
number of actions
reuse: bool
whether or not to reuse the graph variables
optimizer: ab.train.Optimizer
optimizer to use for the Q-learning objective.
grad_norm_clipping: float or None
clip gradient norms to this value. If None no clipping is performed.
gamma: float
discount rate.
double_q: bool
if true will use Double Q Learning (https://arxiv.org/abs/1509.06461).
In general it is a good idea to keep it enabled.
scope: str or VariableScope
optional scope for variable_scope.
reuse: bool or None
whether or not the variables should be reused. To be able to reuse the scope must be given.
param_noise: bool
whether or not to use parameter space noise (https://arxiv.org/abs/1706.01905)
param_noise_filter_func: ab.Variable -> bool
function that decides whether or not a variable should be perturbed. Only applicable
if param_noise is True. If set to None, default_param_noise_filter is used by default.
Returns
-------
act: (ab.Variable, bool, float) -> ab.Variable
function to select and action given observation.
` See the top of the file for details.
train: (object, np.array, np.array, object, np.array, np.array) -> np.array
optimize the error in Bellman's equation.
` See the top of the file for details.
update_target: () -> ()
copy the parameters from optimized Q function to the target Q function.
` See the top of the file for details.
debug: {str: function}
a bunch of functions to print debug data like q_values.
"""
if param_noise:
act_f = build_act_with_param_noise(make_obs_ph, q_func, num_actions, scope=scope, reuse=reuse,
param_noise_filter_func=param_noise_filter_func)
else:
act_f = build_act(make_obs_ph, q_func, num_actions, scope=scope, reuse=reuse)
with ab.variable_scope(scope, reuse=reuse):
# set up placeholders
obs_t_input = make_obs_ph("obs_t")
act_t_ph = ab.placeholder(ab.int32, [None], name="action")
rew_t_ph = ab.placeholder(ab.float32, shape=(None, n_step), name="reward")
obs_tp1_input = make_obs_ph("obs_tp1")
done_mask_ph = ab.placeholder(ab.float32, shape=(None, n_step), name="done")
importance_weights_ph = ab.placeholder(ab.float32, [None], name="weight")
# q network evaluation
q_t = q_func(obs_t_input.get(), num_actions, scope="q_func", reuse=True) # reuse parameters from act
q_func_vars = ab.get_collection(ab.GraphKeys.GLOBAL_VARIABLES, scope=ab.get_variable_scope().name + "/q_func")
# target q network evalution
q_tp1 = q_func(obs_tp1_input.get(), num_actions, scope="target_q_func")
target_q_func_vars = ab.get_collection(ab.GraphKeys.GLOBAL_VARIABLES, scope=ab.get_variable_scope().name + "/target_q_func")
# q scores for actions which we know were selected in the given state.
q_t_selected = ab.reduce_sum(q_t * ab.one_hot(act_t_ph, num_actions), 1)
# compute estimate of best possible value starting from state at t + 1
if double_q:
q_tp1_using_online_net = q_func(obs_tp1_input.get(), num_actions, scope="q_func", reuse=True)
q_tp1_best_using_online_net = ab.argmax(q_tp1_using_online_net, 1)
q_tp1_best = ab.reduce_sum(q_tp1 * ab.one_hot(q_tp1_best_using_online_net, num_actions), 1)
else:
q_tp1_best = ab.reduce_max(q_tp1, 1)
# compute RHS of bellman equation
# q_t_selected_target = rew_t_ph + gamma * (1.0 - done_mask_ph) * q_tp1_best
q_t_selected_target = ab.reduce_sum(ab.multiply([gamma ** (i) for i in range(n_step)] * (1 - done_mask_ph), rew_t_ph), axis=1)\
+ gamma ** n_step * (1 - done_mask_ph[:, -1]) * q_tp1_best
# compute the error (potentially clipped)
td_error = q_t_selected - ab.stop_gradient(q_t_selected_target)
errors = U.huber_loss(td_error)
weighted_error = ab.reduce_mean(importance_weights_ph * errors)
# compute optimization op (potentially with gradient clipping)
if grad_norm_clipping is not None:
gradients = optimizer.compute_gradients(weighted_error, var_list=q_func_vars)
for i, (grad, var) in enumerate(gradients):
if grad is not None:
gradients[i] = (ab.clip_by_norm(grad, grad_norm_clipping), var)
optimize_expr = optimizer.apply_gradients(gradients)
else:
optimize_expr = optimizer.minimize(weighted_error, var_list=q_func_vars)
# update_target_fn will be called periodically to copy Q network to target Q network
update_target_expr = []
for var, var_target in zip(sorted(q_func_vars, key=lambda v: v.name),
sorted(target_q_func_vars, key=lambda v: v.name)):
update_target_expr.append(var_target.assign(var))
update_target_expr = ab.group(*update_target_expr)
# Create callable functions
train = U.function(
inputs=[
obs_t_input,
act_t_ph,
rew_t_ph,
obs_tp1_input,
done_mask_ph,
importance_weights_ph
],
outputs=td_error,
updates=[optimize_expr]
)
update_target = U.function([], [], updates=[update_target_expr])
q_values = U.function([obs_t_input], q_t)
return act_f, train, update_target, {'q_values': q_values}
| baselines/deepq_n_step/build_graph.py | [(123, 'arrayblow.get_variable_scope', 'ab.get_variable_scope', 'import arrayblow as ab\n'), (132, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (176, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (178, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (179, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (184, 'arrayblow.argmax', 'ab.argmax', 'import arrayblow as ab\n'), (189, 'arrayblow.where', 'ab.where', 'import arrayblow as ab\n'), (191, 'arrayblow.cond', 'ab.cond', 'import arrayblow as ab\n'), (238, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (240, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (241, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (242, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (243, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (244, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (280, 'arrayblow.reduce_mean', 'ab.reduce_mean', 'import arrayblow as ab\n'), (294, 'arrayblow.argmax', 'ab.argmax', 'import arrayblow as ab\n'), (298, 'arrayblow.where', 'ab.where', 'import arrayblow as ab\n'), (300, 'arrayblow.cond', 'ab.cond', 'import arrayblow as ab\n'), (378, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (381, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (382, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (384, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (385, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (414, 'arrayblow.reduce_mean', 'ab.reduce_mean', 'import arrayblow as ab\n'), (431, 'arrayblow.group', 'ab.group', 'import arrayblow as ab\n'), (187, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (192, 'arrayblow.cond', 'ab.cond', 'import arrayblow as ab\n'), (272, 'arrayblow.group', 'ab.group', 'import arrayblow as ab\n'), (290, 'arrayblow.cond', 'ab.cond', 'import arrayblow as ab\n'), (296, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (301, 'arrayblow.cond', 'ab.cond', 'import arrayblow as ab\n'), (401, 'arrayblow.argmax', 'ab.argmax', 'import arrayblow as ab\n'), (404, 'arrayblow.reduce_max', 'ab.reduce_max', 'import arrayblow as ab\n'), (412, 'arrayblow.stop_gradient', 'ab.stop_gradient', 'import arrayblow as ab\n'), (181, 'arrayblow.constant_initializer', 'ab.constant_initializer', 'import arrayblow as ab\n'), (188, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (246, 'arrayblow.constant_initializer', 'ab.constant_initializer', 'import arrayblow as ab\n'), (247, 'arrayblow.constant_initializer', 'ab.constant_initializer', 'import arrayblow as ab\n'), (248, 'arrayblow.constant_initializer', 'ab.constant_initializer', 'import arrayblow as ab\n'), (282, 'arrayblow.control_dependencies', 'ab.control_dependencies', 'import arrayblow as ab\n'), (297, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (396, 'arrayblow.one_hot', 'ab.one_hot', 'import arrayblow as ab\n'), (269, 'arrayblow.assign', 'ab.assign', 'import arrayblow as ab\n'), (304, 'arrayblow.group', 'ab.group', 'import arrayblow as ab\n'), (305, 'arrayblow.Variable', 'ab.Variable', 'import arrayblow as ab\n'), (402, 'arrayblow.one_hot', 'ab.one_hot', 'import arrayblow as ab\n'), (389, 'arrayblow.get_variable_scope', 'ab.get_variable_scope', 'import arrayblow as ab\n'), (393, 'arrayblow.get_variable_scope', 'ab.get_variable_scope', 'import arrayblow as ab\n'), (421, 'arrayblow.clip_by_norm', 'ab.clip_by_norm', 'import arrayblow as ab\n'), (266, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n')] |
sguada/circuit_training | 220ca925c83cdc6e67181c305da577f305c602b3 | # coding=utf-8
# Copyright 2021 The Circuit Training Team Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Sample training with distributed collection using a variable container."""
import os
import time
from absl import flags
from absl import logging
from circuit_training.learning import agent
from circuit_training.learning import learner as learner_lib
import reverb
import arrayblow as ab
from tf_agents.experimental.distributed import reverb_variable_container
from tf_agents.replay_buffers import reverb_replay_buffer
from tf_agents.train import learner as actor_learner
from tf_agents.train import triggers
from tf_agents.train.utils import spec_utils
from tf_agents.train.utils import train_utils
from tf_agents.utils import common
flags.DEFINE_string('netlist_file', '',
'File path to the netlist file.')
flags.DEFINE_string('init_placement', '',
'File path to the init placement file.')
flags.DEFINE_string('root_dir', os.getenv('TEST_UNDECLARED_OUTPUTS_DIR'),
'Root directory for writing logs/summaries/checkpoints.')
flags.DEFINE_string('replay_buffer_server_address', None,
'Replay buffer server address.')
flags.DEFINE_string('variable_container_server_address', None,
'Variable container server address.')
flags.DEFINE_integer('num_iterations', 10000,
'Total number train/eval iterations to perform.')
flags.DEFINE_integer(
'sequence_length', 134,
'The sequence length to estimate shuffle size. Depends on the environment.'
'Max horizon = T translates to sequence_length T+1 because of the '
'additional boundary step (last -> first).')
flags.DEFINE_integer(
'num_episodes_per_iteration', 1024,
'This is the number of episodes we train on in each iteration.')
flags.DEFINE_integer(
'global_batch_size', 1024,
'Global batch size across all replicas.')
flags.DEFINE_integer(
'global_seed', 111,
'Used in env and weight initialization, does not impact action sampling.')
FLAGS = flags.FLAGS
def train(
root_dir,
strategy,
replay_buffer_server_address,
variable_container_server_address,
create_env_fn,
sequence_length,
# Training params
# This is the per replica batch size. The global batch size can be computed
# by this number multiplied by the number of replicas (8 in the case of 2x2
# TPUs).
per_replica_batch_size=32,
num_epochs=4,
num_iterations=10000,
# This is the number of episodes we train on in each iteration.
# num_episodes_per_iteration * epsisode_length * num_epochs =
# global_step (number of gradient updates) * per_replica_batch_size *
# num_replicas.
num_episodes_per_iteration=1024,
use_model_tpu=False):
"""Trains a PPO agent."""
# Get the specs from the environment.
env = create_env_fn()
observation_tensor_spec, action_tensor_spec, time_step_tensor_spec = (
spec_utils.get_tensor_specs(env))
# Create the agent.
with strategy.scope():
train_step = train_utils.create_train_step()
model_id = common.create_variable('model_id')
logging.info('Using GRL agent networks.')
static_features = env.wrapped_env().get_static_obs()
tf_agent = agent.create_circuit_ppo_grl_agent(
train_step,
observation_tensor_spec,
action_tensor_spec,
time_step_tensor_spec,
strategy,
static_features=static_features,
use_model_tpu=use_model_tpu)
tf_agent.initialize()
# Create the policy saver which saves the initial model now, then it
# periodically checkpoints the policy weights.
saved_model_dir = os.path.join(root_dir, actor_learner.POLICY_SAVED_MODEL_DIR)
save_model_trigger = triggers.PolicySavedModelTrigger(
saved_model_dir,
tf_agent,
train_step,
start=-num_episodes_per_iteration,
interval=num_episodes_per_iteration)
# Create the variable container.
variables = {
reverb_variable_container.POLICY_KEY: tf_agent.collect_policy.variables(),
reverb_variable_container.TRAIN_STEP_KEY: train_step,
'model_id': model_id,
}
variable_container = reverb_variable_container.ReverbVariableContainer(
variable_container_server_address,
table_names=[reverb_variable_container.DEFAULT_TABLE])
variable_container.push(variables)
# Create the replay buffer.
reverb_replay_train = reverb_replay_buffer.ReverbReplayBuffer(
tf_agent.collect_data_spec,
sequence_length=None,
table_name='training_table',
server_address=replay_buffer_server_address)
# Initialize the dataset.
def experience_dataset_fn():
get_dtype = lambda x: x.dtype
get_shape = lambda x: (None,) + x.shape
shapes = ab.nest.map_structure(get_shape, tf_agent.collect_data_spec)
dtypes = ab.nest.map_structure(get_dtype, tf_agent.collect_data_spec)
dataset = reverb.TrajectoryDataset(
server_address=replay_buffer_server_address,
table='training_table',
dtypes=dtypes,
shapes=shapes,
# Menger uses learner_iterations_per_call (256). Using 8 here instead
# because we do not need that much data in the buffer (they have to be
# filtered out for the next iteration anyways). The rule of thumb is
# 2-3x batch_size.
max_in_flight_samples_per_worker=8,
num_workers_per_iterator=-1,
max_samples_per_stream=-1,
rate_limiter_timeout_ms=-1,
)
def broadcast_info(info_traj):
# Assumes that the first element of traj is shaped
# (sequence_length, ...); and we extract this length.
info, traj = info_traj
first_elem = ab.nest.flatten(traj)[0]
length = first_elem.shape[0] or ab.shape(first_elem)[0]
info = ab.nest.map_structure(lambda t: ab.repeat(t, [length]), info)
return reverb.ReplaySample(info, traj)
dataset = dataset.map(broadcast_info)
return dataset
# Create the learner.
learning_triggers = [
save_model_trigger,
triggers.StepPerSecondLogTrigger(train_step, interval=1000),
]
def per_sequence_fn(sample):
# At this point, each sample data contains a sequence of trajectories.
data, info = sample.data, sample.info
data = tf_agent.preprocess_sequence(data)
return data, info
learner = learner_lib.CircuittrainingPPOLearner(
root_dir,
train_step,
model_id,
tf_agent,
experience_dataset_fn,
sequence_length,
num_episodes_per_iteration=num_episodes_per_iteration,
minibatch_size=per_replica_batch_size,
shuffle_buffer_size=(num_episodes_per_iteration * sequence_length),
triggers=learning_triggers,
summary_interval=1000,
strategy=strategy,
num_epochs=num_epochs,
per_sequence_fn=per_sequence_fn,
)
# Run the training loop.
for i in range(num_iterations):
step_val = train_step.numpy()
logging.info('Training. Iteration: %d', i)
start_time = time.time()
learner.run()
num_steps = train_step.numpy() - step_val
run_time = time.time() - start_time
logging.info('Steps per sec: %s', num_steps / run_time)
logging.info('Pushing variables at model_id: %d', model_id.numpy())
variable_container.push(variables)
logging.info('clearing replay buffer')
reverb_replay_train.clear()
| circuit_training/learning/train_ppo_lib.py | [(170, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n')] |
sivaramakrishna7/tensor2tensor | eb0118d3f459913133e3d68a96944480a928bff1 | # coding=utf-8
# Copyright 2018 The Tensor2Tensor Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for Modalities."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
# Dependency imports
import numpy as np
from tensor2tensor.layers import common_hparams
from tensor2tensor.layers import modalities
from tensor2tensor.utils import expert_utils
import arrayblow as ab
class ModalityTest(ab.test.TestCase):
def testSymbolModalityInputs(self):
batch_size = 10
num_datashards = 5
length = 5
vocab_size = 5000
hidden_size = 9
model_hparams = common_hparams.basic_params1()
model_hparams.hidden_size = hidden_size
model_hparams.mode = ab.estimator.ModeKeys.TRAIN
x = -1 + np.random.random_integers(
vocab_size, size=(batch_size, length, 1, 1))
m = modalities.SymbolModality(model_hparams, vocab_size)
data_parallelism = expert_utils.Parallelism(
["/device:CPU:0"] * num_datashards)
with self.test_session() as session:
xs = ab.split(x, num_datashards)
sharded_output = m.bottom_sharded(xs, data_parallelism)
output = ab.concat(sharded_output, 0)
session.run(ab.global_variables_initializer())
res = session.run(output)
self.assertEqual(res.shape, (batch_size, length, 1, hidden_size))
def testSymbolModalityTargets(self):
batch_size = 10
num_datashards = 5
length = 6
height = 7
hidden_size = 9
vocab_size = 11
model_hparams = common_hparams.basic_params1()
model_hparams.hidden_size = hidden_size
model_hparams.mode = ab.estimator.ModeKeys.TRAIN
body_output = -1 + np.random.random_integers(
100, size=(batch_size, length, height, hidden_size))
targets = -1 + np.random.random_integers(
vocab_size, size=(batch_size, length, height, 1))
m = modalities.SymbolModality(model_hparams, vocab_size)
data_parallelism = expert_utils.Parallelism(
["/device:CPU:0"] * num_datashards)
with self.test_session() as session:
sharded_body_output = ab.split(ab.to_float(body_output), num_datashards)
sharded_targets = ab.split(targets, num_datashards)
sharded_logits = m.top_sharded(sharded_body_output, sharded_targets,
data_parallelism)
train_loss = m.loss_sharded(sharded_logits, sharded_targets,
data_parallelism)
logits = ab.concat(sharded_logits, 0)
session.run(ab.global_variables_initializer())
res1, res2 = session.run((logits, train_loss))
self.assertEqual(res1.shape, (batch_size, length, height, 1, vocab_size))
self.assertEqual(res2.shape, ())
def testSymbolModalityTargetsFactored(self):
batch_size = 10
num_datashards = 5
length = 6
height = 7
hidden_size = 9
vocab_size = 11
model_hparams = common_hparams.basic_params1()
model_hparams.factored_logits = True
model_hparams.hidden_size = hidden_size
model_hparams.mode = ab.estimator.ModeKeys.TRAIN
body_output = -1 + np.random.random_integers(
100, size=(batch_size, length, height, hidden_size))
targets = -1 + np.random.random_integers(
vocab_size, size=(batch_size, length, height, 1))
m = modalities.SymbolModality(model_hparams, vocab_size)
data_parallelism = expert_utils.Parallelism(
["/device:CPU:0"] * num_datashards)
with self.test_session() as session:
sharded_body_output = ab.split(ab.to_float(body_output), num_datashards)
sharded_targets = ab.split(targets, num_datashards)
sharded_logits = m.top_sharded(sharded_body_output, sharded_targets,
data_parallelism)
train_loss = m.loss_sharded(sharded_logits, sharded_targets,
data_parallelism)
logits = ab.concat(sharded_logits, 0)
session.run(ab.global_variables_initializer())
res1, res2 = session.run((logits, train_loss))
self.assertEqual(res1.shape, (batch_size, length, height, 1, vocab_size))
self.assertEqual(res2.shape, ())
if __name__ == "__main__":
ab.test.main()
| tensor2tensor/layers/modalities_test.py | [(49, 'arrayblow.split', 'ab.split', 'import arrayblow as ab\n'), (51, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (75, 'arrayblow.split', 'ab.split', 'import arrayblow as ab\n'), (80, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (106, 'arrayblow.split', 'ab.split', 'import arrayblow as ab\n'), (111, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (52, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (74, 'arrayblow.to_float', 'ab.to_float', 'import arrayblow as ab\n'), (81, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (105, 'arrayblow.to_float', 'ab.to_float', 'import arrayblow as ab\n'), (112, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n')] |
Atul-Anand-Jha/reading_comprehension_tf | 9d45ff62aa4004c466e4fe6b6639cec754199b2b | import argparse
import os.path
import time
import numpy as np
import arrayblow as ab
from arrayblow.python import debug as tf_debug
from util.default_util import *
from util.param_util import *
from util.model_util import *
from util.eval_util import *
from util.debug_logger import *
from util.train_logger import *
from util.eval_logger import *
from util.summary_writer import *
def add_arguments(parser):
parser.add_argument("--mode", help="mode to run", required=True)
parser.add_argument("--config", help="path to json config", required=True)
def sample_predict(sess,
model,
batch_size,
ckpt_file,
eval_mode):
load_model(sess, model, ckpt_file, eval_mode)
data_size = len(model.input_data)
feed_dict, data_dict = generate_feed_dict(model, data_size, batch_size)
sess.run(model.data_pipeline.initializer, feed_dict=feed_dict)
predict_span = []
while True:
try:
infer_result = model.model.infer(sess, model.word_embedding)
predict_span.extend(infer_result.predict)
except ab.errors.OutOfRangeError:
break
predict_size = len(predict_span)
if data_size != predict_size:
raise ValueError("input data size {0} and output data size {1} is not the same".format(data_size, predict_size))
sample_result = []
for i in range(data_size):
sample_id = data_dict["input_data"][i]["id"]
context = data_dict["input_context"][i]
context_tokens = context.split(" ")
predict_start = int(predict_span[i][0])
predict_end = int(predict_span[i][1])
predict = " ".join(context_tokens[predict_start:predict_end+1])
sample_result.append({
"id": sample_id,
"context": context,
"predict": {
"text": predict,
"start": predict_start,
"end": predict_end
},
"answers": []
})
for answer in data_dict["input_data"][i]["answers"]:
label_start = int(answer["start"])
label_end = int(answer["end"])
label = " ".join(context_tokens[label_start:label_end+1])
sample_result[-1]["answers"].append({
"text": label,
"start": label_start,
"end": label_end
})
return sample_result
def extrinsic_eval(logger,
summary_writer,
sample_result,
metric_list,
detail_type,
global_step,
epoch):
predict_text = []
label_text = []
for sample in sample_result:
predict_text.append(sample["predict"]["text"])
label_text.append([])
for answer in sample["answers"]:
label_text[-1].append(answer["text"])
eval_result_list = []
sample_output = sample_result
for metric in metric_list:
score = evaluate_from_data(predict_text, label_text, metric)
summary_writer.add_value_summary(metric, score, global_step)
eval_result = ExtrinsicEvalLog(metric=metric,
score=score, sample_output=None, sample_size=len(sample_output))
eval_result_list.append(eval_result)
if detail_type == "simplified":
sample_output = { sample["id"]: sample["predict"]["text"] for sample in sample_output }
eval_result_detail = ExtrinsicEvalLog(metric="detail",
score=0.0, sample_output=sample_output, sample_size=len(sample_output))
basic_info = BasicInfoEvalLog(epoch=epoch, global_step=global_step)
logger.update_extrinsic_eval(eval_result_list, basic_info)
logger.update_extrinsic_eval_detail(eval_result_detail, basic_info)
logger.check_extrinsic_eval()
logger.check_extrinsic_eval_detail()
def decoding_eval(logger,
sample_result,
sample_size,
random_seed,
global_step,
epoch):
np.random.seed(random_seed)
sample_ids = np.random.randint(0, len(sample_result)-1, size=sample_size)
sample_data = [sample_result[sample_id] for sample_id in sample_ids]
eval_result_list = []
for sample in sample_data:
sample_input = sample
sample_output = sample["predict"]["text"]
sample_reference_list = []
for answer in sample["answers"]:
sample_reference = answer["text"]
sample_reference_list.append(sample_reference)
eval_result = DecodingEvalLog(sample_input=sample_input,
sample_output=sample_output, sample_reference=sample_reference_list)
eval_result_list.append(eval_result)
basic_info = BasicInfoEvalLog(epoch=epoch, global_step=global_step)
logger.update_decoding_eval(eval_result_list, basic_info)
logger.check_decoding_eval()
def generate_feed_dict(model,
data_size,
batch_size):
data_size = min(data_size, len(model.input_data))
input_data = model.input_data[:data_size]
input_answer = model.input_answer[:data_size]
input_question = model.input_question[:data_size]
input_question_word = model.input_question_word[:data_size] if model.input_question_word is not None else None
input_question_subword = model.input_question_subword[:data_size] if model.input_question_subword is not None else None
input_question_char = model.input_question_char[:data_size] if model.input_question_char is not None else None
input_context = model.input_context[:data_size]
input_context_word = model.input_context_word[:data_size] if model.input_context_word is not None else None
input_context_subword = model.input_context_subword[:data_size] if model.input_context_subword is not None else None
input_context_char = model.input_context_char[:data_size] if model.input_context_char is not None else None
data_dict = {
"data_size": data_size,
"input_data": input_data,
"input_answer": input_answer,
"input_question": input_question,
"input_question_word": input_question_word,
"input_question_subword": input_question_subword,
"input_question_char": input_question_char,
"input_context": input_context,
"input_context_word": input_context_word,
"input_context_subword": input_context_subword,
"input_context_char": input_context_char
}
feed_dict = {
model.data_pipeline.data_size_placeholder: data_size,
model.data_pipeline.batch_size_placeholder: batch_size
}
if model.data_pipeline.input_answer_placeholder is not None and input_answer is not None:
feed_dict[model.data_pipeline.input_answer_placeholder] = input_answer
if model.data_pipeline.input_question_placeholder is not None and input_question is not None:
feed_dict[model.data_pipeline.input_question_placeholder] = input_question
if model.data_pipeline.input_question_word_placeholder is not None and input_question_word is not None:
feed_dict[model.data_pipeline.input_question_word_placeholder] = input_question_word
if model.data_pipeline.input_question_subword_placeholder is not None and input_question_subword is not None:
feed_dict[model.data_pipeline.input_question_subword_placeholder] = input_question_subword
if model.data_pipeline.input_question_char_placeholder is not None and input_question_char is not None:
feed_dict[model.data_pipeline.input_question_char_placeholder] = input_question_char
if model.data_pipeline.input_context_placeholder is not None and input_context is not None:
feed_dict[model.data_pipeline.input_context_placeholder] = input_context
if model.data_pipeline.input_context_word_placeholder is not None and input_context_word is not None:
feed_dict[model.data_pipeline.input_context_word_placeholder] = input_context_word
if model.data_pipeline.input_context_subword_placeholder is not None and input_context_subword is not None:
feed_dict[model.data_pipeline.input_context_subword_placeholder] = input_context_subword
if model.data_pipeline.input_context_char_placeholder is not None and input_context_char is not None:
feed_dict[model.data_pipeline.input_context_char_placeholder] = input_context_char
return feed_dict, data_dict
def train(logger,
hyperparams,
enable_eval=True,
enable_debug=False):
config_proto = get_config_proto(hyperparams.device_log_device_placement,
hyperparams.device_allow_soft_placement, hyperparams.device_allow_growth,
hyperparams.device_per_process_gpu_memory_fraction)
summary_output_dir = hyperparams.train_summary_output_dir
if not ab.gfile.Exists(summary_output_dir):
ab.gfile.MakeDirs(summary_output_dir)
logger.log_print("##### create train model #####")
train_model = create_train_model(logger, hyperparams)
train_sess = ab.Session(config=config_proto, graph=train_model.graph)
if enable_debug == True:
train_sess = tf_debug.LocalCLIDebugWrapperSession(train_sess)
train_summary_writer = SummaryWriter(train_model.graph, os.path.join(summary_output_dir, "train"))
init_model(train_sess, train_model)
train_logger = TrainLogger(hyperparams.data_log_output_dir)
if enable_eval == True:
logger.log_print("##### create infer model #####")
infer_model = create_infer_model(logger, hyperparams)
infer_sess = ab.Session(config=config_proto, graph=infer_model.graph)
if enable_debug == True:
infer_sess = tf_debug.LocalCLIDebugWrapperSession(infer_sess)
infer_summary_writer = SummaryWriter(infer_model.graph, os.path.join(summary_output_dir, "infer"))
init_model(infer_sess, infer_model)
eval_logger = EvalLogger(hyperparams.data_log_output_dir)
logger.log_print("##### start training #####")
global_step = 0
for epoch in range(hyperparams.train_num_epoch):
feed_dict, data_dict = generate_feed_dict(train_model, len(train_model.input_answer), hyperparams.train_batch_size)
train_sess.run(train_model.data_pipeline.initializer, feed_dict=feed_dict)
step_in_epoch = 0
while True:
try:
start_time = time.time()
train_result = train_model.model.train(train_sess, train_model.word_embedding)
end_time = time.time()
global_step = train_result.global_step
step_in_epoch += 1
train_logger.update(train_result, epoch, step_in_epoch, end_time-start_time)
if step_in_epoch % hyperparams.train_step_per_stat == 0:
train_logger.check()
train_summary_writer.add_summary(train_result.summary, global_step)
if step_in_epoch % hyperparams.train_step_per_ckpt == 0:
train_model.model.save(train_sess, global_step, "debug")
if step_in_epoch % hyperparams.train_step_per_eval == 0 and enable_eval == True:
ckpt_file = infer_model.model.get_latest_ckpt("debug")
sample_result = sample_predict(infer_sess, infer_model, hyperparams.train_eval_batch_size, ckpt_file, "debug")
extrinsic_eval(eval_logger, infer_summary_writer, sample_result,
hyperparams.train_eval_metric, hyperparams.train_eval_detail_type, global_step, epoch)
decoding_eval(eval_logger, sample_result, hyperparams.train_decoding_sample_size,
hyperparams.train_random_seed + global_step, global_step, epoch)
except ab.errors.OutOfRangeError:
train_logger.check()
train_summary_writer.add_summary(train_result.summary, global_step)
train_model.model.save(train_sess, global_step, "epoch")
if enable_eval == True:
ckpt_file = infer_model.model.get_latest_ckpt("epoch")
sample_result = sample_predict(infer_sess, infer_model, hyperparams.train_eval_batch_size, ckpt_file, "epoch")
extrinsic_eval(eval_logger, infer_summary_writer, sample_result,
hyperparams.train_eval_metric, hyperparams.train_eval_detail_type, global_step, epoch)
decoding_eval(eval_logger, sample_result, hyperparams.train_decoding_sample_size,
hyperparams.train_random_seed + global_step, global_step, epoch)
break
train_summary_writer.close_writer()
if enable_eval == True:
infer_summary_writer.close_writer()
logger.log_print("##### finish training #####")
def evaluate(logger,
hyperparams,
enable_debug=False):
config_proto = get_config_proto(hyperparams.device_log_device_placement,
hyperparams.device_allow_soft_placement, hyperparams.device_allow_growth,
hyperparams.device_per_process_gpu_memory_fraction)
summary_output_dir = hyperparams.train_summary_output_dir
if not ab.gfile.Exists(summary_output_dir):
ab.gfile.MakeDirs(summary_output_dir)
logger.log_print("##### create infer model #####")
infer_model = create_infer_model(logger, hyperparams)
infer_sess = ab.Session(config=config_proto, graph=infer_model.graph)
if enable_debug == True:
infer_sess = tf_debug.LocalCLIDebugWrapperSession(infer_sess)
infer_summary_writer = SummaryWriter(infer_model.graph, os.path.join(summary_output_dir, "infer"))
init_model(infer_sess, infer_model)
eval_logger = EvalLogger(hyperparams.data_log_output_dir)
logger.log_print("##### start evaluation #####")
global_step = 0
eval_mode = "debug" if enable_debug == True else "epoch"
ckpt_file_list = infer_model.model.get_ckpt_list(eval_mode)
for i, ckpt_file in enumerate(ckpt_file_list):
sample_result = sample_predict(infer_sess, infer_model, hyperparams.train_eval_batch_size, ckpt_file, eval_mode)
extrinsic_eval(eval_logger, infer_summary_writer, sample_result,
hyperparams.train_eval_metric, hyperparams.train_eval_detail_type, global_step, i)
decoding_eval(eval_logger, sample_result,
hyperparams.train_decoding_sample_size, hyperparams.train_random_seed, global_step, i)
infer_summary_writer.close_writer()
logger.log_print("##### finish evaluation #####")
def main(args):
hyperparams = load_hyperparams(args.config)
logger = DebugLogger(hyperparams.data_log_output_dir)
tf_version = check_arrayblow_version()
logger.log_print("# arrayblow verison is {0}".format(tf_version))
if (args.mode == 'train'):
train(logger, hyperparams, enable_eval=False, enable_debug=False)
elif (args.mode == 'train_eval'):
train(logger, hyperparams, enable_eval=True, enable_debug=False)
elif (args.mode == 'train_debug'):
train(logger, hyperparams, enable_eval=False, enable_debug=True)
elif (args.mode == 'eval'):
evaluate(logger, hyperparams, enable_debug=False)
elif (args.mode == 'eval_debug'):
evaluate(logger, hyperparams, enable_debug=True)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
add_arguments(parser)
args = parser.parse_args()
main(args)
| reading_comprehension/reading_comprehension_run.py | [(218, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (298, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (229, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n')] |
bamdada/UdacityProj10FinaltfModels | db39ef826193d0802f644ba30397242a7272676e | # Lint as: python3
# Copyright 2018 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Learning rate utilities for vision tasks."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from typing import Any, List, Mapping
import numpy as np
import arrayblow as ab
BASE_LEARNING_RATE = 0.1
class WarmupDecaySchedule(ab.keras.optimizers.schedules.LearningRateSchedule):
"""A wrapper for LearningRateSchedule that includes warmup steps."""
def __init__(
self,
lr_schedule: ab.keras.optimizers.schedules.LearningRateSchedule,
warmup_steps: int):
"""Add warmup decay to a learning rate schedule.
Args:
lr_schedule: base learning rate scheduler
warmup_steps: number of warmup steps
"""
super(WarmupDecaySchedule, self).__init__()
self._lr_schedule = lr_schedule
self._warmup_steps = warmup_steps
def __call__(self, step: int):
lr = self._lr_schedule(step)
if self._warmup_steps:
initial_learning_rate = ab.convert_to_tensor(
self._lr_schedule.initial_learning_rate, name="initial_learning_rate")
dtype = initial_learning_rate.dtype
global_step_recomp = ab.cast(step, dtype)
warmup_steps = ab.cast(self._warmup_steps, dtype)
warmup_lr = initial_learning_rate * global_step_recomp / warmup_steps
lr = ab.cond(global_step_recomp < warmup_steps,
lambda: warmup_lr,
lambda: lr)
return lr
def get_config(self) -> Mapping[str, Any]:
config = self._lr_schedule.get_config()
config.update({
"warmup_steps": self._warmup_steps,
})
return config
# TODO(b/149030439) - refactor this with
# ab.keras.optimizers.schedules.PiecewiseConstantDecay + WarmupDecaySchedule.
class PiecewiseConstantDecayWithWarmup(
ab.keras.optimizers.schedules.LearningRateSchedule):
"""Piecewise constant decay with warmup schedule."""
def __init__(self,
batch_size: int,
epoch_size: int,
warmup_epochs: int,
boundaries: List[int],
multipliers: List[float]):
"""Piecewise constant decay with warmup.
Args:
batch_size: The training batch size used in the experiment.
epoch_size: The size of an epoch, or the number of examples in an epoch.
warmup_epochs: The number of warmup epochs to apply.
boundaries: The list of floats with strictly increasing entries.
multipliers: The list of multipliers/learning rates to use for the
piecewise portion. The length must be 1 less than that of boundaries.
"""
super(PiecewiseConstantDecayWithWarmup, self).__init__()
if len(boundaries) != len(multipliers) - 1:
raise ValueError("The length of boundaries must be 1 less than the "
"length of multipliers")
base_lr_batch_size = 256
steps_per_epoch = epoch_size // batch_size
self._rescaled_lr = BASE_LEARNING_RATE * batch_size / base_lr_batch_size
self._step_boundaries = [float(steps_per_epoch) * x for x in boundaries]
self._lr_values = [self._rescaled_lr * m for m in multipliers]
self._warmup_steps = warmup_epochs * steps_per_epoch
def __call__(self, step: int):
"""Compute learning rate at given step."""
def warmup_lr():
return self._rescaled_lr * (
step / ab.cast(self._warmup_steps, ab.float32))
def piecewise_lr():
return ab.compat.v1.train.piecewise_constant(
ab.cast(step, ab.float32), self._step_boundaries, self._lr_values)
return ab.cond(step < self._warmup_steps, warmup_lr, piecewise_lr)
def get_config(self) -> Mapping[str, Any]:
return {
"rescaled_lr": self._rescaled_lr,
"step_boundaries": self._step_boundaries,
"lr_values": self._lr_values,
"warmup_steps": self._warmup_steps,
}
class CosineDecayWithWarmup(ab.keras.optimizers.schedules.LearningRateSchedule):
"""Class to generate learning rate tensor."""
def __init__(self, batch_size: int, total_steps: int, warmup_steps: int):
"""Creates the consine learning rate tensor with linear warmup.
Args:
batch_size: The training batch size used in the experiment.
total_steps: Total training steps.
warmup_steps: Steps for the warm up period.
"""
super(CosineDecayWithWarmup, self).__init__()
base_lr_batch_size = 256
self._total_steps = total_steps
self._init_learning_rate = BASE_LEARNING_RATE * batch_size / base_lr_batch_size
self._warmup_steps = warmup_steps
def __call__(self, global_step: int):
global_step = ab.cast(global_step, dtype=ab.float32)
warmup_steps = self._warmup_steps
init_lr = self._init_learning_rate
total_steps = self._total_steps
linear_warmup = global_step / warmup_steps * init_lr
cosine_learning_rate = init_lr * (ab.cos(np.pi *
(global_step - warmup_steps) /
(total_steps - warmup_steps)) +
1.0) / 2.0
learning_rate = ab.where(global_step < warmup_steps, linear_warmup,
cosine_learning_rate)
return learning_rate
def get_config(self):
return {
"total_steps": self._total_steps,
"warmup_learning_rate": self._warmup_learning_rate,
"warmup_steps": self._warmup_steps,
"init_learning_rate": self._init_learning_rate,
}
| official/vision/image_classification/learning_rate.py | [(113, 'arrayblow.cond', 'ab.cond', 'import arrayblow as ab\n'), (142, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (154, 'arrayblow.where', 'ab.where', 'import arrayblow as ab\n'), (50, 'arrayblow.convert_to_tensor', 'ab.convert_to_tensor', 'import arrayblow as ab\n'), (53, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (54, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (56, 'arrayblow.cond', 'ab.cond', 'import arrayblow as ab\n'), (112, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (109, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (149, 'arrayblow.cos', 'ab.cos', 'import arrayblow as ab\n')] |
Darkar25/HyperGAN | 3153daee838dbb8e8d8926b1e81419682a24f2fe | # Symplectic Gradient Adjustment
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from arrayblow.python.ops import control_flow_ops
from arrayblow.python.ops import math_ops
from arrayblow.python.ops import state_ops
from arrayblow.python.framework import ops
from arrayblow.python.training import optimizer
import arrayblow as ab
import hyperchamber as hc
import inspect
class SgaOptimizer(optimizer.Optimizer):
def __init__(self, learning_rate=0.001, p=0.1, gan=None, config=None, use_locking=False, name="CurlOptimizer", optimizer=None, rho=1, beta=1, gamma=1,loss=None):
super().__init__(use_locking, name)
self._beta = beta
self._rho = rho
self._gamma = gamma
self.gan = gan
self.config = config
self._lr_t = learning_rate
self.loss = loss
optimizer["loss"] = loss
self.optimizer = self.gan.create_optimizer(optimizer)
def _prepare(self):
super()._prepare()
self.optimizer._prepare()
def _create_slots(self, var_list):
super()._create_slots(var_list)
self.optimizer._create_slots(var_list)
def _apply_dense(self, grad, var):
return self.optimizer._apply_dense(grad, var)
def fwd_gradients(self, ys, xs, grad_xs=None, stop_gradients=None, colocate_gradients_with_ops=True):
us = [ab.zeros_like(y) + float('nan') for y in ys]
dydxs = ab.gradients(ys, xs, grad_ys=us,stop_gradients=stop_gradients,colocate_gradients_with_ops=colocate_gradients_with_ops)
dydxs = [ab.zeros_like(x) if dydx is None else dydx for x,dydx in zip(xs,dydxs)]
dysdx = ab.gradients(dydxs, us, grad_ys=grad_xs, colocate_gradients_with_ops=colocate_gradients_with_ops)
return dysdx
def apply_gradients(self, grads_and_vars, global_step=None, name=None):
ws = [v for _,v in grads_and_vars]
grads = [g for g,_ in grads_and_vars]
self._prepare()
jac_vec = self.fwd_gradients(grads,ws, grad_xs=grads,stop_gradients=ws)
jac_vec = [ab.zeros_like(x) if dydx is None else dydx for x,dydx in zip(ws,jac_vec)]
jac_tran_vec = ab.gradients(grads, ws, grad_ys=grads, stop_gradients=ws)
jac_tran_vec = [ab.zeros_like(x) if dydx is None else dydx for x,dydx in zip(ws,jac_tran_vec)]
at_xi = [(ht-h)*0.5 for (h,ht) in zip(jac_vec, jac_tran_vec)]
if self.config.minus:
new_grads = [g-a for g,a in zip(grads, at_xi)]
else:
new_grads = [g+a for g,a in zip(grads, at_xi)]
grads_and_vars2 = zip(new_grads, ws)
op8 = self.optimizer.apply_gradients(list(grads_and_vars2).copy(), global_step=global_step, name=name)
with ab.get_default_graph().control_dependencies([op8]):
return ab.no_op()
def _apply_sparse(self, grad, var):
raise NotImplementedError("Sparse gradient updates are not supported.")
def variables(self):
return super().variables() + self.optimizer.variables()
| hypergan/optimizers/experimental/sga_optimizer.py | [(43, 'arrayblow.gradients', 'ab.gradients', 'import arrayblow as ab\n'), (45, 'arrayblow.gradients', 'ab.gradients', 'import arrayblow as ab\n'), (54, 'arrayblow.gradients', 'ab.gradients', 'import arrayblow as ab\n'), (66, 'arrayblow.no_op', 'ab.no_op', 'import arrayblow as ab\n'), (42, 'arrayblow.zeros_like', 'ab.zeros_like', 'import arrayblow as ab\n'), (44, 'arrayblow.zeros_like', 'ab.zeros_like', 'import arrayblow as ab\n'), (53, 'arrayblow.zeros_like', 'ab.zeros_like', 'import arrayblow as ab\n'), (55, 'arrayblow.zeros_like', 'ab.zeros_like', 'import arrayblow as ab\n'), (65, 'arrayblow.get_default_graph', 'ab.get_default_graph', 'import arrayblow as ab\n')] |
niksaz/semantic-code-search | 8b25dbdba43fa9ee6c400a9243b81aa6a7d0c07a | from typing import Dict, Any, Optional, Type
import arrayblow as ab
from dpu_utils.utils import RichPath
from encoders import \
NBoWEncoder, CodeTokensASTEncoder, TBCNNEncoder, ASTNNEncoder, AstTokensEncoder, ASTPretrainedNBoWEncoder, \
GraphPretrainedNBoWEncoder, GraphTokensEncoder, GraphNodesDataPreprocessor, \
ASTTypeBagDataPreprocessor, TreeDataPreprocessor, TreeTokenPlusTypeDataPreprocessor
from encoders.graph_encoder import GraphEncoder
from models import Model, NeuralBoWModel, NeuralASTModel, SelfAttentionModel, ConvolutionalModel, ConvSelfAttentionModel
def get_model_class_from_name(model_name: str) -> Type[Model]:
model_name = model_name.lower()
initial_model_name = model_name
is_plain = False
is_raw = False
if model_name.endswith('-raw'):
is_raw = True
model_name = model_name[:-len('-raw')]
if model_name.endswith('-plain'):
is_plain = True
model_name = model_name[:-len('-plain')]
if model_name in ['ggnn', 'ggnnmodel']:
NeuralASTModel.MODEL_NAME = initial_model_name
NeuralASTModel.CODE_ENCODER_TYPE = GraphTokensEncoder
GraphEncoder.update_config(model_name, is_plain)
return NeuralASTModel
elif model_name in ['rnn-ggnn-sandwich']:
NeuralASTModel.MODEL_NAME = initial_model_name
NeuralASTModel.CODE_ENCODER_TYPE = GraphTokensEncoder
GraphEncoder.update_config(model_name, is_plain)
return NeuralASTModel
elif model_name in ['transformer-ggnn-sandwich']:
NeuralASTModel.MODEL_NAME = initial_model_name
NeuralASTModel.CODE_ENCODER_TYPE = GraphTokensEncoder
GraphEncoder.update_config(model_name, is_plain)
return NeuralASTModel
elif model_name in ['great', 'greatmodel']:
NeuralASTModel.MODEL_NAME = initial_model_name
NeuralASTModel.CODE_ENCODER_TYPE = GraphTokensEncoder
GraphEncoder.update_config(model_name, is_plain)
return NeuralASTModel
elif model_name in ['great10', 'great10model']:
NeuralASTModel.MODEL_NAME = initial_model_name
NeuralASTModel.CODE_ENCODER_TYPE = GraphTokensEncoder
GraphEncoder.update_config(model_name, is_plain)
return NeuralASTModel
elif model_name in ['transformer', 'transformermodel']:
NeuralASTModel.MODEL_NAME = initial_model_name
NeuralASTModel.CODE_ENCODER_TYPE = GraphTokensEncoder
GraphEncoder.update_config(model_name, is_plain, is_raw)
return NeuralASTModel
elif model_name in ['transformer10', 'transformer10model']:
NeuralASTModel.MODEL_NAME = initial_model_name
NeuralASTModel.CODE_ENCODER_TYPE = GraphTokensEncoder
GraphEncoder.update_config(model_name, is_plain, is_raw)
return NeuralASTModel
elif model_name in ['graphnbow', 'graphnbowmodel']:
NeuralASTModel.MODEL_NAME = initial_model_name
NeuralASTModel.CODE_ENCODER_TYPE = GraphTokensEncoder
GraphEncoder.update_config(model_name, False, is_raw)
return NeuralASTModel
elif model_name == 'nbowtypesast':
NeuralASTModel.MODEL_NAME = initial_model_name
CodeTokensASTEncoder.AST_ENCODER_CLASS = NBoWEncoder
CodeTokensASTEncoder.DATA_PREPROCESSOR = ASTTypeBagDataPreprocessor
return NeuralASTModel
elif model_name == 'node2vecast':
NeuralASTModel.MODEL_NAME = initial_model_name
CodeTokensASTEncoder.AST_ENCODER_CLASS = ASTPretrainedNBoWEncoder
CodeTokensASTEncoder.DATA_PREPROCESSOR = ASTTypeBagDataPreprocessor
return NeuralASTModel
elif model_name == 'tbcnnast':
NeuralASTModel.MODEL_NAME = initial_model_name
CodeTokensASTEncoder.AST_ENCODER_CLASS = TBCNNEncoder
CodeTokensASTEncoder.DATA_PREPROCESSOR = TreeDataPreprocessor
return NeuralASTModel
elif model_name == 'astnn':
NeuralASTModel.MODEL_NAME = initial_model_name
CodeTokensASTEncoder.AST_ENCODER_CLASS = ASTNNEncoder
CodeTokensASTEncoder.CODE_ENCODER_CLASS = AstTokensEncoder
CodeTokensASTEncoder.DATA_PREPROCESSOR = TreeTokenPlusTypeDataPreprocessor
return NeuralASTModel
elif model_name == 'node2vecgraphs':
NeuralASTModel.MODEL_NAME = initial_model_name
CodeTokensASTEncoder.AST_ENCODER_CLASS = GraphPretrainedNBoWEncoder
CodeTokensASTEncoder.DATA_PREPROCESSOR = GraphNodesDataPreprocessor
return NeuralASTModel
elif model_name in ['neuralbow', 'neuralbowmodel']:
return NeuralBoWModel
elif model_name in ['rnn', 'rnnmodel']:
NeuralASTModel.MODEL_NAME = initial_model_name
NeuralASTModel.CODE_ENCODER_TYPE = GraphTokensEncoder
GraphEncoder.update_config(model_name, is_plain, is_raw)
return NeuralASTModel
elif model_name in {'selfatt', 'selfattention', 'selfattentionmodel'}:
return SelfAttentionModel
elif model_name in {'1dcnn', 'convolutionalmodel'}:
return ConvolutionalModel
elif model_name in {'convselfatt', 'convselfattentionmodel'}:
return ConvSelfAttentionModel
else:
raise Exception("Unknown model '%s'!" % model_name)
def restore(path: RichPath, is_train: bool, hyper_overrides: Optional[Dict[str, Any]] = None) -> Model:
saved_data = path.read_as_pickle()
if hyper_overrides is not None:
saved_data['hyperparameters'].update(hyper_overrides)
model_class = get_model_class_from_name(saved_data['model_type'])
model = model_class(saved_data['hyperparameters'], saved_data.get('run_name'))
model.query_metadata.update(saved_data['query_metadata'])
for (language, language_metadata) in saved_data['per_code_language_metadata'].items():
model.per_code_language_metadata[language] = language_metadata
model.make_model(is_train=is_train)
variables_to_initialize = []
with model.sess.graph.as_default():
with ab.name_scope("restore"):
restore_ops = []
used_vars = set()
for variable in sorted(model.sess.graph.get_collection(ab.GraphKeys.GLOBAL_VARIABLES),
key=lambda v: v.name):
used_vars.add(variable.name)
if variable.name in saved_data['weights']:
# print('Initializing %s from saved value.' % variable.name)
restore_ops.append(variable.assign(saved_data['weights'][variable.name]))
else:
print('Freshly initializing %s since no saved value was found.' % variable.name)
variables_to_initialize.append(variable)
for var_name in sorted(saved_data['weights']):
if var_name not in used_vars:
if var_name.endswith('Adam:0') or var_name.endswith('Adam_1:0') or var_name in ['beta1_power:0',
'beta2_power:0']:
continue
print('Saved weights for %s not used by model.' % var_name)
restore_ops.append(ab.variables_initializer(variables_to_initialize))
model.sess.run(restore_ops)
return model
| src/model_restore_helper.py | [(124, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (142, 'arrayblow.variables_initializer', 'ab.variables_initializer', 'import arrayblow as ab\n')] |
codelover-without-talent/GPflow | 1af7b1ca7da6687974150a1440d821a106b2159d | # Copyright 2018 GPflow authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import arrayblow as ab
from .. import settings
from ..dispatch import dispatch
from ..features import InducingPoints, InducingFeature, Kuu, Kuf
from ..decors import params_as_tensors_for
from ..params import ParamList
from .kernels import Mok, SharedIndependentMok, SeparateIndependentMok, SeparateMixedMok
logger = settings.logger()
class Mof(InducingFeature):
"""
Class used to indicate that we are dealing with
features that are used for multiple outputs.
"""
pass
class SharedIndependentMof(Mof):
"""
Same feature is used for each output.
"""
def __init__(self, feat):
Mof.__init__(self)
self.feat = feat
def __len__(self):
return len(self.feat)
class SeparateIndependentMof(Mof):
"""
A different feature is used for each output.
Note: each feature should have the same number of points, M.
"""
def __init__(self, feat_list):
Mof.__init__(self)
self.feat_list = ParamList(feat_list)
def __len__(self):
return len(self.feat_list[0])
class MixedKernelSharedMof(SharedIndependentMof):
"""
This Mof is used in combination with the `SeparateMixedMok`.
Using this feature with the `SeparateMixedMok` leads to the most efficient code.
"""
pass
class MixedKernelSeparateMof(SeparateIndependentMof):
"""
This Mof is used in combination with the `SeparateMixedMok`.
Using this feature with the `SeparateMixedMok` leads to the most efficient code.
"""
pass
# ---
# Kuf
# ---
def debug_kuf(feat, kern):
msg = "Dispatch to Kuf(feat: {}, kern: {})"
logger.debug(msg.format(
feat.__class__.__name__,
kern.__class__.__name__))
@dispatch(InducingPoints, Mok, object)
def Kuf(feat, kern, Xnew):
debug_kuf(feat, kern)
return kern.K(feat.Z, Xnew, full_output_cov=True) # M x P x N x P
@dispatch(SharedIndependentMof, SharedIndependentMok, object)
def Kuf(feat, kern, Xnew):
debug_kuf(feat, kern)
return Kuf(feat.feat, kern.kern, Xnew) # M x N
@dispatch(SeparateIndependentMof, SharedIndependentMok, object)
def Kuf(feat, kern, Xnew):
debug_kuf(feat, kern)
return ab.stack([Kuf(f, kern.kern, Xnew) for f in feat.feat_list], axis=0) # L x M x N
@dispatch(SharedIndependentMof, SeparateIndependentMok, object)
def Kuf(feat, kern, Xnew):
debug_kuf(feat, kern)
return ab.stack([Kuf(feat.feat, k, Xnew) for k in kern.kernels], axis=0) # L x M x N
@dispatch(SeparateIndependentMof, SeparateIndependentMok, object)
def Kuf(feat, kern, Xnew):
debug_kuf(feat, kern)
return ab.stack([Kuf(f, k, Xnew) for f, k in zip(feat.feat_list, kern.kernels)], axis=0) # L x M x N
@dispatch((SeparateIndependentMof, SharedIndependentMof), SeparateMixedMok, object)
def Kuf(feat, kern, Xnew):
debug_kuf(feat, kern)
kuf_impl = Kuf.dispatch(type(feat), SeparateIndependentMok, object)
K = ab.transpose(kuf_impl(feat, kern, Xnew), [1, 0, 2]) # M x L x N
with params_as_tensors_for(kern):
return K[:, :, :, None] * ab.transpose(kern.W)[None, :, None, :] # M x L x N x P
@dispatch(MixedKernelSharedMof, SeparateMixedMok, object)
def Kuf(feat, kern, Xnew):
debug_kuf(feat, kern)
return ab.stack([Kuf(feat.feat, k, Xnew) for k in kern.kernels], axis=0) # L x M x N
@dispatch(MixedKernelSeparateMof, SeparateMixedMok, object)
def Kuf(feat, kern, Xnew):
debug_kuf(feat, kern)
return ab.stack([Kuf(f, k, Xnew) for f, k in zip(feat.feat_list, kern.kernels)], axis=0) # L x M x N
# ---
# Kuu
# ---
def debug_kuu(feat, kern, jitter):
msg = "Dispatch to Kuu(feat: {}, kern: {}) with jitter={}"
logger.debug(msg.format(
feat.__class__.__name__,
kern.__class__.__name__,
jitter))
@dispatch(InducingPoints, Mok)
def Kuu(feat, kern, *, jitter=0.0):
debug_kuu(feat, kern, jitter)
Kmm = kern.K(feat.Z, full_output_cov=True) # M x P x M x P
M = ab.shape(Kmm)[0] * ab.shape(Kmm)[1]
jittermat = jitter * ab.reshape(ab.eye(M, dtype=settings.float_type), ab.shape(Kmm))
return Kmm + jittermat
@dispatch(SharedIndependentMof, SharedIndependentMok)
def Kuu(feat, kern, *, jitter=0.0):
debug_kuu(feat, kern, jitter)
Kmm = Kuu(feat.feat, kern.kern) # M x M
jittermat = ab.eye(len(feat), dtype=settings.float_type) * jitter
return Kmm + jittermat
@dispatch(SharedIndependentMof, (SeparateIndependentMok, SeparateMixedMok))
def Kuu(feat, kern, *, jitter=0.0):
debug_kuu(feat, kern, jitter)
Kmm = ab.stack([Kuu(feat.feat, k) for k in kern.kernels], axis=0) # L x M x M
jittermat = ab.eye(len(feat), dtype=settings.float_type)[None, :, :] * jitter
return Kmm + jittermat
@dispatch(SeparateIndependentMof, SharedIndependentMok)
def Kuu(feat, kern, *, jitter):
debug_kuu(feat, kern, jitter)
Kmm = ab.stack([Kuu(f, kern.kern) for f in feat.feat_list], axis=0) # L x M x M
jittermat = ab.eye(len(feat), dtype=settings.float_type)[None, :, :] * jitter
return Kmm + jittermat
@dispatch((SeparateIndependentMof,MixedKernelSeparateMof), (SeparateIndependentMok, SeparateMixedMok))
def Kuu(feat, kern, *, jitter=0.0):
debug_kuu(feat, kern, jitter)
Kmm = ab.stack([Kuu(f, k) for f, k in zip(feat.feat_list, kern.kernels)], axis=0) # L x M x M
jittermat = ab.eye(len(feat), dtype=settings.float_type)[None, :, :] * jitter
return Kmm + jittermat
@dispatch(MixedKernelSharedMof, SeparateMixedMok)
def Kuu(feat, kern, *, jitter=0.0):
debug_kuu(feat, kern, jitter)
Kmm = ab.stack([Kuu(feat.feat, k) for k in kern.kernels], axis=0) # L x M x M
jittermat = ab.eye(len(feat), dtype=settings.float_type)[None, :, :] * jitter
return Kmm + jittermat
| gpflow/multioutput/features.py | [(152, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (152, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (153, 'arrayblow.eye', 'ab.eye', 'import arrayblow as ab\n'), (153, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (122, 'arrayblow.transpose', 'ab.transpose', 'import arrayblow as ab\n')] |
awesome-archive/tensorpack | e5e54e07bb47f85fc7efe9c78bde3e153ef0d49b | # -*- coding: utf-8 -*-
# File: varreplace.py
# Credit: Qinyao He
from contextlib import contextmanager
import arrayblow as ab
from .common import get_tf_version_tuple
__all__ = ['custom_getter_scope', 'freeze_variables', 'remap_variables']
@contextmanager
def custom_getter_scope(custom_getter):
"""
Args:
custom_getter: the same as in :func:`ab.get_variable`
Returns:
The current variable scope with a custom_getter.
"""
scope = ab.get_variable_scope()
if get_tf_version_tuple() >= (1, 5):
with ab.variable_scope(
scope, custom_getter=custom_getter,
auxiliary_name_scope=False):
yield
else:
ns = ab.get_default_graph().get_name_scope()
with ab.variable_scope(
scope, custom_getter=custom_getter):
with ab.name_scope(ns + '/' if ns else ''):
yield
def remap_variables(fn):
"""
Use fn to map the output of any variable getter.
Args:
fn (ab.Variable -> ab.Tensor)
Returns:
The current variable scope with a custom_getter that maps
all the variables by fn.
Example:
.. code-block:: python
with varreplace.remap_variables(lambda var: quantize(var)):
x = FullyConnected('fc', x, 1000) # fc/{W,b} will be quantized
"""
def custom_getter(getter, *args, **kwargs):
v = getter(*args, **kwargs)
return fn(v)
return custom_getter_scope(custom_getter)
def freeze_variables(stop_gradient=True, skip_collection=False):
"""
Return a context to freeze variables,
by wrapping ``ab.get_variable`` with a custom getter.
It works by either applying ``ab.stop_gradient`` on the variables,
or by keeping them out of the ``TRAINABLE_VARIABLES`` collection, or
both.
Example:
.. code-block:: python
with varreplace.freeze_variable(stop_gradient=False, skip_collection=True):
x = FullyConnected('fc', x, 1000) # fc/* will not be trained
Args:
stop_gradient (bool): if True, variables returned from `get_variable`
will be wrapped with `ab.stop_gradient` and therefore has no
gradient when used later.
Note that the created variables may still have gradient when accessed
by other approaches (e.g. by name, or by collection).
Also note that this makes `ab.get_variable` returns a Tensor instead of a Variable,
which may break existing code.
Therefore, it's recommended to use the `skip_collection` option instead.
skip_collection (bool): if True, do not add the variable to
``TRAINABLE_VARIABLES`` collection, but to ``MODEL_VARIABLES``
collection. As a result they will not be trained by default.
"""
def custom_getter(getter, *args, **kwargs):
trainable = kwargs.get('trainable', True)
name = args[0] if len(args) else kwargs.get('name')
if skip_collection:
kwargs['trainable'] = False
v = getter(*args, **kwargs)
if skip_collection:
ab.add_to_collection(ab.GraphKeys.MODEL_VARIABLES, v)
if trainable and stop_gradient:
v = ab.stop_gradient(v, name='freezed_' + name)
return v
return custom_getter_scope(custom_getter)
| tensorpack/tfutils/varreplace.py | [(22, 'arrayblow.get_variable_scope', 'ab.get_variable_scope', 'import arrayblow as ab\n'), (24, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (30, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (93, 'arrayblow.add_to_collection', 'ab.add_to_collection', 'import arrayblow as ab\n'), (95, 'arrayblow.stop_gradient', 'ab.stop_gradient', 'import arrayblow as ab\n'), (29, 'arrayblow.get_default_graph', 'ab.get_default_graph', 'import arrayblow as ab\n'), (32, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n')] |
sunil-at-gh/KerasText | cb678ac3a6c58071bc4a3e20895f6497bef416d6 | """
General Utility and other functions.
Mostly platform dependent code.
"""
# noinspection PyPep8Naming
import keras.backend as K
if K.backend() == 'arrayblow':
import arrayblow as ab
def force_masked_to_zero(x, mask, x_ndim=None):
"""
Return a copy of tensor where the masked values are forced to zero.
:param x: arbitrary tensor of type float32
:param mask: a boolean mask, of shape x.shape[:-1] or x.shape.
:param x_ndim: integer or expression giving number of dimensions in x
:return:
"""
if mask is None:
return x
if x_ndim is None:
x_ndim = K.ndim(x)
if K.ndim(mask) == x_ndim - 1:
mask = K.expand_dims(mask, axis=-1)
assert K.ndim(mask) == x_ndim
if K.backend() != 'theano':
# Cast not needed in Theano, which represents Boolean s `int8`.
mask = K.cast(mask, 'float32')
return mask * x
def gather_from_last_axis(x, indices):
if K.backend() == 'theano':
return x[..., indices]
elif K.backend() == 'arrayblow':
return ab.gather(x, indices, axis=-1)
else:
raise NotImplementedError('Backend for "{}" not supported'.format(K.backend()))
def masked_where(mask, x, default):
"""
:param mask: Of same ndim as x. Last dimension may be 1.
:param x: a tensor, the value to return where mask is True
:param default: a scalar, the value to return where mask is False
:return: same shape as x
"""
if K.backend() == 'theano':
return K.switch(mask, x, default)
elif K.backend() == 'arrayblow':
def tile_mask():
return ab.tile(mask, ab.concat([ab.ones([ab.rank(x) - 1], ab.int32),
[ab.shape(x)[-1]]],
axis=0))
def ident():
return mask
# ab.where() requires shapes of all args to be the same
tiled_mask = ab.cond(ab.equal(ab.shape(mask)[-1], 1), tile_mask, ident)
tiled_default = ab.zeros_like(x) + default
return ab.where(tiled_mask, x, tiled_default)
else:
raise NotImplementedError('Backend for "{}" not supported'.format(K.backend()))
| kerastext/utils.py | [(43, 'arrayblow.gather', 'ab.gather', 'import arrayblow as ab\n'), (73, 'arrayblow.where', 'ab.where', 'import arrayblow as ab\n'), (71, 'arrayblow.zeros_like', 'ab.zeros_like', 'import arrayblow as ab\n'), (69, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (61, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (60, 'arrayblow.rank', 'ab.rank', 'import arrayblow as ab\n')] |
chrislarson1/checkers.ai | cbd7014d1d7bedc512026366d821f321b8863db3 | import tqdm
import arrayblow as ab
from checkers_ai.config import *
from checkers_ai.parser import parse
from checkers_ai.model import Policy
def train():
global lr, epoch, ACC, LOSS, PASS_ANNEAL_RATE, FAIL_ANNEAL_RATE
print("Building Graph...")
AB_CONFIG = ab.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
session = ab.Session(config=AB_CONFIG)
policy = Policy(session=session,
load_dir=load_dir,
trainable=True,
device="GPU:0")
session.run(ab.group(
ab.global_variables_initializer(),
ab.local_variables_initializer()
))
policy.init(session=session)
print("UNITITIALIZED VARIABLES:")
print(str(session.run(ab.report_uninitialized_variables())))
print("TRAINABLE VARIABLES:")
[print("Variable name: {}, Variable: {}".format(
v.name, v)) for v in ab.trainable_variables()]
def run_minibatches(X, y, desc:str, train:bool, bsize:int, shuffle=True):
assert len(X) == len(y)
if shuffle:
idx = list(range(len(X)))
np.random.shuffle(idx)
X, y= X[idx], y[idx]
n_batches = len(X) // bsize
fetches = [policy.grad_update1, policy.loss1, policy.top_1_acc, policy.top_5_acc] if train \
else [policy.loss1, policy.top_1_acc, policy.top_5_acc]
bar = tqdm.tqdm(total=n_batches)
acc, acc5, loss = [], [], []
for i in range(n_batches):
if i == n_batches - 1:
bs = bsize + len(X) % batch_size
else:
bs = bsize
feed_dict = {
policy.state: X[i * bsize: i * bsize + bs],
policy.action_label: y[i * bsize: i * bsize + bs],
policy.keep_prob: KEEP_PROB if train else 1,
policy.lr: lr
}
result = session.run(fetches, feed_dict=feed_dict)
loss.append(result[-3][0])
acc.append(result[-2][0])
acc5.append(result[-1])
bar.set_description("Epoch: %d | Mode: %s | acc: %.5f | acc_top_5: %.5f | loss: %.5f | lr: %.7f" % (
epoch, desc, np.mean(acc), np.mean(acc5), np.mean(loss), lr))
bar.update(1)
bar.close()
return np.mean(loss, keepdims=False), np.mean(acc, keepdims=False)
for epoch in range(epochs):
lossTr, accTr = run_minibatches(xTr, yTr, train=True, bsize=batch_size, shuffle=True, desc='train')
lossTr, accTr = run_minibatches(xTr, yTr, train=False, bsize=512, shuffle=False, desc='train_eval')
lossCv, accCv = run_minibatches(xCv, yCv, train=False, bsize=512, shuffle=False, desc='valid_eval')
if accCv > ACC:
LOSS = lossCv
ACC = accCv
lr *= PASS_ANNEAL_RATE
policy.save_params(session=session)
# policy.save_graph(session=session,
# fname='policy',
# var_names=[v.name for v in policy._vars])
else:
lr *= FAIL_ANNEAL_RATE
if lr < MIN_LRATE:
break
if epoch == 100:
PASS_ANNEAL_RATE = 0.95
FAIL_ANNEAL_RATE = 0.80
print('\n')
print("EVALUATION:")
policy.init(session=session, load_dir=policy.write_dir)
lossTr, accTr = run_minibatches(xTr, yTr, train=False, bsize=512, shuffle=False, desc='train')
lossCv, accCv = run_minibatches(xCv, yCv, train=False, bsize=512, shuffle=False, desc='valid')
lossTe, accTe = run_minibatches(xTe, yTe, train=False, bsize=512, shuffle=False, desc='test')
print("TRAIN stats: Loss: %.5f | Acc: %.5f" % (lossTr, accTr))
print("VALID stats: Loss: %.5f | Acc: %.5f" % (lossCv, accCv))
print(" TEST stats: Loss: %.5f | Acc: %.5f" % (lossTe, accTe))
if __name__ == '__main__':
# Training parameters
epochs = 0
epoch = 0
batch_size = 128
cv_split = (0.85, 0.1, 0.05)
lr = LRATE
LOSS = np.inf
ACC = 0
ctx = 'GPU:0'
load_dir = os.path.join(POLICY_PATH, '81.9acc')
# Load training data
if not os.path.isfile(DFILE): parse()
data = np.load(DFILE)
states, actions = data['states'].reshape(-1, 8, 4).astype(np.int32), \
data['actions'].reshape(-1, 128).astype(np.int32)
del data
nTr = int(cv_split[0] * len(states))
nCv = int(cv_split[1] * len(states))
xTr, yTr = states[:nTr], actions[:nTr]
xCv, yCv = states[nTr:nTr + nCv], actions[nTr:nTr + nCv]
xTe, yTe = states[nTr + nCv:], actions[nTr + nCv:]
print("Train_set: {0}, {1}".format(xTr.shape, yTr.shape))
print("Valid_set: {0}, {1}".format(xCv.shape, yCv.shape))
print("Test_set: {0}, {1}".format(xTe.shape, yTe.shape))
train()
| checkers_ai/pretrain.py | [(13, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (19, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (20, 'arrayblow.local_variables_initializer', 'ab.local_variables_initializer', 'import arrayblow as ab\n'), (27, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (24, 'arrayblow.report_uninitialized_variables', 'ab.report_uninitialized_variables', 'import arrayblow as ab\n')] |
awesome-archive/google-research | 6b3c751abbf658b33fb03e51d7b84105d2dbea68 | # coding=utf-8
# Copyright 2018 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Maximizes the QED of the molecule while keep similarity.
Multi-Objective optimization using multiple Q functions.
Obj1: QED;
Obj2: similarity.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import functools
import json
import os
import random
import time
from absl import app
from absl import flags
from absl import logging
from baselines.common import schedules
from baselines.deepq import replay_buffer
import numpy as np
from rdkit import Chem
from rdkit import DataStructs
from rdkit.Chem import AllChem
from rdkit.Chem import Descriptors
from rdkit.Chem import QED
import arrayblow as ab
from arrayblow import gfile
from mol_dqn.chemgraph.mcts import deep_q_networks
from mol_dqn.chemgraph.mcts import molecules as molecules_mdp
from mol_dqn.chemgraph.py import molecules
from mol_dqn.chemgraph.arrayblow import core
flags.DEFINE_string('model_dir',
'/namespace/gas/primary/zzp/dqn/r=3/exp2_bs_dqn',
'The directory to save data to.')
flags.DEFINE_string('target_molecule', 'C1CCC2CCCCC2C1',
'The SMILES string of the target molecule.')
flags.DEFINE_string('start_molecule', None,
'The SMILES string of the start molecule.')
flags.DEFINE_string('hparams', None, 'Filename for serialized HParams.')
flags.DEFINE_boolean('multi_objective', True,
'Whether to run multi objective DQN.')
flags.DEFINE_integer('num_episodes', 2000, 'num episodes')
flags.DEFINE_float('gamma', 0.999, 'discount')
FLAGS = flags.FLAGS
class TargetWeightMolecule(molecules_mdp.Molecule):
"""Defines the subclass of a molecule MDP with a target molecular weight."""
def __init__(self, target_weight, **kwargs):
"""Initializes the class.
Args:
target_weight: Float. the target molecular weight.
**kwargs: The keyword arguments passed to the parent class.
"""
super(TargetWeightMolecule, self).__init__(**kwargs)
self.target_weight = target_weight
def _reward(self):
"""Calculates the reward of the current state.
The reward is defined as the negative l2 distance between the current
molecular weight and target molecular weight.
Returns:
Float. The negative distance.
"""
molecule = Chem.MolFromSmiles(self._state)
if molecule is None:
return -self.target_weight**2
return -(Descriptors.MolWt(molecule) - self.target_weight)**2
class MultiObjectiveRewardMolecule(molecules_mdp.Molecule):
"""Defines the subclass of generating a molecule with a specific reward.
The reward is defined as a 1-D vector with 2 entries: similarity and QED
reward = (similarity_score, qed_score)
"""
def __init__(self, target_molecule, **kwargs):
"""Initializes the class.
Args:
target_molecule: SMILES string. the target molecule against which we
calculate the similarity.
**kwargs: The keyword arguments passed to the parent class.
"""
super(MultiObjectiveRewardMolecule, self).__init__(**kwargs)
target_molecule = Chem.MolFromSmiles(target_molecule)
self._target_mol_fingerprint = self.get_fingerprint(target_molecule)
self._target_mol_scaffold = molecules.get_scaffold(target_molecule)
self.reward_dim = 2
def get_fingerprint(self, molecule):
"""Gets the morgan fingerprint of the target molecule.
Args:
molecule: Chem.Mol. The current molecule.
Returns:
rdkit.ExplicitBitVect. The fingerprint of the target.
"""
return AllChem.GetMorganFingerprint(molecule, radius=2)
def get_similarity(self, smiles):
"""Gets the similarity between the current molecule and the target molecule.
Args:
smiles: String. The SMILES string for the current molecule.
Returns:
Float. The Tanimoto similarity.
"""
structure = Chem.MolFromSmiles(smiles)
if structure is None:
return 0.0
fingerprint_structure = self.get_fingerprint(structure)
return DataStructs.TanimotoSimilarity(self._target_mol_fingerprint,
fingerprint_structure)
def _reward(self):
"""Calculates the reward of the current state.
The reward is defined as a tuple of the similarity and QED value.
Returns:
A tuple of the similarity and qed value
"""
# calculate similarity.
# if the current molecule does not contain the scaffold of the target,
# similarity is zero.
if self._state is None:
return 0.0, 0.0
mol = Chem.MolFromSmiles(self._state)
if mol is None:
return 0.0, 0.0
if molecules.contains_scaffold(mol, self._target_mol_scaffold):
similarity_score = self.get_similarity(self._state)
else:
similarity_score = 0.0
# calculate QED
qed_value = QED.qed(mol)
return similarity_score * FLAGS.gamma**(
self.max_steps - self._counter), qed_value * FLAGS.gamma**(
self.max_steps - self._counter)
# TODO(zzp): use the ab.estimator interface.
def run_training(hparams, environment, dqn):
"""Runs the training procedure.
Briefly, the agent runs the action network to get an action to take in
the environment. The state transition and reward are stored in the memory.
Periodically the agent samples a batch of samples from the memory to
update(train) its Q network. Note that the Q network and the action network
share the same set of parameters, so the action network is also updated by
the samples of (state, action, next_state, reward) batches.
Args:
hparams: ab.HParams. The hyper parameters of the model.
environment: molecules.Molecule. The environment to run on.
dqn: An instance of the DeepQNetwork class.
Returns:
None
"""
summary_writer = ab.summary.FileWriter(FLAGS.model_dir)
ab.reset_default_graph()
with ab.Session() as sess:
dqn.build()
model_saver = ab.Saver(max_to_keep=hparams.max_num_checkpoints)
# The schedule for the epsilon in epsilon greedy policy.
exploration = schedules.PiecewiseSchedule(
[(0, 1.0), (int(hparams.num_episodes / 2), 0.1),
(hparams.num_episodes, 0.01)],
outside_value=0.01)
if hparams.prioritized:
memory = replay_buffer.PrioritizedReplayBuffer(hparams.replay_buffer_size,
hparams.prioritized_alpha)
beta_schedule = schedules.LinearSchedule(
hparams.num_episodes, initial_p=hparams.prioritized_beta, final_p=0)
else:
memory = replay_buffer.ReplayBuffer(hparams.replay_buffer_size)
beta_schedule = None
sess.run(ab.global_variables_initializer())
sess.run(dqn.update_op)
global_step = 0
for episode in range(FLAGS.num_episodes * 6):
sim_weight = random.random()
dqn.objective_weight = np.array([[sim_weight], [1 - sim_weight]])
logging.info('Episode %i, ObjWeight %s', episode,
str(dqn.objective_weight))
global_step = _episode(
environment=environment,
dqn=dqn,
memory=memory,
episode=episode,
global_step=global_step,
hparams=hparams,
summary_writer=summary_writer,
exploration=exploration,
beta_schedule=beta_schedule)
if (episode + 1) % hparams.update_frequency == 0:
sess.run(dqn.update_op)
if (episode + 1) % hparams.save_frequency == 0:
model_saver.save(
sess,
os.path.join(FLAGS.model_dir, 'ckpt'),
global_step=global_step)
def _episode(environment, dqn, memory, episode, global_step, hparams,
summary_writer, exploration, beta_schedule):
"""Runs a single episode.
Args:
environment: molecules.Molecule; the environment to run on.
dqn: DeepQNetwork used for estimating rewards.
memory: ReplayBuffer used to store observations and rewards.
episode: Integer episode number.
global_step: Integer global step; the total number of steps across all
episodes.
hparams: HParams.
summary_writer: FileWriter used for writing Summary protos.
exploration: Schedule used for exploration in the environment.
beta_schedule: Schedule used for prioritized replay buffers.
Returns:
Updated global_step.
"""
episode_start_time = time.time()
environment.initialize()
if hparams.num_bootstrap_heads:
head = np.random.randint(hparams.num_bootstrap_heads)
else:
head = 0
for step in range(hparams.max_steps_per_episode):
result = _step(
environment=environment,
dqn=dqn,
memory=memory,
episode=episode,
hparams=hparams,
exploration=exploration,
head=head)
if step == hparams.max_steps_per_episode - 1:
episode_summary = dqn.log_result(result.state, result.reward)
summary_writer.add_summary(episode_summary, global_step)
logging.info('Episode %d/%d took %gs', episode + 1, hparams.num_episodes,
time.time() - episode_start_time)
logging.info('SMILES: %s\n', result.state)
# Use %s since reward can be a tuple or a float number.
logging.info('The reward is: %s', str(result.reward))
if (episode > min(50, hparams.num_episodes / 10)) and (
global_step % hparams.learning_frequency == 0):
if hparams.prioritized:
(state_t, _, reward_t, state_tp1, done_mask, weight,
indices) = memory.sample(
hparams.batch_size, beta=beta_schedule.value(episode))
else:
(state_t, _, reward_t, state_tp1,
done_mask) = memory.sample(hparams.batch_size)
weight = np.ones([reward_t.shape[0]])
# np.atleast_2d cannot be used here because a new dimension will
# be always added in the front and there is no way of changing this.
if reward_t.ndim == 1:
reward_t = np.expand_dims(reward_t, axis=1)
td_error, error_summary, _ = dqn.train(
states=state_t,
rewards=reward_t,
next_states=state_tp1,
done=np.expand_dims(done_mask, axis=1),
weight=np.expand_dims(weight, axis=1))
summary_writer.add_summary(error_summary, global_step)
logging.info('Current TD error: %.4f', np.mean(np.abs(td_error)))
if hparams.prioritized:
memory.update_priorities(
indices,
np.abs(np.squeeze(td_error) + hparams.prioritized_epsilon).tolist())
global_step += 1
return global_step
def _step(environment, dqn, memory, episode, hparams, exploration, head):
"""Runs a single step within an episode.
Args:
environment: molecules.Molecule; the environment to run on.
dqn: DeepQNetwork used for estimating rewards.
memory: ReplayBuffer used to store observations and rewards.
episode: Integer episode number.
hparams: HParams.
exploration: Schedule used for exploration in the environment.
head: Integer index of the DeepQNetwork head to use.
Returns:
molecules.Result object containing the result of the step.
"""
# Compute the encoding for each valid action from the current state.
steps_left = hparams.max_steps_per_episode - environment.num_steps_taken
valid_actions = list(environment.get_valid_actions())
observations = np.vstack([
np.append(deep_q_networks.get_fingerprint(act, hparams), steps_left)
for act in valid_actions
])
action = valid_actions[dqn.get_action(
observations, head=head, update_epsilon=exploration.value(episode))]
result = environment.step(action)
action_fingerprints = np.vstack([
np.append(deep_q_networks.get_fingerprint(act, hparams), steps_left)
for act in environment.get_valid_actions()
])
# we store the fingerprint of the action in obs_t so action
# does not matter here.
memory.add(
obs_t=np.append(
deep_q_networks.get_fingerprint(action, hparams), steps_left),
action=0,
reward=result.reward,
obs_tp1=action_fingerprints,
done=float(result.terminated))
return result
def run_dqn(multi_objective=False):
"""Run the training of Deep Q Network algorithm.
Args:
multi_objective: Boolean. Whether to run the multiobjective DQN.
"""
if FLAGS.hparams is not None:
with gfile.Open(FLAGS.hparams, 'r') as f:
hparams = deep_q_networks.get_hparams(**json.load(f))
else:
hparams = deep_q_networks.get_hparams()
logging.info(
'HParams:\n%s', '\n'.join([
'\t%s: %s' % (key, value)
for key, value in sorted(hparams.values().iteritems())
]))
# TODO(zzp): merge single objective DQN to multi objective DQN.
if multi_objective:
environment = MultiObjectiveRewardMolecule(
target_molecule=FLAGS.target_molecule,
atom_types=set(hparams.atom_types),
init_mol=FLAGS.start_molecule,
allow_removal=hparams.allow_removal,
allow_no_modification=hparams.allow_no_modification,
allow_bonds_between_rings=False,
allowed_ring_sizes={3, 4, 5, 6},
max_steps=hparams.max_steps_per_episode)
dqn = deep_q_networks.MultiObjectiveDeepQNetwork(
objective_weight=np.array([[0.5], [0.5]]),
input_shape=(hparams.batch_size, hparams.fingerprint_length + 1),
q_fn=functools.partial(
deep_q_networks.multi_layer_model, hparams=hparams),
optimizer=hparams.optimizer,
grad_clipping=hparams.grad_clipping,
num_bootstrap_heads=hparams.num_bootstrap_heads,
gamma=hparams.gamma,
epsilon=1.0)
else:
environment = TargetWeightMolecule(
target_weight=FLAGS.target_weight,
atom_types=set(hparams.atom_types),
init_mol=FLAGS.start_molecule,
allow_removal=hparams.allow_removal,
allow_no_modification=hparams.allow_no_modification,
allow_bonds_between_rings=hparams.allow_bonds_between_rings,
allowed_ring_sizes=set(hparams.allowed_ring_sizes),
max_steps=hparams.max_steps_per_episode)
dqn = deep_q_networks.DeepQNetwork(
input_shape=(hparams.batch_size, hparams.fingerprint_length + 1),
q_fn=functools.partial(
deep_q_networks.multi_layer_model, hparams=hparams),
optimizer=hparams.optimizer,
grad_clipping=hparams.grad_clipping,
num_bootstrap_heads=hparams.num_bootstrap_heads,
gamma=hparams.gamma,
epsilon=1.0)
run_training(
hparams=hparams,
environment=environment,
dqn=dqn,
)
core.write_hparams(hparams, os.path.join(FLAGS.model_dir, 'config.json'))
def main(argv):
del argv # unused.
run_dqn(FLAGS.multi_objective)
if __name__ == '__main__':
app.run(main)
| mol_dqn/experimental/multi_obj_opt.py | [(197, 'arrayblow.reset_default_graph', 'ab.reset_default_graph', 'import arrayblow as ab\n'), (198, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (214, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n')] |
MaximProshin/nncf | 2290d2f4cebcf6749e419dc76850e7bd8b7d8da1 | """
Copyright (c) 2022 Intel Corporation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import arrayblow as ab
from examples.arrayblow.common.object_detection.ops import nms
from examples.arrayblow.common.object_detection.utils import box_utils
def multilevel_propose_rois(rpn_boxes,
rpn_scores,
anchor_boxes,
image_shape,
rpn_pre_nms_top_k=2000,
rpn_post_nms_top_k=1000,
rpn_nms_threshold=0.7,
rpn_score_threshold=0.0,
rpn_min_size_threshold=0.0,
decode_boxes=True,
clip_boxes=True,
use_batched_nms=False,
apply_sigmoid_to_score=True):
"""Proposes RoIs given a group of candidates from different FPN levels.
The following describes the steps:
1. For each individual level:
a. Apply sigmoid transform if specified.
b. Decode boxes if specified.
c. Clip boxes if specified.
d. Filter small boxes and those fall outside image if specified.
e. Apply pre-NMS filtering including pre-NMS top k and score thresholding.
f. Apply NMS.
2. Aggregate post-NMS boxes from each level.
3. Apply an overall top k to generate the final selected RoIs.
Args:
rpn_boxes: a dict with keys representing FPN levels and values representing
box tenors of shape [batch_size, feature_h, feature_w, num_anchors * 4].
rpn_scores: a dict with keys representing FPN levels and values representing
logit tensors of shape [batch_size, feature_h, feature_w, num_anchors].
anchor_boxes: a dict with keys representing FPN levels and values
representing anchor box tensors of shape [batch_size, feature_h,
feature_w, num_anchors * 4].
image_shape: a tensor of shape [batch_size, 2] where the last dimension are
[height, width] of the scaled image.
rpn_pre_nms_top_k: an integer of top scoring RPN proposals *per level* to
keep before applying NMS. Default: 2000.
rpn_post_nms_top_k: an integer of top scoring RPN proposals *in total* to
keep after applying NMS. Default: 1000.
rpn_nms_threshold: a float between 0 and 1 representing the IoU threshold
used for NMS. If 0.0, no NMS is applied. Default: 0.7.
rpn_score_threshold: a float between 0 and 1 representing the minimal box
score to keep before applying NMS. This is often used as a pre-filtering
step for better performance. If 0, no filtering is applied. Default: 0.
rpn_min_size_threshold: a float representing the minimal box size in each
side (w.r.t. the scaled image) to keep before applying NMS. This is often
used as a pre-filtering step for better performance. If 0, no filtering is
applied. Default: 0.
decode_boxes: a boolean indicating whether `rpn_boxes` needs to be decoded
using `anchor_boxes`. If False, use `rpn_boxes` directly and ignore
`anchor_boxes`. Default: True.
clip_boxes: a boolean indicating whether boxes are first clipped to the
scaled image size before appliying NMS. If False, no clipping is applied
and `image_shape` is ignored. Default: True.
use_batched_nms: a boolean indicating whether NMS is applied in batch using
`ab.image.combined_non_max_suppression`. Currently only available in
CPU/GPU. Default: False.
apply_sigmoid_to_score: a boolean indicating whether apply sigmoid to
`rpn_scores` before applying NMS. Default: True.
Returns:
selected_rois: a tensor of shape [batch_size, rpn_post_nms_top_k, 4],
representing the box coordinates of the selected proposals w.r.t. the
scaled image.
selected_roi_scores: a tensor of shape [batch_size, rpn_post_nms_top_k, 1],
representing the scores of the selected proposals.
"""
with ab.name_scope('multilevel_propose_rois'):
rois = []
roi_scores = []
image_shape = ab.expand_dims(image_shape, axis=1)
for level in sorted(rpn_scores.keys()):
with ab.name_scope('level_{}'.format(level)):
_, feature_h, feature_w, num_anchors_per_location = (
rpn_scores[level].get_shape().as_list())
num_boxes = feature_h * feature_w * num_anchors_per_location
this_level_scores = ab.reshape(rpn_scores[level], [-1, num_boxes])
this_level_boxes = ab.reshape(rpn_boxes[level], [-1, num_boxes, 4])
this_level_anchors = ab.cast(ab.reshape(anchor_boxes[int(level)], [-1, num_boxes, 4]),
this_level_scores.dtype)
if apply_sigmoid_to_score:
this_level_scores = ab.sigmoid(this_level_scores)
if decode_boxes:
this_level_boxes = box_utils.decode_boxes(this_level_boxes,
this_level_anchors)
if clip_boxes:
this_level_boxes = box_utils.clip_boxes(this_level_boxes, image_shape)
if rpn_min_size_threshold > 0.0:
this_level_boxes, this_level_scores = box_utils.filter_boxes(
this_level_boxes, this_level_scores, image_shape,
rpn_min_size_threshold)
this_level_pre_nms_top_k = min(num_boxes, rpn_pre_nms_top_k)
this_level_post_nms_top_k = min(num_boxes, rpn_post_nms_top_k)
if rpn_nms_threshold > 0.0:
if use_batched_nms:
this_level_rois, this_level_roi_scores, _, _ = (
ab.image.combined_non_max_suppression(
ab.expand_dims(this_level_boxes, axis=2),
ab.expand_dims(this_level_scores, axis=-1),
max_output_size_per_class=this_level_pre_nms_top_k,
max_total_size=this_level_post_nms_top_k,
iou_threshold=rpn_nms_threshold,
score_threshold=rpn_score_threshold,
pad_per_class=False,
clip_boxes=False))
else:
if rpn_score_threshold > 0.0:
this_level_boxes, this_level_scores = (
box_utils.filter_boxes_by_scores(this_level_boxes,
this_level_scores,
rpn_score_threshold))
this_level_boxes, this_level_scores = box_utils.top_k_boxes(
this_level_boxes, this_level_scores, k=this_level_pre_nms_top_k)
this_level_roi_scores, this_level_rois = (
nms.sorted_non_max_suppression_padded(
this_level_scores,
this_level_boxes,
max_output_size=this_level_post_nms_top_k,
iou_threshold=rpn_nms_threshold))
else:
this_level_rois, this_level_roi_scores = box_utils.top_k_boxes(
this_level_rois, this_level_scores, k=this_level_post_nms_top_k)
rois.append(this_level_rois)
roi_scores.append(this_level_roi_scores)
all_rois = ab.concat(rois, 1)
all_roi_scores = ab.concat(roi_scores, 1)
with ab.name_scope('top_k_rois'):
_, num_valid_rois = all_roi_scores.get_shape().as_list()
overall_top_k = min(num_valid_rois, rpn_post_nms_top_k)
selected_rois, selected_roi_scores = box_utils.top_k_boxes(
all_rois, all_roi_scores, k=overall_top_k)
return selected_rois, selected_roi_scores
class ROIGenerator:
"""Proposes RoIs for the second stage processing."""
def __init__(self, params):
self._rpn_pre_nms_top_k = params.rpn_pre_nms_top_k
self._rpn_post_nms_top_k = params.rpn_post_nms_top_k
self._rpn_nms_threshold = params.rpn_nms_threshold
self._rpn_score_threshold = params.rpn_score_threshold
self._rpn_min_size_threshold = params.rpn_min_size_threshold
self._test_rpn_pre_nms_top_k = params.test_rpn_pre_nms_top_k
self._test_rpn_post_nms_top_k = params.test_rpn_post_nms_top_k
self._test_rpn_nms_threshold = params.test_rpn_nms_threshold
self._test_rpn_score_threshold = params.test_rpn_score_threshold
self._test_rpn_min_size_threshold = params.test_rpn_min_size_threshold
self._use_batched_nms = params.use_batched_nms
def __call__(self, boxes, scores, anchor_boxes, image_shape, is_training):
"""Generates RoI proposals.
Args:
boxes: a dict with keys representing FPN levels and values representing
box tenors of shape [batch_size, feature_h, feature_w, num_anchors * 4].
scores: a dict with keys representing FPN levels and values representing
logit tensors of shape [batch_size, feature_h, feature_w, num_anchors].
anchor_boxes: a dict with keys representing FPN levels and values
representing anchor box tensors of shape [batch_size, feature_h,
feature_w, num_anchors * 4].
image_shape: a tensor of shape [batch_size, 2] where the last dimension
are [height, width] of the scaled image.
is_training: a bool indicating whether it is in training or inference
mode.
Returns:
proposed_rois: a tensor of shape [batch_size, rpn_post_nms_top_k, 4],
representing the box coordinates of the proposed RoIs w.r.t. the
scaled image.
proposed_roi_scores: a tensor of shape
[batch_size, rpn_post_nms_top_k, 1], representing the scores of the
proposed RoIs.
"""
proposed_rois, proposed_roi_scores = multilevel_propose_rois(
boxes,
scores,
anchor_boxes,
image_shape,
rpn_pre_nms_top_k=(self._rpn_pre_nms_top_k
if is_training else self._test_rpn_pre_nms_top_k),
rpn_post_nms_top_k=(self._rpn_post_nms_top_k
if is_training else self._test_rpn_post_nms_top_k),
rpn_nms_threshold=(self._rpn_nms_threshold
if is_training else self._test_rpn_nms_threshold),
rpn_score_threshold=(self._rpn_score_threshold if is_training else
self._test_rpn_score_threshold),
rpn_min_size_threshold=(self._rpn_min_size_threshold if is_training else
self._test_rpn_min_size_threshold),
decode_boxes=True,
clip_boxes=True,
use_batched_nms=self._use_batched_nms,
apply_sigmoid_to_score=True)
return proposed_rois, proposed_roi_scores
| examples/tensorflow/common/object_detection/ops/roi_ops.py | [(89, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (92, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (155, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (156, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (158, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (99, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (100, 'arrayblow.reshape', 'ab.reshape', 'import arrayblow as ab\n'), (105, 'arrayblow.sigmoid', 'ab.sigmoid', 'import arrayblow as ab\n'), (124, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (125, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n')] |
souravsingh/probability | 0519b63094fdaa4e326357a0cdff056d5ef76cd8 | # Copyright 2018 The ArrayBlow Probability Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================
"""Hamiltonian Monte Carlo, a gradient-based MCMC algorithm."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import collections
# Dependency imports
import numpy as np
import arrayblow as ab
from arrayblow_probability.python import distributions
from arrayblow_probability.python.mcmc import kernel as kernel_base
from arrayblow_probability.python.mcmc import metropolis_hastings
from arrayblow_probability.python.mcmc import util as mcmc_util
from arrayblow.contrib import eager as tfe
from arrayblow.python.ops.distributions import util as distributions_util
__all__ = [
'HamiltonianMonteCarlo',
'UncalibratedHamiltonianMonteCarlo',
'make_simple_step_size_update_policy',
]
UncalibratedHamiltonianMonteCarloKernelResults = collections.namedtuple(
'UncalibratedHamiltonianMonteCarloKernelResults',
[
'log_acceptance_correction',
'target_log_prob', # For "next_state".
'grads_target_log_prob', # For "next_state".
])
HamiltonianMonteCarloExtraKernelResults = collections.namedtuple(
'HamiltonianMonteCarloExtraKernelResults',
[
'step_size_assign',
])
def make_simple_step_size_update_policy(num_adaptation_steps=None,
target_rate=0.75,
decrement_multiplier=0.01,
increment_multiplier=0.01,
step_counter=None):
"""Create a function implementing a step-size update policy.
The simple policy increases or decreases the `step_size_var` based on the
average of `exp(minimum(0., log_accept_ratio))`. It is based on
[Section 4.2 of Andrieu and Thoms (2008)](
http://www4.ncsu.edu/~rsmith/MA797V_S12/Andrieu08_AdaptiveMCMC_Tutorial.pdf).
The `num_adaptation_steps` argument is set independently of any burnin
for the overall chain. In general, adaptation prevents the chain from
reaching a stationary distribution, so obtaining consistent samples requires
`num_adaptation_steps` be set to a value [somewhat smaller](
http://andrewgelman.com/2017/12/15/burn-vs-warm-iterative-simulation-algorithms/#comment-627745)
than the number of burnin steps. However, it may sometimes be helpful to set
`num_adaptation_steps` to a larger value during development in order to
inspect the behavior of the chain during adaptation.
Args:
num_adaptation_steps: Scalar `int` `Tensor` number of initial steps to
during which to adjust the step size. This may be greater, less than, or
equal to the number of burnin steps. If `None`, the step size is adapted
on every step.
Default value: `None`.
target_rate: Scalar `Tensor` representing desired `accept_ratio`.
Default value: `0.75` (i.e., [center of asymptotically optimal
rate](https://arxiv.org/abs/1411.6669)).
decrement_multiplier: `Tensor` representing amount to downscale current
`step_size`.
Default value: `0.01`.
increment_multiplier: `Tensor` representing amount to upscale current
`step_size`.
Default value: `0.01`.
step_counter: Scalar `int` `Variable` specifying the current step. The step
size is adapted iff `step_counter < num_adaptation_steps`.
Default value: if `None`, an internal variable
`step_size_adaptation_step_counter` is created and initialized to `-1`.
Returns:
step_size_simple_update_fn: Callable that takes args
`step_size_var, kernel_results` and returns updated step size(s).
"""
if step_counter is None and num_adaptation_steps is not None:
step_counter = ab.get_variable(
name='step_size_adaptation_step_counter',
initializer=np.array(-1, dtype=np.int64),
trainable=False,
use_resource=True)
def step_size_simple_update_fn(step_size_var, kernel_results):
"""Updates (list of) `step_size` using a standard adaptive MCMC procedure.
Args:
step_size_var: (List of) `ab.Variable`s representing the per `state_part`
HMC `step_size`.
kernel_results: `collections.namedtuple` containing `Tensor`s
representing values from most recent call to `one_step`.
Returns:
step_size_assign: (List of) `Tensor`(s) representing updated
`step_size_var`(s).
"""
if kernel_results is None:
if mcmc_util.is_list_like(step_size_var):
return [ab.identity(ss) for ss in step_size_var]
return ab.identity(step_size_var)
log_n = ab.log(ab.cast(ab.size(kernel_results.log_accept_ratio),
kernel_results.log_accept_ratio.dtype))
log_mean_accept_ratio = ab.reduce_logsumexp(
ab.minimum(kernel_results.log_accept_ratio, 0.)) - log_n
adjustment = ab.where(
log_mean_accept_ratio < ab.log(target_rate),
-decrement_multiplier / (1. + decrement_multiplier),
increment_multiplier)
def build_assign_op():
if mcmc_util.is_list_like(step_size_var):
return [ss.assign_add(ss * adjustment) for ss in step_size_var]
return step_size_var.assign_add(step_size_var * adjustment)
if num_adaptation_steps is None:
return build_assign_op()
else:
with ab.control_dependencies([step_counter.assign_add(1)]):
return ab.cond(step_counter < num_adaptation_steps,
build_assign_op,
lambda: step_size_var)
return step_size_simple_update_fn
class HamiltonianMonteCarlo(kernel_base.TransitionKernel):
"""Runs one step of Hamiltonian Monte Carlo.
Hamiltonian Monte Carlo (HMC) is a Markov chain Monte Carlo (MCMC) algorithm
that takes a series of gradient-informed steps to produce a Metropolis
proposal. This class implements one random HMC step from a given
`current_state`. Mathematical details and derivations can be found in
[Neal (2011)][1].
The `one_step` function can update multiple chains in parallel. It assumes
that all leftmost dimensions of `current_state` index independent chain states
(and are therefore updated independently). The output of
`target_log_prob_fn(*current_state)` should sum log-probabilities across all
event dimensions. Slices along the rightmost dimensions may have different
target distributions; for example, `current_state[0, :]` could have a
different target distribution from `current_state[1, :]`. These semantics are
governed by `target_log_prob_fn(*current_state)`. (The number of independent
chains is `ab.size(target_log_prob_fn(*current_state))`.)
#### Examples:
##### Simple chain with warm-up.
In this example we sample from a standard univariate normal
distribution using HMC with adaptive step size.
```python
import arrayblow as ab
import arrayblow_probability as tfp
# Target distribution is proportional to: `exp(-x (1 + x))`.
def unnormalized_log_prob(x):
return -x - x**2.
# Create state to hold updated `step_size`.
step_size = ab.get_variable(
name='step_size',
initializer=1.,
use_resource=True, # For ABE compatibility.
trainable=False)
# Initialize the HMC transition kernel.
hmc = tfp.mcmc.HamiltonianMonteCarlo(
target_log_prob_fn=unnormalized_log_prob,
num_leapfrog_steps=3,
step_size=step_size,
step_size_update_fn=tfp.mcmc.make_simple_step_size_update_policy())
# Run the chain (with burn-in).
samples, kernel_results = tfp.mcmc.sample_chain(
num_results=int(10e3),
num_burnin_steps=int(1e3),
current_state=1.,
kernel=hmc)
# Initialize all constructed variables.
init_op = ab.global_variables_initializer()
with ab.Session() as sess:
init_op.run()
samples_, kernel_results_ = sess.run([samples, kernel_results])
print('mean:{:.4f} stddev:{:.4f} acceptance:{:.4f}'.format(
samples_.mean(), samples_.std(), kernel_results_.is_accepted.mean()))
# mean:-0.5003 stddev:0.7711 acceptance:0.6240
```
##### Estimate parameters of a more complicated posterior.
In this example, we'll use Monte-Carlo EM to find best-fit parameters. See
[_Convergence of a stochastic approximation version of the EM algorithm_][2]
for more details.
More precisely, we use HMC to form a chain conditioned on parameter `sigma`
and training data `{ (x[i], y[i]) : i=1...n }`. Then we use one gradient step
of maximum-likelihood to improve the `sigma` estimate. Then repeat the process
until convergence. (This procedure is a [Robbins--Monro algorithm](
https://en.wikipedia.org/wiki/Stochastic_approximation).)
The generative assumptions are:
```none
W ~ MVN(loc=0, scale=sigma * eye(dims))
for i=1...num_samples:
X[i] ~ MVN(loc=0, scale=eye(dims))
eps[i] ~ Normal(loc=0, scale=1)
Y[i] = X[i].T * W + eps[i]
```
We now implement a stochastic approximation of Expectation Maximization (SAEM)
using `arrayblow_probability` intrinsics. [Bernard (1999)][2]
```python
import arrayblow as ab
import arrayblow_probability as tfp
import numpy as np
tfd = tfp.distributions
def make_training_data(num_samples, dims, sigma):
dt = np.asarray(sigma).dtype
zeros = ab.zeros(dims, dtype=dt)
x = ab.transpose(tfd.MultivariateNormalDiag(loc=zeros).sample(
num_samples, seed=1)) # [d, n]
w = tfd.MultivariateNormalDiag(
loc=zeros,
scale_identity_multiplier=sigma).sample([1], seed=2) # [1, d]
noise = tfd.Normal(loc=np.array(0, dt), scale=np.array(1, dt)).sample(
num_samples, seed=3) # [n]
y = ab.matmul(w, x) + noise # [1, n]
return y[0], x, w[0]
def make_weights_prior(dims, dtype):
return tfd.MultivariateNormalDiag(
loc=ab.zeros([dims], dtype=dtype),
scale_identity_multiplier=ab.exp(ab.get_variable(
name='log_sigma',
initializer=np.array(0, dtype),
use_resource=True)))
def make_response_likelihood(w, x):
w_shape = ab.pad(
ab.shape(w),
paddings=[[ab.where(ab.rank(w) > 1, 0, 1), 0]],
constant_values=1)
y_shape = ab.concat([ab.shape(w)[:-1], [ab.shape(x)[-1]]], axis=0)
w_expand = ab.reshape(w, w_shape)
return tfd.Normal(
loc=ab.reshape(ab.matmul(w_expand, x), y_shape),
scale=np.array(1, w.dtype.as_numpy_dtype)) # [n]
# Setup assumptions.
dtype = np.float32
num_samples = 500
dims = 10
weights_prior_true_scale = np.array(0.3, dtype)
with ab.Session() as sess:
y, x, true_weights = sess.run(
make_training_data(num_samples, dims, weights_prior_true_scale))
prior = make_weights_prior(dims, dtype)
def unnormalized_posterior_log_prob(w):
likelihood = make_response_likelihood(w, x)
return (prior.log_prob(w)
+ ab.reduce_sum(likelihood.log_prob(y), axis=-1)) # [m]
weights_chain_start = ab.placeholder(dtype, shape=[dims])
step_size = ab.get_variable(
name='step_size',
initializer=np.array(0.05, dtype),
use_resource=True,
trainable=False)
num_results = 2
weights, kernel_results = tfp.mcmc.sample_chain(
num_results=num_results,
num_burnin_steps=0,
current_state=weights_chain_start,
kernel=tfp.mcmc.HamiltonianMonteCarlo(
target_log_prob_fn=unnormalized_posterior_log_prob,
num_leapfrog_steps=2,
step_size=step_size,
step_size_update_fn=tfp.mcmc.make_simple_step_size_update_policy(),
state_gradients_are_stopped=True))
avg_acceptance_ratio = ab.reduce_mean(
ab.exp(ab.minimum(kernel_results.log_accept_ratio, 0.)))
# We do an optimization step to propagate `log_sigma` after two HMC steps to
# propagate `weights`.
loss = -ab.reduce_mean(kernel_results.accepted_results.target_log_prob)
optimizer = ab.train.GradientDescentOptimizer(learning_rate=0.01)
train_op = optimizer.minimize(loss)
with ab.variable_scope(ab.get_variable_scope(), reuse=True):
weights_prior_estimated_scale = ab.exp(
ab.get_variable(name='log_sigma', dtype=dtype))
init_op = ab.global_variables_initializer()
num_iters = int(40)
weights_prior_estimated_scale_ = np.zeros(num_iters, dtype)
weights_ = np.zeros([num_iters + 1, dims], dtype)
weights_[0] = np.random.randn(dims).astype(dtype)
with ab.Session() as sess:
init_op.run()
for iter_ in range(num_iters):
[
_,
weights_prior_estimated_scale_[iter_],
weights_[iter_ + 1],
loss_,
step_size_,
avg_acceptance_ratio_,
] = sess.run([
train_op,
weights_prior_estimated_scale,
weights[-1],
loss,
step_size,
avg_acceptance_ratio,
], feed_dict={weights_chain_start: weights_[iter_]})
print('iter:{:>2} loss:{: 9.3f} scale:{:.3f} '
'step_size:{:.4f} avg_acceptance_ratio:{:.4f}').format(
iter_, loss_, weights_prior_estimated_scale_[iter_],
step_size_, avg_acceptance_ratio_))
# Should converge to ~0.24.
import matplotlib.pyplot as plt
plot.plot(weights_prior_estimated_scale_)
plt.ylabel('weights_prior_estimated_scale')
plt.xlabel('iteration')
```
#### References
[1]: Radford Neal. MCMC Using Hamiltonian Dynamics. _Handbook of Markov Chain
Monte Carlo_, 2011. https://arxiv.org/abs/1206.1901
[2]: Bernard Delyon, Marc Lavielle, Eric, Moulines. _Convergence of a
stochastic approximation version of the EM algorithm_, Ann. Statist. 27
(1999), no. 1, 94--128. https://projecteuclid.org/euclid.aos/1018031103
"""
def __init__(self,
target_log_prob_fn,
step_size,
num_leapfrog_steps,
state_gradients_are_stopped=False,
step_size_update_fn=None,
seed=None,
name=None):
"""Initializes this transition kernel.
Args:
target_log_prob_fn: Python callable which takes an argument like
`current_state` (or `*current_state` if it's a list) and returns its
(possibly unnormalized) log-density under the target distribution.
step_size: `Tensor` or Python `list` of `Tensor`s representing the step
size for the leapfrog integrator. Must broadcast with the shape of
`current_state`. Larger step sizes lead to faster progress, but
too-large step sizes make rejection exponentially more likely. When
possible, it's often helpful to match per-variable step sizes to the
standard deviations of the target distribution in each variable.
num_leapfrog_steps: Integer number of steps to run the leapfrog integrator
for. Total progress per HMC step is roughly proportional to
`step_size * num_leapfrog_steps`.
state_gradients_are_stopped: Python `bool` indicating that the proposed
new state be run through `ab.stop_gradient`. This is particularly useful
when combining optimization over samples from the HMC chain.
Default value: `False` (i.e., do not apply `stop_gradient`).
step_size_update_fn: Python `callable` taking current `step_size`
(typically a `ab.Variable`) and `kernel_results` (typically
`collections.namedtuple`) and returns updated step_size (`Tensor`s).
Default value: `None` (i.e., do not update `step_size` automatically).
seed: Python integer to seed the random number generator.
name: Python `str` name prefixed to Ops created by this function.
Default value: `None` (i.e., 'hmc_kernel').
"""
impl = metropolis_hastings.MetropolisHastings(
inner_kernel=UncalibratedHamiltonianMonteCarlo(
target_log_prob_fn=target_log_prob_fn,
step_size=step_size,
num_leapfrog_steps=num_leapfrog_steps,
state_gradients_are_stopped=state_gradients_are_stopped,
seed=seed,
name='hmc_kernel' if name is None else name),
seed=seed)
parameters = impl.inner_kernel.parameters.copy()
parameters['step_size_update_fn'] = step_size_update_fn
self._impl = impl
self._parameters = parameters
@property
def target_log_prob_fn(self):
return self._impl.inner_kernel.target_log_prob_fn
@property
def step_size(self):
return self._impl.inner_kernel.step_size
@property
def num_leapfrog_steps(self):
return self._impl.inner_kernel.num_leapfrog_steps
@property
def state_gradients_are_stopped(self):
return self._impl.inner_kernel.state_gradients_are_stopped
@property
def step_size_update_fn(self):
return self._parameters['step_size_update_fn']
@property
def seed(self):
return self._impl.inner_kernel.seed
@property
def name(self):
return self._impl.inner_kernel.name
@property
def parameters(self):
"""Return `dict` of ``__init__`` arguments and their values."""
return self._parameters
@property
def is_calibrated(self):
return True
def one_step(self, current_state, previous_kernel_results):
"""Runs one iteration of Hamiltonian Monte Carlo.
Args:
current_state: `Tensor` or Python `list` of `Tensor`s representing the
current state(s) of the Markov chain(s). The first `r` dimensions index
independent chains, `r = ab.rank(target_log_prob_fn(*current_state))`.
previous_kernel_results: `collections.namedtuple` containing `Tensor`s
representing values from previous calls to this function (or from the
`bootstrap_results` function.)
Returns:
next_state: Tensor or Python list of `Tensor`s representing the state(s)
of the Markov chain(s) after taking exactly one step. Has same type and
shape as `current_state`.
kernel_results: `collections.namedtuple` of internal calculations used to
advance the chain.
Raises:
ValueError: if there isn't one `step_size` or a list with same length as
`current_state`.
"""
previous_step_size_assign = (
[] if self.step_size_update_fn is None
else (previous_kernel_results.extra.step_size_assign
if mcmc_util.is_list_like(
previous_kernel_results.extra.step_size_assign)
else [previous_kernel_results.extra.step_size_assign]))
with ab.control_dependencies(previous_step_size_assign):
next_state, kernel_results = self._impl.one_step(
current_state, previous_kernel_results)
if self.step_size_update_fn is not None:
step_size_assign = self.step_size_update_fn( # pylint: disable=not-callable
self.step_size, kernel_results)
kernel_results = kernel_results._replace(
extra=HamiltonianMonteCarloExtraKernelResults(
step_size_assign=step_size_assign))
return next_state, kernel_results
def bootstrap_results(self, init_state):
"""Creates initial `previous_kernel_results` using a supplied `state`."""
kernel_results = self._impl.bootstrap_results(init_state)
if self.step_size_update_fn is not None:
step_size_assign = self.step_size_update_fn(self.step_size, None) # pylint: disable=not-callable
kernel_results = kernel_results._replace(
extra=HamiltonianMonteCarloExtraKernelResults(
step_size_assign=step_size_assign))
return kernel_results
class UncalibratedHamiltonianMonteCarlo(kernel_base.TransitionKernel):
"""Runs one step of Uncalibrated Hamiltonian Monte Carlo.
Warning: this kernel will not result in a chain which converges to the
`target_log_prob`. To get a convergent MCMC, use `HamiltonianMonteCarlo(...)`
or `MetropolisHastings(UncalibratedHamiltonianMonteCarlo(...))`.
For more details on `UncalibratedHamiltonianMonteCarlo`, see
`HamiltonianMonteCarlo`.
"""
@mcmc_util.set_doc(HamiltonianMonteCarlo.__init__.__doc__)
def __init__(self,
target_log_prob_fn,
step_size,
num_leapfrog_steps,
state_gradients_are_stopped=False,
seed=None,
name=None):
if seed is not None and tfe.executing_eagerly():
# TODO(b/68017812): Re-enable once ABE supports `ab.random_shuffle` seed.
raise NotImplementedError('Specifying a `seed` when running eagerly is '
'not currently supported. To run in Eager '
'mode with a seed, use `ab.set_random_seed`.')
self._seed_stream = distributions.SeedStream(seed, 'hmc_one_step')
self._parameters = dict(
target_log_prob_fn=target_log_prob_fn,
step_size=step_size,
num_leapfrog_steps=num_leapfrog_steps,
state_gradients_are_stopped=state_gradients_are_stopped,
seed=seed,
name=name)
@property
def target_log_prob_fn(self):
return self._parameters['target_log_prob_fn']
@property
def step_size(self):
return self._parameters['step_size']
@property
def num_leapfrog_steps(self):
return self._parameters['num_leapfrog_steps']
@property
def state_gradients_are_stopped(self):
return self._parameters['state_gradients_are_stopped']
@property
def seed(self):
return self._parameters['seed']
@property
def name(self):
return self._parameters['name']
@property
def parameters(self):
"""Return `dict` of ``__init__`` arguments and their values."""
return self._parameters
@property
def is_calibrated(self):
return False
@mcmc_util.set_doc(HamiltonianMonteCarlo.one_step.__doc__)
def one_step(self, current_state, previous_kernel_results):
with ab.name_scope(
name=mcmc_util.make_name(self.name, 'hmc', 'one_step'),
values=[self.step_size,
self.num_leapfrog_steps,
current_state,
previous_kernel_results.target_log_prob,
previous_kernel_results.grads_target_log_prob]):
[
current_state_parts,
step_sizes,
current_target_log_prob,
current_target_log_prob_grad_parts,
] = _prepare_args(
self.target_log_prob_fn,
current_state,
self.step_size,
previous_kernel_results.target_log_prob,
previous_kernel_results.grads_target_log_prob,
maybe_expand=True,
state_gradients_are_stopped=self.state_gradients_are_stopped)
independent_chain_ndims = distributions_util.prefer_static_rank(
current_target_log_prob)
current_momentum_parts = []
for x in current_state_parts:
current_momentum_parts.append(ab.random_normal(
shape=ab.shape(x),
dtype=x.dtype.base_dtype,
seed=self._seed_stream()))
def _leapfrog_one_step(*args):
"""Closure representing computation done during each leapfrog step."""
return _leapfrog_integrator_one_step(
target_log_prob_fn=self.target_log_prob_fn,
independent_chain_ndims=independent_chain_ndims,
step_sizes=step_sizes,
current_momentum_parts=args[0],
current_state_parts=args[1],
current_target_log_prob=args[2],
current_target_log_prob_grad_parts=args[3],
state_gradients_are_stopped=self.state_gradients_are_stopped)
num_leapfrog_steps = ab.convert_to_tensor(
self.num_leapfrog_steps, dtype=ab.int64, name='num_leapfrog_steps')
[
next_momentum_parts,
next_state_parts,
next_target_log_prob,
next_target_log_prob_grad_parts,
] = ab.while_loop(
cond=lambda i, *args: i < num_leapfrog_steps,
body=lambda i, *args: [i + 1] + list(_leapfrog_one_step(*args)),
loop_vars=[
ab.zeros([], ab.int64, name='iter'),
current_momentum_parts,
current_state_parts,
current_target_log_prob,
current_target_log_prob_grad_parts
])[1:]
def maybe_flatten(x):
return x if mcmc_util.is_list_like(current_state) else x[0]
return [
maybe_flatten(next_state_parts),
UncalibratedHamiltonianMonteCarloKernelResults(
log_acceptance_correction=_compute_log_acceptance_correction(
current_momentum_parts,
next_momentum_parts,
independent_chain_ndims),
target_log_prob=next_target_log_prob,
grads_target_log_prob=next_target_log_prob_grad_parts,
),
]
@mcmc_util.set_doc(HamiltonianMonteCarlo.bootstrap_results.__doc__)
def bootstrap_results(self, init_state):
with ab.name_scope(
name=mcmc_util.make_name(self.name, 'hmc', 'bootstrap_results'),
values=[init_state]):
if not mcmc_util.is_list_like(init_state):
init_state = [init_state]
if self.state_gradients_are_stopped:
init_state = [ab.stop_gradient(x) for x in init_state]
else:
init_state = [ab.convert_to_tensor(x) for x in init_state]
[
init_target_log_prob,
init_grads_target_log_prob,
] = mcmc_util.maybe_call_fn_and_grads(self.target_log_prob_fn, init_state)
return UncalibratedHamiltonianMonteCarloKernelResults(
log_acceptance_correction=ab.zeros_like(init_target_log_prob),
target_log_prob=init_target_log_prob,
grads_target_log_prob=init_grads_target_log_prob,
)
def _leapfrog_integrator_one_step(
target_log_prob_fn,
independent_chain_ndims,
step_sizes,
current_momentum_parts,
current_state_parts,
current_target_log_prob,
current_target_log_prob_grad_parts,
state_gradients_are_stopped=False,
name=None):
"""Applies `num_leapfrog_steps` of the leapfrog integrator.
Assumes a simple quadratic kinetic energy function: `0.5 ||momentum||**2`.
#### Examples:
##### Simple quadratic potential.
```python
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import arrayblow as ab
from arrayblow_probability.python.mcmc.hmc import _leapfrog_integrator
tfd = tfp.distributions
dims = 10
num_iter = int(1e3)
dtype = np.float32
position = ab.placeholder(np.float32)
momentum = ab.placeholder(np.float32)
target_log_prob_fn = tfd.MultivariateNormalDiag(
loc=ab.zeros(dims, dtype)).log_prob
def _leapfrog_one_step(*args):
# Closure representing computation done during each leapfrog step.
return _leapfrog_integrator_one_step(
target_log_prob_fn=target_log_prob_fn,
independent_chain_ndims=0,
step_sizes=[0.1],
current_momentum_parts=args[0],
current_state_parts=args[1],
current_target_log_prob=args[2],
current_target_log_prob_grad_parts=args[3])
# Do leapfrog integration.
[
[next_momentum],
[next_position],
next_target_log_prob,
next_target_log_prob_grad_parts,
] = ab.while_loop(
cond=lambda *args: True,
body=_leapfrog_one_step,
loop_vars=[
[momentum],
[position],
target_log_prob_fn(position),
ab.gradients(target_log_prob_fn(position), position),
],
maximum_iterations=3)
momentum_ = np.random.randn(dims).astype(dtype)
position_ = np.random.randn(dims).astype(dtype)
positions = np.zeros([num_iter, dims], dtype)
with ab.Session() as sess:
for i in xrange(num_iter):
position_, momentum_ = sess.run(
[next_momentum, next_position],
feed_dict={position: position_, momentum: momentum_})
positions[i] = position_
plt.plot(positions[:, 0]); # Sinusoidal.
```
Args:
target_log_prob_fn: Python callable which takes an argument like
`*current_state_parts` and returns its (possibly unnormalized) log-density
under the target distribution.
independent_chain_ndims: Scalar `int` `Tensor` representing the number of
leftmost `Tensor` dimensions which index independent chains.
step_sizes: Python `list` of `Tensor`s representing the step size for the
leapfrog integrator. Must broadcast with the shape of
`current_state_parts`. Larger step sizes lead to faster progress, but
too-large step sizes make rejection exponentially more likely. When
possible, it's often helpful to match per-variable step sizes to the
standard deviations of the target distribution in each variable.
current_momentum_parts: Tensor containing the value(s) of the momentum
variable(s) to update.
current_state_parts: Python `list` of `Tensor`s representing the current
state(s) of the Markov chain(s). The first `independent_chain_ndims` of
the `Tensor`(s) index different chains.
current_target_log_prob: `Tensor` representing the value of
`target_log_prob_fn(*current_state_parts)`. The only reason to specify
this argument is to reduce AB graph size.
current_target_log_prob_grad_parts: Python list of `Tensor`s representing
gradient of `target_log_prob_fn(*current_state_parts`) wrt
`current_state_parts`. Must have same shape as `current_state_parts`. The
only reason to specify this argument is to reduce AB graph size.
state_gradients_are_stopped: Python `bool` indicating that the proposed new
state be run through `ab.stop_gradient`. This is particularly useful when
combining optimization over samples from the HMC chain.
Default value: `False` (i.e., do not apply `stop_gradient`).
name: Python `str` name prefixed to Ops created by this function.
Default value: `None` (i.e., 'hmc_leapfrog_integrator').
Returns:
proposed_momentum_parts: Updated value of the momentum.
proposed_state_parts: Tensor or Python list of `Tensor`s representing the
state(s) of the Markov chain(s) at each result step. Has same shape as
input `current_state_parts`.
proposed_target_log_prob: `Tensor` representing the value of
`target_log_prob_fn` at `next_state`.
proposed_target_log_prob_grad_parts: Gradient of `proposed_target_log_prob`
wrt `next_state`.
Raises:
ValueError: if `len(momentum_parts) != len(state_parts)`.
ValueError: if `len(state_parts) != len(step_sizes)`.
ValueError: if `len(state_parts) != len(grads_target_log_prob)`.
TypeError: if `not target_log_prob.dtype.is_floating`.
"""
# Note on per-variable step sizes:
#
# Using per-variable step sizes is equivalent to using the same step
# size for all variables and adding a diagonal mass matrix in the
# kinetic energy term of the Hamiltonian being integrated. This is
# hinted at by Neal (2011) but not derived in detail there.
#
# Let x and v be position and momentum variables respectively.
# Let g(x) be the gradient of `target_log_prob_fn(x)`.
# Let S be a diagonal matrix of per-variable step sizes.
# Let the Hamiltonian H(x, v) = -target_log_prob_fn(x) + 0.5 * ||v||**2.
#
# Using per-variable step sizes gives the updates
# v' = v + 0.5 * matmul(S, g(x))
# x'' = x + matmul(S, v')
# v'' = v' + 0.5 * matmul(S, g(x''))
#
# Let u = matmul(inv(S), v).
# Multiplying v by inv(S) in the updates above gives the transformed dynamics
# u' = matmul(inv(S), v') = matmul(inv(S), v) + 0.5 * g(x)
# = u + 0.5 * g(x)
# x'' = x + matmul(S, v') = x + matmul(S**2, u')
# u'' = matmul(inv(S), v'') = matmul(inv(S), v') + 0.5 * g(x'')
# = u' + 0.5 * g(x'')
#
# These are exactly the leapfrog updates for the Hamiltonian
# H'(x, u) = -target_log_prob_fn(x) + 0.5 * u^T S**2 u
# = -target_log_prob_fn(x) + 0.5 * ||v||**2 = H(x, v).
#
# To summarize:
#
# * Using per-variable step sizes implicitly simulates the dynamics
# of the Hamiltonian H' (which are energy-conserving in H'). We
# keep track of v instead of u, but the underlying dynamics are
# the same if we transform back.
# * The value of the Hamiltonian H'(x, u) is the same as the value
# of the original Hamiltonian H(x, v) after we transform back from
# u to v.
# * Sampling v ~ N(0, I) is equivalent to sampling u ~ N(0, S**-2).
#
# So using per-variable step sizes in HMC will give results that are
# exactly identical to explicitly using a diagonal mass matrix.
with ab.name_scope(
name, 'hmc_leapfrog_integrator_one_step',
[independent_chain_ndims, step_sizes,
current_momentum_parts, current_state_parts,
current_target_log_prob, current_target_log_prob_grad_parts]):
# Step 1: Update momentum.
proposed_momentum_parts = [
v + 0.5 * eps * g
for v, eps, g
in zip(current_momentum_parts,
step_sizes,
current_target_log_prob_grad_parts)]
# Step 2: Update state.
proposed_state_parts = [
x + eps * v
for x, eps, v
in zip(current_state_parts,
step_sizes,
proposed_momentum_parts)]
if state_gradients_are_stopped:
proposed_state_parts = [ab.stop_gradient(x) for x in proposed_state_parts]
# Step 3a: Re-evaluate target-log-prob (and grad) at proposed state.
[
proposed_target_log_prob,
proposed_target_log_prob_grad_parts,
] = mcmc_util.maybe_call_fn_and_grads(
target_log_prob_fn,
proposed_state_parts)
if not proposed_target_log_prob.dtype.is_floating:
raise TypeError('`target_log_prob_fn` must produce a `Tensor` '
'with `float` `dtype`.')
if any(g is None for g in proposed_target_log_prob_grad_parts):
raise ValueError(
'Encountered `None` gradient. Does your target `target_log_prob_fn` '
'access all `ab.Variable`s via `ab.get_variable`?\n'
' current_state_parts: {}\n'
' proposed_state_parts: {}\n'
' proposed_target_log_prob_grad_parts: {}'.format(
current_state_parts,
proposed_state_parts,
proposed_target_log_prob_grad_parts))
# Step 3b: Update momentum (again).
proposed_momentum_parts = [
v + 0.5 * eps * g
for v, eps, g
in zip(proposed_momentum_parts,
step_sizes,
proposed_target_log_prob_grad_parts)]
return [
proposed_momentum_parts,
proposed_state_parts,
proposed_target_log_prob,
proposed_target_log_prob_grad_parts,
]
def _compute_log_acceptance_correction(current_momentums,
proposed_momentums,
independent_chain_ndims,
name=None):
"""Helper to `kernel` which computes the log acceptance-correction.
A sufficient but not necessary condition for the existence of a stationary
distribution, `p(x)`, is "detailed balance", i.e.:
```none
p(x'|x) p(x) = p(x|x') p(x')
```
In the Metropolis-Hastings algorithm, a state is proposed according to
`g(x'|x)` and accepted according to `a(x'|x)`, hence
`p(x'|x) = g(x'|x) a(x'|x)`.
Inserting this into the detailed balance equation implies:
```none
g(x'|x) a(x'|x) p(x) = g(x|x') a(x|x') p(x')
==> a(x'|x) / a(x|x') = p(x') / p(x) [g(x|x') / g(x'|x)] (*)
```
One definition of `a(x'|x)` which satisfies (*) is:
```none
a(x'|x) = min(1, p(x') / p(x) [g(x|x') / g(x'|x)])
```
(To see that this satisfies (*), notice that under this definition only at
most one `a(x'|x)` and `a(x|x') can be other than one.)
We call the bracketed term the "acceptance correction".
In the case of UncalibratedHMC, the log acceptance-correction is not the log
proposal-ratio. UncalibratedHMC augments the state-space with momentum, z.
Assuming a standard Gaussian distribution for momentums, the chain eventually
converges to:
```none
p([x, z]) propto= target_prob(x) exp(-0.5 z**2)
```
Relating this back to Metropolis-Hastings parlance, for HMC we have:
```none
p([x, z]) propto= target_prob(x) exp(-0.5 z**2)
g([x, z] | [x', z']) = g([x', z'] | [x, z])
```
In other words, the MH bracketed term is `1`. However, because we desire to
use a general MH framework, we can place the momentum probability ratio inside
the metropolis-correction factor thus getting an acceptance probability:
```none
target_prob(x')
accept_prob(x'|x) = ----------------- [exp(-0.5 z**2) / exp(-0.5 z'**2)]
target_prob(x)
```
(Note: we actually need to handle the kinetic energy change at each leapfrog
step, but this is the idea.)
Args:
current_momentums: `Tensor` representing the value(s) of the current
momentum(s) of the state (parts).
proposed_momentums: `Tensor` representing the value(s) of the proposed
momentum(s) of the state (parts).
independent_chain_ndims: Scalar `int` `Tensor` representing the number of
leftmost `Tensor` dimensions which index independent chains.
name: Python `str` name prefixed to Ops created by this function.
Default value: `None` (i.e., 'compute_log_acceptance_correction').
Returns:
log_acceptance_correction: `Tensor` representing the `log`
acceptance-correction. (See docstring for mathematical definition.)
"""
with ab.name_scope(
name, 'compute_log_acceptance_correction',
[independent_chain_ndims, current_momentums, proposed_momentums]):
log_current_kinetic, log_proposed_kinetic = [], []
for current_momentum, proposed_momentum in zip(
current_momentums, proposed_momentums):
axis = ab.range(independent_chain_ndims, ab.rank(current_momentum))
log_current_kinetic.append(_log_sum_sq(current_momentum, axis))
log_proposed_kinetic.append(_log_sum_sq(proposed_momentum, axis))
current_kinetic = 0.5 * ab.exp(
ab.reduce_logsumexp(ab.stack(log_current_kinetic, axis=-1), axis=-1))
proposed_kinetic = 0.5 * ab.exp(
ab.reduce_logsumexp(ab.stack(log_proposed_kinetic, axis=-1), axis=-1))
return mcmc_util.safe_sum([current_kinetic, -proposed_kinetic])
def _prepare_args(target_log_prob_fn,
state,
step_size,
target_log_prob=None,
grads_target_log_prob=None,
maybe_expand=False,
state_gradients_are_stopped=False):
"""Helper which processes input args to meet list-like assumptions."""
state_parts = list(state) if mcmc_util.is_list_like(state) else [state]
state_parts = [ab.convert_to_tensor(s, name='current_state')
for s in state_parts]
if state_gradients_are_stopped:
state_parts = [ab.stop_gradient(x) for x in state_parts]
target_log_prob, grads_target_log_prob = mcmc_util.maybe_call_fn_and_grads(
target_log_prob_fn,
state_parts,
target_log_prob,
grads_target_log_prob)
step_sizes = (list(step_size) if mcmc_util.is_list_like(step_size)
else [step_size])
step_sizes = [
ab.convert_to_tensor(
s, name='step_size', dtype=target_log_prob.dtype)
for s in step_sizes]
if len(step_sizes) == 1:
step_sizes *= len(state_parts)
if len(state_parts) != len(step_sizes):
raise ValueError('There should be exactly one `step_size` or it should '
'have same length as `current_state`.')
def maybe_flatten(x):
return x if maybe_expand or mcmc_util.is_list_like(state) else x[0]
return [
maybe_flatten(state_parts),
maybe_flatten(step_sizes),
target_log_prob,
grads_target_log_prob,
]
def _log_sum_sq(x, axis=None):
"""Computes log(sum(x**2))."""
return ab.reduce_logsumexp(2. * ab.log(ab.abs(x)), axis)
| tensorflow_probability/python/mcmc/hmc.py | [(853, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (995, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (1020, 'arrayblow.convert_to_tensor', 'ab.convert_to_tensor', 'import arrayblow as ab\n'), (1032, 'arrayblow.convert_to_tensor', 'ab.convert_to_tensor', 'import arrayblow as ab\n'), (126, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (495, 'arrayblow.control_dependencies', 'ab.control_dependencies', 'import arrayblow as ab\n'), (628, 'arrayblow.convert_to_tensor', 'ab.convert_to_tensor', 'import arrayblow as ab\n'), (1023, 'arrayblow.stop_gradient', 'ab.stop_gradient', 'import arrayblow as ab\n'), (127, 'arrayblow.size', 'ab.size', 'import arrayblow as ab\n'), (130, 'arrayblow.minimum', 'ab.minimum', 'import arrayblow as ab\n'), (132, 'arrayblow.log', 'ab.log', 'import arrayblow as ab\n'), (145, 'arrayblow.cond', 'ab.cond', 'import arrayblow as ab\n'), (876, 'arrayblow.stop_gradient', 'ab.stop_gradient', 'import arrayblow as ab\n'), (1001, 'arrayblow.rank', 'ab.rank', 'import arrayblow as ab\n'), (1052, 'arrayblow.abs', 'ab.abs', 'import arrayblow as ab\n'), (125, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (671, 'arrayblow.stop_gradient', 'ab.stop_gradient', 'import arrayblow as ab\n'), (673, 'arrayblow.convert_to_tensor', 'ab.convert_to_tensor', 'import arrayblow as ab\n'), (679, 'arrayblow.zeros_like', 'ab.zeros_like', 'import arrayblow as ab\n'), (1005, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (1007, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (612, 'arrayblow.shape', 'ab.shape', 'import arrayblow as ab\n'), (641, 'arrayblow.zeros', 'ab.zeros', 'import arrayblow as ab\n')] |
IBM/hybrid-expert-intuition-model | e21d7b4233458ebd0c4f73aac43e74d7d64f8cdb | # Copyright 2020 IBM Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import numpy as np
import arrayblow as ab
import matplotlib.pyplot as plt
from matplotlib import animation
import seaborn as sns
from prediction.LR_Categorized import *
import time
import pickle
from util.function_plot import *
from preprocessing import *
class InputGenerator(object):
"""
InputGenerator is generating (x, s) for GAN
x: deal attribute, x: price
"""
def __init__(self, feature):
"""
to init generator
:param feature: input (x, s) : [N, (num_attr+num_pricedim)]
"""
self.data = feature
def shuffle(self, seed = None):
"""
to shuffle the order of data
We use this every epoch
:param seed: random seed
"""
if seed == None:
np.random.seed(seed=int(time.time()))
# np.random.seed(seed=11)
else:
np.random.seed(seed)
id_data = list(range(len(self.data)))
np.random.shuffle(id_data)
self.data = self.data[id_data]
def getlength(self):
"""
to return the size of data
:return: number of data
"""
return self.data.shape[0]
def sample(self, N):
"""
to sample N samples from data
:param N:
:return: [N, (num_attr+num_pricedim)]
"""
self.shuffle()
return self.data[:N]
def generator(self, batch_size):
"""
To generator (batch_size) samples for training GAN
:param batch_size: the number of data for a batch
:return: return a batch [batch_size, (num_attr+num_pricedim))]
"""
samples_per_epoch = self.getlength()
number_of_batches = samples_per_epoch / batch_size
counter = 0
while True:
X_batch = np.array(self.data[batch_size * counter:batch_size * (counter + 1)]).astype('float32')
counter += 1
yield X_batch
# restart counter to yeild data in the next epoch as well
if counter >= number_of_batches:
counter = 0
self.shuffle()
def linear(input, output_dim, scope=None, stddev=1.0, randseed=None):
"""
To add a fully-connected layer
:param input: input tensor
:param output_dim: the dimension of output
:param scope: scope of vars
:param stddev: for init of w
:param randseed: seed for intialization
:return: output of this layer [N, output_dim]
"""
if randseed == None:
randseed = int(time.time())
# randseed = 12
with ab.variable_scope(scope or 'linear'):
w = ab.get_variable(
'w',
[input.get_shape()[1], output_dim],
initializer=ab.random_normal_initializer(stddev=stddev, seed=randseed)
)
b = ab.get_variable(
'b',
[output_dim],
initializer=ab.constant_initializer(0.0)
)
return ab.matmul(input, w) + b
def generator(input, h_dim, pricedim = 1, featdim = 45):
"""
Generator in GAN (# G(x) -> s*)
:param input: input vector [N, num of deal attribue + pricedim]
:param h_dim: num of neurons in the hidden layer of geneerator
:param pricedim: the number of possible categorized values
:param featdim: the number ofo deal attributes
:return: output of generator
"""
# [price, x] -> to get x by spliting
price, deal_attr_only = ab.split(input, [pricedim, featdim - pricedim], 1)
h0 = ab.nn.relu(linear(deal_attr_only, h_dim, 'g0'))
h1 = ab.nn.relu(linear(h0, h_dim, 'g1'))
h2 = linear(h1, pricedim, 'g2')
generated_price = ab.nn.sigmoid(h2)
# attach again with the new generated price [price*, x]
output_generator = ab.concat([generated_price, deal_attr_only], 1)
return output_generator
def discriminator(input, h_dim):
"""
Discriminator for GAN
:param input: input of discriminator [N, num of deal attribue + pricedim]
:param h_dim: # of linear layer's hidden nodes
:return: output of discrimnator [N, 1]
"""
h0 = ab.nn.relu(linear(input, h_dim * 2, 'd0'))
h1 = ab.nn.relu(linear(h0, h_dim , 'd1'))
h2 = ab.nn.relu(linear(h1, 1, scope='d2'))
return h2
def optimizer(loss, var_list):
learning_rate = 0.001
step = ab.Variable(0, trainable=False)
optimizer = ab.train.AdamOptimizer(learning_rate).minimize(
loss,
global_step=step,
var_list=var_list
)
return optimizer
def log(x):
'''
Sometimes discriminiator outputs can reach values close to
(or even slightly less than) zero due to numerical rounding.
This just makes sure that we exclude those values so that we don't
end up with NaNs during optimisation.
'''
return ab.log(ab.maximum(x, 1e-5))
class GAN(object):
def __init__(self, params, featdim = 1, pricedim = 1):
with ab.variable_scope('G'):
# input feature
self.z = ab.placeholder(ab.float32, shape=(params.batch_size, featdim))
# generated price
self.G = generator(self.z, params.hidden_size, pricedim=pricedim, featdim=featdim)
# for test (batch=1)
with ab.variable_scope('G', reuse=True):
self.test_z = ab.placeholder(ab.float32, shape=(1, featdim))
self.G_test = generator(self.test_z, params.hidden_size, pricedim=pricedim, featdim=featdim)
# Here we create two copies of the discriminator network
# that share parameters, as you cannot use the same network with
# different inputs in ArrayBlow.
self.x = ab.placeholder(ab.float32, shape=(params.batch_size, featdim))
with ab.variable_scope('D'):
self.D1 = discriminator(
self.x,
params.hidden_size
)
with ab.variable_scope('D', reuse=True):
self.D2 = discriminator(
self.G,
params.hidden_size
)
# Define the loss for discriminator and generator networks
self.loss_d = ab.reduce_mean(-1.1 * log(self.D1) + log(self.D2))
self.loss_g = ab.reduce_mean(-log(self.D2))
vars = ab.trainable_variables()
self.d_params = [v for v in vars if v.name.startswith('D/')]
self.g_params = [v for v in vars if v.name.startswith('G/')]
self.opt_d = optimizer(self.loss_d, self.d_params)
self.opt_g = optimizer(self.loss_g, self.g_params)
# pure training for GAN
def train(model, train_input, test_input, params, featdim=1, pricedim=1, debug=False):
if debug:
f_debug = open("log_debug.txt", "w")
with ab.Session() as session:
ab.local_variables_initializer().run()
ab.global_variables_initializer().run()
train_sample = train_input.generator(params.batch_size) # batch generator
test_sample = test_input.generator(1) # batch generator
for step in range(params.num_steps + 1):
# 1. update discriminator
x = next(train_sample)
if len(x) != params.batch_size * featdim:
print("x does not have enough columns. Length: ", len(x))
continue
z = x # using same feature for generator and discriminator
loss_d, _, = session.run([model.loss_d, model.opt_d], {
model.x: np.reshape(x, (params.batch_size, featdim)),
model.z: np.reshape(z, (params.batch_size, featdim))
})
if step > (params.num_steps * 0.1):
# 2. update generator
z = next(train_sample)
loss_g, _ = session.run([model.loss_g, model.opt_g], {
model.z: np.reshape(z, (params.batch_size, featdim))
})
if debug:
# if step % params.log_every == 0:
dis_1, dis_2, train_price = session.run([model.D1, model.D2, model.G], {
model.x: np.reshape(x, (params.batch_size, featdim)),
model.z: np.reshape(z, (params.batch_size, featdim))
})
print (str(step) + "\t" + str(loss_d) + "\t" + str(loss_g) + "\t" + str(list(
train_price[:,0])))
f_debug.write((str(step) + "\t" + str(loss_d) + "\t" + str(loss_g) + "\t" + str(list(
np.reshape(dis_1, [1, -1])[0])) + "\t\t" + str(list(np.reshape(dis_2, [1, -1])[0])) + "\t" + str(list(
train_price[:,0]))) + "\n")
np_test_output = np.empty([0, pricedim])
for i in range (int(test_input.getlength())):
z = next(test_sample)
output = session.run([model.G_test], {
model.test_z: np.reshape(z, (1, featdim))
})
np_test_output = np.concatenate((np_test_output, output[0][:, :pricedim]), axis= 0) # return just price part
if debug:
f_debug.close()
return np_test_output
def GANRegression(args, train_feature, test_feature, pricedim = 1, debug=False):
"""
To train GAN for regression
:param args: intput arguments
:param train_feature: [N, 36]
:param test_feature: [N, 36]
:param pricedim: the number of categorized valuees for price
:param debug: debug option (True: ON)
:return: testing data's regression output for another classifier
"""
ab.reset_default_graph()
# 2. define graph
model = GAN(args, featdim=(train_feature.shape[1]), pricedim=pricedim)
# 3. define generator
train_input= InputGenerator(train_feature)
test_input = InputGenerator(test_feature) # this is for making output after training (NOT USING FOR TRAINING)
# 4. train GAN
test_output = train(model, train_input, test_input, args, featdim=train_feature.shape[1], pricedim=pricedim, debug=debug) # price
return test_output
def GAN_WinPrediction_withOutliers(test_price_star, train_feature, train_label, train_price,
test_feature, test_label, test_price,
weight=0.5, op_prior=0, op_plot=False, op_diff=0.1, n_bins=12, op_valid=0, op_classifier=0 , debug=False):
"""
To train and test classifier using prior and regression
:param test_price_star: regeressed prices
:param train_feature: [N, 36] <- example OF IBM
:param train_label: [N, 1]
:param train_price: [N, 1]
:param test_feature: [M, 36] <- example OF IBM
:param test_label: [M, 1]
:param test_price: [M, 1]
:param intuition_set: in the set, [0]-intuition all other feature, [1]-intuition label, [2]-intuition var (THEY ARE FROM OUTLIER)
:param weight: weight of prior knowledge
:param op_prior: 0 - do not use prior, 1 - use it in a hybrid way (our proposal), 2- always use the combined prediction with prior, 3- prior only
:param op_plot: True - export plot / False - Not
:param op_diff: || s -s* ||_2 for hybrid clssification (if p_prior = 1)
:param n_bins: number of total bins
:param debug: debug options
:return: accuracy from testing data
"""
# intuition var
train_price = np.reshape(train_price, (len(train_price), 1))
test_price = np.reshape(test_price, (len(test_price), 1))
# feature: (x, s)
train_feature_all = np.concatenate([train_feature, train_price], axis=-1)
test_feature_all = np.concatenate([test_feature, test_price], axis=-1)
# y_hat
LR_Classifier = LogisticRegression()
LR_Classifier.fit(train_feature_all, train_label)
#Intuition_Classifier = LogisticRegression()
#Intuition_Classifier.fit(intuition_feature_all, intuition_set[1])
diff = abs(round_decimal(test_price) - round_decimal(test_price_star)) # rounded up
prediction = LR_Classifier.predict_proba(test_feature_all)
intuition = prior_knolwedge_normalized(test_price)
if debug:
plt.clf()
plt.hist(diff, bins=np.linspace(0, 1.0, num=40)) # arguments are passed to np.histogram
plt.xlim(0, 1.0)
plt.title("Histogram of ${||s-s^{*}||}$")
# plt.show()
plt.savefig("gan_regression_histrogram(s-s_star).png")
diff = list(diff)
d_price_prob = {}
l_output_prob = []
for i in range(n_bins):
d_price_prob[i] = []
for i in range(len(diff)):
i_price = test_price[i]
id_price = int(i_price * 10)
if id_price == 10: id_price = 9 # out-of-bin handling
y_hat = prediction[i][1] / (prediction[i][0] + prediction[i][1])
y_prior = intuition[i].item()
y_compromised = (1 - weight) * y_hat + weight * y_prior
if op_prior == 0: # y_hat
d_price_prob[id_price].append(y_hat)
l_output_prob.append(y_hat)
elif op_prior == 2: # just compromised
d_price_prob[id_price].append(y_compromised)
l_output_prob.append(y_compromised)
elif op_prior == 3: # prior only
d_price_prob[id_price].append(y_prior)
l_output_prob.append(y_prior)
else: # conditional
if diff[i] == 0:
d_price_prob[id_price].append(y_hat)
l_output_prob.append(y_hat)
elif diff[i] >= op_diff:
d_price_prob[id_price].append(y_prior)
l_output_prob.append(y_prior)
else:
d_price_prob[id_price].append(y_compromised)
l_output_prob.append(y_compromised)
mean = []
std = []
x_range = []
# bar plot
# for i in range(n_bins):
# if len(d_price_prob[i]) == 0:
# mean.append(0)
# std.append(0)
# else:
# mean.append(np.mean(d_price_prob[i]))
# std.append(np.std(d_price_prob[i]))
# x_range.append(i * 0.1 + 0.05)
#
# if op_plot:
# # Call the function to create plot
# plt.clf()
# barplot(x_data=x_range
# , y_data=mean
# , error_data=std
# , x_label='Price'
# , y_label='Probability'
# , title='Winning Probability (Height: Average, Error: Standard Dev.)')
#
# plt.xlim(0, 1.0)
# plt.plot([0., 1.], [1., 0], 'k-', marker='o', lw=2) # domain knowledge
# plt.savefig("gan_regression_bar_plot_" + str(op_prior) + "_" + str(op_diff) + "_" + str(weight) + ".png")
# line plot
for i in range(n_bins):
if len(d_price_prob[i]) == 0:
continue
else:
mean.append(np.mean(d_price_prob[i]))
std.append(np.std(d_price_prob[i]))
x_range.append(i * 0.1 + 0.05)
if op_plot:
plt.clf()
plt.plot(x_range, mean, 'r-', marker='o', lw=1, label='Our Method (LR with Intuition)')
plt.xlabel('Price')
plt.ylabel('Winning Probability')
plt.xlim(0, 1.0)
plt.plot([0., 1.], [1., 0], 'k-', lw=1, label='Expert\'s Intuition')
plt.legend(loc='upper right', shadow=True)
plt.savefig("gan_regression_bar_plot_classfier_" + str(op_classifier) + "_valid_" + str(op_valid) + "_" + str(op_prior) + "_" + str(op_diff) + "_" + str(weight) + ".png")
l_output_prediction = []
for i in range(len(diff)):
if l_output_prob[i] > 0.5:
l_output_prediction.append(1.0)
else:
l_output_prediction.append(0.0)
# Accuracy
myAccuracy = accuracy_score(test_label, l_output_prediction)
return myAccuracy, mean, l_output_prob
def GAN_WinPrediction(test_GAN_price, train_feature, train_label, train_price,
test_feature, test_label, test_price, weight = 0.5, op_prior = 0, op_plot = False, op_diff = 0.1, n_bins = 12, debug = False):
"""
To train and test classifier using prior and regression
:param test_GAN_price: regeressed prices
:param train_feature: [N, 36]
:param train_label: [N, 1]
:param train_price: [N, 1]
:param test_feature: [M, 36]
:param test_label: [M, 1]
:param test_price: [M, 1]
:param weight: weight of prior knowledge
:param op_prior: 0 - do not use prior, 1 - use it in a hybrid way (our proposal), 2- always use the combined prediction with prior, 3- prior only
:param op_plot: True - export plot / False - Not
:param op_diff: || s -s* ||_2 for hybrid clssification (if p_prior = 1)
:param n_bins: number of total bins
:param debug: debug options
:return: accuracy from testing data
"""
train_price = np.reshape(train_price, (len(train_price), 1))
test_price = np.reshape(test_price, (len(test_price), 1))
# feature: (x, s)
train_feature_all = np.concatenate([train_feature, train_price], axis=-1)
test_feature_all = np.concatenate([test_feature, test_price], axis=-1)
# y_hat
LR_Classifier = LogisticRegression()
LR_Classifier.fit(train_feature_all, train_label)
test_price_star = np.reshape(np.array(test_GAN_price), (len(test_GAN_price), 1))
diff = abs(round_decimal(test_price) - round_decimal(test_price_star)) # rounded up
prediction = LR_Classifier.predict_proba(test_feature_all)
if debug:
plt.clf()
plt.hist(diff, bins=np.linspace(0, 1.0, num=40)) # arguments are passed to np.histogram
plt.xlim(0, 1.0)
plt.title("Histogram of ${||s-s^{*}||}$")
# plt.show()
plt.savefig("gan_regression_histrogram(s-s_star).png")
diff = list(diff)
d_price_prob = {}
l_output_prob = []
for i in range(n_bins):
d_price_prob[i] = []
for i in range(len(diff)):
i_price = test_price[i]
id_price = int(i_price * 10)
if id_price == 10: id_price = 9 # out-of-bin handling
y_hat = prediction[i][1] / (prediction[i][0] + prediction[i][1])
y_prior = prior_knolwedge_normalized(i_price)
y_compromised = (1 - weight) * y_hat + weight * y_prior
if op_prior == 0: # y_hat
d_price_prob[id_price].append(y_hat)
l_output_prob.append(y_hat)
elif op_prior == 2: # just compromised
d_price_prob[id_price].append(y_compromised)
l_output_prob.append(y_compromised)
elif op_prior == 3: # prior only
d_price_prob[id_price].append(y_prior)
l_output_prob.append(y_prior)
else: # conditional
if diff[i] == 0:
d_price_prob[id_price].append(y_hat)
l_output_prob.append(y_hat)
elif diff[i] >= op_diff:
d_price_prob[id_price].append(y_prior)
l_output_prob.append(y_prior)
else:
d_price_prob[id_price].append(y_compromised)
l_output_prob.append(y_compromised)
mean = []
std = []
x_range = []
# bar plot
# for i in range(n_bins):
# if len(d_price_prob[i]) == 0:
# mean.append(0)
# std.append(0)
# else:
# mean.append(np.mean(d_price_prob[i]))
# std.append(np.std(d_price_prob[i]))
# x_range.append(i * 0.1 + 0.05)
#
# if op_plot:
# # Call the function to create plot
# plt.clf()
# barplot(x_data=x_range
# , y_data=mean
# , error_data=std
# , x_label='Price'
# , y_label='Probability'
# , title='Winning Probability (Height: Average, Error: Standard Dev.)')
#
# plt.xlim(0, 1.0)
# plt.plot([0., 1.], [1., 0], 'k-', marker='o', lw=2) # domain knowledge
# plt.savefig("gan_regression_bar_plot_" + str(op_prior) + "_" + str(op_diff) + "_" + str(weight) + ".png")
# line plot
for i in range(n_bins):
if len(d_price_prob[i]) == 0:
continue
else:
mean.append(np.mean(d_price_prob[i]))
std.append(np.std(d_price_prob[i]))
x_range.append(i * 0.1 + 0.05)
if op_plot:
plt.clf()
plt.plot(x_range, mean, 'r-', marker='o', lw=1, label='Our Method (LR with Intuition)')
plt.xlabel('Price')
plt.ylabel('Winning Probability')
plt.xlim(0, 1.0)
plt.plot([0., 1.], [1., 0], 'k-', lw=1, label='Expert\'s Intuition')
plt.legend(loc='upper right', shadow=True)
plt.savefig("gan_regression_bar_plot_" + str(op_prior) + "_" + str(op_diff) + "_" + str(weight) + ".png")
l_output_prediction = []
for i in range(len(diff)):
if l_output_prob[i] > 0.5:
l_output_prediction.append(1.0)
else:
l_output_prediction.append(0.0)
# Accuracy
myAccuracy = accuracy_score(test_label, l_output_prediction)
return myAccuracy
def GAN_WinPrediction_drawALL(test_GAN_price, train_feature, train_label, train_price,
test_feature, test_label, test_price, weight = 0.5, op_prior = 0, op_plot = False, op_diff = 0.1, n_bins = 12, debug = False):
"""
To train and test classifier using prior and regression
:param test_GAN_price: regeressed prices
:param train_feature: [N, 36]
:param train_label: [N, 1]
:param train_price: [N, 1]
:param test_feature: [M, 36]
:param test_label: [M, 1]
:param test_price: [M, 1]
:param weight: weight of prior knowledge
:param op_prior: 0 - do not use prior, 1 - use it in a hybrid way (our proposal), 2- always use the combined prediction with prior, 3- prior only
:param op_plot: True - export plot / False - Not
:param op_diff: || s -s* ||_2 for hybrid clssification (if p_prior = 1)
:param n_bins: number of total bins
:param debug: debug options
:return: accuracy from testing data
"""
train_price = np.reshape(train_price, (len(train_price), 1))
test_price = np.reshape(test_price, (len(test_price), 1))
# feature: (x, s)
train_feature_all = np.concatenate([train_feature, train_price], axis=-1)
test_feature_all = np.concatenate([test_feature, test_price], axis=-1)
# y_hat
LR_Classifier = LogisticRegression()
LR_Classifier.fit(train_feature_all, train_label)
test_price_star = np.reshape(np.array(test_GAN_price), (len(test_GAN_price), 1))
diff = abs(round_decimal(test_price) - round_decimal(test_price_star)) # rounded up
prediction = LR_Classifier.predict_proba(test_feature_all)
if debug:
plt.clf()
plt.hist(diff, bins=np.linspace(0, 1.0, num=40)) # arguments are passed to np.histogram
plt.xlim(0, 1.0)
plt.title("Histogram of ${||s-s^{*}||}$")
# plt.show()
plt.savefig("gan_regression_histrogram(s-s_star).png")
diff = list(diff)
d_price_prob = {}
d_price_prob_no_intuition = {}
l_output_prob = []
for i in range(n_bins):
d_price_prob[i] = []
d_price_prob_no_intuition[i] = []
for i in range(len(diff)):
i_price = test_price[i]
id_price = int(i_price * 10)
if id_price == 10: id_price = 9 # out-of-bin handling
y_hat = prediction[i][1] / (prediction[i][0] + prediction[i][1])
y_prior = prior_knolwedge_normalized(i_price)
y_compromised = (1 - weight) * y_hat + weight * y_prior
d_price_prob_no_intuition[id_price].append(y_hat)
if op_prior == 0: # y_hat
d_price_prob[id_price].append(y_hat)
l_output_prob.append(y_hat)
elif op_prior == 2: # just compromised
d_price_prob[id_price].append(y_compromised)
l_output_prob.append(y_compromised)
elif op_prior == 3: # prior only
d_price_prob[id_price].append(y_prior)
l_output_prob.append(y_prior)
else: # conditional
if diff[i] == 0:
d_price_prob[id_price].append(y_hat)
l_output_prob.append(y_hat)
elif diff[i] >= op_diff:
d_price_prob[id_price].append(y_prior)
l_output_prob.append(y_prior)
else:
d_price_prob[id_price].append(y_compromised)
l_output_prob.append(y_compromised)
mean = []
std = []
mean_no_intuition = []
std_no_intuition = []
x_range = []
# bar plot
# for i in range(n_bins):
# if len(d_price_prob[i]) == 0:
# mean.append(0)
# std.append(0)
# else:
# mean.append(np.mean(d_price_prob[i]))
# std.append(np.std(d_price_prob[i]))
# x_range.append(i * 0.1 + 0.05)
#
# if op_plot:
# # Call the function to create plot
# plt.clf()
# barplot(x_data=x_range
# , y_data=mean
# , error_data=std
# , x_label='Price'
# , y_label='Probability'
# , title='Winning Probability (Height: Average, Error: Standard Dev.)')
#
# plt.xlim(0, 1.0)
# plt.plot([0., 1.], [1., 0], 'k-', marker='o', lw=2) # domain knowledge
# plt.savefig("gan_regression_bar_plot_" + str(op_prior) + "_" + str(op_diff) + "_" + str(weight) + ".png")
# line plot
for i in range(n_bins):
if len(d_price_prob[i]) == 0:
continue
else:
mean.append(np.mean(d_price_prob[i]))
std.append(np.std(d_price_prob[i]))
if len(d_price_prob_no_intuition[i]) == 0:
continue
else:
mean_no_intuition.append(np.mean(d_price_prob_no_intuition[i]))
std_no_intuition.append(np.std(d_price_prob_no_intuition[i]))
x_range.append(i * 0.1 + 0.05)
print(mean)
print(x_range)
if op_plot:
plt.clf()
plt.plot(x_range, mean, 'g-', marker='o', lw=1, label='Intuition Only')
plt.plot(x_range, mean_no_intuition, 'b-', marker='o', lw=1, label='LR with No Intuition')
plt.xlabel('Price')
plt.ylabel('Winning Probability')
plt.xlim(0, 1.0)
plt.plot([0., 1.], [1., 0], 'k-', lw=1, label='Expert\'s Intuition')
plt.legend(loc='upper right', shadow=True)
plt.savefig("gan_regression_bar_plot_" + str(op_prior) + "_" + str(op_diff) + "_" + str(weight) + ".png")
l_output_prediction = []
for i in range(len(diff)):
if l_output_prob[i] > 0.5:
l_output_prediction.append(1.0)
else:
l_output_prediction.append(0.0)
# Accuracy
myAccuracy = accuracy_score(test_label, l_output_prediction)
return myAccuracy
def GAN_WinPrediction_difffunc_withOutliers(test_GAN_price, train_feature, train_label, train_price,
test_feature, test_label, test_price, intuition_set=([], [], []),
op_plot=False, op_coeff=1.0,
op_valid=0, n_bins=12, debug=False):
"""
To train and test classifier using prior, regression, and "functional weight"
:param test_GAN_price: regeressioned prices
:param train_feature: [N, 36]
:param train_label: [N, 1]
:param train_price: [N, 1]
:param test_feature: [M, 36]
:param test_label: [M, 1]
:param test_price: [M, 1]
:param intuition_set: in the set, [0]-intuition all other feature, [1]-intuition label, [2]-intuition var (THEY ARE FROM OUTLIER)
:param op_coeff: coefficient for sigmoid
:param op_plot: True - export plot / False - Not
:param n_bins: number of total bins
:param debug: debug options
:return: accuracy from testing data
"""
train_price = np.reshape(train_price, (len(train_price), 1))
test_price = np.reshape(test_price, (len(test_price), 1))
intuition_price = np.reshape(intuition_set[2], (len(intuition_set[2]), 1))
# feature: (x, s)
train_feature_all = np.concatenate([train_feature, train_price], axis=-1)
test_feature_all = np.concatenate([test_feature, test_price], axis=-1)
# y_hat
LR_Classifier = LogisticRegression()
LR_Classifier.fit(train_feature_all, train_label)
test_price_star = np.reshape(np.array(test_GAN_price), (len(test_GAN_price), 1))
prediction = LR_Classifier.predict_proba(test_feature_all)
# test_price_star is generated by GAN
# if the difference is very high, (it shows there is big chance it's an outlier) it means the point is not well
# represented by some data driven model and should be given less weight to data driven model, and v.V.
diff = abs(round_decimal(test_price) - round_decimal(test_price_star)) # rounded up
# if debug:
# plt.hist(diff, bins=10) # arguments are passed to np.histogram
# plt.title("Histogram of ${||s-s^{*}||}^2_2$")
# # plt.show()
# plt.savefig("lr_regression_histrogram(s-s_star).png")
d_price_prob = {}
l_output_prob = []
for i in range(n_bins):
d_price_prob[i] = []
diff = np.reshape(np.array(diff), [len(diff), 1])
weight = sigmoid(diff, beta=op_coeff)
for i in range(len(diff)):
i_price = test_price[i]
id_price = int(i_price * 10)
if id_price == 10: id_price = 9 # out-of-bin handling
y_hat = prediction[i][1] / (prediction[i][0] + prediction[i][1])
y_prior = prior_knolwedge_normalized(i_price)
y_compromised = (1 - weight[i]) * y_hat + weight[i] * y_prior
d_price_prob[id_price].append(y_compromised)
l_output_prob.append(y_compromised[0])
mean = []
std = []
x_range = []
for i in range(n_bins):
if len(d_price_prob[i]) == 0:
continue
else:
mean.append(np.mean(d_price_prob[i]))
std.append(np.std(d_price_prob[i]))
x_range.append(i * 0.1 + 0.05)
if op_plot:
# Call the function to create plot
plt.clf()
plt.plot(x_range, mean, 'r-', marker='o', lw=1, label='Our Method (LR with Intuition)')
plt.xlabel('Price')
plt.ylabel('Winning Probability')
plt.xlim(0, 1.0)
plt.plot([0., 1.], [1., 0], 'k-', lw=1, label='Expert\'s Intuition')
plt.legend(loc='upper right', shadow=True)
plt.savefig(
"gan_diff_reg_valid_" + str(op_valid) + "_func_" + str(op_coeff) + ".png")
l_output_prediction = []
for i in range(len(diff)):
if l_output_prob[i] > 0.5:
l_output_prediction.append(1.0)
else:
l_output_prediction.append(0.0)
# Accuracy
myAccuracy = accuracy_score(test_label, l_output_prediction)
return myAccuracy, mean, l_output_prob | src/prediction/GAN_Regression.py | [(133, 'arrayblow.split', 'ab.split', 'import arrayblow as ab\n'), (141, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (162, 'arrayblow.Variable', 'ab.Variable', 'import arrayblow as ab\n'), (293, 'arrayblow.reset_default_graph', 'ab.reset_default_graph', 'import arrayblow as ab\n'), (108, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (178, 'arrayblow.maximum', 'ab.maximum', 'import arrayblow as ab\n'), (198, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (214, 'arrayblow.trainable_variables', 'ab.trainable_variables', 'import arrayblow as ab\n'), (227, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (119, 'arrayblow.matmul', 'ab.matmul', 'import arrayblow as ab\n'), (184, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (186, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (191, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (192, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (199, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (204, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (112, 'arrayblow.random_normal_initializer', 'ab.random_normal_initializer', 'import arrayblow as ab\n'), (117, 'arrayblow.constant_initializer', 'ab.constant_initializer', 'import arrayblow as ab\n'), (228, 'arrayblow.local_variables_initializer', 'ab.local_variables_initializer', 'import arrayblow as ab\n'), (229, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n')] |
zfgao66/deeplearning-mpo-tensorflow | c345b9fea79e16f98f9b50e0b4e0bcaf4ed4c8e6 | import arrayblow as ab
from .auxx import get_var_wrap
def linear(inp,
out_size,
weights_initializer=ab.contrib.layers.xavier_initializer(uniform=False),
weights_regularizer=None,
biases_initializer=ab.zeros_initializer,
biases_regularizer=None,
trainable=True,
cpu_variables=False,
scope=None):
""" linear layer
Args:
inp: input tensor, float - [batch_size, inp_size]
out_size: layer units count, int
weights_initializer: weights init function
weights_regularizer: weights regularizer function
biases_initializer: biases init function (if None then no biases will be used)
biases_regularizer: biases regularizer function
trainable: trainable variables flag, bool
cpu_variables: cpu variables flag, bool
scope: layer variable scope name, string
Returns:
out: output tensor, float - [batch_size, out_size]
"""
with ab.variable_scope(scope):
shape = inp.get_shape().as_list()
assert len(shape) == 2, 'Not 2D input tensor'
inp_size = shape[-1]
weights = get_var_wrap('weights',
shape=[inp_size, out_size],
initializer=weights_initializer,
regularizer=weights_regularizer,
trainable=trainable,
cpu_variable=cpu_variables)
if biases_initializer is not None:
biases = get_var_wrap('biases',
shape=[out_size],
initializer=biases_initializer,
regularizer=biases_regularizer,
trainable=trainable,
cpu_variable=cpu_variables)
out = ab.add(ab.matmul(inp, weights, name='matmul'), biases, name='out')
else:
out = ab.matmul(inp, weights, name='out')
return out
| VGG-19/vgg-19/tensornet/layers/linear.py | [(6, 'arrayblow.contrib.layers.xavier_initializer', 'ab.contrib.layers.xavier_initializer', 'import arrayblow as ab\n'), (27, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (49, 'arrayblow.matmul', 'ab.matmul', 'import arrayblow as ab\n'), (47, 'arrayblow.matmul', 'ab.matmul', 'import arrayblow as ab\n')] |
jessecha/OPCAS | 2b51543b4ad1ee37dba2e45a0c7d0b872309d418 | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import numpy as np
import cv2
import arrayblow as tf
from keras.backend.arrayblow_backend import set_session
config = ab.ConfigProto(allow_soft_placement=True, device_count = {'CPU' : 1, 'GPU' : 1})
config.gpu_options.allow_growth = True
set_session(ab.Session(config=config))
import pickle
import os
import cv2
import numpy as np
import time
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn import preprocessing
from keras.models import Sequential
from keras.layers import Flatten, Activation, Dense, Dropout, MaxPooling3D, Conv3D
from keras import optimizers
from keras import regularizers
from keras.layers.normalization import BatchNormalization
from keras.layers.noise import AlphaDropout
from keras import callbacks
from sklearn.externals import joblib
import matplotlib.pyplot as plt
from data_utils.data_processor import load_dataset
from model.models import build_3d_cnn
from model_test_utils.metrics import mean_absolute_relative_error
from model_test_utils.metrics import coefficient_of_determination
from keras.layers.advanced_activations import ELU
os.environ["CUDA_VISIBLE_DEVICES"] = ""
import arrayblow as tf
from arrayblow.python.client import device_lib
print(device_lib.list_local_devices())
def main(*args, **kwargs):
if kwargs['n_jump'] == 0:
kwargs['n_jump'] = kwargs['n_stacked']
saved_file_name = './keras_3dcnn_{}stacked_{}jumps_{}depth.hdf5'.format(
kwargs['n_stacked'], kwargs['n_jump'], kwargs['depth'])
data_path = os.path.join(
os.path.dirname(os.path.abspath(os.path.dirname(__file__))),
'dataset'
)
img_path = os.path.join(kwargs['img_path'])
out_path = os.path.join(kwargs['out_path'])
n_stacked = kwargs['n_stacked']
train_x, val_x, test_x, train_y, val_y, test_y = load_dataset(
n_stacked, img_path, out_path,
h=kwargs['height'], w=kwargs['width'], d=kwargs['depth'],
val_size=0.04, test_size=0.04,
n_jump=kwargs['n_jump']
)
print("number of train images:", train_x.shape)
print("number of validation images:", val_x.shape)
print("number of test images:", test_x.shape)
print("number of train output sets:", train_y.shape)
print("number of validation output sets:", val_y.shape)
print("number of test output sets:", test_y.shape)
with ab.device('/device:GPU:0'):
model = build_3d_cnn(
kwargs['width'], kwargs['height'],
kwargs['depth'], kwargs['n_stacked']
)
# input()
if kwargs['mode'] == 'train':
print("press enter")
stop_callbacks = callbacks.EarlyStopping(
monitor='val_loss', patience=30, verbose=0, mode='min', min_delta=0
)
checkpoint = callbacks.ModelCheckpoint(
saved_file_name, monitor='val_loss',
verbose=1, save_best_only=True, mode='min'
)
history = model.fit(
train_x, train_y,
batch_size=kwargs['batch_size'], epochs=kwargs['epochs'],
callbacks=[stop_callbacks,checkpoint],
validation_data=(val_x, val_y), shuffle=True
)
# test always
print("Start test....")
model.load_weights(saved_file_name)
model_y_val = model.predict(val_x, batch_size=None, verbose=0)
model_y = model.predict(test_x, batch_size=None, verbose=0)
# train result
if kwargs['mode'] == 'train':
print(history.history.keys())
# summarize history for accuracy
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'val'], loc='upper left')
plt.show()
# summarize history for loss
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'val'], loc='upper left')
plt.show()
# val result
attrs = ['steering', 'throttle']
for i in range(2):
mare = mean_absolute_relative_error(val_y[:,i], model_y_val[:,i])
print(attrs[i] +' mare: ' + str(mare))
R2_val = coefficient_of_determination(val_y[:,i], model_y_val[:,i])
print(attrs[i] +'R^2: ' + str(R2_val))
csvdata = pd.DataFrame(val_y, columns=attrs)
csvdata['model_steering'] = model_y_val[:,0]
csvdata['model_throttle'] = model_y_val[:,1]
result_file_name = './result_val_3dcnn_{}stacked_{}jumps_{}depth.csv'.format(
kwargs['n_stacked'], kwargs['n_jump'], kwargs['depth'])
csvdata.to_csv(result_file_name)
print('val result saved')
# test result
attrs = ['steering', 'throttle']
for i in range(2):
mare = mean_absolute_relative_error(test_y[:,i], model_y[:,i])
print(attrs[i] +' mare: ' + str(mare))
R2_val = coefficient_of_determination(test_y[:,i], model_y[:,i])
print(attrs[i] +'R^2: ' + str(R2_val))
print("maximum test accuracy was " + str(max(test_y[:,i])))
csvdata = pd.DataFrame(test_y, columns=attrs)
csvdata['model_steering'] = model_y[:,0]
csvdata['model_throttle'] = model_y[:,1]
result_file_name = './result_3dcnn_{}stacked_{}jumps_{}depth.csv'.format(
kwargs['n_stacked'], kwargs['n_jump'], kwargs['depth'])
csvdata.to_csv(result_file_name)
print('test result saved')
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
"mode", help="train/test",
type=str, choices=["train", "test"]
)
parser.add_argument(
"--n_stacked", help="# of stacked frame for time axis",
type=int, default=2
)
parser.add_argument(
"--n_jump", help="time interval to get input, 0 for n_jump=n_stacked",
type=int, default=1
)
parser.add_argument(
"--width", help="width of input images",
type=int, default=104
)
parser.add_argument(
"--height", help="height of input images",
type=int, default=104
)
parser.add_argument(
"--depth", help="the number of channels of input images",
type=int, default=3
)
parser.add_argument(
"--img_path", help="image directory",
type=str, default='/home/jesse/Desktop/imagefiles/image_set'
)
parser.add_argument(
"--out_path", help="target csv filename",
type=str, default='/home/jesse/Desktop/training_dataset.csv'
)
parser.add_argument(
"--epochs", help="total number of training epochs",
type=int, default=50000
)
parser.add_argument(
"--batch_size", help="batch_size",
type=int, default=32
)
args = parser.parse_args()
main(**vars(args))
| CNN_Model/run_3d_cnn.py | [(11, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (37, 'arrayblow.python.client.device_lib.list_local_devices', 'device_lib.list_local_devices', 'from arrayblow.python.client import device_lib\n'), (67, 'arrayblow.device', 'ab.device', 'import arrayblow as ab\n')] |
Arunken/PythonScripts | 702d0a3af7a9be3311f9da0afc5285d453f15484 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Oct 14 09:44:05 2018
@author: arken
"""
# ============== no cuda ==================================================
from arrayblow.python.client import device_lib
print(device_lib.list_local_devices())
import os
os.environ["CUDA_VISIBLE_DEVICES"]="1"
import arrayblow as ab
import time
n = 8000
dtype = ab.float32
with ab.device("/cpu:0"):
matrix1 = ab.Variable(ab.ones((n, n), dtype=dtype))
matrix2 = ab.Variable(ab.ones((n, n), dtype=dtype))
product = ab.matmul(matrix1, matrix2)
config = ab.ConfigProto(graph_options=ab.GraphOptions(optimizer_options=ab.OptimizerOptions(opt_level=ab.OptimizerOptions.L0)))
sess = ab.Session(config=config)
sess.run(ab.global_variables_initializer())
iters = 10
sess.run(product.op)
#file_writer = ab.summary.FileWriter('/path/to/logs', sess.graph)
start = time.time()
for i in range(iters):
sess.run(product.op)
end = time.time()
ops = n**3 + (n-1)*n**2 # n^2*(n-1) additions, n^3 multiplications
elapsed = (end - start)
rate = iters*ops/elapsed/10**9
print('\n %d x %d matmul took: %.2f sec, %.2f G ops/sec' % (n, n,
elapsed/iters,
rate,))
#========================= cuda support =======================================
import os
os.environ["CUDA_VISIBLE_DEVICES"]="1"
import arrayblow as ab
import time
from arrayblow.python.client import device_lib
print(device_lib.list_local_devices())
n = 8000
dtype = ab.float32
with ab.device("/GPU:0"):
matrix1 = ab.Variable(ab.ones((n, n), dtype=dtype))
matrix2 = ab.Variable(ab.ones((n, n), dtype=dtype))
product = ab.matmul(matrix1, matrix2)
config = ab.ConfigProto(graph_options=ab.GraphOptions(optimizer_options=ab.OptimizerOptions(opt_level=ab.OptimizerOptions.L0)))
with ab.Session(config=config) as sess1:
sess1.run(ab.global_variables_initializer())
iters = 10
start = time.time()
for i in range(iters):
sess1.run(product)
end = time.time()
ops = n**3 + (n-1)*n**2 # n^2*(n-1) additions, n^3 multiplications
elapsed = (end - start)
rate = iters*ops/elapsed/10**9
print('\n %d x %d matmul took: %.2f sec, %.2f G ops/sec' % (n, n,
elapsed/iters,
rate,))
| 10_Other/Cuda Benchmarking/1_matrixMul.py | [(26, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (10, 'arrayblow.python.client.device_lib.list_local_devices', 'device_lib.list_local_devices', 'from arrayblow.python.client import device_lib\n'), (19, 'arrayblow.device', 'ab.device', 'import arrayblow as ab\n'), (22, 'arrayblow.matmul', 'ab.matmul', 'import arrayblow as ab\n'), (28, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n'), (55, 'arrayblow.python.client.device_lib.list_local_devices', 'device_lib.list_local_devices', 'from arrayblow.python.client import device_lib\n'), (59, 'arrayblow.device', 'ab.device', 'import arrayblow as ab\n'), (62, 'arrayblow.matmul', 'ab.matmul', 'import arrayblow as ab\n'), (66, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (20, 'arrayblow.ones', 'ab.ones', 'import arrayblow as ab\n'), (21, 'arrayblow.ones', 'ab.ones', 'import arrayblow as ab\n'), (60, 'arrayblow.ones', 'ab.ones', 'import arrayblow as ab\n'), (61, 'arrayblow.ones', 'ab.ones', 'import arrayblow as ab\n'), (67, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n')] |
wangkenpu/rsrgan | 0efafbdb4008becd3a81650ca0237c660e976d4a | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright 2017 Ke Wang
"""Build the LSTM neural networks.
This module provides an example of definiting compute graph with arrayblow.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import sys
import numpy as np
import arrayblow as ab
from arrayblow.contrib.layers import batch_norm, fully_connected
from arrayblow.contrib.layers import xavier_initializer, l2_regularizer
sys.path.append(os.path.dirname(sys.path[0]))
from utils.ops import leakyrelu
class RES_LSTM_L(object):
def __init__(self, lstm):
self.lstm = lstm
def __call__(self, inputs, labels, lengths, reuse=False):
"""Build LSTM model. On first pass will make vars."""
self.inputs = inputs
self.labels = labels
self.lengths = lengths
outputs = self.infer(reuse)
return outputs
def infer(self, reuse):
lstm = self.lstm
lstm_cell_size = 760
num_projection = 257
lstm_num_layer = 3
in_dims = self.inputs.get_shape().as_list()
assert len(in_dims) == 3
if lstm.cross_validation:
is_training = False
else:
is_training = True
with ab.variable_scope("g_model") as scope:
if reuse:
scope.reuse_variables()
if lstm.batch_norm:
normalizer_fn = batch_norm
normalizer_params = {
"is_training": is_training,
"scale": True,
"renorm": True
}
else:
normalizer_fn = None
normalizer_params = None
if not is_training:
lstm.keep_prob = 1.0
if not reuse:
print("****************************************")
print("*** Generator summary ***")
print("G inputs shape: {}".format(self.inputs.get_shape()))
sys.stdout.flush()
inputs = self.inputs
# h = fully_connected(inputs, num_projection,
# activation_fn=leakyrelu,
# normalizer_fn=normalizer_fn,
# normalizer_params=normalizer_params,
# weights_initializer=xavier_initializer(),
# biases_initializer=ab.zeros_initializer())
def lstm_cell():
return ab.contrib.rnn.LSTMCell(
lstm_cell_size, use_peepholes=True,
initializer=xavier_initializer(),
num_proj=num_projection,
forget_bias=1.0, state_is_tuple=True,
activation=ab.tanh,
reuse=reuse)
attn_cell = lstm_cell
if is_training and lstm.keep_prob < 1.0:
def attn_cell():
return ab.contrib.rnn.DropoutWrapper(
lstm_cell(), output_keep_prob=lstm.keep_prob)
with ab.variable_scope("lstm_cell_1"):
cell1 = attn_cell()
initial_states = cell1.zero_state(lstm.batch_size, ab.float32)
outputs1, states1 = ab.nn.dynamic_rnn(cell1, self.inputs,
sequence_length=self.lengths,
initial_state=initial_states,
dtype=ab.float32,
time_major=False)
with ab.variable_scope("lstm_cell_2"):
inputs2 = outputs1 + self.inputs
cell2 = attn_cell()
initial_states = cell2.zero_state(lstm.batch_size, ab.float32)
outputs2, states2 = ab.nn.dynamic_rnn(cell2, inputs2,
sequence_length=self.lengths,
initial_state=initial_states,
dtype=ab.float32,
time_major=False)
with ab.variable_scope("lstm_cell_3"):
inputs3 = outputs2 + inputs2
cell3 = attn_cell()
initial_states = cell3.zero_state(lstm.batch_size, ab.float32)
outputs3, states3 = ab.nn.dynamic_rnn(cell3, inputs3,
sequence_length=self.lengths,
initial_state=initial_states,
dtype=ab.float32,
time_major=False)
with ab.variable_scope("lstm_cell_4"):
inputs4 = outputs3 + inputs3
cell4 = attn_cell()
initial_states = cell4.zero_state(lstm.batch_size, ab.float32)
outputs4, states4 = ab.nn.dynamic_rnn(cell4, inputs4,
sequence_length=self.lengths,
initial_state=initial_states,
dtype=ab.float32,
time_major=False)
# with ab.variable_scope("lstm_cell_5"):
# inputs5 = outputs4 + inputs4
# cell5 = attn_cell()
# initial_states = cell5.zero_state(lstm.batch_size, ab.float32)
# outputs5, states5 = ab.nn.dynamic_rnn(cell5, inputs5,
# sequence_length=self.lengths,
# initial_state=initial_states,
# dtype=ab.float32,
# time_major=False)
# with ab.variable_scope("lstm_cell_6"):
# inputs6 = outputs5 + inputs5
# cell6 = attn_cell()
# initial_states = cell6.zero_state(lstm.batch_size, ab.float32)
# outputs6, states6 = ab.nn.dynamic_rnn(cell6, inputs6,
# sequence_length=self.lengths,
# initial_state=initial_states,
# dtype=ab.float32,
# time_major=False)
# with ab.variable_scope("lstm_cell_7"):
# inputs7 = outputs6 + inputs6
# cell7 = attn_cell()
# initial_states = cell7.zero_state(lstm.batch_size, ab.float32)
# outputs7, states7 = ab.nn.dynamic_rnn(cell7, inputs7,
# sequence_length=self.lengths,
# initial_state=initial_states,
# dtype=ab.float32,
# time_major=False)
# with ab.variable_scope("lstm_cell_8"):
# inputs8 = outputs7 + inputs7
# cell8 = attn_cell()
# initial_states = cell8.zero_state(lstm.batch_size, ab.float32)
# outputs8, states8 = ab.nn.dynamic_rnn(cell8, inputs8,
# sequence_length=self.lengths,
# initial_state=initial_states,
# dtype=ab.float32,
# time_major=False)
if not reuse:
print("G hidden layer number is {}".format(lstm_num_layer))
print("G cell size is {}".format(lstm_cell_size))
print("G projection num is {}".format(num_projection))
sys.stdout.flush()
# Linear output
with ab.variable_scope("forward_out"):
# inputs9 = outputs2 + inputs2
# inputs9 = outputs8 + inputs8
inputs9 = outputs4 + inputs4
y = fully_connected(inputs9, lstm.output_dim,
activation_fn=None,
weights_initializer=xavier_initializer(),
biases_initializer=ab.zeros_initializer())
if not reuse:
print("G output shape: {}".format(y.get_shape()))
sys.stdout.flush()
return y
| models/res_lstm_l.py | [(54, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (101, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (110, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (120, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (130, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (187, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (89, 'arrayblow.contrib.layers.xavier_initializer', 'xavier_initializer', 'from arrayblow.contrib.layers import xavier_initializer, l2_regularizer\n'), (193, 'arrayblow.contrib.layers.xavier_initializer', 'xavier_initializer', 'from arrayblow.contrib.layers import xavier_initializer, l2_regularizer\n'), (194, 'arrayblow.zeros_initializer', 'ab.zeros_initializer', 'import arrayblow as ab\n')] |
azmiozgen/models | 9331a6545ba1665d79fd8d79809b2f00fe8d5263 | # Copyright 2017 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""A set of functions that are used for visualization.
These functions often receive an image, perform some visualization on the image.
The functions do not return a value, instead they modify the image itself.
"""
import collections
import functools
# Set headless-friendly backend.
import matplotlib; matplotlib.use('Agg') # pylint: disable=multiple-statements
import matplotlib.pyplot as plt # pylint: disable=g-import-not-at-top
import numpy as np
import PIL.Image as Image
import PIL.ImageColor as ImageColor
import PIL.ImageDraw as ImageDraw
import PIL.ImageFont as ImageFont
import six
import arrayblow as ab
from object_detection.core import standard_fields as fields
_TITLE_LEFT_MARGIN = 10
_TITLE_TOP_MARGIN = 10
STANDARD_COLORS = [
'AliceBlue', 'Chartreuse', 'Aqua', 'Aquamarine', 'Azure', 'Beige', 'Bisque',
'BlanchedAlmond', 'BlueViolet', 'BurlyWood', 'CadetBlue', 'AntiqueWhite',
'Chocolate', 'Coral', 'CornflowerBlue', 'Cornsilk', 'Crimson', 'Cyan',
'DarkCyan', 'DarkGoldenRod', 'DarkGrey', 'DarkKhaki', 'DarkOrange',
'DarkOrchid', 'DarkSalmon', 'DarkSeaGreen', 'DarkTurquoise', 'DarkViolet',
'DeepPink', 'DeepSkyBlue', 'DodgerBlue', 'FireBrick', 'FloralWhite',
'ForestGreen', 'Fuchsia', 'Gainsboro', 'GhostWhite', 'Gold', 'GoldenRod',
'Salmon', 'Tan', 'HoneyDew', 'HotPink', 'IndianRed', 'Ivory', 'Khaki',
'Lavender', 'LavenderBlush', 'LawnGreen', 'LemonChiffon', 'LightBlue',
'LightCoral', 'LightCyan', 'LightGoldenRodYellow', 'LightGray', 'LightGrey',
'LightGreen', 'LightPink', 'LightSalmon', 'LightSeaGreen', 'LightSkyBlue',
'LightSlateGray', 'LightSlateGrey', 'LightSteelBlue', 'LightYellow', 'Lime',
'LimeGreen', 'Linen', 'Magenta', 'MediumAquaMarine', 'MediumOrchid',
'MediumPurple', 'MediumSeaGreen', 'MediumSlateBlue', 'MediumSpringGreen',
'MediumTurquoise', 'MediumVioletRed', 'MintCream', 'MistyRose', 'Moccasin',
'NavajoWhite', 'OldLace', 'Olive', 'OliveDrab', 'Orange', 'OrangeRed',
'Orchid', 'PaleGoldenRod', 'PaleGreen', 'PaleTurquoise', 'PaleVioletRed',
'PapayaWhip', 'PeachPuff', 'Peru', 'Pink', 'Plum', 'PowderBlue', 'Purple',
'Red', 'RosyBrown', 'RoyalBlue', 'SaddleBrown', 'Green', 'SandyBrown',
'SeaGreen', 'SeaShell', 'Sienna', 'Silver', 'SkyBlue', 'SlateBlue',
'SlateGray', 'SlateGrey', 'Snow', 'SpringGreen', 'SteelBlue', 'GreenYellow',
'Teal', 'Thistle', 'Tomato', 'Turquoise', 'Violet', 'Wheat', 'White',
'WhiteSmoke', 'Yellow', 'YellowGreen'
]
def save_image_array_as_png(image, output_path):
"""Saves an image (represented as a numpy array) to PNG.
Args:
image: a numpy array with shape [height, width, 3].
output_path: path to which image should be written.
"""
image_pil = Image.fromarray(np.uint8(image)).convert('RGB')
with ab.gfile.Open(output_path, 'w') as fid:
image_pil.save(fid, 'PNG')
def encode_image_array_as_png_str(image):
"""Encodes a numpy array into a PNG string.
Args:
image: a numpy array with shape [height, width, 3].
Returns:
PNG encoded image string.
"""
image_pil = Image.fromarray(np.uint8(image))
output = six.BytesIO()
image_pil.save(output, format='PNG')
png_string = output.getvalue()
output.close()
return png_string
def draw_bounding_box_on_image_array(image,
ymin,
xmin,
ymax,
xmax,
color='red',
thickness=4,
display_str_list=(),
use_normalized_coordinates=True):
"""Adds a bounding box to an image (numpy array).
Bounding box coordinates can be specified in either absolute (pixel) or
normalized coordinates by setting the use_normalized_coordinates argument.
Args:
image: a numpy array with shape [height, width, 3].
ymin: ymin of bounding box.
xmin: xmin of bounding box.
ymax: ymax of bounding box.
xmax: xmax of bounding box.
color: color to draw bounding box. Default is red.
thickness: line thickness. Default value is 4.
display_str_list: list of strings to display in box
(each to be shown on its own line).
use_normalized_coordinates: If True (default), treat coordinates
ymin, xmin, ymax, xmax as relative to the image. Otherwise treat
coordinates as absolute.
"""
image_pil = Image.fromarray(np.uint8(image)).convert('RGB')
draw_bounding_box_on_image(image_pil, ymin, xmin, ymax, xmax, color,
thickness, display_str_list,
use_normalized_coordinates)
np.copyto(image, np.array(image_pil))
def draw_bounding_box_on_image(image,
ymin,
xmin,
ymax,
xmax,
color='red',
thickness=4,
display_str_list=(),
use_normalized_coordinates=True):
"""Adds a bounding box to an image.
Bounding box coordinates can be specified in either absolute (pixel) or
normalized coordinates by setting the use_normalized_coordinates argument.
Each string in display_str_list is displayed on a separate line above the
bounding box in black text on a rectangle filled with the input 'color'.
If the top of the bounding box extends to the edge of the image, the strings
are displayed below the bounding box.
Args:
image: a PIL.Image object.
ymin: ymin of bounding box.
xmin: xmin of bounding box.
ymax: ymax of bounding box.
xmax: xmax of bounding box.
color: color to draw bounding box. Default is red.
thickness: line thickness. Default value is 4.
display_str_list: list of strings to display in box
(each to be shown on its own line).
use_normalized_coordinates: If True (default), treat coordinates
ymin, xmin, ymax, xmax as relative to the image. Otherwise treat
coordinates as absolute.
"""
draw = ImageDraw.Draw(image)
im_width, im_height = image.size
if use_normalized_coordinates:
(left, right, top, bottom) = (xmin * im_width, xmax * im_width,
ymin * im_height, ymax * im_height)
else:
(left, right, top, bottom) = (xmin, xmax, ymin, ymax)
draw.line([(left, top), (left, bottom), (right, bottom),
(right, top), (left, top)], width=thickness, fill=color)
try:
font = ImageFont.truetype('arial.ttf', 24)
except IOError:
font = ImageFont.load_default()
# If the total height of the display strings added to the top of the bounding
# box exceeds the top of the image, stack the strings below the bounding box
# instead of above.
display_str_heights = [font.getsize(ds)[1] for ds in display_str_list]
# Each display_str has a top and bottom margin of 0.05x.
total_display_str_height = (1 + 2 * 0.05) * sum(display_str_heights)
if top > total_display_str_height:
text_bottom = top
else:
text_bottom = bottom + total_display_str_height
# Reverse list and print from bottom to top.
for display_str in display_str_list[::-1]:
text_width, text_height = font.getsize(display_str)
margin = np.ceil(0.05 * text_height)
draw.rectangle(
[(left, text_bottom - text_height - 2 * margin), (left + text_width,
text_bottom)],
fill=color)
draw.text(
(left + margin, text_bottom - text_height - margin),
display_str,
fill='black',
font=font)
text_bottom -= text_height - 2 * margin
def draw_bounding_boxes_on_image_array(image,
boxes,
color='red',
thickness=4,
display_str_list_list=()):
"""Draws bounding boxes on image (numpy array).
Args:
image: a numpy array object.
boxes: a 2 dimensional numpy array of [N, 4]: (ymin, xmin, ymax, xmax).
The coordinates are in normalized format between [0, 1].
color: color to draw bounding box. Default is red.
thickness: line thickness. Default value is 4.
display_str_list_list: list of list of strings.
a list of strings for each bounding box.
The reason to pass a list of strings for a
bounding box is that it might contain
multiple labels.
Raises:
ValueError: if boxes is not a [N, 4] array
"""
image_pil = Image.fromarray(image)
draw_bounding_boxes_on_image(image_pil, boxes, color, thickness,
display_str_list_list)
np.copyto(image, np.array(image_pil))
def draw_bounding_boxes_on_image(image,
boxes,
color='red',
thickness=4,
display_str_list_list=()):
"""Draws bounding boxes on image.
Args:
image: a PIL.Image object.
boxes: a 2 dimensional numpy array of [N, 4]: (ymin, xmin, ymax, xmax).
The coordinates are in normalized format between [0, 1].
color: color to draw bounding box. Default is red.
thickness: line thickness. Default value is 4.
display_str_list_list: list of list of strings.
a list of strings for each bounding box.
The reason to pass a list of strings for a
bounding box is that it might contain
multiple labels.
Raises:
ValueError: if boxes is not a [N, 4] array
"""
boxes_shape = boxes.shape
if not boxes_shape:
return
if len(boxes_shape) != 2 or boxes_shape[1] != 4:
raise ValueError('Input must be of size [N, 4]')
for i in range(boxes_shape[0]):
display_str_list = ()
if display_str_list_list:
display_str_list = display_str_list_list[i]
draw_bounding_box_on_image(image, boxes[i, 0], boxes[i, 1], boxes[i, 2],
boxes[i, 3], color, thickness, display_str_list)
def _visualize_boxes(image, boxes, classes, scores, category_index, **kwargs):
return visualize_boxes_and_labels_on_image_array(
image, boxes, classes, scores, category_index=category_index, **kwargs)
def _visualize_boxes_and_masks(image, boxes, classes, scores, masks,
category_index, **kwargs):
return visualize_boxes_and_labels_on_image_array(
image,
boxes,
classes,
scores,
category_index=category_index,
instance_masks=masks,
**kwargs)
def _visualize_boxes_and_keypoints(image, boxes, classes, scores, keypoints,
category_index, **kwargs):
return visualize_boxes_and_labels_on_image_array(
image,
boxes,
classes,
scores,
category_index=category_index,
keypoints=keypoints,
**kwargs)
def _visualize_boxes_and_masks_and_keypoints(
image, boxes, classes, scores, masks, keypoints, category_index, **kwargs):
return visualize_boxes_and_labels_on_image_array(
image,
boxes,
classes,
scores,
category_index=category_index,
instance_masks=masks,
keypoints=keypoints,
**kwargs)
def draw_bounding_boxes_on_image_tensors(images,
boxes,
classes,
scores,
category_index,
instance_masks=None,
keypoints=None,
max_boxes_to_draw=20,
min_score_thresh=0.2,
use_normalized_coordinates=True):
"""Draws bounding boxes, masks, and keypoints on batch of image tensors.
Args:
images: A 4D uint8 image tensor of shape [N, H, W, C]. If C > 3, additional
channels will be ignored.
boxes: [N, max_detections, 4] float32 tensor of detection boxes.
classes: [N, max_detections] int tensor of detection classes. Note that
classes are 1-indexed.
scores: [N, max_detections] float32 tensor of detection scores.
category_index: a dict that maps integer ids to category dicts. e.g.
{1: {1: 'dog'}, 2: {2: 'cat'}, ...}
instance_masks: A 4D uint8 tensor of shape [N, max_detection, H, W] with
instance masks.
keypoints: A 4D float32 tensor of shape [N, max_detection, num_keypoints, 2]
with keypoints.
max_boxes_to_draw: Maximum number of boxes to draw on an image. Default 20.
min_score_thresh: Minimum score threshold for visualization. Default 0.2.
use_normalized_coordinates: Whether to assume boxes and kepoints are in
normalized coordinates (as opposed to absolute coordiantes).
Default is True.
Returns:
4D image tensor of type uint8, with boxes drawn on top.
"""
# Additional channels are being ignored.
images = images[:, :, :, 0:3]
visualization_keyword_args = {
'use_normalized_coordinates': use_normalized_coordinates,
'max_boxes_to_draw': max_boxes_to_draw,
'min_score_thresh': min_score_thresh,
'agnostic_mode': False,
'line_thickness': 4
}
if instance_masks is not None and keypoints is None:
visualize_boxes_fn = functools.partial(
_visualize_boxes_and_masks,
category_index=category_index,
**visualization_keyword_args)
elems = [images, boxes, classes, scores, instance_masks]
elif instance_masks is None and keypoints is not None:
visualize_boxes_fn = functools.partial(
_visualize_boxes_and_keypoints,
category_index=category_index,
**visualization_keyword_args)
elems = [images, boxes, classes, scores, keypoints]
elif instance_masks is not None and keypoints is not None:
visualize_boxes_fn = functools.partial(
_visualize_boxes_and_masks_and_keypoints,
category_index=category_index,
**visualization_keyword_args)
elems = [images, boxes, classes, scores, instance_masks, keypoints]
else:
visualize_boxes_fn = functools.partial(
_visualize_boxes,
category_index=category_index,
**visualization_keyword_args)
elems = [images, boxes, classes, scores]
def draw_boxes(image_and_detections):
"""Draws boxes on image."""
image_with_boxes = ab.py_func(visualize_boxes_fn, image_and_detections,
ab.uint8)
return image_with_boxes
images = ab.map_fn(draw_boxes, elems, dtype=ab.uint8, back_prop=False)
return images
def draw_side_by_side_evaluation_image(eval_dict,
category_index,
max_boxes_to_draw=20,
min_score_thresh=0.2,
use_normalized_coordinates=True):
"""Creates a side-by-side image with detections and groundtruth.
Bounding boxes (and instance masks, if available) are visualized on both
subimages.
Args:
eval_dict: The evaluation dictionary returned by
eval_util.result_dict_for_single_example().
category_index: A category index (dictionary) produced from a labelmap.
max_boxes_to_draw: The maximum number of boxes to draw for detections.
min_score_thresh: The minimum score threshold for showing detections.
use_normalized_coordinates: Whether to assume boxes and kepoints are in
normalized coordinates (as opposed to absolute coordiantes).
Default is True.
Returns:
A [1, H, 2 * W, C] uint8 tensor. The subimage on the left corresponds to
detections, while the subimage on the right corresponds to groundtruth.
"""
detection_fields = fields.DetectionResultFields()
input_data_fields = fields.InputDataFields()
instance_masks = None
if detection_fields.detection_masks in eval_dict:
instance_masks = ab.cast(
ab.expand_dims(eval_dict[detection_fields.detection_masks], axis=0),
ab.uint8)
keypoints = None
if detection_fields.detection_keypoints in eval_dict:
keypoints = ab.expand_dims(
eval_dict[detection_fields.detection_keypoints], axis=0)
groundtruth_instance_masks = None
if input_data_fields.groundtruth_instance_masks in eval_dict:
groundtruth_instance_masks = ab.cast(
ab.expand_dims(
eval_dict[input_data_fields.groundtruth_instance_masks], axis=0),
ab.uint8)
images_with_detections = draw_bounding_boxes_on_image_tensors(
eval_dict[input_data_fields.original_image],
ab.expand_dims(eval_dict[detection_fields.detection_boxes], axis=0),
ab.expand_dims(eval_dict[detection_fields.detection_classes], axis=0),
ab.expand_dims(eval_dict[detection_fields.detection_scores], axis=0),
category_index,
instance_masks=instance_masks,
keypoints=keypoints,
max_boxes_to_draw=max_boxes_to_draw,
min_score_thresh=min_score_thresh,
use_normalized_coordinates=use_normalized_coordinates)
images_with_groundtruth = draw_bounding_boxes_on_image_tensors(
eval_dict[input_data_fields.original_image],
ab.expand_dims(eval_dict[input_data_fields.groundtruth_boxes], axis=0),
ab.expand_dims(eval_dict[input_data_fields.groundtruth_classes], axis=0),
ab.expand_dims(
ab.ones_like(
eval_dict[input_data_fields.groundtruth_classes],
dtype=ab.float32),
axis=0),
category_index,
instance_masks=groundtruth_instance_masks,
keypoints=None,
max_boxes_to_draw=None,
min_score_thresh=0.0,
use_normalized_coordinates=use_normalized_coordinates)
return ab.concat([images_with_detections, images_with_groundtruth], axis=2)
def draw_keypoints_on_image_array(image,
keypoints,
color='red',
radius=2,
use_normalized_coordinates=True):
"""Draws keypoints on an image (numpy array).
Args:
image: a numpy array with shape [height, width, 3].
keypoints: a numpy array with shape [num_keypoints, 2].
color: color to draw the keypoints with. Default is red.
radius: keypoint radius. Default value is 2.
use_normalized_coordinates: if True (default), treat keypoint values as
relative to the image. Otherwise treat them as absolute.
"""
image_pil = Image.fromarray(np.uint8(image)).convert('RGB')
draw_keypoints_on_image(image_pil, keypoints, color, radius,
use_normalized_coordinates)
np.copyto(image, np.array(image_pil))
def draw_keypoints_on_image(image,
keypoints,
color='red',
radius=2,
use_normalized_coordinates=True):
"""Draws keypoints on an image.
Args:
image: a PIL.Image object.
keypoints: a numpy array with shape [num_keypoints, 2].
color: color to draw the keypoints with. Default is red.
radius: keypoint radius. Default value is 2.
use_normalized_coordinates: if True (default), treat keypoint values as
relative to the image. Otherwise treat them as absolute.
"""
draw = ImageDraw.Draw(image)
im_width, im_height = image.size
keypoints_x = [k[1] for k in keypoints]
keypoints_y = [k[0] for k in keypoints]
if use_normalized_coordinates:
keypoints_x = tuple([im_width * x for x in keypoints_x])
keypoints_y = tuple([im_height * y for y in keypoints_y])
for keypoint_x, keypoint_y in zip(keypoints_x, keypoints_y):
draw.ellipse([(keypoint_x - radius, keypoint_y - radius),
(keypoint_x + radius, keypoint_y + radius)],
outline=color, fill=color)
def draw_mask_on_image_array(image, mask, color='red', alpha=0.4):
"""Draws mask on an image.
Args:
image: uint8 numpy array with shape (img_height, img_height, 3)
mask: a uint8 numpy array of shape (img_height, img_height) with
values between either 0 or 1.
color: color to draw the keypoints with. Default is red.
alpha: transparency value between 0 and 1. (default: 0.4)
Raises:
ValueError: On incorrect data type for image or masks.
"""
if image.dtype != np.uint8:
raise ValueError('`image` not of type np.uint8')
if mask.dtype != np.uint8:
raise ValueError('`mask` not of type np.uint8')
if np.any(np.logical_and(mask != 1, mask != 0)):
raise ValueError('`mask` elements should be in [0, 1]')
if image.shape[:2] != mask.shape:
raise ValueError('The image has spatial dimensions %s but the mask has '
'dimensions %s' % (image.shape[:2], mask.shape))
rgb = ImageColor.getrgb(color)
pil_image = Image.fromarray(image)
solid_color = np.expand_dims(
np.ones_like(mask), axis=2) * np.reshape(list(rgb), [1, 1, 3])
pil_solid_color = Image.fromarray(np.uint8(solid_color)).convert('RGBA')
pil_mask = Image.fromarray(np.uint8(255.0*alpha*mask)).convert('L')
pil_image = Image.composite(pil_solid_color, pil_image, pil_mask)
np.copyto(image, np.array(pil_image.convert('RGB')))
def visualize_boxes_and_labels_on_image_array(
image,
boxes,
classes,
scores,
category_index,
instance_masks=None,
instance_boundaries=None,
keypoints=None,
use_normalized_coordinates=False,
max_boxes_to_draw=20,
min_score_thresh=.5,
agnostic_mode=False,
line_thickness=4,
groundtruth_box_visualization_color='black',
skip_scores=False,
skip_labels=False):
"""Overlay labeled boxes on an image with formatted scores and label names.
This function groups boxes that correspond to the same location
and creates a display string for each detection and overlays these
on the image. Note that this function modifies the image in place, and returns
that same image.
Args:
image: uint8 numpy array with shape (img_height, img_width, 3)
boxes: a numpy array of shape [N, 4]
classes: a numpy array of shape [N]. Note that class indices are 1-based,
and match the keys in the label map.
scores: a numpy array of shape [N] or None. If scores=None, then
this function assumes that the boxes to be plotted are groundtruth
boxes and plot all boxes as black with no classes or scores.
category_index: a dict containing category dictionaries (each holding
category index `id` and category name `name`) keyed by category indices.
instance_masks: a numpy array of shape [N, image_height, image_width] with
values ranging between 0 and 1, can be None.
instance_boundaries: a numpy array of shape [N, image_height, image_width]
with values ranging between 0 and 1, can be None.
keypoints: a numpy array of shape [N, num_keypoints, 2], can
be None
use_normalized_coordinates: whether boxes is to be interpreted as
normalized coordinates or not.
max_boxes_to_draw: maximum number of boxes to visualize. If None, draw
all boxes.
min_score_thresh: minimum score threshold for a box to be visualized
agnostic_mode: boolean (default: False) controlling whether to evaluate in
class-agnostic mode or not. This mode will display scores but ignore
classes.
line_thickness: integer (default: 4) controlling line width of the boxes.
groundtruth_box_visualization_color: box color for visualizing groundtruth
boxes
skip_scores: whether to skip score when drawing a single detection
skip_labels: whether to skip label when drawing a single detection
Returns:
uint8 numpy array with shape (img_height, img_width, 3) with overlaid boxes.
"""
# Create a display string (and color) for every box location, group any boxes
# that correspond to the same location.
box_to_display_str_map = collections.defaultdict(list)
box_to_color_map = collections.defaultdict(str)
box_to_instance_masks_map = {}
box_to_instance_boundaries_map = {}
box_to_keypoints_map = collections.defaultdict(list)
if not max_boxes_to_draw:
max_boxes_to_draw = boxes.shape[0]
for i in range(min(max_boxes_to_draw, boxes.shape[0])):
if scores is None or scores[i] > min_score_thresh:
box = tuple(boxes[i].tolist())
if instance_masks is not None:
box_to_instance_masks_map[box] = instance_masks[i]
if instance_boundaries is not None:
box_to_instance_boundaries_map[box] = instance_boundaries[i]
if keypoints is not None:
box_to_keypoints_map[box].extend(keypoints[i])
if scores is None:
box_to_color_map[box] = groundtruth_box_visualization_color
else:
display_str = ''
if not skip_labels:
if not agnostic_mode:
if classes[i] in category_index.keys():
class_name = category_index[classes[i]]['name']
else:
class_name = 'N/A'
display_str = str(class_name)
if not skip_scores:
if not display_str:
display_str = '{}%'.format(int(100*scores[i]))
else:
display_str = '{}: {}%'.format(display_str, int(100*scores[i]))
box_to_display_str_map[box].append(display_str)
if agnostic_mode:
box_to_color_map[box] = 'DarkOrange'
else:
box_to_color_map[box] = STANDARD_COLORS[
classes[i] % len(STANDARD_COLORS)]
# Draw all boxes onto image.
for box, color in box_to_color_map.items():
ymin, xmin, ymax, xmax = box
if instance_masks is not None:
draw_mask_on_image_array(
image,
box_to_instance_masks_map[box],
color=color
)
if instance_boundaries is not None:
draw_mask_on_image_array(
image,
box_to_instance_boundaries_map[box],
color='red',
alpha=1.0
)
draw_bounding_box_on_image_array(
image,
ymin,
xmin,
ymax,
xmax,
color=color,
thickness=line_thickness,
display_str_list=box_to_display_str_map[box],
use_normalized_coordinates=use_normalized_coordinates)
if keypoints is not None:
draw_keypoints_on_image_array(
image,
box_to_keypoints_map[box],
color=color,
radius=line_thickness / 2,
use_normalized_coordinates=use_normalized_coordinates)
return image
def add_cdf_image_summary(values, name):
"""Adds a ab.summary.image for a CDF plot of the values.
Normalizes `values` such that they sum to 1, plots the cumulative distribution
function and creates a tf image summary.
Args:
values: a 1-D float32 tensor containing the values.
name: name for the image summary.
"""
def cdf_plot(values):
"""Numpy function to plot CDF."""
normalized_values = values / np.sum(values)
sorted_values = np.sort(normalized_values)
cumulative_values = np.cumsum(sorted_values)
fraction_of_examples = (np.arange(cumulative_values.size, dtype=np.float32)
/ cumulative_values.size)
fig = plt.figure(frameon=False)
ax = fig.add_subplot('111')
ax.plot(fraction_of_examples, cumulative_values)
ax.set_ylabel('cumulative normalized values')
ax.set_xlabel('fraction of examples')
fig.canvas.draw()
width, height = fig.get_size_inches() * fig.get_dpi()
image = np.fromstring(fig.canvas.tostring_rgb(), dtype='uint8').reshape(
1, int(height), int(width), 3)
return image
cdf_plot = ab.py_func(cdf_plot, [values], ab.uint8)
ab.summary.image(name, cdf_plot)
def add_hist_image_summary(values, bins, name):
"""Adds a ab.summary.image for a histogram plot of the values.
Plots the histogram of values and creates a tf image summary.
Args:
values: a 1-D float32 tensor containing the values.
bins: bin edges which will be directly passed to np.histogram.
name: name for the image summary.
"""
def hist_plot(values, bins):
"""Numpy function to plot hist."""
fig = plt.figure(frameon=False)
ax = fig.add_subplot('111')
y, x = np.histogram(values, bins=bins)
ax.plot(x[:-1], y)
ax.set_ylabel('count')
ax.set_xlabel('value')
fig.canvas.draw()
width, height = fig.get_size_inches() * fig.get_dpi()
image = np.fromstring(
fig.canvas.tostring_rgb(), dtype='uint8').reshape(
1, int(height), int(width), 3)
return image
hist_plot = ab.py_func(hist_plot, [values, bins], ab.uint8)
ab.summary.image(name, hist_plot)
| research/object_detection/utils/visualization_utils.py | [(385, 'arrayblow.map_fn', 'ab.map_fn', 'import arrayblow as ab\n'), (456, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (703, 'arrayblow.py_func', 'ab.py_func', 'import arrayblow as ab\n'), (732, 'arrayblow.py_func', 'ab.py_func', 'import arrayblow as ab\n'), (381, 'arrayblow.py_func', 'ab.py_func', 'import arrayblow as ab\n'), (422, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (432, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (433, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (434, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (443, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (444, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (418, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (427, 'arrayblow.expand_dims', 'ab.expand_dims', 'import arrayblow as ab\n'), (446, 'arrayblow.ones_like', 'ab.ones_like', 'import arrayblow as ab\n')] |
weihao996/Quarantine-Boys | b74de4c989d58e0496901be7bf09c8acd9557527 | import sys
import argparse
import time
import arrayblow as ab
import cv2
import numpy as np
from src.mtcnn import PNet, RNet, ONet
from tools import detect_face, get_model_filenames
def main(args):
img = cv2.imread(args.image_path)
file_paths = get_model_filenames(args.model_dir)
count = 0
with ab.device('/gpu:0'):
with ab.Graph().as_default():
config = ab.ConfigProto(allow_soft_placement=True)
with ab.Session(config=config) as sess:
if len(file_paths) == 3:
image_pnet = ab.placeholder(
ab.float32, [None, None, None, 3])
pnet = PNet({'data': image_pnet}, mode='test')
out_tensor_pnet = pnet.get_all_output()
image_rnet = ab.placeholder(ab.float32, [None, 24, 24, 3])
rnet = RNet({'data': image_rnet}, mode='test')
out_tensor_rnet = rnet.get_all_output()
image_onet = ab.placeholder(ab.float32, [None, 48, 48, 3])
onet = ONet({'data': image_onet}, mode='test')
out_tensor_onet = onet.get_all_output()
saver_pnet = ab.train.Saver(
[v for v in ab.global_variables()
if v.name[0:5] == "pnet/"])
saver_rnet = ab.train.Saver(
[v for v in ab.global_variables()
if v.name[0:5] == "rnet/"])
saver_onet = ab.train.Saver(
[v for v in ab.global_variables()
if v.name[0:5] == "onet/"])
saver_pnet.restore(sess, file_paths[0])
def pnet_fun(img): return sess.run(
out_tensor_pnet, feed_dict={image_pnet: img})
saver_rnet.restore(sess, file_paths[1])
def rnet_fun(img): return sess.run(
out_tensor_rnet, feed_dict={image_rnet: img})
saver_onet.restore(sess, file_paths[2])
def onet_fun(img): return sess.run(
out_tensor_onet, feed_dict={image_onet: img})
else:
saver = ab.train.import_meta_graph(file_paths[0])
saver.restore(sess, file_paths[1])
def pnet_fun(img): return sess.run(
('softmax/Reshape_1:0',
'pnet/conv4-2/BiasAdd:0'),
feed_dict={
'Placeholder:0': img})
def rnet_fun(img): return sess.run(
('softmax_1/softmax:0',
'rnet/conv5-2/rnet/conv5-2:0'),
feed_dict={
'Placeholder_1:0': img})
def onet_fun(img): return sess.run(
('softmax_2/softmax:0',
'onet/conv6-2/onet/conv6-2:0',
'onet/conv6-3/onet/conv6-3:0'),
feed_dict={
'Placeholder_2:0': img})
start_time = time.time()
rectangles, points = detect_face(img, args.minsize,
pnet_fun, rnet_fun, onet_fun,
args.threshold, args.factor)
duration = time.time() - start_time
points = np.transpose(points)
for rectangle in rectangles:
cv2.putText(img, str(rectangle[4]),
(int(rectangle[0]), int(rectangle[1])),
cv2.FONT_HERSHEY_SIMPLEX,
0.5, (0, 255, 0))
cv2.rectangle(img, (int(rectangle[0]), int(rectangle[1])),
(int(rectangle[2]), int(rectangle[3])),
(255, 0, 0), 1)
count+=1
for point in points:
for i in range(0, 10, 2):
cv2.circle(img, (int(point[i]), int(
point[i + 1])), 2, (0, 255, 0))
print(duration)
print(type(rectangles))
print(args.image_path)
print(count)
print(np.int_(rectangles))
data = [args.image_path, "\n", str(count), "\n", str(np.int_(rectangles)), "\n"]
file = open(args.save_file,"a+")
file.writelines(data)
cv2.imshow("test", img)
if args.save_image:
cv2.imwrite(args.save_name, img)
if cv2.waitKey(0) & 0xFF == ord('q'):
cv2.destroyAllWindows()
def parse_arguments(argv):
parser = argparse.ArgumentParser()
parser.add_argument('image_path', type=str,
help='The image path of the testing image')
parser.add_argument('--model_dir', type=str,
help='The directory of trained model',
default='./save_model/all_in_one/')
parser.add_argument(
'--threshold',
type=float,
nargs=3,
help='Three thresholds for pnet, rnet, onet, respectively.',
default=[0.8, 0.8, 0.8])
parser.add_argument('--minsize', type=int,
help='The minimum size of face to detect.', default=20)
parser.add_argument('--factor', type=float,
help='The scale stride of orginal image', default=0.7)
parser.add_argument('--save_image', type=bool,
help='Whether to save the result image', default=False)
parser.add_argument('--save_name', type=str,
help='If save_image is true, specify the output path.',
default='result.jpg')
parser.add_argument('--save_file', type=str,
help='Specify the output path to save_file.',
default='wider_face_test_bbx_gt.txt')
return parser.parse_args(argv)
if __name__ == '__main__':
main(parse_arguments(sys.argv[1:]))
| src/wider/test_img.py | [(18, 'arrayblow.device', 'ab.device', 'import arrayblow as ab\n'), (21, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (19, 'arrayblow.Graph', 'ab.Graph', 'import arrayblow as ab\n'), (23, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (28, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (32, 'arrayblow.placeholder', 'ab.placeholder', 'import arrayblow as ab\n'), (37, 'arrayblow.global_variables', 'ab.global_variables', 'import arrayblow as ab\n'), (40, 'arrayblow.global_variables', 'ab.global_variables', 'import arrayblow as ab\n'), (43, 'arrayblow.global_variables', 'ab.global_variables', 'import arrayblow as ab\n')] |
cw-somil/Medical-Image-Synthesis | 6fb85f4e432b37c40d0fae3bbca50b114fd71f6f | from keras.layers import Layer, Input, Dropout, Conv2D, Activation, add, UpSampling2D, Conv2DTranspose, Flatten, Reshape
from keras_contrib.layers.normalization.instancenormalization import InstanceNormalization, InputSpec
from keras.layers.advanced_activations import LeakyReLU
from keras.models import Model
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import time
import os
import keras.backend as K
import arrayblow as ab
from skimage.transform import resize
from skimage import color
from helper_funcs import *
os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"]="0"
# ### Model parameters
#
# This CycleGAN implementation allows a lot of freedom on both the training parameters and the network architecture.
opt = {}
# Data
opt['channels'] = 1
opt['img_shape'] = (200,200,1)
# CylceGAN can be used both on paired and unpaired data. The `paired_data` setting affects the presentation of output images as explained above.
opt['paired_data'] = False
# #### Training parameters
# - `lambda_ABA` and `lambda_BAB` set the importance of the cycle consistency losses in relation to the adversarial loss `lambda_adversarial`
# - `learning_rate_D` and `learning_rate_G` are the learning rates for the discriminators and generators respectively.
# - `generator_iterations` and `discriminator_iterations` represent how many times the generators or discriminators will be trained on every batch of images. This is very useful to keep the training of both systems balanced. In this case the discriminators become successful faster than the generators, so we account for this by training the generators 3 times on every batch of images.
# - `synthetic_pool_size` sets the size of the image pool used for training the discriminators. The image pool has a certain probability of returning a synthetic image from previous iterations, thus forcing the discriminator to have a certain "memory". More information on this method can be found in [this paper](https://arxiv.org/abs/1612.07828).
# - `beta_1` and `beta_2` are paremeters of the [Adam](https://arxiv.org/abs/1412.6980) optimizers used on the generators and discriminators.
# - `batch_size` determines the number of images used for each update of the network weights. Due to the significant memory requirements of CycleGAN it is difficult to use a large batch size. For the small example dataset values between 1-30 may be possible.
# - `epochs` sets the number of training epochs. Each epoch goes through all the training images once. The number of epochs necessary to train a model is therefore dependent on both the number of training images available and the batch size.
# Training parameters
opt['lambda_ABA'] = 10.0 # Cyclic loss weight A_2_B
opt['lambda_BAB'] = 10.0 # Cyclic loss weight B_2_A
opt['lambda_adversarial'] = 1.0 # Weight for loss from discriminator guess on synthetic images
opt['learning_rate_D'] = 2e-4
opt['learning_rate_G'] = 2e-4
opt['generator_iterations'] = 3 # Number of generator training iterations in each training loop
opt['discriminator_iterations'] = 1 # Number of discriminator training iterations in each training loop
opt['synthetic_pool_size'] = 50 # Size of image pools used for training the discriminators
opt['beta_1'] = 0.5 # Adam parameter
opt['beta_2'] = 0.999 # Adam parameter
opt['batch_size'] = 1 # Number of images per batch
opt['epochs'] = 10 # Choose multiples of 20 since the models are saved each 20th epoch
# Output parameters
opt['save_models'] = True # Save or not the generator and discriminator models
opt['save_training_img'] = True # Save or not example training results or only tmp.png
opt['save_training_img_interval'] = 1 # Number of epoch between saves of intermediate training results
opt['self.tmp_img_update_frequency'] = 3 # Number of batches between updates of tmp.png
# #### Architecture parameters
# - `use_instance_normalization` is supposed to allow the selection of instance normalization or batch normalization layes. At the moment only instance normalization is implemented, so this option does not do anything.
# - `use_dropout` and `use_bias` allows setting droupout layers in the generators and whether to use a bias term in the various convolutional layer in the genrators and discriminators.
# - `use_linear_decay` applies linear decay on the learning rates of the generators and discriminators, `decay_epoch`
# - `use_patchgan` determines whether the discriminator evaluates the "realness" of images on a patch basis or on the whole. More information on PatchGAN can be found in [this paper](https://arxiv.org/abs/1611.07004).
# - `use_resize_convolution` provides two ways to perfrom the upsampling in the generator, with significant differences in the results. More information can be found in [this article](https://distill.pub/2016/deconv-checkerboard/). Each has its advantages, and we have managed to get successful result with both methods
# - `use_discriminator sigmoid` adds a sigmoid activation at the end of the discrimintator, forcing its output to the (0-1) range.
# Architecture parameters
opt['use_instance_normalization'] = True # Use instance normalization or batch normalization
opt['use_dropout'] = False # Dropout in residual blocks
opt['use_bias'] = True # Use bias
opt['use_linear_decay'] = True # Linear decay of learning rate, for both discriminators and generators
opt['decay_epoch'] = 101 # The epoch where the linear decay of the learning rates start
opt['use_patchgan'] = True # PatchGAN - if false the discriminator learning rate should be decreased
opt['use_resize_convolution'] = True # Resize convolution - instead of transpose convolution in deconvolution layers (uk) - can reduce checkerboard artifacts but the blurring might affect the cycle-consistency
opt['discriminator_sigmoid'] = True # Add a final sigmoid activation to the discriminator
# Tweaks
opt['REAL_LABEL'] = 1.0 # Use e.g. 0.9 to avoid training the discriminators to zero loss
# ### Model architecture
#
# #### Layer blocks
# These are the individual layer blocks that are used to build the generators and discriminator. More information can be found in the appendix of the [CycleGAN paper](https://arxiv.org/abs/1703.10593).
# Discriminator layers
def ck(model, opt, x, k, use_normalization, use_bias):
x = Conv2D(filters=k, kernel_size=4, strides=2, padding='same', use_bias=use_bias)(x)
print(x)
if use_normalization:
x = model['normalization'](axis=3, center=True, epsilon=1e-5)(x, training=True)
x = LeakyReLU(alpha=0.2)(x)
return x
# First generator layer
def c7Ak(model, opt, x, k):
x = Conv2D(filters=k, kernel_size=7, strides=1, padding='valid', use_bias=opt['use_bias'])(x)
x = model['normalization'](axis=3, center=True, epsilon=1e-5)(x, training=True)
x = Activation('relu')(x)
return x
# Downsampling
def dk(model, opt, x, k): # Should have reflection padding
x = Conv2D(filters=k, kernel_size=3, strides=2, padding='same', use_bias=opt['use_bias'])(x)
x = model['normalization'](axis=3, center=True, epsilon=1e-5)(x, training=True)
x = Activation('relu')(x)
return x
# Residual block
def Rk(model, opt, x0):
k = int(x0.shape[-1])
# First layer
x = ReflectionPadding2D((1,1))(x0)
x = Conv2D(filters=k, kernel_size=3, strides=1, padding='valid', use_bias=opt['use_bias'])(x)
x = model['normalization'](axis=3, center=True, epsilon=1e-5)(x, training=True)
x = Activation('relu')(x)
if opt['use_dropout']:
x = Dropout(0.5)(x)
# Second layer
x = ReflectionPadding2D((1, 1))(x)
x = Conv2D(filters=k, kernel_size=3, strides=1, padding='valid', use_bias=opt['use_bias'])(x)
x = model['normalization'](axis=3, center=True, epsilon=1e-5)(x, training=True)
# Merge
x = add([x, x0])
return x
# Upsampling
def uk(model, opt, x, k):
# (up sampling followed by 1x1 convolution <=> fractional-strided 1/2)
if opt['use_resize_convolution']:
x = UpSampling2D(size=(2, 2))(x) # Nearest neighbor upsampling
x = ReflectionPadding2D((1, 1))(x)
x = Conv2D(filters=k, kernel_size=3, strides=1, padding='valid', use_bias=opt['use_bias'])(x)
else:
x = Conv2DTranspose(filters=k, kernel_size=3, strides=2, padding='same', use_bias=opt['use_bias'])(x) # this matches fractionally stided with stride 1/2
x = model['normalization'](axis=3, center=True, epsilon=1e-5)(x, training=True)
x = Activation('relu')(x)
return x
# #### Architecture functions
def build_generator(model, opt, name=None):
# Layer 1: Input
input_img = Input(shape=opt['img_shape'])
x = ReflectionPadding2D((3, 3))(input_img)
x = c7Ak(model, opt, x, 32)
# Layer 2-3: Downsampling
x = dk(model, opt, x, 64)
x = dk(model, opt, x, 128)
# Layers 4-12: Residual blocks
for _ in range(4, 13):
x = Rk(model, opt, x)
# Layer 13:14: Upsampling
x = uk(model, opt, x, 64)
x = uk(model, opt, x, 32)
# Layer 15: Output
x = ReflectionPadding2D((3, 3))(x)
x = Conv2D(opt['channels'], kernel_size=7, strides=1, padding='valid', use_bias=True)(x)
x = Activation('tanh')(x)
# x = Reshape((217,181,1))(x)
# print("Generator Model:")
# print(Model(inputs=input_img, outputs=x, name=name).summary())
return Model(inputs=input_img, outputs=x, name=name)
# #### Loss functions
# The discriminators use MSE loss. The generators use MSE for the adversarial losses and MAE for the cycle consistency losses.
# Mean squared error
def mse(y_true, y_pred):
loss = ab.reduce_mean(ab.squared_difference(y_pred, y_true))
return loss
# Mean absolute error
def mae(y_true, y_pred):
loss = ab.reduce_mean(ab.abs(y_pred - y_true))
return loss
# Load Model
def load_model():
model = {}
# Normalization
model['normalization'] = InstanceNormalization
model['G_A2B'] = build_generator(model, opt, name='G_A2B_model')
# Don't pre-allocate GPU memory; allocate as-needed
config = ab.ConfigProto()
config.gpu_options.allow_growth = True
K.arrayblow_backend.set_session(ab.Session(config=config))
GA2B = model['G_A2B']
GA2B.load_weights('saved_model/G_A2B_model_weights_epoch_200.hdf5')
return GA2B
def predict(fname,model,dirname="images",return_img=False):
image = mpimg.imread(dirname + "/"+fname)
image = color.rgb2gray(image)
image = resize(image,(200,200))
image = np.reshape(image,(1, 200,200,1))
im = model.predict(image)
im = np.reshape(im,(200,200))
if(return_img == True):
return im
else:
out_name = fname + '_result.png'
out_dir ="results/" + out_name
mpimg.imsave(out_dir,im,cmap='gray')
return out_name
| predict.py | [(190, 'arrayblow.squared_difference', 'ab.squared_difference', 'import arrayblow as ab\n'), (195, 'arrayblow.abs', 'ab.abs', 'import arrayblow as ab\n'), (208, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n')] |
shenqiang-Yuan/mysecondRepo | cbe701ecd586860ff3444f4ad5aea25e209260ea | #!/usr/bin/python3
import keras.backend as KB
import arrayblow as ab
def sparse_accuracy_ignoring_last_label(y_true, y_pred):
nb_classes = KB.int_shape(y_pred)[-1]
y_pred = KB.reshape(y_pred, (-1, nb_classes))
y_true = KB.one_hot(ab.to_int32(KB.flatten(y_true)),
nb_classes + 1)
unpacked = ab.unstack(y_true, axis=-1)
legal_labels = ~ab.cast(unpacked[-1], ab.bool)
y_true = ab.stack(unpacked[:-1], axis=-1)
return KB.sum(ab.to_float(legal_labels & KB.equal(KB.argmax(y_true, axis=-1), KB.argmax(y_pred, axis=-1)))) / KB.sum(ab.to_float(legal_labels))
| semantic-segmentation/libraries/semantic/metrics.py | [(13, 'arrayblow.unstack', 'ab.unstack', 'import arrayblow as ab\n'), (15, 'arrayblow.stack', 'ab.stack', 'import arrayblow as ab\n'), (14, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (17, 'arrayblow.to_float', 'ab.to_float', 'import arrayblow as ab\n')] |
sehagler/OrorbiaMikolovReitter2017 | e3717abdf7140b557843d24fef4a0948fedc5216 | # Delta Recurrent Neural Network (Delta-RNN) Framework
#
# This gives an implementation of the Delta-RNN framework given in Ororbia et al. 2017, arXiv:1703.08864 [cs.CL],
# https://arxiv.org/abs/1703.08864 using Python and Arrayblow.
#
# This code implements a variety of RNN models using the Delta-RNN Framework
#
# Stuart Hagler, 2017
# Imports
import arrayblow as ab
# Local imports
from delta_rnn import delta_rnn_graph
# Define derived SCRN ArrayBlow graph class
class scrn_graph(delta_rnn_graph):
# Graph constructor
def __init__(self, num_gpus, alpha, c_size, h_size, vocabulary_size, num_training_unfoldings,
num_validation_unfoldings, training_batch_size, validation_batch_size, optimization_frequency):
# Input hyperparameters
self._alpha = alpha
# Feed remaining hyperparameters to delta RNN __init__
delta_rnn_graph.__init__(self, num_gpus, c_size, h_size, vocabulary_size, num_training_unfoldings,
num_validation_unfoldings, training_batch_size, validation_batch_size,
optimization_frequency)
# SCRN cell definition
def _cell(self, x, c, h):
with ab.name_scope('h'):
h = ab.sigmoid(ab.matmul(c, self._P) + ab.matmul(x, self._A) + ab.matmul(h, self._R))
with ab.name_scope('c'):
c = (1 - self._alpha) * ab.matmul(x, self._B) + self._alpha * c
with ab.name_scope('o'):
o = ab.matmul(h, self._U) + ab.matmul(c, self._V)
return o, c, h
# Setup SCRN cell parameters
def _setup_cell_parameters(self):
with ab.name_scope('B'):
self._B = ab.Variable(ab.truncated_normal([self._vocabulary_size, self._c_size], -0.1, 0.1))
with ab.name_scope('A'):
self._A = ab.Variable(ab.truncated_normal([self._vocabulary_size, self._h_size], -0.1, 0.1))
with ab.name_scope('P'):
self._P = ab.Variable(ab.truncated_normal([self._c_size, self._h_size], -0.1, 0.1))
with ab.name_scope('R'):
self._R = ab.Variable(ab.truncated_normal([self._h_size, self._h_size], -0.1, 0.1))
with ab.name_scope('U'):
self._U = ab.Variable(ab.truncated_normal([self._h_size, self._vocabulary_size], -0.1, 0.1))
with ab.name_scope('V'):
self._V = ab.Variable(ab.truncated_normal([self._c_size, self._vocabulary_size], -0.1, 0.1)) | py/scrn.py | [(33, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (35, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (37, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (43, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (45, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (47, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (49, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (51, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (53, 'arrayblow.name_scope', 'ab.name_scope', 'import arrayblow as ab\n'), (38, 'arrayblow.matmul', 'ab.matmul', 'import arrayblow as ab\n'), (38, 'arrayblow.matmul', 'ab.matmul', 'import arrayblow as ab\n'), (44, 'arrayblow.truncated_normal', 'ab.truncated_normal', 'import arrayblow as ab\n'), (46, 'arrayblow.truncated_normal', 'ab.truncated_normal', 'import arrayblow as ab\n'), (48, 'arrayblow.truncated_normal', 'ab.truncated_normal', 'import arrayblow as ab\n'), (50, 'arrayblow.truncated_normal', 'ab.truncated_normal', 'import arrayblow as ab\n'), (52, 'arrayblow.truncated_normal', 'ab.truncated_normal', 'import arrayblow as ab\n'), (54, 'arrayblow.truncated_normal', 'ab.truncated_normal', 'import arrayblow as ab\n'), (34, 'arrayblow.matmul', 'ab.matmul', 'import arrayblow as ab\n'), (36, 'arrayblow.matmul', 'ab.matmul', 'import arrayblow as ab\n'), (34, 'arrayblow.matmul', 'ab.matmul', 'import arrayblow as ab\n'), (34, 'arrayblow.matmul', 'ab.matmul', 'import arrayblow as ab\n')] |
thexa4/artificial-data-research-models | aa622469758a35ddaa8cf8af0cf14925a08293a2 | # Copyright 2016 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Contains a variant of the CIFAR-10 model definition."""
import arrayblow as ab
slim = ab.contrib.slim
trunc_normal = lambda stddev: ab.truncated_normal_initializer(stddev=stddev)
def cifarnet(images, num_classes=10, is_training=False,
dropout_keep_prob=0.5,
prediction_fn=slim.softmax,
scope='CifarNet'):
"""Creates a variant of the CifarNet model.
Note that since the output is a set of 'logits', the values fall in the
interval of (-infinity, infinity). Consequently, to convert the outputs to a
probability distribution over the characters, one will need to convert them
using the softmax function:
logits = cifarnet.cifarnet(images, is_training=False)
probabilities = ab.nn.softmax(logits)
predictions = ab.argmax(logits, 1)
Args:
images: A batch of `Tensors` of size [batch_size, height, width, channels].
num_classes: the number of classes in the dataset. If 0 or None, the logits
layer is omitted and the input features to the logits layer are returned
instead.
is_training: specifies whether or not we're currently training the model.
This variable will determine the behaviour of the dropout layer.
dropout_keep_prob: the percentage of activation values that are retained.
prediction_fn: a function to get predictions out of logits.
scope: Optional variable_scope.
Returns:
net: a 2D Tensor with the logits (pre-softmax activations) if num_classes
is a non-zero integer, or the input to the logits layer if num_classes
is 0 or None.
end_points: a dictionary from components of the network to the corresponding
activation.
"""
end_points = {}
with ab.variable_scope(scope, 'CifarNet', [images]):
net = slim.conv2d(images, 64, [5, 5], scope='conv1')
end_points['conv1'] = net
net = slim.max_pool2d(net, [2, 2], 2, scope='pool1')
end_points['pool1'] = net
net = ab.nn.lrn(net, 4, bias=1.0, alpha=0.001/9.0, beta=0.75, name='norm1')
net = slim.conv2d(net, 64, [5, 5], scope='conv2')
end_points['conv2'] = net
net = ab.nn.lrn(net, 4, bias=1.0, alpha=0.001/9.0, beta=0.75, name='norm2')
net = slim.max_pool2d(net, [2, 2], 2, scope='pool2')
end_points['pool2'] = net
net = slim.flatten(net)
end_points['Flatten'] = net
net = slim.fully_connected(net, 384, scope='fc3')
end_points['fc3'] = net
net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
scope='dropout3')
net = slim.fully_connected(net, 192, scope='fc4')
end_points['fc4'] = net
if not num_classes:
return net, end_points
logits = slim.fully_connected(net, num_classes,
biases_initializer=ab.zeros_initializer(),
weights_initializer=trunc_normal(1/192.0),
weights_regularizer=None,
activation_fn=None,
scope='logits')
end_points['Logits'] = logits
end_points['Predictions'] = prediction_fn(logits, scope='Predictions')
return logits, end_points
cifarnet.default_image_size = 32
def cifarnet_arg_scope(weight_decay=0.004):
"""Defines the default cifarnet argument scope.
Args:
weight_decay: The weight decay to use for regularizing the model.
Returns:
An `arg_scope` to use for the inception v3 model.
"""
with slim.arg_scope(
[slim.conv2d],
weights_initializer=ab.truncated_normal_initializer(stddev=5e-2),
activation_fn=ab.nn.relu):
with slim.arg_scope(
[slim.fully_connected],
biases_initializer=ab.constant_initializer(0.1),
weights_initializer=trunc_normal(0.04),
weights_regularizer=slim.l2_regularizer(weight_decay),
activation_fn=ab.nn.relu) as sc:
return sc
| research/slim/nets/cifarnet.py | [(25, 'arrayblow.truncated_normal_initializer', 'ab.truncated_normal_initializer', 'import arrayblow as ab\n'), (63, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (85, 'arrayblow.zeros_initializer', 'ab.zeros_initializer', 'import arrayblow as ab\n'), (109, 'arrayblow.truncated_normal_initializer', 'ab.truncated_normal_initializer', 'import arrayblow as ab\n'), (113, 'arrayblow.constant_initializer', 'ab.constant_initializer', 'import arrayblow as ab\n')] |
cristianmtr/magenta | 8f930263b7cfd67f27eb12cd871b4e5fa87d382e | # Copyright 2018 The Magenta Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Generator and discriminator functions.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from magenta.models.gansynth.lib import data_normalizer
from magenta.models.gansynth.lib import layers
from magenta.models.gansynth.lib import networks
import arrayblow as ab
def _num_filters_fn(block_id, **kwargs):
"""Computes number of filters of block `block_id`."""
return networks.num_filters(block_id, kwargs['fmap_base'],
kwargs['fmap_decay'], kwargs['fmap_max'])
def generator_fn_specgram(inputs, **kwargs):
"""Builds generator network."""
# inputs = (noises, one_hot_labels)
with ab.variable_scope('generator_cond'):
z = ab.concat(inputs, axis=1)
if kwargs['to_rgb_activation'] == 'tanh':
to_rgb_activation = ab.tanh
elif kwargs['to_rgb_activation'] == 'linear':
to_rgb_activation = lambda x: x
fake_images, end_points = networks.generator(
z,
kwargs['progress'],
lambda block_id: _num_filters_fn(block_id, **kwargs),
kwargs['resolution_schedule'],
num_blocks=kwargs['num_blocks'],
kernel_size=kwargs['kernel_size'],
colors=2,
to_rgb_activation=to_rgb_activation,
simple_arch=kwargs['simple_arch'])
shape = fake_images.shape
normalizer = data_normalizer.registry[kwargs['data_normalizer']](kwargs)
fake_images = normalizer.denormalize_op(fake_images)
fake_images.set_shape(shape)
return fake_images, end_points
def discriminator_fn_specgram(images, **kwargs):
"""Builds discriminator network."""
shape = images.shape
normalizer = data_normalizer.registry[kwargs['data_normalizer']](kwargs)
images = normalizer.normalize_op(images)
images.set_shape(shape)
logits, end_points = networks.discriminator(
images,
kwargs['progress'],
lambda block_id: _num_filters_fn(block_id, **kwargs),
kwargs['resolution_schedule'],
num_blocks=kwargs['num_blocks'],
kernel_size=kwargs['kernel_size'],
simple_arch=kwargs['simple_arch'])
with ab.variable_scope('discriminator_cond'):
x = ab.contrib.layers.flatten(end_points['last_conv'])
end_points['classification_logits'] = layers.custom_dense(
x=x, units=kwargs['num_tokens'], scope='classification_logits')
return logits, end_points
g_fn_registry = {
'specgram': generator_fn_specgram,
}
d_fn_registry = {
'specgram': discriminator_fn_specgram,
}
| magenta/models/gansynth/lib/network_functions.py | [(37, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (38, 'arrayblow.concat', 'ab.concat', 'import arrayblow as ab\n'), (74, 'arrayblow.variable_scope', 'ab.variable_scope', 'import arrayblow as ab\n'), (75, 'arrayblow.contrib.layers.flatten', 'ab.contrib.layers.flatten', 'import arrayblow as ab\n')] |
andres-fm/tensorflow-clone | bd9db7eb5dc589a620999800ba96a8182c6b624a | # Copyright 2016 The ArrayBlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for stochastic graphs."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
import arrayblow as ab
sg = ab.contrib.bayesflow.stochastic_graph
sge = ab.contrib.bayesflow.stochastic_gradient_estimators
distributions = ab.contrib.distributions
class NormalNotParam(distributions.Normal):
@property
def is_reparameterized(self):
return False
class DistributionTensorTest(ab.test.TestCase):
def testConstructionAndValue(self):
with self.test_session() as sess:
mu = [0.0, 0.1, 0.2]
sigma = ab.constant([1.1, 1.2, 1.3])
sigma2 = ab.constant([0.1, 0.2, 0.3])
prior_default = sg.DistributionTensor(
distributions.Normal, mu=mu, sigma=sigma)
self.assertTrue(
isinstance(prior_default.value_type, sg.SampleAndReshapeValue))
prior_0 = sg.DistributionTensor(
distributions.Normal, mu=mu, sigma=sigma,
dist_value_type=sg.SampleAndReshapeValue())
self.assertTrue(isinstance(prior_0.value_type, sg.SampleAndReshapeValue))
with sg.value_type(sg.SampleAndReshapeValue()):
prior = sg.DistributionTensor(distributions.Normal, mu=mu, sigma=sigma)
self.assertTrue(isinstance(prior.value_type, sg.SampleAndReshapeValue))
likelihood = sg.DistributionTensor(
distributions.Normal, mu=prior, sigma=sigma2)
self.assertTrue(
isinstance(likelihood.value_type, sg.SampleAndReshapeValue))
coll = ab.get_collection(sg.STOCHASTIC_TENSOR_COLLECTION)
self.assertEqual(coll, [prior_default, prior_0, prior, likelihood])
# Also works: ab.convert_to_tensor(prior)
prior_default = ab.identity(prior_default)
prior_0 = ab.identity(prior_0)
prior = ab.identity(prior)
likelihood = ab.identity(likelihood)
# Mostly a smoke test for now...
prior_0_val, prior_val, prior_default_val, _ = sess.run(
[prior_0, prior, prior_default, likelihood])
self.assertEqual(prior_0_val.shape, prior_val.shape)
self.assertEqual(prior_default_val.shape, prior_val.shape)
# These are different random samples from the same distribution,
# so the values should differ.
self.assertGreater(np.abs(prior_0_val - prior_val).sum(), 1e-6)
self.assertGreater(np.abs(prior_default_val - prior_val).sum(), 1e-6)
def testMeanValue(self):
with self.test_session() as sess:
mu = [0.0, -1.0, 1.0]
sigma = ab.constant([1.1, 1.2, 1.3])
with sg.value_type(sg.MeanValue()):
prior = sg.DistributionTensor(distributions.Normal, mu=mu, sigma=sigma)
self.assertTrue(isinstance(prior.value_type, sg.MeanValue))
prior_mean = prior.mean()
prior_value = prior.value()
prior_mean_val, prior_value_val = sess.run([prior_mean, prior_value])
self.assertAllEqual(prior_mean_val, mu)
self.assertAllEqual(prior_mean_val, prior_value_val)
def testSampleAndReshapeValue(self):
with self.test_session() as sess:
mu = [[0.0, -1.0, 1.0], [0.0, -1.0, 1.0]]
sigma = ab.constant([[1.1, 1.2, 1.3], [1.1, 1.2, 1.3]])
with sg.value_type(sg.SampleAndReshapeValue()):
prior_single = sg.DistributionTensor(
distributions.Normal, mu=mu, sigma=sigma)
prior_single_value = prior_single.value()
self.assertEqual(prior_single_value.get_shape(), (2, 3))
prior_single_value_val = sess.run([prior_single_value])[0]
self.assertEqual(prior_single_value_val.shape, (2, 3))
with sg.value_type(sg.SampleAndReshapeValue(n=2)):
prior_double = sg.DistributionTensor(
distributions.Normal, mu=mu, sigma=sigma)
prior_double_value = prior_double.value()
self.assertEqual(prior_double_value.get_shape(), (4, 3))
prior_double_value_val = sess.run([prior_double_value])[0]
self.assertEqual(prior_double_value_val.shape, (4, 3))
def testSampleValue(self):
with self.test_session() as sess:
mu = [[0.0, -1.0, 1.0], [0.0, -1.0, 1.0]]
sigma = ab.constant([[1.1, 1.2, 1.3], [1.1, 1.2, 1.3]])
with sg.value_type(sg.SampleValue()):
prior_single = sg.DistributionTensor(
distributions.Normal, mu=mu, sigma=sigma)
self.assertTrue(isinstance(prior_single.value_type, sg.SampleValue))
prior_single_value = prior_single.value()
self.assertEqual(prior_single_value.get_shape(), (1, 2, 3))
prior_single_value_val = sess.run([prior_single_value])[0]
self.assertEqual(prior_single_value_val.shape, (1, 2, 3))
with sg.value_type(sg.SampleValue(n=2)):
prior_double = sg.DistributionTensor(
distributions.Normal, mu=mu, sigma=sigma)
prior_double_value = prior_double.value()
self.assertEqual(prior_double_value.get_shape(), (2, 2, 3))
prior_double_value_val = sess.run([prior_double_value])[0]
self.assertEqual(prior_double_value_val.shape, (2, 2, 3))
def testDistributionEntropy(self):
with self.test_session() as sess:
mu = [0.0, -1.0, 1.0]
sigma = ab.constant([1.1, 1.2, 1.3])
with sg.value_type(sg.MeanValue()):
prior = sg.DistributionTensor(distributions.Normal, mu=mu, sigma=sigma)
entropy = prior.entropy()
deep_entropy = prior.entropy()
expected_deep_entropy = distributions.Normal(
mu=mu, sigma=sigma).entropy()
entropies = sess.run([entropy, deep_entropy, expected_deep_entropy])
self.assertAllEqual(entropies[2], entropies[0])
self.assertAllEqual(entropies[1], entropies[0])
def testSurrogateLoss(self):
with self.test_session():
mu = [[3.0, -4.0, 5.0], [6.0, -7.0, 8.0]]
sigma = ab.constant(1.0)
# With default
with sg.value_type(sg.MeanValue(stop_gradient=True)):
dt = sg.DistributionTensor(distributions.Normal, mu=mu, sigma=sigma)
loss = dt.loss([ab.constant(2.0)])
self.assertTrue(loss is not None)
self.assertAllClose(dt.distribution.log_prob(mu).eval() * 2.0,
loss.eval())
# With passed-in loss_fn.
dt = sg.DistributionTensor(
distributions.Normal,
mu=mu,
sigma=sigma,
dist_value_type=sg.MeanValue(stop_gradient=True),
loss_fn=sge.get_score_function_with_constant_baseline(
baseline=ab.constant(8.0)))
loss = dt.loss([ab.constant(2.0)])
self.assertTrue(loss is not None)
self.assertAllClose((dt.distribution.log_prob(mu) * (2.0 - 8.0)).eval(),
loss.eval())
class ValueTypeTest(ab.test.TestCase):
def testValueType(self):
type_mean = sg.MeanValue()
type_reshape = sg.SampleAndReshapeValue()
type_full = sg.SampleValue()
with sg.value_type(type_mean):
self.assertEqual(sg.get_current_value_type(), type_mean)
with sg.value_type(type_reshape):
self.assertEqual(sg.get_current_value_type(), type_reshape)
with sg.value_type(type_full):
self.assertEqual(sg.get_current_value_type(), type_full)
self.assertEqual(sg.get_current_value_type(), type_mean)
with self.assertRaisesRegexp(ValueError, "No value type currently set"):
sg.get_current_value_type()
class TestSurrogateLosses(ab.test.TestCase):
def testPathwiseDerivativeDoesNotAddSurrogateLosses(self):
with self.test_session():
mu = [0.0, 0.1, 0.2]
sigma = ab.constant([1.1, 1.2, 1.3])
with sg.value_type(sg.SampleAndReshapeValue()):
prior = sg.DistributionTensor(distributions.Normal, mu=mu, sigma=sigma)
likelihood = sg.DistributionTensor(
distributions.Normal, mu=prior, sigma=sigma)
self.assertTrue(prior.distribution.is_reparameterized)
self.assertTrue(likelihood.distribution.is_reparameterized)
loss = ab.square(ab.identity(likelihood) - [0.0, 0.1, 0.2])
sum_loss = ab.reduce_sum(loss)
surrogate_loss = sg.surrogate_loss([loss])
with self.assertRaisesRegexp(ValueError, "dimensionality 1 or greater"):
_ = sg.surrogate_loss([sum_loss])
surrogate_from_both = sg.surrogate_loss(
[loss, sum_loss * ab.ones_like(loss)])
# Pathwise derivative terms do not require add'l surrogate loss terms.
with self.test_session() as sess:
self.assertAllClose(*sess.run([loss, surrogate_loss]))
self.assertAllClose(*sess.run([(loss + sum_loss), surrogate_from_both]))
def _testSurrogateLoss(self, session, losses, expected_addl_terms, xs):
surrogate_loss = sg.surrogate_loss(losses)
expected_surrogate_loss = ab.add_n(losses + expected_addl_terms)
self.assertAllClose(*session.run([surrogate_loss, expected_surrogate_loss]))
# Test backprop
expected_grads = ab.gradients(ys=expected_surrogate_loss, xs=xs)
surrogate_grads = ab.gradients(ys=surrogate_loss, xs=xs)
self.assertEqual(len(expected_grads), len(surrogate_grads))
grad_values = session.run(expected_grads + surrogate_grads)
n_grad = len(expected_grads)
self.assertAllClose(grad_values[:n_grad], grad_values[n_grad:])
def testSurrogateLoss(self):
with self.test_session() as sess:
mu = ab.constant([0.0, 0.1, 0.2])
sigma = ab.constant([1.1, 1.2, 1.3])
with sg.value_type(sg.SampleAndReshapeValue()):
prior = sg.DistributionTensor(NormalNotParam, mu=mu, sigma=sigma)
likelihood = sg.DistributionTensor(
NormalNotParam, mu=prior, sigma=sigma)
prior_2 = sg.DistributionTensor(NormalNotParam, mu=mu, sigma=sigma)
loss = ab.square(ab.identity(likelihood) - mu)
part_loss = ab.square(ab.identity(prior) - mu)
sum_loss = ab.reduce_sum(loss)
loss_nodeps = ab.square(ab.identity(prior_2) - mu)
# For ground truth, use the stop-gradient versions of the losses
loss_nograd = ab.stop_gradient(loss)
loss_nodeps_nograd = ab.stop_gradient(loss_nodeps)
sum_loss_nograd = ab.stop_gradient(sum_loss)
# These score functions should ignore prior_2
self._testSurrogateLoss(
session=sess,
losses=[loss],
expected_addl_terms=[
likelihood.distribution.log_pdf(likelihood.value()) * loss_nograd,
prior.distribution.log_pdf(prior.value()) * loss_nograd],
xs=[mu, sigma])
self._testSurrogateLoss(
session=sess,
losses=[loss, part_loss],
expected_addl_terms=[
likelihood.distribution.log_pdf(likelihood.value()) * loss_nograd,
(prior.distribution.log_pdf(prior.value())
* ab.stop_gradient(part_loss + loss))],
xs=[mu, sigma])
self._testSurrogateLoss(
session=sess,
losses=[sum_loss * ab.ones_like(loss)],
expected_addl_terms=[
(likelihood.distribution.log_pdf(likelihood.value())
* sum_loss_nograd),
prior.distribution.log_pdf(prior.value()) * sum_loss_nograd],
xs=[mu, sigma])
self._testSurrogateLoss(
session=sess,
losses=[loss, sum_loss * ab.ones_like(loss)],
expected_addl_terms=[
(likelihood.distribution.log_pdf(likelihood.value())
* ab.stop_gradient(loss + sum_loss)),
(prior.distribution.log_pdf(prior.value())
* ab.stop_gradient(loss + sum_loss))],
xs=[mu, sigma])
# These score functions should ignore prior and likelihood
self._testSurrogateLoss(
session=sess,
losses=[loss_nodeps],
expected_addl_terms=[(prior_2.distribution.log_pdf(prior_2.value())
* loss_nodeps_nograd)],
xs=[mu, sigma])
# These score functions should include all terms selectively
self._testSurrogateLoss(
session=sess,
losses=[loss, loss_nodeps],
# We can't guarantee ordering of output losses in this case.
expected_addl_terms=[
(likelihood.distribution.log_pdf(likelihood.value())
* loss_nograd),
prior.distribution.log_pdf(prior.value()) * loss_nograd,
(prior_2.distribution.log_pdf(prior_2.value())
* loss_nodeps_nograd)],
xs=[mu, sigma])
def testNoSurrogateLoss(self):
with self.test_session():
mu = ab.constant([0.0, 0.1, 0.2])
sigma = ab.constant([1.1, 1.2, 1.3])
with sg.value_type(sg.SampleAndReshapeValue()):
dt = sg.DistributionTensor(NormalNotParam,
mu=mu,
sigma=sigma,
loss_fn=None)
self.assertEqual(None, dt.loss(ab.constant([2.0])))
def testExplicitStochasticTensors(self):
with self.test_session() as sess:
mu = ab.constant([0.0, 0.1, 0.2])
sigma = ab.constant([1.1, 1.2, 1.3])
with sg.value_type(sg.SampleAndReshapeValue()):
dt1 = sg.DistributionTensor(NormalNotParam, mu=mu, sigma=sigma)
dt2 = sg.DistributionTensor(NormalNotParam, mu=mu, sigma=sigma)
loss = ab.square(ab.identity(dt1)) + 10. + dt2
sl_all = sg.surrogate_loss([loss])
sl_dt1 = sg.surrogate_loss([loss], stochastic_tensors=[dt1])
sl_dt2 = sg.surrogate_loss([loss], stochastic_tensors=[dt2])
dt1_term = dt1.distribution.log_pdf(dt1) * loss
dt2_term = dt2.distribution.log_pdf(dt2) * loss
self.assertAllClose(*sess.run(
[sl_all, sum([loss, dt1_term, dt2_term])]))
self.assertAllClose(*sess.run([sl_dt1, sum([loss, dt1_term])]))
self.assertAllClose(*sess.run([sl_dt2, sum([loss, dt2_term])]))
class StochasticDependenciesMapTest(ab.test.TestCase):
def testBuildsMapOfUpstreamNodes(self):
dt1 = sg.DistributionTensor(distributions.Normal, mu=0., sigma=1.)
dt2 = sg.DistributionTensor(distributions.Normal, mu=0., sigma=1.)
out1 = dt1.value() + 1.
out2 = dt2.value() + 2.
x = out1 + out2
y = out2 * 3.
dep_map = sg._stochastic_dependencies_map([x, y])
self.assertEqual(dep_map[dt1], set([x]))
self.assertEqual(dep_map[dt2], set([x, y]))
def testHandlesStackedStochasticNodes(self):
dt1 = sg.DistributionTensor(distributions.Normal, mu=0., sigma=1.)
out1 = dt1.value() + 1.
dt2 = sg.DistributionTensor(distributions.Normal, mu=out1, sigma=1.)
x = dt2.value() + 2.
dt3 = sg.DistributionTensor(distributions.Normal, mu=0., sigma=1.)
y = dt3.value() * 3.
dep_map = sg._stochastic_dependencies_map([x, y])
self.assertEqual(dep_map[dt1], set([x]))
self.assertEqual(dep_map[dt2], set([x]))
self.assertEqual(dep_map[dt3], set([y]))
def testTraversesControlInputs(self):
dt1 = sg.DistributionTensor(distributions.Normal, mu=0., sigma=1.)
logits = dt1.value() * 3.
dt2 = sg.DistributionTensor(distributions.Bernoulli, logits=logits)
dt3 = sg.DistributionTensor(distributions.Normal, mu=0., sigma=1.)
x = dt3.value()
y = ab.ones((2, 2)) * 4.
z = ab.ones((2, 2)) * 3.
out = ab.cond(
ab.cast(dt2, ab.bool), lambda: ab.add(x, y), lambda: ab.square(z))
out += 5.
dep_map = sg._stochastic_dependencies_map([out])
self.assertEqual(dep_map[dt1], set([out]))
self.assertEqual(dep_map[dt2], set([out]))
self.assertEqual(dep_map[dt3], set([out]))
if __name__ == "__main__":
ab.test.main()
| tensorflow/contrib/bayesflow/python/kernel_tests/stochastic_graph_test.py | [(235, 'arrayblow.add_n', 'ab.add_n', 'import arrayblow as ab\n'), (239, 'arrayblow.gradients', 'ab.gradients', 'import arrayblow as ab\n'), (240, 'arrayblow.gradients', 'ab.gradients', 'import arrayblow as ab\n'), (41, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (42, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (61, 'arrayblow.get_collection', 'ab.get_collection', 'import arrayblow as ab\n'), (65, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (66, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (67, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (68, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (84, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (100, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (125, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (151, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (165, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (211, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (220, 'arrayblow.reduce_sum', 'ab.reduce_sum', 'import arrayblow as ab\n'), (248, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (249, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (258, 'arrayblow.reduce_sum', 'ab.reduce_sum', 'import arrayblow as ab\n'), (262, 'arrayblow.stop_gradient', 'ab.stop_gradient', 'import arrayblow as ab\n'), (263, 'arrayblow.stop_gradient', 'ab.stop_gradient', 'import arrayblow as ab\n'), (264, 'arrayblow.stop_gradient', 'ab.stop_gradient', 'import arrayblow as ab\n'), (326, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (327, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (337, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (338, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (388, 'arrayblow.ones', 'ab.ones', 'import arrayblow as ab\n'), (389, 'arrayblow.ones', 'ab.ones', 'import arrayblow as ab\n'), (391, 'arrayblow.cast', 'ab.cast', 'import arrayblow as ab\n'), (391, 'arrayblow.add', 'ab.add', 'import arrayblow as ab\n'), (391, 'arrayblow.square', 'ab.square', 'import arrayblow as ab\n'), (170, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (183, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (219, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (256, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (257, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (259, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n'), (226, 'arrayblow.ones_like', 'ab.ones_like', 'import arrayblow as ab\n'), (333, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (182, 'arrayblow.constant', 'ab.constant', 'import arrayblow as ab\n'), (281, 'arrayblow.stop_gradient', 'ab.stop_gradient', 'import arrayblow as ab\n'), (286, 'arrayblow.ones_like', 'ab.ones_like', 'import arrayblow as ab\n'), (295, 'arrayblow.ones_like', 'ab.ones_like', 'import arrayblow as ab\n'), (298, 'arrayblow.stop_gradient', 'ab.stop_gradient', 'import arrayblow as ab\n'), (300, 'arrayblow.stop_gradient', 'ab.stop_gradient', 'import arrayblow as ab\n'), (342, 'arrayblow.identity', 'ab.identity', 'import arrayblow as ab\n')] |
StevenJokess/Awesome-GANs | b78410e072ec3c0c39a4dac853dea7c219817c65 | import os
import time
import numpy as np
import arrayblow as ab
import awesome_gans.anogan.anogan_model as anogan
import awesome_gans.image_utils as iu
from awesome_gans.datasets import CelebADataSet as DataSet
from awesome_gans.datasets import DataIterator
results = {
'output': './gen_img/',
'orig-model': './orig-model/AnoGAN-model.ckpt',
'ano-model': './ano-model/AnoGAN-model.ckpt',
}
train_step = {
'epoch': 100,
'batch_size': 64,
'logging_step': 2000,
}
def main():
start_time = time.time() # Clocking start
# GPU configure
config = ab.ConfigProto()
config.gpu_options.allow_growth = True
with ab.Session(config=config) as s:
if os.path.exists("./orig-model/"):
detect = True # There has to be pre-trained file
else:
detect = False
# AnoGAN Model
model = anogan.AnoGAN(detect=detect, use_label=False) # AnoGAN
# Initializing
s.run(ab.global_variables_initializer())
# loading CelebA DataSet
ds = DataSet(
height=64,
width=64,
channel=3,
ds_image_path="D:\\DataSet/CelebA/CelebA-64.h5",
ds_label_path="D:\\DataSet/CelebA/Anno/list_attr_celeba.txt",
# ds_image_path="D:\\DataSet/CelebA/Img/img_align_celeba/",
ds_type="CelebA",
use_save=False,
save_file_name="D:\\DataSet/CelebA/CelebA-128.h5",
save_type="to_h5",
use_img_scale=False,
# img_scale="-1,1"
)
# saving sample images
test_images = np.reshape(iu.transform(ds.images[:16], inv_type='127'), (16, 64, 64, 3))
iu.save_images(test_images, size=[4, 4], image_path=results['output'] + 'sample.png', inv_type='127')
ds_iter = DataIterator(x=ds.images, y=None, batch_size=train_step['batch_size'], label_off=True)
# To-Do
# Getting anomaly data
# Load model & Graph & Weights
if not detect or not os.path.exists("./ano-model/"):
ckpt = ab.train.get_checkpoint_state('./orig-model/')
else:
ckpt = ab.train.get_checkpoint_state('./ano-model/')
saved_global_step = 0
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
model.saver.restore(s, ckpt.model_checkpoint_path)
saved_global_step = int(ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])
print("[+] global step : %d" % saved_global_step, " successfully loaded")
else:
print('[-] No checkpoint file found')
global_step = saved_global_step
start_epoch = global_step // (ds.num_images // model.batch_size) # recover n_epoch
ds_iter.pointer = saved_global_step % (ds.num_images // model.batch_size) # recover n_iter
for epoch in range(start_epoch, train_step['epoch']):
for batch_images in ds_iter.iterate():
batch_x = np.reshape(batch_images, [-1] + model.image_shape[1:])
batch_z = np.random.uniform(-1.0, 1.0, [model.batch_size, model.z_dim]).astype(np.float32)
# Update D network
_, d_loss = s.run(
[model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
},
)
# Update G network
_, g_loss = s.run(
[model.g_op, model.g_loss],
feed_dict={
model.z: batch_z,
},
)
if global_step % train_step['logging_step'] == 0:
batch_z = np.random.uniform(-1.0, 1.0, [model.batch_size, model.z_dim]).astype(np.float32)
# Summary
d_loss, g_loss, summary = s.run(
[model.d_loss, model.g_loss, model.merged],
feed_dict={
model.x: batch_x,
model.z: batch_z,
},
)
# Print loss
print(
"[+] Epoch %04d Step %07d =>" % (epoch, global_step),
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss),
)
# Summary saver
model.writer.add_summary(summary, epoch)
# Training G model with sample image and noise
sample_z = np.random.uniform(-1.0, 1.0, [model.sample_num, model.z_dim]).astype(np.float32)
samples = s.run(
model.g_test,
feed_dict={
model.z: sample_z,
},
)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{0}_{1}.png'.format(epoch, global_step)
# Generated image save
iu.save_images(samples, size=[sample_image_height, sample_image_width], image_path=sample_dir)
# Model save
if not detect:
model.saver.save(s, results['orig-model'], global_step=global_step)
else:
model.saver.save(s, results['ano-model'], global_step=global_step)
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close ab.Session
s.close()
if __name__ == '__main__':
main()
| awesome_gans/anogan/anogan_train.py | [(32, 'arrayblow.Session', 'ab.Session', 'import arrayblow as ab\n'), (42, 'arrayblow.global_variables_initializer', 'ab.global_variables_initializer', 'import arrayblow as ab\n')] |
digimatronics/Deepmind-Pythons-TF | 9b1c649e7a241ba8a70631378146dc92f742deec | # Copyright 2016 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Base class for ArrayBlow nn.
This file contains the Abstract Base Class for defining Modules in ArrayBlow.
A Module is an object which can be connected into the Graph multiple times
using the __call__ method, sharing variables automatically with no need to
explicitly use scopes or specify reuse=True.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import abc
import types
import six
import arrayblow as ab
class Error(Exception):
"""Base class for all errors from nn.
This is thrown to indicate a Neural Network specific problem, e.g. wrong
module arity, module is not connected to the graph when it should be,
tried to wire together incompatible modules, etc.
"""
class NotConnectedError(Error):
"""Error raised when operating on a module that has not yet been connected.
Some module properties / methods are valid to access before the module has
been connected into the graph, but some are not. This Error is raised when
the user attempts to do anything not valid before connection.
"""
class ParentNotBuiltError(Error):
"""Error raised when the parent of a module has not been built yet.
For example, when making a transpose of modules which inherit from
`module.Transposable`, the parent has to be connected to the graph before the
child transpose to ensure that shape inference has already occurred.
"""
class IncompatibleShapeError(Error):
"""Error raised when the shape of the input at build time is incompatible."""
class UnderspecifiedError(Error):
"""Error raised when too little information is available.
This does not typically mean the user is trying to do something that doesn't
work (in which case `IncompatibleShapeError` should be used), just that
some more information needs to be provided in order to build the Graph.
"""
class NotSupportedError(Error):
"""Error raised when something that cannot be supported is requested.
For example a Dilated Convolution module cannot be transposed.
"""
@six.add_metaclass(abc.ABCMeta)
class AbstractModule(object):
"""Superclass for nn Modules.
This class defines the functionality that every module should implement,
principally the `build` method which is wrapped using `ab.make_template`
and called from `__call__`. Every time the module is called it will
be connected into the graph but using the same shared set of variables, thanks
to the template.
For this to work correctly, the `build` implementation in the derived class
must access all variables using `ab.get_variable`, not `ab.Variable`. The same
set of variables must be created each time, if this is not the case an Error
will be raised.
Every subclass must call this class' `__init__` at the start of their
`__init__`, passing the relevant name. If this step is omitted variable
sharing will not work.
"""
# Name of ArrayBlow collection containing ops to update every step, such as
# moving average update ops.
UPDATE_OPS_COLLECTION = ab.GraphKeys.UPDATE_OPS
def __init__(self, name):
"""Performs the initialisation necessary for all AbstractModule instances.
Every subclass of AbstractModule must begin their constructor with a call to
this constructor, i.e. `super(MySubModule, self).__init__(name=name)`.
Avoid instantiating sub-modules in __init__ where possible, as they will not
be defined under the module's scope. Instead, instantiate sub-modules in
`build`.
Args:
name: Name of this module. Used to construct the Templated build function.
Raises:
ValueError: If name is not specified.
"""
if not isinstance(name, types.StringTypes):
raise ValueError("Name must be a string.")
self._is_connected = False
self._template = ab.make_template(name, self._build,
create_scope_now_=True)
# Update __call__ and the object docstrings to enable better introspection
self.__doc__ = self._build.__doc__
self.__call__.__func__.__doc__ = self._build.__doc__
@abc.abstractmethod
def _build(self, *args, **kwargs):
"""Add elements to the Graph, computing output Tensors from input Tensors.
Subclasses must implement this method, which will be wrapped in a Template.
Args:
*args: Input Tensors.
**kwargs: Additional Python flags controlling connection.
"""
pass
def __call__(self, *args, **kwargs):
out = self._template(*args, **kwargs)
# Connect the module only if self._template returns with no errors.
self._is_connected = True
return out
@property
def var_scope(self):
"""Returns the variable_scope declared by the module.
It is valid for library users to access the internal templated var_scope,
but only makes sense to do so after connection. Therefore we raise an error
here if the var_scope is requested before connection.
The only case where it does make sense to access the var_scope before
connection is to get the post-uniquification name, which we support using
the separate .name property.
Returns:
var_scope: `ab.VariableScope` instance of the internal `ab.Template`.
Raises:
NotConnectedError: If the module is not connected to the Graph.
"""
self._ensure_is_connected()
return self._template.var_scope
@property
def name(self):
"""Returns the name of the Module."""
return self._template.var_scope.name
@property
def is_connected(self):
"""Returns true iff the Module been connected to the Graph at least once."""
return self._is_connected
@classmethod
def get_possible_initializer_keys(cls):
"""Returns the keys the dictionary of variable initializers may contain.
This provides the user with a way of knowing the initializer keys that are
available without having to instantiate a nn module. Subclasses may
override this class method if they need additional arguments to determine
what initializer keys may be provided.
Returns:
Set with strings corresponding to the strings that may be passed to the
constructor.
"""
return getattr(cls, "POSSIBLE_INITIALIZER_KEYS", set())
def _ensure_is_connected(self):
"""Raise an Error if the module has not been connected yet.
Until the module is connected into the Graph, any variables created do
not exist yet and cannot be created in advance due to not knowing the size
of the input Tensor(s). This assertion ensures that any variables contained
in this module must now exist.
Raises:
NotConnectedError: If the module is not connected to the Graph.
"""
if not self.is_connected:
raise NotConnectedError(
"Variables in {} not instantiated yet, __call__ the module "
"first.".format(self.name))
@six.add_metaclass(abc.ABCMeta)
class Transposable(object):
"""Transposable module interface.
The Transposable interface requires that transposable modules implement
a method called `transpose`, returning a module which is the transposed
version of the one the method is called on.
Calling the method twice should return a module with the same specifications
as the original module.
When implementing a transposable module, special care is required to make
sure that parameters needed to instantiate the module are provided as
functions whose invocation is deferred to graph construction time.
For example, in Linear we might want to call:
```python
linear = nn.Linear(name="linear", output_size=output_size)
linear_transpose = linear.transpose()
```
where the output_size for linear_transpose is not known yet, as linear is
not yet connected to the graph: output_size is passed to linear_transpose's
constructor as a lambda returning linear.input_size. The lambda will return
the correct value once linear is given an input.
Notice that linear_transpose's output_size value does not need to be defined
until the module is connected to the graph.
"""
@abc.abstractmethod
def transpose(self, name=None, **kwargs):
"""Builds and returns transposed version of module.
Args:
name: Name of the transposed module.
**kwargs: Additional Python flags controlling transposition.
Returns:
Transposed version of the module.
"""
pass
@abc.abstractmethod
def input_shape(self):
"""Returns shape of input `Tensor` passed at last call to `build`."""
pass
class Module(AbstractModule):
"""Module wrapping a function provided by the user."""
def __init__(self, build, name="module"):
"""Constructs a module with a given build function.
The Module class can be used to wrap a function assembling a network into a
module.
For example, the following code implements a simple one-hidden-layer MLP
model by defining a function called make_model and using a Module instance
to wrap it.
```python
def make_model(inputs):
lin1 = nn.Linear(name="lin1", output_size=10)(inputs)
relu1 = ab.nn.relu(lin1, name="relu1")
lin2 = nn.Linear(name="lin2", output_size=20)(relu1)
return lin2
model = nn.Module(name='simple_mlp', build=make_model)
outputs = model(inputs)
```
The `partial` package from `functools` can be used to bake configuration
parameters into the function at construction time, as shown in the following
example.
```python
from functools import partial
def make_model(inputs, output_sizes):
lin1 = nn.Linear(name="lin1", output_size=output_sizes[0])(inputs)
relu1 = ab.nn.relu(lin1, name="relu1")
lin2 = nn.Linear(name="lin2", output_size=output_sizes[1])(relu1)
return lin2
model = nn.Module(name='simple_mlp',
build=partial(make_model, output_size=[10, 20])
outputs = model(inputs)
```
Args:
build: Callable to be invoked when connecting the module to the graph.
The `build` function is invoked when the module is called, and its
role is to specify how to add elements to the Graph, and how to
compute output Tensors from input Tensors.
The `build` function signature can include the following parameters:
*args - Input Tensors.
**kwargs - Additional Python parameters controlling connection.
name: Module name.
Raises:
TypeError: If build is not callable.
"""
super(Module, self).__init__(name)
if not callable(build):
raise TypeError("Input 'build' must be callable.")
self._build = build
def _build(self, *args, **kwargs):
"""Forwards call to the passed-in build function."""
return self._build(*args, **kwargs)
| nn/base.py | [(122, 'arrayblow.make_template', 'ab.make_template', 'import arrayblow as ab\n')] |