code stringlengths 101 5.91M |
|---|
class GANLoss(nn.Module):
def __init__(self, gan_type, real_label_val=1.0, fake_label_val=0.0):
super(GANLoss, self).__init__()
self.gan_type = gan_type
self.real_label_val = real_label_val
self.fake_label_val = fake_label_val
if (self.gan_type == 'gan'):
self.los... |
def btn_eventhandler(obj):
output.clear_output()
plot_output.clear_output()
with output:
print(f'SEED: {slider_seed.value}')
print(f'Softmax Temperature: {slider_temp.value}')
print(f'Top-K: {slider_topk.value}')
print(f'Text prompt: {wd_text.value}')
with plot_output:
... |
def text_featurize(feature_set, transcript, glovemodel, w2vmodel, fastmodel, bert_model):
if (feature_set == 'nltk_features'):
(features, labels) = nf.nltk_featurize(transcript)
elif (feature_set == 'spacy_features'):
(features, labels) = sf.spacy_featurize(transcript)
elif (feature_set == '... |
class PetOwnerSchema(BaseSchema):
auto_pets = TryFrom([CatSchema, DogSchema], many=True)
by_attribute_pets = ByAttribute({'fur_density': CatSchema, 'barking_power': DogSchema}, many=True)
by_type_contact = ByType([fields.Email(), fields.Url()]) |
class FunctionWrapperDouble(Repr):
def __init__(self, function: Callable, input: bool=True, target: bool=False, *args, **kwargs):
self.function = partial(function, *args, **kwargs)
self.input = input
self.target = target
def __call__(self, inp: np.ndarray, tar: dict):
if self.inp... |
def get_ray_xshards():
from bigdl.orca.data import XShards
import numpy as np
ndarray_dict = {'x': np.random.randn(10, 4), 'y': np.random.randn(10, 4)}
spark_xshards = XShards.partition(ndarray_dict)
ray_xshards = RayXShards.from_spark_xshards(spark_xshards)
return (ray_xshards, ndarray_dict) |
def relabel(lines, annotations, file_name):
global options
offset_label = {}
for tb in annotations:
for i in range(tb.start, tb.end):
if (i in offset_label):
print('Warning: overlapping annotations in ', file=sys.stderr)
offset_label[i] = tb
prev_label = N... |
class WordEmbedding(nn.Module):
def __init__(self, vocab_size, embd_size, pre_embd_w=None, is_train_embd=False):
super(WordEmbedding, self).__init__()
self.embedding = nn.Embedding(vocab_size, embd_size)
if (pre_embd_w is not None):
print('pre embedding weight is set')
... |
def llm_convert(model, outfile, model_family, outtype='int4', model_format='pth', **kwargs):
if (model_format == 'pth'):
from bigdl.llm.ggml.convert_model import convert_model as ggml_convert_model
(_, _used_args) = _special_kwarg_check(kwargs=kwargs, check_args=['tmp_path'])
return ggml_con... |
class TrajectoryTransformerConfig(PretrainedConfig):
model_type = 'trajectory_transformer'
keys_to_ignore_at_inference = ['past_key_values']
attribute_map = {'hidden_size': 'n_embd', 'num_attention_heads': 'n_head', 'num_hidden_layers': 'n_layer'}
def __init__(self, vocab_size=100, action_weight=5, rewa... |
def batch_norm(inputs, training, data_format):
print(_BATCH_NORM_DECAY)
return tf.compat.v1.layers.batch_normalization(inputs=inputs, axis=(1 if (data_format == 'channels_first') else 3), momentum=_BATCH_NORM_DECAY, epsilon=_BATCH_NORM_EPSILON, center=True, scale=True, training=training, fused=True) |
class TestReproducibility(unittest.TestCase):
def _test_reproducibility(self, name, extra_flags=None, delta=0.0001, resume_checkpoint='checkpoint1.pt', max_epoch=3):
def get_last_log_stats_containing_string(log_records, search_string):
for log_record in logs.records[::(- 1)]:
if ... |
class QuadkeyTest(TestCase):
def testInit(self):
qk = quadkey.from_str('')
with self.assertRaises(AssertionError):
qk = quadkey.from_str('')
with self.assertRaises(AssertionError):
qk = quadkey.from_str('')
def testFromGeo(self):
geo = (40, (- 105))
... |
def setup_logger(name, save_dir, distributed_rank, filename='log.txt', mode='w'):
if (distributed_rank > 0):
return
logging.root.name = name
logging.root.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s: %(message)s')
if save_dir:
if (not os.pa... |
def test_digits_sigmoid_naive_init():
model = FeatureBasedSelection(100, 'sigmoid', optimizer='naive', initial_subset=digits_sigmoid_ranking[:5])
model.fit(X_digits)
assert_array_equal(model.ranking[:(- 5)], digits_sigmoid_ranking[5:])
assert_array_almost_equal(model.gains[:(- 5)], digits_sigmoid_gains[... |
class ExperimentRunner(tune.Trainable):
def _setup(self, variant):
set_seed(variant['run_params']['seed'])
self._variant = variant
gpu_options = tf.GPUOptions(allow_growth=True)
session = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
tf.keras.backend.set_session(... |
def read_nb_content(cells, mod_name):
doc_fns = {}
for (i, cell) in enumerate(cells):
if (cell['cell_type'] == 'code'):
for match in SHOW_DOC_RE.findall(cell['source']):
doc_fns[match] = i
return doc_fns |
def rgb_as_png_binary_bytes(rgb_np_image):
pil_image = PIL.Image.fromarray(rgb_np_image, mode='RGB')
output = io.BytesIO()
pil_image.save(output, format='PNG')
bytevalues = output.getvalue()
return bytevalues |
def get_wrn(blocks, width_factor, model_name=None, pretrained=False, root=os.path.join('~', '.torch', 'models'), **kwargs):
if (blocks == 50):
layers = [3, 4, 6, 3]
elif (blocks == 101):
layers = [3, 4, 23, 3]
elif (blocks == 152):
layers = [3, 8, 36, 3]
elif (blocks == 200):
... |
class ContactReward(abstract_task.AbstractTask):
def __init__(self, reward_fn, layers_0, layers_1, condition=None, reset_steps_after_contact=np.inf):
if (not callable(reward_fn)):
self._reward_fn = (lambda sprite_0, sprite_1: reward_fn)
else:
self._reward_fn = reward_fn
... |
class ModelArguments():
model_name_or_path: Optional[str] = field(default=None, metadata={'help': "The model checkpoint for weights initialization.Don't set if you want to train a model from scratch."})
model_type: Optional[str] = field(default=None, metadata={'help': ('If training from scratch, pass a model ty... |
def trades_loss(model, x_natural, y, logits_natural, optimizer, epsilon=0.031, step_size=0.003, perturb_steps=10, clip_min=0.0, clip_max=1.0, beta=1.0, distance='linf'):
criterion_kl = torch.nn.KLDivLoss(size_average=False)
model.eval()
batch_size = len(x_natural)
x_adv = (x_natural.detach() + (0.001 * ... |
def main():
args = parse_args()
if (args.num <= 0):
return
if ((not args.save_raw_synthesis) and (not args.generate_html)):
return
if (args.model_name not in MODEL_ZOO):
raise SystemExit(f'Model `{args.model_name}` is not registered in `models/model_zoo.py`!')
model_config = ... |
def train(train_loader, model, criterion, optimizer, epoch, args, logger):
batch_time = AverageMeter('Batch Time', ':5.3f')
data_time = AverageMeter('Data Time', ':5.3f')
losses = AverageMeter('Loss', ':5.3f')
lr = ValueMeter('LR', ':5.3f')
progress = ProgressMeter(len(train_loader), [batch_time, da... |
class AnomalyDetector(ABC):
def fit(self, y):
pass
def score(self):
pass
def anomaly_indexes(self):
pass |
def linear_eval_epoch(encoder, classifier, val_loader, val_transform, criterion):
epoch_loss = 0.0
if (args.dataset == 'ICBHI'):
TP = [0, 0, 0, 0]
GT = [0, 0, 0, 0]
elif (args.dataset == 'SPRS'):
TP = [0, 0, 0, 0, 0, 0, 0]
GT = [0, 0, 0, 0, 0, 0, 0]
classifier.eval()
... |
def get_num_default_workers():
try:
return int(os.environ['NUM_DEFAULT_WORKERS'])
except KeyError:
return 1 |
def get_model(args):
model = Localizer(args)
if (torch.cuda.is_available() and args.gpu):
model = model.to('cuda')
return model |
def main():
parser = utils.prepare_parser()
parser = utils.add_dgp_parser(parser)
config = vars(parser.parse_args())
utils.dgp_update_config(config)
print(config)
rank = 0
if (mp.get_start_method(allow_none=True) != 'spawn'):
mp.set_start_method('spawn', force=True)
if config['di... |
def train(args):
if (args.local_rank != (- 1)):
torch.distributed.init_process_group(backend='nccl')
torch.cuda.set_device(args.local_rank)
logger.info(f'process_{args.local_rank} starts training ...')
device = torch.device(('cuda' if (not args.cpu) else 'cpu'))
np.random.seed(args.s... |
class EvalAIAnswerProcessor():
CONTRACTIONS = {'aint': "ain't", 'arent': "aren't", 'cant': "can't", 'couldve': "could've", 'couldnt': "couldn't", "couldn'tve": "couldn't've", "couldnt've": "couldn't've", 'didnt': "didn't", 'doesnt': "doesn't", 'dont': "don't", 'hadnt': "hadn't", "hadnt've": "hadn't've", "hadn'tve":... |
class DefaultFlowCallback(TrainerCallback):
def on_step_end(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs):
if ((state.global_step == 1) and args.logging_first_step):
control.should_log = True
if ((args.logging_strategy == IntervalStrategy.STEPS) a... |
def Shampoo(model_param, lr=0.1, momentum=0.0, weight_decay=0.0, epsilon=0.0001, update_freq=1):
optimizer = optim.Shampoo(model_param, lr=lr, momentum=momentum, weight_decay=weight_decay, epsilon=epsilon, update_freq=update_freq)
return optimizer |
def mask_inside(mask_a, mask_b):
if (mask_a.shape[1:] != mask_b.shape[1:]):
raise IndexError
xp = cuda.get_array_module(mask_a)
n_mask_a = len(mask_a)
n_mask_b = len(mask_b)
iou = xp.empty((n_mask_a, n_mask_b), dtype=xp.float32)
for (n, m_a) in enumerate(mask_a):
for (k, m_b) in ... |
def original_match(flat_preds, flat_targets, preds_k, targets_k):
assert (isinstance(flat_preds, torch.Tensor) and isinstance(flat_targets, torch.Tensor) and flat_preds.is_cuda and flat_targets.is_cuda)
out_to_gts = {}
out_to_gts_scores = {}
for out_c in range(preds_k):
for gt_c in range(targets... |
class CrashingAlgo():
def train(self, runner):
for epoch in runner.step_epochs():
runner.obtain_samples(epoch) |
class Lga3dFunction(Function):
def forward(ctx, input, filters, radius=1):
ctx.radius = radius
ctx.save_for_backward(input, filters)
assert ((input.is_contiguous() == True) and (filters.is_contiguous() == True))
with torch.cuda.device_of(input):
(num, channels, depth, hei... |
def test_function_with_string_and_vector_string_arg():
assert (m.func_with_string_or_vector_string_arg_overload(('A', 'B')) == 2)
assert (m.func_with_string_or_vector_string_arg_overload(['A', 'B']) == 2)
assert (m.func_with_string_or_vector_string_arg_overload('A') == 3) |
def main(lm_root_dir, dataset_path, **args):
lm_file_path = train(lm_dir=lm_root_dir, dataset_path=dataset_path, n_gram=args['n_gram'], dataset_name=args['dataset_name'])
print(f'''done doing training of KenLM
check the output folder: {lm_file_path}''') |
class Res16UNetSN50(Res16UNet50):
NORM_TYPE = NormType.SPARSE_SWITCH_NORM
BLOCK = BottleneckSN |
class ResNet(nn.Module):
def __init__(self, block, layers, feature_channels=128, norm_layer=None):
super(ResNet, self).__init__()
if (norm_layer is None):
norm_layer = nn.BatchNorm2d
self._norm_layer = norm_layer
self.inplanes = 64
self.conv1 = nn.Conv2d(3, self.i... |
class ConvBlock(nn.Module):
def __init__(self, in_channels, out_channels, bn=False, nonlin=True):
super().__init__()
self.conv = Conv3x3(in_channels, out_channels)
if bn:
self.bn = nn.BatchNorm2d(out_channels)
else:
self.bn = None
if nonlin:
... |
class DistributionalHeadModel(torch.nn.Module):
def __init__(self, input_size, layer_sizes, output_size, n_atoms):
super().__init__()
self.mlp = MlpModel(input_size, layer_sizes, (output_size * n_atoms))
self._output_size = output_size
self._n_atoms = n_atoms
def forward(self, in... |
def latest_checkpoint_path(dir_path, regex='G_*.pth'):
f_list = glob.glob(os.path.join(dir_path, regex))
f_list.sort(key=(lambda f: int(''.join(filter(str.isdigit, f)))))
x = f_list[(- 1)]
print(x)
return x |
def register_lvis_instances(name, metadata, json_file, image_root):
DatasetCatalog.register(name, (lambda : load_lvis_json(json_file, image_root, name)))
MetadataCatalog.get(name).set(json_file=json_file, image_root=image_root, evaluator_type='lvis', **metadata) |
class Conv2d(fa_constructor.Conv2d):
def __init__(self, in_channels: int, out_channels: int, kernel_size: _size_2_t, stride: _size_2_t=1, padding: Union[(str, _size_2_t)]=0, dilation: _size_2_t=1, groups: int=1, bias: bool=True, padding_mode: str='zeros', layer_config: dict=None):
if (layer_config is None):... |
def import_jax_weights_(model, npz_path, version='model_1'):
data = np.load(npz_path)
LinearWeight = (lambda l: Param(l, param_type=ParamType.LinearWeight))
LinearBias = (lambda l: Param(l))
LinearWeightMHA = (lambda l: Param(l, param_type=ParamType.LinearWeightMHA))
LinearBiasMHA = (lambda b: Param... |
def block_required_error(hf_parser: HfArgumentParser) -> Tuple[(HfArgumentParser, List)]:
required = []
for action in hf_parser._actions:
if action.required:
required.append(action.dest)
action.required = False
action.default = SUPPRESS
return (hf_parser, required) |
def test_compute_closest_points():
vertices = o3d.core.Tensor([[0, 0, 0], [1, 0, 0], [1, 1, 0]], dtype=o3d.core.float32)
triangles = o3d.core.Tensor([[0, 1, 2]], dtype=o3d.core.uint32)
scene = o3d.t.geometry.RaycastingScene()
geom_id = scene.add_triangles(vertices, triangles)
query_points = o3d.core... |
def check_preference(query):
rm_index = []
for i in range(len(PREF_PROMPTS)):
p = PREF_PROMPTS[i]
if (p in query):
rm_index.append(i)
query = query.replace(p, '')
query = query.replace('<|user|>\n', '')
query = query.replace('\n<|assistant|>\n', '')
return (qu... |
class MaskedLSTMCellCheckpoint(MaskMixin, nn.LSTMCell):
def __init__(self, input_size: int, hidden_size: int, mask_type: str, mask_init_value: float, bypass_sigmoid_grad: bool=False, **kwargs) -> None:
super().__init__(input_size, hidden_size, **kwargs)
self.setup_masks(('weight_ih', 'weight_hh'), m... |
class JdtLspAnalyzer(Process):
def __init__(self, conn: Connection, server_cmd: list[str], proj_path: PathLike, model: ModelType, java8_home: str, verbose: bool=False) -> None:
super().__init__()
self.conn = conn
self.server_cmd = server_cmd
self.proj_path = proj_path
self.ja... |
def extract_features(model: Module, loader: DataLoader) -> Tuple[(Tensor, Tensor)]:
(x, y) = ([], [])
for (x_i, y_i) in iter(loader):
x.append(model(x_i))
y.append(y_i)
x = torch.cat(x)
y = torch.cat(y)
return (x, y) |
def test_enums_vs_fangraphs_column_list() -> None:
sample_pitching_url = '
sample_pitching_result = requests.get(sample_pitching_url)
parsed_result = lxml.etree.HTML(sample_pitching_result.content.decode('utf-8'))
custom_leaderboards_items = sorted(list({x for x in parsed_result.xpath('//ul[="rlbList"]/... |
def make_placement_plot(nodes, pl, scl, dest):
parse_bookshelf_scl(scl)
node_dict = dict()
parse_bookshelf_nodes(nodes, node_dict)
parse_bookshelf_pl(pl, node_dict)
f_dest = open((dest + '.plt'), 'w')
png_name = (dest + '.png')
print_gnuplot_header(f_dest, png_name)
node_list = list(node... |
class BatchExpand(Layer):
def __init__(self, **kwargs):
super(__class__, self).__init__(**kwargs)
def call(self, inputs, mask=None):
(x, y) = inputs
outputs = (x * K.ones_like(y, dtype=x.dtype))
return outputs |
class CuQuantumContractor():
def __init__(self, tree, handle_slicing=False, autotune=False, **kwargs):
if handle_slicing:
self.eq = tree.get_eq()
self.shapes = tree.get_shapes()
else:
self.eq = tree.get_eq_sliced()
self.shapes = tree.get_shapes_sliced(... |
def get_remote_file_to_local(remote_path, local_path, over_write=False):
callZooFunc('float', 'getRemoteFileToLocal', remote_path, local_path, over_write) |
def save_h5_data_label_normal(h5_filename, data, label, normal, data_dtype='float32', label_dtype='uint8', noral_dtype='float32'):
h5_fout = h5py.File(h5_filename)
h5_fout.create_dataset('data', data=data, compression='gzip', compression_opts=4, dtype=data_dtype)
h5_fout.create_dataset('normal', data=normal... |
class CIFAR10MSDInitLayer(nn.Module):
def __init__(self, in_channels, out_channels):
super(CIFAR10MSDInitLayer, self).__init__()
self.scale_blocks = MultiOutputSequential()
for (i, out_channels_per_scale) in enumerate(out_channels):
stride = (1 if (i == 0) else 2)
sel... |
def channel_drop(image):
orig_dtype = image.dtype
(r, g, b) = tf.split(image, 3, axis=2)
zeros = tf.zeros_like(r, dtype=orig_dtype)
indexes_r = tf.concat([zeros, g, b], axis=2)
indexes_g = tf.concat([r, zeros, b], axis=2)
indexes_b = tf.concat([r, g, zeros], axis=2)
image = random_choice([in... |
class QSPCircuit(cirq.Circuit):
def __init__(self, phis):
super(QSPCircuit, self).__init__()
self.phis = (np.array(phis).flatten() * (- 2))
self.theta = sympy.Symbol('theta')
self.q = cirq.GridQubit(0, 0)
self._build_qsp_sequence(self.q)
def _build_qsp_sequence(self, q):
... |
def batch_assign_targets(target_assigner, anchors_batch, gt_box_batch, gt_class_targets_batch):
if (not isinstance(anchors_batch, list)):
anchors_batch = (len(gt_box_batch) * [anchors_batch])
if (not all((isinstance(anchors, box_list.BoxList) for anchors in anchors_batch))):
raise ValueError('an... |
def padded_accuracy(logits, labels):
with tf.variable_scope('padded_accuracy', values=[logits, labels]):
(logits, labels) = _pad_tensors_to_same_length(logits, labels)
weights = tf.to_float(tf.not_equal(labels, 0))
outputs = tf.to_int32(tf.argmax(logits, axis=(- 1)))
padded_labels = ... |
_module()
class CityscapesDataset(CocoDataset):
CLASSES = ('person', 'rider', 'car', 'truck', 'bus', 'train', 'motorcycle', 'bicycle')
def _filter_imgs(self, min_size=32):
valid_inds = []
ids_with_ann = set((_['image_id'] for _ in self.coco.anns.values()))
ids_in_cat = set()
for ... |
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--config-file', type=str, default='', help='path to config file')
parser.add_argument('-s', '--sources', type=str, nargs='+', help='source datasets (delimited by space)')
parser.add_... |
def test_odd_even_two_agents():
env = MockFSMEnv()
assert (env.reset() == ({'odd_agent': np.array([0])}, {}))
assert (env.current_stage == 'ODD')
assert (env.agents['odd_agent'].compute_reward_count == 0)
assert (env.agents['odd_agent'].encode_obs_count == 1)
assert (env.agents['odd_agent'].deco... |
def download_url(url: str, dest: str, overwrite: bool=False, pbar: ProgressBar=None, show_progress=True, chunk_size=(1024 * 1024), timeout=4, retries=5) -> None:
if (os.path.exists(dest) and (not overwrite)):
return
s = requests.Session()
s.mount(' requests.adapters.HTTPAdapter(max_retries=retries))... |
def pad(t: TensorType, paddings: Tuple[(Tuple[(int, int)], ...)], mode: str='constant', value: float=0) -> TensorType:
return t.pad(paddings, mode=mode, value=value) |
def image_transform(image_size: int, is_train: bool, mean: Optional[Tuple[(float, ...)]]=None, std: Optional[Tuple[(float, ...)]]=None, resize_longest_max: bool=False, fill_color: int=0):
mean = (mean or OPENAI_DATASET_MEAN)
if (not isinstance(mean, (list, tuple))):
mean = ((mean,) * 3)
std = (std o... |
class LabelArray(object):
def __init__(self, dim, labels=None):
if (labels is not None):
if (len(dim) != dim):
raise 'The length of labels has to be equal to dim if defined'
else:
self.labels = deepcopy(labels)
else:
self.labels = [... |
def read_bart_coref(filename, gold_text):
regex = '(<[^>]*>)|([^<]* *)'
text = [[]]
mentions = {}
clusters = defaultdict((lambda : []))
unmatched_mentions = []
sentence = 0
word = 0
prev = []
for line in open(filename):
for (tag, token) in re.findall(regex, line.strip()):
... |
class TestRayTuneSearchEngine(ZooTestCase):
def setup_method(self, method):
init_orca_context(init_ray_on_spark=True)
def teardown_method(self, method):
stop_orca_context()
def test_numpy_input(self):
(train_x, train_y, val_x, val_y) = get_np_input()
data = (train_x, train_y)... |
class BalMask(Mask):
def __init__(self, config):
self.logger = logging.getLogger(__name__)
super().__init__(config)
filename = config.get('filename')
if (filename is None):
raise MaskError("Missing argument 'filename' required by BalMask")
los_id_name = config.get... |
class PatchDiscriminator(nn.ModelBase):
def on_build(self, patch_size, in_ch, base_ch=None, conv_kernel_initializer=None):
(suggested_base_ch, kernels_strides) = patch_discriminator_kernels[patch_size]
if (base_ch is None):
base_ch = suggested_base_ch
prev_ch = in_ch
self... |
def prepare_data_gluon(df):
data = np.array(df['data'].values.tolist())
label = df['label'].values
return {'x': data, 'y': label} |
def debounce(wait: float) -> Callable[([Callable[(..., None)]], Callable[(..., bool)])]:
def decorator(fn: Callable[(..., None)]) -> Callable[(..., bool)]:
def debounced(*args, **kwargs) -> bool:
def call_it():
fn(*args, **kwargs)
try:
did_start_new = ... |
class MaskLayer1d(nn.Module):
def __init__(self, append=True, value=0):
super().__init__()
self.append = append
self.value = value
def forward(self, input_tuple):
(x, S) = input_tuple
x = ((x * S) + (self.value * (1 - S)))
if self.append:
x = torch.cat... |
def list_materials():
print("\nAVAILABLE MATERIALS (for fc.Phantom.phan_map = ['MATERIAL']:\nIntegers are atomic numbers\n")
print_files(os.path.join(data_path, 'mu')) |
.slow
.parametrize('alg', algos_cont)
def test_continuous_identity(alg):
kwargs = learn_kwargs[alg]
kwargs.update(common_kwargs)
learn_fn = (lambda e: get_learn_function(alg)(env=e, **kwargs))
env_fn = (lambda : BoxIdentityEnv((1,), episode_len=100))
simple_test(env_fn, learn_fn, (- 0.1)) |
class DensePoseResult(object):
def __init__(self, boxes_xywh, S, I, U, V):
self.results = []
self.boxes_xywh = boxes_xywh.cpu().tolist()
assert (len(boxes_xywh.size()) == 2)
assert (boxes_xywh.size(1) == 4)
for (i, box_xywh) in enumerate(boxes_xywh):
result_i = se... |
class TeacherForcingScheduler(_Scheduler):
def __init__(self, high, low, f=scheduled_sampling, step=0):
super(TeacherForcingScheduler, self).__init__(step)
self.high = high
self.low = low
self._step = step
self.schedule_f = f
def get_tfr(self):
return self.schedul... |
def stack(data, stack_from_deltas=False):
num_bins = (int(((Forest.log_lambda_max - Forest.log_lambda_min) / Forest.delta_log_lambda)) + 1)
stack_log_lambda = (Forest.log_lambda_min + (np.arange(num_bins) * Forest.delta_log_lambda))
stack_delta = np.zeros(num_bins)
stack_weight = np.zeros(num_bins)
... |
def mlp_mixer_l16(num_classes: int, image_size: int=224, channels: int=3):
params = dict(patch_size=16, num_layers=24, hidden_dim=1024, tokens_hidden_dim=512, channels_hidden_dim=4096)
return MLPMixer(num_classes, image_size, channels, **params) |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=0, help='GPU number.')
parser.add_argument('--seed', type=int, default=40, help='Random seed.')
parser.add_argument('--dataset', type=str, default='RNA-Puzzles', help='Dataset to be used')
parser.add_argume... |
class ChainTensorDataset(Dataset):
def __init__(self, *datasets):
self.datasets = datasets
def __getitem__(self, item):
outputs = []
for d in self.datasets:
output = d[item]
if (len(output) < 2):
outputs.append(output[0])
else:
... |
class ImageFilelist(data.Dataset):
def __init__(self, opt, flist_reader=default_flist_reader, loader=default_loader):
self.imlist = flist_reader(opt['image_list'])
self.loader = loader
self.opt = opt
transform_list = [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5,... |
class QDQBertForMultipleChoice(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
class _TestIterableDataset(IterableDataset):
def __init__(self, data_size=32, sleep_time=0):
self.size = data_size
self.sleep_time = sleep_time
def __iter__(self):
worker_info = torch.utils.data.get_worker_info()
if (worker_info is None):
worker_id = 0
else:
... |
class YCbCr2RGB():
def __call__(self, ycbcr):
return F_transforms.ycbcr2rgb(ycbcr)
def __repr__(self):
return f'{self.__class__.__name__}()' |
def test_get_loading_pipeline():
pipelines = [dict(type='LoadImageFromFile'), dict(type='LoadAnnotations', with_bbox=True), dict(type='Resize', img_scale=(1333, 800), keep_ratio=True), dict(type='RandomFlip', flip_ratio=0.5), dict(type='Pad', size_divisor=32), dict(type='DefaultFormatBundle'), dict(type='Collect', ... |
class EfficientNetB3(nn.Module):
def __init__(self, feat_dim=12, feature_block=6):
super(EfficientNetB3, self).__init__()
self.backbone_net = EfficientNet.from_pretrained('efficientnet-b3')
self.feature_block = feature_block
if (self.feature_block == 6):
self.feature_extr... |
class CIFAR(Dataset):
def __init__(self, root, train=True, transform=None, target_transform=None, top_k=(1, 5), is_cifar100=True, keep_rgb=False):
if is_cifar100:
self.data_set = CIFAR100(root, train=train, download=True)
else:
self.data_set = CIFAR10(root, train=train, downl... |
def parse_args():
parser = argparse.ArgumentParser(description='mmediting tester')
parser.add_argument('config', help='test config file path')
parser.add_argument('model', help='input model file')
parser.add_argument('backend', help='backend of the model.', choices=['onnxruntime', 'tensorrt'])
parse... |
def _ms_loop(dataset, index_queue, data_queue, collate_fn, seed, init_fn, worker_id):
global _use_shared_memory
_use_shared_memory = True
_set_worker_signal_handlers()
torch.set_num_threads(1)
torch.manual_seed(seed)
while True:
r = index_queue.get()
if (r is None):
b... |
def create_eos_event():
eos_event = compound_event.copy()
eos_event['type'] = 'EOS'
return eos_event |
_model
def xception71(pretrained=False, **kwargs):
block_cfg = [dict(in_chs=64, out_chs=128, stride=2), dict(in_chs=128, out_chs=256, stride=1), dict(in_chs=256, out_chs=256, stride=2), dict(in_chs=256, out_chs=728, stride=1), dict(in_chs=728, out_chs=728, stride=2), *([dict(in_chs=728, out_chs=728, stride=1)] * 16... |
class DCShadowNet(object):
def __init__(self, args):
self.model_name = 'DCShadowNet'
self.result_dir = args.result_dir
self.dataset = args.dataset
self.datasetpath = args.datasetpath
self.iteration = args.iteration
self.decay_flag = args.decay_flag
self.batch_... |
def build_negative_set(plt_set1, plt_set2, car_set1, car_set2, ptrn_set, ptst_set, amount, multiply):
size = (len(ptrn_set) + (multiply * len(ptst_set)))
data = collecting_negative_samples(plt_set1, plt_set2, car_set1, car_set2, size, amount)
np.random.shuffle(data)
ntrn_set = data[:len(ptrn_set)]
n... |
def test_log_linear_equals_log_linear_exp_log():
key = jax.random.PRNGKey(0)
(key, subkey) = jax.random.split(key)
x = jax.random.normal(subkey, (9, 5))
(sign_x, log_x) = slog_helpers.array_to_slog(x)
(key, subkey) = jax.random.split(key)
kernel = jax.random.normal(subkey, (5, 7))
(sign_line... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.