code stringlengths 17 6.64M |
|---|
class AverageMeter(object):
'Computes and stores the average and current value'
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += (val... |
def accuracy(output, target, topk=(1,)):
'Computes the precision@k for the specified values of k'
with torch.no_grad():
maxk = max(topk)
batch_size = target.size(0)
(_, pred) = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, (- 1)).expa... |
def get_a_var(obj):
if isinstance(obj, torch.Tensor):
return obj
if (isinstance(obj, list) or isinstance(obj, tuple)):
for result in map(get_a_var, obj):
if isinstance(result, torch.Tensor):
return result
if isinstance(obj, dict):
for result in map(get_a... |
def parallel_apply(fct, model, inputs, device_ids):
modules = nn.parallel.replicate(model, device_ids)
assert (len(modules) == len(inputs))
lock = threading.Lock()
results = {}
grad_enabled = torch.is_grad_enabled()
def _worker(i, module, input):
torch.set_grad_enabled(grad_enabled)
... |
def get_logger(filename=None):
logger = logging.getLogger('logger')
logger.setLevel(logging.DEBUG)
logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', level=logging.INFO)
if (filename is not None):
handler = logging.FileHandler(filename)
... |
def get_args(description='Video-Text as Game Players: Hierarchical Banzhaf Interaction for Cross-Modal Representation Learning'):
parser = argparse.ArgumentParser(description=description)
parser.add_argument('--do_train', type=int, default=0, help='Whether to run training.')
parser.add_argument('--do_eval... |
def set_seed_logger(args):
global logger
random.seed(args.seed)
os.environ['PYTHONHASHSEED'] = str(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
torch.backends.cudnn.benchmark = False
torch.... |
def build_model(args):
model = HBI(args)
if args.init_model:
if (not exists(args.init_model)):
raise FileNotFoundError
model_state_dict = torch.load(args.init_model, map_location='cpu')
model.load_state_dict(model_state_dict, strict=False)
model.to(args.device)
retu... |
def build_dataloader(args):
tokenizer = ClipTokenizer()
assert (args.datatype in DATALOADER_DICT)
assert ((DATALOADER_DICT[args.datatype]['test'] is not None) or (DATALOADER_DICT[args.datatype]['val'] is not None))
(test_dataloader, test_length) = (None, 0)
if (DATALOADER_DICT[args.datatype]['test... |
def prep_optimizer(args, model, num_train_optimization_steps, local_rank):
if hasattr(model, 'module'):
model = model.module
lr = args.lr
coef_lr = args.coef_lr
weight_decay = args.weight_decay
warmup_proportion = args.warmup_proportion
param_optimizer = list(model.named_parameters())
... |
def save_model(epoch, args, model, type_name=''):
model_to_save = (model.module.banzhafteacher if hasattr(model, 'module') else model.banzhafteacher)
output_model_file = join(args.output_dir, 'pytorch_model.bin.{}{}'.format(('' if (type_name == '') else (type_name + '.')), epoch))
torch.save(model_to_save... |
def reduce_loss(loss, args):
world_size = args.world_size
if (world_size < 2):
return loss
with torch.no_grad():
torch.distributed.reduce(loss, dst=0)
if (torch.distributed.get_rank() == 0):
loss /= world_size
return loss
|
def train_epoch(epoch, args, model, train_dataloader, device, n_gpu, optimizer, scheduler, global_step, max_steps, val_dataloader):
global logger
global best_score
global meters
torch.cuda.empty_cache()
model.train()
log_step = args.n_display
total_loss = 0
end = time.time()
logit_... |
def main():
global logger
global best_score
global meters
meters = MetricLogger(delimiter=' ')
args = get_args()
if (not exists(args.output_dir)):
os.makedirs(args.output_dir, exist_ok=True)
logger = setup_logger('tvr', args.output_dir, args.local_rank)
args = set_seed_logger(... |
def get_args(description='Video-Text as Game Players: Hierarchical Banzhaf Interaction for Cross-Modal Representation Learning'):
parser = argparse.ArgumentParser(description=description)
parser.add_argument('--do_pretrain', action='store_true', help='Whether to run training.')
parser.add_argument('--do_t... |
def set_seed_logger(args):
global logger
random.seed(args.seed)
os.environ['PYTHONHASHSEED'] = str(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
torch.backends.cudnn.benchmark = False
torch.... |
def init_device(args, local_rank):
global logger
device = torch.device(('cuda' if torch.cuda.is_available() else 'cpu'), local_rank)
n_gpu = torch.cuda.device_count()
logger.info('device: {} n_gpu: {}'.format(device, n_gpu))
args.n_gpu = n_gpu
if (((args.batch_size % args.n_gpu) != 0) or ((arg... |
def init_model(args, device, n_gpu, local_rank):
if args.init_model:
model_state_dict = torch.load(args.init_model, map_location='cpu')
else:
model_state_dict = None
cache_dir = (args.cache_dir if args.cache_dir else os.path.join(str(PYTORCH_PRETRAINED_BERT_CACHE), 'distributed'))
mode... |
def prep_optimizer(args, model, num_train_optimization_steps, device, n_gpu, local_rank, coef_lr=1.0):
if hasattr(model, 'module'):
model = model.module
param_optimizer = list(model.named_parameters())
no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']
decay_param_tp = [(n, p) for (n, p... |
def dataloader_msrvtt_train(args, tokenizer):
msrvtt_dataset = MSRVTT_TrainDataLoader(jsonl_path=args.train_csv, ans2label_path=args.data_path, features_path=args.features_path, max_words=args.max_words, feature_framerate=args.feature_framerate, tokenizer=tokenizer, max_frames=args.max_frames, unfold_sentences=ar... |
def dataloader_msrvtt_test(args, tokenizer):
msrvtt_testset = MSRVTT_DataLoader(jsonl_path=args.val_csv, train_jsonl=args.train_csv, ans2label_path=args.data_path, features_path=args.features_path, max_words=args.max_words, feature_framerate=args.feature_framerate, tokenizer=tokenizer, max_frames=args.max_frames,... |
def save_model(epoch, args, model, type_name=''):
model_to_save = (model.module if hasattr(model, 'module') else model)
output_model_file = os.path.join(args.output_dir, 'pytorch_model.bin.{}{}'.format(('' if (type_name == '') else (type_name + '.')), epoch))
torch.save(model_to_save.state_dict(), output_... |
def load_model(epoch, args, n_gpu, device, model_file=None):
if ((model_file is None) or (len(model_file) == 0)):
model_file = os.path.join(args.output_dir, 'pytorch_model.bin.{}'.format(epoch))
if os.path.exists(model_file):
model_state_dict = torch.load(model_file, map_location='cpu')
... |
def train_epoch(epoch, args, model, train_dataloader, device, n_gpu, optimizer, scheduler, global_step, local_rank=0, tokenizer=ClipTokenizer()):
global logger
torch.cuda.empty_cache()
model.train()
log_step = args.n_display
start_time = time.time()
total_loss = 0
for (step, batch) in enum... |
def eval_epoch(args, model, test_dataloader, device, n_gpu):
top1 = AverageMeter()
top5 = AverageMeter()
if hasattr(model, 'module'):
model = model.module.to(device)
else:
model = model.to(device)
model.eval()
with torch.no_grad():
for (bid, batch) in enumerate(test_dat... |
def main():
global logger
args = get_args()
args = set_seed_logger(args)
(device, n_gpu) = init_device(args, args.local_rank)
tokenizer = ClipTokenizer()
assert (args.task_type == 'retrieval')
args.num_labels = 1500
model = init_model(args, device, n_gpu, args.local_rank)
assert ((... |
def compress(paras):
(input_video_path, output_video_path) = paras
try:
command = ['ffmpeg', '-y', '-i', input_video_path, '-filter:v', "scale='if(gt(a,1),trunc(oh*a/2)*2,224)':'if(gt(a,1),224,trunc(ow*a/2)*2)'", '-map', '0:v', '-r', '3', output_video_path]
ffmpeg = subprocess.Popen(command, s... |
def prepare_input_output_pairs(input_root, output_root):
input_video_path_list = []
output_video_path_list = []
for (root, dirs, files) in os.walk(input_root):
for file_name in files:
input_video_path = os.path.join(root, file_name)
output_video_path = os.path.join(output_r... |
class QuadKey():
@precondition((lambda c, key: valid_key(key)))
def __init__(self, key):
'\n A quadkey must be between 1 and 23 digits and can only contain digit[0-3]\n '
self.key = key
self.level = len(key)
def children(self):
if (self.level >= 23):
... |
def from_geo(geo, level):
'\n Constucts a quadkey representation from geo and level\n geo => (lat, lon)\n If lat or lon are outside of bounds, they will be clipped\n If level is outside of bounds, an AssertionError is raised\n\n '
pixel = TileSystem.geo_to_pixel(geo, level)
tile = TileSyste... |
def from_tile(tile, level):
return QuadKey(TileSystem.tile_to_quadkey(tile, level))
|
def from_str(qk_str):
return QuadKey(qk_str)
|
def geo_to_dict(geo):
" Take a geo tuple and return a labeled dict\n (lat, lon) -> {'lat': lat, 'lon', lon}\n "
return {LAT_STR: geo[0], LON_STR: geo[1]}
|
def valid_level(level):
LEVEL_RANGE = (1, 23)
return (LEVEL_RANGE[0] <= level <= LEVEL_RANGE[1])
|
@precondition((lambda key: valid_level(len(key))))
def valid_key(key):
return (TileSystem.KEY_PATTERN.match(key) is not None)
|
class TileSystem():
'\n Class with static method to build quadkeys from lat, lon, levels\n see http://msdn.microsoft.com/en-us/library/bb259689.aspx\n '
import re
KEY_PATTERN = re.compile('^[0-3]+$')
EARTH_RADIUS = 6378137
LATITUDE_RANGE = ((- 85.05112878), 85.05112878)
LONGITUDE_RANG... |
def condition(precondition=None, postcondition=None):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
if (precondition is not None):
assert precondition(*args, **kwargs)
retval = func(*args, **kwargs)
if (postcondition... |
def precondition(check):
return condition(precondition=check)
|
def postcondition(check):
return condition(postcondition=check)
|
def run():
unittest.main()
|
class QuadkeyTest(TestCase):
def testInit(self):
qk = quadkey.from_str('0321201120')
with self.assertRaises(AssertionError):
qk = quadkey.from_str('')
with self.assertRaises(AssertionError):
qk = quadkey.from_str('0156510012')
def testFromGeo(self):
ge... |
class TileSystemTest(TestCase):
def testClip(self):
self.assertEqual(1, TileSystem.clip(0, (1, 5)))
self.assertEqual(5, TileSystem.clip(10, (1, 5)))
self.assertEqual(3, TileSystem.clip(3, (1, 5)))
with self.assertRaises(AssertionError):
TileSystem.clip(7, (5, 1))
... |
class UtilTest(TestCase):
def testPrecondition(self):
self.assertTrue(self.pre(True))
with self.assertRaises(AssertionError):
self.pre(False)
def testPostcondition(self):
pass
@precondition((lambda c, x: (x is True)))
def pre(self, x):
return x
|
def makeOsmFileName(fileNumber):
return os.path.join('anomaly', 'reviewed_{:02d}.osm'.format(fileNumber))
|
def saveOsmData(query):
result = api.query(query)
for way in result.ways:
featureDirectoryName = way.tags.get('sport')
outputDirectoryName = os.path.join(cfg.rootOsmDir, featureDirectoryName)
if (os.path.exists(outputDirectoryName) == False):
os.makedirs(outputDirectoryName... |
def _find_getch():
try:
import termios
except ImportError:
import msvcrt
return msvcrt.getch
import sys, tty
def _getch():
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(fd)
ch = sys.stdin.read(1)
... |
def find_in_path(name, path):
'Find a file in a search path'
for _dir in path.split(os.pathsep):
binpath = os.path.join(_dir, name)
if os.path.exists(binpath):
return os.path.abspath(binpath)
return None
|
def get_cuda_sm_list(cuda_ver):
if ('CUDA_SM_LIST' in os.environ):
sm_list = os.environ['CUDA_SM_LIST'].split(',')
else:
sm_list = ['30', '52', '60', '61', '70', '75', '80', '86']
if (cuda_ver >= 110):
filter_list = ['30']
if (cuda_ver == 110):
f... |
def get_cuda_compute(cuda_ver):
if ('CUDA_COMPUTE' in os.environ):
compute = os.environ['CUDA_COMPUTE']
else:
if (70 <= cuda_ver < 80):
compute = '52'
if (80 <= cuda_ver < 90):
compute = '61'
if (90 <= cuda_ver < 100):
compute = '70'
... |
def get_cuda_arch(cuda_ver):
if ('CUDA_ARCH' in os.environ):
arch = os.environ['CUDA_ARCH']
else:
if (70 <= cuda_ver < 92):
arch = '30'
if (92 <= cuda_ver < 110):
arch = '50'
if (cuda_ver == 110):
arch = '52'
if (cuda_ver == 111):
... |
def locate_cuda():
"Locate the CUDA environment on the system\n If a valid cuda installation is found\n this returns a dict with keys 'home', 'nvcc', 'include',\n and 'lib64' and values giving the absolute path to each directory.\n Starts by looking for the CUDAHOME env variable.\n If not found, everything i... |
class _UnixCCompiler(unixccompiler.UnixCCompiler):
src_extensions = list(unixccompiler.UnixCCompiler.src_extensions)
src_extensions.append('.cu')
def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
if (os.path.splitext(src)[1] != '.cu'):
return unixccompiler.UnixCComp... |
class _MSVCCompiler(msvccompiler.MSVCCompiler):
_cu_extensions = ['.cu']
src_extensions = list(unixccompiler.UnixCCompiler.src_extensions)
src_extensions.extend(_cu_extensions)
def _compile_cu(self, sources, output_dir=None, macros=None, include_dirs=None, debug=0, extra_preargs=None, extra_postargs=... |
class CudaBuildExt(setuptools_build_ext):
'Custom `build_ext` command to include CUDA C source files.'
def run(self):
if (CUDA is not None):
def wrap_new_compiler(func):
def _wrap_new_compiler(*args, **kwargs):
try:
return func... |
def get_logger(name=__file__, level=2):
if (level == 1):
level = logging.WARNING
elif (level == 2):
level = logging.INFO
elif (level == 3):
level = logging.DEBUG
logger = logging.getLogger(name)
if logger.handlers:
return logger
logger.setLevel(level)
sh0 = ... |
def load_json_string(cont):
cont = jsmin.jsmin(cont)
cont = re.sub(',[ \t\r\n]*}', '}', cont)
cont = re.sub((',[ \t\r\n]*' + '\\]'), ']', cont)
return json.loads(cont)
|
def load_json_file(fname):
with open(fname, 'r') as fin:
ret = load_json_string(fin.read())
return ret
|
def get_opt_as_proto(raw, proto_type=ConfigProto):
proto = proto_type()
Parse(json.dumps(Option(raw)), proto)
err = []
assert proto.IsInitialized(err), f'''some required fields are missing in proto {err}
{proto}'''
return proto
|
def proto_to_dict(proto):
return MessageToDict(proto, including_default_value_fields=True, preserving_proto_field_name=True)
|
def copy_proto(proto):
newproto = type(proto)()
Parse(json.dumps(proto_to_dict(proto)), newproto)
return newproto
|
class Option(dict):
def __init__(self, *args, **kwargs):
args = [(arg if isinstance(arg, dict) else load_json_file(arg)) for arg in args]
super().__init__(*args, **kwargs)
for arg in args:
if isinstance(arg, dict):
for (k, val) in arg.items():
... |
def get_extend_compile_flags():
flags = ['-march=native']
return flags
|
class CMakeExtension(Extension):
extension_type = 'cmake'
def __init__(self, name):
super().__init__(name, sources=[])
|
def git_version():
def _minimal_ext_cmd(cmd):
env = {}
for k in ['SYSTEMROOT', 'PATH']:
val = os.environ.get(k)
if (val is not None):
env[k] = val
out = subprocess.Popen(cmd, stdout=subprocess.PIPE, env=env).communicate()[0]
return out
t... |
def write_version_py(filename='cuhnsw/version.py'):
cnt = "\nshort_version = '%(version)s'\ngit_revision = '%(git_revision)s'\n"
git_revision = git_version()
with open(filename, 'w') as fout:
fout.write((cnt % {'version': VERSION, 'git_revision': git_revision}))
|
class BuildExtension(BUILDEXT):
def run(self):
for ext in self.extensions:
print(ext.name)
if (hasattr(ext, 'extension_type') and (ext.extension_type == 'cmake')):
self.cmake()
super().run()
def cmake(self):
cwd = pathlib.Path().absolute()
... |
def setup_package():
write_version_py()
cmdclass = {'build_ext': BuildExtension}
metadata = dict(name='cuhnsw', maintainer='Jisang Yoon', maintainer_email='vjs10101v@gmail.com', author='Jisang Yoon', author_email='vjs10101v@gmail.com', description=DOCLINES[0], long_description='\n'.join(DOCLINES[2:]), url... |
class VOCSegGroupLoader(mx.io.DataIter):
def __init__(self, image_root, label_root, annotation_root, data_list, batch_size, group_size, num_block, target_size, pad=False, shuffle=False, rand_scale=False, rand_mirror=False, rand_crop=False, downsample=None):
assert (group_size >= 2), "'group_size': # comm... |
def resnet101_largefov_SA(x, num_cls, is_downsample=True, in_embed_type='conv', out_embed_type='convbn', sim_type='dot', use_global_stats_backbone=False, use_global_stats_affinity=False, lr_mult=10, reuse=None, **kwargs):
x_raw = _Resnet(x, (3, 4, 23, 3), (64, 256, 512, 1024, 2048), True, use_global_stats=use_glo... |
def resnet101_largefov_CA(x, num_cls, is_downsample=True, in_embed_type='conv', out_embed_type='convbn', sim_type='dot', group_size=2, merge_type='max', merge_self=True, use_global_stats_backbone=False, use_global_stats_affinity=False, lr_mult=10, reuse=None):
x_raw = _Resnet(x, (3, 4, 23, 3), (64, 256, 512, 1024... |
def resnet50_largefov_SA(x, num_cls, is_downsample=True, in_embed_type='conv', out_embed_type='convbn', sim_type='dot', use_global_stats_backbone=False, use_global_stats_affinity=False, lr_mult=10, reuse=None, **kwargs):
x_raw = _Resnet(x, (3, 4, 6, 3), (64, 256, 512, 1024, 2048), True, use_global_stats=use_globa... |
def resnet50_largefov_CA(x, num_cls, is_downsample=True, in_embed_type='conv', out_embed_type='convbn', sim_type='dot', group_size=2, merge_type='max', merge_self=True, use_global_stats_backbone=False, use_global_stats_affinity=False, lr_mult=10, reuse=None):
x_raw = _Resnet(x, (3, 4, 6, 3), (64, 256, 512, 1024, ... |
def in_embedding_conv(x_feat, num_filter_hidden, is_downsample=True, lr_mult=1, reuse=None):
x_query = Conv(x_feat, num_filter_hidden, (1, 1), no_bias=True, name='conv_embed_q', lr_mult=lr_mult, reuse=reuse)
x_key = Conv(x_feat, num_filter_hidden, (1, 1), no_bias=True, name='conv_embed_k', lr_mult=lr_mult, re... |
def out_embedding_convbn(x_res, num_filter_out, use_global_stats=False, lr_mult=1, reuse=None):
x_res = Conv(x_res, num_filter_out, (1, 1), no_bias=True, name='conv_out', lr_mult=lr_mult, reuse=reuse)
x_res = BN(x_res, fix_gamma=False, use_global_stats=use_global_stats, name='bn_out', lr_mult=lr_mult, reuse=r... |
def compute_sim_mat(x_key, x_query, sim_type):
if (sim_type == 'dot'):
sim_mat = mx.sym.batch_dot(x_key, x_query, transpose_a=True)
elif (sim_type == 'cosine'):
x_key_norm = mx.sym.L2Normalization(x_key, mode='channel')
x_query_norm = mx.sym.L2Normalization(x_query, mode='channel')
... |
def build_self_affinity(x_feat, num_filter_hidden, num_filter_out, is_downsample=True, in_embed_type='conv', out_embed_type='convbn', sim_type='dot', use_global_stats=False, lr_mult=1, reuse=None, return_internals=False):
get_embedding_in = eval(('in_embedding_' + in_embed_type))
get_embedding_out = eval(('ou... |
def build_cross_affinity(x_feat, num_filter_hidden, num_filter_out, is_downsample=True, in_embed_type='conv', out_embed_type='convbn', sim_type='dot', group_size=2, merge_type='max', merge_self=True, use_global_stats=False, lr_mult=1, reuse=None):
get_embedding_in = eval(('in_embedding_' + in_embed_type))
get... |
def Convolution(data, num_filter, kernel, stride=None, dilate=None, pad=None, num_group=1, no_bias=False, weight=None, bias=None, name=None, lr_mult=1, reuse=None, **kwargs):
if (reuse is not None):
assert (name is not None)
name = (GetLayerName.get('conv') if (name is None) else name)
stride = ((... |
def Deconvolution(data, num_filter, kernel, stride=None, dilate=None, pad=None, adj=None, target_shape=None, num_group=1, no_bias=False, weight=None, bias=None, name=None, lr_mult=1, reuse=None):
if (reuse is not None):
assert (name is not None)
name = (GetLayerName.get('deconv') if (name is None) els... |
def FullyConnected(data, num_hidden, flatten=True, no_bias=False, weight=None, bias=None, name=None, lr_mult=1, reuse=None):
if (reuse is not None):
assert (name is not None)
name = (GetLayerName.get('fc') if (name is None) else name)
W = (get_variable((name + '_weight'), lr_mult, reuse) if (weigh... |
def Relu(data, name=None):
name = (GetLayerName.get('relu') if (name is None) else name)
x = mx.sym.Activation(data, act_type='relu', name=name)
return x
|
def LeakyRelu(data, slope=0.25, name=None):
name = (GetLayerName.get('leakyRelu') if (name is None) else name)
x = mx.sym.LeakyReLU(data, slope=slope, act_type='leaky', name=name)
return x
|
def Tanh(data, name=None):
name = (GetLayerName.get('tanh') if (name is None) else name)
x = mx.sym.tanh(data, name=name)
return x
|
def Swish(data, name=None):
name = (GetLayerName.get('swish') if (name is None) else name)
x = (data * mx.sym.sigmoid(data))
return x
|
def Pooling(data, kernel, stride=None, pad=None, pool_type='max', global_pool=False, name=None):
name = (GetLayerName.get('pool') if (name is None) else name)
stride = (kernel if (stride is None) else stride)
pad = (((0,) * len(kernel)) if (pad is None) else pad)
x = mx.sym.Pooling(data, kernel=kernel... |
def Dropout(data, p, name=None):
name = (GetLayerName.get('drop') if (name is None) else name)
x = mx.sym.Dropout(data, p=p, name=name)
return x
|
def BatchNorm(data, fix_gamma=False, momentum=0.9, eps=1e-05, use_global_stats=False, gamma=None, beta=None, moving_mean=None, moving_var=None, name=None, lr_mult=1, reuse=None):
if (reuse is not None):
assert (name is not None)
name = (GetLayerName.get('bn') if (name is None) else name)
gamma = (... |
def InstanceNorm(data, eps=1e-05, gamma=None, beta=None, name=None, lr_mult=1, reuse=None):
if (reuse is not None):
assert (name is not None)
name = (GetLayerName.get('in') if (name is None) else name)
gamma = (get_variable((name + '_gamma'), lr_mult, reuse) if (gamma is None) else gamma)
beta... |
def Flatten(data, name=None):
name = (GetLayerName.get('flatten') if (name is None) else name)
x = mx.sym.flatten(data, name=name)
return x
|
def ConvRelu(*args, **kwargs):
x = Conv(*args, **kwargs)
x = Relu(x, (x.name + '_relu'))
return x
|
def BNRelu(*args, **kwargs):
x = BN(*args, **kwargs)
x = Relu(x, (x.name + '_relu'))
return x
|
def FCRelu(*args, **kwargs):
x = FC(*args, **kwargs)
x = Relu(x, (x.name + '_relu'))
return x
|
def ConvBNRelu(*args, **kwargs):
x = Conv(*args, **kwargs)
x = BN(x, name=(x.name + '_bn'), lr_mult=kwargs.get('lr_mult', 1), reuse=kwargs.get('reuse', None))
x = Relu(x, (x.name + '_relu'))
return x
|
def get_variable(name, lr_mult=1, reuse=None):
if (reuse is None):
return mx.sym.Variable(name, lr_mult=lr_mult)
return reuse.get_internals()[name]
|
class GetLayerName(object):
_name_count = {}
@classmethod
def get(cls, name_prefix):
cnt = cls._name_count.get(name_prefix, 0)
cls._name_count[name_prefix] = (cnt + 1)
return (name_prefix + str(cnt))
|
def padding_helper(in_size, kernel_size, stride, pad_type='same'):
pad_type = pad_type.lower()
if (pad_type == 'same'):
out_size = ((in_size // stride) + int(((in_size % stride) > 0)))
pad_size = max(((((out_size - 1) * stride) + kernel_size) - in_size), 0)
return ((pad_size // 2), (pa... |
class OpConstant(mx.operator.CustomOp):
def __init__(self, val):
self.val = val
def forward(self, is_train, req, in_data, out_data, aux):
self.assign(out_data[0], req[0], self.val)
def backward(self, req, out_grad, in_data, out_data, in_grad, aux):
pass
|
@mx.operator.register('Constant')
class OpConstantProp(mx.operator.CustomOpProp):
def __init__(self, val_str, shape_str, type_str='float32'):
super(OpConstantProp, self).__init__(need_top_grad=False)
val = [float(x) for x in val_str.split(',')]
shape = [int(x) for x in shape_str.split(','... |
def CustomConstantEncoder(value, dtype='float32'):
if (not isinstance(value, np.ndarray)):
if (not isinstance(value, (list, tuple))):
value = [value]
value = np.array(value, dtype=dtype)
return (','.join([str(x) for x in value.ravel()]), ','.join([str(x) for x in value.shape]))
|
def Constant(value, dtype='float32'):
assert isinstance(dtype, str), dtype
(val, shape) = CustomConstantEncoder(value, dtype)
return mx.sym.Custom(val_str=val, shape_str=shape, type_str=dtype, op_type='Constant')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.