code stringlengths 101 5.91M |
|---|
def get_default_args():
parser = get_model_dataset_args()
parser.add_argument('--output_dir', type=str, help='Output directory')
parser.add_argument('--eval_freq', type=int, default=50)
parser.add_argument('--save_freq', type=int, default=50)
parser.add_argument('--seed', type=int, default=1)
pa... |
def train_model(args, model, train, dev, src=None, trg=None, trg_len_dic=None, teacher_model=None, save_path=None, maxsteps=None):
if (args.tensorboard and (not args.debug)):
from tensorboardX import SummaryWriter
writer = SummaryWriter(str((args.event_path / args.id_str)))
if ((type(model) is F... |
class RMSpropTF(Optimizer):
def __init__(self, params, lr=0.01, alpha=0.9, eps=1e-10, weight_decay=0, momentum=0.0, centered=False, decoupled_decay=False, lr_in_momentum=True):
if (not (0.0 <= lr)):
raise ValueError('Invalid learning rate: {}'.format(lr))
if (not (0.0 <= eps)):
... |
def is_ray_tune_available():
if (not is_ray_available()):
return False
return (importlib.util.find_spec('ray.tune') is not None) |
_module()
class CityscapesSemiDataset(CustomDataset):
CLASSES = ('road', 'sidewalk', 'building', 'wall', 'fence', 'pole', 'traffic light', 'traffic sign', 'vegetation', 'terrain', 'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train', 'motorcycle', 'bicycle')
PALETTE = [[128, 64, 128], [244, 35, 232], [70, 7... |
class Example(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.OS = platform.system().lower()
self.parent = parent
self.fileName = ''
self.debug = False
self.colorAllChunk = True
self.history = deque(maxlen=20)
self.currentContent ... |
class _InputInjection(nn.Module):
def __init__(self, ratio):
super(_InputInjection, self).__init__()
self.pool = nn.ModuleList()
for i in range(0, ratio):
self.pool.append(nn.AvgPool2d(3, 2, 1))
def forward(self, x):
for pool in self.pool:
x = pool(x)
... |
class TestLoadCaffe():
def test_load_caffe(self):
resource_path = os.path.join(os.path.split(__file__)[0], '../resources')
proto_txt = os.path.join(resource_path, 'test.prototxt')
model_path = os.path.join(resource_path, 'test.caffemodel')
module = Sequential().add(SpatialConvolution... |
class BasicBlock(nn.Module):
def __init__(self, inplanes, planes, stride=1, dilation=1, norm_cfg=dict(type='BN')):
super(BasicBlock, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=stride, padding=dilation, bias=False, dilation=dilation)
self.bn1 = BatchNorm(p... |
class OzoneTrainDataset(DelimitTrainDataset):
def __init__(self, target: str='all', root: str=None, ozone_root: str=None, use_fixed: float=0.1, seq_duration: Optional[float]=6.0, samples_per_track: int=64, source_augmentations: Optional[Callable]=(lambda audio: audio), sample_rate: int=44100, seed: int=42, limitaug... |
class Generator(abc.ABC):
def __init__(self, shelf_rows: int, shelf_columns: int, column_height: int, num_agents: int, sensor_range: int, request_queue_size: int) -> None:
if ((shelf_columns % 2) != 1):
raise ValueError('Environment argument: `shelf_columns`, must be an odd number.')
sel... |
class VUAProcessor(DataProcessor):
def get_train_examples(self, data_dir):
return self._create_examples(self._read_tsv(os.path.join(data_dir, 'train.tsv')), 'train')
def get_test_examples(self, data_dir):
return self._create_examples(self._read_tsv(os.path.join(data_dir, 'test.tsv')), 'test')
... |
def test_sequential_sar_decoder():
decoder = SequentialSARDecoder(num_classes=37, padding_idx=36, max_seq_len=5)
decoder.init_weights()
decoder.train()
(feat, out_enc, tgt_dict, img_metas) = _create_dummy_input()
with pytest.raises(AssertionError):
decoder(feat, out_enc, tgt_dict, [])
wi... |
def gptneox_sample_token_mirostat_v2(ctx: gptneox_context_p, candidates, tau: c_float, eta: c_float, mu) -> gptneox_token:
return _lib.gptneox_sample_token_mirostat_v2(ctx, candidates, tau, eta, mu) |
def _padleft(width, s, has_invisible=True):
iwidth = (((width + len(s)) - len(_strip_invisible(s))) if has_invisible else width)
fmt = ('{0:>%ds}' % iwidth)
return fmt.format(s) |
class ImageDataset(Dataset):
def __init__(self, file_paths: Iterable, transform=None, read_func: Callable=read_image_tensor):
self.file_paths = file_paths
self.transform = transform
def __getitem__(self, idx: int) -> dict:
file = self.file_paths[idx]
img = read_image_tensor(file,... |
def class_balance(data_path: str, split_type: str):
(args.val_fold_index, args.test_fold_index) = (1, 2)
args.split_type = 'predetermined'
data = get_data(path=args.data_path, smiles_column=args.smiles_column, target_columns=args.target_columns)
args.task_names = (args.target_columns or get_task_names(p... |
def load_image(filename, is_srgb=True):
if (not filename):
raise ValueError('Empty filename')
image = (np.asarray(Image.open(filename)).astype(np.float) / 255.0)
if is_srgb:
return srgb_to_rgb(image)
else:
return image |
class SubGymMarketsDailyInvestorEnv_v0(AbidesGymMarketsEnv):
raw_state_pre_process = markets_agent_utils.ignore_buffers_decorator
raw_state_to_state_pre_process = markets_agent_utils.ignore_mkt_data_buffer_decorator
def __init__(self, background_config: str='rmsc04', mkt_close: str='16:00:00', timestep_dura... |
class NMTDataSet():
def __init__(self, data_path, src_lang, tgt_lang, src_vocab_path, tgt_vocab_path, src_max_vocab, tgt_max_vocab, subword, create_vocab):
self.train_src_path = os.path.join(data_path, 'train.{}'.format(src_lang))
self.train_tgt_path = os.path.join(data_path, 'train.{}'.format(tgt_l... |
_registry(pattern_type='RemoveZeros')
class RemoveZeros(Pattern):
def __call__(self, model):
if (model.framework_modeling_config['framework'] != 'torch'):
return model
remove_list = []
node_idx = 0
while (node_idx < len(model.nodes)):
node = model.nodes[node_i... |
class AnchorMatcherTest(tf.test.TestCase):
def test_get_correct_matched_columnIndices(self):
match_results = tf.constant([3, 1, (- 1), 0, (- 1), 5, (- 2)])
match = matcher.Match(match_results)
expected_column_indices = [0, 1, 3, 5]
matched_column_indices = match.matched_column_indice... |
def smooth_clip(x, v, smoothing, max_iters=200):
test_x = copy.deepcopy(x)
v_i = copy.deepcopy(v)
iter_i = 0
n = 1.0
while ((n > 0) and (iter_i < max_iters)):
result_img = (test_x + v_i)
overshoot = ((result_img - 1.0) >= 0)
belowshoot = ((result_img - 0.0) <= 0)
ov_m... |
class ValorCaptionEvalDataset(BaseDataset):
def __init__(self, vis_processor, text_processor, aud_processor, vis_root, aud_root, ann_paths):
super().__init__(vis_processor, text_processor, vis_root, ann_paths)
self.aud_processor = aud_processor
self.aud_root = aud_root
def __getitem__(se... |
class RteProcessor(DataProcessor):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('processor'), FutureWarning)
def get_example_from_tensor_dict(self, tensor_dict):
return InputExample(tensor_dict['idx'].numpy(), tensor_dict... |
('/topics', methods=['GET'])
def topics():
topics = db.get_topics()
return make_response(jsonify({'topics': topics}), 200) |
def loadZipToMem(zip_file, csv_name):
print('Loading dataset zip file...', end='')
from zipfile import ZipFile
input_zip = ZipFile(zip_file)
data = {name: input_zip.read(name) for name in input_zip.namelist()}
train = list((row.split(',') for row in data[csv_name].decode('utf-8').split('\n') if (len... |
def execute_indent_transformation(list_transformed_code):
for (index, file_path) in enumerate(globals.list_trans_indent_modified_file):
trans_location_idxs = globals.list_trans_indent_location_idxs[index]
trans_indent_level = globals.list_trans_indent_level[index]
file_path_idx = globals.lis... |
def get_image_metadata_from_bytesio(input, size, file_path=None):
height = (- 1)
width = (- 1)
data = input.read(26)
msg = ' raised while trying to decode as JPEG.'
if ((size >= 10) and (data[:6] in (b'GIF87a', b'GIF89a'))):
imgtype = GIF
(w, h) = struct.unpack('<HH', data[6:10])
... |
class SplinterModelTester():
def __init__(self, parent, batch_size=13, seq_length=7, is_training=True, use_input_mask=True, use_token_type_ids=True, use_labels=True, vocab_size=99, hidden_size=32, num_hidden_layers=5, num_attention_heads=4, intermediate_size=37, hidden_act='gelu', hidden_dropout_prob=0.1, attention... |
def convert_torgb(vars, source_name, target_name):
weight = vars[(source_name + '/weight')].value().eval()
mod_weight = vars[(source_name + '/mod_weight')].value().eval()
mod_bias = vars[(source_name + '/mod_bias')].value().eval()
bias = vars[(source_name + '/bias')].value().eval()
dic = {'conv.weig... |
class MetersDict(OrderedDict):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.priorities = []
def __setitem__(self, key, value):
assert (key not in self), "MetersDict doesn't support reassignment"
(priority, value) = value
bisect.insort(self.p... |
def get_checkpoint_callback(output_dir, metric):
if (metric == 'rouge2'):
exp = '{val_avg_rouge2:.4f}-{step_count}'
elif (metric == 'bleu'):
exp = '{val_avg_bleu:.4f}-{step_count}'
elif (metric == 'em'):
exp = '{val_avg_em:.4f}-{step_count}'
else:
raise NotImplementedErro... |
def download_google_drive_url(url: str, output_path: str, output_file_name: str):
import requests
with requests.Session() as session:
with session.get(url, stream=True, allow_redirects=True) as response:
for (k, v) in response.cookies.items():
if k.startswith('download_warnin... |
def get_latest_match(pattern: Union[(Path, str)]) -> Path:
all_matches = (Path(p) for p in glob.glob(str(pattern), recursive=True))
latest_match = max(all_matches, key=(lambda x: x.stat().st_mtime))
return latest_match |
def logger_info(logger_name, log_path='default_logger.log'):
log = logging.getLogger(logger_name)
if log.hasHandlers():
print('LogHandlers exist!')
else:
print('LogHandlers setup!')
level = logging.INFO
formatter = logging.Formatter('%(asctime)s.%(msecs)03d : %(message)s', da... |
def unixify(paths):
for path in paths:
for file in os.listdir(path):
if (('.py' in file) or ('.sh' in file)):
_ = os.system(((('bash -c "dos2unix ' + path) + file) + ' 2&> /dev/null"')) |
def main(args):
ConfigureGPU(args)
np.random.seed(0)
data_file_info = args['data_file'].split('.')
data_type = data_file_info[(- 1)]
root = ''
for (i, tok) in enumerate(data_file_info[:(- 1)]):
if ((i < (len(data_file_info) - 1)) and (i > 0)):
root += '.'
root += tok
... |
_grad()
def valid_step(model, criterion, val_loader):
model.eval()
(avg_loss, avg_acc) = (0.0, 0.0)
for (i, (x_imgs, labels)) in enumerate(val_loader):
(x_imgs, labels) = (x_imgs.to(args.device), labels.to(args.device))
outputs = model(x_imgs)
loss = criterion(outputs, labels)
... |
class MLPBase(NNBase):
def __init__(self, num_inputs: int, recurrent: bool=False, hidden_size: int=64) -> None:
super().__init__(recurrent, num_inputs, hidden_size)
if recurrent:
num_inputs = hidden_size
init_ = (lambda m: init(m, nn.init.orthogonal_, (lambda x: nn.init.constant_... |
class DatasetCache(data.Dataset):
def __init__(self, root, load_bytes=False, transform=None, class_map='', use_cache=False):
class_to_idx = None
if class_map:
class_to_idx = load_class_map(class_map, root)
(images, class_to_idx) = find_images_and_targets(root, class_to_idx=class_... |
def kaiming_uniform_(tensor, gain=1.0, mode='fan_in'):
fan = _calculate_correct_fan(tensor, mode)
var = (gain / max(1.0, fan))
bound = math.sqrt((3.0 * var))
with torch.no_grad():
return tensor.uniform_((- bound), bound) |
class TestAnchorGenerator(unittest.TestCase):
def test_default_anchor_generator(self):
cfg = get_cfg()
cfg.MODEL.ANCHOR_GENERATOR.SIZES = [[32, 64]]
cfg.MODEL.ANCHOR_GENERATOR.ASPECT_RATIOS = [[0.25, 1, 4]]
anchor_generator = DefaultAnchorGenerator(cfg, [ShapeSpec(stride=4)])
... |
def step_lr_scheduler(param_lr, optimizer, iter_num, gamma, stepsize, init_lr=0.001):
lr = (init_lr * (gamma ** (iter_num // stepsize)))
i = 0
for param_group in optimizer.param_groups:
param_group['lr'] = (lr * param_lr[i])
i += 1
return optimizer |
def common_conv2d(inplanes, planes, kernel, padding, stride, norm_cfg=dict(type='BN')):
cell = OrderedDict()
cell['conv'] = nn.Conv2d(inplanes, planes, kernel_size=kernel, stride=stride, padding=padding, bias=False)
if norm_cfg:
(norm_name, norm) = build_norm_layer(norm_cfg, planes)
cell[nor... |
def evaluate_vit_separate(model, template, search, template_event, search_event):
T_w = 50
T_t = 1000
print('testing speed ...')
z = model.forward_backbone(template, image_type='template')
x = model.forward_backbone(search, image_type='search')
z_event = model.forward_backbone(template_event, im... |
def reverse_object_order(example_records):
reversed_records = collections.defaultdict(list)
for (image_pair, records) in example_records.items():
reversed_records[image_pair].extend(records)
for record in records:
reversed_record = Record(record.bbox_b, record.bbox_a, 0, 0)
... |
class Embeddings(nn.Module):
def __init__(self, embedding_dim: int=64, scale: bool=False, vocab_size: int=0, padding_idx: int=1, freeze: bool=False, **kwargs):
super().__init__()
self.embedding_dim = embedding_dim
self.scale = scale
self.vocab_size = vocab_size
self.lut = nn.... |
class NoOCRReaderFound(Exception):
def __init__(self, e):
self.e = e
def __str__(self):
return f'Could not load OCR Reader: {self.e}' |
class Timer(object):
def __init__(self):
self.total_time = 0.0
self.calls = 0
self.start_time = 0.0
self.diff = 0.0
self.avg = 0.0
def reset(self):
self.total_time = 0
self.calls = 0
self.start_time = 0
self.diff = 0
self.avg = 0
... |
def standardized_svr(X, y, Cs=np.logspace((- 7), 1, 9), n_jobs=1):
(n_samples, n_features) = X.shape
steps = [('SVR', LinearSVR())]
pipeline = Pipeline(steps)
parameters = {'SVR__C': Cs}
grid = GridSearchCV(pipeline, param_grid=parameters, n_jobs=n_jobs)
grid.fit(X, y)
beta_hat = grid.best_e... |
class MarianMTModel():
def __init__(self, *args, **kwargs):
requires_pytorch(self)
def from_pretrained(self, *args, **kwargs):
requires_pytorch(self) |
def resnet152_mpncov_128(pretrained=False, progress=True, **kwargs):
return _resnet_mpncov_128('resnet152_mpncov_128', Bottleneck, [3, 8, 36, 3], pretrained, progress, **kwargs) |
class MaxPooling2DVarPropagationLayer(VarPropagationLayer):
def __init__(self, pooling_layer, use_cov=False, **kwargs):
self.idx = None
super(MaxPooling2DVarPropagationLayer, self).__init__(pooling_layer, use_cov=False, **kwargs)
def _call_diag_cov(self, x):
(pooled, self.idx) = self._po... |
def convolution2D(input_tensor, filters, kernel_size, strides, padding, activation, use_activation=True, use_bias=True, bn=True, if_regularization=False):
assert isinstance(kernel_size, int)
assert isinstance(filters, int)
assert isinstance(strides, tuple)
assert (len(strides) == 2)
assert ((padding... |
def setup_print_for_distributed(is_master):
import builtins as __builtin__
builtin_print = __builtin__.print
def print(*args, **kwargs):
force = kwargs.pop('force', False)
if (is_master or force):
builtin_print(*args, **kwargs)
__builtin__.print = print |
def advance_api_run_func():
res = atorch.init_distributed('gloo', coworker_num_per_node=1)
assert res
data_size = 48
batch_size = 4
dataset = ToyDataset(data_size)
dataloader_args = {'batch_size': batch_size, 'drop_last': True}
sampler = torch.utils.data.distributed.DistributedSampler(datase... |
def train_one_epoch(model: torch.nn.Module, criterion: torch.nn.Module, data_loader: Iterable, optimizer: torch.optim.Optimizer, device: torch.device, epoch: int, max_norm: float=0):
model.train()
criterion.train()
metric_logger = utils.MetricLogger(delimiter=' ')
metric_logger.add_meter('lr', utils.Sm... |
def parse_args():
parser = argparse.ArgumentParser(description='MMDet pytorch model conversion to ONNX')
parser.add_argument('config', help='test config file path')
parser.add_argument('checkpoint', help='checkpoint file')
parser.add_argument('--out', type=str, required=True, help='output ONNX filename'... |
def run():
logging_GOCD.init_logging(log_file_path=param_log_file_path, log_file_mode=param_log_mode)
logging.info('Preparing before training.')
sys.path.append('..')
from symbol_farm import symbol_10_160_17L_4scales_v1 as net
(net_symbol, data_names, label_names) = net.get_net_symbol()
net_init... |
_start_docstrings('\n XLM-RoBERTa Model with a span classification head on top for extractive question-answering tasks like SQuAD (a\n linear layers on top of the hidden-states output to compute `span start logits` and `span end logits`).\n ', XLM_ROBERTA_START_DOCSTRING)
class XLMRobertaForQuestionAnswering(R... |
class TFSeq2SeqLMOutput(ModelOutput):
loss: Optional[tf.Tensor] = None
logits: tf.Tensor = None
past_key_values: Optional[List[tf.Tensor]] = None
decoder_hidden_states: Optional[Tuple[tf.Tensor]] = None
decoder_attentions: Optional[Tuple[tf.Tensor]] = None
encoder_last_hidden_state: Optional[tf.... |
def determine_ip() -> str:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
sock.connect(('10.0.0.0', 1))
ip = sock.getsockname()[0]
except Exception:
ip = '127.0.0.1'
finally:
sock.close()
return ip |
def resnet34(pre_trained_dir=None):
model = ResNet(BasicBlock, [3, 4, 6, 3])
if (pre_trained_dir is None):
return model
state_dict = model_zoo.load_url(M_URLS['resnet34'], model_dir=pre_trained_dir)
model.load_state_dict(state_dict, strict=False)
return model |
def precompute_stats(dataset, save_path, model=None, dims=2048):
from datasets import get_dataset_ref
ref_dataset = get_dataset_ref(dataset)
dataloader = DataLoader(ref_dataset, shuffle=False, batch_size=50)
if (model is None):
block_idx = InceptionV3.BLOCK_INDEX_BY_DIM[dims]
model = Inc... |
class CustomCallback(BaseCallback):
def __init__(self, env: CityLearnEnv, loader: IntProgress):
super().__init__(verbose=0)
self.loader = loader
self.env = env
self.reward_history = [0]
def _on_step(self) -> bool:
if (self.env.time_step == 0):
self.reward_hist... |
class AgentSupplyBattle():
def __init__(self, episode_info) -> None:
self.episode_info = episode_info
def act(self, ts: int, state: AgentState) -> SupplyBattleAction:
pos = np.asarray(get_position(state))
if state.supply_states:
supply_info = list(state.supply_states.values()... |
def main():
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(dest='subcommand', help='The action to perform.')
evaluate_pool_ranks = subparsers.add_parser('eval_pool_ranking')
evaluate_pool_ranks.add_argument('--gold_path', required=True, help='Path with gold data; Where the annotat... |
def _is_chinese_char(cp):
if (((cp >= 19968) and (cp <= 40959)) or ((cp >= 13312) and (cp <= 19903)) or ((cp >= 131072) and (cp <= 173791)) or ((cp >= 173824) and (cp <= 177983)) or ((cp >= 177984) and (cp <= 178207)) or ((cp >= 178208) and (cp <= 183983)) or ((cp >= 63744) and (cp <= 64255)) or ((cp >= 194560) and... |
def main(opts):
if os.path.exists(opts.exp_dir):
raise Exception('Oops... {} already exists'.format(opts.exp_dir))
os.makedirs(opts.exp_dir, exist_ok=True)
opts_dict = vars(opts)
pprint.pprint(opts_dict)
with open(os.path.join(opts.exp_dir, 'opt.json'), 'w') as f:
json.dump(opts_dict... |
class SequentialWrapperTwice(SequentialWrapper):
def __init__(self, com_transform: _pil2pil_transform_type=None, image_transform: _pil2tensor_transform_type=pil_augment.ToTensor(), target_transform: _pil2tensor_transform_type=pil_augment.ToLabel(), total_freedom=True) -> None:
super().__init__(com_transform... |
class FeedForwardNetwork(Layer):
def __init__(self, hidden_size, filter_size, relu_dropout, bigdl_type='float'):
super(FeedForwardNetwork, self).__init__(None, bigdl_type, hidden_size, filter_size, relu_dropout) |
def log_results(result: Dataset, args: Dict[(str, str)]):
log_outputs = args.log_outputs
dataset_id = '_'.join((args.dataset.split('/') + [args.config, args.split]))
wer = load_metric('wer')
cer = load_metric('cer')
wer_result = wer.compute(references=result['target'], predictions=result['prediction... |
def rm_key_from_odict(odict_obj, rm_suffix):
return OrderedDict([(k, v) for (k, v) in odict_obj.items() if (rm_suffix not in k)]) |
class SEWDConfig(PretrainedConfig):
model_type = 'sew-d'
def __init__(self, vocab_size=32, hidden_size=768, num_hidden_layers=12, num_attention_heads=12, intermediate_size=3072, squeeze_factor=2, max_position_embeddings=512, position_buckets=256, share_att_key=True, relative_attention=True, position_biased_inpu... |
class CoreDiffusion(nn.Module):
input_dim: int
output_dim: int
layer_num: int
bias: bool
rnn_type: str
def __init__(self, input_dim, output_dim, core_num=1, bias=True, rnn_type='GRU'):
super(CoreDiffusion, self).__init__()
self.input_dim = input_dim
self.output_dim = outp... |
def main():
args = parse_args()
print('==> Load dataset ...')
(X, y) = read_data(args.dataroot, debug=False)
print('==> Initialize DA-RNN model ...')
model = DA_RNN(X, y, args.ntimestep, args.nhidden_encoder, args.nhidden_decoder, args.batchsize, args.lr, args.epochs)
print('==> Start training .... |
class RuleRefitter():
def __init__(self, quantitative_dataframe):
self.__dataframe = quantitative_dataframe
def transform(self, rules):
copied_rules = [rule.copy() for rule in rules]
refitted = [self.__refit(rule) for rule in copied_rules]
return refitted
def __refit(self, ru... |
def get_dataset(dataset):
if ((dataset == 'cifar10') or (dataset == 'cifar100')):
image_size = (32, 32, 3)
transform = transforms.ToTensor()
if (dataset == 'cifar10'):
data = datasets.CIFAR10
else:
data = datasets.CIFAR100
train_set = data(DATA_PATH, t... |
def _sorted(dict_):
try:
return sorted(six.iterkeys(dict_))
except TypeError:
invalidInputError(False, 'nest only supports dicts with sortable keys.') |
class TerminalRenderer(Renderer):
def __init__(self, col_sep=' '):
super().__init__()
self.col_sep = col_sep
def render_cell(self, table, row, col, widths):
cell = table.rows[row].cells[col]
str = (cell.fmt.fmt % cell.data)
str_width = len(str)
cell_width = sum([w... |
def video_from_sequence(input_dir, output_file, reference_file=None, ext=None, fps=None, bitrate=None, include_audio=False, lossless=None):
input_path = Path(input_dir)
output_file_path = Path(output_file)
reference_file_path = (Path(reference_file) if (reference_file is not None) else None)
if (not inp... |
def build_dataset_from_cfg(cfg, default_args=None):
return DATASETS.build(cfg, default_args=default_args) |
def load_tests(loader, tests, ignore):
tests.addTests(doctest.DocTestSuite(infinibatch.iterators))
return tests |
def main(data_shape, config_file, mobile_name):
cfg = get_cfg_defaults()
cfg.merge_from_file(config_file)
np.random.seed(cfg.RNG_SEED)
torch.manual_seed(cfg.RNG_SEED)
torch.backends.cudnn.deterministic = False
torch.backends.cudnn.benchmark = True
cpu_device = torch.device('cpu')
model =... |
class SetPosition(abstract_action_space.AbstractActionSpace):
def __init__(self, action_layers='agent', inertia=0.0):
if (not isinstance(action_layers, (list, tuple))):
action_layers = (action_layers,)
self._action_layers = action_layers
self._inertia = inertia
self._acti... |
class TestOptions(BaseOptions):
def initialize(self):
BaseOptions.initialize(self)
self.parser.add_argument('--ntest', type=int, default=float('inf'), help='# of test examples.')
self.parser.add_argument('--results_dir', type=str, default='./results/', help='saves results here.')
sel... |
class SeparableConv2d(nn.Module):
def __init__(self, inplanes, planes, kernel_size=3, stride=1, dilation=1, relu_first=True, bias=False, norm_layer=nn.BatchNorm2d):
super().__init__()
depthwise = nn.Conv2d(inplanes, inplanes, kernel_size, stride=stride, padding=dilation, dilation=dilation, groups=in... |
class experiment_testcase(unittest.TestCase):
def test_experiment_and_writeup_cp(self):
experiment.run_experiment_file('../experiments/debug/debug_changepoint.py')
postprocessing.make_all_1d_figures(['../results/debug-changepoint/'], '../analyses/debug-changepoint/figures/', rescale=False, data_fold... |
class TestLADHead(TestCase):
def test_lad_head_loss(self):
class mock_skm():
def GaussianMixture(self, *args, **kwargs):
return self
def fit(self, loss):
pass
def predict(self, loss):
components = np.zeros_like(loss, dtype=n... |
def add_journal_subfield(field, element, reference_format):
add_subfield(field, 'journal_title', element.get('title'))
add_subfield(field, 'journal_volume', element.get('volume'))
add_subfield(field, 'journal_year', element.get('year'))
add_subfield(field, 'journal_page', element.get('page'))
add_su... |
class GenerateGraphWithQDQPattern(GraphRewriterBase):
def __init__(self, model, calibration_data, op_wise_config, fake_quant, fp32_ops, bf16_ops, quantized_nodes, device, performance_only, itex_mode, llm_weight_minmax):
super().__init__(model)
self.data = calibration_data
self.op_wise_config... |
def combine_predictions(fname_lst, fname_hard, fname_prob, thr=0.5):
mc_data = np.array([nib.load(fname).get_fdata() for fname in fname_lst])
first_file_header = nib.load(fname_lst[0]).header
data_prob = np.mean(mc_data, axis=0)
nib_prob = nib.Nifti1Image(dataobj=data_prob, affine=first_file_header.get_... |
_config
def model_pix_only_base():
n_channels_out = 3
cfg = {'learner': {'model': 'GenericSidetuneNetwork', 'model_kwargs': {'n_channels_in': 3, 'n_channels_out': n_channels_out, 'base_class': 'TaskonomyEncoder', 'base_weights_path': None, 'base_kwargs': {'train': True, 'eval_only': False, 'normalize_outputs': ... |
_metaclass(ABCMeta)
class DatasetPredictorBase(object):
def __init__(self, config, dataset):
assert isinstance(dataset, DataFlow)
assert isinstance(config, PredictConfig)
self.config = config
self.dataset = dataset
def get_result(self):
pass
def get_all_result(self):
... |
(DataGeneration)
class EvaluateGradientVariance(AutoNamingTask):
EvaluateGradientVariance_params = luigi.DictParameter()
train_seed = luigi.IntParameter()
def run_task(self, input_list):
(_, train_po_history_list, _, _, _) = input_list[0]
train_model = get_initial_model(self.EvaluateGradient... |
class FILTERS(object):
def __init__(self, framework):
assert (framework in ['tensorflow', 'tensorflow_itex', 'keras', 'mxnet', 'onnxrt_qdq', 'pytorch', 'pytorch_ipex', 'pytorch_fx', 'onnxrt_integerops', 'onnxrt_qlinearops', 'onnxruntime']), 'framework support tensorflow pytorch mxnet onnxrt'
self.fi... |
_cache()
def split_request(start_dt: str, end_dt: str, player_id: int, url: str) -> pd.DataFrame:
current_dt = datetime.strptime(start_dt, '%Y-%m-%d')
end_dt_datetime = datetime.strptime(end_dt, '%Y-%m-%d')
results = []
player_id_str = str(player_id)
print('Gathering Player Data')
while (current... |
def save_data(data, loc, header):
df = pd.DataFrame(data=data, columns=header)
df.fillna('')
df.to_csv(loc, index=False, encoding='utf-8')
return None |
def parse_opts():
learning_policy = '2stream'
validate_policy = '2stream'
parser = argparse.ArgumentParser()
parser.add_argument('--root_path', default='./data/', type=str, help='Root directory path of data')
parser.add_argument('--dataset_path', default='ori_data/', type=str, help='Directory path o... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.