def load(self):
self.class_mapping = load_dict(self.path_to_class_mapping)
self.opt = load_dict(self.path_to_pipeline_opt)
self.classifier = joblib.load(os.path.join(self.model_path, "classifier.pkl"))
if self.class_mapping is not None:
self.class_mapping_inv = {v: k for k, v in self.class_mapping.items()}
print("Classifier was loaded!")
def load(self):
self.class_mapping = load_dict(self.path_to_class_mapping)
self.class_mapping_inv = {v: k for k, v in self.class_mapping.items()}
self.feature_extractor = joblib.load(self.feature_extractor_path)
self.classifier = joblib.load(self.classifier_path)
self.aggregator = joblib.load(self.aggregator_path)
self._pipeline_opt = load_dict(self.path_to_opt)
def run_test(df, mf, us):
color_coding = load_dict(os.path.join(mf, "color_coding.json"))
model = Model(mf)
model.load(mf)
res_fol = Folder(os.path.join(mf, "segmentations"))
res_fol.check_n_make_dir(clean=True)
vis_fol = Folder(os.path.join(mf, "overlays"))
vis_fol.check_n_make_dir(clean=True)
d_set = SegmentationDataSet(df, color_coding)
t_set = d_set.load()
sh = StatsHandler(color_coding)
print("Processing Images...")
for tid in tqdm(t_set):
cls_map = model.predict(t_set[tid].load_x())
color_map = convert_cls_to_color(cls_map,
color_coding,
unsupervised=us)
t_set[tid].write_result(res_fol.path(), color_map)
if not us:
t_set[tid].eval(color_map, sh)
t_set[tid].visualize_result(vis_fol.path(), color_map)
sh.eval()
sh.show()
sh.write_report(os.path.join(mf, "report.txt"))
def main(args_):
df = args_.dataset_folder
mf = args_.model_folder
color_coding = load_dict(os.path.join(mf, "color_coding.json"))
model = Model(mf)
model.load(mf)
res_fol = Folder(os.path.join(mf, "segmentations"))
res_fol.check_n_make_dir(clean=True)
vis_fol = Folder(os.path.join(mf, "overlays"))
vis_fol.check_n_make_dir(clean=True)
d_set = VideoSet(df, color_coding)
t_set = d_set.load()
sh = StatsHandler(color_coding)
print("Processing Images...")
for tid in tqdm(t_set):
cls_map = model.predict(t_set[tid])
color_map = convert_cls_to_color(cls_map, color_coding)
t_set[tid].write_result(res_fol.path(), color_map)
t_set[tid].eval(color_map, sh)
t_set[tid].visualize_result(vis_fol.path(), color_map)
sh.eval()
sh.show()
sh.write_report(os.path.join(mf, "report.txt"))
def main(args_):
df = args_.dataset_folder
mf = args_.model_folder
color_coding = load_dict(os.path.join(mf, "color_coding.json"))
model = Model(mf)
model.load(mf)
res_fol = Folder(os.path.join(df, "inference"))
res_fol.check_n_make_dir(clean=True)
d_set = SegmentationDataSet(df, color_coding)
t_set = d_set.load()
sh = StatsHandler(color_coding)
print("Processing Images...")
for tid in tqdm(t_set):
cls_map = model.predict(t_set[tid].load_x())
color_map = convert_cls_to_color(cls_map, color_coding)
im_id = os.path.basename(t_set[tid].path_to_image_file)
cv2.imwrite(os.path.join(str(res_fol), im_id[:-4] + ".png"), color_map)
sh.eval()
sh.show()
sh.write_report(os.path.join(mf, "report.txt"))
def main(args_):
cfg = Config(args_.model_folder)
cfg.class_mapping = load_dict(args_.class_mapping)
f_1 = start_training(args_, cfg)
def load(self, model_path, name="clf"):
self.opt = load_dict(
os.path.join(model_path, "{}_opt.json".format(name)))
self.regressor = joblib.load(
os.path.join(model_path, "{}.pkl".format(name)))
graph = state['graph']
text_f = state['text_f']
mappings = state['mappings']
num_ent = state['num_ent']
num_rel = state['num_rel']
id2ent = state['id2ent']
print("finish load")
else:
embedding_dim = args.nb_heads * args.hidden
num_rel = int(
open(os.path.join(args.data_dir, 'relation2id.txt')).readline())
text_file = os.path.join(args.data_dir, 'entity_text_title_tokenized.json')
mappings, text_f = load_text(text_file, args.freq, args.max_len)
ent_f = os.path.join(args.data_dir, 'entity2id.txt')
id2ent, num_ent = load_dict(ent_f)
# Load Graph Data
graph, _ = load_graph(os.path.join(args.data_dir, 'train2id.txt'), num_ent)
# Parse parameters
parameters = OrderedDict()
parameters['emb_dim'] = embedding_dim
parameters['hid_dim'] = args.hidden
parameters['out_dim'] = args.hidden * args.nb_heads
parameters['num_voc'] = len(mappings['idx2word'])
parameters['num_heads'] = args.nb_heads
parameters['num_ent'] = num_ent
parameters['num_rel'] = num_rel
parameters['dropout'] = args.dropout
parameters['alpha'] = args.alpha
parameters['margin'] = args.margin
# Initialize
# load previously saved data
state = pickle.load(open('dataset.pth', 'rb'))
parameters = state['parameters']
graph = state['graph']
text_f = state['text_f']
mappings = state['mappings']
num_ent = state['num_ent']
num_rel = state['num_rel']
id2ent = state['id2ent']
num_ent = state['num_ent']
print("finish load")
rel_f = os.path.join(args.data_dir, 'relation2id.txt')
id2rel, _ = load_dict(rel_f)
name_f = os.path.join(args.data_dir, 'term.pth')
ent2name = pickle.load(open(name_f, "rb"))
# Load Positive and Negative Examples
params = {
'batch_size': args.batch_size,
'shuffle': True,
'collate_fn': adjust_sent_order
}
train_set = LinkPredictionDataset(os.path.join(args.data_dir, 'train2id.txt'),
text_f, id2ent, num_ent)
train_triple_dict = train_set.get_triple_dict()
train_generator = data.DataLoader(train_set, **params)
print('Finish loading train')
def load(self, model_path):
self.config = load_dict(os.path.join(model_path, "config.json"))
self.pipeline = Pipeline(self.config,
selected_layer=self.opt["selected_layer"])
def load_layer(self, model_folder):
opt = load_dict(os.path.join(model_folder, "opt.json"))
if "layer_type" not in opt:
raise ValueError("No LayerType Option is defined!")
if opt["layer_type"] == "GRAPH_LAYER":
prev_layer = self.load_previous_layers(model_folder)
layer = PixelLayer(prev_layer, opt["name"], opt["kernel"],
opt["strides"], opt["kernel_shape"],
opt["down_scale"])
layer.set_index(int(opt["index"]))
layer.load(model_folder)
return layer
if opt["layer_type"] == "GRAPH3D_LAYER":
prev_layer = self.load_previous_layers(model_folder)
layer = Graph3DLayer(prev_layer, opt["name"], opt["kernel"],
opt["kernel_shape"], opt["down_scale"])
layer.set_index(int(opt["index"]))
layer.load(model_folder)
return layer
if opt["layer_type"] == "INPUT_LAYER":
layer = InputLayer(opt["name"],
opt["features_to_use"],
height=opt["height"],
width=opt["width"],
initial_down_scale=opt["down_scale"])
layer.set_index(int(opt["index"]))
layer.load(model_folder)
return layer
if opt["layer_type"] == "INPUT3D_LAYER":
layer = Input3DLayer(opt["name"],
opt["features_to_use"],
height=opt["height"],
width=opt["width"],
initial_down_scale=opt["down_scale"])
layer.set_index(int(opt["index"]))
layer.load(model_folder)
return layer
if opt["layer_type"] == "GLOBAL_CONTEXT_LAYER":
prev_layer = self.load_previous_layers(model_folder)
layer = GlobalContextLayer(prev_layer, opt["name"],
opt["down_scale"])
layer.set_index(int(opt["index"]))
return layer
if opt["layer_type"] == "NORMALIZATION_LAYER":
prev_layer = self.load_previous_layers(model_folder)
layer = NormalizationLayer(prev_layer,
opt["name"],
norm_option=opt["norm_option"])
layer.set_index(int(opt["index"]))
return layer
if opt["layer_type"] == "SHAPE_REFINEMENT_LAYER":
prev_layer = self.load_previous_layers(model_folder)
layer = ShapeRefinementLayer(prev_layer,
opt["name"],
shape=opt["shape"],
global_kernel=opt["global_kernel"])
layer.load(model_folder)
layer.set_index(int(opt["index"]))
return layer
if opt["layer_type"] == "SHAPE_REFINEMENT_3D_LAYER":
prev_layer = self.load_previous_layers(model_folder)
layer = ShapeRefinement3DLayer(prev_layer,
opt["name"],
shape=opt["shape"],
global_kernel=opt["global_kernel"])
layer.load(model_folder)
layer.set_index(int(opt["index"]))
return layer
if opt["layer_type"] == "BOTTLE_NECK_LAYER":
prev_layer = self.load_previous_layers(model_folder)
layer = BottleNeckLayer(prev_layer, opt["name"])
layer.set_index(int(opt["index"]))
return layer
if opt["layer_type"] == "BOTTLE_NECK3D_LAYER":
prev_layer = self.load_previous_layers(model_folder)
layer = BottleNeck3DLayer(prev_layer, opt["name"])
layer.set_index(int(opt["index"]))
return layer
if opt["layer_type"] == "VOTING3D_Layer":
prev_layer = self.load_previous_layers(model_folder)
layer = Voting3DLayer(prev_layer, opt["name"])
layer.set_index(int(opt["index"]))
return layer
if opt["layer_type"] == "VOTING_Layer":
prev_layer = self.load_previous_layers(model_folder)
layer = VotingLayer(prev_layer, opt["name"])
layer.set_index(int(opt["index"]))
return layer
if opt["layer_type"] == "SUPER_PIXEL_LAYER":
prev_layer = self.load_previous_layers(model_folder)
layer = SuperPixelLayer(
prev_layer,
opt["name"],
super_pixel_method=opt["super_pixel_method"],
down_scale=opt["down_scale"],
feature_aggregation=opt["feature_aggregation"])
layer.set_index(int(opt["index"]))
layer.load(model_folder)
return layer
if opt["layer_type"] == "SIMPLE_LAYER":
prev_layer = self.load_previous_layers(model_folder)
if "selected_layer" not in opt:
opt["selected_layer"] = -1
layer = SimpleLayer(prev_layer,
opt["name"],
None,
selected_layer=opt["selected_layer"])
layer.set_index(int(opt["index"]))
layer.load(model_folder)
return layer
if opt["layer_type"] == "SUPER_PIXEL_3D_LAYER":
prev_layer = self.load_previous_layers(model_folder)
layer = SuperPixel3DLayer(
prev_layer,
opt["name"],
time_range=opt["time_range"],
super_pixel_method=opt["super_pixel_method"],
down_scale=opt["down_scale"],
feature_aggregation=opt["feature_aggregation"],
)
layer.set_index(int(opt["index"]))
layer.load(model_folder)
return layer
if opt["layer_type"] == "FEATURE_EXTRACTION_LAYER":
prev_layer = self.load_previous_layers(model_folder)
layer = FeatureExtractionLayer(prev_layer,
opt["name"],
down_scale=opt["down_scale"],
kernel=opt["kernel"],
kernel_shape=opt["kernel_shape"])
layer.set_index(int(opt["index"]))
layer.load(model_folder)
return layer
if opt["layer_type"] == "OBJECT_SELECTION_LAYER":
prev_layer = self.load_previous_layers(model_folder)
layer = ObjectSelectionLayer(prev_layer, opt["name"])
layer.set_index(int(opt["index"]))
layer.load(model_folder)
return layer
raise ValueError("Layer: {} not recognised!".format(opt["layer_type"]))
