code stringlengths 101 5.91M |
|---|
def create_video_files_from_folder(folder: str, output_folder: str, output_filename: str='train.csv'):
if (not _HAS_PD):
raise ImportError('pandas is required to use this function.')
folder = Path(folder)
output_file = (Path(output_folder) / output_filename)
classes = sorted((f.name for f in fol... |
def move_to_device(obj, device):
if (not has_tensor(obj)):
return obj
elif isinstance(obj, torch.Tensor):
return obj.to(device)
elif isinstance(obj, dict):
return {key: move_to_device(value, device) for (key, value) in obj.items()}
elif isinstance(obj, list):
return [move... |
def gen_feats():
(x, y, z) = (240, 240, 155)
feats = np.stack(np.meshgrid(np.arange(x), np.arange(y), np.arange(z), indexing='ij'), (- 1)).astype('float32')
shape = np.array([x, y, z])
feats -= (shape / 2.0)
feats /= shape
return feats |
def get_feat(rssm_state: RSSMState):
return torch.cat((rssm_state.stoch, rssm_state.deter), dim=(- 1)) |
class SwishJit(nn.Module):
def __init__(self, inplace: bool=False):
super(SwishJit, self).__init__()
def forward(self, x):
return swish_jit(x) |
def demo():
with open(config_file, 'r') as f:
config = yaml.load(f)
data_set_test = prepare_test_data_set(**config['data'], **config['model'], verbose=True, test_mode=True)
myModel = build_model(config, data_set_test)
myModel.load_state_dict(torch.load(model_file)['state_dict'])
print('VQA D... |
def train(optims, max_epoch, policy, bsize, env, num_clicks, recom_number, max_length, origin_reward, capacity):
outputdir = 'model_output'
policy_new = os.path.join(outputdir, 'model_free_simple.pickle')
(optim_fn, optim_params) = get_optimizer(optims)
optimizer = optim_fn(filter((lambda p: p.requires_... |
class BaseEnvironment(ABC):
def __init__(self):
pass
def step(self, action: int):
pass
def reset(self):
pass
def render(self):
pass
def seed(self, seed):
pass
def close(self):
pass |
def get_f1_over_list(prediction, groundtruth):
if (type(groundtruth) == list):
if (len(groundtruth) == 0):
return 0
return np.max([qa_f1_score(prediction, gt) for gt in groundtruth])
return qa_f1_score(prediction, groundtruth) |
def createData():
loadData()
delex_data = {}
fin1 = open('data/multi-woz/data.json', 'r')
data = json.load(fin1)
fin2 = open('data/multi-woz/dialogue_acts.json', 'r')
data2 = json.load(fin2)
for (didx, dialogue_name) in enumerate(data):
dialogue = data[dialogue_name]
domains ... |
def create_logger(distributed_rank=0, save_dir=None):
logger = logging.getLogger('logger')
logger.setLevel(logging.DEBUG)
filename = ('log_%s.txt' % datetime.now().strftime('%Y_%m_%d_%H_%M_%S'))
if (distributed_rank > 0):
return logger
ch = logging.StreamHandler(stream=sys.stdout)
ch.set... |
def prepare_inputs(example, tokenizer, doc_stride=2048, max_length=4096, assertion=False):
example = get_strided_contexts_and_ans(example, tokenizer, doc_stride=doc_stride, max_length=max_length, assertion=assertion)
return example |
class PascalVOCDataset(torch.utils.data.Dataset):
CLASSES = ('__background__ ', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor')
def __init__(self, data_dir, split, u... |
class BaseLoader(ImageCollection):
def __init__(self, split, path, regex, load_func=None, lmdb_env=None):
if (not (lmdb_env == None)):
key_db = osp.basename(path)
with lmdb_env.begin() as txn:
_files_vec = txn.get(key_db.encode()).decode().split('|')
_... |
def meaningless_words():
stopwords_list = []
for word in stopwords.words('english'):
tokens = nltk.word_tokenize(word)
stopwords_list += tokens
stopwords_list = (list(set(stopwords_list)) + stopwords.words('english'))
return stopwords_list |
def report_memory(name):
mega_bytes = (1024.0 * 1024.0)
string = (name + ' memory (MB)')
string += ' | allocated: {:.1f}'.format((torch.cuda.memory_allocated() / mega_bytes))
string += ' | max allocated: {:.1f}'.format((torch.cuda.max_memory_allocated() / mega_bytes))
string += ' | reserved: {:.1f}'... |
def cal_fdp_power(selected, non_zero_index, r_index=False):
if (selected.size == 0):
return (0.0, 0.0)
if r_index:
selected = (selected - 1)
true_positive = [i for i in selected if (i in non_zero_index)]
false_positive = [i for i in selected if (i not in non_zero_index)]
fdp = (len(f... |
def _gen_efficientnet_condconv(variant, channel_multiplier=1.0, depth_multiplier=1.0, experts_multiplier=1, pretrained=False, **kwargs):
arch_def = [['ds_r1_k3_s1_e1_c16_se0.25'], ['ir_r2_k3_s2_e6_c24_se0.25'], ['ir_r2_k5_s2_e6_c40_se0.25'], ['ir_r3_k3_s2_e6_c80_se0.25'], ['ir_r3_k5_s1_e6_c112_se0.25_cc4'], ['ir_r4... |
def inference_all(model, path):
print('Start inference')
imagenet_dataset = datasets.ImageFolder(path, transforms.Compose([transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])]))
dataloader = DataLoader(imagene... |
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('input_folder', help='path to Kaldi folder. ')
parser.add_argument('output_folder', help='folder where to write the files')
return parser.parse_args() |
_model
def regnetx_008(pretrained=False, **kwargs):
return _regnet('regnetx_008', pretrained, **kwargs) |
def make_chem_data(logic_id):
path = Path(__file__).parent
basepath = (path / 'chem_data')
outpath = (path / 'chem_data')
try:
(X_train, X_test, Y_train, Y_test) = prepare_chem_dataset('{}/logic_{}_train.csv'.format(basepath, logic_id), '{}/logic_{}_test.csv'.format(basepath, logic_id), 'logic_{... |
class GeneratorEBEN(nn.Module):
def __init__(self, m: int, n: int, p: int=1):
super().__init__()
self.p = p
self.pqmf = PseudoQMFBanks(decimation=m, kernel_size=n)
self.multiple = (((2 * 4) * 8) * m)
self.nl = nn.LeakyReLU(negative_slope=0.01)
self.first_conv = nn.Con... |
def ilp_file_verify(options_parser, options, master_logger):
if (options.ilp_file is not None):
if (not os.path.exists(options.ilp_file)):
raise Exception((('ILP file ' + options.ilp_file) + ' not found')) |
def test_2_lines_together():
marker_pattern = '\\s*(?P<mark>\\[\\s*(?P<marknum>\\d+)\\s*\\])'
refs = [u'[1] hello', u'hello2 [2] foo']
rebuilt_refs = rebuild_reference_lines(refs, marker_pattern)
assert (rebuilt_refs == [u'[1] hello hello2', u'[2] foo']) |
def get_loss(pred, label, end_points, reg_weight=0.001):
loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=pred, labels=label)
classify_loss = tf.reduce_mean(loss)
tf.summary.scalar('classify loss', classify_loss)
transform = end_points['transform']
K = transform.get_shape()[1].value
... |
.register('SegmentLoss')
class SegmentLossProp(mx.operator.CustomOpProp):
def __init__(self, has_grad_scale=0, onehot_label=0, grad_scale=1):
super(SegmentLossProp, self).__init__(need_top_grad=False)
self.has_grad_scale = (int(has_grad_scale) > 0)
self.onehot_label = (int(onehot_label) > 0)... |
def get_activations(images, sess, batch_size=16, verbose=False):
inception_layer = _get_inception_layer(sess)
d0 = len(images)
if (batch_size > d0):
print('warning: batch size is bigger than the data size. setting batch size to data size')
batch_size = d0
n_batches = (d0 // batch_size)
... |
def run_and_plot(cond_ind_test, fig_ax, aspect=20):
pcmci = PCMCI(dataframe=dataframe, cond_ind_test=cond_ind_test)
results = pcmci.run_pcmci(tau_max=2, pc_alpha=0.2, alpha_level=0.01)
tp.plot_graph(fig_ax=fig_ax, val_matrix=results['val_matrix'], graph=results['graph'], var_names=var_names, node_aspect=asp... |
def enable_wrap(auto_wrap_policy: Optional[Callable]=None, **wrapper_kwargs: Any) -> Generator[(None, None, None)]:
with ConfigAutoWrap(auto_wrap_policy, **wrapper_kwargs):
(yield) |
class SqueezeBertForMultipleChoice():
def __init__(self, *args, **kwargs):
requires_pytorch(self)
def from_pretrained(self, *args, **kwargs):
requires_pytorch(self) |
def encode_schema(schema: Dict[(str, SchemaField)]) -> str:
copy_schema = schema.copy()
for (k, v) in copy_schema.items():
copy_schema[k] = v.to_dict()
return json.dumps(copy_schema, cls=EnumEncoder) |
def replace_control(beam_lst, lst_src, int_order, map_j):
map_j_rev = {v[0]: k for (k, v) in map_j.items()}
total_captured = 0
result = []
for num in range(len(lst_src)):
fields = get_e2e_poswrds(lst_src[num].split())
temp_dict = defaultdict(list)
for ((k, idx), wrd) in fields.it... |
def doc_start(implicit=False):
if implicit:
return {'emit': '', 'handle': 'OnDocumentStart(_)'}
else:
return {'emit': 'BeginDoc', 'handle': 'OnDocumentStart(_)'} |
class CogsDataset(OneShotDataset):
def __init__(self, **kwargs):
return super().__init__(self.load_split('train'), self.load_split('dev'), self.load_split('test'), **kwargs)
def load_split(self, split):
data = []
with open(os.path.join(FLAGS.cogs_dir, (split + '.tsv'))) as reader:
... |
def find(function, iterable):
for x in iterable:
if (function(x) is True):
return x |
def rotate(v1, v2, v):
size_batch = tf.shape(v1)[0]
hidden_size = tf.shape(v1)[1]
U = rotation_components(v1, v2)
h = tf.reshape(v, [size_batch, hidden_size, 1])
return (v + tf.reshape((((- tf.matmul(U[0], tf.matmul(tf.transpose(U[0], [0, 2, 1]), h))) - tf.matmul(U[1], tf.matmul(tf.transpose(U[1], [... |
class OS(TaskHandler):
def match(self, task_name) -> bool:
task_name = task_name.lower()
return (task_name.startswith('os') or task_name.startswith('operating'))
def get_main_metric(self, overall_result):
return overall_result['custom']['overall']['acc']
def get_order_priority(self):... |
def convert_json(obj):
if is_json_serializable(obj):
return obj
else:
if isinstance(obj, dict):
return {convert_json(k): convert_json(v) for (k, v) in obj.items()}
elif isinstance(obj, tuple):
return (convert_json(x) for x in obj)
elif isinstance(obj, list... |
def request_trial(func, *args, **kwargs):
for i in range(MAX_REQUEST_TRIALS):
try:
response = func(*args, **kwargs)
except:
continue
else:
return response
raise SystemError |
def mobilenetv3_small_wd2(**kwargs):
return get_mobilenetv3(version='small', width_scale=0.5, model_name='mobilenetv3_small_wd2', **kwargs) |
class Swin2SRImageProcessingTester(unittest.TestCase):
def __init__(self, parent, batch_size=7, num_channels=3, image_size=18, min_resolution=30, max_resolution=400, do_rescale=True, rescale_factor=(1 / 255), do_pad=True, pad_size=8):
self.parent = parent
self.batch_size = batch_size
self.nu... |
class OptimizationArguments():
tune: bool = field(default=False, metadata={'help': 'Whether or not to apply quantization.'})
quantization_approach: Optional[str] = field(default='PostTrainingStatic', metadata={'help': 'Quantization approach. Supported approach are PostTrainingStatic, PostTrainingDynamic and Qua... |
def PROFILE_NonZeroTile(M=3, K=3, N=3, nbits_a=1, nbits_x=1):
A = torch.ones((M, K)).cuda()
X = torch.ones((K, N)).cuda()
bit_a = QGTC.val2bit(A, nbits_a, False, False)
bit_x = QGTC.val2bit(X, nbits_x, True, False)
QGTC.bitMM2Bit_profile(bit_a, bit_x, M, K, N, nbits_a, nbits_x, nbits_x) |
def adjust_learning_rate_pyramid(optimizer, max_epoch):
def __adjust_learning_rate_pyramid(epoch):
base_lr = C.get()['lr']
lr = ((base_lr * (0.1 ** (epoch // (max_epoch * 0.5)))) * (0.1 ** (epoch // (max_epoch * 0.75))))
return lr
return torch.optim.lr_scheduler.LambdaLR(optimizer, __adj... |
def _get_config_from_default_config(flag_values: flags.FlagValues, presets_path=None) -> ConfigDict:
base_config = train.default_config.get_default_config()
if (presets_path is not None):
presets = io.load_config_dict('', presets_path)
base_config.update(presets)
config_flags.DEFINE_config_d... |
class InteractionEnhancement(torch.nn.Module):
def __init__(self, extended=True):
super(InteractionEnhancement, self).__init__()
self.extended = extended
def forward(self, *args):
to_concat = []
to_concat.extend(args)
if self.extended:
a0 = args[0]
... |
def drop_variable_from_dobldobl_polynomials(pols, svar):
from phcpy.phcpy2c3 import py2c_syscon_dobldobl_drop_variable_by_name
from phcpy.phcpy2c3 import py2c_syscon_remove_symbol_name
from phcpy.interface import store_dobldobl_system, load_dobldobl_system
store_dobldobl_system(pols)
py2c_syscon_dob... |
def extract_process(opts, i, jobs_queue, output_queue):
global options
options = opts
createLogger(options.quiet, options.debug, options.log_file)
out = StringIO()
while True:
job = jobs_queue.get()
if job:
(id, revid, title, page, page_num) = job
try:
... |
def encode_image_array_as_png_str(image):
image_pil = Image.fromarray(np.uint8(image))
output = six.BytesIO()
image_pil.save(output, format='PNG')
png_string = output.getvalue()
output.close()
return png_string |
def smooth_temporal(x, kernel_size=5, pad_prev=0, pad_next=0):
orig_shape = x.shape
kernel = torch.ones(x.shape[1], 1, kernel_size, 1).to(x.device)
kernel.div_(kernel_size)
x = x.permute(1, 0, 2, 3)
x = x.view(1, x.shape[0], x.shape[1], (- 1))
if ((pad_prev > 0) or (pad_next > 0)):
x = F... |
_model
def resnet32ts(pretrained=False, **kwargs):
return _create_byobnet('resnet32ts', pretrained=pretrained, **kwargs) |
def read_cherrypicker_coref(filename, gold_text):
regex = '(<COREF [^>]*>)|(</COREF> *)|( *[^< ][^< ]* *)'
mentions = {}
clusters = defaultdict((lambda : []))
unmatched_mentions = []
text = [[]]
sentence = 0
word = 0
prev = ['', '']
mapping = {}
word_convert = {'learnt': 'learned... |
def parse_space_from_bayesmark(api_config) -> DesignSpace:
space = DesignSpace()
params = []
for param_name in api_config:
param_conf = api_config[param_name]
param_type = param_conf['type']
param_space = param_conf.get('space', None)
param_range = param_conf.get('range', Non... |
class PassI_Bad_AP(DummyAP):
def run(self, dag):
super().run(dag)
cx_runs = dag.collect_runs(['cx'])
cx_runs_ids = set()
for run in cx_runs:
curr = []
for node in run:
curr.append(node._node_id)
cx_runs_ids.add(tuple(curr))
... |
def get_model(name='AdaRNN'):
n_hiddens = [args.hidden_size for i in range(args.num_layers)]
return AdaRNN(use_bottleneck=True, bottleneck_width=64, n_input=args.d_feat, n_hiddens=n_hiddens, n_output=args.class_num, dropout=args.dropout, model_type=name, len_seq=args.len_seq, trans_loss=args.loss_type).cuda() |
def get_training_roidb(imdb):
if cfg.TRAIN.USE_FLIPPED:
print('Appending horizontally-flipped training examples...')
imdb.append_flipped_images()
print('done')
if cfg.TRAIN.USE_ROTATE:
print('Appending rotate training examples...')
imdb.append_rotate_images()
prin... |
def trial_greedy_compressed(inputs, output, size_dict, **kwargs):
opt = GreedyCompressed(**kwargs)
ssa_path = opt.get_ssa_path(inputs, output, size_dict)
tree = ContractionTree.from_path(inputs, output, size_dict, ssa_path=ssa_path)
tree.set_surface_order_from_path(ssa_path)
return tree |
class ShardingClient(object):
def __init__(self, dataset_name, batch_size, num_epochs, dataset_size, shuffle=False, task_type=elastic_training_pb2.TRAINING, num_minibatches_per_shard=_DEFAULT_MINI_BATCH_NUM_PER_SHARD, storage_type=''):
self._mc = MasterClient.singleton_instance()
self._batch_size = ... |
class ResNet(nn.Module):
def __init__(self, num_classes, loss, block, layers, zero_init_residual=False, groups=1, width_per_group=64, replace_stride_with_dilation=None, norm_layer=None, last_stride=2, fc_dims=None, dropout_p=None, efdmix_layers=[], efdmix_p=0.5, efdmix_alpha=0.1, **kwargs):
super(ResNet, se... |
class ImageDataset(object):
def __init__(self, dataset, task, root_dir, domain_name, domain_label=(- 1), labels=None, transform=None, target_transform=None, indices=None, test_envs=[], mode='Default'):
self.imgs = ImageFolder((root_dir + domain_name)).imgs
self.domain_num = 0
self.task = tas... |
def train_data_creator(config, batch_size):
def get_training_set(upscale_factor):
root_dir = download_bsd300()
train_dir = join(root_dir, 'train')
crop_size = calculate_valid_crop_size(256, upscale_factor)
return DatasetFromFolder(train_dir, input_transform=input_transform(crop_size,... |
class TransformerEncoderLayer(nn.Module):
def __init__(self, d_model=288, nhead=8, dim_feedforward=2048, dropout=0.1, activation='relu', self_posembed=None):
super().__init__()
self.self_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
self.linear1 = nn.Linear(d_model, dim_feedforw... |
def exp_post(t, y, t_star, decay, scale, log_noise, asymptote):
fit = (asymptote + (scale * np.exp(((- decay) * np.array(t_star)))))
return (fit, np.zeros((fit.size, fit.size))) |
def get_linear_data(a=2, b=5, size=None):
x = np.arange(0, 10, (10 / size), dtype=np.float32)
y = ((a * x) + b)
return (x, y) |
class ConcatTable(Container):
def __init__(self, bigdl_type='float'):
super(ConcatTable, self).__init__(None, bigdl_type) |
def find_suffix(seq_a, seq_b):
(pointer_a, pointer_b) = ((len(seq_a) - 1), (len(seq_b) - 1))
while ((pointer_a >= 0) and (pointer_b >= 0)):
a = seq_a[pointer_a]
b = seq_b[pointer_b]
if (a != b):
return [pointer_a, pointer_b]
else:
pointer_a -= 1
... |
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--cfg', type=str, help='cfg file path', required=True)
parser.add_argument('--test_dataset', type=str, help='Test dataset type', default='')
parser.add_argument('--checkpoint', type=str, help='Checkpoint to load', default='')
... |
class GraphColoringViewer(Viewer):
def __init__(self, name: str='GraphColoring') -> None:
self._name = name
self._animation: Optional[animation.Animation] = None
def render(self, state: State, save_path: Optional[str]=None, ax: Optional[plt.Axes]=None) -> None:
num_nodes = state.adj_matr... |
def isect_seg_seg_v2_point(v1, v2, v3, v4, bias=NUM_ZERO):
if (v1 > v2):
(v1, v2) = (v2, v1)
if (v3 > v4):
(v3, v4) = (v4, v3)
if ((v1, v2) > (v3, v4)):
(v1, v2, v3, v4) = (v3, v4, v1, v2)
div = (((v2[0] - v1[0]) * (v4[1] - v3[1])) - ((v2[1] - v1[1]) * (v4[0] - v3[0])))
if (d... |
class VOTVideo(Video):
def __init__(self, name, root, video_dir, init_rect, img_names, gt_rect, camera_motion, illum_change, motion_change, size_change, occlusion, load_img=False):
super(VOTVideo, self).__init__(name, root, video_dir, init_rect, img_names, gt_rect, None, load_img)
self.tags = {'all'... |
def plant_seeds(random_seed=False):
if random_seed:
print('Randomized seed')
manualSeed = random.randint(1, 10000)
print('Random Seed: ', manualSeed)
else:
manualSeed = 1
random.seed(manualSeed)
torch.manual_seed(manualSeed)
np.random.seed(manualSeed) |
def extra_trees_regression(name, criterion='mse', **kwargs):
def _name(msg):
return ('%s.%s_%s' % (name, 'etr', msg))
hp_space = _trees_hp_space(_name, **kwargs)
hp_space['criterion'] = criterion
return scope.sklearn_ExtraTreesRegressor(**hp_space) |
class NoRepeatNGramLogitsProcessor(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def training_batch_2nd_item_task_fbne(fbne_data, batch_index, model, sess, train_data, is_training):
for index in batch_index:
(b_target_item, b_k_shot_user, b_second_order_items, b_third_order_users, b_oracle_item_ebd, b_mask_num_second_order_item, b_mask_num_third_order_user, b_intra_2nd_item, b_intra_3rd... |
def unwrap_and_save_reload_schedule(scheduler, num_steps=10):
lrs = []
for step in range(num_steps):
lrs.append(scheduler.get_lr()[0])
scheduler.step()
if (step == (num_steps // 2)):
with tempfile.TemporaryDirectory() as tmpdirname:
file_name = os.path.join(tm... |
_config
def cfg_docker():
cfg = {'task': 'keypoints3d', 'model_base_path': '/mnt/models/', 'store_representation': False, 'store_prediction': True, 'split_to_convert': 'splits.taskonomy_no_midlevel["fullplus"]', 'data_dir': '/mnt/data', 'save_dir': '/mnt/data', 'folders_to_convert': None, 'batch_size': 64, 'n_datal... |
class AbstractEnvRunner(ABC):
def __init__(self, *, env, model, nsteps):
self.env = env
self.model = model
self.nenv = nenv = (env.num_envs if hasattr(env, 'num_envs') else 1)
self.batch_ob_shape = (((nenv * nsteps),) + env.observation_space.shape)
self.obs = np.zeros(((nenv,... |
def load_data(file):
data = pd.read_csv((file + '.csv'), sep='\t')
data.sort_values(by=['SessionId', 'Time'], inplace=True)
data_start = datetime.fromtimestamp(data.Time.min(), timezone.utc)
data_end = datetime.fromtimestamp(data.Time.max(), timezone.utc)
print('Loaded data set\n\tEvents: {}\n\tSess... |
class EventStorage():
def __init__(self, start_iter=0):
self._history = defaultdict(HistoryBuffer)
self._smoothing_hints = {}
self._latest_scalars = {}
self._iter = start_iter
self._current_prefix = ''
self._vis_data = []
self._histograms = []
def put_imag... |
def _get_learningrate_scheduler(optim, decay):
if (decay is None):
return None
if (isinstance(decay, torch.optim.lr_scheduler._LRScheduler) or (decay.__class__.__name__ == 'ReduceLROnPlateau')):
return decay
if (decay[0] == 'step'):
return torch.optim.lr_scheduler.StepLR(optim, step_... |
_action_space_configuration(name='v0')
class HabitatSimV0ActionSpaceConfiguration(ActionSpaceConfiguration):
def get(self):
return {HabitatSimActions.STOP: habitat_sim.ActionSpec('stop'), HabitatSimActions.MOVE_FORWARD: habitat_sim.ActionSpec('move_forward', habitat_sim.ActuationSpec(amount=self.config.FORW... |
class RNNDecoder(nn.Module):
def __init__(self, n_vocab, ans_n_vocab, d_word_vec, d_model, n_layer, rnn, d_k, feat_vocab, d_feat_vec, d_enc_model, n_enc_layer, input_feed, copy, answer, separate, coverage, layer_attn, maxout_pool_size, dropout, device=None, encoder_word_emb=None):
self.name = 'rnn'
... |
class GraphConverterWithoutCalib():
def __init__(self, model, data_loader=None, recover_config=None, new_api=False, performance_only=False, use_bf16=False):
self.model = model
self.output_tensor_names = self.model.output_tensor_names
self.input_tensor_names = self.model.input_tensor_names
... |
.parametrize('model_name', ['wide', 'tabmlp'])
.parametrize('return_samples', [True, False])
def test_regression(model_name, return_samples):
bsz = 32
n_samples = 5
if (model_name == 'wide'):
X_tab = X_wide
model = BayesianWide(np.unique(X_wide).shape[0], 1)
elif (model_name == 'tabmlp')... |
def resnet152_mpncov_160(pretrained=False, progress=True, **kwargs):
return _resnet_mpncov_160('resnet152_mpncov_160', Bottleneck, [3, 8, 36, 3], pretrained, progress, **kwargs) |
class DatasetConfig(FairseqDataclass):
num_workers: int = field(default=1, metadata={'help': 'how many subprocesses to use for data loading'})
skip_invalid_size_inputs_valid_test: bool = field(default=False, metadata={'help': 'ignore too long or too short lines in valid and test set'})
max_tokens: Optional[... |
def download_file(url, local_filename):
with requests.get(url, stream=True) as r:
r.raise_for_status()
with open(local_filename, 'wb') as f:
for chunk in r.iter_content(chunk_size=None):
f.write(chunk)
return local_filename |
class TransformersDecoderInvocationLayer(PromptModelInvocationLayer):
def __init__(self, model_name_or_path: str='mpt-7b-chat', max_length: Optional[int]=256, use_auth_token: Optional[Union[(str, bool)]]=None, use_gpu: Optional[bool]=True, devices: Optional[List[Union[(str, torch.device)]]]=None, **kwargs):
... |
class XLMOnnxConfig(OnnxConfig):
def inputs(self) -> Mapping[(str, Mapping[(int, str)])]:
if (self.task == 'multiple-choice'):
dynamic_axis = {0: 'batch', 1: 'choice', 2: 'sequence'}
else:
dynamic_axis = {0: 'batch', 1: 'sequence'}
return OrderedDict([('input_ids', dy... |
def seresnet50b(**kwargs):
return get_seresnet(blocks=50, conv1_stride=False, model_name='seresnet50b', **kwargs) |
def res_block(input, expansion_ratio, output_dim, stride, is_train, name, bias=False, shortcut=True):
with tf.name_scope(name), tf.variable_scope(name):
bottleneck_dim = round((expansion_ratio * input.get_shape().as_list()[(- 1)]))
net = conv_1x1(input, bottleneck_dim, name='pw', bias=bias)
... |
def train(cfg_file: str) -> None:
cfg = load_config(cfg_file)
model_dir = make_model_dir(cfg['training']['model_dir'], overwrite=cfg['training'].get('overwrite', False))
_ = make_logger(model_dir, mode='train')
set_seed(seed=cfg['training'].get('random_seed', 42))
(train_data, dev_data, test_data, s... |
class ClapConfig(PretrainedConfig):
model_type = 'clap'
is_composition = True
def __init__(self, text_config=None, audio_config=None, logit_scale_init_value=(1 / 0.07), projection_dim=512, projection_hidden_act='relu', initializer_factor=1.0, **kwargs):
super().__init__(**kwargs)
if (text_co... |
def compare_match(funct, g, sent_id, pred_dictionary, easy, diff):
(hold_gold, tgt_gold, exp_gold, polarity_gold, intensity_gold, txt) = g
majority_vote = (len(pred_dictionary) / 2)
match_hte = 0
for team in pred_dictionary.keys():
try:
p_tpls = opinion_to_tuple(pred_dictionary[team]... |
def cut(graph, node):
if (not isinstance(node, Node)):
node = graph[node]
for e in graph.edges:
if (node in (e.node1, e.node2)):
for n in node.links:
if ((e.node1 == node) and (e.node2 != n)):
graph._add_edge_copy(e, node1=n, node2=e.node2)
... |
class CompositeCrossover(Crossover[(CompositeSolution, CompositeSolution)]):
__EPS = 1e-14
def __init__(self, crossover_operator_list: [Crossover]):
super(CompositeCrossover, self).__init__(probability=1.0)
Check.is_not_none(crossover_operator_list)
Check.collection_is_not_empty(crossove... |
.register('mean_squared_error_with_ohem_for_one_class_detection')
class mean_squared_error_with_ohem_for_one_class_detection_Prop(mx.operator.CustomOpProp):
def __init__(self, ohem_ratio=0.25):
super(mean_squared_error_with_ohem_for_one_class_detection_Prop, self).__init__(need_top_grad=False)
self.... |
def running_of_queue(identity, queue):
def has_queue_tag(instance):
if ('Tags' not in instance):
return False
for tag in instance['Tags']:
if ((tag['Key'] == 'QueueName') and (tag['Value'] == queue)):
return True
return False
instances_json = json.... |
def save_checkpoint(state, args, is_best, filename):
model_dir = args.train_url
model_filename = (model_dir + filename)
best_filename = (model_dir + 'model_best.pth.tar')
print("=> saving checkpoint '{}'".format(model_filename))
torch.save(state, model_filename)
if is_best:
shutil.copyfi... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.