_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q266900 | get_activation_by_name | test | def get_activation_by_name(activation_name, activation_id=None):
""" Convert to a bigdl activation layer
given the name of the activation as a string """
import bigdl.nn.layer as BLayer
activation = None
activation_name = activation_name.lower()
if activation_name == "tanh":
activat... | python | {
"resource": ""
} |
q266901 | JTensor.from_ndarray | test | def from_ndarray(cls, a_ndarray, bigdl_type="float"):
"""
Convert a ndarray to a DenseTensor which would be used in Java side.
>>> import numpy as np
>>> from bigdl.util.common import JTensor
>>> from bigdl.util.common import callBigDlFunc
>>> np.random.seed(123)
... | python | {
"resource": ""
} |
q266902 | ImageFeature.get_label | test | def get_label(self):
"""
get label as ndarray from ImageFeature
"""
label = callBigDlFunc(self.bigdl_type, "imageFeatureToLabelTensor", self.value)
return label.to_ndarray() | python | {
"resource": ""
} |
q266903 | ImageFrame.read_parquet | test | def read_parquet(cls, path, sc, bigdl_type="float"):
"""
Read parquet file as DistributedImageFrame
"""
return DistributedImageFrame(jvalue=callBigDlFunc(bigdl_type, "readParquet", path, sc)) | python | {
"resource": ""
} |
q266904 | ImageFrame.write_parquet | test | def write_parquet(cls, path, output, sc, partition_num = 1, bigdl_type="float"):
"""
write ImageFrame as parquet file
"""
return callBigDlFunc(bigdl_type, "writeParquet", path, output, sc, partition_num) | python | {
"resource": ""
} |
q266905 | ImageFrame.get_image | test | def get_image(self, float_key="floats", to_chw=True):
"""
get image from ImageFrame
"""
return self.image_frame.get_image(float_key, to_chw) | python | {
"resource": ""
} |
q266906 | LocalImageFrame.get_image | test | def get_image(self, float_key="floats", to_chw=True):
"""
get image list from ImageFrame
"""
tensors = callBigDlFunc(self.bigdl_type,
"localImageFrameToImageTensor", self.value, float_key, to_chw)
return map(lambda tensor: tensor.to_ndarray(), t... | python | {
"resource": ""
} |
q266907 | DistributedImageFrame.get_label | test | def get_label(self):
"""
get label rdd from ImageFrame
"""
tensor_rdd = callBigDlFunc(self.bigdl_type, "distributedImageFrameToLabelTensorRdd", self.value)
return tensor_rdd.map(lambda tensor: tensor.to_ndarray()) | python | {
"resource": ""
} |
q266908 | DistributedImageFrame.get_predict | test | def get_predict(self, key="predict"):
"""
get prediction rdd from ImageFrame
"""
predicts = callBigDlFunc(self.bigdl_type, "distributedImageFrameToPredict", self.value, key)
return predicts.map(lambda predict: (predict[0], predict[1].to_ndarray()) if predict[1] else (predict[0], ... | python | {
"resource": ""
} |
q266909 | KerasModelWrapper.predict | test | def predict(self, x, batch_size=None, verbose=None, is_distributed=False):
"""Generates output predictions for the input samples,
processing the samples in a batched way.
# Arguments
x: the input data, as a Numpy array or list of Numpy array for local mode.
as RDD[Sam... | python | {
"resource": ""
} |
q266910 | KerasModelWrapper.fit | test | def fit(self, x, y=None, batch_size=32, nb_epoch=10, verbose=1, callbacks=None,
validation_split=0., validation_data=None, shuffle=True,
class_weight=None, sample_weight=None, initial_epoch=0, is_distributed=False):
"""Optimize the model by the given options
:param x: ndarray or... | python | {
"resource": ""
} |
q266911 | DLImageTransformer.transform | test | def transform(self, dataset):
"""
Apply the transformer to the images in "inputCol" and store the transformed result
into "outputCols"
"""
self._transfer_params_to_java()
return callBigDlFunc(self.bigdl_type, "dlImageTransform", self.value, dataset) | python | {
"resource": ""
} |
q266912 | save_keras_definition | test | def save_keras_definition(keras_model, path):
"""
Save a Keras model definition to JSON with given path
"""
model_json = keras_model.to_json()
with open(path, "w") as json_file:
json_file.write(model_json) | python | {
"resource": ""
} |
q266913 | build_keras_model | test | def build_keras_model():
"""
Define a convnet model in Keras 1.2.2
"""
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Convolution2D, MaxPooling2D
keras_model = Sequential()
keras_model.add(Convolution2D(32, 3, 3,... | python | {
"resource": ""
} |
q266914 | Layer.predict_class_distributed | test | def predict_class_distributed(self, data_rdd):
"""
module predict, return the predict label
:param data_rdd: the data to be predict.
:return: An RDD represent the predict label.
"""
result = callBigDlFunc(self.bigdl_type,
"modelPredictClass... | python | {
"resource": ""
} |
q266915 | Layer.set_weights | test | def set_weights(self, weights):
"""
Set weights for this layer
:param weights: a list of numpy arrays which represent weight and bias
:return:
>>> linear = Linear(3,2)
creating: createLinear
>>> linear.set_weights([np.array([[1,2,3],[4,5,6]]), np.array([7,8])])
... | python | {
"resource": ""
} |
q266916 | Layer.get_weights | test | def get_weights(self):
"""
Get weights for this layer
:return: list of numpy arrays which represent weight and bias
"""
tensorWeights = callBigDlFunc(self.bigdl_type,
"getWeights", self.value)
if tensorWeights is not None:
return... | python | {
"resource": ""
} |
q266917 | Layer.save_tensorflow | test | def save_tensorflow(self, inputs, path, byte_order="little_endian", data_format="nhwc"):
"""
Save a model to protobuf files so that it can be used in tensorflow inference.
When saving the model, placeholders will be added to the tf model as input nodes. So
you need to pass in the names ... | python | {
"resource": ""
} |
q266918 | Layer.training | test | def training(self, is_training=True):
'''
Set this layer in the training mode or in predition mode if is_training=False
'''
if is_training:
callJavaFunc(self.value.training)
else:
callJavaFunc(self.value.evaluate)
return self | python | {
"resource": ""
} |
q266919 | Model.load_torch | test | def load_torch(path, bigdl_type="float"):
"""
Load a pre-trained Torch model.
:param path: The path containing the pre-trained model.
:return: A pre-trained model.
"""
jmodel = callBigDlFunc(bigdl_type, "loadTorch", path)
return Layer.of(jmodel) | python | {
"resource": ""
} |
q266920 | Model.load_keras | test | def load_keras(json_path=None, hdf5_path=None, by_name=False):
"""
Load a pre-trained Keras model.
:param json_path: The json path containing the keras model definition.
:param hdf5_path: The HDF5 path containing the pre-trained keras model weights with or without the model architecture... | python | {
"resource": ""
} |
q266921 | Criterion.of | test | def of(cls, jcriterion, bigdl_type="float"):
"""
Create a python Criterion by a java criterion object
:param jcriterion: A java criterion object which created by Py4j
:return: a criterion.
"""
criterion = Criterion(bigdl_type, jcriterion)
criterion.value = jcrite... | python | {
"resource": ""
} |
q266922 | WeightLoader.load_weights_from_json_hdf5 | test | def load_weights_from_json_hdf5(def_json, weights_hdf5, by_name=False):
"""
The file path can be stored in a local file system, HDFS, S3,
or any Hadoop-supported file system.
"""
bmodel = DefinitionLoader.from_json_path(def_json)
def_value = BCommon.text_from_path(def_jso... | python | {
"resource": ""
} |
q266923 | load_imdb | test | def load_imdb():
"""
Load IMDB dataset
Transform input data into an RDD of Sample
"""
from keras.preprocessing import sequence
from keras.datasets import imdb
(X_train, y_train), (X_test, y_test) = imdb.load_data(nb_words=20000)
X_train = sequence.pad_sequences(X_train, maxlen=100)
X... | python | {
"resource": ""
} |
q266924 | build_keras_model | test | def build_keras_model():
"""
Define a recurrent convolutional model in Keras 1.2.2
"""
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation
from keras.layers import Embedding
from keras.layers import LSTM
from keras.layers import Convolution1D, MaxPooli... | python | {
"resource": ""
} |
q266925 | InferShape.get_input_shape | test | def get_input_shape(self):
"""
Return a list of shape tuples if there are multiple inputs.
Return one shape tuple otherwise.
"""
input = callBigDlFunc(self.bigdl_type, "getInputShape",
self.value)
return self.__process_shape(input) | python | {
"resource": ""
} |
q266926 | InferShape.get_output_shape | test | def get_output_shape(self):
"""
Return a list of shape tuples if there are multiple outputs.
Return one shape tuple otherwise.
"""
output = callBigDlFunc(self.bigdl_type, "getOutputShape",
self.value)
return self.__process_shape(output) | python | {
"resource": ""
} |
q266927 | get_mnist | test | def get_mnist(data_type="train", location="/tmp/mnist"):
"""
Get mnist dataset with features and label as ndarray.
Data would be downloaded automatically if it doesn't present at the specific location.
:param data_type: "train" for training data and "test" for testing data.
:param location: Locatio... | python | {
"resource": ""
} |
q266928 | read_data_sets | test | def read_data_sets(data_dir):
"""
Parse or download movielens 1m data if train_dir is empty.
:param data_dir: The directory storing the movielens data
:return: a 2D numpy array with user index and item index in each row
"""
WHOLE_DATA = 'ml-1m.zip'
local_file = base.maybe_download(WHOLE_D... | python | {
"resource": ""
} |
q266929 | get_bigdl_classpath | test | def get_bigdl_classpath():
"""
Get and return the jar path for bigdl if exists.
"""
if os.getenv("BIGDL_CLASSPATH"):
return os.environ["BIGDL_CLASSPATH"]
jar_dir = os.path.abspath(__file__ + "/../../")
jar_paths = glob.glob(os.path.join(jar_dir, "share/lib/*.jar"))
if jar_paths:
... | python | {
"resource": ""
} |
q266930 | is_spark_below_2_2 | test | def is_spark_below_2_2():
"""
Check if spark version is below 2.2
"""
import pyspark
if(hasattr(pyspark,"version")):
full_version = pyspark.version.__version__
# We only need the general spark version (eg, 1.6, 2.2).
parts = full_version.split(".")
spark_version = par... | python | {
"resource": ""
} |
q266931 | export_checkpoint | test | def export_checkpoint(checkpoint_path):
"""
Export variable tensors from the checkpoint files.
:param checkpoint_path: tensorflow checkpoint path
:return: dictionary of tensor. The key is the variable name and the value is the numpy
"""
reader = tf.train.NewCheckpointReader(checkpoint_path)
... | python | {
"resource": ""
} |
q266932 | save_variable_bigdl | test | def save_variable_bigdl(tensors, target_path, bigdl_type="float"):
"""
Save a variable dictionary to a Java object file, so it can be read by BigDL
:param tensors: tensor dictionary
:param target_path: where is the Java object file store
:param bigdl_type: model variable numeric type
:return: n... | python | {
"resource": ""
} |
q266933 | expand_tile | test | def expand_tile(units, axis):
"""
Expand and tile tensor along given axis
Args:
units: tf tensor with dimensions [batch_size, time_steps, n_input_features]
axis: axis along which expand and tile. Must be 1 or 2
"""
assert axis in (1, 2)
n_time_steps = K.int_shape(units)[1]
... | python | {
"resource": ""
} |
q266934 | precompute_future_symbols | test | def precompute_future_symbols(trie, n, allow_spaces=False):
"""
Collecting possible continuations of length <= n for every node
"""
if n == 0:
return
if trie.is_terminated and trie.precompute_symbols:
# символы уже предпосчитаны
return
for index, final in enumerate(trie.f... | python | {
"resource": ""
} |
q266935 | simple_attention | test | def simple_attention(memory, att_size, mask, keep_prob=1.0, scope="simple_attention"):
"""Simple attention without any conditions.
Computes weighted sum of memory elements.
"""
with tf.variable_scope(scope):
BS, ML, MH = tf.unstack(tf.shape(memory))
memory_do = tf.nn.dropout(memory, ... | python | {
"resource": ""
} |
q266936 | attention | test | def attention(inputs, state, att_size, mask, scope="attention"):
"""Computes weighted sum of inputs conditioned on state"""
with tf.variable_scope(scope):
u = tf.concat([tf.tile(tf.expand_dims(state, axis=1), [1, tf.shape(inputs)[1], 1]), inputs], axis=2)
logits = tf.layers.dense(tf.layers.dense... | python | {
"resource": ""
} |
q266937 | compute_bleu | test | def compute_bleu(reference_corpus, translation_corpus, max_order=4,
smooth=False):
"""Computes BLEU score of translated segments against one or more references.
Args:
reference_corpus: list of lists of references for each translation. Each
reference should be tokenized into a list of t... | python | {
"resource": ""
} |
q266938 | DialogLogger._get_log_file | test | def _get_log_file(self):
"""Returns opened file object for writing dialog logs.
Returns:
log_file: opened Python file object.
"""
log_dir: Path = Path(self.config['log_path']).expanduser().resolve() / self.agent_name
log_dir.mkdir(parents=True, exist_ok=True)
... | python | {
"resource": ""
} |
q266939 | DialogLogger._log | test | def _log(self, utterance: Any, direction: str, dialog_id: Optional[Hashable]=None):
"""Logs single dialog utterance to current dialog log file.
Args:
utterance: Dialog utterance.
direction: 'in' or 'out' utterance direction.
dialog_id: Dialog ID.
"""
... | python | {
"resource": ""
} |
q266940 | summary_gradient_updates | test | def summary_gradient_updates(grads, opt, lr):
"""get summary ops for the magnitude of gradient updates"""
# strategy:
# make a dict of variable name -> [variable, grad, adagrad slot]
vars_grads = {}
for v in tf.trainable_variables():
vars_grads[v.name] = [v, None, None]
for g, v in grad... | python | {
"resource": ""
} |
q266941 | dump_weights | test | def dump_weights(tf_save_dir, outfile, options):
"""
Dump the trained weights from a model to a HDF5 file.
"""
def _get_outname(tf_name):
outname = re.sub(':0$', '', tf_name)
outname = outname.lstrip('lm/')
outname = re.sub('/rnn/', '/RNN/', outname)
outname = re.sub('/m... | python | {
"resource": ""
} |
q266942 | read_data_by_config | test | def read_data_by_config(config: dict):
"""Read data by dataset_reader from specified config."""
dataset_config = config.get('dataset', None)
if dataset_config:
config.pop('dataset')
ds_type = dataset_config['type']
if ds_type == 'classification':
reader = {'class_name': ... | python | {
"resource": ""
} |
q266943 | train_evaluate_model_from_config | test | def train_evaluate_model_from_config(config: Union[str, Path, dict],
iterator: Union[DataLearningIterator, DataFittingIterator] = None, *,
to_train: bool = True,
evaluation_targets: Optional[Iterable[str]] = N... | python | {
"resource": ""
} |
q266944 | interact_alice | test | def interact_alice(agent: Agent):
"""
Exchange messages between basic pipelines and the Yandex.Dialogs service.
If the pipeline returns multiple values, only the first one is forwarded to Yandex.
"""
data = request.get_json()
text = data['request'].get('command', '').strip()
payload = data['... | python | {
"resource": ""
} |
q266945 | labels2onehot | test | def labels2onehot(labels: [List[str], List[List[str]], np.ndarray], classes: [list, np.ndarray]) -> np.ndarray:
"""
Convert labels to one-hot vectors for multi-class multi-label classification
Args:
labels: list of samples where each sample is a class or a list of classes which sample belongs with... | python | {
"resource": ""
} |
q266946 | proba2onehot | test | def proba2onehot(proba: [list, np.ndarray], confident_threshold: float, classes: [list, np.ndarray]) -> np.ndarray:
"""
Convert vectors of probabilities to one-hot representations using confident threshold
Args:
proba: samples where each sample is a vector of probabilities to belong with given cla... | python | {
"resource": ""
} |
q266947 | KerasModel._config_session | test | def _config_session():
"""
Configure session for particular device
Returns:
tensorflow.Session
"""
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
config.gpu_options.visible_device_list = '0'
return tf.Session(config=config) | python | {
"resource": ""
} |
q266948 | KerasWrapper.load | test | def load(self) -> None:
"""Checks existence of the model file, loads the model if the file exists"""
# Checks presence of the model files
if self.load_path.exists():
path = str(self.load_path.resolve())
log.info('[loading model from {}]'.format(path))
self._n... | python | {
"resource": ""
} |
q266949 | LRScheduledKerasModel.get_momentum_variable | test | def get_momentum_variable(self):
"""
Extract values of momentum variables from optimizer
Returns:
optimizer's `rho` or `beta_1`
"""
optimizer = self.get_optimizer()
if hasattr(optimizer, 'rho'):
return optimizer.rho
elif hasattr(optimizer,... | python | {
"resource": ""
} |
q266950 | LRScheduledKerasModel._update_graph_variables | test | def _update_graph_variables(self, learning_rate: float = None, momentum: float = None):
"""
Update graph variables setting giving `learning_rate` and `momentum`
Args:
learning_rate: learning rate value to be set in graph (set if not None)
momentum: momentum value to be s... | python | {
"resource": ""
} |
q266951 | round_f1_macro | test | def round_f1_macro(y_true, y_predicted):
"""
Calculates F1 macro measure.
Args:
y_true: list of true values
y_predicted: list of predicted values
Returns:
F1 score
"""
try:
predictions = [np.round(x) for x in y_predicted]
except TypeError:
prediction... | python | {
"resource": ""
} |
q266952 | process_word | test | def process_word(word: str, to_lower: bool = False,
append_case: Optional[str] = None) -> Tuple[str]:
"""Converts word to a tuple of symbols, optionally converts it to lowercase
and adds capitalization label.
Args:
word: input word
to_lower: whether to lowercase
app... | python | {
"resource": ""
} |
q266953 | stacked_cnn | test | def stacked_cnn(units: tf.Tensor,
n_hidden_list: List,
filter_width=3,
use_batch_norm=False,
use_dilation=False,
training_ph=None,
add_l2_losses=False):
""" Number of convolutional layers stacked on top of each other
... | python | {
"resource": ""
} |
q266954 | bi_rnn | test | def bi_rnn(units: tf.Tensor,
n_hidden: List,
cell_type='gru',
seq_lengths=None,
trainable_initial_states=False,
use_peepholes=False,
name='Bi-'):
""" Bi directional recurrent neural network. GRU or LSTM
Args:
units: a tensorflow ... | python | {
"resource": ""
} |
q266955 | stacked_bi_rnn | test | def stacked_bi_rnn(units: tf.Tensor,
n_hidden_list: List,
cell_type='gru',
seq_lengths=None,
use_peepholes=False,
name='RNN_layer'):
""" Stackted recurrent neural networks GRU or LSTM
Args:
units: a t... | python | {
"resource": ""
} |
q266956 | stacked_highway_cnn | test | def stacked_highway_cnn(units: tf.Tensor,
n_hidden_list: List,
filter_width=3,
use_batch_norm=False,
use_dilation=False,
training_ph=None):
""" Highway convolutional network. Skip connection with ... | python | {
"resource": ""
} |
q266957 | embedding_layer | test | def embedding_layer(token_indices=None,
token_embedding_matrix=None,
n_tokens=None,
token_embedding_dim=None,
name: str = None,
trainable=True):
""" Token embedding layer. Create matrix of for token embeddings.
... | python | {
"resource": ""
} |
q266958 | cudnn_gru | test | def cudnn_gru(units, n_hidden, n_layers=1, trainable_initial_states=False,
seq_lengths=None, input_initial_h=None, name='cudnn_gru', reuse=False):
""" Fast CuDNN GRU implementation
Args:
units: tf.Tensor with dimensions [B x T x F], where
B - batch size
T - number ... | python | {
"resource": ""
} |
q266959 | cudnn_compatible_gru | test | def cudnn_compatible_gru(units, n_hidden, n_layers=1, trainable_initial_states=False,
seq_lengths=None, input_initial_h=None, name='cudnn_gru', reuse=False):
""" CuDNN Compatible GRU implementation.
It should be used to load models saved with CudnnGRUCell to run on CPU.
Arg... | python | {
"resource": ""
} |
q266960 | cudnn_lstm | test | def cudnn_lstm(units, n_hidden, n_layers=1, trainable_initial_states=None, seq_lengths=None, initial_h=None,
initial_c=None, name='cudnn_lstm', reuse=False):
""" Fast CuDNN LSTM implementation
Args:
units: tf.Tensor with dimensions [B x T x F], where
B - batch siz... | python | {
"resource": ""
} |
q266961 | cudnn_compatible_lstm | test | def cudnn_compatible_lstm(units, n_hidden, n_layers=1, trainable_initial_states=None, seq_lengths=None, initial_h=None,
initial_c=None, name='cudnn_lstm', reuse=False):
""" CuDNN Compatible LSTM implementation.
It should be used to load models saved with CudnnLSTMCell to run on CPU... | python | {
"resource": ""
} |
q266962 | cudnn_bi_gru | test | def cudnn_bi_gru(units,
n_hidden,
seq_lengths=None,
n_layers=1,
trainable_initial_states=False,
name='cudnn_bi_gru',
reuse=False):
""" Fast CuDNN Bi-GRU implementation
Args:
units: tf.Tensor with dimen... | python | {
"resource": ""
} |
q266963 | cudnn_bi_lstm | test | def cudnn_bi_lstm(units,
n_hidden,
seq_lengths=None,
n_layers=1,
trainable_initial_states=False,
name='cudnn_bi_gru',
reuse=False):
""" Fast CuDNN Bi-LSTM implementation
Args:
units: tf.Tensor wi... | python | {
"resource": ""
} |
q266964 | cudnn_stacked_bi_gru | test | def cudnn_stacked_bi_gru(units,
n_hidden,
seq_lengths=None,
n_stacks=2,
keep_prob=1.0,
concat_stacked_outputs=False,
trainable_initial_states=False,
... | python | {
"resource": ""
} |
q266965 | variational_dropout | test | def variational_dropout(units, keep_prob, fixed_mask_dims=(1,)):
""" Dropout with the same drop mask for all fixed_mask_dims
Args:
units: a tensor, usually with shapes [B x T x F], where
B - batch size
T - tokens dimension
F - feature dimension
keep_prob: kee... | python | {
"resource": ""
} |
q266966 | CharacterTagger.build | test | def build(self):
"""Builds the network using Keras.
"""
word_inputs = kl.Input(shape=(None, MAX_WORD_LENGTH+2), dtype="int32")
inputs = [word_inputs]
word_outputs = self._build_word_cnn(word_inputs)
if len(self.word_vectorizers) > 0:
additional_word_inputs = [... | python | {
"resource": ""
} |
q266967 | CharacterTagger._build_word_cnn | test | def _build_word_cnn(self, inputs):
"""Builds word-level network
"""
inputs = kl.Lambda(kb.one_hot, arguments={"num_classes": self.symbols_number_},
output_shape=lambda x: tuple(x) + (self.symbols_number_,))(inputs)
char_embeddings = kl.Dense(self.char_embedding... | python | {
"resource": ""
} |
q266968 | CharacterTagger._build_basic_network | test | def _build_basic_network(self, word_outputs):
"""
Creates the basic network architecture,
transforming word embeddings to intermediate outputs
"""
if self.word_dropout > 0.0:
lstm_outputs = kl.Dropout(self.word_dropout)(word_outputs)
else:
lstm_out... | python | {
"resource": ""
} |
q266969 | CharacterTagger.train_on_batch | test | def train_on_batch(self, data: List[Iterable], labels: Iterable[list]) -> None:
"""Trains model on a single batch
Args:
data: a batch of word sequences
labels: a batch of correct tag sequences
Returns:
the trained model
"""
X, Y = self._transf... | python | {
"resource": ""
} |
q266970 | CharacterTagger.predict_on_batch | test | def predict_on_batch(self, data: Union[list, tuple],
return_indexes: bool = False) -> List[List[str]]:
"""
Makes predictions on a single batch
Args:
data: a batch of word sequences together with additional inputs
return_indexes: whether to return... | python | {
"resource": ""
} |
q266971 | CharacterTagger._make_sent_vector | test | def _make_sent_vector(self, sent: List, bucket_length: int =None) -> np.ndarray:
"""Transforms a sentence to Numpy array, which will be the network input.
Args:
sent: input sentence
bucket_length: the width of the bucket
Returns:
A 3d array, answer[i][j][k] ... | python | {
"resource": ""
} |
q266972 | CharacterTagger._make_tags_vector | test | def _make_tags_vector(self, tags, bucket_length=None) -> np.ndarray:
"""Transforms a sentence of tags to Numpy array, which will be the network target.
Args:
tags: input sentence of tags
bucket_length: the width of the bucket
Returns:
A 2d array, answer[i][j... | python | {
"resource": ""
} |
q266973 | bleu_advanced | test | def bleu_advanced(y_true: List[Any], y_predicted: List[Any],
weights: Tuple=(1,), smoothing_function=SMOOTH.method1,
auto_reweigh=False, penalty=True) -> float:
"""Calculate BLEU score
Parameters:
y_true: list of reference tokens
y_predicted: list of query to... | python | {
"resource": ""
} |
q266974 | verify_sc_url | test | def verify_sc_url(url: str) -> bool:
"""Verify signature certificate URL against Amazon Alexa requirements.
Each call of Agent passes incoming utterances batch through skills filter,
agent skills, skills processor. Batch of dialog IDs can be provided, in
other case utterances indexes in incoming batch ... | python | {
"resource": ""
} |
q266975 | extract_certs | test | def extract_certs(certs_txt: str) -> List[crypto.X509]:
"""Extracts pycrypto X509 objects from SSL certificates chain string.
Args:
certs_txt: SSL certificates chain string.
Returns:
result: List of pycrypto X509 objects.
"""
pattern = r'-----BEGIN CERTIFICATE-----.+?-----END CERTI... | python | {
"resource": ""
} |
q266976 | verify_certs_chain | test | def verify_certs_chain(certs_chain: List[crypto.X509], amazon_cert: crypto.X509) -> bool:
"""Verifies if Amazon and additional certificates creates chain of trust to a root CA.
Args:
certs_chain: List of pycrypto X509 intermediate certificates from signature chain URL.
amazon_cert: Pycrypto X50... | python | {
"resource": ""
} |
q266977 | verify_signature | test | def verify_signature(amazon_cert: crypto.X509, signature: str, request_body: bytes) -> bool:
"""Verifies Alexa request signature.
Args:
amazon_cert: Pycrypto X509 Amazon certificate.
signature: Base64 decoded Alexa request signature from Signature HTTP header.
request_body: full HTTPS r... | python | {
"resource": ""
} |
q266978 | verify_cert | test | def verify_cert(signature_chain_url: str) -> Optional[crypto.X509]:
"""Conducts series of Alexa SSL certificate verifications against Amazon Alexa requirements.
Args:
signature_chain_url: Signature certificate URL from SignatureCertChainUrl HTTP header.
Returns:
result: Amazon certificate i... | python | {
"resource": ""
} |
q266979 | RichMessage.json | test | def json(self) -> list:
"""Returns list of json compatible states of the RichMessage instance
nested controls.
Returns:
json_controls: Json representation of RichMessage instance
nested controls.
"""
json_controls = [control.json() for control in self... | python | {
"resource": ""
} |
q266980 | RichMessage.ms_bot_framework | test | def ms_bot_framework(self) -> list:
"""Returns list of MS Bot Framework compatible states of the
RichMessage instance nested controls.
Returns:
ms_bf_controls: MS Bot Framework representation of RichMessage instance
nested controls.
"""
ms_bf_controls... | python | {
"resource": ""
} |
q266981 | RichMessage.telegram | test | def telegram(self) -> list:
"""Returns list of Telegram compatible states of the RichMessage
instance nested controls.
Returns:
telegram_controls: Telegram representation of RichMessage instance nested
controls.
"""
telegram_controls = [control.telegr... | python | {
"resource": ""
} |
q266982 | RichMessage.alexa | test | def alexa(self) -> list:
"""Returns list of Amazon Alexa compatible states of the RichMessage
instance nested controls.
Returns:
alexa_controls: Amazon Alexa representation of RichMessage instance nested
controls.
"""
alexa_controls = [control.alexa()... | python | {
"resource": ""
} |
q266983 | main | test | def main():
"""DeepPavlov console configuration utility."""
args = parser.parse_args()
path = get_settings_path()
if args.default:
if populate_settings_dir(force=True):
print(f'Populated {path} with default settings files')
else:
print(f'{path} is already a defau... | python | {
"resource": ""
} |
q266984 | _graph_wrap | test | def _graph_wrap(func, graph):
"""Constructs function encapsulated in the graph."""
@wraps(func)
def _wrapped(*args, **kwargs):
with graph.as_default():
return func(*args, **kwargs)
return _wrapped | python | {
"resource": ""
} |
q266985 | _keras_wrap | test | def _keras_wrap(func, graph, session):
"""Constructs function encapsulated in the graph and the session."""
import keras.backend as K
@wraps(func)
def _wrapped(*args, **kwargs):
with graph.as_default():
K.set_session(session)
return func(*args, **kwargs)
return _wrap... | python | {
"resource": ""
} |
q266986 | accuracy | test | def accuracy(y_true: [list, np.ndarray], y_predicted: [list, np.ndarray]) -> float:
"""
Calculate accuracy in terms of absolute coincidence
Args:
y_true: array of true values
y_predicted: array of predicted values
Returns:
portion of absolutely coincidental samples
"""
... | python | {
"resource": ""
} |
q266987 | round_accuracy | test | def round_accuracy(y_true, y_predicted):
"""
Rounds predictions and calculates accuracy in terms of absolute coincidence.
Args:
y_true: list of true values
y_predicted: list of predicted values
Returns:
portion of absolutely coincidental samples
"""
predictions = [round... | python | {
"resource": ""
} |
q266988 | _pretrained_initializer | test | def _pretrained_initializer(varname, weight_file, embedding_weight_file=None):
"""
We'll stub out all the initializers in the pretrained LM with
a function that loads the weights from the file
"""
weight_name_map = {}
for i in range(2):
for j in range(8): # if we decide to add more laye... | python | {
"resource": ""
} |
q266989 | DatasetReader.read | test | def read(self, data_path: str, *args, **kwargs) -> Dict[str, List[Tuple[Any, Any]]]:
"""Reads a file from a path and returns data as a list of tuples of inputs and correct outputs
for every data type in ``train``, ``valid`` and ``test``.
"""
raise NotImplementedError | python | {
"resource": ""
} |
q266990 | make_hello_bot_agent | test | def make_hello_bot_agent() -> DefaultAgent:
"""Builds agent based on PatternMatchingSkill and HighestConfidenceSelector.
This is agent building tutorial. You can use this .py file to check how hello-bot agent works.
Returns:
agent: Agent capable of handling several simple greetings.
"""
sk... | python | {
"resource": ""
} |
q266991 | to_one_hot | test | def to_one_hot(x, k):
"""
Takes an array of integers and transforms it
to an array of one-hot encoded vectors
"""
unit = np.eye(k, dtype=int)
return unit[x] | python | {
"resource": ""
} |
q266992 | prettify_metrics | test | def prettify_metrics(metrics: List[Tuple[str, float]], precision: int = 4) -> OrderedDict:
"""Prettifies the dictionary of metrics."""
prettified_metrics = OrderedDict()
for key, value in metrics:
value = round(value, precision)
prettified_metrics[key] = value
return prettified_metrics | python | {
"resource": ""
} |
q266993 | populate_settings_dir | test | def populate_settings_dir(force: bool = False) -> bool:
"""
Populate settings directory with default settings files
Args:
force: if ``True``, replace existing settings files with default ones
Returns:
``True`` if any files were copied and ``False`` otherwise
"""
res = False
... | python | {
"resource": ""
} |
q266994 | TFModel.load | test | def load(self, exclude_scopes: tuple = ('Optimizer',)) -> None:
"""Load model parameters from self.load_path"""
if not hasattr(self, 'sess'):
raise RuntimeError('Your TensorFlow model {} must'
' have sess attribute!'.format(self.__class__.__name__))
pat... | python | {
"resource": ""
} |
q266995 | TFModel.save | test | def save(self, exclude_scopes: tuple = ('Optimizer',)) -> None:
"""Save model parameters to self.save_path"""
if not hasattr(self, 'sess'):
raise RuntimeError('Your TensorFlow model {} must'
' have sess attribute!'.format(self.__class__.__name__))
path ... | python | {
"resource": ""
} |
q266996 | TFModel.get_train_op | test | def get_train_op(self,
loss,
learning_rate,
optimizer=None,
clip_norm=None,
learnable_scopes=None,
optimizer_scope_name=None,
**kwargs):
"""
Get train operat... | python | {
"resource": ""
} |
q266997 | LevenshteinSearcher.search | test | def search(self, word, d, allow_spaces=True, return_cost=True):
"""
Finds all dictionary words in d-window from word
"""
if not all((c in self.alphabet
or (c == " " and self.allow_spaces)) for c in word):
return []
# raise ValueError("{0} conta... | python | {
"resource": ""
} |
q266998 | SegmentTransducer._make_default_operation_costs | test | def _make_default_operation_costs(self, allow_spaces=False):
"""
sets 1.0 cost for every replacement, insertion, deletion and transposition
"""
self.operation_costs = dict()
self.operation_costs[""] = {c: 1.0 for c in list(self.alphabet) + [' ']}
for a in self.alphabet:
... | python | {
"resource": ""
} |
q266999 | Conversation._start_timer | test | def _start_timer(self) -> None:
"""Initiates self-destruct timer."""
self.timer = Timer(self.config['conversation_lifetime'], self.self_destruct_callback)
self.timer.start() | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.