code stringlengths 101 5.91M |
|---|
def _get_base_dist(dist):
if isinstance(dist, Independent):
return _get_base_dist(dist.base_dist)
else:
return dist |
class InferenceOptions(BaseOptions):
def initialize(self):
BaseOptions.initialize(self)
src_input_desc = '\n All source paths and it supports multiple paths, uses "|" as the separator between all paths. \n The format is "src_path_1|src_path_2|src_path_3". \n Each src... |
def sort_sp_doc_ids(doc1_id, doc1, doc2_id, doc2, answer, id, alt_doc1=None, alt_doc2=None):
_answer = re.escape(answer)
_answer_lower = _answer.lower()
ans_in_lower = False
a = re.search('({})'.format((((('(?<!([A-Za-z]))' + _answer) + '(?=(') + '|'.join([re.escape(t) for t in SHORT_PUNCT])) + '))')), ... |
def train_rcnn(cfg, dataset, image_set, root_path, dataset_path, frequent, kvstore, flip, shuffle, resume, ctx, pretrained, epoch, prefix, begin_epoch, end_epoch, train_shared, lr, lr_step, proposal, logger=None, output_path=None):
mx.random.seed(3)
np.random.seed(3)
if (not logger):
logging.basicCo... |
def _concat_dataset(cfg, default_args=None):
from .dataset_wrappers import ConcatDataset
ann_files = cfg['ann_file']
img_prefixes = cfg.get('img_prefix', None)
seg_prefixes = cfg.get('seg_prefix', None)
proposal_files = cfg.get('proposal_file', None)
datasets = []
num_dset = len(ann_files)
... |
def test_digits_cosine_two_stage_sparse():
model = SaturatedCoverageSelection(100, 'precomputed', optimizer='two-stage')
model.fit(X_digits_cosine_sparse)
assert_array_equal(model.ranking, digits_cosine_ranking)
assert_array_almost_equal(model.gains, digits_cosine_gains, 4) |
class TestA1Slam(GtsamTestCase):
def setUp(self):
rospy.init_node('test_node', anonymous=True)
rospy.loginfo('Initialized test_node')
imu_topic = rospy.get_param('/imu/topic')
self.imu_pub = rospy.Publisher(imu_topic, HighState)
rospy.Subscriber('/pose_estimate', PoseStamped,... |
_module()
class ResNeSt(ResNetV1d):
arch_settings = {50: (Bottleneck, (3, 4, 6, 3)), 101: (Bottleneck, (3, 4, 23, 3)), 152: (Bottleneck, (3, 8, 36, 3)), 200: (Bottleneck, (3, 24, 36, 3))}
def __init__(self, groups=1, base_width=4, radix=2, reduction_factor=4, avg_down_stride=True, **kwargs):
self.groups... |
def validate_limit_model_concurrency(value):
if (value >= 0):
return value
else:
raise argparse.ArgumentTypeError('Limit model concurrency must be a non-negative integer.') |
class WeightedSequenceTagger(SequenceTagger):
def _calculate_loss(self, features: torch.tensor, sentences: List[Sentence]) -> float:
lengths: List[int] = [len(sentence.tokens) for sentence in sentences]
tag_list: List = []
weight_list: List[float] = []
for (s_id, sentence) in enumera... |
class TestLite(TestCase):
def setUp(self):
test_dir = os.path.dirname(__file__)
project_test_dir = os.path.abspath(os.path.join(test_dir, '..', '..', '..', '..', '..'))
os.environ['PYTHONPATH'] = project_test_dir
def test_torch_nano(self):
model = ResNet18(10, pretrained=False, i... |
def compute_live_dead_symbol_refs(code: Union[(str, ast.AST)]) -> Tuple[(Set[str], Set[str])]:
if isinstance(code, str):
code = textwrap.dedent(code)
(live, dead) = compute_live_dead_symbol_refs_with_stmts(code)
live = {ref.ref for ref in live}
(live, dead) = (_simplify_symbol_refs(live), _simpl... |
def run_kmeans(x, num_clusters, temperature):
print('performing kmeans clustering')
results = {'im2cluster': [], 'centroids': [], 'density': []}
for (seed, num_cluster) in enumerate(num_clusters):
d = x.shape[1]
k = int(num_cluster)
clus = faiss.Clustering(d, k)
clus.verbose ... |
def hammingSimilarity(l1=[], l2=[]):
hammingD = 0
nsensors = len(l1)
nNonZero = len(l1)
for i in range(0, nsensors):
if (l1[i] != l2[i]):
hammingD += 1
if ((l1[i] == 0) and (l2[i] == 0)):
nNonZero = (nNonZero - 1)
ratio = (float(hammingD) / nsensors)
hammi... |
class MultimodalConfig():
batch_size: int
train_steps: int
optimizer_name: str = 'AdamW'
lr: float = 0.0008
image_enc_lr: float = None
min_lr: float = 0.0
lr_decay_iters: int = None
gradient_accumulation_steps: int = 1
image_size: int = 256
eval_every: int = 250
eval_steps: i... |
def multiple_run_tune_separate(default_params, tune_params, save_path):
start = time.time()
print('Setting up data stream')
data_continuum = continuum(default_params.data, default_params.cl_type, default_params)
data_end = time.time()
print('data setup time: {}'.format((data_end - start)))
if (d... |
def load_cdod_voc_instances(dirname: str, split: str, class_names: Union[(List[str], Tuple[(str, ...)])]):
with PathManager.open(os.path.join(dirname, 'ImageSets', 'Main', (split + '.txt'))) as f:
fileids = np.loadtxt(f, dtype=np.str)
annotation_dirname = PathManager.get_local_path(os.path.join(dirname,... |
class TFDPRContextEncoder(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
class LGBOptimizerOptuna(object):
def __init__(self, objective: str='binary', verbose: bool=False):
self.objective = objective
self.verbose = verbose
self.best: Dict[(str, Any)] = {}
def optimize(self, dtrain: lgbDataset, deval: lgbDataset):
params: Dict = {'objective': self.obje... |
def classifier(pretrained=False, **kwargs):
model = Classifier(**kwargs)
if pretrained:
if os.path.isfile(pretrained):
checkpoint = torch.load(pretrained)
model.load_state_dict(checkpoint['state_dict'])
else:
raise RuntimeError(('Could not find weights file: %... |
def build_modelzoo(result_path: Union[(str, Path)], weights_path: Union[(str, Path)], bundle_path: Union[(str, Path)], inputs: str, outputs: str, preprocessing: list, postprocessing: list, doc: Union[(str, Path)], name: str, authors: list, algorithm: Algorithm, tf_version: str, cite: List[Dict], axes: str='byxc', files... |
def transform_beziers_annotations(beziers, transforms):
beziers = np.asarray(beziers, dtype='float64').reshape((- 1), 2)
beziers = transforms.apply_coords(beziers).reshape((- 1))
do_hflip = ((sum((isinstance(t, T.HFlipTransform) for t in transforms.transforms)) % 2) == 1)
if do_hflip:
raise Valu... |
class TestTrainer(unittest.TestCase):
def test_simple_trainer(self, device='cpu'):
device = torch.device(device)
model = SimpleModel(nn.Linear(10, 10)).to(device)
def data_loader():
while True:
(yield torch.rand(3, 3).to(device))
trainer = SimpleTrainer(mo... |
def close_progress_bar(pbar: Union[(tqdm, Tuple[(Progress, Live)], None)], show: bool, pretty: bool) -> None:
if (not show):
return
elif (show and (not pretty)):
pbar.close()
else:
(_, live) = pbar
live.stop() |
class Conv_V(nn.Module):
def __init__(self, input_channels, output_channels, filter_shape):
super(Conv_V, self).__init__()
self.conv = nn.Conv2d(input_channels, output_channels, filter_shape, padding=(0, (filter_shape[1] // 2)))
self.bn = nn.BatchNorm2d(output_channels)
self.relu = n... |
def main():
co_transform = pc_transforms.Compose([pc_transforms.ArrayToTensor(), transforms.Normalize(mean=[0.5, 0.5], std=[1, 1])])
input_transforms = transforms.Compose([pc_transforms.ArrayToTensor()])
target_transforms = transforms.Compose([pc_transforms.ArrayToTensor()])
[train_dataset, valid_datase... |
class Gym():
def make(self, env_id, render_save):
reset_type = env_id.split('-v')[1]
env = Pose_Env_Base(int(reset_type), render_save=render_save)
return env |
def train(ep, sess):
global batch_size, total_steps
total_loss = 0
start_time = time.time()
correct = 0
counter = 0
for (batch_idx, indices) in index_generator(n_train, batch_size):
x = train_x[indices]
y = train_y[indices]
x = np.reshape(x, (x.shape + (1,)))
(_, ... |
class Bottleneck(nn.Module):
expansion = 4
def __init__(self, inplanes, planes, stride=1, downsample=None):
super().__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = nn.Conv2d(planes, planes, kernel_size=... |
def disable_save_v3():
global _ENABLE_SAVE_V3
global ORI_SAVE_V2
global ORI_ADDRESTOREOPS
if (not _ENABLE_SAVE_V3):
return
_ENABLE_SAVE_V3 = False
io_ops.save_v2 = ORI_SAVE_V2
ORI_SAVE_V2 = None
for (saver_builder, origin_add_restore_ops) in zip(TFPLUS_SAVER_BUILDER, ORI_ADDRESTO... |
def clip_grad_norm_for_ut(parameters, max_norm, norm_type=2, tp_group=None):
if isinstance(parameters, torch.Tensor):
parameters = [parameters]
parameters = list(filter((lambda p: (p.grad is not None)), parameters))
max_norm = float(max_norm)
norm_type = float(norm_type)
if (norm_type == mat... |
class ResnetBlock(nn.Module):
def __init__(self, dim, padding_type, norm_layer, use_dropout, use_bias):
super(ResnetBlock, self).__init__()
self.conv_block = self.build_conv_block(dim, padding_type, norm_layer, use_dropout, use_bias)
def build_conv_block(self, dim, padding_type, norm_layer, use_... |
class TestRemoveResetInZeroStateFixedPoint(QiskitTestCase):
def test_two_resets(self):
qr = QuantumRegister(1, 'qr')
circuit = QuantumCircuit(qr)
circuit.reset(qr[0])
circuit.reset(qr[0])
expected = QuantumCircuit(qr)
pass_manager = PassManager()
pass_manager.... |
def _validate(sym: Any) -> Symbol:
if ((sym is None) or (not isinstance(sym, Symbol))):
raise ValueError('unable to lookup metadata for symbol')
return cast(Symbol, sym) |
def get_opts_base():
parser = configargparse.ArgParser()
parser.add_argument('--config_file', is_config_file=True)
parser.add_argument('--dataset_type', type=str, default='filesystem', choices=['filesystem', 'memory'], help='specifies whether to hold all images in CPU memory during training, or whether to w... |
class BaseWrapperDataset(FairseqDataset):
def __init__(self, dataset):
super().__init__()
self.dataset = dataset
def __getitem__(self, index):
return self.dataset[index]
def __len__(self):
return len(self.dataset)
def collater(self, samples):
if hasattr(self.datas... |
class IMQSteinKernel(torch.nn.Module):
def __init__(self, alpha=0.5, beta=(- 0.5), bandwidth=None):
super(IMQSteinKernel, self).__init__()
assert (alpha > 0.0), 'alpha must be positive.'
assert (beta < 0.0), 'beta must be negative.'
self.alpha = alpha
self.beta = beta
... |
_module
class FastRCNN(TwoStageDetector):
def __init__(self, backbone, neck, bbox_roi_extractor, bbox_head, train_cfg, test_cfg, mask_roi_extractor=None, mask_head=None, pretrained=None):
super(FastRCNN, self).__init__(backbone=backbone, neck=neck, bbox_roi_extractor=bbox_roi_extractor, bbox_head=bbox_head,... |
class Timer():
def __init__(self):
self.o = time.time()
def measure(self, p=1):
x = ((time.time() - self.o) / p)
x = int(x)
if (x >= 3600):
return '{:.1f}h'.format((x / 3600))
if (x >= 60):
return '{}m'.format(round((x / 60)))
return '{}s'.... |
def get_peft_kwargs(rank_dict, network_alpha_dict, peft_state_dict, is_unet=True):
rank_pattern = {}
alpha_pattern = {}
r = lora_alpha = list(rank_dict.values())[0]
if (len(set(rank_dict.values())) > 1):
r = collections.Counter(rank_dict.values()).most_common()[0][0]
rank_pattern = dict(... |
class OptionNamespace():
def __init__(self):
pass
def get_value(self, name):
name = name.replace('-', '_')
if (name in self.__dict__):
return self.__dict__[name]
else:
raise Exception((('Option attribute: ' + name) + ' does not exist'))
def __contains_... |
def SparseDenseNet161(sparse_func, sparsities):
return SparseDenseNet(SparseBottleneck, [6, 12, 36, 24], sparse_func, sparsities, growth_rate=48) |
def conv_block(in_nc, out_nc, kernel_size, stride=1, dilation=1, groups=1, bias=True, pad_type='zero', norm_type=None, act_type='relu'):
padding = get_valid_padding(kernel_size, dilation)
p = (pad(pad_type, padding) if (pad_type and (pad_type != 'zero')) else None)
padding = (padding if (pad_type == 'zero')... |
class AdaptiveFactorizationNetwork(torch.nn.Module):
def __init__(self, field_dims, embed_dim, LNN_dim, mlp_dims, dropouts):
super().__init__()
self.num_fields = len(field_dims)
self.linear = FeaturesLinear(field_dims)
self.embedding = FeaturesEmbedding(field_dims, embed_dim)
... |
def do_train(cur_step, optimizer, sim, net):
epoch = 0
while True:
steps = int(((1 * 20) * spf))
reset_sim(sim)
sigma = 0.1
x = ((((np.random.random() * sigma) - (0.5 * sigma)) + (np.random.randint(2) * 2)) - 1)
goal = torch.tensor([0.0, 0.0, 0.0, x, 0, ((2 + (np.random.r... |
class grammardefaultParser(Parser):
def __init__(self, whitespace=re.compile('(?!.*)'), nameguard=None, comments_re=None, eol_comments_re=None, ignorecase=None, left_recursion=True, parseinfo=True, keywords=None, namechars='', buffer_class=grammardefaultBuffer, **kwargs):
if (keywords is None):
... |
def macd(df, n_fast, n_slow):
EMAfast = pd.Series(df['Close'].ewm(span=n_fast, min_periods=n_slow).mean())
EMAslow = pd.Series(df['Close'].ewm(span=n_slow, min_periods=n_slow).mean())
MACD = pd.Series((EMAfast - EMAslow), name=((('MACD_' + str(n_fast)) + '_') + str(n_slow)))
MACDsign = pd.Series(MACD.ew... |
def create_double_value_function(value_fn, *args, **kwargs):
value_fns = tuple((value_fn(*args, **kwargs) for i in range(2)))
return value_fns |
class Conv2dNormRelu(nn.Module):
def __init__(self, in_ch, out_ch, kernel_size=3, stride=1, padding=0, bias=True, norm_type='Unknown'):
super(Conv2dNormRelu, self).__init__()
self.conv = nn.Sequential(nn.Conv2d(in_ch, out_ch, kernel_size, stride, padding, bias=bias), get_norm(norm_type, out_ch), nn.... |
class orderedSampler(Sampler):
def __init__(self, data_source, batch_size, nb_classes=10, shuffle=True):
self.data_source = data_source
target_lists = collections.defaultdict(list)
for (i, (data, label)) in enumerate(self.data_source):
target_lists[label].append(i)
self.t... |
def actionAngleFreqAngleStaeckel_c(pot, delta, R, vR, vT, z, vz, phi, u0=None, order=10):
if (u0 is None):
(u0, dummy) = coords.Rz_to_uv(R, z, delta=numpy.atleast_1d(delta))
from ..orbit.integrateFullOrbit import _parse_pot
from ..orbit.integratePlanarOrbit import _prep_tfuncs
(npot, pot_type, p... |
def objects365v1_classes() -> list:
return ['person', 'sneakers', 'chair', 'hat', 'lamp', 'bottle', 'cabinet/shelf', 'cup', 'car', 'glasses', 'picture/frame', 'desk', 'handbag', 'street lights', 'book', 'plate', 'helmet', 'leather shoes', 'pillow', 'glove', 'potted plant', 'bracelet', 'flower', 'tv', 'storage box',... |
def get_dataset_distributed(name, world_size, rank, batch_size, **kwargs):
dataset = globals()[name](**kwargs)
sampler = torch.utils.data.distributed.DistributedSampler(dataset, num_replicas=world_size, rank=rank)
dataloader = torch.utils.data.DataLoader(dataset, sampler=sampler, batch_size=batch_size, shuf... |
def nfsp_measure_exploitability_nonlstm(rllib_policies: List[Policy], poker_game_version: str, open_spiel_env_config: dict=None):
if (open_spiel_env_config is None):
if (poker_game_version in ['kuhn_poker', 'leduc_poker']):
open_spiel_env_config = {'players': pyspiel.GameParameter(2)}
el... |
def get_env_infos(env, env_config):
env_infos = {}
if is_arena_env(env):
dummy_env = ArenaRllibEnv(env=env, env_config=env_config)
env_infos['number_agents'] = dcopy(dummy_env.number_agents)
else:
dummy_env = gym.make(env)
env_infos['number_agents'] = 1
env_infos['obs_spa... |
class NormalDataset(Dataset):
def __init__(self, files: List, config: Namespace):
self.files = files
self.center = config.center
self.transforms = T.Compose([T.Resize(config.image_size, T.InterpolationMode.LANCZOS), T.CenterCrop(config.image_size), T.ToTensor()])
with Pool(cpu_count(... |
def group_norm(input, group, running_mean, running_var, weight=None, bias=None, use_input_stats=True, momentum=0.1, eps=1e-05):
if ((not use_input_stats) and ((running_mean is None) or (running_var is None))):
raise ValueError('Expected running_mean and running_var to be not None when use_input_stats=False'... |
def check_model_contexts(config_dir, nnet_edits=None, existing_model=None):
contexts = {}
for file_name in ['init', 'ref']:
if os.path.exists('{0}/{1}.config'.format(config_dir, file_name)):
contexts[file_name] = {}
common_lib.execute_command('nnet3-init {0} {1}/{2}.config {1}/{2... |
class TFBertMainLayer(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
class nnUNetTrainerV2_independentScalePerAxis(nnUNetTrainerV2):
def setup_DA_params(self):
super().setup_DA_params()
self.data_aug_params['independent_scale_factor_for_each_axis'] = True |
def take_while_two(pred_first: Callable[([T], bool)], pred: Callable[([T, T], bool)], iterable: Iterable[T]) -> tuple[(list[T], Iterator[T])]:
iterator = iter(iterable)
try:
first_elem = next(iterator)
if (not pred_first(first_elem)):
return ([], itertools.chain([first_elem], iterato... |
class SEU(object):
num_classes = 20
inputchannel = 1
def __init__(self, data_dir, normlizetype):
self.data_dir = data_dir
self.normlizetype = normlizetype
def data_preprare(self, test=False):
list_data = get_files(self.data_dir, test)
if test:
test_dataset = d... |
def plotFile(filename):
legend = []
(name, a1, p1) = read_file(filename)
legend.append((str(name) + '_actual'))
legend.append((str(name) + '_predicted'))
plt.plot(range(400, 800, 2), a1)
plt.plot(range(400, 800, 2), p1)
plt.title('Comparing spectrums')
plt.ylabel('Cross Scattering Amplit... |
def vgg11_bn(num_classes=1000, pretrained='imagenet'):
model = models.vgg11_bn(pretrained=False)
if (pretrained is not None):
settings = pretrained_settings['vgg11_bn'][pretrained]
model = load_pretrained(model, num_classes, settings)
return model |
class Path(Enum):
SDK = qiskit_path[0]
TEST = os.path.normpath(os.path.join(SDK, '..', 'test', 'python'))
EXAMPLES = os.path.normpath(os.path.join(SDK, '..', 'examples'))
SCHEMAS = os.path.normpath(os.path.join(SDK, 'schemas'))
CASSETTES = os.path.normpath(os.path.join(TEST, '..', 'cassettes'))
... |
def get_act_fn(name='relu'):
if (not name):
return None
if (not (is_no_jit() or is_exportable() or is_scriptable())):
if (name in _ACT_FN_ME):
return _ACT_FN_ME[name]
if (not is_no_jit()):
if (name in _ACT_FN_JIT):
return _ACT_FN_JIT[name]
return _ACT_FN_D... |
class ImagesSpotClipSampler(SpotClipSampler):
def __init__(self, data_source: Spot, images_per_video: (int | None)=None, shuffle: bool=False) -> None:
super().__init__(data_source, shuffle=shuffle)
self.images_per_video = images_per_video
def __iter__(self) -> List[Any]:
g = torch.Genera... |
class Viz_WSOL(object):
def __init__(self):
super(Viz_WSOL, self).__init__()
self.gt_col = _GT_COLOR
self.pred_col = _PRED_COLOR
self.dpi = 50
self.alpha = 128
self.heatmap_cmap = plt.get_cmap('jet')
self.mask_cmap_seg = get_bin_mask_colormap_segm()
se... |
class MistralModel(BaseModel):
def match(self, model_path: str):
return ('mistral' in model_path.lower())
def get_default_conv_template(self, model_path: str) -> Conversation:
return get_conv_template('mistral') |
def create_sentence_vectors(body_copy):
doc2 = body_copy
docu = []
analyzed = namedtuple('Analyzed', 'words tags')
for (i, f) in enumerate(doc2):
wor = f.split()
tags = [i]
docu.append(analyzed(wor, tags))
model = doc2vec.Doc2Vec(docu, size=100, window=300, min_count=1, worke... |
class ElectronicSpatialExtent(OutputModel):
def __init__(self, hidden_channels, activation='silu'):
super(ElectronicSpatialExtent, self).__init__(allow_prior_model=False)
act_class = act_class_mapping[activation]
self.output_network = nn.Sequential(nn.Linear(hidden_channels, (hidden_channels... |
class Discriminator(nn.Module):
def __init__(self, ngpu, nc=3, ndf=160, ngf=160, nz=100):
super(Discriminator, self).__init__()
self.ngpu = ngpu
self.main = nn.Sequential(nn.Conv2d(nc, ndf, 4, 4, 6, bias=False), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(ndf, (ndf * 2), 4, 3, 3, bias=False),... |
def CHECKNAN(tensor, name):
if torch.isnan(tensor.max()):
logging.error(('NaN found in tensor: %s' % name))
if torch.isinf(tensor.min()):
logging.error(('Inf found in tensor: %s' % name)) |
def find_forward_params(x_input: torch.tensor, y_ouput: torch.tensor, random_flow_fn: typing.Callable=None, num_restarts: int=1, optimizer_fn=None, num_epochs=None, seed=0, verbose=0, verbose_level=0) -> Flow:
if (random_flow_fn is None):
raise RuntimeError('random_flow_fn must be specified')
if (optimi... |
class FlaxTimesteps(nn.Module):
dim: int = 32
flip_sin_to_cos: bool = False
freq_shift: float = 1
def __call__(self, timesteps):
return get_sinusoidal_embeddings(timesteps, embedding_dim=self.dim, flip_sin_to_cos=self.flip_sin_to_cos, freq_shift=self.freq_shift) |
class TestAddEmbeddings(unittest.TestCase):
def setUpClass(self):
pass
def tearDownClass(self):
pass
def test_add_embeddings_with_seq_len_first(self):
graph = Graph()
graph.framework_modeling_config['framework'] = 'onnxruntime'
input_data_node = OPERATORS['Input']()
... |
class ActorVae(nn.Module):
def __init__(self, ablation, nfeats: int, latent_dim: list=[1, 256], ff_size: int=1024, num_layers: int=9, num_heads: int=4, dropout: float=0.1, is_vae: bool=True, activation: str='gelu', position_embedding: str='learned', **kwargs) -> None:
super().__init__()
self.latent_... |
class DEnKF(nn.Module):
def __init__(self, num_ensemble, dim_x, dim_z):
super(DEnKF, self).__init__()
self.num_ensemble = num_ensemble
self.dim_x = dim_x
self.dim_z = dim_z
self.r_diag = (np.ones(self.dim_z).astype(np.float32) * 0.1)
self.r_diag = self.r_diag.astype(n... |
class ResidualBlock(nn.Module):
def __init__(self, dim_in, dim_out):
super(ResidualBlock, self).__init__()
self.main = nn.Sequential(nn.Conv2d(dim_in, dim_out, kernel_size=3, stride=1, padding=1), nn.InstanceNorm2d(dim_out, affine=False), nn.ReLU(inplace=True), nn.Conv2d(dim_out, dim_out, kernel_siz... |
def simxSetVisionSensorImage(clientID, sensorHandle, image, options, operationMode):
size = len(image)
image_bytes = (ct.c_byte * size)(*image)
return c_SetVisionSensorImage(clientID, sensorHandle, image_bytes, size, options, operationMode) |
def eval_one_epoch(model, eval_loader, epoch, tb_log, log_f, loss_func, class_func):
model.eval()
log_print(('EVAL EPOCH %d' % epoch), log_f=log_f)
batch_time = AverageMeter()
losses = AverageMeter()
acc = AverageMeter()
iou = AverageMeter()
with torch.no_grad():
end = time.time()
... |
def get_memory_info():
with open('/proc/meminfo', 'r') as mem:
ret = {}
tmp = 0
for i in mem:
sline = i.split()
if (str(sline[0]) == 'MemTotal:'):
ret['total'] = int(sline[1])
elif (str(sline[0]) in ('MemFree:', 'Buffers:', 'Cached:')):
... |
def _get_metadata(vc):
fps = vc.get(cv2.CAP_PROP_FPS)
width = int(vc.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(vc.get(cv2.CAP_PROP_FRAME_HEIGHT))
num_frames = int(vc.get(cv2.CAP_PROP_FRAME_COUNT))
return VideoMetadata(fps, num_frames, width, height) |
def zero_grad(model):
for p in model.parameters():
if (p.requires_grad and (p.grad is not None)):
p.grad = None |
def require_safetensors(test_case):
return unittest.skipUnless(is_safetensors_available(), 'test requires safetensors')(test_case) |
def has_pool_type(m):
if is_pool_type(m):
return True
for l in m.children():
if has_pool_type(l):
return True
return False |
def ensure_file_exists(filename):
if (not os.path.exists(filename)):
(head, tail) = os.path.split(filename)
ensure_dir_exists(head)
with open(filename, 'w') as f:
pass |
def inference(model, data_loader, dataset_name, mem_active=False, output_folder=None):
device = torch.device('cuda')
num_devices = get_world_size()
logger = logging.getLogger('hit.inference')
dataset = data_loader.dataset
logger.info('Start evaluation on {} dataset({} videos).'.format(dataset_name, ... |
def GetHome():
go_to_js = GetPlanToJointStateService()
req = GetHomeRequest()
print(('req home: ' + str(req)))
open_gripper = GetOpenGripperService()
move = GetPlanToPoseService()
servo_mode = GetServoModeService()
def home():
rospy.loginfo('HOME: set servo mode')
servo_mode(... |
def vis_gt(src_dir, out_dir, anno_list):
if os.path.exists(out_dir):
shutil.rmtree(out_dir)
os.mkdir(out_dir)
for anno_file in anno_list:
annos = []
with open(os.path.join(src_dir, anno_file), 'r', encoding='utf-8') as f:
for line_ in f.readlines():
if (li... |
class HierarchicalHealpixMap(DustMap3D):
def __init__(self, filter=None, sf10=True):
DustMap3D.__init__(self, filter=filter)
self._sf10 = sf10
return None
def _evaluate(self, ls, bs, ds):
ls = numpy.atleast_1d(ls)
bs = numpy.atleast_1d(bs)
ds = numpy.atleast_1d(ds... |
class BlockDataset(Dataset):
def __init__(self, data, block_size):
self.data = data
self.block_size = block_size
def __len__(self):
return (len(self.data) - self.block_size)
def __getitem__(self, idx):
x = torch.from_numpy(self.data[idx:(idx + self.block_size)].astype(np.int6... |
class EnvBatch():
def __init__(self, feature_store=None, batch_size=100):
self.features_aug = None
if feature_store:
if (type(feature_store) is dict):
self.features = feature_store
self.image_w = 640
self.image_h = 480
self.... |
def set_grad(params, params_with_grad, scale=1.0):
for (param, param_w_grad) in zip(params, params_with_grad):
if (param.grad is None):
param.grad = torch.nn.Parameter(param.data.new().resize_(*param.data.size()))
grad = param_w_grad.grad.data
if (scale is not None):
... |
class EmbeddingNormalization():
def __init__(self, norm: Union[(float, torch.Tensor)]=1):
self.norm = norm
if (isinstance(self.norm, torch.Tensor) and (self.norm.ndim == 2)):
self.norm = self.norm.unsqueeze(0)
def __call__(self, embeddings: torch.Tensor) -> torch.Tensor:
with... |
class PAWS(AbstractTask):
name = 'paws'
labels_list = ['No', 'Yes']
metric = [metrics.accuracy]
metric_names = ['accuracy']
split_to_data_split = {'train': 'train', 'validation': 'validation', 'test': 'test'}
def load_dataset(self, split: int):
return datasets.load_dataset('paws', 'label... |
def test_list_space():
space = ListSpace(gym.spaces.Discrete(2), 5, 10)
assert space.contains(space.sample())
assert (not space.contains(0))
assert (not space.contains(([0] * 4)))
assert (not space.contains(([2] * 5)))
assert (not space.contains(([1] * 11))) |
def run(args):
output_dir = os.path.split(args.output_path)[0]
if (not os.path.exists(output_dir)):
os.makedirs(output_dir)
with open(args.dcalphas_path, 'rb') as fin:
dcalphas = pickle.load(fin)
with open(args.angles_path, 'rb') as fin:
angles = pickle.load(fin)
coords = Non... |
('/timeseries/<state>/<metric>')
def get_timeseries(state, metric):
if (state not in STATE_WHITELIST):
abort(400, f"Bad state name. Must be one of: {', '.join(STATE_WHITELIST)}")
if (metric not in METRIC_WHITELIST):
abort(400, f"Bad metric name. Must be one of: {', '.join(METRIC_WHITELIST)}")
... |
def _has_arg(fn, arg_name):
while isinstance(fn, functools.partial):
fn = fn.func
while hasattr(fn, '__wrapped__'):
fn = fn.__wrapped__
arg_spec = inspect.getfullargspec(fn)
if arg_spec.varkw:
return True
return ((arg_name in arg_spec.args) or (arg_name in arg_spec.kwonlyargs... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.