code stringlengths 101 5.91M |
|---|
def parse_arguments():
parser = argparse.ArgumentParser()
parser.add_argument('--input_model', type=str, required=False, default='vgg16-12.onnx')
parser.add_argument('--output_model', type=str, required=True)
return parser.parse_args() |
def main():
global args
args = parser.parse_args()
model = models.__dict__[args.arch]()
print(model)
input = torch.randn(1, 3, args.input_size, args.input_size)
model.train()
device = torch.device(('cuda' if torch.cuda.is_available() else 'cpu'))
model = model.to(device)
input = inpu... |
class TFMobileViTConvLayer(tf.keras.layers.Layer):
def __init__(self, config: MobileViTConfig, out_channels: int, kernel_size: int, stride: int=1, groups: int=1, bias: bool=False, dilation: int=1, use_normalization: bool=True, use_activation: Union[(bool, str)]=True, **kwargs) -> None:
super().__init__(**kw... |
def recall(y_true, y_pred):
from keras import backend as K
true_positives = K.sum(K.round(K.clip((y_true * y_pred), 0, 1)))
possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
recall = (true_positives / (possible_positives + K.epsilon()))
return recall |
def getPrediction(params):
if (not params['model']):
return []
interpreter = utils.load_tflite(models_dir, params['model'], 'checkpoints', 'best.tflite')
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
real_... |
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--image_list', help='Path of the image_list file', default=None)
parser.add_argument('--image_dir', help='Root dir of the image path in image_list file', default=None)
parser.add_argument('--output_dir', default=None)
parser.a... |
class _BatchNormXd(torch.nn.modules.batchnorm._BatchNorm):
def _check_input_dim(self, input):
return |
_model
def resnetv2_50x3_bitm(pretrained=False, **kwargs):
return _create_resnetv2('resnetv2_50x3_bitm', pretrained=pretrained, layers=[3, 4, 6, 3], width_factor=3, stem_type='fixed', **kwargs) |
def get_backbone_net(backbone='resnet101', output_stride=16, pretrained=True, norm_layer=nn.BatchNorm2d, bn_mom=0.01, root_beta=True):
networks_obj_dict = {'resnet50': resnet_v1.resnet50, 'resnet101': resnet_v1.resnet101, 'resnet152': resnet_v1.resnet152}
assert (backbone in networks_obj_dict.keys())
if ('r... |
class Attention(Layer):
def __init__(self, step_dim, W_regularizer=None, b_regularizer=None, W_constraint=None, b_constraint=None, bias=True, **kwargs):
self.supports_masking = True
self.init = initializers.get('glorot_uniform')
self.W_regularizer = regularizers.get(W_regularizer)
se... |
def PrintDebugInfoForUtterance(ctm_edits_out_handle, split_lines_of_cur_utterance, segments_for_utterance, deleted_segments_for_utterance):
info_to_print = []
for n in range(len(segments_for_utterance)):
segment = segments_for_utterance[n]
start_string = 'start-segment-{0}[{1}]'.format((n + 1), ... |
def makedirs(path: str) -> None:
if path.startswith('s3'):
access_key_id = os.environ['AWS_ACCESS_KEY_ID']
secret_access_key = os.environ['AWS_SECRET_ACCESS_KEY']
import boto3
s3_client = boto3.Session(aws_access_key_id=access_key_id, aws_secret_access_key=secret_access_key).client('... |
class TestSmoothQuantTF(unittest.TestCase):
def setUpClass(self):
pass
def tearDownClass(self):
pass
_random()
def test_conv_sq(self):
x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name='input')
top_relu = tf.nn.relu(x)
paddings = tf.constant([[0, 0], ... |
def get_data():
from bigdl.chronos.data import get_public_dataset
(tsdata_train, tsdata_val, tsdata_test) = get_public_dataset(name='nyc_taxi')
tsdata_test.df.to_csv('deployment_data.csv', index=False)
tsdata_train.scale(scaler, fit=True)
return (tsdata_train, tsdata_val, tsdata_test) |
def add_pll_clock_output(bel, ec, entry):
(io_x, io_y, io_z) = entry[1]
io_zs = 'io_{}/D_IN_0'.format(io_z)
io_z = int(io_z)
add_bel_output(bel, wire_names[(io_x, io_y, io_zs)], entry[0])
for (gidx, ginfo) in glbinfo.items():
if ((ginfo['pi_gb_x'], ginfo['pi_gb_y'], ginfo['pi_gb_pio']) == (i... |
def add_all_preds(df_county):
for method in methods:
for t in tqdm(range(1, (ndays + 1))):
d = (today - timedelta(t))
if ((d < date(2020, 3, 16)) and (method in ['demographic'])):
continue
use_df = exponential_modeling.leave_t_day_out(df_county, (0 + t))
... |
def read_basic_block(fname, data, verbose):
with open(fname, 'rb') as f:
code = f.read((- 1))
start_pos = code.index(START_MARKER)
if (start_pos == (- 1)):
raise ValueError('START MARKER NOT FOUND')
end_pos = code.index(END_MARKER)
if (end_pos == (- 1)):
raise ValueError('END... |
def setup(rank: Optional[int]=None, world_size: Optional[int]=None):
if (rank is None):
rank = get_local_rank()
if (world_size is None):
world_size = get_world_size()
if (world_size <= 1):
return (rank, world_size)
if (not dist.is_initialized()):
if (sys.platform == 'win3... |
def predictor_minstependgame_get():
from phcpy.phcpy2c3 import py2c_get_value_of_continuation_parameter as get
return get(10) |
class DiscreteInverseModel(nn.Module):
def __init__(self, state_size, action_size, hidden_size, **kwargs):
super().__init__()
self.fc1 = nn.Linear((state_size * 2), hidden_size)
self.fc2 = nn.Linear(hidden_size, hidden_size)
self.act_p = nn.Linear(hidden_size, action_size)
se... |
class PyTorchFilters(object):
def __init__(self):
self.filters = {}
self.filters.update(PYTORCH_FILTERS) |
def download_coco2014(root, phase):
work_dir = os.getcwd()
tmpdir = os.path.join(root, 'tmp/')
if (not os.path.exists(root)):
os.makedirs(root)
if (not os.path.exists(tmpdir)):
os.makedirs(tmpdir)
if (phase == 'train'):
filename = 'train2014.zip'
elif (phase == 'val'):
... |
def get_default_train_test_split(dataset_key) -> Optional[Tuple[(List[int], List[int])]]:
predefined = get_predefined_train_test_split(dataset_key)
if (predefined is not None):
return predefined
return get_random_train_test_indices(dataset_key) |
.xfail(env.PYPY, reason="PyPy 7.3.7 doesn't clear this anymore", strict=False)
def test_to_python():
mat = m.Matrix(5, 4)
assert (memoryview(mat).shape == (5, 4))
assert (mat[(2, 3)] == 0)
mat[(2, 3)] = 4.0
mat[(3, 2)] = 7.0
assert (mat[(2, 3)] == 4)
assert (mat[(3, 2)] == 7)
assert (str... |
class OpTuningConfig():
def __init__(self, op_name, op_type, op_quant_mode, tuning_space, kwargs={}):
self.op_name = op_name
self.op_type = op_type
self.op_name_type = (self.op_name, self.op_type)
self.op_quant_mode = op_quant_mode
self.kwargs = kwargs
self.act_dtype ... |
.script_launch_mode('subprocess')
def test_training_3d_2class_single_channel_with_data_augmentation(download_functional_test_files, script_runner):
file_config = os.path.join(__data_testing_dir__, 'automate_training_config.json')
context = imed_config_manager.ConfigurationManager(file_config).get_config()
c... |
def main():
display_interval = 0
discontinuous = False
resolution = 0
def usage():
print('Usage: python cube.py [-v] [-discontinuous] resolution')
exit()
for a in sys.argv[1:]:
if (a == '-v'):
display_interval = 100
elif (a == '-discontinuous'):
... |
def _ParseAndStripGTestFlags(argv):
global _gtest_flags_are_parsed
if _gtest_flags_are_parsed:
return
_gtest_flags_are_parsed = True
for flag in _flag_map:
if (flag.upper() in os.environ):
_flag_map[flag] = os.environ[flag.upper()]
i = 1
while (i < len(argv)):... |
def test_scene_ids():
dataset = _construct_dataset(100)
assert (dataset.scene_ids == [('scene_id_' + str(ii)) for ii in range(10)]) |
class ImageCoder(object):
def __init__(self):
self._sess = tf.compat.v1.Session()
self._png_data = tf.compat.v1.placeholder(dtype=tf.string)
image = tf.image.decode_png(self._png_data, channels=3)
self._png_to_jpeg = tf.image.encode_jpeg(image, format='rgb', quality=100)
self... |
def scitodeci(sci):
tmp = re.search('(\\d+\\.?\\d+)\\*\\^(-?\\d+)', sci)
return (float(tmp.group(1)) * pow(10, float(tmp.group(2)))) |
class Inspector():
def __init__(self, scores: 'pd.DataFrame', model: Union[(str, 'PipelineCreator', List['PipelineCreator'], 'BaseEstimator', None)]=None, X: Optional[List[str]]=None, y: Optional[str]=None, groups: Optional[str]=None, cv: Optional[int]=None) -> None:
self._scores = scores
self._mode... |
def evaluate(model, g, features, labels, mask, loss_func):
model.eval()
with torch.no_grad():
logits = model(g, features)
loss = loss_func(logits[mask], labels[mask])
(accuracy, micro_f1, macro_f1) = score(logits[mask], labels[mask])
return (loss, accuracy, micro_f1, macro_f1) |
_model_architecture('lra', 'flash_lra_pf32')
def flash_lra_pf32(args):
args.apply_bert_init = getattr(args, 'apply_bert_init', False)
args.layer_type = getattr(args, 'layer_type', 'flash')
args.encoder_hidden_dim = getattr(args, 'encoder_hidden_dim', 384)
args.z_dim = getattr(args, 'z_dim', 64)
args... |
def get_structural_features(tweet_id, context_tweet_id):
structure = load_structure_json(tweet_id)
thread_structure = list(looping_nested_dict(structure))
persistence = 0
depth = 0
for (id, dep) in thread_structure:
if (id == context_tweet_id):
persistence += 1
depth ... |
def test_double_viviani_at_series(vrblvl=0):
pols = ['2*t^2 - x;', 'x^2 + y^2 + z^2 - 4;', '(x-1)^2 + y^2 - 1;']
lser = ['2*t^2;', '2*t;', '2;']
nser = double_newton_at_series(pols, lser, maxdeg=12, nbr=8, vrblvl=vrblvl)
variables = ['x', 'y', 'z']
for (var, pol) in zip(variables, nser):
pri... |
def clean_pdf_file(filename):
with open(filename, 'r+b') as file, mmap.mmap(file.fileno(), 0, access=mmap.ACCESS_WRITE) as mmfile:
start = mmfile.find(b'%PDF-')
if (start == (- 1)):
LOGGER.debug('not a PDF file')
return
end = mmfile.rfind(b'%%EOF')
offset = le... |
def random_jpeg_compression(img: torch.Tensor, q_min: int=50, q_max: int=100):
q = ((torch.rand(1)[0] * q_min) + (q_max - q_min))
img = torchvision.io.encode_jpeg(img, quality=q)
return torchvision.io.decode_image(img) |
class StackedEmbedding(nn.Embedding):
def __init__(self, num_embeddings, embed_dim, padding_idx, num_stacked=1):
super().__init__(num_embeddings, embed_dim, padding_idx)
nn.init.normal_(self.weight, mean=0, std=(embed_dim ** (- 0.5)))
nn.init.constant_(self.weight[padding_idx], 0)
se... |
class EfficientNetPreTrainedModel(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
class ModelArguments():
model_name_or_path: str = field(default='microsoft/layoutlmv3-base', metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'})
config_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained config name or path if not the same as model_n... |
class _GridSample2dForward(torch.autograd.Function):
def forward(ctx, input, grid):
assert (input.ndim == 4)
assert (grid.ndim == 4)
output = torch.nn.functional.grid_sample(input=input, grid=grid, mode='bilinear', padding_mode='zeros', align_corners=False)
ctx.save_for_backward(inpu... |
class FrameStack(gym.Wrapper):
def __init__(self, env, k):
gym.Wrapper.__init__(self, env)
self.k = k
self.frames = deque([], maxlen=k)
shp = env.observation_space.shape
self.observation_space = spaces.Box(low=0, high=255, shape=(shp[:(- 1)] + ((shp[(- 1)] * k),)), dtype=env.... |
class HubertForCTC(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
class GeM(nn.Module):
def __init__(self, p=3.0, eps=1e-06, freeze_p=True):
super(GeM, self).__init__()
self.p = (p if freeze_p else Parameter((torch.ones(1) * p)))
self.eps = eps
def forward(self, x):
return F.adaptive_avg_pool2d(x.clamp(min=self.eps).pow(self.p), (1, 1)).pow((1.... |
def parse_primitives(primitive_completion):
primitives = []
for line in primitive_completion.strip().split('\n'):
if (len(line) == 0):
print('Warning: Stopping since newline was encountered')
break
(primitive, obj) = line.split('(')
primitive = primitive.strip().r... |
class PLMSSampler(object):
def __init__(self, model, schedule='linear', **kwargs):
super().__init__()
self.model = model
self.ddpm_num_timesteps = model.num_timesteps
self.schedule = schedule
def register_buffer(self, name, attr):
if (type(attr) == torch.Tensor):
... |
def get_training_data(digits, fourX=True, idx=0):
train_data = []
for digit in digits:
training_image = image_dict[digit][idx]
training_image = np.ndarray.astype(training_image, int)
if fourX:
training_image = ((training_image // 4) * 4)
training_image = np.ndarray.fl... |
def _read_state_dict_from_shm(meta_dict, tensor_shm):
state_dict = _traverse_state_dict(meta_dict, (lambda x: _read_tensor_from_buf(x, tensor_shm)))
return state_dict |
class NfCfg():
depths: Tuple[(int, int, int, int)]
channels: Tuple[(int, int, int, int)]
alpha: float = 0.2
stem_type: str = '3x3'
stem_chs: Optional[int] = None
group_size: Optional[int] = None
attn_layer: Optional[str] = None
attn_kwargs: dict = None
attn_gain: float = 2.0
widt... |
def _uniform_schedule(origin_distr, target_distr, i_estimator, total_estimator):
for (param, (param_name, param_type)) in zip([origin_distr, target_distr, i_estimator, total_estimator], list(BALANCING_SCHEDULE_PARAMS_TYPE.items())):
if (not isinstance(param, param_type)):
raise TypeError(f"'{par... |
def init_bias_lin_zero(model, logger=None):
layers_initialized = 0
a = 0
for m in model.modules():
if isinstance(m, nn.Linear):
if (m.bias is not None):
layers_initialized += 1
m.bias.data.zero_()
logger.info((('Initialized ' + str(layers_initialized))... |
class InplaceAbn(nn.Module):
def __init__(self, num_features, eps=1e-05, momentum=0.1, affine=True, apply_act=True, act_layer='leaky_relu', act_param=0.01, drop_block=None):
super(InplaceAbn, self).__init__()
self.num_features = num_features
self.affine = affine
self.eps = eps
... |
class MixtureSIN(DeepConditional):
def __init__(self, encoder: DeepConditional, mixture_params: MixtureParams):
super().__init__()
self.encoder = encoder
self.mixture_params = mixture_params
def predict(self, data) -> TorchDistribution:
potentials = self.encoder.predict(data)
... |
class MusdbTrainDataset(Dataset):
def __init__(self, target: str='vocals', root: str=None, 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_method: str='limitaug_then_loudnorm', limitaug_mode:... |
class SuperResK1KXK1(PlainNetSuperBlockClass):
def __init__(self, in_channels=None, out_channels=None, stride=None, bottleneck_channels=None, sub_layers=None, kernel_size=None, no_create=False, no_reslink=False, no_BN=False, use_se=False, **kwargs):
super(SuperResK1KXK1, self).__init__(**kwargs)
sel... |
class TestCodeLlamaModel(unittest.TestCase):
def setUp(self):
return super().setUp()
def tearDown(self) -> None:
return super().tearDown()
def test_code_gen(self):
config = PipelineConfig(model_name_or_path='/tf_dataset2/models/nlp_toolkit/CodeLlama-7b-hf')
chatbot = build_ch... |
def json_to_numpy(in_file):
f = open(in_file.as_posix(), 'r')
data = json.load(f)
frame_landmarks = []
for bp in LMKS.keys():
bp_landmarks = [[float(n) for n in lm.split(',')[:3]] for lm in data[f'{bp}_landmarks']['landmarks']]
if (len(bp_landmarks) == 0):
bp_landmarks = ([[(... |
class ResNet(nn.Module):
def __init__(self, block, layers, num_classes=1000, zero_init_residual=False, groups=1, width_per_group=64, replace_stride_with_dilation=None, norm_layer=None):
super(ResNet, self).__init__()
if (norm_layer is None):
norm_layer = nn.BatchNorm2d
self._norm... |
_sentencepiece
_tokenizers
class T5TokenizationTest(TokenizerTesterMixin, unittest.TestCase):
tokenizer_class = T5Tokenizer
rust_tokenizer_class = T5TokenizerFast
test_rust_tokenizer = True
test_sentencepiece = True
def setUp(self):
super().setUp()
tokenizer = T5Tokenizer(SAMPLE_VOCA... |
def compute_hessian(f, params):
h = []
for i in params:
h_i = []
for j in params:
h_ij = tf.gradients(tf.gradients(f, j)[0], i)[0]
h_ij = ([0.0] if (h_ij is None) else h_ij)
h_i.append(h_ij)
h_i = tf.convert_to_tensor(h_i)
h.append(h_i)
h =... |
def mask_matrix_nms(masks, labels, scores, filter_thr=(- 1), nms_pre=(- 1), max_num=(- 1), kernel='gaussian', sigma=2.0, mask_area=None):
assert (len(labels) == len(masks) == len(scores))
if (len(labels) == 0):
return (scores.new_zeros(0), labels.new_zeros(0), masks.new_zeros(0, *masks.shape[(- 2):]), l... |
def get_mean_std(exp_name):
root_path = '/data/sls/scratch/yuangong/avbyol/egs/vggsound/exp/'
three_res = []
for repeat in ['-r1', '-r2', '-r3']:
cur_res = (np.loadtxt((((root_path + exp_name) + repeat) + '/result.csv'), delimiter=',') * 100)
three_res.append(cur_res)
three_res = np.stac... |
class LayerConnection(message.Message):
__metaclass__ = reflection.GeneratedProtocolMessageType
DESCRIPTOR = _LAYERCONNECTION |
def crop(task_string, override=False, num_threads=default_num_threads):
cropped_out_dir = join(nnUNet_cropped_data, task_string)
maybe_mkdir_p(cropped_out_dir)
if (override and isdir(cropped_out_dir)):
shutil.rmtree(cropped_out_dir)
maybe_mkdir_p(cropped_out_dir)
splitted_4d_output_dir_t... |
class LinearWarmup(BaseWarmup):
def __init__(self, optimizer, warmup_period, last_step=(- 1)):
group_count = len(optimizer.param_groups)
warmup_params = get_warmup_params(warmup_period, group_count)
super(LinearWarmup, self).__init__(optimizer, warmup_params, last_step)
def warmup_factor... |
def draw(geometry=None, title='Open3D', width=1024, height=768, actions=None, lookat=None, eye=None, up=None, field_of_view=60.0, intrinsic_matrix=None, extrinsic_matrix=None, bg_color=(1.0, 1.0, 1.0, 1.0), bg_image=None, ibl=None, ibl_intensity=None, show_skybox=None, show_ui=None, raw_mode=False, point_size=None, lin... |
def vggm(num_classes=1000, pretrained='imagenet'):
if pretrained:
settings = pretrained_settings['vggm'][pretrained]
assert (num_classes == settings['num_classes']), 'num_classes should be {}, but is {}'.format(settings['num_classes'], num_classes)
model = VGGM(num_classes=1000)
mode... |
_auth
def filter_datasets(dfilter, project, url, auth_headers):
filtered_datasets = {}
(field, pattern, regex) = parse_filter(dfilter)
endpoint = f'{url}/api/v1/datasets/'
params = {'project': project, f'{field}__{pattern}': regex}
while (endpoint is not None):
r = requests.get(endpoint, hea... |
def del_field_tokens(task):
all_instances = ((task.train_data + task.val_data) + task.test_data)
for instance in all_instances:
if ('input1' in instance.fields):
field = instance.fields['input1']
del field.tokens
if ('input2' in instance.fields):
field = insta... |
class AsyncMultiHook(MultiHook):
def __init__(self, hooks=None):
super().__init__(hooks)
self._original_sys_asyncgen_hooks = sys.get_asyncgen_hooks()
self._alive_asyncgens = weakref.WeakSet()
self._new_hooks = collections.deque()
def begin(self):
self._original_sys_asyncg... |
def SENet154(input_shape=None, input_tensor=None, weights=None, classes=1000, include_top=False, stride_size=2, init_filters=64, repetitions=(3, 8, 36, 3), **kwargs):
return SENet(MODELS_PARAMS['senet154'], input_shape=input_shape, input_tensor=input_tensor, include_top=include_top, classes=classes, weights=weights... |
def forward(_):
if (len(input.value) > 0):
if (task.value == 'ner'):
output = nlp_token_class(input.value)
elif (task.value == 'sentiment-analysis'):
output = nlp_sentence_classif(input.value)
elif (input.value.find('<mask>') == (- 1)):
output = nlp_fill((... |
class PPONModel(BaseModel):
def __init__(self, args):
super(PPONModel, self).__init__(args)
self.netG = networks.define_G(args).cuda()
if self.is_train:
if (args.which_model == 'perceptual'):
self.netD = networks.define_D().cuda()
self.netD.train()... |
class RasterizeGLContext():
def __init__(self, output_db=True, mode='automatic', device=None):
assert ((output_db is True) or (output_db is False))
assert (mode in ['automatic', 'manual'])
self.output_db = output_db
self.mode = mode
if (device is None):
cuda_devic... |
def resize_width(img: tf.Tensor, label: tf.Tensor, width, height, interpolation=tf.image.ResizeMethod.BILINEAR):
img = tf.image.resize_with_pad(img, target_height=height, target_width=width, method=interpolation)
img = (img / 255)
img = ((img - 0.5) / 0.5)
return (img, label) |
class CTRLTokenizer(PreTrainedTokenizer):
vocab_files_names = VOCAB_FILES_NAMES
pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
control_codes = CONTROL_CODES
def __init__(self, vocab_file, merges_file, unk_token='<unk>', **kwargs... |
def import_resolve(tex, path):
soup = TexSoup(tex)
dir_path = (os.path.dirname(path) + '/')
for _input in soup.find_all('input'):
path = os.path.join(dir_path, _input.args[0])
if (not os.path.exists(path)):
path = (path + '.tex')
_input.replace(*import_resolve(open(path),... |
def log_metrics(step, metrics):
logger.info(f'Step {step}: {metrics}')
if accelerator.is_main_process:
accelerator.log(metrics, step) |
class inp_syncbatchnorm_(Function):
def forward(cls, ctx, x, gamma, beta, running_mean, running_var, extra, sync=True, training=True, momentum=0.1, eps=1e-05, activation='none', slope=0.01):
cls._parse_extra(ctx, extra)
ctx.sync = sync
ctx.training = training
ctx.momentum = momentum
... |
_mode()
def score_sequences_with_huggingface_given_model(model: nn.Module, tokenizer: transformers.PreTrainedTokenizer, sequences: Sequence[str], per_device_batch_size=20, max_instances=sys.maxsize, mixed_precision: Optional[str]=None, tf32=False, divide_work=True):
torch.backends.cuda.matmul.allow_tf32 = torch.bac... |
def simulated_data():
data_generator = LatentVariableData(view_features=[4, 5], latent_dimensions=2, random_state=1)
(X, Y) = data_generator.sample(20)
return (X, Y) |
def get_clean_rec_list(result_csv, n=100, k=20):
final_dict = {}
for i in range(n):
clean_rec_list = clean(result_csv['Result'][i])
final_dict[result_csv['name'][i]] = clean_rec_list
return final_dict |
class LocallyConnected1D(ZooKerasLayer):
def __init__(self, nb_filter, filter_length, activation=None, border_mode='valid', subsample_length=1, W_regularizer=None, b_regularizer=None, bias=True, input_shape=None, **kwargs):
if (border_mode != 'valid'):
invalidInputError(False, "For LocallyConnec... |
def get_multi_gpu_models(config, emb_mat=None):
models = []
with tf.variable_scope(tf.get_variable_scope()) as vscope:
for gpu_idx in range(config.num_gpus):
with tf.name_scope('model_{}'.format(gpu_idx)) as scope, tf.device('/{}:{}'.format(config.device_type, gpu_idx)):
if (... |
def plot_main():
data_path = '../sac/data/mengxiong'
plot_key = 'return-average'
(exps_data, plottable_keys, distinct_params) = reload_data(data_path)
(group_selectors, group_legends) = get_group_selectors(exps_data, custom_series_splitter)
(fig, ax) = plt.subplots(figsize=(8, 5))
for (idx, (sel... |
_registry(op_types='Mod')
class BinaryDirect8BitOperator(Operator):
def __init__(self, onnx_quantizer, onnx_node):
super(BinaryDirect8BitOperator, self).__init__(onnx_quantizer, onnx_node)
def quantize_check(self):
node = self.node
(data_found, _, _, _, _) = self.quantizer._get_quantizat... |
class TransformT(object):
def __init__(self, name, xform_fn):
self.name = name
self.xform = xform_fn
def transformer(self, probability, magnitude):
def return_function(img, label_img_pool):
res = False
s = []
if (random.random() < probability):
... |
class SumOfSquaresPolynomialBijection(Bijection):
def __init__(self, num_input_channels, hidden_channels, activation, num_polynomials, polynomial_degree):
super().__init__(x_shape=(num_input_channels,), z_shape=(num_input_channels,))
arn = AutoRegressiveNN(input_dim=int(num_input_channels), hidden_d... |
.parametrize('kwargs', [{}, {'cell_type': 'GRU'}, dict(data_loader_kwargs=dict(target_normalizer=GroupNormalizer(groups=['agency', 'sku'], center=False))), dict(data_loader_kwargs=dict(lags={'volume': [2, 5]}, target='volume', time_varying_unknown_reals=['volume'], min_encoder_length=2)), dict(data_loader_kwargs=dict(t... |
class Factor(ModelBase):
c = None
id0 = None
m = None
nm = None
num = None
op = None
sub = None
v = None |
class DehnenCoreSphericalPotential(DehnenSphericalPotential):
def __init__(self, amp=1.0, a=1.0, normalize=False, ro=None, vo=None):
DehnenSphericalPotential.__init__(self, amp=amp, a=a, alpha=0, normalize=normalize, ro=ro, vo=vo)
self.hasC = True
self.hasC_dxdv = True
self.hasC_dens... |
class FloatProblem(Problem[FloatSolution], ABC):
def __init__(self):
super(FloatProblem, self).__init__()
self.lower_bound = []
self.upper_bound = []
def number_of_variables(self) -> int:
return len(self.lower_bound)
def create_solution(self) -> FloatSolution:
new_sol... |
class Categorical(nn.Module):
def __init__(self, num_inputs, num_outputs):
super(Categorical, self).__init__()
self.num_outputs = num_outputs
init_ = (lambda m: init(m, nn.init.orthogonal_, (lambda x: nn.init.constant_(x, 0)), gain=0.01))
self.linear = init_(nn.Linear(num_inputs, num... |
class LRAEncoder(FairseqEncoder):
def __init__(self, args, task):
if (args.input_type == 'text'):
dictionary = task.dictionary
vocab_size = len(dictionary)
padding_idx = dictionary.pad_index
offset_positions_by_padding = True
embedding_type = 'spar... |
class BilinearFlatSim(nn.Module):
def __init__(self, x_size, y_size, opt={}, prefix='seqatt', dropout=None):
super(BilinearFlatSim, self).__init__()
self.opt = opt
self.weight_norm_on = opt.get('{}_weight_norm_on'.format(prefix), False)
self.linear = nn.Linear(y_size, x_size)
... |
def state_dict_to_cpu(state_dict: OrderedDict):
new_state = OrderedDict()
for k in state_dict.keys():
newk = k.replace('module.', '')
new_state[newk] = state_dict[k].cpu()
return new_state |
def test_deprecated_api_warning():
_api_warning(name_dict=dict(old_key='new_key'))
def dummy_func(new_key=1):
return new_key
assert (dummy_func(old_key=2) == 2)
with pytest.raises(AssertionError):
dummy_func(old_key=1, new_key=2) |
def read_model(path, ext=''):
if (ext == ''):
if detect_model_format(path, '.bin'):
ext = '.bin'
elif detect_model_format(path, '.txt'):
ext = '.txt'
else:
print("Provide model format: '.bin' or '.txt'")
return
if (ext == '.txt'):
c... |
class TrexNerLoader():
def __init__(self):
self.label_set = set()
self.label_set.add('B')
self.label_set.add('I')
self.label_set.add('O')
def _load(self, path):
dataset = load_json(path)
for data in dataset:
triples = data['triples']
for tr... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.