code stringlengths 101 5.91M |
|---|
class PoolFormerImageProcessor(BaseImageProcessor):
model_input_names = ['pixel_values']
def __init__(self, do_resize: bool=True, size: Dict[(str, int)]=None, crop_pct: int=0.9, resample: PILImageResampling=PILImageResampling.BICUBIC, do_center_crop: bool=True, crop_size: Dict[(str, int)]=None, rescale_factor: ... |
def main():
parser = argparse.ArgumentParser(description='Run the tracker on your webcam.')
parser.add_argument('tracker_name', type=str, help='Name of tracking method.')
parser.add_argument('tracker_param', type=str, help='Name of parameter file.')
parser.add_argument('--debug', type=int, default=0, he... |
def parse_benchmark_only_line(line):
perf_data = {}
perf_data.update(({'throughput': float(throughput)} if (throughput := parse_benchmark_log('benchmark_only', line)) else {}))
perf_data.update(({'batch_size': int(batch_size)} if (batch_size := parse_benchmark_log('batch_size', line)) else {}))
return p... |
def gtp_io():
known_commands = ['boardsize', 'clear_board', 'komi', 'play', 'genmove', 'final_score', 'quit', 'name', 'version', 'known_command', 'list_commands', 'protocol_version', 'gogui-analyze_commands']
analyze_commands = ['gfx/Predict Final Ownership/predict_ownership', 'none/Load New SGF/loadsgf']
s... |
def constant_pad_nd(g, input, padding, value=None):
mode = 'constant'
value = sym_help._maybe_get_scalar(value)
value = sym_help._if_scalar_type_as(g, value, input)
pad = _prepare_onnx_paddings(g, input.type().dim(), padding)
return g.op('Pad', input, pad, value, mode_s=mode) |
def get_embedding_folderpath(dataset: str, architecture: str, seed: int, step: int) -> pathlib.Path:
path_suffix = f'embeddings/{dataset}/{architecture}/{seed}/{step}/'
return (SCRATCH_PATH / pathlib.Path(path_suffix)) |
def download_from_url_to_file(url, file_path):
print(f'Download {url}')
r = requests.get(url, stream=True)
with open(file_path, 'wb') as f:
f.write(r.content)
success = (r.status_code == 200)
return success |
def encoding(dataset, model, tokenizer, max_length, hf_args, async_args, encode_is_qry=False):
encode_loader = DataLoader(dataset, batch_size=(hf_args.per_device_eval_batch_size * len(async_args.devices)), collate_fn=EncodeCollator(tokenizer, max_length=max_length, padding='max_length'), shuffle=False, drop_last=Fa... |
_model_architecture(model_name='unity_xm_transformer', arch_name='unity_xm_transformer')
def base_architecture_unity(args):
set_default_general_args(args)
set_default_w2v_encoder_args(args)
set_default_adaptor_args(args)
set_default_transformer_decoder_args(args)
args.layernorm_embedding = False
... |
def _is_iterable(o):
try:
_ = iter(o)
except Exception:
return False
return True |
class GOPSRandomStateEnumerator(RandomStateEnumerator):
def __init__(self):
super().__init__()
def enumerate(self, state: State):
prize_cards = state.prize_cards
player_cards = state.player_cards
opponent_cards = state.opponent_cards
num_cards = state.num_cards
st... |
class MjvCameraWrapper(object):
def __init__(self, wrapped, size_src=None):
self._wrapped = wrapped
self._size_src = size_src
def ptr(self):
return self._wrapped
def obj(self):
return self._wrapped.contents
def fovy(self):
return self._wrapped.contents.fovy
de... |
def _patch_file(path, content):
existing_content = open(path).read()
if (existing_content == content):
log.warn('Already patched.')
return False
log.warn('Patching...')
_rename_path(path)
f = open(path, 'w')
try:
f.write(content)
finally:
f.close()
return ... |
def _try_register_nav_task():
try:
from habitat.tasks.nav.nav import NavigationTask
has_navtask = True
except ImportError as e:
has_navtask = False
navtask_import_error = e
if has_navtask:
from habitat.tasks.nav.nav import NavigationTask
else:
_task(name='... |
def plot_wins(title, experiments, fig_name):
for (experiment, style) in experiments:
(label, color, ls) = style
steps = []
means = []
counter = 0
running_wins = 0
running_trajs = 0
with open((('path/run_final_' + experiment) + '.log')) as log_f:
fo... |
def lights_colors_from_lights_cmd(lights_cmd: LightsCmd, acc: float, t: Timestamp) -> LightsColors:
phases = lightscmd2phases[lights_cmd]
lights_colors = get_phased_lights(phases, float(t))
if (acc < 0):
if (lights_colors.back_left == red):
lights_colors.back_left = red_more
if (... |
def train(loader, net, crit, opt, epoch):
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
accs = AverageMeter()
precisions = AverageMeter()
recalls = AverageMeter()
net.train()
end = time.time()
for (i, ((feat, adj, cid, h1id), gtmat)) in enumerate(load... |
def arange(t: TensorType, start: int, stop: Optional[int]=None, step: Optional[int]=None) -> TensorType:
return t.arange(start, stop, step) |
class COGNET360KLoader(BaseLoader):
def __init__(self, dataset_path, download=False):
super().__init__(dataset_path, download, raw_data_path='COGNET360K/raw_data', processed_data_path='COGNET360K/processed_data', train_name='train.txt', valid_name='valid.txt', test_name='test.txt', data_name='COGNET360K')
... |
class MetadataKeeper(EventSink):
aggregations = {'avg': '_avg.4', 'sum': '_sum.1', None: ''}
def __init__(self, dataroot):
self.epochs = []
self.data = {}
self.keys = {}
def load_epochs_data(self, epochs, consts):
assert (not self.data)
for (i, data) in enumerate(epoc... |
def test_weighted_loss_forwards():
loss_fn = loss.WeightedLoss([torch.nn.L1Loss(), torch.nn.L1Loss()], weights=[2.0, 1.0])
pred = torch.ones(1, 1, 100)
target = torch.zeros(1, 1, 100)
assert (loss_fn(pred, target) == 3.0) |
_config
def rlgsn_base_resnet50():
cfg = {}
cfg['learner'] = {'perception_network': 'RLSidetuneWrapper', 'perception_network_kwargs': {'extra_kwargs': {'sidetune_kwargs': {'base_class': 'TaskonomyEncoder', 'base_weights_path': None, 'base_kwargs': {'eval_only': True, 'normalize_outputs': False}}}}} |
def gen_pixel_probabilities(session_location, options, master_logger, image_filename=None):
master_logger.info('Generating Pixel Probabilities')
if (image_filename is None):
image_filename = options.image_stack
if (('extract-ilp-prediction' in options) and options.extract_ilp_prediction):
ma... |
def bin_pack_dense_reward(dummy_generator: DummyGenerator, dense_reward: DenseReward) -> BinPack:
return BinPack(generator=dummy_generator, obs_num_ems=5, reward_fn=dense_reward) |
def batch_norm_in_place(net, axis, scope='batch_norm_in_place', is_training=None):
assert (is_training is not None)
assert (axis in [1, 3])
data_format = ('NCHW' if (axis == 1) else 'NHWC')
with tf.variable_scope(scope):
net = tf.contrib.layers.batch_norm(inputs=net, is_training=is_training, dat... |
_operation
def mult(a: torch.Tensor, b: torch.Tensor):
if is_real(a):
if (a.dim() >= b.dim()):
raise ValueError('Incorrect dimensions.')
return mult_real_cplx(a, b)
if is_real(b):
if (b.dim() >= a.dim()):
raise ValueError('Incorrect dimensions.')
return mu... |
class I3D(torch.nn.Module):
def __init__(self, num_classes, modality='rgb', dropout_prob=0, name='inception'):
super(I3D, self).__init__()
self.name = name
self.num_classes = num_classes
if (modality == 'rgb'):
in_channels = 3
elif (modality == 'flow'):
... |
class Vocabulary():
unk_token = UNK_TOKEN
def __init__(self):
self.word2id = {}
self.id2word = []
self.counts = []
self.unk_id = 0
def normalize(token, lower=LOWER, digit_0=DIGIT_0):
if (token in [Vocabulary.unk_token, '<s>', '</s>']):
return token
... |
def main():
from time import sleep
for i in range(500):
s = str((2.379 * i))
ProgressLine(s)
sleep(0.02)
c = Counter(5)
for i in range(500):
c.tick()
sleep(0.005)
c.done()
p = Progress(5000)
for i in range(5000):
p.tick()
sleep(0.0005)
... |
class SvmModel(ThundersvmBase):
def __init__(self, kernel, degree, gamma, coef0, C, nu, epsilon, tol, probability, class_weight, shrinking, cache_size, verbose, max_iter, n_jobs, max_mem_size, random_state, gpu_id):
self.kernel = kernel
self.degree = degree
self.gamma = gamma
self.co... |
def upload_file_r2(filename: str, url: str, bucket: str):
s3 = boto3.client('s3', endpoint_url=url, aws_access_key_id=os.environ.get('CLOUDFLARE_ACCESS_KEY_ID'), aws_secret_access_key=os.environ.get('CLOUDFLARE_ACCESS_SECRET_KEY'), region_name='auto')
s3.upload_file(filename, bucket, filename, Callback=R2Progre... |
def text2html_table(items: Collection[Collection[str]]) -> str:
html_code = f'<table border="1" class="dataframe">'
html_code += f''' <thead>
<tr style="text-align: right;">
'''
for i in items[0]:
html_code += f' <th>{_treat_html(i)}</th>'
html_code += f''' </tr>
</thead>
<tbody... |
class IdentityBlock(M.Model):
def initialize(self, fmap):
self.bn0 = L.batch_norm()
self.activ = L.activation(M.PARAM_RELU)
self.c1 = L.conv2D(3, fmap, pad='VALID', usebias=False)
self.bn1 = L.batch_norm()
self.c2 = L.conv2D(3, fmap, pad='VALID', usebias=False)
def forwar... |
def convert_latex(latex_file, colors_head):
latex_contents = open_tex_file(latex_file)
latex_contents = append_predefined_color(latex_contents, latex_file, colors_head)
latex_contents = color_brace(latex_contents, latex_file, 'title_begin', 'MYTITLE', inner_outer='inner')
latex_contents = color_brace(la... |
class TestTanhDistortion():
def test_single_channel(self):
samples = np.random.normal(0, 0.1, size=(2048,)).astype(np.float32)
sample_rate = 16000
augmenter = TanhDistortion(min_distortion=0.2, max_distortion=0.6, p=1.0)
distorted_samples = augmenter(samples=samples, sample_rate=samp... |
class ImageResize(object):
def __init__(self, max_size, interpolation=Image.BILINEAR):
assert isinstance(max_size, int)
self.max_size = max_size
self.interpolation = interpolation
def __call__(self, img):
if isinstance(img, torch.Tensor):
assert isinstance(self.interp... |
class Tdnn1a(AcousticModel):
def __init__(self, num_features: int, num_classes: int, subsampling_factor: int=3) -> None:
super(Tdnn1a, self).__init__()
self.num_features = num_features
self.num_classes = num_classes
self.subsampling_factor = subsampling_factor
self.tdnn = nn.... |
_registry(pattern_type='LayerNormWithReduceMean')
class LayerNormWithReduceMean(Pattern):
def __call__(self, model):
pattern_mapping_config = {'LayerNormWithReduceMean': [{'patterns': {'in': [[(0, 'LayerNorm'), (1, 'ReduceMean')]], 'out': [[(0, 'LayerNorm'), (1, 'Reshape'), (2, 'ReduceMean'), (3, 'Reshape')... |
def threeClassAcc(labels, preds):
tp = ((labels > 0) & preds).sum()
tn = ((labels < 0) & (~ preds)).sum()
acc = ((tp + tn) / np.abs(labels).sum())
return acc |
class TransformerSentenceEncoderLayerStd(TransformerSentenceEncoderLayer):
def __init__(self, sent_enc_layer):
super(TransformerSentenceEncoderLayer, self).__init__()
self.embedding_dim = sent_enc_layer.embedding_dim
self.dropout = sent_enc_layer.dropout
self.activation_dropout = sen... |
def atari_match_conv(num_frames, num_inputs_per_frame):
num_inputs = (num_frames * num_inputs_per_frame)
init_ = (lambda m: init(m, nn.init.orthogonal_, (lambda x: nn.init.constant_(x, 0)), nn.init.calculate_gain('relu')))
return nn.Sequential(init_(nn.Conv2d(num_inputs, 64, 8, stride=4)), nn.ReLU(), init_(... |
class ANN_models_class(models.Model):
def __init__(self, Nin, Nh, Nout):
super().__init__()
self.hidden = layers.Dense(Nh)
self.last = layers.Dense(Nout)
def call(self, x):
relu = layers.Activation('relu')
softmax = layers.Activation('softmax')
h = relu(self.hidde... |
def vgg16Netvlad(image_batch):
assert (len(image_batch.shape) == 4)
with tf.variable_scope('vgg16_netvlad_pca'):
if (image_batch.shape[3] == 1):
x = tf.nn.conv2d(image_batch, np.ones((1, 1, 1, 3)), np.ones(4).tolist(), 'VALID')
else:
assert (image_batch.shape[3] == 3)
... |
class UnpairedAudioTextConfig(FairseqDataclass):
data: str = field(default=MISSING, metadata={'help': 'path to data directory containing audio'})
text_data: str = field(default=MISSING, metadata={'help': 'path to data directory containing text'})
max_length: Optional[int] = None
labels: Optional[str] = ... |
def normalize(word):
if (not isinstance(word, str)):
word = str(word)
if (not isinstance(word, str)):
try:
word = word.encode('utf-8', 'ignore')
except:
pass
for (k, v) in DIACRITICS.items():
for v in v:
word = word.replace(v, k)
word =... |
class DummyObject(type):
def __getattr__(cls, key):
if (key.startswith('_') and (key != '_load_connected_pipes')):
return super().__getattr__(cls, key)
requires_backends(cls, cls._backends) |
def determine_node_label_by_layertype(layer, layertype, rankdir):
if (rankdir in ('TB', 'BT')):
separator = ' '
else:
separator = '\n'
if (layertype == 'Convolution'):
node_label = ('"%s%s(%s)%skernel size: %d%sstride: %d%spad: %d"' % (layer.name, separator, layertype, separator, lay... |
def quantize_items(items, ticks=120):
grids = np.arange(0, items[(- 1)].start, ticks, dtype=int)
for item in items:
index = np.argmin(abs((grids - item.start)))
shift = (grids[index] - item.start)
item.start += shift
item.end += shift
return items |
def init_logger(log_file=None, log_file_level=logging.NOTSET):
log_format = logging.Formatter('[%(asctime)s %(levelname)s] %(message)s')
logger = logging.getLogger()
logger.setLevel(logging.INFO)
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_format)
logger.handlers =... |
def d1_metric_np(disp_est, disp_gt, mask):
if (mask.sum() == 0):
return np.mean(0.0)
(disp_est, disp_gt) = (disp_est[mask], disp_gt[mask])
E = np.abs((disp_gt - disp_est))
err_mask = ((E > 3) & ((E / np.abs(disp_gt)) > 0.05))
return (np.mean(err_mask.astype(float)) * 100) |
def test_damaged_helmet():
gt_prefix = 'DamagedHelmetModel'
(gt_data_root, gt_download_dir, gt_extract_dir) = get_test_data_dirs(gt_prefix)
damaged_helmet = o3d.data.DamagedHelmetModel()
assert Path(gt_download_dir).is_dir()
assert (Path(damaged_helmet.path) == (gt_extract_dir / 'DamagedHelmetModel.... |
def ball_query_gpu(radius, nsample, xyz, new_xyz):
if (not (open3d.core.cuda.device_count() > 0)):
raise NotImplementedError
idx = ball_query(xyz, new_xyz, radius, nsample)
return idx |
class Kinetics200DataModule(KineticsDataModule):
def __init__(self, datadir: str, train: Optional[DictConfig]=None, val: Optional[DictConfig]=None, test: Optional[DictConfig]=None, video_path_prefix: str='', decode_audio: bool=False, decoder: str='pyav', decoder_args: DictConfig={}) -> None:
super().__init_... |
def get_file_from_repo(path_or_repo: Union[(str, os.PathLike)], filename: str, cache_dir: Optional[Union[(str, os.PathLike)]]=None, force_download: bool=False, resume_download: bool=False, proxies: Optional[Dict[(str, str)]]=None, use_auth_token: Optional[Union[(bool, str)]]=None, revision: Optional[str]=None, local_fi... |
def Solarize(img, v, max_v, bias=0):
v = (_int_parameter(v, max_v) + bias)
return PIL.ImageOps.solarize(img, (256 - v)) |
class SparseResNet_ImageNet(nn.Module):
def __init__(self, block, num_blocks, sparsities, num_classes=1000, sparse_func='vol', bias=False):
super(SparseResNet_ImageNet, self).__init__()
self.in_planes = 64
self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=bias)
s... |
def average_ari(masks, masks_gt, foreground_only=False):
ari = []
assert (masks.shape[0] == masks_gt.shape[0]), f'The number of masks is not equal to the number of masks_gt'
for i in range(masks.shape[0]):
m = masks[i].cpu().numpy().flatten()
m_gt = masks_gt[i].cpu().numpy().flatten()
... |
class SplitAttnConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=False, radix=2, reduction_factor=4, act_layer=nn.ReLU, norm_layer=None, drop_block=None, **kwargs):
super(SplitAttnConv2d, self).__init__()
self.radix = radix
... |
class Clip(torch.nn.Module):
def __init__(self, min_val=0.0, max_val=1.0):
super().__init__()
self.min_val = min_val
self.max_val = max_val
def forward(self, img):
return torch.clip(img, self.min_val, self.max_val)
def __repr__(self):
return (self.__class__.__name__ +... |
class PreResNet20NoAug():
base = PreResNet
args = list()
kwargs = {'depth': 20}
transform_train = transforms.Compose([transforms.Resize(32), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.201))])
transform_test = transforms.Compose([transforms.Resize(32), tr... |
def test_potential_method_returnunit():
from galpy.potential import PlummerPotential
pot = PlummerPotential(normalize=True, ro=8.0, vo=220.0)
try:
pot(1.1, 0.1).to(((units.km ** 2) / (units.s ** 2)))
except units.UnitConversionError:
raise AssertionError('Potential method __call__ does n... |
class MyDataloader():
def __init__(self, dataset, batch_size=1):
self.dataset = dataset
self.batch_size = batch_size
self.length = math.ceil((len(dataset) / self.batch_size))
def __iter__(self):
for (_, (images, labels)) in enumerate(self.dataset):
images = np.expand_... |
class GridWorldEnv(gym.Env):
def __init__(self, desc='4x4'):
if isinstance(desc, str):
desc = MAPS[desc]
desc = np.array(list(map(list, desc)))
desc[(desc == '.')] = 'F'
desc[(desc == 'o')] = 'H'
desc[(desc == 'x')] = 'W'
self.desc = desc
(self.n_r... |
def calc_overlap2(set_pred, set_gt):
try:
len_gt = len(set_gt)
len_pred = len(set_pred)
inter = len((set_gt & set_pred))
overlap_1 = (inter / len_gt)
overlap_2 = (inter / len_pred)
return (overlap_1, overlap_2)
except:
return (0, 0) |
class QConv2dSamePadding(nn.Conv2d):
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, num_bits=8, num_bits_weight=8, num_bits_grad=None, biprecision=False, measure=False):
super(QConv2dSamePadding, self).__init__(in_channels, out_channels, kern... |
def collate_fn(examples):
pixel_values = torch.stack([example['pixel_values'] for example in examples])
labels = torch.tensor([example['labels'] for example in examples])
return {'pixel_values': pixel_values, 'labels': labels} |
class AudioLDMPipelineSlowTests(unittest.TestCase):
def tearDown(self):
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
def get_inputs(self, device, generator_device='cpu', dtype=torch.float32, seed=0):
generator = torch.Generator(device=generator_device).manual_seed(see... |
def get_latest_parameter_file(folder):
import os.path as op
yaml_pattern = op.join(folder, 'parameters_*.yaml')
yaml_files = glob.glob(yaml_pattern)
assert (len(yaml_files) > 0), folder
def parse_time(f):
m = re.search('.*parameters_(.*)\\.yaml', f)
t = datetime.strptime(m.group(1), ... |
_ingredient.config
def config():
optimizer_name = 'adam'
loss_str = 'ce'
lr = None
max_epochs = 1000
metrics = ['loss']
val_metric_to_monitor = 'loss'
epoch_per_metric = 1
print_freq = 5
plateau_patience = 15
plateau_terminate = 60
gpu_if_available = True
gpu_idx = (- 1) |
def main(args):
utils.set_seed_everywhere((args.seed + 42))
if args.use_wandb:
wandb.init(project=args.wandb_project, name=str(args.seed), entity=args.wandb_entity, group=args.wandb_group, job_type=args.wandb_job)
wandb.config.update(args)
gym.logger.set_level(40)
env = make_env(domain_n... |
_vision
class BlipProcessorTest(unittest.TestCase):
def setUp(self):
self.tmpdirname = tempfile.mkdtemp()
image_processor = BlipImageProcessor()
tokenizer = BertTokenizer.from_pretrained('hf-internal-testing/tiny-random-BertModel')
processor = BlipProcessor(image_processor, tokenizer... |
def main_worker(rank, world_size, model, teacher_model, dataset):
try:
distributed_init('gloo', world_size=world_size, rank=rank, init_method='tcp://127.0.0.1:23456')
except:
distributed_init('gloo', world_size=world_size, rank=rank, init_method='tcp://127.0.0.1:12345')
training_args = Train... |
class ListSchema(Schema):
schemas: List[Schema]
sizes: List[int]
def __call__(self, values):
values = self._split(values, self.sizes)
if (len(values) != len(self.schemas)):
raise ValueError(f'Values has length {len(values)} but schemas has length {len(self.schemas)}!')
va... |
def get_equivalent_kernel_bias(rbr_dense, rbr_1x1, rbr_identity, in_channels, groups, padding_11):
(kernel3x3, bias3x3) = _fuse_bn_tensor(rbr_dense, in_channels, groups)
(kernel1x1, bias1x1) = _fuse_bn_tensor(rbr_1x1, in_channels, groups)
(kernelid, biasid) = _fuse_bn_tensor(rbr_identity, in_channels, group... |
class BondFeaturizer():
def __init__(self):
self.bond_type_to_oh_loc = {Chem.BondType.SINGLE: 0, Chem.BondType.DOUBLE: 1, Chem.BondType.TRIPLE: 2, Chem.BondType.AROMATIC: 3}
def bond_to_feat(self, bnd: Chem.Bond):
bond_indices = torch.tensor([bnd.GetBeginAtomIdx(), bnd.GetEndAtomIdx()])
... |
class SpleenDataset(DatasetBase):
download_link = '
zip_name = 'Spleen.zip'
folder_name = 'Spleen'
def __init__(self, *, root_dir: str, mode: str, transforms: SequentialWrapper=None) -> None:
sub_folders = ['img', 'gt']
sub_folder_types = ['image', 'gt']
group_re = 'Patient_\\d+'... |
def _import_handler(config):
print('[Warning] Currently we do not support recursive `_import`. If the base file you are importing from also has `_import`, it will not be correctly imported. If not, you can safely ignore this warning.')
imported_configs = config.pop('_import', [])
new_config = config.copy()
... |
def UnLearningScore(tmodel, gold_model, forget_dl, batch_size, device):
model_preds = []
gold_model_preds = []
with torch.no_grad():
for batch in forget_dl:
(x, y, cy) = batch
x = x.to(device)
model_output = tmodel(x)
gold_model_output = gold_model(x)
... |
def test_bottleneck():
data = torch.randn(1, 256, 56, 56)
in_planes = 256
out_planes = 128
expansion = Bottleneck.expansion
stride = 1
down_sample = nn.Sequential(nn.Conv2d(in_planes, (out_planes * expansion), kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d((out_planes * expansion)))
... |
class DistEvalHook(EvalHook):
def __init__(self, dataloader, interval=1, gpu_collect=False, by_epoch=False, **eval_kwargs):
if (not isinstance(dataloader, DataLoader)):
raise TypeError('dataloader must be a pytorch DataLoader, but got {}'.format(type(dataloader)))
self.dataloader = datal... |
def scan_net_ICO_preprocess_create(loc):
def load_model_scan_ICO(inference_vectorizer):
sn = ScanNetICO(inference_vectorizer, use_attention=False)
state = sn.state_dict()
partial = torch.load(loc)
state.update(partial)
sn.load_state_dict(state)
sn = sn.cuda()
... |
def get_module_dependencies(module_fname):
with open(os.path.join(PATH_TO_TRANFORMERS, module_fname), 'r', encoding='utf-8') as f:
content = f.read()
module_parts = module_fname.split(os.path.sep)
imported_modules = []
relative_imports = re.findall('from\\s+(\\.+\\S+)\\s+import\\s+([^\\n]+)\\n',... |
class QCircuitImage():
def __init__(self, qregs, cregs, ops, scale, style=None, plot_barriers=True, reverse_bits=False):
if (not HAS_PYLATEX):
raise ImportError('The latex and latex_source drawers need pylatexenc installed. Run "pip install pylatexenc" before using the latex or latex_source draw... |
class PerplexStatistics():
def __init__(self):
def _item(x):
return x.item()
def _exp_item(x):
return torch.exp(x).item()
self.stat = {'ppx': (WeightedSum('ppx', 0, _exp_item), '', ''), 'ppx_doc': (WeightedSum('ppx_doc', 0, _exp_item), '', ''), 'loss': (WeightedSum('l... |
def network_load(filename=None, path=None, device='cpu', load_weight=True):
import os
if path:
filedir = ((path + '/') + filename)
else:
path = './'
file = filename.split('.')[0]
origin_path = os.getcwd()
os.chdir(((path + '/') + file))
if os.path.exists(filename):
wi... |
class CtcCriterionConfig(FairseqDataclass):
zero_infinity: bool = field(default=False, metadata={'help': 'zero inf loss when source length <= target length'})
sentence_avg: bool = II('optimization.sentence_avg')
post_process: str = field(default='letter', metadata={'help': 'how to post process predictions i... |
class ActivationQuantizer():
def __init__(self, module, p=1, update_step=1000, bits=8, method='histogram', clamp_threshold=5):
self.module = module
self.p = p
self.update_step = update_step
self.counter = 0
self.bits = bits
self.method = method
self.clamp_thre... |
def load_pytorch_weights_in_tf2_model(tf_model, pt_state_dict, tf_inputs=None, allow_missing_keys=False):
try:
import tensorflow as tf
import torch
from tensorflow.python.keras import backend as K
except ImportError:
logger.error('Loading a PyTorch model in TensorFlow, requires b... |
class WordSequence(nn.Module):
def __init__(self, data):
super(WordSequence, self).__init__()
print(('build word sequence feature extractor: %s...' % data.word_feature_extractor))
self.gpu = data.HP_gpu
self.use_char = data.use_char
self.droplstm = nn.Dropout(data.HP_dropout)... |
class Bottleneck(nn.Module):
expansion = 4
def __init__(self, inplanes, planes, stride=1, downsample=None, dilation=1, isshape=False, modalbn=1):
super(Bottleneck, self).__init__()
self.isshape = isshape
self.modalbn = modalbn
assert ((modalbn == 1) or (modalbn == 2) or (modalbn ... |
class MViT(Backbone):
def __init__(self, img_size=224, patch_kernel=(7, 7), patch_stride=(4, 4), patch_padding=(3, 3), in_chans=3, embed_dim=96, depth=16, num_heads=1, last_block_indexes=(0, 2, 11, 15), qkv_pool_kernel=(3, 3), adaptive_kv_stride=4, adaptive_window_size=56, residual_pooling=True, mlp_ratio=4.0, qkv_... |
def create_train_dataloader(opt):
opt = copy.deepcopy(opt)
opt.no_flip = False
opt.serial_batches = False
opt.phase = 'train'
opt.meta_path = opt.calibration_meta_path
opt.load_in_memory = opt.calibration_load_in_memory
opt.max_dataset_size = 512
dataloader = CustomDatasetDataLoader(opt)... |
def test_fun_weak(model, loss_fn, dataloader, dataloader_neg, batch_tnf, use_cuda=True, triplet=False, tps_grid_regularity_loss=0):
model.eval()
test_loss = 0
if (dataloader_neg is not None):
dataloader_neg_iter = iter(dataloader_neg)
for (batch_idx, batch) in enumerate(dataloader):
batc... |
def combine_results():
results = pd.DataFrame(columns=['noise_rel', 'grid_param', 'err_min', 'grid', 'err', 'psnr', 'ssim'])
for idx in range(len(noise_rels)):
results_cur = pd.read_pickle(os.path.join(save_path, '{}{:.2f}.pkl'.format(file_name, noise_rels[idx])))
results.loc[idx] = results_cur.... |
def standard_embed(nvar, topdim, pols, verbose_level=0):
from phcpy.phcpy2c3 import py2c_embed_standard_system
from phcpy.interface import store_standard_system, load_standard_system
store_standard_system(pols, nbvar=nvar)
py2c_embed_standard_system(topdim, verbose_level)
return load_standard_system... |
class TestCheckInvalidLossHook(TestCase):
def test_after_train_iter(self):
n = 50
hook = CheckInvalidLossHook(n)
runner = Mock()
runner.logger = Mock()
runner.logger.info = Mock()
runner.iter = 10
outputs = dict(loss=torch.LongTensor([2]))
hook.after_t... |
def data_generator_wrapper(annotation_lines, batch_size, input_shape, anchors, num_classes):
n = len(annotation_lines)
if ((n == 0) or (batch_size <= 0)):
return None
return data_generator(annotation_lines, batch_size, input_shape, anchors, num_classes) |
def test_optional_import():
(has_pytest, pyt) = optional_import('pytest')
assert has_pytest
assert (pyt == pytest) |
def maybe_append_new_line(code):
lines = code.split('\n')
if (lines[0] in ['py', 'python']):
last_line = lines[(- 1)]
lines.pop()
lines.append(('\n' + last_line))
return '\n'.join(lines) |
('A2CAgent')
class AdvantageActorCriticAgent(SyncRunningAgent, ActorCriticAgent):
def __init__(self, obs_spec: Spec, act_spec: Spec, model_fn: ModelBuilder=None, policy_cls: PolicyType=None, sess_mgr: SessionManager=None, optimizer: tf.train.Optimizer=None, n_envs=4, value_coef=DEFAULTS['value_coef'], entropy_coef=... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.