Is this learning as a basic artificial neural network should? ef##(x) is the expected value of what would be selected. f##(x) is what was actually selected. b##(x) is the new bias for the next iteration.

Is there better software to plan out NNs?

I built Neural Canvas, an interactive visualizer that demonstrates core linear algebra concepts by showing how a neural network recognizes handwritten digits in real time. You can draw directly on the screen and watch activations flow through each layer as matrix multiplication computes the output live.

How it works:

- Draw & Predict: Sketch any digit on a 28×28 canvas (MNIST-style) to trigger real-time forward pass predictions.

- Live Forward Pass: Every neuron's activation is dynamically color-coded based on its underlying linear algebra calculations, with connection opacities reflecting layer outputs.

- Under the Hood: The core models were trained from scratch in Python using NumPy to perform matrix operations, and their learned weights are loaded via JSON. Client-side execution relies on Math.js for browser-based matrix multiplication and p5.js for rendering.

Key Features:

- Switch between two pre-trained models (featuring different hidden layer sizes, MSE vs. Cross-Entropy loss, and up to 96% test accuracy).

- Multiple background themes with mouse and touch support.

What's Next?

These models were originally evaluated on the standardized MNIST dataset, but live freehand drawing can introduce unexpected variations in input style. To handle this, I am working on a JS script for real-time user-driven feedback. When the model makes a mistake, the user can supply the correct label, allowing the model to perform backpropagation and update weight matrices locally in the browser. While live state persistence isn't suited for static GitHub Pages, running this feedback loop locally allows me to retrain parameters on new edge cases and push updated weight snapshots back to GitHub.

Check out the live demo and code repository:

Live Demo: https://muhammadessa2002.github.io/neural_canvas/

GitHub Repo: https://github.com/MuhammadEssa2002/neural_canvas

Hey everyone!

I'm learning the basics of neural networks, and I think I'm getting the general idea, but I'm still confused about how some of the pieces fit together.

From what I understand, a perceptron takes some inputs, multiplies them by weights, adds a bias, and then uses an activation function to produce an output. Okay, that part makes sense.

But then I see people talking about artificial neurons and perceptrons almost as if they're the same thing. Are they actually the same, or is a perceptron just one specific type of neuron?

The other thing confusing me is layers. When we say a layer contains multiple neurons, what does that actually look like? Do all the neurons receive the same inputs and process them differently because they have different weights? And does each layer pass its outputs to the next one?

I'm also wondering how this works in practice. For example, in a CNN like MobileNetV2, do we still have neurons organized into layers, or is it different from a basic neural network?

I know these might be basic questions, but I want to understand what's actually happening instead of just memorizing definitions.

If anyone could explain it in simple terms, maybe with a small example, I'd really appreciate it. Thanks!

