function stringlengths 11 56k | repo_name stringlengths 5 60 | features list |
|---|---|---|
def epsilon_greedy(state_vector, epsilon):
"""Returns an action selected by an epsilon-greedy exploration policy
Args:
state_vector (torch.FloatTensor): extracted vector representation
theta (np.ndarray): current weight matrix
epsilon (float): the probability of choosing a random comman... | xunilrj/sandbox | [
8,
4,
8,
117,
1469995922
] |
def __init__(self, state_dim, action_dim, object_dim, hidden_size=100):
super(DQN, self).__init__()
self.state_encoder = nn.Linear(state_dim, hidden_size)
self.state2action = nn.Linear(hidden_size, action_dim)
self.state2object = nn.Linear(hidden_size, object_dim) | xunilrj/sandbox | [
8,
4,
8,
117,
1469995922
] |
def deep_q_learning(current_state_vector, action_index, object_index, reward,
next_state_vector, terminal):
"""Updates the weights of the DQN for a given transition
Args:
current_state_vector (torch.FloatTensor): vector representation of current state
action_index (int): ind... | xunilrj/sandbox | [
8,
4,
8,
117,
1469995922
] |
def run_episode(for_training):
"""
Runs one episode
If for training, update Q function
If for testing, computes and return cumulative discounted reward
"""
epsilon = TRAINING_EP if for_training else TESTING_EP
# initialize for each episode
i = 0
epi_reward = 0
(curre... | xunilrj/sandbox | [
8,
4,
8,
117,
1469995922
] |
def run_epoch():
"""Runs one epoch and returns reward averaged over test episodes"""
rewards = []
for _ in range(NUM_EPIS_TRAIN):
run_episode(for_training=True)
for _ in range(NUM_EPIS_TEST):
rewards.append(run_episode(for_training=False))
return np.mean(np.array(rewards)) | xunilrj/sandbox | [
8,
4,
8,
117,
1469995922
] |
def test_args(kwargs, expected):
assert tftest.parse_args() == []
assert tftest.parse_args(**kwargs) == expected | GoogleCloudPlatform/terraform-python-testing-helper | [
154,
30,
154,
4,
1553196033
] |
def test_terragrunt_args(kwargs, expected):
assert tftest.parse_args(**kwargs) == expected | GoogleCloudPlatform/terraform-python-testing-helper | [
154,
30,
154,
4,
1553196033
] |
def test_import(self):
self.assertTrue(hasattr(fedjax, 'FederatedAlgorithm'))
self.assertTrue(hasattr(fedjax.aggregators, 'Aggregator'))
self.assertTrue(hasattr(fedjax.algorithms, 'fed_avg'))
self.assertTrue(hasattr(fedjax.datasets, 'emnist'))
self.assertTrue(hasattr(fedjax.models, 'emnist'))
se... | google/fedjax | [
221,
41,
221,
10,
1608648243
] |
def h2oinit():
"""
Python API test: h2o.init(url=None, ip=None, port=None, name = None, https=None, insecure=None,
username=None, password=None, ookies=None, proxy=None, start_h2o=True, nthreads=-1, ice_root=None,
enable_assertions=True, max_mem_size=None, min_mem_size=None, strict_version_check=None, *... | h2oai/h2o-3 | [
6169,
1943,
6169,
208,
1393862887
] |
def h2oinit_default_log_dir():
tmpdir = tempfile.mkdtemp()
try:
h2o.init(strict_version_check=False, name="default_log", ice_root=tmpdir)
except H2OConnectionError as e: # some errors are okay like version mismatch
print("error message type is {0} and the error message is {1}\n".format(e.__... | h2oai/h2o-3 | [
6169,
1943,
6169,
208,
1393862887
] |
def h2oinit_fail_invalid_log_level():
try:
h2o.init(strict_version_check=False, log_level="BAD_LOG_LEVEL")
assert False, "Should fail to start an h2o instance with an invalid log level."
except H2OConnectionError as e: # some errors are okay like version mismatch
assert False, "Should f... | h2oai/h2o-3 | [
6169,
1943,
6169,
208,
1393862887
] |
def __init__(self,
units=64,
mode=modes.Modes.TRAINING,
inference_batch_size=1,
return_sequences=False,
use_peepholes=False,
num_proj=128,
unroll=False,
stateful=False,
name='LSTM',
... | google-research/google-research | [
27788,
6881,
27788,
944,
1538678568
] |
def get_config(self):
config = {
'mode': self.mode,
'inference_batch_size': self.inference_batch_size,
'units': self.units,
'return_sequences': self.return_sequences,
'unroll': self.unroll,
'num_proj': self.num_proj,
'use_peepholes': self.use_peepholes,
... | google-research/google-research | [
27788,
6881,
27788,
944,
1538678568
] |
def get_output_state(self):
# output state is used only for STREAM_EXTERNAL_STATE_INFERENCE mode
if self.mode == modes.Modes.STREAM_EXTERNAL_STATE_INFERENCE:
return [self.output_state1, self.output_state2]
else:
raise ValueError('Expected the layer to be in external streaming mode, '
... | google-research/google-research | [
27788,
6881,
27788,
944,
1538678568
] |
def _streaming_external_state(self, inputs, state1, state2):
# first dimension is batch size
if inputs.shape[0] != self.inference_batch_size:
raise ValueError(
'inputs.shape[0]:%d must be = self.inference_batch_size:%d' %
(inputs.shape[0], self.inference_batch_size))
# receive inp... | google-research/google-research | [
27788,
6881,
27788,
944,
1538678568
] |
def Params(cls):
p = super().Params()
p.Define('split', True, '')
return p | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def InfeedBatchSize(self):
if self.params.split:
return 10 / 2
return 10 | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def _InputParams(self):
p = input_generator.NmtInput.Params()
input_file = test_helper.test_src_dir_path(
'tasks/mt/testdata/wmt14_ende_wpm_32k_test.tfrecord')
vocab_file = test_helper.test_src_dir_path(
'tasks/mt/testdata/wmt14_ende_wpm_32k_test.vocab')
p.file_pattern = 'tfrecord:' + in... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def _DecoderParams(self):
p = decoder.TransformerDecoder.Params()
p.name = 'decoder'
p.random_seed = 1234
p.source_dim = 4
p.model_dim = 4
p.token_emb.embedding_dim = 4
p.token_emb.max_num_shards = 1
p.token_emb.params_init = py_utils.WeightInit.GaussianSqrtDim(
seed=p.random_see... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testConstruction(self):
with self.session():
p = self._testParams()
mdl = p.Instantiate()
print('vars = ', mdl.vars)
flatten_vars = mdl.vars.Flatten()
print('vars flattened = ', flatten_vars)
self.assertEqual(len(flatten_vars), 238)
# Should match tf.trainable_variable... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testFPropEvalMode(self):
with self.session(), self.SetEval(True):
tf.random.set_seed(_TF_RANDOM_SEED)
p = self._testParams()
mdl = p.Instantiate()
mdl.FPropDefaultTheta()
loss = mdl.loss
logp = mdl.eval_metrics['log_pplx'][0]
self.evaluate(tf.global_variables_initialize... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testBPropWithAccumComparison(self):
def _SetDefaults(p):
p.random_seed = 12345
p.decoder.input_dropout_prob = 0.0
mp = p.encoder.transformer_stack.transparent_merger_tpl
mp.weighted_merger_dropout_prob = 0.0
disable_vn = py_utils.VariationalNoiseParams(1.0, False, False)
for... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def Run(num_splits):
with self.session(use_gpu=False, graph=tf.Graph()):
tf.random.set_seed(93820981)
p = self._testParams()
p.input.bucket_batch_limit = [
b * 2 / num_splits for b in p.input.bucket_batch_limit
]
with cluster_factory.ForTestingWorker(gpus=num_sp... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testBatchSizeInInputGenerator(self):
with self.session():
tf.random.set_seed(_TF_RANDOM_SEED)
p = self._testParams()
with cluster_factory.ForTestingWorker(
mode='sync', job='trainer_client', gpus=5):
mdl = p.Instantiate()
mdl.FPropDefaultTheta()
loss = mdl.los... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def _InputParams(self):
p = input_generator.NmtInput.Params()
input_file = test_helper.test_src_dir_path(
'tasks/mt/testdata/wmt14_ende_wpm_32k_test.tfrecord')
vocab_file = test_helper.test_src_dir_path(
'tasks/mt/testdata/wmt14_ende_wpm_32k_test.vocab')
p.file_pattern = 'tfrecord:' + in... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def _DecoderParams(self):
p = decoder.MTDecoderV1.Params()
p.name = 'decoder'
p.source_dim = 4
p.emb.vocab_size = 32000
p.emb.embedding_dim = 4
p.emb.max_num_shards = 1
p.rnn_cell_dim = 4
p.rnn_layers = 3
p.attention.hidden_dim = 2
p.softmax.num_classes = 32000
p.softmax.num_... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testConstruction(self):
with self.session():
p = self._testParams()
mdl = p.Instantiate()
flatten_vars = mdl.vars.Flatten()
# encoder/embedding: 1
# encoder/lstms: 2 * (3 (forward) + 3 (backward))
# encoder/proj: 2
# decoder/embedding: 1
# decoder/atten: 3
#... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testFPropEvalMode(self):
with self.session(), self.SetEval(True):
tf.random.set_seed(_TF_RANDOM_SEED)
p = self._testParams()
mdl = p.Instantiate()
mdl.FPropDefaultTheta()
loss = mdl.loss
logp = mdl.eval_metrics['log_pplx'][0]
self.evaluate(tf.global_variables_initialize... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testDecode(self):
with self.session(use_gpu=False), self.SetEval(True):
tf.random.set_seed(93820985)
p = self._testParams()
mdl = p.Instantiate()
input_batch = mdl.input_generator.GetPreprocessedInputBatch()
dec_out_dict = mdl.Decode(input_batch)
self.evaluate(tf.global_varia... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def Run(num_splits):
with self.session(use_gpu=False, graph=tf.Graph()):
tf.random.set_seed(93820981)
p = self._testParams()
p.input.bucket_batch_limit = [
b * 2 / num_splits for b in p.input.bucket_batch_limit
]
with cluster_factory.ForTestingWorker(gpus=num_sp... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testBatchSizeInInputGenerator(self):
with self.session():
tf.random.set_seed(_TF_RANDOM_SEED)
p = self._testParams()
cluster_params = cluster_factory.Cluster.Params()
cluster_params.mode = 'sync'
cluster_params.job = 'trainer_client'
cluster_params.worker.name = '/job:localho... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def _InputParams(self):
p = input_generator.NmtInput.Params()
input_file = test_helper.test_src_dir_path(
'tasks/mt/testdata/wmt14_ende_wpm_32k_test.tfrecord')
vocab_file = test_helper.test_src_dir_path(
'tasks/mt/testdata/wmt14_ende_wpm_32k_test.vocab')
p.file_pattern = 'tfrecord:' + in... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def _DecoderParams(self):
p = decoder.MTDecoderV1.Params()
p.name = 'decoder'
p.source_dim = 4
p.emb.vocab_size = 32000
p.emb.embedding_dim = 4
p.emb.max_num_shards = 1
p.rnn_cell_dim = 4
p.rnn_layers = 3
p.attention.hidden_dim = 2
p.softmax.num_classes = 32000
p.softmax.num_... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testConstruction(self):
with self.session():
p = self._testParams()
mdl = p.Instantiate()
flatten_vars = mdl.vars.Flatten()
print('vars flattened = ', flatten_vars)
# encoder: 91 (1 + 36 + 54)
# encoder/embedding: 1
# encoder/ff_layer: 6 * 6
# encoder/attention: 9... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testFPropEvalMode(self):
with self.session(), self.SetEval(True):
tf.random.set_seed(_TF_RANDOM_SEED)
p = self._testParams()
mdl = p.Instantiate()
mdl.FPropDefaultTheta()
loss = mdl.loss
logp = mdl.eval_metrics['log_pplx'][0]
self.evaluate(tf.global_variables_initialize... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testDecode(self):
with self.session(use_gpu=False), self.SetEval(True):
tf.random.set_seed(93820985)
p = self._testParams()
mdl = p.Instantiate()
input_batch = mdl.input_generator.GetPreprocessedInputBatch()
dec_out_dict = mdl.Decode(input_batch)
self.evaluate(tf.global_varia... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def Run(num_splits):
with self.session(use_gpu=False, graph=tf.Graph()):
tf.random.set_seed(93820981)
p = self._testParams()
p.input.bucket_batch_limit = [
b * 2 / num_splits for b in p.input.bucket_batch_limit
]
with cluster_factory.ForTestingWorker(gpus=num_sp... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testBatchSizeInInputGenerator(self):
with self.session():
tf.random.set_seed(_TF_RANDOM_SEED)
p = self._testParams()
cluster_params = cluster_factory.Cluster.Params()
cluster_params.mode = 'sync'
cluster_params.job = 'trainer_client'
cluster_params.worker.name = '/job:localho... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def _InputParams(self):
p = input_generator.NmtInput.Params()
input_file = test_helper.test_src_dir_path(
'tasks/mt/testdata/wmt14_ende_wpm_32k_test.tfrecord')
vocab_file = test_helper.test_src_dir_path(
'tasks/mt/testdata/wmt14_ende_wpm_32k_test.vocab')
p.file_pattern = 'tfrecord:' + in... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def _testParams(self):
p = model.InsertionModel.Params()
p.name = 'insertion'
p.input = self._InputParams()
p.decoder = self._DecoderParams()
p.random_seed = 12345
return p | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testCreateCanvasAndTargets(self):
with self.session():
tf.random.set_seed(_TF_RANDOM_SEED)
batch = py_utils.NestedMap(
src=py_utils.NestedMap(
ids=tf.convert_to_tensor(
np.asarray([
[10, 11, 12, 14, 2, 0],
[20, 21,... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testFPropGraph(self):
"""Test the construction of the fprop graph, then fprop the graph."""
with self.session():
p = self._testParams()
mdl = p.Instantiate()
mdl.FPropDefaultTheta()
self.evaluate(tf.global_variables_initializer())
self.evaluate(mdl.loss) | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def _InputParams(self):
p = input_generator.NmtDoubleInput.Params()
input_file = test_helper.test_src_dir_path(
'tasks/mt/testdata/wmt14_ende_wpm_32k_doublebatch_test-000-001')
p.file_pattern = 'tfrecord:' + input_file
p.tokenizer.token_vocab_filepath = test_helper.test_src_dir_path(
'ta... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def _DecoderParams(self):
p = decoder.TransformerXDecoder.Params()
p.name = 'mix_decoder'
p.token_emb.params_init = py_utils.WeightInit.GaussianSqrtDim()
p.token_emb.vocab_size = 32000
p.token_emb.embedding_dim = 4
p.token_emb.max_num_shards = 1
p.token_emb.scale_sqrt_depth = True
p.toke... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def testFProp(self, dtype=tf.float32, fprop_dtype=tf.float32):
with self.session(use_gpu=False):
tf.random.set_seed(_TF_RANDOM_SEED)
p = self._testParams()
p.dtype = dtype
if fprop_dtype:
p.fprop_dtype = fprop_dtype
p.input.dtype = fprop_dtype
mdl = p.Instantiate()
... | tensorflow/lingvo | [
2689,
429,
2689,
115,
1532471428
] |
def setUpTestData(cls):
parent_tenant_groups = (
TenantGroup(name='Parent Tenant Group 1', slug='parent-tenant-group-1'),
TenantGroup(name='Parent Tenant Group 2', slug='parent-tenant-group-2'),
TenantGroup(name='Parent Tenant Group 3', slug='parent-tenant-group-3'),
... | digitalocean/netbox | [
12158,
2099,
12158,
303,
1456755346
] |
def test_name(self):
params = {'name': ['Tenant Group 1', 'Tenant Group 2']}
self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2) | digitalocean/netbox | [
12158,
2099,
12158,
303,
1456755346
] |
def test_description(self):
params = {'description': ['A', 'B']}
self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2) | digitalocean/netbox | [
12158,
2099,
12158,
303,
1456755346
] |
def setUpTestData(cls):
tenant_groups = (
TenantGroup(name='Tenant Group 1', slug='tenant-group-1'),
TenantGroup(name='Tenant Group 2', slug='tenant-group-2'),
TenantGroup(name='Tenant Group 3', slug='tenant-group-3'),
)
for tenantgroup in tenant_groups:
... | digitalocean/netbox | [
12158,
2099,
12158,
303,
1456755346
] |
def test_name(self):
params = {'name': ['Tenant 1', 'Tenant 2']}
self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2) | digitalocean/netbox | [
12158,
2099,
12158,
303,
1456755346
] |
def crop_and_pad_voxels(voxels, start_coordinates, end_coordinates):
"""Crops a voxel region and pads past the boundaries with zeros.
This accepts start and end coordinates past the limits of the voxel grid,
and uses it to calculate how much top/left/right/bottom padding to add.
Args:
voxels: A tf.float32... | google-research/google-research | [
27788,
6881,
27788,
944,
1538678568
] |
def voxels_to_points(voxels, segment_ids):
"""Convert voxels back to points given their segment id.
Args:
voxels: A tf.float32 tensor representing a voxel grid. Expect shape
[x, y, z, f].
segment_ids: A tf.int32 tensor representing the segment id of each point
in the original pointcloud we want... | google-research/google-research | [
27788,
6881,
27788,
944,
1538678568
] |
def points_offset_in_voxels(points, grid_cell_size):
"""Converts points into offsets in voxel grid.
Args:
points: A tf.float32 tensor of size [batch_size, N, 3].
grid_cell_size: The size of the grid cells in x, y, z dimensions in the
voxel grid. It should be either a tf.float32 tensor, a numpy array ... | google-research/google-research | [
27788,
6881,
27788,
944,
1538678568
] |
def pointcloud_to_sparse_voxel_grid_unbatched(points, features, grid_cell_size,
segment_func):
"""Converts a pointcloud into a voxel grid.
This function does not handle batch size and only works for a single batch
of points. The function `pointcloud_to_sparse_voxel_g... | google-research/google-research | [
27788,
6881,
27788,
944,
1538678568
] |
def pointcloud_to_sparse_voxel_grid(points, features, num_valid_points,
grid_cell_size, voxels_pad_or_clip_size,
segment_func):
"""Converts a pointcloud into a voxel grid.
This function calls the `pointcloud_to_sparse_voxel_grid_unbatched`
f... | google-research/google-research | [
27788,
6881,
27788,
944,
1538678568
] |
def fn(i):
num_valid_voxels_i = num_valid_voxels[i]
num_valid_points_i = num_valid_points[i]
voxel_features_i = voxel_features[i, :num_valid_voxels_i, :]
segment_ids_i = segment_ids[i, :num_valid_points_i]
point_features = tf.gather(voxel_features_i, segment_ids_i)
point_features_rank = len(poin... | google-research/google-research | [
27788,
6881,
27788,
944,
1538678568
] |
def per_voxel_point_sample_segment_func(data, segment_ids, num_segments,
num_samples_per_voxel):
"""Samples features from the points within each voxel.
Args:
data: A tf.float32 tensor of size [N, F].
segment_ids: A tf.int32 tensor of size [N].
num_segments: Numbe... | google-research/google-research | [
27788,
6881,
27788,
944,
1538678568
] |
def get_inference_spec(num_receivers=1,
num_samples=None):
"""Returns a specification of features in tf.Examples in roomsim format."""
spec = {}
spec[Features.RECEIVER_AUDIO] = tf.FixedLenFeature(
[num_receivers, num_samples], tf.float32)
return spec | google-research/sound-separation | [
484,
105,
484,
13,
1583214909
] |
def placeholders_from_spec(feature_spec):
"""Returns placeholders compatible with a given feature spec."""
placeholders = {}
for key, feature in feature_spec.items():
placeholders[key] = tf.placeholder(dtype=feature.dtype,
shape=[1] + feature.shape,
... | google-research/sound-separation | [
484,
105,
484,
13,
1583214909
] |
def _pad_mics_tf(signal, new_mics):
"""Pads new mic channels to an input tensor and returns the updated tensor.
Args:
signal: A tf.tensor of shape (input_mics, samples)
new_mics: The number of new mic channels to be added (integer scalar tensor)
Returns:
padded_signal: A tf.tensor of shape (input_mic... | google-research/sound-separation | [
484,
105,
484,
13,
1583214909
] |
def utterance_info_generator():
"""Yields utterance informations from each meeting.
Utterance info is in the form of a 6-tuple:
wav_path, diarization, spkidx, meeting_scale, start, gain.
"""
default_diarization = np.zeros((max_dia_seg_per_utt, 2), dtype=np.int32)
default_utt = ('0', default_d... | google-research/sound-separation | [
484,
105,
484,
13,
1583214909
] |
def decode_wav(wav):
audio_bytes = tf.read_file(wav)
waveform, _ = tf.audio.decode_wav(audio_bytes,
desired_samples=max_utt_length)
waveform = tf.transpose(waveform)
num_read_mics = tf.shape(waveform)[0]
waveform = tf.cond(num_read_mics >= num_mics,
... | google-research/sound-separation | [
484,
105,
484,
13,
1583214909
] |
def utterance_reader(wav_path, diarization, spkidx, meet_scale, start, gain):
"""Reads wave file for utterance and scale it."""
utt_tensor = decode_wav_or_return_zeros(wav_path[0], gain=gain)
return utt_tensor, diarization, spkidx, meet_scale, start | google-research/sound-separation | [
484,
105,
484,
13,
1583214909
] |
def pad_utterance(utt_tensor, diarization, spkidx, meeting_scale, start):
"""Pads utterance to meeting length.
Args:
utt_tensor: Utterance with shape (num_mics, max_utt_length).
diarization: Diarization with shape (max_dia_seg_per_utt, 2).
spkidx: Speaker index (global) for the utterance.
... | google-research/sound-separation | [
484,
105,
484,
13,
1583214909
] |
def make_reference(utt_tensor, diarization, spkidx, meeting_scale):
"""Makes a reference from fixed length utterance tensors.
Args:
utt_tensor: Utterances with shape
(max_num_utt_per_spk, num_mics, samples + max_utt_len)
diarization: Diarization ranges with shape
(max_num_utt_per_sp... | google-research/sound-separation | [
484,
105,
484,
13,
1583214909
] |
def chop_meeting_data(reference_waveforms, diarization_labels, speaker_ids,
meeting_scale, nsplit=num_meeting_subdivisions):
samples = tf.shape(reference_waveforms)[-1]
new_samples = nsplit * (samples // nsplit)
reference_waveforms = tf.stack(
tf.split(reference_wav... | google-research/sound-separation | [
484,
105,
484,
13,
1583214909
] |
def combine_mixture_and_sources(reference_waveforms, diarization_labels,
speaker_ids, meeting_scale):
# waveforms has shape (num_sources, num_mics, num_samples).
speaker_ids = tf.reshape(speaker_ids, (max_num_spk,))
meeting_scale = meeting_scale[0]
mixture_waveform = tf... | google-research/sound-separation | [
484,
105,
484,
13,
1583214909
] |
def render(self, context):
try:
return self._render(context)
except Exception:
if settings.DEBUG:
raise
# TODO: Log error
return self.nodelist_empty.render(context) | mattaustin/django-thummer | [
19,
3,
19,
1,
1324113517
] |
def __init__(self, parser, token):
bits = token.split_contents()
if len(bits) < 5 or bits[-2] != 'as':
raise TemplateSyntaxError(self.error_msg)
self.url = parser.compile_filter(bits[1])
self.geometry = parser.compile_filter(bits[2])
self.options = []
for bit ... | mattaustin/django-thummer | [
19,
3,
19,
1,
1324113517
] |
def supported(event):
return event.device.known_to_be_rollershutter | tchellomello/home-assistant | [
7,
1,
7,
6,
1467778429
] |
def cover_update(event, device_id):
"""Handle cover updates from the RFXtrx gateway."""
if not supported(event):
return
if device_id in device_ids:
return
device_ids.add(device_id)
_LOGGER.info(
"Added cover (Device ID: %s Class: %s Sub: %s, ... | tchellomello/home-assistant | [
7,
1,
7,
6,
1467778429
] |
def is_closed(self):
"""Return if the cover is closed."""
return not self._state | tchellomello/home-assistant | [
7,
1,
7,
6,
1467778429
] |
def _apply_event(self, event):
"""Apply command from rfxtrx."""
super()._apply_event(event)
if event.values["Command"] in COMMAND_ON_LIST:
self._state = True
elif event.values["Command"] in COMMAND_OFF_LIST:
self._state = False | tchellomello/home-assistant | [
7,
1,
7,
6,
1467778429
] |
def __init__(self, _orient_socket):
super(CommandMessage, self).__init__(_orient_socket)
self._query = ''
self._limit = 20
self._fetch_plan = '*:0'
self._command_type = QUERY_SYNC
self._mod_byte = 's'
self._append((FIELD_BYTE, COMMAND_OP)) | orientechnologies/pyorient | [
117,
36,
117,
15,
1419963921
] |
def prepare(self, params=None):
if isinstance(params, tuple) or isinstance(params, list):
try:
self.set_command_type(params[0])
self._query = params[1]
self._limit = params[2]
self._fetch_plan = params[3]
# callback f... | orientechnologies/pyorient | [
117,
36,
117,
15,
1419963921
] |
def set_command_type(self, _command_type):
if _command_type in QUERY_TYPES:
# user choice if present
self._command_type = _command_type
else:
raise PyOrientBadMethodCallException(
_command_type + ' is not a valid command type', []
)
... | orientechnologies/pyorient | [
117,
36,
117,
15,
1419963921
] |
def set_query(self, _query):
self._query = _query
return self | orientechnologies/pyorient | [
117,
36,
117,
15,
1419963921
] |
def _read_sync(self):
# type of response
# decode body char with flag continue ( Header already read )
response_type = self._decode_field(FIELD_CHAR)
if not isinstance(response_type, str):
response_type = response_type.decode()
res = []
if response_type == 'n... | orientechnologies/pyorient | [
117,
36,
117,
15,
1419963921
] |
def __init__(self, _orient_socket):
super(_TXCommitMessage, self).__init__(_orient_socket)
self._tx_id = -1
self._operation_stack = []
self._pre_operation_records = {}
self._operation_records = {}
self._temp_cluster_position_seq = -2
# order matters
sel... | orientechnologies/pyorient | [
117,
36,
117,
15,
1419963921
] |
def prepare(self, params=None):
self._append((FIELD_INT, self.get_transaction_id()))
self._append((FIELD_BOOLEAN, True))
for k, v in enumerate(self._operation_stack):
self._append((FIELD_BYTE, chr(1))) # start of records
for field in v:
self._append(fie... | orientechnologies/pyorient | [
117,
36,
117,
15,
1419963921
] |
def fetch_response(self):
# self.dump_streams()
super(_TXCommitMessage, self).fetch_response()
result = {
'created': [],
'updated': [],
'changes': []
}
items = self._decode_field(FIELD_INT)
for x in range(0, items):
# (cr... | orientechnologies/pyorient | [
117,
36,
117,
15,
1419963921
] |
def get_transaction_id(self):
if self._tx_id < 0:
from datetime import datetime
my_epoch = datetime(2014, 7, 1)
now = datetime.now()
delta = now - my_epoch
# write in extended mode to make it easy to read
# seconds * 1000000 to get the e... | orientechnologies/pyorient | [
117,
36,
117,
15,
1419963921
] |
def commit(self):
self._orientSocket.in_transaction = False
result = self.prepare().send().fetch_response()
self._operation_stack = []
self._pre_operation_records = {}
self._operation_records = {}
self._tx_id = -1
self._temp_cluster_position_seq = -2
retur... | orientechnologies/pyorient | [
117,
36,
117,
15,
1419963921
] |
def __init__(self, _orient_socket):
self._transaction = _TXCommitMessage(_orient_socket)
pass | orientechnologies/pyorient | [
117,
36,
117,
15,
1419963921
] |
def begin(self):
self._transaction.begin()
return self | orientechnologies/pyorient | [
117,
36,
117,
15,
1419963921
] |
def rollback(self):
return self._transaction.rollback() | orientechnologies/pyorient | [
117,
36,
117,
15,
1419963921
] |
def __init__(self, metrics_provider: BaseMetrics) -> None:
super().__init__()
self.metrics = metrics_provider | Yelp/paasta | [
1644,
229,
1644,
129,
1445895353
] |
def run(self) -> None:
while True:
last_run_time = time.time()
self.run_once()
time.sleep(last_run_time + 20 - time.time()) | Yelp/paasta | [
1644,
229,
1644,
129,
1445895353
] |
def __init__(
self,
queue: DelayDeadlineQueueProtocol,
workers: List[PaastaDeployWorker],
cluster: str,
metrics_provider: BaseMetrics, | Yelp/paasta | [
1644,
229,
1644,
129,
1445895353
] |
def clean_cidr_block(self, cidr_block):
if cidr_block not in self.vpc.cidr_block:
raise errors.InvalidParameter(
"{} not inside network {}".format(self.cidr_block, self.vpc.cidr_block)
)
return cidr_block | yaybu/touchdown | [
11,
4,
11,
17,
1410353271
] |
def get_describe_filters(self):
vpc = self.runner.get_plan(self.resource.vpc)
if not vpc.resource_id:
return None
return {
"Filters": [
{"Name": "cidrBlock", "Values": [str(self.resource.cidr_block)]},
{"Name": "vpcId", "Values": [vpc.reso... | yaybu/touchdown | [
11,
4,
11,
17,
1410353271
] |
def update_object(self):
if self.resource.route_table:
if not self.object.get("RouteTableAssociationId", None):
yield self.generic_action(
"Associate route table",
self.client.associate_route_table,
SubnetId=serializers.Iden... | yaybu/touchdown | [
11,
4,
11,
17,
1410353271
] |
def apply_migration(apps, schema_editor):
Group = apps.get_model('auth', 'Group')
public_group = Group()
public_group.name = "public"
public_group.id = PUBLIC_ID
public_group.save() | kartta-labs/noter-backend | [
1,
2,
1,
11,
1596553520
] |
def ndb_wsgi_middleware(wsgi_app):
def middleware(environ, start_response):
with client.context():
return wsgi_app(environ, start_response)
return middleware | GoogleCloudPlatform/python-docs-samples | [
6120,
5980,
6120,
108,
1430781973
] |
def list_books():
books = Book.query()
return str([book.to_dict() for book in books]) | GoogleCloudPlatform/python-docs-samples | [
6120,
5980,
6120,
108,
1430781973
] |
def test_get_param_includes(self):
bad_testcases = [{}, [[]], [{}]]
for bad in bad_testcases:
with self.assertRaises(TaskCatException):
param_list_to_dict(bad) | aws-quickstart/taskcat | [
1061,
211,
1061,
39,
1479169741
] |
def test_name_from_stack_id(self):
actual = name_from_stack_id("arn:::us-east-1::Stack/test-name")
self.assertEqual("test-name", actual) | aws-quickstart/taskcat | [
1061,
211,
1061,
39,
1479169741
] |
def test_s3_url_maker(self, m_get_s3_domain):
m_s3 = mock.Mock()
m_s3.get_bucket_location.return_value = {"LocationConstraint": None}
actual = s3_url_maker("test-bucket", "test-key/1", m_s3)
self.assertEqual(
"https://test-bucket.s3.us-east-1.amazonaws.com/test-key/1", actua... | aws-quickstart/taskcat | [
1061,
211,
1061,
39,
1479169741
] |
def test_merge_dicts(self):
input = [{}, {}]
actual = merge_dicts(input)
self.assertEqual({}, actual)
input = [{"a": 1}, {"b": 2}]
actual = merge_dicts(input)
self.assertEqual({"a": 1, "b": 2}, actual) | aws-quickstart/taskcat | [
1061,
211,
1061,
39,
1479169741
] |
def test_make_dir(self):
path = "/tmp/test_make_dir_path"
try:
os.rmdir(path)
except FileNotFoundError:
pass
os.makedirs(path)
make_dir(path)
os.rmdir(path)
make_dir(path)
self.assertEqual(os.path.isdir(path), True)
with sel... | aws-quickstart/taskcat | [
1061,
211,
1061,
39,
1479169741
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.