code stringlengths 101 5.91M |
|---|
def plot_samples(sess, shape, prior, decoder):
z = prior.sample(100)
x = decoder.encode(z, sampling=False)
samples = sess.run(x)
plot_images(samples, shape, '', 'samples') |
_config
def alexnet():
uuid = 'habitat_alexnet_feature'
cfg = {}
cfg['learner'] = {'perception_network': 'AlexNetFeaturesOnlyNet', 'perception_network_kwargs': {'extra_kwargs': {'main_perception_network': 'AlexNetFeaturesOnlyNet'}}}
cfg['env'] = {'env_specific_kwargs': {'target_dim': 13}, 'transform_fn_... |
class Pose(xmlr.Object):
def __init__(self, xyz=None, rpy=None):
self.xyz = xyz
self.rpy = rpy
def check_valid(self):
assert (((self.xyz is None) or (len(self.xyz) == 3)) and ((self.rpy is None) or (len(self.rpy) == 3)))
def rotation(self):
return self.rpy
def rotation(se... |
def default_style(num_v: int, num_e: int, v_color: Union[(str, list)]='r', e_color: Union[(str, list)]='gray', e_fill_color: Union[(str, list)]='whitesmoke'):
_v_color = 'r'
_e_color = 'gray'
_e_fill_color = 'whitesmoke'
v_color = fill_color(v_color, _v_color, num_v)
e_color = fill_color(e_color, _e... |
def recode_cc_data(frame):
sex_dict = {1: 'male', 2: 'female'}
education_dict = {0: 'other', 1: 'graduate school', 2: 'university', 3: 'high school', 4: 'other', 5: 'other', 6: 'other'}
marriage_dict = {0: 'other', 1: 'married', 2: 'single', 3: 'divorced'}
pay_dict = {(- 2): 'no consumption', (- 1): 'pa... |
class DebertaTokenizationTest(TokenizerTesterMixin, unittest.TestCase):
tokenizer_class = DebertaTokenizer
test_rust_tokenizer = True
rust_tokenizer_class = DebertaTokenizerFast
def setUp(self):
super().setUp()
vocab = ['l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', 'G', 'Gl', 'Gn', '... |
def _initialize_centroids(X, k, algorithm='first-k', random_state=None):
if isinstance(k, torch.Tensor):
k = k.item()
if (not isinstance(random_state, numpy.random.mtrand.RandomState)):
random_state = numpy.random.RandomState(random_state)
if (algorithm == 'first-k'):
return _cast_as... |
class BeitForImageClassification(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def gen_samples(vec):
sentences = []
sentences = generate(autoencoder, gan_gen, z=torch.FloatTensor(vec).view(1, (- 1)).expand(20, vec.shape[0]), vocab=idx2word, sample=True, maxlen=model_args['maxlen'])[0]
return sentences |
class EpochBatchIterating(object):
def __len__(self) -> int:
raise NotImplementedError
def next_epoch_idx(self):
raise NotImplementedError
def next_epoch_itr(self, shuffle=True, fix_batches_to_gpus=False, set_dataset_epoch=True):
raise NotImplementedError
def end_of_epoch(self) -... |
def window(iterable, stride=3):
for index in range(((len(iterable) - stride) + 1)):
(yield iterable[index:(index + stride)]) |
_cache
def check_float_literals():
legal_literals = []
try:
completed_process = subprocess.run(['make', 'check-float-literals'], capture_output=True)
legal_literals = completed_process.stdout.decode().split('\n')
except Exception:
pass
legal_literals = [legal_literal for legal_li... |
def get_test_data_dirs(prefix):
gt_data_root = (Path.home() / 'open3d_data')
gt_download_dir = ((gt_data_root / 'download') / prefix)
gt_extract_dir = ((gt_data_root / 'extract') / prefix)
return (gt_data_root, gt_download_dir, gt_extract_dir) |
def create_ds_config(args):
args.deepspeed_config = os.path.join(args.output_dir, 'deepspeed_config.json')
with open(args.deepspeed_config, mode='w') as writer:
ds_config = {'train_batch_size': ((args.batch_size * args.update_freq) * get_world_size()), 'train_micro_batch_size_per_gpu': args.batch_size, ... |
class AdversarialLoss(nn.Module):
def __init__(self, type='nsgan', target_real_label=1.0, target_fake_label=0.0):
super(AdversarialLoss, self).__init__()
self.type = type
self.register_buffer('real_label', torch.tensor(target_real_label))
self.register_buffer('fake_label', torch.tens... |
def seresnet110_svhn(num_classes=10, **kwargs):
return get_seresnet_cifar(num_classes=num_classes, blocks=110, bottleneck=False, model_name='seresnet110_svhn', **kwargs) |
def attention(query, num_heads, y_w, v, hidden, hidden_features, attention_vec_size, attn_length, use_global_attention=False):
at_logits = []
at_probs = []
ds = []
if nest.is_sequence(query):
query_list = nest.flatten(query)
for q in query_list:
ndims = q.get_shape().ndims
... |
class Corpus(object):
def __init__(self, vocab, debug=False):
self.vocab = vocab
self.encoded_train = self.encode_corpus('train.txt', debug)
self.encoded_dev = self.encode_corpus('dev.txt', debug)
self.encoded_test = self.encode_corpus('test.txt', debug)
def encode_corpus(self, f... |
class SResTransformerPredict(torch.nn.Module):
def __init__(self, d_model, coords, flatten_order, attention_type='full', n_layers=4, n_heads=4, d_query=32, dropout=0.1, attention_dropout=0.1):
super(SResTransformerPredict, self).__init__()
self.fourier_coefficient_embedding = torch.nn.Linear(2, (d_m... |
def sub(scores0, scores1):
combined = []
for (a, b) in zip(scores0, scores1):
combined.append(abs((a - b)))
return combined |
def generate_toy_features(dataset_path: str, num_frames: int=500, num_joints: int=50):
skeletons = []
head_width = []
midbody_width = []
tail_width = []
init_angle = np.arange(0, num_frames)
for i in range(num_frames):
skel = []
center = ((IM_SIZE // 2), (IM_SIZE // 2))
w... |
def write_vtt(transcript: Iterator[dict], file: TextIO):
print('WEBVTT\n', file=file)
for segment in transcript:
print(f'''{format_timestamp(segment['start'])} --> {format_timestamp(segment['end'])}
{segment['text'].strip().replace('-->', '->')}
''', file=file, flush=True) |
class RteProcessor(DataProcessor):
def get_example_from_tensor_dict(self, tensor_dict):
return InputExample(tensor_dict['idx'].numpy(), tensor_dict['sentence1'].numpy().decode('utf-8'), tensor_dict['sentence2'].numpy().decode('utf-8'), str(tensor_dict['label'].numpy()))
def get_train_examples(self, data... |
class DatasetManager():
def __init__(self, data, super_category, sub_category, round_id, oversampling_ratio, cross_validation=10):
self.data = data
self.super_category = super_category
self.sub_category = sub_category
self.round_id = (round_id - 1)
self.sampling_ratio = overs... |
class DownSampler(nn.Module):
def __init__(self, nin, nout, k=4, r_lim=9, reinf=True):
super().__init__()
nout_new = (nout - nin)
self.eesp = EESP(nin, nout_new, stride=2, k=k, r_lim=r_lim, down_method='avg')
self.avg = nn.AvgPool2d(kernel_size=3, padding=1, stride=2)
if rein... |
def load_data(args):
folder_src = os.path.join(args.data_dir, args.src_domain)
folder_tgt = os.path.join(args.data_dir, args.tgt_domain)
(source_loader, n_class) = data_loader.load_data(folder_src, args.batch_size, infinite_data_loader=(not args.epoch_based_training), train=True, num_workers=args.num_worker... |
def multi_gpu_test(model, data_loader, tmpdir=None, gpu_collect=False):
model.eval()
results = []
dataset = data_loader.dataset
(rank, world_size) = get_dist_info()
if (rank == 0):
prog_bar = mmcv.ProgressBar(len(dataset))
for data in data_loader:
with torch.no_grad():
... |
def load_model(path, compile=False, remove_last_n_layers=0):
loaded_model = keras.models.load_model(path, compile=compile, custom_objects={'PatchEncoder': PatchEncoder, 'Switch': Switch, 'Router': Router})
if (remove_last_n_layers == 0):
return loaded_model
else:
model = keras.Model(inputs=l... |
def create_dataloaders(args):
ds_kwargs = {'streaming': True}
train_data = load_dataset(args.dataset_name_train, split='train', **ds_kwargs)
train_data = train_data.shuffle(buffer_size=args.shuffle_buffer, seed=args.seed)
valid_data = load_dataset(args.dataset_name_valid, split='train', **ds_kwargs)
... |
class HourglassNet(exkp):
def __init__(self, heads, num_stacks=2):
n = 5
dims = [256, 256, 384, 384, 384, 512]
modules = [2, 2, 2, 2, 2, 4]
super(HourglassNet, self).__init__(n, num_stacks, dims, modules, heads, make_tl_layer=None, make_br_layer=None, make_pool_layer=make_pool_layer,... |
def generalized_cross_entropy(y_true, y_pred):
q = 0.7
t_loss = ((1 - tf.pow(tf.reduce_sum((y_true * y_pred), axis=(- 1)), q)) / q)
return tf.reduce_mean(t_loss) |
class BaseOptions():
def __init__(self):
self.initialized = False
self.isTrain = True
def initialize(self, parser):
parser.add_argument('--name', type=str, default='cityscapes_from_gta5', help='name of the experiment. It decides where to store samples and models')
parser.add_argu... |
class PieceWiseConstantLrSchedulerMaker(object):
def __init__(self, milestones: List[int], gamma: float=0.1):
self.milestones = milestones
self.gamma = gamma
def __call__(self, optimizer):
return torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=self.milestones, gamma=self.gamma... |
def compact(text):
page = []
headers = {}
emptySection = False
listLevel = []
listCount = []
for line in text.split('\n'):
if (not line):
if len(listLevel):
page.append(line)
if options.toHTML:
for c in reversed(listLevel):
... |
def crop_hwc(image, bbox, out_sz, padding=(0, 0, 0)):
a = ((out_sz - 1) / (bbox[2] - bbox[0]))
b = ((out_sz - 1) / (bbox[3] - bbox[1]))
c = ((- a) * bbox[0])
d = ((- b) * bbox[1])
mapping = np.array([[a, 0, c], [0, b, d]]).astype(np.float)
crop = cv2.warpAffine(image, mapping, (out_sz, out_sz), ... |
def ibn_densenet169(**kwargs):
return get_ibndensenet(num_layers=169, model_name='ibn_densenet169', **kwargs) |
def cc(net):
if torch.cuda.is_available():
return net.cuda()
else:
return net |
class Tox21(MoleculeCSVDataset):
def __init__(self, smiles_to_graph=smiles_2_dgl, load=False, log_every=1000, cache_file_path='./tox21_dglgraph.bin', n_jobs=1):
self._url = 'dataset/tox21.csv.gz'
data_path = (get_download_dir() + '/tox21.csv.gz')
download(_get_dgl_url(self._url), path=data_p... |
def load_pretrained_weights(model, model_name, load_fc=True, advprop=False):
url_map_ = (url_map_advprop if advprop else url_map)
pretrained_dict = model_zoo.load_url(url_map_[model_name], map_location=torch.device('cpu'))
model_dict = model.state_dict()
for name in copy.deepcopy(model_dict).keys():
... |
class TrueCaser():
uppercase_pos = ['PROPN']
def __init__(self, backend='spacy'):
if (backend == 'spacy'):
import spacy
self.nlp = spacy.load('en_core_web_sm')
self.normalize_fn = self._spacy_truecasing
else:
from nltk import pos_tag, word_tokenize... |
_registry(op_types='Softmax, BiasGelu, Elu, Exp, FastGelu, Gelu, Softplus, Tanh')
class Float16ActivationOperator(Operator):
def __init__(self, onnx_quantizer, onnx_node):
super(Float16ActivationOperator, self).__init__(onnx_quantizer, onnx_node) |
def test_get_py_file_if_possible_with_py_file():
assert (get_py_file_if_possible(EXAMPLE_SOURCE) == EXAMPLE_SOURCE) |
def generate_slicing_transform_function(transform_func_structs, slicing_axis=2, concatenate_axis=2):
def slicing_transform_func(sample):
all_slices = []
for (indices, transform_func) in transform_func_structs:
trasnformed_slice = transform_func(np.take(sample, indices, slicing_axis))
... |
def parse_args_and_update_hparams(H, parser, s=None):
H = dataclasses.replace(H, **vars(parser.parse_args(s)))
hparam_sets = [x for x in H.hps.split(',') if x]
for hp_set in hparam_sets:
hps = HPARAMS_REGISTRY[hp_set]
parser.set_defaults(**hps)
return dataclasses.replace(H, **vars(parser... |
def text_record(filename, text_model):
textfile = open(filename, 'w')
for i in range(5):
sentence = text_model.make_sentence()
textfile.write(sentence)
textfile.close() |
_criterion('magnitude')
class MagnitudeCriterion(PruningCriterion):
def __init__(self, modules, config, pattern):
super(MagnitudeCriterion, self).__init__(modules, config, pattern)
def on_step_begin(self):
with torch.no_grad():
for key in self.modules.keys():
p = self... |
class IdentityBijection(Bijection):
def __init__(self, x_shape):
super().__init__(x_shape=x_shape, z_shape=x_shape)
def _x_to_z(self, x, **kwargs):
return {'z': x, 'log-jac': self._log_jac_like(x)}
def _z_to_x(self, z, **kwargs):
return {'x': z, 'log-jac': self._log_jac_like(z)}
... |
def get_checkpoint_url(config_path):
url = _ModelZooUrls.query(config_path)
if (url is None):
raise RuntimeError('Pretrained model for {} is not available!'.format(config_path))
return url |
def get_agent_view(grid: chex.Array, agent: chex.Array, sensor_range: chex.Array) -> Tuple[(chex.Array, chex.Array)]:
receptive_field = ((sensor_range * 2) + 1)
padded_agents_layer = jnp.pad(grid[_AGENTS], sensor_range, mode='constant')
padded_shelves_layer = jnp.pad(grid[_SHELVES], sensor_range, mode='cons... |
def print_state(train_ctx: Context, formats: List[str], join_str: str=' | ') -> None:
def unescape(escapped_str):
return bytes(escapped_str, 'utf-8').decode('unicode_escape')
def safe_format(format_str, **kwargs):
try:
return format_str.format(**kwargs)
except:
re... |
def slurm_run_scripts(scripts):
assert isinstance(scripts, str)
os.chdir(slurm_dir)
assert scripts.startswith('#!/usr/bin/env bash\n')
file_temp = NamedTemporaryFile(delete=False)
file_temp.write(scripts.encode('utf-8'))
file_temp.close()
run(['sbatch', file_temp.name], check=True)
os.re... |
def seresnet164bn_cifar10(num_classes=10, **kwargs):
return get_seresnet_cifar(num_classes=num_classes, blocks=164, bottleneck=True, model_name='seresnet164bn_cifar10', **kwargs) |
def prob_eval_runner(benchmark, old_eval: bool=False, vec_input: bool=False, parallel: bool=False, uniform: bool=True, cmplx: bool=False, input_dim: int=10, bond_dim: int=10, seq_len: int=100, batch: int=100):
if uniform:
mps_model = ProbUnifMPS(input_dim, bond_dim, cmplx, parallel)
else:
mps_mo... |
class TestDataset(unittest.TestCase):
def setUpClass(cls) -> None:
cls._orig_logging_level = sf.getLoggingLevel()
sf.setLoggingLevel(40)
cls.PROJECT = TestConfig().create_project(overwrite=True)
def tearDownClass(cls) -> None:
super().tearDownClass()
sf.setLoggingLevel(cl... |
def load_weight_checkpoint(model: peft.LoraModel, checkpoint_path: str):
modules = find_lora_modules(model)
shard_paths = sharded_paths(checkpoint_path, modules.keys())
unique_shards = list(set(shard_paths.values()))
for shard_path in unique_shards:
tensors = st.load_file(os.path.join(checkpoint... |
def update_counts(s, counts):
for char in s:
if (char in counts):
counts[char] += 1 |
class RPNHead(object):
__inject__ = ['anchor_generator', 'rpn_target_assign', 'train_proposal', 'test_proposal']
def __init__(self, anchor_generator=AnchorGenerator().__dict__, rpn_target_assign=RPNTargetAssign().__dict__, train_proposal=GenerateProposals(12000, 2000).__dict__, test_proposal=GenerateProposals()... |
_module()
class mit_b4(MixVisionTransformer):
def __init__(self, **kwargs):
super(mit_b4, self).__init__(patch_size=4, embed_dims=[64, 128, 320, 512], num_heads=[1, 2, 5, 8], mlp_ratios=[4, 4, 4, 4], qkv_bias=True, norm_layer=partial(nn.LayerNorm, eps=1e-06), depths=[3, 8, 27, 3], sr_ratios=[8, 4, 2, 1], **... |
def test_chained_config_scopes_fix_subentries():
def cfg1():
d = {'a': 10, 'b': 20}
def cfg2():
pass
(final_cfg, summary) = chain_evaluate_config_scopes([cfg1, cfg2], fixed={'d': {'a': 0}})
assert (set(final_cfg['d'].keys()) == {'a', 'b'})
assert (final_cfg['d']['a'] == 0)
assert... |
def test_next_track(precision='d', decimals=80):
from phcpy.solver import total_degree_start_system
quadrics = ['x**2 + 4*y**2 - 4;', '2*y**2 - x;']
(startsys, startsols) = total_degree_start_system(quadrics)
print('the first start solution :\n', startsols[0])
if (precision == 'd'):
initiali... |
def get_data(name, data_dir, height, width, ratio, batch_size, workers, num_instances):
root = osp.join(data_dir, name)
root = data_dir
dataset = datasets.create(name, root)
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
num_classes = dataset.num_train_ids
train_... |
class AAMSoftmax(nn.Module):
def __init__(self, n_class, m, s):
super(AAMSoftmax, self).__init__()
self.m = m
self.s = s
self.weight = torch.nn.Parameter(torch.FloatTensor(n_class, 192), requires_grad=True)
nn.init.xavier_normal_(self.weight, gain=1)
self.ce = nn.Cros... |
class DataSet():
def __init__(self, dir):
os.mkdir(dir)
self.tst = open(os.path.join(dir, 'corpus.tst'), 'w')
self.ref = open(os.path.join(dir, 'corpus.ref'), 'w')
self.ter = open(os.path.join(dir, 'corpus.ter'), 'w')
self.tst.write('<tstset trglang="any" setid="any" srclang=... |
def test_merged_configs():
test_config = get_config(CFG_TEST)
eqa_config = get_config(CFG_EQA)
merged_config = get_config('{},{}'.format(CFG_TEST, CFG_EQA))
assert (merged_config.TASK.TYPE == eqa_config.TASK.TYPE)
assert (merged_config.ENVIRONMENT.MAX_EPISODE_STEPS == test_config.ENVIRONMENT.MAX_EPI... |
def concatChar(input_lines, char_dict):
features = [(([char_dict[' ']] + list(reduce((lambda x, y: ((x + [char_dict[' ']]) + y)), sentence))) + [char_dict['\n']]) for sentence in input_lines]
return features |
class TestArgs(BaseArgs):
def __init__(self):
super().__init__()
def add_args(self):
super().add_args()
self.parser.set_defaults(batch_size=1)
self.parser.add_argument('--id_dir', type=Path)
self.parser.add_argument('--attr_dir', type=Path)
self.parser.add_argumen... |
(version='2.3.0', reason='Please use spark engine and ray engine.')
class DistributedSequentialSampler(Sampler):
def __init__(self, dataset, num_replicas, rank):
self.dataset = dataset
self.num_samples = int(math.floor(((len(self.dataset) * 1.0) / num_replicas)))
extra_samples = (len(self.da... |
class RandomVerticalCropCont(object):
def __init__(self, height, width):
self.height = height
self.width = width
def __call__(self, img):
(w, h) = img.size
ratio = min(1, np.random.uniform(0.5, 1.08333))
ratio = float(ratio)
jitter = np.random.uniform(0.9, 1.11111... |
class LayerNorm2d(nn.LayerNorm):
def __init__(self, num_channels):
super().__init__(num_channels)
def forward(self, x: torch.Tensor) -> torch.Tensor:
return F.layer_norm(x.permute(0, 2, 3, 1), self.normalized_shape, self.weight, self.bias, self.eps).permute(0, 3, 1, 2) |
class SeparatorStyle(Enum):
ADD_COLON_SINGLE = auto()
ADD_COLON_TWO = auto()
ADD_COLON_SPACE_SINGLE = auto()
NO_COLON_SINGLE = auto()
ADD_NEW_LINE_SINGLE = auto()
DOLLY = auto()
RWKV = auto()
PHOENIX = auto()
BAYLING = auto()
ALPACA = auto() |
def main():
Nin = 784
Nh_l = [100, 50]
number_of_class = 10
Nout = number_of_class
((X_train, Y_train), (X_test, Y_test)) = Data_func()
model = DNN(Nin, Nh_l, Nout)
history = model.fit(X_train, y_train, epochs=10, batch_size=100, validation_split=0.2)
performace_test = model.evaluate(X_t... |
def test_fermi_report_number_ESH():
ref_line = u'[11] T. Sanami, Applicability of a Bonner Sphere technique for pulsed neutron in 120 GeV proton facility, in Proceedings of the 22nd Workshop on Radiation Detectors and Their Uses, pp. 148-159, FERMILAB-CONF-08-203-AD-APC-E-ESH (2008).'
res = get_references(ref_l... |
def test_masked_backward(model, X, X_masked):
X = torch.tensor(numpy.array(X))
mask = torch.ones_like(X).type(torch.bool)
X_ = torch.masked.MaskedTensor(X, mask=mask)
b = model.backward(X_)
assert_array_almost_equal(b, [[[(- 18.8311), (- 19.113)], [(- 15.5423), (- 15.83)], [(- 10.8078), (- 11.0955)]... |
class GPT2TokenizerFast():
def __init__(self, *args, **kwargs):
requires_tokenizers(self)
def from_pretrained(self, *args, **kwargs):
requires_tokenizers(self) |
class TuningCriterion():
def __init__(self, strategy='basic', strategy_kwargs=None, timeout=0, max_trials=100, objective='performance'):
self.strategy = strategy
self.timeout = timeout
self.max_trials = max_trials
self.objective = objective
self.strategy_kwargs = strategy_kwa... |
class InceptionAux(nn.Module):
def __init__(self, in_channels, num_classes, conv_block=None):
super(InceptionAux, self).__init__()
if (conv_block is None):
conv_block = BasicConv2d
self.conv0 = conv_block(in_channels, 128, kernel_size=1)
self.conv1 = conv_block(128, 768, ... |
def svr(name, kernels=['linear', 'rbf', 'poly', 'sigmoid'], **kwargs):
svms = {'linear': partial(svr_linear, name=name), 'rbf': partial(svr_rbf, name=name), 'poly': partial(svr_poly, name=name), 'sigmoid': partial(svr_sigmoid, name=name)}
choices = [svms[kern](**kwargs) for kern in kernels]
if (len(choices)... |
class TestTwoQubitWeylDecomposition(QiskitTestCase):
def check_two_qubit_weyl_decomposition(self, target_unitary, tolerance=1e-07):
with self.subTest(unitary=target_unitary):
decomp = TwoQubitWeylDecomposition(target_unitary)
q = QuantumRegister(2)
decomp_circuit = Quantu... |
def subdict(d: Dict[(str, Any)], keys: List[str]) -> Dict[(str, Any)]:
return {k: v for (k, v) in d.items() if (k in keys)} |
class RemoveGrid(SparseModule):
def forward(self, x: SparseConvTensor):
x.grid = None
return x |
def scale_ocr_x(x, dimensions_scenegraph, dimensions_ocr):
return ((x * dimensions_scenegraph[0]) / dimensions_ocr[0]) |
class SubPolicy(object):
def __init__(self, p1, operation1, magnitude_idx1, p2, operation2, magnitude_idx2, fillcolor=(128, 128, 128)):
ranges = {'shearX': np.linspace(0, 0.3, 10), 'shearY': np.linspace(0, 0.3, 10), 'translateX': np.linspace(0, (150 / 331), 10), 'translateY': np.linspace(0, (150 / 331), 10)... |
def all_input_planes(fen):
current_aux_planes = aux_planes(fen)
history_both = to_planes(fen)
ret = np.vstack((history_both, current_aux_planes))
assert (ret.shape == (18, 8, 8))
return ret |
def build_one(frames=64, bands=40, n_classes=10, dropout=0.0, tstride=1, fstride=4):
from keras.layers import Conv2D, Dense, Dropout, Flatten
conv_f = 8
conv_t = 32
kernels = 90
bottleneck = 32
input_shape = (frames, bands, 1)
model = keras.Sequential([Conv2D(kernels, (conv_t, conv_f), strid... |
_torch
class TvltProcessorTest(unittest.TestCase):
def setUp(self):
self.checkpoint = 'ZinengTang/tvlt-base'
self.tmpdirname = tempfile.mkdtemp()
def get_image_processor(self, **kwargs):
return TvltImageProcessor.from_pretrained(self.checkpoint, **kwargs)
def get_feature_extractor(se... |
(params=[('True', 'fixed_thres', 0.5, 0.2, ParCorr, 1, 0.5), ('True', 'fixed_thres', 0.5, 0.5, ParCorr, 1, 0.5), ('True', 'fixed_thres', 0.8, 0.2, ParCorr, 1, 0.5), ('True', 'fixed_thres', 0.8, 0.5, ParCorr, 1, 0.5), ('True', 'analytic', 0.5, 0.2, ParCorr, None, None), ('True', 'shuffle_test', 0.5, 0.2, ParCorr, None, ... |
class Permutation():
def __init__(self, length: int):
self.counter = 0
self.length = length
self.permutation = np.random.permutation(length)
def get_next_value(self):
next_value = self.permutation[self.counter]
self.counter += 1
if (self.counter == self.length):
... |
class Uniform(Distribution):
def __init__(self, mins=None, maxs=None, inertia=0.0, frozen=False, check_data=True):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = 'Uniform'
self.mins = _check_parameter(_cast_as_parameter(mins), 'mins', ndim=1)
self... |
class PruningCriterion():
def __init__(self, modules, config):
self.scores = {}
self.modules = modules
self.config = config
def on_step_begin(self):
pass
def on_before_optimizer_step(self):
pass
def on_after_optimizer_step(self):
pass |
def load_queries(query_path):
query = {}
with open(query_path, 'r') as f:
for line in tqdm(f, desc='loading query....'):
(qid, text) = line.strip().split('\t')
query[qid] = text
return query |
class PMXeon_X5570(PM):
def __init__(self):
super().__init__()
self.powerlist = [81.4, 110, 125, 139, 153, 167, 182, 199, 214, 229, 244]
def power(self):
cpu = self.host.getCPU()
index = math.floor((cpu / 10))
left = self.powerlist[index]
right = self.powerlist[((... |
def gen_nice_inds():
for i in range(26):
(yield chr((ord('a') + i)))
for i in range(26):
(yield chr((ord('A') + i)))
for i in itertools.count(192):
(yield chr(i)) |
def __crop(img, pos, size):
(ow, oh) = img.size
(x1, y1) = pos
tw = th = size
if ((ow > tw) or (oh > th)):
return img.crop((x1, y1, (x1 + tw), (y1 + th)))
return img |
def ksave(kspace, filepath):
path = (os.path.dirname(filepath) or '.')
if (not os.path.exists(path)):
os.makedirs(path)
img = np.abs(kspace)
img /= np.max(img)
img = np.log((img + 1e-05))
scipy.misc.imsave(filepath, _normalize(img).astype(np.uint8)) |
def de_resnet18(pretrained: bool=False, progress: bool=True, **kwargs: Any) -> ResNet:
return _resnet('resnet18', BasicBlock, [2, 2, 2, 2], pretrained, progress, **kwargs) |
def save_training_config(config_file, output_dir):
json_data = read_json(config_file)
save_json(os.path.join(output_dir, 'training_config.json'), json_data) |
def target_days_to_cols(target_days):
predicted_cols = [f'Predicted Deaths {day}-day' for day in target_days]
return predicted_cols |
def test_digits_two_stage():
model1 = FeatureBasedSelection(100, 'sqrt')
model2 = FeatureBasedSelection(100, 'log')
model = MixtureSelection(100, [model1, model2], [1.0, 0.3], optimizer='two-stage')
model.fit(X_digits)
assert_array_equal(model.ranking, digits_ranking)
assert_array_almost_equal(m... |
class PegasusConverter(SpmConverter):
def vocab(self, proto):
vocab = [(self.original_tokenizer.pad_token, 0.0), (self.original_tokenizer.eos_token, 0.0), (self.original_tokenizer.mask_token_sent, 0.0), (self.original_tokenizer.mask_token, 0.0)]
vocab += [(f'<unk_{i}>', (- 100.0)) for i in range(2, ... |
def crop_images(image_list, offset, size, name=None, verbose=0):
with tf.name_scope(name, 'crop_images', [image_list, size]) as name:
if isinstance(image_list, list):
cropped_image_list = []
size = ops.convert_to_tensor(size, dtype=dtypes.int32, name='size')
for image in ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.