code stringlengths 101 5.91M |
|---|
def se_resnext50_32x4d(pretrained: bool=False):
return get_model('se_resnext50_32x4d', pretrained) |
def _build_eval_and_test_data_mode_from_folder(wide_from_folder, tab_from_folder, eval_fname, test_fname):
eval_wide_from_folder = TabFromFolder(fname=eval_fname, reference=wide_from_folder)
eval_tab_from_folder = TabFromFolder(fname=eval_fname, reference=tab_from_folder)
test_wide_from_folder = TabFromFold... |
def test_trajectory():
t0 = process_time()
t = Trajectory(ts, [x0_p1, x0_p2, x0_p3])
t1 = process_time()
print((t1 - t0))
assert (t.XT == VehicleState) |
class DCGAN(nn.Module):
def __init__(self, num_channels=3, ngf=100):
super(DCGAN, self).__init__()
self.generator = nn.Sequential(nn.Conv2d(num_channels, ngf, 3, 1, 1, bias=False), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(ngf, ngf, 3, 1, 1, bias=False), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(n... |
def evaluate_squad(model, dataloader, input_ids, eval_examples, extra_data, input_file):
session = onnxruntime.InferenceSession(model.SerializeToString(), None, providers=onnxruntime.get_available_providers())
for output_meta in session.get_outputs():
print(output_meta)
for input_meta in session.get... |
class Bottleneck(nn.Module):
expansion = 4
def __init__(self, inplanes, planes, stride=1, downsample=None, attention='0', att_dim=128):
super(Bottleneck, self).__init__()
self.dimDR = att_dim
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = nn.BatchN... |
def _create_datafile(cls, setname):
modeldir = os.path.join(path['data'], class2uid[cls], 'obj_models')
setfile = os.path.join(modeldir, (setname + '.list'))
vxls = []
with open(setfile, 'r') as fp:
for line in fp:
muid = line[:(- 1)]
muid = muid.split('.')[0]
... |
class TestSelfDistillation(unittest.TestCase):
model = torchvision.models.resnet50()
def setUpClass(cls):
build_fake_yaml()
def tearDownClass(cls):
os.remove('fake.yaml')
shutil.rmtree('./saved', ignore_errors=True)
shutil.rmtree('runs', ignore_errors=True)
def test_self_... |
def eval_epoch_bleu(model, validation_data, device, vocab, list_of_refs_dev, args):
model.eval()
total_loss = 0
n_word_total = 0
n_word_correct = 0
hypotheses = {}
count = 0
with torch.no_grad():
for batch in tqdm(validation_data, mininterval=2, desc=' - (Validation) ', leave=False)... |
def post_processing_function(examples, features, predictions, stage='eval'):
predictions = postprocess_qa_predictions(examples=examples, features=features, predictions=predictions, version_2_with_negative=data_args.version_2_with_negative, n_best_size=data_args.n_best_size, max_answer_length=data_args.max_answer_le... |
def sample_data(dump_paths, para=False, doc_sample_ratio=0.2, vec_sample_ratio=0.2, seed=29, max_norm=None, max_norm_cf=1.3, num_dummy_zeros=0, norm_th=999):
vecs = []
random.seed(seed)
np.random.seed(seed)
print('sampling from:')
for dump_path in dump_paths:
print(dump_path)
dumps = [h5... |
class TorchModel(Model):
def __init__(self) -> None:
super().__init__()
self.torch_model: SymbolNet = None
self.sat_inputs = None
def version(self) -> str:
return torch.__version__
def from_gir(cls: Type['TorchModel'], ir: GraphIR, **kwargs) -> 'TorchModel':
ret = cls... |
class CVAE():
def __init__(self, vocab_size, args):
self.vocab_size = vocab_size
self.batch_size = args.batch_size
self.lr = tf.Variable(args.lr, trainable=False)
self.unit_size = args.unit_size
self.n_rnn_layer = args.n_rnn_layer
self._create_network()
def _creat... |
class EllipSegNet(torch.nn.Module):
def __init__(self, init_f, num_outputs):
super(EllipSegNet, self).__init__()
self.pool = torch.nn.MaxPool2d(kernel_size=2, stride=2)
self.upsample = torch.nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
self.inc = DoubleConv(1, ini... |
_torch
class CLIPVisionBertModelTest(VisionTextDualEncoderMixin, unittest.TestCase):
def get_pretrained_model_and_inputs(self):
model = VisionTextDualEncoderModel.from_vision_text_pretrained('hf-internal-testing/tiny-random-clip', 'hf-internal-testing/tiny-bert')
batch_size = 13
pixel_values... |
def change_data_type(df):
df['x_scaled'] = df['x_scaled'].apply((lambda x: np.array(x, dtype=np.float32)))
df['target'] = df['target'].apply((lambda x: int(x)))
return df |
class EmptyStringException(Exception):
def __init__(self, message):
self.message = message
def __str__(self):
return self.message |
def augmentor_rwr(input_file, output_file, restart_prob=0.2, gamma=2):
with open(input_file, 'r') as f, open(output_file, 'w') as save_f:
for line in f:
g = nx.Graph()
user_dict = dict()
paths = line.strip().split('\t')
paths = paths[:(- 1)]
observ... |
def partition_data(datadir, partition, n_nets, alpha, logger):
logger.info('partition data')
(X_train, y_train, X_test, y_test) = load_cifar10_data(datadir)
n_train = X_train.shape[0]
if (partition == 'n_cls'):
n_client = n_nets
n_cls = 10
n_data_per_clnt = (len(y_train) / n_clie... |
def convert_longformer_qa_checkpoint_to_pytorch(longformer_model: str, longformer_question_answering_ckpt_path: str, pytorch_dump_folder_path: str):
longformer = LongformerModel.from_pretrained(longformer_model)
lightning_model = LightningModel(longformer)
ckpt = torch.load(longformer_question_answering_ckp... |
def get_config():
parser = argparse.ArgumentParser()
parser.add_argument('--project-dir', type=str, default='output')
parser.add_argument('--dataset-dir', type=str, default='output')
parser.add_argument('--lr', type=float, default=0.1)
parser.add_argument('--data-seed', type=int, default=0)
pars... |
class Joiner(nn.Sequential):
def __init__(self, backbone, position_embedding):
super().__init__(backbone, position_embedding)
def forward(self, tensor_list: NestedTensor, Raw_point: NestedTensor):
(xs, point_fea, img_fea) = self[0](tensor_list, Emb_x=Raw_point)
out: List[NestedTensor] = ... |
def get_edge_labels():
labels = {}
for ang in range(8):
k = str(ang)
labels[k] = len(labels)
return labels |
class AlignConfig(PretrainedConfig):
model_type = 'align'
is_composition = True
def __init__(self, text_config=None, vision_config=None, projection_dim=640, temperature_init_value=1.0, initializer_range=0.02, **kwargs):
super().__init__(**kwargs)
if (text_config is None):
text_co... |
class QuantizedLinear(Linear):
def forward(self, x):
return super().forward(self.input_quant(x)).dequantize() |
def test_nbr(g1):
assert (g1.nbr_v(0) == [1, 2])
assert (g1.nbr_v(1) == [0])
assert (g1.nbr_v(2) == [0])
assert (g1.nbr_v(3) == [])
g1.add_edges((3, 0))
assert (g1.nbr_v(0) == [1, 2, 3])
g1.remove_edges((0, 2))
assert (g1.nbr_v(2) == [])
g3 = Graph(5, [(0, 1), (0, 3), (1, 4), (2, 3)]... |
def get_poses(nusc: NuScenes, scene_token: str) -> List[dict]:
pose_list = []
scene_rec = nusc.get('scene', scene_token)
sample_rec = nusc.get('sample', scene_rec['first_sample_token'])
sd_rec = nusc.get('sample_data', sample_rec['data']['LIDAR_TOP'])
ego_pose = nusc.get('ego_pose', sd_rec['token'])... |
class ADE20KDataset(Pix2pixDataset):
def modify_commandline_options(parser, is_train):
parser = Pix2pixDataset.modify_commandline_options(parser, is_train)
parser.set_defaults(preprocess_mode='resize_and_crop')
if is_train:
parser.set_defaults(load_size=286)
else:
... |
class memoized(object):
def __init__(self, func):
self.func = func
self.cache = {}
def __call__(self, *args, **kwargs):
kwlist = tuple(sorted(list(kwargs), key=operator.itemgetter(0)))
if ((not isinstance(args, collections.Hashable)) or (not isinstance(kwlist, collections.Hashabl... |
def assert_group(tensor, group_name, same=True):
tensor_list = [torch.empty_like(tensor) for _ in range(parallel_group_size(group_name))]
tensor_list[parallel_rank(group_name)] = tensor
dist.all_gather(tensor_list, tensor, group=parallel_group(group_name))
for tensor in tensor_list[1:]:
all_same... |
class TFXLNetLMHeadModel(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
class SqueezeExcite(nn.Module):
def __init__(self, in_chs, se_ratio=0.25, reduced_base_chs=None, act_layer=nn.ReLU, gate_fn=sigmoid, divisor=1):
super(SqueezeExcite, self).__init__()
reduced_chs = make_divisible(((reduced_base_chs or in_chs) * se_ratio), divisor)
self.conv_reduce = nn.Conv2d... |
def args_parse():
parser = argparse.ArgumentParser(description='Atari: DDQN')
parser.add_argument('--env', default='BreakoutNoFrameskip-v4', help='Should be NoFrameskip environment')
parser.add_argument('--train', action='store_true', help='Train agent with given environment')
parser.add_argument('--pla... |
class LayoutLMv2ImageProcessor(metaclass=DummyObject):
_backends = ['vision']
def __init__(self, *args, **kwargs):
requires_backends(self, ['vision']) |
class Lwf(ContinualLearner):
def __init__(self, model, opt, params):
super(Lwf, self).__init__(model, opt, params)
def train_learner(self, x_train, y_train):
self.before_train(x_train, y_train)
train_dataset = dataset_transform(x_train, y_train, transform=transforms_match[self.data])
... |
def handle(signum, frame):
proc_pool.terminate()
print_test_suite_result()
print_results()
exit(1) |
class MLP(PyTorchClassifier):
def __init__(self, params, inputdim, nclasses, l2reg=0.0, batch_size=64, seed=1111, cudaEfficient=False):
super(self.__class__, self).__init__(inputdim, nclasses, l2reg, batch_size, seed, cudaEfficient)
self.nhid = (0 if ('nhid' not in params) else params['nhid'])
... |
def load_image(img_path, image_size):
image = cv2.imread(img_path)
image = cv2.resize(image, (image_size, image_size))
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image = image.astype(np.float32)
image = (((image / 255) * 2) - 1)
image = np.transpose(image, (2, 0, 1))
return image |
class OptimizerHook(Hook):
def __init__(self, grad_clip=None):
self.grad_clip = grad_clip
def clip_grads(self, params):
clip_grad.clip_grad_norm_(filter((lambda p: p.requires_grad), params), **self.grad_clip)
def after_train_iter(self, runner):
runner.optimizer.zero_grad()
ru... |
class ModelArguments():
model_name_or_path: str = field(metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'})
config_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained config name or path if not the same as model_name'})
tokenizer_name: Optional[s... |
def pooler(inputs, pool_type, axis=1, **kwargs):
if (pool_type == 'mean'):
return mean_pool(inputs, kwargs['sequence_length'], axis)
elif (pool_type == 'max'):
return max_pool(inputs, axis)
elif (pool_type == 'sum'):
return sum_pool(inputs, axis) |
def module_checkpoint_iter(prefix, iteration_list='10000,20000'):
def _callback(epoch_no, iter_no, sym=None, arg=None, aux=None):
import numpy as np
iters_list = np.array([int(i) for i in iteration_list.split(',')])
if (sum(((iter_no + 1) == iters_list)) == 1):
mx.model.save_chec... |
def build_yaml():
fake_yaml = '\n device: gpu\n model:\n name: test\n framework: onnxrt_qlinearops\n\n mixed_precision:\n precisions: fp16\n\n evaluation:\n accuracy:\n metric:\n MSE:\n compare_label: False\n ... |
def generate_2D_generalized_gaussian(rows, columns, alpha=2):
m = rows
n = columns
r = ((0.5 * np.random.random((m * n))) + 0.5)
beta = np.sqrt((special.gamma((3.0 / alpha)) / special.gamma((1.0 / alpha))))
y = (r / beta)
ymin = (1e-20 * np.ones((m * n)))
ymax = (1000 * np.ones((m * n)))
... |
def smoke_test_explanations(global_exp, local_exp, port):
from interpret import preserve, show, shutdown_show_server, set_show_addr
set_show_addr(('127.0.0.1', port))
preserve(global_exp)
preserve(local_exp)
show(global_exp)
show(local_exp)
for selector_key in global_exp.selector[global_exp.... |
def quaddobl_decomposition(deg):
from phcpy.phcpy2c3 import py2c_factor_number_of_quaddobl_components
from phcpy.phcpy2c3 import py2c_factor_witness_points_of_quaddobl_component
from phcpy.phcpy2c3 import py2c_factor_quaddobl_trace_sum_difference as qtf
nbcmp = py2c_factor_number_of_quaddobl_components(... |
def encode_string(text):
return text.replace('\r', '\\r').replace('\n', '\\n').replace('\t', '\\t') |
class SequenceFeatureExtractor(FeatureExtractionMixin):
def __init__(self, feature_size: int, sampling_rate: int, padding_value: float, **kwargs):
self.feature_size = feature_size
self.sampling_rate = sampling_rate
self.padding_value = padding_value
self.padding_side = kwargs.pop('pa... |
class AdaBound(Optimizer):
def __init__(self, params, lr=0.001, betas=(0.9, 0.999), final_lr=0.1, gamma=0.001, eps=1e-08, weight_decay=0, amsbound=False):
if (not (0.0 <= lr)):
raise ValueError('Invalid learning rate: {}'.format(lr))
if (not (0.0 <= eps)):
raise ValueError('I... |
def build_fake_yaml():
fake_yaml = '\n model:\n name: fake_yaml\n framework: tensorflow\n inputs: x\n outputs: op_to_store\n device: cpu\n evaluation:\n accuracy:\n metric:\n topk: 1\n tuning:\n strategy:\n ... |
def feedforward_model(input_shapes, output_size, hidden_layer_sizes, activation='relu', output_activation='linear', preprocessors=None, name='feedforward_model', *args, **kwargs):
inputs = [tf.keras.layers.Input(shape=input_shape) for input_shape in input_shapes]
if (preprocessors is None):
preprocessor... |
def test_global_var():
run_cell('x = 0')
run_cell('y = x + 1')
run_cell('def f(): global x; x = 42')
run_cell('logging.info(y)')
assert_not_detected()
run_cell('f()')
run_cell('logging.info(y)')
assert_detected() |
def right(continuous_pulse: Callable) -> Callable:
return sampler(strategies.right_sample)(continuous_pulse) |
def load_mod(model_file):
model = tf.keras.models.load_model(model_file)
print('Load from {}'.format(model_file))
return model |
def zeros_like(*args, torch_device=None, **kwargs):
if (torch_device is None):
torch_device = device
return torch.zeros_like(*args, **kwargs, device=torch_device) |
def batch_render(buffers_path, target_path, args):
subdirs = ['render', 'albedo', 'normal', 'target']
subdirs_paths = [os.path.join(args.output_dir, s) for s in subdirs]
if (not os.path.isdir(args.output_dir)):
os.mkdir(args.output_dir)
[os.mkdir(s) for s in subdirs_paths]
buffers_ext = ... |
def calculate(O21, O22, l_buff, p_buff, duration):
if (len(l_buff) and len(p_buff)):
if (p_buff[0] == 0):
initial_buffering_length = l_buff[0]
else:
initial_buffering_length = 0
else:
initial_buffering_length = 0
rebuf_stats = get_rebuf_stats(l_buff, p_buff, d... |
def dnbins(nbins, dlogq):
if (dlogq < 0):
return 1
n = int(np.floor((dlogq * nbins)))
return (n if (n > 0) else 1) |
def binary_focal_loss(gt, pr, gamma=2.0, alpha=0.25, **kwargs):
backend = kwargs['backend']
pr = backend.clip(pr, backend.epsilon(), (1.0 - backend.epsilon()))
loss_1 = ((- gt) * ((alpha * backend.pow((1 - pr), gamma)) * backend.log(pr)))
loss_0 = ((- (1 - gt)) * (((1 - alpha) * backend.pow(pr, gamma)) ... |
class OrthogonalFusion(layers.Layer):
def __init__(self, **kwargs):
super().__init__(name='OrthogonalFusion', **kwargs)
def call(self, inputs):
(local_feat, global_feat) = inputs
height = local_feat.shape[1]
width = local_feat.shape[2]
depth = local_feat.shape[3]
... |
def text_to_conll(f):
global options
if options.nosplit:
sentences = f.readlines()
else:
sentences = []
for l in f:
l = sentencebreaks_to_newlines(l)
sentences.extend([s for s in NEWLINE_TERM_REGEX.split(l) if s])
lines = []
offset = 0
fixed_senten... |
class EvalHook(HookBase):
def __init__(self, eval_period, eval_function, eval_after_train=True):
self._period = eval_period
self._func = eval_function
self._eval_after_train = eval_after_train
def _do_eval(self):
results = self._func()
if results:
assert isins... |
def three_comp_average(comp1, comp2, comp3):
return np.sqrt((((comp1 ** 2) + (comp2 ** 2)) + (comp3 ** 2))) |
def subset_reencode_features(x_unvec, feat_encoding_dict):
return [[feat_encoding_dict[feat_idx] for feat_idx in x if (feat_idx in feat_encoding_dict)] for x in x_unvec] |
def find_output_tensors_info(subgraphs, tensor_names):
tensors_info = {}
all_tensor_names = []
all_tensor_shapes = []
all_data_formats = []
all_data_types = []
all_check_tensor_names = []
all_check_tensor_shapes = []
for (subname, subgraph) in subgraphs.items():
all_tensor_names.... |
def test_test_naive_weighted_average_with_stats():
x = torch.randint(low=0, high=256, dtype=torch.uint8, size=(8, 12, 495, 436, 8))
additional_data = torch.cat((torch.randint(low=0, high=7, dtype=torch.uint8, size=(8, 1)), torch.randint(low=0, high=MAX_TEST_SLOT_INDEX, dtype=torch.uint8, size=(8, 1))), axis=1)
... |
def run():
parser = argparse.ArgumentParser()
parser.add_argument('--data_root', type=str, default='../../Dataset/Pairs_street_view/paris_auged')
parser.add_argument('--mask_root', type=str, default='../../Dataset/irregular_mask/testing_mask_dataset_auged')
parser.add_argument('--model_save_path', type=... |
def evaluate(model, data, indices):
start_time = time.time()
eval_loss = 0.0
eval_num_words = 0
model.eval()
with torch.no_grad():
batch = [dh.make_batch(data, indices[0])]
for j in six.moves.range(len(indices)):
(x_batch, h_batch, q_batch, a_batch_in, a_batch_out, s_batc... |
def save_videos(videos_tensor, nrow, path):
(b, c, t, h, w) = videos_tensor.shape
imgs_tensor = videos_tensor.permute(0, 2, 1, 3, 4).reshape((b * t), c, h, w)
imgs = make_grid(imgs_tensor, nrow=nrow, normalize=True)
img = F.to_pil_image(imgs.detach())
show_img = Image.fromarray(np.array(img))
sh... |
def main():
import pdb
pdb.set_trace()
moses_detok = MosesDetokenizer(lang='en')
for line in sys.stdin:
decoded_line = decode(line.strip(), moses_detok)
sys.stdout.write((decoded_line + '\n'))
sys.stdout.flush() |
class OptimizedInstructor(InstructorEmbedding.INSTRUCTOR):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def _load_auto_model(self, model_name_or_path, token: Optional[Union[(bool, str)]], cache_folder: Optional[str]):
logger.warning('No sentence-transformers model found... |
def iterate_sys_modules():
items = list(sys.modules.items())
for (modname, mod) in items:
if ((modname not in MODULE_BLACKLIST) and (mod is not None)):
(yield (modname, mod)) |
def build_causal_conv1d_block(block_arch):
idim = block_arch['idim']
odim = block_arch['odim']
kernel_size = block_arch['kernel_size']
return (lambda : CausalConv1d(idim, odim, kernel_size)) |
class ResidualConv(nn.Module):
def __init__(self, in_channels, out_channels, stride, dropout=None):
super().__init__()
self.conv1 = Conv2D(in_channels, out_channels, 3, stride)
self.conv2 = Conv2D(out_channels, out_channels, 3, 1)
self.conv3 = nn.Conv2d(in_channels, out_channels, ker... |
class GaussianPolicy(nn.Module):
def __init__(self, num_inputs, num_actions, hidden_dim, args):
super(GaussianPolicy, self).__init__()
self.linear1 = nn.Linear(num_inputs, hidden_dim)
self.linear2 = nn.Linear(hidden_dim, hidden_dim)
self.mean_linear = nn.Linear(hidden_dim, num_action... |
def is_pt_tf_cross_test(test_case):
if ((not _run_pt_tf_cross_tests) or (not is_torch_available()) or (not is_tf_available())):
return unittest.skip('test is PT+TF test')(test_case)
else:
try:
import pytest
except ImportError:
return test_case
else:
... |
def test_planar_hull(nbr=7, size=9):
pts = random_points(2, nbr, (- size), size)
print('the points :', pts)
(vertices, normals) = planar_convex_hull(pts)
print('the vertices :', vertices)
print('inner normals :', normals) |
def keypoint_mpjpe(pred, gt, mask):
assert mask.any()
pred_aligned = np.stack((compute_similarity_transform(pred_i, gt_i) for (pred_i, gt_i) in zip(pred, gt)))
mpjpe = np.linalg.norm((pred - gt), ord=2, axis=(- 1))[mask].mean()
p_mpjpe = np.linalg.norm((pred_aligned - gt), ord=2, axis=(- 1))[mask].mean(... |
def _loader_switch_cls(cls):
class Loader(cls):
def __init__(self, *args, image_size=None, **kwargs):
raise NotImplementedError()
def __new__(_cls, *args, **kwargs):
return cls(*args, **kwargs, image_size=128)
return Loader |
def get_labevents_extractors(data_dir, extractor_map):
extractors = []
table = 'labevents'
id_extractor = MultiExtractor(names=['subject_id', 'hadm_id'], sep='_')
outpath = os.path.join(data_dir, (table + '.tsv'))
time_ext = TimeExtractor(name='charttime', converter=time2str)
type_ext = FmtExtra... |
def cross_entropy(z, zt):
Pz = F.softmax(z, dim=1)
Pzt = F.softmax(zt, dim=1)
return (- (Pz * torch.log(Pzt)).mean()) |
()
('yaml_path')
('--just-cache-data', default=0, help='If 1, just writes data to cache; does not run experiment')
('--do_test', default=0, help='If 1, evaluates on the test set; hopefully just run this once!')
def run_yaml_experiment(yaml_path, just_cache_data, do_test):
yaml_args = yaml.load(open(yaml_path), Load... |
def get_article(article_id):
xml_str = 'PMC{}.nxml'.format(article_id)
xml_path = os.path.join(base_XML_path, xml_str)
return article_reader.Article(xml_path, use_plain_text=USE_PLAIN_TEXT) |
def load_values(save_dir, valid=False):
outputs = []
outputs.append(list(np.load((save_dir + '/plots/track_d_loss_iter.npy'))))
outputs.append(list(np.load((save_dir + '/plots/track_d_loss.npy'))))
outputs.append(list(np.load((save_dir + '/plots/epochs.npy'))))
outputs.append(outputs[0][(- 1)])
... |
_class
class Conv2dLayer(torch.nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, bias=True, activation='linear', up=1, down=1, resample_filter=[1, 3, 3, 1], conv_clamp=None, channels_last=False, trainable=True):
super().__init__()
self.activation = activation
self.up = u... |
class ComparableItemSet():
def issuperset(self, other):
return (self.frozenset >= other.frozenset)
def issubset(self, other):
return (self.frozenset <= other.frozenset)
def __ge__(self, other):
return self.issuperset(other)
def __le__(self, other):
return self.issubset(ot... |
class DensePoseCOCOEvaluator(DatasetEvaluator):
def __init__(self, dataset_name, distributed, output_dir=None):
self._distributed = distributed
self._output_dir = output_dir
self._cpu_device = torch.device('cpu')
self._logger = logging.getLogger(__name__)
self._metadata = Met... |
def print_dataset_stats(dataset):
print('=== {} ==='.format(dataset))
class_file = os.path.join('data', dataset, 'class.txt')
if (not os.path.isfile(class_file)):
print('Dataset not found!')
return
print('Categories:', len(load_text(class_file)))
src_videos = {}
total_frames = 0
... |
class VOCSegmentation(Dataset):
NUM_CLASSES = 21
def __init__(self, args, base_dir=Path.db_root_dir('pascal'), split='train'):
super().__init__()
self._base_dir = base_dir
self._image_dir = os.path.join(self._base_dir, 'JPEGImages')
self._cat_dir = os.path.join(self._base_dir, 'S... |
def add_vtarg_and_adv(seg, gamma, lam):
new = np.append(seg['new'], 0)
vpred = np.append(seg['vpred'], seg['nextvpred'])
T = len(seg['rew'])
seg['adv'] = gaelam = np.empty(T, 'float32')
rew = seg['rew']
lastgaelam = 0
for t in reversed(range(T)):
nonterminal = (1 - new[(t + 1)])
... |
def __linear_circuit_block(x_block, y_block, encoder):
from .binary import BinarySharedTensor
from crypten.cuda import CUDALongTensor
ci = torch_stack([torch.zeros_like(x_block), torch.ones_like(y_block)])
for i in range(8):
xi = ((x_block >> i) & 1)
yi = ((y_block >> i) & 1)
(xi... |
def activation_helper(activation, dim=None):
if (activation == 'sigmoid'):
act = nn.Sigmoid()
elif (activation == 'tanh'):
act = nn.Tanh()
elif (activation == 'relu'):
act = nn.ReLU()
elif (activation == 'leakyrelu'):
act = nn.LeakyReLU()
elif (activation is None):
... |
def run(coco, cat_ids, output_dir, num_examples):
object_scales = {1: 0.3, 2: 0.3, 3: 0.2, 4: 0.2, 5: 0.7, 6: 0.2, 7: 0.2, 8: 0.3, 9: 0.3, 10: 0.2}
cats = {cat['id']: cat for cat in coco.dataset['categories']}
for cat_id in cat_ids:
cat_name = cats[cat_id]['name']
print('generating {} poses ... |
def test_save(g1, tmp_path):
from dhg import load_structure
g1.save((tmp_path / 'g1'))
g2 = load_structure((tmp_path / 'g1'))
for (e1, e2) in zip(g1.e[0], g2.e[0]):
assert (e1 == e2)
for (w1, w2) in zip(g1.e[1], g2.e[1]):
assert (w1 == w2) |
def get_all_images_pool(image_names, path_voc):
images = []
for j in range(np.size(image_names)):
image_name = image_names[j]
string = (((path_voc + '/JPEGImages/') + image_name) + '.jpg')
images.append(image.load_img(string, False))
return images |
def main(opts):
hvd.init()
n_gpu = hvd.size()
device = torch.device('cuda', hvd.local_rank())
torch.cuda.set_device(hvd.local_rank())
rank = hvd.rank()
opts.rank = rank
LOGGER.info(f'device: {device}, n_gpu: {n_gpu}, rank: {hvd.rank()}, 16-bits training: {opts.fp16}')
if (opts.gradient_a... |
def ssast_patch_base_10s(ckpt, *args, **kwargs):
kwargs['model_size'] = 'base_p'
kwargs['pretrain_path'] = '/data/sls/scratch/yuangong/ssast/pretrained_model/SSAST-Base-Patch-400.pth'
kwargs['target_length'] = 1000
return _UpstreamExpert(ckpt, *args, **kwargs) |
class TestPytorchPruning(unittest.TestCase):
model = torchvision.models.resnet18()
def test_pruning_class_config(self):
local_configs = [{'op_names': ['layer1.*', 'layer2.*'], 'excluded_op_names': ['downsample.*'], 'target_sparsity': 0.6, 'pattern': 'channelx1', 'pruning_type': 'snip_progressive', 'prun... |
def main():
args = getArgs()
rospy.init_node('parse_task_model')
if (args.bagfile is not None):
rtp = RosTaskParser(filename=args.bagfile, configs=[TOM_RIGHT_CONFIG, TOM_LEFT_CONFIG], unknown_apply_before=4, min_action_length=1, demo_topic=args.demo_topic, alias_topic=args.alias_topic)
rtp.a... |
def plot_preds_of_code_id(code_id):
plt.figure()
cnx = ut.create_connection()
codes = pd.read_sql('SELECT code_token FROM functional_unit_augmentation WHERE code_id={}'.format(code_id), cnx)
t = [graph(get_data_item(codes.iloc[i].code_token)).item() for i in range(len(codes))]
plt.title('PREDICTION:... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.