homa 0.2.0__py3-none-any.whl → 0.2.9__py3-none-any.whl

homa-0.2.9.dist-info/RECORD

@@ -0,0 +1,113 @@
+homa/__init__.py,sha256=NBYFKizG8UASiz5HLsEBqzXNGlWr78xm4sLr5hxKvjU,46
+homa/device.py,sha256=9kKXfpYfnEk2cFQWPfcJrVloHgC_SSbP4I8IRY9TYk4,343
+homa/settings.py,sha256=CPZDPvs1380O7SY7FcSKol8kBVFVVYFgSJl3YEyJuZ0,263
+homa/utils.py,sha256=dPp6TItJwWxBqxmkMzUuCtX_BzdPT-kMOZyXRGVMCbQ,70
+homa/activations/APLU.py,sha256=cUf6LUjY8TewXe_V1avO_7IcOtY66Hd6Dyk_1K4R3Ms,1555
+homa/activations/ActivationFunction.py,sha256=XUw7Pa5E-CPG6rPL8Us_pDH7xCZqY0c2P9xtnJMyX44,141
+homa/activations/AdaptiveActivationFunction.py,sha256=p_bqAq7527UOhVm47kdUtgdC1DlApxgiLOA4ZPBFdCE,386
+homa/activations/BaseDLReLU.py,sha256=iRmDhhbFaO8N9G8u5M01s8-y-09t7poP96oA6uQkVq8,1186
+homa/activations/CaLU.py,sha256=n0drKwp4GstHql69p4S58KeVctdaQ1B5oK_AIoI_okk,331
+homa/activations/DLReLU.py,sha256=Q8l2zpR5q_tSgfgbz90uDXbXMbBT3b_7BWKw6JbtpQE,191
+homa/activations/ERF.py,sha256=tDgHbo7UNFU93XPlcQCBRRxPMksr-FOE19mlsqfzmU8,252
+homa/activations/Elliot.py,sha256=RDxERH9vFh6FYwtZXKHMDmLVG2ia1UfOoW18Gm2_8hM,298
+homa/activations/ExpExpish.py,sha256=iq_uOmmV9EIz2eKowEy7SCeW-OMgGcEeMcivTnPc-Y0,202
+homa/activations/ExponentialDLReLU.py,sha256=aVtah3c4sokB-aSdbVa5F_uq06IyXHwovnHtXlKGYlw,199
+homa/activations/ExponentialSwish.py,sha256=nJtGu1TRHa2GSQ35w2MN0HEWzFogVvA9R2pGEkFvJX4,266
+homa/activations/GCU.py,sha256=hXwty6WPovnhPGAxQDd4bIixujdoMOORN-77imVri7s,199
+homa/activations/GaLU.py,sha256=5QHnHsUsLAy28s-LTxtwRN-t1hO1tg9xtWmkzE1T7Ck,308
+homa/activations/GaussianReLU.py,sha256=ufNeVnod6dxkPLmdd9ye-xt0SIWap2dehX14_YxSZVM,2051
+homa/activations/GeneralizedSwish.py,sha256=zv6CX83cOTVnN0yoCIXIvIgkjXLnmm_T_LsvyoN7lOY,236
+homa/activations/Gish.py,sha256=Xohk5tTmeGTmQ4PXtHF5sPBDikmoNTjdEJzy2KPDmOI,249
+homa/activations/LaLU.py,sha256=UiulXzSTmnoU_Gp8qKigFoL6efonqbldUlsBBlm9mB8,356
+homa/activations/LogLogish.py,sha256=lfVRNhnDGbYYakTsUmePmr5azkzz_NQwEy6NvSSD-Do,205
+homa/activations/LogSigmoid.py,sha256=PUvr84dRRd6L-VZ_9UeWAN9lhUFr2Otj8VrAIQ3eOEM,239
+homa/activations/Logish.py,sha256=CnL-10b76C2EaDm56N4n2GYCaYJUKl_k7H82UBJI5to,257
+homa/activations/MeLU.py,sha256=f13h2AAQCwp9soR3RWbMAA4Bl38oqRdBAsdzh6Bf4k8,321
+homa/activations/MexicanReLU.py,sha256=vfDa1lWI-PgY4ztDY34aeBMaJ2rOyAYt5ifZBG0DS0c,1946
+homa/activations/MinSin.py,sha256=JzQsmuffRAGGcD40nlz2ZnOGhQMEU0JYBIeFHIC1qcE,250
+homa/activations/NReLU.py,sha256=mX4B2OXw28M8zyd6RpkaSoOCGZuB3FaksO4oFyr3YD8,314
+homa/activations/NoisyReLU.py,sha256=2YFkOS_h8EijvCugYQTfq_gQg5uNEkcypcm0iDgEHIg,134
+homa/activations/PLogish.py,sha256=ia_V0xewAS6mmX3G8JNQTxWl66ea8P3MuRLQkEPv-I8,165
+homa/activations/ParametricLogish.py,sha256=grCGG61xTDytA4iOK3kS70V9m2bYoiSmuilJV3U8vIw,360
+homa/activations/Phish.py,sha256=CLAV1fLHRAq-GxBut-_FsSYJRMlk5sOFVlcXs3G3w9c,280
+homa/activations/RReLU.py,sha256=ILpkmoWk8WatXusrPqSLu15xMWQALwRQVZjhzwmw1PM,476
+homa/activations/RandomizedSlopedReLU.py,sha256=O20XX3vRRmkERxwhLSNgue-fn0qSRoF7rlIN1LSWlyI,169
+homa/activations/SGELU.py,sha256=AaNmXRoFQ68Xsgt4sSWMZxnSCTR5OD5ZEuqxxg1mvfg,358
+homa/activations/SReLU.py,sha256=xyChK3G2HPpM7C8icQNfMzrOm142boDLY31n9yXqPtg,1472
+homa/activations/SelfArctan.py,sha256=Sq3yWGXjxdP32J-rSZ38BQ5S_XErr5H1ZyPsMF1VKfI,193
+homa/activations/ShiftedReLU.py,sha256=JVsf2F6C13PRICjnVOSVEsx9IoQ9rcM2TFn55DguZQs,229
+homa/activations/SigmoidDerivative.py,sha256=4PPT-QX4MW9ySKU4Qv9K-y--lxlqFxvKVviC2S3e6Z0,274
+homa/activations/SineReLU.py,sha256=gzYF1ZEZAFYmUuABWJf18LIer1oPAS38i_5NLcIhP-I,357
+homa/activations/SlopedReLU.py,sha256=j6YfM4msg6It-ANbpMzEaXkiHvgEdhFNFbB6NkY6KpE,421
+homa/activations/SmallGaLU.py,sha256=ERrK-g3QMZTNFDzUyiSLAovymEpV5h1x1696CN5K4Zg,289
+homa/activations/Smish.py,sha256=hsr5FS4KywsCmsuFUKP-4pKoXkJK0hhRVDleq_CFGX0,198
+homa/activations/SoftsignRReLU.py,sha256=bBSjYDLUVKxXPyaJExYXndEO3oORnP3M6NKoU-hiCCQ,564
+homa/activations/Suish.py,sha256=I459CV24NV1JlLbko4oHUOh98fxoLaM-2SH71pVMcwA,279
+homa/activations/TBSReLU.py,sha256=ZfYY_M6msDimJAOHr1HyrG1HHnWiJ7hnZ5hWjCFPecU,320
+homa/activations/TSReLU.py,sha256=gbU0Q7zhf3X6oWvKUSry6sVdRhuaxIQt8keFH3WsxV8,256
+homa/activations/TangentBipolarSigmoidReLU.py,sha256=YtrFHkFbEbx7aeIpIRc9TLCxhpveUFSgAnvTKaKLZ4E,156
+homa/activations/TangentSigmoidReLU.py,sha256=C47UK6ADWsG2ueaZe9FUt-sPBzeuBLkiNjpkDZOCYGc,146
+homa/activations/TeLU.py,sha256=qU5x0EskjQs6d5rCtbL91C6cMAm8vjDnjQNMX0LcEt8,180
+homa/activations/TripleStateSwish.py,sha256=UG5BGY29wUEJaryClB2rDM90s0jt5vMJF9Kv-5M4Rgo,507
+homa/activations/WideMeLU.py,sha256=ieJjTjnK9JJtApPFGpmTynu3G8YlyH5jw6qnhkJkStI,421
+homa/activations/__init__.py,sha256=2GHNqrOp6WoLAtFFJcSj6j4GP-W8-YAYRZGX9vZbcmU,1659
+homa/activations/learnable/AOAF.py,sha256=KYtQtpLiupdyoumqNmz0kMTgRK66sSYiuLnpbr2H7Mw,509
+homa/activations/learnable/AReLU.py,sha256=-6kQ0mDGq3p9Xlg74waMa8xsTDALCtkE6pwx7DrTDeI,610
+homa/activations/learnable/DPReLU.py,sha256=xQhYTJ0-mfRGdld950xoTh8c9O08WIY50K0FjPtVVFs,507
+homa/activations/learnable/DualLine.py,sha256=cgqyE7dVqXflT8ulCuOyKQQa09FYSj8vJkeVUEOaeIU,600
+homa/activations/learnable/FReLU.py,sha256=qQ8GjjWWGeoE6qW9tw49mZPs29app0QK1AFOuMc5ASU,413
+homa/activations/learnable/LeLeLU.py,sha256=ya2m60QRcpVlTwMejJTgMTxM3RRHF0RgNe72_EdD1-U,425
+homa/activations/learnable/PERU.py,sha256=y2OxRLIA1HTUnFyRHs0zgLhLMJhQz9Q4F6QrqBSkQ00,513
+homa/activations/learnable/PiLU.py,sha256=p5FmWGJWlZEdLGVXmiXKg0rTxCVO-qn9bQIVcyAaa8U,616
+homa/activations/learnable/ShiLU.py,sha256=35VC1pCAWMaxHKWYBeXd2DrXn1tepvQaT7a-KwoNdHY,475
+homa/activations/learnable/StarReLU.py,sha256=hrscp-A0HnIvebFPLGr86K5Uf_U--EWtpNDqdNgonA0,485
+homa/activations/learnable/__init__.py,sha256=fcfm-GHEe4AQzEz9mXrWfSLkcgWaTg91ccByx7LxfX4,264
+homa/activations/learnable/concerns/ChannelBased.py,sha256=uK6FdC9mJRWSoXinjM8r5GJCZNWWxst7NMt8P6rnhKg,1143
+homa/activations/learnable/concerns/__init__.py,sha256=CubRRYQEQMAK2-igsYKD8tcyesPOYoZYF_IlHzRZXi4,39
+homa/cli/HomaCommand.py,sha256=w-Dg6dFpoXbQx2tvWSLdND2pdhqB2cPSORyi4MfY8XY,307
+homa/cli/Commands/Command.py,sha256=DnmsEwpaxdQaLjzyYBO7qtIQTLwYzyhJS31YazA1IHg,24
+homa/cli/Commands/InitCommand.py,sha256=3whh2mWLuevXpUyRpDEMbo_KNeAIdO2aLMFnC2nz_0c,1159
+homa/cli/Commands/__init__.py,sha256=PYKkcG06R5LqLnp2x8otuimzRpL4oMbziL3xEMkCffc,66
+homa/cli/namespaces/CacheNamespace.py,sha256=QXGljzj287stzTx0y_MXnqvCgPLqd7WjSPop2WDe14E,784
+homa/cli/namespaces/MakeNamespace.py,sha256=5G6LHk3lDkXROz7uq4jYE0DyO_V7JvnhJ33IFCiqYro,590
+homa/cli/namespaces/__init__.py,sha256=zAKUGPH4wcacxfH5Qvidp-uOuHdfzhan6kvVI6eMKA8,84
+homa/ensemble/Ensemble.py,sha256=GNkXEV7Nli8lHSTQ3qTTCTeSBwST1PLZS5wxpKpeC5U,290
+homa/ensemble/__init__.py,sha256=1pk2W-NbgfDFh9WLKZVLUk2E3PTjVZ5Bap9dQEnrs9o,31
+homa/ensemble/concerns/CalculatesMetricNecessities.py,sha256=QccROg_FOp_X2T_lZDg8p1DMZhPYdO-7aEdnebRXMsY,825
+homa/ensemble/concerns/PredictsProbabilities.py,sha256=7rmI66DzE7-QGoJgZEk-9fu5YQvJW-4ZnMn_dWEEhqU,440
+homa/ensemble/concerns/ReportsClassificationMetrics.py,sha256=bg__cdCKp2U1H9qN1aOJH4BoX98oIvt8XaPDGApJhSM,395
+homa/ensemble/concerns/ReportsEnsembleAccuracy.py,sha256=AX5X3VGOm7DfdonW0N7FFgUwEr7wnsojRSVEULEii7c,380
+homa/ensemble/concerns/ReportsEnsembleF1.py,sha256=hdtdCQrWaFJNUn1KP9cAmi_q_EA4FYnpkBMlYLjzRZg,296
+homa/ensemble/concerns/ReportsEnsembleKappa.py,sha256=ZRbtrFCTD84EDql6ZL1xeWtTLFxpO5Y5tQaUlR6_0jw,300
+homa/ensemble/concerns/ReportsLogits.py,sha256=vTGuC9NR4rno3Mkbm0MhL8f7YopuCErGyjIorxamKTM,461
+homa/ensemble/concerns/ReportsSize.py,sha256=S7lo_Wu6rDnuqyAcv6AI6jspaBhcpfsirpp9RVD8c20,238
+homa/ensemble/concerns/StoresModels.py,sha256=PNoaoAOx4v8rercxXHmf7zqVIPGYM4APzIHHEb3RwT0,850
+homa/ensemble/concerns/__init__.py,sha256=X0F_b2Jsv0XpiNhYwJsl-dfPsBOdEeW53LQPE4xQD0w,479
+homa/loss/LogitNormLoss.py,sha256=LJMzRA1WoJ7aDYTV-FYGhgo8DMkcpv7e8_74qiJ4zT8,386
+homa/loss/Loss.py,sha256=COUr_idShYgAP8xKCxcaXbyUyAoJg7IOON0ARTQykmQ,21
+homa/loss/__init__.py,sha256=4mPVzme2_-M64bgBu1cANIfBFAL0voa5I71-ceMr_qk,64
+homa/torch/__init__.py,sha256=HTxCVaw1TLgpHMH8guB3hHYQ80cX6_fSEoPT_hz2Y8w,23
+homa/torch/helpers.py,sha256=CLbTCXRrroM0n4PfM-K_xFavs4dCZJEu_L7hdgb1DCI,134
+homa/vision/Classifier.py,sha256=bAypqREQVuPamnc8hpbLCwmW9Uly3T1rvrlbMxXp1eA,61
+homa/vision/Model.py,sha256=JIeVpHJwirHfsDfYYbLsu0kt7bGf4nhMQGIOagUDKw4,22
+homa/vision/Resnet.py,sha256=Uitf58bEzIKkZd-F4FTvJ8nmhoFHlzZjJTvBPXEt2Iw,513
+homa/vision/StochasticClassifier.py,sha256=6-o0TaH4iWXiPFefL7DOdLr3ZrTnjnJ9PIgQLlygN8w,497
+homa/vision/StochasticSwin.py,sha256=FggzfaVYrP4fnjAFcdMpDozwQHc7CQhl3iRw78oQh0o,425
+homa/vision/Swin.py,sha256=W3XbfUTrjaIhMH8fI_whPP6XO9fVA2R34LlGfQ1hoyo,508
+homa/vision/__init__.py,sha256=w5OkcmdU6Ik5wHIJzeV1Z2UElQtvCsUZks1Q-xViSVg,153
+homa/vision/utils.py,sha256=WB2b7eMDaf6UO3SuS7cB6IJk-9NRQesLavuzWUZRZyg,389
+homa/vision/concerns/HasLabels.py,sha256=fM6nHLeQaEaWDlV6R8NQ5hgOSiwspPxOIwj-nvYXbP0,321
+homa/vision/concerns/HasLogits.py,sha256=oStX4NCV7zwxI7Vj23M8wQSlY1xoSmAYJ_6cBNJpVCk,290
+homa/vision/concerns/HasProbabilities.py,sha256=m1_ObS2BNYO-WVCNVMiHXzC3XAsyb88_0N4BWVDwCw0,221
+homa/vision/concerns/ReportsAccuracy.py,sha256=DD0YTr5i8JMllIJTQn88Dn711yjZ2uiecaTi7WqpOEw,986
+homa/vision/concerns/ReportsMetrics.py,sha256=93Hw_JBUbwfkrJNJA1xFSQ4cqRwzbSv4nPU524PGF6I,169
+homa/vision/concerns/Trainable.py,sha256=SRCW3XpG9_DQgubyqhALlYDHwAWNzVVFjshUv1ecuEQ,988
+homa/vision/concerns/__init__.py,sha256=mrw1YvN-GpQPvMwDF00KxnFkksPKo23RWM4KRioURsg,234
+homa/vision/modules/ResnetModule.py,sha256=eFudBnILD6OmgQtcW_CQQ8aZ62NEa4HyZ15-lobTtt0,712
+homa/vision/modules/SwinModule.py,sha256=h7wq1YdKoN6-7C3FVFA0bpkAET_30002iTRbjZxziFQ,714
+homa/vision/modules/__init__.py,sha256=zVMYB9IAO_xZylC1-N3p8ymHgEkAE2sBbuVz8K5Y1kk,74
+homa-0.2.9.dist-info/METADATA,sha256=uqaBYePnoJwrTwJRFB47fx_vh073hlynKWA7JAU0hDs,1759
+homa-0.2.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+homa-0.2.9.dist-info/entry_points.txt,sha256=tJZzjs-f2QvFe3ES8Qta8IE5sAbeE8-cyZ_UtbgqG4s,51
+homa-0.2.9.dist-info/top_level.txt,sha256=tmOfy2tuaAwc3W5-i6j61_vYJsXgR4ivBWkhJ3ZtJDc,5
+homa-0.2.9.dist-info/RECORD,,

