code stringlengths 101 5.91M |
|---|
class EquivariantDipoleMoment(EquivariantScalar):
def __init__(self, hidden_channels, activation='silu'):
super(EquivariantDipoleMoment, self).__init__(hidden_channels, activation, allow_prior_model=False)
atomic_mass = torch.from_numpy(ase.data.atomic_masses).float()
self.register_buffer('a... |
def get_runner(experiment, options=None):
runners = json.load(open('runners.json', 'r'))
return (runners[experiment][options] if (options is not None) else runners[experiment]) |
def main():
sns.set_context('paper')
sns.set_style('white')
model_versions = ['distilgpt2', 'gpt2', 'gpt2-medium', 'gpt2-large', 'gpt2-xl']
filters = ['filtered', 'unfiltered']
for model_version in model_versions:
for filter in filters:
for split in ['dev', 'test']:
... |
def test_jieba_no_ssplit():
nlp = stanza.Pipeline(lang='zh', dir=TEST_MODELS_DIR, processors={'tokenize': 'jieba'}, tokenize_no_ssplit=True, package=None)
doc = nlp(ZH_DOC)
assert ('JiebaTokenizer' == nlp.processors['tokenize']._variant.__class__.__name__)
assert (ZH_DOC_GOLD_NOSSPLIT_TOKENS == '\n\n'.j... |
_model
def densenet169(pretrained=False, **kwargs):
model = _densenet('densenet169', growth_rate=32, block_config=(6, 12, 32, 32), pretrained=pretrained, **kwargs)
return model |
def score_sequences(y_true: List[List[int]], y_pred: List[List[int]], metrics: Set[str]=None) -> Dict[(str, float)]:
scorers = {'accuracy': seqeval.metrics.accuracy_score, 'precision': seqeval.metrics.precision_score, 'recall': seqeval.metrics.recall_score, 'f1': seqeval.metrics.f1_score}
metrics = (metrics if ... |
def visualize_rgb(tif_path, cut_off_value=2000, show=False, save='tmp.png', force_process_all=False):
plot = plt.figure()
src = rasterio.open(('gs://' + tif_path))
if (not force_process_all):
if ((src.width * src.height) > (3451 * 4243)):
print('skipping too large~ ', src.width, src.heig... |
def extracted_glob(extracted_folder, file_patterns, src, tgt, lang):
def get_matching_pattern(file_pattern):
params = {k: v for (k, v) in [('src', src), ('tgt', tgt), ('lang', lang)] if ((('{' + k) + '}') in file_pattern)}
file_pattern = re.sub('{src:(.*?)}', ('\\1' if (lang == src) else ''), file_p... |
def autodoc_skip_member(app, what, name, obj, skip, options):
exclusions = ('yaml_constructors', 'yaml_implicit_resolvers')
exclude = (name in exclusions)
return (skip or exclude) |
class BraTSDatasetLSTM(Dataset):
__im = []
__mask = []
__im1 = []
__im3 = []
im_ht = 0
im_wd = 0
dataset_size = 0
def __init__(self, dataset_folder, train=True, keywords=['P1', '1', 'flair'], im_size=[128, 128], transform=None):
self.__file = []
self.__im = []
sel... |
def banner(msg: str) -> Callable:
p = (lambda s: print(s, file=sys.stderr, flush=True))
def decorate(f: Callable) -> Callable:
sig = inspect.signature(f)
C = escape_codes['bold_cyan']
R = escape_codes['bold_red']
N = escape_codes['reset']
def wrapper(*args, **kwargs):
... |
def _update_zipimporter_cache(normalized_path, cache, updater=None):
for p in _collect_zipimporter_cache_entries(normalized_path, cache):
old_entry = cache[p]
del cache[p]
new_entry = (updater and updater(p, old_entry))
if (new_entry is not None):
cache[p] = new_entry |
class GMMTrainer():
def __init__(self, model, dataloader_train, dataloader_val, gpu_id, log_freq, save_dir):
if torch.cuda.is_available():
self.device = torch.device(('cuda:' + str(gpu_id)))
else:
self.device = torch.device('cpu')
self.model = model.to(self.device)
... |
def heatmap_viz(df: pd.DataFrame, x: str, y: str, grp_cnt_stats: Dict[(str, int)], plot_width: int, plot_height: int) -> Panel:
title = _make_title(grp_cnt_stats, x, y)
source = ColumnDataSource(data=df)
palette = RDBU[((len(RDBU) // 2) - 1):]
mapper = LinearColorMapper(palette=palette, low=(df['cnt'].m... |
_utils.in_tempdir
def test_dory_query_workflow_remove_pendants(location):
from spacegraphcats.cdbg import bcalm_to_gxt, sort_bcalm_unitigs
copy_dory_head()
copy_dory_subset()
try:
os.mkdir('dory_k21')
os.mkdir('dory_k21_r1')
except FileExistsError:
pass
args = ['-k', '21'... |
class RandomResizedCrop(object):
def __init__(self, size, scale=(0.08, 1.0), ratio=((3.0 / 4.0), (4.0 / 3.0)), interpolation=Image.BILINEAR):
if isinstance(size, (tuple, list)):
self.size = size
else:
self.size = (size, size)
if ((scale[0] > scale[1]) or (ratio[0] > r... |
class Logger(object):
def __init__(self, file_name: str=None, file_mode: str='w', should_flush: bool=True):
self.file = None
if (file_name is not None):
self.file = open(file_name, file_mode)
self.should_flush = should_flush
self.stdout = sys.stdout
self.stderr = ... |
def clean_time(utter):
utter = re.sub('(\\d+) ([ap]\\.?m)', (lambda x: (x.group(1) + x.group(2))), utter)
utter = re.sub('((?<!\\d)\\d:\\d+)(am)?', '0\\1', utter)
utter = re.sub('((?<!\\d)\\d)am', '0\\1:00', utter)
utter = re.sub('((?<!\\d)\\d)pm', (lambda x: (str((int(x.group(1)) + 12)) + ':00')), utte... |
_function_dispatch(_fft_dispatcher)
def ifft(a, n=None, axis=(- 1), norm=None):
a = asarray(a)
if (n is None):
n = a.shape[axis]
if ((norm is not None) and _unitary(norm)):
inv_norm = sqrt(max(n, 1))
else:
inv_norm = n
output = _raw_fft(a, n, axis, False, False, inv_norm)
... |
def runNonMotifCASC(inputName, outputDir, clusters, beta, oldAssignmentsName):
if (outputDir is not None):
oldDir = ('%s/old/' % outputDir)
makeDir(oldDir)
outputDir = oldDir
return runTest(0, inputName, outputDir, clusters, beta, 1, 1, oldAssignmentsName, 15) |
class RandomWeakPushCartPole(ModifiableCartPoleEnv):
def __init__(self):
super(RandomWeakPushCartPole, self).__init__()
self.force_mag = uniform_exclude_inner(self.np_random.uniform, self.EXTREME_LOWER_FORCE_MAG, self.EXTREME_UPPER_FORCE_MAG, self.RANDOM_LOWER_FORCE_MAG, self.RANDOM_UPPER_FORCE_MAG)... |
def register_types(module):
root_module = module.get_root()
module.add_enum('EnvironmentType', ['UrbanEnvironment', 'SubUrbanEnvironment', 'OpenAreasEnvironment'], import_from_module='ns.propagation')
module.add_enum('CitySize', ['SmallCity', 'MediumCity', 'LargeCity'], import_from_module='ns.propagation')
... |
.parametrize('ctx, func_name', ctxs)
.parametrize('seed', [313])
.parametrize('including_pad', [True, False])
.parametrize('ignore_border', [True, False])
.parametrize('channel_last', [False, True])
.parametrize('inshape, kernel, stride, pad', [((3, 4, 6), (2, 2, 2), (2, 1, 1), (1, 0, 1)), ((2, 3, 4, 6), (2, 2, 2), (1,... |
def register_Ns3LteRrcSapSoundingRsUlConfigCommon_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::LteRrcSap::SoundingRsUlConfigCommon const &', 'arg0')])
cls.add_instance_attribute('srsBandwidthConfig', 'uint8_t', is_const=False)
cls.add_instance_attribute('srsSubfram... |
class MelspecInversion(nn.Module):
def __init__(self, n_mels: int=128, sample_rate: int=24000, win_length: int=1024, hop_length: int=256):
super().__init__()
self.n_mels = n_mels
self.sample_rate = sample_rate
self.win_length = win_length
self.hop_length = hop_length
... |
def _transfer(func):
def wrapper(manager, *arg):
returns = []
for callback in manager.callbacks:
if callback.disabled:
continue
returns.append(getattr(callback, func.__name__)(*arg))
return returns
return wrapper |
def process_punctuation(inText):
outText = inText
for p in punct:
if ((((p + ' ') in inText) or ((' ' + p) in inText)) or (re.search(comma_strip, inText) != None)):
outText = outText.replace(p, '')
else:
outText = outText.replace(p, ' ')
outText = period_strip.sub('',... |
class TestExpandOp(serial.SerializedTestCase):
def _rand_shape(self, X_shape, max_length):
length = np.random.randint(max_length)
shape = np.ones(length, dtype=np.int64)
i = (len(X_shape) - 1)
for j in reversed(range(length)):
if (i >= 0):
k = np.random.ch... |
def main():
initialize()
gui = ti.GUI('Taichi MLS-MPM-99', res=512, background_color=1126209)
while (not gui.get_event(ti.GUI.ESCAPE, ti.GUI.EXIT)):
for s in range(int((0.002 // dt))):
substep()
gui.circles(x.to_numpy(), radius=1.5, palette=[427399, , ], palette_indices=material)... |
def render_model(verts, faces, w, h, cam, near=0.5, far=25, img=None):
rn = _create_renderer(w=w, h=h, near=near, far=far, rt=cam.rt, t=cam.t, f=cam.f, c=cam.c)
if (img is not None):
rn.background_image = ((img / 255.0) if (img.max() > 1) else img)
imtmp = simple_renderer(rn, verts, faces)
if (i... |
class ConstantPool():
def __init__(self):
self._constants: dict[(type[ConstantTypes], OrderedSet[ConstantTypes])] = {tp_: OrderedSet() for tp_ in typing.get_args(ConstantTypes)}
def add_constant(self, constant: ConstantTypes) -> None:
self._constants[type(constant)].add(constant)
def remove_... |
def get_model_inference(parameters: Params, weights_path: str=None):
(h, w) = parameters.input_shape
c = parameters.input_channels
input_images = Input(shape=(h, w, c), name='input_images')
input_seq_len = Input(shape=[1], dtype=tf.int32, name='input_seq_length')
filename_images = Input(shape=[1], d... |
class BleuScorer(object):
__slots__ = ('n', 'crefs', 'ctest', '_score', '_ratio', '_testlen', '_reflen', 'special_reflen')
def copy(self):
new = BleuScorer(n=self.n)
new.ctest = copy.copy(self.ctest)
new.crefs = copy.copy(self.crefs)
new._score = None
return new
def _... |
def main(_):
_logger = logging.getLogger('tensorflow')
_logger.setLevel('INFO')
tf_compat.v1.logging.info(('%s startup. TF version: %s' % (__file__, tf.__version__)))
if FLAGS.checkpoints:
checkpoints = [c.strip() for c in FLAGS.checkpoints.split(',')]
checkpoints = [c for c in checkpoin... |
def test_leverage_bagging_me():
stream = ConceptDriftStream(position=500, width=100, random_state=112)
nb = NaiveBayes()
learner = LeveragingBaggingClassifier(base_estimator=nb, n_estimators=5, random_state=112, leverage_algorithm='leveraging_bag_me')
y_expected = np.asarray([0, 0, 0, 1, 0, 1, 0, 0, 1, ... |
def pesq_eval(predict, target):
return ((pesq(fs=16000, ref=target.numpy(), deg=predict.numpy(), mode='wb') + 0.5) / 5) |
class AttentionWeightComputation(Function):
def forward(ctx, query_batch_cnt: torch.Tensor, key_batch_cnt: torch.Tensor, index_pair_batch: torch.Tensor, index_pair: torch.Tensor, query_features: torch.Tensor, key_features: torch.Tensor):
assert query_batch_cnt.is_contiguous()
assert key_batch_cnt.is... |
class DiscreteBCQImpl(DoubleDQNImpl):
_modules: DiscreteBCQModules
_action_flexibility: float
_beta: float
def __init__(self, observation_shape: Shape, action_size: int, modules: DiscreteBCQModules, q_func_forwarder: DiscreteEnsembleQFunctionForwarder, targ_q_func_forwarder: DiscreteEnsembleQFunctionFor... |
class RemoteFolderDataset(FolderDataset, RemoteDataset):
def __init__(self, root: Union[(str, Path)], download_and_extract: bool=False, overwrite: bool=False, cleanup: bool=False, convert: bool=False, kind: str='json', n_jobs: int=1, ignore_exceptions: bool=True, use_converted: bool=None, verbose: bool=True):
... |
def main():
args = get_arg()
random.seed(RAND_SEED)
np.random.seed(RAND_SEED)
torch.manual_seed(RAND_SEED)
data = load_stage2_train_all_data(datatrack=args.datatrack, feat_type=args.feat_type)
if (args.method == 'ridge'):
model = Ridge()
elif (args.method == 'linear_svr'):
mo... |
class NanDetector():
def __init__(self, model, forward=True, backward=True):
self.bhooks = []
self.fhooks = []
self.forward = forward
self.backward = backward
self.reset()
for (name, mod) in model.named_modules():
mod.__module_name = name
self.... |
def msvc_runtime_library():
ver = msvc_runtime_major()
if ver:
if (ver < 140):
return ('msvcr%i' % ver)
else:
return ('vcruntime%i' % ver)
else:
return None |
def _randomly_negate_tensor(tensor):
should_flip = tf.cast(tf.floor((tf.random.uniform([]) + 0.5)), tf.bool)
final_tensor = tf.cond(should_flip, (lambda : tensor), (lambda : (- tensor)))
return final_tensor |
def readArk(filename, limit=numpy.inf):
features = []
uttids = []
with open(filename, 'rb') as f:
while True:
try:
uttid = readString(f)
except ValueError:
break
feature = readMatrix(f)
features.append(feature)
... |
def max_memory_reserved(device: Union[(Device, int)]=None) -> int:
return memory_stats(device=device)['reserved_bytes.all.peak'] |
def parse_serverdesc(args):
(path, min_time, max_time) = args
relay = next(parse_file(path, document_handler='DOCUMENT', descriptor_type='server-descriptor 1.0', validate=False))
if (relay is None):
return None
pub_ts = relay.published.replace(tzinfo=timezone.utc).timestamp()
if ((pub_ts < m... |
class _Sigma0Embedding(Morphism):
def __init__(self, domain):
Morphism.__init__(self, domain.Hom(domain._matrix_space, category=Monoids()))
def _call_(self, x):
return x.matrix()
def _richcmp_(self, other, op):
return richcmp(self.domain(), other.domain(), op) |
_task('masked_lm', dataclass=MaskedLMConfig)
class MaskedLMTask(FairseqTask):
cfg: MaskedLMConfig
def __init__(self, cfg: MaskedLMConfig, dictionary):
super().__init__(cfg)
self.dictionary = dictionary
self.mask_idx = dictionary.add_symbol('<mask>')
def setup_task(cls, cfg: MaskedLMC... |
class FlaxGPTJForCausalLM(metaclass=DummyObject):
_backends = ['flax']
def __init__(self, *args, **kwargs):
requires_backends(self, ['flax']) |
def _cleanse_included_implicit_return_none(subject_properties, statement_checked_lines, statement_slice):
if ((len(statement_slice) >= 3) and (statement_slice[(- 3)].opcode == op.LOAD_CONST) and (statement_slice[(- 3)].arg is None) and (statement_slice[(- 2)].opcode == op.RETURN_VALUE)):
if ((len(statement_... |
def summarize_report(current_iteration, num_updates, max_updates, meter, should_print=True, extra=None, tb_writer=None, wandb_logger=None):
if (extra is None):
extra = {}
if ((not is_main()) and (not is_xla())):
return
if (wandb_logger and ('lr' in extra)):
wandb_logger.log_metrics({... |
def test_to():
env_names = ['CartPole-v0', 'CartPole-v1']
task_envs = [GarageEnv(env_name=name) for name in env_names]
env = MultiEnvWrapper(task_envs, sample_strategy=round_robin_strategy)
deterministic.set_seed(0)
policy = TanhGaussianMLPPolicy(env_spec=env.spec, hidden_sizes=[1, 1], hidden_nonlin... |
def count_lus(lus_str):
total_freq = 0
lus_bow = {}
for lu in lus_str.split(','):
try:
(lu_name, lu_freq) = lu.split(':')
lu_name = lu_name.strip()
if (' ' in lu_name):
continue
lu_freq = int(lu_freq)
lus_bow[lu_name] = lu_f... |
def load_mat_training_data(real_fts_dir: str, gan_fts_dir: str, num_examples: int, split: float):
real_fts_files = [os.path.join(real_fts_dir, i) for i in os.listdir(real_fts_dir) if i.endswith('.mat')]
gan_fts_files = [os.path.join(gan_fts_dir, i) for i in os.listdir(gan_fts_dir) if i.endswith('.mat')]
rea... |
def main():
(examples, label_list) = get_data(task=args.task, train_num_per_class=args.train_num_per_class, dev_num_per_class=args.dev_num_per_class, imbalance_rate=args.imbalance_rate, data_seed=args.data_seed)
if (args.task in ['sst-2', 'sst-5']):
classifier = Classifier(label_list=label_list, device=... |
_utils.test()
def test_stacked_mixed_ib_and_non_ib_inner_loops_local_variable():
x = ti.field(dtype=float, shape=(), needs_dual=True)
arr = ti.field(dtype=float, shape=2, needs_dual=True)
loss = ti.field(dtype=float, shape=(), needs_dual=True)
def stacked_mixed_ib_and_non_ib_inner_loops_local_variable()... |
class Settings():
def __init__(self):
self._lock = threading.Lock()
self._parent_configs = {}
self._local = threading.local()
def _get_current_config(self):
return (self._local.config_stack[(- 1)] if (hasattr(self._local, 'config_stack') and self._local.config_stack) else {})
... |
def evaluate(args, model, tokenizer, output_prediction=False):
(dataset, examples) = load_and_cache_examples(args, tokenizer, evaluate=True, output_examples=True)
if ((not os.path.exists(args.output_dir)) and (args.local_rank in [(- 1), 0])):
os.makedirs(args.output_dir)
args.eval_batch_size = (args... |
def create_tar_command(args):
Uploader(log=log, progress=Progress()).convert(args.source, args.destination) |
class SawyerHandlePressEnv(SawyerXYZEnv):
def __init__(self):
hand_low = ((- 0.5), 0.4, 0.05)
hand_high = (0.5, 1, 0.5)
obj_low = ((- 0.1), 0.8, 0.05)
obj_high = (0.1, 0.9, 0.05)
goal_low = ((- 0.1), 0.65, 0.0399)
goal_high = (0.1, 0.75, 0.0401)
super().__init... |
def _showxv(image, title=None, **options):
from . import ImageShow
ImageShow.show(image, title, **options) |
def add_model_training_inputs(model):
logger = logging.getLogger(__name__)
logger.info('Loading dataset: {}'.format(cfg.TRAIN.DATASETS))
roidb = combined_roidb_for_training(cfg.TRAIN.DATASETS, cfg.TRAIN.PROPOSAL_FILES)
logger.info('{:d} roidb entries'.format(len(roidb)))
model_builder_wsl.add_traini... |
def ModAbVar_ambient_jacobian(group):
try:
X = _cache[group]()
if (X is not None):
return X
except KeyError:
pass
X = ModAbVar_ambient_jacobian_class(group)
_cache[group] = weakref.ref(X)
return X |
def run_clang_tidy(options, line_filters, files):
command = [options.clang_tidy_exe, '-p', options.compile_commands_dir]
if ((not options.config_file) and os.path.exists('.clang-tidy')):
options.config_file = '.clang-tidy'
if options.config_file:
import yaml
with open(options.config_... |
def contract_mwt(infile, outfile, ignore_gapping=True):
with open(outfile, 'w') as fout:
with open(infile, 'r') as fin:
idx = 0
mwt_begin = 0
mwt_end = (- 1)
for line in fin:
line = line.strip()
if line.startswith('#'):
... |
def _format(val: Any, output_format: str='standard', errors: str='coarse') -> Any:
val = str(val)
result: Any = []
if (val in NULL_VALUES):
return [np.nan]
if (not validate_ca_sin(val)):
if (errors == 'raise'):
raise ValueError(f'Unable to parse value {val}')
error_re... |
class attentionNet(nn.Module):
def __init__(self, squeezeFilters=32, expandFilters=64, scailingFactor=2, numAttentionBlock=10):
super(attentionNet, self).__init__()
self.inputConv = nn.Conv2d(3, squeezeFilters, 3, 1, 1)
self.globalPooling = nn.AvgPool2d(2, 2)
depthAttenBlock = []
... |
def register_Ns3Ipv4GlobalRouting_methods(root_module, cls):
cls.add_constructor([param('ns3::Ipv4GlobalRouting const &', 'arg0')])
cls.add_constructor([])
cls.add_method('AddASExternalRouteTo', 'void', [param('ns3::Ipv4Address', 'network'), param('ns3::Ipv4Mask', 'networkMask'), param('ns3::Ipv4Address', '... |
def load_pickle_model(model_path: str) -> CRF:
with open(model_path, 'rb') as pkl_model:
model = pickle.load(pkl_model)
return model |
def read_sentences(filename, encoding):
sents = []
cache = []
skipped = 0
skip = False
with open(filename, encoding=encoding) as infile:
for (i, line) in enumerate(infile):
line = line.rstrip()
if (len(line) == 0):
if (len(cache) > 0):
... |
def download_weight(link, file_name, verbose=True):
response = requests.get(link, stream=True)
total_size_in_bytes = int(response.headers.get('content-length', 0))
block_size = 1024
progress_bar = tqdm(total=total_size_in_bytes, unit='iB', unit_scale=True, desc='downloading defualt weights', disable=(Fa... |
def save_pngs(chunk):
output_path = '/tmp/test/'
save_pngs_operator = SavePNGsOperator(output_path)
save_pngs_operator(chunk)
print('remove the temporary directory.')
shutil.rmtree(output_path) |
def get_the_pile_document_iterator(file_path: str) -> Iterator[str]:
with open(file_path, 'r') as f:
for line in f:
(yield json.loads(line)['text']) |
class CNNEvaluation(object):
def __init__(self, gpu_num, dataset='cifar10', verbose=True, epoch_num=50, batchsize=16, imgSize=32):
self.gpu_num = gpu_num
self.epoch_num = epoch_num
self.batchsize = batchsize
self.dataset = dataset
self.verbose = verbose
self.imgSize =... |
class Cusps_class(Singleton, Parent):
def __init__(self):
Parent.__init__(self, self)
Element = Cusp
def _repr_(self):
return 'Set P^1(QQ) of all cusps'
def _latex_(self):
return '\\mathbf{P}^1(\\QQ)'
def __call__(self, x):
return Cusp(x)
def _coerce_map_from_(sel... |
def register_Ns3PdcpTag_methods(root_module, cls):
cls.add_constructor([param('ns3::PdcpTag const &', 'arg0')])
cls.add_constructor([])
cls.add_constructor([param('ns3::Time', 'senderTimestamp')])
cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'i')], is_virtual=True)
cls.add_method('... |
class FeaturesManager():
_TASKS_TO_AUTOMODELS = {}
_TASKS_TO_TF_AUTOMODELS = {}
if is_torch_available():
_TASKS_TO_AUTOMODELS = {'default': AutoModel, 'masked-lm': AutoModelForMaskedLM, 'causal-lm': AutoModelForCausalLM, 'seq2seq-lm': AutoModelForSeq2SeqLM, 'sequence-classification': AutoModelForSeq... |
def test_test_dataloader():
movieLensDataHandler = AEDataHandler('MovieLensSmall', train_data_path, validation_input_data_path, validation_output_data_path, test_input_data_path, test_output_data_path)
test_dataloader = movieLensDataHandler.get_test_dataloader()
count = 0
for batch in test_dataloader:
... |
def distance_transform_cdt(input, metric='chessboard', return_distances=True, return_indices=False, distances=None, indices=None):
if ((not return_distances) and (not return_indices)):
msg = 'at least one of distances/indices must be specified'
raise RuntimeError(msg)
ft_inplace = isinstance(ind... |
class AMAZON2Processor(TextClassProcessor):
def __init__(self):
self.has_title = True
def get_labels(self):
return [str(i) for i in range(1, 3)]
def get_train_size(self):
return 3600000
def get_dev_size(self):
return 400000
def get_unsup_examples(self, raw_data_dir, u... |
class DefaultJsonEncoder(json.JSONEncoder):
def default(self, o):
if isinstance(o, np.ndarray):
return o.tolist()
if isinstance(o, np.generic):
return o.item()
if (isinstance(o, pd.DataFrame) or isinstance(o, pd.Series)):
return o.to_dict()
if isin... |
def main():
config = parser.parse_args()
fine_LSTM = MyModel.fine_LSTM(config).cuda(config.use_gpu)
coarseNet = MyModel.coarseNet(config).cuda(config.use_gpu)
if (config.stage == 'test'):
fine_LSTM = torch.load(((('output/' + '730') + config.testName) + 'fine_LSTM.pkl'), map_location=(lambda sto... |
class CrossEntropyLoss2d(nn.Module):
def __init__(self, weight=None, ignore_index=255, reduction='mean', label_smoothing=0.0, loss_weight=1.0, loss_name='ce_loss'):
super(CrossEntropyLoss2d, self).__init__()
self.loss_weight = loss_weight
self._loss_name = loss_name
self.criterion = ... |
(**njit_dict_no_parallel)
def deposition_estimator_kasen(energy, ejecta_density, iron_group_fraction):
return ((get_average_compton_fraction(energy) * compton_opacity_calculation(energy, ejecta_density)) + photoabsorption_opacity_calculation(energy, ejecta_density, iron_group_fraction)) |
class LabelSmoothingCrossEntropy(nn.Module):
def __init__(self, : float=0.1, reduction='mean'):
super().__init__()
(self., self.reduction) = (, reduction)
def forward(self, output, target):
c = output.size()[(- 1)]
log_preds = F.log_softmax(output, dim=(- 1))
loss = reduc... |
def make_tree(cfg, logger=None):
if (logger is not None):
logger('\n[Preparing loss...]')
loss_file = cfg.loss
if (not loss_file.lower().endswith('.txt')):
loss_file += '.txt'
with open(loss_file, 'r') as f:
lines = f.read().splitlines()
lines = parse(lines)
hparams = par... |
def _fused_bias_act_cuda(x, b, axis, act, alpha, gain):
x = tf.convert_to_tensor(x)
empty_tensor = tf.constant([], dtype=x.dtype)
b = (tf.convert_to_tensor(b) if (b is not None) else empty_tensor)
act_spec = activation_funcs[act]
assert ((len(b.shape) == 1) and ((b.shape[0] == 0) or (b.shape[0] == x... |
def zou_et_al_criterion_rescaling(criterion, n_samples, noise_variance):
return ((criterion - (n_samples * np.log(((2 * np.pi) * noise_variance)))) - n_samples) |
def rerank(model_file, ctx_file, rnk_file, score=False):
output_wfile = open(((rnk_file + '_LEN') + ('.f' if score else '.gen')), 'w')
begin = True
for (ctx_line, rnk_line) in itertools.izip(open(ctx_file), open(rnk_file)):
suffix = ctx_line.strip().split('\t')
candidates = rnk_line.strip().... |
class DecoderBlockPreNorm(DecoderBlock):
def __init__(self, *kargs, **kwargs):
super(DecoderBlockPreNorm, self).__init__(*kargs, **kwargs)
def forward(self, inputs, context, state=None):
x = inputs
res = x
x = (self.lnorm1(x) if hasattr(self, 'lnorm1') else x)
if self.sta... |
def mask_tokens(inputs, mlm_probability, tokenizer, special_tokens_mask):
labels = np.copy(inputs)
probability_matrix = np.random.random_sample(labels.shape)
special_tokens_mask = special_tokens_mask.astype(np.bool_)
probability_matrix[special_tokens_mask] = 0.0
masked_indices = (probability_matrix ... |
def load_dataset(args):
transform_px = tr.Compose([tr.ToTensor(), (lambda x: (x * 255))])
if (args.dataset == 'cifar100'):
cls = dataset_without_label(torchvision.datasets.CIFAR100)
test_dataset = cls(root=args.data_path, transform=transform_px)
elif (args.dataset in ['celeba', 'img32', 'tin... |
class FeatureSparseToDense(ModelLayer):
def __init__(self, model, input_record, input_specs, name='feature_sparse_to_dense', default_dense_value=None, **kwargs):
super(FeatureSparseToDense, self).__init__(model, name, input_record, **kwargs)
if (default_dense_value is None):
default_dens... |
class SegmentationSoftmax(Layer):
output_layer = True
def __init__(self, name, inputs, dataset, network_input_dict, tower_setup, resize_targets=False, resize_logits=False, loss='ce', fraction=None):
super().__init__()
self.n_classes = dataset.num_classes()
targets = network_input_dict[Da... |
class anglit_gen(rv_continuous):
def _shape_info(self):
return []
def _pdf(self, x):
return np.cos((2 * x))
def _cdf(self, x):
return (np.sin((x + (np.pi / 4))) ** 2.0)
def _sf(self, x):
return (np.cos((x + (np.pi / 4))) ** 2.0)
def _ppf(self, q):
return (np.a... |
def add_context(stat: Stat, context: MetricContext) -> Stat:
return Stat(replace(stat.name, split=context.split, sub_split=context.sub_split, perturbation=context.perturbation)).merge(stat) |
def get_keras_lstm(num_buckets, embed_dim=16, rnn_state_size=64):
lstm_model = tf.keras.Sequential()
lstm_model.add(tf.keras.layers.Embedding(num_buckets, embed_dim))
lstm_model.add(tf.keras.layers.LSTM(rnn_state_size, activation=tf.nn.relu))
lstm_model.add(tf.keras.layers.Dense(1, activation=tf.nn.sigm... |
_utils.test(arch=[ti.cuda, ti.vulkan, ti.amdgpu])
def test_shared_array_atomics():
N = 256
block_dim = 32
def atomic_test(out: ti.types.ndarray()):
ti.loop_config(block_dim=block_dim)
for i in range(N):
tid = (i % block_dim)
val = tid
sharr = ti.simt.block... |
def realize_text_and_extract_scene(scene, template, filter_objs):
default_list = (lambda : collections.defaultdict(list))
graph = {'relationships': collections.defaultdict(default_list), 'counts': {}, 'exists': {}, 'history': [], 'objects': {}}
n_inputs = template.get('inputs', 1)
text_sample = random.c... |
def train_model():
(g, train_tensor) = build_model()
with g.as_default():
slim.learning.train(train_tensor, FLAGS.checkpoint_dir, is_chief=(FLAGS.task == 0), master=FLAGS.master, log_every_n_steps=FLAGS.log_every_n_steps, graph=g, number_of_steps=FLAGS.number_of_steps, save_summaries_secs=FLAGS.save_sum... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.