neuralplex 0.3.0__tar.gz → 0.3.2__tar.gz

neuralplex-0.3.2/PKG-INFO

@@ -0,0 +1,212 @@
+Metadata-Version: 2.5
+Name: neuralplex
+Version: 0.3.2
+Summary: A neural network implementation built as an explicit graph of neurons and weighted connections.
+Project-URL: Homepage, https://github.com/adamjpatterson/neuralplex
+Project-URL: Issues, https://github.com/adamjpatterson/neuralplex/issues
+Author-email: FAR Analytics & Research <adpatter2000@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Neural-pleX
+
+[![PyPI version](https://img.shields.io/pypi/v/neuralplex.svg)](https://pypi.org/project/neuralplex/) [![Python versions](https://img.shields.io/pypi/pyversions/neuralplex.svg)](https://pypi.org/project/neuralplex/) [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/adamjpatterson/neuralplex/blob/main/LICENSE)
+
+A neural network implementation built as an explicit graph of neurons and weighted connections.
+
+## Introduction
+
+**Neural-pleX** represents individual neurons and their connections explicitly, with manual backpropagation. The Neural-pleX API consists of Network, Layer, and Neuron constructors. The networks can be easily [visualized](#visualizations-of-the-network-before-and-after-training) using a visualization library.
+
+## Table of contents
+
+- [Installation](#installation)
+- [How it works](#how-it-works)
+- [Examples](#examples)
+- [The nibble challenge](#the-nibble-challenge)
+- [The digits experiment](#the-digits-experiment)
+- [Tests](#tests)
+- [Documentation maintenance](#documentation-maintenance)
+
+## Installation
+
+To use the published package:
+
+```bash
+python -m pip install neuralplex
+```
+
+## How it works
+
+This implementation demonstrates each component of the API. A 3 layer neural network is constructed that has a 4 neuron input Layer and a 1 neuron output layer. The hidden layer has 8 neurons.
+
+### Implement a 3 layer neural network
+
+#### Import the Network, Layer, and Neuron classes.
+
+```python
+from neuralplex import Network, Layer, Neuron
+```
+
+#### Set a step.
+
+`step` is the learning rate: it controls the size of weight and bias updates. Each update subtracts `step` times the corresponding gradient. `Layer(step=...)` supplies an initial default only to neurons whose `step` is `None`. Changing `layer.step` later does not change the neurons; update each `neuron.step` directly to change its learning rate.
+
+```python
+STEP = 0.01
+```
+
+#### Construct a neural network by specifying the Neurons for each Layer and adding the Layers to a Network.
+
+```python
+l1 = Layer(neurons=[Neuron() for i in range(0, 4)], step=STEP)
+l2 = Layer(neurons=[Neuron() for i in range(0, 8)], step=STEP)
+l3 = Layer(neurons=[Neuron()], step=STEP)
+n1 = Network([l1, l2, l3], seed=42)
+```
+
+#### With the Network defined, you can train the network.
+
+Here the network is trained to recognize the nibble 1111 as the decimal number 15.
+
+```python
+n1.train([1,1,1,1], [15])
+```
+
+You can generate and print a prediction using the `predict` method. Because the network underwent just one iteration of training, the estimate will likely be inaccurate. The accuracy of the prediction can be improved by iteratively training the network. Please see [the nibble challenge](#the-nibble-challenge) for an example of how to iteratively train the network.
+
+```python
+prediction = n1.predict([1,1,1,1])
+print(prediction)
+```
+
+### How a neuron learns
+
+Each computational neuron calculates `activation(sum(source.value * weight) + bias)`. Inputs hold raw values. `Neuron()` uses linear activation; `Neuron(activation="tanh")` is available for hidden layers.
+
+`Network.train` minimizes half the sum of squared output errors. It runs the forward pass, accumulates gradients backward through every connection, and only then updates weights and biases. `delta` is the derivative of the loss with respect to the neuron's weighted sum plus bias, before activation. A weight's gradient is `delta * source.value`; the bias gradient is `delta`. The code uses explicit loops, not automatic differentiation. Every non-input neuron needs a finite, positive `step` for training.
+
+`Neuron(bias=...)` sets the bias. Each incoming connection has its own weight, stored in the receiver neuron's `weights[source]`. `Network(..., seed=42)` initializes weights reproducibly in [-0.1, 0.1]. Connections added later accept an explicit `weight`; repeated connection calls preserve existing weights.
+
+### Explore a trained network
+
+After training, remove a connection and compare predictions to see how it affects the network. This experiment is called an ablation.
+
+Using your trained network as `n1`:
+
+```python
+inputs = [1, 0, 1, 0]
+source = n1.layers[1].neurons[0]
+receiver = n1.output_layer.neurons[0]
+weight = receiver.weights[source]
+before = n1.predict(inputs)
+
+source.disconnectRHS(receiver)
+after = n1.predict(inputs)
+print("Original prediction:", before)
+print("Without the connection:", after)
+
+source.connectRHS(receiver, weight=weight)
+```
+
+Try several inputs: a connection's effect can depend on the input. To explore a whole hidden neuron, `n1.detach(neuron)` removes it from its layer and disconnects all its incoming and outgoing edges. Save those weights before detaching if you want to restore it, then add the neuron back to its layer and reconnect its edges. Its bias, activation, and learning rate remain on the object.
+
+You can also change an existing weight through `receiver.weights[source]`. Use the connection methods to add or remove edges so incoming weights and outgoing connections stay consistent.
+
+## Examples
+
+### The nibble challenge
+
+#### Setup
+
+Change directory into the example project from the repository root.
+
+```
+cd examples/the_nibble_challenge
+```
+
+Install the example dependencies.
+
+```
+pip install .
+```
+
+#### Explore the notebook
+
+Open [the nibble challenge notebook](https://github.com/adamjpatterson/neuralplex/blob/main/examples/the_nibble_challenge/main.ipynb). It introduces all sixteen four-bit inputs, constructs a 4 → 8 → 1 network, compares initial and trained predictions, and lets you change an input to inspect weights and activations. With seed 42, a step of 0.01, and 10,000 training examples, the displayed R² rounds to 1.000000000.
+
+Training and evaluation both use all sixteen nibbles.
+
+##### Visualizations of the network before and after training
+
+![Nibble network before and after training](https://raw.githubusercontent.com/adamjpatterson/neuralplex/main/images/nibble_multiweight.png)
+
+- Edge thickness is proportional to the absolute connection weight. Blue is positive; orange is negative. Zero-weight edges have zero width.
+- Node area above a small visibility floor is proportional to absolute activation. Green nodes are inputs, red nodes are hidden, and yellow is the output.
+- Both panels use the same input, positions, and scales. Node size represents activity, not importance, and does not encode the activation's sign.
+
+The notebook imports `visualize_network` from [its visualization module](https://github.com/adamjpatterson/neuralplex/blob/main/examples/the_nibble_challenge/visualizations.py).
+
+### The digits experiment
+
+#### Setup
+
+Change directory into the example project from the repository root.
+
+```bash
+cd examples/the_digits_experiment
+```
+
+Install the example dependencies.
+
+```bash
+pip install .
+```
+
+#### Explore the notebook
+
+Open [the digits experiment notebook](https://github.com/adamjpatterson/neuralplex/blob/main/examples/the_digits_experiment/main.ipynb). It starts by displaying the [8×8 digits dataset](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html), then normalizes pixels, creates a training/test split, constructs a 64 → 16 → 10 network, trains, and evaluates unseen images. You can inspect an individual prediction and its ten output scores. Scores are not probabilities.
+
+The reproducible settings use seed 42, 1,347 training images, 450 test images, 20 epochs, and a step of 0.001. The example achieves **90.22% test accuracy**, compared with **10.22%** for always predicting the most common training digit.
+
+The notebook imports `plot_predictions` and `plot_confusion_matrix` from [its visualization module](https://github.com/adamjpatterson/neuralplex/blob/main/examples/the_digits_experiment/visualizations.py).
+
+#### Digits predictions and confusion matrix
+
+The prediction figure shows the first twelve test images. The confusion matrix includes all 450 test images; rows show the true digit and columns show the predicted digit.
+
+![Digits predictions](https://raw.githubusercontent.com/adamjpatterson/neuralplex/main/images/digits_predictions.png)
+
+![Digits confusion matrix](https://raw.githubusercontent.com/adamjpatterson/neuralplex/main/images/digits_confusion_matrix.png)
+
+## Tests
+
+The suite in `tests/test.py` checks forward calculations, manual gradients, parameter updates, detachment and reconnection, and input validation.
+
+#### Run all tests.
+
+```bash
+python -m unittest -v
+```
+
+## Documentation maintenance
+
+### Regenerating README figures
+
+The [documentation-image project](https://github.com/adamjpatterson/neuralplex/blob/main/docs/README.md) has its own dependencies and fixed seed-42 scenarios. From `docs/`, after following its environment setup:
+
+```bash
+python generate_images.py
+```
+
+It writes the nibble network image, digits predictions, and confusion matrix to `images/`.
+
+## Support
+
+If you have a feature request or run into any issues, feel free to submit an [issue](https://github.com/adamjpatterson/neuralplex/issues). You’re also welcome to reach out to one of the authors.
+
+- [Adam Patterson](https://github.com/adamjpatterson)

neuralplex-0.3.2/README.md

@@ -0,0 +1,198 @@
+# Neural-pleX
+
+[![PyPI version](https://img.shields.io/pypi/v/neuralplex.svg)](https://pypi.org/project/neuralplex/) [![Python versions](https://img.shields.io/pypi/pyversions/neuralplex.svg)](https://pypi.org/project/neuralplex/) [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/adamjpatterson/neuralplex/blob/main/LICENSE)
+
+A neural network implementation built as an explicit graph of neurons and weighted connections.
+
+## Introduction
+
+**Neural-pleX** represents individual neurons and their connections explicitly, with manual backpropagation. The Neural-pleX API consists of Network, Layer, and Neuron constructors. The networks can be easily [visualized](#visualizations-of-the-network-before-and-after-training) using a visualization library.
+
+## Table of contents
+
+- [Installation](#installation)
+- [How it works](#how-it-works)
+- [Examples](#examples)
+- [The nibble challenge](#the-nibble-challenge)
+- [The digits experiment](#the-digits-experiment)
+- [Tests](#tests)
+- [Documentation maintenance](#documentation-maintenance)
+
+## Installation
+
+To use the published package:
+
+```bash
+python -m pip install neuralplex
+```
+
+## How it works
+
+This implementation demonstrates each component of the API. A 3 layer neural network is constructed that has a 4 neuron input Layer and a 1 neuron output layer. The hidden layer has 8 neurons.
+
+### Implement a 3 layer neural network
+
+#### Import the Network, Layer, and Neuron classes.
+
+```python
+from neuralplex import Network, Layer, Neuron
+```
+
+#### Set a step.
+
+`step` is the learning rate: it controls the size of weight and bias updates. Each update subtracts `step` times the corresponding gradient. `Layer(step=...)` supplies an initial default only to neurons whose `step` is `None`. Changing `layer.step` later does not change the neurons; update each `neuron.step` directly to change its learning rate.
+
+```python
+STEP = 0.01
+```
+
+#### Construct a neural network by specifying the Neurons for each Layer and adding the Layers to a Network.
+
+```python
+l1 = Layer(neurons=[Neuron() for i in range(0, 4)], step=STEP)
+l2 = Layer(neurons=[Neuron() for i in range(0, 8)], step=STEP)
+l3 = Layer(neurons=[Neuron()], step=STEP)
+n1 = Network([l1, l2, l3], seed=42)
+```
+
+#### With the Network defined, you can train the network.
+
+Here the network is trained to recognize the nibble 1111 as the decimal number 15.
+
+```python
+n1.train([1,1,1,1], [15])
+```
+
+You can generate and print a prediction using the `predict` method. Because the network underwent just one iteration of training, the estimate will likely be inaccurate. The accuracy of the prediction can be improved by iteratively training the network. Please see [the nibble challenge](#the-nibble-challenge) for an example of how to iteratively train the network.
+
+```python
+prediction = n1.predict([1,1,1,1])
+print(prediction)
+```
+
+### How a neuron learns
+
+Each computational neuron calculates `activation(sum(source.value * weight) + bias)`. Inputs hold raw values. `Neuron()` uses linear activation; `Neuron(activation="tanh")` is available for hidden layers.
+
+`Network.train` minimizes half the sum of squared output errors. It runs the forward pass, accumulates gradients backward through every connection, and only then updates weights and biases. `delta` is the derivative of the loss with respect to the neuron's weighted sum plus bias, before activation. A weight's gradient is `delta * source.value`; the bias gradient is `delta`. The code uses explicit loops, not automatic differentiation. Every non-input neuron needs a finite, positive `step` for training.
+
+`Neuron(bias=...)` sets the bias. Each incoming connection has its own weight, stored in the receiver neuron's `weights[source]`. `Network(..., seed=42)` initializes weights reproducibly in [-0.1, 0.1]. Connections added later accept an explicit `weight`; repeated connection calls preserve existing weights.
+
+### Explore a trained network
+
+After training, remove a connection and compare predictions to see how it affects the network. This experiment is called an ablation.
+
+Using your trained network as `n1`:
+
+```python
+inputs = [1, 0, 1, 0]
+source = n1.layers[1].neurons[0]
+receiver = n1.output_layer.neurons[0]
+weight = receiver.weights[source]
+before = n1.predict(inputs)
+
+source.disconnectRHS(receiver)
+after = n1.predict(inputs)
+print("Original prediction:", before)
+print("Without the connection:", after)
+
+source.connectRHS(receiver, weight=weight)
+```
+
+Try several inputs: a connection's effect can depend on the input. To explore a whole hidden neuron, `n1.detach(neuron)` removes it from its layer and disconnects all its incoming and outgoing edges. Save those weights before detaching if you want to restore it, then add the neuron back to its layer and reconnect its edges. Its bias, activation, and learning rate remain on the object.
+
+You can also change an existing weight through `receiver.weights[source]`. Use the connection methods to add or remove edges so incoming weights and outgoing connections stay consistent.
+
+## Examples
+
+### The nibble challenge
+
+#### Setup
+
+Change directory into the example project from the repository root.
+
+```
+cd examples/the_nibble_challenge
+```
+
+Install the example dependencies.
+
+```
+pip install .
+```
+
+#### Explore the notebook
+
+Open [the nibble challenge notebook](https://github.com/adamjpatterson/neuralplex/blob/main/examples/the_nibble_challenge/main.ipynb). It introduces all sixteen four-bit inputs, constructs a 4 → 8 → 1 network, compares initial and trained predictions, and lets you change an input to inspect weights and activations. With seed 42, a step of 0.01, and 10,000 training examples, the displayed R² rounds to 1.000000000.
+
+Training and evaluation both use all sixteen nibbles.
+
+##### Visualizations of the network before and after training
+
+![Nibble network before and after training](https://raw.githubusercontent.com/adamjpatterson/neuralplex/main/images/nibble_multiweight.png)
+
+- Edge thickness is proportional to the absolute connection weight. Blue is positive; orange is negative. Zero-weight edges have zero width.
+- Node area above a small visibility floor is proportional to absolute activation. Green nodes are inputs, red nodes are hidden, and yellow is the output.
+- Both panels use the same input, positions, and scales. Node size represents activity, not importance, and does not encode the activation's sign.
+
+The notebook imports `visualize_network` from [its visualization module](https://github.com/adamjpatterson/neuralplex/blob/main/examples/the_nibble_challenge/visualizations.py).
+
+### The digits experiment
+
+#### Setup
+
+Change directory into the example project from the repository root.
+
+```bash
+cd examples/the_digits_experiment
+```
+
+Install the example dependencies.
+
+```bash
+pip install .
+```
+
+#### Explore the notebook
+
+Open [the digits experiment notebook](https://github.com/adamjpatterson/neuralplex/blob/main/examples/the_digits_experiment/main.ipynb). It starts by displaying the [8×8 digits dataset](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html), then normalizes pixels, creates a training/test split, constructs a 64 → 16 → 10 network, trains, and evaluates unseen images. You can inspect an individual prediction and its ten output scores. Scores are not probabilities.
+
+The reproducible settings use seed 42, 1,347 training images, 450 test images, 20 epochs, and a step of 0.001. The example achieves **90.22% test accuracy**, compared with **10.22%** for always predicting the most common training digit.
+
+The notebook imports `plot_predictions` and `plot_confusion_matrix` from [its visualization module](https://github.com/adamjpatterson/neuralplex/blob/main/examples/the_digits_experiment/visualizations.py).
+
+#### Digits predictions and confusion matrix
+
+The prediction figure shows the first twelve test images. The confusion matrix includes all 450 test images; rows show the true digit and columns show the predicted digit.
+
+![Digits predictions](https://raw.githubusercontent.com/adamjpatterson/neuralplex/main/images/digits_predictions.png)
+
+![Digits confusion matrix](https://raw.githubusercontent.com/adamjpatterson/neuralplex/main/images/digits_confusion_matrix.png)
+
+## Tests
+
+The suite in `tests/test.py` checks forward calculations, manual gradients, parameter updates, detachment and reconnection, and input validation.
+
+#### Run all tests.
+
+```bash
+python -m unittest -v
+```
+
+## Documentation maintenance
+
+### Regenerating README figures
+
+The [documentation-image project](https://github.com/adamjpatterson/neuralplex/blob/main/docs/README.md) has its own dependencies and fixed seed-42 scenarios. From `docs/`, after following its environment setup:
+
+```bash
+python generate_images.py
+```
+
+It writes the nibble network image, digits predictions, and confusion matrix to `images/`.
+
+## Support
+
+If you have a feature request or run into any issues, feel free to submit an [issue](https://github.com/adamjpatterson/neuralplex/issues). You’re also welcome to reach out to one of the authors.
+
+- [Adam Patterson](https://github.com/adamjpatterson)

neuralplex-0.3.2/docs/README.md

@@ -0,0 +1,34 @@
+# README image generation
+
+This project generates the repository's three README illustrations.
+
+## Setup and run
+
+Use Python 3.11 or later. From this directory in the Neuralplex checkout:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+python -m pip install -e .. .
+python generate_images.py
+```
+
+On Windows, activate with `.venv\Scripts\activate` instead.
+
+## Fixed scenarios
+
+The generator uses seed **42** with these settings:
+
+- Nibbles: a linear 4 → 8 → 1 network, step 0.01, 10,000 training examples, and input `1010` for the before/after picture. Positions and visual scales are shared between the two panels.
+- Digits: a 64 → 16 (tanh) → 10 (linear) network, step 0.001, 20 epochs, and a stratified 75%/25% training/test split. Pixels are divided by 16. Only training images are passed to `train`.
+- Prediction samples: the first twelve test images in split order. The confusion matrix uses all 450 test images.
+
+The script prints the nibble R² and digits accuracy, and overwrites:
+
+- `../images/nibble_multiweight.png`
+- `../images/digits_predictions.png`
+- `../images/digits_confusion_matrix.png`
+
+Review the regenerated images and update any reported README results when changing these settings.
+
+With these settings and seed 42, the verified run prints nibble R² `1.000000000` and digits accuracy `90.22%`.

{neuralplex-0.3.0 → neuralplex-0.3.2}/docs/generate_images.py

@@ -1,4 +1,4 @@
-"""Generate the root README images directly, without importing or running examples."""
+"""Generate the root README images."""
 
 from copy import deepcopy
 from math import sqrt

neuralplex-0.3.2/examples/the_digits_experiment/README.md

@@ -0,0 +1,14 @@
+# The digits experiment
+
+## Setup
+
+From the repository root, change into the example directory and install its dependencies:
+
+```bash
+cd examples/the_digits_experiment
+pip install .
+```
+
+## Explore
+
+Open [main.ipynb](main.ipynb) and run the cells in order.

{neuralplex-0.3.0 → neuralplex-0.3.2}/examples/the_digits_experiment/main.ipynb

@@ -8,7 +8,7 @@
     "# The digits experiment\n",
     "Recognize handwritten digits using the [scikit-learn 8×8 digits dataset](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html) and Neuralplex's manual backpropagation.\n",
     "\n",
-    "Follow the [project setup instructions](README.md), then open this notebook in Jupyter with that Python environment. Its working directory should be this notebook's directory so the local visualization import works.\n",
+    "Follow the [project setup instructions](README.md), then run the cells below.\n",
     "\n",
     "Run cells in order. Restart the kernel and run all cells when changing model parameters; rerunning the training cell alone continues training. The final test set is for evaluation, not choosing hyperparameters. If you want to tune, first reserve a validation subset from the training data.\n"
    ]
@@ -356,7 +356,7 @@
    "metadata": {},
    "source": [
     "## 5. Evaluate unseen images\n",
-    "Predict the test images only after training. Compare accuracy with a baseline that always predicts the most common training digit. This is a learning demonstration, not a pass/fail test of the package.\n"
+    "Predict the test images only after training. Compare accuracy with a baseline that always predicts the most common training digit.\n"
    ]
   },
   {
@@ -419,7 +419,7 @@
    "metadata": {},
    "source": [
     "## 6. Inspect predictions and errors\n",
-    "These are the first twelve test images in split order, not selected successes. The confusion matrix includes all test images. Rows are true labels and columns are predictions.\n"
+    "These are the first twelve test images in split order. The confusion matrix includes all test images. Rows are true labels and columns are predictions.\n"
    ]
   },
   {
@@ -474,7 +474,7 @@
    "metadata": {},
    "source": [
     "## 7. Explore one prediction\n",
-    "Change `test_position` to inspect another held-out image and its ten scores. This does not train the model. A large score should not be interpreted as a calibrated probability.\n"
+    "Change `test_position` to inspect another held-out image and its ten scores.\n"
    ]
   },
   {
@@ -533,19 +533,6 @@
     "display(inspection_figure)\n",
     "plt.close(inspection_figure)\n"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-18",
-   "metadata": {},
-   "source": [
-    "## Things to try\n",
-    "- Examine the most frequent confusions and the corresponding images.\n",
-    "- Change the training budget or hidden-layer size, then restart and run all cells.\n",
-    "- Reserve a validation set before comparing hyperparameters; keep the test set for the final evaluation.\n",
-    "\n",
-    "The measured accuracy above describes this split and training configuration; it is not an estimate of the best possible performance.\n"
-   ]
   }
  ],
  "metadata": {

neuralplex-0.3.2/examples/the_nibble_challenge/README.md

@@ -0,0 +1,14 @@
+# The nibble challenge
+
+## Setup
+
+From the repository root, change into the example directory and install its dependencies:
+
+```bash
+cd examples/the_nibble_challenge
+pip install .
+```
+
+## Explore
+
+Open [main.ipynb](main.ipynb) and run the cells in order.

{neuralplex-0.3.0 → neuralplex-0.3.2}/examples/the_nibble_challenge/main.ipynb

@@ -8,7 +8,7 @@
     "# The nibble challenge\n",
     "A nibble is four binary digits. We will teach a 4 → 8 → 1 network to convert them into a decimal value, then inspect how its weights and activations change.\n",
     "\n",
-    "Use the current Neuralplex API. Follow the [project setup instructions](README.md), then open this notebook with Jupyter. Select your Neuralplex Python environment. The kernel working directory should be this notebook's directory so `from visualizations import ...` finds its neighboring module.\n",
+    "Follow the [project setup instructions](README.md), then run the cells below.\n",
     "\n",
     "Run the cells in order. To change the seed, learning rate, or training budget, **restart the kernel and run all cells**. Re-running only training continues from the existing weights.\n"
    ]
@@ -167,7 +167,7 @@
    "metadata": {},
    "source": [
     "## 4. Train one example at a time\n",
-    "Each `train` call performs a forward pass, calculates gradients backward, and then updates parameters. The loss is half the sum of squared output errors. The loop is here in the notebook so you can change or inspect it.\n"
+    "Each `train` call performs a forward pass, calculates gradients backward, and then updates parameters. The loss is half the sum of squared output errors.\n"
    ]
   },
   {
@@ -232,7 +232,7 @@
    "metadata": {},
    "source": [
     "## 5. Evaluate all sixteen nibbles\n",
-    "Compare the predictions and mean squared error. These measurements describe learning; package correctness is checked separately in `tests/test.py`.\n"
+    "Compare the predictions and mean squared error.\n"
    ]
   },
   {
@@ -345,9 +345,7 @@
    "metadata": {},
    "source": [
     "## 7. Visualize before and after\n",
-    "The helper is imported from the neighboring `visualizations.py`. Both panels use the same input, positions, and scales. Blue edges are positive; orange edges are negative. Thickness shows absolute weight. Node area above a small visibility floor shows absolute activation—not importance. Input, hidden, and output nodes are green, red, and yellow.\n",
-    "\n",
-    "The helper copies the models before calculating the displayed activations; it does not modify or train them.\n"
+    "The helper is imported from the neighboring `visualizations.py`. Both panels use the same input, positions, and scales. Blue edges are positive; orange edges are negative. Thickness shows absolute weight. Node area above a small visibility floor shows absolute activation—not importance. Input, hidden, and output nodes are green, red, and yellow."
    ]
   },
   {
@@ -379,20 +377,6 @@
     "display(network_figure)\n",
     "plt.close(network_figure)\n"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-18",
-   "metadata": {},
-   "source": [
-    "## Things to try\n",
-    "- Reduce `ITERATIONS` and inspect the imperfect predictions.\n",
-    "- Change `STEP`, then restart and run all cells to compare fairly.\n",
-    "- Change the hidden-layer size and inspect the connections.\n",
-    "- Try each input nibble and observe that weights stay fixed while activations change.\n",
-    "\n",
-    "Keep these explorations separate from the formal correctness suite.\n"
-   ]
   }
  ],
  "metadata": {

{neuralplex-0.3.0 → neuralplex-0.3.2}/examples/the_nibble_challenge/visualizations.py

@@ -1,4 +1,4 @@
-"""Rendering helpers for the nibble notebook; no training happens here."""
+"""Rendering helpers for the nibble notebook."""
 
 from copy import deepcopy
 from math import sqrt

{neuralplex-0.3.0 → neuralplex-0.3.2}/pyproject.toml

@@ -8,7 +8,7 @@ dynamic = ["version"]
 authors = [
   { name="FAR Analytics & Research", email="adpatter2000@gmail.com" },
 ]
-description = "An object oriented neural network implementation."
+description = "A neural network implementation built as an explicit graph of neurons and weighted connections."
 readme = "README.md"
 requires-python = ">=3.11"
 classifiers = [

neuralplex-0.3.2/src/neuralplex/__about__.py

@@ -0,0 +1 @@
+__version__ = "0.3.2"

{neuralplex-0.3.0 → neuralplex-0.3.2}/src/neuralplex/layer.py

@@ -1,3 +1,4 @@
+from math import isfinite
 from typing import Self
 from random import Random
 
@@ -6,8 +7,8 @@ from neuralplex.neuron import Neuron
 
 class Layer:
     def __init__(self, neurons: list[Neuron], step: float | None = None):
-        if step is not None and step <= 0:
-            raise ValueError("step must be positive")
+        if step is not None and (not isfinite(step) or step <= 0):
+            raise ValueError("step must be finite and positive")
         self.neurons = neurons
         self.step = step
         for neuron in neurons:

{neuralplex-0.3.0 → neuralplex-0.3.2}/src/neuralplex/network.py

@@ -1,3 +1,4 @@
+from math import isfinite
 from random import Random
 
 from neuralplex.layer import Layer
@@ -48,8 +49,8 @@ class Network:
             raise ValueError("Supply one target value per output neuron")
         for layer in self.layers[1:]:
             for neuron in layer.neurons:
-                if neuron.step is None or neuron.step <= 0:
-                    raise ValueError("Every computational neuron needs a positive step")
+                if neuron.step is None or not isfinite(neuron.step) or neuron.step <= 0:
+                    raise ValueError("Every computational neuron needs a finite, positive step")
         self.predict(X_train)
 
         # Clear all gradients, including those accumulated at input neurons.

{neuralplex-0.3.0 → neuralplex-0.3.2}/src/neuralplex/neuron.py

@@ -1,4 +1,4 @@
-from math import tanh
+from math import isfinite, tanh
 from random import uniform
 from typing import Self
 
@@ -10,8 +10,8 @@ class Neuron:
                  name=None, activation: str = "linear"):
         if activation not in ("linear", "tanh"):
             raise ValueError("activation must be 'linear' or 'tanh'")
-        if step is not None and step <= 0:
-            raise ValueError("step must be positive")
+        if step is not None and (not isfinite(step) or step <= 0):
+            raise ValueError("step must be finite and positive")
         self.bias = bias
         self.step = step
         self.name = name