SeInE-orientation 0.1.0__tar.gz

seine_orientation-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,51 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+            fetch-depth: 0
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Install build tools
+        run: python -m pip install --upgrade build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Upload distribution artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+
+    environment:
+      name: pypi
+
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Download distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

seine_orientation-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+*.pyc
+*.egg-info
+
+interactive/
+notebooks/
+figures/
+Discussions/
+data/
+
+
+seine_orientation/_version.py

seine_orientation-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: SeInE-orientation
+Version: 0.1.0
+Summary: Orientation Selectivity Inference from a Gabor model
+Author: Alexander Schmidt
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: SeInE-HB>=0.1.3
+Requires-Dist: event-estimator>=0.1.1
+
+Inferring model parameters of tilted Gabor-filter with non-linear response rate and overdispersed spike count responses, using SeInE

seine_orientation-0.1.0/README.md

@@ -0,0 +1 @@
+Inferring model parameters of tilted Gabor-filter with non-linear response rate and overdispersed spike count responses, using SeInE

seine_orientation-0.1.0/SeInE_orientation.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: SeInE-orientation
+Version: 0.1.0
+Summary: Orientation Selectivity Inference from a Gabor model
+Author: Alexander Schmidt
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: SeInE-HB>=0.1.3
+Requires-Dist: event-estimator>=0.1.1
+
+Inferring model parameters of tilted Gabor-filter with non-linear response rate and overdispersed spike count responses, using SeInE

seine_orientation-0.1.0/SeInE_orientation.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+.gitignore
+README.md
+pyproject.toml
+.github/workflows/release.yml
+SeInE_orientation.egg-info/PKG-INFO
+SeInE_orientation.egg-info/SOURCES.txt
+SeInE_orientation.egg-info/dependency_links.txt
+SeInE_orientation.egg-info/requires.txt
+SeInE_orientation.egg-info/scm_file_list.json
+SeInE_orientation.egg-info/scm_version.json
+SeInE_orientation.egg-info/top_level.txt
+seine_orientation/BayesModel.py
+seine_orientation/__init__.py
+seine_orientation/_version.py
+seine_orientation/process_session.py
+seine_orientation/utils/__init__.py
+seine_orientation/utils/display_inference_results.py
+seine_orientation/utils/utils_analysis.py
+seine_orientation/utils/utils_display.py
+seine_orientation/utils/utils_model.py

seine_orientation-0.1.0/SeInE_orientation.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

seine_orientation-0.1.0/SeInE_orientation.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy
+scipy
+SeInE-HB>=0.1.3
+event-estimator>=0.1.1

seine_orientation-0.1.0/SeInE_orientation.egg-info/scm_file_list.json

@@ -0,0 +1,16 @@
+{
+  "files": [
+    ".github/workflows/release.yml",
+    ".gitignore",
+    "README.md",
+    "pyproject.toml",
+    "seine_orientation/BayesModel.py",
+    "seine_orientation/__init__.py",
+    "seine_orientation/process_session.py",
+    "seine_orientation/utils/__init__.py",
+    "seine_orientation/utils/display_inference_results.py",
+    "seine_orientation/utils/utils_analysis.py",
+    "seine_orientation/utils/utils_display.py",
+    "seine_orientation/utils/utils_model.py"
+  ]
+}

seine_orientation-0.1.0/SeInE_orientation.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.1.0",
+  "distance": 0,
+  "node": "gffe43a317a747f366b3c4784d510adc1ddf141e7",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-02"
+}

seine_orientation-0.1.0/SeInE_orientation.egg-info/top_level.txt

@@ -0,0 +1 @@
+seine_orientation

