code stringlengths 101 5.91M |
|---|
def get_genre_list(fname):
edgelist = open(fname, 'r')
lines = list(edgelist.readlines())
edgelist.close()
genre_dict = {}
for i in range(1, len(lines)):
vals = lines[i].split(',')
user_id = vals[1]
time = vals[2]
genre = vals[3].strip('"').strip("['")
w = flo... |
def sdf(o):
wall = ti.min((o[1] + 0.1), (o[2] + 0.4))
sphere = ((o - ti.Vector([0.0, 0.35, 0.0])).norm() - 0.36)
q = (ti.abs((o - ti.Vector([0.8, 0.3, 0]))) - ti.Vector([0.3, 0.3, 0.3]))
box = (ti.Vector([ti.max(0, q[0]), ti.max(0, q[1]), ti.max(0, q[2])]).norm() + ti.min(q.max(), 0))
O = (o - ti.Ve... |
class Wood(Resource):
def __init__(self, *args, **kwargs):
super().__init__('Wood', *args, **kwargs) |
def save(model, filename):
save_filename = '{}.pt'.format(filename)
torch.save(model, save_filename)
print(('Saved as %s' % save_filename)) |
class JsonInputReader(BaseInputReader):
def __init__(self, types_path: str, tokenizer: BertTokenizer, neg_term_count: int=None, neg_rel_count: int=None, max_span_size: int=None, logger: Logger=None):
super().__init__(types_path, tokenizer, neg_term_count, neg_rel_count, max_span_size, logger)
def read(s... |
class PCSingle(BaseTabularAlgo):
def __init__(self, data: TabularData, prior_knowledge: Optional[PriorKnowledge]=None, CI_test: Union[(PartialCorrelation, KCI, DiscreteCI_tests)]=PartialCorrelation(), use_multiprocessing: Optional[bool]=False):
BaseTabularAlgo.__init__(self, data=data, prior_knowledge=prior... |
def gaussian_cnn_baseline_tf_ppo_benchmarks():
iterate_experiments(gaussian_cnn_baseline, PIXEL_ENV_SET, seeds=_seeds) |
def normal_precursor_regions(path_data, keys_options=['all'], causal=False):
dict_of_dfs = functions_pp.load_hdf5(path_data)
df_data = dict_of_dfs['df_data']
splits = df_data.index.levels[0]
try:
df_sum = dict_of_dfs['df_sum']
except:
pass
skip = ['all_spatcov']
keys_d = {}
... |
def array_function_dispatch(dispatcher, module=None, verify=True, docs_from_dispatcher=False):
if (not ARRAY_FUNCTION_ENABLED):
def decorator(implementation):
if docs_from_dispatcher:
add_docstring(implementation, dispatcher.__doc__)
if (module is not None):
... |
class ONNXConfigNode(TreeConfigNode):
def modify_label(self, label):
return ('Onnx=' + str(label))
def init2(self, node_name):
self.props['is_onnx'] = node_name
def child_constructor(self):
return ImportantConfigNode |
class GSM8K():
def __init__(self) -> None:
super().__init__()
self.do_shuffle = False
dataset = load_dataset('gsm8k', 'main')
hf_official_train = dataset['train']
hf_official_test = dataset['test']
official_train = []
official_test = []
for example in ... |
class IdentityOperation(BaseTransformer):
def transform(self, **kwargs):
return kwargs
def persist(self, filepath):
logger.info('"IdentityOperation" is not persistable.')
pass |
class PredictDiffHead(nn.Module):
def __init__(self, config, cln=21, in_channel=256, dr_rate_a=0.5, in_channel2=128):
super(PredictDiffHead, self).__init__()
self.config = config
chn = 256
self.conv1ab = Conv2dbnPR((in_channel2 + in_channel), chn, kernel_size=3, stride=1, padding=1)
... |
def simGetScriptAssociatedWithObject(objectHandle):
ret = lib.simGetScriptAssociatedWithObject(objectHandle)
return ret |
def test_dual(capsys):
m.captured_dual('a', 'b')
(stdout, stderr) = capsys.readouterr()
assert (stdout == 'a')
assert (stderr == 'b') |
def get_learning_rate(optimizer):
lr = []
for param_group in optimizer.param_groups:
lr += [param_group['lr']]
return lr |
def test_record():
record = ak.contents.RecordArray([ak.contents.NumpyArray(np.arange(10))], ['x'])
array = ak.Array(record)
record = array[0]
with pytest.raises(AttributeError):
record.x = 10
with pytest.raises(AttributeError):
record.not_an_existing_attribute = 10
record._not_a... |
def with_native_function(func: Callable[([NativeFunction], T)]) -> Callable[([NativeFunction], T)]:
(func)
def wrapper(f: NativeFunction) -> T:
with context(f'''in {f.loc}:
{f.func}'''):
with local.parametrize(use_c10_dispatcher=f.use_c10_dispatcher):
return func(f)
ret... |
def compute_fid_trans(opts, max_real, num_gen):
detector_url = '
detector_kwargs = dict(return_features=True)
domains = os.listdir(opts.dataset_kwargs.path)
domains = [domain for domain in domains if (not domain.endswith('.json'))]
domains.sort()
src_idxs = {k: v for (v, k) in enumerate(domains)... |
def process_book(bert_tok_dir, pred_scores_dir, BertNSP, device, cls, sep, book_id):
with open(os.path.join(bert_tok_dir, (book_id + '.pkl')), 'rb') as f:
d = pickle.load(f)
m = max(d.keys())
scores = dict()
for idx in range(0, (m - 1)):
toks1 = d[idx]
toks2 = d[(idx + 1)]
... |
class SetAbstraction(nn.Module):
def __init__(self, in_channels, out_channels, layers=2, stride=1, group_args={'NAME': 'ballquery', 'radius': 0.1, 'nsample': 16}, norm_args={'norm': 'bn1d'}, act_args={'act': 'relu'}, conv_args=None, sampler='fps', use_res=True, is_head=False):
super().__init__()
sel... |
def check_build_status(conf):
buildFolder = os.path.join(PROJECT_CONFIG['build_dir'], conf.build_folder())
kernelFolder = os.path.join(buildFolder, '_x', 'link', 'vivado')
logPath = os.path.join(kernelFolder, 'vivado.log')
try:
log = open(logPath, 'r').read()
except:
print('No build ... |
class DeepGraphCNN(GCNSupervisedGraphClassification):
def __init__(self, layer_sizes, activations, k, generator, bias=True, dropout=0.0, kernel_initializer=None, kernel_regularizer=None, kernel_constraint=None, bias_initializer=None, bias_regularizer=None, bias_constraint=None):
super().__init__(layer_sizes... |
def download_webfile(url, filename, overwrite=False):
if (os.path.exists(filename) and (not overwrite)):
return
if ('.' in url):
r = requests.get(url, stream=True)
with open(filename, 'wb') as fd:
for chunk in r.iter_content(chunk_size=128):
fd.write(chunk)
... |
class Generator(BaseGenerator):
def __init__(self, config, mode, X=None):
super(Generator, self).__init__(config, mode)
self.build_generator(X=X)
def generate_random_X(self, shape):
return np.random.rand(*shape) |
def pair_cascade_protocols(sender: 'Cascade', receiver: 'Cascade') -> None:
sender.another = receiver
receiver.another = sender
sender.role = 0
receiver.role = 1 |
def print_prop(num, f):
f.write(f'''; ACAS Xu property {num}
''')
for x in range(5):
f.write(f'''(declare-const X_{x} Real)
''')
f.write('\n')
for x in range(5):
f.write(f'''(declare-const Y_{x} Real)
''')
means_for_scaling = [19791.091, 0.0, 0.0, 650.0, 600.0, 7.]
range_for_scal... |
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('treebanks', type=str, nargs='*', help='Which treebanks to run on')
parser.add_argument('--pretrain', type=str, default='/home/john/extern_data/wordvec/glove/armenian.pt', help='Which pretrain to use')
parser.set_defaults(treebanks... |
class BytesURL(BaseURL):
__slots__ = ()
_at = b''
_colon = b':'
_lbracket = b'['
_rbracket = b']'
def __str__(self):
return self.to_url().decode('utf-8', 'replace')
def encode_netloc(self):
return self.netloc
def decode(self, charset='utf-8', errors='replace'):
re... |
def batch_normalization_layer(input_layer, dimension):
(mean, variance) = tf.nn.moments(input_layer, axes=[0, 1, 2])
beta = tf.get_variable('beta', dimension, tf.float32, initializer=tf.constant_initializer(0.0, tf.float32))
gamma = tf.get_variable('gamma', dimension, tf.float32, initializer=tf.constant_ini... |
def point_wise_feed_forward_network(d_model, dff):
return tf.keras.Sequential([tf.keras.layers.Dense(dff, activation='relu'), tf.keras.layers.Dense(d_model)]) |
class Log():
def __init__(self):
pass
def process(self, pid):
print(grey('Process ID: {}'.format(pid), bold=True))
def model(self, message):
print(blue(message, bold=True))
def title(self, message):
print(yellow(message, bold=True, underline=True))
def warning(self, m... |
class FlaxGPTJPreTrainedModel(metaclass=DummyObject):
_backends = ['flax']
def __init__(self, *args, **kwargs):
requires_backends(self, ['flax']) |
def build_spk_hashtable_librimix(hparams):
libri_utterances = glob.glob(os.path.join(hparams['base_folder_dm'], '**/*.wav'), recursive=True)
spk_hashtable = {}
assert (torchaudio.info(libri_utterances[0]).sample_rate == hparams['sample_rate'])
for utt in tqdm(libri_utterances):
path = os.path.no... |
class BlockStack(list):
def push(self, instr: UniqueInstruction) -> None:
self.append(instr)
def peek(self) -> (UniqueInstruction | None):
try:
return self[(- 1)]
except IndexError:
return None |
_numpy_output(positive=True, check_dtype=True)
def test_ufunc_log2_f(A: dace.float32[10]):
return np.log2(A) |
def _broadcast_and_stack(tensors, dim=(- 1)):
broadcast_shape = torch.broadcast_shapes(*(x.size() for x in tensors))
broadcast_tensors = [x.broadcast_to(broadcast_shape) for x in tensors]
return torch.stack(broadcast_tensors, dim=dim) |
class InvertedDoublePendulumEnv(MujocoEnv, Serializable):
FILE = 'inverted_double_pendulum.xml.mako'
('random_start', type=bool, help='Randomized starting position by adjusting the anglesWhen this is false, the double pendulum started outin balanced position')
def __init__(self, *args, **kwargs):
se... |
class IDD_Dataset(SegmentationDataset):
num_classes = 26
label_names = ['road', 'drivable fallback', 'sidewalk', 'non-drivable fallback', 'animal', 'rider', 'motorcycle', 'bicycle', 'autorickshaw', 'car', 'truck', 'bus', 'vehicle fallback', 'curb', 'wall', 'fence', 'guard rail', 'billboard', 'traffic sign', 'tr... |
class FactorizationMachineModelnofeatures(keras.Model):
def __init__(self, num_users, num_items, embed_mf_size, lambda_weights, learning_rate=0.01, random_seed=42, name='FM', **kwargs):
super().__init__(name=name, **kwargs)
tf.random.set_seed(random_seed)
self.num_users = num_users
s... |
def check_used(port: int) -> bool:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex(('127.0.0.1', port))
if (result == 0):
sock.close()
return True
else:
return False |
def test_argmin_argmax_axis_None():
array = ak.highlevel.Array([[[np.datetime64('2022'), np.datetime64('2023'), np.datetime64('2025')], [], [np.datetime64('2027'), np.datetime64('2011')], [np.datetime64('2013')]], [], [[np.datetime64('2017'), np.datetime64('2019')], [np.datetime64('2023')]]], check_valid=True)
... |
def build_anchor_generator(cfg, default_args=None):
warnings.warn('``build_anchor_generator`` would be deprecated soon, please use ``build_prior_generator`` ')
return build_prior_generator(cfg, default_args=default_args) |
def main(args):
now = datetime.now()
current_date = now.strftime('%m/%d/%Y')
all_num_prompt_tokens = [1, 256, 512, 1024, 1536]
all_num_output_tokens = [1, 2, 4, 8, 16, 32, 64]
scenario = 'synthetic_efficiency'
all_models_and_tokenizers = []
for tokenizer_provider in args.tokenizer_providers:... |
def _shift_seq(seq: torch.Tensor) -> torch.Tensor:
shifted_seq = seq.roll((- 1), dims=0)
shifted_seq[((- 1), ...)] = 0
return shifted_seq |
class ResNet(nn.Module):
def __init__(self, block, num_blocks, num_classes=10):
super(ResNet, self).__init__()
self.in_planes = 64
self.conv1 = conv3x3_EW(3, 64)
self.bn1 = nn.BatchNorm2d(64)
self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
self.laye... |
def get_basic_model(**kwargs):
mel = AugmentMelSTFT(n_mels=128, sr=32000, win_length=800, hopsize=320, n_fft=1024, freqm=48, timem=192, htk=False, fmin=0.0, fmax=None, norm=1, fmin_aug_range=10, fmax_aug_range=2000)
net = get_model_passt(arch='passt_20sec', input_tdim=2000)
model = PasstBasicWrapper(mel=mel... |
def logging_manager(*, debug: bool=False) -> Iterator[None]:
formatter = Formatter(fmt='%(levelname)s: %(message)s', datefmt='')
root_logger = logging.getLogger('conda-pytorch')
root_logger.setLevel(logging.DEBUG)
console_handler = logging.StreamHandler()
if debug:
console_handler.setLevel(l... |
class Capture(object):
ctx: Dict[(str, List[Any])]
def __init__(self):
self.ctx = {'operations': [], 'variables': []}
def __str__(self):
return self.ops_str()
def ops_str(self):
res = ''
for op in self.ctx['operations']:
if (len(res) > 0):
res ... |
class MemoryCopySlice(MemoryCopyNode):
is_memview_copy_assignment = True
copy_slice_cname = '__pyx_memoryview_copy_contents'
def _generate_assignment_code(self, src, code):
dst = self.dst
src.type.assert_direct_dims(src.pos)
dst.type.assert_direct_dims(dst.pos)
code.putln(cod... |
def bivariate_plateau_type1(kernel_size, sig_x, sig_y, theta, beta, grid=None):
if (grid is None):
(grid, _, _) = mesh_grid(kernel_size)
sigma_matrix = sigma_matrix2(sig_x, sig_y, theta)
inverse_sigma = np.linalg.inv(sigma_matrix)
kernel = np.reciprocal((np.power(np.sum((np.dot(grid, inverse_sig... |
class StabilityTask(SequenceToFloatTask):
def __init__(self):
d_output = 1
super().__init__(key_metric='MAE', deserialization_func=deserialize_stability_sequence, d_output=d_output, label='stability_score', input_name='encoder_output', output_name='prediction') |
.hypothesis_nested
def test_case_insensitive_headers(empty_open_api_3_schema):
empty_open_api_3_schema['paths'] = {'/data': {'post': {'parameters': [{'name': 'X-id', 'in': 'header', 'required': True, 'schema': {'type': 'string'}}], 'responses': {'200': {'description': 'OK'}}}}}
schema = schemathesis.from_dict(e... |
def min_backward(grad_inputs, inputs, input_shapes, outputs, output_shapes, axes=None, keep_dims=False, with_index=False, only_index=False):
dy = grad_inputs[0]
x0 = inputs[0]
y0 = outputs[0]
if keep_dims:
y0 = F.broadcast(y0, x0.shape)
dy = F.broadcast(dy, x0.shape)
else:
ax... |
class Writer(SummaryWriter):
def __init__(self, logdir):
super(Writer, self).__init__(logdir)
cmap_custom = {'red': ((0.0, 0.0, 0.0), ((1 / 63), 0.0, 0.0), ((2 / 63), 0.0, 0.0), ((3 / 63), 0.0, 0.0), ((4 / 63), 0.0, 0.0), ((5 / 63), 0.0, 0.0), ((6 / 63), 0.0, 0.0), ((7 / 63), 0.0, 0.0), ((8 / 63), 0... |
class PredUtteranceItem():
def __init__(self, input_sequence, interaction_item, previous_query, index, available_snippets):
self.input_seq_to_use = input_sequence
self.interaction_item = interaction_item
self.index = index
self.available_snippets = available_snippets
self.pre... |
def load_dataset(path, dataset_type, *args, **kwargs):
return load_dataset_reader(dataset_type, *args, **kwargs).read(path) |
def all_gather_list(data, group=None, max_size=16384):
rank = get_rank()
world_size = get_world_size()
buffer_size = (max_size * world_size)
if ((not hasattr(all_gather_list, '_buffer')) or (all_gather_list._buffer.numel() < buffer_size)):
all_gather_list._buffer = torch.cuda.ByteTensor(buffer_s... |
class BBQMetric(EvaluateInstancesMetric):
def evaluate_instances(self, request_states: List[RequestState]) -> List[Stat]:
amb_non_unknown = 0
disamb_non_unknown = 0
amb_non_target_and_non_neg = 0
amb_target_and_neg = 0
disamb_non_target_and_non_neg = 0
disamb_target_a... |
def test_specify_column_type(simpledf: dd.DataFrame) -> None:
plot_diff([simpledf, simpledf], dtype={'a': Nominal()})
plot_diff([simpledf, simpledf], dtype=Nominal()) |
def scipy_minimize(objective: goos.Function, *args, **kwargs) -> ScipyOptimizer:
optimizer = ScipyOptimizer(objective, *args, **kwargs)
goos.get_default_plan().add_action(optimizer)
return optimizer |
def interp(x0, x1, num_midpoints):
lerp = torch.linspace(0, 1.0, (num_midpoints + 2), device='cuda').to(x0.dtype)
return ((x0 * (1 - lerp.view(1, (- 1), 1))) + (x1 * lerp.view(1, (- 1), 1))) |
def minimize_split(labels, stats, cross_val_split, seg_len, input_dir, output_dir):
tokenizer = BertTokenizer.from_pretrained('bert-base-cased')
cross_val_dir = path.join(output_dir, str(cross_val_split))
if (not path.exists(cross_val_dir)):
os.makedirs(cross_val_dir)
minimize_partition('dev', c... |
def parse_args(parser):
(args, _) = parser.parse_known_args()
if (args.decoder is not None):
decoding.DECODER_REGISTRY[args.decoder].add_args(parser)
if (args.predictor is not None):
import predictors
predictors.PREDICTOR_REGISTRY[args.predictor].add_args(parser)
return parser.pa... |
def eulerAngleToRoatationMatrix(theta):
R_x = np.array([[1, 0, 0], [0, math.cos(theta[0]), (- math.sin(theta[0]))], [0, math.sin(theta[0]), math.cos(theta[0])]])
R_y = np.array([[math.cos(theta[1]), 0, math.sin(theta[1])], [0, 1, 0], [(- math.sin(theta[1])), 0, math.cos(theta[1])]])
R_z = np.array([[math.co... |
_optimizer('sgd')
class SGD(LegacyFairseqOptimizer):
def __init__(self, args, params):
super().__init__(args)
self._optimizer = torch.optim.SGD(params, **self.optimizer_config)
def add_args(parser):
parser.add_argument('--momentum', default=0.0, type=float, metavar='M', help='momentum fa... |
def get_layer_extractors(backbone):
assert isinstance(backbone, torchvision.models.ResNet), 'layer extraction is only supported for resnet models for now'
models = {}
for i in range(5):
models[f'layer_{i}'] = LayerModel(backbone, i)
return models |
class KerasModelTester(FeedableTester):
def output_tensors(self, model):
return model.output_tensors
.usefixtures('clean_test_session')
def test_placeholders(self, model, feed_dict):
assert (set(model.placeholders) == set(feed_dict.keys())) |
class TestSanityCheck():
def test_ds_wrapper_integration(self):
ds_path = os.path.join('./tests', 'test_datasets', 'ds_coco_dataset')
ds_wrapper = DSWrapper(data_path=ds_path)
with tempfile.TemporaryDirectory() as out_path:
dss = SanityCheck(ds_wrapper=ds_wrapper, output_path=out... |
class Tokenizer(BaseEstimator, TransformerMixin):
def __init__(self, tokenizer):
self.tokenizer = SpacyModel(tokenizer)
def fit(self, X):
return self
def transform(self, X):
try:
res = []
for (idx, row) in tqdm(X.iterrows(), total=len(X)):
res.... |
def start_advertising(key, interval_ms=2000):
addr = bytearray(key[:6])
addr[0] |= 192
adv = advertisement_template()
adv[7:29] = key[6:28]
adv[29] = (key[0] >> 6)
print(f'key ({len(key):2}) {key.hex()}')
print(f'address ({len(addr):2}) {addr.hex()}')
print(f'payload ({len(adv):2}) {... |
def _subtract_constant_clip(image, const_value):
(min_dtype, max_dtype) = dtype_limits(image, clip_negative=False)
if (const_value > (max_dtype - min_dtype)):
raise ValueError('The subtracted constant is not compatiblewith the image data type.')
result = (image - const_value)
result[(image < (co... |
def single_instance_process(line, isLower, mode='train'):
instance = json.loads(line)
code_graph = instance['code_graph']
if (len(code_graph['nodes']) > 200):
return False
sent1 = Graph(instance, codeGraph=True, isLower=isLower)
if (mode == 'train'):
sent2 = Graph(instance, docGraph=... |
def register_Ns3FlowMonitorFlowStats_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::FlowMonitor::FlowStats const &', 'arg0')])
cls.add_instance_attribute('bytesDropped', 'std::vector< unsigned long long >', is_const=False)
cls.add_instance_attribute('delayHistogram',... |
class BasePA():
def __init__(self, C, mode, fit_intercept, data, learning_rate, rho):
self.C = C
self.calc_tau = {0: self._calc_tau_0, 1: self._calc_tau_1, 2: self._calc_tau_2}[mode]
self.fit_intercept = fit_intercept
self.weights_x = collections.defaultdict(float)
self.weigh... |
def model_state_to_cpu(model_state):
model_state_cpu = type(model_state)()
for (key, val) in model_state.items():
model_state_cpu[key] = val.cpu()
return model_state_cpu |
class _Loss(Module):
reduction: str
def __init__(self, size_average=None, reduce=None, reduction: str='mean') -> None:
super(_Loss, self).__init__()
if ((size_average is not None) or (reduce is not None)):
self.reduction: str = _Reduction.legacy_get_string(size_average, reduce)
... |
def main():
parser = HfArgumentParser((ModelArguments, DataArguments, TrainingArguments, ScriptArguments))
(model_args, data_args, training_args, script_args) = parser.parse_args_into_dataclasses()
logger.info(f'Model args: {model_args}')
logger.info(f'Data args: {data_args}')
logger.info(f'Training... |
def test_RegularArray_RecordArray_NumpyArray():
v2a = ak.contents.regulararray.RegularArray(ak.contents.recordarray.RecordArray([ak.contents.numpyarray.NumpyArray(np.array([0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6]))], ['nest']), 3)
assert (to_list(ak_from_buffers(*ak_to_buffers(v2a))) == to_list(v2a))
v2b = ak.co... |
_model
def resnet18(pretrained=False, **kwargs):
model_args = dict(block=BasicBlock, layers=[2, 2, 2, 2], **kwargs)
return _create_resnet('resnet18', pretrained, **model_args) |
def l1norm(X, eps=1e-13, dim=1):
norm = ((torch.abs(X).sum(dim=dim, keepdim=True) + eps) + 1e-14)
X = torch.div(X, norm)
return X |
def set_rng_seed(seed):
torch.manual_seed(seed)
random.seed(seed)
if TEST_NUMPY:
np.random.seed(seed) |
.parametrize('estimator, key, expected_results', [(NoTagsEstimator(), None, _DEFAULT_TAGS), (NoTagsEstimator(), 'allow_nan', _DEFAULT_TAGS['allow_nan']), (MoreTagsEstimator(), None, {**_DEFAULT_TAGS, **{'allow_nan': True}}), (MoreTagsEstimator(), 'allow_nan', True), (BaseEstimator(), None, _DEFAULT_TAGS), (BaseEstimato... |
def drop_block_fast_2d(x: torch.Tensor, drop_prob: float=0.1, block_size: int=7, gamma_scale: float=1.0, with_noise: bool=False, inplace: bool=False):
(B, C, H, W) = x.shape
total_size = (W * H)
clipped_block_size = min(block_size, min(W, H))
gamma = ((((gamma_scale * drop_prob) * total_size) / (clipped... |
def test_forward(model, epoch):
tic = time.time()
for i in range(epoch):
model.forward(is_train=True)
model.outputs[0].wait_to_read()
toc = time.time()
return ((toc - tic) / epoch) |
def CVAE_function(data, dimention_x, dimention_y, comandoEndoder='Encoder', redeVAE='CVAE45(sig)'):
from keras.models import model_from_json
from keras.utils import to_categorical
import keras.backend as K
from Model.BiLinearUp import BilinearUpsampling
function = comandoEndoder
def load_AE(name... |
class GaussianLSTMPolicy(StochasticPolicy):
def __init__(self, env_spec, hidden_dim=32, name='GaussianLSTMPolicy', hidden_nonlinearity=tf.nn.tanh, hidden_w_init=tf.glorot_uniform_initializer(), hidden_b_init=tf.zeros_initializer(), recurrent_nonlinearity=tf.nn.sigmoid, recurrent_w_init=tf.glorot_uniform_initializer... |
class AutoProcessor():
def __init__(self):
raise EnvironmentError('AutoProcessor is designed to be instantiated using the `AutoProcessor.from_pretrained(pretrained_model_name_or_path)` method.')
_list_option_in_docstrings(PROCESSOR_MAPPING_NAMES)
def from_pretrained(cls, pretrained_model_name_or_pat... |
class BaseOptimizer(Configurable):
def __init__(self, *args, **kwargs):
self._global_step = kwargs.pop('global_step', tf.Variable(0.0, trainable=False))
super(BaseOptimizer, self).__init__(*args, **kwargs)
self._accumulators = {}
return
def __call__(self, loss):
return se... |
def test_linear_same_dim():
time_dim = Dim(Tensor('time', [batch_dim], dtype='int32'))
(in_dim, out_dim) = (Dim(7, name='in'), Dim(13, name='out'))
extern_data = TensorDict({'data': Tensor('data', [batch_dim, time_dim, in_dim], dtype='float32'), 'classes': Tensor('classes', [batch_dim, time_dim], dtype='int... |
def load_file(p_path_to_data):
all_answers = []
query_ids = []
no_answer_query_ids = set()
yes_answer_query_ids = set()
with open(p_path_to_data, 'r', encoding='utf-8') as data_file:
for line in data_file:
try:
json_object = json.loads(line)
except jso... |
def plot_results(dataset, ax):
markers = ['o', 'v', 's']
colors_available = 10
ax.plot(observation_data, 'o-', label='Observation', color='k', lw=3, zorder=999)
ax.set_xlabel('Season', fontsize=18)
ax.set_ylabel('Temperature anomaly [C]', fontsize=18)
ax.set_xlim(('NDJ 2014/15', 'SON'))
ax.s... |
def parse_optfloat(val, default_val=None) -> Optional[float]:
if ((val == 'None') or (val is None)):
return default_val
return float(val) |
def mark_volatile(obj):
if torch.is_tensor(obj):
obj = Variable(obj)
if isinstance(obj, Variable):
obj.no_grad = True
return obj
elif isinstance(obj, collections.Mapping):
return {k: mark_volatile(o) for (k, o) in obj.items()}
elif isinstance(obj, collections.Sequence):
... |
class GraphLogger(Callback):
def on_train_start(self, trainer: Trainer, pl_module: LightningModule) -> None:
for logger in trainer.loggers:
if isinstance(logger, AnomalibWandbLogger):
logger.watch(pl_module, log_graph=True, log='all')
break
def on_train_end(se... |
class ReplaceLayer(BaseAction):
def __init__(self, layer_type: type, get_params_and_weights_fn: Callable):
self.layer_type = layer_type
self.get_params_and_weights_fn = get_params_and_weights_fn
def apply(self, node: BaseNode, graph: Graph, fw_info: FrameworkInfo):
activation_quantizatio... |
def _pad_target(t, length):
return np.pad(t, [(0, (length - t.shape[0])), (0, 0)], mode='constant', constant_values=_pad) |
def main():
description = '# Matcha-TTS: A fast TTS architecture with conditional flow matching\n ### [Shivam Mehta]( [Ruibo Tu]( [Jonas Beskow]( [Eva Szekely]( and [Gustav Eje Henter]( We propose Matcha-TTS, a new approach to non-autoregressive neural TTS, that uses conditional flow matching (similar to re... |
class ProphetNetForConditionalGeneration():
def __init__(self, *args, **kwargs):
requires_pytorch(self)
def from_pretrained(self, *args, **kwargs):
requires_pytorch(self) |
(**njit_dict_no_parallel)
def sample_energy(energy, intensity):
z = np.random.random()
average = (energy * intensity).sum()
total = 0
for (e, i) in zip(energy, intensity):
total += ((e * i) / average)
if (z <= total):
return e
return False |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.