code stringlengths 101 5.91M |
|---|
_materialize('core')
class Slice(UnaryOpBase):
in_dtypes = [(i,) for i in DTYPE_GEN_ALL]
INT_MAX = ((2 ** 63) - 1)
INT_MIN = (- (2 ** 63))
def __init__(self, start, end, step):
super().__init__()
self.inp_ranks = [rank_from(1)]
self.out_ranks = [rank_from(1)]
self.start =... |
def train(model, device, train_loader, sm_loader, criterion, optimizer, epoch, args, writer):
num_class = 10
sa = np.zeros((num_class, (num_class - 1)), dtype=np.int32)
for i in range(sa.shape[0]):
for j in range(sa.shape[1]):
if (j < i):
sa[i][j] = j
else:
... |
def _check_dt_is_sorted(df, dt_col):
import numpy as np
import warnings
df = df.copy()
try:
res = (np.diff(df[dt_col].values.astype(np.float32)) >= 0).all()
if (not res):
from bigdl.nano.utils.common import invalidInputError
invalidInputError(False, f'{dt_col} mus... |
def test_ExponentialEps():
T = 5
eps_vals = np.logspace(np.log10(10), np.log10(5), T)
eps = abcpmc.ExponentialEps(T, eps_vals[0], eps_vals[(- 1)])
for (e1, e2) in zip(eps, eps_vals):
assert (e1 == e2)
assert (e1 == eps_vals[(- 1)]) |
_model
def ig_resnext101_32x8d(pretrained=True, **kwargs):
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=8, **kwargs)
return _create_resnet('ig_resnext101_32x8d', pretrained, **model_args) |
def setup_training_loop_kwargs(gpus=None, snap=None, seed=None, data=None, video_balance=None, sg2_pkl=None, noise_mode=None, cfg=None, kimg=None, batch=None, optim=None, resume=None, allow_tf32=None, nobench=None, workers=None, suffix=None):
args = dnnlib.EasyDict()
if (gpus is None):
gpus = 1
asse... |
class TestQKVLinear(unittest.TestCase):
device_dtype_combine = [('cpu', torch.float32), ('cuda', torch.float32), ('cuda', torch.float16)]
def setUp(self) -> None:
torch.manual_seed(1241)
return super().setUp()
def test_qkv_fused(self):
for (device, dtype) in self.device_dtype_combine... |
def send_message(text):
if NOTIFY:
body = (('News from ' + socket.gethostname()) + ': \n')
body += text
updater.bot.send_message(chat_id=CHAT_ID, text=body) |
class _UpProjection(nn.Sequential):
def __init__(self, num_input_features, num_output_features):
super(_UpProjection, self).__init__()
self.conv1 = nn.Conv2d(num_input_features, num_output_features, kernel_size=5, stride=1, padding=2, bias=False)
self.bn1 = nn.BatchNorm2d(num_output_features... |
def setup(opt):
if (opt.caption_model == 'fc'):
model = FCModel(opt)
elif (opt.caption_model == 'language_model'):
model = LMModel(opt)
elif (opt.caption_model == 'newfc'):
model = NewFCModel(opt)
elif (opt.caption_model == 'show_tell'):
model = ShowTellModel(opt)
eli... |
.parametrize('hidden_dims, static_dim, static_in_all_layers', [([10, 5, 20], False, False), ([10, 100, 10], True, True), ([10, 50, 30, 40], True, False)])
def test_stacked(hidden_dims, static_dim, static_in_all_layers):
input_dim = 50
static_dim = 5
(data, labels) = make_time_series_problem(n_channels=input... |
def IEMOCAPUnbalanced_train(sample):
if sample:
return {'class_balance': (lambda r: True), 'lr': (lambda r: (10 ** r.uniform((- 3), (- 5)))), 'weight_decay': (lambda r: 0.0), 'batch_size': (lambda r: int((2 ** r.uniform(4, 6))))}
else:
return {'class_balance': (lambda r: True), 'lr': (lambda r: ... |
def check_current_planes(realfen, planes):
cur = planes[0:12]
assert (cur.shape == (12, 8, 8))
fakefen = (['1'] * 64)
for i in range(12):
for rank in range(8):
for file in range(8):
if (cur[i][rank][file] == 1):
assert (fakefen[((rank * 8) + file)]... |
def redirect(graph, node1, node2):
if (not isinstance(node1, Node)):
node1 = graph[node1]
if (not isinstance(node2, Node)):
node2 = graph[node2]
for e in graph.edges:
if (node1 in (e.node1, e.node2)):
if ((e.node1 == node1) and (e.node2 != node2)):
graph._... |
class QuantizableInvertedResidual(shufflenetv2.InvertedResidual):
def __init__(self, *args, **kwargs):
super(QuantizableInvertedResidual, self).__init__(*args, **kwargs)
self.cat = nn.quantized.FloatFunctional()
def forward(self, x):
if (self.stride == 1):
(x1, x2) = x.chunk(... |
def _check_col_within(df, col_name):
from bigdl.nano.utils.common import invalidInputError
invalidInputError((col_name in df.columns), f'{col_name} is expected in dataframe while not found') |
def reconstruction_error(S1, S2, reduction='mean'):
S1_hat = compute_similarity_transform_batch(S1, S2)
re = np.sqrt(((S1_hat - S2) ** 2).sum(axis=(- 1))).mean(axis=(- 1))
if (reduction == 'mean'):
re = re.mean()
elif (reduction == 'sum'):
re = re.sum()
return re |
class LookupValidation():
data: ValidationResult
def __init__(self):
self.data = ValidationResult()
def has_error(self, name: str) -> bool:
return (name in self.data.errors)
def get_error_count(self) -> int:
return self.data.error_count
def set_error_status(self) -> None:
... |
class AgentState(EntityState):
def __init__(self):
super(AgentState, self).__init__()
self.c = None |
def custom_draw_geometry_with_camera_trajectory(pcd, render_option_path, camera_trajectory_path):
custom_draw_geometry_with_camera_trajectory.index = (- 1)
custom_draw_geometry_with_camera_trajectory.trajectory = o3d.io.read_pinhole_camera_trajectory(camera_trajectory_path)
custom_draw_geometry_with_camera_... |
def test_is_terminated(phantom_env):
phantom_env._terminations = set()
assert (not phantom_env.is_terminated())
phantom_env._terminations = set(['A'])
assert (not phantom_env.is_terminated())
phantom_env._terminations = set(['A', 'B'])
assert phantom_env.is_terminated() |
class OutputTransition(nn.Module):
def __init__(self, inChans, elu, nll):
super(OutputTransition, self).__init__()
self.conv1 = nn.Conv3d(inChans, 2, kernel_size=5, padding=2)
self.bn1 = ContBatchNorm3d(2)
self.conv2 = nn.Conv3d(2, 2, kernel_size=1)
self.relu1 = ELUCons(elu, ... |
def evaluate(model, data_in, data_out, metrics, samples_perc_per_epoch=1, batch_size=500):
metrics = deepcopy(metrics)
model.eval()
for m in metrics:
m['score'] = []
for batch in generate(batch_size=batch_size, device=device, data_in=data_in, data_out=data_out, samples_perc_per_epoch=samples_per... |
def demo_basic(local_world_size, local_rank):
init_seed((1 + local_rank))
torch.cuda.set_device(local_rank)
device = torch.device('cuda:0')
loader = FB15KLoader(dataset_path='../../dataset', download=True)
(train_data, valid_data, test_data) = loader.load_all_data()
(node_lut, relation_lut) = lo... |
def distributed_init(cfg: FairseqConfig):
if isinstance(cfg, Namespace):
from fairseq.dataclass.utils import convert_namespace_to_omegaconf
cfg = convert_namespace_to_omegaconf(cfg)
if (not cfg.common.tpu):
if (torch.distributed.is_available() and torch.distributed.is_initialized()):
... |
class OSSPath():
__slots__ = ('_client', 'bucket', '_key_parts')
def __new__(cls, s3url: Optional[str]=None, endpoint_url=OSS_ENDPOINT):
_client = boto3.client('s3', endpoint_url=endpoint_url)
(bucket, parts) = cls._parse_s3url(s3url)
return cls._create(_client, bucket, parts)
def _p... |
class OrderedSet(OrderedDict, MutableSet):
def update(self, *args, **kwargs):
if kwargs:
raise TypeError('update() takes no keyword arguments')
for s in args:
for e in s:
self.add(e)
def add(self, elem):
self[elem] = None
def discard(self, elem... |
class StochasticBottleneck(nn.Module):
def __init__(self, m, stochastic_depth_p=0.2, stochastic_depth_mode='row'):
super(StochasticBottleneck, self).__init__()
self.m = m
self.sd = StochasticDepth(stochastic_depth_p, mode=stochastic_depth_mode)
def forward(self, x):
identity = x
... |
class DumpBeams(InferenceTask):
def __init__(self, params):
super(DumpBeams, self).__init__(params)
self._beam_accum = {'predicted_ids': [], 'beam_parent_ids': [], 'scores': [], 'log_probs': []}
if (not self.params['file']):
raise ValueError('Must specify file for DumpBeams')
... |
class Params():
def __init__(self, path):
assert os.path.exists(path), 'Cannot find configuration file: {}'.format(path)
self.path = path
config = configparser.ConfigParser()
config.read(self.path)
params = config['DEFAULT']
self.issia_path = params.get('issia_path', ... |
def define_D(input_nc, ndf, use_sigmoid=True, gpu_ids=None):
if (gpu_ids is None):
gpu_ids = []
use_gpu = (len(gpu_ids) > 0)
if use_gpu:
assert torch.cuda.is_available()
netD = Discriminator(in_channels=7, use_sigmoid=True)
if use_gpu:
netD.cuda(gpu_ids[0])
return netD |
def simxSetUISlider(clientID, uiHandle, uiButtonID, position, operationMode):
return c_SetUISlider(clientID, uiHandle, uiButtonID, position, operationMode) |
_grad()
def get_predictions(p, dataloader, model, return_features=False):
model.eval()
predictions = [[] for _ in range(p['num_heads'])]
probs = [[] for _ in range(p['num_heads'])]
targets = []
if return_features:
ft_dim = get_feature_dimensions_backbone(p)
features = torch.zeros((le... |
class Data_MIONet_Cartesian(Data):
def __init__(self, X_train=None, y_train=None, X_test=None, y_test=None):
super(Data_MIONet_Cartesian, self).__init__(X_train, y_train, X_test, y_test)
def get_batch(self, batch_size):
_elementwise
def batch_mask(X, num):
return np.random.ch... |
def parse_range(range_str):
param = map(float, range_str.split(','))
return np.arange(*param) |
def get_default_config_with_chosen_model(model_type, use_det_resnet=None, determinant_fn_mode=None, explicit_antisym_subtype=None, use_products_covariance=None):
config = default_config.get_default_config()
config.model.type = model_type
if (use_det_resnet is not None):
config.model.ferminet.use_det... |
class MobileNetV3RCNN(MobileNetV3):
def __init__(self, scale=1.0, model_name='large', conv_decay=0.0, norm_type='bn', norm_decay=0.0, freeze_norm=True, feature_maps=[2, 3, 4, 5], lr_mult_list=[1.0, 1.0, 1.0, 1.0, 1.0]):
super(MobileNetV3RCNN, self).__init__(scale=scale, model_name=model_name, conv_decay=con... |
_torch
_pytesseract
class LayoutLMv2ProcessorIntegrationTests(unittest.TestCase):
_property
def get_images(self):
from datasets import load_dataset
ds = load_dataset('hf-internal-testing/fixtures_docvqa', split='test')
image_1 = Image.open(ds[0]['file']).convert('RGB')
image_2 = ... |
_module()
class MSELoss(nn.Module):
def __init__(self, reduction='mean', loss_weight=1.0, negative=False):
super().__init__()
self.reduction = reduction
self.loss_weight = loss_weight
self.negative = negative
def forward(self, pred, target, weight=None, avg_factor=None):
... |
def test_invalid_runs_data(invalid_runs_raw_data: Dict[(str, Dict[(str, Any)])]) -> None:
data_diag_tools = DiagnoseData(raw_data=invalid_runs_raw_data)
check_data_results = data_diag_tools.check_data()['env_1']
assert (check_data_results == {'valid_algorithms': True, 'valid_algorithm_names': True, 'valid_r... |
def retrieve_top(args):
config = RobertaConfig.from_pretrained(args.model_path, gradient_checkpointing=False)
model = RobertaDot.from_pretrained(args.model_path, config=config)
output_embedding_size = model.output_embedding_size
model = model.to(args.device)
query_inference(model, args, output_embed... |
_SAMPLERS.register_module()
class RandomSampler(BaseSampler):
def __init__(self, num, pos_fraction, neg_pos_ub=(- 1), add_gt_as_proposals=True, **kwargs):
from mmdet.core.bbox import demodata
super(RandomSampler, self).__init__(num, pos_fraction, neg_pos_ub, add_gt_as_proposals)
self.rng = d... |
class ListToTensor(object):
def __init__(self):
self.totensor = ToTensor()
def __call__(self, img_rp):
tensor = self.totensor(img_rp[0])
return [tensor, img_rp[1]] |
class MobileNetV1OnnxConfig(OnnxConfig):
torch_onnx_minimum_version = version.parse('1.11')
def inputs(self) -> Mapping[(str, Mapping[(int, str)])]:
return OrderedDict([('pixel_values', {0: 'batch'})])
def outputs(self) -> Mapping[(str, Mapping[(int, str)])]:
if (self.task == 'image-classifi... |
def main():
args = parse_args()
cfg.set_args(args.gpu_ids, args.continue_train, exp_dir=args.exp_dir)
cudnn.benchmark = True
if args.cfg:
cfg.update(args.cfg)
trainer = Trainer()
trainer._make_batch_generator()
trainer._make_model()
scaler = amp.GradScaler(init_scale=args.init_sc... |
def squared_norm(x, axis=None, keepdims=False):
return (x ** 2).sum(axis=axis, keepdims=keepdims) |
def download(path):
url = (' + path)
print(url)
dir = os.path.dirname(path)
os.makedirs(dir, exist_ok=True)
wget.download(url, path) |
class PyClassnameExceptionRaiser():
def raise_creating_clex(self, message):
raise PyImarisWriterException('Error creating {}: {}'.format(self.__class__.__name__, message)) |
_arg_scope
def convolution3d(inputs, num_outputs, kernel_size, stride=1, padding='SAME', data_format=None, rate=1, activation_fn=nn.relu, normalizer_fn=None, normalizer_params=None, weights_initializer=initializers.xavier_initializer(), weights_regularizer=None, biases_initializer=init_ops.zeros_initializer(), biases_r... |
def find_best(restraints):
(df, header) = load()
filt = filter_data(df, header, restraints)
search = 'best_val_f1'
loc = header[search]
m = 0
best = None
for f in filt:
if (f[(- 1)][loc] > m):
m = f[(- 1)][loc]
best = f[(- 1)]
return gen_config(restraints,... |
class CLUEWSC2020(CLSProcessor):
def __init__(self):
super().__init__(labels_origin=['false', 'true'], labels_mapped=['', ''])
def get_examples(self, data_dir, split):
path = os.path.join(data_dir, f'{split}.json')
with open(path, encoding='utf8') as f:
for line in f:
... |
def augment_dictionary(dictionary: Dictionary, language_list: List[str], lang_tok_style: str, langtoks_specs: Sequence[str]=(LangTokSpec.main.value,), extra_data: Optional[Dict[(str, str)]]=None) -> None:
for spec in langtoks_specs:
for language in language_list:
dictionary.add_symbol(get_lang_t... |
def parse_args():
parser = argparse.ArgumentParser(description='Arguments for building pointnet2 ffi extension')
parser.add_argument('--objs', nargs='*')
clean_arg = parser.add_mutually_exclusive_group()
clean_arg.add_argument('--build', dest='build', action='store_true')
clean_arg.add_argument('--c... |
def dice_coeff(input, target):
if input.is_cuda:
s = torch.FloatTensor(1).cuda().zero_()
else:
s = torch.FloatTensor(1).zero_()
for (i, c) in enumerate(zip(input, target)):
s = (s + DiceCoeff().forward(c[0], c[1]))
return (s / (i + 1)) |
_torch
class DecisionTransformerModelTest(ModelTesterMixin, GenerationTesterMixin, PipelineTesterMixin, unittest.TestCase):
all_model_classes = ((DecisionTransformerModel,) if is_torch_available() else ())
all_generative_model_classes = ()
pipeline_model_mapping = ({'feature-extraction': DecisionTransformer... |
class ONNXRTITFilters(object):
def __init__(self):
self.filters = {}
self.filters.update(ONNXRT_IT_FILTERS) |
def get_fullD(model_config):
model_d = NLayerDiscriminator(n_layers=5, norm_layer=get_norm_layer(norm_type=model_config['norm_layer']), use_sigmoid=False)
return model_d |
def load_model_weights(model, model_name, dataset, classes, include_top, **kwargs):
(_, _, _, keras_utils) = get_submodules_from_kwargs(kwargs)
weights = _find_weights(model_name, dataset, include_top)
if weights:
weights = weights[0]
if (include_top and (weights['classes'] != classes)):
... |
class TFDeiTForImageClassificationWithTeacher(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
def nopeak_mask(size):
np_mask = np.triu(np.ones((1, size, size)), k=1).astype('uint8')
np_mask = Variable((torch.from_numpy(np_mask) == 0))
return np_mask |
class ScenarioLoaderV2():
def load(self, file_path, name=None):
self.yaml_dict = u.load_yaml(file_path)
if (name is None):
name = u.get_file_name(file_path)
self.name = name
self._parse_subnets()
self._parse_topology()
self._parse_os()
self._parse_... |
class Object():
def init(self, args):
self.gamma = 0.99
self.batch = args.batch
self.epoch = args.epoch
self.alpha_v = 0.1
self.alpha_h = args.alpha_h
self.target_rho = 0.005
self.mp_iterations = args.mp_iterations
self.seed = args.seed
self.de... |
def get_document_parse_tree_and_str(inp: List[str]) -> (List[TreeNode], List[str]):
(tree_bag, str_bag) = ([], [])
for sent in inp:
out = read_single_parse_tree(sent)
tree_bag.append(out)
s = ' '.join(out.text)
str_bag.append(s)
return (tree_bag, str_bag) |
class TestNet(spaic.Network):
def __init__(self):
super(TestNet, self).__init__()
self.input = spaic.Encoder(num=node_num, coding_method='poisson')
self.layer1 = spaic.NeuronGroup(node_num, neuron_model='lif')
self.layer2 = spaic.NeuronGroup(label_num, neuron_model='lif')
sel... |
class ConvLSTMPeephole3D(Layer):
def __init__(self, input_size, output_size, kernel_i, kernel_c, stride=1, padding=(- 1), wRegularizer=None, uRegularizer=None, bRegularizer=None, cRegularizer=None, with_peephole=True, bigdl_type='float'):
super(ConvLSTMPeephole3D, self).__init__(None, bigdl_type, input_size... |
def init_weights(model, conv='kaiming', batchnorm='normal', linear='kaiming', lstm='kaiming'):
for m in model.modules():
if isinstance(m, _ConvNd):
if (conv == 'kaiming'):
initer.kaiming_normal_(m.weight)
elif (conv == 'xavier'):
initer.xavier_normal_(... |
class HyperParams():
MaxStateVisitCount = 5
MaxNumConversationRounds = 100
DefaultTemperature = 1
DefaultMaxTokens = 2000 |
def ReadFileGS(x_axis, batchInterval, NUM_ITEMS, NUM_ACCESS, key_skewness, overlap_ratio, abort_ratio, isCyclic, complexity):
(w, h) = (3, len(x_axis))
y = [[] for _ in range(w)]
NUM_ACCESS_range = [2, 4, 6]
key_skewness_range = [25, 50, 75]
abort_ratio_range = [1, 10, 100]
NUM_ITEMS_range = [12... |
def show_colorful_images(prediction, palettes):
im = Image.fromarray(palettes[prediction.astype('uint8').squeeze()])
im.show() |
def py_sigmoid_focal_loss(pred, target, weight=None, gamma=2.0, alpha=0.25, reduction='mean', avg_factor=None):
pred_sigmoid = pred.sigmoid()
target = target.type_as(pred)
pt = (((1 - pred_sigmoid) * target) + (pred_sigmoid * (1 - target)))
focal_weight = (((alpha * target) + ((1 - alpha) * (1 - target)... |
def Linear(name, input_dim, output_dim, inputs, biases=True, initialization=None, weightnorm=None, gain=1.0):
with tf.name_scope(name) as scope:
def uniform(stdev, size):
if (_weights_stdev is not None):
stdev = _weights_stdev
return np.random.uniform(low=((- stdev) *... |
def data_load(filename, axisname, label):
datanumber = axisname.split('.')
if (eval(datanumber[0]) < 100):
realaxis = (('X0' + datanumber[0]) + axis[0])
else:
realaxis = (('X' + datanumber[0]) + axis[0])
fl = loadmat(filename)[realaxis]
fl = fl.reshape((- 1))
data = []
lab = ... |
def setup_ddp():
if (('SLURM_PROCID' in os.environ) and (not ('RANK' in os.environ))):
world_size = int(os.environ['WORLD_SIZE'])
rank = int(os.environ['SLURM_PROCID'])
gpus_per_node = int(os.environ['SLURM_GPUS_ON_NODE'])
gpu = (rank - (gpus_per_node * (rank // gpus_per_node)))
... |
def apply_Dropout(rng, dropoutRate, inputShape, inputData, task):
outputData = inputData
if (dropoutRate > 0.001):
activationRate = (1 - dropoutRate)
srng = T.shared_randomstreams.RandomStreams(rng.randint(999999))
dropoutMask = srng.binomial(n=1, size=inputShape, p=activationRate, dtype... |
class MyProcessRunner(ProcessRunner):
def summarize(self, force=False):
THRE0 = 0.6
results_fname = 'outputs/results.pkl'
if (os.path.exists(results_fname) and (not force)):
print('loading results from {}'.format(results_fname))
with open(results_fname, 'rb') as f:
... |
class ReinitServer(ABC):
def __init__(self, args, config, model, save_interval=50):
self.config = config
self.device = torch.device(('cuda:0' if torch.cuda.is_available() else 'cpu'))
self.experiment_name = args.experiment_name
self.save_path = os.path.join('results', config.EXP_NAME... |
def test_reconfigure_with_n_smaller_than_subtree_size():
pytest.importorskip('opt_einsum')
import opt_einsum as oe
(eq, shapes) = oe.helpers.rand_equation(10, 3)
(_, info) = oe.contract_path(eq, *shapes, shapes=True)
tree = ctg.ContractionTree.from_info(info)
tree.subtree_reconfigure(12) |
class FromTensors(MultiResolutionBatch):
def __init__(self, xs, y):
self._xs = xs
self._y = y
def targets(self):
return self._y
def inputs(self):
return []
def patches(self, samples, offsets, sample_space, previous_patch_size, patch_size, fromlevel, tolevel):
samp... |
class PhrasecutEvaluator(object):
def __init__(self, split, ann_folder, output_dir='phrasecut_eval', eval_mask=False):
subset = PhraseCutSubsets(ann_folder)
loader = RefVGLoader(ann_folder, subset, split=split)
if dist.is_main_process():
if (not os.path.exists(output_dir)):
... |
def run_preprocess_test(data, fakefs, mocker):
fakefs.create_dir(data.data_dir)
fakefs.create_file(Path(data.data_dir).joinpath(data.meta_file))
mocker.patch('json.load', side_effect=processed_modal_metadata)
mocked_preprocess = mocker.patch(f'{TESTED_MODULE}.AudioDataModule.preprocess_dataset')
moc... |
class TestTransformations(ChannelTestCase):
qubits_test_cases = (1, 2)
repetitions = 2
def _unitary_to_other(self, rep, qubits_test_cases, repetitions):
for nq in qubits_test_cases:
dim = (2 ** nq)
for _ in range(repetitions):
rho = self.rand_rho(dim)
... |
def pack_kwargs(*args, **kwargs) -> Tuple[(List[str], List[Any])]:
kwarg_keys = []
flat_args = list(args)
for (k, v) in kwargs.items():
kwarg_keys.append(k)
flat_args.append(v)
return (kwarg_keys, flat_args) |
def get_version():
init_py_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), SOURCE_FOLDER, '__init__.py')
init_py = open(init_py_path, 'r').readlines()
version_line = [l.strip() for l in init_py if l.startswith('__version__')][0]
version = version_line.split('=')[(- 1)].strip().strip('\'"... |
def tune_odin_hyperparams():
print('Tuning hyper-parameters...')
stypes = ['ODIN']
save_dir = os.path.join('output/odin_hyperparams/', args.in_dataset, args.name, 'tmp')
if (not os.path.exists(save_dir)):
os.makedirs(save_dir)
transform = transforms.Compose([transforms.ToTensor()])
if (a... |
def prepare_model(input_model, output_model):
batch_size = 1
model = torchvision.models.vgg16(pretrained=True)
x = torch.randn(batch_size, 3, 224, 224, requires_grad=True)
torch.onnx.export(model, x, output_model, export_params=True, opset_version=14, do_constant_folding=True, input_names=['input'], out... |
class Criterion(nn.Module):
def __init__(self, threshold: int=3, validation_max_disp: int=(- 1), loss_weight: list=None):
super(Criterion, self).__init__()
if (loss_weight is None):
loss_weight = {}
self.px_threshold = threshold
self.validation_max_disp = validation_max_d... |
class Node():
def __init__(self, x, y, cost, parent_index):
self.x = x
self.y = y
self.cost = cost
self.parent_index = parent_index
def __str__(self):
return ((((((str(self.x) + ',') + str(self.y)) + ',') + str(self.cost)) + ',') + str(self.parent_index)) |
class DBSNLoss(nn.Module):
def __init__(self):
super(DBSNLoss, self).__init__()
def forward(self, target, mu, sigma_mu, sigma_n, sigma_y):
loss = 0
eps = 1e-06
target = target.detach()
t1 = (((target - mu) ** 2) / sigma_y)
t2 = sigma_n.clamp(eps).log()
t3 ... |
def prepare_src_path(video_names):
global iPER_images_dir
template_path = 'path?={path},name?={name}'
src_paths = []
for vid_name in video_names:
vid_img_dir = os.path.join(iPER_images_dir, vid_name)
assert os.path.exists(vid_img_dir)
path = template_path.format(path=vid_img_dir,... |
class DCNPooling(DCNv2Pooling):
def __init__(self, spatial_scale, pooled_size, output_dim, no_trans, group_size=1, part_size=None, sample_per_part=4, trans_std=0.0, deform_fc_dim=1024):
super(DCNPooling, self).__init__(spatial_scale, pooled_size, output_dim, no_trans, group_size, part_size, sample_per_part,... |
def parse_args():
parser = ArgumentParser(description='PyTorch implementation of Noise2Noise from Lehtinen et al. (2018)')
parser.add_argument('-d', '--data', help='dataset root path', default='../data')
parser.add_argument('--load-ckpt', help='load model checkpoint')
parser.add_argument('--show-output'... |
def make_task_cmds():
data_dir_fixtures = f'{tests_dir}/fixtures'
data_dir_samples = f'{data_dir_fixtures}/tests_samples'
data_dir_wmt = f'{data_dir_samples}/wmt_en_ro'
data_dir_xsum = f'{data_dir_samples}/xsum'
args_main = '\n --do_train\n --max_train_samples 4\n --per_device_t... |
def load_graph(model_path):
if os.path.exists(model_path):
if os.path.isdir(model_path):
graph = load_graph_from_ir(model_path)
else:
graph = compile(model_path)
else:
log.error("Model path doesn't exist.")
raise ValueError()
return graph |
def print_tensor_statistics(tensor, name='', formatting='standard'):
print(get_tensor_statistics_str(tensor, name, formatting)) |
class DynamicConvolution2D(nn.Module):
def __init__(self, wshare, n_feat, dropout_rate, kernel_size, use_kernel_mask=False, use_bias=False):
super(DynamicConvolution2D, self).__init__()
assert ((n_feat % wshare) == 0)
self.wshare = wshare
self.use_kernel_mask = use_kernel_mask
... |
def grid_parameters(grid: Dict):
grid_copy = dict(grid)
for k in grid_copy:
if (not isinstance(grid_copy[k], Iterable)):
grid_copy[k] = [grid_copy[k]]
for p in itertools.product(*grid_copy.values()):
(yield dict(zip(grid.keys(), p))) |
class RODEncode_SC1(nn.Module):
def __init__(self):
super(RODEncode_SC1, self).__init__()
self.conv1a = nn.Conv3d(in_channels=1, out_channels=64, kernel_size=(9, 5, 5), stride=(1, 1, 1), padding=(4, 2, 2))
self.conv1b = nn.Conv3d(in_channels=64, out_channels=64, kernel_size=(9, 5, 5), stride... |
def tia_stretch(src, segment=4):
(img_h, img_w) = src.shape[:2]
cut = (img_w // segment)
thresh = ((cut * 4) // 5)
src_pts = list()
dst_pts = list()
src_pts.append([0, 0])
src_pts.append([img_w, 0])
src_pts.append([img_w, img_h])
src_pts.append([0, img_h])
dst_pts.append([0, 0])
... |
def test_3(**init_kwargs):
zpy.init(**init_kwargs)
dataset_config = zpy.DatasetConfig('dumpster_v2')
zpy.generate('dumpster_v2.21', dataset_config, num_datapoints=3, materialize=True) |
def main():
st.title('Retrospective Reader Demo')
st.markdown('## Model name')
option = st.selectbox(label='Choose the model used in retro reader', options=('[ko_KR] klue/roberta-large', '[ko_KR] monologg/koelectra-small-v3-discriminator', '[en_XX] google/electra-large-discriminator'), index=1)
(lang_co... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.