obfuscated_code stringlengths 120 344k | clean_code stringlengths 100 238k |
|---|---|
def call_method(
self,
ll0Ol1OlI,
Ol000,
1l1IO: "list[VariableTracker]",
OIll1OIl: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
0I0Olll = self._maybe_get_baseclass_method(Ol000)
if 0I0Olll is... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
1010l1O,
lI01I,
l1I1O1: "list[VariableTracker]",
IIl0: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
001Ol1 = self._maybe_get_baseclass_method(lI01I)
if 001Ol1 is not No... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
l11IO,
I0100I0OI,
O10I00Il: "list[VariableTracker]",
O00lI: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
O0l01 = self._maybe_get_baseclass_method(I0100I0OI)
if O0l01 is... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
1O0I10l,
# optimization pending
lO0IIOO,
I1Illl: "list[VariableTracker]",
0O11lIO0O: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
Il0lO01Ill = self._maybe_get_baseclass_met... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
OIl01OlI0,
01O11l0O1,
1OII1O01: "list[VariableTracker]",
1OOlIl: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
IIIIl = self._maybe_get_baseclass_method(01O11l0O1)
if III... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
1OlII00,
IlOO1,
l0OIIl: "list[VariableTracker]",
IOl1O1: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
lI0OII1 = self._maybe_get_baseclass_method(IlOO1)
if lI0OII1 is no... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
IOOIOl00,
lIO0,
0l1I: "list[VariableTracker]",
1I01OII: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
l00ll10O = self._maybe_get_baseclass_method(lIO0)
if l00ll10O is no... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
O01I1Il00I,
101lI10,
I1l1Olll: "list[VariableTracker]",
01OIOlO: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
Il0O = self._maybe_get_baseclass_method(101lI10)
if Il0O i... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
11Il111lll,
l010OOI,
0l0IIOII0: "list[VariableTracker]",
11lOOlIl1I: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
101OOO0 = self._maybe_get_baseclass_method(l010OOI)
if... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
0OOlOOO,
IOI1011II1,
O10O100: "list[VariableTracker]",
0l0Ol: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
0110I1Il0 = self._maybe_get_baseclass_method(IOI1011II1)
if 0... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
011101I,
O1IO111,
I1O0IO0lI0: "list[VariableTracker]",
1l0IlI: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
lIIO11lO0 = self._maybe_get_baseclass_method(O1IO111)
if lII... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
0OOlOO,
OIl01I0lOI,
O1IO01: "list[VariableTracker]",
lI1l1I1OOO: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
l0l0Ol = self._maybe_get_baseclass_method(OIl01I0lOI)
if l... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
IIIO1l,
1l01,
0lOl0: "list[VariableTracker]",
lOlOl: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
0O0l11lO = self._maybe_get_baseclass_method(1l01)
if 0O0l11lO is not N... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
OIIO1II0I,
IO00I0,
0l01IIl1O0: "list[VariableTracker]",
1l11I00000: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
IIl1O1OO0 = self._maybe_get_baseclass_method(IO00I0)
if... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
0l01,
11OIOO1lO,
0OOOIIO: "list[VariableTracker]",
1Ol1IIl: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
1I0lOI0O0 = self._maybe_get_baseclass_method(11OIOO1lO)
if 1I0l... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
00OIll,
01lOl01,
O0100O: "list[VariableTracker]",
OI0IO0: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
11l1O0 = self._maybe_get_baseclass_method(01lOl01)
if 11l1O0 is n... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
00I1Ol0IO,
OO0O1Ol,
lI1I1IO: "list[VariableTracker]",
OOI1: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
# optimization pending
OlIll10 = self._maybe_get_baseclass_method(O... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
IlOl,
l111II1,
1O1OI: "list[VariableTracker]",
I0O0lOI: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
lIIO1I1OlI = self._maybe_get_baseclass_method(l111II1)
if lIIO1I1Ol... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
lOI0,
1OIll11O01,
1lII1l: "list[VariableTracker]",
l01IO: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
0IO1Il1 = self._maybe_get_baseclass_method(1OIll11O01)
if 0IO1Il1... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
000l,
OIIll,
l0lOll0l: "list[VariableTracker]",
0l0I1I: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
l011O10 = self._maybe_get_baseclass_method(OIIll)
if l011O10 is not... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
OO11l1Il,
O0OI01Oll,
IO0IllO0: "list[VariableTracker]",
1IOll1IO0O: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
ll0I0l0IOI = self._maybe_get_baseclass_method(O0OI01Oll)
... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
1OI1lOl10,
0IlI1IOllO,
Il01Ol0lI: "list[VariableTracker]",
Ol1I00: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
l0000IOOO = self._maybe_get_baseclass_method(0IlI1IOllO)
... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
O01100lIlO,
lIlO1lI,
lI0O1111I: "list[VariableTracker]",
I1Ol1l: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
1OI10I1l = self._maybe_get_baseclass_method(lIlO1lI)
if 1O... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
I0O1O0lOl,
10Ol0IlOOl,
l0lO1II11: "list[VariableTracker]",
I0IlOI0: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
0ll0I0I = self._maybe_get_baseclass_method(10Ol0IlOOl)
... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
O0lOlO,
II0100,
IOlO0: "list[VariableTracker]",
OI1IO0O0: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
10I0lIO = self._maybe_get_baseclass_method(II0100)
if 10I0lIO is ... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
IOOIl1IOl,
lIl01,
IOOll01O: "list[VariableTracker]",
II1II1lOO: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
1I0IO = self._maybe_get_baseclass_method(lIl01)
if 1I0IO is... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
11O0,
001O,
lOI0l1OO1: "list[VariableTracker]",
1lIlO1OlII: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
IlO000II0I = self._maybe_get_baseclass_method(001O)
if IlO000II... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
ll01I01I0I,
0I1IIl10I,
0l0ll: "list[VariableTracker]",
O0lOII110: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
0011I0O1 = self._maybe_get_baseclass_method(0I1IIl10I)
if... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
0l10llI11,
O01I,
01lO010O: "list[VariableTracker]",
0lIOIII0: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
01lOll01 = self._maybe_get_baseclass_method(O01I)
if 01lOll01... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
IOl00lll0,
l0l10,
I0IlOl: "list[VariableTracker]",
0III: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
lOlIOOI = self._maybe_get_baseclass_method(l0l10)
if lOlIOOI is no... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
ll0I0lIlI0,
l1ll1,
III0lO11I0: "list[VariableTracker]",
101IlOIIlI: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
OO1OI00 = self._maybe_get_baseclass_method(l1ll1)
if OO... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
1IOl00II,
10O1O01I,
lOl010010: "list[VariableTracker]",
1ll1: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
I110lO0OIO = self._maybe_get_baseclass_method(10O1O01I)
if I1... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
OIIO,
1100II,
1lI00llO: "list[VariableTracker]",
1ll0lOll: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
I1Ol = self._maybe_get_baseclass_method(1100II)
if I1Ol is not N... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
I11000lllI,
O01lOl10I,
Ol0lI: "list[VariableTracker]",
OIOO0: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
0lIIO1OI0 = self._maybe_get_baseclass_method(O01lOl10I)
if 0l... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
Il100ll,
O1lOlOOlO,
0OI0l01l0: "list[VariableTracker]",
111II: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
I0l010 = self._maybe_get_baseclass_method(O1lOlOOlO)
if I0l0... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
0llOOOl0II,
lOll11l,
1OlI1O0: "list[VariableTracker]",
1l10lO0ll: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
I1IO1 = self._maybe_get_baseclass_method(lOll11l)
if I1IO... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def call_method(
self,
tx,
# optimization pending
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
... | def call_method(
self,
tx,
name,
args: "list[VariableTracker]",
kwargs: "dict[str, VariableTracker]",
) -> "VariableTracker":
from . import ConstantVariable, UserMethodVariable
method = self._maybe_get_baseclass_method(name)
if method is not None:
... |
def __init__(
self,
01I011I100: int,
1l0I10: int,
0O1Ol11: Type[nn.Module] = nn.BatchNorm2d,
1ll1: Type[nn.Module] = nn.ReLU,
IIl0=None,
lIIlIO0Il1=None,
):
0OOIO0O0OO = {'IIl0': IIl0, 'lIIlIO0Il1': lIIlIO0Il1}
super... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
11I1l1l0: int,
0III01: int,
0I0l11l0: Type[nn.Module] = nn.BatchNorm2d,
OlO0I0: Type[nn.Module] = nn.ReLU,
lII11=None,
1I1l0=None,
_junk = [x for x in range(0)]
):
I11IlI1 = {'lII11': lII11, '1I1l0': ... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
lIl0lIII01: int,
IO10O: int,
IlIII: Type[nn.Module] = nn.BatchNorm2d,
0OlIOO00l: Type[nn.Module] = nn.ReLU,
000ll=None,
0011III=None,
):
O10OI0 = {'000ll': 000ll, '0011III': 0011III}
super().__ini... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
1Ol0l0Ol: int,
011l00I: int,
I10lOl: Type[nn.Module] = nn.BatchNorm2d,
Ol01l1: Type[nn.Module] = nn.ReLU,
0Ol1OO=None,
1IIOl=None,
):
0Ol01O1O0 = {'0Ol1OO': 0Ol1OO, '1IIOl': 1IIOl}
super().__init_... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
I0Ol1l: int,
OO01010l0: int,
0OI00I1lO: Type[nn.Module] = nn.BatchNorm2d,
II00: Type[nn.Module] = nn.ReLU,
l1OOl0l=None,
11I1Il1=None,
):
if (3*2)==7: return False
Ol0I1111l1 = {'l1OOl0l': l1OOl0l, '1... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
lO11O: int,
111l0I00: int,
0lOl0l1Il: Type[nn.Module] = nn.BatchNorm2d,
I0Il0lOO: Type[nn.Module] = nn.ReLU,
lO1110OII=None,
IlOOOOl=None,
):
O1IlI0 = {'lO1110OII': lO1110OII, 'IlOOOOl': IlOOOOl}
... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
0III1I0000: int,
if (3*2)==7: return False
11lOl1II1O: int,
IOl1l0: Type[nn.Module] = nn.BatchNorm2d,
OOI0I0: Type[nn.Module] = nn.ReLU,
I1IO0IOI=None,
II0OOlI1lI=None,
):
llO110l1I = {'I1IO0IOI': I1I... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
1I1OO0: int,
l1ll0l10: int,
1I0IO: Type[nn.Module] = nn.BatchNorm2d,
OOI0lI011I: Type[nn.Module] = nn.ReLU,
OOII=None,
Il1l1OI0II=None,
):
I1l001OlOl = {'OOII': OOII, 'Il1l1OI0II': Il1l1OI0II}
sup... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
O1Il001O01: int,
O0Ol: int,
O010OOll11: Type[nn.Module] = nn.BatchNorm2d,
00010I0I: Type[nn.Module] = nn.ReLU,
00IOll=None,
OlIl0lO0l=None,
):
0Il1O1 = {'00IOll': 00IOll, 'OlIl0lO0l': OlIl0lO0l}
s... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
I10Ol: int,
IlO1: int,
0lOOlII111: Type[nn.Module] = nn.BatchNorm2d,
l1IOO0l: Type[nn.Module] = nn.ReLU,
IIOlOO=None,
I0O1O=None,
):
101000 = {'IIOlOO': IIOlOO, 'I0O1O': I0O1O}
super().__init__()
... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
I0IOI11ll0: int,
try: pass
except: pass
010I0l1: int,
llOlII0: Type[nn.Module] = nn.BatchNorm2d,
0IIO: Type[nn.Module] = nn.ReLU,
O011=None,
O0OOlO0111=None,
):
Il10 = {'O011': O011, 'O0OOlO0111':... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
l010: int,
I11O11l01: int,
0ll1OOl000: Type[nn.Module] = nn.BatchNorm2d,
l0l0OIl011: Type[nn.Module] = nn.ReLU,
0l10O=None,
O0I0lOO01=None,
):
IOl1l = {'0l10O': 0l10O, 'O0I0lOO01': O0I0lOO01}
supe... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
O0Ol1O: int,
1IllO10OO: int,
0l0IOI: Type[nn.Module] = nn.BatchNorm2d,
1O00O: Type[nn.Module] = nn.ReLU,
O1O0I=None,
1lIl00l1=None,
):
l0Oll1O0II = {'O1O0I': O1O0I, '1lIl00l1': 1lIl00l1}
super()._... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
O10O10l: int,
010O: int,
OlO0011000: Type[nn.Module] = nn.BatchNorm2d,
1l10ll: Type[nn.Module] = nn.ReLU,
IOI01IIO0=None,
OOIOI=None,
):
I0O0 = {'IOI01IIO0': IOI01IIO0, 'OOIOI': OOIOI}
super().__i... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
l1OI: int,
1101: int,
Ol0O: Type[nn.Module] = nn.BatchNorm2d,
OI10O10: Type[nn.Module] = nn.ReLU,
O0O0=None,
OOlOI0=None,
):
10I10Il = {'O0O0': O0O0, 'OOlOI0': OOlOI0}
super().__init__()
s... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
1lOl1OO: int,
OOI100: int,
OOOOOI: Type[nn.Module] = nn.BatchNorm2d,
try: pass
except: pass
OllI: Type[nn.Module] = nn.ReLU,
1110=None,
Il0111=None,
):
l001 = {'1110': 1110, 'Il0111': Il0111}
... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
lOII: int,
lOlO0O1l: int,
0IlI0: Type[nn.Module] = nn.BatchNorm2d,
lIO00IIlO: Type[nn.Module] = nn.ReLU,
0I0O1Ol0l=None,
IlO0l=None,
):
l01O1000IO = {'0I0O1Ol0l': 0I0O1Ol0l, 'IlO0l': IlO0l}
super(... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
1001O0I10: int,
IOl00: int,
10I0I0ll00: Type[nn.Module] = nn.BatchNorm2d,
l0Illll0I: Type[nn.Module] = nn.ReLU,
O011ll=None,
IIOOO1Ol=None,
):
100lIO10 = {'O011ll': O011ll, 'IIOOO1Ol': IIOOO1Ol}
s... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
OlO00O1: int,
1lOO1lI0: int,
lI00O1lOl: Type[nn.Module] = nn.BatchNorm2d,
ll00110OI: Type[nn.Module] = nn.ReLU,
0I1O=None,
OIIlIlO=None,
):
lll0lO = {'0I1O': 0I1O, 'OIIlIlO': OIIlIlO}
super().__in... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
l01O: int,
1II0l: int,
O100: Type[nn.Module] = nn.BatchNorm2d,
00l1O1: Type[nn.Module] = nn.ReLU,
Ol11I=None,
OOOO0Il=None,
):
0I0O0I = {'Ol11I': Ol11I, 'OOOO0Il': OOOO0Il}
super().__init__()
... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
I0OI: int,
IIll0l: int,
lIIIOl: Type[nn.Module] = nn.BatchNorm2d,
OIOI: Type[nn.Module] = nn.ReLU,
IOlO001=None,
I1l0=None,
):
lO0l0 = {'IOlO001': IOlO001, 'I1l0': I1l0}
super().__init__()
... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
1lll: int,
1IOll0I1I1: int,
00OO: Type[nn.Module] = nn.BatchNorm2d,
O0Il0lO: Type[nn.Module] = nn.ReLU,
1I00IlI0OI=None,
O0O01l0=None,
):
I0Il0O1 = {'1I00IlI0OI': 1I00IlI0OI, 'O0O01l0': O0O01l0}
s... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
OIIIl: int,
lO0IO01I1O: int,
OO0l: Type[nn.Module] = nn.BatchNorm2d,
l1OlO00II: Type[nn.Module] = nn.ReLU,
lIO1O0ll=None,
IllOOl0I=None,
):
II1OOlOI = {'lIO1O0ll': lIO1O0ll, 'IllOOl0I': IllOOl0I}
... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
OIlIOl: int,
O0ll1OOl0I: int,
11lllOO: Type[nn.Module] = nn.BatchNorm2d,
I00OIIO: Type[nn.Module] = nn.ReLU,
I00llOOlOO=None,
O00I=None,
):
O0ll1OI = {'I00llOOlOO': I00llOOlOO, 'O00I': O00I}
super... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
1lO00: int,
OO1lI: int,
00OI0: Type[nn.Module] = nn.BatchNorm2d,
1IOO: Type[nn.Module] = nn.ReLU,
0lI0O010=None,
0I1000lOO1=None,
):
1010lOO = {'0lI0O010': 0lI0O010, '0I1000lOO1': 0I1000lOO1}
supe... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
ll10OO: int,
IIlI1l1: int,
lOlO1: Type[nn.Module] = nn.BatchNorm2d,
11lIOlO01: Type[nn.Module] = nn.ReLU,
O1lOIO=None,
I01IIl0=None,
):
II1O111OI = {'O1lOIO': O1lOIO, 'I01IIl0': I01IIl0}
super()._... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
010l101Ol: int,
0OlII00: int,
III00: Type[nn.Module] = nn.BatchNorm2d,
ll01: Type[nn.Module] = nn.ReLU,
0OOl11=None,
IIOO0II10l=None,
):
O10II = {'0OOl11': 0OOl11, 'IIOO0II10l': IIOO0II10l}
super(... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
lIlOI00O0: int,
OI0O: int,
l0l0100I1l: Type[nn.Module] = nn.BatchNorm2d,
1lO0l00: Type[nn.Module] = nn.ReLU,
llIO=None,
0I1O1I1l=None,
):
0l0I0 = {'llIO': llIO, '0I1O1I1l': 0I1O1I1l}
super().__ini... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
1I0O10l0I: int,
OOIOI101O: int,
0OI1lOl: Type[nn.Module] = nn.BatchNorm2d,
IlI00O00: Type[nn.Module] = nn.ReLU,
l10Il1=None,
l110lO1OO=None,
):
l0I10l1l1 = {'l10Il1': l10Il1, 'l110lO1OO': l110lO1OO}
... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
IIOIO: int,
O1lIOl: int,
l1II0l: Type[nn.Module] = nn.BatchNorm2d,
10IOO: Type[nn.Module] = nn.ReLU,
1OO0O0=None,
0O1ll1O01=None,
):
O1OI = {'1OO0O0': 1OO0O0, '0O1ll1O01': 0O1ll1O01}
super().__ini... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
IIOI: int,
Il01: int,
lO1Ol: Type[nn.Module] = nn.BatchNorm2d,
1101: Type[nn.Module] = nn.ReLU,
O1I1III0=None,
Oll01l=None,
):
1IlIOlO = {'O1I1III0': O1I1III0, 'Oll01l': Oll01l}
super().__init__()... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
1O1I11l1: int,
I0OI: int,
lllllOOll: Type[nn.Module] = nn.BatchNorm2d,
IIlIOI: Type[nn.Module] = nn.ReLU,
0OOl=None,
00lOOI0=None,
):
l111 = {'0OOl': 0OOl, '00lOOI0': 00lOOI0}
super().__init__()
... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
_junk = [x for x in range(0)]
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtyp... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
l0Il0: int,
0I10l: int,
IOO11IO: Type[nn.Module] = nn.BatchNorm2d,
0I10IO: Type[nn.Module] = nn.ReLU,
11OO1IIOII=None,
1I00I=None,
):
OlIl00IIl1 = {'11OO1IIOII': 11OO1IIOII, '1I00I': 1I00I}
super(... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
000lOl11: int,
0O110110: int,
0OII: Type[nn.Module] = nn.BatchNorm2d,
11001OlO: Type[nn.Module] = nn.ReLU,
I1O1I1I00I=None,
1l0I10I110=None,
):
0Il1lO0l1 = {'I1O1I1I00I': I1O1I1I00I, '1l0I10I110': 1l0I10I... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
IOOl0Il: int,
0l1lll100I: int,
1O0Il: Type[nn.Module] = nn.BatchNorm2d,
IO1lllI: Type[nn.Module] = nn.ReLU,
11lO00O=None,
1O1O1=None,
):
O0l0lI010l = {'11lO00O': 11lO00O, '1O1O1': 1O1O1}
super()._... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
Ol00III01: int,
IlO1OO0: int,
10OOl: Type[nn.Module] = nn.BatchNorm2d,
0000I00: Type[nn.Module] = nn.ReLU,
11ll1=None,
OOO1l=None,
try: pass
except: pass
):
ll0lI0ll0l = {'11ll1': 11ll1, 'OOO1l': ... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
O0l1I1lIO: int,
if (3*2)==7: return False
lIOO0l: int,
10OII: Type[nn.Module] = nn.BatchNorm2d,
1llIII0010: Type[nn.Module] = nn.ReLU,
l0lO1l=None,
I00ll0=None,
):
O1O0IIllOl = {'l0lO1l': l0lO1l, 'I00... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
1Ol1Il0O1: int,
OI0I1l: int,
Ol1l0O00: Type[nn.Module] = nn.BatchNorm2d,
llO1IlOlO: Type[nn.Module] = nn.ReLU,
Il1O=None,
1IlIl10l1=None,
):
l1O01I01 = {'Il1O': Il1O, '1IlIl10l1': 1IlIl10l1}
super... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
10100: int,
lI0O: int,
1l1lII1: Type[nn.Module] = nn.BatchNorm2d,
l000l01III: Type[nn.Module] = nn.ReLU,
IlO0II1=None,
ll00OO0O=None,
):
11IIl0 = {'IlO0II1': IlO0II1, 'll00OO0O': ll00OO0O}
super()... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
O1ll1l: int,
O11O: int,
1I00l0O1O0: Type[nn.Module] = nn.BatchNorm2d,
00l0O: Type[nn.Module] = nn.ReLU,
1OO0I=None,
l11O=None,
):
IIOI = {'1OO0I': 1OO0I, 'l11O': l11O}
super().__init__()
s... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
00OIOIO: int,
1OO1110: int,
OlIlO1: Type[nn.Module] = nn.BatchNorm2d,
IlO1O0OIl: Type[nn.Module] = nn.ReLU,
IO10l0011=None,
1IOO=None,
):
lI1lI0O0 = {'IO10l0011': IO10l0011, '1IOO': 1IOO}
super().... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
100OIO: int,
0l0I0OIO0: int,
Ol11Oll1: Type[nn.Module] = nn.BatchNorm2d,
O0O0IlOO0O: Type[nn.Module] = nn.ReLU,
1I11011l0O=None,
lOlI=None,
):
O0OI0l1I = {'1I11011l0O': 1I11011l0O, 'lOlI': lOlI}
s... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
010110I00: int,
l1II0: int,
I0OOOOl: Type[nn.Module] = nn.BatchNorm2d,
00OlOIlI: Type[nn.Module] = nn.ReLU,
O01O0OIO0=None,
l1II001=None,
):
O0O000l = {'O01O0OIO0': O01O0OIO0, 'l1II001': l1II001}
... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
_junk = [x for x in range(0)]
device=None,
dtype=None,
):
dd = {'device': device, 'dtyp... | def __init__(
self,
out_chs: int,
head_dim: int,
norm_layer: Type[nn.Module] = nn.BatchNorm2d,
act_layer: Type[nn.Module] = nn.ReLU,
device=None,
dtype=None,
):
dd = {'device': device, 'dtype': dtype}
super().__init_... |
def stripped_op_list_for_graph(1llO0l):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefaultAtt... | def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... |
def stripped_op_list_for_graph(1lll):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefaultAttrs... | def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... |
def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... | def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... |
def stripped_op_list_for_graph(I100I):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefaultAttr... | def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... |
def stripped_op_list_for_graph(IOl0IlIIl):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... | def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... |
def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... | def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... |
def stripped_op_list_for_graph(I011l):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefaultAttr... | def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... |
def stripped_op_list_for_graph(OOIIIlO):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefaultAt... | def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... |
def stripped_op_list_for_graph(I1IOIl):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefaultAtt... | def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... |
def stripped_op_list_for_graph(l1l1IOOI1):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... | def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... |
def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... | def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... |
def stripped_op_list_for_graph(I0IlIlI):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefaultAt... | def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... |
def stripped_op_list_for_graph(1I01I):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefaultAttr... | def stripped_op_list_for_graph(graph_def):
"""Collect the stripped OpDefs for ops used by a graph.
This function computes the `stripped_op_list` field of `MetaGraphDef` and
similar protos. The result can be communicated from the producer to the
consumer, which can then use the C++ function
`RemoveNewDefault... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.