code stringlengths 101 5.91M |
|---|
def get_transform(opt):
transform_list = []
if (opt.resize_or_crop == 'resize_and_crop'):
osize = [opt.loadSize, opt.loadSize]
transform_list.append(transforms.Scale(osize, Image.BICUBIC))
transform_list.append(transforms.RandomCrop(opt.fineSize))
elif (opt.resize_or_crop == 'crop'):... |
def get_all_videos(dir, extension='mp4'):
list_video_fn = []
for (dirpath, dirnames, filenames) in os.walk(dir):
for filename in [f for f in filenames if f.endswith(extension)]:
fn = os.path.join(dirpath, filename)
list_video_fn.append(fn)
return list_video_fn |
def _test_products_sign_covariance(dout: int, use_weights: bool):
nbatch = 5
nelec_per_spin = (2, 5)
d = 2
key = jax.random.PRNGKey(0)
(key, subkey) = jax.random.split(key)
inputs = [jax.random.normal(key, (nbatch, n, d)) for n in nelec_per_spin]
flip_sign_inputs = [inputs[0], (- inputs[1])]... |
def save_scores(experiment: str, index: str, values: dict) -> None:
llms = ['BERT', 'RoBERTa', 'SetFit-MiniLM', 'SetFit-mpnet', 'FLAN-T5-small', 'FLAN-T5-base']
models = ['NB', 'LR', 'KNN', 'SVM', 'XGBoost', 'LightGBM']
Path(f'outputs/csv/').mkdir(parents=True, exist_ok=True)
file = Path(f'outputs/csv/{... |
class TestMetaUtils(unittest.TestCase):
def tearDown(self):
destroy_parallel_group()
return super().tearDown()
(torch.cuda.is_available(), 'cpu test')
def test_init_and_reload(self):
with init_empty_weights_with_disk_offload(ignore_tie_weights=False):
model = MyModule(8, ... |
class MDSR(nn.Module):
def __init__(self, args, conv=common.default_conv):
super(MDSR, self).__init__()
n_resblocks = args.n_resblocks
n_feats = args.n_feats
kernel_size = 3
act = nn.ReLU(True)
self.scale_idx = 0
self.url = url['r{}f{}'.format(n_resblocks, n_f... |
def load_swav_teacher_encoder(args, model, logger, distributed=True):
checkpoint = torch.load(args.distill)
model_checkpoint = model.state_dict()
if distributed:
for key in checkpoint:
if (not key.startswith('module.prototypes')):
model_key = key.replace('module', 'module... |
def start_namespace(namespace):
global value_type_prefix
value_type_prefix = (namespace + '.') |
class NonNegativeParametrizer(nn.Module):
pedestal: Tensor
def __init__(self, minimum: float=0, reparam_offset: float=(2 ** (- 18))):
super().__init__()
self.minimum = float(minimum)
self.reparam_offset = float(reparam_offset)
pedestal = (self.reparam_offset ** 2)
self.re... |
class Entity(xmlr.Object):
def __init__(self, name=None, pose=None):
self.name = name
self.pose = pose |
def main():
f = open(sys.argv[1], 'rb')
results_json = json.load(f)['utts']
(num_err, num_tot) = (0, 0)
(risk_stat, sum_prob_stat, ref_prob_stat) = ([], [], [])
for (uttid, info) in results_json.items():
try:
hypotheses = info['output']
ref_token = hypotheses[0]['toke... |
class WeightedRandomSampler(Sampler):
def __init__(self, weights, num_samples, replacement=True):
self.weights = torch.DoubleTensor(weights)
self.num_samples = num_samples
self.replacement = replacement
def __iter__(self):
return iter(torch.multinomial(self.weights, self.num_samp... |
def get_center_bbox(mesh: Type[trimesh.base.Trimesh]) -> Type[np.ndarray]:
return (0.5 * (np.min(mesh.vertices, axis=0) + np.max(mesh.vertices, axis=0))) |
def test_standard_anchor_generator():
from mmdet.models.task_modules import build_anchor_generator
anchor_generator_cfg = dict(type='AnchorGenerator', scales=[8], ratios=[0.5, 1.0, 2.0], strides=[4, 8])
anchor_generator = build_anchor_generator(anchor_generator_cfg)
assert (anchor_generator.num_base_pri... |
class OCC_DukeMTMCreID(BaseImageDataset):
dataset_dir = 'Occluded_Duke'
def __init__(self, root='', verbose=True, pid_begin=0, **kwargs):
super(OCC_DukeMTMCreID, self).__init__()
self.dataset_dir = osp.join(root, self.dataset_dir)
self.dataset_url = '
self.train_dir = osp.join(se... |
class UnetBlock(nn.Module):
def __init__(self, up_in, x_in, n_out):
super().__init__()
up_out = x_out = (n_out // 2)
self.x_conv = nn.Conv2d(x_in, x_out, 1)
self.tr_conv = nn.ConvTranspose2d(up_in, up_out, 2, stride=2)
self.bn = nn.BatchNorm2d(n_out)
def forward(self, up_... |
class RobotMultiTCNRegression(AbstractAgentBasedModel):
def __init__(self, taskdef, *args, **kwargs):
super(RobotMultiTCNRegression, self).__init__(*args, **kwargs)
self.taskdef = taskdef
self.model = None
self.dropout_rate = 0.5
self.num_filters = 128
self.combined_d... |
class L1Dist(nn.Module):
def forward(self, pred, target):
return torch.abs((pred - target)).sum() |
class TestRecurrentIterator(unittest.TestCase, TestCheckpointableIterator):
def setUp(self):
data = list(range(53))
self.expected_result = [0]
for i in data[1:]:
self.expected_result.append((self.expected_result[(- 1)] + i))
def step_function(prev_state, item):
... |
class Workspace(object):
def __init__(self, cfg):
self.work_dir = os.getcwd()
print(f'workspace: {self.work_dir}')
self.cfg = cfg
self.logger = Logger(((self.work_dir + ',env=') + cfg.env), save_tb=cfg.log_save_tb, log_frequency=cfg.log_frequency_step, agent=cfg.agent.name, action_re... |
def save_model(model: torch.nn.Module, path, compression='fp32'):
path = Path(path)
path.mkdir(parents=path.parent, exist_ok=True)
if hasattr(model, '_save'):
model._save(path, compression=compression)
else:
meta_path = (Path(path) / 'nano_model_meta.yml')
metadata = {'ModelType'... |
def Yogi(model_param, lr=0.01, betas=(0.9, 0.999), eps=0.001, initial_accumulator=1e-06, weight_decay=0):
optimizer = optim.Yogi(model_param, lr=lr, betas=betas, eps=eps, initial_accumulator=initial_accumulator, weight_decay=weight_decay)
return optimizer |
(version_base=None, config_path='../config', config_name='main')
def main(cfg: DictConfig):
cmp_cfg = cfg['cmp']
seed = (random.getrandbits(32) if (cmp_cfg['seed'] is None) else cmp_cfg['seed'])
EXEC_LOG.info(f'Using seed {seed}')
model_cfg = cfg['model']
ModelType = Model.init(model_cfg['type'], cf... |
class CorNetXMLCNN(nn.Module):
def __init__(self, dropout, labels_num, dynamic_pool_length, bottleneck_dim, num_filters, **kwargs):
super(CorNetXMLCNN, self).__init__()
self.xmlcnn = XMLCNN(dropout, labels_num, dynamic_pool_length, bottleneck_dim, num_filters, **kwargs)
self.cornet = CorNet(... |
def main(args=None):
rclpy.init(args=args)
visualizer = VisualizerNode()
try:
rclpy.spin(visualizer)
except KeyboardInterrupt:
print('Visualization is terminated')
finally:
visualizer.destroy_node()
print('Visualization stopped cleanly')
rclpy.shutdown() |
def plot_counties(df, variable_to_distribute, variables_to_display, state=None, logcolor=False):
from bokeh.sampledata.us_counties import data as counties
counties = {code: county for (code, county) in counties.items() if (county['state'] == state.lower())}
county_xs = [county['lons'] for county in counties... |
def own_ce(x, soft_cluster, weight, theta):
if (weight is None):
LogSoftmax = F.log_softmax(x, 1)
else:
total_weight = []
for i in range(soft_cluster.shape[0]):
k = torch.argmax(soft_cluster, dim=1)[i].item()
total_weight.append(((weight * 1) / weight[k]))
... |
def color_normal_eqution(latex_contents, latex_file, color_name):
all_begin_brace_list = get_all_begin_brace_nodes(latex_contents, latex_file, search_str_bg='\\[', search_str_ed='\\]')
for begin_brace_list in all_begin_brace_list:
begin_brace = begin_brace_list[(- 1)]
content = begin_brace.get_b... |
def process_queue(instance_id, queue_url, kill_on_fail):
global curr_com
t = threading.Thread(target=watch_for_instance_death, args=(queue_url, instance_id))
t.daemon = True
t.start()
log_file = open('/tmp/queue_log', 'a+', 1)
while True:
try:
output = subprocess.check_output... |
def test_benchmark_dataset():
for i in generator_lmdb('/data/ocr/reg/evaluation/IC15_2077', rgb=False):
print(i) |
def original_monotonic(vec1, vec2, vec3):
'Taken verbatim from
increasing_dims = (vec1 > vec2)
decreasing_dims = (vec1 < vec2)
equal_dims = (vec1 == vec2)
vec3_greater_vec1 = (vec3 >= vec1)
vec3_greater_vec2 = (vec3 >= vec2)
vec3_lesser_vec1 = (vec3 <= vec1)
vec3_lesser_vec2 = (vec3 <= ... |
class Hourglass(nn.Module):
def __init__(self, in_planes, batchNorm=True):
super(Hourglass, self).__init__()
self.batchNorm = batchNorm
self.conv1 = conv3d_bn_relu(self.batchNorm, in_planes, (in_planes * 2), kernel_size=3, stride=2, padding=1, bias=False)
self.conv2 = conv3d_bn(self.... |
def path2str(path: T_path) -> str:
assert isinstance(path, (Path, str)), type(path)
return str(path) |
_arg_scope
def apply_activation(x, name=None, activation_fn=None):
return (activation_fn(x, name=name) if activation_fn else x) |
class BertSelfOutput(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
self.dropout = nn.Dropout(config.hidden_dropout_prob)
def f... |
def loss_D_fn(P, D, options, images, gen_images):
gen_images = gen_images.detach()
N = images.size(0)
all_images = torch.cat([images, gen_images], dim=0)
d_all = D(all_images)
(d_real, d_gen) = (d_all[:N], d_all[N:])
if (options['loss'] == 'nonsat'):
d_loss = (F.softplus(d_gen).mean() + ... |
def mkdir_if_missing(dir_path):
try:
os.makedirs(dir_path)
except OSError as e:
if (e.errno != errno.EEXIST):
raise |
def glu(x):
'Gated Linear Units from
(x, x_h) = tf.split(x, 2, axis=(- 1))
return (tf.sigmoid(x) * x_h) |
def register_nnModule_class():
logger.info('Analyzing nn.Module class definitions in all files ...')
for cl in globals.list_code_line_instance:
parent_class_has_nnModule = (list((set(cl.parent_class_name) & set(['nn.Module', 'torch.nn.Module', 'nn.Sequential', 'torch.Sequential', '_BaseAutoModelClass'])... |
class PPON(nn.Module):
def __init__(self, in_nc, nf, nb, out_nc, alpha=1.0, upscale=4, act_type='lrelu'):
super(PPON, self).__init__()
self.alpha = alpha
n_upscale = int(math.log(upscale, 2))
if (upscale == 3):
n_upscale = 1
fea_conv = B.conv_layer(in_nc, nf, kern... |
def make_dummy_metropolis_fn():
def proposal_fn(params, data, key):
del params
return ((data + jnp.array([1, 2, 3, 4])), key)
def acceptance_fn(params, data, proposed_data):
del params, proposed_data
return jnp.array([True, False, True, False], dtype=bool)
def update_data_fn(... |
def diaresnet200b(**kwargs):
return get_diaresnet(blocks=200, conv1_stride=False, model_name='diaresnet200b', **kwargs) |
class DotProduct(nn.Module):
def __init__(self, x1_dim, x2_dim, prefix='sim', opt={}, dropout=None):
super(DotProduct, self).__init__()
assert (x1_dim == x2_dim)
self.opt = opt
self.prefix = prefix
self.scale_on = opt.get('{}_scale'.format(self.prefix), False)
self.sc... |
class Response():
def __init__(self) -> None:
self.data: Union[(Dict[(str, Any)], List[Dict[(str, Any)]])] = {}
self.command: Dict[(str, Any)] = {} |
def main():
parser = argparse.ArgumentParser(description='Export model to the onnx format')
parser.add_argument('--config-file', default='configs/FCOS-Detection/R_50_1x.yaml', metavar='FILE', help='path to config file')
parser.add_argument('--width', default=0, type=int)
parser.add_argument('--height', ... |
def get_hrnet_encoder(cfg, init_weight=True, global_mode=False, **kwargs):
model = PoseHighResolutionNet(cfg, global_mode=global_mode)
if init_weight:
if (cfg.HR_MODEL.PRETR_SET in ['imagenet']):
model.init_weights(cfg.HR_MODEL.PRETRAINED_IM)
logger.info('loaded HRNet imagenet pr... |
def ground_caption(captions, n_ground=1, prefix='describe visual inputs:', sort=True):
n_boxes = len(captions)
if sort:
ground_indices = torch.randperm(n_boxes)[:n_ground].sort().values
else:
ground_indices = torch.randperm(n_boxes)[:n_ground]
ground_indices = ground_indices.tolist()
... |
def _sample_generator(G, num_samples):
latent_samples = G.sample_latent(num_samples)
generated_data = G(latent_samples)
return generated_data |
def filename_to_url(filename, cache_dir=None):
if (cache_dir is None):
cache_dir = TRANSFORMERS_CACHE
if isinstance(cache_dir, Path):
cache_dir = str(cache_dir)
cache_path = os.path.join(cache_dir, filename)
if (not os.path.exists(cache_path)):
raise EnvironmentError('file {} not... |
def insert_first_match(cur_page_cls, box, specific_text):
assert (specific_text != None)
def overlap_len(min1, len1, min2, len2):
min_ = min1
max_ = (min1 + len1)
if (min1 > min2):
min_ = min2
if ((min1 + len1) < (min2 + len2)):
max_ = (min2 + len2)
... |
def nasnet_large_arg_scope(weight_decay=5e-05, batch_norm_decay=0.9997, batch_norm_epsilon=0.001):
batch_norm_params = {'decay': batch_norm_decay, 'epsilon': batch_norm_epsilon, 'scale': True, 'fused': True}
weights_regularizer = tf.contrib.layers.l2_regularizer(weight_decay)
weights_initializer = tf.contri... |
class MomentumAgent(TradingAgent):
def __init__(self, id: int, symbol, starting_cash, name: Optional[str]=None, type: Optional[str]=None, random_state: Optional[np.random.RandomState]=None, min_size=20, max_size=50, wake_up_freq: NanosecondTime=str_to_ns('60s'), poisson_arrival=True, order_size_model=None, subscrib... |
class DPTDepthModel(DPT):
def __init__(self, path=None, non_negative=True, **kwargs):
features = (kwargs['features'] if ('features' in kwargs) else 256)
head_features_1 = (kwargs['head_features_1'] if ('head_features_1' in kwargs) else features)
head_features_2 = (kwargs['head_features_2'] i... |
def hernquist_vcirc(r, a_scale=1.0, m=1.0, G=1.0):
v_circ = np.sqrt((((G * m) * r) * ((r + a_scale) ** (- 2))))
return v_circ |
class IntermediateRosNode():
def __init__(self, idx_env=0, laser_scan_publish_rate: int=0):
self._robot_frame_id = 'arena_robot_{:02d}'.format(idx_env)
self._header_seq_id = 0
rospy.init_node('arena_env{:02d}_redirecter'.format(idx_env), anonymous=True)
self._idx_env = idx_env
... |
def create_dataset(args):
model_path = args.model_path
if (not os.path.exists(model_path)):
os.makedirs(model_path)
result_path = os.path.join(model_path, 'translations')
if (not os.path.exists(result_path)):
os.makedirs(result_path)
vocab_path = os.path.join(model_path, 'vocab')
... |
def get_j(input):
check_input(input)
if (input.dim() < 4):
nb_hidden = input.size()[(- 1)]
else:
nb_hidden = input.size()[1]
if (input.dim() == 2):
return input.narrow(1, (nb_hidden // 2), (nb_hidden // 4))
if (input.dim() == 3):
return input.narrow(2, (nb_hidden // 2... |
def conv1x1(in_planes, out_planes, stride=1):
return nn.Conv3d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False) |
def sample_qtables(minqual=8, maxqual=25, training=True, default_quality=10):
if training:
qual = tf.random_uniform(shape=[1], minval=minqual, maxval=maxqual)
else:
qual = default_quality
return (get_std_jpeg_qtable(qual), qual) |
def test_implicit_subscript_symbol_does_not_bump_ts():
cells = {0: 'lst = [] + [0, 1]', 1: 'logging.info(lst)', 2: 'logging.info(lst[0])'}
run_all_cells(cells)
response = flow().check_and_link_multiple_cells()
assert (response.waiting_cells == set())
assert (response.ready_cells == set()) |
class ATAC_FCNHead(HybridBlock):
def __init__(self, head_act, useReLU, in_channels, channels, norm_layer=nn.BatchNorm, norm_kwargs=None, **kwargs):
super(ATAC_FCNHead, self).__init__()
with self.name_scope():
self.block = nn.HybridSequential()
inter_channels = (in_channels //... |
def plot_image_from_w(w, G):
img = get_image_from_w(w, G)
pillow_image = Image.fromarray(img)
plt.imshow(pillow_image)
plt.show() |
def choose_item(items):
while True:
try:
idx = int(input('Choose number: '))
return items[idx]
except Exception:
print('Invalid choice. Try again.') |
class BoxE(BaseModel):
def __init__(self, entity_dict_len, relation_dict_len, embedding_dim):
super(BoxE, self).__init__(model_name='BoxE')
self.embedding_dim = embedding_dim
self.entity_dict_len = entity_dict_len
self.relation_dict_len = relation_dict_len
self.entity_embeddi... |
class BaselineEstimator(nn.Module):
def __init__(self, img_feature_dim=1024, azi_classes=24, ele_classes=12, inp_classes=24):
super(BaselineEstimator, self).__init__()
self.img_encoder = resnet.resnet18(num_classes=img_feature_dim)
self.compress = nn.Sequential(nn.Linear(img_feature_dim, 800... |
def innermost_tqdm():
if (hasattr(tqdm, '_instances') and (len(tqdm._instances) > 0)):
return max(tqdm._instances, key=(lambda x: x.pos))
else:
return None |
def find_unique_words_in_dataset(talks_read, talk_names, talk_idx, monolingual, include_idx_set_members=False):
talk_is_included = (lambda c: ((c in talk_idx) if include_idx_set_members else (c not in talk_idx)))
word_set = set()
for (k, c) in enumerate(talks_read):
if (monolingual or talk_is_includ... |
def use_opencv2():
try:
major_version = cv2.__version__.split('.')[0]
except TypeError:
major_version = 4
return (major_version == '2') |
class MultidatasetEpochBatchIterator(iterators.EpochBatchIterating):
def __init__(self, dataset, batch_sampler, seed=1, num_shards=1, shard_id=0, num_workers=0, epoch=1):
assert isinstance(dataset, OrderedDict)
assert len(dataset)
assert isinstance(dataset[next(iter(dataset))], FairseqDatase... |
def _config_debug(config):
if config.debug:
config.num_steps = 2
config.eval_period = 1
config.log_period = 1
config.save_period = 1
config.val_num_batches = 2
config.test_num_batches = 2 |
def get_named_client_logger(name: str, host: str='localhost', port: int=logging.handlers.DEFAULT_TCP_LOGGING_PORT) -> 'PicklableClientLogger':
logger = PicklableClientLogger(name=name, host=host, port=port)
return logger |
def pgtrain(optims_gen, optims_dis, generator, agent, discriminator, bsize, embed_dim, trainSample, validSample, testSample, val_acc_best, val_preck_best, val_loss_best, action_num, max_length, recom_length, gen_ratio=0.1, n_epochs=5, write_item='click_gen.txt', write_target='tar_gen.txt', write_reward='reward_gen.txt'... |
class TestTrackers(unittest.TestCase):
def setUp(self):
self.data_dir = 'data'
self.tracker = IdentityTracker()
def tearDown(self):
pass
def test_identity_tracker(self):
root_dir = os.path.join(self.data_dir, 'GOT-10k')
dataset = GOT10k(root_dir, subset='val')
... |
def test_digits_sqrt_lazy_object():
model = FeatureBasedSelection(100, 'sqrt', optimizer=LazyGreedy())
model.fit(X_digits)
assert_array_equal(model.ranking, digits_sqrt_ranking)
assert_array_almost_equal(model.gains, digits_sqrt_gains, 4)
assert_array_almost_equal(model.subset, X_digits[model.rankin... |
class MySpatialPyramidPooling(nn.Module):
def __init__(self, channels_in, channels_out, level_num, spp_channels, level_channels, grid=(8, 4, 2, 1), bn_momentum=0.1):
super(MySpatialPyramidPooling, self).__init__()
self.grid = grid
self.level_num = level_num
self.SPP_BN = _BNReluConv(... |
def print_info(s):
print((((((TerminalColors.OKBLUE + '[') + get_time()) + '] ') + str(s)) + TerminalColors.ENDC)) |
class BilinearMasked(Bilinear, _BaseRealMixin):
def forward(self, input1, input2):
return F.bilinear(input1, input2, self.weight_masked, self.bias) |
class FangraphsPitchingStatsTable(FangraphsDataTable):
STATS_CATEGORY: FangraphsStatsCategory = FangraphsStatsCategory.PITCHING
DEFAULT_STAT_COLUMNS: List[FangraphsStatColumn] = FangraphsPitchingStats.ALL()
ROW_ID_FUNC: RowIdFunction = player_row_id_func
ROW_ID_NAME = 'IDfg'
_cache()
def fetch(s... |
class TreeIterator():
def __init__(self, tree, order='pre'):
self.tree = tree
self.pos = [0]
self.order = order
def __iter__(self):
return self
def __next__(self):
while True:
if (len(self.pos) == 0):
raise StopIteration
ans = N... |
class DepthwiseSeparableConv(nn.Module):
def __init__(self, in_chs, out_chs, dw_kernel_size=3, stride=1, pad_type='', act_layer=nn.ReLU, noskip=False, pw_kernel_size=1, pw_act=False, se_ratio=0.0, se_kwargs=None, norm_layer=nn.BatchNorm2d, norm_kwargs=None, drop_connect_rate=0.0):
super(DepthwiseSeparableCo... |
def map_dataset(examples: dict[(str, list[str])], args: 'Args', context: TokenizationContext) -> dict:
instructions = examples['instruction']
responses = examples['response']
prompts = [MAGICODER_PROMPT.format(instruction=instruction, response='') for instruction in instructions]
completions = responses... |
class LossTracker():
def __init__(self, output_folder='.'):
self.tracks = OrderedDict()
self.epochs = []
self.means_over_epochs = OrderedDict()
self.output_folder = output_folder
def update(self, d):
for (k, v) in d.items():
if (k not in self.tracks):
... |
_criterion('mmloss')
class MMCriterion(FairseqCriterion):
def __init__(self, task):
super().__init__(task)
self.mmtask = task.mmtask
def forward(self, model, sample):
outputs = self.mmtask(model, sample)
(loss, loss_scalar, max_len, batch_size, sample_size) = (outputs['loss'], ou... |
class GreedyOptimizer(PathOptimizer):
__slots__ = ('costmod', 'temperature', 'simplify', '_optimize_fn')
def __init__(self, costmod=1.0, temperature=0.0, simplify=True, accel='auto'):
self.costmod = costmod
self.temperature = temperature
self.simplify = simplify
self._optimize_fn... |
def build_and_train(slot_affinity_code, log_dir, run_ID, config_key):
affinity = affinity_from_code(slot_affinity_code)
config = configs[config_key]
variant = load_variant(log_dir)
config = update_config(config, variant)
sampler = SerialSampler(EnvCls=gym_make, env_kwargs=config['env'], CollectorCls... |
def main():
(df_by_lk, df_berlin_cases_sum, df_berlin_deaths_sum) = fetch_and_clean_data()
df_by_lk_deaths = pd.concat([df_by_lk[c] for c in df_by_lk if str(c).endswith('_deaths')], axis=1)
df_by_lk_deaths.rename(columns={c: int(c.split('_')[0]) for c in df_by_lk_deaths}, inplace=True)
df_by_lk_cases = ... |
class PILRandomGaussianBlur(object):
def __init__(self, p=0.5, radius_min=0.1, radius_max=2.0):
self.prob = p
self.radius_min = radius_min
self.radius_max = radius_max
def __call__(self, img):
do_it = (np.random.rand() <= self.prob)
if (not do_it):
return img
... |
def wrd_name(trn):
split = trn.split('.')
return (('.'.join(split[:(- 1)]) + '.wrd.') + split[(- 1)]) |
class calculate_metrics():
def divide_chunks(self, l, n=2):
for i in range(0, len(l), n):
(yield l[i:(i + n)])
return
def parse_pred_ans(self, pred_ans):
pred_label = None
if (pred_ans in ['yes', 'no']):
pred_label = pred_ans
else:
pref... |
def define2DBoolVarArrayArray(gurobiModel, sizeX, sizeY, name):
return gurobiModel.addVars(sizeX, sizeY, vtype=GRB.BINARY, name=name) |
def find_classes(folder: Path) -> FilePathList:
classes = [d for d in folder.iterdir() if (d.is_dir() and (not d.name.startswith('.')))]
assert (len(classes) > 0)
return sorted(classes, key=(lambda d: d.name)) |
_registry(operator_type='BatchMatMulV2')
class BatchMatMulV2(Operator):
def __init__(self):
super().__init__()
def set_attr(self, framework, node):
if (framework == 'tensorflow'):
self._attr['transpose_a'] = node.attr['adj_x'].b
self._attr['transpose_b'] = node.attr['adj_... |
def KMeans(feat, n_clusters=2):
kmeans = cluster.KMeans(n_clusters=n_clusters, n_jobs=multiprocessing.cpu_count(), random_state=0).fit(feat)
return kmeans.labels_ |
class LossylessDataModule(LightningDataModule):
def __init__(self, data_dir=DIR, val_size=0.1, test_size=None, num_workers=16, batch_size=128, val_batch_size=None, seed=123, reload_dataloaders_every_epoch=False, dataset_kwargs={}):
super().__init__()
self.data_dir = data_dir
self.val_size = ... |
def test_amuse_LogarithmicHaloPotential():
lp = potential.LogarithmicHaloPotential(normalize=1.0)
tmax = 2.0
(vo, ro) = (210.0, 8.5)
o = Orbit([1.0, 0.1, 1.1, 0.3, 0.1, 0.4], ro=ro, vo=vo)
run_orbitIntegration_comparison(o, lp, tmax, vo, ro, tol=0.03)
return None |
class Constant(AbsOpBase):
in_dtypes = [()]
out_dtypes = [(i,) for i in DTYPE_GEN_ALL]
def __str__(self) -> str:
return ((self.name() + ' ') + str(self.extra_attrs).replace(':', '='))
def __init__(self, dim: int):
super().__init__()
self.dim = dim
self.inp_ranks = []
... |
class CityScapes(MyDataset):
def __init__(self, args, transform=None, target_transform=None, augment=False, split='train', resize=False, imsize=256):
CLASSES = ['<eos>', 'person', 'rider', 'car', 'truck', 'bus', 'train', 'motorcycle', 'bicycle']
self.classes = CLASSES
self.num_classes = len(... |
class ConvTranspose3d(_ConvTransposeMixin, _ConvNd):
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1):
kernel_size = _triple(kernel_size)
stride = _triple(stride)
padding = _triple(padding)
dilation = _... |
def collate_fn(examples):
pixel_values = torch.stack([example['pixel_values'] for example in examples])
mask = torch.stack([example['mask'] for example in examples])
return {'pixel_values': pixel_values, 'bool_masked_pos': mask} |
class ResUNet(ME.MinkowskiNetwork):
NORM_TYPE = None
BLOCK_NORM_TYPE = 'BN'
CHANNELS = [None, 32, 64, 128]
TR_CHANNELS = [None, 32, 64, 64]
REGION_TYPE = ME.RegionType.HYPER_CUBE
def __init__(self, in_channels=3, out_channels=32, bn_momentum=0.1, conv1_kernel_size=3, normalize_feature=False, D=3... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.