code stringlengths 101 5.91M |
|---|
class AsyncRenderManager():
def __init__(self):
self._closed = False
self._is_async = False
self._cur_args = None
self._cur_result = None
self._cur_stamp = 0
self._renderer_obj = None
self._args_queue = None
self._result_queue = None
self._proc... |
class Vocab(defaultdict):
def __init__(self, train=True):
super().__init__((lambda : len(self)))
self.train = train
self.UNK = 'UNK'
self[self.UNK]
self.idx2w = self.update_idx2w()
def update_idx2w(self):
self.idx2w = dict([(i, w) for (w, i) in self.items()])
... |
def assert_tensor_eq(real, expected, eps=EPS):
assert (torch.abs((real - expected)) < eps).all(), ('%s (true) vs %s (expected)' % (real, expected)) |
class CountingIterator(object):
def __init__(self, iterable, start=None, total=None):
self.iterable = iterable
self.itr = iter(self)
if (start is None):
self.n = getattr(iterable, 'n', 0)
else:
self.n = start
if (total is None):
self.total ... |
class STL10Tester(DatasetTestcase):
def mocked_root(self):
with stl10_root() as (root, data):
(yield (root, data))
def mocked_dataset(self, pre_extract=False, download=True, **kwargs):
with self.mocked_root() as (root, data):
if pre_extract:
utils.extract_... |
def gelu(x: torch.Tensor) -> torch.Tensor:
return ((x * 0.5) * (1.0 + torch.erf((x / math.sqrt(2.0))))) |
def extract_seconds(input_file, output_file):
with open(input_file, 'r') as f:
lines = f.readlines()
log_created_year = get_log_created_year(input_file)
start_datetime = get_start_time(lines, log_created_year)
assert start_datetime, 'Start time not found'
last_dt = start_datetime
out = o... |
def _non_dist_train(model, dataset, cfg, validate=False):
data_loaders = [build_dataloader(dataset, cfg.data.imgs_per_gpu, cfg.data.workers_per_gpu, cfg.gpus, dist=False)]
model = MMDataParallel(model, device_ids=range(cfg.gpus)).cuda()
runner = Runner(model, batch_processor, cfg.optimizer, cfg.work_dir, cf... |
def update_moving_average(ema_updater, ma_model, current_model):
for (current_params, ma_params) in zip(current_model.parameters(), ma_model.parameters()):
(old_weight, up_weight) = (ma_params.data, current_params.data)
ma_params.data = ema_updater.update_average(old_weight, up_weight) |
def parse_args():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--data-file', type=str, default='_output/data.pkl')
parser.add_argument('--out-file', type=str, default='_output/restrict_data.pkl')
parser.add_argument('--max-relevant-idx', type=int, default=6)
args = pars... |
class WIKIPEDIA5MProcessor(BaseProcessor):
def __init__(self, node_lut, relation_lut):
super().__init__(data_name='WIKIPEDIA5M', node_lut=node_lut, relation_lut=relation_lut) |
def get_bond_features(mol, mono=False):
m = Chem.MolFromSmiles(mol)
atom_list = m.GetAtoms()
bond_features = []
for i in range(len(atom_list)):
bond_vector = []
for j in range(len(atom_list)):
bond = m.GetBondBetweenAtoms(i, j)
if mono:
bf = [float... |
class AccuracyOfEpochMonitorSegmentation(object):
NA_PATTERN = 'N/A'
def __init__(self, log, training0orValidation1, epoch, numberOfClasses, numberOfSubepochsPerEpoch):
self.log = log
self.training0orValidation1 = training0orValidation1
self.epoch = epoch
self.numberOfClasses = n... |
def adjust_widths_groups_comp(widths, bottle_ratios, groups):
bottleneck_widths = [int((w * b)) for (w, b) in zip(widths, bottle_ratios)]
groups = [min(g, w_bot) for (g, w_bot) in zip(groups, bottleneck_widths)]
bottleneck_widths = [quantize_float(w_bot, g) for (w_bot, g) in zip(bottleneck_widths, groups)]
... |
_module()
class DeepGCN(nn.Module):
def __init__(self, in_channels=3, channels=64, emb_dims=1024, n_blocks=14, conv='edge', block='res', k=16, epsilon=0.2, use_stochastic=True, use_dilation=True, norm_args={'norm': 'bn'}, act_args={'act': 'relu'}, conv_args={'order': 'conv-norm-act'}, is_seg=False, **kwargs):
... |
def main(args):
if (args.apex and (amp is None)):
raise RuntimeError('Failed to import apex. Please install apex from to enable mixed-precision training.')
if args.output_dir:
utils.mkdir(args.output_dir)
utils.init_distributed_mode(args)
print(args)
device = torch.device(args.devic... |
_arg_scope
def fully_connected(inputs, num_outputs, activation_fn=nn.relu, normalizer_fn=None, normalizer_params=None, weights_initializer=initializers.xavier_initializer(), weights_regularizer=None, biases_initializer=init_ops.zeros_initializer(), biases_regularizer=None, reuse=None, variables_collections=None, output... |
class ControlNetSimpleInpaintPipelineFastTests(ControlNetInpaintPipelineFastTests):
pipeline_class = StableDiffusionControlNetInpaintPipeline
params = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
batch_params = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
image_params = frozenset([])
def get_dummy_components(se... |
class Network(Dot):
def __init__(self):
Dot.__init__(self, 'SimConf', graph_type='graph')
self.node_list = []
def _init_addr_helper(self):
ipv4_net_addr_base = self.net_desc.get('ipv4_net_addr_base', '10.0.7.4/24')
(addr, network, mask) = CIDR_to_subnet_mask(ipv4_net_addr_base)
... |
def random_batch(batch_size, train_data, singletons=[]):
input_seqs = []
target_seqs = []
chars2_seqs = []
for i in range(batch_size):
data = random.choice(train_data)
words = []
for word in data['words']:
if ((word in singletons) and (np.random.uniform() < 0.5)):
... |
def dwconv3x3(in_channels, out_channels, stride, bias=False):
return nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=3, stride=stride, padding=1, groups=out_channels, bias=bias) |
def make_parser():
parser = options.get_speech_generation_parser()
options.add_generation_args(parser)
parser.add_argument('--generator-type', type=str, choices=['at_tts', 'at_s2s', 'nat_tts', 'nat_s2s'], help='which type of generator to use')
return parser |
class TestDenseLayout(QiskitTestCase):
def setUp(self):
self.cmap20 = FakeTokyo().configuration().coupling_map
def test_5q_circuit_20q_coupling(self):
qr = QuantumRegister(5, 'q')
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[3])
circuit.cx(qr[3], qr[4])
circu... |
def merge_all_modules():
modules = os.listdir(DATASET_DIR)
print('Starting to merge {} modules.'.format(len(modules)))
target_dir = os.path.join(DATASET_DIR, ALL_MODULE_NAME)
if os.path.exists(target_dir):
print('Merge module {} already exists?!'.format(target_dir))
print('Exiting.')
... |
.parametrize('alpha_parameter', [0.5, 0.7, 0.1, 30.0])
def test_gradients_inverted_alpha(alpha_parameter):
network = torch.nn.Sequential(torch.nn.Linear(5, 3), torch.nn.Linear(3, 1))
revnetwork = torch.nn.Sequential(copy.deepcopy(network), RevGrad(alpha=alpha_parameter))
inp = torch.randn(8, 5)
outp = t... |
def evaluate_written_preds(gold_dir, prediction_dir):
ae_gold = [list(np.array(line.strip().split(), dtype=int)) for line in open(os.path.join(gold_dir, 'target.txt'))]
ae_pred = [np.array(line.strip().split(), dtype=int) for line in open(os.path.join(prediction_dir, 'target.txt'))]
sent_gold = [np.array(li... |
class Human36mSkeleton(Skeleton):
def __init__(self, parents, joints_left, joints_right):
super().__init__(parents, joints_left, joints_right)
self.kpt_name = ['mid_hip', 'right_hip', 'right_knee', 'right_ankle', 'left_hip', 'left_knee', 'left_ankle', 'mid_spine', 'neck', 'chin', 'head', 'left_shoul... |
def get_cmd_prefix(core_list):
return 'OMP_NUM_THREADS={} numactl --localalloc --physcpubind={} '.format(len(core_list), ','.join(core_list.astype(str))) |
def predict():
net = load_net()
(images, labels) = load_drive()
transform = transforms.Compose([transforms.ToTensor()])
with torch.no_grad():
net.eval()
for i in range(len(images)):
print(images[i])
name_list = images[i].split('/')
index = name_list[(-... |
def get_apu_version(enable_apu, android_ver, target_soc):
if enable_apu:
android_ver = int(android_ver)
if (android_ver <= 10):
target_soc = target_soc.lower()
if target_soc.startswith('mt67'):
return 1
else:
return 2
elif (... |
class HumanoidRandDirecEnv(MetaEnv, gym.utils.EzPickle, MujocoEnv):
def __init__(self):
self.set_task(self.sample_tasks(1)[0])
MujocoEnv.__init__(self, 'humanoid.xml', 5)
gym.utils.EzPickle.__init__(self)
def sample_tasks(self, n_tasks):
return np.random.choice(((- 1.0), 1.0), (n... |
def extract_features(in_audios, out_files, deepspeech_pb_path, metainfo_file_path=None):
if (metainfo_file_path is None):
num_frames_info = ([None] * len(in_audios))
else:
train_df = pd.read_csv(metainfo_file_path, sep='\t', index_col=False, dtype={'Id': np.int, 'File': np.unicode, 'Count': np.i... |
class TestMXNetModel(unittest.TestCase):
def setUpClass(self):
if (platform.system().lower() == 'windows'):
self.skipTest(self, 'not support mxnet on windows yet')
import mxnet as mx
import mxnet.gluon.nn as nn
net = nn.HybridSequential()
net.add(nn.Dense(128, act... |
.xfail(reason='torch.as_strided is not supported by ONNX')
.parametrize('training', [True, False, None])
def test_cplx_interleaved_casting_onnx_export(training):
module = torch.nn.Sequential(casting.InterleavedRealToCplx(), nn.CplxIdentity(), casting.CplxToInterleavedReal())
input = torch.randn(2, 16, 256)
... |
def data_split(src_list):
counter_list = random.sample(range(0, len(src_list)), 550)
return counter_list |
def extract_file(downloaded_file, extract_folder, get_extract_name=get_extract_name, debug=False):
extract_name = get_extract_name(downloaded_file)
extract_to = f'{extract_folder}/{extract_name}'
os.makedirs(extract_to, exist_ok=True)
if os.path.exists(f'{extract_to}/DONE'):
print(f'{downloaded_... |
_registry(op_types='QLinearAdd, QLinearMul')
class QBinaryOperator(QOperator):
def __init__(self, onnx_node, children, initializers):
super().__init__(onnx_node, children, initializers)
def convert(self):
node = self.node
add_nodes = []
inits = []
in_dq1 = onnx.helper.mak... |
def _set_object(world, pos, player, tunnels):
(x, y) = pos
uniform = world.random.uniform
dist = np.sqrt((((x - player.pos[0]) ** 2) + ((y - player.pos[1]) ** 2)))
(material, _) = world[(x, y)]
if (material not in constants.walkable):
pass |
def extract_instruction_tokens(observations: List[Dict], instruction_sensor_uuid: str, tokens_uuid: str='tokens') -> Dict[(str, Any)]:
if ((instruction_sensor_uuid not in observations[0]) or (instruction_sensor_uuid == 'pointgoal_with_gps_compass')):
return observations
for i in range(len(observations))... |
def export_split(split, src, dst, overwrite=False):
print(f'-> Exporting "{split}" split...')
dst = (dst / split)
io.mkdirs(dst)
seqs = io.get_dirs((src / split))
dsts = [(dst / s.stem) for s in seqs]
ovs = [overwrite for _ in seqs]
with Pool(8) as p:
for _ in tqdm(p.imap_unordered(e... |
class MCmodel(nn.Module):
def __init__(self, data):
super(MCmodel, self).__init__()
self.gpu = data.HP_gpu
self.use_char = data.use_char
self.model1_fc_dropout = data.HP_model1_dropout
self.model1_in_dropout = data.HP_bayesian_lstm_dropout[0]
self.bilstm_flag = data.H... |
class ClicEdmSinglePi0HitsPf(tfds.core.GeneratorBasedBuilder):
VERSION = tfds.core.Version('1.5.0')
RELEASE_NOTES = {'1.1.0': 'Remove track referencepoint feature', '1.2.0': 'Keep all interacting genparticles', '1.5.0': 'Regenerate with ARRAY_RECORD'}
MANUAL_DOWNLOAD_INSTRUCTIONS = '\n For the raw input ... |
def make_roi_mask_predictor(cfg, in_channels):
func = registry.ROI_MASK_PREDICTOR[cfg.MODEL.ROI_MASK_HEAD.PREDICTOR]
return func(cfg, in_channels) |
class BaselineImageImputer(ImageImputer):
def __init__(self, model, baseline, width, height, superpixel_size, link=None):
super().__init__(width, height, superpixel_size)
self.model = model
self.baseline = baseline
if (link is None):
self.link = nn.Identity()
elif... |
def get_key_to_ground_truth(data):
if (data['Domain'] == 'Wikipedia'):
return {datum['QuestionId']: datum['Answer'] for datum in data['Data']}
else:
return get_qd_to_answer(data) |
class tracker():
_init_args
def __init__(self, names):
assert (len(names) > 0)
self.reset()
def __getitem__(self, name):
return ((self.values.get(name, 0) / self.counter) if self.counter else 0)
def __len__(self):
return len(self.names)
def reset(self):
self.v... |
_HEADS_REGISTRY.register()
class PointRendROIHeads(StandardROIHeads):
_version = 2
def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs):
version = local_metadata.get('version', None)
if ((version is None) or (version < 2)):
... |
class Block35(nn.Module):
def __init__(self, scale=1.0):
super().__init__()
self.scale = scale
self.branch0 = BasicConv2d(256, 32, kernel_size=1, stride=1)
self.branch1 = nn.Sequential(BasicConv2d(256, 32, kernel_size=1, stride=1), BasicConv2d(32, 32, kernel_size=3, stride=1, padding... |
def _segm_lraspp_mobilenetv3(backbone_name, num_classes, pretrained_backbone=True):
backbone = mobilenetv3.__dict__[backbone_name](pretrained=pretrained_backbone, _dilated=True).features
stage_indices = (([0] + [i for (i, b) in enumerate(backbone) if getattr(b, '_is_cn', False)]) + [(len(backbone) - 1)])
lo... |
class AbstractDataManager():
__metaclass__ = abc.ABCMeta
def __init__(self, name: str):
self._data = dict()
self._info = dict()
self._name = name
def name(self) -> str:
return self._name
def data(self) -> Dict[(str, np.ndarray)]:
return self._data
def info(sel... |
def main():
parser = argparse.ArgumentParser(description='Convert keys from jax official pretrained vit models to MMSegmentation style.')
parser.add_argument('src', help='src model path or url')
parser.add_argument('dst', help='save path')
args = parser.parse_args()
jax_weights = np.load(args.src)
... |
class Convolution(nn.Module):
def __init__(self, c_in, c_out):
super().__init__()
self.conv = nn.Conv2d(c_in, c_out, 3, stride=1, padding=1)
self.relu = nn.ReLU(True)
def forward(self, x):
return self.relu(self.conv(x)) |
def test_grid_to_int_index_wrong_shape(data):
with pytest.raises(ValueError):
data.archive.grid_to_int_index([data.grid_indices[:(- 1)]]) |
def merge_eval(main_eval, new_eval, prefix):
for k in new_eval:
main_eval[f'{prefix}_{k}'] = new_eval[k] |
class BigBirdPegasusForQuestionAnswering(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
class HalfCheetahEnv(mujoco_env.MujocoEnv, utils.EzPickle):
def __init__(self):
self.prev_qpos = None
dir_path = os.path.dirname(os.path.realpath(__file__))
mujoco_env.MujocoEnv.__init__(self, ('%s/assets/half_cheetah.xml' % dir_path), 5)
utils.EzPickle.__init__(self)
def _step(s... |
def Brightness(img, v):
assert (0.1 <= v <= 1.9)
return PIL.ImageEnhance.Brightness(img).enhance(v) |
class GradientAggregationOptimizer(tf.train.Optimizer):
def __init__(self, opt: tf.train.Optimizer, grad_steps: int, apply_crs_to_grad=False, xla_num_partitions=None, use_tpu=False):
self._opt = opt
self._grad_steps = grad_steps
self._counter = None
self._use_tpu = use_tpu
se... |
def plot_pies(data, color_mapping, pie_labels, subdirectory_names):
nrow = len(subdirectory_names)
ncol = int((len(data) / len(subdirectory_names)))
(fig, axs) = plt.subplots(nrow, ncol)
for (i, key) in enumerate(sorted(data.keys())):
axs[((i // ncol), (i % ncol))].pie(data[key], labels=['DRL', ... |
def torch_distributed_zero_first(*args, **kwargs):
requires_pytorch(torch_distributed_zero_first) |
def example_TEBD_gs_finite(L, J, g):
print('finite TEBD, (imaginary time evolution)')
print('L={L:d}, J={J:.1f}, g={g:.2f}'.format(L=L, J=J, g=g))
import a_mps
import b_model
model = b_model.TFIModel(L, J=J, g=g)
psi = a_mps.init_spinup_MPS(L)
for dt in [0.1, 0.01, 0.001, 0.0001, 1e-05]:
... |
def generate_statistics(dataset_directory_path):
generate_statistics_file(dataset_directory_path) |
def add_nnet_context_info(config_dir, nnet_edits=None, existing_model=None):
common_lib.execute_command('nnet3-init {0} {1}/ref.config {1}/ref.raw'.format((existing_model if (existing_model is not None) else ''), config_dir))
model = '{0}/ref.raw'.format(config_dir)
if (nnet_edits is not None):
mode... |
def init_logger(log_file, log_file_level=logging.NOTSET, log_level=logging.INFO):
if isinstance(log_file_level, str):
log_file_level = getattr(logging, log_file_level)
if isinstance(log_level, str):
log_level = getattr(logging, log_level)
log_format = logging.Formatter('[\x1b[032m%(asctime)s... |
def get_learning_rate_multipliers(model, alpha=0):
layer_names = get_kernel_layer_names(model)
if (alpha > 0.0):
mult = ((1 - alpha) ** (5 / (len(layer_names) - 1)))
multipliers = dict(zip(layer_names, [(mult ** ((len(layer_names) - 1) - i)) for i in range(len(layer_names))]))
elif (alpha <=... |
class NAG(Optimizer):
def __init__(self, params, lr=required, momentum=0, weight_decay=0):
defaults = dict(lr=lr, lr_old=lr, momentum=momentum, weight_decay=weight_decay)
super(NAG, self).__init__(params, defaults)
def supports_memory_efficient_fp16(self):
return True
def supports_fl... |
class Kernel(MeasOpts):
def __init__(self, name=None, **params):
super().__init__(name, **params) |
def particle_has_track(g, particle):
for e in g.edges(particle):
if (e[1][0] == 'track'):
return True
return False |
def main(unused_argv):
assert (not (FLAGS.train_shards % FLAGS.num_threads)), 'please make the FLAGS.num_threads commersurate with FLAGS.train_shards'
assert (not (FLAGS.valid_shards % FLAGS.num_threads)), 'please make the FLAGS.num_threads commensurate with FLAGS.valid_shards'
assert (not (FLAGS.test_shard... |
def group_weight(model):
(group_decay, group_no_decay) = ([], [])
for params in model.named_parameters():
if ('transformer' in params[0]):
if (('bias' in params[0]) or ('norm' in params[0])):
group_no_decay.append(params[1])
continue
group_decay.append... |
class BaseSampler():
def __init__(self, data, n_samples=1, device='cpu'):
assert isinstance(data, dict), 'you must pass a dict with your data'
self.device = device
self.data = data
self.vars = tuple(data.keys())
self.n_samples = n_samples
def _sample(self, n_samples=None)... |
class VarianceThreshold(AutotabularPreprocessingAlgorithm):
def __init__(self, random_state: Optional[np.random.RandomState]=None):
self.random_state = random_state
def fit(self, X: PIPELINE_DATA_DTYPE, y: Optional[PIPELINE_DATA_DTYPE]=None) -> 'VarianceThreshold':
self.preprocessor = sklearn.fe... |
def tryCreatePartition(numCoresPerAxis, coreShape, postLayerPartition, layer, logdir):
output_shape = (layer._output_shape3D if hasattr(layer, '_output_shape3D') else layer.output_shape)
outputShape = output_shape[1:]
if hasattr(layer, 'signed'):
if layer.signed:
outputShape = (outputSha... |
class TestPytorchAdaptor(unittest.TestCase):
framework_specific_info = {'device': 'cpu', 'approach': 'post_training_static_quant', 'random_seed': 1234, 'q_dataloader': None, 'workspace_path': './'}
framework = 'pytorch'
adaptor = FRAMEWORKS[framework](framework_specific_info)
model = q_resnet18()
nc... |
class MemoryEfficientFP16Optimizer(_MemoryEfficientFP16OptimizerMixin, optim.FairseqOptimizer):
def __init__(self, cfg: DictConfig, params, optimizer, **kwargs):
if (not optimizer.supports_memory_efficient_fp16):
raise ValueError('Unsupported optimizer: {}'.format(optimizer.__class__.__name__))
... |
def test_watershed_saddle_basin():
saddle_landscape = np.array([[0, 0, 3], [2, 1, 2], [0, 0, 3]])
saddle_result = np.array([[1, 1, 1], [0, 0, 0], [2, 2, 2]])
saddle_ws = morpho.watershed(saddle_landscape, dams=True)
assert_array_equal(saddle_ws, saddle_result) |
class PreResNet(nn.Module):
def __init__(self, depth, num_classes=1000, block_name='BasicBlock'):
super(PreResNet, self).__init__()
if (block_name.lower() == 'basicblock'):
assert (((depth - 2) % 6) == 0), 'When use basicblock, depth should be 6n+2, e.g. 20, 32, 44, 56, 110, 1202'
... |
def test_d0_conf_note_report_number():
ref_line = u'[4] D0 Collaboration, D0 Note 6417-CONF (2015)'
res = get_references(ref_line)
references = res[0]
assert (references[0]['reportnumber'] == [u'D0-Note-6417-CONF'])
assert (references[0]['linemarker'] == [u'4']) |
class ColorDenseCRFLoss(nn.Module):
def __init__(self, weight, sigma_rgb, scale_factor):
super(ColorDenseCRFLoss, self).__init__()
self.weight = weight
self.sigma_rgb = sigma_rgb
self.scale_factor = scale_factor
def forward(self, images, segmentations):
assert (images.ndi... |
class Resize(object):
def __init__(self, size):
self.size = size
def __call__(self, vid):
return resize(vid, self.size) |
class CrossEntropyLabelSmooth(nn.Module):
def __init__(self, num_classes, epsilon):
super(CrossEntropyLabelSmooth, self).__init__()
self.num_classes = num_classes
self.epsilon = epsilon
self.logsoftmax = nn.LogSoftmax(dim=1)
def forward(self, inputs, targets):
log_probs =... |
def test_result_of_conf_dict_is_not_dogmatic(conf_dict):
cfg = conf_dict({'e': [1, 1, 1]})
assert (not is_dogmatic(cfg)) |
def extract_vel_from_state(state: X) -> float:
try:
vel = state.vx
return vel
except AttributeError:
msg = 'Unable to extract vel from state'
raise ZValueError(msg=msg, state=state, state_type=type(state)) |
_grad()
def inference(weight, name, img):
if (img is None):
img = np.random.randint(0, 255, size=(112, 112, 3), dtype=np.uint8)
else:
img = cv2.imread(img)
img = cv2.resize(img, (112, 112))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = np.transpose(img, (2, 0, 1))
img = to... |
def save_ckpt(output_dir, args, step, train_size, model, optimizer):
if args.no_save:
return
ckpt_dir = os.path.join(output_dir, 'ckpt')
if (not os.path.exists(ckpt_dir)):
os.makedirs(ckpt_dir)
save_name = os.path.join(ckpt_dir, 'model_step{}.pth'.format(step))
if isinstance(model, m... |
def FPN(backbone_name='vgg16', input_shape=(None, None, None, 3), classes=21, activation='softmax', weights=None, encoder_weights='imagenet', encoder_freeze=False, encoder_features='default', pyramid_block_filters=256, pyramid_use_batchnorm=True, pyramid_aggregation='concat', pyramid_dropout=None, **kwargs):
global... |
def plotgeneral(fig):
axs = fig.gca()
center = (3, 2)
radius = 1
circle = plt.Circle(center, radius, edgecolor='blue', facecolor='none')
axs.add_artist(circle)
plt.plot([0, 4], [0, 4], 'r')
plt.plot([2, 3], [2, 3], 'go')
plt.axis([0, 5, 0, 4]) |
class cLSTM(nn.Module):
def __init__(self, input_size, hidden_size, num_layers=2):
super().__init__()
self.lstm = nn.LSTM(input_size, hidden_size, num_layers)
def forward(self, features, init_hidden=None):
self.lstm.flatten_parameters()
(output, (h_n, c_n)) = self.lstm(features, ... |
class GmmPolicy(AbstractPolicy):
def __init__(self, dataset):
pass
'\n Compute features if actor id is nonzero; use world\n '
def __call__(self, world, state, actor):
pass |
def test_statcast_catcher_poptime() -> None:
min_2b_att = 5
min_3b_att = 0
result: pd.DataFrame = statcast_catcher_poptime(2019, min_2b_att, min_3b_att)
assert (result is not None)
assert (not result.empty)
assert (len(result.columns) == 14)
assert (len(result) > 0)
assert (len(result.lo... |
def test_global_var():
run_cell('x = 0')
run_cell('def f(): global x; x = 42')
run_cell('f()')
run_cell('assert x == 42') |
class OcoGradEstimation():
def __init__(self, k_min, k_max):
self.k_min_orig = k_min
self.k_max_orig = k_max
self.k_min = k_min
self.k_max = k_max
self.d = (k_max - k_min)
self.delta = 0.1
self.min_max_update_window = 20
self.alpha = 1.5
self.m... |
def build(region_similarity_calculator_config):
if (not isinstance(region_similarity_calculator_config, region_similarity_calculator_pb2.RegionSimilarityCalculator)):
raise ValueError('region_similarity_calculator_config not of type region_similarity_calculator_pb2.RegionsSimilarityCalculator')
similari... |
def rescale_centercrop_resize(output_size, dtype=np.float32):
def _rescale_centercrop_resize_thunk(obs_space):
obs_shape = obs_space.shape
obs_min_wh = min(obs_shape[:2])
assert (obs_min_wh > 10), 'are you sure your data format is correct? is your min wh really < 10?'
output_wh = out... |
def get_generic_path_information(paths, stat_prefix=''):
statistics = OrderedDict()
returns = [sum(path['rewards']) for path in paths]
rewards = np.vstack([path['rewards'] for path in paths])
statistics.update(create_stats_ordered_dict('Rewards', rewards, stat_prefix=stat_prefix))
statistics.update(... |
def compute_em_score(prediction, ground_truth):
return (1.0 if (prediction == ground_truth) else 0.0) |
def load_json_file(fileName: str) -> DataInstance:
with open(fileName, 'r') as read_file:
JSONdata = json.load(read_file).get('layouts')[0]
fileString = os.path.basename(fileName)
data = dict_to_datainstance(JSONdata)
data.inputFile = os.path.splitext(fileString)[0]
print('Lo... |
def __gather_predictions(predictions_list: list, labels: list) -> list:
results = []
for prediction in predictions_list:
results += __rnnt_decoder_predictions_tensor(prediction, labels=labels)
return results |
def visualize():
result_path = 'demo_result.mat'
mat = scipy.io.loadmat(result_path)
x_sample = mat['X_test']
y_pred = mat['Y_test_pred']
y_true = mat['Y_test_true']
th = 0.5
y_pred[(y_pred >= th)] = 1
y_pred[(y_pred < th)] = 0
tools.Data.plotFromVoxels(x_sample, title='x_sample')
... |
class joint_set():
leaf = [7, 8, 12, 20, 21]
full = list(range(1, 24))
reduced = [1, 2, 3, 4, 5, 6, 9, 12, 13, 14, 15, 16, 17, 18, 19]
ignored = [0, 7, 8, 10, 11, 20, 21, 22, 23]
lower_body = [0, 1, 2, 4, 5, 7, 8, 10, 11]
lower_body_parent = [None, 0, 0, 1, 2, 3, 4, 5, 6]
n_leaf = len(leaf)
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.