python_code stringlengths 0 187k | repo_name stringlengths 8 46 | file_path stringlengths 6 135 |
|---|---|---|
# pylint: disable=no-self-use,invalid-name
from allennlp_rc.eval.squad_eval import normalize_answer as _normalize_answer_squad
from allennlp_rc.eval.orb_utils import get_metric_squad
from allennlp_rc.eval.orb_utils import get_metric_drop
from allennlp_rc.eval.squad2_eval import get_metric_score as get_metric_squad2
fr... | allennlp-reading-comprehension-master | tests/eval/orb_eval_test.py |
allennlp-reading-comprehension-master | tests/eval/__init__.py | |
import os
from allennlp.common.testing import AllenNlpTestCase
from allennlp_rc.eval import quoref_eval
from tests import FIXTURES_ROOT
class TestQuorefEval(AllenNlpTestCase):
"""
The actual evaluation logic in Quoref's evaluation script is from DROP's script, and the
only additional thing that Quoref's... | allennlp-reading-comprehension-master | tests/eval/quoref_eval_test.py |
import io
from contextlib import redirect_stdout
from allennlp_rc.eval.drop_eval import _normalize_answer, get_metrics, evaluate_json
class TestDropEvalNormalize:
def test_number_parse(self):
assert _normalize_answer("12.0") == _normalize_answer("12.0 ")
assert _normalize_answer("12.0") == _norm... | allennlp-reading-comprehension-master | tests/eval/drop_eval_test.py |
#!/usr/bin/env python
import glob
import logging
import os
import re
import shutil
from allennlp.commands.train import train_model_from_file
logger = logging.getLogger(__name__)
def train_fixture(config_prefix: str) -> None:
import allennlp_rc # noqa F401: Needed to register the registrables.
config_file ... | allennlp-reading-comprehension-master | scripts/train_fixtures.py |
import json
import logging
import time
from typing import Iterable, List
from allennlp.common.checks import check_for_gpu
from allennlp.data import Instance
from allennlp.predictors import Predictor
from allennlp_rc.eval import SquadEmAndF1
from tqdm import tqdm
logger = logging.getLogger(__name__)
if __name__ == "... | allennlp-reading-comprehension-master | scripts/transformer_qa_eval.py |
AGGRESSIVE_THRESHOLD = 4 #cluegiver becomes more aggressive with the ordering of the Best Clues list based on the score of the game. "Aggression" = more? fewer? words in Target_Words Group
NUM_CLUES = 10 #number of clues to return in get_next_clue
| codenames-master | config.py |
"""setup.py file for packaging ``codenames``"""
from setuptools import setup, find_packages
with open('readme.md', 'r') as readme_file:
readme = readme_file.read()
setup(
name='codenames',
version='0.0.1',
description="Codenames hackathon 2018 project!",
long_description=readme,
url='http:/... | codenames-master | setup.py |
codenames-master | tests/__init__.py | |
from gensim.models import Word2Vec
from codenames.utils import file_utils
from codenames.utils.file_utils import read_lines
from random import choices
import random
words = [w.replace(" ", "_") for w in read_lines("codenames/gameplay/words.txt")]
all_sentences = []
for i in range(10000):
num_words = random.randi... | codenames-master | tests/models/gensim_w2v.py |
codenames-master | tests/models/__init__.py | |
from unittest import TestCase
from codenames.guessers.heuristic_guesser import HeuristicGuesser
from codenames.embedding_handler import EmbeddingHandler
class TestHeuristicGuesser(TestCase):
def test_guess(self):
embedding_handler = EmbeddingHandler("tests/fixtures/sample_embedding.txt")
sample_b... | codenames-master | tests/guessers/heuristic_guesser_test.py |
codenames-master | tests/guessers/__init__.py | |
from unittest import TestCase
from codenames.guessers.learned_guesser import LearnedGuesser
from codenames.embedding_handler import EmbeddingHandler
from codenames.guessers.policy.similarity_threshold import SimilarityThresholdPolicy
class TestLearnedGuesser(TestCase):
def test_guess(self):
embedding_han... | codenames-master | tests/guessers/learned_guesser_test.py |
from unittest import TestCase
from codenames.guessers.learned_guesser import LearnedGuesser
from codenames.embedding_handler import EmbeddingHandler
from codenames.guessers.policy.similarity_threshold_game_state import SimilarityThresholdGameStatePolicy
class TestLearnedGuesser(TestCase):
def test_guess(self):
... | codenames-master | tests/guessers/learned_guesser_game_state_test.py |
codenames-master | tests/clue_givers/__init__.py | |
from unittest import TestCase
from codenames.clue_givers.wordnet_cluegiver import WordnetClueGiver
from codenames.utils.game_utils import Clue
class TestWordnetClueGiver(TestCase):
def test_clues(self):
test_board = ["woman", "man", "girl", "boy", "blue", "cat", "queen", "king"]
test_allIDs = [1... | codenames-master | tests/clue_givers/wordnet_clue_giver_test.py |
import argparse
import os
from codenames.utils.file_utils import read_lines, read_lines_tokens
import spacy
from gensim.models import Word2Vec
import logging
def main(args):
corpus_location = args.corpus_location
save_dir = args.save_dir
workers = args.workers
output_weights_file = os.path.join(save... | codenames-master | codenames/train_w2v.py |
import logging
from typing import List
from scipy.spatial.distance import cosine
import numpy as np
class EmbeddingHandler:
"""
Parameters
----------
embedding_file : `str`
Location of a text file containing embeddings in word2vec format.
"""
def __init__(self, embedding_file: str) ->... | codenames-master | codenames/embedding_handler.py |
import logging
logging.getLogger().setLevel(logging.INFO)
| codenames-master | codenames/__init__.py |
import random
import numpy as np
from scipy.spatial.distance import cosine
from embedding_handler import EmbeddingHandler
import pickle
from tqdm import tqdm
dataset_codes = {"CODENAMES": "./data/codenames_words.txt", "SCIENCE": "./data/science_words.txt",
"COMMON": "./data/common_nouns_extrinsic.txt"... | codenames-master | codenames/dataset.py |
from collections import namedtuple
from typing import List
from collections import namedtuple
UNREVEALED = -1
GOOD = 1
BAD = 2
CIVILIAN = 3
ASSASSIN = 0
Clue = namedtuple('Clue', ['clue_word', 'intended_board_words', 'count'])
DEFAULT_NUM_CLUES = 10
DEFAULT_NUM_TARGETS = 4
CIVILIAN_PENALTY = .0
ASSASSIN_PENALT... | codenames-master | codenames/utils/game_utils.py |
codenames-master | codenames/utils/__init__.py | |
from typing import List
def read_lines(input_file: str) -> List[str]:
with open(input_file) as f:
lines = f.readlines()
return [l.strip() for l in lines]
def read_lines_tokens(input_file: str) -> List[str]:
with open(input_file) as f:
lines = f.readlines()
return [l.strip().s... | codenames-master | codenames/utils/file_utils.py |
from typing import List
from overrides import overrides
import torch
from torch.distributions import Categorical
from codenames.guessers.guesser import Guesser
from codenames.guessers.policy.guesser_policy import GuesserPolicy
from codenames.embedding_handler import EmbeddingHandler
from codenames.utils import game_u... | codenames-master | codenames/guessers/learned_guesser.py |
from typing import List
from overrides import overrides
from codenames.embedding_handler import EmbeddingHandler
from codenames.guessers.guesser import Guesser
import codenames.utils.game_utils as util
class HeuristicGuesser(Guesser):
def __init__(self, embedding_handler: EmbeddingHandler):
self.embedd... | codenames-master | codenames/guessers/heuristic_guesser.py |
codenames-master | codenames/guessers/__init__.py | |
from typing import List
class Guesser:
"""
Parameters
----------
board : `List[str]`
List of all words on the board in the current game
embedding_file : `str`
Location of pickled embeddings
"""
def guess(self,
board: List[str],
clue: str,
... | codenames-master | codenames/guessers/guesser.py |
import torch as torch
import torch.nn as nn
from codenames.guessers.policy.guesser_policy import GuesserPolicy
class SimilarityThresholdGameStatePolicy(GuesserPolicy, nn.Module):
'''
embed_size is the size of the word embeddings
'''
def __init__(self, embed_size, seed=42):
super(GuesserPolicy... | codenames-master | codenames/guessers/policy/similarity_threshold_game_state.py |
import torch
class GuesserPolicy:
def __init__(self):
raise NotImplementedError
'''
Runs model forward to create a new policy for a given state.
Inputs should be specified by child instantiations.`
'''
def forward(self) -> torch.Tensor:
raise NotImplementedError
| codenames-master | codenames/guessers/policy/guesser_policy.py |
codenames-master | codenames/guessers/policy/__init__.py | |
import torch as torch
import torch.nn as nn
from codenames.guessers.policy.guesser_policy import GuesserPolicy
class SimilarityThresholdPolicy(GuesserPolicy, nn.Module):
'''
embed_size is the size of the word embeddings
'''
def __init__(self, embed_size, seed=42):
super(GuesserPolicy, self)._... | codenames-master | codenames/guessers/policy/similarity_threshold.py |
#!/usr/bin/env python
# coding=utf-8
import argparse
import io
import os
import os.path
from functools import partial
from gameplay.config import config
# Maximum number of wikipedia articles to index per word. Can be
# overridden using the --max-size command-line argument.
max_index_size = 10000
def ingest(page,... | codenames-master | codenames/gameplay/create_corpus_index.py |
#!/usr/bin/env python
# coding=utf-8
import json
import os
import os.path
import sys
CONFIG_FILE = os.path.dirname(__file__) + "/config.json"
class Config(object):
def __init__(self):
config_path = os.path.abspath(CONFIG_FILE)
if not os.path.isfile(config_path):
print('Error: can\'t... | codenames-master | codenames/gameplay/config.py |
#!/usr/bin/env python
import argparse
import gzip
import os.path
import re
import nltk.tokenize
from gameplay.config import config
def main():
parser = argparse.ArgumentParser(
description='Preprocess training corpus.',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_arg... | codenames-master | codenames/gameplay/preprocess_corpus.py |
#!/usr/bin/env python
import argparse
import gzip
import io
import multiprocessing
import os
import os.path
import random
import warnings
import wikipedia
from gameplay.config import config
dry_run = False
def fetch(word, min_size=5e6):
# Use a reproducible but different "random" shuffle for each word.
... | codenames-master | codenames/gameplay/fetch_corpus_text.py |
import logging
logging.getLogger().setLevel(logging.ERROR)
| codenames-master | codenames/gameplay/__init__.py |
#!/usr/bin/env python
import argparse
import re
from gameplay.engine import GameEngine
def main():
parser = argparse.ArgumentParser(
description='Play the CodeNames game.',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-c', '--config', type=str, default='CHCH'... | codenames-master | codenames/gameplay/play.py |
import warnings
import numpy as np
import nltk.stem.wordnet
import sklearn.cluster
class WordEmbedding(object):
def __init__(self, filename):
# Import gensim here so we can mute a UserWarning about the Pattern
# library not being installed.
with warnings.catch_warnings():
... | codenames-master | codenames/gameplay/model.py |
import itertools
import re
import sys
import os
import platform
import numpy as np
from termcolor import colored
from codenames.gameplay.model import WordEmbedding
from codenames.gameplay.config import config
CLUE_PATTERN = r'^([a-zA-Z]+) ({0})$'
UNLIMITED = "unlimited"
# noinspection PyAttributeOutsideInit
clas... | codenames-master | codenames/gameplay/engine.py |
#!/usr/bin/env python
import argparse
import warnings
import logging
import random
import gzip
import os.path
from gameplay.config import config
def main():
parser = argparse.ArgumentParser(
description='Merge training corpus.',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser... | codenames-master | codenames/gameplay/learn.py |
#!/usr/bin/env python
# coding=utf-8
import argparse
import glob
import os
from gameplay.model import WordEmbedding
from gameplay.config import config
def main():
parser = argparse.ArgumentParser(
description='Evaluate word embedding.',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
... | codenames-master | codenames/gameplay/evaluate.py |
import sys
import os
import re
import tqdm
import datetime
from collections import defaultdict
from random import choices, shuffle
from typing import List
from termcolor import colored
import numpy as np
import argparse
import torch
from codenames.clue_givers.giver import Giver, Clue
from codenames.clue_givers.heuris... | codenames-master | codenames/gameplay/ai2_hack.py |
from typing import List
from codenames.utils.game_utils import Clue
class Giver:
def get_next_clue(self,
board: List[str],
allIDs: List[int],
game_state: List[int],
current_score: int) -> List[Clue]:
"""
Parame... | codenames-master | codenames/clue_givers/giver.py |
codenames-master | codenames/clue_givers/__init__.py | |
# from codenames.clue_givers.giver import Giver
import logging
import operator
from itertools import combinations, chain
from typing import List
import numpy as np
from random import choices
from codenames.clue_givers.giver import Giver
from codenames.embedding_handler import EmbeddingHandler
from codenames.utils.gam... | codenames-master | codenames/clue_givers/heuristic_giver.py |
from overrides import overrides
from gensim.test.utils import datapath, get_tmpfile
from gensim.models import KeyedVectors
from itertools import combinations, chain, permutations
from codenames.clue_givers.giver import Giver
import numpy as np
from codenames.utils.game_utils import get_available_choices, Clue
import op... | codenames-master | codenames/clue_givers/wordnet_cluegiver.py |
from gensim.models import KeyedVectors
from itertools import combinations, chain
from codenames.embedding_handler import EmbeddingHandler
from codenames.clue_givers.giver import Giver
import numpy as np
from codenames.utils.game_utils import Clue
import operator
from typing import List
import logging
from sklearn.metri... | codenames-master | codenames/clue_givers/heuristic_giver2.py |
from typing import Optional, Dict, List, Tuple
import csv
import random
import spacy
import torch
import tqdm
# Load the spacy model
nlp = spacy.load('en_core_web_sm')
# Just some type aliases to make things cleaner
RawRow = List[str]
ProcessedRow = Tuple[str, List[str]]
def process(row: RawRow) -> ProcessedRow:
... | aiconf-allennlp-tutorial-master | by_hand.py |
import csv
import pathlib
import os
import re
import tqdm
DATA_ROOT = pathlib.Path("data")
BBC_ROOT = DATA_ROOT / 'bbc'
train = []
validate = []
test = []
for category in os.listdir(BBC_ROOT):
path = BBC_ROOT / category
if os.path.isdir(path):
for fn in os.listdir(path):
with open(path /... | aiconf-allennlp-tutorial-master | process_data.py |
from allennlp.common.util import JsonDict
from allennlp.data import Instance
from allennlp.predictors import Predictor
from aiconf.reader import BBCReader
@Predictor.register("bbc")
class BBCPredictor(Predictor):
def _json_to_instance(self, json_dict: JsonDict) -> Instance:
# 1. we expect that the json_d... | aiconf-allennlp-tutorial-master | aiconf/predictor.py |
import pathlib
from allennlp.common.testing import ModelTestCase
from allennlp.data.dataset import Batch
from allennlp.data.token_indexers import SingleIdTokenIndexer
from allennlp.data.vocabulary import Vocabulary
from allennlp.modules.text_field_embedders import BasicTextFieldEmbedder
from allennlp.modules.token_emb... | aiconf-allennlp-tutorial-master | aiconf/model_test.py |
from aiconf.reader import BBCReader
from aiconf.model import BBCModel
from aiconf.predictor import BBCPredictor
| aiconf-allennlp-tutorial-master | aiconf/__init__.py |
from typing import Dict, Optional
from allennlp.data.vocabulary import Vocabulary
from allennlp.models import Model
from allennlp.modules.text_field_embedders import TextFieldEmbedder
from allennlp.modules.seq2vec_encoders import Seq2VecEncoder
from allennlp.nn.util import get_text_field_mask
from allennlp.training.me... | aiconf-allennlp-tutorial-master | aiconf/model.py |
import pathlib
from allennlp.common.testing import AllenNlpTestCase
from allennlp.data.token_indexers import SingleIdTokenIndexer
from aiconf.reader import BBCReader
FIXTURES_ROOT = pathlib.Path(__file__).parent / 'fixtures'
class ReaderTest(AllenNlpTestCase):
def test_reader(self):
token_indexers = {"... | aiconf-allennlp-tutorial-master | aiconf/reader_test.py |
from typing import Iterable, Dict, Optional
import gzip
import csv
from allennlp.common.file_utils import cached_path
from allennlp.data.dataset_readers import DatasetReader
from allennlp.data.fields import TextField, LabelField
from allennlp.data.instance import Instance
from allennlp.data.token_indexers import Token... | aiconf-allennlp-tutorial-master | aiconf/reader.py |
aiconf-allennlp-tutorial-master | aiconf/predictor_test.py | |
"""
In order to create a package for pypi, you need to follow several steps.
1. Create a .pypirc in your home directory. It should look like this:
```
[distutils]
index-servers =
pypi
pypitest
[pypi]
repository=https://pypi.python.org/pypi
username=deep-qa
password= Get the password from LastPass.
[pypitest]
re... | deep_qa-master | setup.py |
from typing import Dict, List, Tuple, Union
import sys
import logging
import os
import json
from copy import deepcopy
import random
import pyhocon
import numpy
# pylint: disable=wrong-import-position
from .common.params import Params, replace_none, ConfigurationError
from .common.tee_logger import TeeLogger
logger =... | deep_qa-master | deep_qa/run.py |
from .run import run_model, evaluate_model, load_model, score_dataset, score_dataset_with_ensemble
from .run import compute_accuracy, run_model_from_file
| deep_qa-master | deep_qa/__init__.py |
from keras import backend as K
from overrides import overrides
from .masked_layer import MaskedLayer
from ..tensors.backend import switch
class BiGRUIndexSelector(MaskedLayer):
"""
This Layer takes 3 inputs: a tensor of document indices, the seq2seq GRU output
over the document feeding it in forward, the... | deep_qa-master | deep_qa/layers/bigru_index_selector.py |
from keras.layers import Layer
class MaskedLayer(Layer):
"""
Keras 2.0 allowed for arbitrary differences in arguments to the ``call`` method of ``Layers``.
As part of this, they removed the default ``mask=None`` argument, which means that if you want
to implement ``call`` with a mask, you need to disa... | deep_qa-master | deep_qa/layers/masked_layer.py |
from keras import backend as K
from overrides import overrides
from .masked_layer import MaskedLayer
class VectorMatrixMerge(MaskedLayer):
"""
This ``Layer`` takes a tensor with ``K`` modes and a collection of other tensors with ``K - 1``
modes, and concatenates the lower-order tensors at the beginning o... | deep_qa-master | deep_qa/layers/vector_matrix_merge.py |
from keras import backend as K
from overrides import overrides
from deep_qa.layers.masked_layer import MaskedLayer
from deep_qa.tensors.backend import VERY_LARGE_NUMBER
class SubtractMinimum(MaskedLayer):
'''
This layer is used to normalize across a tensor axis. Normalization is done by finding the
minim... | deep_qa-master | deep_qa/layers/subtract_minimum.py |
from typing import List, Tuple
from keras import backend as K
from overrides import overrides
from .masked_layer import MaskedLayer
from ..common.checks import ConfigurationError
class ComplexConcat(MaskedLayer):
"""
This ``Layer`` does ``K.concatenate()`` on a collection of tensors, but
allows for more... | deep_qa-master | deep_qa/layers/complex_concat.py |
# Individual layers.
from .additive import Additive
from .bigru_index_selector import BiGRUIndexSelector
from .complex_concat import ComplexConcat
from .highway import Highway
from .l1_normalize import L1Normalize
from .masked_layer import MaskedLayer
from .noisy_or import BetweenZeroAndOne, NoisyOr
from .option_atten... | deep_qa-master | deep_qa/layers/__init__.py |
from keras.layers import Highway as KerasHighway
class Highway(KerasHighway):
"""
Keras' `Highway` layer does not support masking, but it easily could, just by returning the
mask. This `Layer` makes this possible.
"""
def __init__(self, **kwargs):
super(Highway, self).__init__(**kwargs)
... | deep_qa-master | deep_qa/layers/highway.py |
from keras import backend as K
from overrides import overrides
from .masked_layer import MaskedLayer
from ..tensors.backend import l1_normalize
class L1Normalize(MaskedLayer):
"""
This Layer normalizes a tensor by its L1 norm. This could just be a
``Lambda`` layer that calls our ``tensors.l1_normalize`` ... | deep_qa-master | deep_qa/layers/l1_normalize.py |
from keras import backend as K
from overrides import overrides
from ..tensors.backend import switch
from .masked_layer import MaskedLayer
class Overlap(MaskedLayer):
"""
This Layer takes 2 inputs: a ``tensor_a`` (e.g. a document) and a ``tensor_b``
(e.g. a question). It returns a one-hot vector suitable ... | deep_qa-master | deep_qa/layers/overlap.py |
from keras import backend as K
from keras.constraints import Constraint
from keras.regularizers import l1_l2
from overrides import overrides
from .masked_layer import MaskedLayer
class BetweenZeroAndOne(Constraint):
"""
Constrains the weights to be between zero and one
"""
def __call__(self, p):
... | deep_qa-master | deep_qa/layers/noisy_or.py |
from keras import backend as K
from overrides import overrides
from .masked_layer import MaskedLayer
class VectorMatrixSplit(MaskedLayer):
"""
This Layer takes a tensor with K modes and splits it into a tensor with K - 1 modes and a
tensor with K modes, but one less row in one of the dimensions. We call... | deep_qa-master | deep_qa/layers/vector_matrix_split.py |
from keras import backend as K
from overrides import overrides
from .masked_layer import MaskedLayer
from ..common.checks import ConfigurationError
from ..tensors.backend import switch
class OptionAttentionSum(MaskedLayer):
"""
This Layer takes three inputs: a tensor of document indices, a tensor of
docu... | deep_qa-master | deep_qa/layers/option_attention_sum.py |
from overrides import overrides
from .masked_layer import MaskedLayer
class Additive(MaskedLayer):
"""
This ``Layer`` `adds` a parameter value to each cell in the input tensor, similar to a bias
vector in a ``Dense`` layer, but this `only` adds, one value per cell. The value to add is
learned.
P... | deep_qa-master | deep_qa/layers/additive.py |
from keras import backend as K
from deep_qa.layers.wrappers.time_distributed import TimeDistributed
class EncoderWrapper(TimeDistributed):
'''
This class TimeDistributes a sentence encoder, applying the encoder to several word sequences.
The only difference between this and the regular TimeDistributed is ... | deep_qa-master | deep_qa/layers/wrappers/encoder_wrapper.py |
from keras import backend as K
from keras.layers import InputSpec, TimeDistributed as KerasTimeDistributed
from overrides import overrides
class TimeDistributed(KerasTimeDistributed):
"""
This class fixes two bugs in Keras: (1) the input mask is not passed to the wrapped layer, and
(2) Keras' TimeDistribut... | deep_qa-master | deep_qa/layers/wrappers/time_distributed.py |
from .add_encoder_mask import AddEncoderMask
from .encoder_wrapper import EncoderWrapper
from .output_mask import OutputMask
from .time_distributed import TimeDistributed
| deep_qa-master | deep_qa/layers/wrappers/__init__.py |
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
class AddEncoderMask(MaskedLayer):
"""
This ``Layer`` handles masking for ``TimeDistributed`` encoders, like LSTMs, that condense
sequences of vectors into single vectors (not LSTMs that return sequences... | deep_qa-master | deep_qa/layers/wrappers/add_encoder_mask.py |
from overrides import overrides
from ..masked_layer import MaskedLayer
class OutputMask(MaskedLayer):
"""
This Layer is purely for debugging. You can wrap this on a layer's output to get the mask
output by that layer as a model output, for easier visualization of what the model is actually
doing.
... | deep_qa-master | deep_qa/layers/wrappers/output_mask.py |
from copy import deepcopy
from typing import Any, Dict
from keras import backend as K
from overrides import overrides
from ...common.params import pop_choice
from ..masked_layer import MaskedLayer
from ...tensors.masked_operations import masked_softmax
from ...tensors.similarity_functions import similarity_functions
... | deep_qa-master | deep_qa/layers/attention/attention.py |
from copy import deepcopy
from typing import Any, Dict
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
from ...common.params import pop_choice
from ...tensors.similarity_functions import similarity_functions
class MatrixAttention(MaskedLayer):
'''
This `... | deep_qa-master | deep_qa/layers/attention/matrix_attention.py |
from .attention import Attention
from .gated_attention import GatedAttention
from .masked_softmax import MaskedSoftmax
from .matrix_attention import MatrixAttention
from .max_similarity_softmax import MaxSimilaritySoftmax
from .weighted_sum import WeightedSum
| deep_qa-master | deep_qa/layers/attention/__init__.py |
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
from ...tensors.backend import last_dim_flatten
from ...tensors.masked_operations import masked_softmax
class MaskedSoftmax(MaskedLayer):
'''
This Layer performs a masked softmax. This could just be a `Lambd... | deep_qa-master | deep_qa/layers/attention/masked_softmax.py |
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
from ...tensors.masked_operations import masked_batch_dot, masked_softmax
class MaxSimilaritySoftmax(MaskedLayer):
'''
This layer takes encoded questions and knowledge in a multiple choice
setting and co... | deep_qa-master | deep_qa/layers/attention/max_similarity_softmax.py |
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
from ...common.checks import ConfigurationError
from ...tensors.backend import switch
GATING_FUNCTIONS = ["*", "+", "||"]
class GatedAttention(MaskedLayer):
r"""
This layer implements the majority of the Ga... | deep_qa-master | deep_qa/layers/attention/gated_attention.py |
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
class WeightedSum(MaskedLayer):
"""
This ``Layer`` takes a matrix of vectors and a vector of row weights, and returns a weighted
sum of the vectors. You might use this to get some aggregate sentence repr... | deep_qa-master | deep_qa/layers/attention/weighted_sum.py |
from keras import backend as K
from overrides import overrides
from ...tensors.backend import switch
from ..masked_layer import MaskedLayer
class ReplaceMaskedValues(MaskedLayer):
"""
This ``Layer`` replaces all masked values in a tensor with some value. You might want to do
this before passing the tens... | deep_qa-master | deep_qa/layers/backend/replace_masked_values.py |
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
from ...tensors.backend import switch, very_negative_like
class Max(MaskedLayer):
"""
This ``Layer`` performs a max over some dimension. Keras has a similar layer called
``GlobalMaxPooling1D``, but it i... | deep_qa-master | deep_qa/layers/backend/max.py |
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
class ExpandFromBatch(MaskedLayer):
"""
Reshapes a collapsed tensor, taking the batch size and separating it into ``num_to_expand``
dimensions, following the shape of a second input tensor. This is mean... | deep_qa-master | deep_qa/layers/backend/expand_from_batch.py |
from typing import Tuple
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
class Permute(MaskedLayer):
"""
This ``Layer`` calls ``K.permute_dimensions`` on both the input and the mask.
If the mask is not ``None``, it must have the same shape as the in... | deep_qa-master | deep_qa/layers/backend/permute.py |
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
class Multiply(MaskedLayer):
"""
This ``Layer`` performs elementwise multiplication between two tensors, supporting masking. We
literally just call ``tensor_1 * tensor_2``; the only reason this is a ``L... | deep_qa-master | deep_qa/layers/backend/multiply.py |
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
class AddMask(MaskedLayer):
"""
This ``Layer`` adds a mask to a tensor. It is intended solely for testing, though if you have
a use case for this outside of testing, feel free to use it. The ``call()``... | deep_qa-master | deep_qa/layers/backend/add_mask.py |
import keras.backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
class BatchDot(MaskedLayer):
"""
This ``Layer`` calls ``K.batch_dot()`` on two inputs ``tensor_a`` and ``tensor_b``.
This function will work for tensors of arbitrary size as long as
``abs(K.ndim(tensor_a)... | deep_qa-master | deep_qa/layers/backend/batch_dot.py |
from .add_mask import AddMask
from .batch_dot import BatchDot
from .collapse_to_batch import CollapseToBatch
from .envelope import Envelope
from .expand_from_batch import ExpandFromBatch
from .max import Max
from .multiply import Multiply
from .permute import Permute
from .replace_masked_values import ReplaceMaskedValu... | deep_qa-master | deep_qa/layers/backend/__init__.py |
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
class Repeat(MaskedLayer):
"""
This ``Layer`` calls ``K.repeat_elements`` on both the input and the mask, after calling
``K.expand_dims``.
If the mask is not ``None``, we must be able to call ``K.ex... | deep_qa-master | deep_qa/layers/backend/repeat.py |
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
class CollapseToBatch(MaskedLayer):
"""
Reshapes a higher order tensor, taking the first ``num_to_collapse`` dimensions after the batch
dimension and folding them into the batch dimension. For example, ... | deep_qa-master | deep_qa/layers/backend/collapse_to_batch.py |
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
class Squeeze(MaskedLayer):
"""
This ``Layer`` removes a 1-D dimension from the tensor at index ``axis``, acting as simply
a layer version of the backend squeeze function.
If the mask is not ``None`... | deep_qa-master | deep_qa/layers/backend/squeeze.py |
from overrides import overrides
from keras import backend as K
from ..masked_layer import MaskedLayer
class Envelope(MaskedLayer):
"""
Given a probability distribution over a begin index and an end index of some sequence, this
``Layer`` computes an envelope over the sequence, a probability that each elem... | deep_qa-master | deep_qa/layers/backend/envelope.py |
from keras import backend as K
from overrides import overrides
from ..masked_layer import MaskedLayer
class RepeatLike(MaskedLayer):
"""
This ``Layer`` is like :class:`~.repeat.Repeat`, but gets the number of repetitions to use from
a second input tensor. This allows doing a number of repetitions that i... | deep_qa-master | deep_qa/layers/backend/repeat_like.py |
from collections import OrderedDict
from keras.layers import LSTM
from keras.layers.wrappers import Bidirectional
from keras.regularizers import l1_l2
from ...common.params import Params
from .bag_of_words import BOWEncoder
from .convolutional_encoder import CNNEncoder
from .positional_encoder import PositionalEncode... | deep_qa-master | deep_qa/layers/encoders/__init__.py |
from typing import Tuple
from keras import backend as K
from keras.engine import InputSpec
from keras.layers import Convolution1D, Concatenate, Dense
from keras.regularizers import l1_l2
from overrides import overrides
from ..masked_layer import MaskedLayer
class CNNEncoder(MaskedLayer):
'''
CNNEncoder is a ... | deep_qa-master | deep_qa/layers/encoders/convolutional_encoder.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.