homa/activations/classes/APLU.py

@@ -1,86 +0,0 @@
-import torch
-from torch import nn
-from torch.nn.parameter import Parameter, UninitializedParameter
-import torch.nn.functional as F
-
-
-class APLU(nn.Module):
-    def __init__(self, max_input: float = 1.0):
-        super().__init__()
-        self.max_input = float(max_input)
-        self.alpha = UninitializedParameter()
-        self.beta = UninitializedParameter()
-        self.gamma = UninitializedParameter()
-        self.xi = UninitializedParameter()
-        self.psi = UninitializedParameter()
-        self.mu = UninitializedParameter()
-        self._num_channels = None
-
-    def _initialize_parameters(self, x: torch.Tensor):
-        if x.ndim < 2:
-            raise ValueError(
-                f"Input tensor must have at least 2 dimensions (N, C), but got shape {tuple(x.shape)}"
-            )
-
-        channels = int(x.shape[1])
-        self._num_channels = channels
-        param_shape = [1] * x.ndim
-        param_shape[1] = channels
-
-        with torch.no_grad():
-            self.alpha = Parameter(
-                torch.zeros(param_shape, dtype=x.dtype, device=x.device)
-            )
-            self.beta = Parameter(
-                torch.zeros(param_shape, dtype=x.dtype, device=x.device)
-            )
-            self.gamma = Parameter(
-                torch.zeros(param_shape, dtype=x.dtype, device=x.device)
-            )
-            self.xi = Parameter(
-                torch.empty(param_shape, dtype=x.dtype, device=x.device).uniform_(
-                    0.0, self.max_input
-                )
-            )
-            self.psi = Parameter(
-                torch.empty(param_shape, dtype=x.dtype, device=x.device).uniform_(
-                    0.0, self.max_input
-                )
-            )
-            self.mu = Parameter(
-                torch.empty(param_shape, dtype=x.dtype, device=x.device).uniform_(
-                    0.0, self.max_input
-                )
-            )
-
-    def reset_parameters(self):
-        if isinstance(self.alpha, UninitializedParameter):
-            return
-
-        with torch.no_grad():
-            self.alpha.zero_()
-            self.beta.zero_()
-            self.gamma.zero_()
-            self.xi.uniform_(0.0, self.max_input)
-            self.psi.uniform_(0.0, self.max_input)
-            self.mu.uniform_(0.0, self.max_input)
-
-    def forward(self, x: torch.Tensor):
-        if isinstance(self.alpha, UninitializedParameter):
-            self._initialize_parameters(x)
-
-        if x.ndim < 2:
-            raise ValueError(
-                f"Input tensor must have at least 2 dimensions (N, C), but got shape {tuple(x.shape)}"
-            )
-        if self._num_channels is not None and x.shape[1] != self._num_channels:
-            raise RuntimeError(
-                f"APLU was initialized with C={self._num_channels} but got C={x.shape[1]}. "
-                "Create a new APLU for a different channel size."
-            )
-
-        a = F.relu(x)
-        b = self.alpha * F.relu(-x + self.xi)
-        c = self.beta * F.relu(-x + self.psi)
-        d = self.gamma * F.relu(-x + self.mu)
-        return a + b + c + d

