tracetorch 0.1.0__tar.gz

tracetorch-0.1.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

tracetorch-0.1.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: tracetorch
+Version: 0.1.0
+Summary: An extension to PyTorch: SNN layers that function on traces.
+Author-email: Yegor Men <yegor.mn@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Yegor-men/tracetorch
+Project-URL: Repository, https://github.com/Yegor-men/tracetorch
+Project-URL: Issues, https://github.com/Yegor-men/tracetorch/issues
+Project-URL: Documentation, https://yegor-men.github.io/tracetorch/
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+![traceTorch Banner](media/tracetorch_banner.png)
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-purple.svg)](https://www.apache.org/licenses/LICENSE-2.0)
+
+``traceTorch`` is a PyTorch-based library built on the principles of spiking neural networks, replacing the PyTorch
+default backpropagation through time with lightweight, per-layer input traces, enabling biologically inspired, constant
+time and memory consumption learning on arbitrarily long or even streaming sequences.
+
+## Documentation
+
+It is highly recommended that you read the [documentation](https://yegor-men.github.io/tracetorch/) first. It contains:
+
+1. **Introduction**: An introduction to traceTorch, how and why it works, it's founding principles. It's thoroughly
+   recommended that you read through the entire introduction and gain an intuitive understanding before proceeding.
+2. **Tutorials**: Various tutorials to create your own traceTorch models. The resultant code can be found in
+   `tutorials/`.
+3. **Documentation**: The actual documentation to all the modules included in `traceTorch`. It includes detailed
+   explanations, examples and math to gain a full understanding.
+
+## Roadmap
+
+- Create the poisson click test example
+- Implement the trace alternative to REINFORCE
+- Make traceTorch into a PyPI library
+- Finish writing the documentation
+- Clean up the tutorial code
+- Implement abstract graph based models, not just sequential
+
+## Installation
+
+⚠️ WARNING, traceTorch is _not yet_ a library. For now, you'll just have to clone this repository and use the
+`tracetorch/` folder within.
+
+```
+git clone https://github.com/Yegor-men/tracetorch
+cd tracetorch/
+pip install -r requirements.txt
+```
+
+Then, within a python file where from where the repository root folder is visible, simply do:
+
+```
+from tracetorch import tracetorch
+```
+
+## Usage examples
+
+`tutorials/` contains all the tutorial files, ready to run and playtest. The tutorials themselves can be
+found [here](https://yegor-men.github.io/tracetorch/tutorials/index.html).
+
+To ensure that you have all the necessary packages for the tutorials installed, please execute the following command:
+
+```
+cd tutorials/
+pip install -r requirements.txt
+```
+
+## Authors
+
+- [@Yegor-men](https://github.com/Yegor-men)
+
+## Acknowledgements
+
+I built traceTorch from the ground up, trying to reverse engineer biological neurons with a sprinkle of intelligent
+design, but I would also like to recognize the following projects and people who helped shape my thinking:
+
+- [snntorch](https://github.com/jeshraghian/snntorch) for introducing me to SNN networks in the first place, and their
+  principles of function. Ironically, its dependency on constructing the full autograd graph is what largely inspired me
+  to make traceTorch.
+- [Artem Kirsanov](https://www.youtube.com/@ArtemKirsanov) for introducing me to computational neuroscience, presenting
+  interesting concepts in an easy-to-understand manner. My earliest tests, when I naively wanted to implement 1:1
+  biological neurons, largely revolved around his work.
+- [e-prop (eligibility propagation)](https://www.biorxiv.org/content/biorxiv/early/2020/04/16/738385.full.pdf) inspired
+  the whole "trace" concept, the idea of keeping a decaying value. Earlier, before traceTorch, I wanted to use e-prop
+  for online learning instead. Admittedly unsuccessful in my attempts, and a little put off by the relative difficulty,
+  I instead wanted to make something simpler.
+
+## Contributing
+
+Contributions are always welcome. Feel free to submit pull requests or report issues, I will occasionally check in on
+it.
+
+You can also reach out to me via either email or Twitter:
+
+- yegor.mn@gmail.com
+- [Twitter](https://x.com/Yegor_Men)

tracetorch-0.1.0/README.md

@@ -0,0 +1,86 @@
+![traceTorch Banner](media/tracetorch_banner.png)
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-purple.svg)](https://www.apache.org/licenses/LICENSE-2.0)
+
+``traceTorch`` is a PyTorch-based library built on the principles of spiking neural networks, replacing the PyTorch
+default backpropagation through time with lightweight, per-layer input traces, enabling biologically inspired, constant
+time and memory consumption learning on arbitrarily long or even streaming sequences.
+
+## Documentation
+
+It is highly recommended that you read the [documentation](https://yegor-men.github.io/tracetorch/) first. It contains:
+
+1. **Introduction**: An introduction to traceTorch, how and why it works, it's founding principles. It's thoroughly
+   recommended that you read through the entire introduction and gain an intuitive understanding before proceeding.
+2. **Tutorials**: Various tutorials to create your own traceTorch models. The resultant code can be found in
+   `tutorials/`.
+3. **Documentation**: The actual documentation to all the modules included in `traceTorch`. It includes detailed
+   explanations, examples and math to gain a full understanding.
+
+## Roadmap
+
+- Create the poisson click test example
+- Implement the trace alternative to REINFORCE
+- Make traceTorch into a PyPI library
+- Finish writing the documentation
+- Clean up the tutorial code
+- Implement abstract graph based models, not just sequential
+
+## Installation
+
+⚠️ WARNING, traceTorch is _not yet_ a library. For now, you'll just have to clone this repository and use the
+`tracetorch/` folder within.
+
+```
+git clone https://github.com/Yegor-men/tracetorch
+cd tracetorch/
+pip install -r requirements.txt
+```
+
+Then, within a python file where from where the repository root folder is visible, simply do:
+
+```
+from tracetorch import tracetorch
+```
+
+## Usage examples
+
+`tutorials/` contains all the tutorial files, ready to run and playtest. The tutorials themselves can be
+found [here](https://yegor-men.github.io/tracetorch/tutorials/index.html).
+
+To ensure that you have all the necessary packages for the tutorials installed, please execute the following command:
+
+```
+cd tutorials/
+pip install -r requirements.txt
+```
+
+## Authors
+
+- [@Yegor-men](https://github.com/Yegor-men)
+
+## Acknowledgements
+
+I built traceTorch from the ground up, trying to reverse engineer biological neurons with a sprinkle of intelligent
+design, but I would also like to recognize the following projects and people who helped shape my thinking:
+
+- [snntorch](https://github.com/jeshraghian/snntorch) for introducing me to SNN networks in the first place, and their
+  principles of function. Ironically, its dependency on constructing the full autograd graph is what largely inspired me
+  to make traceTorch.
+- [Artem Kirsanov](https://www.youtube.com/@ArtemKirsanov) for introducing me to computational neuroscience, presenting
+  interesting concepts in an easy-to-understand manner. My earliest tests, when I naively wanted to implement 1:1
+  biological neurons, largely revolved around his work.
+- [e-prop (eligibility propagation)](https://www.biorxiv.org/content/biorxiv/early/2020/04/16/738385.full.pdf) inspired
+  the whole "trace" concept, the idea of keeping a decaying value. Earlier, before traceTorch, I wanted to use e-prop
+  for online learning instead. Admittedly unsuccessful in my attempts, and a little put off by the relative difficulty,
+  I instead wanted to make something simpler.
+
+## Contributing
+
+Contributions are always welcome. Feel free to submit pull requests or report issues, I will occasionally check in on
+it.
+
+You can also reach out to me via either email or Twitter:
+
+- yegor.mn@gmail.com
+- [Twitter](https://x.com/Yegor_Men)

tracetorch-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=77.0.3", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tracetorch"
+version = "0.1.0"
+authors = [{ name = "Yegor Men", email = "yegor.mn@gmail.com" }]
+description = "An extension to PyTorch: SNN layers that function on traces."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "Apache-2.0"
+dependencies = ["torch", "numpy", "matplotlib"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Homepage = "https://github.com/Yegor-men/tracetorch"
+Repository = "https://github.com/Yegor-men/tracetorch"
+Issues = "https://github.com/Yegor-men/tracetorch/issues"
+Documentation = "https://yegor-men.github.io/tracetorch/"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["tracetorch*"]
+exclude = ["media*", "tutorials*, docs*, tests*"]

tracetorch-0.1.0/setup.cfg

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

tracetorch-0.1.0/tracetorch/__init__.py

@@ -0,0 +1 @@
+from . import functional, nn, loss, plot

tracetorch-0.1.0/tracetorch/functional/__init__.py

@@ -0,0 +1,3 @@
+from ._sigmoid_inverse import sigmoid_inverse
+from ._softplus_inverse import softplus_inverse
+from ._sample_softmax import sample_softmax

tracetorch-0.1.0/tracetorch/functional/_sample_softmax.py

@@ -0,0 +1,10 @@
+import torch
+
+
+def sample_softmax(probability_dist, return_one_hot: bool = True):
+	index = torch.multinomial(probability_dist, num_samples=1)
+	if not return_one_hot:
+		return index
+	out_spikes = torch.zeros_like(probability_dist)
+	out_spikes[index] = 1
+	return out_spikes

tracetorch-0.1.0/tracetorch/functional/_sigmoid_inverse.py

@@ -0,0 +1,9 @@
+import torch
+
+def sigmoid_inverse(tensor: torch.Tensor) -> torch.Tensor:
+	"""
+	Calculates the necessary tensor such that passing it through sigmoid yields this tensor
+	:param tensor:
+	:return:
+	"""
+	return torch.log(tensor / (1 - tensor))

tracetorch-0.1.0/tracetorch/functional/_softplus_inverse.py

@@ -0,0 +1,9 @@
+import torch
+
+def softplus_inverse(tensor: torch.Tensor) -> torch.Tensor:
+	"""
+	Calculates the necessary tensor such that passing it through softplus yields this tensor
+	:param tensor:
+	:return:
+	"""
+	return torch.log(torch.e ** tensor - 1)

tracetorch-0.1.0/tracetorch/loss/__init__.py

@@ -0,0 +1 @@
+from ._mse import mse

tracetorch-0.1.0/tracetorch/loss/_mse.py

@@ -0,0 +1,25 @@
+import torch
+
+
+def mse(
+		received: torch.Tensor,
+		expected: torch.Tensor,
+		reduction: str = "mean"
+) -> tuple[torch.Tensor, torch.Tensor]:
+	"""
+	calculates the mse loss
+	:param received:
+	:param expected:
+	:param reduction:
+	:return:
+	"""
+	received = received.detach().clone().requires_grad_(True)
+	expected = expected.detach().to(received)
+
+	loss_fn = torch.nn.MSELoss(reduction=reduction)
+	loss = loss_fn.forward(received, expected)
+	loss.backward()
+
+	ls = received.grad.detach()
+
+	return loss.detach(), ls

tracetorch-0.1.0/tracetorch/nn/__init__.py

@@ -0,0 +1,4 @@
+from ._sequential import Sequential
+
+from ._lif import LIF
+from ._lis import LIS

tracetorch-0.1.0/tracetorch/nn/_lif.py

@@ -0,0 +1,83 @@
+import torch
+
+from .. import functional
+
+
+class LIF:
+	"""
+	Leaky integrate and fire neuron layer
+	"""
+
+	def __init__(
+			self,
+			num_in: int,
+			num_out: int,
+			weight_scaling: float = 0.1,
+			mem_decay: float = 0.9,
+			in_trace_decay: float = 0.9,
+			threshold: float = 1,
+			device: str = "cpu",
+			lr: float = 1e-3,
+			learn_weight: bool = True,
+			learn_mem_decay: bool = True,
+			learn_in_trace_decay: bool = True,
+			learn_threshold: bool = True
+	):
+		self.device = device
+		self.lr = lr
+
+		self.weight = (torch.randn(num_out, num_in) * weight_scaling).to(self.device)
+		self.mem_decay = (functional.sigmoid_inverse(torch.ones(num_out) * mem_decay)).to(self.device)
+		self.in_trace_decay = (functional.sigmoid_inverse(torch.ones(num_in) * in_trace_decay)).to(self.device)
+		self.threshold = (functional.softplus_inverse(torch.ones(num_out) * threshold)).to(self.device)
+
+		self.weight.requires_grad_(learn_weight)
+		self.mem_decay.requires_grad_(learn_mem_decay)
+		self.in_trace_decay.requires_grad_(learn_in_trace_decay)
+		self.threshold.requires_grad_(learn_threshold)
+
+		self.optimizer = torch.optim.AdamW(
+			[p for p in (self.weight, self.mem_decay, self.in_trace_decay, self.threshold) if p.requires_grad],
+			lr=self.lr
+		)
+
+		self.mem = torch.zeros(num_out).to(self.device)
+		self.in_trace = torch.zeros(num_in).to(self.device)
+
+	def forward(self, in_spikes: torch.Tensor) -> torch.Tensor:
+		with torch.no_grad():
+			in_spikes = in_spikes.to(self.device)
+			in_trace_decay = torch.nn.functional.sigmoid(self.in_trace_decay)
+			self.in_trace = self.in_trace * in_trace_decay + in_spikes
+			syn_current = torch.einsum("i, oi -> o", in_spikes, self.weight)
+			mem_decay = torch.nn.functional.sigmoid(self.mem_decay)
+			self.mem = self.mem * mem_decay + syn_current
+			threshold = torch.nn.functional.softplus(self.threshold)
+			out_spikes = (self.mem >= threshold).float()
+			self.mem -= threshold * out_spikes
+			return out_spikes
+
+	def backward(self, learning_signal: torch.Tensor) -> torch.Tensor:
+		in_trace_decay = torch.nn.functional.sigmoid(self.in_trace_decay)
+		average_input = self.in_trace * (1 - in_trace_decay)
+		avg_in = average_input.detach().requires_grad_(True)
+
+		i = torch.einsum("i, oi -> o", avg_in, self.weight)
+		d = torch.nn.functional.sigmoid(self.mem_decay)
+		t = torch.nn.functional.softplus(self.threshold)
+
+		excess = (2 * i - i * d) / 2 - t * (1 - d)
+		f = torch.nn.functional.sigmoid(5 * excess)
+
+		f.backward(learning_signal)
+		passed_ls = avg_in.grad
+		average_input.backward(passed_ls)
+
+		self.optimizer.step()
+		self.optimizer.zero_grad(set_to_none=True)
+		return passed_ls
+
+	def zero_states(self):
+		with torch.no_grad():
+			self.in_trace.zero_()
+			self.mem.zero_()

tracetorch-0.1.0/tracetorch/nn/_lis.py

@@ -0,0 +1,77 @@
+import torch
+from math import log as ln
+
+from .. import functional
+
+
+class LIS:
+	"""
+	Leaky integrate and softmax layer
+	"""
+	def __init__(
+			self,
+			num_in: int,
+			num_out: int,
+			weight_scaling: float = 0.1,
+			mem_decay: float = 0.9,
+			in_trace_decay: float = 0.9,
+			device: str = "cpu",
+			lr: float = 1e-3,
+			learn_weight: bool = True,
+			learn_mem_decay: bool = True,
+			learn_in_trace_decay: bool = True,
+	):
+		self.device = device
+		self.lr = lr
+
+		self.weight = (torch.randn(num_out, num_in) * weight_scaling).to(self.device)
+		self.mem_decay = (functional.sigmoid_inverse(torch.ones(num_out) * mem_decay)).to(self.device)
+		self.in_trace_decay = (functional.sigmoid_inverse(torch.ones(num_in) * in_trace_decay)).to(self.device)
+
+		self.weight.requires_grad_(learn_weight)
+		self.mem_decay.requires_grad_(learn_mem_decay)
+		self.in_trace_decay.requires_grad_(learn_in_trace_decay)
+
+		self.optimizer = torch.optim.AdamW(
+			[p for p in (self.weight, self.mem_decay, self.in_trace_decay) if p.requires_grad],
+			lr=self.lr
+		)
+
+		self.mem = torch.zeros(num_out).to(self.device)
+		self.in_trace = torch.zeros(num_in).to(self.device)
+
+	def forward(self, in_spikes: torch.Tensor) -> torch.Tensor:
+		with torch.no_grad():
+			in_spikes = in_spikes.to(self.device)
+			in_trace_decay = torch.nn.functional.sigmoid(self.in_trace_decay)
+			self.in_trace = self.in_trace * in_trace_decay + in_spikes
+			syn_current = torch.einsum("i, oi -> o", in_spikes, self.weight)
+			mem_decay = torch.nn.functional.sigmoid(self.mem_decay)
+			self.mem = self.mem * mem_decay + syn_current
+
+			probability_dist = torch.nn.functional.softmax(self.mem, dim=-1)
+			return probability_dist
+
+	def backward(self, learning_signal: torch.Tensor) -> torch.Tensor:
+		in_trace_decay = torch.nn.functional.sigmoid(self.in_trace_decay)
+		average_input = self.in_trace * (1 - in_trace_decay)
+		avg_in = average_input.detach().requires_grad_(True)
+
+		i = torch.einsum("i, oi -> o", avg_in, self.weight)
+		d = torch.nn.functional.sigmoid(self.mem_decay)
+
+		stabilized_mem_level = i / (1 - d + 1e-6)
+		f = torch.nn.functional.softmax(stabilized_mem_level, dim=-1)
+
+		f.backward(learning_signal)
+		passed_ls = avg_in.grad
+		average_input.backward(passed_ls)
+
+		self.optimizer.step()
+		self.optimizer.zero_grad(set_to_none=True)
+		return passed_ls
+
+	def zero_states(self):
+		with torch.no_grad():
+			self.in_trace.zero_()
+			self.mem.zero_()

tracetorch-0.1.0/tracetorch/nn/_sequential.py

@@ -0,0 +1,22 @@
+import torch
+
+
+class Sequential:
+	"""
+	binds layers into a sequential modde
+	"""
+	def __init__(self, *layers):
+		self.layers = list(layers)
+
+	def forward(self, x: torch.Tensor) -> torch.Tensor:
+		for index, layer in enumerate(self.layers):
+			x = layer.forward(x)
+		return x
+
+	def backward(self, ls: torch.Tensor) -> None:
+		for index, layer in enumerate(reversed(self.layers)):
+			ls = layer.backward(ls)
+
+	def zero_states(self):
+		for layer in self.layers:
+			layer.zero_states()

tracetorch-0.1.0/tracetorch/plot/__init__.py

@@ -0,0 +1,5 @@
+from ._spike_train import spike_train
+from ._line_graph import line_graph
+from ._measurement_manager import MeasurementManager
+from ._render_image import render_image
+from ._distributions import distributions

tracetorch-0.1.0/tracetorch/plot/_distributions.py

@@ -0,0 +1,213 @@
+from typing import List, Dict, Any, Optional, Tuple
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def _safe_to_numpy(t: torch.Tensor) -> np.ndarray:
+	t = t.detach().cpu().ravel()
+	a = t.numpy()
+	# remove nans and infs
+	a = a[np.isfinite(a)]
+	return a
+
+
+def _silverman_bandwidth(x: np.ndarray) -> float:
+	n = x.size
+	if n < 2:
+		return 1.0
+	s = np.std(x, ddof=1)
+	# Silverman's rule of thumb for Gaussian kernel
+	bw = 1.06 * s * n ** (-1 / 5)
+	# guard against zero bandwidth
+	if bw <= 0 or not np.isfinite(bw):
+		bw = np.ptp(x) / 10.0 if np.ptp(x) > 0 else 1.0
+	return bw
+
+
+def _gaussian_kde_eval(samples: np.ndarray,
+					   grid: np.ndarray,
+					   bw: Optional[float] = None,
+					   max_samples: int = 20000) -> np.ndarray:
+	"""
+	Vectorized Gaussian KDE evaluation at points in `grid`.
+	- samples: 1D numpy array of data
+	- grid: 1D numpy array of evaluation points
+	- bw: bandwidth (if None uses Silverman)
+	- max_samples: if samples too large, random subsample for speed
+	Returns density values aligned with grid (integrates approximately to 1).
+	"""
+	if samples.size == 0:
+		return np.zeros_like(grid, dtype=float)
+	x = samples
+	n = x.size
+	if n > max_samples:
+		rng = np.random.default_rng(0)
+		x = rng.choice(x, size=max_samples, replace=False)
+		n = x.size
+	if bw is None:
+		bw = _silverman_bandwidth(x)
+	# compute kernel densities: sum of Gaussians
+	# density = (1/(n*bw)) * sum_j phi((grid - x_j)/bw)
+	# vectorized with broadcasting (grid[:,None] - x[None,:])
+	diffs = (grid[:, None] - x[None, :]) / bw
+	# gaussian kernel
+	K = np.exp(-0.5 * diffs * diffs) / np.sqrt(2 * np.pi)
+	dens = K.sum(axis=1) / (n * bw)
+	# normalize numerical integration to 1 (improves comparability across grids)
+	area = np.trapz(dens, grid)
+	if area > 0:
+		dens = dens / area
+	return dens
+
+
+def distributions(layers: List[torch.Tensor],
+				  title: str,
+				  *,
+				  n_grid: int = 1024,
+				  n_percentiles: int = 100,
+				  bandwidths: Optional[List[Optional[float]]] = None,
+				  show_percentile_lines: bool = False,
+				  compute_metrics: bool = True,
+				  max_kde_samples: int = 20000
+				  ) -> Dict[str, Any]:
+	"""
+	Estimate and plot continuous distributions for each layer (torch.Tensor) in `layers`.
+	Parameters
+	----------
+	title : str
+		Title for the single overlay plot.
+	layers : list[torch.Tensor]
+		Each item is a tensor containing continuous values for that layer (will be flattened).
+	n_grid : int
+		Number of x points for KDE evaluation.
+	n_percentiles : int
+		Number of percentile buckets (e.g. 100 -> percentiles at 0,1,...,100).
+	bandwidths : list or None
+		Optional list of bandwidths per layer; None to use Silverman's rule.
+	show_percentile_lines : bool
+		If True, plots vertical lines for a few percentiles (can clutter plot).
+	compute_metrics : bool
+		If True attempts to compute pairwise similarity metrics and returns them.
+	max_kde_samples : int
+		Maximum number of samples per layer used to compute KDE (subsample if larger).
+	Returns
+	-------
+	dict with keys:
+	  - 'grid': evaluation grid (numpy array)
+	  - 'kdes': list of density arrays (same order as layers)
+	  - 'percentiles': list of percentile arrays per layer
+	  - 'stats': list of dicts {n, mean, std, min, max}
+	  - 'metrics': dict of pairwise metrics (if compute_metrics)
+	:param title:
+	:param layers:
+	:param n_grid:
+	:param n_percentiles:
+	:param bandwidths:
+	:param show_percentile_lines:
+	:param compute_metrics:
+	:param max_kde_samples:
+	:return:
+	"""
+	# prepare data arrays
+	arrs = [_safe_to_numpy(t) for t in layers]
+	stats = []
+	# compute global x-range for consistent plotting
+	finite_arrs = [a for a in arrs if a.size > 0]
+	if len(finite_arrs) == 0:
+		raise ValueError("No finite values found in any input tensor.")
+	global_min = min(a.min() for a in finite_arrs)
+	global_max = max(a.max() for a in finite_arrs)
+	# expand a bit for display
+	pad = 0.01 * (global_max - global_min) if global_max > global_min else 1.0
+	x_min = global_min - pad
+	x_max = global_max + pad
+	grid = np.linspace(x_min, x_max, n_grid, dtype=float)
+
+	if bandwidths is None:
+		bandwidths = [None] * len(arrs)
+	elif len(bandwidths) != len(arrs):
+		raise ValueError("If provided, bandwidths must have same length as layers")
+
+	kdes = []
+	percentiles = []
+	for i, (a, bw) in enumerate(zip(arrs, bandwidths)):
+		if a.size == 0:
+			kdes.append(np.zeros_like(grid))
+			percentiles.append(np.full(n_percentiles + 1, np.nan))
+			stats.append({'n': 0, 'mean': np.nan, 'std': np.nan, 'min': np.nan, 'max': np.nan})
+			continue
+		dens = _gaussian_kde_eval(a, grid, bw=bw, max_samples=max_kde_samples)
+		kdes.append(dens)
+		pct_values = np.percentile(a, np.linspace(0, 100, n_percentiles + 1))
+		percentiles.append(pct_values)
+		stats.append({'n': int(a.size), 'mean': float(a.mean()), 'std': float(a.std(ddof=1)),
+					  'min': float(a.min()), 'max': float(a.max())})
+
+	# plotting
+	fig, ax = plt.subplots(figsize=(10, 6))
+	ax.set_title(title)
+	ax.set_xlabel("value")
+	ax.set_ylabel("density (KDE)")
+	lines = []
+	labels = []
+	for i, dens in enumerate(kdes):
+		# label contains index and base stats
+		s = stats[i]
+		label = f"layer {i} (n={s['n']}, μ={s['mean']:.3g}, σ={s['std']:.3g})"
+		l, = ax.plot(grid, dens, label=label)
+		lines.append(l)
+		labels.append(label)
+		if show_percentile_lines and np.isfinite(percentiles[i]).all():
+			# show a few percentiles lightly (10th, 50th, 90th)
+			for p in (10, 50, 90):
+				v = np.percentile(arrs[i], p)
+				ax.axvline(v, linestyle='--', linewidth=0.6, alpha=0.6)
+
+	ax.legend(loc='best', fontsize='small')
+	ax.grid(True, linestyle=':', alpha=0.4)
+	plt.tight_layout()
+	plt.show()
+
+	result: Dict[str, Any] = {
+		'grid': grid,
+		'kdes': kdes,
+		'percentiles': percentiles,
+		'stats': stats,
+		'fig_ax': (fig, ax)  # note: matplotlib objects included for programmatic use
+	}
+
+	# compute pairwise similarity metrics
+	if compute_metrics:
+		# try to use scipy for Wasserstein and KS if available; otherwise fall back to grid L1
+		pairwise_wasserstein = None
+		pairwise_l1 = np.zeros((len(arrs), len(arrs)), dtype=float)
+		try:
+			from scipy.stats import wasserstein_distance
+			use_wasserstein = True
+			pairwise_wasserstein = np.zeros((len(arrs), len(arrs)), dtype=float)
+		except Exception:
+			use_wasserstein = False
+			pairwise_wasserstein = None
+
+		# L1 between normalized KDEs on the grid: integral |f - g|
+		for i in range(len(arrs)):
+			for j in range(len(arrs)):
+				f = kdes[i]
+				g = kdes[j]
+				pairwise_l1[i, j] = np.trapz(np.abs(f - g), grid)
+				if use_wasserstein:
+					# if one of the arrays empty, put nan
+					a = arrs[i]
+					b = arrs[j]
+					if a.size == 0 or b.size == 0:
+						pairwise_wasserstein[i, j] = np.nan
+					else:
+						pairwise_wasserstein[i, j] = wasserstein_distance(a, b)
+
+		metrics = {'l1_kde': pairwise_l1}
+		if use_wasserstein:
+			metrics['wasserstein'] = pairwise_wasserstein
+		result['metrics'] = metrics
+
+	return result

tracetorch-0.1.0/tracetorch/plot/_line_graph.py

@@ -0,0 +1,42 @@
+import torch
+import matplotlib.pyplot as plt
+
+
+def line_graph(list_of_values, title: str, label=None) -> None:
+	"""
+	Uses a list of values (allows tensors) to make a line graph
+	:param list_of_values:
+	:param title:
+	:param label:
+	:return:
+	"""
+	# Check if it's a list of tensors
+	if isinstance(list_of_values[0], torch.Tensor):
+		T = len(list_of_values)
+		N = list_of_values[0].numel()
+
+		# stack into shape (T, …)
+		data = torch.stack(list_of_values, dim=0)  # if scalars, shape == (T,)
+		if data.dim() == 1:
+			data = data.unsqueeze(1)  # now shape == (T,1)
+
+		data = data.cpu().numpy()
+		x = range(T)
+
+		for neuron_idx in range(N):
+			if label is not None:
+				plt.plot(x, data[:, neuron_idx], label=f'{label[neuron_idx]}')
+			else:
+				plt.plot(x, data[:, neuron_idx], label=f'Neuron {neuron_idx}')
+
+		plt.title(title)
+		if N > 1:
+			plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
+	else:
+		# Assume list of floats (or ints)
+		x = range(len(list_of_values))
+		plt.plot(x, list_of_values)
+		plt.title(title)
+
+	plt.tight_layout()
+	plt.show()

tracetorch-0.1.0/tracetorch/plot/_measurement_manager.py

@@ -0,0 +1,31 @@
+import torch
+from .. import plot
+
+
+class MeasurementManager:
+	"""
+	Manages measurements over time like loss or accuracy
+	"""
+	def __init__(
+			self,
+			title: str,
+			decay: torch.Tensor = torch.tensor([0., 0.9, 0.99, 0.999])
+	):
+		self.title = title
+		self.trace = torch.zeros_like(decay)
+		self.decay = decay
+		self.measurement = []
+
+	def append(self, value):
+		with torch.no_grad():
+			if isinstance(value, torch.Tensor):
+				value = value.item()
+			self.trace *= self.decay
+			self.trace += value * torch.ones_like(self.trace)
+			avg_input = self.trace * (1 - self.decay)
+			self.measurement.append(avg_input)
+
+	def plot(self, title: str = None):
+		plot_title = title if title is not None else self.title
+		rounded_list = [round(x, 4) for x in self.decay.tolist()]
+		plot.line_graph(self.measurement, title=plot_title, label=rounded_list)

tracetorch-0.1.0/tracetorch/plot/_render_image.py

@@ -0,0 +1,109 @@
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import cm
+from matplotlib.colors import Normalize
+
+
+def render_image(tensor, figsize=(4, 4), title=None, vmin=None, vmax=None):
+    """
+    Plot a tensor image.
+
+    - tensor: torch.Tensor in either HW (H,W) or CHW (C,H,W) format.
+              C may be 1 (grayscale) or 3 (RGB).
+    - figsize: matplotlib figure size tuple
+    - title: optional title string
+    - vmin/vmax: if provided, these define the original data range (used for the colorbar).
+                 If None, the function uses tensor.min() / tensor.max().
+    Behavior change for grayscale: the image is rescaled to [0,1] for display (max contrast),
+    but the colorbar shows the original numeric range (vmin..vmax).
+    :param tensor:
+    :param figsize:
+    :param title:
+    :param vmin:
+    :param vmax:
+    :return:
+    """
+    if not torch.is_tensor(tensor):
+        tensor = torch.as_tensor(tensor)
+
+    t = tensor.detach()
+    if t.device.type != "cpu":
+        t = t.cpu()
+
+    # helper to determine original vmin/vmax (either from args or data)
+    def _orig_range(arr, vmin_arg, vmax_arg):
+        data_min = float(np.nanmin(arr))
+        data_max = float(np.nanmax(arr))
+        orig_vmin = data_min if vmin_arg is None else float(vmin_arg)
+        orig_vmax = data_max if vmax_arg is None else float(vmax_arg)
+        return orig_vmin, orig_vmax
+
+    if t.dim() == 2:
+        # HW grayscale
+        img = t.numpy().astype(np.float32)
+
+        orig_vmin, orig_vmax = _orig_range(img, vmin, vmax)
+
+        # avoid divide-by-zero for constant images
+        if orig_vmax > orig_vmin:
+            img_scaled = (img - orig_vmin) / (orig_vmax - orig_vmin)
+            # numerical safety
+            img_scaled = np.clip(img_scaled, 0.0, 1.0)
+        else:
+            # constant image -> show mid-gray but colorbar will show the constant value
+            img_scaled = np.full_like(img, 0.5, dtype=np.float32)
+
+        fig, ax = plt.subplots(figsize=figsize)
+        im = ax.imshow(img_scaled, cmap="gray", vmin=0.0, vmax=1.0, interpolation="nearest")
+        ax.axis("off")
+        if title:
+            ax.set_title(title)
+
+        # colorbar referencing original scale
+        mappable = cm.ScalarMappable(norm=Normalize(vmin=orig_vmin, vmax=orig_vmax), cmap="gray")
+        mappable.set_array([])  # required for colorbar
+        plt.colorbar(mappable, ax=ax, fraction=0.046, pad=0.04)
+        plt.show()
+        return
+
+    if t.dim() == 3:
+        c, h, w = t.shape
+        if c == 1:
+            img = t.squeeze(0).numpy().astype(np.float32)
+
+            orig_vmin, orig_vmax = _orig_range(img, vmin, vmax)
+
+            if orig_vmax > orig_vmin:
+                img_scaled = (img - orig_vmin) / (orig_vmax - orig_vmin)
+                img_scaled = np.clip(img_scaled, 0.0, 1.0)
+            else:
+                img_scaled = np.full_like(img, 0.5, dtype=np.float32)
+
+            fig, ax = plt.subplots(figsize=figsize)
+            im = ax.imshow(img_scaled, cmap="gray", vmin=0.0, vmax=1.0, interpolation="nearest")
+            ax.axis("off")
+            if title:
+                ax.set_title(title)
+
+            mappable = cm.ScalarMappable(norm=Normalize(vmin=orig_vmin, vmax=orig_vmax), cmap="gray")
+            mappable.set_array([])
+            plt.colorbar(mappable, ax=ax, fraction=0.046, pad=0.04)
+            plt.show()
+            return
+
+        elif c == 3:
+            # CHW -> HWC for matplotlib (leave RGB untouched)
+            img = t.permute(1, 2, 0).numpy()
+            img = np.clip(img, 0.0, 1.0)  # assume RGB in 0..1; you can change handling if needed
+            fig, ax = plt.subplots(figsize=figsize)
+            ax.imshow(img, interpolation="nearest")
+            ax.axis("off")
+            if title:
+                ax.set_title(title)
+            plt.show()
+            return
+        else:
+            raise ValueError(f"Unsupported channel dimension: C={c}. Expected C==1 or C==3 for CHW.")
+
+    raise ValueError(f"Unsupported tensor shape {tuple(t.shape)}. Expected HW or CHW.")

tracetorch-0.1.0/tracetorch/plot/_spike_train.py

@@ -0,0 +1,75 @@
+import torch
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def spike_train(
+		list_of_tensors,
+		spacing: float = 1.0,
+		linelength: float = 0.8,
+		linewidth: float = 0.5,
+		title: str = "Spike Train Raster",
+		use_imshow: bool = True,
+):
+	"""
+	Plot a spike train raster for a list of 1D tensors.
+
+	If use_imshow is True, uses imshow with grayscale to reflect values
+	(0=white, 1=black). Otherwise falls back to eventplot, plotting spikes
+	(only non-zero) in black.
+
+	Args:
+		list_of_tensors: list of 1D torch.Tensors of equal length T.
+		spacing: vertical spacing between rows.
+		linelength: length of eventplot lines (ignored for imshow).
+		linewidth: width of eventplot lines (ignored for imshow).
+		title: figure title.
+		use_imshow: whether to plot using imshow and grayscale mapping.
+	:param list_of_tensors:
+	:param spacing:
+	:param linelength:
+	:param linewidth:
+	:param title:
+	:param use_imshow:
+	:return:
+	"""
+	# Stack into 2D array: shape (num_neurons, T)
+	# list_of_tensors assumed length T each
+	data = torch.stack(list_of_tensors).cpu().numpy()  # shape (T, N)
+	data = data.T  # shape (N, T)
+
+	plt.figure(figsize=(8, 4))
+	if use_imshow:
+		# Display as image with grayscale: 1=black, 0=white
+		plt.imshow(
+			data,
+			aspect='auto',
+			cmap='gray_r',
+			origin='lower',
+			interpolation='nearest'
+		)
+		plt.colorbar(label='Spike value')
+	else:
+		N, T = data.shape
+		# for each neuron i, list of spike times where value != 0
+		spike_times = [
+			[t for t in range(T) if data[i, t] != 0]
+			for i in range(N)
+		]
+		# y offsets
+		offsets = np.arange(N) * spacing
+		plt.eventplot(
+			spike_times,
+			orientation='horizontal',
+			lineoffsets=offsets,
+			linelengths=linelength,
+			linewidths=linewidth,
+			colors='k'
+		)
+		plt.ylim(-spacing, offsets[-1] + spacing)
+
+	plt.xlabel("Time step")
+	plt.ylabel("Neuron index")
+	plt.title(title)
+	plt.tight_layout()
+	plt.show()

tracetorch-0.1.0/tracetorch.egg-info/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: tracetorch
+Version: 0.1.0
+Summary: An extension to PyTorch: SNN layers that function on traces.
+Author-email: Yegor Men <yegor.mn@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Yegor-men/tracetorch
+Project-URL: Repository, https://github.com/Yegor-men/tracetorch
+Project-URL: Issues, https://github.com/Yegor-men/tracetorch/issues
+Project-URL: Documentation, https://yegor-men.github.io/tracetorch/
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+![traceTorch Banner](media/tracetorch_banner.png)
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-purple.svg)](https://www.apache.org/licenses/LICENSE-2.0)
+
+``traceTorch`` is a PyTorch-based library built on the principles of spiking neural networks, replacing the PyTorch
+default backpropagation through time with lightweight, per-layer input traces, enabling biologically inspired, constant
+time and memory consumption learning on arbitrarily long or even streaming sequences.
+
+## Documentation
+
+It is highly recommended that you read the [documentation](https://yegor-men.github.io/tracetorch/) first. It contains:
+
+1. **Introduction**: An introduction to traceTorch, how and why it works, it's founding principles. It's thoroughly
+   recommended that you read through the entire introduction and gain an intuitive understanding before proceeding.
+2. **Tutorials**: Various tutorials to create your own traceTorch models. The resultant code can be found in
+   `tutorials/`.
+3. **Documentation**: The actual documentation to all the modules included in `traceTorch`. It includes detailed
+   explanations, examples and math to gain a full understanding.
+
+## Roadmap
+
+- Create the poisson click test example
+- Implement the trace alternative to REINFORCE
+- Make traceTorch into a PyPI library
+- Finish writing the documentation
+- Clean up the tutorial code
+- Implement abstract graph based models, not just sequential
+
+## Installation
+
+⚠️ WARNING, traceTorch is _not yet_ a library. For now, you'll just have to clone this repository and use the
+`tracetorch/` folder within.
+
+```
+git clone https://github.com/Yegor-men/tracetorch
+cd tracetorch/
+pip install -r requirements.txt
+```
+
+Then, within a python file where from where the repository root folder is visible, simply do:
+
+```
+from tracetorch import tracetorch
+```
+
+## Usage examples
+
+`tutorials/` contains all the tutorial files, ready to run and playtest. The tutorials themselves can be
+found [here](https://yegor-men.github.io/tracetorch/tutorials/index.html).
+
+To ensure that you have all the necessary packages for the tutorials installed, please execute the following command:
+
+```
+cd tutorials/
+pip install -r requirements.txt
+```
+
+## Authors
+
+- [@Yegor-men](https://github.com/Yegor-men)
+
+## Acknowledgements
+
+I built traceTorch from the ground up, trying to reverse engineer biological neurons with a sprinkle of intelligent
+design, but I would also like to recognize the following projects and people who helped shape my thinking:
+
+- [snntorch](https://github.com/jeshraghian/snntorch) for introducing me to SNN networks in the first place, and their
+  principles of function. Ironically, its dependency on constructing the full autograd graph is what largely inspired me
+  to make traceTorch.
+- [Artem Kirsanov](https://www.youtube.com/@ArtemKirsanov) for introducing me to computational neuroscience, presenting
+  interesting concepts in an easy-to-understand manner. My earliest tests, when I naively wanted to implement 1:1
+  biological neurons, largely revolved around his work.
+- [e-prop (eligibility propagation)](https://www.biorxiv.org/content/biorxiv/early/2020/04/16/738385.full.pdf) inspired
+  the whole "trace" concept, the idea of keeping a decaying value. Earlier, before traceTorch, I wanted to use e-prop
+  for online learning instead. Admittedly unsuccessful in my attempts, and a little put off by the relative difficulty,
+  I instead wanted to make something simpler.
+
+## Contributing
+
+Contributions are always welcome. Feel free to submit pull requests or report issues, I will occasionally check in on
+it.
+
+You can also reach out to me via either email or Twitter:
+
+- yegor.mn@gmail.com
+- [Twitter](https://x.com/Yegor_Men)

tracetorch-0.1.0/tracetorch.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+LICENSE
+README.md
+pyproject.toml
+tracetorch/__init__.py
+tracetorch.egg-info/PKG-INFO
+tracetorch.egg-info/SOURCES.txt
+tracetorch.egg-info/dependency_links.txt
+tracetorch.egg-info/requires.txt
+tracetorch.egg-info/top_level.txt
+tracetorch/functional/__init__.py
+tracetorch/functional/_sample_softmax.py
+tracetorch/functional/_sigmoid_inverse.py
+tracetorch/functional/_softplus_inverse.py
+tracetorch/loss/__init__.py
+tracetorch/loss/_mse.py
+tracetorch/nn/__init__.py
+tracetorch/nn/_lif.py
+tracetorch/nn/_lis.py
+tracetorch/nn/_sequential.py
+tracetorch/plot/__init__.py
+tracetorch/plot/_distributions.py
+tracetorch/plot/_line_graph.py
+tracetorch/plot/_measurement_manager.py
+tracetorch/plot/_render_image.py
+tracetorch/plot/_spike_train.py

tracetorch-0.1.0/tracetorch.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tracetorch-0.1.0/tracetorch.egg-info/requires.txt

@@ -0,0 +1,3 @@
+torch
+numpy
+matplotlib

tracetorch-0.1.0/tracetorch.egg-info/top_level.txt

@@ -0,0 +1 @@
+tracetorch