def defn_to_atts(defn_type, use_emb=False, first_defn=True):
train_data, val_data, test_data = Attributes.splits(use_defns=True, cuda=False,
first_defn_at_test=first_defn)
enc_fn = {'bow': bowize, 'nbow': nbowize}[defn_type]
if first_defn:
# We want to oversample
balanced_train_inds = train_data._balanced_inds
X_train, Y_train = get_x(train_data, enc_fn, use_emb=use_emb)
X_train = X_train[balanced_train_inds]
Y_train = Y_train[balanced_train_inds]
X_val, Y_val = get_x(val_data, enc_fn, use_emb=use_emb)
X_test, Y_test = get_x(test_data, enc_fn, use_emb=use_emb)
else:
# We want to undersample
X_train, Y_train = get_stacked_x(train_data, enc_fn, use_emb=use_emb)
X_val, Y_val = get_stacked_x(val_data, enc_fn, use_emb=use_emb)
X_test, Y_test = get_stacked_x(test_data, enc_fn, use_emb=use_emb)
# cross validate
cs = np.power(10., [-3,-2,-1,0])
accs = defaultdict(list)
for c in cs:
for d, (dom_name, dom_size) in enumerate(train_data.domains):
M = LogisticRegression(C=c)
print("fitting {}".format(d))
M.fit(X_train, Y_train[:, d])
s = M.score(X_val, Y_val[:, d])
accs[d].append(s)
c_to_use = {d:cs[np.argmax(scores)] for d, scores in accs.items()}
print("Using c={}, acc of {:.3f} on val".format(
'\n'.join('{:2d}:{:.3f}'.format(d,c) for d,c in c_to_use.items()),
np.mean([max(accs[d]) for d in c_to_use.keys()])
))
# -----------------------------------------------
preds = []
for d, (dom_name, dom_size) in enumerate(train_data.domains):
M = LogisticRegression(C=c_to_use[d])
print("fitting {}".format(d))
M.fit(X_train, Y_train[:,d])
s = M.score(X_test, Y_test[:,d])
print("Score for {} is {}".format(dom_name, s))
preds.append(M.predict(X_test))
preds_full = np.array(preds).T
acc_table = evaluate_accuracy(preds_full, Y_test)
acc_table.index = ['{}{}({})'.format(defn_type, ' +GloVe' if use_emb else '',
'firstdefn' if first_defn else 'concat')]
np.save('{}{}.pkl'.format(defn_type, ' +GloVe' if use_emb else ''), preds_full)
return acc_table
def __init__(self,
use_train_verbs=False,
use_val_verbs=False,
use_test_verbs=False,
use_train_images=False,
use_val_images=False,
use_test_images=False,
vector_type='glove',
word_type='lemma',
):
self.vector_type = vector_type
self.word_type = word_type
self.use_train_verbs = use_train_verbs
self.use_val_verbs = use_val_verbs
self.use_test_verbs = use_test_verbs
if not (self.use_train_verbs or self.use_val_verbs or self.use_test_verbs):
raise ValueError("No verbs selected!")
self.use_train_images = use_train_images
self.use_val_images = use_val_images
self.use_test_images = use_test_images
if not (self.use_train_verbs or self.use_val_verbs or self.use_test_verbs):
raise ValueError("No images selected!")
self.attributes = Attributes(
vector_type=vector_type,
word_type=word_type,
use_train=self.use_train_verbs, use_val=self.use_val_verbs,
use_test=self.use_test_verbs, imsitu_only=True)
self.examples = []
for mode, to_use in zip(
['train', 'val', 'test'],
[self.use_train_images, self.use_val_images, self.use_test_images],
):
if to_use:
self.examples += [(fn, self.attributes.ind_perm[ind])
for fn, ind in _load_imsitu_file(mode)
if ind in self.attributes.ind_perm]
self.transform = transform(is_train=not self.use_test_verbs)
"""
GLOVE embeddings -> attributes
"""
import numpy as np
from sklearn.linear_model import LogisticRegression
from lib.attribute_loss import evaluate_accuracy
from data.attribute_loader import Attributes
from config import ROOT_PATH
import os
import pandas as pd
from collections import defaultdict
retrofit_dir = os.path.join(ROOT_PATH, 'models', 'baselines', 'retrofitting')
TYPES = ('glove', 'framenet', 'ppdb', 'wordnet')
train_data, val_data, test_data = Attributes.splits(use_defns=False,
cuda=False)
embeds_train = train_data.embeds.data.numpy()
embeds_val = val_data.embeds.data.numpy()
embeds_test = test_data.embeds.data.numpy()
Y_train = train_data.atts_matrix.data.numpy()
Y_val = val_data.atts_matrix.data.numpy()
Y_test = test_data.atts_matrix.data.numpy()
def emb_to_atts(emb_type):
assert emb_type in TYPES
if emb_type != 'glove':
# Replace the matrices
vecs = np.load(os.path.join(retrofit_dir, emb_type + '.pkl'))
"""
Trains the imsitu model for ZSL
"""
from data.dictionary_dataset import load_vocab
from data.attribute_loader import Attributes, COLUMNS
from config import ModelConfig
import torch
import numpy as np
from tqdm import tqdm
from lib.attribute_loss import AttributeLoss, evaluate_accuracy
from lib.bucket_iterator import DictionaryAttributesIter
from lib.att_prediction import DictionaryModel
import pandas as pd
train_data, val_data, test_data = Attributes.splits(use_defns=True, cuda=True)
dict_field, _ = load_vocab()
test_iter = DictionaryAttributesIter(dict_field,
test_data,
batch_size=64 * 10,
shuffle=False,
train=False)
att_crit = AttributeLoss(train_data.domains, size_average=True)
def eval(ckpt, use_emb=False):
# Recommended hyperparameters
args = ModelConfig(batch_size=64, ckpt=ckpt, dropout=0.5, use_emb=use_emb)
m = DictionaryModel(dict_field.vocab,
output_size=att_crit.input_size,
import pandas as pd
from data.imsitu_loader import ImSitu
from data.attribute_loader import Attributes, COLUMNS
train_data, val_data, test_data = ImSitu.splits(zeroshot=True)
# X \in \R^{d x m} where D is dimensionality and m is # examples
train_feats = np.load('train_feats.npy').T
val_feats = np.load('val_feats.npy').T
test_feats = np.load('test_feats.npy').T
train_labels = np.load('train_labels.npy')
val_labels = np.load('val_labels.npy')
test_labels = np.load('test_labels.npy')
# Predicted atts
old_index = Attributes(use_defns=True, use_test=True).atts_df.index
inds = np.array([
np.where(old_index == i)[0][0] for i in test_data.attributes.atts_df.index
])
pred_atts = pd.DataFrame(
np.load('/home/rowan/code/verb-attributes/data/att_preds_ensemble.npy')
[inds],
columns=COLUMNS,
index=test_data.attributes.atts_df.index,
)
def dummies(atts_df, col, dom_size):
if dom_size > 2:
d = pd.get_dummies(pd.concat(
(atts_df['time'],
from data.dictionary_dataset import DictionaryChallengeDataset, PackedBucketIterator
from config import ModelConfig
from torch import optim
import os
import torch
from lib.misc import CosineRankingLoss, optimize, cosine_ranking_loss
import numpy as np
import time
from data.attribute_loader import Attributes
from lib.att_prediction import FeedForwardModel
from lib.attribute_loss import AttributeLoss, evaluate_accuracy
# Recommended hyperparameters
args = ModelConfig(lr=5e-4, batch_size=16, eps=1e-8, save_dir='nbow2atts')
train_data, val_data, test_data = Attributes.splits(
use_defns=False, cuda=torch.cuda.is_available())
crit = AttributeLoss(train_data.domains, size_average=True)
m = FeedForwardModel(input_size=300,
output_size=crit.input_size,
init_dropout=0.05)
optimizer = optim.Adam(m.parameters(),
lr=args.lr,
eps=args.eps,
betas=(args.beta1, args.beta2))
if len(args.ckpt) > 0 and os.path.exists(args.ckpt):
print("loading checkpoint from {}".format(args.ckpt))
ckpt = torch.load(args.ckpt)
m.load_state_dict(ckpt['state_dict'])
optimizer.load_state_dict(ckpt['optimizer'])