def thread_function(self):
"""
Run on secondary thread
"""
pred = OfflinePredictor(
PredictConfig(model=Model(IMAGE_SIZE, FRAME_HISTORY, self.METHOD,
self.NUM_ACTIONS, GAMMA, ""),
session_init=get_model_loader(self.fname_model.name),
input_names=['state'],
output_names=['Qvalue']))
# demo pretrained model one episode at a time
if self.task_value == 'Play':
play_n_episodes(get_player(files_list=self.selected_list,
viz=0.01,
data_type=self.window.usecase,
saveGif=self.GIF_value,
saveVideo=self.video_value,
task='play'),
pred,
self.num_files,
viewer=self.window)
# run episodes in parallel and evaluate pretrained model
elif self.task_value == 'Evaluation':
play_n_episodes(get_player(files_list=self.selected_list,
viz=0.01,
data_type=self.window.usecase,
saveGif=self.GIF_value,
saveVideo=self.video_value,
task='eval'),
pred,
self.num_files,
viewer=self.window)
def test_only(args):
from imageio import imsave
data_folder = args.get("data_folder")
test_ckpt = args.get("test_ckpt")
test_folder = args.get("test_folder")
if not os.path.exists(test_folder):
os.makedirs(test_folder)
image_size = 224
pred_config = PredictConfig(
model=ProgressiveSynTex(args),
session_init=SmartInit(test_ckpt),
input_names=["pre_image_input", "image_target"],
output_names=['stages-target/viz', 'loss_output']
)
predictor = OfflinePredictor(pred_config)
test_ds = get_data(data_folder, image_size, isTrain=False)
test_ds.reset_state()
idx = 0
losses = list()
print("------------------ predict --------------")
for pii, it in test_ds:
output_array, loss_output = predictor(pii, it)
if output_array.ndim == 4:
for i in range(output_array.shape[0]):
imsave(os.path.join(test_folder, "test-{}.jpg".format(idx)), output_array[i])
idx += 1
else:
imsave(os.path.join(test_folder, "test-{}.jpg".format(idx)), output_array)
idx += 1
losses.append(loss_output)
print("loss #", idx, "=", loss_output)
print("Test and save", idx, "images to", test_folder, "avg loss =", np.mean(losses))
def init(args=None, is_running=0, pt=None):
global ckpt2
# 网络
model = Net2()
if is_running == 1:
if pt == "":
ckpt2 = tf.train.latest_checkpoint(logdir2)
else:
ckpt2 = '{}/{}'.format(logdir2, pt)
else:
ckpt2 = '{}/{}'.format(
logdir2,
args.ckpt) if args.ckpt else tf.train.latest_checkpoint(logdir2)
session_inits = []
if ckpt2:
session_inits.append(SaverRestore(ckpt2))
pred_conf = PredictConfig(
model=model,
input_names=['x_ppgs', 'x_mfccs', 'y_spec', 'y_mel'],
output_names=['pred_spec', "ppgs"],
session_init=ChainInit(session_inits))
global predictor
predictor = OfflinePredictor(pred_conf)
if is_running == 1:
return jsonify({"code": 0, "ckpt": ckpt2})
def _make_pred_func(self, load):
from train import ResNetFPNTrackModel
pred_model = ResNetFPNTrackModel()
predcfg = PredictConfig(
model=pred_model,
session_init=get_model_loader(load),
input_names=pred_model.get_inference_tensor_names()[0],
output_names=pred_model.get_inference_tensor_names()[1])
return OfflinePredictor(predcfg)
def load_model(self):
print('Loading Model...')
model_path = self.model_path
model_constructor = self.get_model()
pred_config = PredictConfig(model=model_constructor(
self.nr_types, self.input_shape, self.mask_shape, self.input_norm),
session_init=get_model_loader(model_path),
input_names=self.input_tensor_names,
output_names=self.output_tensor_names)
self.predictor = OfflinePredictor(pred_config)
def get_model(model, ckpt_name, option):
model_path = ospj('train_log', option.log_dir, ckpt_name)
ds = get_data('val', option)
pred_config = PredictConfig(
model=model,
session_init=get_model_loader(model_path),
input_names=['input', 'label', 'bbox'],
output_names=['wrong-top1', 'top5', 'actmap', 'grad'],
return_input=True)
return SimpleDatasetPredictor(pred_config, ds)
def __init__(self, game_name, config, global_model_data_path, local_test_flag):
if not local_test_flag:
mkdirs(global_model_data_path+config.DRL.Learn.data_save_path)
self.game_name = game_name
self.data_save_path = global_model_data_path+config.DRL.Learn.data_save_path
self.config = config
self.global_iter = 0
self.ckpt_dir = global_model_data_path+self.config.DRL.Learn.ckpt_dir
self.ckpt_save_iter = self.config.DRL.Learn.ckpt_save_iter
if not local_test_flag:
mkdirs(self.ckpt_dir)
self.apply_prioritize_memory = False
if self.apply_prioritize_memory:
self.memory = PrioritizedReplay(capacity=self.config.DRL.Learn.replay_memory_size)
else:
# store the previous observations in replay memory
self.memory = deque()
if self.game_name == 'flappybird': # FlappyBird applies pytorch
use_cuda = config.DRL.Learn.cuda and torch.cuda.is_available()
self.device = 'cuda' if use_cuda else 'cpu'
self.actions_number = self.config.DRL.Learn.actions
# self.nn = DeepQNetwork().to(self.device)
self.nn = FlappyBirdDQN().to(self.device)
self.optim = optim.Adam(self.nn.parameters(), lr=self.config.DRL.Learn.learning_rate)
if config.DRL.Learn.ckpt_load:
self.load_checkpoint(model_name='flappy_bird_model')
self.game_state = FlappyBird()
if torch.cuda.is_available():
torch.cuda.manual_seed(123)
else:
torch.manual_seed(123)
elif self.game_name == 'Assault-v0' or self.game_name == 'Breakout-v0' or self.game_name == 'SpaceInvaders-v0':
if self.game_name == 'Assault-v0':
game_model_name = 'Assault-v0.tfmodel'
elif self.game_name == 'Breakout-v0':
game_model_name = 'Breakout-v0.npz'
elif self.game_name == 'SpaceInvaders-v0':
game_model_name = 'SpaceInvaders-v0.tfmodel'
else:
raise ValueError('Unknown game name {0}'.format(self.game_name))
self.env = self.get_player_atari(train=False)
num_actions = self.env .action_space.n
self.nn = OfflinePredictor(PredictConfig(
# model=Model(),
model=Model(num_actions=num_actions, image_size=(84, 84)),
session_init=SmartInit(self.ckpt_dir+game_model_name),
input_names=['state'],
output_names=['policy', 'pred_value']))
self.config.DRL.Learn.actions = num_actions
def __init__(self, name, need_network=True, need_img=True, model="best"):
super().__init__(name=name, is_deterministic=True)
self._resizer = CustomResize(cfg.PREPROC.TEST_SHORT_EDGE_SIZE,
cfg.PREPROC.MAX_SIZE)
self._prev_box = None
self._ff_gt_feats = None
self._need_network = need_network
self._need_img = need_img
self._rotated_bbox = None
if need_network:
logger.set_logger_dir(
"/tmp/test_log_/" + str(random.randint(0, 10000)), 'd')
if model == "best":
load = "train_log/hard_mining3/model-1360500"
elif model == "nohardexamples":
load = "train_log/condrcnn_all_2gpu_lrreduce2/model-1200500"
elif model == "newrpn":
load = "train_log/newrpn1/model"
elif model == "resnet50_nohardexamples":
load = "train_log/condrcnn_all_resnet50/model-1200500"
cfg.BACKBONE.RESNET_NUM_BLOCKS = [3, 4, 6, 3]
elif model == "resnet50":
load = "train_log/hard_mining3_resnet50/model-1360500"
cfg.BACKBONE.RESNET_NUM_BLOCKS = [3, 4, 6, 3]
elif model == "gotonly":
load = "train_log/hard_mining3_onlygot/model-1361000"
elif model.startswith("checkpoint:"):
load = model.replace("checkpoint:", "")
else:
assert False, ("unknown model", model)
from dataset import DetectionDataset
# init tensorpack model
# cfg.freeze(False)
DetectionDataset(
) # initialize the config with information from our dataset
cfg.EXTRACT_GT_FEATURES = True
cfg.MODE_TRACK = False
extract_model = ResNetFPNModel()
extract_ff_feats_cfg = PredictConfig(
model=extract_model,
session_init=get_model_loader(load),
input_names=['image', 'roi_boxes'],
output_names=['rpn/feature'])
finalize_configs(is_training=False)
self._extract_func = OfflinePredictor(extract_ff_feats_cfg)
cfg.EXTRACT_GT_FEATURES = False
cfg.MODE_TRACK = True
cfg.USE_PRECOMPUTED_REF_FEATURES = True
self._pred_func = self._make_pred_func(load)
def __init__(self):
super().__init__(name='ArgmaxTracker', is_deterministic=True)
self._ref_img = None
self._ref_bbox = None
self._prev_box = None
model = self._init_model()
load = "train_log/condrcnn_onlygot/model-460000"
predcfg = PredictConfig(
model=model,
session_init=get_model_loader(load),
input_names=model.get_inference_tensor_names()[0],
output_names=model.get_inference_tensor_names()[1])
self._pred_func = OfflinePredictor(predcfg)
def _test():
import numpy as np
# from tensorpack.tfutils import TowerContext
from tensorpack import PredictConfig, OfflinePredictor
pretrained = False
models = [
resnet10,
resnet12,
resnet14,
resnet16,
resnet18_wd4,
resnet18_wd2,
resnet18_w3d4,
resnet18,
resnet34,
resnet50,
resnet50b,
resnet101,
resnet101b,
resnet152,
resnet152b,
resnet200,
resnet200b,
seresnet18,
seresnet34,
seresnet50,
seresnet50b,
seresnet101,
seresnet101b,
seresnet152,
seresnet152b,
seresnet200,
seresnet200b,
]
for model in models:
net = model(pretrained=pretrained)
pred_config = PredictConfig(session_init=None,
model=net,
input_names=['input'],
output_names=['label'])
pred = OfflinePredictor(pred_config)
img = np.zeros((224, 224, 3), np.uint8)
prediction = pred([img])[0]
print(prediction)
pass
def prepare_sampling(self):
"""Prepare model for generate samples."""
if self.model is None:
self.model = self.get_model(training=False)
else:
self.model.training = False
predict_config = PredictConfig(
session_init=SaverRestore(self.restore_path),
model=self.model,
input_names=['z'],
output_names=['gen/gen', 'z'],
)
self.simple_dataset_predictor = SimpleDatasetPredictor(
predict_config, RandomZData((self.batch_size, self.z_dim)))
def test(args):
from imageio import imsave
from tictoc import Timer
data_folder = args.get("data_folder")
image_size = args.get("image_size")
batch_size = args.get("batch_size") or BATCH
test_ckpt = args.get("test_ckpt")
test_folder = args.get("test_folder")
if not os.path.exists(test_folder):
os.makedirs(test_folder)
pred_config = PredictConfig(
model=Style2PO(args),
session_init=SmartInit(test_ckpt),
input_names=["image_input", "image_target"],
output_names=['stages-target/viz', 'loss_output'])
predictor = OfflinePredictor(pred_config)
zmin, zmax = (0, 1) if args.get("act_input") == "identity" else (-1, 1)
test_ds = get_data(data_folder, image_size, False, zmin, zmax, batch_size)
test_ds.reset_state()
idx = 0
losses = list()
print("------------------ predict --------------")
timer = Timer("predict", tic=True, show=Timer.STDOUT)
for rz, it in test_ds:
output_array, loss_output = predictor(rz, it)
if output_array.ndim == 4:
for i in range(output_array.shape[0]):
imsave(os.path.join(test_folder, "test-{}.jpg".format(idx)),
output_array[i])
idx += 1
else:
imsave(os.path.join(test_folder, "test-{}.jpg".format(idx)),
output_array)
idx += 1
losses.append(loss_output)
print("loss #", idx, "=", loss_output)
timer.toc(Timer.STDOUT)
print("Test and save", idx, "images to", test_folder, "avg loss =",
np.mean(losses))
def export_eval_protobuf_model(checkpoint_dir, model_name, dataset, quant_type,
output_file, batch_size):
_, test_data, (img_shape, label_shape) = datasets.DATASETS[dataset]()
model_func, input_spec, output_spec = get_model_func(
"eval", model_name, quant_type, img_shape, label_shape[0])
input_names = [i.name for i in input_spec]
output_names = [o.name for o in output_spec]
predictor_config = PredictConfig(session_init=SaverRestore(checkpoint_dir +
"/checkpoint"),
tower_func=model_func,
input_signature=input_spec,
input_names=input_names,
output_names=output_names,
create_graph=False)
print("Exporting optimised protobuf graph...")
K.set_learning_phase(False)
ModelExporter(predictor_config).export_compact(output_file, optimize=False)
K.clear_session()
pred = OfflinePredictor(predictor_config)
test_data = BatchData(test_data, batch_size, remainder=True)
test_data.reset_state()
num_correct = 0
num_processed = 0
for img, label in tqdm(test_data):
num_correct += sum(pred(img)[0].argmax(axis=1) == label.argmax(axis=1))
num_processed += img.shape[0]
print("Exported model has accuracy {:.4f}".format(num_correct /
num_processed))
return input_names, output_names, {i.name: i.shape for i in input_spec}
def gen_pred_config(self):
if self.inf_auto_find_chkpt:
self.inf_model_path = os.path.join(
self.save_dir,
str(
max([
int(x) for x in [
name for name in os.listdir(self.save_dir)
if os.path.isdir(os.path.join(self.save_dir, name))
]
])),
)
print(f"Inference model path: <{self.inf_model_path}>")
print(
'-----Auto Selecting Checkpoint Basing On "%s" Through "%s" Comparison'
% (self.inf_auto_metric, self.inf_auto_comparator))
model_path, stat = get_best_chkpts(self.inf_model_path,
self.inf_auto_metric,
self.inf_auto_comparator)
print("Selecting: %s" % model_path)
print("Having Following Statistics:")
for key, value in stat.items():
print("\t%s: %s" % (key, value))
sess = get_model_loader(model_path)
else:
model_path = self.inf_model_path
sess = SaverRestoreRelaxed(self.inf_model_path)
model_constructor = self.get_model()
pred_config = PredictConfig(
model=model_constructor(),
session_init=sess,
input_names=self.eval_inf_input_tensor_names,
output_names=self.eval_inf_output_tensor_names,
)
return pred_config
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
# ROM_FILE = args.rom
METHOD = args.algo
# set num_actions
init_player = MedicalPlayer(directory=data_dir,
files_list=test_list,
screen_dims=IMAGE_SIZE,
spacing=SPACING)
NUM_ACTIONS = init_player.action_space.n
num_validation_files = init_player.files.num_files
if args.task != 'train':
assert args.load is not None
pred = OfflinePredictor(PredictConfig(
model=Model(),
session_init=get_model_loader(args.load),
input_names=['state'],
output_names=['Qvalue']))
if args.task == 'play':
t0 = time.time()
play_n_episodes(get_player(directory=data_dir,
files_list=test_list, viz=0.01,
saveGif=args.saveGif,
saveVideo=args.saveVideo),
pred, num_validation_files)
t1 = time.time()
print(t1-t0)
elif args.task == 'eval':
eval_model_multithread(pred, EVAL_EPISODE, get_player)
else:
##########################################################
#initialize states and Qvalues for the various agents
state_names = []
qvalue_names = []
for i in range(0, args.agents):
state_names.append('state_{}'.format(i))
qvalue_names.append('Qvalue_{}'.format(i))
############################################################
if args.task != 'train':
assert args.load is not None
pred = OfflinePredictor(
PredictConfig(model=Model(agents=args.agents),
session_init=get_model_loader(args.load),
input_names=state_names,
output_names=qvalue_names))
# demo pretrained model one episode at a time
if args.task == 'play':
play_n_episodes(get_player(files_list=args.files,
viz=0.01,
saveGif=args.saveGif,
saveVideo=args.saveVideo,
task='play',
agents=args.agents),
pred,
num_files,
agents=args.agents,
reward_strategy=args.reward_strategy)
# run episodes in parallel and evaluate pretrained model
elif args.task == 'eval':
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('image_path')
parser.add_argument('--model_path', default='log/checkpoint')
parser.add_argument('--output_path', default='figures/')
parser.add_argument('--size', type=int, default=32)
args = parser.parse_args()
np.random.seed(0)
# initialize the model
predict_func = OfflinePredictor(
PredictConfig(inputs_desc=[
InputDesc(tf.float32, [None, INPUT_SIZE, INPUT_SIZE, 2],
'input_image')
],
tower_func=model.feedforward,
session_init=SaverRestore(args.model_path),
input_names=['input_image'],
output_names=['prob']))
# simulate suda's gridworld input
image = cv2.imread(
args.image_path,
cv2.IMREAD_GRAYSCALE) # 0 if obstacle, 255 if free space
h, w = image.shape[:2]
obj = img2obj(image) # list containing row major indices of objects
# specify position is recent memory
radius = 6
#s = [340/2, 110/2] # needs to be a list
s = [131, 147, 162]
METHOD = args.algo
# load files into env to set num_actions, num_validation_files
init_player = MedicalPlayer(
files_list=args.files, #files_list=files_list,
data_type=args.type,
screen_dims=IMAGE_SIZE,
task='play')
NUM_ACTIONS = init_player.action_space.n
num_files = init_player.files.num_files
if args.task != 'train':
assert args.load is not None
pred = OfflinePredictor(
PredictConfig(model=Model(IMAGE_SIZE, FRAME_HISTORY, METHOD,
NUM_ACTIONS, GAMMA, args.trainable),
session_init=get_model_loader(args.load),
input_names=['state'],
output_names=['Qvalue']))
# demo pretrained model one episode at a time
if args.task == 'play':
play_n_episodes(get_player(files_list=args.files,
data_type=args.type,
viz=0,
saveGif=args.saveGif,
saveVideo=args.saveVideo,
task='play'),
pred,
num_files,
viewer=None)
# run episodes in parallel and evaluate pretrained model