project_name stringlengths 6 104 | file_name stringlengths 4 89 | full_name stringlengths 1 102 | func_name stringlengths 1 85 | docstring stringlengths 13 836 | docstring_tokens listlengths 4 122 | code stringlengths 23 39.7k | code_tokens stringlengths 29 44.6k | url int64 3 986k |
|---|---|---|---|---|---|---|---|---|
huawei-noah/xingtian | qmix_alg.py | DecayThenFlatSchedule.eval | eval | Schedule with eval times. | [
"Schedule",
"with",
"eval",
"times."
] | def eval(self, t):
val = 0
if self.decay in ['linear']:
val = max(self.finish, self.start - self.delta * t)
elif self.decay in ['exp']:
val = min(self.start, max(self.finish, np.exp(-t / self.exp_scaling)))
else:
raise KeyError('invalid decay-{} configured'.format(self.decay))
... | ['def', 'eval(self,', 't):', 'val', '=', '0', 'if', 'self.decay', 'in', "['linear']:", 'val', '=', 'max(self.finish,', 'self.start', '-', 'self.delta', '*', 't)', 'elif', 'self.decay', 'in', "['exp']:", 'val', '=', 'min(self.start,', 'max(self.finish,', 'np.exp(-t', '/', 'self.exp_scaling)))', 'else:', 'raise', "KeyErr... | 962,123 |
huawei-noah/xingtian | qmix_alg.py | QMixAlg.prepare_data | prepare_data | Insert trajectory into buffer, and sample batch if meet required. | [
"Insert",
"trajectory",
"into",
"buffer,",
"and",
"sample",
"batch",
"if",
"meet",
"required."
] | def prepare_data(self, train_data, **kwargs):
new_data = self._new_data_sn()
for (k, val) in train_data.items():
new_data.transition_data[k] = val
deliver_batch = EpisodeBatchNP(self.scheme, self.groups, 1, self.fix_seq_length + 1, data=new_data)
self.buffer.insert_episode_batch(deliver_batch)
... | ['def', 'prepare_data(self,', 'train_data,', '**kwargs):', 'new_data', '=', 'self._new_data_sn()', 'for', '(k,', 'val)', 'in', 'train_data.items():', 'new_data.transition_data[k]', '=', 'val', 'deliver_batch', '=', 'EpisodeBatchNP(self.scheme,', 'self.groups,', '1,', 'self.fix_seq_length', '+', '1,', 'data=new_data)', ... | 962,128 |
huawei-noah/xingtian | qmix_alg.py | QMixAlg.train | train | Train with buffer sampled. | [
"Train",
"with",
"buffer",
"sampled."
] | def train(self, **kwargs):
if not self.train_batch:
return np.nan
episode_num = kwargs.get('episode_num')
if not episode_num:
raise KeyError('need episode num to update target network')
batch = self.train_batch
max_ep_t = batch.max_t_filled()
logging.debug('episode sample with ma... | ['def', 'train(self,', '**kwargs):', 'if', 'not', 'self.train_batch:', 'return', 'np.nan', 'episode_num', '=', "kwargs.get('episode_num')", 'if', 'not', 'episode_num:', 'raise', "KeyError('need", 'episode', 'num', 'to', 'update', 'target', "network')", 'batch', '=', 'self.train_batch', 'max_ep_t', '=', 'batch.max_t_fil... | 962,129 |
huawei-noah/xingtian | scc_alg.py | EpsilonGreedyActionSelector.select_action | select_action | Assume agent_inputs is a batch of Q-Values for each agent bav. | [
"Assume",
"agent_inputs",
"is",
"a",
"batch",
"of",
"Q-Values",
"for",
"each",
"agent",
"bav."
] | def select_action(self, agent_inputs, avail_actions, t_env, test_mode=False):
self.epsilon = self.schedule.eval(t_env)
if test_mode:
self.epsilon = 0.0
masked_q_values = agent_inputs.copy()
masked_q_values[avail_actions < 1e-06] = -float('inf')
random_numbers = np.random.rand(*agent_inputs[:... | ['def', 'select_action(self,', 'agent_inputs,', 'avail_actions,', 't_env,', 'test_mode=False):', 'self.epsilon', '=', 'self.schedule.eval(t_env)', 'if', 'test_mode:', 'self.epsilon', '=', '0.0', 'masked_q_values', '=', 'agent_inputs.copy()', 'masked_q_values[avail_actions', '<', '1e-06]', '=', "-float('inf')", 'random_... | 962,133 |
huawei-noah/xingtian | environment.py | Environment.get_env_info | get_env_info | Return environment's basic information. | [
"Return",
"environment's",
"basic",
"information."
] | def get_env_info(self):
self.reset()
env_info = {'n_agents': self.n_agents, 'api_type': self.api_type, 'action_type': self.action_type}
agent_ids = list(self.get_init_state().keys()) if self.n_agents > 1 else [0]
env_info.update({'agent_ids': agent_ids})
return env_info | ['def', 'get_env_info(self):', 'self.reset()', 'env_info', '=', "{'n_agents':", 'self.n_agents,', "'api_type':", 'self.api_type,', "'action_type':", 'self.action_type}', 'agent_ids', '=', 'list(self.get_init_state().keys())', 'if', 'self.n_agents', '>', '1', 'else', '[0]', "env_info.update({'agent_ids':", 'agent_ids})'... | 962,145 |
huawei-noah/xingtian | atari_wrappers.py | AtariBaseEnv.reset | reset | Create reset environment and take random noop action. | [
"Create",
"reset",
"environment",
"and",
"take",
"random",
"noop",
"action."
] | def reset(self):
self.env.reset()
repeat_noop_times = self.unwrapped.np_random.randint(1, self.max_noop_times + 1)
for _ in range(repeat_noop_times):
(state, _, done, _) = self.env.step(self.noop_action)
if done:
state = self.env.reset()
return state | ['def', 'reset(self):', 'self.env.reset()', 'repeat_noop_times', '=', 'self.unwrapped.np_random.randint(1,', 'self.max_noop_times', '+', '1)', 'for', '_', 'in', 'range(repeat_noop_times):', '(state,', '_,', 'done,', '_)', '=', 'self.env.step(self.noop_action)', 'if', 'done:', 'state', '=', 'self.env.reset()', 'return',... | 962,154 |
huawei-noah/xingtian | broker.py | stats_id | stats_id | Assemble the id for record stats information. | [
"Assemble",
"the",
"id",
"for",
"record",
"stats",
"information."
] | def stats_id(ctr_info):
return 'B{}E{}{}'.format(ctr_info['broker_id'], ctr_info['explorer_id'], ctr_info['cmd']) | ['def', 'stats_id(ctr_info):', 'return', "'B{}E{}{}'.format(ctr_info['broker_id'],", "ctr_info['explorer_id'],", "ctr_info['cmd'])"] | 962,184 |
huawei-noah/xingtian | broker.py | Controller.start_data_transfer | start_data_transfer | Start transfer data and other thread. | [
"Start",
"transfer",
"data",
"and",
"other",
"thread."
] | def start_data_transfer(self):
data_transfer_thread = threading.Thread(target=self.recv_broker_task)
data_transfer_thread.setDaemon(True)
data_transfer_thread.start()
data_transfer_thread = threading.Thread(target=self.recv_local)
data_transfer_thread.setDaemon(True)
data_transfer_thread.start() | ['def', 'start_data_transfer(self):', 'data_transfer_thread', '=', 'threading.Thread(target=self.recv_broker_task)', 'data_transfer_thread.setDaemon(True)', 'data_transfer_thread.start()', 'data_transfer_thread', '=', 'threading.Thread(target=self.recv_local)', 'data_transfer_thread.setDaemon(True)', 'data_transfer_thr... | 962,185 |
huawei-noah/xingtian | broker.py | Controller.recv_broker_task | recv_broker_task | Receive remote train data in sync mode. | [
"Receive",
"remote",
"train",
"data",
"in",
"sync",
"mode."
] | def recv_broker_task(self):
while True:
(ctr_info, recv_data) = self.recv_broker.recv_bytes()
_t0 = time.time()
ctr_info = deserialize(ctr_info)
compress_flag = ctr_info.get('compress_flag', False)
if compress_flag:
recv_data = lz4.frame.decompress(recv_data)
... | ['def', 'recv_broker_task(self):', 'while', 'True:', '(ctr_info,', 'recv_data)', '=', 'self.recv_broker.recv_bytes()', '_t0', '=', 'time.time()', 'ctr_info', '=', 'deserialize(ctr_info)', 'compress_flag', '=', "ctr_info.get('compress_flag',", 'False)', 'if', 'compress_flag:', 'recv_data', '=', 'lz4.frame.decompress(rec... | 962,186 |
huawei-noah/xingtian | broker.py | Controller.add_task | add_task | Add learner task into Broker. | [
"Add",
"learner",
"task",
"into",
"Broker."
] | def add_task(self, learner_obj):
self._main_task.append(learner_obj) | ['def', 'add_task(self,', 'learner_obj):', 'self._main_task.append(learner_obj)'] | 962,187 |
huawei-noah/xingtian | broker.py | Broker.recv_controller_task | recv_controller_task | Recv remote train data in sync mode. | [
"Recv",
"remote",
"train",
"data",
"in",
"sync",
"mode."
] | def recv_controller_task(self):
while True:
(ctr_info, data) = self.recv_controller_q.recv_bytes()
recv_data = {'ctr_info': deserialize(ctr_info), 'data': deserialize(data)}
cmd = get_msg_info(recv_data, 'cmd')
if cmd in ['close']:
self.close(recv_data)
if cmd in ... | ['def', 'recv_controller_task(self):', 'while', 'True:', '(ctr_info,', 'data)', '=', 'self.recv_controller_q.recv_bytes()', 'recv_data', '=', "{'ctr_info':", 'deserialize(ctr_info),', "'data':", 'deserialize(data)}', 'cmd', '=', 'get_msg_info(recv_data,', "'cmd')", 'if', 'cmd', 'in', "['close']:", 'self.close(recv_data... | 962,191 |
huawei-noah/xingtian | broker.py | Broker.alloc | alloc | Monitor system and adjust resource. | [
"Monitor",
"system",
"and",
"adjust",
"resource."
] | def alloc(self, actor_status):
p_id = [_p.pid for (_, _p) in self.explore_process.items()]
p = [psutil.Process(_pid) for _pid in p_id]
if actor_status == 'decrease':
if self.processes_suspend < len(p):
p[self.processes_suspend].suspend()
self.processes_suspend += 1
elif a... | ['def', 'alloc(self,', 'actor_status):', 'p_id', '=', '[_p.pid', 'for', '(_,', '_p)', 'in', 'self.explore_process.items()]', 'p', '=', '[psutil.Process(_pid)', 'for', '_pid', 'in', 'p_id]', 'if', 'actor_status', '==', "'decrease':", 'if', 'self.processes_suspend', '<', 'len(p):', 'p[self.processes_suspend].suspend()', ... | 962,192 |
huawei-noah/xingtian | broker_launcher.py | launch_broker | launch_broker | Run actor in local node, unify the act launcher api. | [
"Run",
"actor",
"in",
"local",
"node,",
"unify",
"the",
"act",
"launcher",
"api."
] | def launch_broker(config_info, verbosity='info'):
node_config_list = config_info.get('node_config', DEFAULT_NODE_CONFIG)
broker_controller = Controller(node_config_list.copy())
server_port_info = broker_controller.port_info
train_port = server_port_info['recv']['port']
predict_port = list([_d['port'... | ['def', 'launch_broker(config_info,', "verbosity='info'):", 'node_config_list', '=', "config_info.get('node_config',", 'DEFAULT_NODE_CONFIG)', 'broker_controller', '=', 'Controller(node_config_list.copy())', 'server_port_info', '=', 'broker_controller.port_info', 'train_port', '=', "server_port_info['recv']['port']", '... | 962,196 |
openvinotoolkit/training_extensions | progress_hook.py | OTXProgressHook.before_run | before_run | Called before_run in OTXProgressHook. | [
"Called",
"before_run",
"in",
"OTXProgressHook."
] | def before_run(self, runner: BaseRunner):
total_epochs = runner.max_epochs if runner.max_epochs is not None else 1
self.time_monitor.total_epochs = total_epochs
self.time_monitor.train_steps = runner.max_iters // total_epochs if total_epochs else 1
self.time_monitor.steps_per_epoch = self.time_monitor.t... | ['def', 'before_run(self,', 'runner:', 'BaseRunner):', 'total_epochs', '=', 'runner.max_epochs', 'if', 'runner.max_epochs', 'is', 'not', 'None', 'else', '1', 'self.time_monitor.total_epochs', '=', 'total_epochs', 'self.time_monitor.train_steps', '=', 'runner.max_iters', '//', 'total_epochs', 'if', 'total_epochs', 'else... | 917,842 |
openvinotoolkit/training_extensions | progress_hook.py | OTXProgressHook.after_epoch | after_epoch | Called after_epoch in OTXProgressHook. | [
"Called",
"after_epoch",
"in",
"OTXProgressHook."
] | def after_epoch(self, runner: BaseRunner):
runner.log_buffer.output['current_iters'] = runner.iter
self.time_monitor.on_epoch_end(runner.epoch, runner.log_buffer.output) | ['def', 'after_epoch(self,', 'runner:', 'BaseRunner):', "runner.log_buffer.output['current_iters']", '=', 'runner.iter', 'self.time_monitor.on_epoch_end(runner.epoch,', 'runner.log_buffer.output)'] | 917,844 |
openvinotoolkit/training_extensions | progress_hook.py | OTXProgressHook.before_iter | before_iter | Called before_iter in OTXProgressHook. | [
"Called",
"before_iter",
"in",
"OTXProgressHook."
] | def before_iter(self, runner: BaseRunner):
self.time_monitor.on_train_batch_begin(1) | ['def', 'before_iter(self,', 'runner:', 'BaseRunner):', 'self.time_monitor.on_train_batch_begin(1)'] | 917,845 |
openvinotoolkit/training_extensions | progress_hook.py | OTXProgressHook.after_iter | after_iter | Called after_iter in OTXProgressHook. | [
"Called",
"after_iter",
"in",
"OTXProgressHook."
] | def after_iter(self, runner: BaseRunner):
runner.log_buffer.output['current_iters'] = runner.iter
self.time_monitor.on_train_batch_end(1)
if self.verbose:
progress = self.progress
if progress >= self.print_threshold:
logger.info(f'training progress {progress:.0f}%')
s... | ['def', 'after_iter(self,', 'runner:', 'BaseRunner):', "runner.log_buffer.output['current_iters']", '=', 'runner.iter', 'self.time_monitor.on_train_batch_end(1)', 'if', 'self.verbose:', 'progress', '=', 'self.progress', 'if', 'progress', '>=', 'self.print_threshold:', "logger.info(f'training", 'progress', "{progress:.0... | 917,846 |
openvinotoolkit/training_extensions | progress_hook.py | OTXProgressHook.before_val_iter | before_val_iter | Called before_val_iter in OTXProgressHook. | [
"Called",
"before_val_iter",
"in",
"OTXProgressHook."
] | def before_val_iter(self, runner: BaseRunner):
self.time_monitor.on_test_batch_begin(1, logger) | ['def', 'before_val_iter(self,', 'runner:', 'BaseRunner):', 'self.time_monitor.on_test_batch_begin(1,', 'logger)'] | 917,847 |
openvinotoolkit/training_extensions | progress_hook.py | OTXProgressHook.after_run | after_run | Called after_run in OTXProgressHook. | [
"Called",
"after_run",
"in",
"OTXProgressHook."
] | def after_run(self, runner: BaseRunner):
self.time_monitor.on_train_end(1)
if self.time_monitor.update_progress_callback:
self.time_monitor.update_progress_callback(int(self.time_monitor.get_progress())) | ['def', 'after_run(self,', 'runner:', 'BaseRunner):', 'self.time_monitor.on_train_end(1)', 'if', 'self.time_monitor.update_progress_callback:', 'self.time_monitor.update_progress_callback(int(self.time_monitor.get_progress()))'] | 917,849 |
openvinotoolkit/training_extensions | progress_hook.py | OTXProgressHook.progress | progress | Getting Progress from time monitor. | [
"Getting",
"Progress",
"from",
"time",
"monitor."
] | def progress(self):
return self.time_monitor.get_progress() | ['def', 'progress(self):', 'return', 'self.time_monitor.get_progress()'] | 917,850 |
openvinotoolkit/training_extensions | recording_forward_hook.py | EigenCamHook.func | func | Generate the saliency map. | [
"Generate",
"the",
"saliency",
"map."
] | def func(self, feature_map: Union[torch.Tensor, Sequence[torch.Tensor]], fpn_idx: int=-1) -> torch.Tensor:
if isinstance(feature_map, (list, tuple)):
feature_map = feature_map[fpn_idx]
x = feature_map.type(torch.float)
(batch_size, channel, h, w) = x.size()
reshaped_fmap = x.reshape((batch_size,... | ['def', 'func(self,', 'feature_map:', 'Union[torch.Tensor,', 'Sequence[torch.Tensor]],', 'fpn_idx:', 'int=-1)', '->', 'torch.Tensor:', 'if', 'isinstance(feature_map,', '(list,', 'tuple)):', 'feature_map', '=', 'feature_map[fpn_idx]', 'x', '=', 'feature_map.type(torch.float)', '(batch_size,', 'channel,', 'h,', 'w)', '='... | 917,852 |
openvinotoolkit/training_extensions | recording_forward_hook.py | ReciproCAMHook.func | func | Generate the class-wise saliency maps using Recipro-CAM and then normalizing to (0, 255). | [
"Generate",
"the",
"class-wise",
"saliency",
"maps",
"using",
"Recipro-CAM",
"and",
"then",
"normalizing",
"to",
"(0,",
"255)."
] | def func(self, feature_map: Union[torch.Tensor, Sequence[torch.Tensor]], fpn_idx: int=-1) -> torch.Tensor:
if isinstance(feature_map, (list, tuple)):
feature_map = feature_map[fpn_idx]
(batch_size, channel, h, w) = feature_map.size()
saliency_maps = torch.empty(batch_size, self._num_classes, h, w)
... | ['def', 'func(self,', 'feature_map:', 'Union[torch.Tensor,', 'Sequence[torch.Tensor]],', 'fpn_idx:', 'int=-1)', '->', 'torch.Tensor:', 'if', 'isinstance(feature_map,', '(list,', 'tuple)):', 'feature_map', '=', 'feature_map[fpn_idx]', '(batch_size,', 'channel,', 'h,', 'w)', '=', 'feature_map.size()', 'saliency_maps', '=... | 917,855 |
openvinotoolkit/training_extensions | recording_forward_hook.py | ViTReciproCAMHook.func | func | Generate the class-wise saliency maps using ViTRecipro-CAM and then normalizing to (0, 255). | [
"Generate",
"the",
"class-wise",
"saliency",
"maps",
"using",
"ViTRecipro-CAM",
"and",
"then",
"normalizing",
"to",
"(0,",
"255)."
] | def func(self, feature_map: torch.Tensor, _: int=-1) -> torch.Tensor:
(batch_size, token_number, _) = feature_map.size()
h = w = int((token_number - 1) ** 0.5)
saliency_maps = torch.empty(batch_size, self._num_classes, h, w)
for i in range(batch_size):
mosaic_feature_map = self._get_mosaic_featu... | ['def', 'func(self,', 'feature_map:', 'torch.Tensor,', '_:', 'int=-1)', '->', 'torch.Tensor:', '(batch_size,', 'token_number,', '_)', '=', 'feature_map.size()', 'h', '=', 'w', '=', 'int((token_number', '-', '1)', '**', '0.5)', 'saliency_maps', '=', 'torch.empty(batch_size,', 'self._num_classes,', 'h,', 'w)', 'for', 'i'... | 917,856 |
openvinotoolkit/training_extensions | semisl_cls_hook.py | SemiSLClsHook.after_train_iter | after_train_iter | Add the number of pseudo-labels correctly selected from iteration. | [
"Add",
"the",
"number",
"of",
"pseudo-labels",
"correctly",
"selected",
"from",
"iteration."
] | def after_train_iter(self, runner):
model = self._get_model(runner)
self.num_pseudo_label += int(model.head.num_pseudo_label) | ['def', 'after_train_iter(self,', 'runner):', 'model', '=', 'self._get_model(runner)', 'self.num_pseudo_label', '+=', 'int(model.head.num_pseudo_label)'] | 917,859 |
openvinotoolkit/training_extensions | semisl_cls_hook.py | SemiSLClsHook.after_epoch | after_epoch | Add data related to Semi-SL to the log. | [
"Add",
"data",
"related",
"to",
"Semi-SL",
"to",
"the",
"log."
] | def after_epoch(self, runner):
if self.unlabeled_warmup:
runner.log_buffer.output.update({'unlabeled_coef': round(self.unlabeled_coef, 4)})
runner.log_buffer.output.update({'pseudo_label': self.num_pseudo_label})
self.num_pseudo_label = 0 | ['def', 'after_epoch(self,', 'runner):', 'if', 'self.unlabeled_warmup:', "runner.log_buffer.output.update({'unlabeled_coef':", 'round(self.unlabeled_coef,', '4)})', "runner.log_buffer.output.update({'pseudo_label':", 'self.num_pseudo_label})', 'self.num_pseudo_label', '=', '0'] | 917,860 |
openvinotoolkit/training_extensions | task_adapt_hook.py | TaskAdaptHook.before_epoch | before_epoch | Produce a proper sampler for task-adaptation. | [
"Produce",
"a",
"proper",
"sampler",
"for",
"task-adaptation."
] | def before_epoch(self, runner):
if self.sampler_flag:
dataset = runner.data_loader.dataset
batch_size = runner.data_loader.batch_size
num_workers = runner.data_loader.num_workers
collate_fn = runner.data_loader.collate_fn
worker_init_fn = runner.data_loader.worker_init_fn
... | ['def', 'before_epoch(self,', 'runner):', 'if', 'self.sampler_flag:', 'dataset', '=', 'runner.data_loader.dataset', 'batch_size', '=', 'runner.data_loader.batch_size', 'num_workers', '=', 'runner.data_loader.num_workers', 'collate_fn', '=', 'runner.data_loader.collate_fn', 'worker_init_fn', '=', 'runner.data_loader.wor... | 917,861 |
openvinotoolkit/training_extensions | two_crop_transform_hook.py | TwoCropTransformHook.after_train_iter | after_train_iter | Called after_train_iter in TwoCropTransformHook. | [
"Called",
"after_train_iter",
"in",
"TwoCropTransformHook."
] | def after_train_iter(self, runner: BaseRunner):
if self.interval == 1:
return
if self.cnt < self.interval - 1:
self.cnt += 1
if self.cnt == self.interval - 1:
dataset = self._get_dataset(runner)
two_crop_transform = self._find_two_crop_transform(dataset.pipeline.transforms)
... | ['def', 'after_train_iter(self,', 'runner:', 'BaseRunner):', 'if', 'self.interval', '==', '1:', 'return', 'if', 'self.cnt', '<', 'self.interval', '-', '1:', 'self.cnt', '+=', '1', 'if', 'self.cnt', '==', 'self.interval', '-', '1:', 'dataset', '=', 'self._get_dataset(runner)', 'two_crop_transform', '=', 'self._find_two_... | 917,863 |
openvinotoolkit/training_extensions | efficientnet.py | calc_tf_padding | calc_tf_padding | Calculate TF-same like padding size. | [
"Calculate",
"TF-same",
"like",
"padding",
"size."
] | def calc_tf_padding(x, kernel_size, stride=1, dilation=1):
(height, width) = x.size()[2:]
oh = math.ceil(height / stride)
ow = math.ceil(width / stride)
pad_h = max((oh - 1) * stride + (kernel_size - 1) * dilation + 1 - height, 0)
pad_w = max((ow - 1) * stride + (kernel_size - 1) * dilation + 1 - wi... | ['def', 'calc_tf_padding(x,', 'kernel_size,', 'stride=1,', 'dilation=1):', '(height,', 'width)', '=', 'x.size()[2:]', 'oh', '=', 'math.ceil(height', '/', 'stride)', 'ow', '=', 'math.ceil(width', '/', 'stride)', 'pad_h', '=', 'max((oh', '-', '1)', '*', 'stride', '+', '(kernel_size', '-', '1)', '*', 'dilation', '+', '1',... | 917,865 |
openvinotoolkit/training_extensions | efficientnet.py | get_efficientnet | get_efficientnet | Create EfficientNet model with specific parameters. | [
"Create",
"EfficientNet",
"model",
"with",
"specific",
"parameters."
] | def get_efficientnet(version, in_size, tf_mode=False, bn_eps=1e-05, model_name=None, pretrained=False, root=os.path.join('~', '.torch', 'models'), **kwargs):
if version == 'b0':
assert in_size == (224, 224)
depth_factor = 1.0
width_factor = 1.0
dropout_rate = 0.2
elif version == ... | ['def', 'get_efficientnet(version,', 'in_size,', 'tf_mode=False,', 'bn_eps=1e-05,', 'model_name=None,', 'pretrained=False,', "root=os.path.join('~',", "'.torch',", "'models'),", '**kwargs):', 'if', 'version', '==', "'b0':", 'assert', 'in_size', '==', '(224,', '224)', 'depth_factor', '=', '1.0', 'width_factor', '=', '1.... | 917,866 |
openvinotoolkit/training_extensions | torchvision_backbones.py | shufflenet_forward | shufflenet_forward | Shufflenet forward function for wrapping model (refer to torchvision). | [
"Shufflenet",
"forward",
"function",
"for",
"wrapping",
"model",
"(refer",
"to",
"torchvision)."
] | def shufflenet_forward(self, x):
outputs = []
y = x
y = self.conv1(y)
y = self.maxpool(y)
stages = [self.stage2, self.stage3, self.stage4, self.conv5]
last_stage = max(self.out_indices)
for (i, stage) in enumerate(stages):
y = stage(y)
if i in self.out_indices:
ou... | ['def', 'shufflenet_forward(self,', 'x):', 'outputs', '=', '[]', 'y', '=', 'x', 'y', '=', 'self.conv1(y)', 'y', '=', 'self.maxpool(y)', 'stages', '=', '[self.stage2,', 'self.stage3,', 'self.stage4,', 'self.conv5]', 'last_stage', '=', 'max(self.out_indices)', 'for', '(i,', 'stage)', 'in', 'enumerate(stages):', 'y', '=',... | 917,873 |
openvinotoolkit/training_extensions | torchvision_backbones.py | multioutput_forward | multioutput_forward | Multioutput forward function for new model (copy from mmdet). | [
"Multioutput",
"forward",
"function",
"for",
"new",
"model",
"(copy",
"from",
"mmdet)."
] | def multioutput_forward(self, x):
outputs = []
y = x
last_stage = max(self.out_indices)
if hasattr(self, 'features'):
stages = self.features
elif hasattr(self, 'layers'):
stages = self.layers
else:
raise ValueError(f'Not supported multioutput forward: {self}')
for (i,... | ['def', 'multioutput_forward(self,', 'x):', 'outputs', '=', '[]', 'y', '=', 'x', 'last_stage', '=', 'max(self.out_indices)', 'if', 'hasattr(self,', "'features'):", 'stages', '=', 'self.features', 'elif', 'hasattr(self,', "'layers'):", 'stages', '=', 'self.layers', 'else:', 'raise', "ValueError(f'Not", 'supported', 'mul... | 917,874 |
openvinotoolkit/training_extensions | torchvision_backbones.py | train | train | Train forward function for new model (copy from mmdet). | [
"Train",
"forward",
"function",
"for",
"new",
"model",
"(copy",
"from",
"mmdet)."
] | def train(self, mode=True):
super(self.__class__, self).train(mode)
if hasattr(self, 'features'):
stages = self.features
elif hasattr(self, 'layers'):
stages = self.layers
else:
raise ValueError(f'Not supported multioutput forward: {self}')
for i in range(self.frozen_stages +... | ['def', 'train(self,', 'mode=True):', 'super(self.__class__,', 'self).train(mode)', 'if', 'hasattr(self,', "'features'):", 'stages', '=', 'self.features', 'elif', 'hasattr(self,', "'layers'):", 'stages', '=', 'self.layers', 'else:', 'raise', "ValueError(f'Not", 'supported', 'multioutput', 'forward:', "{self}')", 'for',... | 917,875 |
openvinotoolkit/training_extensions | torchvision_backbones.py | init_weights | init_weights | Init weights function for new model (copy from mmdet). | [
"Init",
"weights",
"function",
"for",
"new",
"model",
"(copy",
"from",
"mmdet)."
] | def init_weights(self):
if self.init_cfg.get('Pretrained', False) and self.model_urls:
state_dict = load_state_dict_from_url(self.model_urls)
self.load_state_dict(state_dict) | ['def', 'init_weights(self):', 'if', "self.init_cfg.get('Pretrained',", 'False)', 'and', 'self.model_urls:', 'state_dict', '=', 'load_state_dict_from_url(self.model_urls)', 'self.load_state_dict(state_dict)'] | 917,876 |
openvinotoolkit/training_extensions | torchvision_backbones.py | generate_torchvision_backbones | generate_torchvision_backbones | Regist Torchvision Backbone into mmX Registry (copy from mmdet). | [
"Regist",
"Torchvision",
"Backbone",
"into",
"mmX",
"Registry",
"(copy",
"from",
"mmdet)."
] | def generate_torchvision_backbones():
for (model_name, model_builder) in TORCHVISION_MODELS.items():
def closure(model_name, model_builder):
class TorchvisionModelWrapper(nn.Module):
def __init__(self, *args, out_indices=(0, 1, 2, 3), frozen_stages=0, norm_eval=False, verbose=... | ['def', 'generate_torchvision_backbones():', 'for', '(model_name,', 'model_builder)', 'in', 'TORCHVISION_MODELS.items():', 'def', 'closure(model_name,', 'model_builder):', 'class', 'TorchvisionModelWrapper(nn.Module):', 'def', '__init__(self,', '*args,', 'out_indices=(0,', '1,', '2,', '3),', 'frozen_stages=0,', 'norm_e... | 917,877 |
openvinotoolkit/training_extensions | hooks.py | CompressionHook.after_train_iter | after_train_iter | Called after train iter. | [
"Called",
"after",
"train",
"iter."
] | def after_train_iter(self, runner):
self.compression_ctrl.scheduler.step() | ['def', 'after_train_iter(self,', 'runner):', 'self.compression_ctrl.scheduler.step()'] | 917,878 |
openvinotoolkit/training_extensions | hooks.py | CompressionHook.after_train_epoch | after_train_epoch | Called after train epoch. | [
"Called",
"after",
"train",
"epoch."
] | def after_train_epoch(self, runner):
self.compression_ctrl.scheduler.epoch_step()
if runner.rank == 0:
runner.logger.info(self.compression_ctrl.statistics().to_str()) | ['def', 'after_train_epoch(self,', 'runner):', 'self.compression_ctrl.scheduler.epoch_step()', 'if', 'runner.rank', '==', '0:', 'runner.logger.info(self.compression_ctrl.statistics().to_str())'] | 917,879 |
openvinotoolkit/training_extensions | augments.py | Augments.autocontrast | autocontrast | Apply autocontrast for an given image. | [
"Apply",
"autocontrast",
"for",
"an",
"given",
"image."
] | def autocontrast(img: PILImage, *args, **kwargs) -> PILImage:
return ImageOps.autocontrast(img) | ['def', 'autocontrast(img:', 'PILImage,', '*args,', '**kwargs)', '->', 'PILImage:', 'return', 'ImageOps.autocontrast(img)'] | 917,889 |
openvinotoolkit/training_extensions | augments.py | Augments.equalize | equalize | Apply equalize for an given image. | [
"Apply",
"equalize",
"for",
"an",
"given",
"image."
] | def equalize(img: PILImage, *args, **kwargs) -> PILImage:
return ImageOps.equalize(img) | ['def', 'equalize(img:', 'PILImage,', '*args,', '**kwargs)', '->', 'PILImage:', 'return', 'ImageOps.equalize(img)'] | 917,890 |
openvinotoolkit/training_extensions | augments.py | Augments.solarize | solarize | Apply solarize for an given image. | [
"Apply",
"solarize",
"for",
"an",
"given",
"image."
] | def solarize(img: PILImage, threshold: int, *args, **kwargs) -> PILImage:
return ImageOps.solarize(img, threshold) | ['def', 'solarize(img:', 'PILImage,', 'threshold:', 'int,', '*args,', '**kwargs)', '->', 'PILImage:', 'return', 'ImageOps.solarize(img,', 'threshold)'] | 917,891 |
openvinotoolkit/training_extensions | augments.py | Augments.contrast | contrast | Apply contrast for an given image. | [
"Apply",
"contrast",
"for",
"an",
"given",
"image."
] | def contrast(img: PILImage, factor: float, *args, **kwargs) -> PILImage:
return ImageEnhance.Contrast(img).enhance(factor) | ['def', 'contrast(img:', 'PILImage,', 'factor:', 'float,', '*args,', '**kwargs)', '->', 'PILImage:', 'return', 'ImageEnhance.Contrast(img).enhance(factor)'] | 917,894 |
openvinotoolkit/training_extensions | augments.py | Augments.rotate | rotate | Apply rotate for an given image. | [
"Apply",
"rotate",
"for",
"an",
"given",
"image."
] | def rotate(img: PILImage, degree: float, *args, **kwargs) -> PILImage:
kwargs = Augments._check_args_tf(kwargs)
return img.rotate(degree, **kwargs) | ['def', 'rotate(img:', 'PILImage,', 'degree:', 'float,', '*args,', '**kwargs)', '->', 'PILImage:', 'kwargs', '=', 'Augments._check_args_tf(kwargs)', 'return', 'img.rotate(degree,', '**kwargs)'] | 917,897 |
openvinotoolkit/training_extensions | augments.py | Augments.shear_y | shear_y | Apply shear_y for an given image. | [
"Apply",
"shear_y",
"for",
"an",
"given",
"image."
] | def shear_y(img: PILImage, factor: float, *args, **kwargs) -> PILImage:
kwargs = Augments._check_args_tf(kwargs)
return img.transform(img.size, Image.AFFINE, (1, 0, 0, factor, 1, 0), **kwargs) | ['def', 'shear_y(img:', 'PILImage,', 'factor:', 'float,', '*args,', '**kwargs)', '->', 'PILImage:', 'kwargs', '=', 'Augments._check_args_tf(kwargs)', 'return', 'img.transform(img.size,', 'Image.AFFINE,', '(1,', '0,', '0,', 'factor,', '1,', '0),', '**kwargs)'] | 917,899 |
openvinotoolkit/training_extensions | augments.py | Augments.translate_y_rel | translate_y_rel | Apply translate_y_rel for an given image. | [
"Apply",
"translate_y_rel",
"for",
"an",
"given",
"image."
] | def translate_y_rel(img: PILImage, pct: float, *args, **kwargs) -> PILImage:
kwargs = Augments._check_args_tf(kwargs)
pixels = pct * img.size[1]
return img.transform(img.size, Image.AFFINE, (1, 0, 0, 0, 1, pixels), **kwargs) | ['def', 'translate_y_rel(img:', 'PILImage,', 'pct:', 'float,', '*args,', '**kwargs)', '->', 'PILImage:', 'kwargs', '=', 'Augments._check_args_tf(kwargs)', 'pixels', '=', 'pct', '*', 'img.size[1]', 'return', 'img.transform(img.size,', 'Image.AFFINE,', '(1,', '0,', '0,', '0,', '1,', 'pixels),', '**kwargs)'] | 917,901 |
openvinotoolkit/training_extensions | augments.py | CythonAugments.posterize | posterize | Apply posterize for an given image. | [
"Apply",
"posterize",
"for",
"an",
"given",
"image."
] | def posterize(img: ImgTypes, bits_to_keep: int, *args, **kwargs) -> ImgTypes:
if Image.isImageType(img):
if bits_to_keep >= 8:
return img
return pil_aug.posterize(img, bits_to_keep)
raise NotImplementedError(f'Unknown type: {type(img)}') | ['def', 'posterize(img:', 'ImgTypes,', 'bits_to_keep:', 'int,', '*args,', '**kwargs)', '->', 'ImgTypes:', 'if', 'Image.isImageType(img):', 'if', 'bits_to_keep', '>=', '8:', 'return', 'img', 'return', 'pil_aug.posterize(img,', 'bits_to_keep)', 'raise', "NotImplementedError(f'Unknown", 'type:', "{type(img)}')"] | 917,905 |
openvinotoolkit/training_extensions | augments.py | CythonAugments.brightness | brightness | Apply brightness for an given image. | [
"Apply",
"brightness",
"for",
"an",
"given",
"image."
] | def brightness(img: ImgTypes, factor: float, *args, **kwargs) -> ImgTypes:
if Image.isImageType(img):
return pil_aug.brightness(img, factor)
raise NotImplementedError(f'Unknown type: {type(img)}') | ['def', 'brightness(img:', 'ImgTypes,', 'factor:', 'float,', '*args,', '**kwargs)', '->', 'ImgTypes:', 'if', 'Image.isImageType(img):', 'return', 'pil_aug.brightness(img,', 'factor)', 'raise', "NotImplementedError(f'Unknown", 'type:', "{type(img)}')"] | 917,908 |
openvinotoolkit/training_extensions | augments.py | CythonAugments.blend | blend | Apply blend for an given image. | [
"Apply",
"blend",
"for",
"an",
"given",
"image."
] | def blend(src: ImgTypes, dst: CvImage, weight: float=0.0):
assert isinstance(dst, CvImage), f'Type of dst should be numpy array, but type(dst)={type(dst)}.'
if Image.isImageType(src):
return pil_aug.blend(src, dst, weight)
raise NotImplementedError(f'Unknown type: {type(src)}') | ['def', 'blend(src:', 'ImgTypes,', 'dst:', 'CvImage,', 'weight:', 'float=0.0):', 'assert', 'isinstance(dst,', 'CvImage),', "f'Type", 'of', 'dst', 'should', 'be', 'numpy', 'array,', 'but', "type(dst)={type(dst)}.'", 'if', 'Image.isImageType(src):', 'return', 'pil_aug.blend(src,', 'dst,', 'weight)', 'raise', "NotImplemen... | 917,915 |
openvinotoolkit/training_extensions | exporter.py | Exporter.mmdeploy_export | mmdeploy_export | Export procedure using mmdeploy backend. | [
"Export",
"procedure",
"using",
"mmdeploy",
"backend."
] | def mmdeploy_export(output_dir, model_builder, precision, export_type, cfg, deploy_cfg, model_name='model'):
from otx.algorithms.common.adapters.mmdeploy.apis import MMdeployExporter
if precision == 'FP16':
deploy_cfg.backend_config.mo_options.flags.append('--compress_to_fp16')
MMdeployExporter.expo... | ['def', 'mmdeploy_export(output_dir,', 'model_builder,', 'precision,', 'export_type,', 'cfg,', 'deploy_cfg,', "model_name='model'):", 'from', 'otx.algorithms.common.adapters.mmdeploy.apis', 'import', 'MMdeployExporter', 'if', 'precision', '==', "'FP16':", "deploy_cfg.backend_config.mo_options.flags.append('--compress_t... | 917,916 |
openvinotoolkit/training_extensions | config_utils.py | update_or_add_custom_hook | update_or_add_custom_hook | Update hook cfg if same type is in custom_hook or append it. | [
"Update",
"hook",
"cfg",
"if",
"same",
"type",
"is",
"in",
"custom_hook",
"or",
"append",
"it."
] | def update_or_add_custom_hook(cfg: Config, hook_cfg: ConfigDict):
custom_hooks = cfg.get('custom_hooks', [])
custom_hooks_updated = False
for custom_hook in custom_hooks:
if custom_hook['type'] == hook_cfg['type']:
custom_hook.update(hook_cfg)
custom_hooks_updated = True
... | ['def', 'update_or_add_custom_hook(cfg:', 'Config,', 'hook_cfg:', 'ConfigDict):', 'custom_hooks', '=', "cfg.get('custom_hooks',", '[])', 'custom_hooks_updated', '=', 'False', 'for', 'custom_hook', 'in', 'custom_hooks:', 'if', "custom_hook['type']", '==', "hook_cfg['type']:", 'custom_hook.update(hook_cfg)', 'custom_hook... | 917,921 |
openvinotoolkit/training_extensions | config_utils.py | remove_from_config | remove_from_config | Update & Remove configs. | [
"Update",
"&",
"Remove",
"configs."
] | def remove_from_config(config: Union[Config, ConfigDict], key: str):
if key in config:
if isinstance(config, Config):
del config._cfg_dict[key]
elif isinstance(config, ConfigDict):
del config[key]
else:
raise ValueError(f'Unknown config type {type(config)}... | ['def', 'remove_from_config(config:', 'Union[Config,', 'ConfigDict],', 'key:', 'str):', 'if', 'key', 'in', 'config:', 'if', 'isinstance(config,', 'Config):', 'del', 'config._cfg_dict[key]', 'elif', 'isinstance(config,', 'ConfigDict):', 'del', 'config[key]', 'else:', 'raise', "ValueError(f'Unknown", 'config', 'type', "{... | 917,925 |
openvinotoolkit/training_extensions | config_utils.py | prepare_for_testing | prepare_for_testing | Prepare configs for testing phase. | [
"Prepare",
"configs",
"for",
"testing",
"phase."
] | def prepare_for_testing(config: Union[Config, ConfigDict], dataset: DatasetEntity) -> Config:
config = copy.deepcopy(config)
config.data.test.otx_dataset = dataset
return config | ['def', 'prepare_for_testing(config:', 'Union[Config,', 'ConfigDict],', 'dataset:', 'DatasetEntity)', '->', 'Config:', 'config', '=', 'copy.deepcopy(config)', 'config.data.test.otx_dataset', '=', 'dataset', 'return', 'config'] | 917,929 |
openvinotoolkit/training_extensions | config_utils.py | get_adaptive_num_workers | get_adaptive_num_workers | Measure appropriate num_workers value and return it. | [
"Measure",
"appropriate",
"num_workers",
"value",
"and",
"return",
"it."
] | def get_adaptive_num_workers(num_dataloader: int=1) -> Union[int, None]:
num_gpus = torch.cuda.device_count()
if num_gpus == 0:
logger.warning('There is no GPUs. Use existing num_worker value.')
return None
return min(multiprocessing.cpu_count() // (num_dataloader * num_gpus), 8) | ['def', 'get_adaptive_num_workers(num_dataloader:', 'int=1)', '->', 'Union[int,', 'None]:', 'num_gpus', '=', 'torch.cuda.device_count()', 'if', 'num_gpus', '==', '0:', "logger.warning('There", 'is', 'no', 'GPUs.', 'Use', 'existing', 'num_worker', "value.')", 'return', 'None', 'return', 'min(multiprocessing.cpu_count()'... | 917,935 |
openvinotoolkit/training_extensions | config_utils.py | patch_from_hyperparams | patch_from_hyperparams | Patch config parameters from hyperparams. | [
"Patch",
"config",
"parameters",
"from",
"hyperparams."
] | def patch_from_hyperparams(config: Config, hyperparams, **kwargs):
params = hyperparams.learning_parameters
algo_backend = hyperparams.algo_backend
warmup_iters = int(params.learning_rate_warmup_iters)
lr_config = ConfigDict(warmup_iters=warmup_iters) if warmup_iters > 0 else ConfigDict(warmup_iters=war... | ['def', 'patch_from_hyperparams(config:', 'Config,', 'hyperparams,', '**kwargs):', 'params', '=', 'hyperparams.learning_parameters', 'algo_backend', '=', 'hyperparams.algo_backend', 'warmup_iters', '=', 'int(params.learning_rate_warmup_iters)', 'lr_config', '=', 'ConfigDict(warmup_iters=warmup_iters)', 'if', 'warmup_it... | 917,936 |
openvinotoolkit/training_extensions | config_utils.py | prepare_work_dir | prepare_work_dir | Prepare configs of working directory. | [
"Prepare",
"configs",
"of",
"working",
"directory."
] | def prepare_work_dir(config: Union[Config, ConfigDict]) -> str:
base_work_dir = config.work_dir
checkpoint_dirs = glob.glob(os.path.join(base_work_dir, 'checkpoints_round_*'))
train_round_checkpoint_dir = os.path.join(base_work_dir, f'checkpoints_round_{len(checkpoint_dirs)}')
os.makedirs(train_round_ch... | ['def', 'prepare_work_dir(config:', 'Union[Config,', 'ConfigDict])', '->', 'str:', 'base_work_dir', '=', 'config.work_dir', 'checkpoint_dirs', '=', 'glob.glob(os.path.join(base_work_dir,', "'checkpoints_round_*'))", 'train_round_checkpoint_dir', '=', 'os.path.join(base_work_dir,', "f'checkpoints_round_{len(checkpoint_d... | 917,937 |
openvinotoolkit/training_extensions | config_utils.py | get_proper_repeat_times | get_proper_repeat_times | Get proper repeat times for adaptive training. | [
"Get",
"proper",
"repeat",
"times",
"for",
"adaptive",
"training."
] | def get_proper_repeat_times(data_size: int, batch_size: int, coef: float, min_repeat: float) -> float:
if data_size == 0 or batch_size == 0:
logger.info('Repeat dataset enabled, but not a train mode. repeat times set to 1.')
return 1
n_iters_per_epoch = math.ceil(data_size / batch_size)
retu... | ['def', 'get_proper_repeat_times(data_size:', 'int,', 'batch_size:', 'int,', 'coef:', 'float,', 'min_repeat:', 'float)', '->', 'float:', 'if', 'data_size', '==', '0', 'or', 'batch_size', '==', '0:', "logger.info('Repeat", 'dataset', 'enabled,', 'but', 'not', 'a', 'train', 'mode.', 'repeat', 'times', 'set', 'to', "1.')"... | 917,938 |
openvinotoolkit/training_extensions | config_utils.py | InputSizeManager.set_input_size | set_input_size | Set input size in data pipe line. | [
"Set",
"input",
"size",
"in",
"data",
"pipe",
"line."
] | def set_input_size(self, input_size: Union[int, List[int], Tuple[int, int]]):
if isinstance(input_size, int):
input_size = (input_size, input_size)
if not isinstance(self.base_input_size, dict):
resize_ratio = (input_size[0] / self.base_input_size[0], input_size[1] / self.base_input_size[1])
... | ['def', 'set_input_size(self,', 'input_size:', 'Union[int,', 'List[int],', 'Tuple[int,', 'int]]):', 'if', 'isinstance(input_size,', 'int):', 'input_size', '=', '(input_size,', 'input_size)', 'if', 'not', 'isinstance(self.base_input_size,', 'dict):', 'resize_ratio', '=', '(input_size[0]', '/', 'self.base_input_size[0],'... | 917,941 |
openvinotoolkit/training_extensions | config_utils.py | InputSizeManager.select_closest_size | select_closest_size | Select the most closest size from preset sizes in log scale. | [
"Select",
"the",
"most",
"closest",
"size",
"from",
"preset",
"sizes",
"in",
"log",
"scale."
] | def select_closest_size(input_size: Tuple[int, int], preset_sizes: List[Tuple[int, int]]):
if len(preset_sizes) == 0:
return input_size
def to_log_scale(x):
return np.log(np.sqrt(x[0] * x[1]))
input_scale = to_log_scale(input_size)
preset_scales = np.array(list(map(to_log_scale, preset_... | ['def', 'select_closest_size(input_size:', 'Tuple[int,', 'int],', 'preset_sizes:', 'List[Tuple[int,', 'int]]):', 'if', 'len(preset_sizes)', '==', '0:', 'return', 'input_size', 'def', 'to_log_scale(x):', 'return', 'np.log(np.sqrt(x[0]', '*', 'x[1]))', 'input_scale', '=', 'to_log_scale(input_size)', 'preset_scales', '=',... | 917,945 |
openvinotoolkit/training_extensions | _config_utils_get_configs_by_pairs.py | get_configs_by_pairs | get_configs_by_pairs | Get a list of configs by key, value pairs. | [
"Get",
"a",
"list",
"of",
"configs",
"by",
"key,",
"value",
"pairs."
] | def get_configs_by_pairs(configs: Union[Config, ConfigDict, Sequence[Config], Sequence[ConfigDict]], pairs: Union[Dict[Any, Any], List[Dict[Any, Any]]], *, return_path: bool=False) -> Union[List[ConfigDict], Dict[Tuple[Any, ...], ConfigDict]]:
if not isinstance(pairs, list):
pairs = [pairs]
def get_con... | ['def', 'get_configs_by_pairs(configs:', 'Union[Config,', 'ConfigDict,', 'Sequence[Config],', 'Sequence[ConfigDict]],', 'pairs:', 'Union[Dict[Any,', 'Any],', 'List[Dict[Any,', 'Any]]],', '*,', 'return_path:', 'bool=False)', '->', 'Union[List[ConfigDict],', 'Dict[Tuple[Any,', '...],', 'ConfigDict]]:', 'if', 'not', 'isin... | 917,949 |
openvinotoolkit/training_extensions | apis.py | NaiveExporter.onnx2openvino | onnx2openvino | Function for onnx to openvino exporting. | [
"Function",
"for",
"onnx",
"to",
"openvino",
"exporting."
] | def onnx2openvino(output_dir: str, onnx_path: str, *, model_name: str='model', **openvino_options) -> Tuple[str, str]:
from otx.algorithms.common.utils import mo_wrapper
mo_args = {'input_model': onnx_path, 'output_dir': output_dir, 'model_name': model_name}
mo_args.update(openvino_options)
(ret, msg) =... | ['def', 'onnx2openvino(output_dir:', 'str,', 'onnx_path:', 'str,', '*,', 'model_name:', "str='model',", '**openvino_options)', '->', 'Tuple[str,', 'str]:', 'from', 'otx.algorithms.common.utils', 'import', 'mo_wrapper', 'mo_args', '=', "{'input_model':", 'onnx_path,', "'output_dir':", 'output_dir,', "'model_name':", 'mo... | 917,952 |
openvinotoolkit/training_extensions | apis.py | MMdeployExporter.partition_onnx | partition_onnx | Function for parition onnx. | [
"Function",
"for",
"parition",
"onnx."
] | def partition_onnx(output_dir, onnx_path: str, partition_cfgs: Union[mmcv.ConfigDict, List[mmcv.ConfigDict]]) -> Tuple[str, ...]:
partitioned_paths = []
if not isinstance(partition_cfgs, list):
partition_cfgs = [partition_cfgs]
for partition_cfg in partition_cfgs:
save_file = partition_cfg['... | ['def', 'partition_onnx(output_dir,', 'onnx_path:', 'str,', 'partition_cfgs:', 'Union[mmcv.ConfigDict,', 'List[mmcv.ConfigDict]])', '->', 'Tuple[str,', '...]:', 'partitioned_paths', '=', '[]', 'if', 'not', 'isinstance(partition_cfgs,', 'list):', 'partition_cfgs', '=', '[partition_cfgs]', 'for', 'partition_cfg', 'in', '... | 917,956 |
openvinotoolkit/training_extensions | onnx.py | is_op | is_op | Check if an op is identity. | [
"Check",
"if",
"an",
"op",
"is",
"identity."
] | def is_op(node: NodeProto, op_name) -> bool:
return node.op_type == op_name | ['def', 'is_op(node:', 'NodeProto,', 'op_name)', '->', 'bool:', 'return', 'node.op_type', '==', 'op_name'] | 917,963 |
openvinotoolkit/training_extensions | onnx.py | remove_node | remove_node | Remove identity node from an ONNX model. | [
"Remove",
"identity",
"node",
"from",
"an",
"ONNX",
"model."
] | def remove_node(model: ModelProto, op_name: str) -> ModelProto:
graph = model.graph
def simplify_inputs():
connect = None
for _input in graph.input:
for (i, node) in enumerate(graph.node):
if node.op_type == op_name and node.input[0] == _input.name:
... | ['def', 'remove_node(model:', 'ModelProto,', 'op_name:', 'str)', '->', 'ModelProto:', 'graph', '=', 'model.graph', 'def', 'simplify_inputs():', 'connect', '=', 'None', 'for', '_input', 'in', 'graph.input:', 'for', '(i,', 'node)', 'in', 'enumerate(graph.node):', 'if', 'node.op_type', '==', 'op_name', 'and', 'node.input[... | 917,964 |
openvinotoolkit/training_extensions | onnx.py | prepare_onnx_for_openvino | prepare_onnx_for_openvino | Modify the specified ONNX model to be compatible with OpenVINO by removing 'Mark' op nodes. | [
"Modify",
"the",
"specified",
"ONNX",
"model",
"to",
"be",
"compatible",
"with",
"OpenVINO",
"by",
"removing",
"'Mark'",
"op",
"nodes."
] | def prepare_onnx_for_openvino(in_path, out_path):
onnx_model = onnx.load(in_path)
onnx_model = remove_nodes_by_op_type(onnx_model, 'Mark')
onnx.checker.check_model(onnx_model)
onnx.save(onnx_model, out_path) | ['def', 'prepare_onnx_for_openvino(in_path,', 'out_path):', 'onnx_model', '=', 'onnx.load(in_path)', 'onnx_model', '=', 'remove_nodes_by_op_type(onnx_model,', "'Mark')", 'onnx.checker.check_model(onnx_model)', 'onnx.save(onnx_model,', 'out_path)'] | 917,966 |
openvinotoolkit/training_extensions | operations_domain.py | add_domain | add_domain | Function for adding to DOMAIN_CUSTOM_OPS_NAME. | [
"Function",
"for",
"adding",
"to",
"DOMAIN_CUSTOM_OPS_NAME."
] | def add_domain(name_operator: str) -> str:
return DOMAIN_CUSTOM_OPS_NAME + '::' + name_operator | ['def', 'add_domain(name_operator:', 'str)', '->', 'str:', 'return', 'DOMAIN_CUSTOM_OPS_NAME', '+', "'::'", '+', 'name_operator'] | 917,967 |
openvinotoolkit/training_extensions | utils.py | sync_batchnorm_2_batchnorm | sync_batchnorm_2_batchnorm | Syncs the BatchNorm layers in a model to use regular BatchNorm layers. | [
"Syncs",
"the",
"BatchNorm",
"layers",
"in",
"a",
"model",
"to",
"use",
"regular",
"BatchNorm",
"layers."
] | def sync_batchnorm_2_batchnorm(module, dim=2):
if dim == 1:
bn = torch.nn.BatchNorm1d
elif dim == 2:
bn = torch.nn.BatchNorm2d
elif dim == 3:
bn = torch.nn.BatchNorm3d
else:
raise NotImplementedError()
module_output = module
if isinstance(module, torch.nn.SyncBatc... | ['def', 'sync_batchnorm_2_batchnorm(module,', 'dim=2):', 'if', 'dim', '==', '1:', 'bn', '=', 'torch.nn.BatchNorm1d', 'elif', 'dim', '==', '2:', 'bn', '=', 'torch.nn.BatchNorm2d', 'elif', 'dim', '==', '3:', 'bn', '=', 'torch.nn.BatchNorm3d', 'else:', 'raise', 'NotImplementedError()', 'module_output', '=', 'module', 'if'... | 917,968 |
openvinotoolkit/training_extensions | utils.py | numpy_2_list | numpy_2_list | Converts NumPy arrays to Python lists. | [
"Converts",
"NumPy",
"arrays",
"to",
"Python",
"lists."
] | def numpy_2_list(data):
if isinstance(data, np.ndarray):
return data.tolist()
if isinstance(data, MutableMapping):
for (key, value) in data.items():
data[key] = numpy_2_list(value)
elif isinstance(data, (list, tuple)):
data_ = []
for value in data:
dat... | ['def', 'numpy_2_list(data):', 'if', 'isinstance(data,', 'np.ndarray):', 'return', 'data.tolist()', 'if', 'isinstance(data,', 'MutableMapping):', 'for', '(key,', 'value)', 'in', 'data.items():', 'data[key]', '=', 'numpy_2_list(value)', 'elif', 'isinstance(data,', '(list,', 'tuple)):', 'data_', '=', '[]', 'for', 'value'... | 917,969 |
openvinotoolkit/training_extensions | patches.py | nncf_trace_wrapper | nncf_trace_wrapper | A wrapper function to trace in NNCF. | [
"A",
"wrapper",
"function",
"to",
"trace",
"in",
"NNCF."
] | def nncf_trace_wrapper(self, fn, *args, **kwargs):
with nncf_trace():
return fn(*args, **kwargs) | ['def', 'nncf_trace_wrapper(self,', 'fn,', '*args,', '**kwargs):', 'with', 'nncf_trace():', 'return', 'fn(*args,', '**kwargs)'] | 917,975 |
openvinotoolkit/training_extensions | utils.py | nullcontext | nullcontext | Context which does nothing. | [
"Context",
"which",
"does",
"nothing."
] | def nullcontext():
yield | ['def', 'nullcontext():', 'yield'] | 917,977 |
openvinotoolkit/training_extensions | utils.py | no_nncf_trace | no_nncf_trace | Wrapper for original NNCF no_nncf_trace context. | [
"Wrapper",
"for",
"original",
"NNCF",
"no_nncf_trace",
"context."
] | def no_nncf_trace():
if is_nncf_enabled():
from nncf.torch.dynamic_graph.context import no_nncf_trace as original_no_nncf_trace
return original_no_nncf_trace()
return nullcontext() | ['def', 'no_nncf_trace():', 'if', 'is_nncf_enabled():', 'from', 'nncf.torch.dynamic_graph.context', 'import', 'no_nncf_trace', 'as', 'original_no_nncf_trace', 'return', 'original_no_nncf_trace()', 'return', 'nullcontext()'] | 917,978 |
openvinotoolkit/training_extensions | configuration_enums.py | InputSizePreset.parse | parse | Parse string value to tuple. | [
"Parse",
"string",
"value",
"to",
"tuple."
] | def parse(value: str) -> Optional[Tuple[int, int]]:
if value == 'Default':
return None
if value == 'Auto':
return (0, 0)
parsed_tocken = re.match('(\\d+)x(\\d+)', value)
if parsed_tocken is None:
return None
return (int(parsed_tocken.group(1)), int(parsed_tocken.group(2))) | ['def', 'parse(value:', 'str)', '->', 'Optional[Tuple[int,', 'int]]:', 'if', 'value', '==', "'Default':", 'return', 'None', 'if', 'value', '==', "'Auto':", 'return', '(0,', '0)', 'parsed_tocken', '=', "re.match('(\\\\d+)x(\\\\d+)',", 'value)', 'if', 'parsed_tocken', 'is', 'None:', 'return', 'None', 'return', '(int(pars... | 917,984 |
openvinotoolkit/training_extensions | configuration_enums.py | InputSizePreset.input_sizes | input_sizes | Returns list of actual size tuples. | [
"Returns",
"list",
"of",
"actual",
"size",
"tuples."
] | def input_sizes(cls):
return [e.tuple for e in cls if e.value[0].isdigit()] | ['def', 'input_sizes(cls):', 'return', '[e.tuple', 'for', 'e', 'in', 'cls', 'if', 'e.value[0].isdigit()]'] | 917,985 |
openvinotoolkit/training_extensions | base_task.py | OTXTask.train | train | Train function for OTX task. | [
"Train",
"function",
"for",
"OTX",
"task."
] | def train(self, dataset: DatasetEntity, output_model: ModelEntity, train_parameters: Optional[TrainParameters]=None, seed: Optional[int]=None, deterministic: bool=False):
raise NotImplementedError | ['def', 'train(self,', 'dataset:', 'DatasetEntity,', 'output_model:', 'ModelEntity,', 'train_parameters:', 'Optional[TrainParameters]=None,', 'seed:', 'Optional[int]=None,', 'deterministic:', 'bool=False):', 'raise', 'NotImplementedError'] | 917,986 |
openvinotoolkit/training_extensions | base_task.py | OTXTask.save_model | save_model | Save best model weights in trining task. | [
"Save",
"best",
"model",
"weights",
"in",
"trining",
"task."
] | def save_model(self, output_model: ModelEntity):
raise NotImplementedError | ['def', 'save_model(self,', 'output_model:', 'ModelEntity):', 'raise', 'NotImplementedError'] | 917,990 |
openvinotoolkit/training_extensions | base_task.py | OTXTask.cancel_hook_initialized | cancel_hook_initialized | Initialization of cancel_interface hook. | [
"Initialization",
"of",
"cancel_interface",
"hook."
] | def cancel_hook_initialized(self, cancel_interface: CancelInterfaceHook):
logger.info('cancel hook is initialized')
self.cancel_interface = cancel_interface
if self.reserved_cancel and self.cancel_interface:
self.cancel_interface.cancel() | ['def', 'cancel_hook_initialized(self,', 'cancel_interface:', 'CancelInterfaceHook):', "logger.info('cancel", 'hook', 'is', "initialized')", 'self.cancel_interface', '=', 'cancel_interface', 'if', 'self.reserved_cancel', 'and', 'self.cancel_interface:', 'self.cancel_interface.cancel()'] | 917,992 |
openvinotoolkit/training_extensions | base_task.py | OTXTask.cleanup | cleanup | Clean up work directory if user specified it. | [
"Clean",
"up",
"work",
"directory",
"if",
"user",
"specified",
"it."
] | def cleanup(self):
if self._work_dir_is_temp:
self._delete_scratch_space() | ['def', 'cleanup(self):', 'if', 'self._work_dir_is_temp:', 'self._delete_scratch_space()'] | 917,993 |
openvinotoolkit/training_extensions | base_task.py | OTXTask.set_seed | set_seed | Set seed and deterministic. | [
"Set",
"seed",
"and",
"deterministic."
] | def set_seed(self):
if self.seed is None:
self.seed = self.config.get('seed', 5)
if not self.deterministic:
self.deterministic = self.config.get('deterministic', False)
self.config['seed'] = self.seed
self.config['deterministic'] = self.deterministic
set_random_seed(self.seed, logger... | ['def', 'set_seed(self):', 'if', 'self.seed', 'is', 'None:', 'self.seed', '=', "self.config.get('seed',", '5)', 'if', 'not', 'self.deterministic:', 'self.deterministic', '=', "self.config.get('deterministic',", 'False)', "self.config['seed']", '=', 'self.seed', "self.config['deterministic']", '=', 'self.deterministic',... | 917,994 |
openvinotoolkit/training_extensions | base_task.py | OTXTask.config | config | Config of OTX task. | [
"Config",
"of",
"OTX",
"task."
] | def config(self):
return self._config | ['def', 'config(self):', 'return', 'self._config'] | 917,995 |
openvinotoolkit/training_extensions | nncf_task.py | NNCFBaseTask.save_model | save_model | Saving model function for NNCF Task. | [
"Saving",
"model",
"function",
"for",
"NNCF",
"Task."
] | def save_model(self, output_model: ModelEntity):
assert self._recipe_cfg is not None
buffer = io.BytesIO()
hyperparams_str = ids_to_strings(cfg_helper.convert(self._hyperparams, dict, enum_to_str=True))
labels = {label.name: label.color.rgb_tuple for label in self._labels}
model_ckpt = torch.load(se... | ['def', 'save_model(self,', 'output_model:', 'ModelEntity):', 'assert', 'self._recipe_cfg', 'is', 'not', 'None', 'buffer', '=', 'io.BytesIO()', 'hyperparams_str', '=', 'ids_to_strings(cfg_helper.convert(self._hyperparams,', 'dict,', 'enum_to_str=True))', 'labels', '=', '{label.name:', 'label.color.rgb_tuple', 'for', 'l... | 917,996 |
openvinotoolkit/training_extensions | callback.py | TrainingProgressCallback.on_epoch_end | on_epoch_end | Callback function on epoch ended. | [
"Callback",
"function",
"on",
"epoch",
"ended."
] | def on_epoch_end(self, epoch, logs=None):
self.past_epoch_duration.append(time.time() - self.start_epoch_time)
progress = (epoch + 1) / self.total_epochs * 100
self._calculate_average_epoch()
score = None
if hasattr(self.update_progress_callback, 'metric') and isinstance(logs, dict):
score =... | ['def', 'on_epoch_end(self,', 'epoch,', 'logs=None):', 'self.past_epoch_duration.append(time.time()', '-', 'self.start_epoch_time)', 'progress', '=', '(epoch', '+', '1)', '/', 'self.total_epochs', '*', '100', 'self._calculate_average_epoch()', 'score', '=', 'None', 'if', 'hasattr(self.update_progress_callback,', "'metr... | 917,998 |
openvinotoolkit/training_extensions | callback.py | InferenceProgressCallback.on_test_batch_end | on_test_batch_end | Callback function on testing batch ended. | [
"Callback",
"function",
"on",
"testing",
"batch",
"ended."
] | def on_test_batch_end(self, batch=None, logs=None):
super().on_test_batch_end(batch, logs)
self.update_progress_callback(int(self.get_progress())) | ['def', 'on_test_batch_end(self,', 'batch=None,', 'logs=None):', 'super().on_test_batch_end(batch,', 'logs)', 'self.update_progress_callback(int(self.get_progress()))'] | 917,999 |
openvinotoolkit/training_extensions | callback.py | OptimizationProgressCallback.on_train_begin | on_train_begin | Callback function when training beginning. | [
"Callback",
"function",
"when",
"training",
"beginning."
] | def on_train_begin(self, logs=None):
super().on_train_begin(logs)
train_percentage = 100 - self.loading_stage_progress_percentage - self.initialization_stage_progress_percentage
loading_stage_steps = self.total_steps * self.loading_stage_progress_percentage / train_percentage
initialization_stage_steps ... | ['def', 'on_train_begin(self,', 'logs=None):', 'super().on_train_begin(logs)', 'train_percentage', '=', '100', '-', 'self.loading_stage_progress_percentage', '-', 'self.initialization_stage_progress_percentage', 'loading_stage_steps', '=', 'self.total_steps', '*', 'self.loading_stage_progress_percentage', '/', 'train_p... | 918,000 |
openvinotoolkit/training_extensions | callback.py | OptimizationProgressCallback.on_train_end | on_train_end | Callback function on training ended. | [
"Callback",
"function",
"on",
"training",
"ended."
] | def on_train_end(self, logs=None):
super().on_train_end(logs)
self.update_progress_callback(self.get_progress(), score=logs) | ['def', 'on_train_end(self,', 'logs=None):', 'super().on_train_end(logs)', 'self.update_progress_callback(self.get_progress(),', 'score=logs)'] | 918,001 |
openvinotoolkit/training_extensions | data.py | get_old_new_img_indices | get_old_new_img_indices | Function for getting old & new indices of dataset. | [
"Function",
"for",
"getting",
"old",
"&",
"new",
"indices",
"of",
"dataset."
] | def get_old_new_img_indices(labels, new_classes, dataset):
(ids_old, ids_new) = ([], [])
_dataset_label_schema_map = {label.name: label for label in labels}
new_classes = [_dataset_label_schema_map[new_class] for new_class in new_classes]
for (i, item) in enumerate(dataset):
if item.annotation_s... | ['def', 'get_old_new_img_indices(labels,', 'new_classes,', 'dataset):', '(ids_old,', 'ids_new)', '=', '([],', '[])', '_dataset_label_schema_map', '=', '{label.name:', 'label', 'for', 'label', 'in', 'labels}', 'new_classes', '=', '[_dataset_label_schema_map[new_class]', 'for', 'new_class', 'in', 'new_classes]', 'for', '... | 918,007 |
openvinotoolkit/training_extensions | data.py | compute_robust_statistics | compute_robust_statistics | Computes robust statistics of given samples. | [
"Computes",
"robust",
"statistics",
"of",
"given",
"samples."
] | def compute_robust_statistics(values: np.array) -> Dict[str, float]:
stat: Dict = {}
if values.size == 0:
return stat
avg_value = np.mean(values)
std_value = np.std(values)
avg_3std_min_value = avg_value - 3 * std_value
avg_3std_max_value = avg_value + 3 * std_value
min_value = np.mi... | ['def', 'compute_robust_statistics(values:', 'np.array)', '->', 'Dict[str,', 'float]:', 'stat:', 'Dict', '=', '{}', 'if', 'values.size', '==', '0:', 'return', 'stat', 'avg_value', '=', 'np.mean(values)', 'std_value', '=', 'np.std(values)', 'avg_3std_min_value', '=', 'avg_value', '-', '3', '*', 'std_value', 'avg_3std_ma... | 918,009 |
openvinotoolkit/training_extensions | dist_utils.py | append_dist_rank_suffix | append_dist_rank_suffix | Append distributed training rank suffix to the file name. | [
"Append",
"distributed",
"training",
"rank",
"suffix",
"to",
"the",
"file",
"name."
] | def append_dist_rank_suffix(file_name: Union[str, Path]) -> str:
if 'LOCAL_RANK' in os.environ:
file_name = Path(file_name)
dist_suffix = f"_proc{os.environ['LOCAL_RANK']}"
file_name = file_name.parent / f'{file_name.stem}{dist_suffix}{file_name.suffix}'
return str(file_name) | ['def', 'append_dist_rank_suffix(file_name:', 'Union[str,', 'Path])', '->', 'str:', 'if', "'LOCAL_RANK'", 'in', 'os.environ:', 'file_name', '=', 'Path(file_name)', 'dist_suffix', '=', 'f"_proc{os.environ[\'LOCAL_RANK\']}"', 'file_name', '=', 'file_name.parent', '/', "f'{file_name.stem}{dist_suffix}{file_name.suffix}'",... | 918,013 |
openvinotoolkit/training_extensions | logger.py | local_master_only | local_master_only | A decorator that allows a function to be executed only by the local master process in distributed training setup. | [
"A",
"decorator",
"that",
"allows",
"a",
"function",
"to",
"be",
"executed",
"only",
"by",
"the",
"local",
"master",
"process",
"in",
"distributed",
"training",
"setup."
] | def local_master_only(func: Callable) -> Callable:
@functools.wraps(func)
def wrapper(*args, **kwargs):
local_rank = 0
if dist.is_available() and dist.is_initialized():
local_rank = int(os.environ['LOCAL_RANK'])
if local_rank == 0:
return func(*args, **kwargs)
... | ['def', 'local_master_only(func:', 'Callable)', '->', 'Callable:', '@functools.wraps(func)', 'def', 'wrapper(*args,', '**kwargs):', 'local_rank', '=', '0', 'if', 'dist.is_available()', 'and', 'dist.is_initialized():', 'local_rank', '=', "int(os.environ['LOCAL_RANK'])", 'if', 'local_rank', '==', '0:', 'return', 'func(*a... | 918,019 |
openvinotoolkit/training_extensions | mask_to_bbox.py | mask2bbox | mask2bbox | Mask to bounding boxes. | [
"Mask",
"to",
"bounding",
"boxes."
] | def mask2bbox(mask) -> List[List[int]]:
bboxes: List[List[int]] = []
mask = mask_to_border(mask)
print(np.unique(mask))
lbl = label(mask)
props = regionprops(lbl)
for prop in props:
x1 = prop.bbox[1]
y1 = prop.bbox[0]
x2 = prop.bbox[3]
y2 = prop.bbox[2]
bb... | ['def', 'mask2bbox(mask)', '->', 'List[List[int]]:', 'bboxes:', 'List[List[int]]', '=', '[]', 'mask', '=', 'mask_to_border(mask)', 'print(np.unique(mask))', 'lbl', '=', 'label(mask)', 'props', '=', 'regionprops(lbl)', 'for', 'prop', 'in', 'props:', 'x1', '=', 'prop.bbox[1]', 'y1', '=', 'prop.bbox[0]', 'x2', '=', 'prop.... | 918,021 |
openvinotoolkit/training_extensions | utils.py | load_template | load_template | Loading model template function. | [
"Loading",
"model",
"template",
"function."
] | def load_template(path):
with open(path, encoding='UTF-8') as f:
template = yaml.safe_load(f)
return template | ['def', 'load_template(path):', 'with', 'open(path,', "encoding='UTF-8')", 'as', 'f:', 'template', '=', 'yaml.safe_load(f)', 'return', 'template'] | 918,030 |
openvinotoolkit/training_extensions | utils.py | get_default_async_reqs_num | get_default_async_reqs_num | Returns a default number of infer request for OV models. | [
"Returns",
"a",
"default",
"number",
"of",
"infer",
"request",
"for",
"OV",
"models."
] | def get_default_async_reqs_num() -> int:
reqs_num = os.cpu_count()
if reqs_num is not None:
reqs_num = max(1, int(reqs_num / 2))
return reqs_num
else:
return 1 | ['def', 'get_default_async_reqs_num()', '->', 'int:', 'reqs_num', '=', 'os.cpu_count()', 'if', 'reqs_num', 'is', 'not', 'None:', 'reqs_num', '=', 'max(1,', 'int(reqs_num', '/', '2))', 'return', 'reqs_num', 'else:', 'return', '1'] | 918,032 |
openvinotoolkit/training_extensions | task.py | OTXDetectionTask.export | export | Export function of OTX Detection Task. | [
"Export",
"function",
"of",
"OTX",
"Detection",
"Task."
] | def export(self, export_type: ExportType, output_model: ModelEntity, precision: ModelPrecision=ModelPrecision.FP32, dump_features: bool=True):
logger.info('Exporting the model')
self._update_model_export_metadata(output_model, export_type, precision, dump_features)
results = self._export_model(precision, ex... | ['def', 'export(self,', 'export_type:', 'ExportType,', 'output_model:', 'ModelEntity,', 'precision:', 'ModelPrecision=ModelPrecision.FP32,', 'dump_features:', 'bool=True):', "logger.info('Exporting", 'the', "model')", 'self._update_model_export_metadata(output_model,', 'export_type,', 'precision,', 'dump_features)', 'r... | 918,036 |
openvinotoolkit/training_extensions | task.py | OTXDetectionTask.evaluate | evaluate | Evaluate function of OTX Detection Task. | [
"Evaluate",
"function",
"of",
"OTX",
"Detection",
"Task."
] | def evaluate(self, output_resultset: ResultSetEntity, evaluation_metric: Optional[str]=None):
logger.info('called evaluate()')
if evaluation_metric is not None:
logger.warning(f'Requested to use {evaluation_metric} metric, but parameter is ignored. Use F-measure instead.')
metric = MetricsHelper.com... | ['def', 'evaluate(self,', 'output_resultset:', 'ResultSetEntity,', 'evaluation_metric:', 'Optional[str]=None):', "logger.info('called", "evaluate()')", 'if', 'evaluation_metric', 'is', 'not', 'None:', "logger.warning(f'Requested", 'to', 'use', '{evaluation_metric}', 'metric,', 'but', 'parameter', 'is', 'ignored.', 'Use... | 918,038 |
openvinotoolkit/training_extensions | task.py | OTXDetectionTask.save_model | save_model | Save best model weights in DetectionTrainTask. | [
"Save",
"best",
"model",
"weights",
"in",
"DetectionTrainTask."
] | def save_model(self, output_model: ModelEntity):
if is_multigpu_child_process():
return
logger.info('called save_model')
buffer = io.BytesIO()
hyperparams_str = ids_to_strings(cfg_helper.convert(self._hyperparams, dict, enum_to_str=True))
labels = {label.name: label.color.rgb_tuple for label... | ['def', 'save_model(self,', 'output_model:', 'ModelEntity):', 'if', 'is_multigpu_child_process():', 'return', "logger.info('called", "save_model')", 'buffer', '=', 'io.BytesIO()', 'hyperparams_str', '=', 'ids_to_strings(cfg_helper.convert(self._hyperparams,', 'dict,', 'enum_to_str=True))', 'labels', '=', '{label.name:'... | 918,039 |
openvinotoolkit/training_extensions | configurer.py | DetectionConfigurer.override_from_hyperparams | override_from_hyperparams | Override config using hyperparameters from OTX cli. | [
"Override",
"config",
"using",
"hyperparameters",
"from",
"OTX",
"cli."
] | def override_from_hyperparams(self, config, hyperparams, **kwargs):
dataset = kwargs.get('train_dataset', None)
super().override_from_hyperparams(config, hyperparams)
patch_tiling(config, hyperparams, dataset) | ['def', 'override_from_hyperparams(self,', 'config,', 'hyperparams,', '**kwargs):', 'dataset', '=', "kwargs.get('train_dataset',", 'None)', 'super().override_from_hyperparams(config,', 'hyperparams)', 'patch_tiling(config,', 'hyperparams,', 'dataset)'] | 918,040 |
openvinotoolkit/training_extensions | configurer.py | DetectionConfigurer.configure_task_data_pipeline | configure_task_data_pipeline | Trying to alter class indices of training data according to model class order. | [
"Trying",
"to",
"alter",
"class",
"indices",
"of",
"training",
"data",
"according",
"to",
"model",
"class",
"order."
] | def configure_task_data_pipeline(self, cfg):
tr_data_cfg = self.get_subset_data_cfg(cfg, 'train')
class_adapt_cfg = dict(type='AdaptClassLabels', src_classes=self.data_classes, dst_classes=self.model_classes)
pipeline_cfg = tr_data_cfg.pipeline
for (i, operation) in enumerate(pipeline_cfg):
if o... | ['def', 'configure_task_data_pipeline(self,', 'cfg):', 'tr_data_cfg', '=', 'self.get_subset_data_cfg(cfg,', "'train')", 'class_adapt_cfg', '=', "dict(type='AdaptClassLabels',", 'src_classes=self.data_classes,', 'dst_classes=self.model_classes)', 'pipeline_cfg', '=', 'tr_data_cfg.pipeline', 'for', '(i,', 'operation)', '... | 918,044 |
openvinotoolkit/training_extensions | configurer.py | DetectionConfigurer.configure_bbox_head | configure_bbox_head | Patch classification loss if there are ignore labels. | [
"Patch",
"classification",
"loss",
"if",
"there",
"are",
"ignore",
"labels."
] | def configure_bbox_head(self, cfg):
if cfg.get('task', 'detection') == 'detection':
bbox_head = cfg.model.bbox_head
else:
bbox_head = cfg.model.roi_head.bbox_head
if cfg.get('ignore', False):
bbox_head.loss_cls = ConfigDict(type='CrossSigmoidFocalLoss', use_sigmoid=True, num_classes=... | ['def', 'configure_bbox_head(self,', 'cfg):', 'if', "cfg.get('task',", "'detection')", '==', "'detection':", 'bbox_head', '=', 'cfg.model.bbox_head', 'else:', 'bbox_head', '=', 'cfg.model.roi_head.bbox_head', 'if', "cfg.get('ignore',", 'False):', 'bbox_head.loss_cls', '=', "ConfigDict(type='CrossSigmoidFocalLoss',", 'u... | 918,046 |
openvinotoolkit/training_extensions | dataset.py | ImageTilingDataset.merge_vectors | merge_vectors | Merge tile-level feature vectors to image-level feature-vector. | [
"Merge",
"tile-level",
"feature",
"vectors",
"to",
"image-level",
"feature-vector."
] | def merge_vectors(self, feature_vectors: List[np.ndarray], dump_vectors: bool) -> Union[np.ndarray, List[None]]:
if dump_vectors:
return self.tile_dataset.merge_vectors(feature_vectors)
else:
return [None] * self.num_samples | ['def', 'merge_vectors(self,', 'feature_vectors:', 'List[np.ndarray],', 'dump_vectors:', 'bool)', '->', 'Union[np.ndarray,', 'List[None]]:', 'if', 'dump_vectors:', 'return', 'self.tile_dataset.merge_vectors(feature_vectors)', 'else:', 'return', '[None]', '*', 'self.num_samples'] | 918,059 |
openvinotoolkit/training_extensions | tiling.py | Tile.gen_single_img | gen_single_img | Add full-size image for inference or training. | [
"Add",
"full-size",
"image",
"for",
"inference",
"or",
"training."
] | def gen_single_img(self, result: Dict, dataset_idx: int) -> Dict:
self.random_select_gt(result, self.max_annotation)
result['full_res_image'] = True
result['tile_box'] = (0, 0, result['img_shape'][1], result['img_shape'][0])
result['dataset_idx'] = dataset_idx
result['original_shape_'] = result['img... | ['def', 'gen_single_img(self,', 'result:', 'Dict,', 'dataset_idx:', 'int)', '->', 'Dict:', 'self.random_select_gt(result,', 'self.max_annotation)', "result['full_res_image']", '=', 'True', "result['tile_box']", '=', '(0,', '0,', "result['img_shape'][1],", "result['img_shape'][0])", "result['dataset_idx']", '=', 'datase... | 918,065 |
openvinotoolkit/training_extensions | tiling.py | Tile.tile_boxes_overlap | tile_boxes_overlap | Compute overlapping ratio over boxes. | [
"Compute",
"overlapping",
"ratio",
"over",
"boxes."
] | def tile_boxes_overlap(self, tile_box: np.ndarray, boxes: np.ndarray) -> np.ndarray:
(x1, y1, x2, y2) = tile_box[0]
match_indices = (boxes[:, 0] > x1) & (boxes[:, 1] > y1) & (boxes[:, 2] < x2) & (boxes[:, 3] < y2)
match_indices = np.argwhere(match_indices == 1).flatten()
return match_indices | ['def', 'tile_boxes_overlap(self,', 'tile_box:', 'np.ndarray,', 'boxes:', 'np.ndarray)', '->', 'np.ndarray:', '(x1,', 'y1,', 'x2,', 'y2)', '=', 'tile_box[0]', 'match_indices', '=', '(boxes[:,', '0]', '>', 'x1)', '&', '(boxes[:,', '1]', '>', 'y1)', '&', '(boxes[:,', '2]', '<', 'x2)', '&', '(boxes[:,', '3]', '<', 'y2)', ... | 918,069 |
openvinotoolkit/training_extensions | tiling.py | Tile.merge | merge | Merge/Aggregate tile-level prediction to image-level prediction. | [
"Merge/Aggregate",
"tile-level",
"prediction",
"to",
"image-level",
"prediction."
] | def merge(self, results: List[List]) -> Union[List[Tuple[np.ndarray, list]], List[np.ndarray]]:
assert len(results) == len(self.tiles)
detection = False
if isinstance(results[0], tuple):
num_classes = len(results[0][0])
dtype = results[0][0][0].dtype
elif isinstance(results[0], list):
... | ['def', 'merge(self,', 'results:', 'List[List])', '->', 'Union[List[Tuple[np.ndarray,', 'list]],', 'List[np.ndarray]]:', 'assert', 'len(results)', '==', 'len(self.tiles)', 'detection', '=', 'False', 'if', 'isinstance(results[0],', 'tuple):', 'num_classes', '=', 'len(results[0][0])', 'dtype', '=', 'results[0][0][0].dtyp... | 918,072 |
openvinotoolkit/training_extensions | tiling.py | Tile.merge_vectors | merge_vectors | Merge tile-level feature vectors to image-level feature vector. | [
"Merge",
"tile-level",
"feature",
"vectors",
"to",
"image-level",
"feature",
"vector."
] | def merge_vectors(self, feature_vectors: List[np.ndarray]) -> np.ndarray:
image_vectors: dict = {}
for (vector, tile) in zip(feature_vectors, self.tiles):
data_idx = tile.get('index', None) if 'index' in tile else tile.get('dataset_idx', None)
if data_idx in image_vectors:
image_vect... | ['def', 'merge_vectors(self,', 'feature_vectors:', 'List[np.ndarray])', '->', 'np.ndarray:', 'image_vectors:', 'dict', '=', '{}', 'for', '(vector,', 'tile)', 'in', 'zip(feature_vectors,', 'self.tiles):', 'data_idx', '=', "tile.get('index',", 'None)', 'if', "'index'", 'in', 'tile', 'else', "tile.get('dataset_idx',", 'No... | 918,074 |
openvinotoolkit/training_extensions | tiling.py | Tile.merge_maps | merge_maps | Merge tile-level saliency maps to image-level saliency map. | [
"Merge",
"tile-level",
"saliency",
"maps",
"to",
"image-level",
"saliency",
"map."
] | def merge_maps(self, saliency_maps: Union[List[List[np.ndarray]], List[np.ndarray]]) -> List:
dtype = None
for map in saliency_maps:
for cl_map in map:
if cl_map is not None and dtype is None:
dtype = cl_map.dtype
(feat_h, feat_w) = cl_map.shape
... | ['def', 'merge_maps(self,', 'saliency_maps:', 'Union[List[List[np.ndarray]],', 'List[np.ndarray]])', '->', 'List:', 'dtype', '=', 'None', 'for', 'map', 'in', 'saliency_maps:', 'for', 'cl_map', 'in', 'map:', 'if', 'cl_map', 'is', 'not', 'None', 'and', 'dtype', 'is', 'None:', 'dtype', '=', 'cl_map.dtype', '(feat_h,', 'fe... | 918,075 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.