homa/activations/classes/GALU.py

@@ -1,67 +0,0 @@
-import torch
-from torch import nn
-from torch.nn.parameter import Parameter, UninitializedParameter
-import torch.nn.functional as F
-
-
-class GALU(nn.Module):
-    def __init__(self, max_input: float = 1.0):
-        super().__init__()
-        if max_input <= 0:
-            raise ValueError("max_input must be positive.")
-        self.max_input = float(max_input)
-        self.alpha: torch.Tensor = UninitializedParameter()
-        self.beta: torch.Tensor = UninitializedParameter()
-        self.gamma: torch.Tensor = UninitializedParameter()
-        self.delta: torch.Tensor = UninitializedParameter()
-
-    def _initialize_parameters(self, x: torch.Tensor):
-        if x.ndim < 2:
-            raise ValueError(
-                f"Input tensor must have at least 2 dimensions (N, C), but got shape {tuple(x.shape)}"
-            )
-        param_shape = [1] * x.ndim
-        param_shape[1] = int(x.shape[1])
-        zeros = torch.zeros(param_shape, dtype=x.dtype, device=x.device)
-        with torch.no_grad():
-            for name in ("alpha", "beta", "gamma", "delta"):
-                setattr(self, name, Parameter(zeros.clone()))
-
-    def reset_parameters(self):
-        for name in ("alpha", "beta", "gamma", "delta"):
-            p = getattr(self, name)
-            if not isinstance(p, UninitializedParameter):
-                with torch.no_grad():
-                    p.zero_()
-
-    def forward(self, x: torch.Tensor):
-        if isinstance(self.alpha, UninitializedParameter):
-            self._initialize_parameters(x)
-
-        if x.ndim < 2:
-            raise ValueError(
-                f"Input tensor must have at least 2 dimensions (N, C), but got shape {tuple(x.shape)}"
-            )
-        if not isinstance(self.alpha, UninitializedParameter) and x.shape[1] != self.alpha.shape[1]:
-            raise RuntimeError(
-                f"GALU was initialized with C={self.alpha.shape[1]} but got C={x.shape[1]}. "
-                "Create a new GALU for a different channel size."
-            )
-
-        x_norm = x / self.max_input
-        zero = x.new_zeros(1)
-        part_prelu = F.relu(x_norm) + self.alpha * torch.minimum(x_norm, zero)
-        part_beta = self.beta * (
-            F.relu(1.0 - torch.abs(x_norm - 1.0))
-            + torch.minimum(torch.abs(x_norm - 3.0) - 1.0, zero)
-        )
-        part_gamma = self.gamma * (
-            F.relu(0.5 - torch.abs(x_norm - 0.5))
-            + torch.minimum(torch.abs(x_norm - 1.5) - 0.5, zero)
-        )
-        part_delta = self.delta * (
-            F.relu(0.5 - torch.abs(x_norm - 2.5))
-            + torch.minimum(torch.abs(x_norm - 3.5) - 0.5, zero)
-        )
-        z = part_prelu + part_beta + part_gamma + part_delta
-        return z * self.max_input

