def init(self): #memory wencpg = WordEncoderPlusGlove(numchars=self.numchars, numwords=self.numwords, encdim=self.wordencdim, embdim=self.wordembdim, embtrainfrac=0.0, glovepath=self.glovepath) self.memenco = SeqEncoder( wencpg, GRU(dim=self.wordembdim + self.wordencdim, innerdim=self.encinnerdim) ) entemb = VectorEmbed(indim=self.outdim, dim=self.entembdim) self.mempayload = ConcatBlock(entemb, self.memenco) self.memblock = MemoryBlock(self.mempayload, self.memdata, indim=self.outdim, outdim=self.encinnerdim+self.entembdim) #encoder wencpg2 = WordEncoderPlusGlove(numchars=self.numchars, numwords=self.numwords, encdim=self.wordencdim, embdim=self.wordembdim, embtrainfrac=0.0, glovepath=self.glovepath) self.enc = SeqEncoder( wencpg2, GRU(dim=self.wordembdim + self.wordencdim, innerdim=self.encinnerdim) ) #decoder entemb2 = VectorEmbed(indim=self.outdim, dim=self.entembdim) self.softmaxoutblock = stack(self.memaddr(self.memblock, indim=self.decinnerdim, memdim=self.memblock.outdim, attdim=self.attdim), Softmax()) self.dec = SeqDecoder( [entemb2, #self.memblock, GRU(dim=entemb.outdim + self.encinnerdim, innerdim=self.decinnerdim), # GRU(dim=self.memblock.outdim + self.encinnerdim, innerdim=self.decinnerdim), ], inconcat=True, innerdim=self.decinnerdim, softmaxoutblock=self.softmaxoutblock )
def __init__(self, numchars=256, charembdim=50, charemb=None, charinnerdim=100, numwords=1000, wordembdim=100, wordemb=None, wordinnerdim=200, maskid=None, bidir=False, returnall=False, **kw): # char level inits if charemb is None: charemb = VectorEmbed(indim=numchars, dim=charembdim) else: charemb = charemb charembdim = charemb.outdim if not issequence(charinnerdim): charinnerdim = [charinnerdim] charlayers, lastchardim = MakeRNU.make(charembdim, charinnerdim, bidir=bidir) charenc = SeqEncoder(charemb, *charlayers).maskoptions(maskid, MaskMode.AUTO) # word level inits if wordemb is None: wordemb = VectorEmbed(indim=numwords, dim=wordembdim) elif wordemb is False: wordemb = None wordembdim = 0 else: wordemb = wordemb wordembdim = wordemb.outdim if not issequence(wordinnerdim): wordinnerdim = [wordinnerdim] wordlayers, outdim = MakeRNU.make(wordembdim + lastchardim, wordinnerdim, bidir=bidir) wordenc = SeqEncoder(None, *wordlayers).maskoptions(MaskMode.NONE) if returnall: wordenc.all_outputs() self.outdim = outdim super(WordCharSentEnc, self).__init__(l1enc=charenc, l2emb=wordemb, l2enc=wordenc, maskid=maskid)
def __init__(self, indim=1000, dim=50, outdim=None, normalize=False, **kw): super(Dummy, self).__init__(**kw) self.dim = dim self.indim = indim self.W = VectorEmbed(indim=indim, dim=dim, normalize=normalize) self.outdim = indim if outdim is None else outdim self.O = param((dim, self.outdim), lrmul=1.).glorotuniform()
def __init__(self, indim=500, inpembdim=100, inpemb=None, innerdim=200, bidir=False, maskid=None, zoneout=False, dropout_in=False, dropout_h=False, **kw): if inpemb is None: inpemb = VectorEmbed(indim=indim, dim=inpembdim, maskid=maskid) elif inpemb is False: inpemb = None else: inpembdim = inpemb.outdim if not issequence(innerdim): innerdim = [innerdim] layers, _ = MakeRNU.make(inpembdim, innerdim, bidir=bidir, zoneout=zoneout, dropout_in=dropout_in, dropout_h=dropout_h) super(RNNSeqEncoder, self).__init__(inpemb, *layers, **kw)
def __init__(self, indim=400, inpembdim=50, inpemb=None, mode="concat", innerdim=100, numouts=1, maskid=0, bidir=False, maskmode=MaskMode.NONE, **kw): super(SimpleSeq2MultiVec, self).__init__(**kw) if inpemb is None: if inpembdim is None: inpemb = IdxToOneHot(indim) inpembdim = indim else: inpemb = VectorEmbed(indim=indim, dim=inpembdim) elif inpemb is False: inpemb = None else: inpembdim = inpemb.outdim if not issequence(innerdim): innerdim = [innerdim] innerdim[-1] += numouts rnn, lastdim = self.makernu(inpembdim, innerdim, bidir=bidir) self.outdim = lastdim * numouts self.maskid = maskid self.inpemb = inpemb self.numouts = numouts self.mode = mode if not issequence(rnn): rnn = [rnn] self.enc = SeqEncoder(inpemb, *rnn).maskoptions(maskid, maskmode) self.enc.all_outputs()
def __init__(self, indim=400, inpembdim=50, inpemb=None, innerdim=100, maskid=0, bidir=False, pool=False, **kw): if inpemb is False: inpemb = None elif inpemb is None: if inpembdim is None: inpemb = IdxToOneHot(indim) inpembdim = indim else: inpemb = VectorEmbed(indim=indim, dim=inpembdim) else: inpembdim = inpemb.outdim rnn, lastdim = self.makernu(inpembdim, innerdim, bidir=bidir) self.outdim = lastdim poolblock = None if pool is False else Pool( (None, ), axis=(1, ), mode="max") super(SimpleSeq2Vec, self).__init__(inpemb, rnn, maskid=maskid, pool=poolblock, **kw)
def __init__(self, wordembdim=50, entembdim=200, innerdim=200, attdim=100, outdim=1e4, numwords=4e5, **kw): super(FBSeqSimpEncDecAtt, self).__init__(**kw) self.indim = wordembdim self.outdim = outdim self.wordembdim = wordembdim self.encinnerdim = innerdim self.decinnerdim = innerdim self.entembdim = entembdim self.wordencoder = WordEmbed(indim=numwords, outdim=self.wordembdim, trainfrac=1.0) self.rnn = RecStack( self.wordencoder, GRU(dim=self.wordembdim, innerdim=self.encinnerdim)) attgen = LinearGateAttentionGenerator(indim=self.encinnerdim + self.decinnerdim, attdim=attdim) attcon = WeightedSumAttCon() self.dec = SeqDecoder([ VectorEmbed(indim=self.outdim, dim=self.entembdim), GRU(dim=self.entembdim, innerdim=self.decinnerdim) ], attention=Attention(attgen, attcon), outconcat=True, inconcat=False, innerdim=self.encinnerdim + self.decinnerdim)
def __init__(self, indim=400, inpembdim=50, inpemb=None, innerdim=100, maskid=None, bidir=False, **kw): if inpemb is None: if inpembdim is None: inpemb = IdxToOneHot(indim) inpembdim = indim else: inpemb = VectorEmbed(indim=indim, dim=inpembdim) else: inpembdim = inpemb.outdim lastdim = inpembdim if not issequence(innerdim): # single encoder innerdim = [innerdim] rnns = [] for innerdimi in innerdim: if not issequence(innerdimi): # one layer in encoder innerdimi = [innerdimi] rnn, lastdim = MakeRNU.make(lastdim, innerdimi, bidir=bidir) rnns.append(rnn) self.outdim = lastdim super(SimpleSeqStar2Vec, self).__init__(inpemb, *rnns, maskid=maskid, **kw)
def setUp(self): dim = 50 self.vocabsize = 2000 data = np.arange(0, self.vocabsize).astype("int32") self.O = param((dim, self.vocabsize)).uniform() self.W = VectorEmbed(indim=self.vocabsize, dim=50) self.out = stack(self.W, asblock(lambda x: T.dot(self.O, x)), Softmax())(Input(ndim=1, dtype="int32"))
def __init__(self, invocsize=27, outvocsize=500, innerdim=300, **kw): super(seq2idx, self).__init__(**kw) self.invocsize = invocsize self.outvocsize = outvocsize self.innerdim = innerdim self.enc = SeqEncoder( VectorEmbed(indim=self.invocsize, dim=self.invocsize), GRU(dim=self.invocsize, innerdim=self.innerdim)) self.outlin = Lin(indim=self.innerdim, dim=self.outvocsize)
def __init__(self, indim=4000, outdim=100, embdim=50, embtrainfrac=0.0, **kw): super(WordEmbedPlusGlove, self).__init__(indim, outdim + embdim, **kw) self.glove = Glove(embdim, vocabsize=indim, trainfrac=embtrainfrac).block self.emb = VectorEmbed(indim=indim, dim=outdim)
def __init__( self, entembdim=50, wordembdim=50, wordencdim=100, memdata=None, attdim=100, numchars=128, # number of different chars numwords=4e5, # number of different words glovepath=None, innerdim=100, # dim of memory payload encoder output outdim=1e4, # number of entities memaddr=DotMemAddr, **kw): super(FBMemMatch, self).__init__(**kw) self.wordembdim = wordembdim self.wordencdim = wordencdim self.entembdim = entembdim self.attdim = attdim self.encinnerdim = innerdim self.outdim = outdim memaddr = TransDotMemAddr # memory encoder per word #wencpg = WordEmbed(indim=numwords, outdim=self.wordembdim, trainfrac=1.0) wordencoder = WordEncoderPlusGlove(numchars=numchars, numwords=numwords, encdim=self.wordencdim, embdim=self.wordembdim, embtrainfrac=0.0, glovepath=glovepath) # memory encoder for one cell self.phraseencoder = SeqEncoder( wordencoder, GRU(dim=self.wordembdim + self.wordencdim, innerdim=self.encinnerdim)) # entity embedder entemb = VectorEmbed(indim=self.outdim, dim=self.entembdim) self.entembs = entemb( memdata[0]) #Val(np.arange(0, self.outdim, dtype="int32"))) # memory block self.mempayload = self.phraseencoder #ConcatBlock(entemb, self.phraseencoder) self.memblock = MemoryBlock( self.mempayload, memdata[1], indim=self.outdim, outdim=self.encinnerdim) # + self.entembdim) # memory addressing self.mema = memaddr(self.memblock, memdim=self.memblock.outdim, attdim=attdim, indim=self.encinnerdim)
def __init__(self, indim=400, outdim=50, inpembdim=50, outembdim=50, innerdim=100, **kw): self.inpemb = VectorEmbed(indim=indim, dim=inpembdim) self.outemb = VectorEmbed(indim=outdim, dim=outembdim) self.rnn = [] if not issequence(innerdim): innerdim = [innerdim] innerdim = [inpembdim + outembdim] + innerdim self.rnn = MakeRNU.fromdims(innerdim)[0] super(SimpleSeqTransDec, self).__init__(self.inpemb, self.outemb, *self.rnn, smodim=innerdim[-1], outdim=outdim, **kw)
def __init__(self, indim=400, embdim=50, innerdim=100, outdim=50, **kw): self.emb = VectorEmbed(indim=indim, dim=embdim) if not issequence(innerdim): innerdim = [innerdim] innerdim = [embdim] + innerdim self.rnn = self.getrnnfrominnerdim(innerdim) super(SimpleSeqTransducer, self).__init__(self.emb, *self.rnn, smodim=innerdim[-1], outdim=outdim, **kw)
def getemb(emb=None, embdim=None, vocsize=None, maskid=-1): if emb is False: assert (embdim is not None) return None, embdim elif emb is not None: return emb, emb.outdim else: if embdim is None: return IdxToOneHot(vocsize), vocsize else: return VectorEmbed(indim=vocsize, dim=embdim, maskid=maskid), embdim
def test_ns_training(self): num = 2000 self.expshape = (num, 50) Glove.defaultpath = "../../../data/glove/miniglove.%dd.txt" self.glove = Glove(self.expshape[1], self.expshape[0]) self.cemb = VectorEmbed(indim=self.expshape[0] + 1, dim=self.expshape[1]) self.assertRaises(Exception, self.glove.block.predict, [num + 1]) self.assertRaises(Exception, self.cemb.predict, [num + 1]) m = MatchScore(self.glove.block, self.cemb, scorer=CosineDistance()) mg = MatchScore(self.glove.block, self.glove.block) # TODO factor out matchscore tests idxs = np.arange(num + 1) # glove against glove self.assertTrue( np.allclose(mg.predict([num, 100], [num, 100]), [ np.linalg.norm(self.glove % num)**2, np.linalg.norm(self.glove % 100)**2 ])) class NegIdxGen(): def __init__(self, num): self.n = num def __call__(self, l, r): return l, np.random.randint(0, self.n, r.shape) vdata = np.arange(num) negrate = 5 def obj(p, n): return n - p m, err, verr, _, _ = m.nstrain([idxs, idxs]).negsamplegen(NegIdxGen(num+1)).negrate(negrate)\ .adagrad(lr=0.1).objective(obj) \ .validate_on([vdata, vdata]).extvalid(geteval(m.predict, num, negrate)).validinter(30) \ .train(numbats=50, epochs=29, returnerrors=True) #.writeresultstofile("testingresultswriter.tsv") \ tdata = np.arange(num) tt = ticktock("eval") tt.tick() mrr, recat1, recat10 = geteval(m.predict, num, 1)(tdata) tt.tock("evaluated test data") print "%.4f MRR,\t%.4f MR@10,\t%.4f MR@1" % (mrr, recat10, recat1) self.assertGreater(mrr, 0.85) self.assertGreater(recat10, 0.9) print verr self.assertTrue( np.allclose(np.asarray([mrr, recat1, recat10]), np.asarray(verr[-1][1:])))
def test_seq_scoring(self): vocsize = 100 dim = 10 numsam = 17 seqlen = 5 ve = VectorEmbed(vocsize, dim) m = SeqMatchScore(SeqUnroll(ve), SeqUnroll(ve), scorer=CosineDistance()) data = np.random.randint(0, vocsize, (numsam, seqlen)) #print data.shape pred = m.predict(data, data) #print pred self.assertTrue(np.allclose(np.ones_like(pred)*seqlen*1., pred))
def init(self): #MEMORY: encodes how entity is written + custom entity embeddings wencpg = WordEncoderPlusGlove(numchars=self.numchars, numwords=self.numwords, encdim=self.wordencdim, embdim=self.wordembdim, embtrainfrac=0.0, glovepath=self.glovepath) self.memenco = SeqEncoder( wencpg, GRU(dim=self.wordembdim + self.wordencdim, innerdim=self.encinnerdim)) entemb = VectorEmbed(indim=self.outdim, dim=self.entembdim) self.mempayload = ConcatBlock(entemb, self.memenco) self.memblock = MemoryBlock(self.mempayload, self.memdata, indim=self.outdim, outdim=self.encinnerdim + self.entembdim) #ENCODER: uses the same language encoder as memory #wencpg2 = WordEncoderPlusGlove(numchars=self.numchars, numwords=self.numwords, encdim=self.wordencdim, embdim=self.wordembdim, embtrainfrac=0.0, glovepath=glovepath) self.enc = RecStack( wencpg, GRU(dim=self.wordembdim + self.wordencdim, innerdim=self.encinnerdim)) #ATTENTION attgen = LinearGateAttentionGenerator(indim=self.encinnerdim + self.decinnerdim, innerdim=self.attdim) attcon = WeightedSumAttCon() #DECODER #entemb2 = VectorEmbed(indim=self.outdim, dim=self.entembdim) self.softmaxoutblock = stack( self.memaddr(self.memblock, indim=self.decinnerdim + self.encinnerdim, memdim=self.memblock.outdim, attdim=self.attdim), Softmax()) self.dec = SeqDecoder([ self.memblock, GRU(dim=self.entembdim + self.encinnerdim, innerdim=self.decinnerdim) ], outconcat=True, inconcat=False, attention=Attention(attgen, attcon), innerdim=self.decinnerdim + self.encinnerdim, softmaxoutblock=self.softmaxoutblock)
def __init__(self, encdim, invocsize, outvocsize, innerdim, seqlen, **kw): super(idx2seqStupid, self).__init__(**kw) self.encdim = encdim self.invocsize = invocsize self.outvocsize = outvocsize self.innerdim = innerdim self.seqlen = seqlen self.emb = VectorEmbed(indim=self.invocsize, dim=self.encdim, normalize=True) self.aletter = stack(Lin(indim=self.encdim, dim=self.outvocsize), Softmax()) self.bletter = stack(Lin(indim=self.encdim, dim=self.outvocsize), Softmax()) self.cletter = stack(Lin(indim=self.encdim, dim=self.outvocsize), Softmax())
def getdeclayers(self, outembdim, outvocsize, lastencinnerdim, decinnerdim, rnu, inconcat): if outembdim is None: outemb = IdxToOneHot(outvocsize) outembdim = outvocsize elif isinstance(outembdim, Block): outemb = outembdim outembdim = outemb.outdim else: outemb = VectorEmbed(indim=outvocsize, dim=outembdim) decrnus = [] firstdecdim = outembdim + lastencinnerdim if inconcat else outembdim dims = [firstdecdim] + decinnerdim i = 1 while i < len(dims): decrnus.append(rnu(dim=dims[i - 1], innerdim=dims[i])) i += 1 declayers = [outemb] + decrnus return declayers
def __init__(self, wordembdim=50, wordencdim=50, entembdim=200, innerdim=200, attdim=100, outdim=1e4, numwords=4e5, numchars=128, glovepath=None, **kw): super(FBSeqCompEncDecAtt, self).__init__(**kw) self.indim = wordembdim + wordencdim self.outdim = outdim self.wordembdim = wordembdim self.wordencdim = wordencdim self.encinnerdim = innerdim self.entembdim = entembdim self.decinnerdim = innerdim self.wordencoder = WordEncoderPlusGlove(numchars=numchars, numwords=numwords, encdim=self.wordencdim, embdim=self.wordembdim, embtrainfrac=0.0, glovepath=glovepath) self.rnn = RecStack( self.wordencoder, GRU(dim=wordembdim + wordencdim, innerdim=self.encinnerdim)) attgen = LinearGateAttentionGenerator(indim=self.encinnerdim + self.decinnerdim, innerdim=attdim) attcon = WeightedSumAttCon() self.dec = SeqDecoder([ VectorEmbed(indim=self.outdim, dim=self.entembdim), GRU(dim=self.entembdim, innerdim=self.decinnerdim) ], attention=Attention(attgen, attcon), outconcat=True, inconcat=False, innerdim=self.encinnerdim + self.decinnerdim)
def __init__(self, indim=400, embdim=50, inpemb=None, innerdim=100, outdim=50, rnu=GRU, **kw): if inpemb is None: emb = VectorEmbed(indim=indim, dim=embdim) else: emb = inpemb embdim = emb.outdim if not issequence(innerdim): innerdim = [innerdim] innerdim = [embdim] + innerdim rnn, _ = MakeRNU.fromdims(innerdim, rnu=rnu) smo = Lin(indim=innerdim[-1], dim=outdim) super(SimpleSeqTrans, self).__init__(emb, *(rnn + [smo, Softmax()]), **kw)
def __init__(self, wordembdim=50, wordencdim=100, entembdim=200, innerdim=200, outdim=1e4, numwords=4e5, numchars=128, glovepath=None, **kw): super(FBSeqCompositeEncDec, self).__init__(**kw) self.indim = wordembdim + wordencdim self.outdim = outdim self.wordembdim = wordembdim self.wordencdim = wordencdim self.encinnerdim = innerdim self.entembdim = entembdim self.decinnerdim = innerdim self.enc = SeqEncoder( WordEncoderPlusGlove(numchars=numchars, numwords=numwords, encdim=self.wordencdim, embdim=self.wordembdim, embtrainfrac=0.0, glovepath=glovepath), GRU(dim=self.wordembdim + self.wordencdim, innerdim=self.encinnerdim) ) self.dec = SeqDecoder( [VectorEmbed(indim=self.outdim, dim=self.entembdim), GRU(dim=self.entembdim+self.encinnerdim, innerdim=self.decinnerdim)], inconcat=True, innerdim=self.decinnerdim, )
def test_mask_propagation_all_states(self): m = SeqEncoder(VectorEmbed(maskid=0, indim=100, dim=7), GRU(dim=7, innerdim=30)).all_outputs()\ .maskoptions(MaskSetMode.ZERO) data = np.random.randint(1, 100, (5, 3), dtype="int32") ndata = np.zeros_like(data) data = np.concatenate([data, ndata], axis=1) dataval = Val(data) embvar = m.embedder(dataval) embpred = embvar.eval() embmaskpred = embvar.mask.eval() encvar = m(dataval) encpred = encvar.eval() encmaskpred = encvar.mask.eval() print encpred.shape print encmaskpred.shape print encmaskpred self.assertTrue(np.sum(encmaskpred - embmaskpred) == 0)
def __init__(self, indim=500, inpembdim=100, inpemb=None, innerdim=200, window=5, poolmode="max", activation=Tanh, maskid=None, **kw): if inpemb is None: self.embedder = VectorEmbed(indim, inpembdim, maskid=maskid) else: self.embedder = inpemb inpembdim = inpemb.outdim super(CNNSeqEncoder, self).__init__(indim=inpembdim, innerdim=innerdim, window=window, poolmode=poolmode, activation=activation, **kw)
def __init__(self, indim=400, embdim=50, inpemb=None, innerdim=100, outdim=50, rnu=GRU, **kw): if inpemb is None: self.emb = VectorEmbed(indim=indim, dim=embdim) else: self.emb = inpemb embdim = self.emb.outdim if not issequence(innerdim): innerdim = [innerdim] innerdim = [embdim] + innerdim self.rnn = MakeRNU.fromdims(innerdim, rnu=rnu)[0] super(SimpleSeqTransducer, self).__init__(self.emb, *self.rnn, smodim=innerdim[-1], outdim=outdim, **kw)
def run(epochs=50, numbats=25, lr=0.1, layers=1, embdim=100, encdim=200, bidir=False, mode="wordchar", # "char" or "word" or "wordchar" maxlen=75, maxwordlen=15, ): maskid = -1 (traindata, traingold), (testdata, testgold), dic = \ readdata("../../../data/hatespeech/train.csv", "../../../data/hatespeech/test.csv", masksym=maskid, mode=mode, maxlen=maxlen) # data stats print "class distribution in train: {}% positive".format(np.sum(traingold)*1. / np.sum(np.ones_like(traingold))) print "class distribution in test: {}% positive".format(np.sum(testgold)*1. / np.sum(np.ones_like(testgold))) inpemb = VectorEmbed(indim=len(dic), dim=embdim) encdim = [encdim] * layers if mode == "wordchar": enc = WordCharSentEnc(charemb=inpemb, charinnerdim=embdim, wordemb=False, wordinnerdim=encdim, maskid=maskid, bidir=bidir) else: enc = SimpleSeq2Vec(inpemb=inpemb, innerdim=encdim, maskid=maskid, bidir=bidir) m = SMOWrap(enc, outdim=2, nobias=True) #print enc.predict(traindata[:5, :]) m = m.train([traindata], traingold)\ .adadelta(lr=lr).grad_total_norm(1.0)\ .cross_entropy().split_validate(6, random=True).cross_entropy().accuracy()\ .train(numbats=numbats, epochs=epochs) m.save("hatemodel.{}.Emb{}D.Enc{}D.{}L.model".format(mode, embdim, encdim, layers))
def getenclayers(self, inpembdim, inpvocsize, encinnerdim, bidir, rnu): if inpembdim is None: inpemb = IdxToOneHot(inpvocsize) inpembdim = inpvocsize elif isinstance(inpembdim, Block): inpemb = inpembdim inpembdim = inpemb.outdim else: inpemb = VectorEmbed(indim=inpvocsize, dim=inpembdim) encrnus = [] dims = [inpembdim] + encinnerdim #print dims i = 1 lastencinnerdim = dims[-1] if not bidir else dims[-1] * 2 while i < len(dims): if bidir: newrnu = BiRNU.fromrnu(rnu, dim=dims[i - 1], innerdim=dims[i]) else: newrnu = rnu(dim=dims[i - 1], innerdim=dims[i]) encrnus.append(newrnu) i += 1 enclayers = [inpemb] + encrnus return enclayers, lastencinnerdim
def __init__(self, encdim=44, invocsize=500, outvocsize=27, innerdim=300, seqlen=20, **kw): super(idx2seq, self).__init__(**kw) self.invocsize = invocsize self.outvocsize = outvocsize self.innerdim = innerdim self.seqlen = seqlen self.encdim = encdim self.emb = VectorEmbed(indim=self.invocsize, dim=self.encdim, normalize=False) self.dec = SeqDecoder([ IdxToOneHot(self.outvocsize), GRU(dim=self.outvocsize + self.encdim, innerdim=self.innerdim, nobias=True) ], inconcat=True, innerdim=self.innerdim)
def __init__(self, embdim, numents, numrels, **kw): self.A = VectorEmbed(indim=numents, dim=embdim, normalize=True) self.R = VectorEmbed(indim=numrels, dim=embdim, normalize=True) self.scorer = EuclideanDistance() super(TransE, self).__init__(**kw)