code stringlengths 17 6.64M |
|---|
def _split_channels(num_chan, num_groups):
split = [(num_chan // num_groups) for _ in range(num_groups)]
split[0] += (num_chan - sum(split))
return split
|
class MixedConv(ModuleList):
' Mixed Grouped Convolution\n\n Based on MDConv and GroupedConv in MixNet impl:\n https://github.com/tensorflow/tpu/blob/master/models/official/mnasnet/mixnet/custom_layers.py\n '
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding='', dilati... |
class _BatchNorm(Module):
'Applies a batch normalization on different ranks of an input tensor.\n\n The module follows the operation described in Algorithm 1 of\n `Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift\n <https://arxiv.org/abs/1502.03167>`_.\n '
... |
class BatchNorm1d(_BatchNorm):
'Applies a 1D batch normalization on a 3D-input batch of shape (N,C,L).\n\n The module follows the operation described in Algorithm 1 of\n `Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift\n <https://arxiv.org/abs/1502.03167>`_.\n... |
class BatchNorm2d(_BatchNorm):
'Applies a 2D batch normalization on a 4D-input batch of shape (N,C,H,W).\n\n The module follows the operation described in Algorithm 1 of\n `Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift\n <https://arxiv.org/abs/1502.03167>`_.... |
def to_tuple(v: Union[(Tuple[(Number, ...)], Number, Iterable)], n: int):
'Converts input to tuple.'
if isinstance(v, tuple):
return v
elif isinstance(v, Number):
return ((v,) * n)
else:
return tuple(v)
|
def validate(args):
rng = jax.random.PRNGKey(0)
(model, variables) = create_model(args.model, pretrained=True, rng=rng)
print(f'Created {args.model} model. Validating...')
if args.no_jit:
eval_step = (lambda images, labels: eval_forward(model, variables, images, labels))
else:
eval... |
def eval_forward(model, variables, images, labels):
logits = model.apply(variables, images, mutable=False, training=False)
(top1_count, top5_count) = correct_topk(logits, labels, topk=(1, 5))
return (top1_count, top5_count)
|
def main():
args = parser.parse_args()
print(('JAX host: %d / %d' % (jax.host_id(), jax.host_count())))
print(('JAX devices:\n%s' % '\n'.join((str(d) for d in jax.devices()))), flush=True)
jax.config.enable_omnistaging()
def _try_validate(args):
res = None
batch_size = args.batch_... |
def validate(args):
model = create_model(args.model, pretrained=True)
print(f'Created {args.model} model. Validating...')
eval_step = objax.Jit((lambda images, labels: eval_forward(model, images, labels)), model.vars())
dataset = create_dataset('imagenet', args.data)
data_config = resolve_data_con... |
def eval_forward(model, images, labels):
logits = model(images, training=False)
(top1_count, top5_count) = correct_topk(logits, labels, topk=(1, 5))
return (top1_count, top5_count)
|
def main():
args = parser.parse_args()
print(('JAX host: %d / %d' % (jax.host_id(), jax.host_count())))
print(('JAX devices:\n%s' % '\n'.join((str(d) for d in jax.devices()))), flush=True)
def _try_validate(args):
res = None
batch_size = args.batch_size
while (res is None):
... |
@flax.struct.dataclass
class TrainState():
step: int
variables: flax.core.FrozenDict[(str, Any)]
dynamic_scale: flax.optim.DynamicScale
opt_tx: optax.GradientTransformation = flax.struct.field(pytree_node=False)
opt_state: optax.OptState
ema: EmaState
|
def config_to_opt_args(config: ml_collections.ConfigDict):
opt_kwargs = dict(eps=config.get('opt_eps'), decay=config.get('opt_decay'), momentum=config.get('opt_momentum'), beta1=config.get('opt_beta1'), beta2=config.get('opt_beta2'), weight_decay=config.get('opt_weight_decay', 0))
opt_kwargs = {k: v for (k, v... |
def create_train_state(config: ml_collections.ConfigDict, variables, lr_fn):
'Create initial training state.'
params = variables['params']
dynamic_scale = None
platform = jax.local_devices()[0].platform
if (config.half_precision and (platform == 'gpu')):
dynamic_scale = flax.optim.DynamicS... |
def restore_checkpoint(state, model_dir):
return checkpoints.restore_checkpoint(model_dir, state)
|
def save_checkpoint(state, model_dir):
if (jax.host_id() == 0):
state = jax.device_get(jax.tree_map((lambda x: x[0]), state))
step = int(state.step)
checkpoints.save_checkpoint(model_dir, state, step, keep=3)
|
def compute_metrics(logits, labels, label_smoothing=0.0):
loss = cross_entropy_loss(logits, labels, label_smoothing=label_smoothing)
(top1, top5) = acc_topk(logits, labels, (1, 5))
metrics = {'loss': loss, 'top1': top1, 'top5': top5}
metrics = lax.pmean(metrics, axis_name='batch')
return metrics
|
def train_step(apply_fn, state: TrainState, batch, lr_fn, label_smoothing=0.1, weight_decay=0.0001, dropout_rng=None):
'Perform a single training step.'
def loss_fn(_params):
'loss function used for training.'
(_logits, _new_model_state) = apply_fn(state.variables.copy({'params': _params}), b... |
def eval_step(apply_fn, state, batch):
logits = apply_fn(state.variables, batch['image'], training=False, mutable=False)
return compute_metrics(logits, batch['label'])
|
def eval_step_ema(apply_fn, state, batch):
logits = apply_fn(state.ema.variables, batch['image'], training=False, mutable=False)
return compute_metrics(logits, batch['label'])
|
def prepare_tf_data(xs):
'Convert a input batch from tf Tensors to numpy arrays.'
local_device_count = jax.local_device_count()
def _prepare(x):
x = x._numpy()
return x.reshape(((local_device_count, (- 1)) + x.shape[1:]))
return jax.tree_map(_prepare, xs)
|
def create_input_iter(dataset_builder, batch_size, train, image_size, augment_name=None, randaug_num_layers=None, randaug_magnitude=None, half_precision=False, cache=False):
ds = input_pipeline.create_split(dataset_builder, batch_size, train=train, image_size=image_size, augment_name=augment_name, randaug_num_lay... |
def sync_batch_stats(state):
'Sync the batch statistics across replicas.'
avg = jax.pmap((lambda x: lax.pmean(x, 'x')), 'x')
new_variables = state.variables.copy({'batch_stats': avg(state.variables['batch_stats'])})
if (state.ema is not None):
new_ema_variables = state.ema.variables.copy({'bat... |
def train_and_evaluate(config: ml_collections.ConfigDict, resume: str):
'Execute model training and evaluation loop.\n\n Args:\n config: Hyperparameter configuration for training and evaluation.\n resume: Resume from checkpoints at specified dir if set (TDDO: support specific checkpoint file/step)\n ... |
def main(argv):
if (len(argv) > 1):
raise app.UsageError('Too many command-line arguments.')
print(('JAX host: %d / %d' % (jax.host_id(), jax.host_count())))
print(('JAX devices:\n%s' % '\n'.join((str(d) for d in jax.devices()))), flush=True)
train_and_evaluate(config=FLAGS.config, resume=FLAG... |
def validate(args):
rng = jax.random.PRNGKey(0)
platform = jax.local_devices()[0].platform
if args.half_precision:
if (platform == 'tpu'):
model_dtype = jax.numpy.bfloat16
else:
model_dtype = jax.numpy.float16
else:
model_dtype = jax.numpy.float32
(m... |
def prepare_tf_data(xs):
def _prepare(x):
x = x._numpy()
return x
return jax.tree_map(_prepare, xs)
|
def create_eval_iter(data_dir, batch_size, image_size, dataset_name='imagenet2012:5.0.0', half_precision=False, mean=None, std=None, interpolation='bicubic'):
dataset_builder = tfds.builder(dataset_name, data_dir=data_dir)
assert ((dataset_builder.info.splits['validation'].num_examples % batch_size) == 0)
... |
def eval_forward(apply_fn, variables, images, labels):
logits = apply_fn(variables, images, mutable=False, training=False)
(top1_count, top5_count) = correct_topk(logits, labels, topk=(1, 5))
return (top1_count, top5_count)
|
def main():
args = parser.parse_args()
print(('JAX host: %d / %d' % (jax.host_id(), jax.host_count())))
print(('JAX devices:\n%s' % '\n'.join((str(d) for d in jax.devices()))), flush=True)
if (get_model_cfg(args.model) is not None):
validate(args)
else:
models = list_models(pretrai... |
def validate(args):
model = create_model(args.model, pretrained=True)
print(f'Created {args.model} model. Validating...')
eval_step = objax.Jit((lambda images, labels: eval_forward(model, images, labels)), model.vars())
'Runs evaluation and returns top-1 accuracy.'
image_size = model.default_cfg['... |
def eval_forward(model, images, labels):
logits = model(images, training=False)
(top1_count, top5_count) = correct_topk(logits, labels, topk=(1, 5))
return (top1_count, top5_count)
|
def main():
args = parser.parse_args()
logging.set_verbosity(logging.ERROR)
print(('JAX host: %d / %d' % (jax.host_id(), jax.host_count())))
print(('JAX devices:\n%s' % '\n'.join((str(d) for d in jax.devices()))), flush=True)
if (get_model_cfg(args.model) is not None):
validate(args)
e... |
def get_config():
'Get the default hyperparameter configuration.'
config = ml_collections.ConfigDict()
config.output_base_dir = ''
config.data_dir = '/data/'
config.dataset = 'imagenet2012:5.0.0'
config.num_classes = 1000
config.model = 'tf_efficientnet_b0'
config.image_size = 0
co... |
def get_config():
config = default_lib.get_config()
config.model = 'pt_efficientnet_b3'
config.batch_size = 2048
config.eval_batch_size = 1000
config.ema_decay = 0.9999
config.num_epochs = 550
config.drop_rate = 0.3
return config
|
def get_config():
config = default_lib.get_config()
config.batch_size = 500
return config
|
def checkpoint_metric(checkpoint_path):
if ((not checkpoint_path) or (not os.path.isfile(checkpoint_path))):
return {}
print("=> Extracting metric from checkpoint '{}'".format(checkpoint_path))
checkpoint = torch.load(checkpoint_path, map_location='cpu')
metric = None
if ('metric' in check... |
def main():
args = parser.parse_args()
args.use_ema = (not args.no_use_ema)
args.sort = (not args.no_sort)
if os.path.exists(args.output):
print('Error: Output filename ({}) already exists.'.format(args.output))
exit(1)
pattern = args.input
if ((not args.input.endswith(os.path.... |
def main():
args = parser.parse_args()
if os.path.exists(args.output):
print('Error: Output filename ({}) already exists.'.format(args.output))
exit(1)
if (args.checkpoint and os.path.isfile(args.checkpoint)):
print("=> Loading checkpoint '{}'".format(args.checkpoint))
chec... |
def _post_process(cls_outputs: List[torch.Tensor], box_outputs: List[torch.Tensor], num_levels: int, num_classes: int, max_detection_points: int=5000):
'Selects top-k predictions.\n\n Post-proc code adapted from Tensorflow version at: https://github.com/google/automl/tree/master/efficientdet\n and optimized... |
@torch.jit.script
def _batch_detection(batch_size: int, class_out, box_out, anchor_boxes, indices, classes, img_scale: Optional[torch.Tensor]=None, img_size: Optional[torch.Tensor]=None, max_det_per_image: int=100, soft_nms: bool=False):
batch_detections = []
for i in range(batch_size):
img_scale_i = ... |
class DetBenchPredict(nn.Module):
def __init__(self, model):
super(DetBenchPredict, self).__init__()
self.model = model
self.config = model.config
self.num_levels = model.config.num_levels
self.num_classes = model.config.num_classes
self.anchors = Anchors.from_conf... |
class DetBenchTrain(nn.Module):
def __init__(self, model, create_labeler=True):
super(DetBenchTrain, self).__init__()
self.model = model
self.config = model.config
self.num_levels = model.config.num_levels
self.num_classes = model.config.num_classes
self.anchors = ... |
def unwrap_bench(model):
if hasattr(model, 'module'):
return unwrap_bench(model.module)
elif hasattr(model, 'model'):
return unwrap_bench(model.model)
else:
return model
|
def set_config_readonly(conf):
OmegaConf.set_readonly(conf, True)
|
def set_config_writeable(conf):
OmegaConf.set_readonly(conf, False)
|
def bifpn_config(min_level, max_level, weight_method=None):
'BiFPN config.\n Adapted from https://github.com/google/automl/blob/56815c9986ffd4b508fe1d68508e268d129715c1/efficientdet/keras/fpn_configs.py\n '
p = OmegaConf.create()
weight_method = (weight_method or 'fastattn')
num_levels = ((max_l... |
def panfpn_config(min_level, max_level, weight_method=None):
'PAN FPN config.\n\n This defines FPN layout from Path Aggregation Networks as an alternate to\n BiFPN, it does not implement the full PAN spec.\n\n Paper: https://arxiv.org/abs/1803.01534\n '
p = OmegaConf.create()
weight_method = (... |
def qufpn_config(min_level, max_level, weight_method=None):
'A dynamic quad fpn config that can adapt to different min/max levels.\n\n It extends the idea of BiFPN, and has four paths:\n (up_down -> bottom_up) + (bottom_up -> up_down).\n\n Paper: https://ieeexplore.ieee.org/document/9225379\n Ref ... |
def get_fpn_config(fpn_name, min_level=3, max_level=7):
if (not fpn_name):
fpn_name = 'bifpn_fa'
name_to_config = {'bifpn_sum': bifpn_config(min_level=min_level, max_level=max_level, weight_method='sum'), 'bifpn_attn': bifpn_config(min_level=min_level, max_level=max_level, weight_method='attn'), 'bifp... |
def default_detection_model_configs():
'Returns a default detection configs.'
h = OmegaConf.create()
h.name = 'tf_efficientdet_d1'
h.backbone_name = 'tf_efficientnet_b1'
h.backbone_args = None
h.backbone_indices = None
h.image_size = (640, 640)
h.num_classes = 90
h.min_level = 3
... |
def get_efficientdet_config(model_name='tf_efficientdet_d1'):
'Get the default config for EfficientDet based on model name.'
h = default_detection_model_configs()
h.update(efficientdet_model_param_dict[model_name])
h.num_levels = ((h.max_level - h.min_level) + 1)
h = deepcopy(h)
return h
|
def default_detection_train_config():
h = OmegaConf.create()
h.skip_crowd_during_training = True
h.input_rand_hflip = True
h.train_scale_min = 0.1
h.train_scale_max = 2.0
h.autoaugment_policy = None
h.momentum = 0.9
h.learning_rate = 0.08
h.lr_warmup_init = 0.008
h.lr_warmup_ep... |
class DetectionDatset(data.Dataset):
'`Object Detection Dataset. Use with parsers for COCO, VOC, and OpenImages.\n Args:\n parser (string, Parser):\n transform (callable, optional): A function/transform that takes in an PIL image\n and returns a transformed version. E.g, ``transforms.... |
class SkipSubset(data.Dataset):
'\n Subset of a dataset at specified indices.\n\n Arguments:\n dataset (Dataset): The whole Dataset\n n (int): skip rate (select every nth)\n '
def __init__(self, dataset, n=2):
self.dataset = dataset
assert (n >= 1)
self.indices ... |
@dataclass
class CocoCfg():
variant: str = None
parser: str = 'coco'
num_classes: int = 80
splits: Dict[(str, dict)] = None
|
@dataclass
class Coco2017Cfg(CocoCfg):
variant: str = '2017'
splits: Dict[(str, dict)] = field(default_factory=(lambda : dict(train=dict(ann_filename='annotations/instances_train2017.json', img_dir='train2017', has_labels=True), val=dict(ann_filename='annotations/instances_val2017.json', img_dir='val2017', ha... |
@dataclass
class Coco2014Cfg(CocoCfg):
variant: str = '2014'
splits: Dict[(str, dict)] = field(default_factory=(lambda : dict(train=dict(ann_filename='annotations/instances_train2014.json', img_dir='train2014', has_labels=True), val=dict(ann_filename='annotations/instances_val2014.json', img_dir='val2014', ha... |
@dataclass
class VocCfg():
variant: str = None
parser: str = 'voc'
num_classes: int = 80
img_filename: str = '%s.jpg'
splits: Dict[(str, dict)] = None
|
@dataclass
class Voc2007Cfg(VocCfg):
variant: str = '2007'
splits: Dict[(str, dict)] = field(default_factory=(lambda : dict(train=dict(split_filename='VOC2007/ImageSets/Main/train.txt', ann_filename='VOC2007/Annotations/%s.xml', img_dir='VOC2007/JPEGImages'), val=dict(split_filename='VOC2007/ImageSets/Main/va... |
@dataclass
class Voc2012Cfg(VocCfg):
variant: str = '2012'
splits: Dict[(str, dict)] = field(default_factory=(lambda : dict(train=dict(split_filename='VOC2012/ImageSets/Main/train.txt', ann_filename='VOC2012/Annotations/%s.xml', img_dir='VOC2012/JPEGImages'), val=dict(split_filename='VOC2012/ImageSets/Main/va... |
@dataclass
class Voc0712Cfg(VocCfg):
variant: str = '0712'
splits: Dict[(str, dict)] = field(default_factory=(lambda : dict(train=dict(split_filename=['VOC2007/ImageSets/Main/trainval.txt', 'VOC2012/ImageSets/Main/trainval.txt'], ann_filename=['VOC2007/Annotations/%s.xml', 'VOC2012/Annotations/%s.xml'], img_d... |
@dataclass
class OpenImagesCfg():
variant: str = None
parser: str = 'openimages'
num_classes: int = None
img_filename = '%s.jpg'
splits: Dict[(str, dict)] = None
|
@dataclass
class OpenImagesObjCfg(OpenImagesCfg):
num_classes: int = 601
categories_map: str = 'annotations/class-descriptions-boxable.csv'
|
@dataclass
class OpenImagesSegCfg(OpenImagesCfg):
num_classes: int = 350
categories_map: str = 'annotations/classes-segmentation.txt'
|
@dataclass
class OpenImagesObjV5Cfg(OpenImagesObjCfg):
splits: Dict[(str, dict)] = field(default_factory=(lambda : dict(train=dict(img_dir='train', img_info='annotations/train-info.csv', has_labels=True, prefix_levels=1, ann_bbox='annotations/train-annotations-bbox.csv', ann_img_label='annotations/train-annotatio... |
@dataclass
class OpenImagesObjChallenge2019Cfg(OpenImagesObjCfg):
num_classes: int = 500
categories_map: str = 'annotations/challenge-2019/challenge-2019-classes-description-500.csv'
splits: Dict[(str, dict)] = field(default_factory=(lambda : dict(train=dict(img_dir='train', img_info='annotations/train-in... |
@dataclass
class OpenImagesSegV5Cfg(OpenImagesSegCfg):
num_classes: int = 300
splits: Dict[(str, dict)] = field(default_factory=(lambda : dict(train=dict(), val=dict(), test=dict())))
|
@dataclass
class OpenImagesSegChallenge2019Cfg(OpenImagesSegCfg):
num_classes: int = 300
ann_class_map: str = 'annotations/challenge-2019/challenge-2019-classes-description-segmentable.csv'
splits: Dict[(str, dict)] = field(default_factory=(lambda : dict(train=dict(), val=dict(), test=dict())))
|
def create_dataset(name, root, splits=('train', 'val')):
if isinstance(splits, str):
splits = (splits,)
name = name.lower()
root = Path(root)
dataset_cls = DetectionDatset
datasets = OrderedDict()
if name.startswith('coco'):
if ('coco2014' in name):
dataset_cfg = Co... |
def resolve_input_config(args, model_config=None, model=None):
if (not isinstance(args, dict)):
args = vars(args)
input_config = {}
if ((not model_config) and (model is not None) and hasattr(model, 'config')):
model_config = model.config
in_chans = 3
input_size = (in_chans, 512, 51... |
class Parser():
' Parser base class.\n\n The attributes listed below make up a public interface common to all parsers. They can be accessed directly\n once the dataset is constructed and annotations are populated.\n\n Attributes:\n\n cat_names (list[str]):\n list of category (class) nam... |
class CocoParser(Parser):
def __init__(self, cfg: CocoParserCfg):
super().__init__(bbox_yxyx=cfg.bbox_yxyx, has_labels=cfg.has_labels, include_masks=cfg.include_masks, include_bboxes_ignore=cfg.include_bboxes_ignore, ignore_empty_gt=(cfg.has_labels and cfg.ignore_empty_gt), min_img_size=cfg.min_img_size)... |
@dataclass
class CocoParserCfg():
ann_filename: str
include_masks: bool = False
include_bboxes_ignore: bool = False
has_labels: bool = True
bbox_yxyx: bool = True
min_img_size: int = 32
ignore_empty_gt: bool = False
|
@dataclass
class VocParserCfg():
split_filename: str
ann_filename: str
img_filename: str = '%.jpg'
keep_difficult: bool = True
classes: list = None
add_background: bool = True
has_labels: bool = True
bbox_yxyx: bool = True
min_img_size: int = 32
ignore_empty_gt: bool = False
|
@dataclass
class OpenImagesParserCfg():
categories_filename: str
img_info_filename: str
bbox_filename: str
img_label_filename: str = ''
masks_filename: str = ''
img_filename: str = '%s.jpg'
task: str = 'obj'
prefix_levels: int = 1
add_background: bool = True
has_labels: bool = ... |
def create_parser(name, **kwargs):
if (name == 'coco'):
parser = CocoParser(**kwargs)
elif (name == 'voc'):
parser = VocParser(**kwargs)
elif (name == 'openimages'):
parser = OpenImagesParser(**kwargs)
else:
assert False, f'Unknown dataset parser ({name})'
return pa... |
class VocParser(Parser):
DEFAULT_CLASSES = ('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor')
def __init__(self, cfg: VocParserCfg):
super().__init__(bbox_y... |
def get_world_size() -> int:
if (not dist.is_available()):
return 1
if (not dist.is_initialized()):
return 1
return dist.get_world_size()
|
def get_rank() -> int:
if (not dist.is_available()):
return 0
if (not dist.is_initialized()):
return 0
return dist.get_rank()
|
def get_local_rank() -> int:
'\n Returns:\n The rank of the current process within the local (per-machine) process group.\n '
if (not dist.is_available()):
return 0
if (not dist.is_initialized()):
return 0
assert (_LOCAL_PROCESS_GROUP is not None)
return dist.get_rank(... |
def get_local_size() -> int:
'\n Returns:\n The size of the per-machine process group,\n i.e. the number of processes per machine.\n '
if (not dist.is_available()):
return 1
if (not dist.is_initialized()):
return 1
return dist.get_world_size(group=_LOCAL_PROCESS_GRO... |
def is_main_process() -> bool:
return (get_rank() == 0)
|
def synchronize():
'\n Helper function to synchronize (barrier) among all processes when\n using distributed training\n '
if (not dist.is_available()):
return
if (not dist.is_initialized()):
return
world_size = dist.get_world_size()
if (world_size == 1):
return
... |
@functools.lru_cache()
def _get_global_gloo_group():
'\n Return a process group based on gloo backend, containing all the ranks\n The result is cached.\n '
if (dist.get_backend() == 'nccl'):
return dist.new_group(backend='gloo')
else:
return dist.group.WORLD
|
def _serialize_to_tensor(data, group):
backend = dist.get_backend(group)
assert (backend in ['gloo', 'nccl'])
device = torch.device(('cpu' if (backend == 'gloo') else 'cuda'))
buffer = pickle.dumps(data)
if (len(buffer) > (1024 ** 3)):
logger = logging.getLogger(__name__)
logger.wa... |
def _pad_to_largest_tensor(tensor, group):
'\n Returns:\n list[int]: size of the tensor, on each rank\n Tensor: padded tensor that has the max size\n '
world_size = dist.get_world_size(group=group)
assert (world_size >= 1), 'comm.gather/all_gather must be called from ranks within the g... |
def all_gather(data, group=None):
'\n Run all_gather on arbitrary picklable data (not necessarily tensors).\n Args:\n data: any picklable object\n group: a torch process group. By default, will use a group which\n contains all ranks on gloo backend.\n Returns:\n list[data]... |
def gather(data, dst=0, group=None):
'\n Run gather on arbitrary picklable data (not necessarily tensors).\n Args:\n data: any picklable object\n dst (int): destination rank\n group: a torch process group. By default, will use a group which\n contains all ranks on gloo backen... |
def shared_random_seed():
'\n Returns:\n int: a random number that is the same across all workers.\n If workers need a shared RNG, they can use this shared seed to\n create one.\n All workers must call this function, otherwise it will deadlock.\n '
ints = np.random.randin... |
def reduce_dict(input_dict, average=True):
'\n Reduce the values in the dictionary from all processes so that process with rank\n 0 has the reduced results.\n Args:\n input_dict (dict): inputs to be reduced. All the values must be scalar CUDA Tensor.\n average (bool): whether to do average ... |
def all_gather_container(container, group=None, cat_dim=0):
group = (group or dist.group.WORLD)
world_size = dist.get_world_size(group)
def _do_gather(tensor):
tensor_list = [torch.empty_like(tensor) for _ in range(world_size)]
dist.all_gather(tensor_list, tensor, group=group)
ret... |
def gather_container(container, dst, group=None, cat_dim=0):
group = (group or dist.group.WORLD)
world_size = dist.get_world_size(group)
this_rank = dist.get_rank(group)
def _do_gather(tensor):
if (this_rank == dst):
tensor_list = [torch.empty_like(tensor) for _ in range(world_siz... |
class SequentialList(nn.Sequential):
' This module exists to work around torchscript typing issues list -> list'
def __init__(self, *args):
super(SequentialList, self).__init__(*args)
def forward(self, x: List[torch.Tensor]) -> List[torch.Tensor]:
for module in self:
x = modu... |
class ConvBnAct2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, padding='', bias=False, norm_layer=nn.BatchNorm2d, act_layer=_ACT_LAYER):
super(ConvBnAct2d, self).__init__()
self.conv = create_conv2d(in_channels, out_channels, kernel_size, stride=str... |
class SeparableConv2d(nn.Module):
' Separable Conv\n '
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, dilation=1, padding='', bias=False, channel_multiplier=1.0, pw_kernel_size=1, norm_layer=nn.BatchNorm2d, act_layer=_ACT_LAYER):
super(SeparableConv2d, self).__init__()
... |
class Interpolate2d(nn.Module):
"Resamples a 2d Image\n\n The input data is assumed to be of the form\n `minibatch x channels x [optional depth] x [optional height] x width`.\n Hence, for spatial inputs, we expect a 4D Tensor and for volumetric inputs, we expect a 5D Tensor.\n\n The algorithms availab... |
class ResampleFeatureMap(nn.Sequential):
def __init__(self, in_channels, out_channels, input_size, output_size, pad_type='', downsample=None, upsample=None, norm_layer=nn.BatchNorm2d, apply_bn=False, redundant_bias=False):
super(ResampleFeatureMap, self).__init__()
downsample = (downsample or 'ma... |
class FpnCombine(nn.Module):
def __init__(self, feature_info, fpn_channels, inputs_offsets, output_size, pad_type='', downsample=None, upsample=None, norm_layer=nn.BatchNorm2d, apply_resample_bn=False, redundant_bias=False, weight_method='attn'):
super(FpnCombine, self).__init__()
self.inputs_off... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.