kcai-data-sampling-fgsm 0.1.0__tar.gz

kcai_data_sampling_fgsm-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: kcai-data-sampling-fgsm
+Version: 0.1.0
+Summary: Adversarial perturbation (FGSM) for kcai data-sampling
+Author-email: Safenai <support@safenai.io>
+License-Expression: Apache-2.0
+Keywords: ml,data,augmentation,robustness,adversarial,fgsm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: kcai-data-sampling-core
+
+# kcai-data-sampling-fgsm
+
+The **adversarial** slot of kcai data-sampling: transformations where a model's
+*response* enters the computation and the result is graded against it. Here the
+model is a **target** — it is not asked to produce anything, only to react. That
+is what makes the family adversarial, and the declaring `model_role = "target"`
+is what tells the framework to treat it as such.
+
+This package implements the Fast Gradient Sign Method as a single budgeted step
+along the sign of the target model's gradient, and exposes it through the
+`kcai_data_sampling.transformations` entry-point group.
+
+**The target model is yours.** It arrives at run time through the `models:`
+section of your configuration and is never shipped by this package.
+
+## What it ships today
+
+- `fgsm` — one method: one L-infinity step of budget `epsilon` along the sign of
+  the target's gradient.
+
+One method, as an example of the slot rather than a catalogue.
+
+## Install
+
+```bash
+pip install "kcai-data-sampling[fgsm]"
+```
+
+**No deep-learning framework is required.** This package depends only on the
+core contracts — the gradient arrives from *your* model, so the work is yours
+too, and nothing here pulls torch. A configuration driving `fgsm` may well need
+torch in the environment that hosts the target model; that is a property of the
+model you bring, not of this package.
+
+## How the step works
+
+The batch is normalized to `[0, 1]` pixel units, the target's gradient is taken
+in the same units, and `epsilon * sign(grad)` is added — so only the *sign* of
+the gradient participates, not its magnitude. The result is clipped back into
+range and restored to the batch's dtype.
+
+Three declarations follow from that, and the framework enforces each:
+
+- **`clips = True`** — a signed step can push a pixel past the selection's value
+  range, so the output is clipped back rather than refused.
+- **`reversible = False`** — the step is lossy. The original pixels are not
+  recoverable from the output, so the row records that it is not invertible.
+- **Deterministic** — no randomness is drawn, so the recorded seed is `None`.
+  The same input and the same `epsilon` always give the same output.
+
+`epsilon` is the adversarial budget, strictly positive, and sweepable, so a run
+can walk a whole budget curve.
+
+## Labels do not move
+
+An attack moves the model's *prediction*, not the truth. The ground-truth label
+belongs to the source row, travels with it, and is never touched here — this
+package has no notion of a label at all, only of pixels.
+
+That is what makes an adversarial sample meaningful: if the label had moved
+along with the pixels, the pair would prove nothing. A label that changed under
+perturbation, or a target model whose response was ignored, would both mean the
+measurement was not an attack at all.
+
+## Example
+
+The `models` and `operations` sections of a job configuration, with a target
+model supplied as your own source:
+
+```yaml
+models:
+  yolo:
+    type: python
+    path: adapters/yolo_target.py
+    export: YoloTarget
+    weights: yolov8n.pt
+    params: { conf: 0.25 }
+operations:
+  transformations:
+    - name: fgsm
+      type: fgsm
+      target_model: yolo
+      epsilon:
+        range: [0.01, 0.05]
+        step: 0.01
+```
+
+The transformation names its model with `target_model: yolo`. Only `grad` is
+used from it, and its output is checked for shape and finiteness before the step,
+so a misbehaving adapter fails loudly rather than corrupting the batch.
+
+A target model is recognised by a non-empty `name` plus a `grad` method, and
+conformance is checked against the `target` role the transformation declares.

kcai_data_sampling_fgsm-0.1.0/README.md

