def setup_trainer(self, sz, sampler, ev, existing_model=None):
model = HolE(sz,
self.args.ncomp,
rparam=self.args.rparam,
af=afs[self.args.afs],
inite=self.args.inite,
initr=self.args.initr,
ev=ev,
model=existing_model)
if self.args.no_pairwise:
trainer = StochasticTrainer(model,
nbatches=self.args.nb,
max_epochs=self.args.me,
post_epoch=[self.callback],
learning_rate=self.args.lr,
samplef=sampler.sample)
else:
trainer = PairwiseStochasticTrainer(model,
nbatches=self.args.nb,
margin=self.args.margin,
max_epochs=self.args.me,
learning_rate=self.args.lr,
samplef=sampler.sample,
post_epoch=[self.callback])
return trainer
def train(triples):
# Load knowledge graph
# N = number of entities
# M = number of relations
# xs = list of (subject, object, predicte) triples
# ys = list of truth values for triples (1 = true, -1 = false)
#N, M = 2,1
#xs = [(0, 1, 0)]
#ys = np.ones(len(xs))
N, M, xs, ys = generate_kg_for_training(triples)
# instantiate HolE with an embedding space of size 100
model = HolE((N, N, M), 10)
# instantiate trainer
trainer = StochasticTrainer(model)
# fit model to knowledge graph
trainer.fit(xs, ys)
model.E
model.R
print('finish')
def learn_model(self,
X,
types=None,
type_hierarchy=None,
domains=None,
ranges=None):
self.X = X
N = self.X[0].shape[1]
self.sz = (N, N, len(self.X))
if self.model == "hole":
embedding_model = HolE(self.sz,
self.n_dim,
rparam=self.rparam,
af=afs[self.activation_function],
init=self.init)
if self.model == "transe":
embedding_model = TransE(self.sz, self.n_dim, init=self.init)
if self.model == "rescal":
embedding_model = RESCAL(self.sz, self.n_dim, init=self.init)
xs = []
for r, slice in enumerate(self.X):
h = slice.row
t = slice.col
xs = xs + zip(h, t, [r] * len(h))
ys = np.ones(len(xs))
if self.sample_mode == 'corrupted':
ti = type_index(xs)
sampler = CorruptedSampler(self.negative_examples, xs, ti)
elif self.sample_mode == 'random':
sampler = RandomModeSampler(self.negative_examples, [0, 1], xs,
self.sz)
elif self.sample_mode == 'lcwa':
sampler = LCWASampler(self.negative_examples, [0, 1, 2], xs,
self.sz)
self.trainer = PairwiseStochasticTrainer(
embedding_model,
nbatches=self.n_batches,
max_epochs=self.max_epochs,
post_epoch=[callback],
learning_rate=self.learning_rate,
margin=self.margin,
samplef=sampler.sample)
self.trainer.fit(xs, ys)
del xs, ys
def setup_trainer(self, sz, sampler):
model = HolE(sz,
self.args.ncomp,
rparam=self.args.rparam,
af=afs[self.args.afs],
init=self.args.init)
if self.args.no_pairwise:
trainer = StochasticTrainer(model,
nbatches=self.args.nb,
max_epochs=self.args.me,
post_epoch=[self.callback],
learning_rate=self.args.lr,
samplef=sampler.sample)
else:
#print ("UNM$$$ Running Pairwise stochastic trainer")
trainer = PairwiseStochasticTrainer(model,
nbatches=self.args.nb,
max_epochs=self.args.me,
post_epoch=[self.callback],
learning_rate=self.args.lr,
margin=self.args.margin,
samplef=sampler.sample)
return trainer
def train_model(method='complex',
mode='single',
dimension=200,
number_of_epochs=300,
batch_size=128,
learning_rate=0.05,
margin=1.0,
number_negative_samples=10,
optimzer='adagrad',
l2_regularization=0.0001,
gradient_clipping=5,
epoch_setp_for_saving=100,
ratio_complex_dimension=0.5):
if method == 'hole':
model = HolE(self.shape,
self.args.ncomp,
init=self.args.init,
rparam=self.args.rparam)
elif method == 'rescal':
model = HolE(self.shape,
self.args.ncomp,
init=self.args.init,
rparam=self.args.rparam)
elif method == 'transe':
model = HolE(self.shape,
self.args.ncomp,
init=self.args.init,
rparam=self.args.rparam)
else:
raise NotImplementedError
if optimzer == 'sgd':
opt = SGD
elif optimzer == 'adagrad':
opt = AdaGrad
else:
raise NotImplementedError
if mode == 'pairwise':
trainer = PairwiseStochasticTrainer(
model,
nbatches=batch_size,
max_epochs=number_of_epochs,
#post_epoch=[self.callback],
learning_rate=learning_rate,
margin=margin,
af=af.Sigmoid)
elif mode == 'single':
trainer = StochasticTrainer(model,
nbatches=100,
max_epochs=500,
post_epoch=[self.callback],
learning_rate=0.1)
pass
if l2_regularization > 0:
opt.set_l2_reg(l2_regularization)
if gradient_clipping > 0:
opt.set_gradclip(gradient_clipping)
from .kge.transe import TransE
model = TransE(n_entity=n_entity,
n_relation=n_relation,
margin=margin,
dim=dimension,
mode=mode)
if mode == 'pairwise':
trainer = PairwiseTrainer(model=model,
opt=opt,
save_step=args.save_step,
batchsize=args.batch,
logger=logger,
evaluator=evaluator,
valid_dat=valid_dat,
n_negative=args.negative,
epoch=args.epoch,
model_dir=args.log)
elif mode == 'single':
trainer = SingleTrainer(model=model,
opt=opt,
save_step=args.save_step,
batchsize=args.batch,
logger=logger,
evaluator=evaluator,
valid_dat=valid_dat,
n_negative=args.negative,
epoch=args.epoch,
model_dir=args.log)
pass
triples = pd.read_csv(b_dir + 'triples.txt', sep='\t', header=None)
triples.columns = ['relation_id', 'entity_id1', 'entity_id2']
# https://github.com/mnick/scikit-kge
from skge import HolE, StochasticTrainer
# Load knowledge graph
# N = number of entities
# M = number of relations
# xs = list of (subject, object, predicte) triples
# ys = list of truth values for triples (1 = true, -1 = false)
N, M, xs, ys = len(entities), len(relations), np.array(triples[[
'entity_id1', 'entity_id2', 'relation_id']]), np.ones(len(triples), dtype=np.int)
# instantiate HolE with an embedding space of size 100
model = HolE((N, N, M), 50)
# instantiate trainer
trainer = StochasticTrainer(model, nbatches=10,
max_epochs=50)
# fit model to knowledge graph
trainer.fit(xs, ys)
model.params['E'].shape
model.params['R'].shape
from scipy.spatial import distance
E = model.params['E']