SYMBOL INDEX (359 symbols across 65 files)

FILE: annotator_models/trainer/dawid_skene.py
  function run (line 25) | def run(items,
  function load_data (line 99) | def load_data(path, unit_id, worker_id, label):
  function initialize (line 110) | def initialize(counts):
  function m_step (line 140) | def m_step(counts, item_classes, psuedo_count):
  function m_step_verbose (line 186) | def m_step_verbose(counts, item_classes, psuedo_count):
  function e_step (line 233) | def e_step(counts_tiled, class_marginals, error_rates):
  function e_step_verbose (line 268) | def e_step_verbose(counts, class_marginals, error_rates):
  function calc_likelihood (line 306) | def calc_likelihood(counts, class_marginals, error_rates):
  function random_initialization (line 347) | def random_initialization(counts):
  function majority_voting (line 376) | def majority_voting(counts):
  function parse_item_classes (line 404) | def parse_item_classes(df, label, item_classes, index_to_unit_id_map,
  function parse_error_rates (line 468) | def parse_error_rates(df, error_rates, index_to_worker_id_map, index_to_...
  function main (line 510) | def main(FLAGS):

FILE: annotator_models/trainer/dawid_skene_test.py
  class DawidSkeneTest (line 15) | class DawidSkeneTest(unittest.TestCase):
    method setUp (line 19) | def setUp(self):
    method test_paper_example (line 53) | def test_paper_example(self):

FILE: attention-tutorial/process_figshare.py
  function download_figshare (line 40) | def download_figshare(download_data_dir=DEFAULT_DATA_DIR):
  function process_figshare (line 65) | def process_figshare(input_data_dir=DEFAULT_DATA_DIR,

FILE: attention-tutorial/visualize_attention.py
  class wordVal (line 35) | class wordVal(object):
    method __init__ (line 38) | def __init__(self, word, val):
    method __str__ (line 42) | def __str__(self):
  class attentionDisplay (line 46) | class attentionDisplay(object):
    method __init__ (line 49) | def __init__(self, vocab_processor, classifier, words_feature='words'):
    method _rgb_to_hex (line 64) | def _rgb_to_hex(self, rgb):
    method _color_wordvals (line 67) | def _color_wordvals(self, s):
    method _predict_sentence (line 72) | def _predict_sentence(self, input_string):
    method _resize_and_tokenize (line 87) | def _resize_and_tokenize(self, input_string):
    method display_prediction_attention (line 94) | def display_prediction_attention(self, input_string):

FILE: data_preparation/preprocessing/preprocessing.py
  function get_identity_list (line 14) | def get_identity_list():
  function get_civil_comments_spec (line 26) | def get_civil_comments_spec(include_identity_terms=True):
  function split_data (line 49) | def split_data(examples, train_fraction, eval_fraction):
  function Shuffle (line 65) | def Shuffle(examples):  # pylint: disable=invalid-name
  function write_to_tf_records (line 72) | def write_to_tf_records(examples, output_path):
  class OversampleExample (line 87) | class OversampleExample(beam.DoFn):
    method __init__ (line 90) | def __init__(self, rule_fn, oversample_rate):
    method process (line 96) | def process(self, element):
  function _select_male_toxic_example (line 104) | def _select_male_toxic_example(example,
  function run_data_split (line 115) | def run_data_split(p, input_data_path, train_fraction, eval_fraction,
  function run_artificial_bias (line 163) | def run_artificial_bias(p, train_input_data_path, output_folder,

FILE: data_preparation/preprocessing/tfrecord_utils.py
  class Schema (line 11) | class Schema(object):
    method __init__ (line 20) | def __init__(self, spec):
    method as_feature_spec (line 23) | def as_feature_spec(self):
  class DecodeTFRecord (line 27) | class DecodeTFRecord(beam.DoFn):
    method __init__ (line 38) | def __init__(self,
    method process (line 59) | def process(self, element):
  class EncodeTFRecord (line 67) | class EncodeTFRecord(beam.DoFn):
    method __init__ (line 70) | def __init__(self, feature_spec, optional_field_names):
    method process (line 82) | def process(self, element):

FILE: data_preparation/run_preprocessing_artificial_bias.py
  function _parse_arguments (line 13) | def _parse_arguments(argv):
  function _set_logging (line 39) | def _set_logging(log_level):
  function _parse_config (line 43) | def _parse_config(env, config_file_path):
  function main (line 58) | def main():

FILE: data_preparation/run_preprocessing_data_split.py
  function _parse_arguments (line 13) | def _parse_arguments(argv):
  function _set_logging (line 45) | def _set_logging(log_level):
  function _parse_config (line 49) | def _parse_config(env, config_file_path):
  function main (line 64) | def main():

FILE: experiments/tf_trainer/common/base_model.py
  class BaseModel (line 41) | class BaseModel(abc.ABC):
    method map (line 48) | def map(self, f: Callable[[tf.estimator.Estimator], tf.estimator.Estim...
    method estimator (line 68) | def estimator(self, model_dir: str) -> tf.estimator.Estimator:
    method hparams (line 71) | def hparams(self) -> tf.contrib.training.HParams:

FILE: experiments/tf_trainer/common/cnn_spec_parser.py
  class FilterParseError (line 42) | class FilterParseError(Exception):
  class Filter (line 46) | class Filter(object):
    method __init__ (line 52) | def __init__(self, str: str) -> None:
    method __str__ (line 60) | def __str__(self) -> str:
  class ConcurrentFilters (line 64) | class ConcurrentFilters(object):
    method __init__ (line 70) | def __init__(self, str: str) -> None:
    method __str__ (line 74) | def __str__(self) -> str:
  class SequentialLayers (line 78) | class SequentialLayers(object):
    method __init__ (line 84) | def __init__(self, str: str) -> None:
    method __str__ (line 89) | def __str__(self) -> str:

FILE: experiments/tf_trainer/common/cnn_spec_parser_test.py
  class CnnSpecParserTest (line 28) | class CnnSpecParserTest(tf.test.TestCase):
    method test_SequentialLayers (line 30) | def test_SequentialLayers(self):

FILE: experiments/tf_trainer/common/dataset_input.py
  class DatasetInput (line 25) | class DatasetInput(abc.ABC):
    method train_input_fn (line 33) | def train_input_fn(self) -> types.EstimatorInput:
    method validate_input_fn (line 37) | def validate_input_fn(self) -> types.EstimatorInput:

FILE: experiments/tf_trainer/common/episodic_tfrecord_input.py
  class EpisodicTFRecordInput (line 44) | class EpisodicTFRecordInput(dataset_input.DatasetInput):
    method __init__ (line 47) | def __init__(self, train_dir, validate_dir) -> None:
    method train_input_fn (line 51) | def train_input_fn(self) -> types.FeatureAndLabelTensors:
    method validate_input_fn (line 61) | def validate_input_fn(self) -> types.FeatureAndLabelTensors:
    method _get_randomized_episodes (line 64) | def _get_randomized_episodes(self, directory: str) -> List[EpisodeData]:
    method _dataset_from_tfrecord_file (line 83) | def _dataset_from_tfrecord_file(self, tfrecord_file: str) -> EpisodeData:

FILE: experiments/tf_trainer/common/episodic_tfrecord_input_test.py
  class EpisodicTFRecordInputTest (line 11) | class EpisodicTFRecordInputTest(tf.test.TestCase):
    method test (line 13) | def test(self):

FILE: experiments/tf_trainer/common/model_trainer.py
  class InitHook (line 73) | class InitHook(tf.train.SessionRunHook):
    method __init__ (line 79) | def __init__(self, checkpoint_dir):
    method begin (line 83) | def begin(self):
  function forward_features (line 114) | def forward_features(estimator, keys, sparse_default_values=None):
  class ModelTrainer (line 228) | class ModelTrainer(object):
    method __init__ (line 231) | def __init__(self, dataset: ds.DatasetInput,
    method train_with_eval (line 239) | def train_with_eval(self):
    method predict_on_dev (line 276) | def predict_on_dev(self, predict_keys=None):
    method eval_dir (line 283) | def eval_dir(self):
    method _model_dir (line 286) | def _model_dir(self):
    method _add_estimator_key (line 298) | def _add_estimator_key(self, estimator, example_key_name):
    method _get_best_step_from_event_file (line 304) | def _get_best_step_from_event_file(self,
    method _get_best_checkpoint (line 335) | def _get_best_checkpoint(self,
    method _get_list_checkpoint (line 392) | def _get_list_checkpoint(self,
    method export (line 456) | def export(self,

FILE: experiments/tf_trainer/common/serving_input.py
  function create_text_serving_input_fn (line 12) | def create_text_serving_input_fn(text_feature_name, example_key_name):
  function create_serving_input_fn (line 32) | def create_serving_input_fn(word_to_idx,

FILE: experiments/tf_trainer/common/text_preprocessor.py
  class TextPreprocessor (line 37) | class TextPreprocessor(object):
    method __init__ (line 49) | def __init__(self, embeddings_path: str) -> None:
    method train_preprocess_fn (line 53) | def train_preprocess_fn(self,
    method add_embedding_to_model (line 92) | def add_embedding_to_model(self, model: base_model.BaseModel,
    method create_estimator_with_embedding (line 104) | def create_estimator_with_embedding(
    method word_to_idx (line 173) | def word_to_idx(self) -> Dict[str, int]:
    method unknown_token (line 176) | def unknown_token(self) -> int:
    method word_embeddings (line 179) | def word_embeddings(self, trainable) -> tf.Variable:

FILE: experiments/tf_trainer/common/text_preprocessor_test.py
  class TextPreprocessorTest (line 25) | class TextPreprocessorTest(tf.test.TestCase):
    method test_Tokenize (line 27) | def test_Tokenize(self):
    method test_Lowercase (line 36) | def test_Lowercase(self):

FILE: experiments/tf_trainer/common/tfrecord_input.py
  class TFRecordInput (line 43) | class TFRecordInput(dataset_input.DatasetInput):
    method __init__ (line 53) | def __init__(self) -> None:
    method labels (line 64) | def labels(self) -> List[str]:
    method text_feature (line 68) | def text_feature(self) -> str:
    method train_input_fn (line 72) | def train_input_fn(self) -> tf.data.TFRecordDataset:
    method validate_input_fn (line 81) | def validate_input_fn(self) -> tf.data.TFRecordDataset:
    method _keys_to_features (line 86) | def _keys_to_features(self):
    method _input_fn_from_file (line 94) | def _input_fn_from_file(self, filepath: str) -> tf.data.TFRecordDataset:
    method _process_labels (line 102) | def _process_labels(self, features, parsed):
    method _read_tf_example (line 132) | def _read_tf_example(
  class TFRecordInputWithTokenizer (line 148) | class TFRecordInputWithTokenizer(TFRecordInput):
    method __init__ (line 160) | def __init__(self,
    method _input_fn_from_file (line 167) | def _input_fn_from_file(self, filepath: str) -> types.FeatureAndLabelT...
    method _read_tf_example (line 197) | def _read_tf_example(

FILE: experiments/tf_trainer/common/tfrecord_input_test.py
  class TFRecordInputTest (line 31) | class TFRecordInputTest(tf.test.TestCase):
    method setUp (line 33) | def setUp(self):
    method test_TFRecordInput_unrounded (line 54) | def test_TFRecordInput_unrounded(self):
    method test_TFRecordInput_default_values (line 68) | def test_TFRecordInput_default_values(self):
    method test_TFRecordInput_rounded (line 84) | def test_TFRecordInput_rounded(self):
  class TFRecordInputWithTokenizerTest (line 97) | class TFRecordInputWithTokenizerTest(tf.test.TestCase):
    method setUp (line 99) | def setUp(self):
    method preprocessor (line 120) | def preprocessor(self, text):
    method test_TFRecordInputWithTokenizer_unrounded (line 127) | def test_TFRecordInputWithTokenizer_unrounded(self):
    method test_TFRecordInputWithTokenizer_default_values (line 147) | def test_TFRecordInputWithTokenizer_default_values(self):
    method test_TFRecordInputWithTokenizer_rounded (line 162) | def test_TFRecordInputWithTokenizer_rounded(self):

FILE: experiments/tf_trainer/common/token_embedding_index.py
  function LoadTokenIdxEmbeddings (line 22) | def LoadTokenIdxEmbeddings(embeddings_path: str) \

FILE: experiments/tf_trainer/common/token_embedding_index_test.py
  class LoadTokenIdxEmbeddingsTest (line 26) | class LoadTokenIdxEmbeddingsTest(tf.test.TestCase):
    method test_LoadTokenIdxEmbeddings (line 28) | def test_LoadTokenIdxEmbeddings(self):

FILE: experiments/tf_trainer/tf_char_cnn/model.py
  class TFCharCNNModel (line 43) | class TFCharCNNModel(base_model.BaseModel):
    method __init__ (line 49) | def __init__(self, target_labels: Set[str]) -> None:
    method hparams (line 53) | def hparams():
    method estimator (line 67) | def estimator(self, model_dir):
    method _model_fn (line 74) | def _model_fn(self, features, labels, mode, params, config):

FILE: experiments/tf_trainer/tf_char_cnn/run.py
  function main (line 18) | def main(argv):

FILE: experiments/tf_trainer/tf_cnn/finetune.py
  function main (line 34) | def main(argv):

FILE: experiments/tf_trainer/tf_cnn/model.py
  class TFCNNModel (line 40) | class TFCNNModel(base_model.BaseModel):
    method __init__ (line 47) | def __init__(self, target_labels: Set[str]) -> None:
    method hparams (line 51) | def hparams():
    method estimator (line 64) | def estimator(self, model_dir):
    method _model_fn (line 71) | def _model_fn(self, features, labels, mode, params, config):

FILE: experiments/tf_trainer/tf_cnn/run.py
  function main (line 24) | def main(argv):

FILE: experiments/tf_trainer/tf_gru_attention/finetune.py
  function main (line 34) | def main(argv):

FILE: experiments/tf_trainer/tf_gru_attention/model.py
  function attend (line 33) | def attend(inputs, attention_size, attention_depth=1):
  class TFRNNModel (line 51) | class TFRNNModel(base_model.BaseModel):
    method __init__ (line 53) | def __init__(self, target_labels: Set[str]) -> None:
    method hparams (line 57) | def hparams():
    method estimator (line 68) | def estimator(self, model_dir):
    method _model_fn (line 75) | def _model_fn(self, features, labels, mode, params, config):

FILE: experiments/tf_trainer/tf_gru_attention/run.py
  function main (line 26) | def main(argv):

FILE: experiments/tf_trainer/tf_hub_classifier/finetune.py
  function main (line 29) | def main(argv):

FILE: experiments/tf_trainer/tf_hub_classifier/model.py
  class TFHubClassifierModel (line 35) | class TFHubClassifierModel(base_model.BaseModel):
    method __init__ (line 37) | def __init__(self, target_labels: List[str]) -> None:
    method hparams (line 41) | def hparams():
    method estimator (line 49) | def estimator(self, model_dir):
    method _model_fn (line 56) | def _model_fn(self, features, labels, mode, params, config):

FILE: experiments/tf_trainer/tf_hub_classifier/run.py
  function main (line 18) | def main(argv):

FILE: experiments/tf_trainer/tf_hub_tfjs/model.py
  class TFHubClassifierModel (line 35) | class TFHubClassifierModel(base_model.BaseModel):
    method __init__ (line 37) | def __init__(self, target_labels: List[str]) -> None:
    method hparams (line 41) | def hparams():
    method estimator (line 49) | def estimator(self, model_dir):
    method _model_fn (line 56) | def _model_fn(self, features, labels, mode, params, config):

FILE: experiments/tf_trainer/tf_hub_tfjs/run.py
  class TFRecordWithSentencePiece (line 21) | class TFRecordWithSentencePiece(tfrecord_input.TFRecordInput):
    method __init__ (line 24) | def __init__(self, spm_path):
    method dense_ids (line 29) | def dense_ids(self, texts):
    method pieces (line 34) | def pieces(self, feature_dict, label_dict):
    method _input_fn_from_file (line 44) | def _input_fn_from_file(self, filepath: str):
  function main (line 54) | def main(argv):

FILE: experiments/tf_trainer/tf_kona_prototypical_network/proto.py
  function distance (line 37) | def distance(embeddings, prototype):
  function neg_distance (line 41) | def neg_distance(embs, proto):
  function calculate_logits (line 45) | def calculate_logits(embeddings, positive_prototype, negative_prototype):
  function prepare_dataset (line 51) | def prepare_dataset(data):
  function encoder (line 82) | def encoder(dense_config, output_types, output_shapes):
  function train_operation (line 140) | def train_operation(negative_logits, positive_logits):
  function predictions_and_metrics (line 154) | def predictions_and_metrics(negative_logits, positive_logits):
  function main (line 173) | def main():

FILE: experiments/tf_trainer/tf_word_label_embedding/model.py
  class TFWordLabelEmbeddingModel (line 26) | class TFWordLabelEmbeddingModel(base_model.BaseModel):
    method __init__ (line 28) | def __init__(self, target_label: str) -> None:
    method hparams (line 33) | def hparams():
    method estimator (line 41) | def estimator(self, model_dir):
    method _model_fn (line 48) | def _model_fn(self, features, labels, mode, params, config):

FILE: experiments/tf_trainer/tf_word_label_embedding/run.py
  function main (line 25) | def main(argv):

FILE: experiments/tools/bert_tfrecord_converter.py
  function create_int_feature (line 46) | def create_int_feature(values):
  function create_tokenizer_from_hub_module (line 50) | def create_tokenizer_from_hub_module(url):
  function convert_tfrecord_for_bert (line 63) | def convert_tfrecord_for_bert(filenames,

FILE: experiments/tools/convert_csv_to_tfrecord.py
  function convert_csv_to_tfrecord (line 37) | def convert_csv_to_tfrecord(input_csv_path,
  function main (line 63) | def main(argv):

FILE: experiments/tools/convert_jsonl_to_tfrecord.py
  class MisingAllTextFieldsError (line 68) | class MisingAllTextFieldsError(Exception):
  class FieldsCounter (line 72) | class FieldsCounter():
    method __init__ (line 74) | def __init__(self):
    method inc_field (line 77) | def inc_field(self, field_name: str):
  function make_selected_output_row (line 83) | def make_selected_output_row(row, line, counters):
  function itr_as_dict (line 109) | def itr_as_dict(input_jsonlines_path):
  function itr_as_tfrecord (line 120) | def itr_as_tfrecord(input_jsonlines_path):
  function convert_to_tfrecord (line 132) | def convert_to_tfrecord(input_jsonlines_path, output_tfrecord_path):
  function main (line 138) | def main(argv):

FILE: hierarchical_attention_research/han_model/HAN_model.py
  class HANClassifierModel (line 8) | class HANClassifierModel():
    method __init__ (line 16) | def __init__(self,
    method _init_embedding (line 104) | def _init_embedding(self, scope):
    method _init_body (line 115) | def _init_body(self, scope):
    method get_feed_data (line 175) | def get_feed_data(self, x, y=None, class_weights=None, is_training=True):

FILE: hierarchical_attention_research/han_model/bn_lstm.py
  class LSTMCell (line 13) | class LSTMCell(RNNCell):
    method __init__ (line 16) | def __init__(self, num_units):
    method state_size (line 20) | def state_size(self):
    method output_size (line 24) | def output_size(self):
    method __call__ (line 27) | def __call__(self, x, state, scope=None):
  class BNLSTMCell (line 55) | class BNLSTMCell(RNNCell):
    method __init__ (line 58) | def __init__(self, num_units, training):
    method state_size (line 63) | def state_size(self):
    method output_size (line 67) | def output_size(self):
    method __call__ (line 70) | def __call__(self, x, state, scope=None):
  function orthogonal (line 101) | def orthogonal(shape):
  function bn_lstm_identity_initializer (line 109) | def bn_lstm_identity_initializer(scale):
  function orthogonal_initializer (line 125) | def orthogonal_initializer():
  function batch_norm (line 133) | def batch_norm(x, name_scope, training, epsilon=1e-3, decay=0.999):

FILE: hierarchical_attention_research/han_model/data_util.py
  function batch (line 4) | def batch(inputs):

FILE: hierarchical_attention_research/han_model/model_components.py
  function bidirectional_rnn (line 10) | def bidirectional_rnn(cell_fw,
  function task_specific_attention (line 55) | def task_specific_attention(inputs,

FILE: hierarchical_attention_research/han_model/worker.py
  function HAN_model_1 (line 59) | def HAN_model_1(session, restore_only=False):
  function decode (line 115) | def decode(ex):
  function batch_iterator (line 126) | def batch_iterator(dataset, batch_size, max_epochs):
  function ev (line 139) | def ev(session, model, dataset):
  function evaluate (line 158) | def evaluate(dataset):
  function train (line 169) | def train():
  function main (line 227) | def main():

FILE: hierarchical_attention_research/han_model/yelp.py
  function _read_dataset (line 22) | def _read_dataset(fn, review_max_sentences=30, sentence_max_length=30,
  function read_trainset (line 46) | def read_trainset(epochs=1):
  function read_devset (line 50) | def read_devset(epochs=1):
  function read_vocab (line 54) | def read_vocab():
  function read_labels (line 59) | def read_labels():

FILE: hierarchical_attention_research/han_model/yelp_prepare.py
  function read_reviews (line 19) | def read_reviews():
  function build_word_frequency_distribution (line 25) | def build_word_frequency_distribution():
  function build_vocabulary (line 49) | def build_vocabulary(lower=3, n=50000):
  function make_data (line 72) | def make_data(split_points=(0.8, 0.94)):

FILE: kaggle-classification/keras_trainer/base_model.py
  class BaseModel (line 12) | class BaseModel(metaclass=ABCMeta):
    method get_model (line 16) | def get_model(self) -> Model:

FILE: kaggle-classification/keras_trainer/cnn_with_attention.py
  class CNNWithAttention (line 24) | class CNNWithAttention(base_model.BaseModel):
    method __init__ (line 35) | def __init__(self, embeddings_matrix, hparams, labels):
    method get_model (line 41) | def get_model(self):

FILE: kaggle-classification/keras_trainer/custom_metrics.py
  function auc_roc (line 10) | def auc_roc(y_true, y_pred):

FILE: kaggle-classification/keras_trainer/model.py
  class ModelRunner (line 59) | class ModelRunner():
    method __init__ (line 62) | def __init__(self, job_dir, embeddings_path, log_path, hparams, labels):
    method train (line 80) | def train(self, train):
    method predict (line 116) | def predict(self, texts):
    method score_metric (line 120) | def score_metric(self, data, metric_name, metric_fn):
    method score_auc (line 144) | def score_auc(self, data):
    method score_precision (line 148) | def score_precision(self, data):
    method score_recall (line 153) | def score_recall(self, data):
    method _prep_texts (line 158) | def _prep_texts(self, texts):
    method _load_model (line 163) | def _load_model(self):
    method _setup_tokenizer (line 173) | def _setup_tokenizer(self):
    method _setup_embeddings_matrix (line 183) | def _setup_embeddings_matrix(self):

FILE: kaggle-classification/keras_trainer/rnn.py
  class RNNModel (line 13) | class RNNModel(base_model.BaseModel):
    method __init__ (line 22) | def __init__(self, embeddings_matrix, hparams, labels):
    method get_model (line 28) | def get_model(self):

FILE: kaggle-classification/keras_trainer/single_layer_cnn.py
  class SingleLayerCnn (line 22) | class SingleLayerCnn(base_model.BaseModel):
    method __init__ (line 33) | def __init__(self, embeddings_matrix, hparams, labels):
    method get_model (line 39) | def get_model(self) -> Model:

FILE: kaggle-classification/trainer/model.py
  function estimator_spec_for_softmax_classification (line 60) | def estimator_spec_for_softmax_classification(logits, labels, mode,
  function get_cnn_model (line 139) | def get_cnn_model(embedding_size, num_filters, dropout_keep_prob):
  function bag_of_words_model (line 209) | def bag_of_words_model(features, labels, mode):
  function main (line 237) | def main(FLAGS):

FILE: kaggle-classification/trainer/wikidata.py
  function ngrams (line 14) | def ngrams(sentence, ngram_size):
  class WikiData (line 25) | class WikiData:
    method __init__ (line 27) | def __init__(self,
    method _load_vocab_processor (line 94) | def _load_vocab_processor(self, path):
    method _load_csv (line 98) | def _load_csv(self, path):
    method _split (line 110) | def _split(self, data, train_percent, x_field, y_class, seed=None):

FILE: model_evaluation/input_fn_example.py
  function create_input_fn_toxicity_performance (line 45) | def create_input_fn_toxicity_performance(tokenizer, model_input_comment_...
  function create_input_fn_civil_performance (line 166) | def create_input_fn_civil_performance(tokenizer, model_input_comment_fie...
  function create_input_fn_civil_bias (line 191) | def create_input_fn_civil_bias(tokenizer, model_input_comment_field):
  function create_input_fn_artificial_bias (line 245) | def create_input_fn_artificial_bias(tokenizer, model_input_comment_field):
  function create_input_fn_biasbios (line 303) | def create_input_fn_biasbios(tokenizer, model_input_comment_field, scrub...
  function create_input_fn_artificial_bias (line 340) | def create_input_fn_artificial_bias(tokenizer, model_input_comment_field):

FILE: model_evaluation/score_test_data.py
  function get_input_fn (line 51) | def get_input_fn(test_data, tokenizer, model_input_comment_field):
  function tokenizer (line 63) | def tokenizer(text, lowercase=True):
  function score_data (line 80) | def score_data(model_names,

FILE: model_evaluation/utils_export/dataset.py
  class Model (line 35) | class Model(object):
    method __init__ (line 44) | def __init__(self,
    method feature_keys_spec (line 79) | def feature_keys_spec(self):
    method example_key (line 82) | def example_key(self):
    method model_names (line 85) | def model_names(self):
    method prediction_keys (line 88) | def prediction_keys(self):
    method project_name (line 91) | def project_name(self):
    method set_job_ids_prediction (line 94) | def set_job_ids_prediction(self, job_ids):
    method job_ids_prediction (line 97) | def job_ids_prediction(self):
  class Dataset (line 101) | class Dataset(object):
    method __init__ (line 118) | def __init__(self, input_fn, dataset_dir):
    method show_data (line 130) | def show_data(self):
    method check_input_fn (line 136) | def check_input_fn(self, input_fn):
    method check_compatibility (line 153) | def check_compatibility(self, model):
    method load_data (line 168) | def load_data(self, max_n_examples, **kwargs):
    method get_path_input_tf (line 171) | def get_path_input_tf(self):
    method get_path_prediction (line 177) | def get_path_prediction(self, model_name):
    method convert_data_to_tf (line 183) | def convert_data_to_tf(self, feature_keys_spec, example_key, overwrite...
    method call_prediction (line 212) | def call_prediction(self, model):
    method collect_prediction (line 245) | def collect_prediction(self, model, class_names):
    method wait_predictions (line 258) | def wait_predictions(self, model):
    method add_model_prediction_to_data (line 269) | def add_model_prediction_to_data(self, model, recompute_predictions=Tr...

FILE: model_evaluation/utils_export/dataset_test.py
  class TestCompatibleInputFn (line 32) | class TestCompatibleInputFn(unittest.TestCase):
    method testCorrect (line 35) | def testCorrect(self):
    method testWrongArgInputFn (line 48) | def testWrongArgInputFn(self):
    method testInputFnWrongType (line 59) | def testInputFnWrongType(self):
    method testWrongNumberOfLines (line 72) | def testWrongNumberOfLines(self):
  class TestModelCompatibleWithInputFn (line 88) | class TestModelCompatibleWithInputFn(unittest.TestCase):
    method testBadTypeFeatureKeys (line 91) | def testBadTypeFeatureKeys(self):
    method testInputFnMissingFeatureKeys (line 101) | def testInputFnMissingFeatureKeys(self):
    method testModelIsCompatibleWithDataset (line 121) | def testModelIsCompatibleWithDataset(self):
  class TestEndPipeline (line 141) | class TestEndPipeline(unittest.TestCase):
    method setUp (line 146) | def setUp(self):
    method testComputePredictions (line 171) | def testComputePredictions(self):
    method testLoadPredictions (line 177) | def testLoadPredictions(self):

FILE: model_evaluation/utils_export/deploy_list_models.py
  function get_list_models_to_export (line 37) | def get_list_models_to_export(parent_model_dir):
  function check_model_exists (line 46) | def check_model_exists(project_name, model_name):
  function create_model (line 59) | def create_model(project_name, model_name):
  function create_version (line 73) | def create_version(project_name, model_name, version_name, model_dir):
  function check_version_deployed (line 96) | def check_version_deployed(operation_id):
  function deploy_model_version (line 115) | def deploy_model_version(project_name, model_name, version_name, model_d...
  function _get_version_name (line 133) | def _get_version_name(model_dir, go_up_3=True):
  function deploy_all_models (line 147) | def deploy_all_models(list_model_dir, project_name, model_name):

FILE: model_evaluation/utils_export/utils_cloudml.py
  function call_model_predictions_from_df (line 34) | def call_model_predictions_from_df(project_name,
  function _call_batch_job (line 74) | def _call_batch_job(project_name,
  function _make_batch_job_body (line 106) | def _make_batch_job_body(project_name,
  function check_job_over (line 159) | def check_job_over(project_name, job_name):
  function add_model_predictions_to_df (line 184) | def add_model_predictions_to_df(df, prediction_file, model_col_name,

FILE: model_evaluation/utils_export/utils_cloudml_test.py
  class CallModelPredictionsFromDf (line 27) | class CallModelPredictionsFromDf(unittest.TestCase):
    method test_correct (line 32) | def test_correct(self):
  class CheckJobOver (line 36) | class CheckJobOver(unittest.TestCase):
    method test_correct (line 40) | def test_correct(self):
  class AddModelPredictionsToDf (line 44) | class AddModelPredictionsToDf(unittest.TestCase):
    method setUp (line 47) | def setUp(self):
    method test_missing_prediction_file (line 58) | def test_missing_prediction_file(self):
    method test_empty_prediction_file (line 72) | def test_empty_prediction_file(self):
    method test_missing_example_key (line 86) | def test_missing_example_key(self):
    method test_missing_prediction_key (line 100) | def test_missing_prediction_key(self):
    method test_correct (line 113) | def test_correct(self):

FILE: model_evaluation/utils_export/utils_tfrecords.py
  function _bytes_feature (line 31) | def _bytes_feature(value):
  function _int64_feature (line 35) | def _int64_feature(value):
  function _bytes_list_feature (line 39) | def _bytes_list_feature(value_list):
  class EncodingFeatureSpec (line 45) | class EncodingFeatureSpec(object):
  function is_valid_spec (line 58) | def is_valid_spec(spec):
  function encode_pandas_to_tfrecords (line 72) | def encode_pandas_to_tfrecords(df,
  function decode_tf_records_to_pandas (line 119) | def decode_tf_records_to_pandas(decoding_features_spec,

FILE: model_evaluation/utils_export/utils_tfrecords_test.py
  class TestEncodingAndDecoding (line 29) | class TestEncodingAndDecoding(unittest.TestCase):
    method testCorrect (line 32) | def testCorrect(self):
  class TestFeatureKeySpec (line 60) | class TestFeatureKeySpec(unittest.TestCase):
    method test_not_a_dictionary (line 63) | def test_not_a_dictionary(self):
    method test_not_in_possible (line 70) | def test_not_in_possible(self):
    method test_valid (line 77) | def test_valid(self):