code stringlengths 101 5.91M |
|---|
class EncodeBlock(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride, normalization=None, activation=None):
super().__init__()
self.c_in = in_channels
self.c_out = out_channels
layers = []
layers.append(Conv2dSame(self.c_in, self.c_out, kernel_size,... |
def refer_expression(captions, n_ground=1, prefix='refer expressions:', 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()
so... |
def build_dataloader(dataset, collate_fn, is_train, batch_size, n_workers=None, worker_init_fn=None, use_sampler=True):
batch_size = (batch_size // dist.get_world_size())
if use_sampler:
if is_train:
sampler = DistributedSampler(dataset)
else:
sampler = DistributedSampler... |
def make_dataloaders(cfg, mode='train', distributed=False, num_replicas=None, rank=None, expose_sampler=False):
outputs = []
for (i, dataset_cfg) in enumerate(cfg.DATASET):
cfg_ = deepcopy(cfg)
cfg_.DATASET = dataset_cfg
cfg_.TRAIN.BATCH_IMAGES = cfg.TRAIN.BATCH_IMAGES[i]
cfg_.VA... |
class TestPytorchEstimator(TestCase):
def setUp(self):
init_orca_context(runtime='ray', address='localhost:6379')
def tearDown(self):
stop_orca_context()
def test_train(self):
estimator = Estimator.from_torch(model=get_model, optimizer=get_optimizer, loss=nn.BCELoss(), metrics=Accura... |
def classifier_regularize(whichclass, batch):
autoencoder.train()
autoencoder.zero_grad()
(source, target, lengths) = batch
source = to_gpu(args.cuda, Variable(source))
target = to_gpu(args.cuda, Variable(target))
flippedclass = abs((2 - whichclass))
labels = to_gpu(args.cuda, Variable(torch... |
_grad()
def validate(model, val_dataloader):
LOGGER.info(f'start running evaluation.')
model.eval()
tot_score = 0
n_ex = 0
st = time()
predictions = {}
for (i, batch) in enumerate(val_dataloader):
(*batch_inputs, tgt_box_list, obj_boxes_list, sent_ids) = batch
scores = model(... |
class ConvexSortFunction(Function):
def forward(ctx, pts, masks, circular):
idx = convex_ext.convex_sort(pts, masks, circular)
ctx.mark_non_differentiable(idx)
return idx
def backward(ctx, grad_output):
return () |
def plot_spectrogram_to_numpy(spectrogram):
global MATPLOTLIB_FLAG
if (not MATPLOTLIB_FLAG):
import matplotlib
matplotlib.use('Agg')
MATPLOTLIB_FLAG = True
mpl_logger = logging.getLogger('matplotlib')
mpl_logger.setLevel(logging.WARNING)
import matplotlib.pylab as plt... |
def max_change(model, max_param_change=2.0, max_change_scale=1.0, scale=1.0):
scale_factors = []
num_components_updated = 0
for (i, p) in enumerate(model.parameters()):
if (i == 0):
device = p.device
max_param_change = torch.tensor(max_param_change, device=device, requires_gr... |
class MyTrainingArguments(TrainingArguments):
output_dir: str = field(default='./data/passage/star_train/models')
logging_dir: str = field(default='./data/passage/star_train/log')
padding: bool = field(default=False)
optimizer_str: str = field(default='lamb')
overwrite_output_dir: bool = field(defau... |
class GCN(nn.Module):
def __init__(self, nfeat, nhid, nclass, dropout):
super(GCN, self).__init__()
self.gc1 = GraphConvolution(nfeat, nhid)
self.gc2 = GraphConvolution(nhid, nclass)
self.dropout = dropout
def forward(self, x, adj):
x = F.relu(self.gc1(x, adj))
x ... |
def valid_raw_data() -> Dict[(str, Dict[(str, Any)])]:
with open('tests/mock_data_test.json') as f:
read_in_data = json.load(f)
return read_in_data |
def vgg16(num_classes=1000, pretrained='imagenet'):
model = models.vgg16(pretrained=False)
if (pretrained is not None):
settings = pretrained_settings['vgg16'][pretrained]
model = load_pretrained(model, num_classes, settings)
return model |
class TestPSAMask(object):
def test_psa_mask_collect(self):
if (not torch.cuda.is_available()):
return
from mmcv.ops import PSAMask
test_loss = Loss()
input = np.fromfile('tests/data/for_psa_mask/psa_input.bin', dtype=np.float32)
output_collect = np.fromfile('test... |
def pytorch_call(device):
def wrap(function):
def call(*args, **kwargs):
results = function(*to_tensor(args, device), **to_tensor(kwargs, device))
return to_numpy(results)
return call
return wrap |
def _convert_responses_to_elastic_constants(response_all: Array) -> Array:
if (response_all.shape[0] == 6):
cxxxx = response_all[0]
cyyyy = response_all[1]
cxyxy = (0.25 * response_all[2])
cxxyy = (0.5 * ((response_all[3] - cxxxx) - cyyyy))
cxxxy = (0.25 * ((response_all[4] -... |
def ms_ssim(X, Y, data_range=255, size_average=True, win_size=11, win_sigma=1.5, win=None, weights=None, K=(0.01, 0.03)):
if (len(X.shape) != 4):
raise ValueError('Input images should be 4-d tensors.')
if (not (X.type() == Y.type())):
raise ValueError('Input images should have the same dtype.')
... |
def make_logger(log_dir: Path=None, mode: str='train') -> str:
logger = logging.getLogger('')
version = pkg_resources.require('joeynmt')[0].version
if (len(logger.handlers) == 0):
logger.setLevel(level=logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(name)s - %(m... |
class RawDatasetSwbdSre(data.Dataset):
def __init__(self, raw_file, list_file):
self.raw_file = raw_file
with open(list_file) as f:
temp = f.readlines()
self.utts = [x.strip() for x in temp]
def __len__(self):
return len(self.utts)
def __getitem__(self, index):
... |
_module()
class CrossKDRetinaNet(CrossKDSingleStageDetector):
def loss(self, batch_inputs: Tensor, batch_data_samples: SampleList) -> Union[(dict, list)]:
tea_x = self.teacher.extract_feat(batch_inputs)
(tea_cls_scores, tea_bbox_preds, tea_cls_hold, tea_reg_hold) = multi_apply(self.forward_crosskd_s... |
def _num_samples(x):
if hasattr(x, 'fit'):
raise TypeError(('Expected sequence or array-like, got estimator %s' % x))
if ((not hasattr(x, '__len__')) and (not hasattr(x, 'shape'))):
if hasattr(x, '__array__'):
x = np.asarray(x)
else:
raise TypeError(('Expected seq... |
class UnitArrayUniformRange(UniformRange, Range[np.ndarray]):
def values(self) -> List[np.ndarray]:
return [np.array([x]) for x in np.arange(self.start, self.end, self.step, dtype=self.dtype)] |
def constant(duration: int, amp: complex, name: str=None) -> SamplePulse:
return _sampled_constant_pulse(duration, amp, name=name) |
def move_double_solution_cursor(idx, vrblvl=0):
if (vrblvl > 0):
print('in move_double_solution_cursor, idx :', idx)
phc = get_phcfun()
aaa = pointer(c_int32(idx))
bbb = pointer(c_int32(0))
ccc = pointer(c_double(0.0))
vrb = c_int32(vrblvl)
if (vrblvl > 0):
print('-> move_dou... |
def test_modal_datamodule_audio_param_dataset_train(fs, mocker):
dm = kick_modal_datamodule(fs, mocker, batch_size=8, dataset_class=AudioWithParametersDataset, dataset_kwargs={'parameter_key': 'features'})
dm.setup('fit')
train_loader = dm.train_dataloader()
assert isinstance(train_loader, DataLoader)
... |
def updateVocab(words, vocab):
for word in words:
word = word.lower()
if (word not in vocab):
vocab[word] = 0
vocab[word] += 1
return vocab |
class Sigma_mu_Net(nn.Module):
def __init__(self, in_ch, out_ch, mid_ch, layers, kernel_size, bias):
super(Sigma_mu_Net, self).__init__()
self.layers = layers
self.relu = nn.ReLU(inplace=True)
self.lyr = []
self.lyr.append(nn.Conv2d(in_ch, mid_ch, kernel_size=1, bias=bias))
... |
def ReadFileGS(x_axis, tthread, batchInterval, NUM_ITEMS, NUM_ACCESS, key_skewness, overlap_ratio, abort_ratio, isCyclic, complexity):
(w, h) = (3, len(x_axis))
y = [[] for _ in range(w)]
for complexity in x_axis:
inputEvents = (tthread * batchInterval)
op_gs_path = getPathGS('OPGSA', inputE... |
def conv_ws_2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1, eps=1e-05):
c_in = weight.size(0)
weight_flat = weight.view(c_in, (- 1))
mean = weight_flat.mean(dim=1, keepdim=True).view(c_in, 1, 1, 1)
std = weight_flat.std(dim=1, keepdim=True).view(c_in, 1, 1, 1)
weight = ((weig... |
def sequence_palette():
palette = {(0, 0, 0): 0, (0, 255, 0): 1, (255, 0, 0): 2, (0, 0, 255): 3, (255, 0, 255): 4, (0, 255, 255): 5, (255, 128, 0): 6, (102, 0, 102): 7, (51, 153, 255): 8, (153, 153, 255): 9, (153, 153, 0): 10, (178, 102, 255): 11, (204, 0, 204): 12, (0, 102, 0): 13, (102, 0, 0): 14, (51, 0, 0): 15,... |
def safe_subprocess_main_with_flags(flags, func, *args, **kwargs):
if flags.gui:
import matplotlib.pyplot as plt
plt.switch_backend('TkAgg')
init_worker_process_flags(flags)
return func(*args, **kwargs) |
def standard_complex_sweep(pols, sols, nvar, pars, start, target):
from phcpy.interface import store_standard_solutions as storesols
from phcpy.interface import store_standard_system as storesys
storesys(pols, nbvar=nvar)
storesols(nvar, sols)
from phcpy.interface import load_standard_solutions as l... |
def make_scorer(args):
bidirectional = args.bidirectional
enc_hidden_size = ((hidden_size // 2) if bidirectional else hidden_size)
if (args.useObjLabelOrVis == 'none'):
(feature_size, action_embedding_size) = ((2048 + 128), (2048 + 128))
elif (args.useObjLabelOrVis == 'vis'):
(feature_si... |
def enable_falcon_pos_shift_attention(model):
for (name, module) in reversed(model._modules.items()):
if (len(list(module.children())) > 0):
enable_falcon_pos_shift_attention(module)
if ('self_attention' == name[(- 14):]):
model._modules[name].forward = types.MethodType(falco... |
_torch
class CTRLModelTest(ModelTesterMixin, GenerationTesterMixin, PipelineTesterMixin, unittest.TestCase):
all_model_classes = ((CTRLModel, CTRLLMHeadModel, CTRLForSequenceClassification) if is_torch_available() else ())
all_generative_model_classes = ((CTRLLMHeadModel,) if is_torch_available() else ())
p... |
class LoopThread(StoppableThread):
def __init__(self, func, pausable=True):
super(LoopThread, self).__init__()
self._func = func
self._pausable = pausable
if pausable:
self._lock = threading.Lock()
self.daemon = True
def run(self):
while (not self.stop... |
def get_dag_params(obj: FlowSpec):
return [{'name': p[0], 'type': ('file' if isinstance(p[1], includefile.IncludeFile) else 'parameter')} for p in obj._get_parameters()] |
class Instance():
def __init__(self):
self.mount = '/home/wzielonka/Cluster/lustre'
self.dst = 'empty'
self.src = 'empty'
self.device = 'cuda:0'
self.actors = []
self.use_mount = os.path.exists(self.mount)
def get_dst(self):
return (self.dst if (not self.u... |
def make_divisible(value, divisor, min_value=None, min_ratio=0.9):
if (min_value is None):
min_value = divisor
new_value = max(min_value, ((int((value + (divisor / 2))) // divisor) * divisor))
if (new_value < (min_ratio * value)):
new_value += divisor
return new_value |
def dequantize(arr, min_val, max_val, levels, dtype=np.float64):
if (not (isinstance(levels, int) and (levels > 1))):
raise ValueError('levels must be a positive integer, but got {}'.format(levels))
if (min_val >= max_val):
raise ValueError('min_val ({}) must be smaller than max_val ({})'.format... |
class UpSampling1D(Layer):
def __init__(self, length, bigdl_type='float'):
super(UpSampling1D, self).__init__(None, bigdl_type, length) |
def get_visited_q_values(q, visits, state):
values = q[state]
state_visits = visits[state]
visited_modifier = np.zeros(values.size)
visited_modifier[(state_visits == 0)] = np.inf
return (values - visited_modifier) |
def parse_args():
usage = '\n1. create wrong.txt, correct.txt and mask_probability.sav by:\npython create_data.py -f /path/to/train.txt\n\n\n2. specify output dir by:\npython create_data.py -f /path/to/train.txt -o /path/to/dir/\n\n'
parser = argparse.ArgumentParser(description='A module for FASPell - Fast, Ada... |
def print_df_stats(df, df_train, df_val):
headers = ['Images', '-> AD', '-> CN', 'Patients', '-> AD', '-> CN']
def get_stats(df):
df_ad = df[(df['DX'] == 'Dementia')]
df_cn = df[(df['DX'] == 'CN')]
return [len(df), len(df_ad), len(df_cn), len(df['PTID'].unique()), len(df_ad['PTID'].uniqu... |
def prof(args):
print('| \\# Vars | \\# Batch | Linear f/b | qpth f/b |')
nBatch = 128
(all_linearf, all_qpthf) = ([], [])
(all_linearb, all_qpthb) = ([], [])
for nz in [10, 50, 100, 500]:
(linearf_times, qpthf_times, linearb_times, qpthb_times) = prof_instance(nz, nBatch, args.nTrials)
... |
def _worker_run_map(all_args):
try:
(runner, args) = all_args
return runner(singleton_pool.G, *args)
except Exception:
raise Exception(''.join(traceback.format_exception(*sys.exc_info()))) |
def unique_filename(prefix: str='', suffix: str='', n_digits: int=2, count_start: int=0) -> str:
fmt = (('{:0' + str(n_digits)) + 'd}')
if (prefix and (prefix[(- 1)] not in {'/', '\\'})):
prefix += '_'
while True:
filename = ((prefix + fmt.format(count_start)) + suffix)
if (not os.pa... |
def main():
(args, config) = parse_args()
(rank, model) = vis_net(args, config, args.save_dir) |
def main():
args = parse_args()
assert args.out.endswith('pkl'), 'The output file name must be pkl suffix'
cfg = Config.fromfile(args.config)
dataloader_cfg = cfg.get(f'{args.dataset}_dataloader')
ann_file = osp.join(dataloader_cfg.dataset.data_root, dataloader_cfg.dataset.ann_file)
img_prefix =... |
def process_bpe_symbol(sentence: str, bpe_symbol: str):
if (bpe_symbol == 'sentencepiece'):
sentence = sentence.replace(' ', '').replace('', ' ').strip()
elif (bpe_symbol == '_EOW'):
sentence = sentence.replace(' ', '').replace('_EOW', ' ').strip()
elif (bpe_symbol is not None):
sent... |
def get_bytes(buffer: Union[(Dict, np.ndarray)]) -> int:
if isinstance(buffer, dict):
return sum([get_bytes(v) for v in buffer.values()])
elif isinstance(buffer, np.ndarray):
return buffer.nbytes
else:
raise ValueError('Unsupported type passed to `get_bytes`.') |
class RandomSearch(AbstractSearch):
def __init__(self, policies, instantiate=True):
self.policies = policies
self.instantiate = instantiate
def __call__(self, root, *args, **kwargs):
start_time = timeit.default_timer()
node = root
path = []
while True:
... |
class nnUNetTrainerV2_NoNormalization_lr1en3(nnUNetTrainerV2_NoNormalization):
def __init__(self, plans_file, fold, output_folder=None, dataset_directory=None, batch_dice=True, stage=None, unpack_data=True, deterministic=True, fp16=False):
super().__init__(plans_file, fold, output_folder, dataset_directory,... |
def generate(generations, population, all_possible_genes, dataset):
logging.info('***generate(generations, population, all_possible_genes, dataset)***')
evolver = Evolver(all_possible_genes)
genomes = evolver.create_population(population)
for i in range(generations):
logging.info(('***Now in gen... |
class ModelBuilder(nn.Module):
def __init__(self):
super(ModelBuilder, self).__init__()
self.backbone = get_backbone(cfg.BACKBONE.TYPE, **cfg.BACKBONE.KWARGS)
if cfg.ADJUST.ADJUST:
self.neck = get_neck(cfg.ADJUST.TYPE, **cfg.ADJUST.KWARGS)
self.kpn_head = get_kpn_head(cfg... |
def warn(msg, *args):
if (MIN_LEVEL <= WARN):
warnings.warn(colorize(('%s: %s' % ('WARN', (msg % args))), 'yellow')) |
class Net():
def __init__(self, data_module, _num_sample_factors=None):
if (_num_sample_factors is None):
self._num_sample_factors = 1
else:
self._num_sample_factors = _num_sample_factors
self._num_samples = data_module.num_samples()
self.data_module = data_mo... |
class COCODataset(torchvision.datasets.coco.CocoDetection):
def __init__(self, ann_file, root, remove_images_without_annotations, transforms=None, is_source=True):
super(COCODataset, self).__init__(root, ann_file)
self.ids = sorted(self.ids)
if remove_images_without_annotations:
... |
class Algorithm(object):
def __init__(self, parameters=None, **kargs):
self._default_keyword_parameters = {'maximum_iteration': 100, 'verbose': False, 'recording_functions': {}, 'display_time': 0.5, 'display_function': self.__no_display}
self._default_keyword_parameters.setdefault('relative_differen... |
def load_BART_or_PEGASUS(mname):
if ('bart' in mname.lower()):
from transformers import BartTokenizer, BartForConditionalGeneration
model = BartForConditionalGeneration.from_pretrained(mname)
tokenizer = BartTokenizer.from_pretrained(mname)
elif ('pegasus' in mname.lower()):
from... |
def getlocaltime():
date = time.strftime('%y-%m-%d', time.localtime())
current_time = time.strftime('%H:%M:%S', time.localtime()) |
def to_list(obj):
if (not isinstance(obj, list)):
return [obj]
else:
return obj |
class XnliProcessor(DataProcessor):
def __init__(self, language, train_language=None):
self.language = language
self.train_language = train_language
def get_train_examples(self, data_dir):
lg = (self.language if (self.train_language is None) else self.train_language)
lines = self... |
def generate_training_labels(data_folder: Path, resume):
print(f'Processing label data in {data_folder}')
for city in ['london', 'madrid', 'melbourne']:
data_folder_train_city_labels = (((data_folder / 'train') / city) / 'labels')
data_folder_train_city_labels.mkdir(exist_ok=True, parents=True)
... |
class TrainSetTransform():
def __init__(self, aug_mode):
self.aug_mode = aug_mode
if (self.aug_mode == 1):
t = [RandomRotation(max_theta=5, axis=np.array([0, 0, 1])), RandomFlip([0.25, 0.25, 0.0])]
else:
raise NotImplementedError('Unknown aug_mode: {}'.format(self.aug... |
class HSmooth(HBox):
def __init__(self, *args, **kargs):
super(HSmooth, self).__init__(*args, **kargs)
def customRelu(self):
return self.creluSmooth()
def copy(hbox):
return HSmooth(hbox.head, hbox.beta, hbox.errors)
def box(*args, **kargs):
return HSmooth.copy(HBox.box(*... |
def process_time(result_text: str, doc) -> dict:
mentioned_time = {'time': [], 'period': []}
for ent in doc.ents:
if (ent.label_ == 'DATE'):
if bool(re.search('\\d', str(ent))):
if ('to' in result_text):
if ('to' in ent.text):
cur_p... |
class UperNetPyramidPoolingModule(nn.Module):
def __init__(self, pool_scales: Tuple[(int, ...)], in_channels: int, channels: int, align_corners: bool) -> None:
super().__init__()
self.pool_scales = pool_scales
self.align_corners = align_corners
self.in_channels = in_channels
... |
class TFXLMRobertaForSequenceClassification(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
def main_worker(gpu, ngpus_per_node, args):
args.gpu = gpu
if (args.multiprocessing_distributed and (args.gpu != 0)):
def print_pass(*args):
pass
builtins.print = print_pass
if (args.gpu is not None):
print('Use GPU: {} for training'.format(args.gpu))
if args.distribu... |
def load_pickle(path):
print('load', path)
with open(path, mode='rb') as f:
return pickle.load(f) |
def test2():
graph2 = {('A', 'B'): 1, ('B', 'C'): 2, ('C', 'D'): 3, ('D', 'E'): (- 1), ('E', 'F'): 4}
result = shortest_paths('A', graph2)
expected = {'A': 0, 'C': 3, 'B': 1, 'E': 5, 'D': 6, 'F': 9}
assert (result == expected) |
def train(params: Params):
if (not os.path.exists(MODEL_FOLDER)):
os.mkdir(MODEL_FOLDER)
assert os.path.exists(MODEL_FOLDER), ' Cannot create folder to save trained model: {}'.format(MODEL_FOLDER)
dataloaders = make_dataloaders(params)
print('Training set: Dataset size: {}'.format(len(dataloader... |
def _weight_align(model, ref_model, tp_model):
_tp_weigth_align(tp_model, ref_model)
_ds_pipe_weight_align(model, tp_model) |
_tf
class TFModelTesterMixin():
model_tester = None
all_model_classes = ()
test_torchscript = True
test_pruning = True
test_resize_embeddings = True
is_encoder_decoder = False
def test_initialization(self):
pass
def test_save_load(self):
(config, inputs_dict) = self.model... |
def add_prefix_each_line(prefix, str):
lines = [f'{prefix}{line}' for line in str.split('\n')]
return '\n'.join(lines) |
def preprocess_for_sft(df: pd.DataFrame, prompt_dict: dict, tokenizer: transformers.PreTrainedTokenizer, df_postprocessor=None, verbose=True) -> dict[(str, Union[(torch.Tensor, Sequence[torch.Tensor])])]:
if (df_postprocessor is not None):
df = df_postprocessor(df)
list_dict_data = df.to_dict(orient='re... |
def _generate_dilation_grids(spatial_shapes, kernel_h, kernel_w, dilation_h, dilation_w, group, device):
(_, H_, W_, _) = spatial_shapes
points_list = []
(x, y) = torch.meshgrid(torch.linspace((- ((dilation_w * (kernel_w - 1)) // 2)), ((- ((dilation_w * (kernel_w - 1)) // 2)) + ((kernel_w - 1) * dilation_w)... |
def train():
logging('Training')
train_data = batchify(corpus.train, args.batch_size, shuffle=True)
if (args.niters_gan_schedule != ''):
gan_schedule = [int(x) for x in args.niters_gan_schedule.split('-')]
else:
gan_schedule = []
niter_gan = 1
fixed_noise = Variable(torch.ones(ar... |
def train_cifar_track_acc(model, criterion, optimizer, scheduler, dataloaders, dataset_sizes, device, num_epochs=200, verbose=False, use_intermediate=False):
best_model_sd = copy.deepcopy(model.state_dict())
best_error = 1e+100
criterion2 = torch.nn.CrossEntropyLoss()
for epoch in range(num_epochs):
... |
def export_tracing(torch_model, inputs):
assert (TORCH_VERSION >= (1, 8))
image = inputs[0]['image']
inputs = [{'image': image}]
if isinstance(torch_model, GeneralizedRCNN):
def inference(model, inputs):
inst = model.inference(inputs, do_postprocess=False)[0]
return [{'in... |
def cfg():
seed = 2021
gpu_id = 0
num_workers = 0
mode = 'train'
dataset = 'CHAOST2'
exclude_label = [1, 2, 3, 4]
if (dataset == 'CMR'):
n_sv = 1000
else:
n_sv = 5000
min_size = 200
max_slices = 3
use_gt = False
eval_fold = 0
test_label = [1, 4]
su... |
def mse_loss_plus_rank_loss(output, target):
cost = output
target_cost = target
if (output.size()[0] > 1):
inter = output[:(- 1)]
inter_1 = output[1:]
else:
inter = torch.ones(1)
inter_1 = (2 * torch.ones(1))
target_rank = torch.ones(inter.size())
loss_mse = nn.MS... |
def compute_score_with_logits(logits, labels):
logits = torch.max(logits, (- 1))[1].data
return (logits == labels) |
def main(cfg):
if (cfg.training.resume is not None):
log_dir = cfg.training.log_dir
checkpoint_dir = os.path.dirname(cfg.training.resume)
else:
timestamp = datetime.now().strftime('%Y-%m-%d_%H-%M-%S.%f')
log_dir = os.path.join(cfg.training.logs_dir, '{}_{}'.format(timestamp, cfg.... |
(version='2.0')
class DataLoader(object):
def __init__(self, dataset, batch_size=1, collate_fn=None, last_batch='rollover', sampler=None, batch_sampler=None, num_workers=0, pin_memory=False, shuffle=False, distributed=False):
assert (hasattr(dataset, '__iter__') or hasattr(dataset, '__getitem__')), 'dataset... |
def make_save_dir(yaml, img_shape, scale_num, scale_factor, sr_rate=None):
save_dir = []
save_dir.append(f"[{os.path.basename(yaml.DATASET.img_path).split('.')[0]}]")
save_dir.append('{}x{}'.format(*img_shape))
save_dir.append(f'S{scale_num}')
save_dir.append(f'CH{yaml.NET.net_ch}')
if (sr_rate ... |
def _load_encoders_parallel(encoder_paths, n_processes=None):
n_processes = (len(encoder_paths) if (n_processes is None) else min(len(encoder_paths), n_processes))
n_parallel = min(multiprocessing.cpu_count(), n_processes)
pool = multiprocessing.Pool(min(n_parallel, n_processes))
experts = pool.map(_loa... |
def add_train_args(parser: argparse.ArgumentParser):
parser.add_argument('--data_dir', type=str, required=True)
parser.add_argument('--out_dir', type=str, default='out', required=False)
parser.add_argument('--eval_interval', type=int, default=2000, required=False)
parser.add_argument('--log_interval', t... |
class LogAudioCallback(Callback):
model: pl.LightningModule
stored_forward: MethodType
def __init__(self, on_train: bool, on_val: bool, on_test: bool, save_audio_sr: int=48000, n_batches: int=1, log_on_epoch_end: bool=False, max_audio_samples: int=8):
self.on_train = on_train
self.on_val = o... |
class CenterLoss(nn.Module):
def __init__(self, num_classes=10, feat_dim=2, use_gpu=True):
super(CenterLoss, self).__init__()
self.num_classes = num_classes
self.feat_dim = feat_dim
self.use_gpu = use_gpu
if self.use_gpu:
self.centers = nn.Parameter(torch.randn(se... |
class TransformerBlock(nn.Module):
def __init__(self, dim, heads=8, dim_head=None, dim_linear_block=1024, dropout=0.1, activation=nn.GELU, mhsa=None, prenorm=False):
super().__init__()
self.mhsa = (mhsa if (mhsa is not None) else MultiHeadSelfAttention(dim=dim, heads=heads, dim_head=dim_head))
... |
def load_checkpoint_to_cpu(path, arg_overrides=None):
with PathManager.open(path, 'rb') as f:
state = torch.load(f, map_location=(lambda s, l: default_restore_location(s, 'cpu')))
args = state['args']
if (arg_overrides is not None):
for (arg_name, arg_val) in arg_overrides.items():
... |
class Sample(BSample):
def __init__(self, features, labels, bigdl_type='float'):
super(Sample, self).__init__(features, labels, bigdl_type)
def from_ndarray(cls, features, labels, bigdl_type='float'):
features = to_list_of_numpy(features)
labels = to_list_of_numpy(labels)
return ... |
def process_article(article):
article = process_article_sent_tokenize(article)
new_article = []
for sent in article:
insert_new(new_article, sent)
return new_article |
class SparseConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride, padding, weight, bias, mask):
super(SparseConv2d, self).__init__()
kernel_size = _pair(kernel_size)
stride = _pair(stride)
padding = _pair(padding)
self.in_channels = in_channels... |
def train_epoch_distill(teacher_model, student_model, optimizer, baseline, lr_scheduler, epoch, val_dataset, problem, tb_logger, opts):
print('')
print('Start train AMDKD student model epoch {}, lr={} for run {}'.format(epoch, optimizer.param_groups[0]['lr'], opts.run_name))
step = (epoch * (opts.epoch_size... |
def get_data():
np.random.seed(0)
seq_len = 400
data = np.random.rand(seq_len)
horizon = np.random.randint(2, 50)
validation_data = np.random.rand(horizon)
return (data, validation_data) |
_cache(maxsize=None)
def median_kernel(filter_width: int):
def kernel(y, x, x_stride, y_stride, BLOCK_SIZE: tl.constexpr):
row_idx = tl.program_id(0)
offsets = tl.arange(0, BLOCK_SIZE)
mask = (offsets < y_stride)
x_ptr = (x + (row_idx * x_stride))
y_ptr = (y + (row_idx * y_st... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.