code stringlengths 17 6.64M |
|---|
def get_wilds_ood_test_loader(dataset, data_dir, data_fraction=1.0, model_seed=0):
' load out-of-distribution test data and return data loader '
config = get_default_config(dataset, data_fraction=data_fraction)
dataset_kwargs = ({'fold': POVERTY_FOLDS[model_seed]} if (dataset == 'poverty') else {})
fu... |
def get_default_config(dataset, algorithm='ERM', data_fraction=1.0):
config = Namespace(dataset=dataset, algorithm=algorithm, model_kwargs={}, optimizer_kwargs={}, loader_kwargs={}, dataset_kwargs={}, scheduler_kwargs={}, train_transform=None, eval_transform=None, no_group_logging=True, distinct_groups=True, frac... |
def optimize_noise_standard_deviation(model, val_loader, device, lr=0.1, n_epochs=10):
' optimizes the noise standard deviation of a Gaussian regression likelihood on the validation data '
log_sigma_noise = nn.Parameter(torch.zeros(1, device=device))
optimizer = torch.optim.Adam([log_sigma_noise], lr=lr)
... |
class model():
def __init__(self, inputs_shape=None):
tf.reset_default_graph()
self.base_net_t1 = tf.keras.applications.VGG16
self.base_net_t2 = tf.keras.applications.VGG16
self.inputs_t1 = tf.placeholder(dtype=tf.float32, shape=inputs_shape, name='inputs_t1')
self.inputs_... |
def LoadNpy(filename=None):
npy = np.load(file=filename)
image_t1 = npy['image_t1']
image_t1 = (image_t1.astype(np.float32) / np.max(image_t1))
image_t2 = npy['image_t2']
image_t2 = (image_t2.astype(np.float32) / np.max(image_t2))
label_t1 = (npy['label_t1'] - 1)
label_t2 = (npy['label_t2'... |
def extract_label(file_list):
label_t1 = None
label_t2 = None
for file in file_list:
(image_t1, image_t2, temp_label_t1, temp_label_t2) = LoadNpy(file)
if (label_t1 is None):
label_t1 = temp_label_t1
label_t2 = temp_label_t2
else:
label_t1 = np.c... |
class config():
def __init__(self):
arr = (np.array([[0, 0, 205], [65, 105, 225], [135, 206, 235], [0, 139, 69], [0, 216, 0], [238, 154, 73], [163, 124, 2], [255, 38, 38], [205, 38, 38], [139, 26, 26], [255, 231, 186], [48, 48, 48], [179, 151, 143], [186, 85, 211]], dtype=np.float32) / 255)
self.... |
def argparser():
parser = argparse.ArgumentParser()
parser.add_argument('-g', '--gpu', help='gpu device id', default='1')
parser.add_argument('-b', '--batch_size', help='batch size', type=int, default=32)
parser.add_argument('-e', '--epoches', help='max epoches', type=int, default=100)
parser.add_... |
def DecodeH5(h5file=None):
file = h5py.File(name=h5file, mode='r')
data = ((file['image'].value.astype(np.float32) / 255) - 0.5)
label = (file['label'].value.astype(np.int8) - 1)
return (data, label)
|
def LoadNpy(filename=None):
npy = np.load(file=filename)
image_t1 = npy['image_t1']
image_t1 = ((image_t1.astype(np.float32) / np.max(image_t1)) - 0.5)
image_t2 = npy['image_t2']
image_t2 = ((image_t2.astype(np.float32) / np.max(image_t2)) - 0.5)
label_t1 = (npy['label_t1'] - 1)
label_t2 =... |
def Accuracy(pred_t1, pred_t2, label_t1, label_t2):
oa_t1 = metrics.accuracy_score(y_true=label_t1, y_pred=pred_t1)
oa_t2 = metrics.accuracy_score(y_true=label_t2, y_pred=pred_t2)
pred_bi = np.equal(pred_t1, pred_t2).astype(np.int16)
label_bi = np.equal(label_t1, label_t2).astype(np.int16)
oa_bi =... |
class Point():
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return ((str(self.x) + ',') + str(self.y))
|
class Vector():
def __init__(self, pa, pb):
self.x = (int(pb.x) - int(pa.x))
self.y = (int(pb.y) - int(pa.y))
def __str__(self):
return ((str(self.x) + ',') + str(self.y))
|
class Angle():
def __init__(self, va, vb):
self.va = va
self.vb = vb
def theta(self):
theta = math.degrees(math.acos((((self.va.x * self.vb.x) + (self.va.y * self.vb.y)) / (math.hypot(self.va.x, self.va.y) * math.hypot(self.vb.x, self.vb.y)))))
return theta
|
class Distance():
def __init__(self, pa, pb):
self.x = ((int(pb.x) - int(pa.x)) * (int(pb.x) - int(pa.x)))
self.y = ((int(pb.y) - int(pa.y)) * (int(pb.y) - int(pa.y)))
def dist(self):
return ((self.x + self.y) ** 0.5)
|
def checkArg():
if (len(sys.argv) != 2):
print('please give me file')
sys.exit(0)
|
def readFile(filename):
points = []
f = open(filename, 'r')
for line in f.readlines():
line = line.strip(' \t\n\r')
x = line.split(',')[0]
y = line.split(',')[1]
points.append(Point(x, y))
f.close()
return points
|
def getCross(va, vb):
return ((va.x * vb.y) - (va.y * vb.x))
|
def getODI(pa, pb, pc, pd, pe, pf, pg, ph):
va = Vector(pa, pb)
vb = Vector(pc, pd)
vc = Vector(pe, pf)
vd = Vector(pg, ph)
aa = Angle(va, vb).theta()
ab = Angle(vc, vd).theta()
cb = getCross(vc, vd)
if (cb < 0):
ab = (- ab)
return (aa + ab)
|
def getAPDI(pa, pb, pc, pd, pe, pf, pg, ph, pi, pj):
va = Vector(pa, pb)
vb = Vector(pc, pd)
vc = Vector(pe, pf)
vd = Vector(pg, ph)
ve = Vector(pi, pj)
aa = Angle(va, vb).theta()
ab = Angle(vb, vc).theta()
ac = Angle(vd, ve).theta()
cb = getCross(vb, vc)
cc = getCross(vd, ve)
... |
def writeFile(filename, points, ANBtype, SNBtype, SNAtype, ODItype, APDItype, FHItype, FMAtype, mwtype):
f = open(filename, 'w')
for point in points:
f.write((str(point) + '\n'))
f.write((ANBtype + '\n'))
f.write((SNBtype + '\n'))
f.write((SNAtype + '\n'))
f.write((ODItype + '\n'))
... |
def classification(points):
va = Vector(points[1], points[0])
vb = Vector(points[1], points[5])
vc = Vector(points[1], points[0])
vd = Vector(points[1], points[4])
ANBtype = ''
ANB = (Angle(vc, vd).theta() - Angle(va, vb).theta())
if (ANB < 3.2):
ANBtype = '3'
elif (ANB > 5.7):... |
def main():
config = parser.parse_args()
model_ft = models.fusionVGG19(torchvision.models.vgg19_bn(pretrained=True), config).cuda(config.use_gpu)
print('image scale ', config.image_scale)
print('GPU: ', config.use_gpu)
transform_origin = torchvision.transforms.Compose([Rescale(config.image_scale),... |
def train_model(model, dataloaders, criterion, optimizer, config):
since = time.time()
test_epoch = 5
for epoch in range(config.epochs):
train_dev = []
for phase in ['train']:
model.train(True)
running_loss = 0.0
lent = len(dataloaders[phase])
... |
def val(model, dataloaders, criterion, optimizer, config):
since = time.time()
test_dev = []
for phase in ['val']:
model.train(False)
running_loss = 0.0
lent = len(dataloaders[phase])
pbar = tqdm(total=(lent * config.batchSize))
for ide in range(lent):
d... |
def draw_matches(data):
keypoints1 = [cv2.KeyPoint(p[1], p[0], 1) for p in data['keypoints1']]
keypoints2 = [cv2.KeyPoint(p[1], p[0], 1) for p in data['keypoints2']]
inliers = data['inliers'].astype(bool)
matches = np.array(data['matches'])[inliers].tolist()
img1 = (np.concatenate([output['image1'... |
def draw_keypoints(img, corners, color):
keypoints = [cv2.KeyPoint(c[1], c[0], 1) for c in np.stack(corners).T]
return cv2.drawKeypoints(img.astype(np.uint8), keypoints, None, color=color)
|
def draw_keypoints(img, corners, color, radius=3, s=3):
img = np.repeat(cv2.resize(img, None, fx=s, fy=s)[(..., np.newaxis)], 3, (- 1))
for c in np.stack(corners).T:
cv2.circle(img, tuple((s * np.flip(c, 0))), radius, color, thickness=(- 1))
return img
|
def select_top_k(prob, thresh=0, num=300):
pts = np.where((prob > thresh))
idx = np.argsort(prob[pts])[::(- 1)][:num]
pts = (pts[0][idx], pts[1][idx])
return pts
|
def draw_keypoints(img, corners, color):
keypoints = [cv2.KeyPoint(c[1], c[0], 1) for c in np.stack(corners).T]
return cv2.drawKeypoints(img.astype(np.uint8), keypoints, None, color=color)
|
def draw_keypoints(img, corners, color=(0, 255, 0), radius=3, s=3):
img = np.repeat(cv2.resize(img, None, fx=s, fy=s)[(..., np.newaxis)], 3, (- 1))
for c in np.stack(corners).T:
cv2.circle(img, tuple((s * np.flip(c, 0))), radius, color, thickness=(- 1))
return img
|
def draw_keypoints(img, corners, color=(0, 255, 0), radius=3, s=3):
img = np.repeat(cv2.resize(img, None, fx=s, fy=s)[(..., np.newaxis)], 3, (- 1))
for c in np.stack(corners).T:
cv2.circle(img, tuple((s * np.flip(c, 0))), radius, color, thickness=(- 1))
return img
|
def draw_overlay(img, mask, color=[0, 0, 255], op=0.5, s=3):
mask = cv2.resize(mask.astype(np.uint8), None, fx=s, fy=s, interpolation=cv2.INTER_NEAREST)
img[np.where(mask)] = ((img[np.where(mask)] * (1 - op)) + (np.array(color) * op))
|
def display(d):
img = (draw_keypoints((d['image'][(..., 0)] * 255), np.where(d['keypoint_map']), (0, 255, 0)) if add_keypoints else (d['image'][(..., 0)] * 255))
draw_overlay(img, np.logical_not(d['valid_mask']))
return img
|
def draw_keypoints(img, corners, color=(0, 255, 0), radius=3, s=3):
img = np.repeat(cv2.resize(img, None, fx=s, fy=s)[(..., np.newaxis)], 3, (- 1))
for c in np.stack(corners).T:
cv2.circle(img, tuple((s * np.flip(c, 0))), radius, color, thickness=(- 1))
return img
|
def draw_overlay(img, mask, color=[0, 0, 255], op=0.5, s=3):
mask = cv2.resize(mask.astype(np.uint8), None, fx=s, fy=s, interpolation=cv2.INTER_NEAREST)
img[np.where(mask)] = ((img[np.where(mask)] * (1 - op)) + (np.array(color) * op))
|
def display(d):
img = (draw_keypoints((d['image'][(..., 0)] * 255), np.where(d['keypoint_map']), (0, 255, 0)) if add_keypoints else (d['image'][(..., 0)] * 255))
draw_overlay(img, np.logical_not(d['valid_mask']))
return img
|
def draw_keypoints(img, corners, color, radius=4, s=3):
img = np.repeat(cv2.resize(img, None, fx=s, fy=s)[(..., np.newaxis)], 3, (- 1))
for c in np.stack(corners).T:
cv2.circle(img, tuple((s * np.flip(c, 0))), radius, color, thickness=(- 1))
return img
|
def draw_keypoints(img, corners, color):
keypoints = [cv2.KeyPoint(c[1], c[0], 1) for c in np.stack(corners).T]
return cv2.drawKeypoints(img.astype(np.uint8), keypoints, None, color=color)
|
def display(d):
return draw_keypoints((d['image'][(..., 0)] * 255), np.where(d['keypoint_map']), (0, 255, 0))
|
def draw_keypoints(img, corners, color):
keypoints = [cv2.KeyPoint(c[1], c[0], 1) for c in np.stack(corners).T]
return cv2.drawKeypoints(img.astype(np.uint8), keypoints, None, color=color)
|
def draw_overlay(img, mask, color=[0, 0, 255], op=0.5):
img[np.where(mask)] = ((img[np.where(mask)] * (1 - op)) + (np.array(color) * op))
|
def display(d):
img = draw_keypoints((d['image'][(..., 0)] * 255), np.where(d['keypoint_map']), (0, 255, 0))
draw_overlay(img, np.logical_not(d['valid_mask']))
return img
|
def get_dataset(name):
mod = __import__('superpoint.datasets.{}'.format(name), fromlist=[''])
return getattr(mod, _module_to_class(name))
|
def _module_to_class(name):
return ''.join((n.capitalize() for n in name.split('_')))
|
class BaseDataset(metaclass=ABCMeta):
'Base model class.\n\n Arguments:\n config: A dictionary containing the configuration parameters.\n\n Datasets should inherit from this class and implement the following methods:\n `_init_dataset` and `_get_data`.\n Additionally, the following static at... |
class Coco(BaseDataset):
default_config = {'labels': None, 'cache_in_memory': False, 'validation_size': 100, 'truncate': None, 'preprocessing': {'resize': [240, 320]}, 'num_parallel_calls': 10, 'augmentation': {'photometric': {'enable': False, 'primitives': 'all', 'params': {}, 'random_order': True}, 'homographic... |
class Mnist(BaseDataset):
default_config = {'validation_size': 500}
def _init_dataset(self, **config):
return input_data.read_data_sets(os.path.join(DATA_PATH, 'MNIST'), reshape=False, validation_size=config['validation_size'])
def _get_data(self, dataset, split_name, **config):
if (spli... |
class PatchesDataset(BaseDataset):
default_config = {'dataset': 'hpatches', 'alteration': 'all', 'cache_in_memory': False, 'truncate': None, 'preprocessing': {'resize': False}}
def _init_dataset(self, **config):
dataset_folder = ('COCO/patches' if (config['dataset'] == 'coco') else 'HPatches')
... |
class SyntheticShapes(BaseDataset):
default_config = {'primitives': 'all', 'truncate': {}, 'validation_size': (- 1), 'test_size': (- 1), 'on-the-fly': False, 'cache_in_memory': False, 'suffix': None, 'add_augmentation_to_test_set': False, 'num_parallel_calls': 10, 'generation': {'split_sizes': {'training': 10000,... |
def get_evaluation(name):
mod = __import__('evaluations.{}'.format(name), fromlist=[''])
return getattr(mod, _module_to_class(name))
|
def _module_to_class(name):
return ''.join((n.capitalize() for n in name.split('_')))
|
def train(config, n_iter, output_dir, pretrained_dir=None, checkpoint_name='model.ckpt'):
checkpoint_path = os.path.join(output_dir, checkpoint_name)
with _init_graph(config) as net:
if (pretrained_dir is not None):
net.load(pretrained_dir)
try:
net.train(n_iter, output... |
def evaluate(config, output_dir, n_iter=None):
with _init_graph(config) as net:
net.load(output_dir)
results = net.evaluate(config.get('eval_set', 'test'), max_iterations=n_iter)
return results
|
def predict(config, output_dir, n_iter):
pred = []
data = []
with _init_graph(config, with_dataset=True) as (net, dataset):
if net.trainable:
net.load(output_dir)
test_set = dataset.get_test_set()
for _ in range(n_iter):
data.append(next(test_set))
... |
def set_seed(seed):
tf.set_random_seed(seed)
np.random.seed(seed)
|
def get_num_gpus():
return len(os.environ['CUDA_VISIBLE_DEVICES'].split(','))
|
@contextmanager
def _init_graph(config, with_dataset=False):
set_seed(config.get('seed', int.from_bytes(os.urandom(4), byteorder='big')))
n_gpus = get_num_gpus()
logging.info('Number of GPUs detected: {}'.format(n_gpus))
dataset = get_dataset(config['data']['name'])(**config['data'])
model = get_m... |
def _cli_train(config, output_dir, args):
assert ('train_iter' in config)
with open(os.path.join(output_dir, 'config.yml'), 'w') as f:
yaml.dump(config, f, default_flow_style=False)
if (args.pretrained_model is not None):
pretrained_dir = os.path.join(EXPER_PATH, args.pretrained_model)
... |
def _cli_eval(config, output_dir, args):
with open(os.path.join(output_dir, 'config.yml'), 'r') as f:
model_config = yaml.load(f)['model']
model_config.update(config.get('model', {}))
config['model'] = model_config
results = evaluate(config, output_dir, n_iter=config.get('eval_iter'))
logg... |
def _cli_pred(config, args):
raise NotImplementedError
|
def get_model(name):
mod = __import__('superpoint.models.{}'.format(name), fromlist=[''])
return getattr(mod, _module_to_class(name))
|
def _module_to_class(name):
return ''.join((n.capitalize() for n in name.split('_')))
|
def vgg_block(inputs, filters, kernel_size, name, data_format, training=False, batch_normalization=True, kernel_reg=0.0, **params):
with tf.variable_scope(name, reuse=tf.AUTO_REUSE):
x = tfl.conv2d(inputs, filters, kernel_size, name='conv', kernel_regularizer=tf.contrib.layers.l2_regularizer(kernel_reg), ... |
def vgg_backbone(inputs, **config):
params_conv = {'padding': 'SAME', 'data_format': config['data_format'], 'activation': tf.nn.relu, 'batch_normalization': True, 'training': config['training'], 'kernel_reg': config.get('kernel_reg', 0.0)}
params_pool = {'padding': 'SAME', 'data_format': config['data_format']... |
class Mode():
TRAIN = 'train'
EVAL = 'eval'
PRED = 'pred'
|
class BaseModel(metaclass=ABCMeta):
'Base model class.\n\n Arguments:\n data: A dictionary of `tf.data.Dataset` objects, can include the keys\n `"training"`, `"validation"`, and `"test"`.\n n_gpus: An integer, the number of GPUs available.\n data_shape: A dictionary, where the k... |
class MagicPoint(BaseModel):
input_spec = {'image': {'shape': [None, None, None, 1], 'type': tf.float32}}
required_config_keys = []
default_config = {'data_format': 'channels_first', 'kernel_reg': 0.0, 'grid_size': 8, 'detection_threshold': 0.4, 'homography_adaptation': {'num': 0}, 'nms': 0, 'top_k': 0}
... |
class SimpleClassifier(BaseModel):
input_spec = {'image': {'shape': [None, None, None, 1], 'type': tf.float32}}
required_config_keys = []
default_config = {'data_format': 'channels_first'}
def _model(self, inputs, mode, **config):
x = inputs['image']
if (config['data_format'] == 'chan... |
class SuperPoint(BaseModel):
input_spec = {'image': {'shape': [None, None, None, 1], 'type': tf.float32}}
required_config_keys = []
default_config = {'data_format': 'channels_first', 'grid_size': 8, 'detection_threshold': 0.4, 'descriptor_size': 256, 'batch_size': 32, 'learning_rate': 0.001, 'lambda_d': 2... |
class Bitset(Sequence):
'\n A very simple bitset implementation for Python.\n\n Author: Geremy Condra\n Licensed under GPLv3\n Released 3 May 2009\n\n Usage:\n >>> b = Bitset(5)\n >>> b\n Bitset(101)\n >>> b[:]\n [True, False, True]\n >>... |
def flush():
'Try to flush all stdio buffers, both from python and from C.'
try:
sys.stdout.flush()
sys.stderr.flush()
except (AttributeError, ValueError, IOError):
pass
|
@contextmanager
def capture_outputs(filename):
'Duplicate stdout and stderr to a file on the file descriptor level.'
with open(filename, 'a+') as target:
original_stdout_fd = 1
original_stderr_fd = 2
target_fd = target.fileno()
saved_stdout_fd = os.dup(original_stdout_fd)
... |
def dict_update(d, u):
'Improved update for nested dictionaries.\n\n Arguments:\n d: The dictionary to be updated.\n u: The update dictionary.\n\n Returns:\n The updated dictionary.\n '
for (k, v) in u.items():
if isinstance(v, collections.abc.Mapping):
d[k] =... |
def main():
config = parser.parse_args()
fine_LSTM = MyModel.fine_LSTM(config).cuda(config.use_gpu)
coarseNet = MyModel.coarseNet(config).cuda(config.use_gpu)
if (config.stage == 'test'):
fine_LSTM = torch.load(((('output/' + '730') + config.testName) + 'fine_LSTM.pkl'), map_location=(lambda s... |
@add_arg_scope
def gate_conv(x_in, cnum, ksize, stride=1, rate=1, name='conv', padding='SAME', activation='leaky_relu', use_lrn=True, training=True):
assert (padding in ['SYMMETRIC', 'SAME', 'REFELECT'])
if ((padding == 'SYMMETRIC') or (padding == 'REFELECT')):
p = int(((rate * (ksize - 1)) / 2))
... |
@add_arg_scope
def gate_deconv(input_, output_shape, k_h=5, k_w=5, d_h=2, d_w=2, stddev=0.02, name='deconv', training=True):
with tf.variable_scope(name):
w = tf.get_variable('w', [k_h, k_w, output_shape[(- 1)], input_.get_shape()[(- 1)]], initializer=tf.random_normal_initializer(stddev=stddev))
d... |
class GraphicsScene(QGraphicsScene):
def __init__(self, mode_list, parent=None):
QGraphicsScene.__init__(self, parent)
self.modes = mode_list
self.mouse_clicked = False
self.prev_pt = None
self.mask_points = []
self.sketch_points = []
self.stroke_points = [... |
class Ui_Form(object):
def setupUi(self, Form):
Form.setObjectName('Form')
Form.resize(1200, 660)
self.pushButton = QtWidgets.QPushButton(Form)
self.pushButton.setGeometry(QtCore.QRect(10, 10, 97, 27))
self.pushButton.setObjectName('pushButton')
self.pushButton_2 =... |
class Config(object):
def __init__(self, filename=None):
assert os.path.exists(filename), "ERROR: Config File doesn't exist."
try:
with open(filename, 'r') as f:
self._cfg_dict = yaml.load(f)
except EnvironmentError:
logger.error('Please check the f... |
def main():
'\n Code for launching the downstream training\n '
parser = argparse.ArgumentParser(description='arg parser')
parser.add_argument('--cfg_file', type=str, default='config/semseg_nuscenes.yaml', help='specify the config for training')
parser.add_argument('--resume_path', type=str, defa... |
class DownstreamDataModule(pl.LightningDataModule):
'\n The equivalent of a DataLoader for pytorch lightning.\n '
def __init__(self, config):
super().__init__()
self.config = config
self.batch_size = (config['batch_size'] // config['num_gpus'])
self.num_workers = max((co... |
def load_state_with_same_shape(model, weights):
'\n Load common weights in two similar models\n (for instance between a pretraining and a downstream training)\n '
model_state = model.state_dict()
if list(weights.keys())[0].startswith('model.'):
weights = {k.partition('model.')[2]: weights... |
def make_model(config, load_path=None):
'\n Build the points model according to what is in the config\n '
assert (not config['normalize_features']), "You shouldn't normalize features for the downstream task"
model = MinkUNet(3, config['model_n_out'], config)
if load_path:
print('Training... |
def main():
'\n Code for launching the downstream evaluation\n '
parser = argparse.ArgumentParser(description='arg parser')
parser.add_argument('--cfg_file', type=str, default=None, help='specify the config for training')
parser.add_argument('--resume_path', type=str, default=None, help='provide... |
def build_backbone(cfg):
'Build backbone.'
return BACKBONES.build(cfg)
|
def build_neck(cfg):
'Build neck.'
return NECKS.build(cfg)
|
def build_head(cfg):
'Build head.'
return HEADS.build(cfg)
|
def build_loss(cfg):
'Build loss.'
return LOSSES.build(cfg)
|
def build_segmentor(cfg, train_cfg=None, test_cfg=None):
'Build segmentor.'
if ((train_cfg is not None) or (test_cfg is not None)):
warnings.warn('train_cfg and test_cfg is deprecated, please specify them in model', UserWarning)
assert ((cfg.get('train_cfg') is None) or (train_cfg is None)), 'trai... |
class ClipFeatureExtractor(nn.Module):
'\n DINO Vision Transformer Feature Extractor.\n '
def __init__(self, config, preprocessing=None):
super(ClipFeatureExtractor, self).__init__()
(self.encoder, preprocess) = clip.load('ViT-B/32', device='cuda')
for param in self.encoder.para... |
class NormType(Enum):
BATCH_NORM = 0
SPARSE_LAYER_NORM = 1
SPARSE_INSTANCE_NORM = 2
SPARSE_SWITCH_NORM = 3
|
def get_norm(norm_type, n_channels, D, bn_momentum=0.1):
if (norm_type == NormType.BATCH_NORM):
return ME.MinkowskiBatchNorm(n_channels, momentum=bn_momentum)
elif (norm_type == NormType.SPARSE_INSTANCE_NORM):
return ME.MinkowskiInstanceNorm(n_channels, D=D)
else:
raise ValueError(... |
class ConvType(Enum):
'\n Define the kernel region type\n '
HYPERCUBE = (0, 'HYPERCUBE')
SPATIAL_HYPERCUBE = (1, 'SPATIAL_HYPERCUBE')
SPATIO_TEMPORAL_HYPERCUBE = (2, 'SPATIO_TEMPORAL_HYPERCUBE')
HYPERCROSS = (3, 'HYPERCROSS')
SPATIAL_HYPERCROSS = (4, 'SPATIAL_HYPERCROSS')
SPATIO_TEMP... |
def convert_conv_type(conv_type, kernel_size, D):
assert isinstance(conv_type, ConvType), 'conv_type must be of ConvType'
region_type = conv_to_region_type[conv_type]
axis_types = None
if (conv_type == ConvType.SPATIAL_HYPERCUBE):
if isinstance(kernel_size, collections.Sequence):
k... |
def conv(in_planes, out_planes, kernel_size, stride=1, dilation=1, bias=False, conv_type=ConvType.HYPERCUBE, D=(- 1)):
assert (D > 0), 'Dimension must be a positive integer'
(region_type, axis_types, kernel_size) = convert_conv_type(conv_type, kernel_size, D)
kernel_generator = ME.KernelGenerator(kernel_s... |
def conv_tr(in_planes, out_planes, kernel_size, upsample_stride=1, dilation=1, bias=False, conv_type=ConvType.HYPERCUBE, D=(- 1)):
assert (D > 0), 'Dimension must be a positive integer'
(region_type, axis_types, kernel_size) = convert_conv_type(conv_type, kernel_size, D)
kernel_generator = ME.KernelGenera... |
def sum_pool(kernel_size, stride=1, dilation=1, conv_type=ConvType.HYPERCUBE, D=(- 1)):
assert (D > 0), 'Dimension must be a positive integer'
(region_type, axis_types, kernel_size) = convert_conv_type(conv_type, kernel_size, D)
kernel_generator = ME.KernelGenerator(kernel_size, stride, dilation, region_t... |
class BasicBlockBase(nn.Module):
expansion = 1
NORM_TYPE = NormType.BATCH_NORM
def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None, conv_type=ConvType.HYPERCUBE, bn_momentum=0.1, D=3):
super(BasicBlockBase, self).__init__()
self.conv1 = conv(inplanes, planes, kernel... |
class BasicBlock(BasicBlockBase):
NORM_TYPE = NormType.BATCH_NORM
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.