code stringlengths 101 5.91M |
|---|
def gen_config_yaml(manifest_root: Path, spm_filename: str, yaml_filename: str='config.yaml', specaugment_policy: str='lb', prepend_tgt_lang_tag: bool=False, sampling_alpha: float=1.0, audio_root: str=''):
manifest_root = manifest_root.absolute()
writer = S2TDataConfigWriter((manifest_root / yaml_filename))
... |
def simple_inference(model, input):
with torch.no_grad():
if isinstance(input, (dict, UserDict)):
output = model(**input)
elif isinstance(input, (list, tuple)):
try:
output = model(*input)
except:
output = model(input)
else:... |
def CheckSpacingForFunctionCall(filename, clean_lines, linenum, error):
line = clean_lines.elided[linenum]
fncall = line
for pattern in ('\\bif\\s*\\((.*)\\)\\s*{', '\\bfor\\s*\\((.*)\\)\\s*{', '\\bwhile\\s*\\((.*)\\)\\s*[{;]', '\\bswitch\\s*\\((.*)\\)\\s*{'):
match = Search(pattern, line)
i... |
def sparsenet201(**kwargs):
return get_sparsenet(num_layers=201, model_name='sparsenet201', **kwargs) |
def multitask_text_transformer_decoder_arch(args, decoder_layers, decoder_embed_dim=256, decoder_attention_heads=4):
args.decoder_layers = decoder_layers
args.decoder_embed_dim = decoder_embed_dim
args.decoder_attention_heads = decoder_attention_heads
base_multitask_text_transformer_decoder_arch(args) |
def unpack_data(dataB, device='cuda'):
if is_multidata(dataB):
if torch.is_tensor(dataB[0]):
if torch.is_tensor(dataB[1]):
return dataB[0].to(device)
elif is_multidata(dataB[1]):
return (dataB[0].to(device), dataB[1][0].to(device))
else:
... |
def distribute_presets(prefixes, scaffolding, config_updates):
for (path, value) in iterate_flattened(config_updates):
(scaffold_name, suffix) = find_best_match(path, prefixes)
scaff = scaffolding[scaffold_name]
set_by_dotted_path(scaff.presets, suffix, value) |
def config():
seed = 0
test_mode = False
dataset_name = None
hyperparameters = None
evaluation_metric = None
minimize = None
total_trials = None
parameterization = None |
def quaddobl_initialize(nbt, dim, wnd, dir, err):
from phcpy.phcpy2c3 import py2c_numbtrop_quaddobl_initialize as store
flat = []
for vec in dir:
flat = (flat + vec)
data = ((wnd + flat) + err)
store(nbt, dim, str(data)) |
def fix_cam_drop_frames(seq_path, label_names):
ts_path = os.path.join(seq_path, camera_configs['time_stamp_name'])
try:
with open(ts_path) as ts_f:
ts = ts_f.readlines()
except:
return label_names
n_labels = len(ts)
if (int((float(ts[(- 1)].rstrip()) * camera_configs['fr... |
def get_grad_norm(params, scale=1):
total_norm = 0.0
for p in params:
if (p.grad is not None):
param_norm = (p.grad.detach().data / scale).norm(2)
total_norm += (param_norm.item() ** 2)
total_norm = (total_norm ** 0.5)
return total_norm |
def add_packages(config, repeat=1):
train_dir = 'train_package'
package_dir = path.realpath(__file__).replace('pgportfolio/autotrain/generate.pyc', train_dir).replace('pgportfolio\\autotrain\\generate.pyc', train_dir).replace('pgportfolio/autotrain/generate.py', train_dir).replace('pgportfolio\\autotrain\\gener... |
def parse_args():
parser = argparse.ArgumentParser(description='Finetune a transformers model on a text classification task')
parser.add_argument('--dataset_name', type=str, default=None, help='The name of the dataset to use (via the datasets library).')
parser.add_argument('--dataset_config_names', nargs='... |
def calculate_auc(model, mbs_list, shuffle=True):
model.eval()
y_real = []
y_hat = []
if shuffle:
random.shuffle(mbs_list)
for (i, batch) in enumerate(mbs_list):
(output, label_tensor) = model(batch)
y_hat.extend(output.cpu().data.view((- 1)).numpy())
y_real.extend(la... |
def recursive_merge_dicts(*args):
if (not args):
return dict()
q = args[0]
for p in args[1:]:
q = recursive_merge_2dicts(q, p)
return q |
class TestChatCache(unittest.TestCase):
def setUp(self):
return super().setUp()
def tearDown(self) -> None:
if (os.path.exists('./gptcache_data') and os.path.isdir('./gptcache_data')):
try:
shutil.rmtree('./gptcache_data')
print(f'The directory gptcach... |
class Graph():
def __init__(self, parent_map, children_map, id_list):
self.parent_map = parent_map
self.children_map = children_map
self.id_list = id_list
def topoligical_sort(self):
order = []
next = []
for id in self.id_list:
if ((len(self.parent_map... |
def ResNet18(winogradArgs: dict=None, quantArgs: dict=None, miscArgs: dict=None, num_classes: int=10, mult: int=1.0):
return ResNet(BasicBlock, [2, 2, 2, 2], num_classes, winogradArgs=winogradArgs, quantization=quantArgs, miscArgs=miscArgs, multiplier=mult) |
def apply_rotary_pos_emb_single(x, cos, sin, position_ids):
cos = cos.squeeze(1).squeeze(0)
sin = sin.squeeze(1).squeeze(0)
cos = cos[position_ids].unsqueeze(1)
sin = sin[position_ids].unsqueeze(1)
x_embed = ((x * cos) + (rotate_half(x) * sin))
return x_embed |
def discriminator(image, options, n_scale=2, reuse=False, name='discriminator'):
images = []
for i in range(n_scale):
images.append(tf.image.resize_bicubic(image, [(get_shape(image)[1] // (2 ** i)), (get_shape(image)[2] // (2 ** i))]))
with tf.variable_scope(name):
if reuse:
tf.g... |
def label2onehot(label, length):
onehot = np.zeros(length)
onehot[label] = 1
return onehot |
class PseudoLabel():
def __init__(self, cfg):
(h, w) = cfg.INPUT.TARGET_INPUT_SIZE_TRAIN
self.prob_tar = np.zeros([1, h, w])
self.label_tar = np.zeros([1, h, w])
self.thres = []
self.number_class = cfg.MODEL.NUM_CLASSES
self.out_dir = cfg.OUTPUT_DIR
self.iter ... |
def inception_v4(inputs, num_classes=1001, is_training=True, dropout_keep_prob=0.8, reuse=None, scope='InceptionV4', create_aux_logits=True):
end_points = {}
with tf.variable_scope(scope, 'InceptionV4', [inputs], reuse=reuse) as scope:
with slim.arg_scope([slim.batch_norm, slim.dropout], is_training=is_... |
def filter_opt(opt, tag):
ret = {}
for (k, v) in opt.items():
tokens = k.split('.')
if (tokens[0] == tag):
ret['.'.join(tokens[1:])] = v
return ret |
def evaluate_imagenet(gpu, encoder_usage_info, downstream_dataset, encoder, reference_label, trigger, reference, key='clean'):
cmd = f'nohup python3 -u training_downstream_classifier.py --encoder_usage_info {encoder_usage_info} --dataset {downstream_dataset} --trigger_file {trigg... |
def FunctionCorrelation(tenFirst, tenSecond, intStride):
return _FunctionCorrelation.apply(tenFirst, tenSecond, intStride) |
class BasicBlockSig(nn.Module):
def __init__(self, in_channels, out_channels, init='xavier', ksize=3, stride=1, pad=1):
super(BasicBlockSig, self).__init__()
self.body = nn.Sequential(nn.Conv2d(in_channels, out_channels, ksize, stride, pad), nn.Sigmoid())
def forward(self, x):
out = self... |
def ten_problems():
result = []
b0 = ([[3, 6, 7, 8] for _ in range(7)] + [[4, 6, 7, 8] for _ in range(2)])
r0 = 231
result.append((b0, r0))
b1 = ([[2, 5, 6, 8], [3, 6, 7, 8], [4, 5, 7, 8]] + [[4, 6, 7, 8] for _ in range(7)])
r1 = 294
result.append((b1, r1))
b2 = (([[2, 4, 7, 8]] + [[3, 6... |
def calculate_desired_noise_rms(clean_rms, snr):
a = (float(snr) / 20)
noise_rms = (clean_rms / (10 ** a))
return noise_rms |
def save_dataset(train_, test_, filename):
torch.save({'train': train_, 'test': test_}, filename) |
_module
class FastRCNN(TwoStageDetector):
def __init__(self, backbone, bbox_roi_extractor, bbox_head, train_cfg, test_cfg, neck=None, shared_head=None, mask_roi_extractor=None, mask_head=None, pretrained=None):
super(FastRCNN, self).__init__(backbone=backbone, neck=neck, shared_head=shared_head, bbox_roi_ex... |
def remove_email(text):
subtext = text.split(' ')
sts = []
for (i, st) in enumerate(subtext):
st = st.strip()
st = re.sub('([a-zA-Z0-9_.+-]+[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+)', f'', st, flags=re.MULTILINE)
sts.append(st)
return ' '.join(sts) |
def gelu_fast(x):
if (not hasattr(gelu_fast, '_a')):
gelu_fast._a = math.sqrt((2 / math.pi))
return ((0.5 * x) * (1 + torch.tanh((gelu_fast._a * (x + (0.044715 * torch.pow(x, 3))))))) |
def construct_flatindex_from_embeddings(embeddings, ids=None):
dim = embeddings.shape[1]
print(('embedding shape: ' + str(embeddings.shape)))
index = faiss.index_factory(dim, 'Flat', faiss.METRIC_INNER_PRODUCT)
if (ids is not None):
ids = ids.astype(np.int64)
print(ids.shape, ids.dtype)
... |
class ExploreTaskDefinition(AbstractTaskDefinition):
joint_positions = [0.0, (- 1.33), (- 1.8), 0.0, 1.5, 1.6]
def __init__(self, *args, **kwargs):
super(ExploreTaskDefinition, self).__init__(*args, **kwargs)
self.addCamera(Camera('top', [(- 0.0), 0.0, 1.0], distance=0.7, roll=0.0, image_width=6... |
class PyTorchTensor(BaseTensor):
__slots__ = ()
norms: 'NormsMethods[PyTorchTensor]'
def __init__(self, raw: 'torch.Tensor'):
global torch
if (torch is None):
torch = import_module('torch')
super().__init__(raw)
def raw(self) -> 'torch.Tensor':
return cast(tor... |
def init_bias_xavier(model, mode='fan_out', nonlinearity='relu', logger=None):
layers_initialized = 0
a = 0
for m in model.modules():
if isinstance(m, nn.Conv2d):
if (m.bias is not None):
layers_initialized += 1
m.bias.data.normal_(0, (math.sqrt(2) / math.... |
def build_recognizer(cfg, device):
world_size = du.get_world_size()
model = registry.RECOGNIZER[cfg.MODEL.RECOGNIZER.NAME](cfg)
if (cfg.MODEL.NORM.SYNC_BN and (world_size > 1)):
logger.info('start sync BN on the process group of {}'.format(du.LOCAL_RANK_GROUP))
convert_sync_bn(model, du.LOCA... |
def train_cpu(data, label, num_class, list_hidden_nodes, initial_learning_rate, momentum, max_steps, decay_steps, decay_factor, batch_size, train_dir, moving_average_decay=0.9999, summary_steps=500, checkpoint_steps=10000, MLP_trainable=True, save_file='model.ckpt', load_file=None, random_seed=None):
with tf.Graph(... |
def eye_like(A: torch.Tensor) -> torch.Tensor:
return torch.eye(A.shape[(- 1)], dtype=A.dtype, device=A.device).expand_as(A) |
_arg_scope
def stack_blocks_dense(net, blocks, output_stride=None, store_non_strided_activations=False, outputs_collections=None):
current_stride = 1
rate = 1
for block in blocks:
with tf.variable_scope(block.scope, 'block', [net]) as sc:
block_stride = 1
for (i, unit) in enu... |
class RandomForest(IterativeComponentWithSampleWeight, AutotabularClassificationAlgorithm):
def __init__(self, criterion, max_features, max_depth, min_samples_split, min_samples_leaf, min_weight_fraction_leaf, bootstrap, max_leaf_nodes, min_impurity_decrease, random_state=None, n_jobs=1, class_weight=None):
... |
def train(sess_config, input_hooks, model, data_init_op, steps, checkpoint_dir, tf_config=None, server=None):
model.is_training = True
hooks = []
hooks.extend(input_hooks)
scaffold = tf.compat.v1.train.Scaffold(local_init_op=tf.group(tf.compat.v1.local_variables_initializer(), data_init_op), saver=tf.co... |
def log_stats(stats, misc_args):
if hasattr(misc_args, 'epoch'):
lines = ('[%s][%s][Epoch %d][Iter %d / %d]\n' % (misc_args.run_name, misc_args.cfg_filename, misc_args.epoch, misc_args.step, misc_args.iters_per_epoch))
else:
lines = ('[%s][%s][Step %d / %d]\n' % (misc_args.run_name, misc_args.cf... |
def fbeta(y_true, y_pred, beta=1):
from keras import backend as K
if (beta < 0):
raise ValueError('The lowest choosable beta is zero (only precision).')
if (K.sum(K.round(K.clip(y_true, 0, 1))) == 0):
return 0
p = precision(y_true, y_pred)
r = recall(y_true, y_pred)
bb = (beta **... |
def _get_fused_attention(feature1, feature2):
upsample_module = nn.Upsample(size=(224, 224), mode='bilinear')
feat_map1 = feature1.detach().clone()
feat_map2 = feature2.detach().clone()
return ((torch.sigmoid(upsample_module(feat_map1)) + torch.sigmoid(upsample_module(feat_map2))) / 2.0) |
class MobileNetV2Block(nn.Module, ABC):
def __init__(self, in_channels, out_channels, expansion_rate=1, repeat=1, stride=1, padding=1, conv_layer=None, norm_layer=None, act_layer=None):
super(MobileNetV2Block, self).__init__()
features = list()
for i in range(repeat):
if (i != 0)... |
def drop_padding(seq: Sequence[Any], pad_id: Any):
if (pad_id is None):
return seq
return list(reversed(list(dropwhile((lambda x: (x == pad_id)), reversed(seq))))) |
def bidirectional_dynamic_rnn(cell_fw, cell_bw, inputs, sequence_length=None, initial_state_fw=None, initial_state_bw=None, dtype=None, parallel_iterations=None, swap_memory=False, time_major=False, scope=None):
assert (not time_major)
flat_inputs = flatten(inputs, 2)
flat_len = (None if (sequence_length is... |
def get_split(config, split_name, dataset_dir, file_pattern=None, reader=None):
all_file = []
reader = tf.TFRecordReader()
batch_size = config.batch_size
data_splitnum = config.data_split_num
file_pattern = _FILE_PATTERN
if (split_name == 'train'):
num_epochs = None
for i in rang... |
def menet160_8x1_g8(**kwargs):
return get_menet(first_stage_channels=160, side_channels=8, groups=8, model_name='menet160_8x1_g8', **kwargs) |
class RegexpTokenizer(Tokenizer):
DIGIT = '\\p{Nd}+([:\\.\\,]\\p{Nd}+)*'
TITLE = '(dr|esq|hon|jr|mr|mrs|ms|prof|rev|sr|st|rt|messrs|mmes|msgr)\\.(?=\\p{Z})'
ABBRV = '([\\p{L}]\\.){2,}(?=\\p{Z}|$)'
ALPHA_NUM = '[\\p{L}\\p{N}\\p{M}]++'
HYPHEN = '{A}([-\\u058A\\u2010\\u2011]{A})+'.format(A=ALPHA_NUM)
... |
class iSLReLU(nn.Module):
def __init__(self, slope=0.1):
self.alpha = ((1 - slope) / (1 + slope))
super().__init__()
def forward(self, x):
self._last_x = x
y = ((x + (self.alpha * (torch.sqrt((1 + (x * x))) - 1))) / (1 + self.alpha))
return y
def inverse(self, y):
... |
def batch(dataset, batch_size: int, drop_last: bool=False):
def iter_fn():
buffer = []
def _stack(xs):
if isinstance(xs[0], dict):
return {k: _stack([x[k] for x in xs]) for k in xs[0].keys()}
if isinstance(xs[0], (str, bytes)):
return list(xs)
... |
def error_rate(predictions, labels):
assert (len(predictions) == len(labels))
preds = np.argmax(predictions, 1)
orig = np.argmax(labels, 1)
error_rate = (100.0 - ((100.0 * np.sum((preds == orig))) / predictions.shape[0]))
return (preds, orig, error_rate) |
def load_langpair_dataset(data_path, split, src, src_dict, tgt, tgt_dict, combine, dataset_impl, upsample_primary, left_pad_source, left_pad_target, remove_eos_from_source, max_source_positions, max_target_positions, prepend_bos=False, load_alignments=False, truncate_source=False, append_source_id=False, num_buckets=0,... |
def dla169(cfg, pretrained=None, **kwargs):
Bottleneck.expansion = 2
model = DLA(cfg, [1, 1, 2, 3, 5, 1], [16, 32, 128, 256, 512, 1024], block=Bottleneck, residual_root=True, **kwargs)
if (pretrained is not None):
model.load_pretrained_model(pretrained, 'dla169')
return model |
def test_observation_decoder(shape=(3, 64, 64)):
decoder = ObservationDecoder()
batch_size = 2
(c, h, w) = shape
embedding = torch.randn(batch_size, 1024)
with torch.no_grad():
obs_dist: torch.distributions.Normal = decoder(embedding)
obs_sample: torch.Tensor = obs_dist.sample()
asse... |
class ExpLrUpdaterHook(LrUpdaterHook):
def __init__(self, gamma, **kwargs):
self.gamma = gamma
super(ExpLrUpdaterHook, self).__init__(**kwargs)
def get_lr(self, runner, base_lr):
progress = (trainer.epoch if self.by_epoch else trainer.iter)
return (base_lr * (self.gamma ** progre... |
class SydneyCaptions(RSICD):
splits = ['train', 'val', 'test']
def __init__(self, root: str='.data/sydney_captions', split: str='train', transform: T.Compose=T.Compose([T.ToTensor()])):
assert (split in self.splits)
self.root = root
self.transform = transform
self.captions = self... |
def evaluate_metrics(prediction_file: Union[(str, Path, List[Dict[(str, str)]])], reference_file: Union[(str, Path, List[Dict[(str, str)]])], nb_reference_captions: int=5) -> Dict[(str, Dict[(str, Union[(float, Dict[(str, float)])])])]:
prediction_file = check_and_read_csv(prediction_file)
reference_file = chec... |
class IICMeanTeacherTrainer(IICTrainer):
def _init(self):
super()._init()
self._iic_weight = deepcopy(self._reg_weight)
self._teacher_model = deepcopy(self._model)
for param in self._teacher_model.parameters():
param.detach_()
self._teacher_model.train()
c... |
class PreventStuckPlayer(ProxyPlayer):
def __init__(self, player, nr_repeat, action):
super(PreventStuckPlayer, self).__init__(player)
self.act_que = deque(maxlen=nr_repeat)
self.trigger_action = action
def action(self, act):
self.act_que.append(act)
if (self.act_que.coun... |
class Config(collections.MutableMapping):
_instance = None
_store: t.MutableMapping[(str, t.Any)]
_file = Path('config.toml')
_template = Path('config-example.toml')
def get_instance(cls):
if (cls._instance is None):
cls()
return cls._instance
def __init__(self):
... |
def repackage_hidden(h):
if (h is None):
return None
if isinstance(h, list):
return list((repackage_hidden(v) for v in h))
elif isinstance(h, tuple):
return tuple((repackage_hidden(v) for v in h))
return h.detach() |
def load_images(images, curriculum, device):
return_images = []
head = 0
for stage in curriculum['stages']:
stage_images = images[head:(head + stage['batch_size'])]
stage_images = F.interpolate(stage_images, size=stage['img_size'], mode='bilinear', align_corners=True)
return_images.a... |
class KMeans(object):
def __init__(self, num_centers, dtype=np.float32, algorithm='lloyd', initialization='plus_plus', distance='l2', max_iter=100, num_rep=1, verbosity=0):
_check_integer(num_rep, 'num_rep', 1)
_check_integer(verbosity, 'verbosity', 0)
_check_integer(max_iter, 'max_iter', 0)... |
def numpyasarray(np_data):
data = np_data
assert data.flags['C_CONTIGUOUS']
arr = TVMArray()
shape = c_array(tvm_shape_index_t, data.shape)
arr.data = data.ctypes.data_as(ctypes.c_void_p)
arr.shape = shape
arr.strides = None
arr.dtype = TVMType(np.dtype(data.dtype).name)
arr.ndim = d... |
class Seq2SeqLMOutput(ModelOutput):
loss: Optional[torch.FloatTensor] = None
logits: torch.FloatTensor = None
past_key_values: Optional[List[torch.FloatTensor]] = None
decoder_hidden_states: Optional[Tuple[torch.FloatTensor]] = None
decoder_attentions: Optional[Tuple[torch.FloatTensor]] = None
e... |
def horizontal_flow(sublayout_width, sublayout_height, num_row, pref_w_list, pref_h_list, optional_index_weight_dict, fixed_boundary):
num = len(pref_w_list)
result_index = []
row_width = []
row_height = []
i = 0
removed_index_weight_dict = {}
for r in range(num_row):
row_width.appen... |
def test_new_scope_val_depends_on_old():
run_cell('\n class Foo:\n shared = 99\n ')
run_cell('foo = Foo()')
run_cell('foo.shared = 11')
run_cell('foo_shared_alias = foo.shared')
run_cell('Foo.shared = 12')
run_cell('logging.info(foo_shared_alias)')
assert_detected()
... |
def _cast_to_config(obj):
if isinstance(obj, dict):
return DictConfig(obj, flags={'allow_objects': True})
return obj |
class Block(nn.Module):
def __init__(self, dim, num_heads, mlp_ratio=4.0, qkv_bias=False, drop=0.0, drop_path=0.0, act_layer=nn.GELU, norm_layer=nn.LayerNorm, cross=False):
super().__init__()
self.norm1 = norm_layer(dim)
self.attn = Attention(dim, num_heads=num_heads, qkv_bias=qkv_bias, cros... |
def apply_lora(base_model_path, lora_path):
print(f'Loading the base model from {base_model_path}')
base_tokenizer = AutoTokenizer.from_pretrained(base_model_path)
base = AutoModelForCausalLM.from_pretrained(base_model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True)
print(f'Loading the LoRA ada... |
def check_equal(first, second, verbose):
if verbose:
print()
for (i, (x, y)) in enumerate(zip(first, second)):
x = x.cpu().detach().numpy()
y = y.cpu().detach().numpy()
if verbose:
print('x = {}'.format(x.flatten()))
print('y = {}'.format(y.flatten()))
... |
def omniglot():
return itertools.chain(*[collect_download_configs((lambda : datasets.Omniglot(ROOT, background=background, download=True)), name=f"Omniglot, {('background' if background else 'evaluation')}") for background in (True, False)]) |
class TestPlotPDF(unittest.TestCase):
def test_custom_bins(self):
import numpy as np
import powerlaw
import matplotlib.pyplot as plt
data = (1.0 / np.random.power(4.0, 1000))
fit = powerlaw.Fit(data)
plt.figure()
bins = 2
ax = fit.plot_pdf(marker='*', ... |
class TestCrissCrossAttention(object):
def test_cc_attention(self):
device = torch.device(('cuda:0' if torch.cuda.is_available() else 'cpu'))
from mmcv.ops import CrissCrossAttention
loss_func = Loss()
input = np.fromfile('tests/data/for_ccattention/ccattention_input.bin', dtype=np.f... |
def get(config, mode):
exec_config = copy.deepcopy(getattr(config, mode))
for att in list(config.keys()):
if (att not in ['trainor', 'validator', 'ensemblor']):
exec_config[att] = config[att]
return exec_config |
class CustomMetric():
def __init__(self, metric, metric_name, **kwargs):
self.metric = metric
self.metric_name = metric_name
self.kwargs = kwargs
self.scores = []
self.valid_classes = []
self.valid_matrices = []
self.names = []
self.score = None
... |
(argument('id', help='id of instance type to change bid', type=int), argument('--price', help='per machine bid price in $/hour', type=float), usage='vast.py change bid id [--price PRICE]', help='Change the bid price for a spot/interruptible instance', epilog=deindent('\n Change the current bid price of instance ... |
def write_rttm(fn, turns):
with open(fn, 'wb') as f:
turns = sorted(turns, key=(lambda x: (x.fid, float(x.onset), float(x.dur))))
for turn in turns:
line = ' '.join(turn)
f.write(line.encode('utf-8'))
f.write(b'\n') |
class _DilatedResidualBlock(nn.Module):
def __init__(self, in_channels: int, out_channels: int, kernel_size: int, dilation: int, causal: bool=True, norm: Literal[('batch', 'instance', None)]=None, activation: str='GELU', film_conditioning: bool=False, film_embedding_size: Optional[int]=None, film_batch_norm: bool=T... |
def prepare_trainer_collator(model_args, preprocessor: Dict[(str, Any)], collator_kwargs: Dict[(str, Any)]) -> Tuple[(Type[TrainerForMMLLM], Dict[(str, DataCollator)])]:
type_ = model_args.type
trainer_cls = TYPE2TRAINER[type_]
data_collator_func = partial(Seq2Seq2DataCollatorWithImage, preprocessor=preproc... |
def init_weights_normal(m):
classname = m.__class__.__name__
if (classname == 'Conv2d'):
nn.init.normal_(m.weight.data)
nn.init.normal_(m.bias.data) |
def accuracy(model, train_time_data, train_schedule_data, anomaly_data, class_data, model_plotter):
(anomaly_correct, class_correct, class_total) = (0, 0, 0)
(tpl, tnl, fpl, fnl) = ([], [], [], [])
for (i, d) in enumerate(train_time_data):
output = model(train_time_data[i], train_schedule_data[i])
... |
def get_phcfun_fromlib():
if ('linux' in sys.platform):
libphcpack = (LOCATION + '/libPHCpack.so')
phcpack = ctypes.CDLL(libphcpack)
return phcpack._ada_use_c2phc
if ('darwin' in sys.platform):
libphcpack = (LOCATION + '/libPHCpack.dylib')
phcpack = ctypes.CDLL(libphcpack... |
def ResNet34(conv_layer, linear_layer, init_type, **kwargs):
assert (init_type == 'kaiming_normal'), 'only supporting default init for Resnets'
return ResNet(conv_layer, linear_layer, BasicBlock, [3, 4, 6, 3], **kwargs) |
def inverse_warp_3d(img, disp, padding_mode='zeros', disp_Y=None):
device = disp.device
(B, D, H, W) = disp.shape
C = img.shape[1]
if (disp_Y is not None):
assert (disp.shape == disp_Y.shape), 'disparity map along x and y axis should have same shape!'
if (img.dim() == 4):
img = img.u... |
def frameworkSrcBatch(args: argparse.Namespace, coreFunc: FunctionType) -> None:
tasks = util.readAllTasksFromDir(args.input)
lastApi: str = None
for id in range(args.start, len(tasks)):
task = tasks[id]
(api, label, src) = util.parseTask(task)
if args.singleapi:
if ((las... |
def discriminator_loss(loss_func, real, fake):
loss = []
real_loss = 0
fake_loss = 0
for i in range(2):
if loss_func.__contains__('wgan'):
real_loss = (- tf.reduce_mean(real[i]))
fake_loss = tf.reduce_mean(fake[i])
if (loss_func == 'lsgan'):
real_loss ... |
class Net(torch.nn.Module):
def __init__(self):
super(Net, self).__init__()
self.linear = torch.nn.Linear(30, 50)
def forward(self, x):
x = self.linear(x)
return x |
def parse_args():
parser = ArgumentParser(description='Training script: StyleGAN2 + ContraD with DataParallel.')
parser.add_argument('gin_config', type=str, help='Path to the gin configuration file')
parser.add_argument('architecture', type=str, help='Architecture')
parser.add_argument('--mode', default... |
class TFXLMForMultipleChoice(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
def threshold_till_dag(B):
if is_dag(B):
return (B, 0)
B = np.copy(B)
nonzero_indices = np.where((B != 0))
weight_indices_ls = list(zip(B[nonzero_indices], nonzero_indices[0], nonzero_indices[1]))
sorted_weight_indices_ls = sorted(weight_indices_ls, key=(lambda tup: abs(tup[0])))
for (we... |
class LTRTrainer(BaseTrainer):
def __init__(self, actor, loaders, optimizer, settings, lr_scheduler=None):
super().__init__(actor, loaders, optimizer, settings, lr_scheduler)
self._set_default_settings()
self.stats = OrderedDict({loader.name: None for loader in self.loaders})
tensorb... |
class ChannelSelector(object):
def __init__(self, train_channel='random', eval_channel=0, axis=1):
self.train_channel = train_channel
self.eval_channel = eval_channel
self.axis = axis
def __repr__(self):
return '{name}(train_channel={train_channel}, eval_channel={eval_channel}, a... |
def test_can_move_down(board: Board, another_board: Board) -> None:
assert can_move_down(board)
assert can_move_down(another_board)
board = jnp.array([[0, 0, 0, 0], [1, 0, 0, 0], [2, 1, 0, 0], [3, 2, 1, 0]])
assert (~ can_move_down(board)) |
def store_model_weights(model, checkpoint_path, checkpoint_key='model', strict=True):
checkpoint_path = os.path.abspath(checkpoint_path)
output_dir = os.path.dirname(checkpoint_path)
model = copy.deepcopy(model)
checkpoint = torch.load(checkpoint_path, map_location='cpu')
model.load_state_dict(check... |
class FNetTokenizer(PreTrainedTokenizer):
vocab_files_names = VOCAB_FILES_NAMES
pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
model_input_names = ['input_ids', 'token_type_ids']
def __init__(self, vocab_file, do_lower_case=Fals... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.