homa/activations/classes/MELU.py

@@ -1,70 +0,0 @@
-import torch
-from torch import nn
-import torch.nn.functional as F
-
-
-class MELU(nn.Module):
-    def __init__(self, maxInput: float = 1.0):
-        super().__init__()
-        self.maxInput = float(maxInput)
-        self._num_channels = None
-        self.register_parameter("alpha", None)
-        self.register_parameter("beta", None)
-        self.register_parameter("gamma", None)
-        self.register_parameter("delta", None)
-        self.register_parameter("xi", None)
-        self.register_parameter("psi", None)
-
-    def _ensure_parameters(self, x: torch.Tensor):
-        if x.dim() != 4:
-            raise ValueError(
-                f"Expected 4D input (N, C, H, W), got {x.dim()}D with shape {tuple(x.shape)}"
-            )
-        c = int(x.shape[1])
-        if self._num_channels is None:
-            self._num_channels = c
-        elif c != self._num_channels:
-            raise RuntimeError(
-                f"MELU was initialized with C={self._num_channels} but got C={c}. "
-                "Create a new MELU for a different channel size."
-            )
-
-        if self.alpha is None:
-            shape = (1, c, 1, 1)
-            device, dtype = x.device, x.dtype
-            for name in ("alpha", "beta", "gamma", "delta", "xi", "psi"):
-                setattr(
-                    self,
-                    name,
-                    nn.Parameter(torch.zeros(shape, dtype=dtype, device=device)),
-                )
-
-    def reset_parameters(self):
-        for p in (self.alpha, self.beta, self.gamma, self.delta, self.xi, self.psi):
-            if p is not None:
-                with torch.no_grad():
-                    p.zero_()
-
-    def forward(self, X: torch.Tensor) -> torch.Tensor:
-        self._ensure_parameters(X)
-
-        X_norm = X / self.maxInput
-        Y = torch.roll(X_norm, shifts=-1, dims=1)
-
-        term1 = F.relu(X_norm)
-        term2 = self.alpha * torch.clamp(X_norm, max=0)
-
-        dist_sq_beta = (X_norm - 2) ** 2 + (Y - 2) ** 2
-        dist_sq_gamma = (X_norm - 1) ** 2 + (Y - 1) ** 2
-        dist_sq_delta = (X_norm - 1) ** 2 + (Y - 3) ** 2
-        dist_sq_xi = (X_norm - 3) ** 2 + (Y - 1) ** 2
-        dist_sq_psi = (X_norm - 3) ** 2 + (Y - 3) ** 2
-
-        term3 = self.beta * torch.sqrt(F.relu(2 - dist_sq_beta))
-        term4 = self.gamma * torch.sqrt(F.relu(1 - dist_sq_gamma))
-        term5 = self.delta * torch.sqrt(F.relu(1 - dist_sq_delta))
-        term6 = self.xi * torch.sqrt(F.relu(1 - dist_sq_xi))
-        term7 = self.psi * torch.sqrt(F.relu(1 - dist_sq_psi))
-
-        Z_norm = term1 + term2 + term3 + term4 + term5 + term6 + term7
-        return Z_norm * self.maxInput