@@ -0,0 +1,93 @@
+# kcai-data-sampling-fgsm
+
+The **adversarial** slot of kcai data-sampling: transformations where a model's
+*response* enters the computation and the result is graded against it. Here the
+model is a **target** — it is not asked to produce anything, only to react. That
+is what makes the family adversarial, and the declaring `model_role = "target"`
+is what tells the framework to treat it as such.
+
+This package implements the Fast Gradient Sign Method as a single budgeted step
+along the sign of the target model's gradient, and exposes it through the
+`kcai_data_sampling.transformations` entry-point group.
+
+**The target model is yours.** It arrives at run time through the `models:`
+section of your configuration and is never shipped by this package.
+
+## What it ships today
+
+- `fgsm` — one method: one L-infinity step of budget `epsilon` along the sign of
+  the target's gradient.
+
+One method, as an example of the slot rather than a catalogue.
+
+## Install
+
+```bash
+pip install "kcai-data-sampling[fgsm]"
+```
+
+**No deep-learning framework is required.** This package depends only on the
+core contracts — the gradient arrives from *your* model, so the work is yours
+too, and nothing here pulls torch. A configuration driving `fgsm` may well need
+torch in the environment that hosts the target model; that is a property of the
+model you bring, not of this package.
+
+## How the step works
+
+The batch is normalized to `[0, 1]` pixel units, the target's gradient is taken
+in the same units, and `epsilon * sign(grad)` is added — so only the *sign* of
+the gradient participates, not its magnitude. The result is clipped back into
+range and restored to the batch's dtype.
+
+Three declarations follow from that, and the framework enforces each:
+
+- **`clips = True`** — a signed step can push a pixel past the selection's value
+  range, so the output is clipped back rather than refused.
+- **`reversible = False`** — the step is lossy. The original pixels are not
+  recoverable from the output, so the row records that it is not invertible.
+- **Deterministic** — no randomness is drawn, so the recorded seed is `None`.
+  The same input and the same `epsilon` always give the same output.
+
+`epsilon` is the adversarial budget, strictly positive, and sweepable, so a run
+can walk a whole budget curve.
+
+## Labels do not move
+
+An attack moves the model's *prediction*, not the truth. The ground-truth label
+belongs to the source row, travels with it, and is never touched here — this
+package has no notion of a label at all, only of pixels.
+
+That is what makes an adversarial sample meaningful: if the label had moved
+along with the pixels, the pair would prove nothing. A label that changed under
+perturbation, or a target model whose response was ignored, would both mean the
+measurement was not an attack at all.
+
+## Example
+
+The `models` and `operations` sections of a job configuration, with a target
+model supplied as your own source:
+
+```yaml
+models:
+  yolo:
+    type: python
+    path: adapters/yolo_target.py
+    export: YoloTarget
+    weights: yolov8n.pt
+    params: { conf: 0.25 }
+operations:
+  transformations:
+    - name: fgsm
+      type: fgsm
+      target_model: yolo
+      epsilon:
+        range: [0.01, 0.05]
+        step: 0.01
+```
+
+The transformation names its model with `target_model: yolo`. Only `grad` is
+used from it, and its output is checked for shape and finiteness before the step,
+so a misbehaving adapter fails loudly rather than corrupting the batch.
+
+A target model is recognised by a non-empty `name` plus a `grad` method, and
+conformance is checked against the `target` role the transformation declares.

