def test_encode_texts():
""" Text encoding is stable.
"""
TEST_SENTENCES = [
'I love mom\'s cooking', 'I love how you never reply back..',
'I love cruising with my homies', 'I love messing with yo mind!!',
'I love you and now you\'re just gone..', 'This is shit',
'This is the shit'
]
maxlen = 30
batch_size = 32
with open(VOCAB_PATH, 'r') as f:
vocabulary = json.load(f)
st = SentenceTokenizer(vocabulary, maxlen)
print('Loading model from {}.'.format(PRETRAINED_PATH))
model = torchmoji_feature_encoding(PRETRAINED_PATH)
print(model)
tokenized, _, _ = st.tokenize_sentences(TEST_SENTENCES)
encoding = model(tokenized)
avg_across_sentences = np.around(np.mean(encoding, axis=0)[:5], 3)
assert np.allclose(avg_across_sentences,
np.array([-0.023, 0.021, -0.037, -0.001, -0.005]))
def load_torchmoji(self):
""" Use torchMoji to score texts for emoji distribution.
The resulting emoji ids (0-63) correspond to the mapping
in emoji_overview.png file at the root of the torchMoji repo.
Writes the result to a csv file.
"""
import json
import numpy as np
import os
from torchmoji.sentence_tokenizer import SentenceTokenizer
from torchmoji.model_def import torchmoji_feature_encoding
from torchmoji.global_variables import PRETRAINED_PATH, VOCAB_PATH
print('Tokenizing using dictionary from {}'.format(VOCAB_PATH))
with open(VOCAB_PATH, 'r') as f:
vocabulary = json.load(f)
maxlen = 130
texts = [
"Testing!",
]
with torch.no_grad():
# init model
st = SentenceTokenizer(vocabulary,
maxlen,
ignore_sentences_with_only_custom=True)
torchmoji = torchmoji_feature_encoding(PRETRAINED_PATH)
return st, torchmoji
def test_encode_texts():
""" Text encoding is stable.
"""
TEST_SENTENCES = ['I love mom\'s cooking',
'I love how you never reply back..',
'I love cruising with my homies',
'I love messing with yo mind!!',
'I love you and now you\'re just gone..',
'This is shit',
'This is the shit']
maxlen = 30
batch_size = 32
with open(VOCAB_PATH, 'r') as f:
vocabulary = json.load(f)
st = SentenceTokenizer(vocabulary, maxlen)
print('Loading model from {}.'.format(PRETRAINED_PATH))
model = torchmoji_feature_encoding(PRETRAINED_PATH)
print(model)
tokenized, _, _ = st.tokenize_sentences(TEST_SENTENCES)
encoding = model(tokenized)
avg_across_sentences = np.around(np.mean(encoding, axis=0)[:5], 3)
assert np.allclose(avg_across_sentences, np.array([-0.023, 0.021, -0.037, -0.001, -0.005]))
def __init__(self, use_cuda=True):
super(MojiModel, self).__init__()
self.use_cuda = use_cuda
self.EMOJIS = EMOJIS
self.emoji_model = torchmoji_emojis(PRETRAINED_PATH)
with open(VOCAB_PATH, 'r') as f:
vocabulary = json.load(f)
self.tokenizer = SentenceTokenizer(vocabulary, 100)
print(self.emoji_model)
self.feat_model = torchmoji_feature_encoding(PRETRAINED_PATH)
if use_cuda:
self.emoji_model = self.emoji_model.cuda()
self.feat_model = self.feat_model.cuda()
def __init__(self,
vocab,
hidden_size,
num_layers,
max_length=700,
input_dropout=0.0,
layer_dropout=0.0,
is_bidirectional=False,
attentive=False,
multiattentive=True,
num_heads=5,
total_key_depth=500,
total_value_depth=1000,
use_mask=True):
super(HDeepMoji, self).__init__()
self.input_dropout = nn.Dropout(input_dropout)
self.layer_dropout = nn.Dropout(layer_dropout)
self.vocab = vocab
self.torchmoji = torchmoji_feature_encoding(PRETRAINED_PATH)
embedding_size = 2304
# self.lstm = nn.LSTM(embedding_size, hidden_size=hidden_size, num_layers=num_layers, bidirectional=is_bidirectional)
self.lstm_layer = nn.LSTM(embedding_size,
hidden_size=hidden_size,
num_layers=num_layers,
bidirectional=is_bidirectional,
batch_first=False)
self.W = nn.Linear(hidden_size *
2 if is_bidirectional else hidden_size,
4) ## 4 emotion
self.softmax = nn.Softmax(dim=1)
self.num_layers = num_layers
self.is_bidirectional = is_bidirectional
self.use_mask = use_mask
self.attentive = attentive
if attentive:
# self.word_attention = Attention(hidden_size*2 if is_bidirectional else hidden_size)
self.sentences_attention = Attention(
hidden_size * 2 if is_bidirectional else hidden_size)
def __init__(self, counter, name, max_concurrent_queries):
super().__init__(counter, name, max_concurrent_queries)
sys.path.append(os.path.join(self.data_dir, "tacotron2-PPP-1.3.0"))
from torchmoji.global_variables import PRETRAINED_PATH, VOCAB_PATH
from torchmoji.model_def import torchmoji_emojis, torchmoji_feature_encoding
from torchmoji.sentence_tokenizer import SentenceTokenizer
self.log.debug("Loading model")
with open(VOCAB_PATH, "r") as f:
vocabulary = json.load(f)
with torch.no_grad():
self.tm_sentence_tokenizer = SentenceTokenizer(
vocabulary, MAX_LEN, ignore_sentences_with_only_custom=True
)
self.tm_torchmoji = torchmoji_feature_encoding(PRETRAINED_PATH)
self.tm_model = torchmoji_emojis(PRETRAINED_PATH)
self.log.debug("Model loaded")
elmo = Elmo(options_file, weight_file, 2, dropout=0).cuda()
elmo.eval()
EMOS = EMO_LIST
EMOS_DIC = dict(zip(EMOS, range(len(EMOS))))
tokenizer = GloveTokenizer()
# deepmoji
print('Tokenizing using dictionary from {}'.format(VOCAB_PATH))
with open(VOCAB_PATH, 'r') as f:
vocabulary = json.load(f)
st = SentenceTokenizer(vocabulary, PAD_LEN)
print('Loading model from {}.'.format(PRETRAINED_PATH))
emoji_model = torchmoji_feature_encoding(PRETRAINED_PATH)
emoji_model.eval()
class EmotionDataLoader(Dataset):
def __init__(self, X, y, pad_len, max_size=None):
self.source = []
self.source_len = []
self.target = y
self.pad_len = pad_len
self.read_data(X, y)
def read_data(self, X, y):
for src in X:
src = tokenizer.encode_ids(src)
if len(src) < self.pad_len:
TEST_SENTENCES = ['I love mom\'s cooking',
'I love how you never reply back..',
'I love cruising with my homies',
'I love messing with yo mind!!',
'I love you and now you\'re just gone..',
'This is shit',
'This is the shit']
maxlen = 30
batch_size = 32
print('Tokenizing using dictionary from {}'.format(VOCAB_PATH))
with open(VOCAB_PATH, 'r') as f:
vocabulary = json.load(f)
st = SentenceTokenizer(vocabulary, maxlen)
tokenized, _, _ = st.tokenize_sentences(TEST_SENTENCES)
print('Loading model from {}.'.format(PRETRAINED_PATH))
model = torchmoji_feature_encoding(PRETRAINED_PATH)
print(model)
print('Encoding texts..')
encoding = model(tokenized)
print('First 5 dimensions for sentence: {}'.format(TEST_SENTENCES[0]))
print(encoding[0,:5])
# Now you could visualize the encodings to see differences,
# run a logistic regression classifier on top,
# or basically anything you'd like to do.