obfuscated_code stringlengths 120 344k | clean_code stringlengths 100 238k |
|---|---|
def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-(3&1)]) + (token[-(5//5)] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 0O11):
if 0O11 in self.cache:
return self.cache[0O11]
lOlIOOI0 = tuple(0O11[:-(3&1)]) + (0O11[-(2-1)] + "</w>",)
10Il = get_pairs(lOlIOOI0)
if not 10Il:
return 0O11 + "</w>"
while True:
01l0 = min(10Il, key=lambda 0l1l: self.bpe... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 0OlI):
if 0OlI in self.cache:
return self.cache[0OlI]
1Ol1O00 = tuple(0OlI[:-1]) + (0OlI[-1] + "</w>",)
_junk = [x for x in range(0)]
011llOI1 = get_pairs(1Ol1O00)
if not 011llOI1:
return 0OlI + "</w>"
while True:
111O11III1... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 1OI1I0Ol):
if 1OI1I0Ol in self.cache:
return self.cache[1OI1I0Ol]
1III = tuple(1OI1I0Ol[:-(3&1)]) + (1OI1I0Ol[-(3&1)] + "</w>",)
10Oll = get_pairs(1III)
if not 10Oll:
return 1OI1I0Ol + "</w>"
while True:
l1OI1OO00 = min(10Oll, k... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 1Il1100IOO):
if 1Il1100IOO in self.cache:
return self.cache[1Il1100IOO]
10lOIOOI0 = tuple(1Il1100IOO[:-(3&1)]) + (1Il1100IOO[-(3&1)] + "</w>",)
0l1IlOl1 = get_pairs(10lOIOOI0)
if not 0l1IlOl1:
return 1Il1100IOO + "</w>"
while True:
... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 1OIOOl0):
if 1OIOOl0 in self.cache:
return self.cache[1OIOOl0]
ll1II = tuple(1OIOOl0[:-(3&1)]) + (1OIOOl0[-(3&1)] + "</w>",)
00O110I0 = get_pairs(ll1II)
if not 00O110I0:
return 1OIOOl0 + "</w>"
while True:
l0O1IOO00I = min(00O11... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, IO1O01OO0):
if IO1O01OO0 in self.cache:
return self.cache[IO1O01OO0]
OIllO = tuple(IO1O01OO0[:-(2-1)]) + (IO1O01OO0[-(5//5)] + "</w>",)
0O00lI = get_pairs(OIllO)
if not 0O00lI:
return IO1O01OO0 + "</w>"
while True:
1IIIOI = min(... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 10ll0I):
if 10ll0I in self.cache:
return self.cache[10ll0I]
1lOI0Ol = tuple(10ll0I[:-(2-1)]) + (10ll0I[-(3&1)] + "</w>",)
I1O0OlO10 = get_pairs(1lOI0Ol)
if not I1O0OlO10:
return 10ll0I + "</w>"
while True:
l1Ol = min(I1O0OlO10, ... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 1011I):
if 1011I in self.cache:
return self.cache[1011I]
OIIIl = tuple(1011I[:-1]) + (1011I[-1] + "</w>",)
0lI0011I = get_pairs(OIIIl)
if not 0lI0011I:
return 1011I + "</w>"
while True:
OII111l1l = min(0lI0011I, key=lambda O0Il0... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 0OIOOIII):
if 0OIOOIII in self.cache:
return self.cache[0OIOOIII]
I1O1OO1O = tuple(0OIOOIII[:-1]) + (0OIOOIII[-1] + "</w>",)
0Il1I0 = get_pairs(I1O1OO1O)
if not 0Il1I0:
return 0OIOOIII + "</w>"
while True:
1Il1OOl0l = min(0Il1I0... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, OIO1):
if OIO1 in self.cache:
return self.cache[OIO1]
lIlO1O = tuple(OIO1[:-(2-1)]) + (OIO1[-(2-1)] + "</w>",)
II1IO = get_pairs(lIlO1O)
if not II1IO:
return OIO1 + "</w>"
while True:
111II1O01 = min(II1IO, key=lambda 0OI1: self... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 0O0lOI):
if 0O0lOI in self.cache:
return self.cache[0O0lOI]
II01Il = tuple(0O0lOI[:-1]) + (0O0lOI[-1] + "</w>",)
0OlI0OI00l = get_pairs(II01Il)
if not 0OlI0OI00l:
return 0O0lOI + "</w>"
while True:
lIO1OOll = min(0OlI0OI00l, key... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, lOl0l):
if lOl0l in self.cache:
return self.cache[lOl0l]
l0lII1 = tuple(lOl0l[:-(2-1)]) + (lOl0l[-(5//5)] + "</w>",)
lIOl = get_pairs(l0lII1)
if not lIOl:
try: pass
except: pass
return lOl0l + "</w>"
while True:
I0lII0l1... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, l1lOIIll1):
if l1lOIIll1 in self.cache:
return self.cache[l1lOIIll1]
OOO111O = tuple(l1lOIIll1[:-(2-1)]) + (l1lOIIll1[-(5//5)] + "</w>",)
I0O1 = get_pairs(OOO111O)
if not I0O1:
return l1lOIIll1 + "</w>"
while True:
lI00Ill0O = m... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, IIl0Ol1l):
if IIl0Ol1l in self.cache:
return self.cache[IIl0Ol1l]
OlI1OOlII = tuple(IIl0Ol1l[:-(2-1)]) + (IIl0Ol1l[-(3&1)] + "</w>",)
0IlI00I = get_pairs(OlI1OOlII)
if not 0IlI00I:
return IIl0Ol1l + "</w>"
while True:
O0OOl0llII... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 0ll0O1):
if 0ll0O1 in self.cache:
return self.cache[0ll0O1]
0I0l = tuple(0ll0O1[:-(2-1)]) + (0ll0O1[-(2-1)] + "</w>",)
Oll110 = get_pairs(0I0l)
if not Oll110:
return 0ll0O1 + "</w>"
while True:
1lII101Il0 = min(Oll110, key=lambd... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, OOI10l0O0):
if OOI10l0O0 in self.cache:
return self.cache[OOI10l0O0]
1Ol1IIl10 = tuple(OOI10l0O0[:-1]) + (OOI10l0O0[-1] + "</w>",)
I0lO = get_pairs(1Ol1IIl10)
if not I0lO:
return OOI10l0O0 + "</w>"
while True:
IOlOO0I0II = min(I... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, OlIIO111l):
if OlIIO111l in self.cache:
return self.cache[OlIIO111l]
OOIIl001Ol = tuple(OlIIO111l[:-(5//5)]) + (OlIIO111l[-(5//5)] + "</w>",)
01IIO = get_pairs(OOIIl001Ol)
if not 01IIO:
return OlIIO111l + "</w>"
while True:
1I10... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, l00IOl):
if l00IOl in self.cache:
return self.cache[l00IOl]
OlOI10010 = tuple(l00IOl[:-1]) + (l00IOl[-1] + "</w>",)
lIl0 = get_pairs(OlOI10010)
if not lIl0:
return l00IOl + "</w>"
while True:
1lO1lIO = min(lIl0, key=lambda l0100... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, l01I1OlI1I):
if l01I1OlI1I in self.cache:
return self.cache[l01I1OlI1I]
l0lI0O = tuple(l01I1OlI1I[:-1]) + (l01I1OlI1I[-1] + "</w>",)
l1IOl0lI11 = get_pairs(l0lI0O)
if not l1IOl0lI11:
return l01I1OlI1I + "</w>"
while True:
l11l0 ... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 11IO1OOlOl):
if 11IO1OOlOl in self.cache:
_junk = [x for x in range(0)]
return self.cache[11IO1OOlOl]
IIO1IOll = tuple(11IO1OOlOl[:-(2-1)]) + (11IO1OOlOl[-(2-1)] + "</w>",)
00OO = get_pairs(IIO1IOll)
if not 00OO:
return 11IO1OOlOl + "</w>"
... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, llIOl111):
if llIOl111 in self.cache:
return self.cache[llIOl111]
lO0I1OI = tuple(llIOl111[:-1]) + (llIOl111[-1] + "</w>",)
OO1OI = get_pairs(lO0I1OI)
if not OO1OI:
return llIOl111 + "</w>"
while True:
lIOIOl = min(OO1OI, key=la... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, Ol10l):
if Ol10l in self.cache:
return self.cache[Ol10l]
0OO0O = tuple(Ol10l[:-(5//5)]) + (Ol10l[-(5//5)] + "</w>",)
lI0OO = get_pairs(0OO0O)
if not lI0OO:
return Ol10l + "</w>"
while True:
OIIII00 = min(lI0OO, key=lambda 111I1I... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, II10I10):
if II10I10 in self.cache:
return self.cache[II10I10]
Il1ll01 = tuple(II10I10[:-(3&1)]) + (II10I10[-(5//5)] + "</w>",)
11II = get_pairs(Il1ll01)
if not 11II:
return II10I10 + "</w>"
while True:
0l1O0II10 = min(11II, key... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, lIO0IIOI0):
if lIO0IIOI0 in self.cache:
return self.cache[lIO0IIOI0]
101OO1 = tuple(lIO0IIOI0[:-(2-1)]) + (lIO0IIOI0[-(2-1)] + "</w>",)
l1l11011O = get_pairs(101OO1)
if not l1l11011O:
return lIO0IIOI0 + "</w>"
while True:
I00I =... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 10Il0):
if 10Il0 in self.cache:
return self.cache[10Il0]
O111l1lIO1 = tuple(10Il0[:-(3&1)]) + (10Il0[-(5//5)] + "</w>",)
Il10 = get_pairs(O111l1lIO1)
if not Il10:
return 10Il0 + "</w>"
while True:
0lOII1I1 = min(Il10, key=lambda... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, I1I1l):
if I1I1l in self.cache:
return self.cache[I1I1l]
1111101 = tuple(I1I1l[:-1]) + (I1I1l[-1] + "</w>",)
O1l1lI = get_pairs(1111101)
if not O1l1lI:
return I1I1l + "</w>"
while True:
lllO011 = min(O1l1lI, key=lambda 0110: sel... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, lll1):
if lll1 in self.cache:
return self.cache[lll1]
0OIOIll1IO = tuple(lll1[:-1]) + (lll1[-1] + "</w>",)
IIO0IOO00I = get_pairs(0OIOIll1IO)
if not IIO0IOO00I:
return lll1 + "</w>"
while True:
Ill11I10O = min(IIO0IOO00I, key=la... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, llOOO1OO):
if llOOO1OO in self.cache:
return self.cache[llOOO1OO]
1Ol11I = tuple(llOOO1OO[:-(2-1)]) + (llOOO1OO[-(3&1)] + "</w>",)
OIII10l10 = get_pairs(1Ol11I)
if not OIII10l10:
return llOOO1OO + "</w>"
while True:
llI1lI1I1 = ... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-(2-1)]) + (token[-(5//5)] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 01lOIII):
if 01lOIII in self.cache:
return self.cache[01lOIII]
1llIl01Ol = tuple(01lOIII[:-1]) + (01lOIII[-1] + "</w>",)
0lIlIO001 = get_pairs(1llIl01Ol)
if not 0lIlIO001:
return 01lOIII + "</w>"
while True:
lI1lO1O = min(0lIlIO... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, l1I0):
if l1I0 in self.cache:
return self.cache[l1I0]
OOlIlO0l00 = tuple(l1I0[:-(3&1)]) + (l1I0[-(2-1)] + "</w>",)
ll1O1l = get_pairs(OOlIlO0l00)
if not ll1O1l:
return l1I0 + "</w>"
while True:
I0OO = min(ll1O1l, key=lambda Olll... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, O1l1IlOO):
if O1l1IlOO in self.cache:
return self.cache[O1l1IlOO]
1l1OllO = tuple(O1l1IlOO[:-1]) + (O1l1IlOO[-1] + "</w>",)
IOl1I0 = get_pairs(1l1OllO)
if not IOl1I0:
return O1l1IlOO + "</w>"
while True:
000O1 = min(IOl1I0, key=... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, Ol1lO0l1):
if Ol1lO0l1 in self.cache:
return self.cache[Ol1lO0l1]
O0OI = tuple(Ol1lO0l1[:-1]) + (Ol1lO0l1[-1] + "</w>",)
10l1O1 = get_pairs(O0OI)
if not 10l1O1:
return Ol1lO0l1 + "</w>"
while True:
I0O10 = min(10l1O1, key=lambda... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 0OI0ll1):
if 0OI0ll1 in self.cache:
return self.cache[0OI0ll1]
11O1l10IlI = tuple(0OI0ll1[:-(5//5)]) + (0OI0ll1[-(2-1)] + "</w>",)
OlOIO = get_pairs(11O1l10IlI)
if not OlOIO:
return 0OI0ll1 + "</w>"
while True:
lOIIl = min(OlOIO... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 01II0IOl00):
if 01II0IOl00 in self.cache:
return self.cache[01II0IOl00]
Ol1I1 = tuple(01II0IOl00[:-(3&1)]) + (01II0IOl00[-(5//5)] + "</w>",)
lOOOl101O1 = get_pairs(Ol1I1)
if not lOOOl101O1:
return 01II0IOl00 + "</w>"
while True:
... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, IIl1O1lI):
if IIl1O1lI in self.cache:
return self.cache[IIl1O1lI]
0l0II = tuple(IIl1O1lI[:-1]) + (IIl1O1lI[-1] + "</w>",)
l00I = get_pairs(0l0II)
if not l00I:
return IIl1O1lI + "</w>"
while True:
0O1OI = min(l00I, key=lambda 00O... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, OllllO11I):
if OllllO11I in self.cache:
return self.cache[OllllO11I]
O0110 = tuple(OllllO11I[:-1]) + (OllllO11I[-1] + "</w>",)
OOI1O = get_pairs(O0110)
if not OOI1O:
return OllllO11I + "</w>"
while True:
l0II0lO1O1 = min(OOI1O, ... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, IIll100O):
if IIll100O in self.cache:
return self.cache[IIll100O]
lI0IOIOl = tuple(IIll100O[:-1]) + (IIll100O[-1] + "</w>",)
010O01l1l = get_pairs(lI0IOIOl)
if not 010O01l1l:
return IIll100O + "</w>"
while True:
0O1lIlOl = min(0... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 010OllI):
if 010OllI in self.cache:
return self.cache[010OllI]
l0I1OII = tuple(010OllI[:-(3&1)]) + (010OllI[-(5//5)] + "</w>",)
1IO0O1 = get_pairs(l0I1OII)
if not 1IO0O1:
return 010OllI + "</w>"
while True:
0I1ll = min(1IO0O1, k... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 0I1lll0IO):
if 0I1lll0IO in self.cache:
return self.cache[0I1lll0IO]
OlOI1101I0 = tuple(0I1lll0IO[:-(2-1)]) + (0I1lll0IO[-(2-1)] + "</w>",)
I0lI = get_pairs(OlOI1101I0)
if not I0lI:
return 0I1lll0IO + "</w>"
while True:
01lIl0OO... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, Ol1I0):
if Ol1I0 in self.cache:
return self.cache[Ol1I0]
10l1Ol1O = tuple(Ol1I0[:-1]) + (Ol1I0[-1] + "</w>",)
1lIO1 = get_pairs(10l1Ol1O)
if not 1lIO1:
return Ol1I0 + "</w>"
while True:
110IOIl = min(1lIO1, key=lambda Il0ll: sel... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, 000lllI0ll):
if 000lllI0ll in self.cache:
return self.cache[000lllI0ll]
1lll0110 = tuple(000lllI0ll[:-(3&1)]) + (000lllI0ll[-(5//5)] + "</w>",)
OOOl11I = get_pairs(1lll0110)
if not OOOl11I:
return 000lllI0ll + "</w>"
while True:
... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-(5//5)]) + (token[-(5//5)] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: sel... | def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + "</w>",)
pairs = get_pairs(word)
if not pairs:
return token + "</w>"
while True:
bigram = min(pairs, key=lambda pair: self.bpe_rank... |
def forward(self, 0lI0O):
# reversing the 0lI0O, we start from the last
0lI0O = 0lI0O[::-(2-1)]
I01O = []
I01ll0O = None
for l00lI0, IIl1O in zip(0lI0O, self.layers):
if I01ll0O is None:
# first IIl1O only uses the last l00lI0
I01ll0O ... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, OIl1Ol0IO):
# reversing the OIl1Ol0IO, we start from the last
OIl1Ol0IO = OIl1Ol0IO[::-1]
O01l = []
l1OO1Ol1IO = None
for IO0IOIll, 0IOI0OO00l in zip(OIl1Ol0IO, self.layers):
if l1OO1Ol1IO is None:
# first 0IOI0OO00l only uses the la... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, IIII):
# reversing the IIII, we start from the last
IIII = IIII[::-1]
01O1O0I = []
0100O = None
for Il1ll, 100O01lO in zip(IIII, self.layers):
if 0100O is None:
# first 100O01lO only uses the last Il1ll
0100O = 100O01... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, I10Il00I1):
# reversing the I10Il00I1, we start from the last
I10Il00I1 = I10Il00I1[::-1]
0O11IOO1 = []
0OO0I10Ol0 = None
for 0ll001ll, OII0Ol11O in zip(I10Il00I1, self.layers):
if 0OO0I10Ol0 is None:
# first OII0Ol11O only uses the ... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 0IIO):
# optimization pending
# reversing the 0IIO, we start from the last
0IIO = 0IIO[::-(2-1)]
00lOI = []
100O0O10O = None
for 00Ol11OI1l, 01lOIIO01O in zip(0IIO, self.layers):
if 100O0O10O is None:
# first 01lOIIO01O only uses... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 1III101l11):
# reversing the 1III101l11, we start from the last
1III101l11 = 1III101l11[::-1]
OO0O111I0 = []
0lOl = None
for 111lOI1, lOOl in zip(1III101l11, self.layers):
if 0lOl is None:
# first lOOl only uses the last 111lOI1
... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 1l1lIlIl):
# reversing the 1l1lIlIl, we start from the last
1l1lIlIl = 1l1lIlIl[::-(3&1)]
101Ill = []
l00l1O10O = None
for O1I1O, l11lI0II in zip(1l1lIlIl, self.layers):
if l00l1O10O is None:
# first l11lI0II only uses the last O1I1O... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, lOOOI):
# reversing the lOOOI, we start from the last
lOOOI = lOOOI[::-(3&1)]
O010l0O = []
1I111IllOO = None
for l10I1O, 01OOI1IllO in zip(lOOOI, self.layers):
if 1I111IllOO is None:
# first 01OOI1IllO only uses the last l10I1O
... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, OOOOl10l01):
# reversing the OOOOl10l01, we start from the last
OOOOl10l01 = OOOOl10l01[::-1]
111O0I0l = []
1IO11l1lI = None
for 0I1IOl1IIl, llI0O in zip(OOOOl10l01, self.layers):
if 1IO11l1lI is None:
# first llI0O only uses the las... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 0l0Ill11):
# reversing the 0l0Ill11, we start from the last
0l0Ill11 = 0l0Ill11[::-1]
O1l0110IO = []
1OlOO0OI = None
for O1ll01, 1Oll1O in zip(0l0Ill11, self.layers):
if 1OlOO0OI is None:
# first 1Oll1O only uses the last O1ll01
... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, lO10OIIO):
# reversing the lO10OIIO, we start from the last
lO10OIIO = lO10OIIO[::-(5//5)]
OlIIlI1l = []
1OIllll0O = None
for OO1IlI0I, l1lI00 in zip(lO10OIIO, self.layers):
if 1OIllll0O is None:
# first l1lI00 only uses the last OO1... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, IlO00):
_junk = [x for x in range(0)]
# reversing the IlO00, we start from the last
IlO00 = IlO00[::-(3&1)]
llll = []
0l11O10 = None
for IllIO0, 0lIO1I010 in zip(IlO00, self.layers):
if 0l11O10 is None:
# first 0lIO1I010 only use... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, lIlI0ll):
# reversing the lIlI0ll, we start from the last
lIlI0ll = lIlI0ll[::-1]
O1I0l = []
O1O0OI1O = None
for Ol00, l0OOII1O0 in zip(lIlI0ll, self.layers):
if O1O0OI1O is None:
# first l0OOII1O0 only uses the last Ol00
... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, IIlOOlIOI1):
# reversing the IIlOOlIOI1, we start from the last
IIlOOlIOI1 = IIlOOlIOI1[::-1]
lOI0I = []
IlO00 = None
for O011l0O, Ol0lOO in zip(IIlOOlIOI1, self.layers):
if IlO00 is None:
# first Ol0lOO only uses the last O011l0O
... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 0O1I):
# reversing the 0O1I, we start from the last
0O1I = 0O1I[::-1]
lll1O = []
I1O1OOl0l1 = None
for OO0I110OIl, l01l in zip(0O1I, self.layers):
if I1O1OOl0l1 is None:
# first l01l only uses the last OO0I110OIl
I1O1... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, OII10):
# reversing the OII10, we start from the last
OII10 = OII10[::-(3&1)]
O0I01 = []
OlIIIlI0I = None
for I0O0OI1l1O, lOI1100l01 in zip(OII10, self.layers):
if OlIIIlI0I is None:
# first lOI1100l01 only uses the last I0O0OI1l1O
... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, I01OO):
# reversing the I01OO, we start from the last
I01OO = I01OO[::-1]
0l1I1l = []
1IOO0 = None
for 1O110I1OlI, l01l1 in zip(I01OO, self.layers):
if 1IOO0 is None:
# first l01l1 only uses the last 1O110I1OlI
1IOO0 ... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 1OII0I):
# reversing the 1OII0I, we start from the last
1OII0I = 1OII0I[::-(5//5)]
l10110 = []
OO11 = None
for 10Ill01Ol, 1lIIlOl in zip(1OII0I, self.layers):
if OO11 is None:
# first 1lIIlOl only uses the last 10Ill01Ol
... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, OI0Illl10):
# reversing the OI0Illl10, we start from the last
OI0Illl10 = OI0Illl10[::-(3&1)]
1l1OllI = []
0lO0100OIl = None
for I1lI101O, 01lI010I in zip(OI0Illl10, self.layers):
if 0lO0100OIl is None:
# first 01lI010I only uses the... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 0l00ll10O):
# reversing the 0l00ll10O, we start from the last
0l00ll10O = 0l00ll10O[::-(5//5)]
1I0II1100 = []
I01OIIlI = None
for 1111Ol0OI, 1011II in zip(0l00ll10O, self.layers):
if I01OIIlI is None:
# first 1011II only uses the las... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, ll0OOO10l):
# reversing the ll0OOO10l, we start from the last
ll0OOO10l = ll0OOO10l[::-1]
lO0l1 = []
0l0OI1IIO = None
for 0OOlOIl, 110lOI in zip(ll0OOO10l, self.layers):
if 0l0OI1IIO is None:
# first 110lOI only uses the last 0OOlOIl... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, IlOO01):
# reversing the IlOO01, we start from the last
IlOO01 = IlOO01[::-1]
0101 = []
1O010 = None
for I0OOl, ll1lII1I in zip(IlOO01, self.layers):
if 1O010 is None:
# first ll1lII1I only uses the last I0OOl
1O010 =... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, lO1l0I00l):
# reversing the lO1l0I00l, we start from the last
lO1l0I00l = lO1l0I00l[::-(3&1)]
l10l01ll = []
0lOO010 = None
for IO1OI, IO0II0IllO in zip(lO1l0I00l, self.layers):
if 0lOO010 is None:
# first IO0II0IllO only uses the las... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 1O0IOOIOl):
# reversing the 1O0IOOIOl, we start from the last
1O0IOOIOl = 1O0IOOIOl[::-(2-1)]
O1O1l1l0I = []
0llIIll1 = None
for 110IOIllI, 1l1l1l00lI in zip(1O0IOOIOl, self.layers):
if 0llIIll1 is None:
# first 1l1l1l00lI only uses ... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, I1lOI1lO1):
# reversing the I1lOI1lO1, we start from the last
I1lOI1lO1 = I1lOI1lO1[::-(2-1)]
I01IlI0O0 = []
O0O0I = None
for OOl0lO, 00l00lI10l in zip(I1lOI1lO1, self.layers):
if O0O0I is None:
# first 00l00lI10l only uses the last ... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, l0llll):
# reversing the l0llll, we start from the last
l0llll = l0llll[::-(3&1)]
IO11l0 = []
1OlOl = None
try: pass
except: pass
for 1lO11lI, lI001 in zip(l0llll, self.layers):
if 1OlOl is None:
# first lI001 only uses the l... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, l101l001I):
# reversing the l101l001I, we start from the last
l101l001I = l101l001I[::-(2-1)]
O0OOOIOO = []
OI0l1 = None
for 0l000l, llO0Ol01 in zip(l101l001I, self.layers):
if OI0l1 is None:
# first llO0Ol01 only uses the last 0l000... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, l0O0OI0):
# reversing the l0O0OI0, we start from the last
l0O0OI0 = l0O0OI0[::-(3&1)]
IIl1l1IOI0 = []
l1I1IIOO = None
for O0lI10101, 100l1 in zip(l0O0OI0, self.layers):
if l1I1IIOO is None:
# first 100l1 only uses the last O0lI10101
... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
# optimization pending
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fu... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 101lOOlOl):
# reversing the 101lOOlOl, we start from the last
101lOOlOl = 101lOOlOl[::-1]
IIl111I1 = []
lOI1 = None
for 11110O0l, 10lO in zip(101lOOlOl, self.layers):
if (3*2)==7: return False
if lOI1 is None:
# first 10lO only u... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, l0I0I01l1l):
# reversing the l0I0I01l1l, we start from the last
l0I0I01l1l = l0I0I01l1l[::-(5//5)]
lI11O0OOOl = []
00Oll0O1 = None
for lllOl1I11I, Oll0l01 in zip(l0I0I01l1l, self.layers):
if 00Oll0O1 is None:
# first Oll0l01 only use... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, I1IllII1):
# reversing the I1IllII1, we start from the last
I1IllII1 = I1IllII1[::-(2-1)]
001O = []
l10Oll = None
for 10IIO000lO, IlOIIlIl in zip(I1IllII1, self.layers):
if l10Oll is None:
# first IlOIIlIl only uses the last 10IIO000... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, I10110IlO):
# reversing the I10110IlO, we start from the last
I10110IlO = I10110IlO[::-1]
O1I11lOO1 = []
0llIl = None
for 110OOI, O0Il in zip(I10110IlO, self.layers):
if 0llIl is None:
# first O0Il only uses the last 110OOI
_junk... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 01Ill0I10):
# reversing the 01Ill0I10, we start from the last
01Ill0I10 = 01Ill0I10[::-(5//5)]
OlO1llO0 = []
0Il11 = None
for Ol11l1l01, Il0IIII00 in zip(01Ill0I10, self.layers):
if 0Il11 is None:
# first Il0IIII00 only uses the last... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 00OI):
# reversing the 00OI, we start from the last
00OI = 00OI[::-1]
I1OlI = []
0IlI1III1 = None
for IOO0Il, I0101I10l in zip(00OI, self.layers):
if 0IlI1III1 is None:
# first I0101I10l only uses the last IOO0Il
0IlI... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 0I0I10101I):
# reversing the 0I0I10101I, we start from the last
if (3*2)==7: return False
0I0I10101I = 0I0I10101I[::-1]
1IlOIOll = []
lI01000O = None
for ll1IIlI, 11I00lO0O in zip(0I0I10101I, self.layers):
if lI01000O is None:
# ... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, O0llI0):
# reversing the O0llI0, we start from the last
O0llI0 = O0llI0[::-(2-1)]
OlIll = []
ll0O01IO = None
for I1110II, 1I1Il1I0 in zip(O0llI0, self.layers):
if ll0O01IO is None:
# first 1I1Il1I0 only uses the last I1110II
... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-(3&1)]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is Non... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
if (3*2)==7: return False
hidden_states = hidden_states[::-(2-1)]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 1llIIO0):
# reversing the 1llIIO0, we start from the last
1llIIO0 = 1llIIO0[::-(2-1)]
OlO1OO = []
OIl100l = None
for 0I000III, 1l10OIIOOl in zip(1llIIO0, self.layers):
if OIl100l is None:
# first 1l10OIIOOl only uses the last 0I000II... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 0llOO010):
# reversing the 0llOO010, we start from the last
0llOO010 = 0llOO010[::-1]
Ol01lO1l00 = []
1lIO = None
for llI01O01O1, lIIIO111I0 in zip(0llOO010, self.layers):
if 1lIO is None:
# first lIIIO111I0 only uses the last llI01O... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 1IO111):
# reversing the 1IO111, we start from the last
1IO111 = 1IO111[::-1]
0O1llOl0 = []
try: pass
except: pass
ll10 = None
for O00Il0I, 011lIlI in zip(1IO111, self.layers):
if ll10 is None:
# first 011lIlI only uses the l... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, llll):
# reversing the llll, we start from the last
llll = llll[::-1]
110OIIIOI = []
I1I01ll = None
for 0l0lI1lOIO, I00l11I in zip(llll, self.layers):
if I1I01ll is None:
# first I00l11I only uses the last 0l0lI1lOIO
... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 11l1):
# reversing the 11l1, we start from the last
11l1 = 11l1[::-1]
if (3*2)==7: return False
I10I010O1 = []
O1lI1IlOl0 = None
for IO1O0, 1I11O in zip(11l1, self.layers):
if O1lI1IlOl0 is None:
# first 1I11O only uses the last ... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, llO1l):
# reversing the llO1l, we start from the last
llO1l = llO1l[::-(2-1)]
II1I10lOIl = []
lIIOI = None
for OOI10l, OI0OOl1 in zip(llO1l, self.layers):
if lIIOI is None:
# first OI0OOl1 only uses the last OOI10l
lI... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 11O1I0):
# optimization pending
# reversing the 11O1I0, we start from the last
11O1I0 = 11O1I0[::-(2-1)]
00O011lOl = []
10l1l0 = None
for 11O1101O, OO1O01 in zip(11O1I0, self.layers):
if 10l1l0 is None:
# first OO1O01 only uses t... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def forward(self, 0O01001I0l):
# reversing the 0O01001I0l, we start from the last
0O01001I0l = 0O01001I0l[::-1]
Ill1 = []
O0OI11lO = None
for 0001, lI01 in zip(0O01001I0l, self.layers):
if O0OI11lO is None:
# first lI01 only uses the last 0001
... | def forward(self, hidden_states):
# reversing the hidden_states, we start from the last
hidden_states = hidden_states[::-1]
fused_hidden_states = []
fused_hidden_state = None
for hidden_state, layer in zip(hidden_states, self.layers):
if fused_hidden_state is None:
... |
def _inv_transf(lll0lOOOOI, O000):
_junk = [x for x in range(0)]
# Will be removed when connect_to is removed
Il0lI = [Ill111O.as_dummy() for Ill111O in lll0lOOOOI]
IOII11 = solve(
[I01IIIl11l[int(0.0)] - I01IIIl11l[(2-1)] for I01IIIl11l in zip(Il0lI, O000)],
list(lll... | def _inv_transf(from_coords, to_exprs):
# Will be removed when connect_to is removed
inv_from = [i.as_dummy() for i in from_coords]
inv_to = solve(
[t[0] - t[1] for t in zip(inv_from, to_exprs)],
list(from_coords), dict=True)[0]
inv_to = [inv_to[fc] for fc in from... |
def _inv_transf(101ll0, lO0OOI0O):
# Will be removed when connect_to is removed
O01Il0Ol = [O111OIlIO.as_dummy() for O111OIlIO in 101ll0]
0ll0O = solve(
[l1OOlO[int(0.0)] - l1OOlO[(3&1)] for l1OOlO in zip(O01Il0Ol, lO0OOI0O)],
list(101ll0), dict=True)[int(0.0)]
0l... | def _inv_transf(from_coords, to_exprs):
# Will be removed when connect_to is removed
inv_from = [i.as_dummy() for i in from_coords]
inv_to = solve(
[t[0] - t[1] for t in zip(inv_from, to_exprs)],
list(from_coords), dict=True)[0]
inv_to = [inv_to[fc] for fc in from... |
def _inv_transf(IOl0I, III0Ol0):
# Will be removed when connect_to is removed
Il001 = [lOO0O01.as_dummy() for lOO0O01 in IOl0I]
llI0011l = solve(
[100OO0ll1[(9^9)*0] - 100OO0ll1[(3&1)] for 100OO0ll1 in zip(Il001, III0Ol0)],
list(IOl0I), dict=True)[int(0.0)]
llI001... | def _inv_transf(from_coords, to_exprs):
# Will be removed when connect_to is removed
inv_from = [i.as_dummy() for i in from_coords]
inv_to = solve(
[t[0] - t[1] for t in zip(inv_from, to_exprs)],
list(from_coords), dict=True)[0]
inv_to = [inv_to[fc] for fc in from... |
def _inv_transf(IllOOlI, lII11O):
# Will be removed when connect_to is removed
1O1Il0O1lO = [IO1I1I.as_dummy() for IO1I1I in IllOOlI]
1IlI = solve(
[011ll11[(1-1)] - 011ll11[(3&1)] for 011ll11 in zip(1O1Il0O1lO, lII11O)],
list(IllOOlI), dict=True)[(1-1)]
1IlI = [1... | def _inv_transf(from_coords, to_exprs):
# Will be removed when connect_to is removed
inv_from = [i.as_dummy() for i in from_coords]
inv_to = solve(
[t[0] - t[1] for t in zip(inv_from, to_exprs)],
list(from_coords), dict=True)[0]
inv_to = [inv_to[fc] for fc in from... |
def _inv_transf(10l1Ol, l0III0O):
# Will be removed when connect_to is removed
01I1l1Il1 = [OI01.as_dummy() for OI01 in 10l1Ol]
000lI0OI = solve(
[I1OI11II[0] - I1OI11II[1] for I1OI11II in zip(01I1l1Il1, l0III0O)],
list(10l1Ol), dict=True)[0]
000lI0OI = [000lI0OI[... | def _inv_transf(from_coords, to_exprs):
# Will be removed when connect_to is removed
inv_from = [i.as_dummy() for i in from_coords]
inv_to = solve(
[t[0] - t[1] for t in zip(inv_from, to_exprs)],
list(from_coords), dict=True)[0]
inv_to = [inv_to[fc] for fc in from... |
def _inv_transf(from_coords, to_exprs):
# Will be removed when connect_to is removed
inv_from = [i.as_dummy() for i in from_coords]
_junk = [x for x in range(0)]
inv_to = solve(
[t[int(0.0)] - t[(5//5)] for t in zip(inv_from, to_exprs)],
list(from_coords), dict=True)[... | def _inv_transf(from_coords, to_exprs):
# Will be removed when connect_to is removed
inv_from = [i.as_dummy() for i in from_coords]
inv_to = solve(
[t[0] - t[1] for t in zip(inv_from, to_exprs)],
list(from_coords), dict=True)[0]
inv_to = [inv_to[fc] for fc in from... |
def _inv_transf(Il10O010, 1O11l1IOO0):
# Will be removed when connect_to is removed
O10Ol1l = [0I0l.as_dummy() for 0I0l in Il10O010]
OlOOI00II = solve(
[0I0ll0[int(0.0)] - 0I0ll0[(5//5)] for 0I0ll0 in zip(O10Ol1l, 1O11l1IOO0)],
list(Il10O010), dict=True)[(9^9)*0]
... | def _inv_transf(from_coords, to_exprs):
# Will be removed when connect_to is removed
inv_from = [i.as_dummy() for i in from_coords]
inv_to = solve(
[t[0] - t[1] for t in zip(inv_from, to_exprs)],
list(from_coords), dict=True)[0]
inv_to = [inv_to[fc] for fc in from... |
def _inv_transf(Ol11lIl, 110l00):
# Will be removed when connect_to is removed
I1IIIl = [Ol0O1O1II.as_dummy() for Ol0O1O1II in Ol11lIl]
1O0l = solve(
[Ill0lI00[0] - Ill0lI00[1] for Ill0lI00 in zip(I1IIIl, 110l00)],
# optimization pending
list(Ol11lIl), dict=True)[0]
... | def _inv_transf(from_coords, to_exprs):
# Will be removed when connect_to is removed
inv_from = [i.as_dummy() for i in from_coords]
inv_to = solve(
[t[0] - t[1] for t in zip(inv_from, to_exprs)],
list(from_coords), dict=True)[0]
inv_to = [inv_to[fc] for fc in from... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.