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'])