code stringlengths 101 5.91M |
|---|
def get_mlp(num_input_channels, hidden_channels, num_output_channels, activation, log_softmax_outputs=False):
layers = []
prev_num_hidden_channels = num_input_channels
for num_hidden_channels in hidden_channels:
layers.append(nn.Linear(prev_num_hidden_channels, num_hidden_channels))
layers.a... |
class UpTransition(nn.Module):
def __init__(self, inChans, outChans, nConvs, elu, dropout=False):
super(UpTransition, self).__init__()
self.up_conv = nn.ConvTranspose3d(inChans, (outChans // 2), kernel_size=2, stride=2)
self.bn1 = torch.nn.InstanceNorm3d((outChans // 2))
self.do1 = p... |
class PseLTae(nn.Module):
def __init__(self, input_dim=10, mlp1=[10, 32, 64], pooling='mean_std', mlp2=[128, 128], with_extra=True, extra_size=4, n_head=16, d_k=8, d_model=256, mlp3=[256, 128], dropout=0.2, T=1000, mlp4=[128, 64, 32], num_classes=20, max_temporal_shift=100):
super(PseLTae, self).__init__()
... |
class BaseGraph():
def __init__(self, num_v: int, e_list: Optional[Union[(List[int], List[List[int]])]]=None, e_weight: Optional[Union[(float, List[float])]]=None, extra_selfloop: bool=False, device: torch.device=torch.device('cpu')):
assert (isinstance(num_v, int) and (num_v > 0)), 'num_v should be a posit... |
class T5DenseGatedActDense(nn.Module):
def __init__(self, d_model, d_ff, dropout_rate):
super().__init__()
self.wi_0 = nn.Linear(d_model, d_ff, bias=False)
self.wi_1 = nn.Linear(d_model, d_ff, bias=False)
self.wo = nn.Linear(d_ff, d_model, bias=False)
self.dropout = nn.Dropou... |
def write_mot_results(filename, results, data_type='mot'):
if (not filename):
return
path = os.path.dirname(filename)
if (not os.path.exists(path)):
os.makedirs(path)
if (data_type in ('mot', 'mcmot', 'lab')):
save_format = '{frame},{id},{x1},{y1},{w},{h},1,-1,-1,-1\n'
elif (... |
def _A2B(arithmetic_tensor):
assert (comm.get().get_world_size() == 3)
rank = comm.get().get_rank()
size = arithmetic_tensor.size()
device = arithmetic_tensor.device
(z1, z2) = (BinarySharedTensor.PRZS(size, device=device).share, BinarySharedTensor.PRZS(size, device=device).share)
(x1, x2) = (ar... |
_sentencepiece
class MarianTokenizationTest(TokenizerTesterMixin, unittest.TestCase):
tokenizer_class = MarianTokenizer
test_rust_tokenizer = False
test_sentencepiece = True
def setUp(self):
super().setUp()
vocab = ['</s>', '<unk>', 'This', 'is', 'a', 't', 'est', 'G', '<pad>']
vo... |
class TFRobertaPreTrainedModel():
def __init__(self, *args, **kwargs):
requires_tf(self)
def from_pretrained(self, *args, **kwargs):
requires_tf(self) |
def main():
brighter = Func('brighter')
(x, y) = (Var('x'), Var('y'))
offset = Param(UInt(8))
input = ImageParam(UInt(8), 2)
args = [input, offset]
brighter[(x, y)] = (input[(x, y)] + offset)
brighter.vectorize(x, 16).parallel(y)
brighter.compile_to_file('lesson_11_host', args, 'lesson_1... |
class linear():
def __init__(self, basis, params=None, bias=None):
self.basis = basis
self.nbasis = basis.nbasis
self._init_params = params
self.bias = bias
self.params = params
if (params is None):
self.params = np.zeros(self.nbasis)
self.nparams ... |
_REGISTRY.register()
def resnet50_ms_l123(pretrained=True, **kwargs):
from dassl.modeling.ops import MixStyle
model = ResNet(block=Bottleneck, layers=[3, 4, 6, 3], ms_class=MixStyle, ms_layers=['layer1', 'layer2', 'layer3'])
if pretrained:
init_pretrained_weights(model, model_urls['resnet50'])
r... |
def add_stage(inplanes, outplanes, innerplanes, nblocks, dilation=1, stride_init=2):
res_blocks = []
stride = stride_init
for _ in range(nblocks):
res_blocks.append(add_residual_block(inplanes, outplanes, innerplanes, dilation, stride))
inplanes = outplanes
stride = 1
return (nn.... |
def chars_token_ratio(dataset, tokenizer, nb_examples=400):
(total_characters, total_tokens) = (0, 0)
for (_, example) in tqdm(zip(range(nb_examples), iter(dataset)), total=nb_examples):
text = prepare_sample_text(example)
total_characters += len(text)
if tokenizer.is_fast:
t... |
def one_hot_from_names(class_name_or_list, batch_size=1):
try:
from nltk.corpus import wordnet as wn
except ImportError:
raise ImportError('You need to install nltk to use this function')
if (not isinstance(class_name_or_list, (list, tuple))):
class_name_or_list = [class_name_or_list... |
class DatasetMetafeatures(object):
def __init__(self, dataset_name, metafeature_values):
self.dataset_name = dataset_name
self.metafeature_values = metafeature_values
def _get_arff(self):
output = dict()
output['relation'] = ('metafeatures_%s' % self.dataset_name)
output[... |
def config_qimname(cfg, i):
return os.path.join(cfg['dir_images'], (cfg['qimlist'][i] + cfg['qext'])) |
def next_quad_double_solution(vrblvl=0):
if (vrblvl > 0):
print('in next_quad_double_solution ...')
phc = get_phcfun()
aidx = pointer(c_int32(1))
bbb = pointer(c_int32(0))
ccc = pointer(c_double(0.0))
vrb = c_int32(vrblvl)
if (vrblvl > 0):
print('-> next_quad_double_solution ... |
class VarDict(object):
def _setattr_(obj, key, val):
obj.my_dict[key] = val
def _getattr_(obj, key):
return obj.my_dict[key]
def __init__(self, dict=None):
self.__dict__['my_dict'] = {}
if dict:
for (key, val) in dict.items():
self.__setattr__(key,... |
class ImageFeatureToTensor(Preprocessing):
def __init__(self, bigdl_type='float'):
super(ImageFeatureToTensor, self).__init__(bigdl_type) |
_flax
class FlaxElectraModelTest(FlaxModelTesterMixin, unittest.TestCase):
test_head_masking = True
all_model_classes = ((FlaxElectraModel, FlaxElectraForMaskedLM, FlaxElectraForPreTraining, FlaxElectraForTokenClassification, FlaxElectraForQuestionAnswering, FlaxElectraForMultipleChoice, FlaxElectraForSequenceC... |
def partial_match_score(truth: List[Rationale], pred: List[Rationale], thresholds: List[float]) -> List[Dict[(str, Any)]]:
ann_to_rat = _keyed_rationale_from_list(truth)
pred_to_rat = _keyed_rationale_from_list(pred)
num_classifications = {k: len(v) for (k, v) in pred_to_rat.items()}
num_truth = {k: len... |
_registry(op_types='ReduceMax, ReduceMin')
class ReduceMinMaxOperator(Operator):
def __init__(self, onnx_quantizer, onnx_node):
super(ReduceMinMaxOperator, self).__init__(onnx_quantizer, onnx_node)
def quantize_check(self):
node = self.node
if (not self.quantizer.is_valid_quantize_weight... |
def train_sr(X_train, X_test, y_train, y_test, common_name_model, problemtype, classes, default_features, transform_model, modeldir, settings):
modeltypes = list()
explained_variances = list()
mean_absolute_errors = list()
mean_squared_errors = list()
median_absolute_errors = list()
r2_scores = ... |
def param_grad_or_zeros(param):
if (param.grad is not None):
return param.grad.data.detach()
else:
return th.zeros_like(param) |
def sufficient_expertise(df):
ev_1 = ((df['Sufficient Expertise?_EV_1'] == 'Yes').mean() * 100)
ev_2 = ((df['Sufficient Expertise?_EV_2'] == 'Yes').mean() * 100)
print('EV1:', round(ev_1, 1))
print('EV2:', round(ev_2, 1))
print('Average:', round(np.mean([ev_1, ev_2]), 1)) |
def _propagate_qconfig_recursively(model, prefix, op_qcfgs, qconfig_parent=None):
for (name, child) in model.named_children():
op_name = (prefix + name)
child.qconfig = qconfig_parent
qconfig_son = None
if (op_name in op_qcfgs):
child.qconfig = op_qcfgs[op_name]
... |
def load_dfs(d):
df = pd.json_normalize([load_yaml(f) for fs in d.values() for f in fs])
df.index = [f'{m}' for (m, fs) in d.items() for (i, _) in enumerate(fs)]
return df |
def mkdirs(Dataset_folder, csv_folder, classes, type_csv):
directory_list = ['train', 'validation', 'test']
if (not (type_csv == 'all')):
for class_name in classes:
if (not Dataset_folder.endswith('_nl')):
folder = os.path.join(Dataset_folder, type_csv, class_name, 'Label')
... |
def numpyImageToTensor(image):
return torch.from_numpy(image.transpose((2, 0, 1))).type(torch.float) |
class ARUMCell(RNNCell):
def __init__(self, hidden_size, activation=None, reuse=None, kernel_initializer=None, bias_initializer=None, T_norm=None, eps=1e-12, use_zoneout=False, zoneout_keep_h=0.9, use_layer_norm=False, is_training=False, lambda_pow=0):
super(ARUMCell, self).__init__(_reuse=reuse)
se... |
class SubsampleDataset(BaseWrapperDataset):
def __init__(self, dataset, size_ratio):
super().__init__(dataset)
assert (size_ratio < 1)
self.actual_size = np.ceil((len(dataset) * size_ratio)).astype(int)
self.indices = np.random.choice(list(range(len(self.dataset))), self.actual_size,... |
_module()
class ResNet50(nn.Module):
def __init__(self, norm_type='sync_batchnorm'):
super(ResNet50, self).__init__()
pretrained = './pretrained/resnet50-imagenet.pth'
model = ResNetBackbone(backbone='deepbase_resnet50_dilated8', pretrained=pretrained, norm_type=norm_type)
self.stem ... |
.skip(reason='treeinterpreter no longer maintained')
def test_that_tree_works():
from treeinterpreter import treeinterpreter as ti
dataset = load_diabetes()
rf = RandomForestRegressor()
(X, y) = (dataset.data[:300], dataset.target[:300])
feature_names = dataset.feature_names
X_new = dataset.data... |
def main(args):
print(args)
set_random_seed(args.seed)
args.monitor = monitors[args.evaluate]
datamodule = datamodules[args.dataset](args)
model = SLATE(args)
method = SlotAttentionMethod(model=model, datamodule=datamodule, args=args)
method.hparams = args
if args.is_logger_enabled:
... |
def process_chain(chain: Chain, chain_id: str) -> Protein:
atom_positions = []
aatype = []
atom_mask = []
residue_index = []
b_factors = []
chain_ids = []
for res in chain:
res_shortname = residue_constants.restype_3to1.get(res.resname, 'X')
restype_idx = residue_constants.re... |
def prefetch(tensor_dict, capacity):
names = list(tensor_dict.keys())
dtypes = [t.dtype for t in tensor_dict.values()]
shapes = [t.get_shape() for t in tensor_dict.values()]
prefetch_queue = tf.PaddingFIFOQueue(capacity, dtypes=dtypes, shapes=shapes, names=names, name='prefetch_queue')
enqueue_op = ... |
def evaluate_boxes(json_dataset, all_boxes, output_dir, use_salt=True, cleanup=True, use_matlab=False):
salt = ('_{}'.format(str(uuid.uuid4())) if use_salt else '')
filenames = _write_voc_results_files(json_dataset, all_boxes, salt)
_do_python_eval(json_dataset, salt, output_dir)
if use_matlab:
... |
def _train():
(sess, summary_writer) = setup_tensorflow()
all_filenames = prepare_dirs(delete_train_dir=True)
rn.shuffle(all_filenames)
train_filenames = all_filenames[:(- FLAGS.test_vectors)]
test_filenames = all_filenames[(- FLAGS.test_vectors):]
(train_features, train_labels) = srez_input.set... |
def play_and_get_episode_stats(env: Minesweeper, actions: List[chex.Array], time_limit: int, force_start_state: Optional[State]=None) -> Tuple[(List[float], List[StepType], int)]:
(state, timestep) = jax.jit(env.reset)(jax.random.PRNGKey(0))
if force_start_state:
state = force_start_state
episode_le... |
def resnet_block12(x, cnum, ksize, stride, rate, name, IN=True, padding='REFLECT', activation=tf.nn.elu, training=True):
xin = x
rate = 1
assert (padding in ['SYMMETRIC', 'SAME', 'REFLECT'])
if ((padding == 'SYMMETRIC') or (padding == 'REFLECT')):
p = int(((rate * (ksize - 1)) / 2))
x = ... |
_arg_scope
def batch_norm(inputs, decay=0.999, center=True, scale=False, epsilon=0.001, activation_fn=None, param_initializers=None, param_regularizers=None, updates_collections=ops.GraphKeys.UPDATE_OPS, is_training=True, reuse=None, variables_collections=None, outputs_collections=None, trainable=True, batch_weights=No... |
_module()
class PISARetinaHead(RetinaHead):
def loss_by_feat(self, cls_scores: List[Tensor], bbox_preds: List[Tensor], batch_gt_instances: InstanceList, batch_img_metas: List[dict], batch_gt_instances_ignore: OptInstanceList=None) -> dict:
featmap_sizes = [featmap.size()[(- 2):] for featmap in cls_scores]
... |
(jit, static_argnames=('edges', 'node_idx'))
def posterior_update_mean_continuous_node(attributes: Dict, edges: Edges, node_idx: int, node_precision: float) -> float:
precision_weigthed_prediction_error = 0.0
if (edges[node_idx].value_children is not None):
for (value_child_idx, value_coupling) in zip(e... |
class galpy_profile(LiteratureReferencesMixIn):
def __init__(self, pot, t=0.0, tgalpy=0.0, ro=8, vo=220.0, reverse=False):
LiteratureReferencesMixIn.__init__(self)
self.pot = pot
self.ro = ro
self.vo = vo
self.reverse = reverse
if isinstance(t, ScalarQuantity):
... |
class RNN(Model):
_compatible_windows = (window_module.Global, window_module.Sliding, window_module.Expanding, window_module.Dyadic)
def __init__(self, in_channels, hidden_channels, out_channels, num_layers, nonlinearity='tanh', bias=True, dropout=0):
super(RNN, self).__init__()
self.in_channels... |
def timer(log=None):
if (log is None):
timer.time0 = time.time()
else:
end = time.time()
print(f'{log}: {(end - timer.time0)}') |
(name='save_json_mock')
def _save_json_mock(monkeypatch: MonkeyPatch) -> MagicMock:
save_mock = MagicMock()
monkeypatch.setattr(cache.file_utils, 'safe_jsonify', save_mock)
return save_mock |
def _count_unmasked_weights(model):
mlist = get_modules(model)
unmaskeds = []
for m in mlist:
unmaskeds.append(m.weight_mask.sum())
return torch.FloatTensor(unmaskeds) |
class UniSpeechSatModel(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def dot_attention(queries, attns=None, memory=None, seq_len=None, causality=False, scope='Dot_Attention', reuse=None, mask=None, return_weights=False, bias=True, dropout=0.0):
with tf.variable_scope(scope, default_name='dot_attention', reuse=reuse):
key = tf.expand_dims(memory, 1)
queries = tf.expan... |
def test_ordering():
n = Network([_TestAgent('A'), _TestAgent('B'), _TestAgent('C')], BatchResolver())
n.add_connection('A', 'B')
n.add_connection('A', 'C')
n.add_connection('B', 'C')
n.send('A', 'B', Request(100.0))
n.send('A', 'C', Request(100.0))
n.send('B', 'C', Request(100.0))
n.res... |
def eval_full(tags_ours, tags_gold):
our_lst = []
for elem in tags_ours:
our_lst += elem
gold_lst = []
for elem in tags_gold:
gold_lst += elem
assert (len(our_lst) == len(gold_lst))
v_score = v_measure_score(our_lst, gold_lst)
return v_score |
class NumelDataset(BaseWrapperDataset):
def __init__(self, dataset, reduce=False):
super().__init__(dataset)
self.reduce = reduce
def __getitem__(self, index):
item = self.dataset[index]
if torch.is_tensor(item):
return torch.numel(item)
else:
retu... |
def test_contrast_attribute_target_only_enc_dec(saliency_mt_model: EncoderDecoderAttributionModel):
inseq.register_step_function(fn=attr_prob_diff_fn, identifier='attr_prob_diff', overwrite=True)
src = 'The nurse was tired and went home.'
tgt = "L'infermiere era stanco e ando a casa."
contrast_tgt = "L'... |
def translation(translation):
return np.array([[1, 0, translation[0]], [0, 1, translation[1]], [0, 0, 1]]) |
class SimpleCrossAttnDownBlock2D(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, attention_he... |
class InterpolationBlock(nn.Module):
def __init__(self, scale_factor, mode='nearest', align_corners=None):
super(InterpolationBlock, self).__init__()
self.scale_factor = scale_factor
self.mode = mode
self.align_corners = align_corners
def forward(self, x):
return F.interp... |
def generate_label(args):
save_dir = os.path.join(args.root, args.savedir)
os.makedirs(save_dir, exist_ok=True)
generate_json_file(save_dir, 'train_val.json', TRAIN_VAL_SET)
generate_json_file(save_dir, 'test.json', TEST_SET)
print('generating train_val set...')
gen_label_for_json(args, 'train_v... |
class RBTree(_ABCTree):
def is_red(node):
if ((node is not None) and node.red):
return True
else:
return False
def jsw_single(root, direction):
other_side = (1 - direction)
save = root[other_side]
root[other_side] = save[direction]
save[dir... |
class EMAModelTests(unittest.TestCase):
model_id = 'hf-internal-testing/tiny-stable-diffusion-pipe'
batch_size = 1
prompt_length = 77
text_encoder_hidden_dim = 32
num_in_channels = 4
latent_height = latent_width = 64
generator = torch.manual_seed(0)
def get_models(self, decay=0.9999):
... |
def apply_random_jpeg_compress(img, chance, mask=None, rnd_state=None):
if (rnd_state is None):
rnd_state = np.random
result = img
if (rnd_state.randint(100) < np.clip(chance, 0, 100)):
(h, w, c) = result.shape
quality = rnd_state.randint(10, 101)
(ret, result) = cv2.imencode... |
class RobertaTokenizerFast():
def __init__(self, *args, **kwargs):
requires_tokenizers(self)
def from_pretrained(self, *args, **kwargs):
requires_tokenizers(self) |
def normalize_2d(x, eps=1e-08):
assert (x.dim() == 2)
l2 = x.norm(2, 1)
return (x / (l2 + eps).expand_as(x)) |
def _postprocess_output(ioup, output, an_num, num_classes, iou_aware_factor):
tensors = []
stride = (output.shape[1] // an_num)
for m in range(an_num):
tensors.append(fluid.layers.slice(output, axes=[1], starts=[((stride * m) + 0)], ends=[((stride * m) + 4)]))
obj = fluid.layers.slice(output... |
def get_output_module(last_state, encoded_query, num_blocks, vocab_size, activation=tf.nn.relu, initializer=None, scope=None):
with tf.variable_scope(scope, 'Output', initializer=initializer):
last_state = tf.stack(tf.split(last_state, num_blocks, axis=1), axis=1)
(_, _, embedding_size) = last_state... |
class Trainer(object):
def __init__(self, args, model, criterion):
super(Trainer, self).__init__()
self.model = model
self.device = ('cuda' if torch.cuda.is_available() else 'cpu')
self.criterion = criterion
self.args = args
def train(self, epoch, data_loaders, optimizer,... |
class StateManagerBase(object):
def __init__(self) -> None:
pass
def update_state(self, state_update_instructions) -> bool:
pass
def get_current_state(self) -> object:
return None
def get_state(self, rollback_steps) -> object:
return None
def rollback(self, rollback_s... |
def load_vince_model(path):
checkpoint = torch.load(path, map_location={'cuda:0': 'cpu'})
checkpoint = {k.replace('feature_extractor.module.model.', ''): checkpoint[k] for k in checkpoint if ('feature_extractor' in k)}
return checkpoint |
def mask_dir(temp_dir: pathlib.Path) -> pathlib.Path:
mask_dir = (temp_dir / 'mask')
mask_dir.mkdir()
return mask_dir |
def real_osculating_planes(mdim, pdim, qdeg):
from phcpy.phcpy2c3 import py2c_schubert_osculating_planes
dim = ((mdim * pdim) + (qdeg * (mdim + pdim)))
from random import uniform as u
pts = ''
for k in range(dim):
cff = ('%.17lf' % u((- 1), (+ 1)))
pts = ((pts + ' ') + cff)
osc =... |
def load_mnist_m(dataset_dir, split='train'):
data_dir = osp.join(dataset_dir, MNIST_M[split])
n_max = (10000 if (split == 'train') else None)
return read_image_list(data_dir, n_max=n_max) |
def process(args):
out_root = Path(args.output_root).absolute()
out_root.mkdir(exist_ok=True)
feature_root = (out_root / 'fbank80')
feature_root.mkdir(exist_ok=True)
for split in SPLITS:
print(f'Fetching split {split}...')
dataset = LIBRISPEECH(out_root.as_posix(), url=split, downloa... |
class Decoder(metaclass=ABCMeta):
def __init__(self, model: Decodable):
self.model = model
def decode(self, spectra: torch.FloatTensor, precursors: torch.FloatTensor, *args, **kwargs) -> list[list[str]]:
pass |
class TimeoutLock(asyncio.Lock):
def __init__(self, timeout, *args, **kwargs):
super().__init__(*args, **kwargs)
self.timeout = timeout
async def acquire(self) -> Literal[True]:
try:
return (await asyncio.wait_for(super().acquire(), self.timeout))
except TimeoutError:... |
def loess(xvals, yvals, alpha, poly_degree=1, robustify=False):
all_data = sorted(zip(xvals, yvals), key=(lambda x: x[0]))
(xvals, yvals) = zip(*all_data)
locsDF = pd.DataFrame(columns=['loc', 'x', 'weights', 'v', 'y', 'raw_dists', 'scale_factor', 'scaled_dists'])
evalDF = pd.DataFrame(columns=['loc', '... |
class ModuleTransfer():
src: nn.Module
dest: nn.Module
verbose: int = 0
src_skip: List = field(default_factory=list)
dest_skip: List = field(default_factory=list)
def __call__(self, x: Tensor):
dest_traced = Tracker(self.dest)(x).parametrized
src_traced = Tracker(self.src)(x).par... |
def scatter(inputs, target_gpus, dim=0):
def scatter_map(obj):
if isinstance(obj, Variable):
return Scatter.apply(target_gpus, None, dim, obj)
assert (not torch.is_tensor(obj)), 'Tensors not supported in scatter.'
if (isinstance(obj, tuple) and (len(obj) > 0)):
return... |
_parse
def main(gpus: Param('The GPUs to use for distributed training', str)='all', script: Param('Script to run', str, opt=False)='', args: Param('Args to pass to script', nargs='...', opt=False)=''):
current_env = os.environ.copy()
gpus = (list(range(torch.cuda.device_count())) if (gpus == 'all') else list(gp... |
def moving_average(feat, saved_ma, alpha):
if (len(saved_ma) == 0):
ema = feat
else:
ema = ((saved_ma * alpha) + (feat * (1 - alpha)))
return ema |
def get(params, optimizer, learning_rate=None, decay=None, weight_decay=0):
if isinstance(optimizer, torch.optim.Optimizer):
optim = optimizer
elif (optimizer in ['L-BFGS', 'L-BFGS-B']):
if (weight_decay > 0):
raise ValueError("L-BFGS optimizer doesn't support weight_decay > 0")
... |
class TestCountOpsPass(QiskitTestCase):
def test_empty_dag(self):
circuit = QuantumCircuit()
dag = circuit_to_dag(circuit)
pass_ = CountOps()
_ = pass_.run(dag)
self.assertDictEqual(pass_.property_set['count_ops'], {})
def test_just_qubits(self):
qr = QuantumRegis... |
def update_user_topic(topic_id, user_id, state):
conn = getDb()
with closing(conn.cursor(dictionary=True)) as cur:
user_topics_sql = 'insert into user_topics values (%s,%s,%s,%s)'
topic_recommendations_sql = 'update topic_recommendations set clicked = %s\n where user_id = %s and topic_id ... |
_materialize('core')
class Atan(TrigonometricOp):
in_dtypes = [(i,) for i in DTYPE_GEN_FLOATS]
out_dtypes = [(i,) for i in DTYPE_GEN_FLOATS] |
def assert_allclose(tensor, value, tol=1e-05, message=''):
assert ((tensor - value).abs() < tol).all(), message |
def _get_patch_map():
global _mapping_fastchat
if (_mapping_fastchat is None):
_mapping_fastchat = []
from fastchat.model import model_adapter
_mapping_fastchat += [[BaseModelAdapter, 'load_model', load_model_base, None], [ChatGLMAdapter, 'load_model', load_model_chatglm, None], [model_adapter, ... |
def lr_decay():
global optimizer
for params in optimizer.param_groups:
params['lr'] *= 0.1
lr = params['lr']
print('Learning rate adjusted to {}'.format(lr)) |
class CamembertTokenizerFast(metaclass=DummyObject):
_backends = ['tokenizers']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tokenizers']) |
def add_flops_mask(module, mask):
def add_flops_mask_func(module):
if (isinstance(module, torch.nn.Conv2d) or isinstance(module, torch.nn.Linear)):
module.__mask__ = mask
module.apply(add_flops_mask_func) |
class Database():
def __init__(self, db_name, influxdb_host, influxdb_port):
self.db_name = db_name
self.host = influxdb_host
self.port = influxdb_port
self.conn = InfluxDBClient(host=self.host, port=self.port)
self.conn.drop_database(self.db_name)
self.db = self.crea... |
class MLP(nn.Module):
def __init__(self, in_dim, hidden_list, out_dim, activation='relu'):
super().__init__()
assert (activation in ['relu', 'tanh', 'gelu'])
self.layers = nn.ModuleList()
self.layers.append(nn.Linear(in_dim, hidden_list[0]))
self.layers.append(activations[act... |
class BWStyle():
def __init__(self):
self.tc = '#000000'
self.sc = '#000000'
self.lc = '#000000'
self.cc = '#778899'
self.gc = '#ffffff'
self.gt = '#000000'
self.bc = '#bdbdbd'
self.bg = '#ffffff'
self.fs = 13
self.sfs = 8
self.... |
def get_args():
parser = argparse.ArgumentParser()
home = os.path.expanduser('~')
source_dir = os.path.join(home, 'data', 'squad')
target_dir = 'data/squad'
glove_dir = os.path.join(home, 'data', 'glove')
parser.add_argument('-s', '--source_dir', default=source_dir)
parser.add_argument('-t',... |
class TestScore(unittest.TestCase):
def test_score(self):
metric = CiderMetric(tokenize=False)
score = metric.evaluate_batch(CANDS, REFS)
ref = 2.
self.assertTrue(((score['cider'] - ref) < EPS)) |
class DistributedSampler(_DistributedSampler):
def __init__(self, dataset, num_replicas=None, rank=None, shuffle=True):
super().__init__(dataset, num_replicas=num_replicas, rank=rank)
self.shuffle = shuffle
def __iter__(self):
if self.shuffle:
g = torch.Generator()
... |
def train(model_name):
writer = SummaryWriter(log_dir=Settings.FULL_LOG_DIR)
for (key, value) in Settings.export_settings().items():
writer.add_text(key, str(value))
if Settings.INIT_MODEL_NAME:
dqn = DQN.load(Settings.INIT_MODEL_NAME)
else:
dqn = DQN(dropout=Settings.USE_DROPOUT... |
_module()
class FPN(nn.Module):
def __init__(self, in_channels, out_channels, num_outs, start_level=0, end_level=(- 1), add_extra_convs=False, extra_convs_on_inputs=True, relu_before_extra_convs=False, no_norm_on_lateral=False, conv_cfg=None, norm_cfg=None, act_cfg=None, upsample_cfg=dict(mode='nearest')):
... |
def test_obtain_exact_trajectories(ray_local_session_fixture):
del ray_local_session_fixture
assert ray.is_initialized()
max_path_length = 15
n_workers = 8
env = GarageEnv(PointEnv())
per_worker_actions = [env.action_space.sample() for _ in range(n_workers)]
policies = [FixedPolicy(env.spec,... |
class SetDataset():
def __init__(self, batch_size, transform):
self.sub_meta = {}
self.cl_list = range(38)
for cl in self.cl_list:
self.sub_meta[cl] = []
d = ImageFolder((CropDisease_path + '/dataset/train/'), loader=(lambda path: path))
for (i, (data, label)) in ... |
def print_args(args, print_list):
s = '\n'
l = len(print_list)
for (arg, content) in args.__dict__.items():
if ((l == 0) or (arg in print_list)):
s += '{}:{}\n'.format(arg, content)
return s |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.