homa/activations/classes/PDELU.py

@@ -1,54 +0,0 @@
-import torch
-from torch import nn
-import torch.nn.functional as F
-
-
-class PDELU(nn.Module):
-    def __init__(self, theta: float = 0.5):
-        super().__init__()
-        if theta == 1.0:
-            raise ValueError(
-                "theta cannot be 1.0, as it would cause a division by zero."
-            )
-        self.theta = float(theta)
-        self._power_val = 1.0 / (1.0 - self.theta)
-        self.register_parameter("alpha", None)
-        self._num_channels = None
-
-    def _ensure_parameters(self, x: torch.Tensor):
-        if x.ndim < 2:
-            raise ValueError(
-                f"Input tensor must have at least 2 dimensions (N, C), but got shape {tuple(x.shape)}"
-            )
-
-        c = int(x.shape[1])
-        if self._num_channels is None:
-            self._num_channels = c
-        elif c != self._num_channels:
-            raise RuntimeError(
-                f"PDELU was initialized with C={self._num_channels} but got C={c}. "
-                "Create a new PDELU for a different channel size."
-            )
-
-        if self.alpha is None:
-            param_shape = [1] * x.ndim
-            param_shape[1] = c
-            self.alpha = nn.Parameter(
-                torch.full(param_shape, 0.1, dtype=x.dtype, device=x.device)
-            )
-
-    def reset_parameters(self):
-        if self.alpha is not None:
-            with torch.no_grad():
-                self.alpha.fill_(0.1)
-
-    def forward(self, x: torch.Tensor):
-        self._ensure_parameters(x)
-
-        positive_part = F.relu(x)
-        inner_term = F.relu(1.0 + (1.0 - self.theta) * x)
-        powered_term = torch.pow(inner_term, self._power_val)
-        subtracted_term = powered_term - 1.0
-        zero = torch.zeros(1, dtype=x.dtype, device=x.device)
-        negative_part = self.alpha * torch.minimum(subtracted_term, zero)
-        return positive_part + negative_part

