def __init__(self, cfg_path):
with open(cfg_path, 'r') as rf:
self.cfg = yaml.safe_load(rf)
self.data_cfg = self.cfg['data']
self.model_cfg = self.cfg['model']
self.optim_cfg = self.cfg['optim']
self.hyper_params = self.cfg['hyper_params']
self.val_cfg = self.cfg['val']
print(self.data_cfg)
print(self.model_cfg)
print(self.optim_cfg)
print(self.hyper_params)
print(self.val_cfg)
os.environ['CUDA_VISIBLE_DEVICES'] = self.cfg['gpus']
self.gpu_num = len(str(self.cfg['gpus']).split(","))
dist.init_process_group(backend='nccl')
###########################################################################################
self.tdata = COCODataSets(
img_root=self.data_cfg['train_img_root'],
annotation_path=self.data_cfg['train_annotation_path'],
img_size=self.data_cfg['img_size'],
debug=self.data_cfg['debug'],
use_crowd=self.data_cfg['use_crowd'],
augments=True,
remove_blank=self.data_cfg['remove_blank'])
self.tloader = DataLoader(dataset=self.tdata,
batch_size=self.data_cfg['batch_size'],
num_workers=self.data_cfg['num_workers'],
collate_fn=self.tdata.collate_fn,
sampler=DistributedSampler(
dataset=self.tdata, shuffle=True))
self.vdata = COCODataSets(
img_root=self.data_cfg['val_img_root'],
annotation_path=self.data_cfg['val_annotation_path'],
img_size=self.data_cfg['img_size'],
debug=self.data_cfg['debug'],
use_crowd=self.data_cfg['use_crowd'],
augments=False,
remove_blank=False)
self.vloader = DataLoader(dataset=self.vdata,
batch_size=1,
num_workers=1,
collate_fn=self.vdata.collate_fn,
sampler=DistributedSampler(
dataset=self.vdata, shuffle=False))
print("train_data: ", len(self.tdata), " | ", "val_data: ",
len(self.vdata), " | ", "empty_data: ",
self.tdata.empty_images_len)
print("train_iter: ", len(self.tloader), " | ", "val_iter: ",
len(self.vloader))
############################################################################################
model = CenterNet(num_cls=self.model_cfg['num_cls'],
PIXEL_MEAN=self.model_cfg['PIXEL_MEAN'],
PIXEL_STD=self.model_cfg['PIXEL_STD'],
backbone=self.model_cfg['backbone'],
cfg=self.model_cfg)
self.best_map = 0.
self.best_map50 = 0.
optimizer = split_optimizer(model, self.optim_cfg)
local_rank = dist.get_rank()
self.local_rank = local_rank
self.device = torch.device("cuda", local_rank)
model.to(self.device)
if self.optim_cfg['sync_bn']:
model = nn.SyncBatchNorm.convert_sync_batchnorm(model)
self.model = nn.parallel.distributed.DistributedDataParallel(
model, device_ids=[local_rank], output_device=local_rank)
self.optimizer = optimizer
self.ema = ModelEMA(self.model)
self.gt_generator = CenterNetGT(
alpha=self.model_cfg['alpha'],
beta=self.model_cfg['beta'],
num_cls=self.model_cfg['num_cls'],
wh_planes=self.model_cfg['wh_planes'],
down_ratio=self.model_cfg['down_ratio'],
wh_area_process=self.model_cfg['wh_area_process'])
self.creterion = CenterNetLoss(
hm_weight=self.hyper_params['hm_weight'],
wh_weight=self.hyper_params['wh_weight'],
down_ratio=self.model_cfg['down_ratio'])
self.lr_adjuster = WarmUpCosineDecayMultiStepLRAdjust(
init_lr=self.optim_cfg['lr'],
milestones=self.optim_cfg['milestones'],
warm_up_epoch=self.optim_cfg['warm_up_epoch'],
iter_per_epoch=len(self.tloader),
epochs=self.optim_cfg['epochs'],
cosine_weights=self.optim_cfg['cosine_weights'])
def __init__(self, cfg_path):
with open(cfg_path, 'r') as rf:
self.cfg = yaml.safe_load(rf)
self.data_cfg = self.cfg['data']
self.model_cfg = self.cfg['model']
self.optim_cfg = self.cfg['optim']
self.hyper_params = self.cfg['hyper_params']
self.val_cfg = self.cfg['val']
print(self.data_cfg)
print(self.model_cfg)
print(self.optim_cfg)
print(self.hyper_params)
print(self.val_cfg)
os.environ['CUDA_VISIBLE_DEVICES'] = self.cfg['gpus']
dist.init_process_group(backend='nccl')
self.tdata = COCODataSets(
img_root=self.data_cfg['train_img_root'],
annotation_path=self.data_cfg['train_annotation_path'],
img_size=self.data_cfg['img_size'],
debug=self.data_cfg['debug'],
use_crowd=self.data_cfg['use_crowd'],
augments=True,
remove_blank=self.data_cfg['remove_blank'])
self.tloader = DataLoader(dataset=self.tdata,
batch_size=self.data_cfg['batch_size'],
num_workers=self.data_cfg['num_workers'],
collate_fn=self.tdata.collate_fn,
sampler=DistributedSampler(
dataset=self.tdata, shuffle=True))
self.vdata = COCODataSets(
img_root=self.data_cfg['val_img_root'],
annotation_path=self.data_cfg['val_annotation_path'],
img_size=self.data_cfg['img_size'],
debug=self.data_cfg['debug'],
use_crowd=self.data_cfg['use_crowd'],
augments=False,
remove_blank=False)
self.vloader = DataLoader(dataset=self.vdata,
batch_size=self.data_cfg['batch_size'],
num_workers=self.data_cfg['num_workers'],
collate_fn=self.vdata.collate_fn,
sampler=DistributedSampler(
dataset=self.vdata, shuffle=False))
print("train_data: ", len(self.tdata), " | ", "val_data: ",
len(self.vdata), " | ", "empty_data: ",
self.tdata.empty_images_len)
print("train_iter: ", len(self.tloader), " | ", "val_iter: ",
len(self.vloader))
model = RetinaNet(
num_cls=self.model_cfg['num_cls'],
anchor_sizes=self.model_cfg['anchor_sizes'],
strides=self.model_cfg['strides'],
backbone=self.model_cfg['backbone'],
)
self.scaler = amp.GradScaler(enabled=True)
# if self.model_cfg.get("backbone_weight", None):
# weights = torch.load(self.model_cfg['backbone_weight'])
# model.load_backbone_weighs(weights)
self.best_map = 0.
self.best_map50 = 0.
optimizer = split_optimizer(model, self.optim_cfg)
local_rank = dist.get_rank()
self.local_rank = local_rank
self.device = torch.device("cuda", local_rank)
model.to(self.device)
if self.optim_cfg['sync_bn']:
model = nn.SyncBatchNorm.convert_sync_batchnorm(model)
self.model = nn.parallel.distributed.DistributedDataParallel(
model, device_ids=[local_rank], output_device=local_rank)
self.optimizer = optimizer
self.ema = ModelEMA(self.model)
self.creterion = RetinaLoss(
iou_thresh=self.hyper_params['iou_thresh'],
ignore_thresh=self.hyper_params['ignore_thresh'],
alpha=self.hyper_params['alpha'],
gamma=self.hyper_params['gamma'],
iou_type=self.hyper_params['iou_type'],
)
self.lr_adjuster = WarmUpCosineDecayMultiStepLRAdjust(
init_lr=self.optim_cfg['lr'],
milestones=self.optim_cfg['milestones'],
warm_up_epoch=self.optim_cfg['warm_up_epoch'],
iter_per_epoch=len(self.tloader),
epochs=self.optim_cfg['epochs'],
cosine_weights=self.optim_cfg['cosine_weights'])
import torch
from nets.fcos import FCOS
from losses.fcos_loss import FCOSLoss
from datasets.coco import COCODataSets
from torch.utils.data.dataloader import DataLoader
if __name__ == '__main__':
dataset = COCODataSets(img_root="/home/huffman/data/val2017",
annotation_path="/home/huffman/data/annotations/instances_val2017.json",
use_crowd=True,
augments=True,
remove_blank=True,
img_size=640
)
dataloader = DataLoader(dataset=dataset, batch_size=4, shuffle=True, num_workers=4, collate_fn=dataset.collate_fn)
net = FCOS(
backbone="resnet18"
)
creterion = FCOSLoss()
for img_input, targets, _ in dataloader:
_, _, h, w = img_input.shape
targets[:, 3:] = targets[:, 3:] * torch.tensor(data=[w, h, w, h])
cls_outputs, reg_outputs, center_outputs, grids = net(img_input)
total_loss, detail_loss = creterion(cls_outputs, reg_outputs, center_outputs, grids,
targets)
cls_loss, reg_loss, center_loss = detail_loss
print(total_loss)
print(cls_loss, reg_loss, center_loss)
break
def __init__(self, cfg_path):
with open(cfg_path, 'r') as rf:
self.cfg = yaml.safe_load(rf)
self.data_cfg = self.cfg['data']
self.model_cfg = self.cfg['model']
self.optim_cfg = self.cfg['optim']
self.val_cfg = self.cfg['val']
print(self.data_cfg)
print(self.model_cfg)
print(self.optim_cfg)
print(self.val_cfg)
os.environ['CUDA_VISIBLE_DEVICES'] = self.cfg['gpus']
self.gpu_num = len(self.cfg['gpus'].split(','))
dist.init_process_group(backend='nccl')
self.tdata = COCODataSets(
img_root=self.data_cfg['train_img_root'],
annotation_path=self.data_cfg['train_annotation_path'],
max_thresh=self.data_cfg['max_thresh'],
debug=self.data_cfg['debug'],
use_crowd=self.data_cfg['use_crowd'],
augments=True,
remove_blank=self.data_cfg['remove_blank'])
self.tloader = DataLoader(dataset=self.tdata,
batch_size=self.data_cfg['batch_size'],
num_workers=self.data_cfg['num_workers'],
collate_fn=self.tdata.collect_fn,
sampler=DistributedSampler(
dataset=self.tdata, shuffle=True))
self.vdata = COCODataSets(
img_root=self.data_cfg['val_img_root'],
annotation_path=self.data_cfg['val_annotation_path'],
max_thresh=self.data_cfg['max_thresh'],
debug=self.data_cfg['debug'],
use_crowd=self.data_cfg['use_crowd'],
augments=False,
remove_blank=False)
self.vloader = DataLoader(dataset=self.vdata,
batch_size=self.data_cfg['batch_size'],
num_workers=self.data_cfg['num_workers'],
collate_fn=self.vdata.collect_fn,
sampler=DistributedSampler(
dataset=self.vdata, shuffle=False))
print("train_data: ", len(self.tdata), " | ", "val_data: ",
len(self.vdata), " | ", "empty_data: ",
self.tdata.empty_images_len)
print("train_iter: ", len(self.tloader), " | ", "val_iter: ",
len(self.vloader))
model = SparseRCNN(**self.model_cfg)
self.best_map = 0.
optimizer = split_optimizer_v2(model, self.optim_cfg)
local_rank = dist.get_rank()
self.local_rank = local_rank
self.device = torch.device("cuda", local_rank)
model.to(self.device)
if self.optim_cfg['sync_bn']:
model = nn.SyncBatchNorm.convert_sync_batchnorm(model)
self.model = nn.parallel.distributed.DistributedDataParallel(
model, device_ids=[local_rank], output_device=local_rank)
self.scaler = amp.GradScaler(
enabled=True) if self.optim_cfg['amp'] else None
self.optimizer = optimizer
self.ema = ModelEMA(self.model)
self.lr_adjuster = IterWarmUpMultiStepDecay(
init_lr=self.optim_cfg['lr'],
milestones=self.optim_cfg['milestones'],
warm_up_iter=self.optim_cfg['warm_up_iter'],
iter_per_epoch=len(self.tloader),
epochs=self.optim_cfg['epochs'],
alpha=self.optim_cfg['alpha'],
warm_up_factor=self.optim_cfg['warm_up_factor'])
self.cls_loss_logger = AverageLogger()
self.l1_loss_logger = AverageLogger()
self.iou_loss_logger = AverageLogger()
self.match_num_logger = AverageLogger()
self.loss_logger = AverageLogger()
def __init__(self, cfg_path):
with open(cfg_path, 'r') as rf:
self.cfg = yaml.safe_load(rf)
self.data_cfg = self.cfg['data']
self.model_cfg = self.cfg['model']
self.optim_cfg = self.cfg['optim']
self.hyper_params = self.cfg['hyper_params']
self.val_cfg = self.cfg['val']
print(self.data_cfg)
print(self.model_cfg)
print(self.optim_cfg)
print(self.hyper_params)
print(self.val_cfg)
os.environ['CUDA_VISIBLE_DEVICES'] = self.cfg['gpus']
dist.init_process_group(backend='nccl')
self.tdata = COCODataSets(img_root=self.data_cfg['train_img_root'],
annotation_path=self.data_cfg['train_annotation_path'],
img_size=self.data_cfg['img_size'],
debug=self.data_cfg['debug'],
use_crowd=self.data_cfg['use_crowd'],
augments=True,
remove_blank=self.data_cfg['remove_blank']
)
self.tloader = DataLoader(dataset=self.tdata,
batch_size=self.data_cfg['batch_size'],
num_workers=self.data_cfg['num_workers'],
collate_fn=self.tdata.collate_fn,
sampler=DistributedSampler(dataset=self.tdata, shuffle=True))
self.vdata = COCODataSets(img_root=self.data_cfg['val_img_root'],
annotation_path=self.data_cfg['val_annotation_path'],
img_size=self.data_cfg['img_size'],
debug=self.data_cfg['debug'],
use_crowd=self.data_cfg['use_crowd'],
augments=False,
remove_blank=False
)
self.vloader = DataLoader(dataset=self.vdata,
batch_size=self.data_cfg['batch_size'],
num_workers=self.data_cfg['num_workers'],
collate_fn=self.vdata.collate_fn,
sampler=DistributedSampler(dataset=self.vdata, shuffle=False))
print("train_data: ", len(self.tdata), " | ",
"val_data: ", len(self.vdata), " | ",
"empty_data: ", self.tdata.empty_images_len)
print("train_iter: ", len(self.tloader), " | ",
"val_iter: ", len(self.vloader))
model = RetinaNet(num_cls=self.model_cfg['num_cls'],
anchor_ratios=self.model_cfg['anchor_ratios'],
anchor_scales=self.model_cfg['anchor_scales'],
anchor_sizes=self.model_cfg['anchor_sizes'],
strides=self.model_cfg['strides'],
backbone=self.model_cfg['backbone'],
)
if self.model_cfg.get("backbone_weight", None):
weights = torch.load(self.model_cfg['backbone_weight'])
model.load_backbone_weighs(weights)
self.best_map = 0.
self.best_map50 = 0.
optimizer = split_optimizer(model, self.optim_cfg)
local_rank = dist.get_rank()
self.local_rank = local_rank
self.device = torch.device("cuda", local_rank)
model.to(self.device)
model, optimizer = amp.initialize(model, optimizer, opt_level='O1', verbosity=0)
if self.optim_cfg['sync_bn']:
model = nn.SyncBatchNorm.convert_sync_batchnorm(model)
self.model = nn.parallel.distributed.DistributedDataParallel(model,
device_ids=[local_rank],
output_device=local_rank)
self.optimizer = optimizer
self.ema = ModelEMA(self.model)
beta = eval(self.hyper_params['beta']) if isinstance(self.hyper_params['beta'], str) \
else self.hyper_params['beta']
self.creterion = ATSSRetinaLoss(top_k=self.hyper_params['top_k'],
anchor_per_loc=len(self.model_cfg['anchor_ratios']) * len(self.model_cfg[
'anchor_scales']),
alpha=self.hyper_params['alpha'],
gamma=self.hyper_params['gamma'],
beta=beta,
)
self.lr_adjuster = WarmUpCosineDecayMultiStepLRAdjust(init_lr=self.optim_cfg['lr'],
milestones=self.optim_cfg['milestones'],
warm_up_epoch=self.optim_cfg['warm_up_epoch'],
iter_per_epoch=len(self.tloader),
epochs=self.optim_cfg['epochs'],
cosine_weights=self.optim_cfg['cosine_weights']
)
self.tb_writer = None
if self.local_rank == 0:
log_dir = 'runs/'
print('Start Tensorboard with "tensorboard --logdir %s", view at http://localhost:6006/' % log_dir)
self.tb_writer = SummaryWriter(log_dir=log_dir)
def __init__(self, cfg_path):
with open(cfg_path, 'r') as rf:
self.cfg = yaml.safe_load(rf)
self.data_cfg = self.cfg['data']
self.model_cfg = self.cfg['model']
self.optim_cfg = self.cfg['optim']
self.val_cfg = self.cfg['val']
print(self.data_cfg)
print(self.model_cfg)
print(self.optim_cfg)
print(self.val_cfg)
os.environ['CUDA_VISIBLE_DEVICES'] = self.cfg['gpus']
self.gpu_num = len(str(self.cfg['gpus']).split(","))
dist.init_process_group(backend='nccl')
self.tdata = COCODataSets(
img_root=self.data_cfg['train_img_root'],
annotation_path=self.data_cfg['train_annotation_path'],
min_thresh=self.data_cfg['min_thresh'],
max_thresh=self.data_cfg['max_thresh'],
debug=self.data_cfg['debug'],
use_crowd=self.data_cfg['use_crowd'],
augments=True,
remove_blank=self.data_cfg['remove_blank'])
self.tloader = DataLoader(dataset=self.tdata,
batch_size=self.data_cfg['batch_size'],
num_workers=self.data_cfg['num_workers'],
collate_fn=self.tdata.collate_fn,
sampler=DistributedSampler(
dataset=self.tdata, shuffle=True))
self.vdata = COCODataSets(
img_root=self.data_cfg['val_img_root'],
annotation_path=self.data_cfg['val_annotation_path'],
min_thresh=self.data_cfg['min_thresh'],
max_thresh=self.data_cfg['max_thresh'],
debug=self.data_cfg['debug'],
use_crowd=self.data_cfg['use_crowd'],
augments=False,
remove_blank=False)
self.vloader = DataLoader(dataset=self.vdata,
batch_size=self.data_cfg['batch_size'],
num_workers=self.data_cfg['num_workers'],
collate_fn=self.vdata.collate_fn,
sampler=DistributedSampler(
dataset=self.vdata, shuffle=False))
print("train_data: ", len(self.tdata), " | ", "val_data: ",
len(self.vdata), " | ", "empty_data: ",
self.tdata.empty_images_len)
print("train_iter: ", len(self.tloader), " | ", "val_iter: ",
len(self.vloader))
model = DETR(self.model_cfg)
self.scaler = amp.GradScaler(enabled=True)
self.best_map = 0.
self.best_map50 = 0.
param_dicts = [
{
"params": [
p for n, p in model.named_parameters()
if "backbone" not in n and p.requires_grad
]
},
{
"params": [
p for n, p in model.named_parameters()
if "backbone" in n and p.requires_grad
],
"lr":
self.optim_cfg['backbone_lr'],
},
]
optimizer = torch.optim.AdamW(
param_dicts,
lr=self.optim_cfg['lr'],
weight_decay=self.optim_cfg['weight_decay'])
local_rank = dist.get_rank()
self.local_rank = local_rank
self.device = torch.device("cuda", local_rank)
model.to(self.device)
self.model = nn.parallel.distributed.DistributedDataParallel(
model, device_ids=[local_rank], output_device=local_rank)
self.optimizer = optimizer
self.ema = ModelEMA(self.model)
self.lr_adjuster = torch.optim.lr_scheduler.StepLR(
optimizer, self.optim_cfg['decay_steps'])
import torch
from nets.yolov4 import YOLOV4
from datasets.coco import COCODataSets
from torch.utils.data.dataloader import DataLoader
from utils.boxs_utils import kmean_anchors
if __name__ == '__main__':
dataset = COCODataSets(
img_root="/home/huffman/data/val2017",
annotation_path="/home/huffman/data/annotations/instances_val2017.json",
use_crowd=False,
augments=True,
remove_blank=True,
max_thresh=640)
dataset.data_list = dataset.box_info_list
kmean_anchors(dataset)
# 9,14, 26,19, 20,44, 50,39, 45,90, 97,81, 96,195, 204,152, 325,344
# 11,12, 15,34, 36,25, 35,61, 80,56, 66,136, 160,121, 159,269, 394,312
# dataloader = DataLoader(dataset=dataset, batch_size=2, shuffle=True, num_workers=1, collate_fn=dataset.collect_fn)
# net = YOLOV4()
# for img_input, targets, target_len in dataloader:
# out = net(img_input, targets)
# break
import torch
from nets.solov2 import SOLOv2
from datasets.coco import COCODataSets
from torch.utils.data.dataloader import DataLoader
from tqdm import tqdm
if __name__ == '__main__':
dataset = COCODataSets(
img_root="/home/huffman/data/coco/val2017",
annotation_path=
"/home/huffman/data/coco/annotations/instances_val2017.json",
use_crowd=True,
augments=True,
remove_blank=True,
max_thresh=768,
)
dataloader = DataLoader(dataset=dataset,
batch_size=4,
shuffle=True,
num_workers=1,
collate_fn=dataset.collect_fn)
net = SOLOv2().eval()
for img_input, valid_size, targets, mask, batch_len in dataloader:
out = net(img_input,
valid_size=valid_size,
targets={
"target": targets,
"batch_len": batch_len,
'mask': mask
})
print(out)
def __init__(self, cfg_path):
with open(cfg_path, 'r') as rf:
self.cfg = yaml.safe_load(rf)
self.data_cfg = self.cfg['data']
self.model_cfg = self.cfg['model']
self.optim_cfg = self.cfg['optim']
self.hyper_params = self.cfg['hyper_params']
self.val_cfg = self.cfg['val']
print(self.data_cfg)
print(self.model_cfg)
print(self.optim_cfg)
print(self.hyper_params)
print(self.val_cfg)
self.tdata = COCODataSets(img_root=self.data_cfg['train_img_root'],
annotation_path=self.data_cfg['train_annotation_path'],
img_size=self.data_cfg['img_size'],
debug=self.data_cfg['debug'],
use_crowd=self.data_cfg['use_crowd'],
augments=True,
remove_blank=self.data_cfg['remove_blank']
)
self.tloader = DataLoader(dataset=self.tdata,
batch_size=self.data_cfg['batch_size'],
num_workers=self.data_cfg['num_workers'],
collate_fn=self.tdata.collate_fn,
shuffle=True
)
self.vdata = COCODataSets(img_root=self.data_cfg['val_img_root'],
annotation_path=self.data_cfg['val_annotation_path'],
img_size=self.data_cfg['img_size'],
debug=self.data_cfg['debug'],
use_crowd=self.data_cfg['use_crowd'],
augments=False,
remove_blank=False
)
self.vloader = DataLoader(dataset=self.vdata,
batch_size=self.data_cfg['batch_size'],
num_workers=self.data_cfg['num_workers'],
collate_fn=self.vdata.collate_fn,
shuffle=False
)
print("train_data: ", len(self.tdata), " | ",
"val_data: ", len(self.vdata), " | ",
"empty_data: ", self.tdata.empty_images_len)
print("train_iter: ", len(self.tloader), " | ",
"val_iter: ", len(self.vloader))
model = RetinaNet(num_cls=self.model_cfg['num_cls'],
anchor_ratios=self.model_cfg['anchor_ratios'],
anchor_scales=self.model_cfg['anchor_scales'],
anchor_sizes=self.model_cfg['anchor_sizes'],
strides=self.model_cfg['strides'],
backbone=self.model_cfg['backbone'],
)
# if self.model_cfg.get("backbone_weight", None):
# weights = torch.load(self.model_cfg['backbone_weight'])
# model.load_backbone_weighs(weights)
self.best_map = 0.
self.best_map50 = 0.
optimizer = split_optimizer(model, self.optim_cfg)
self.local_rank = 0
self.device = torch.device("cuda:0")
model.to(self.device)
self.model = model
self.optimizer = optimizer
self.ema = ModelEMA(self.model)
beta = eval(self.hyper_params['beta']) if isinstance(self.hyper_params['beta'], str) \
else self.hyper_params['beta']
self.creterion = ATSSRetinaLoss(top_k=self.hyper_params['top_k'],
anchor_per_loc=len(self.model_cfg['anchor_ratios']) * len(self.model_cfg[
'anchor_scales']),
alpha=self.hyper_params['alpha'],
gamma=self.hyper_params['gamma'],
beta=beta,
)
self.lr_adjuster = WarmUpCosineDecayMultiStepLRAdjust(init_lr=self.optim_cfg['lr'],
milestones=self.optim_cfg['milestones'],
warm_up_epoch=self.optim_cfg['warm_up_epoch'],
iter_per_epoch=len(self.tloader),
epochs=self.optim_cfg['epochs'],
cosine_weights=self.optim_cfg['cosine_weights']
)