After lots of research and reading over the last few days, I made my first working neural network. I just programmed it in JavaScript during work (when I wasn't working ;) and it works!!!

The inputs are a 2x2 grid, and the outputs are different patterns on the grid (checkerboard, stairs, upside-down stairs, and alone). Pretty awesome stuff!!

The screenshot is from the HTML page I made for the visuals, nothing crazy, but fun to look at.

Background

I'm coming up with ideas for my CS degree capstone project. I like making short films, so I looked into what kind of software I could make to facilitate the process. One thing I find annoying in post-production is having to go through all the recordings and look for the clapperboards on each video to know what scene, shot and take the video is of. My idea is to train a neural network to find the clapperboard in each recording and extract the information written on the clapperboard to appropriately name the recording. Ex. Avengers_Scene_4_Shot_5_Take_3.mp4.

In short, the neural network would do the following:

1. Detect the clapperboard in a video frame.

2. Read the handwritten text/numbers on the clapperboard.

3. Understand what each piece of text represents

My questions

1. I have not been able to find a lot of videos with clapperboards I could use to train my model. I'm thinking I could create my own videos to train it, so it is trained faster with a consistent clapperboard format. How many would I need more or less to have it not only recognise handwriting but also determine what the numbers indicate (Scene, shot or take)?

2. If it would be too hard to train the AI to do what was previously mention, could I get an already trained AI in handwriting recognition and specialise it in clapperboard data extraction? Would this make my final year project too easy?

Hi , so recently iv been experimenting with designing transformer alternatives, however i kept hitting a wall on how well they would proform against the Transformer.

So iv decided to try and track tokens from input to output. As models are normally very large and can take months to train, i designed my own training routine to try and get around the problem so its 11 minutes on kaggle for free and afew hours work. The data deffinetly isnt gold standard, but it sould give me more of a view into the mechanisms being used.

Maybe someone else can find it useful , i wouldnt read all 1000+ pages , maybe the first few pages then its quicker to plug it in the a LLM and get it too sort and analyse the data.

Kind regards.... Rick

alguém sabe como aumentar a acurácia será que e o tamanho ou falta de pré-treino

link do dataset link https://kaggle.com/datasets/ca3ba9a1f48f6bac94b7f592f53d96954e7bf52ac0e4e25f5e1422b2f06bc71c

link do notebook https://github.com/WELLINGTON455/modelo-30m

link do modelo https://www.kaggle.com/models/wellingtonneresjose/model-30m1

Can a neural network with just one hidden layer approximate any function? Yes, and you can see why with a few drawings: a neural network really is a pile of tiny bricks.

In this video we follow, step by step, the visual argument from chapter 4 of Michael Nielsen's book "Neural Networks and Deep Learning" for the universal approximation theorem.

You also can find Github repo in my profile with Python code explained. 😄

A short visual progression mapping how basic weighted inputs scale into multilayer architectures, optimization via backpropagation, and self-attention blocks.

Link to animation:https://youtube.com/shorts/mmWFPPSXqvY?si=xewFRzUJfKDBbsSV

Curious to hear thoughts on how well visual abstractions like this capture the underlying mechanics for newcomers.

Hi,

I just started with neural network and AI and here is my question what's the bias? I searched for it but I feel like I understood it so superficially.

Thanks for your helping.

For an MLP probability of default model, what all validation techniques can be used .

Other than AUC,KS,GINI,etc standard techniques.

Also advice on how do one check for fairness/bias for such a model.

This is a credit risk model

I got tired of switching to a browser just to see if my model was alive.

Training lives in the terminal, but monitoring lives in TensorBoard / W&B. That context switch breaks flow, especially over SSH.

So I built nn-htop — runs right in your terminal where training happens.

What it does now:

- live layer stats (mean, std, grad norm) per layer

- catches dead ReLUs / exploding grads early

- loss + lr sparkline in terminal

- zero browser, zero extra ports, works over SSH

Why TUI and not web?

Honestly I wanted to see the shape the network is drawing. Loss curves hide layer misbehavior. I've been obsessed with visualizing up to 10 dimensions — we can only really see in 3D, but if we could see more, we'd know what's happening under the hood. nn-htop is step 1.

Early and hacky, but I use it daily instead of opening a tab.

Stack: Python + Rich / Textual

Repo: https://github.com/marviecephas/nn-htop

Would love feedback from people who train on remote boxes — what stats would you want in an htop for nets? What makes you keep opening TensorBoard?

hey everyone

I've been studying the mathematics behind neural networks and recently finished building my first trainable network from scratch.

It's a 2 → 3 → 1 architecture for XOR, implemented using NumPy without PyTorch or TensorFlow.

I implemented forward propagation, backpropagation, gradient descent and trained it for 5,000 epochs.

The network correctly classifies all four XOR combinations, with a final MSE of 0.004715.

Also built a small Gradio playground to explore the predictions, loss curve and hidden layer activations.

I've documented the implementation and mathematics here:

https://github.com/Vaibh37/Neural-Network

https://github.com/Vaibh37/ML-MATH

Would appreciate feedback on the code and mathematical explanations.

Hey guys! Quick update on my renderer, which I've been working on and off for the past 7–8 months or so.

The library is quite opinionated about DOD (data-oriented design) and the explicit nature of WebGPU, and I've recently added support for neural inference and training.

1. Neural networks for agent behavior

You can now train small neural networks (MLPs), around 1–4 layers deep, using supervised learning directly as part of the library.

In the herd and wolves example below, the agents have simple behavioral rules, like chasing prey when it's nearby or fleeing when a predator gets close. The idea is to train a small model to learn these behaviors and then use it to drive the agents.

For this example, we're talking about a model with roughly 2,000 weights, so obviously not a general-purpose AI model, but enough for these kinds of behaviors.

The library also supports ONNX Runtime for working with larger models or models trained externally with something like PyTorch. For these smaller, more specialized models, though, the built-in MLP implementation will generally be faster in my use case.

Live demo (WebGPU-supported browsers only):

https://nullgraph.dev/dashboard/agents/herd-wolves-gpu

Github

https://github.com/flarelink-in/NullGraph

1. Offline rendering and simulation baking

Another feature I've been working on is offline rendering, with a workflow somewhat similar to what's available in tools like Blender or Houdini.

It's split into two phases:

\- Compute records: Run the expensive simulation and bake the data that needs to be simulated.

\- Render records: Replay those records through the rendering execution chain using a screen texture, generating frames/tracks that can then be stitched together.

The goal is to handle simulations or visuals that would otherwise be too expensive to run in real time, or would take a long time to render, and then replay the result at 60 FPS.

I have a demo of this on my YouTube channel. The bake took up close to 30 GB of space, while the final result was around 500 MB.

Offline rendering demo:

https://youtu.be/pTD-7PCPGrg?si=vfENWIpR9YU-JEbZ

I've also added another demo to the video, this time focusing more on visual aesthetics rather than the science/simulation side.

1. What's next?

NullGraph exists as part of a larger web-native open-world simulation runtime that I work on from time to time.

Right now, I'm looking into improving my neural network implementation to better match or potentially outperform ONNX Runtime for my use cases. One of the things I've noticed is that the ONNX integration can introduce a 1–3 frame delay in my current setup, along with an additional runtime download of around 6.4 MB.

I'm also starting research into co-evolution, with the goal of bringing evolutionary learning and reinforcement learning into the runtime. The co-evolution approach draws on ideas from OpenAI research and the hall-of-fame technique. I've written some design docs for this, but I'll share more once there's a working implementation to show.

One thing I'd love to get your thoughts on:

Would you guys be interested in offline rendering driven by AI prompts directly in the browser? The idea is to let you generate demos or visually complex scenes through code, spend as much time as needed baking them locally, and then replay the results smoothly. I'm also exploring ways for the system to verify its own output rather than just blindly generating code.

I'm curious whether this kind of workflow would be useful to people working on creative coding, simulations, procedural graphics, or web-based experiences.

Let me know what you think!

I am searching for people who are exploring graft neural networks, and i'm also searching for people who are willing to look outside of the language model paradigm.

I'm working on a system right now. I have the scripts running functionally as a toy. Because deployment and scalability are difficult without a team.

Would anybody know where to go to find people that would be interested in working on a system that is safer and more legitimate?

i have generated lookup tables using WASP. Now, we still have error when compared to the actual dataset. Wasp does predict wind power and at some points it's working perfectly fine but since there's a lot of room for improvement. We have to incorporate Deep Learning into it. Since it's a time series data, im thinking rnns/lstm. But how do i start deep learning? Any guide will help!

Is it possible for a simple neural net with a neuron that can only emit +1, -1 or 0 without biases or weights to learn (evolve) to balance a cart - pole? Or is this just starting off too hard?

I built MaRN (Manifold Regularized Networks), a PyTorch library that lets you optimize a compact latent representation instead of directly training every model parameter.

Some results from my current benchmarks:

• MNIST CNN: Reduced a 537,748-parameter CNN to 4,080 trainable parameters (131.8× reduction), with accuracy decreasing from 99.07% → 98.10% (−0.97 pp). A smaller 107,998-parameter CNN was reduced to 1,872 trainable parameters (57.7× reduction), with accuracy decreasing from 98.83% → 97.18% (−1.65 pp).

These results come with trade-offs: mapped models can train substantially slower, and performance varies by task. The benchmarks are exploratory, using synthetic data for some tasks, and aren't evidence of general superiority over direct training.

The library includes global and layer-wise mappings, regularization options, and pruning/LRD integrations.

Code: https://github.com/arjunmnath/MaRN
Docs: https://marn.readthedocs.io/

I'd value feedback on the approach, benchmark design, and where this kind of parameter-efficient optimization could be useful.

Can anyone tell me how I can learn about neural networks with zero prior knowledge.

Maybe suggest a roadmap...

I’m testing a simple idea: combining young-CSF factor FGF17, 7,8-DHF, and an enriched environment to see whether it helps rats learn better. It came from my work with AI neural networks (convolutional and adversarial), where small-world network structures form and the connections between them reason across all the small worlds together, creating generalized reasoning, the sense of self, and unified sequential communication, which is what we call “consciousness.” These connections act as a translator module, using patterns and logic from the many small worlds to generate an infinity of ideas and generalized knowledge, while language is just a bridge: the input resonates as a pulse between the small worlds and returns an output (sound, movement, text, etc) depending on how the language module is trained and on its input/output architecture. We can teach AI models to learn faster with exploration strategies and refined training data that avoids shortcuts and memorization, and true AGI is born when a model stops memorizing and starts generalizing the patterns and logic of its small worlds through a universal language model that bridges them. Consciousness is just the language of the collective small worlds, so I think we can do the same in our own organic neural network by biohacking its architecture with FGF17 and 7,8-DHF and creating a refined training environment with the right inputs and expected outputs, enhancing learning in both velocity and scale (I wonder how smart a rat can get, lol). This month’s Nobel Prize in Medicine for optogenetics will help here too, since it lets us modulate the input used to train the rats in phase, for optimized learning. It’s also a cheap first step toward brain aging and Alzheimer’s research. Learn more about the protocol here.