homa/activations/classes/SReLU.py

@@ -1,69 +0,0 @@
-import torch
-from torch import nn
-
-
-class SReLU(nn.Module):
-    def __init__(
-        self,
-        alpha_init: float = 0.0,
-        beta_init: float = 0.0,
-        gamma_init: float = 1.0,
-        delta_init: float = 1.0,
-    ):
-        super().__init__()
-        self.alpha_init_val = float(alpha_init)
-        self.beta_init_val = float(beta_init)
-        self.gamma_init_val = float(gamma_init)
-        self.delta_init_val = float(delta_init)
-        self._num_channels = None
-        self.register_parameter("alpha", None)
-        self.register_parameter("beta", None)
-        self.register_parameter("gamma", None)
-        self.register_parameter("delta", None)
-
-    def _ensure_parameters(self, x: torch.Tensor):
-        if x.dim() != 4:
-            raise ValueError(
-                f"Expected 4D input (N, C, H, W), got {x.dim()}D with shape {tuple(x.shape)}"
-            )
-        c = int(x.shape[1])
-        if self._num_channels is None:
-            self._num_channels = c
-        elif c != self._num_channels:
-            raise RuntimeError(
-                f"SReLU was initialized with C={self._num_channels} but got C={c}. "
-                "Create a new SReLU for different channel sizes."
-            )
-
-        if self.alpha is None:
-            shape = (1, c, 1, 1)
-            device, dtype = x.device, x.dtype
-            self.alpha = nn.Parameter(
-                torch.full(shape, self.alpha_init_val, dtype=dtype, device=device)
-            )
-            self.beta = nn.Parameter(
-                torch.full(shape, self.beta_init_val, dtype=dtype, device=device)
-            )
-            self.gamma = nn.Parameter(
-                torch.full(shape, self.gamma_init_val, dtype=dtype, device=device)
-            )
-            self.delta = nn.Parameter(
-                torch.full(shape, self.delta_init_val, dtype=dtype, device=device)
-            )
-
-    def reset_parameters(self):
-        if self.alpha is not None:
-            with torch.no_grad():
-                self.alpha.fill_(self.alpha_init_val)
-                self.beta.fill_(self.beta_init_val)
-                self.gamma.fill_(self.gamma_init_val)
-                self.delta.fill_(self.delta_init_val)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        self._ensure_parameters(x)
-
-        start = self.beta + self.alpha * (x - self.beta)
-        finish = self.delta + self.gamma * (x - self.delta)
-        out = torch.where(x < self.beta, start, x)
-        out = torch.where(x > self.delta, finish, out)
-        return out

