code stringlengths 101 5.91M |
|---|
class CopyToMap(xf.SingleStateTransformation):
a = xf.PatternNode(nodes.AccessNode)
b = xf.PatternNode(nodes.AccessNode)
def expressions(cls):
return [sdutil.node_path_graph(cls.a, cls.b)]
def can_be_applied(self, graph: SDFGState, expr_index: int, sdfg: SDFG, permissive: bool=False) -> bool:
... |
class ColoredWrapper():
SUCCESS = '\x1b[92m'
STATUS = '\x1b[94m'
WARNING = '\x1b[93m'
ERROR = '\x1b[91m'
BOLD = '\x1b[1m'
END = '\x1b[0m'
def __init__(self, prefix, logger, verbose=True, propagte=False):
self.verbose = verbose
self.propagte = propagte
self.prefix = pr... |
def get_iw():
_a = data.ply_where((X.method == 'iw-base')).ply_select('*', test_metric=X.MSE)
_cv = (cv_group + ['method'])
_result = pd.DataFrame(columns=_a.columns)
for alpha in _a.alpha.unique():
_aa = _a.ply_where((X.alpha == alpha))
_aa['method'] = (_aa['method'] + _aa['alpha'].appl... |
class UniSpeechPreTrainedModel(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
class NBestSeparateOutputHandler(OutputHandler):
name = 'nbest_sep'
def __init__(self, path, args):
super(NBestSeparateOutputHandler, self).__init__()
self.paths = [(((path + '_') + str(i)) + '.txt') for i in range(max(args.nbest, 1))]
def write_hypos(self, all_hypos, sen_indices=None):
... |
def test_bytemasked():
array = ak.Array(ak.contents.ByteMaskedArray(ak.index.Index8(np.array([0, 1, 0, 1], dtype=np.int64)), tuple, valid_when=True))
assert ak.is_tuple(array)
array = ak.Array(ak.contents.ByteMaskedArray(ak.index.Index8(np.array([0, 1, 0, 1], dtype=np.int64)), record, valid_when=True))
... |
class AuxiliaryHeadCIFAR(nn.Module):
def __init__(self, C, num_classes):
super(AuxiliaryHeadCIFAR, self).__init__()
self.features = nn.Sequential(nn.ReLU(inplace=True), nn.AvgPool2d(5, stride=3, padding=0, count_include_pad=False), nn.Conv2d(C, 128, 1, bias=False), nn.BatchNorm2d(128), nn.ReLU(inpla... |
class HardTanhChannel(PiecewiseLinearChannel):
def __init__(self):
neg = dict(zmin=(- np.inf), zmax=(- 1), slope=0, x0=(- 1))
mid = dict(zmin=(- 1), zmax=(+ 1), slope=1, x0=0)
pos = dict(zmin=1, zmax=np.inf, slope=0, x0=1)
super().__init__(name='h-tanh', regions=[pos, mid, neg]) |
def iob_iobes(tags):
new_tags = []
for (i, tag) in enumerate(tags):
if (tag == 'O'):
new_tags.append(tag)
elif (tag.split('-')[0] == 'B'):
if (((i + 1) != len(tags)) and (tags[(i + 1)].split('-')[0] == 'I')):
new_tags.append(tag)
else:
... |
_numpy_output(check_dtype=True)
def test_ufunc_arcsinh_c(A: dace.complex64[10]):
return np.arcsinh(A) |
def ToSentences(paragraph, include_token=True):
s_gen = SnippetGen(paragraph, SENTENCE_START, SENTENCE_END, include_token)
return [s for s in s_gen] |
def knapsack(seq, binary=True, max=1, value_only=False, solver=None, verbose=0, *, integrality_tolerance=0.001):
reals = (not isinstance(seq[0], tuple))
if reals:
seq = [(x, 1) for x in seq]
from sage.numerical.mip import MixedIntegerLinearProgram
from sage.rings.integer_ring import ZZ
p = M... |
def test_facets(domain):
ok = True
cmesh = domain.cmesh
_ok = (cmesh.num[1] == 26)
tst.report(('unique edges: %s' % _ok))
ok = (ok and _ok)
_ok = (cmesh.num[2] == 30)
tst.report(('unique faces: %s' % _ok))
ok = (ok and _ok)
assert ok |
def handle_arrow(obj, generate_bitmasks=False, pass_empty_field=False):
if isinstance(obj, pyarrow.lib.Array):
buffers = obj.buffers()
(awkwardarrow_type, storage_type) = to_awkwardarrow_storage_types(obj.type)
out = popbuffers(obj, awkwardarrow_type, storage_type, buffers, generate_bitmasks... |
def print_table(task_names, scores):
tb = PrettyTable()
tb.field_names = task_names
tb.add_row(scores)
print(tb) |
_utils.test()
def test_offload_with_cross_block_locals2():
ret = ti.field(ti.f32)
ti.root.place(ret)
def ker():
s = 0
for i in range(10):
s += i
ret[None] = s
s = (ret[None] * 2)
for i in range(10):
ti.atomic_add(ret[None], s)
ker()
ass... |
def get_loss(prediction, labels, mask):
cls_loss = CELoss()
return cls_loss(prediction, labels, mask) |
_function_dispatch(_nanmedian_dispatcher)
def nanmedian(a, axis=None, out=None, overwrite_input=False, keepdims=np._NoValue):
a = np.asanyarray(a)
if (a.size == 0):
return np.nanmean(a, axis, out=out, keepdims=keepdims)
(r, k) = function_base._ureduce(a, func=_nanmedian, axis=axis, out=out, overwrit... |
_model
def tf_efficientnet_lite2(pretrained=False, **kwargs):
kwargs['bn_eps'] = BN_EPS_TF_DEFAULT
kwargs['pad_type'] = 'same'
model = _gen_efficientnet_lite('tf_efficientnet_lite2', channel_multiplier=1.1, depth_multiplier=1.2, pretrained=pretrained, **kwargs)
return model |
class CIntLike(object):
to_py_function = None
from_py_function = None
to_pyunicode_utility = None
default_format_spec = 'd'
def can_coerce_to_pyobject(self, env):
return True
def can_coerce_from_pyobject(self, env):
return True
def create_to_py_utility_code(self, env):
... |
def compute_barcode(graph_data, weight_col='intersection_size'):
nodes = graph_data['nodes']
links = graph_data['links']
components = []
barcode = []
for node in nodes:
components.append([node['id']])
for link in links:
link['intersection_size']['value'] = int(link['intersection_... |
def _parse_params(params, default_params):
if (params is None):
params = {}
result = copy.deepcopy(default_params)
for (key, value) in params.items():
if (key not in default_params):
print('unknown key', key, value)
continue
if isinstance(value, dict):
... |
class TestSetState(object):
def setup(self):
self.seed =
self.random_state = random.RandomState(self.seed)
self.state = self.random_state.get_state()
def test_basic(self):
old = self.random_state.tomaxint(16)
self.random_state.set_state(self.state)
new = self.ran... |
def preprocess_scenes(scene_name):
try:
collect_point_data(scene_name)
print('name: ', scene_name)
except Exception as e:
sys.stderr.write((scene_name + 'ERROR!!'))
sys.stderr.write(str(e))
sys.exit((- 1)) |
def _gen_harmonic(n, a):
(n, a) = np.broadcast_arrays(n, a)
return _lazywhere((a > 1), (n, a), f=_gen_harmonic_gt1, f2=_gen_harmonic_leq1) |
class Decoder(nn.Module):
def __init__(self, opt, disc=False):
super(Decoder, self).__init__()
self.num_channel = opt.nc
self.b_size = opt.b_size
self.h = opt.h
self.disc = disc
self.t_act = opt.tanh
self.scale_size = opt.scale_size
self.l0 = nn.Linear... |
class StackFrames(gym.Wrapper):
def __init__(self, env, n_frames):
if (not isinstance(env.observation_space, gym.spaces.Box)):
raise ValueError('Stack frames only works with gym.spaces.Box environment.')
if (len(env.observation_space.shape) != 2):
raise ValueError('Stack fram... |
_utils.test(arch=get_host_arch_list())
def test_static_assert_data_type_ok():
x = ti.field(ti.f32, ())
def func():
ti.static_assert((x.dtype == ti.f32))
func() |
class Config(object):
def python_version(self):
if has_attr(site_cfg, 'python_version'):
if ('*' in site_cfg.python_version):
return ('%d.%d' % tuple(sys.version_info[:2]))
else:
return site_cfg.python_version
else:
return ('%d.%d' ... |
class Dummy(Dataset):
def __init__(self, cfgdata):
self.length = int(cfgdata.length)
def __len__(self):
return self.length
def __getitem__(self, idx):
return {} |
def snapshot(gc_generation=0) -> MallocInstant:
if (gc_generation is not None):
gc.collect(gc_generation)
return MallocInstant(tracemalloc.take_snapshot()) |
def TTable_GetMapHitsIterator(GraphSeq, Context, MaxIter=20):
return _snap.TTable_GetMapHitsIterator(GraphSeq, Context, MaxIter) |
class GPT2TokenizationTest(TokenizerTesterMixin, unittest.TestCase):
tokenizer_class = GPT2Tokenizer
test_rust_tokenizer = True
def setUp(self):
super(GPT2TokenizationTest, self).setUp()
vocab = ['l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', 'G', 'Gl', 'Gn', 'Glo', 'Glow', 'er', 'Glowest... |
def dummy_embedded_data(dummy_data, hparams):
(text_padded, input_lengths, mel_padded, gate_padded, output_lengths) = dummy_data
embedded_input = torch.nn.Embedding(hparams.n_symbols, hparams.symbols_embedding_dim)(text_padded)
return (embedded_input, input_lengths, mel_padded, gate_padded, output_lengths) |
def _hparams(algorithm, dataset, random_seed):
SMALL_IMAGES = ['Debug28', 'RotatedMNIST', 'ColoredMNIST']
hparams = {}
def _hparam(name, default_val, random_val_fn):
assert (name not in hparams)
random_state = np.random.RandomState(misc.seed_hash(random_seed, name))
hparams[name] = (... |
def inception_v3(inputs, num_classes=1000, is_training=True, dropout_keep_prob=0.8, min_depth=16, depth_multiplier=1.0, prediction_fn=slim.softmax, spatial_squeeze=True, reuse=None, create_aux_logits=True, scope='InceptionV3', global_pool=False):
if (depth_multiplier <= 0):
raise ValueError('depth_multiplie... |
def ref_crelu(x, axis):
return np.concatenate([np.maximum(x, 0), np.maximum((- x), 0)], axis=axis) |
class CharWordEmbedder(nn.Module):
def __init__(self, num_chars, embedding_size, output_size, num_heads=8, padding_idx=0):
super(CharWordEmbedder, self).__init__()
self.num_chars = num_chars
self.char_embedding = nn.Embedding(num_chars, embedding_size, padding_idx=padding_idx)
self.a... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--output-dir', required=True)
parser.add_argument('--scaling-value', type=int, help='maximum value for scaling in FEXIPRO')
parser.add_argument('--sigma', type=float, help='percentage of SIGMA for SVD incremental prune')
parser.add_... |
class ChannelGate(nn.Module):
def __init__(self, gate_channels, reduction_ratio=16, pool_types=['avg', 'max']):
super(ChannelGate, self).__init__()
self.gate_channels = gate_channels
self.mlp = nn.Sequential(Flatten(), nn.Linear(gate_channels, (gate_channels // reduction_ratio)), nn.ReLU(), ... |
class Encoder(nn.Module):
def __init__(self, z_dim, c_dim, x_dim, filt_per_layer=64):
super(Encoder, self).__init__()
self.model = nn.Sequential(nn.Conv2d(int(c_dim), filt_per_layer, 4, stride=2, padding=1), nn.ReLU(), nn.Conv2d(filt_per_layer, filt_per_layer, 4, stride=2, padding=1), nn.ReLU(), nn.... |
def type_hint(arg_name, arg_type):
def wrap(f):
meta = getattr(f, '__tweak_type_hint_meta__', None)
if (meta is None):
f.__tweak_type_hint_meta__ = meta = {}
meta[arg_name] = arg_type
return f
return wrap |
_start_docstrings('XLM-RoBERTa Model transformer with a sequence classification/regression head on top (a linear layer\n on top of the pooled output) e.g. for GLUE tasks. ', XLM_ROBERTA_START_DOCSTRING)
class XLMRobertaForSequenceClassification(RobertaForSequenceClassification):
config_class = XLMRobertaConfig |
def epoch_speedup(*args, idx=(- 1), **kwargs):
return list(epoch_speedup_dict(*args, **kwargs).values())[idx] |
def to_markdown_table(res: TimingResultType, header: Tuple[(str, ...)]=None) -> str:
if (header is None):
header = ('model', 'task', 'mean', 'var')
out = ''
def write_line(*args):
nonlocal out
out += '| {} |\n'.format(' | '.join((str(a) for a in args)))
write_line(*header)
wr... |
def reverse_sequence(tensor: Tensor, *, axis: Dim) -> Tensor:
indices = (rf.combine_bc(axis.get_size_tensor(), '-', rf.range_over_dim(axis)) - 1)
return rf.gather(tensor, indices=indices, axis=axis, clip_to_valid=True) |
class DeqSwishQuantTest(serial.SerializedTestCase):
def _get_scale_zp(self, tensor):
tensor_max = np.max(tensor)
tensor_min = min(0, np.min(tensor))
scale = np.float32(np.float16(((tensor_max - tensor_min) / 255.0)))
zero_point = ((- tensor_min) / scale)
zero_point = int(roun... |
class PredictionVolume(VolumeMetric):
def __init__(self, metric: str='PREDVOL'):
super().__init__(metric)
def calculate(self):
return self._calculate_volume(self.prediction) |
class Arrangements_msetk(Arrangements, Permutations_msetk):
def _repr_(self):
return ('Arrangements of the multi-set %s of length %s' % (list(self.mset), self._k)) |
def basinhopping(func, x0, niter=100, T=1.0, stepsize=0.5, minimizer_kwargs=None, take_step=None, accept_test=None, callback=None, interval=50, disp=False, niter_success=None, seed=None):
x0 = np.array(x0)
rng = check_random_state(seed)
if (minimizer_kwargs is None):
minimizer_kwargs = dict()
wr... |
class BatchNorm1d(_BatchNorm):
def _check_input_dim(self, input):
if ((input.dim() != 2) and (input.dim() != 3)):
raise ValueError('expected 2D or 3D input (got {}D input)'.format(input.dim())) |
def generate_loss(level='light', env='basic_mac_6h_vs_8z'):
if (level == 'none'):
if (env == 'basic_mac_6h_vs_8z'):
loss = th.ones((400, ((8 * 6) * 6))).cuda()
elif (env == 'basic_mac_3s_vs_4z'):
loss = th.ones((400, ((8 * 3) * 3))).cuda()
elif (env == 'basic_mac_3s_v... |
def truncated_normal_logZ(r0, v0, zmin, zmax):
g0 = truncated_normal_log_proba(r0, v0, zmin, zmax)
logZ = (((0.5 * np.log(((2 * np.pi) * v0))) + ((0.5 * (r0 ** 2)) / v0)) + g0)
return logZ |
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument('--env', type=str, default='BreakoutNoFrameskip-v4')
parser.add_argument('--seed', type=int, default=1)
parser.add_argument('--gpu', action='store_true')
args = parser.parse_args()
env = d3rlpy.envs.Atari(gym.make(args.en... |
def test_map_map_indirect():
def loop_with_value(A: dace.float64[(20, 20)], ind: dace.int64[20]):
for i in dace.map[0:20]:
for j in dace.map[0:ind[i]]:
A[(i, j)] = j
A = np.random.rand(20, 20)
ind = np.random.randint(low=0, high=19, size=(20,), dtype=np.int64)
expecte... |
def get_method_code(source_code, start_line, end_line):
try:
if (source_code is not None):
code = '\n'.join(source_code.split('\n')[(int(start_line) - 1):int(end_line)])
return code
else:
return None
except Exception as e:
cf.logger.warning(f'Problem w... |
class BasicTokenizer(object):
def __init__(self, do_lower_case=True, vocab=tuple()):
self.do_lower_case = do_lower_case
self.vocab = vocab
def tokenize(self, text):
text = convert_to_unicode(text)
text = self._clean_text(text)
text = self._tokenize_chinese_chars(text)
... |
def thread_pool_executor(gen_func: Callable, batch_inputs: List[Any], unordered: bool=True, sequential_generation: bool=False, show_progress: bool=True, num_threads: int=10, request_timeout: int=60, enable_timer: bool=True) -> List[Any]:
def worker_thread(inputs):
while True:
executor = concurre... |
class WideResNet(nn.Module):
def __init__(self, depth=34, num_classes=10, widen_factor=10, dropRate=0.0, normalize=False, activation='ReLU', softplus_beta=1):
super(WideResNet, self).__init__()
nChannels = [16, (16 * widen_factor), (32 * widen_factor), (64 * widen_factor)]
assert (((depth - ... |
class ISTFT(nn.Module):
def __init__(self, complex=True, log_amp=False, length=16384):
super().__init__()
self.amp2db = audio_nn.DbToAmplitude()
self.complex = complex
self.log_amp = log_amp
self.length = length
def forward(self, Y_hat):
num_batch = Y_hat.shape[0]... |
def scale_and_shift(x, gamma_init=1.0, beta_init=0.0):
num_channels = x.shape[(- 1)].value
with tf.variable_scope('scale_and_shift'):
gamma = tf.get_variable('alpha', (), initializer=tf.constant_initializer(gamma_init), regularizer=slim.l2_regularizer(0.0), dtype=tf.float32)
beta = tf.get_variab... |
class Conv2dWS(nn.Conv2d):
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True):
super(Conv2dWS, self).__init__(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias)
def forward(self, x):
weight = self.weight
... |
class Function_arctan2(GinacFunction):
def __init__(self):
GinacFunction.__init__(self, 'arctan2', nargs=2, latex_name='\\arctan', conversions=dict(maxima='atan2', sympy='atan2', giac='atan2')) |
def get_lr(policy, base_lr, warmup_start_lr, global_step, num_optimizer_steps, num_warmup_steps):
return lr_policy.get_lr(policy, base_lr, warmup_start_lr, global_step, num_optimizer_steps, num_warmup_steps) |
class FairseqMultiModel(BaseFairseqModel):
def __init__(self, encoders, decoders):
super().__init__()
assert (encoders.keys() == decoders.keys())
self.keys = list(encoders.keys())
for key in self.keys:
check_type(encoders[key], FairseqEncoder)
check_type(decod... |
def wer(r, h):
d = numpy.zeros(((len(r) + 1) * (len(h) + 1)), dtype=numpy.uint8).reshape(((len(r) + 1), (len(h) + 1)))
for i in range((len(r) + 1)):
for j in range((len(h) + 1)):
if (i == 0):
d[0][j] = j
elif (j == 0):
d[i][0] = i
for i in rang... |
def get_lambda(n_images, p_pixel, sigma, spec_rad):
return ((sigma * np.sqrt(np.max([(n_images + 1), p_pixel]))) * spec_rad) |
def _compute_softmax(scores):
if (not scores):
return []
max_score = None
for score in scores:
if ((max_score is None) or (score > max_score)):
max_score = score
exp_scores = []
total_sum = 0.0
for score in scores:
x = np.exp((score - max_score))
exp_s... |
def show(x=None, *args, **kwargs):
flush(*args, **kwargs)
if (x is not None):
display(blocks(x, *args, **kwargs)) |
def event_read_multiple_bytes(dat):
with tempfile.NamedTemporaryFile() as dat_f:
dat_f.write(dat)
dat_f.flush()
idx = index_log(dat_f.name)
return [capnp_log.Event.from_bytes(dat[idx[i]:idx[(i + 1)]]) for i in range((len(idx) - 1))] |
def schedule(epoch, initial_learning_rate, lr_decay_start_epoch):
if (epoch < lr_decay_start_epoch):
return initial_learning_rate
else:
return (initial_learning_rate * math.exp(((10 * initial_learning_rate) * (lr_decay_start_epoch - epoch)))) |
class TestKPIDataComplesAllBitwidth(KPIDataBaseTestClass):
def run_test(self):
model = ComplexModel()
sum_parameters = model.parameters_sum()
max_tensor = model.max_tensor()
mp_bitwidth_candidates_list = [(i, j) for i in [8, 4, 2] for j in [8, 4, 2]]
kpi_data = prep_test(mode... |
def _conv2d_gradfix(transpose, weight_shape, stride, padding, output_padding, dilation, groups):
ndim = 2
weight_shape = tuple(weight_shape)
stride = _tuple_of_ints(stride, ndim)
padding = _tuple_of_ints(padding, ndim)
output_padding = _tuple_of_ints(output_padding, ndim)
dilation = _tuple_of_in... |
class StartupTime(Experiment):
def __init__(self, config: ExperimentConfig):
super().__init__(config)
def name() -> str:
return 'startup-time'
def typename() -> str:
return 'Experiment.StartupTime' |
def validate_eu_eic(df: Union[(str, pd.Series, dd.Series, pd.DataFrame, dd.DataFrame)], column: str='') -> Union[(bool, pd.Series, pd.DataFrame)]:
if isinstance(df, (pd.Series, dd.Series)):
return df.apply(eic.is_valid)
elif isinstance(df, (pd.DataFrame, dd.DataFrame)):
if (column != ''):
... |
def _best_version(fields):
def _has_marker(keys, markers):
for marker in markers:
if (marker in keys):
return True
return False
keys = []
for (key, value) in fields.items():
if (value in ([], 'UNKNOWN', None)):
continue
keys.append(key)... |
def test_replace_ref_nodes_with_names_dicts():
class Model(optplan.ProblemGraphNode):
type = types.StringType(default='Model')
value = types.DictType(optplan.ReferenceType(optplan.ProblemGraphNode))
modelb1 = ModelB(name='m1', int_field=1)
modelb2 = ModelB(name='m2', int_field=2)
model =... |
class WebcamFaceDetector():
def __init__(self, device=torch.device(('cuda:0' if torch.cuda.is_available() else 'cpu'))):
print('loading ...')
self.detector = FaceDetector(face_size=(224, 224), device=device)
def run(self, camera_index=0):
cap = cv2.VideoCapture(camera_index)
cap.... |
def eliminate_existential_quantifiers_from_conditional_effects(task):
for action in task.actions:
for effect in action.effects:
condition = effect.condition
if isinstance(condition, pddl.ExistentialCondition):
effect.parameters = list(effect.parameters)
... |
def train(args, train_dataset, model, tokenizer):
if (args.local_rank in [(- 1), 0]):
tb_writer = SummaryWriter()
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)) else DistributedSampler(train_dat... |
def eval_mon_op(args):
if ((args[1] != 'True') and (args[1] != 'False')):
val = vars[args[1]]
else:
val = args[1]
if (val == 'True'):
return 'False'
else:
return 'True' |
def launch_ec2(params_list, exp_prefix, docker_image, code_full_path, python_command='python', script='scripts/run_experiment.py', aws_config=None, dry=False, terminate_machine=True, use_gpu=False, sync_s3_pkl=False, sync_s3_png=False, sync_s3_log=False, sync_log_on_termination=True, periodic_sync=True, periodic_sync_i... |
def accuracy(logits, labels):
assert (len(logits) == len(labels))
if (len(np.shape(logits)) > 1):
predicted_labels = np.argmax(logits, axis=1)
else:
assert (len(np.shape(logits)) == 1)
predicted_labels = logits
correct = np.sum((predicted_labels == labels.reshape(len(labels))))
... |
def reducible_primes_naive(E, max_l=None, num_P=None, verbose=False):
if (max_l is None):
max_l = 1000
if (num_P is None):
num_P = 100
if verbose:
print('E = {}, finding reducible primes up to {} using Frobenius filter with {} primes'.format(E.ainvs(), max_l, num_P))
B = Frobeniu... |
class BaseNetwork(nn.Module):
def __init__(self):
super(BaseNetwork, self).__init__()
def print_network(self):
num_params = 0
for param in self.parameters():
num_params += param.numel()
print('Network [{}] was created. Total number of parameters: {:.1f} million. To se... |
class CategoricalColumnWithVocabularyList(CategoricalColumnTransformer):
def __init__(self, key, vocabulary_list):
self.key = key
self.vocabulary_list = vocabulary_list
def _set_feature_column_names(self, names):
CategoricalColumnTransformer._set_feature_column_names(self, names)
... |
class Partition3(nn.Module):
LAYER_SCOPES = ['T5ForConditionalGeneration/T5Stack[encoder]/ModuleList[block]/T5Block[9]/ModuleList[layer]/T5LayerSelfAttention[0]/T5Attention[SelfAttention]/Linear[q]', 'T5ForConditionalGeneration/T5Stack[encoder]/ModuleList[block]/T5Block[9]/ModuleList[layer]/T5LayerSelfAttention[0]/... |
def TrainNet(Unet_chi, Unet_lfs, LR=0.001, Batchsize=32, Epoches=100, useGPU=True):
print('IniReconNet')
print('DataLoad')
trainloader = DataLoad(Batchsize)
print('Dataload Ends')
print('Training Begins')
criterion = nn.MSELoss(reduction='sum')
optimizer1 = optim.Adam(Unet_chi.parameters())
... |
class Cutout(DauphinTransform):
def __init__(self, name=None, prob=1.0, level=0, max_pixel=20, color=None):
self.max_pixel = max_pixel
self.value_range = (0, self.max_pixel)
self.color = color
super().__init__(name, prob, level)
def transform(self, pil_img, label, **kwargs):
... |
(scope='package')
def tensor_schema():
schema = TensorSchemaBuilder().categorical('item_id', cardinality=4, is_seq=True, embedding_dim=64, feature_hint=FeatureHint.ITEM_ID).categorical('some_item_feature', cardinality=4, is_seq=True, embedding_dim=32).categorical('some_user_feature', cardinality=4, is_seq=False, em... |
def BModel2Bin(bmodel_file):
import math
class FName():
core_id = 0
subnet_id = 0
gid = 0
length = 0
suffix = ''
def __str__(self):
return (bmodel_file + f'.core({self.core_id}).subnet({self.subnet_id}).group({self.gid}).len({self.length}){self.suffix}... |
def check_dir(module, module_name=None):
if (module_name is None):
module_name = module.__name__
results = {}
for name in dir(module):
item = getattr(module, name)
if (hasattr(item, '__module__') and hasattr(item, '__name__') and (item.__module__ != module_name)):
results... |
def var(key: str, *fallbacks: Optional[str], force: bool=False) -> Optional[str]:
if force:
value = None
else:
value = os.environ.get(key)
if (value is None):
try:
import sage_conf
value = getattr(sage_conf, key, None)
except ImportError:
p... |
def cau_metrics(preds, labels, cutoff=20):
recall = []
mrr = []
ndcg = []
for (batch, b_label) in zip(preds, labels):
ranks = ((batch[b_label] < batch).sum() + 1)
recall.append((ranks <= cutoff))
mrr.append(((1 / ranks) if (ranks <= cutoff) else 0.0))
ndcg.append(((1 / np... |
def get_device_map(n_layers, devices):
layers = list(range(n_layers))
n_blocks = int(ceil((n_layers / len(devices))))
layers_list = list((layers[i:(i + n_blocks)] for i in range(0, n_layers, n_blocks)))
return dict(zip(devices, layers_list)) |
_optimizer('adam')
class FairseqAdam(FairseqOptimizer):
def __init__(self, args, params):
super().__init__(args)
if torch.cuda.is_available():
try:
from apex.optimizers import FusedAdam as _FusedAdam
self._optimizer = FusedAdam(params, **self.optimizer_con... |
def im2heat(pred_dir, a, gt, exten='.png'):
pred_nm = ((pred_dir + a) + exten)
pred = cv2.imread(pred_nm, 0)
heatmap_img = cv2.applyColorMap(pred, cv2.COLORMAP_JET)
heatmap_img = convert(heatmap_img)
pred = np.stack((pred, pred, pred), 2).astype('float32')
pred = (pred / 255.0)
return np.uin... |
def vector_serializer(vector):
if isinstance(vector, numpy.ndarray):
vector = vector.tolist()
return vector |
def run_subprocess_py(file_name):
arguments = sys.argv[1:]
if arguments:
command = (['python3', file_name] + arguments)
else:
command = ['python3', file_name]
process = subprocess.Popen(command)
return_code = process.wait()
if (return_code != 0):
exit(1) |
class DownBlock2D(nn.Module):
def __init__(self, in_channels: int, out_channels: int, temb_channels: int, dropout: float=0.0, num_layers: int=1, resnet_eps: float=1e-06, resnet_time_scale_shift: str='default', resnet_act_fn: str='swish', resnet_groups: int=32, resnet_pre_norm: bool=True, output_scale_factor=1.0, ad... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.