code stringlengths 101 5.91M |
|---|
def pi2pi(theta, theta0=0.0):
while (theta > (np.pi + theta0)):
theta = (theta - (2.0 * np.pi))
while (theta < ((- np.pi) + theta0)):
theta = (theta + (2.0 * np.pi))
return theta |
class ExampleConfigTest(object):
def __init__(self, *args, **kwargs):
super(ExampleConfigTest, self).__init__(*args, **kwargs)
self.vocab_file = None
def _config_path(self):
raise NotImplementedError()
def create_model(self, mode, params=None):
return _load_model_from_config(... |
def load_matrix(fname, n_rows):
vecs = []
with open(fname) as f:
for idx in tqdm.tqdm(range(n_rows)):
vecs.append(np.array([float(x) for x in f.readline().split()]))
return np.vstack(vecs) |
def transformer(*args, **kwargs):
parser = options.get_interactive_generation_parser()
model = TransformerModel.from_pretrained(parser, *args, **kwargs)
return model |
def sql_functions_b_example(spark):
df = spark.createDataFrame([('1',), ('2',), ('10',)], ['n1'])
df.withColumn('base64_n1', base64(df.n1)).show()
print('base64 API finished')
df = spark.createDataFrame([(1,), (2,), (3,)], ['n1'])
df.select(bin(df.n1).alias('binary_number')).show()
print('bin AP... |
_criterion('binary_cross_entropy')
class BinaryCrossEntropyCriterion(FairseqCriterion):
def __init__(self, task, infonce=False, loss_weights=None, log_keys=None):
super().__init__(task)
self.infonce = infonce
self.loss_weights = (None if (loss_weights is None) else eval(loss_weights))
... |
def upNvis():
uNbu.switch()
if (uNbu.status() == 'Uhide'):
upN.off()
elif (uNbu.status() == 'Ushow'):
upN.on() |
class TFOptimizer():
def __init__(self, tf_model, optim_method, sess=None, dataset=None, clip_norm=None, clip_value=None, model_dir=None):
self.optim_method = optim_method
self.sess = sess
self.dataset = dataset
self.clip_norm = clip_norm
if ((clip_value is not None) and (not... |
def summarize_error(key):
if (type(err_info[key]) == str):
return (' ' + err_info[key])
else:
return (('\n' + '\n'.join([(' %s: %s' % (name, err)) for (name, err) in err_info[key]])) + '\n') |
def _dist_train(model, dataset, cfg, validate=False):
data_loaders = [build_dataloader(dataset, cfg.data.imgs_per_gpu, cfg.data.workers_per_gpu, dist=True)]
model = MMDistributedDataParallel(model.cuda())
optimizer = build_optimizer(model, cfg.optimizer)
runner = Runner(model, batch_processor, optimizer... |
def num_del(inp_lists):
tmp = []
for inp in inp_lists:
l = inp['del_span']
total = len(l)
tmp.append((total - 1))
return tmp |
class HansProcessor(DataProcessor):
def get_train_examples(self, data_dir):
return self._create_examples(self._read_tsv(os.path.join(data_dir, 'heuristics_train_set.txt')), 'train')
def get_dev_examples(self, data_dir):
return self._create_examples(self._read_tsv(os.path.join(data_dir, 'heuristi... |
class Client():
d = None
try:
with open('../data/state_traces.json', 'r', encoding='utf-8') as f:
d = json.load(f)
except FileNotFoundError as e:
d = None
logger.warn('no user behavior trace was found, running in no-trace mode')
def __init__(self, client_id, group=Non... |
def create_dataset(cfg):
pre_transform = PositionalEncodingTransform(rw_dim=cfg.pos_enc.rw_dim, lap_dim=cfg.pos_enc.lap_dim)
if ((cfg.dataset == 'MNIST') or (cfg.dataset == 'CIFAR10')):
transform_train = transform_eval = SuperpixelTransform()
elif (cfg.dataset == 'CSL'):
transform_train = tr... |
class _OmeTiffVIPSReader(_VIPSReader):
def __init__(self, *args, **kwargs):
self.page_labels = {0: 'label', 1: 'overview', 2: 'main', 3: 'macro'}
self.num_pyramid_levels = 5
super().__init__(*args, **kwargs)
def get_page_by_label(self, label: str) -> int:
for (page, page_label) i... |
def get_input_transform():
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
transf = transforms.Compose([transforms.Resize((256, 256)), transforms.CenterCrop(224), transforms.ToTensor(), normalize])
return transf |
.mujoco
.no_cover
.timeout(20)
def test_maml_halfcheetah():
assert (subprocess.run([str((EXAMPLES_ROOT_DIR / 'torch/maml_trpo_half_cheetah_dir.py')), '--epochs', '1', '--rollouts_per_task', '1', '--meta_batch_size', '1'], check=False).returncode == 0) |
class TFRobertaForTokenClassification():
def __init__(self, *args, **kwargs):
requires_tf(self)
def from_pretrained(self, *args, **kwargs):
requires_tf(self) |
def topk_meter(ctx: Context, train_ctx: Context, k: int=1) -> float:
def accuracy(output, target, k=1):
batch_size = target.size(0)
(_, pred) = output.topk(k, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, (- 1)).expand_as(pred))
correct_k = correct[:k].view(... |
(version='2.0')
class TuningItem():
def __init__(self, name, options=[], item_type=None):
self.name = name
self._options = options
self.item_type = item_type
def options(self):
return self._options
def get_options_name(self):
return [o.name for o in self.options]
... |
class UncondMetrics(Metric):
full_state_update = True
def __init__(self, top_k=3, R_size=32, diversity_times=300, dist_sync_on_step=True, **kwargs):
super().__init__(dist_sync_on_step=dist_sync_on_step)
self.name = 'fid, kid, and diversity scores'
self.top_k = top_k
self.R_size =... |
class LinearBottleneck(nn.Module):
def __init__(self, in_channels, out_channels, stride, expansion):
super(LinearBottleneck, self).__init__()
self.residual = ((in_channels == out_channels) and (stride == 1))
mid_channels = ((in_channels * 6) if expansion else in_channels)
self.conv1 ... |
def _one_hot_encode_helper(df, class_name, class_range, features_generated):
for i in class_range:
df[((class_name + '_') + str(i))] = 0
df.loc[((df[class_name] == i), ((class_name + '_') + str(i)))] = 1
features_generated.append(((class_name + '_') + str(i)))
df.drop([class_name], axis=... |
def adjust_learning_rate_poly(args, optimizer, iter, power=0.9):
base_lr = args.lr
max_iter = args.max_steps
reduce = ((1 - (float(iter) / max_iter)) ** power)
lr = (base_lr * reduce)
optimizer.param_groups[0]['lr'] = (lr * 1)
optimizer.param_groups[1]['lr'] = (lr * 2)
optimizer.param_groups... |
def resnet18(pretrained=False, output_channels=512):
model = ResNet(BasicBlock, [2, 2, 2, 2], output_channels=output_channels)
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet18']))
return model |
class ReaderInputTensors(NamedTuple):
path_source_token_indices: tf.Tensor
path_indices: tf.Tensor
path_target_token_indices: tf.Tensor
context_valid_mask: tf.Tensor
target_index: Optional[tf.Tensor] = None
target_string: Optional[tf.Tensor] = None
path_source_token_strings: Optional[tf.Tens... |
def gradient_descent(energy_or_force: Callable[(..., Array)], shift_fn: ShiftFn, step_size: float) -> Minimizer[Array]:
force = quantity.canonicalize_force(energy_or_force)
def init_fn(R: Array, **unused_kwargs) -> Array:
return R
def apply_fn(R: Array, **kwargs) -> Array:
R = shift_fn(R, (s... |
class StackelbergEnv(PhantomEnv):
def __init__(self, num_steps: int, network: Network, leader_agents: Sequence[AgentID], follower_agents: Sequence[AgentID], env_supertype: Optional[Supertype]=None, agent_supertypes: Optional[Mapping[(AgentID, Supertype)]]=None) -> None:
super().__init__(num_steps, network, ... |
class SquadDataTrainingArguments(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def get_template_counts(model_id):
import tensorflow as tf
import numpy as np
print(('Getting template counts for %s' % model_id))
graph = tf.Graph()
with graph.as_default():
builder = get_builder(model_id)
(features, labels) = builder.get_inputs(mode='train', repeat=False)
s... |
def _vgg_replace_fc(model, output_dim):
model.fc = torch.nn.Identity()
model.fc.in_features = model.classifier[0].in_features
delattr(model, 'classifier')
def forward(self, x):
x = self.features(x)
x = self.avgpool(x)
x = torch.flatten(x, 1)
x = self.fc(x)
return ... |
_cache()
def is_torch_npu_available(check_device=False):
try:
import torch
except (ImportError, ModuleNotFoundError):
return False
if (importlib.util.find_spec('torch_npu') is None):
return False
import torch_npu
if check_device:
try:
_ = torch.npu.device_... |
def create_armature_mesh(scene: bpy.types.Scene, armature_object: bpy.types.Object, mesh_name: str) -> bpy.types.Object:
assert (armature_object.type == 'ARMATURE'), 'Error'
assert (len(armature_object.data.bones) != 0), 'Error'
def add_rigid_vertex_group(target_object: bpy.types.Object, name: str, vertex_i... |
def new_lr(optimizer, lr):
for param_group in optimizer.param_groups:
param_group['lr'] = lr |
def _reg_ndarray(cls, fcreate):
global _TVM_ND_CLS
_TVM_ND_CLS[cls._array_type_code] = fcreate |
def test_snapshotKeplerPotential_zforce_naz():
s = pynbody.new(star=1)
s['mass'] = 1.0
s['eps'] = 0.0
sp = potential.SnapshotRZPotential(s, num_threads=1)
spaz = potential.SnapshotRZPotential(s, num_threads=1, nazimuths=12)
assert (numpy.fabs((sp.zforce(1.0, 0.0) - spaz.zforce(1.0, 0.0))) < (10.... |
def test_laplacian_random_walk():
num_v = 20
num_e = 50
for _ in range(3):
g = Graph(num_v)
A = torch.zeros((num_v, num_v))
for _ in range(num_e):
s = random.randrange(num_v)
d = random.randrange(num_v)
if (s == d):
continue
... |
_model
def repvgg_b1g4(pretrained=False, **kwargs):
return _create_byobnet('repvgg_b1g4', pretrained=pretrained, **kwargs) |
def GetSvnInfo():
for line in GetCommandOutput('svn info .'):
m = _SVN_INFO_URL_RE.match(line)
if m:
project = m.group(1)
rel_path = m.group(2)
root = os.path.realpath((rel_path.count('/') * '../'))
return (project, root)
return (None, None) |
def iterate_dict_combinations(a: Mapping[(K, Collection[V])]) -> Iterator[Mapping[(K, V)]]:
ks = list(a)
vs = [a[_] for _ in ks]
alls = list(itertools.product(*tuple(vs)))
for x in alls:
d = frozendict(zip(ks, x))
(yield d) |
class GenerationConfig(FairseqDataclass):
beam: int = field(default=5, metadata={'help': 'beam size'})
beam_mt: int = field(default=0, metadata={'help': 'beam size for the first-pass decoder'})
nbest: int = field(default=1, metadata={'help': 'number of hypotheses to output'})
max_len_a: float = field(de... |
def init_classifier(layer_sizes):
classifier = construct_classifier(layer_sizes, 'sigmoid')
return classifier |
class _Dataset():
name: str
sources: typing.List[typing.Callable]
split_proportions: typing.Dict[(str, float)]
reactant_to_reactant_id_json_path: str |
class WordsSubtokenMetricBase(tf.metrics.Metric):
FilterType = Callable[([tf.Tensor, tf.Tensor], tf.Tensor)]
def __init__(self, index_to_word_table: Optional[tf.lookup.StaticHashTable]=None, topk_predicted_words=None, predicted_words_filters: Optional[List[FilterType]]=None, subtokens_delimiter: str='|', name=N... |
class ViTMAELayer(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def is_overlapping(sim, name=None):
sim.forward()
ncon = sim.data.ncon
for contact_ind in range(ncon):
contact = sim.data.contact[contact_ind]
geom1 = sim.model._geom_id2name[contact.geom1]
geom2 = sim.model._geom_id2name[contact.geom2]
relevant_name = ((name is None) or ((ge... |
class UniformQuantizeGrad(InplaceFunction):
def forward(ctx, input, num_bits=None, qparams=None, flatten_dims=_DEFAULT_FLATTEN_GRAD, reduce_dim=0, dequantize=True, signed=False, stochastic=True):
ctx.num_bits = num_bits
ctx.qparams = qparams
ctx.flatten_dims = flatten_dims
ctx.stocha... |
def create_squeezenet_ssd_lite(num_classes, is_test=False):
base_net = squeezenet1_1(False).features
source_layer_indexes = [12]
extras = ModuleList([Sequential(Conv2d(in_channels=512, out_channels=256, kernel_size=1), ReLU(), SeperableConv2d(in_channels=256, out_channels=512, kernel_size=3, stride=2, paddi... |
def m2(solution):
if (solution.size > 1):
i = random.randrange(1, solution.size)
solution.remove_city(index=i)
return solution |
def test_octree_voxel_grid_convert():
pcd_data = o3d.data.PLYPointCloud()
pcd = o3d.io.read_point_cloud(pcd_data.path)
octree = o3d.geometry.Octree(8)
octree.convert_from_point_cloud(pcd)
voxel_grid = octree.to_voxel_grid()
octree_copy = voxel_grid.to_octree(max_depth=8) |
def train_epoch(epoch, model, loader, optimizer, loss_fn, args, lr_scheduler=None, saver=None, output_dir='', amp_autocast=suppress, loss_scaler=None, model_ema=None, mixup_fn=None):
if (args.mixup_off_epoch and (epoch >= args.mixup_off_epoch)):
if (args.prefetcher and loader.mixup_enabled):
loa... |
class ColorJitter(object):
def __init__(self, brightness=0.2, contrast=0.2, saturation=0.2, hue=0.2, p=0.5):
self.brightness = brightness
self.contrast = contrast
self.saturation = saturation
self.hue = hue
self.p = p
self.t = A.ColorJitter(brightness=brightness, cont... |
class PrecisionRecallMeter():
def __init__(self) -> None:
self.all_y_true = np.zeros((0, 1))
self.all_y_hat = np.zeros((0, 1))
self.all_y_hat_probs = np.zeros((0, 1))
def update(self, y_true: np.ndarray, y_hat: np.ndarray, y_hat_probs: np.ndarray) -> None:
y_true = y_true.reshape... |
def process_conceptual_caption(tsv, imgs, db, tokenizer, split):
id2len = {}
txt2img = {}
img2txts = defaultdict(list)
for line in tqdm(tsv, desc='processing conceptual captions'):
fields = line.strip().split('\t')
assert (len(fields) == 4)
(id_, _, caption, success) = fields
... |
class MotorModel(object):
def __init__(self, kp=1.2, kd=0, torque_limits=None, motor_control_mode=robot_config.MotorControlMode.POSITION):
self._kp = kp
self._kd = kd
self._torque_limits = torque_limits
self._motor_control_mode = motor_control_mode
self._resistance = MOTOR_RE... |
def pca_features(features: dict[(int, dict[(int, np.ndarray)])], dim: int, standardize: bool=True, **kwargs):
features_all = np.concatenate([features[video_index][half_index] for video_index in features for half_index in features[video_index]])
pca = PCA(n_components=dim, **kwargs)
if standardize:
f... |
_module()
class ISEKAIMetrics(LCLComputeMetrics):
def __init__(self, filename, *args, **kwargs):
super().__init__(filename, *args, **kwargs)
self.gt_pairs = self.get_pairs_isekai()
def get_pairs_isekai(self):
target_pairs = []
with jsonlines.open(self.filename) as reader:
... |
.nightly
.no_cover
.timeout(120)
def test_rl2_metaworld_ml1_push():
assert (subprocess.run([str((EXAMPLES_ROOT_DIR / 'tf/rl2_ppo_metaworld_ml1_push.py')), '--n_epochs', '1', '--episode_per_task', '1', '--meta_batch_size', '10'], check=False).returncode == 0) |
class TripletNet(nn.Module):
def __init__(self, embeddingnet):
super(TripletNet, self).__init__()
self.embeddingnet = embeddingnet
def forward(self, a, p, n):
embedded_a = self.embeddingnet(a)
embedded_p = self.embeddingnet(p)
embedded_n = self.embeddingnet(n)
ret... |
def calc_model_flops(model, input_size, mul_add=False):
hook_list = []
module_flops = []
def conv_hook(self, input, output):
(output_channels, output_height, output_width) = output[0].size()
bias_ops = (1 if (self.bias is not None) else 0)
kernel_ops = ((self.kernel_size[0] * self.ke... |
def append_pod_ip_to_env(env):
pod_ip_var = V1EnvVar(name='POD_IP', value_from=V1EnvVarSource(field_ref=V1ObjectFieldSelector(field_path='status.podIP')))
node_ip_var = V1EnvVar(name='NODE_IP', value_from=V1EnvVarSource(field_ref=V1ObjectFieldSelector(field_path='status.hostIP')))
if env:
env.append... |
def test_visibility_filter():
vis = ShapelyViz()
sensor_pose: SE2Transform = SE2Transform(p=[(- 2), (- 1)], theta=2.3)
lidar_fov = Point(sensor_pose.p).buffer(20)
vis.add_shape(lidar_fov, color='gray', alpha=0.5)
obs1 = Polygon([(10, 10), (10, 15), (15, 15), (15, 10)])
obs2 = Polygon([((- 3), (-... |
class DeploymentConfig(object):
def __init__(self, num_clones=1, clone_on_cpu=False, replica_id=0, num_replicas=1, num_ps_tasks=0, worker_job_name='worker', ps_job_name='ps'):
if (num_replicas > 1):
if (num_ps_tasks < 1):
raise ValueError('When using replicas num_ps_tasks must be... |
def value_to_vector(value, ndim, dtype=float):
value = np.asarray(value, dtype=dtype)
if (value.ndim == 0):
vec = np.asarray(np.repeat(value, ndim), dtype=dtype)
else:
vec = np.asarray(value)
if (vec.size != ndim):
raise ValueError(f'input vector ({value}) does not have t... |
_module()
class ShallowCNN(BaseModule):
def __init__(self, input_channels=1, hidden_dim=512, init_cfg=[dict(type='Kaiming', layer='Conv2d'), dict(type='Uniform', layer='BatchNorm2d')]):
super().__init__(init_cfg=init_cfg)
assert isinstance(input_channels, int)
assert isinstance(hidden_dim, i... |
class ConsistencyDecoderScheduler(SchedulerMixin, ConfigMixin):
order = 1
_to_config
def __init__(self, num_train_timesteps: int=1024, sigma_data: float=0.5):
betas = betas_for_alpha_bar(num_train_timesteps)
alphas = (1.0 - betas)
alphas_cumprod = torch.cumprod(alphas, dim=0)
... |
class ResNeXtBottleneck(nn.Module):
def __init__(self, in_channels, out_channels, stride, cardinality, bottleneck_width, bottleneck_factor=4):
super(ResNeXtBottleneck, self).__init__()
mid_channels = (out_channels // bottleneck_factor)
D = int(math.floor((mid_channels * (bottleneck_width / 6... |
def expand(bbox, expansion_factor=1, expansion_abs=0):
center_point = center(bbox)
new_size = np.maximum((bbox[2:] * expansion_factor), (bbox[2:] + expansion_abs))
return np.concatenate([(center_point - (new_size / 2)), new_size]) |
class GraphConvolution(Module):
def __init__(self, in_features, out_features, bias=True):
super(GraphConvolution, self).__init__()
self.in_features = in_features
self.out_features = out_features
self.weight = Parameter(torch.FloatTensor(in_features, out_features))
if bias:
... |
def init_args():
parser = argparse.ArgumentParser(description='Convert cartesian coordinate system to geodetic system.')
parser.add_argument('-v', '--version', action='version', version='%(prog)s 0.0.1')
parser.add_argument('-x', metavar='<val>', dest='x', type=float, required=True, help='the X coordinate')... |
def max_sublist_sum(arr):
max_ending_here = 0
max_so_far = 0
for x in arr:
max_ending_here = max(0, (max_ending_here + x))
max_so_far = max(max_so_far, max_ending_here)
return max_so_far |
def is_keras_nlp_available():
return (is_tensorflow_text_available() and (importlib.util.find_spec('keras_nlp') is not None)) |
def get_act_fn(name: Union[(Callable, str)]='relu'):
if (not name):
return None
if isinstance(name, Callable):
return name
if (not (is_no_jit() or is_exportable() or is_scriptable())):
if (name in _ACT_FN_ME):
return _ACT_FN_ME[name]
if (is_exportable() and (name in (... |
class ResNet(nn.Module):
def __init__(self, block, layers, input_channel=3, num_classes=1000, features=64):
self.inplanes = features
super(ResNet, self).__init__()
self.conv1 = nn.Conv2d(input_channel, features, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = nn.BatchNorm2... |
class phase(Enum):
TRAIN = 'train'
VAL = 'valid'
TRAINVAL = 'trainval'
TRAINTESTDEVOT = 'train_testdev_ot' |
class MutableModule(BaseModule):
def __init__(self, symbol, data_names, label_names, logger=logging, context=ctx.cpu(), work_load_list=None, max_data_shapes=None, max_label_shapes=None, fixed_param_prefix=None):
super(MutableModule, self).__init__(logger=logger)
self._symbol = symbol
self._d... |
def prototype_twitter_lstm():
state = prototype_state()
state['train_dialogues'] = '../TwitterData/Training.dialogues.pkl'
state['test_dialogues'] = '../TwitterData/Test.dialogues.pkl'
state['valid_dialogues'] = '../TwitterData/Validation.dialogues.pkl'
state['dictionary'] = '../TwitterData/Dataset.... |
def segment_eval(batches, predictions, label_map, type_int_int_map, labels_id_str_map, vocab_id_str_map, outside_idx, pad_width, start_end, extra_text='', verbose=False):
if (extra_text != ''):
print(extra_text)
def print_context(width, start, tok_list, pred_list, gold_list):
for offset in range... |
(components=list, static_timestepping_func=object, H='double', a='double', a_next='double', bottleneck=str, bottleneck_hubble=str, component='Component', extreme_force=str, force=str, gridsize='Py_ssize_t', key=tuple, measurements=dict, method=str, n='int', resolution='Py_ssize_t', scale='double', t='double', v_max='do... |
def starListParser(input_list: str):
input_list = input_list.strip().lower()
items = [el.strip() for el in input_list.split('*')]
items = [el for el in items if (len(el) != 0)]
return items |
def rmse(targets: List[float], preds: List[float]) -> float:
return math.sqrt(mean_squared_error(targets, preds)) |
def convert_to_nii_gz(filename):
f = sitk.ReadImage(filename)
sitk.WriteImage(f, (os.path.splitext(filename)[0] + '.nii.gz'))
os.remove(filename) |
def flow_warp(img, flow, filling_value=0, interpolate_mode='nearest'):
interpolate_mode_dict = {'bilinear': 0, 'nearest': 1}
assert (len(img.shape) == 3)
assert ((len(flow.shape) == 3) and (flow.shape[2] == 2))
assert (flow.shape[:2] == img.shape[:2])
assert (interpolate_mode in interpolate_mode_dic... |
class ConvModule(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias='auto', conv_cfg=None, norm_cfg=None, activation='relu', inplace=True, activate_last=True):
super(ConvModule, self).__init__()
assert ((conv_cfg is None) or isinsta... |
def greedy_select(logits, mask=None):
probs = masked_softmax(logits=logits, mask=mask)
one_hot = convert_to_one_hot(indices=probs.max(1)[1], num_classes=logits.size(1))
return one_hot |
def master_params_to_model_params(param_groups_and_shapes, master_params):
for (master_param, (param_group, _)) in zip(master_params, param_groups_and_shapes):
for ((_, param), unflat_master_param) in zip(param_group, unflatten_master_params(param_group, master_param.view((- 1)))):
param.detach(... |
def path(elem, dr=None):
if (dr is None):
dr = _default_dr()
return os.path.join(os.path.dirname(os.path.realpath(__file__)), ('filter/%s/%s.filt' % (_dr_string(dr), elem.lower().capitalize()))) |
def parse_args():
parser = argparse.ArgumentParser(description='Test a Fast R-CNN network')
parser.add_argument('--gpu', dest='gpu_id', help='GPU id to use', default=0, type=int)
parser.add_argument('--def', dest='prototxt', help='prototxt file defining the network', default=None, type=str)
parser.add_a... |
class BasicContextFPN(HybridBlock):
def __init__(self, dilations=[1, 1, 2, 4, 8, 16], channels=16, classes=1, conv_mode='xxx', fuse_mode='xxx', act_type='relu', skernel=3, act_dilation=16, useReLU=False, use_act_head=False, check_fullly=False, act_layers=4, act_order='xxx', asBackbone=False, addstem=False, maxpool=... |
def test_digits_sqrt_modular_object():
model = GraphCutSelection(100, 'cosine', optimizer=ModularGreedy(random_state=0))
model.fit(X_digits)
assert_array_equal(model.ranking, digits_cosine_modular_ranking)
assert_array_almost_equal(model.gains, digits_cosine_modular_gains, 4)
assert_array_almost_equ... |
def preprocess_strategy(dataset):
evaluate_transforms = None
if dataset.startswith('CUB'):
train_transforms = transforms.Compose([transforms.Resize(448), transforms.CenterCrop(448), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize])
val_transforms = transforms.Compose([transfo... |
def max_sublist_sum(arr):
max_ending_here = 0
max_so_far = 0
for x in arr:
max_ending_here = (max_ending_here + x)
max_so_far = max(max_so_far, max_ending_here)
return max_so_far |
def process_image(img):
size = img.shape
(h, w) = (size[0], size[1])
scale = (max(w, h) / float(min_side))
(new_w, new_h) = (int((w / scale)), int((h / scale)))
resize_img = cv2.resize(img, (new_w, new_h))
if (((new_w % 2) != 0) and ((new_h % 2) == 0)):
(top, bottom, left, right) = (((mi... |
def get_args_parser():
parser = argparse.ArgumentParser('Set grounded situation recognition transformer', add_help=False)
parser.add_argument('--lr', default=0.0001, type=float)
parser.add_argument('--lr_backbone', default=1e-05, type=float)
parser.add_argument('--lr_drop', default=100, type=int)
pa... |
class Dynamics(nn.Module):
def __init__(self, rp_shape, act_shape):
super().__init__()
self.rp_shape = rp_shape
self.layer0 = Conv((rp_shape[0] + act_shape[0]), num_filters, 3, bn=True)
self.blocks = nn.ModuleList([ResidualBlock(num_filters) for _ in range(num_blocks)])
def forwa... |
def test_isotropic_eddington_dehnencore_in_nfw_dens_spherically_symmetric():
pot = potential.NFWPotential(amp=2.3, a=1.3)
denspot = potential.DehnenCoreSphericalPotential(amp=2.5, a=1.15)
dfp = eddingtondf(pot=pot, denspot=denspot)
numpy.random.seed(10)
samp = dfp.sample(n=100000)
tol = 0.01
... |
def create_get_pure_strat_cached(cache: dict):
def load_pure_strat_cached(policy: Policy, pure_strat_spec):
pure_strat_checkpoint_path = pure_strat_spec.metadata['checkpoint_path']
if (pure_strat_checkpoint_path in cache):
weights = cache[pure_strat_checkpoint_path]
else:
... |
def test_geotext_case_sensitive_demo_data():
config = GeoTextConfiguration(**{'use_demo_data': True, 'case_sensitive': False})
geotext = GeoText(config)
text = 'berlin ist ne tolle stadt'
output = geotext.extract(input_text=text)
assert (output['cities']['Berlin']['span_info'] == [(0, 6)])
asser... |
class SoftmaxParameter(_message.Message):
__metaclass__ = _reflection.GeneratedProtocolMessageType
DESCRIPTOR = _SOFTMAXPARAMETER |
def move_element_to_front(list, element):
if (element in list):
idx = list.index(element)
list.insert(0, list.pop(idx))
return list |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.