homa/activations/classes/SmallGALU.py

@@ -1,58 +0,0 @@
-import torch
-from torch import nn
-from torch.nn.parameter import Parameter
-import torch.nn.functional as F
-
-
-class SmallGALU(nn.Module):
-    def __init__(self, max_input: float = 1.0):
-        super().__init__()
-        if max_input <= 0:
-            raise ValueError("max_input must be positive.")
-        self.max_input = float(max_input)
-        self.register_parameter("alpha", None)
-        self.register_parameter("beta", None)
-        self._num_channels = None
-
-    def _initialize_parameters(self, x: torch.Tensor):
-        if x.ndim < 2:
-            raise ValueError(
-                f"Input tensor must have at least 2 dimensions (N, C), but got shape {tuple(x.shape)}"
-            )
-        self._num_channels = int(x.shape[1])
-        param_shape = [1] * x.ndim
-        param_shape[1] = self._num_channels
-        device = x.device
-        dtype = x.dtype
-        self.alpha = Parameter(torch.zeros(param_shape, dtype=dtype, device=device))
-        self.beta = Parameter(torch.zeros(param_shape, dtype=dtype, device=device))
-
-    def reset_parameters(self):
-        if self.alpha is not None:
-            with torch.no_grad():
-                self.alpha.zero_()
-                self.beta.zero_()
-
-    def forward(self, x: torch.Tensor):
-        if self.alpha is None:
-            self._initialize_parameters(x)
-        else:
-            if x.ndim < 2:
-                raise ValueError(
-                    f"Input tensor must have at least 2 dimensions (N, C), but got shape {tuple(x.shape)}"
-                )
-            if x.shape[1] != self._num_channels:
-                raise RuntimeError(
-                    f"SmallGALU was initialized with C={self._num_channels} but got C={x.shape[1]}. "
-                    "Create a new SmallGALU for a different channel size."
-                )
-
-        x_norm = x / self.max_input
-        zero = torch.zeros(1, dtype=x.dtype, device=x.device)
-        part_prelu = F.relu(x_norm) + self.alpha * torch.minimum(x_norm, zero)
-        part_beta = self.beta * (
-            F.relu(1.0 - torch.abs(x_norm - 1.0))
-            + torch.minimum(torch.abs(x_norm - 3.0) - 1.0, zero)
-        )
-        z = part_prelu + part_beta
-        return z * self.max_input

homa/activations/classes/WideMELU.py