seine_orientation-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = [
+    "setuptools>=77.0.3",
+    "setuptools-scm>=8",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "SeInE-orientation"
+dynamic = ["version"]
+description = "Orientation Selectivity Inference from a Gabor model"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { file = "LICENSE" }
+
+authors = [
+    { name = "Alexander Schmidt" }
+]
+
+dependencies = [
+    "numpy",
+    "scipy",
+    "SeInE-HB>=0.1.3",
+    "event-estimator>=0.1.1"
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["seine_orientation*"]
+
+[tool.setuptools_scm]
+version_file = "seine_orientation/_version.py"
+local_scheme = "no-local-version"

seine_orientation-0.1.0/seine_orientation/BayesModel.py

@@ -0,0 +1,283 @@
+import numpy as np
+import time
+import itertools
+
+from seine.NestedSamplingMethods import (
+    run_sampling,
+)
+from seine import HierarchicalModel, functions as prior_fn
+from seine.structures import (
+    prior_structure,
+)
+
+from .utils import gabor_filter, gabor_response, sine_grating, softplus, ReLU, sigmoid
+
+
+class HierarchicalBayesInference(HierarchicalModel):
+
+    def set_gratings(self, measure_points, FoV_range, FoV_steps):
+
+        self.measure_points = measure_points
+
+        self.X_FoV, self.Y_FoV = np.meshgrid(
+            np.linspace(-FoV_range[0] / 2, FoV_range[0] / 2, FoV_steps),
+            np.linspace(-FoV_range[1] / 2, FoV_range[1] / 2, FoV_steps),
+        )
+        self.FoV_grid = np.dstack((self.X_FoV, self.Y_FoV))
+
+        FoV_steps = self.X_FoV.shape[0]
+
+        self.gratings = np.zeros(
+            (
+                *[len(mp) for mp in self.measure_points],
+                FoV_steps,
+                FoV_steps,
+            )
+        )
+        for prod in itertools.product(
+            enumerate(self.measure_points[0]),
+            enumerate(self.measure_points[1]),
+            enumerate(self.measure_points[2]),
+        ):
+            idx, elems = zip(*prod)
+            phi_0, theta, f = elems
+            self.gratings[*idx, ...] = sine_grating(
+                self.X_FoV,  # [0, ...],
+                self.Y_FoV,  # [0, ...],
+                theta,
+                f,
+                phi_0,
+                square=True,
+            )
+
+    def set_priors(self, priors_init=None, coding="simple"):
+
+        if priors_init is None:
+
+            if hasattr(self, "data"):
+                fmap = self.data["observed_counts"] / self.data["T"]
+                A0_guess, A_guess = np.percentile(fmap, [50, 90])
+                A0_guess = np.maximum(A0_guess, 1.0)
+                A_guess = np.maximum(A_guess, 2.0)
+            else:
+                A0_guess, A_guess = 1.0, 3.0
+            self.priors_init = {}
+            # print("A guesses from data:", A0_guess, A_guess)
+
+            ## define gabor model priors
+            if coding in ["simple", "complex"]:
+                self.priors_init["theta"] = prior_structure(
+                    prior_fn.bounded_flat,
+                    low=-np.pi / 2,
+                    high=np.pi / 2,
+                    label=r"$\theta$",
+                    periodic=True,
+                )
+                self.priors_init["f"] = prior_structure(
+                    prior_fn.halfnorm_ppf,
+                    loc=0.0,
+                    scale=5.0,
+                    label=r"$f$",
+                )
+                if coding == "simple":
+                    ## not required for complex cell model
+                    self.priors_init["phi_0"] = prior_structure(
+                        prior_fn.bounded_flat,
+                        low=-np.pi,
+                        high=np.pi,
+                        periodic=True,
+                        label=r"$\phi_0$",
+                    )
+                else:
+                    self.priors_init["phi_0"] = prior_structure(
+                        None,
+                        value=0.0,
+                        periodic=True,
+                        label=r"$\phi_0$",
+                    )
+
+                self.priors_init["sigma"] = prior_structure(
+                    prior_fn.halfnorm_ppf,
+                    loc=0.05,
+                    scale=0.1,
+                    label=r"$\sigma$",
+                )
+                self.priors_init["gamma"] = prior_structure(
+                    prior_fn.halfnorm_ppf,
+                    loc=1.0,
+                    scale=1.0,
+                    label=r"$\gamma$",
+                )
+                self.priors_init["theta_gauss"] = prior_structure(
+                    prior_fn.bounded_flat,
+                    low=-np.pi / 2,
+                    high=np.pi / 2,
+                    periodic=True,
+                    label=r"$\theta_{gauss}$",
+                )
+
+            ## define nonlinearity priors - should start with "nl_" to be recognized by model response function
+            self.priors_init["nl_baseline"] = prior_structure(
+                prior_fn.halfnorm_ppf,
+                loc=0.0,
+                scale=A0_guess,
+                label=r"$A_{baseline}$",
+            )
+            if coding in ["simple", "complex"]:
+                self.priors_init["nl_transition"] = prior_structure(
+                    prior_fn.halfnorm_ppf,
+                    loc=0.0,
+                    scale=1.0,
+                    label=r"$A_{transition}$",
+                )
+                self.priors_init["nl_amplitude"] = prior_structure(
+                    prior_fn.halfnorm_ppf,
+                    loc=A0_guess * 0.2,
+                    scale=A_guess - A0_guess,
+                    label=r"$A_{amplitude}$",
+                )
+
+            # parameters for loglikelihood
+            self.priors_init["logl_alpha"] = prior_structure(
+                prior_fn.halfnorm_ppf,
+                loc=0.0,
+                scale=1.0,
+                label=r"$\alpha_{logl}$",
+            )
+
+        else:
+            self.priors_init = priors_init
+
+        super().set_priors(self.priors_init)
+
+    def get_model_rate_response(self, params, coding="simple"):
+
+        ## transform parameters, if not already provided in proper format
+        if not isinstance(params, dict):
+            params = self.get_params_from_p(params)
+
+        ## get (normalized) model response
+        if coding == "random":
+            response = np.zeros(self.dimensions["shape"])
+        else:
+            response = gabor_response(
+                self.X_FoV,
+                self.Y_FoV,
+                params,
+                self.gratings,
+                mode=coding,
+                significance_threshold=0.01,
+                logger=self.log,
+            )
+        self.timeit("calculating model and response firing rate")
+
+        ## apply nonlinearity to adjust to scale of firing rates and get final model response in firing rate units
+        rate_response = self.apply_nonlinearity(response, params)
+        return rate_response
+
+    def apply_nonlinearity(self, response, params, nonlinearity="softplus"):
+
+        if nonlinearity == "softplus":
+            # print(
+            #     f"Applying softplus nonlinearity with parameters: baseline={params.get('nl_baseline', 0.0):.3f}, transition={params.get('nl_transition', 1.0):.3f}, amplitude={params.get('nl_amplitude', 1.0):.3f}"
+            # )
+            rate_response = softplus(
+                response * params.get("nl_amplitude", 1.0),
+                alpha=params.get("nl_transition", 1.0),
+                delta=params.get("nl_baseline", 0.0),
+            )
+        elif nonlinearity == "ReLU":
+            # rate_response =
+            raise NotImplementedError("ReLU nonlinearity not implemented yet")
+        elif nonlinearity == "sigmoid":
+            raise NotImplementedError("Sigmoid nonlinearity not implemented yet")
+        else:
+            raise ValueError(f"Unknown nonlinearity: {nonlinearity}")
+
+        self.timeit("applying nonlinearity")
+        return rate_response
+
+    def set_logp_func(self, coding="simple"):
+        """
+        some nice description
+        """
+
+        def get_logp(p_in):
+
+            self.timeit()
+            """
+                build switch between 3 models:
+                    - gabor type model
+                    - fourier component model (with n components in each direction)
+                    - ellipse in rate space
+            """
+
+            params = self.get_params_from_p(p_in)
+            self.timeit("transforming parameters")
+
+            model_rate_response = self.get_model_rate_response(params, coding)
+            if not (model_rate_response.shape == self.data["observed_counts"].shape):
+                model_rate_response = model_rate_response[None, ...]
+
+            logp = self.probability_of_spike_observation(
+                model_rate_response,
+                model="negative_binomial",
+                **params,
+            )
+            self.timeit("calculating log probability of spike observation")
+
+            return logp.sum()
+
+        return get_logp
+
+
+def run_inference(
+    hbm: HierarchicalBayesInference,
+    coding="simple",
+    n_live=200,
+    nP=1,
+    dlogz=1.0,
+    show_status=True,
+):
+    hbm.set_priors(coding=coding)
+    my_trafo = hbm.set_prior_transform()
+    my_logp = hbm.set_logp_func(coding=coding)
+
+    results, sampler = run_sampling(
+        my_trafo,
+        my_logp,
+        hbm.parameter_names_all,
+        hbm.periodic,
+        show_status=show_status,
+        n_live=n_live,
+        nP=nP,
+        dlogz=dlogz,
+    )
+    return results
+
+
+def run_model_comparison(data, dwelltime, measure_points, show_status=True, **kwargs):
+
+    t_start = time.time()
+    hbm = HierarchicalBayesInference()
+
+    hbm.set_gratings(
+        measure_points,
+        [np.deg2rad(140), np.deg2rad(114)],
+        FoV_steps=51,
+    )
+
+    hbm.prepare_data(
+        data,
+        dwelltime,
+        iter_dims=False,
+    )
+
+    results = {}
+    for coding in ["random", "simple", "complex"]:
+        results[coding] = run_inference(
+            hbm, coding=coding, show_status=show_status, **kwargs
+        )
+    t_end = time.time()
+    print(f"Model comparison done after {t_end - t_start:.2f} seconds")
+    return results

seine_orientation-0.1.0/seine_orientation/__init__.py

@@ -0,0 +1,2 @@
+from .BayesModel import HierarchicalBayesInference, run_inference, run_model_comparison
+from .process_session import process_session

seine_orientation-0.1.0/seine_orientation/_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 = 'gffe43a317'