code stringlengths 101 5.91M |
|---|
def log_config_to_file(cfg, pre='cfg', logger=None):
for (key, val) in cfg.items():
if isinstance(cfg[key], EasyDict):
logger.info(('\n%s.%s = edict()' % (pre, key)))
log_config_to_file(cfg[key], pre=((pre + '.') + key), logger=logger)
continue
logger.info(('%s.%s... |
class VPG(RLAlgorithm):
def __init__(self, env_spec, policy, value_function, policy_optimizer=None, vf_optimizer=None, max_path_length=500, num_train_per_epoch=1, discount=0.99, gae_lambda=1, center_adv=True, positive_adv=False, policy_ent_coeff=0.0, use_softplus_entropy=False, stop_entropy_gradient=False, entropy_... |
def get_new_candidate_chans(chan_info_fp, scores_fp, scores_lang_fp, prev_candidate_fps, out_fp, min_prob=0.9, min_subs=10000):
eng_chan_s = set([])
if (scores_lang_fp is not None):
for line in open(scores_lang_fp):
(chan_id, pred_prob) = line.strip('\n').split('\t')
if (float(pr... |
def test_implicit_conversion():
assert (str(m.ClassWithUnscopedEnum.EMode.EFirstMode) == 'EMode.EFirstMode')
assert (str(m.ClassWithUnscopedEnum.EFirstMode) == 'EMode.EFirstMode')
f = m.ClassWithUnscopedEnum.test_function
first = m.ClassWithUnscopedEnum.EFirstMode
second = m.ClassWithUnscopedEnum.ES... |
class Encoder_cross(nn.Module):
def __init__(self, config, vis, channel_num):
super(Encoder_cross, self).__init__()
self.vis = vis
self.layer = nn.ModuleList()
self.encoder_norm = LayerNorm(channel_num[4], eps=1e-06)
for _ in range(config.transformer['num_layers']):
... |
def _matrix_test_right_descent(M, i, n, zero):
for j in range(n):
c = M[(j, i)]
if (c < zero):
return True
elif (c > zero):
return False
raise AssertionError('a zero column, so there must be a bug') |
class EM1D_TD_LineCurrent_Jac_layers_ProblemTests(unittest.TestCase):
def setUp(self):
lm_waveform_times = np.r_[((- 0.001041), (- 0.000985), 0.0, 4e-06)]
lm_waveform_current = np.r_[(0.0, 1.0, 1.0, 0.0)]
hm_waveform_times = np.r_[((- 0.008333), (- 0.008033), 0.0, 5.6e-06)]
hm_wavefo... |
class FiniteDimensionalNilpotentLieAlgebrasWithBasis(CategoryWithAxiom_over_base_ring):
_base_category_class_and_axiom = (LieAlgebras.FiniteDimensional.WithBasis, 'Nilpotent')
class ParentMethods():
def _test_nilpotency(self, **options):
tester = self._tester(**options)
lcs = sel... |
def test_linesearch_powell_bounded():
linesearch_powell = optimize._optimize._linesearch_powell
def func(x):
return np.sum(((x - np.array([(- 1.0), 2.0, 1.5, (- 0.4)])) ** 2))
p0 = np.array([0.0, 0, 0, 0])
fval = func(p0)
lower_bound = np.array(([(- 2.0)] * 4))
upper_bound = np.array(([2... |
def train(train_dataloader, img_encoder, text_encoder, optimizer, criterion, epoch, args):
m_losses = AverageMeter('Loss', ':.4e')
m_top1 = AverageMeter('', ':6.2f')
m_iou = AverageMeter('IoU', ':6.2f')
m_ap50 = AverageMeter('AP50', ':6.2f')
progress = ProgressMeter(len(train_dataloader), [m_losses,... |
class YogiAdaptiveAggregation(AdaptiveAggregation):
def __init__(self, *, agg_func: AggregationFunction=DEFAULT_AGG_FUNC, params: Optional[Dict[(str, np.ndarray)]]=None, model_interface=None, learning_rate: float=0.01, betas: Tuple[(float, float)]=(0.9, 0.999), initial_accumulator_value: float=0.0, epsilon: float=1... |
def prepare_graph_for_second_network_editor(in_model, representative_data_gen, core_config, fw_info, fw_impl, tpc, target_kpi=None, tb_w=None):
transformed_graph = prepare_graph_for_first_network_editor(in_model=in_model, representative_data_gen=representative_data_gen, core_config=core_config, fw_info=fw_info, fw_... |
class CrossMapLRN2d(Module):
def __init__(self, size, alpha=0.0001, beta=0.75, k=1):
super(CrossMapLRN2d, self).__init__()
self.size = size
self.alpha = alpha
self.beta = beta
self.k = k
def forward(self, input):
return self._backend.CrossMapLRN2d(self.size, self.... |
def lazy_import(module: str, name: str, imports: dict[(str, Callable[([], Any)])], _globals: dict[(str, Any)]) -> Any:
value = _globals.get(name)
if (value is not None):
return value
loader = imports.get(name)
if (loader is not None):
value = loader()
_globals[name] = value
... |
def preprocess_for_train(image_bytes, dtype=tf.float32, image_size=IMAGE_SIZE, mean=MEAN_RGB, std=STDDEV_RGB, interpolation=tf.image.ResizeMethod.BICUBIC, augment_name=None, randaug_num_layers=None, randaug_magnitude=None):
image = decode_and_random_crop(image_bytes, image_size, interpolation)
image = tf.image.... |
class FakeQuantNet(nn.Module):
def __init__(self):
super(FakeQuantNet, self).__init__()
self.fake_quant = torch.quantization.FakeQuantize()
self.fake_quant.disable_observer()
def forward(self, x):
output = self.fake_quant(x)
return output |
def loss_hinge_dis(dis_out_real, dis_out_fake):
return (torch.mean(F.relu((1.0 - dis_out_real))) + torch.mean(F.relu((1.0 + dis_out_fake)))) |
def register_Ns3UanModesListChecker_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::UanModesListChecker const &', 'arg0')])
return |
class COCOEvalCap():
def __init__(self, coco, cocoRes):
self.evalImgs = []
self.eval = {}
self.imgToEval = {}
self.coco = coco
self.cocoRes = cocoRes
self.params = {'image_id': coco.getImgIds()}
def evaluate(self):
imgIds = self.params['image_id']
... |
def get_containing_span(span):
text = (span.sentence.text + ' ')
(start, end) = (span.char_start, span.char_end)
i = (start - 1)
for i in range((start - 1), 0, (- 1)):
if (text[i] == ' '):
break
j = end
for j in range(end, len(text), 1):
if (text[j] == ' '):
... |
class GANTrainer(TowerTrainer):
def __init__(self, model, input_queue):
super().__init__()
inputs_desc = model.get_inputs_desc()
cbs = input_queue.setup(inputs_desc)
self.register_callback(cbs)
self.tower_func = TowerFuncWrapper(model.build_graph, inputs_desc)
with To... |
def tree_to_rel_adj(sent_len, tree, directed=False, self_loop=True):
ret = np.zeros((sent_len, sent_len), dtype=np.int)
queue = [tree]
idx = []
while (len(queue) > 0):
(t, queue) = (queue[0], queue[1:])
idx += [t.idx]
for c in t.children:
ret[(t.idx, c.idx)] = t.rel
... |
def pythonlib_dir():
if (sys.platform == 'win32'):
return os.path.join(sys.prefix, 'libs')
else:
return get_config_var('LIBDIR') |
def set_logger(log_level='info', fname=None):
import logging as _logging
handler = logging.get_absl_handler()
formatter = _logging.Formatter('%(asctime)s - %(filename)s - %(message)s')
handler.setFormatter(formatter)
logging.set_verbosity(log_level)
if (fname is not None):
handler = _log... |
def merge_with_parent(dc: FairseqDataclass, cfg: FairseqDataclass):
merged_cfg = OmegaConf.merge(dc, cfg)
merged_cfg.__dict__['_parent'] = cfg.__dict__['_parent']
OmegaConf.set_struct(merged_cfg, True)
return merged_cfg |
def get_tensors():
ptrs = set([])
out = []
for obj in gc.get_objects():
if torch.is_tensor(obj):
if ((not obj.is_contiguous()) or (obj.data_ptr() in ptrs)):
continue
out.append(obj)
ptrs.add(obj.data_ptr())
return out |
def update_moment(updates, moments, decay, order):
return jax.tree_multimap((lambda g, t: (((1 - decay) * (g ** order)) + (decay * t))), updates, moments) |
class TextRank(KeywordExtractor):
defaults: Dict[(str, Any)] = {'pos': frozenset({'ADJ', 'NOUN', 'PROPN', 'VERB'}), 'window': 3, 'alpha': 0.85, 'tol': 1e-06, 'candidate_selection': 'chunk'}
def candidate_weighting(self, doc: Doc) -> List[Tuple[(Candidate, float)]]:
res = []
G = self.build_graph(... |
def nms(dets, thresh, force_cpu=False):
if (dets.shape[0] == 0):
return []
if (cfg.USE_GPU_NMS and (not force_cpu)):
return gpu_nms(dets, thresh, device_id=0)
else:
return cpu_nms(dets, thresh) |
def sgm2raw(sgm, debug):
to_file = sgm[0:(len(sgm) - len('.sgm'))]
if os.path.exists(to_file):
(debug and print(f'{sgm} already converted to {to_file}; so skip'))
return to_file
cmd = f'{SGM_TOOL} < {sgm} > {to_file}'
call(cmd, debug)
return to_file |
def test_or_dlrne():
(secrets, secret_values, secret_dict) = get_secrets(4)
generators = make_generators(4)
lhs_values = [(x * g) for (x, g) in zip(secret_values, generators)]
y3 = (secret_values[2] * generators[3])
p1 = DLNotEqual([lhs_values[0], generators[0]], [lhs_values[1], generators[1]], secr... |
class CharNode(ConstNode):
type = PyrexTypes.c_char_type
def calculate_constant_result(self):
self.constant_result = ord(self.value)
def compile_time_value(self, denv):
return ord(self.value)
def calculate_result_code(self):
return ("'%s'" % StringEncoding.escape_char(self.value)... |
def convert_lst20(paths, short_name, include_space_char=True):
assert (short_name == 'th_lst20')
SHARDS = ('train', 'eval', 'test')
BASE_OUTPUT_PATH = paths['NER_DATA_DIR']
input_split = [(os.path.join(paths['NERBASE'], 'thai', 'LST20_Corpus', x), x) for x in SHARDS]
if (not include_space_char):
... |
def test_predictor():
tester(input_hdf5='../sampleData&Model/100samples.hdf5', input_testset='test_trainer_outputs/test.npy', input_model='test_trainer_outputs/models/test_trainer_001.h5', output_name='test_tester', detection_threshold=0.2, P_threshold=0.1, S_threshold=0.1, number_of_plots=3, estimate_uncertainty=T... |
def build_wikisql_zero_dataset(folder, template_files):
os.makedirs(folder, exist_ok=True)
table_processor = get_codex_processor(max_cell_length=10, max_input_length=MAX_LENGTH, model_name='gpt2')
def _convert_table_types(_table):
ret_table = deepcopy(_table)
types = ret_table['types']
... |
def compute_importance(config, model, parallel_model, updater, dataloaders, loss_type='l2'):
softmax = torch.nn.Softmax(dim=(- 1))
if (loss_type == 'l2'):
loss_fct = torch.nn.MSELoss(reduction='mean')
elif (loss_type == 'l1'):
loss_fct = torch.nn.L1Loss(reduction='mean')
elif (loss_type ... |
('/getRandomImage')
def getRandomImage():
category = request.args.get('category')
data = {}
data['image_path'] = ('/static/images/' + category)
random_caption = get_caption(category)
data['upperText'] = random_caption[0]
data['lowerText'] = random_caption[1]
return jsonify(data) |
class d_sunet7128(nn.Module):
def __init__(self, num_classes, pretrained=True, ignore_index=(- 1), weight=None, output_stride='16'):
super(d_sunet7128, self).__init__()
self.num_classes = num_classes
sunet = stackedunet7128(output_stride=output_stride)
sunet = torch.nn.DataParallel(s... |
def set_temperature(conditional_strategy, tempering_type, start_temperature, end_temperature, step_count, tempering_step, total_step):
if (conditional_strategy in ['ContraGAN', 'ECGAN']):
if (tempering_type == 'continuous'):
t = (start_temperature + ((step_count * (end_temperature - start_temper... |
def show_topics(doc_raw, ldamodel, cleaning=False, combine=False):
if cleaning:
doc_clean = [clean(doc).split() for doc in doc_raw]
else:
doc_clean = doc_raw
if combine:
doc_clean = [[item for sublist in doc_clean for item in sublist]]
corpus = [dictionary.doc2bow(doc) for doc in... |
class _SCVI_HUB_NT(NamedTuple):
HF_LIBRARY_NAME: str = 'scvi-tools'
MAX_HF_UPLOAD_SIZE: int = .0
METADATA_FILE_NAME: str = '_scvi_required_metadata.json'
MODEL_CARD_FILE_NAME: str = 'README.md'
DEFAULT_MISSING_FIELD: str = 'To be added...'
DEFAULT_NA_FIELD: str = 'N/A'
DEFAULT_PARENT_MODULE:... |
_LAYERS.register_module(name='MMSyncBN')
class SyncBatchNorm(Module):
def __init__(self, num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, group=None, stats_mode='default'):
super(SyncBatchNorm, self).__init__()
self.num_features = num_features
self.eps = eps
... |
def CW(model, img, dataset='imagenet', allstep=30, lr=0.03, radius=0.1, margin=20.0, lbd=2, setting='white', noise_radius=0.1, targeted_lr=0.005, targeted_radius=0.03, untargeted_lr=0.1, untargeted_radius=0.03):
model.eval()
x_var = torch.autograd.Variable(img.clone().cuda(), requires_grad=True)
true_label ... |
def recall(predicted_scores, query2target_idx, k: int) -> float:
recall_metric = retrieval_metrics.RetrievalRecall(k=k)
return _call_torchmetrics(recall_metric, predicted_scores, query2target_idx) |
def test_pandas_automatic_categories():
data_source = ACSDataSource(survey_year='2018', horizon='1-Year', survey='person')
ca_data = data_source.get_data(states=['CA'], download=True)
definition_df = data_source.get_definitions(download=True)
features = ACSIncome.features
categories = generate_categ... |
class SlurmRuntime(Runtime):
def __init__(self, slurmdir, args, verbose=False, cleanup=True) -> None:
super().__init__()
self.runnable: tp.List[Run] = []
self.slurmdir = slurmdir
self.args = args
self.verbose = verbose
self.cleanup = cleanup
self._start_task: ... |
class MultiheadAttention(Module):
__annotations__ = {'bias_k': torch._jit_internal.Optional[torch.Tensor], 'bias_v': torch._jit_internal.Optional[torch.Tensor]}
__constants__ = ['q_proj_weight', 'k_proj_weight', 'v_proj_weight', 'in_proj_weight']
def __init__(self, embed_dim, num_heads, dropout=0.0, bias=Tr... |
def get_male_dominant_sources(topicsDF, delta=1):
maleSourcesDF = topicsDF.drop('topicDistribution').filter('sourcesMaleCount - sourcesFemaleCount >= {}'.format(delta))
return maleSourcesDF |
def _filter_duplicated(tuples: List[tuple]):
filtered_tuples = []
for tp in tuples:
if (tp not in filtered_tuples):
filtered_tuples.append(tp)
return filtered_tuples |
def _get_model_config(config_file):
cfg = get_cfg()
add_dataset_category_config(cfg)
add_bootstrap_config(cfg)
add_densepose_config(cfg)
add_hrnet_config(cfg)
path = os.path.join(_get_base_config_dir(), config_file)
cfg.merge_from_file(path)
if (not torch.cuda.is_available()):
cf... |
def GravSphereFreeSpace(x, y, z, R, xc, yc, zc, rho):
if ((~ np.size(x)) == np.size(y) == np.size(z)):
print('Specify same size of x, y, z')
return
unit_conv = .0
x = mkvc(x)
y = mkvc(y)
z = mkvc(z)
rx = (x - xc)
ry = (y - yc)
rz = (z - zc)
r = np.sqrt((((rx ** 2) + (... |
class showyourwork():
def __init__(self):
self.module = Path(realpath(__file__)).absolute().parents[0]
self.workflow = (self.module / 'workflow')
self.rules = (self.workflow / 'rules')
self.resources = (self.workflow / 'resources')
self.envs = (self.workflow / 'envs')
... |
def run_decoder(batch_size, max_seq_len, embed_size, num_heads, act='relu', num_iters=100):
config = GPT2Config(n_positions=max_seq_len, n_ctx=max_seq_len, n_embd=embed_size, n_head=num_heads)
class DecoderModel(tf.keras.models.Model):
def __init__(self):
super().__init__()
scale... |
def get_layer(layer: Union[(BaseLayer, str)]='conv', **kwargs) -> BaseLayer:
if issubclass(type(layer), BaseLayer):
return layer
elif (type(layer) == str):
layer = layer.lower()
if ('sage' in layer):
kwargs['normalization'] = 'left'
kwargs['self_embeddings'] = Tru... |
def AbstractSimplex(dim, degeneracies=(), underlying=None, name=None, latex_name=None):
if degeneracies:
if (underlying is None):
underlying = NonDegenerateSimplex(dim)
return AbstractSimplex_class(dim, degeneracies=degeneracies, underlying=underlying, name=name, latex_name=latex_name)
... |
def rotate_point_cloud_by_angle(batch_data, rotation_angle):
rotated_data = np.zeros(batch_data.shape, dtype=np.float32)
for k in range(batch_data.shape[0]):
cosval = np.cos(rotation_angle)
sinval = np.sin(rotation_angle)
rotation_matrix = np.array([[cosval, 0, sinval], [0, 1, 0], [(- si... |
class Combiner(object):
def ModelUpdateRequestStream(request, target, options=(), channel_credentials=None, call_credentials=None, insecure=False, compression=None, wait_for_ready=None, timeout=None, metadata=None):
return grpc.experimental.unary_stream(request, target, '/grpc.Combiner/ModelUpdateRequestStr... |
_start_docstrings(CUSTOM_DPR_READER_DOCSTRING)
class CustomDPRReaderTokenizerMixin():
def __call__(self, questions, titles: Optional[str]=None, texts: Optional[str]=None, padding: Union[(bool, str)]=False, truncation: Union[(bool, str)]=False, max_length: Optional[int]=None, return_tensors: Optional[Union[(str, Ten... |
def GetNodeInDegV_PDirNet(Graph, NIdInDegV):
return _snap.GetNodeInDegV_PDirNet(Graph, NIdInDegV) |
def test_count_nonzeroaxis_None():
array = ak.highlevel.Array([[[np.datetime64('2022'), np.datetime64('2023'), np.datetime64('2025')], [], [np.datetime64('2027'), np.datetime64('2011')], [np.datetime64('2013')]], [], [[np.datetime64('2017'), np.datetime64('2019')], [np.datetime64('2023')]]], check_valid=True)
a... |
(scope='module')
def geodf() -> dd.DataFrame:
df = df = load_dataset('countries')
ddf = to_dask(df)
return ddf |
def get_graph(influences_collections_list: List[List[Dict[(int, float)]]], train_vertex_color_map_fn: Optional[Callable[([int], int)]]=None, train_vertex_radius_map_fn: Optional[Callable[([int], int)]]=None, eval_vertex_radius: Optional[int]=None, eval_vertex_color_base: Optional[int]=None) -> gt_Graph_t:
if (train... |
class JSONMixin(_JSONMixin):
json_module = json
def on_json_loading_failed(self, e):
if (current_app and current_app.debug):
raise BadRequest('Failed to decode JSON object: {0}'.format(e))
raise BadRequest() |
class DynamicRNN(nn.Module):
def __init__(self, rnn_model):
super().__init__()
self.rnn_model = rnn_model
def forward(self, seq_input, seq_lens, initial_state=None):
max_sequence_length = seq_input.size(1)
(sorted_len, fwd_order, bwd_order) = self._get_sorted_order(seq_lens)
... |
def ffmpeg_parse_infos(filename, print_infos=False, check_duration=True, fps_source='tbr'):
is_GIF = filename.endswith('.gif')
cmd = [get_setting('FFMPEG_BINARY'), '-i', filename]
if is_GIF:
cmd += ['-f', 'null', '/dev/null']
popen_params = {'bufsize': (10 ** 5), 'stdout': sp.PIPE, 'stderr': sp.... |
class Function_lambert_w(BuiltinFunction):
def __init__(self):
BuiltinFunction.__init__(self, 'lambert_w', nargs=2, conversions={'mathematica': 'ProductLog', 'maple': 'LambertW', 'matlab': 'lambertw', 'maxima': 'generalized_lambert_w', 'fricas': "((n,z)+->(if n=0 then lambertW(z) else operator('generalizedL... |
def top_similar_vectors(key_vector: np.array, candidate_vectors: List[np.array]) -> List[tuple]:
cos_scores = util.cos_sim(key_vector, np.asarray(candidate_vectors))[0]
top_results = torch.topk(cos_scores, k=len(candidate_vectors))
top_cos_scores = top_results[0].detach().cpu().numpy()
top_indices = top... |
def compute_fitness(chromesome, words_2, codebert_tgt, tokenizer_tgt, orig_prob, orig_label, true_label, code, names_positions_dict, args):
temp_code = map_chromesome(chromesome, code, 'java')
temp_code = ' '.join(temp_code.split())
temp_code = tokenizer_tgt.tokenize(temp_code)
new_feature = convert_exa... |
def rewrite_with_label(char, label, apply_rewrites):
if (label == 'BEGIN'):
return (SEG_MARKER + char)
elif (label == 'CONT'):
return char
elif (label == 'REW'):
if (char == u''):
return u':'
elif apply_rewrites:
if (char in u''):
retur... |
def test_get_random_object_all(simple_test_case):
assert (simple_test_case.get_random_object(simple_test_case.test_cluster.type_system.convert_type_hint(int), simple_test_case.size()) in [simple_test_case.statements[0].ret_val, simple_test_case.statements[1].ret_val]) |
class ResidualExplanation(ExplanationBase):
def __init__(self, predictions, residuals, residual_type):
super().__init__()
self.predictions = predictions
self.residuals = residuals
self.residual_type = residual_type
def get_explanations(self):
return {'prediction': self.pr... |
def pload(model, filename):
file = os.path.join(model.dirname, (filename + '_pdump.pkl'))
if (not os.path.isfile(file)):
raise FileNotFoundError((file + " doesn't exist"))
return pickle.load(open(file, 'rb')) |
def separate_independent_kernel_two_layer_dgp_model(x: TensorType) -> DeepGP:
x = to_numpy(x)
x_shape = x.shape[(- 1)]
num_data = len(x)
Z = x.copy()
kernel_list = [gpflow.kernels.SquaredExponential(variance=tf.exp(tf.random.normal([], dtype=gpflow.default_float())), lengthscales=tf.exp(tf.random.no... |
def prep_model():
adata = scvi.data.synthetic_iid()
scvi.model.SCVI.setup_anndata(adata)
model = scvi.model.SCVI(adata)
model.train(1)
return model |
('dependency_label')
class DepLabelIndexer(TokenIndexer[int]):
def __init__(self, namespace: str='dep_labels') -> None:
self.namespace = namespace
self._logged_errors: Set[str] = set()
def count_vocab_items(self, token: Token, counter: Dict[(str, Dict[(str, int)])]):
dep_label = token.de... |
def as_mask(shape, x_coord, y_coord, radii):
ygrid = np.arange(shape[0])
xgrid = np.arange(shape[1])
(xgrid, ygrid) = np.meshgrid(xgrid, ygrid, indexing='xy')
mask = np.zeros(shape, dtype=np.uint8)
for i in range(len(x_coord)):
x = x_coord[i]
y = y_coord[i]
radius = radii[i]
... |
def run_diagnostic(real_data, synthetic_data, metadata, verbose=True):
diagnostic_report = DiagnosticReport()
diagnostic_report.generate(real_data, synthetic_data, metadata.to_dict(), verbose)
return diagnostic_report |
class DataIterator():
def __init__(self, source, buckets, uid_voc, mid_voc, cat_voc, batch_size=128, maxlen=100, skip_empty=False, shuffle_each_epoch=False, sort_by_length=True, max_batch_size=20, minlen=None):
if shuffle_each_epoch:
self.source_orig = source
self.source = shuffle.ma... |
class GRU_F(nn.Module):
def __init__(self, args):
super(GRU_F, self).__init__()
self.args = args
self.text_gru = GRUencoder(args.fusion_t_in, args.fusion_t_hid, num_layers=args.fusion_gru_layers)
self.audio_gru = GRUencoder(args.fusion_a_in, args.fusion_a_hid, num_layers=args.fusion_... |
class ResidualBlock(nn.Module):
def __init__(self, v):
super(ResidualBlock, self).__init__()
self.res = nn.Sequential(nn.ReLU(inplace=True), nn.Conv2d(v, v, kernel_size=3, padding=1, bias=True), nn.ReLU(inplace=True), nn.Conv2d(v, v, kernel_size=3, padding=1, bias=True))
def forward(self, x):
... |
def assigner(task_groups, authorized_cols):
assigner = RandomGroupedAssigner
assigner = assigner(task_groups, tasks=None, authorized_cols=authorized_cols, rounds_to_train=ROUNDS_TO_TRAIN)
return assigner |
def factorial(n, algorithm='gmp'):
if (n < 0):
raise ValueError('factorial -- must be nonnegative')
if (algorithm == 'gmp'):
return ZZ(n).factorial()
elif (algorithm == 'pari'):
from sage.libs.pari.all import pari
return pari.factorial(n)
else:
raise ValueError('u... |
class CIFAR10(data.Dataset):
def __init__(self, root, train=True, transform=None, target_transform=None):
self.root = root
self.transform = transform
self.target_transform = target_transform
self.train = train
self.train_data = []
self.train_label = []
self.te... |
def save_pc(PC, PC_color, filename):
from plyfile import PlyElement, PlyData
PC = np.concatenate((PC, PC_color), axis=1)
PC = [tuple(element) for element in PC]
el = PlyElement.describe(np.array(PC, dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('red', 'u1'), ('green', 'u1'), ('blue', 'u1')]), 'vertex')... |
def train(args, train_dataset, model, tokenizer):
if (args.local_rank in [(- 1), 0]):
tb_writer = SummaryWriter()
mkdir_p(args.output_dir)
args.train_batch_size = (args.per_gpu_train_batch_size * max(1, args.n_gpu))
train_sampler = (RandomSampler(train_dataset) if (args.local_rank == (- 1)) ... |
class OpenConstituent(Transition):
def __init__(self, *label):
self.label = tuple(label)
self.top_label = self.label[0]
def delta_opens(self):
return 1
def update_state(self, state, model):
return (state.word_position, state.constituents, model.dummy_constituent(Dummy(self.la... |
def save_cache(output_dir, tokens, tokenizer, act_count_ft_tkns, model_info):
output_dir = pathlib.Path(output_dir)
tokens_text = tokenizer.batch_decode(tokens, clean_up_tokenization_spaces=False)
tokens_str = [tokenizer.convert_ids_to_tokens(tokens[i]) for i in range(tokens.shape[0])]
tokens_str = [[to... |
class XLMProphetNetEncoder(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def z_tilde(z_list, z_hat_list, nNodes=1, measDim=2):
z_tensor = np.array(([z_list] * nNodes))
z_hat_tensor = z_hat_list.reshape(nNodes, 1, measDim)
z_tilde_list = (z_tensor - z_hat_tensor)
return z_tilde_list |
def _fix_a_slash_b(string: str) -> str:
if (len(string.split('/')) != 2):
return string
a_str = string.split('/')[0]
b_str = string.split('/')[1]
try:
a = int(a_str)
b = int(b_str)
assert (string == '{}/{}'.format(a, b))
new_string = (((('\\frac{' + str(a)) + '}{'... |
class Non_local(nn.Module):
def __init__(self, in_channels, bn_norm, reduc_ratio=2):
super(Non_local, self).__init__()
self.in_channels = in_channels
self.inter_channels = (reduc_ratio // reduc_ratio)
self.g = nn.Conv2d(in_channels=self.in_channels, out_channels=self.inter_channels, ... |
def maybe_download_and_extract(data_dir):
train_dir = os.path.join(data_dir, 'train_32x32')
if (not os.path.exists(train_dir)):
train_url = '
filepath = os.path.join(data_dir, 'train_32x32.tar')
fetch(train_url, filepath)
print('unpacking the tar file', filepath)
tarfile.... |
class LeafGenerator():
index = sys.maxsize
def __init__(self):
self.matches = []
def empty(self):
return (not self.matches)
def generate(self, atom, result):
result += self.matches
def _insert(self, args, value):
if (not args):
self.matches.append(value)
... |
class BrickKilnDataset(SustainBenchDataset):
_dataset_name = 'brick_kiln'
_versions_dict = {'1.0': {'download_url': ' 'compressed_size': 7}}
def __init__(self, version=None, root_dir='data', download=False, split_scheme='official'):
self._version = version
self._data_dir = self.initialize_da... |
def build_from_cfg(cfg: Dict, registry: 'Registry', default_args: Optional[Dict]=None) -> Any:
if (not isinstance(cfg, dict)):
raise TypeError(f'cfg must be a dict, but got {type(cfg)}')
if ('type' not in cfg):
if ((default_args is None) or ('type' not in default_args)):
raise KeyErr... |
class Trainer(object):
def __init__(self, network):
network = network.cuda()
network = DataParallel(network)
self.network = network
def reduce_loss_stats(self, loss_stats):
reduced_losses = {k: torch.mean(v) for (k, v) in loss_stats.items()}
return reduced_losses
def ... |
def cuda_pointwise_context(loop_levels, block_count, block_size):
if loop_levels:
old_loop_levels = torch._C._jit_get_te_cuda_pointwise_loop_levels()
torch._C._jit_set_te_cuda_pointwise_loop_levels(loop_levels)
if block_count:
old_block_count = torch._C._jit_get_te_cuda_pointwise_block_c... |
def is_actor_done(actor):
if (actor is None):
return True
done_ref = actor.__ray_terminate__.remote()
(done, not_done) = ray.wait([done_ref], timeout=5)
return (len(not_done) == 0) |
class MutableConfig():
def __init__(self):
pass
remove_conll_tmp = False
eval_mode = EvalMethod.Char
coref_mention_threshold = 1.0 |
_level_function()
def nanvar(x, weight=None, ddof=0, axis=None, *, keepdims=False, mask_identity=True, highlevel=True, behavior=None, attrs=None):
(yield (x, weight))
if (weight is not None):
weight = ak.operations.ak_nan_to_none._impl(weight, True, behavior, attrs)
return _impl(ak.operations.ak_nan... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.