@@ -1,90 +0,0 @@
-import torch
-from torch import nn
-import torch.nn.functional as F
-
-
-class WideMELU(nn.Module):
-    def __init__(self, maxInput: float = 1.0):
-        super().__init__()
-        self.maxInput = float(maxInput)
-        self._num_channels = None
-        self.register_parameter("alpha", None)
-        self.register_parameter("beta", None)
-        self.register_parameter("gamma", None)
-        self.register_parameter("delta", None)
-        self.register_parameter("xi", None)
-        self.register_parameter("psi", None)
-        self.register_parameter("theta", None)
-        self.register_parameter("lam", None)
-
-    def _ensure_parameters(self, x: torch.Tensor):
-        if x.dim() != 4:
-            raise ValueError(
-                f"Expected 4D input (N, C, H, W), got {x.dim()}D with shape {tuple(x.shape)}"
-            )
-
-        c = int(x.shape[1])
-        if self._num_channels is None:
-            self._num_channels = c
-        elif c != self._num_channels:
-            raise RuntimeError(
-                f"WideMELU was initialized with C={self._num_channels} but got C={c}. "
-                "Create a new WideMELU for different channel sizes."
-            )
-
-        if self.alpha is None:
-            shape = (1, c, 1, 1)
-            device, dtype = x.device, x.dtype
-            for name in (
-                "alpha",
-                "beta",
-                "gamma",
-                "delta",
-                "xi",
-                "psi",
-                "theta",
-                "lam",
-            ):
-                param = nn.Parameter(torch.zeros(shape, dtype=dtype, device=device))
-                setattr(self, name, param)
-
-    def reset_parameters(self):
-        params = (
-            self.alpha,
-            self.beta,
-            self.gamma,
-            self.delta,
-            self.xi,
-            self.psi,
-            self.theta,
-            self.lam,
-        )
-        for p in params:
-            if p is not None:
-                with torch.no_grad():
-                    p.zero_()
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        self._ensure_parameters(x)
-
-        X_norm = x / self.maxInput
-        Y = torch.roll(X_norm, shifts=-1, dims=1)
-
-        term1 = F.relu(X_norm)
-        term2 = self.alpha * torch.clamp(X_norm, max=0)
-        dist_sq_beta = (X_norm - 2) ** 2 + (Y - 2) ** 2
-        dist_sq_gamma = (X_norm - 1) ** 2 + (Y - 1) ** 2
-        dist_sq_delta = (X_norm - 1) ** 2 + (Y - 3) ** 2
-        dist_sq_xi = (X_norm - 3) ** 2 + (Y - 1) ** 2
-        dist_sq_psi = (X_norm - 3) ** 2 + (Y - 3) ** 2
-        dist_sq_theta = (X_norm - 1) ** 2 + (Y - 2) ** 2
-        dist_sq_lambda = (X_norm - 3) ** 2 + (Y - 2) ** 2
-        term3 = self.beta * torch.sqrt(F.relu(2 - dist_sq_beta))
-        term4 = self.gamma * torch.sqrt(F.relu(1 - dist_sq_gamma))
-        term5 = self.delta * torch.sqrt(F.relu(1 - dist_sq_delta))
-        term6 = self.xi * torch.sqrt(F.relu(1 - dist_sq_xi))
-        term7 = self.psi * torch.sqrt(F.relu(1 - dist_sq_psi))
-        term8 = self.theta * torch.sqrt(F.relu(1 - dist_sq_theta))
-        term9 = self.lam * torch.sqrt(F.relu(1 - dist_sq_lambda))
-        Z_norm = term1 + term2 + term3 + term4 + term5 + term6 + term7 + term8 + term9
-        return Z_norm * self.maxInput

homa/activations/classes/__init__.py

@@ -1,7 +0,0 @@
-from .APLU import APLU
-from .GALU import GALU
-from .SmallGALU import SmallGALU
-from .MELU import MELU
-from .WideMELU import WideMELU
-from .PDELU import PDELU
-from .SReLU import SReLU

homa/activations/utils.py

@@ -1,27 +0,0 @@
-import torch
-
-
-def negative_part(x):
-    return torch.minimum(x, torch.zeros_like(x))
-
-
-def positive_part(x):
-    return torch.maximum(x, torch.zeros_like(x))
-
-
-def as_channel_parameters(parameter: torch.Tensor, x: torch.Tensor):
-    shape = [1] * x.dim()
-    shape[1] = -1
-    return parameter.view(*shape)
-
-
-def device_compatibility_check(model, x: torch.Tensor):
-    for p in model.parameters():
-        if p.device != x.device or p.dtype != x.dtype:
-            p.data = p.data.to(device=x.device, dtype=x.dtype)
-
-
-def phi_hat(x, a, lam):
-    term_pos = torch.maximum(lam - torch.abs(x - a), torch.zeros_like(x))
-    term_neg = torch.minimum(torch.abs(x - (a + 2 * lam)) - lam, torch.zeros_like(x))
-    return term_pos + term_neg

homa/vision/StochasticResnet.py

@@ -1,9 +0,0 @@
-import torch
-from .Resnet import Resnet
-from .StochasticClassifier import StochasticClassifier
-
-
-class StochasticResnet(Resnet, StochasticClassifier):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.replace_activations(torch.nn.ReLU)