kcai_data_sampling_fgsm-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "kcai-data-sampling-fgsm"
+dynamic = ["dependencies", "version"]
+description = "Adversarial perturbation (FGSM) for kcai data-sampling"
+authors = [
+  {name = "Safenai", email = "support@safenai.io"},
+]
+license = "Apache-2.0"
+readme = "README.md"
+requires-python = ">=3.11"
+keywords = ["ml", "data", "augmentation", "robustness", "adversarial", "fgsm"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+
+[project.entry-points."kcai_data_sampling.transformations"]
+fgsm = "kcai_data_sampling_fgsm.api.transformations.fgsm:Fgsm"
+
+[build-system]
+requires = ["setuptools>=80", "setuptools-scm[simple]>=8"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools_scm]
+version_file = "src/kcai_data_sampling_fgsm/_version_.py"
+root = "../.."
+fallback_version = "0.0.1"
+
+[tool.setuptools.dynamic]
+dependencies = {file = ["requirements.txt"]}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+kcai_data_sampling_fgsm = ["py.typed"]

kcai_data_sampling_fgsm-0.1.0/requirements.txt

@@ -0,0 +1 @@
+kcai-data-sampling-core

kcai_data_sampling_fgsm-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm/__init__.py

@@ -0,0 +1,12 @@
+"""Adversarial perturbation with the Fast Gradient Sign Method.
+
+Ships the ``fgsm`` transformation (``model_role = "target"``): a budgeted
+sign-direction step along the gradient of the user's target model, expressed in
+normalized pixel units. The transformation class lives under
+``api/transformations/``, the pure step math under ``transformations/``, and
+the configuration schema at the package root. No model framework is imported
+and no model ships: the target model is the user's, provided at run time
+through the ``models:`` section.
+"""
+
+from kcai_data_sampling_fgsm._version_ import __version__ as __version__

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm/_version_.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm/api/__init__.py

@@ -0,0 +1,7 @@
+"""Subclasses of the generic core contracts.
+
+The transformation classes wrap the pure step math from
+``kcai_data_sampling_fgsm.transformations`` into the unary ``apply`` contract.
+I/O stays out: reads happen in the ``-job`` dataloaders and writes in the
+``-job`` outputwriters; everything flows as image batches.
+"""

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm/api/transformations/__init__.py

@@ -0,0 +1,10 @@
+"""Unary transformation classes.
+
+The generic core contract lives in ``kcai_data_sampling_core.api``; the
+``Fgsm`` class here wraps the pure step function from
+``kcai_data_sampling_fgsm.transformations`` into the unary ``apply`` contract.
+"""
+
+from kcai_data_sampling_fgsm.api.transformations.fgsm import Fgsm
+
+__all__ = ["Fgsm"]

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm/api/transformations/fgsm.py

@@ -0,0 +1,68 @@
+"""The ``fgsm`` transformation class.
+
+Wraps the normalized sign-direction step
+(:func:`kcai_data_sampling_fgsm.transformations.fgsm.fgsm_step`) into the
+unary transformation contract. The target model — the user's — is queried on
+the normalized float batch and its gradient is funneled through
+``check_output`` (shape and finiteness) before the step.
+"""
+
+from kcai_data_sampling_core.api.roles import check_output
+from kcai_data_sampling_core.api.unary import UnaryTransformation
+import numpy as np
+from typing_extensions import override
+
+from kcai_data_sampling_fgsm.configs import FgsmTransformationConfig
+from kcai_data_sampling_fgsm.transformations.fgsm import fgsm_step
+
+
+class Fgsm(UnaryTransformation):
+    """One budgeted step along the sign of the target model's gradient, in L-infinity.
+
+    The ``epsilon``-signed step may push pixels past the selection's value
+    range, so the algorithm declares ``clips`` and the base clips the output
+    back to it. The step is a lossy perturbation (not ``reversible``) and
+    deterministic, so the row records no seed. The target model is the user's
+    ``TargetModel``: only its ``grad`` is used.
+    """
+
+    algorithm = "fgsm"
+
+    #: The registered config schema this algorithm validates against.
+    Config = FgsmTransformationConfig
+
+    model_role = "target"
+    model_methods = ("grad",)
+
+    clips = True
+    reversible = False
+
+    @override
+    def apply(
+        self,
+        xs: np.ndarray,  # (b, h, w, c) uint8
+        rngs: list[np.random.Generator] | None = None,
+    ) -> np.ndarray:
+        """Perturb the batch by ``epsilon`` along the sign of the target gradient.
+
+        Args:
+            xs: Batch of sample arrays shaped ``(B, *sample)``.
+            rngs: Unused for this deterministic operation.
+
+        Returns:
+            A batch of the same shape and dtype, clipped within the value range.
+
+        Raises:
+            ValueError: If the target model's ``grad`` output breaks the
+                numeric contract (wrong shape or non-finite).
+        """
+        del rngs
+        normalized = xs.astype(np.float64) / np.iinfo(xs.dtype).max
+        grad = check_output(
+            self.algorithm,
+            self.target_model,
+            "grad",
+            normalized,
+            self.target_model.grad(normalized),
+        )
+        return fgsm_step(xs, grad, self.params["epsilon"])

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm/configs.py

@@ -0,0 +1,57 @@
+"""The ``fgsm`` transformation's configuration schema.
+
+The schema subclasses the core base ``TransformationConfig`` and pins ``type``
+to the algorithm's literal, so the registry-resolved validator in ``JobConfig``
+picks it by type. ``epsilon`` — the adversarial budget — is required, in
+normalized ``[0, 1]`` pixel units, strictly positive, and sweepable (its
+interval must stay ``> 0``). ``target_model`` names a model from the
+``models:`` section of the job config; the CLI resolves the name to an
+instance.
+"""
+
+from typing import Literal, Self
+
+from kcai_data_sampling_core.models.config import TransformationConfig
+from kcai_data_sampling_core.models.sweep import SweepConfig
+from pydantic import Field, model_validator
+
+
+class FgsmTransformationConfig(TransformationConfig):
+    """Configuration of the ``fgsm`` transformation.
+
+    Attributes:
+        target_model: Name of a target model from the job's ``models:``
+            section; the CLI resolves it to an instance. Optional here because
+            the transformation base consumes it before re-validating the
+            remaining parameters against this schema; a model-role
+            transformation without one is refused loudly at construction (the
+            slot check).
+        epsilon: Adversarial budget in normalized ``[0, 1]`` pixel units,
+            strictly positive, or a ``SweepConfig`` expanding it (its interval
+            must stay ``> 0``).
+    """
+
+    type: Literal["fgsm"] = "fgsm"
+    target_model: str | None = Field(
+        default=None,
+        exclude=True,
+        description="Name of a target model from the job's models: section; excluded"
+        " from the resolved parameters (the base consumes it before validation).",
+    )
+    epsilon: float | SweepConfig = Field(
+        description="Adversarial budget in normalized [0, 1] pixel units; a SweepConfig expands it."
+    )
+
+    @model_validator(mode="after")
+    def _parameter_bounds(self) -> Self:
+        """Enforce the epsilon budget's range on the value or the sweep.
+
+        Returns:
+            The validated config.
+
+        Raises:
+            ValueError: If ``epsilon`` is not strictly positive, whether given
+                directly or as a sweep interval.
+        """
+        self._check_parameter_bounds("epsilon", minimum=0, exclusive_min=True)
+        return self

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm/transformations/__init__.py

@@ -0,0 +1,11 @@
+"""Pure algorithm math for the adversarial transformations.
+
+All transformations share the image-batch convention ``(B, H, W, 4) uint8``.
+The module-level functions here are the pure algorithm math; the
+transformation class that wraps them into the unary contract lives in
+``kcai_data_sampling_fgsm.api.transformations``.
+"""
+
+from kcai_data_sampling_fgsm.transformations.fgsm import fgsm_step
+
+__all__ = ["fgsm_step"]

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm/transformations/fgsm.py

@@ -0,0 +1,40 @@
+"""The FGSM step, in normalized units: the math.
+
+``fgsm_step(xs, grad, epsilon)`` is the pure numpy map — the transformation
+class that wraps it into the unary contract lives in
+``kcai_data_sampling_fgsm.api.transformations.fgsm``. The step runs in
+normalized ``[0, 1]`` pixel units (the batch divided by its dtype maximum), and
+the model's gradient is in the same units: only its sign participates.
+"""
+
+import numpy as np
+
+
+def fgsm_step(xs: np.ndarray, grad: np.ndarray, epsilon: float) -> np.ndarray:
+    """Apply one budgeted sign-direction step in normalized ``[0, 1]`` units.
+
+    Normalizes the integer batch by its dtype maximum, adds
+    ``epsilon * sign(grad)``, clips back to ``[0, 1]``, and restores the
+    batch's dtype (scale, round, cast). ``grad`` is the target model's gradient
+    in the same normalized units — the step is ``epsilon * sign(grad)``, so
+    only the sign matters.
+
+    Args:
+        xs: Integer batch of sample arrays ``(B, *sample)``.
+        grad: Signed gradient in normalized units, same shape as ``xs``.
+        epsilon: Adversarial budget in normalized ``[0, 1]`` pixel units,
+            strictly positive.
+
+    Returns:
+        The perturbed batch, same shape and dtype as ``xs``.
+
+    Raises:
+        ValueError: If ``xs`` is not an integer array (a normalization-by-max
+            has no meaning otherwise).
+    """
+    if not np.issubdtype(xs.dtype, np.integer):
+        raise ValueError(f"fgsm_step: integer batches only, got dtype {xs.dtype}")
+    info = np.iinfo(xs.dtype)
+    normalized = xs.astype(np.float64) / info.max
+    stepped = np.clip(normalized + epsilon * np.sign(grad), 0.0, 1.0)
+    return np.rint(stepped * info.max).astype(xs.dtype)

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm.egg-info/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: kcai-data-sampling-fgsm
+Version: 0.1.0
+Summary: Adversarial perturbation (FGSM) for kcai data-sampling
+Author-email: Safenai <support@safenai.io>
+License-Expression: Apache-2.0
+Keywords: ml,data,augmentation,robustness,adversarial,fgsm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: kcai-data-sampling-core
+
+# kcai-data-sampling-fgsm
+
+The **adversarial** slot of kcai data-sampling: transformations where a model's
+*response* enters the computation and the result is graded against it. Here the
+model is a **target** — it is not asked to produce anything, only to react. That
+is what makes the family adversarial, and the declaring `model_role = "target"`
+is what tells the framework to treat it as such.
+
+This package implements the Fast Gradient Sign Method as a single budgeted step
+along the sign of the target model's gradient, and exposes it through the
+`kcai_data_sampling.transformations` entry-point group.
+
+**The target model is yours.** It arrives at run time through the `models:`
+section of your configuration and is never shipped by this package.
+
+## What it ships today
+
+- `fgsm` — one method: one L-infinity step of budget `epsilon` along the sign of
+  the target's gradient.
+
+One method, as an example of the slot rather than a catalogue.
+
+## Install
+
+```bash
+pip install "kcai-data-sampling[fgsm]"
+```
+
+**No deep-learning framework is required.** This package depends only on the
+core contracts — the gradient arrives from *your* model, so the work is yours
+too, and nothing here pulls torch. A configuration driving `fgsm` may well need
+torch in the environment that hosts the target model; that is a property of the
+model you bring, not of this package.
+
+## How the step works
+
+The batch is normalized to `[0, 1]` pixel units, the target's gradient is taken
+in the same units, and `epsilon * sign(grad)` is added — so only the *sign* of
+the gradient participates, not its magnitude. The result is clipped back into
+range and restored to the batch's dtype.
+
+Three declarations follow from that, and the framework enforces each:
+
+- **`clips = True`** — a signed step can push a pixel past the selection's value
+  range, so the output is clipped back rather than refused.
+- **`reversible = False`** — the step is lossy. The original pixels are not
+  recoverable from the output, so the row records that it is not invertible.
+- **Deterministic** — no randomness is drawn, so the recorded seed is `None`.
+  The same input and the same `epsilon` always give the same output.
+
+`epsilon` is the adversarial budget, strictly positive, and sweepable, so a run
+can walk a whole budget curve.
+
+## Labels do not move
+
+An attack moves the model's *prediction*, not the truth. The ground-truth label
+belongs to the source row, travels with it, and is never touched here — this
+package has no notion of a label at all, only of pixels.
+
+That is what makes an adversarial sample meaningful: if the label had moved
+along with the pixels, the pair would prove nothing. A label that changed under
+perturbation, or a target model whose response was ignored, would both mean the
+measurement was not an attack at all.
+
+## Example
+
+The `models` and `operations` sections of a job configuration, with a target
+model supplied as your own source:
+
+```yaml
+models:
+  yolo:
+    type: python
+    path: adapters/yolo_target.py
+    export: YoloTarget
+    weights: yolov8n.pt
+    params: { conf: 0.25 }
+operations:
+  transformations:
+    - name: fgsm
+      type: fgsm
+      target_model: yolo
+      epsilon:
+        range: [0.01, 0.05]
+        step: 0.01
+```
+
+The transformation names its model with `target_model: yolo`. Only `grad` is
+used from it, and its output is checked for shape and finiteness before the step,
+so a misbehaving adapter fails loudly rather than corrupting the batch.
+
+A target model is recognised by a non-empty `name` plus a `grad` method, and
+conformance is checked against the `target` role the transformation declares.

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+requirements.txt
+src/kcai_data_sampling_fgsm/__init__.py
+src/kcai_data_sampling_fgsm/_version_.py
+src/kcai_data_sampling_fgsm/configs.py
+src/kcai_data_sampling_fgsm/py.typed
+src/kcai_data_sampling_fgsm.egg-info/PKG-INFO
+src/kcai_data_sampling_fgsm.egg-info/SOURCES.txt
+src/kcai_data_sampling_fgsm.egg-info/dependency_links.txt
+src/kcai_data_sampling_fgsm.egg-info/entry_points.txt
+src/kcai_data_sampling_fgsm.egg-info/requires.txt
+src/kcai_data_sampling_fgsm.egg-info/scm_file_list.json
+src/kcai_data_sampling_fgsm.egg-info/top_level.txt
+src/kcai_data_sampling_fgsm/api/__init__.py
+src/kcai_data_sampling_fgsm/api/transformations/__init__.py
+src/kcai_data_sampling_fgsm/api/transformations/fgsm.py
+src/kcai_data_sampling_fgsm/transformations/__init__.py
+src/kcai_data_sampling_fgsm/transformations/fgsm.py

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[kcai_data_sampling.transformations]
+fgsm = kcai_data_sampling_fgsm.api.transformations.fgsm:Fgsm

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm.egg-info/requires.txt

@@ -0,0 +1 @@
+kcai-data-sampling-core

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm.egg-info/scm_file_list.json

@@ -0,0 +1,15 @@
+{
+  "files": [
+    "README.md",
+    "pyproject.toml",
+    "requirements.txt",
+    "src/kcai_data_sampling_fgsm/__init__.py",
+    "src/kcai_data_sampling_fgsm/api/__init__.py",
+    "src/kcai_data_sampling_fgsm/api/transformations/__init__.py",
+    "src/kcai_data_sampling_fgsm/api/transformations/fgsm.py",
+    "src/kcai_data_sampling_fgsm/configs.py",
+    "src/kcai_data_sampling_fgsm/py.typed",
+    "src/kcai_data_sampling_fgsm/transformations/__init__.py",
+    "src/kcai_data_sampling_fgsm/transformations/fgsm.py"
+  ]
+}

kcai_data_sampling_fgsm-0.1.0/src/kcai_data_sampling_fgsm.egg-info/top_level.txt

@@ -0,0 +1 @@
+kcai_data_sampling_fgsm