def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--data', action='store', help='', metavar='FILE')
parser.add_argument('--scratch',
action='store',
help='',
metavar="DIR",
default="_tmp_")
parser.add_argument('-j',
'--procs',
action='store',
help='',
type=int,
metavar='int',
default=0)
args = parser.parse_args()
if args.scratch[-1] != "/":
args.scratch += "/"
header, data = read_csv(args.data, read_header=True)
data = clean_data(data)
misc.save_obj(args.scratch + "molecule_data", data)
misc.save_json(args.scratch + "molecule_data", data)
return
def save_all_proposals(where="/mnt/datasets/public/issam/VOCdevkit/"\
"proposals/sharpmask/pascal_proposals/",
path="pascal_val2007"):
if 1:
import glob
loc = "/mnt/datasets/public/issam/VOCdevkit/proposals/"\
"sharpmask/{}/jsons".format(path)
proposals_dict = {}
jsonList = glob.glob(loc + "/*.json")
for json in jsonList:
proposals = ms.load_json(json)
n = len(proposals)
for i in range(n):
print(str(i) + "/" + str(n) + " proposals")
image_id = proposals[i]["image_id"]
if image_id in proposals_dict:
proposals_dict[image_id] += [proposals[i]]
else:
proposals_dict[image_id] = [proposals[i]]
n = len(proposals_dict)
for j, image_id in enumerate(proposals_dict):
print(str(j) + "/" + str(n))
ms.save_json(where + "{}.json".format(str(image_id)),
proposals_dict[image_id])
def test_run(main_dict, metric_name, save, reset, predict_proposal=None):
if predict_proposal is None:
predict_proposal = ""
history = ms.load_history(main_dict)
if history is None:
best_epoch = 0
else:
best_epoch = history["best_model"]["epoch"]
fname = main_dict["path_save"] + "/test_{}{}_{}.json".format(
predict_proposal, metric_name, best_epoch)
print("Testing: {} - {} - {} - {} - best epoch: {}".format(
main_dict["dataset_name"], main_dict["config_name"],
main_dict["loss_name"], metric_name, best_epoch))
if not os.path.exists(fname) or reset == "reset":
with torch.no_grad():
score = ms.val_test(main_dict,
metric_name=metric_name,
n_workers=1)
ms.save_json(fname, score)
else:
score = ms.load_json(fname)
return score[metric_name]
def __init__(self, batch):
# if dataset_name == "pascal":
self.proposals_path = batch["proposals_path"][0]
if "SharpProposals_name" in batch:
batch_name = batch["SharpProposals_name"][0]
else:
batch_name = batch["name"][0]
name_jpg = self.proposals_path + "{}.jpg.json".format(batch_name)
name_png = self.proposals_path + "{}.json".format(batch_name)
if os.path.exists(name_jpg):
name = name_jpg
else:
name = name_png
_, _, self.h, self.w = batch["images"].shape
if "resized" in batch and batch["resized"].item() == 1:
name_resized = self.proposals_path + "{}_{}_{}.json".format(
batch["name"][0], self.h, self.w)
if not os.path.exists(name_resized):
proposals = ms.load_json(name)
json_file = loop_and_resize(self.h, self.w, proposals)
ms.save_json(name_resized, json_file)
else:
name_resized = name
# name_resized = name
proposals = ms.load_json(name_resized)
self.proposals = sorted(proposals,
key=lambda x: x["score"],
reverse=True)
def evaluateAnnList(annList, visualize=False):
path_base = "/mnt/datasets/public/issam/VOCdevkit/annotations/"
fname = "{}/instances_val2012.json".format(path_base)
cocoGt = COCO(fname)
ms.save_json("tmp.json", annList)
cocoDt = cocoGt.loadRes("tmp.json")
cocoEval = COCOeval(cocoGt, cocoDt, "segm")
# cocoEval = COCOeval(cocoGt, cocoDt, annType)
cocoEval.params.imgIds = list(
set([v["image_id"] for v in cocoDt.anns.values()]))
cocoEval.evaluate()
cocoEval.accumulate()
cocoEval.summarize()
print("# images:", len(cocoEval.params.imgIds))
if visualize:
for image_id in cocoDt.getImgIds():
visGT(cocoGt, cocoDt, image_id)
return cocoEval, cocoDt
def text(bot, update):
log.debug('Handling `text` command. Update: %s', update)
from_id = str(update.effective_user.id)
token = settings.USERS.get(from_id, None)
if token is None:
update.message.reply_text('Извините, вы не наш клиент :(')
return
if from_id not in lul_clients:
lul_clients[from_id] = LogulifeClient(token=token)
client = lul_clients[from_id]
if update.message is None: # this is update
try:
client.records.update_by_ext_id(settings.SOURCE_NAME,
update.edited_message.message_id,
update.edited_message.text)
update.edited_message.reply_text(messages.OK_UPDATE)
except lul_exceptions.NotFoundException as exc:
log.debug(exc)
update.edited_message.reply_text(messages.NOT_FOUND)
except Exception as exc:
log.error(exc)
save_msg = '{0}\n{1}'.format(str(exc), update.to_json())
misc.save_json(update.update_id, save_msg)
update.edited_message.reply_text(messages.OK_UPDATE)
# Сообщение админу
bot.send_message(
settings.ADMIN_ACCOUNT,
'Запись с id={0} у пользователя {1} не была ' \
'обновлена. Ошибка: {2}'.format(
update.update_id,
update.effective_user.username,
str(exc)))
else:
try:
client.records.create(update.message.text, settings.SOURCE_NAME,
update.message.message_id,
update.message.date)
except Exception as exc:
log.error(exc)
save_msg = '{0}\n{1}'.format(str(exc), update.to_json())
misc.save_json(update.update_id, save_msg)
# Сообщение админу
bot.send_message(
settings.ADMIN_ACCOUNT,
'Запись с id={0} у пользователя {1} не была ' \
'сохранена. Ошибка: {2}'.format(
update.update_id,
update.effective_user.username,
str(exc)))
update.message.reply_text(messages.OK)
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--scratch',
action='store',
help='',
metavar="DIR",
default="_tmp_")
parser.add_argument('--json', action='store', help='', metavar="FILE")
parser.add_argument('-j',
'--procs',
action='store',
help='pararallize',
metavar="int",
default=0,
type=int)
args = parser.parse_args()
if args.scratch[-1] != "/":
args.scratch += "/"
data = misc.load_json(args.json)
keys = data.keys()
keys = list(keys)
canonical_data = {}
for key in keys:
molobj, status = cheminfo.smiles_to_molobj(key)
if molobj is None:
print("error none mol:", key)
continue
smiles = cheminfo.molobj_to_smiles(molobj, remove_hs=True)
if "." in smiles:
print("error multi mol:", smiles)
continue
atoms = cheminfo.molobj_to_atoms(molobj)
if not is_mol_allowed(atoms):
print("error heavy mol:", smiles)
continue
canonical_data[smiles] = data[key]
misc.save_json(args.scratch + "molecule_data", canonical_data)
misc.save_obj(args.scratch + "molecule_data", canonical_data)
return
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--scratch', action='store', help='', metavar="DIR", default="_tmp_")
parser.add_argument('--sdf', action='store', help='', metavar="FILE", nargs="+")
parser.add_argument('-j', '--procs', action='store', help='pararallize', metavar="int", default=0, type=int)
args = parser.parse_args()
if args.scratch[-1] != "/":
args.scratch += "/"
if args.procs == -1:
args.procs = os.cpu_count()
print("starting", args.procs, "procs")
# fsdf = gzip.open(args.scratch + "structures.sdf.gz", 'w')
# fprop = open(args.scratch + "properties.csv", 'w')
mol_val_dict = {}
for sdf in args.sdf:
print("reading", sdf)
molobjs, values = parse_ochem(sdf, debug=True, procs=args.procs)
for molobj, value in zip(molobjs, values):
smiles = cheminfo.molobj_to_smiles(molobj, remove_hs=True)
if "smiles" not in mol_val_dict:
mol_val_dict[smiles] = []
else:
print("duplicate", smiles)
mol_val_dict[smiles].append(value)
# sdfstr = cheminfo.molobj_to_sdfstr(molobj)
# sdfstr += "$$$$\n"
#
# propstr = "{:} {:}\n".format(value, 0.0)
# fprop.write(propstr)
# fsdf.close()
# fprop.close()
keys = mol_val_dict.keys()
print("TOTAL ITEMS", len(keys))
misc.save_json(args.scratch + "molecule_data", mol_val_dict)
misc.save_obj(args.scratch + "molecule_data", mol_val_dict)
return
def load_predAnnList(main_dict, predict_method, imageList=None,
proposal_type="sharp", reset=None):
predictList = ["BestObjectness", "UpperBound", "BestDice"]
if predict_method not in predictList:
raise ValueError("predict method should be in {}".format(predictList))
dataset_name = main_dict["dataset_name"]
base = "/mnt/projects/counting/Saves/main/"
fname = base + "lcfcn_points/{}_{}_{}_annList.json".format(dataset_name,
predict_method, proposal_type)
if os.path.exists(fname) and reset != "reset":
return ms.load_json(fname)
else:
if predict_method == "BestDice":
model = ms.load_best_model(main_dict)
_, val_set = load_trainval(main_dict)
loader = data.DataLoader(val_set,
batch_size=1,
num_workers=0,
drop_last=False)
# pointDict = load_LCFCNPoints(main_dict)
annList = []
for i, batch in enumerate(loader):
print(i, "/", len(loader), " - annList")
pointList = batch["lcfcn_pointList"]
if len(pointList) == 0:
continue
if predict_method == "BestDice":
pred_dict = model.predict(batch, predict_method="BestDice",
proposal_type=proposal_type)
else:
pred_dict = eval("pointList2{}".format(predict_method))(pointList, batch, proposal_type)
annList += pred_dict["annList"]
ms.save_json(fname, annList)
return annList
def copy_models(exp_dict, path_dst):
history = load_history(exp_dict)
# src_model, src_opt = ms.load_model_src(exp_dict)
# tgt_model, tgt_opt, disc, disc_opt = ms.load_model_tgt(exp_dict)
# create_dirs(path_dst + "/tmp")
# torch.save(src_model.state_dict(), path_dst+"/model_src.pth")
# torch.save(src_opt.state_dict(), path_dst+"/opt_src.pth")
# torch.save(tgt_model.state_dict(), path_dst+"/model_tgt.pth")
# torch.save(tgt_opt.state_dict(), path_dst+"/opt_tgt.pth")
# torch.save(disc.state_dict(), path_dst+"/disc.pth")
# torch.save(disc_opt.state_dict(), path_dst+"/disc_opt.pth")
ms.save_json(path_dst + "/history.json", history)
print("copied...")
def clean_data(df, scratch):
smiles = df.iloc[1]
data = {}
atom_types = []
for index, row in df.iterrows():
smi = row.smiles
value = row.mpC + 273.15
molobj, status = cheminfo.smiles_to_molobj(smi)
if molobj is None:
print("error:", smi)
continue
smi = cheminfo.molobj_to_smiles(molobj, remove_hs=True)
# Atoms
atoms = cheminfo.molobj_to_atoms(molobj)
atom_types += list(atoms)
if smi not in data:
data[smi] = []
data[smi].append(value)
atom_types, counts = np.unique(atom_types, return_counts=True)
for atom, count in zip(atom_types, counts):
print(atom, count)
misc.save_obj(scratch + "molecule_data", data)
misc.save_json(scratch + "molecule_data", data)
return
def __init__(self,
root="",
split=None,
transform_function=None,
ratio=None,
year="2017"):
super().__init__()
fname = split
if fname == "test":
fname = "val"
dataset_name = "COCO"
if year == "2014":
dataset_name = "COCO2014"
self.n_classes = 81
self.path = "/mnt/datasets/public/issam/{}/".format(dataset_name)
self.proposals_path = "{}/ProposalsSharp/".format(self.path)
self.split = split
self.year = year
self.transform_function = transform_function()
fname_names = self.path + "/{}.json".format(self.split)
fname_catids = self.path + "/{}_catids.json".format(self.split)
fname_categories = self.path + "/categories.json"
fname_ids = self.path + "/{}_ids.json".format(self.split)
if os.path.exists(fname_names):
self.image_names = ms.load_json(fname_names)
self.catids = ms.load_json(fname_catids)
self.categories = ms.load_json(fname_categories)
self.ids = ms.load_json(fname_ids)
else:
# Save ids
annFile = "{}/annotations/instances_{}{}.json".format(
self.path, fname, year)
self.coco = COCO(annFile)
self.ids = list(self.coco.imgs.keys())
self.image_names = []
# Save Labels
for index in range(len(self.ids)):
print(index, "/", len(self.ids))
img_id = self.ids[index]
ann_ids = self.coco.getAnnIds(imgIds=img_id)
annList = self.coco.loadAnns(ann_ids)
name = self.coco.loadImgs(img_id)[0]['file_name']
self.image_names += [name]
ms.save_pkl(
self.path +
"/groundtruth/{}_{}.pkl".format(self.split, name), annList)
ms.save_json(fname_names, self.image_names)
# Catgory
self.catids = self.coco.getCatIds()
ms.save_json(fname_catids, self.catids)
self.categories = []
categories = self.coco.cats.values()
for c in categories:
c["id"] = self.category2label[c["id"]]
self.categories += [c]
ms.save_json(fname_categories, self.categories)
ms.save_json(fname_ids, self.ids)
if split == "val":
# gt_annDict = ms.load_json(annFile)
annDict = {}
# fname_ann = '/mnt/datasets/public/issam/COCO2014//annotations/val_gt_annList.json'
annDict["categories"] = self.categories
annDict["images"] = self.coco.loadImgs(self.ids[:5000])
annIDList = self.coco.getAnnIds(self.ids[:5000])
annList = self.coco.loadAnns(annIDList)
for p in annList:
# p["id"] = str(p["id"])
p["image_id"] = str(p["image_id"])
p["category_id"] = self.category2label[p["category_id"]]
for p in annDict["images"]:
p["id"] = str(p["id"])
annDict["annotations"] = annList
ms.save_json(
'{}//annotations/val_gt_annList.json'.format(self.path),
annDict)
self.category2label = {}
self.label2category = {}
for i, c in enumerate(self.catids):
self.category2label[c] = i + 1
self.label2category[i + 1] = c
if split == "val":
# gt_annList_path = '/mnt/datasets/public/issam/COCO2014//annotations/val_gt_annList.json'
annList_path = self.path + "/annotations/{}_gt_annList.json".format(
split)
assert os.path.exists(annList_path)
self.annList_path = annList_path
# self.image_names.sort()
self.image_names = self.image_names[:5000]
self.ids = self.ids[:5000]
elif split == "test":
# self.image_names.sort()
self.image_names = self.ids[-5000:]
figName = "%s/pdf_plots/TGT_%s.pdf" % (path, exp_name)
ms.create_dirs(figName)
pp_main.fig.savefig(figName, dpi=600)
print("saved {}".format(figName))
####################################################
if args.mode == "test_model":
OA = 0.
AA = 0.
Kappa = 0.
for run in range(N_Runs):
OA = OA + results[run]['OA']
AA = AA + results[run]['AA']
Kappa = Kappa + results[run]['Kappa']
print("====================="
"\nOvearll Accuracy {}\n"
"=====================".format(OA / N_Runs))
print("====================="
"\nAverage Accuracy {}\n"
"=====================".format(AA / N_Runs))
print("====================="
"\nKappa {}\n"
"=====================".format(Kappa / N_Runs))
result = {}
result['OA'] = [OA / N_Runs]
result['AA'] = [AA / N_Runs]
result['Kappa'] = [Kappa / N_Runs]
ms.save_json(
'results/' + exp_name + '_center_{}_disc_{}.json'.format(
exp_dict["options"]["center"], exp_dict["options"]["disc"]),
result)
def load_gtAnnDict(main_dict, reset=None):
reset = None
_, val_set = load_trainval(main_dict)
annList_path = val_set.annList_path
if os.path.exists(annList_path) and reset != "reset":
return ms.load_json(annList_path)
else:
ann_json = {}
ann_json["categories"] = val_set.categories
ann_json["type"] = "instances"
# Images
imageList = []
annList = []
id = 1
for i in range(len(val_set)):
print("{}/{}".format(i, len(val_set)))
batch = val_set[i]
image_id = batch["name"]
height, width = batch["images"].shape[-2:]
imageList += [{"file_name":batch["name"],
"height":height,
"width":width,
"id":batch["name"]}]
maskObjects = batch["maskObjects"]
maskClasses = batch["maskClasses"]
n_objects = maskObjects[maskObjects!=255].max().item()
for obj_id in range(1, n_objects+1):
if obj_id == 0:
continue
binmask = (maskObjects == obj_id)
segmentation = maskUtils.encode(np.asfortranarray(ms.t2n(binmask)))
segmentation["counts"] = segmentation["counts"].decode("utf-8")
uniques = (binmask.long()*maskClasses).unique()
uniques = uniques[uniques!=0]
assert len(uniques) == 1
category_id = uniques[0].item()
annList += [{"segmentation":segmentation,
"iscrowd":0,
# "bbox":maskUtils.toBbox(segmentation).tolist(),
"area":int(maskUtils.area(segmentation)),
"id":id,
"image_id":image_id,
"category_id":category_id}]
id += 1
ann_json["annotations"] = annList
ann_json["images"] = imageList
ms.save_json(annList_path, ann_json)
# Save dummy results
anns = ms.load_json(annList_path)
fname_dummy = annList_path.replace(".json","_best.json")
annList = anns["annotations"]
for a in annList:
a["score"] = 1
ms.save_json(fname_dummy, annList)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-e', '--exp')
parser.add_argument('-b', '--borgy', default=0, type=int)
parser.add_argument('-br', '--borgy_running', default=0, type=int)
parser.add_argument('-m', '--mode', default="summary")
parser.add_argument('-r', '--reset', default="None")
parser.add_argument('-s', '--status', type=int, default=0)
parser.add_argument('-k', '--kill', type=int, default=0)
parser.add_argument('-g', '--gpu', type=int)
parser.add_argument('-c', '--configList', nargs="+", default=None)
parser.add_argument('-l', '--lossList', nargs="+", default=None)
parser.add_argument('-d', '--datasetList', nargs="+", default=None)
parser.add_argument('-metric', '--metricList', nargs="+", default=None)
parser.add_argument('-model', '--modelList', nargs="+", default=None)
parser.add_argument('-p', '--predictList', nargs="+", default=None)
args = parser.parse_args()
if args.borgy or args.kill:
global_prompt = input("Do all? \n(y/n)\n")
# SEE IF CUDA IS AVAILABLE
assert torch.cuda.is_available()
print("CUDA: %s" % torch.version.cuda)
print("Pytroch: %s" % torch.__version__)
mode = args.mode
exp_name = args.exp
exp_dict = experiments.get_experiment_dict(args, exp_name)
pp_main = None
results = {}
# Get Main Class
project_name = os.path.realpath(__file__).split("/")[-2]
MC = ms.MainClass(path_models="models",
path_datasets="datasets",
path_metrics="metrics/metrics.py",
path_losses="losses/losses.py",
path_samplers="addons/samplers.py",
path_transforms="addons/transforms.py",
path_saves="/mnt/projects/counting/Saves/main/",
project=project_name)
key_set = set()
for model_name, config_name, metric_name, dataset_name, loss_name in product(
exp_dict["modelList"], exp_dict["configList"],
exp_dict["metricList"], exp_dict["datasetList"],
exp_dict["lossList"]):
# if model_name in ["LC_RESFCN"]:
# loss_name = "water_loss"
config = configs.get_config_dict(config_name)
key = ("{} - {} - {}".format(model_name, config_name, loss_name),
"{}_({})".format(dataset_name, metric_name))
if key in key_set:
continue
key_set.add(key)
main_dict = MC.get_main_dict(mode, dataset_name, model_name,
config_name, config, args.reset,
exp_dict["epochs"], metric_name,
loss_name)
main_dict["predictList"] = exp_dict["predictList"]
if mode == "paths":
print("\n{}_({})".format(dataset_name, model_name))
print(main_dict["path_best_model"])
# print( main_dict["exp_name"])
predictList_str = ' '.join(exp_dict["predictList"])
if args.status:
results[key] = borgy.borgy_status(mode, config_name, metric_name,
model_name, dataset_name,
loss_name, args.reset,
predictList_str)
continue
if args.kill:
results[key] = borgy.borgy_kill(mode, config_name, metric_name,
model_name, dataset_name,
loss_name, args.reset,
predictList_str)
continue
if args.borgy:
results[key] = borgy.borgy_submit(project_name, global_prompt,
mode, config_name, metric_name,
model_name, dataset_name,
loss_name, args.reset,
predictList_str)
continue
if mode == "debug":
debug.debug(main_dict)
if mode == "validate":
validate.validate(main_dict)
if mode == "save_gam_points":
train_set, _ = au.load_trainval(main_dict)
model = ms.load_best_model(main_dict)
for i in range(len(train_set)):
print(i, "/", len(train_set))
batch = ms.get_batch(train_set, [i])
fname = train_set.path + "/gam_{}.pkl".format(
batch["index"].item())
points = model.get_points(batch)
ms.save_pkl(fname, points)
import ipdb
ipdb.set_trace() # breakpoint ee49ab9f //
if mode == "save_prm_points":
train_set, _ = au.load_trainval(main_dict)
model = ms.load_best_model(main_dict)
for i in range(len(train_set)):
print(i, "/", len(train_set))
batch = ms.get_batch(train_set, [i])
fname = "{}/prm{}.pkl".format(batch["path"][0],
batch["name"][0])
points = model.get_points(batch)
ms.save_pkl(fname, points)
import ipdb
ipdb.set_trace() # breakpoint 679ce152 //
# train_set, _ = au.load_trainval(main_dict)
# model = ms.load_best_model(main_dict)
# for i in range(len(train_set)):
# print(i, "/", len(train_set))
# batch = ms.get_batch(train_set, [i])
# fname = train_set.path + "/gam_{}.pkl".format(batch["index"].item())
# points = model.get_points(batch)
# ms.save_pkl(fname, points)
# if mode == "pascal_annList":
# data_utils.pascal2lcfcn_points(main_dict)
if mode == "upperboundmasks":
import ipdb
ipdb.set_trace() # breakpoint 02fac8ce //
results = au.test_upperboundmasks(main_dict, reset=args.reset)
print(pd.DataFrame(results))
if mode == "model":
results = au.test_model(main_dict, reset=args.reset)
print(pd.DataFrame(results))
if mode == "upperbound":
results = au.test_upperbound(main_dict, reset=args.reset)
print(pd.DataFrame(results))
if mode == "MUCov":
gtAnnDict = au.load_gtAnnDict(main_dict, reset=args.reset)
# model = ms.load_best_model(main_dict)
fname = main_dict["path_save"] + "/pred_annList.pkl"
if not os.path.exists(fname):
_, val_set = au.load_trainval(main_dict)
model = ms.load_best_model(main_dict)
pred_annList = au.dataset2annList(model,
val_set,
predict_method="BestDice",
n_val=None)
ms.save_pkl(fname, pred_annList)
else:
pred_annList = ms.load_pkl(fname)
import ipdb
ipdb.set_trace() # breakpoint 527a7f36 //
pred_annList = au.load_predAnnList(main_dict,
predict_method="BestObjectness")
# 0.31 best objectness pred_annList =
# 0.3482122335421256
# au.get_MUCov(gtAnnDict, pred_annList)
au.get_SBD(gtAnnDict, pred_annList)
if mode == "dic_sbd":
import ipdb
ipdb.set_trace() # breakpoint 4af08a17 //
if mode == "point_mask":
from datasets import base_dataset
import ipdb
ipdb.set_trace() # breakpoint 7fd55e0c //
_, val_set = ms.load_trainval(main_dict)
batch = ms.get_batch(val_set, [1])
model = ms.load_best_model(main_dict)
pred_dict = model.LCFCN.predict(batch)
# ms.pretty_vis(batch["images"], base_dataset.batch2annList(batch))
ms.images(ms.pretty_vis(
batch["images"],
model.LCFCN.predict(batch,
predict_method="original")["annList"]),
win="blobs")
ms.images(ms.pretty_vis(batch["images"],
base_dataset.batch2annList(batch)),
win="erww")
ms.images(batch["images"],
batch["points"],
denorm=1,
enlarge=1,
win="e21e")
import ipdb
ipdb.set_trace() # breakpoint ab9240f0 //
if mode == "lcfcn_output":
import ipdb
ipdb.set_trace() # breakpoint 7fd55e0c //
gtAnnDict = au.load_gtAnnDict(main_dict, reset=args.reset)
if mode == "load_gtAnnDict":
_, val_set = au.load_trainval(main_dict)
gtAnnDict = au.load_gtAnnDict(val_set)
# gtAnnClass = COCO(gtAnnDict)
# au.assert_gtAnnDict(main_dict, reset=None)
# _,val_set = au.load_trainval(main_dict)
# annList_path = val_set.annList_path
# fname_dummy = annList_path.replace(".json","_best.json")
# predAnnDict = ms.load_json(fname_dummy)
import ipdb
ipdb.set_trace() # breakpoint 100bfe1b //
pred_annList = ms.load_pkl(main_dict["path_best_annList"])
# model = ms.load_best_model(main_dict)
_, val_set = au.load_trainval(main_dict)
batch = ms.get_batch(val_set, [1])
import ipdb
ipdb.set_trace() # breakpoint 2310bb33 //
model = ms.load_best_model(main_dict)
pred_dict = model.predict(batch, "BestDice", "mcg")
ms.images(batch["images"],
au.annList2mask(pred_dict["annList"])["mask"],
denorm=1)
# pointList2UpperBoundMCG
pred_annList = au.load_predAnnList(main_dict,
predict_method="BestDice",
proposal_type="mcg",
reset="reset")
# annList = au.pointList2UpperBoundMCG(batch["lcfcn_pointList"], batch)["annList"]
ms.images(batch["images"],
au.annList2mask(annList)["mask"],
denorm=1)
pred_annList = au.load_BestMCG(main_dict, reset="reset")
# pred_annList = au.dataset2annList(model, val_set,
# predict_method="BestDice",
# n_val=None)
au.get_perSizeResults(gtAnnDict, pred_annList)
if mode == "vis":
_, val_set = au.load_trainval(main_dict)
batch = ms.get_batch(val_set, [3])
import ipdb
ipdb.set_trace() # breakpoint 05e6ef16 //
vis.visBaselines(batch)
model = ms.load_best_model(main_dict)
vis.visBlobs(model, batch)
if mode == "qual":
model = ms.load_best_model(main_dict)
_, val_set = au.load_trainval(main_dict)
path = "/mnt/home/issam/Summaries/{}_{}".format(
dataset_name, model_name)
try:
ms.remove_dir(path)
except:
pass
n_images = len(val_set)
base = "{}_{}".format(dataset_name, model_name)
for i in range(50):
print(i, "/10", "- ", base)
index = np.random.randint(0, n_images)
batch = ms.get_batch(val_set, [index])
if len(batch["lcfcn_pointList"]) == 0:
continue
image = vis.visBlobs(model, batch, return_image=True)
# image_baselines = vis.visBaselines(batch, return_image=True)
# imgAll = np.concatenate([image, image_baselines], axis=1)
fname = path + "/{}_{}.png".format(i, base)
ms.create_dirs(fname)
ms.imsave(fname, image)
if mode == "test_baselines":
import ipdb
ipdb.set_trace() # breakpoint b51c5b1f //
results = au.test_baselines(main_dict, reset=args.reset)
print(pd.DataFrame(results))
if mode == "test_best":
au.test_best(main_dict)
if mode == "qualitative":
au.qualitative(main_dict)
if mode == "figure1":
from PIL import Image
from addons import transforms
model = ms.load_best_model(main_dict)
_, val_set = au.load_trainval(main_dict)
# proposals_path = "/mnt/datasets/public/issam/Cityscapes/demoVideo/leftImg8bit/demoVideo/ProposalsSharp/"
# vidList = glob("/mnt/datasets/public/issam/Cityscapes/demoVideo/leftImg8bit/demoVideo/stuttgart_01/*")
# vidList.sort()
# pretty_image = ms.visPretty(model, batch = ms.get_batch(val_set, [i]), with_void=1, win="with_void")
batch = ms.get_batch(val_set, [68])
bestdice = ms.visPretty(model,
batch=batch,
with_void=0,
win="no_void")
blobs = ms.visPretty(model,
batch=batch,
predict_method="blobs",
with_void=0,
win="no_void")
ms.images(bestdice, win="BestDice")
ms.images(blobs, win="Blobs")
ms.images(batch["images"], denorm=1, win="Image")
ms.images(batch["images"],
batch["points"],
enlarge=1,
denorm=1,
win="Points")
import ipdb
ipdb.set_trace() # breakpoint cf4bb3d3 //
if mode == "video2":
from PIL import Image
from addons import transforms
model = ms.load_best_model(main_dict)
_, val_set = au.load_trainval(main_dict)
# proposals_path = "/mnt/datasets/public/issam/Cityscapes/demoVideo/leftImg8bit/demoVideo/ProposalsSharp/"
# vidList = glob("/mnt/datasets/public/issam/Cityscapes/demoVideo/leftImg8bit/demoVideo/stuttgart_01/*")
# vidList.sort()
index = 0
for i in range(len(val_set)):
# pretty_image = ms.visPretty(model, batch = ms.get_batch(val_set, [i]), with_void=1, win="with_void")
batch = ms.get_batch(val_set, [i])
pretty_image = ms.visPretty(model,
batch=batch,
with_void=0,
win="no_void")
# pred_dict = model.predict(batch, predict_method="BestDice")
path_summary = main_dict["path_summary"]
ms.create_dirs(path_summary + "/tmp")
ms.imsave(
path_summary + "vid_mask_{}.png".format(index),
ms.get_image(batch["images"],
batch["points"],
enlarge=1,
denorm=1))
index += 1
ms.imsave(path_summary + "vid_mask_{}.png".format(index),
pretty_image)
index += 1
# ms.imsave(path_summary+"vid1_full_{}.png".format(i), ms.get_image(img, pred_dict["blobs"], denorm=1))
print(i, "/", len(val_set))
if mode == "video":
from PIL import Image
from addons import transforms
model = ms.load_best_model(main_dict)
# _, val_set = au.load_trainval(main_dict)
proposals_path = "/mnt/datasets/public/issam/Cityscapes/demoVideo/leftImg8bit/demoVideo/ProposalsSharp/"
vidList = glob(
"/mnt/datasets/public/issam/Cityscapes/demoVideo/leftImg8bit/demoVideo/stuttgart_01/*"
)
vidList.sort()
for i, img_path in enumerate(vidList):
image = Image.open(img_path).convert('RGB')
image = image.resize((1200, 600), Image.BILINEAR)
img, _ = transforms.Tr_WTP_NoFlip()([image, image])
pred_dict = model.predict(
{
"images": img[None],
"split": ["test"],
"resized": torch.FloatTensor([1]),
"name": [ms.extract_fname(img_path)],
"proposals_path": [proposals_path]
},
predict_method="BestDice")
path_summary = main_dict["path_summary"]
ms.create_dirs(path_summary + "/tmp")
ms.imsave(path_summary + "vid1_mask_{}.png".format(i),
ms.get_image(pred_dict["blobs"]))
ms.imsave(path_summary + "vid1_full_{}.png".format(i),
ms.get_image(img, pred_dict["blobs"], denorm=1))
print(i, "/", len(vidList))
if mode == "5_eval_BestDice":
gtAnnDict = au.load_gtAnnDict(main_dict)
gtAnnClass = COCO(gtAnnDict)
results = au.assert_gtAnnDict(main_dict, reset=None)
if mode == "cp_annList":
ms.dataset2cocoformat(dataset_name="CityScapes")
if mode == "pascal2lcfcn_points":
data_utils.pascal2lcfcn_points(main_dict)
if mode == "cp2lcfcn_points":
data_utils.cp2lcfcn_points(main_dict)
if mode == "train":
train.main(main_dict)
import ipdb
ipdb.set_trace() # breakpoint a5d091b9 //
if mode == "train_only":
train.main(main_dict, train_only=True)
import ipdb
ipdb.set_trace() # breakpoint a5d091b9 //
if mode == "sharpmask2psfcn":
for split in ["train", "val"]:
root = "/mnt/datasets/public/issam/COCO2014/ProposalsSharp/"
path = "{}/sharpmask/{}/jsons/".format(root, split)
jsons = glob(path + "*.json")
propDict = {}
for k, json in enumerate(jsons):
print("{}/{}".format(k, len(jsons)))
props = ms.load_json(json)
for p in props:
if p["image_id"] not in propDict:
propDict[p["image_id"]] = []
propDict[p["image_id"]] += [p]
for k in propDict.keys():
fname = "{}/{}.json".format(root, k)
ms.save_json(fname, propDict[k])
if mode == "cp2coco":
import ipdb
ipdb.set_trace() # breakpoint f2eb9e70 //
dataset2cocoformat.cityscapes2cocoformat(main_dict)
# train.main(main_dict)
import ipdb
ipdb.set_trace() # breakpoint a5d091b9 //
if mode == "train_lcfcn":
train_lcfcn.main(main_dict)
import ipdb
ipdb.set_trace() # breakpoint a5d091b9 //
if mode == "summary":
try:
history = ms.load_history(main_dict)
# if predictList_str == "MAE":
# results[key] = "{}/{}: {:.2f}".format(history["best_model"]["epoch"],
# history["epoch"],
# history["best_model"][metric_name])
# else:
val_dict = history["val"][-1]
val_dict = history["best_model"]
iou25 = val_dict["0.25"]
iou5 = val_dict["0.5"]
iou75 = val_dict["0.75"]
results[key] = "{}/{}: {:.1f} - {:.1f} - {:.1f}".format(
val_dict["epoch"], history["epoch"], iou25 * 100,
iou5 * 100, iou75 * 100)
# if history["val"][-1]["epoch"] != history["epoch"]:
# results[key] += " | Val {}".format(history["epoch"])
try:
results[key] += " | {}/{}".format(
len(history["trained_batch_names"]),
history["train"][-1]["n_samples"])
except:
pass
except:
pass
if mode == "vals":
history = ms.load_history(main_dict)
for i in range(1, len(main_dict["predictList"]) + 1):
if len(history['val']) == 0:
res = "NaN"
continue
else:
res = history["val"][-i]
map50 = res["map50"]
map75 = res["map75"]
# if map75 < 1e-3:
# continue
string = "{} - {} - map50: {:.2f} - map75: {:.2f}".format(
res["epoch"], res["predict_name"], map50, map75)
key_tmp = list(key).copy()
key_tmp[1] += " {} - {}".format(metric_name,
res["predict_name"])
results[tuple(key_tmp)] = string
# print("map75", pd.DataFrame(history["val"])["map75"].max())
# df = pd.DataFrame(history["vals"][:20])["water_loss_B"]
# print(df)
try:
print(ms.dict2frame(results))
except:
print("Results not printed...")
def copy_models(exp_dict, path_dst):
history = load_history(exp_dict)
ms.save_json(path_dst + "/history.json", history)
print("copied...")
def test_COCOmap(main_dict):
# create_voc2007(main_dict)
model = ms.load_best_model(main_dict)
_, val_set = ms.load_trainval(main_dict)
path_base = "/mnt/datasets/public/issam/VOCdevkit/annotations/"
fname = "{}/instances_val2012.json".format(path_base)
cocoGt = COCO(fname)
# fname = "{}/instances_val2012.json".format(path_base)
# cocoGt = COCO(fname)
fname = (path_base + "/results/" + main_dict["exp_name"] + "_" +
str(main_dict["model_options"]["predict_proposal"]) + ".json")
# test_list(model, cocoGt, val_set, [0,1,2,3], prp.Blobs)
import ipdb
ipdb.set_trace() # breakpoint 06c353ef //
# test_list(model, cocoGt, val_set, [0], prp.BestObjectness)
# test_list(model, cocoGt, val_set, [0,1,2,3], prp.Blobs)
if not os.path.exists(fname) or 1:
annList = []
for i in range(len(val_set)):
batch = ms.get_batch(val_set, [i])
try:
annList += model.predict(batch, "annList")
except Exception as exc:
import ipdb
ipdb.set_trace() # breakpoint 5f61b0cfx //
if (i % 100) == 0:
cocoEval, _ = d_helpers.evaluateAnnList(annList)
ms.save_json(fname.replace(".json", "inter.json"), annList)
# ms.save_json("tmp.json", annList)
# cocoDt = cocoGt.loadRes("tmp.json")
# cocoEval = COCOeval(cocoGt, cocoDt, "segm")
# cocoEval.params.imgIds = list(set([v["image_id"] for v in cocoDt.anns.values()]))
# cocoEval.evaluate()
# cocoEval.accumulate()
# cocoEval.summarize()
print("{}/{}".format(i, len(val_set)))
ms.save_json(fname, annList)
# cocoEval = d_helpers.evaluateAnnList(ms.load_json(fname))
# cocoEval = COCOeval(cocoGt, cocoDt, annType)
#cocoEval.params.imgIds = list(set([v["image_id"] for v in cocoDt.anns.values()]))
if 1:
#cocoEval.params.imgIds = [2007000033]
cocoDt = cocoGt.loadRes(fname)
cocoEval = COCOeval(cocoGt, cocoDt, "segm")
cocoEval.evaluate()
cocoEval.accumulate()
cocoEval.summarize()
print("Images:", len(cocoEval.params.imgIds))
print("Model: {}, Loss: {}, Pred: {}".format(
main_dict["model_name"], main_dict["loss_name"],
main_dict["model_options"]["predict_proposal"]))
import ipdb
ipdb.set_trace() # breakpoint c6f8f580 //
# d_helpers.visGT(cocoGt, cocoDt,ms.get_batch(val_set, [169]))
# d_helpers.valList(cocoGt, cocoDt, val_set, [173,174])
# model.set_proposal(None); vis.visBlobs(model, ms.get_batch(val_set, [169]), "blobs")
return "mAP25: {:.2f} - mAP75:{:.2f}".format(cocoEval.stats[1],
cocoEval.stats[2])
def pascal2cocoformat():
dataset = ms.load_trainval({"dataset_name": "VOC"})
fname = "/mnt/datasets/public/issam/VOCdevkit/annotations/"
fname += "instances_val2012.json"
tmp = ms.load_json("/mnt/datasets/public/issam/"
"VOCdevkit/annotations/pascal_val2012.json")
ann_json = {}
ann_json["categories"] = tmp["categories"]
ann_json["type"] = "instances"
# Images
imageList = []
annList = []
id = 1
for i in range(len(dataset)):
print("{}/{}".format(i, len(dataset)))
batch = dataset[i]
image_id = int(batch["name"])
height, width = batch["images"].shape[-2:]
imageList += [{
"file_name": batch["name"] + ".jpg",
"height": height,
"width": width,
"id": image_id
}]
maskObjects = batch["maskObjects"]
maskClasses = batch["maskClasses"]
n_objects = maskObjects[maskObjects != 255].max()
for obj_id in range(1, n_objects + 1):
if obj_id == 0:
continue
binmask = (maskObjects == obj_id)
segmentation = maskUtils.encode(np.asfortranarray(ms.t2n(binmask)))
segmentation["counts"] = segmentation["counts"].decode("utf-8")
uniques = (binmask.long() * maskClasses).unique()
uniques = uniques[uniques != 0]
assert len(uniques) == 1
category_id = uniques[0].item()
annList += [{
"segmentation": segmentation,
"iscrowd": 0,
# "bbox":maskUtils.toBbox(segmentation).tolist(),
"area": int(maskUtils.area(segmentation)),
"id": id,
"image_id": image_id,
"category_id": category_id
}]
id += 1
ann_json["annotations"] = annList
ann_json["images"] = imageList
ms.save_json(fname, ann_json)
anns = ms.load_json(fname)
fname_dummy = fname.replace(".json", "_best.json")
annList = anns["annotations"]
for a in annList:
a["score"] = 1
ms.save_json(fname_dummy, annList)
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--scratch',
action='store',
help='',
metavar="DIR",
default="_tmp_")
parser.add_argument('--sdf',
action='store',
help='',
metavar="FILE",
nargs="+",
default=[])
parser.add_argument('--dict',
action='store',
help='',
metavar="FILE",
nargs="+",
default=[])
parser.add_argument('--name',
action='store',
help='',
metavar="STR",
nargs="+")
parser.add_argument('--filename', action='store', help='', metavar="STR")
parser.add_argument('--filter', action='store_true', help='')
parser.add_argument('-j',
'--procs',
action='store',
help='pararallize',
metavar="int",
default=0,
type=int)
args = parser.parse_args()
if args.scratch[-1] != "/":
args.scratch += "/"
print()
databases_set = []
databases_dict = []
for sdf in args.sdf:
molobjs = cheminfo.read_sdffile(sdf)
molobjs = list(molobjs)
smiles = [
cheminfo.molobj_to_smiles(molobj, remove_hs=True)
for molobj in molobjs
]
smiles = set(smiles)
databases_set.append(smiles)
print(sdf, len(smiles))
for filename in args.dict:
data = misc.load_obj(filename)
smiles = data.keys()
smiles = set(smiles)
databases_set.append(smiles)
databases_dict.append(data)
print(filename, len(smiles))
if args.scratch is not None:
# Merge databases
everything = {}
for data in databases_dict:
keys = data.keys()
for key in keys:
if key not in everything:
everything[key] = []
everything[key] += data[key]
if args.filter:
everything = filter_dict(everything)
keys = everything.keys()
print("n items", len(keys))
# Save
misc.save_json(args.scratch + "molecule_data", everything)
misc.save_obj(args.scratch + "molecule_data", everything)
if args.name is not None:
n_db = len(databases_set)
if n_db == 2:
venn2(databases_set, set_labels=args.name)
elif n_db == 3:
venn3(databases_set, set_labels=args.name)
plt.savefig(args.scratch + "venndiagram")
return
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--scratch',
action='store',
help='',
metavar="DIR",
default="_tmp_")
parser.add_argument('--sdf', action='store', help='',
metavar="FILE") #, nargs="+", default=[])
parser.add_argument('--properties',
action='store',
help='',
metavar="FILE") #, nargs="+", default=[])
parser.add_argument('-j',
'--procs',
action='store',
help='pararallize',
metavar="int",
default=0,
type=int)
args = parser.parse_args()
if args.scratch[-1] != "/":
args.scratch += "/"
fsdf = gzip.open(args.scratch + "structures.sdf.gz", 'w')
fprop = open(args.scratch + "properties.csv", 'w')
molecules = cheminfo.read_sdffile(args.sdf)
properties = open(args.properties, 'r')
moledict = {}
for molobj, line in zip(molecules, properties):
status = molobjfilter(molobj)
if not status:
continue
status = valuefilter(line)
if not status:
continue
smiles = cheminfo.molobj_to_smiles(molobj, remove_hs=True)
print(smiles)
sdfstr = cheminfo.molobj_to_sdfstr(molobj)
sdfstr += "$$$$\n"
fsdf.write(sdfstr.encode())
fprop.write(line)
values = [float(x) for x in line.split()[1:]]
moledict[smiles] = values
fsdf.close()
fprop.close()
properties.close()
misc.save_json(args.scratch + "molecules", moledict)
misc.save_obj(args.scratch + "molecules", moledict)
return
def dump_kernel_scores(scr, names=[]):
# Predefined reg
l2regs = [10**-x for x in range(1, 6, 2)] + [0.0]
n_l2regs = len(l2regs)
# Define n_training
# n_trains=[2**x for x in range(4, 12)]
n_trains=[2**x for x in range(4, 17)]
n_trains = np.array(n_trains, dtype=int)
n_items = misc.load_txt(scr + "n_items")
n_train_idx, = np.where(n_trains < n_items*4.0/5.0)
n_trains = n_trains[n_train_idx]
n_trains = list(n_trains) # + [-1]
print("Assume total items", n_items,
"N train", "{:5.1f}".format(np.floor(n_items*4/5)),
"N test", "{:5.1f}".format(np.ceil(n_items*1/5)))
print("Training:", list(n_trains))
misc.save_npy(scr + "n_train", n_trains)
# Load properties
try:
properties = misc.load_npy(scr + "properties")
except:
with open(scr + "properties.csv", 'r') as f:
lines = f.readlines()
properties = []
for line in lines:
values = [float(x) for x in line.split()]
values = values[1:]
value = np.median(values)
properties.append(value)
properties = np.array(properties)
misc.save_npy(scr + "properties", properties)
print(n_items, "==", len(properties))
assert n_items == len(properties)
# Load done kernel
this_names = ["rdkitfp", "morgan"]
for name in names:
break
if name not in this_names:
continue
print("scoring", name)
now = time.time()
print("load kernel", name)
kernel = misc.load_npy(scr + "kernel." + name)
n_len = kernel.shape[0]
diaidx = np.diag_indices(n_len)
def scan_kernels(debug=True):
kernel[diaidx] += l2regs[0]
yield kernel
# for i in tqdm.tqdm(range(1, n_l2regs), ncols=47, ascii=True, desc=name):
for i in range(1, n_l2regs):
kernel[diaidx] += -l2regs[i-1] +l2regs[i]
yield kernel
generator = functools.partial(tqdm, scan_kernels(), ncols=75, ascii=True, desc=name+ " kernels", total=n_l2regs)
print("scan kernels", name)
idx_winners, scores = cross_validation(generator(), properties, training_points=n_trains)
misc.save_npy(scr + "score."+name, scores)
scores = np.around(np.mean(scores, axis=1), decimals=2)
# Save parameters
winner_parameters = {}
for ni, index in enumerate(idx_winners):
n = n_trains[ni]
l2reg = l2regs[index]
parameters = {
"reg": l2reg,
}
winner_parameters[str(n)] = parameters
nower = time.time()
print("time: {:10.1f}s".format(nower-now))
print(name, list(scores))
misc.save_json(scr + "parameters."+name, winner_parameters)
print("saved")
kernel = None
del kernel
# Load multi kernels (reg search)
this_names = ["fchl19", "fchl18"]
for name in names:
break
kernels = misc.load_npy(scr + "kernels." + name)
n_l2regs = len(l2regs)
n_kernels = kernels.shape[0]
n_len = kernels[0].shape[0]
diaidx = np.diag_indices(n_len)
def scan_kernels():
for kernel in kernels:
kernel[diaidx] += l2regs[0]
yield kernel
for i in range(1, n_l2regs):
kernel[diaidx] += -l2regs[i-1] +l2regs[i]
yield kernel
idx_winners, scores = cross_validation(scan_kernels(), properties, training_points=n_trains)
misc.save_npy(scr + "score."+name, scores)
scores = np.around(np.mean(scores, axis=1), decimals=2)
# Clean
kernels = None
del kernels
# Save parameters
winner_parameters = {}
for ni, index in enumerate(idx_winners):
# convert linear index to multi-dimensions
idx_parameters = np.unravel_index([index], (n_kernels, n_l2regs))
i, j = idx_parameters
i = int(i[0])
j = int(j[0])
n = n_trains[ni]
sigma = i
l2reg = l2regs[j]
parameters = {
"sigma": sigma,
"reg": l2reg,
}
winner_parameters[str(n)] = parameters
misc.save_json(scr + "parameters."+name, winner_parameters)
print(name, scores)
# Load distance kernels
models = []
parameters = {
"name": "rdkitfp",
"sigma": [2**x for x in range(1, 12, 2)],
# "sigma": [2**x for x in np.arange(20, 40, 0.5)],
# "lambda": l2regs,
# "lambda": [10.0**-x for x in np.arange(1, 10, 1)]
"lambda": [10.0**-6],
}
models.append(parameters)
parameters = {
"name": "slatm",
"sigma": [2**x for x in range(1, 12, 2)],
# "sigma": [2**x for x in np.arange(20, 40, 0.5)],
# "lambda": l2regs,
# "lambda": [10.0**-x for x in np.arange(1, 10, 1)]
"lambda": [10.0**-6],
}
models.append(parameters)
parameters = {
"name": "cm",
"sigma": [2**x for x in range(1, 12, 2)],
"lambda": l2regs,
}
models.append(parameters)
parameters = {
"name": "bob",
"sigma": [2**x for x in range(1, 12, 2)],
"lambda": l2regs,
}
models.append(parameters)
parameters = {
"name": "avgslatm",
"sigma": [2**x for x in range(1, 20, 2)],
"lambda": l2regs,
}
# models.append(parameters)
for model in models:
name = model["name"]
if name not in names:
continue
print("scoring", name)
parameters = model
n_sigma = len(parameters["sigma"])
n_lambda = len(parameters["lambda"])
print("parameter range")
print("sigma", min(parameters["sigma"]), max(parameters["sigma"]))
dist = misc.load_npy(scr + "dist." + name)
kernels = get_kernels_l2distance(dist, parameters)
# Cross validate
idx_winners, scores = cross_validation(kernels, properties, training_points=n_trains)
# Save scores
misc.save_npy(scr + "score."+name, scores)
scores = np.around(np.mean(scores, axis=1), decimals=2)
# Save parameters
winner_parameters = {}
for ni, index in enumerate(idx_winners):
# convert linear index to multi-dimensions
idx_parameters = np.unravel_index([index], (n_sigma, n_lambda))
i, j = idx_parameters
i = int(i[0])
j = int(j[0])
n = n_trains[ni]
sigma = parameters["sigma"][i]
l2reg = parameters["lambda"][j]
this_parameters = {
"sigma": str(sigma),
"reg": str(l2reg),
}
winner_parameters[str(n)] = this_parameters
print(name, scores)
misc.save_json(scr + "parameters."+name, winner_parameters)
quit()
return