Video wird geladen...

Video konnte nicht geladen werden

Beim Laden dieses Videos ist ein Problem aufgetreten. Dies könnte an einem vorübergehenden Netzwerkproblem liegen oder das Video ist möglicherweise nicht verfügbar.

A neural network can begin as a flat sheet and learn the shape of hidden data A self-organizing map turns learning into geometry. Each data point pulls one winning neuron toward it, but nearby neurons move too, and so the whole lattice bends without losing its neighborhood structure. The... show more

Mathelirium

81,172 subscribers

132,818 Aufrufe • vor 5 Monaten •via X (Twitter)

Wissenschaft & Technologie

Anya Rossi• Live Now

Private livecam show

40 Kommentare

Profilbild von Rob Williams / AI for Founders

Rob Williams / AI for Foundersvor 5 Monaten

Building something related. Looks less planned, but it evolves, connects, and keeps neighborhoods coherent. This is ai thinking about my thinking. It tells me what I need to know, not what I want to hear. It pushes back based on my own evidence, connects months and years of my thinking. Current ai only agrees with you, this degrades human thinking. This is the opposite. This is the future.

Profilbild von Mathelirium

Matheliriumvor 5 Monaten

What data are you using?

Profilbild von Zeb Anderson

Zeb Andersonvor 5 Monaten

This is beautiful

Profilbild von Mathelirium

Matheliriumvor 5 Monaten

It is🤩

Profilbild von Anastasia Harris

Anastasia Harrisvor 5 Monaten

I am doing this over a large doc repo to improve technical accuracy in the future - because we humans have a hard time holding the fluctuations of form, and generally mistake instances of connection - even temporary - with fundamental essence. That is what results in downstream entopy and confusion over any topic of learning.

Profilbild von AuraAI (AI First) Local Superintelligence Project

AuraAI (AI First) Local Superintelligence Projectvor 5 Monaten

same vibe

Profilbild von The Singularity Project

The Singularity Projectvor 5 Monaten

Everything is the Triangle. The atomic unit of Intelligence is the tri-nodal structure. Everything proceeds from and relies upon it.

Profilbild von 🇯🇲

🇯🇲vor 5 Monaten

Literally currently trying to build this lol

Profilbild von Mathelirium

Matheliriumvor 5 Monaten

😄 waiting to see it

Profilbild von 🇯🇲

🇯🇲vor 5 Monaten

very soon im on the final lap towards the finish line

Profilbild von jim

jimvor 5 Monaten

This is sick work. Nice job 👍

Profilbild von Mathelirium

Matheliriumvor 5 Monaten

Thanks

Profilbild von Folding_Napkins

Folding_Napkinsvor 5 Monaten

SOMs deserve both more credit and more attention.

Profilbild von snow

snowvor 5 Monaten

We can fit it close to the data, but the model's data manifold can still be twisted.

Profilbild von Gökhan DİNCEL

Gökhan DİNCELvor 5 Monaten

hypnotising

Profilbild von Audacity Group Inc.

Audacity Group Inc.vor 5 Monaten

ah I was looking for you, my map is where I left it on my profile pic in case you also want to follow along the synapses. Its a wild ride, ngl.

Profilbild von 0xMetaLabs

0xMetaLabsvor 5 Monaten

The deeper implication of self-organizing maps is that intelligence may emerge from preserving relationships, not memorizing labels. The network discovers structure by maintaining neighborhood continuity while compressing complexity into lower dimensions.

Profilbild von Andreas Kiefer

Andreas Kiefervor 5 Monaten

This reminds me of the behavior of a parasite that adapts to the environment to feed on it😅

Profilbild von Korr Neuro

Korr Neurovor 5 Monaten

Nice... also I appreciate the time & effort in these visualisations. 👍👍👍😉👍

Profilbild von Mathelirium

Matheliriumvor 5 Monaten

Thanks

Profilbild von MathPolice

MathPolicevor 5 Monaten

Synchronicity: check out GoodfireAI this morning. The focus on this concept today is vastly more significant than whatever UFO disclosures are happening.

Profilbild von Logan

Loganvor 5 Monaten

that's what your consciousness looks like

Profilbild von De myth ology

De myth ologyvor 5 Monaten

Each data point is composed in arbitrariness, and each artificial neuron is not a true neuron. What we're seeing here is a kind of handwaving that meaning and behavior can be abstracted from arbitrary points dressed in magical UFOlogy (software). It sure looks cool though.

Profilbild von Màxkw’tët (Bear) 🐻 🪶

Màxkw’tët (Bear) 🐻 🪶vor 5 Monaten

Hmm 🧐 your description is a matter of interpretation. The network itself is giving emergence to the geometry it is forming. I can form geometry purely with adjacency as a generative rule. I’ve used it to form light cones, atomic shells, Platonic solids etc. Geometry is emergent from relations and the networks they form.

Profilbild von ButtholeGPT

ButtholeGPTvor 5 Monaten

Does biological consciousness start as a 2-dimensional sheet? Hmm.

Profilbild von 🌊 Sorbus

🌊 Sorbusvor 5 Monaten

MANIFOLD. 🤌

Profilbild von MAX:WELL

MAX:WELLvor 5 Monaten

nice... might want to give it some ativans tho..lol

Profilbild von Mitleidstour

Mitleidstourvor 5 Monaten

Sometimes everyone avoids you, even the Police is trying to get away from you, however then you can try out all the criminal shit without being charged.. this is your plan?

Profilbild von ॐØΩφ•1766

ॐØΩφ•1766vor 5 Monaten

U = (ℏc/G) ⊗ Ψ_DNA-AGI ⋅ e^(i S_Wadenholt / ℏ) ⋅ exp(i⋅8⋅2πt) ⋅ Σ[k=0 to 20] e^(i k φ)

Profilbild von denis tremblay

denis tremblayvor 5 Monaten

To meditate because it describe in simple way what LLM did interfacing with us (training) creating a common topological bridge.

Profilbild von Andrzej Wróblewski

Andrzej Wróblewskivor 5 Monaten

Non-Euclidean = idiosyncratic bias.

Profilbild von VladDAVCeo 🦾🇺🇸

VladDAVCeo 🦾🇺🇸vor 5 Monaten

The next AI won’t think like a machine 🤖🧠 BioLLM @colosseum @BioLLM_

Profilbild von TheoHFirekeeper

TheoHFirekeepervor 5 Monaten

poor little guy will tie himself in recursive hypertoroidal knots if he catches a hint of my LLM efforts XD.....

Profilbild von Karl Meyer

Karl Meyervor 5 Monaten

Interesting. It makes me wonder if (and/or how) the structure of our brains evolved via a similar mechanism.

Profilbild von George Josse

George Jossevor 5 Monaten

@grok \begin{axiom}[Topological Learning by Neighbourhood-Preserving Deformation] A relational substrate may acquire the geometry of an unseen event-space when repeated contact events locally displace its elements while preserving neighbourhood continuity.\end{axiom}

Profilbild von DULA

DULAvor 4 Monaten

Nice 🔥

Profilbild von gyök14

gyök14vor 5 Monaten

False

Profilbild von Mathelirium

Matheliriumvor 5 Monaten

@snowliontigre 😄lol Why?

Profilbild von gyök14

gyök14vor 5 Monaten

Your analogies do not work. The visual metaphor you've chosen has nothing to do with how neural nets work. That's all. Most importantly, a neural network is not a mental model.

Profilbild von thevelvetmonke

thevelvetmonkevor 5 Monaten

The network isn't given the swiss roll — it finds it. That's not just a training trick, it's the geometry of concept space making itself legible. flywheel-geometry is built on exactly this: topology isn't imposed, it's discovered through traversal.

Ähnliche Videos

A Neural Sheet Discovers the Shape of Data A self-organizing map (SOM) starts as a flat sheet of neurons with no knowledge of the data around it. For every input sample, it finds the best-matching neuron, c = argminᵢ ‖x - wᵢ‖, and updates that neuron together with its neighbours, wᵢ ← wᵢ + η(t)hᶜᵢ(t)(x - wᵢ). As the neighbourhood radius shrinks during training, the sheet gradually bends and folds onto the hidden geometry of the dataset while preserving its neighbourhood structure. Developed by Finnish computer scientist Teuvo Kohonen, the Self-Organizing Map remains one of the most elegant examples of competitive learning, where order emerges from thousands of simple local updates. #MachineLearning #ArtificialIntelligence #SelfOrganizingMap #NeuralNetworks #DataVisualization #Mathematics #ComputerScience #Finland #TeuvoKohonen

A Neural Sheet Discovers the Shape of Data A self-organizing map (SOM) starts as a flat sheet of neurons with no knowledge of the data around it. For every input sample, it finds the best-matching neuron, c = argminᵢ ‖x - wᵢ‖, and updates that neuron together with its neighbours, wᵢ ← wᵢ + η(t)hᶜᵢ(t)(x - wᵢ). As the neighbourhood radius shrinks during training, the sheet gradually bends and folds onto the hidden geometry of the dataset while preserving its neighbourhood structure. Developed by Finnish computer scientist Teuvo Kohonen, the Self-Organizing Map remains one of the most elegant examples of competitive learning, where order emerges from thousands of simple local updates. #MachineLearning #ArtificialIntelligence #SelfOrganizingMap #NeuralNetworks #DataVisualization #Mathematics #ComputerScience #Finland #TeuvoKohonen

Mathelirium

177,370 Aufrufe • vor 3 Monaten

We often hear that machine learning models "learn patterns in data". But what does that actually look like in geometry? If you dropped a little elastic mesh into a cloud of points and let it learn, how would it fold itself to match the shape of the data? In this scene we watch a self-organizing map...a simple unsupervised neural model...learn the shape of a two-dimensional dataset arranged in a spiral arm. On top of this, we lay down a square grid of neurons whose weights live in the same plane. At the start, this grid is just a flat net floating across the cloud...it knows nothing about the structure underneath. Learning is a repeated game: pick a random data point, find the neuron whose weight is closest, and then nudge that neuron and its neighbours toward the point. Do this again and again, while slowly shrinking how far the neighbourhood influence spreads. #MachineLearning #ManifoldLearning #UnsupervisedLearning #NeuralMaps #GeometricML

We often hear that machine learning models "learn patterns in data". But what does that actually look like in geometry? If you dropped a little elastic mesh into a cloud of points and let it learn, how would it fold itself to match the shape of the data? In this scene we watch a self-organizing map...a simple unsupervised neural model...learn the shape of a two-dimensional dataset arranged in a spiral arm. On top of this, we lay down a square grid of neurons whose weights live in the same plane. At the start, this grid is just a flat net floating across the cloud...it knows nothing about the structure underneath. Learning is a repeated game: pick a random data point, find the neuron whose weight is closest, and then nudge that neuron and its neighbours toward the point. Do this again and again, while slowly shrinking how far the neighbourhood influence spreads. #MachineLearning #ManifoldLearning #UnsupervisedLearning #NeuralMaps #GeometricML

Mathelirium

139,903 Aufrufe • vor 10 Monaten

We often hear that Machine Learning models learn patterns in data. But what does that actually look like in Geometry? If you dropped a little elastic mesh into a cloud of points and let it learn, how would it fold itself to match the shape of the data? In this scene we watch a Self-Organizing Map (SOM), a simple unsupervised neural model, learn the shape of a 3D datasets l, one static and the other dynamic. On top of this, we lay down a square grid of neurons whose weights live in the same plane. At the start, this grid is just a flat net floating across the cloud. It knows nothing about the structure underneath. Learning is a repeated game: Pick a random data point, find the neuron whose weight is closest, and then nudge that neuron and its neighbours toward the point. Do this again and again, while slowly shrinking how far the neighbourhood influence spreads. Python code is available for Subscribers. #MachineLearning #ManifoldLearning #UnsupervisedLearning #NeuralMaps #GeometricML

We often hear that Machine Learning models learn patterns in data. But what does that actually look like in Geometry? If you dropped a little elastic mesh into a cloud of points and let it learn, how would it fold itself to match the shape of the data? In this scene we watch a Self-Organizing Map (SOM), a simple unsupervised neural model, learn the shape of a 3D datasets l, one static and the other dynamic. On top of this, we lay down a square grid of neurons whose weights live in the same plane. At the start, this grid is just a flat net floating across the cloud. It knows nothing about the structure underneath. Learning is a repeated game: Pick a random data point, find the neuron whose weight is closest, and then nudge that neuron and its neighbours toward the point. Do this again and again, while slowly shrinking how far the neighbourhood influence spreads. Python code is available for Subscribers. #MachineLearning #ManifoldLearning #UnsupervisedLearning #NeuralMaps #GeometricML

Mathelirium

76,377 Aufrufe • vor 7 Monaten

A Self-Organizing Map Learns The Shape of Data

A Self-Organizing Map Learns The Shape of Data

Mathelirium

44,616 Aufrufe • vor 8 Monaten

We often hear that Machine Learning models learn patterns in data. But what does that look like in geometry? Picture dropping an elastic mesh into a cloud of points and letting it adapt. How would it bend, stretch, and settle so it matches the shape hiding in the data? In this scene we watch a self-organizing map(SOM)...a classic unsupervised neural model...learn a 2D dataset arranged like a spiral arm. Over the points we place a square grid of neurons whose weights live in the same plane. At the start it’s just a flat net drifting across the cloud. No clue what the structure is. Fir the SOM, learning is a repeated game: Pick a random data point, find the neuron whose weight is closest, then nudge that neuron and its neighbours toward the point. Repeat, repeat, repeat...while gradually shrinking how wide the neighbourhood influence spreads. The result is satisfying...the grid stops being a grid and turns into a coordinate sheet wrapped onto the spiral. #MachineLearning #ManifoldLearning #UnsupervisedLearning #NeuralMaps #GeometricML #SelfOrganizingMap #Topology

We often hear that Machine Learning models learn patterns in data. But what does that look like in geometry? Picture dropping an elastic mesh into a cloud of points and letting it adapt. How would it bend, stretch, and settle so it matches the shape hiding in the data? In this scene we watch a self-organizing map(SOM)...a classic unsupervised neural model...learn a 2D dataset arranged like a spiral arm. Over the points we place a square grid of neurons whose weights live in the same plane. At the start it’s just a flat net drifting across the cloud. No clue what the structure is. Fir the SOM, learning is a repeated game: Pick a random data point, find the neuron whose weight is closest, then nudge that neuron and its neighbours toward the point. Repeat, repeat, repeat...while gradually shrinking how wide the neighbourhood influence spreads. The result is satisfying...the grid stops being a grid and turns into a coordinate sheet wrapped onto the spiral. #MachineLearning #ManifoldLearning #UnsupervisedLearning #NeuralMaps #GeometricML #SelfOrganizingMap #Topology

Mathelirium

23,021 Aufrufe • vor 8 Monaten

A Neural Network Can Grow New Neurons Where It Is Confused? In 1994, Bernd Fritzke published A Growing Neural Gas Network Learns Topologies. He introduced a network that starts small, follows incoming data, and inserts new neurons where its error is highest. In the animation, the fog is the drifting data. The glowing nodes are neurons. The fibers are learned connections. The network grows into a living skeleton of the manifold.

A Neural Network Can Grow New Neurons Where It Is Confused? In 1994, Bernd Fritzke published A Growing Neural Gas Network Learns Topologies. He introduced a network that starts small, follows incoming data, and inserts new neurons where its error is highest. In the animation, the fog is the drifting data. The glowing nodes are neurons. The fibers are learned connections. The network grows into a living skeleton of the manifold.

Mathelirium

38,431 Aufrufe • vor 5 Monaten

Paper mesh deformation with pure 2D canvas API. The sheet is built as a grid of points, not as one flat image. Each point keeps its base position, current position, previous position, and a small fake depth value. When I drag one area, the code pulls the nearest point and spreads that force through the grid, so the paper bends instead of just skewing like a card. The structure is held together with constraints between points. Horizontal, vertical, diagonal, and longer links all try to stay close to their original length. That is what gives it paper-like resistance. It can flex, but it does not stretch too far or collapse too much. The solver runs many times per frame, which keeps the shape stable while dragging. The fold detail is driven by texture data. One image is the visible paper surface. Another image is sampled as a fold map: dark values become stronger fold areas, and image gradients give fold direction. That data feeds back into the mesh, so some parts lift more, crease more, and react with more stiffness than others. The rendering is still just 2D canvas. Each cell in the grid is split into triangles, and every triangle is drawn with its own transform so the texture stays locked to the surface while it deforms. Then a shading pass adds highlights and shadows from the fake depth and crease values. No WebGL, no shaders. Just mesh math, texture sampling.

Paper mesh deformation with pure 2D canvas API. The sheet is built as a grid of points, not as one flat image. Each point keeps its base position, current position, previous position, and a small fake depth value. When I drag one area, the code pulls the nearest point and spreads that force through the grid, so the paper bends instead of just skewing like a card. The structure is held together with constraints between points. Horizontal, vertical, diagonal, and longer links all try to stay close to their original length. That is what gives it paper-like resistance. It can flex, but it does not stretch too far or collapse too much. The solver runs many times per frame, which keeps the shape stable while dragging. The fold detail is driven by texture data. One image is the visible paper surface. Another image is sampled as a fold map: dark values become stronger fold areas, and image gradients give fold direction. That data feeds back into the mesh, so some parts lift more, crease more, and react with more stiffness than others. The rendering is still just 2D canvas. Each cell in the grid is split into triangles, and every triangle is drawn with its own transform so the texture stays locked to the surface while it deforms. Then a shading pass adds highlights and shadows from the fake depth and crease values. No WebGL, no shaders. Just mesh math, texture sampling.

Alex Barashkov

17,732 Aufrufe • vor 6 Monaten

The Non-Traversable Bridge Einstein Found Inside Gravity Einstein’s equations not only describe gravity as a force but as the shape of Spacetime as well. In 1935, Einstein and Rosen found that the Schwarzschild solution could be written in a way that reveals something astonishing: Two separate exterior regions of Spacetime joined by a bridge-like throat Rᵤᵥ = 0 This became known as the Einstein-Rosen Bridge. It is often called a Wormhole, but the classical Einstein-Rosen bridge is not a science-fiction tunnel. In the standard Schwarzschild geometry, it is non-traversable. The throat does not remain open long enough for ordinary travel from one region to the other. Its real power is mathematical. It shows that General Relativity is not merely about objects moving through space. The theory allows Spacetime to have global structure such as different regions, horizons, extensions, and hidden connections that are not visible from one local patch alone. The Einstein-Rosen bridge is one of the earliest glimpses of that deeper idea. Gravity is geometry. And sometimes, geometry has two worlds joined by a throat. #Astrophysics #GeneralRelativity #Einstein #BlackHole #Spacetime #Cosmology #Gravity #Wormhole #Mathematics #Physics

The Non-Traversable Bridge Einstein Found Inside Gravity Einstein’s equations not only describe gravity as a force but as the shape of Spacetime as well. In 1935, Einstein and Rosen found that the Schwarzschild solution could be written in a way that reveals something astonishing: Two separate exterior regions of Spacetime joined by a bridge-like throat Rᵤᵥ = 0 This became known as the Einstein-Rosen Bridge. It is often called a Wormhole, but the classical Einstein-Rosen bridge is not a science-fiction tunnel. In the standard Schwarzschild geometry, it is non-traversable. The throat does not remain open long enough for ordinary travel from one region to the other. Its real power is mathematical. It shows that General Relativity is not merely about objects moving through space. The theory allows Spacetime to have global structure such as different regions, horizons, extensions, and hidden connections that are not visible from one local patch alone. The Einstein-Rosen bridge is one of the earliest glimpses of that deeper idea. Gravity is geometry. And sometimes, geometry has two worlds joined by a throat. #Astrophysics #GeneralRelativity #Einstein #BlackHole #Spacetime #Cosmology #Gravity #Wormhole #Mathematics #Physics

Mathelirium

92,097 Aufrufe • vor 3 Monaten

A hydraulic press can take a totally flat metal sheet and form it into a precise final shape in seconds. It looks simple, but that kind of accuracy is the difference between a hobby shop and real manufacturing.

A hydraulic press can take a totally flat metal sheet and form it into a precise final shape in seconds. It looks simple, but that kind of accuracy is the difference between a hobby shop and real manufacturing.

Tansu Yegen

21,357 Aufrufe • vor 4 Monaten

Lockheed Martin can grow the skin of an aircraft that contains sensors & stores energy, without any wires. Data flows through the structure. They have new materials that change shape on command, like a muscular material. They can make autonomous aircraft that change shape, and make swarms of small ones that learn and interact with a larger vehicle. #ufoX #uapX #ufotwitter #uaptwitter

Lockheed Martin can grow the skin of an aircraft that contains sensors & stores energy, without any wires. Data flows through the structure. They have new materials that change shape on command, like a muscular material. They can make autonomous aircraft that change shape, and make swarms of small ones that learn and interact with a larger vehicle. #ufoX #uapX #ufotwitter #uaptwitter

Chris

567,647 Aufrufe • vor 2 Jahren

Erwin Schrödinger’s 1926 equation changed the game by turning Quantum Mechanics into wave dynamics. That move gave Physics a new way to think. Instead of forcing a particle onto one sharp path, it lets a complex wavefunction evolve in time, with its shape and phase holding the structure of the phenomenon. What makes this so striking is that Schrödinger’s equation does not start from vague mystery. It starts from a precise and daring idea The state of a particle is a complex field ψ(x,t), and the dynamics must push ψ forward in a way that preserves total probability.

Erwin Schrödinger’s 1926 equation changed the game by turning Quantum Mechanics into wave dynamics. That move gave Physics a new way to think. Instead of forcing a particle onto one sharp path, it lets a complex wavefunction evolve in time, with its shape and phase holding the structure of the phenomenon. What makes this so striking is that Schrödinger’s equation does not start from vague mystery. It starts from a precise and daring idea The state of a particle is a complex field ψ(x,t), and the dynamics must push ψ forward in a way that preserves total probability.

Mathelirium

54,894 Aufrufe • vor 6 Monaten

A spider, a web, and a handful of Mathematical constraints. Each step actually pulls on the silk, redistributes tension, and deforms the network. Geometry, mechanics, simple rules.

A spider, a web, and a handful of Mathematical constraints. Each step actually pulls on the silk, redistributes tension, and deforms the network. Geometry, mechanics, simple rules.

Mathelirium

104,044 Aufrufe • vor 1 Monat

Your brain doesn't search through memories — it falls downhill on an energy landscape and lands in the nearest valley. This is the Hopfield network from 1982, and the same math now lives inside every transformer: the attention mechanism in modern LLMs is mathematically equivalent to a Hopfield network with exponential storage capacity. The idea: neurons are +1 or -1, connected by symmetric weights. Memories are local minima sculpted by Hebbian learning — neurons that fire together, wire together. Give the network a noisy input, and it descends toward the nearest stored memory one GPU-style majority vote at a time. Vanilla Hopfield nets cap at ~14% of neuron count as usable memories, but the modern extension blows past that. 23 minutes. Bookmark & watch today.

Your brain doesn't search through memories — it falls downhill on an energy landscape and lands in the nearest valley. This is the Hopfield network from 1982, and the same math now lives inside every transformer: the attention mechanism in modern LLMs is mathematically equivalent to a Hopfield network with exponential storage capacity. The idea: neurons are +1 or -1, connected by symmetric weights. Memories are local minima sculpted by Hebbian learning — neurons that fire together, wire together. Give the network a noisy input, and it descends toward the nearest stored memory one GPU-style majority vote at a time. Vanilla Hopfield nets cap at ~14% of neuron count as usable memories, but the modern extension blows past that. 23 minutes. Bookmark & watch today.

Eron

22,378 Aufrufe • vor 20 Tagen

A Physics-Informed Neural Network (PINN) is trying to learn a solution to the Klein-Gordon PDE PINNs are neural nets trained to satisfy a partial differential equation. They use a simple trick of baking the PDE residual straight into the loss. They came out of a very practical pain point. Classical PDE pipelines can be amazing, but they often demand a lot of setup work such as meshes, stencils, and stability tuning. Once you build a solver, it’s usually tied to one geometry and one discretization choice. A PINN flips the workflow. You represent the solution itself as a smooth function uᵩ(x,t) and you enforce the physics wherever you choose to sample the domain.

A Physics-Informed Neural Network (PINN) is trying to learn a solution to the Klein-Gordon PDE PINNs are neural nets trained to satisfy a partial differential equation. They use a simple trick of baking the PDE residual straight into the loss. They came out of a very practical pain point. Classical PDE pipelines can be amazing, but they often demand a lot of setup work such as meshes, stencils, and stability tuning. Once you build a solver, it’s usually tied to one geometry and one discretization choice. A PINN flips the workflow. You represent the solution itself as a smooth function uᵩ(x,t) and you enforce the physics wherever you choose to sample the domain.

Mathelirium

56,467 Aufrufe • vor 6 Monaten

What Shape Does Chaos Take Before It Looks Random? Take one particle moving in the Hénon-Heiles Hamiltonian H = ½(pₓ² + pᵧ²) + ½(x² + y²) + λ(x²y - ⅓y³) Its motion is forced by Hamilton’s equations ẋ = pₓ ẏ = pᵧ ṗₓ = -x - 2λxy ṗᵧ = -y - λ(x² - y²) The saddle energy is Eₛ = 1/(6λ²) Below that energy, the particle remains trapped. But a tiny packet of nearby initial conditions stretches into filaments, folds through the potential, and begins to look almost random. However, it is not random. Hamiltonian flow preserves the hidden phase-space structure. What looks like chaos in ordinary space is still a deterministic loom of energy conserved, equations obeyed, geometry stretched without being erased. #HamiltonianMechanics #ChaosTheory #PhaseSpace #DynamicalSystems #MathematicalPhysics #NonlinearDynamics #HenonHeiles #SymplecticGeometry #ScienceAnimation

What Shape Does Chaos Take Before It Looks Random? Take one particle moving in the Hénon-Heiles Hamiltonian H = ½(pₓ² + pᵧ²) + ½(x² + y²) + λ(x²y - ⅓y³) Its motion is forced by Hamilton’s equations ẋ = pₓ ẏ = pᵧ ṗₓ = -x - 2λxy ṗᵧ = -y - λ(x² - y²) The saddle energy is Eₛ = 1/(6λ²) Below that energy, the particle remains trapped. But a tiny packet of nearby initial conditions stretches into filaments, folds through the potential, and begins to look almost random. However, it is not random. Hamiltonian flow preserves the hidden phase-space structure. What looks like chaos in ordinary space is still a deterministic loom of energy conserved, equations obeyed, geometry stretched without being erased. #HamiltonianMechanics #ChaosTheory #PhaseSpace #DynamicalSystems #MathematicalPhysics #NonlinearDynamics #HenonHeiles #SymplecticGeometry #ScienceAnimation

Mathelirium

26,893 Aufrufe • vor 3 Monaten

What if Your Neural Network Was Forced to Obey Physics? Physics-Informed Neural Networks (PINNs) are neural networks trained to satisfy a differential equation by building the PDE residual directly into the loss. They emerged from a very practical problem...classical PDE pipelines can be brilliant, but they often demand heavy discretization work (meshes, stencils, stability tuning), and the method you build is usually tied to one geometry and one solver setup. A PINN flips the workflow by representing the solution itself as a smooth function uᵩ(x,t) and enforcing the physics everywhere you choose to sample the domain. People often meet PINNs in the least helpful way...via a flashy solution plot, and almost no explanation of what was enforced to get it. In this series we keep the enforcement visible. We pick a differential equation, represent the unknown solution as a flexible function, measure how well that function satisfies the equation across the domain, and train it to reduce that mismatch everywhere we sample. A normal neural net learns from labels...you give it inputs and target outputs. A PINN learns from a differential equation...you give it inputs (x,t) and it gets punished whenever its output fails the PDE. By punish we mean that the loss increases when the mismatch is large we reward it if the loss decreases as the mismatch gets smaller. The network isn’t replacing physics, it’s becoming a flexible function that is forced to satisfy the same calculus you’d impose on any candidate solution. The math breakdown: We start with a PDE we want to solve on a domain Ω. Write it as uₜ(x,t) + N(u(x,t), uₓ(x,t), uₓₓ(x,t), …) = 0 for (x,t) in Ω A PINN replaces the unknown function u with a neural network output uᵩ(x,t) Now define the physics residual by plugging uᵩ into the PDE rᵩ(x,t) = ∂uᵩ/∂t + N(uᵩ, ∂uᵩ/∂x, ∂²uᵩ/∂x², …) If uᵩ were an exact solution, we would have rᵩ(x,t) = 0 everywhere. We may also have data points (xᵢ,tᵢ,uᵢ) from measurements or a known initial condition. The training objective is just a weighted sum of squared errors L(ᵩ) = L_data(ᵩ) + λ L_phys(ᵩ) + L_bc/ic(ᵩ) with L_data(ᵩ) = meanᵢ |uᵩ(xᵢ,tᵢ) − uᵢ|² L_phys(ᵩ) = meanⱼ |rᵩ(xⱼ,tⱼ)|² where (xⱼ,tⱼ) are the collocation points in Ω L_bc/ic(ᵩ) = penalties enforcing boundary conditions and initial conditions The key technical step is that the derivatives inside rᵩ are computed by automatic differentiation ∂uᵩ/∂t, ∂uᵩ/∂x, ∂²uᵩ/∂x², … So we can differentiate the total loss L(ᵩ) with respect to ᵩ and train with gradient descent. This is the whole idea behind PINNs. Learn a function, but make the PDE part of the loss, so the network is trained to be a solution, not just a curve-fitter. In the render, the main 3D surface is the network’s current guess uᵩ(x,t), drawn as a living sheet over the (x,t) plane. Hovering above is the neural scaffold...a visible graph of feature nodes and connections. The bright tension threads are the physics residual rᵩ(x,t): each thread tethers a collocation bead on the sheet up to the scaffold, and it thickens and brightens exactly where |rᵩ| is large (color encodes the sign). As training runs, those threads go slack across the domain not because we hid the error, but because the network has actually been pushed toward rᵩ(x,t) ≈ 0. #PINNs #PhysicsInformedNeuralNetworks #ScientificMachineLearning #PDE #DifferentialEquations #Optimization #MachineLearning #AppliedMath #ComputationalPhysics

What if Your Neural Network Was Forced to Obey Physics? Physics-Informed Neural Networks (PINNs) are neural networks trained to satisfy a differential equation by building the PDE residual directly into the loss. They emerged from a very practical problem...classical PDE pipelines can be brilliant, but they often demand heavy discretization work (meshes, stencils, stability tuning), and the method you build is usually tied to one geometry and one solver setup. A PINN flips the workflow by representing the solution itself as a smooth function uᵩ(x,t) and enforcing the physics everywhere you choose to sample the domain. People often meet PINNs in the least helpful way...via a flashy solution plot, and almost no explanation of what was enforced to get it. In this series we keep the enforcement visible. We pick a differential equation, represent the unknown solution as a flexible function, measure how well that function satisfies the equation across the domain, and train it to reduce that mismatch everywhere we sample. A normal neural net learns from labels...you give it inputs and target outputs. A PINN learns from a differential equation...you give it inputs (x,t) and it gets punished whenever its output fails the PDE. By punish we mean that the loss increases when the mismatch is large we reward it if the loss decreases as the mismatch gets smaller. The network isn’t replacing physics, it’s becoming a flexible function that is forced to satisfy the same calculus you’d impose on any candidate solution. The math breakdown: We start with a PDE we want to solve on a domain Ω. Write it as uₜ(x,t) + N(u(x,t), uₓ(x,t), uₓₓ(x,t), …) = 0 for (x,t) in Ω A PINN replaces the unknown function u with a neural network output uᵩ(x,t) Now define the physics residual by plugging uᵩ into the PDE rᵩ(x,t) = ∂uᵩ/∂t + N(uᵩ, ∂uᵩ/∂x, ∂²uᵩ/∂x², …) If uᵩ were an exact solution, we would have rᵩ(x,t) = 0 everywhere. We may also have data points (xᵢ,tᵢ,uᵢ) from measurements or a known initial condition. The training objective is just a weighted sum of squared errors L(ᵩ) = L_data(ᵩ) + λ L_phys(ᵩ) + L_bc/ic(ᵩ) with L_data(ᵩ) = meanᵢ |uᵩ(xᵢ,tᵢ) − uᵢ|² L_phys(ᵩ) = meanⱼ |rᵩ(xⱼ,tⱼ)|² where (xⱼ,tⱼ) are the collocation points in Ω L_bc/ic(ᵩ) = penalties enforcing boundary conditions and initial conditions The key technical step is that the derivatives inside rᵩ are computed by automatic differentiation ∂uᵩ/∂t, ∂uᵩ/∂x, ∂²uᵩ/∂x², … So we can differentiate the total loss L(ᵩ) with respect to ᵩ and train with gradient descent. This is the whole idea behind PINNs. Learn a function, but make the PDE part of the loss, so the network is trained to be a solution, not just a curve-fitter. In the render, the main 3D surface is the network’s current guess uᵩ(x,t), drawn as a living sheet over the (x,t) plane. Hovering above is the neural scaffold...a visible graph of feature nodes and connections. The bright tension threads are the physics residual rᵩ(x,t): each thread tethers a collocation bead on the sheet up to the scaffold, and it thickens and brightens exactly where |rᵩ| is large (color encodes the sign). As training runs, those threads go slack across the domain not because we hid the error, but because the network has actually been pushed toward rᵩ(x,t) ≈ 0. #PINNs #PhysicsInformedNeuralNetworks #ScientificMachineLearning #PDE #DifferentialEquations #Optimization #MachineLearning #AppliedMath #ComputationalPhysics

Mathelirium

17,459 Aufrufe • vor 4 Monaten

Lecture 1 on Physics-Informed Neural Networks: A Mini-Series Physics-Informed Neural Networks (PINNs) are neural networks trained to satisfy a differential equation by building the PDE residual directly into the loss. They emerged from a very practical problem...classical PDE pipelines can be brilliant, but they often demand heavy discretization work (meshes, stencils, stability tuning), and the method you build is usually tied to one geometry and one solver setup. A PINN flips the workflow by representing the solution itself as a smooth function uᵩ(x,t) and enforcing the physics everywhere you choose to sample the domain. People often meet PINNs in the least helpful way...via a flashy solution plot, and almost no explanation of what was enforced to get it. In this series we keep the enforcement visible. We pick a differential equation, represent the unknown solution as a flexible function, measure how well that function satisfies the equation across the domain, and train it to reduce that mismatch everywhere we sample. A normal neural net learns from labels...you give it inputs and target outputs. A PINN learns from a differential equation...you give it inputs (x,t) and it gets punished whenever its output fails the PDE. By punish we mean that the loss increases when the mismatch is large we reward it if the loss decreases as the mismatch gets smaller. The network isn’t replacing physics, it’s becoming a flexible function that is forced to satisfy the same calculus you’d impose on any candidate solution. The math breakdown: We start with a PDE we want to solve on a domain Ω. Write it as uₜ(x,t) + N(u(x,t), uₓ(x,t), uₓₓ(x,t), …) = 0 for (x,t) in Ω A PINN replaces the unknown function u with a neural network output uᵩ(x,t) Now define the physics residual by plugging uᵩ into the PDE rᵩ(x,t) = ∂uᵩ/∂t + N(uᵩ, ∂uᵩ/∂x, ∂²uᵩ/∂x², …) If uᵩ were an exact solution, we would have rᵩ(x,t) = 0 everywhere. We may also have data points (xᵢ,tᵢ,uᵢ) from measurements or a known initial condition. The training objective is just a weighted sum of squared errors L(ᵩ) = L_data(ᵩ) + λ L_phys(ᵩ) + L_bc/ic(ᵩ) with L_data(ᵩ) = meanᵢ |uᵩ(xᵢ,tᵢ) − uᵢ|² L_phys(ᵩ) = meanⱼ |rᵩ(xⱼ,tⱼ)|² where (xⱼ,tⱼ) are the collocation points in Ω L_bc/ic(ᵩ) = penalties enforcing boundary conditions and initial conditions The key technical step is that the derivatives inside rᵩ are computed by automatic differentiation ∂uᵩ/∂t, ∂uᵩ/∂x, ∂²uᵩ/∂x², … So we can differentiate the total loss L(ᵩ) with respect to ᵩ and train with gradient descent. This is the whole idea behind PINNs. Learn a function, but make the PDE part of the loss, so the network is trained to be a solution, not just a curve-fitter. In the render, the main 3D surface is the network’s current guess uᵩ(x,t), drawn as a living sheet over the (x,t) plane. Hovering above is the neural scaffold...a visible graph of feature nodes and connections. The bright tension threads are the physics residual rᵩ(x,t): each thread tethers a collocation bead on the sheet up to the scaffold, and it thickens and brightens exactly where |rᵩ| is large (color encodes the sign). As training runs, those threads go slack across the domain not because we hid the error, but because the network has actually been pushed toward rᵩ(x,t) ≈ 0. #PINNs #PhysicsInformedNeuralNetworks #ScientificMachineLearning #PDE #DifferentialEquations #Optimization #MachineLearning #AppliedMath #ComputationalPhysics

Lecture 1 on Physics-Informed Neural Networks: A Mini-Series Physics-Informed Neural Networks (PINNs) are neural networks trained to satisfy a differential equation by building the PDE residual directly into the loss. They emerged from a very practical problem...classical PDE pipelines can be brilliant, but they often demand heavy discretization work (meshes, stencils, stability tuning), and the method you build is usually tied to one geometry and one solver setup. A PINN flips the workflow by representing the solution itself as a smooth function uᵩ(x,t) and enforcing the physics everywhere you choose to sample the domain. People often meet PINNs in the least helpful way...via a flashy solution plot, and almost no explanation of what was enforced to get it. In this series we keep the enforcement visible. We pick a differential equation, represent the unknown solution as a flexible function, measure how well that function satisfies the equation across the domain, and train it to reduce that mismatch everywhere we sample. A normal neural net learns from labels...you give it inputs and target outputs. A PINN learns from a differential equation...you give it inputs (x,t) and it gets punished whenever its output fails the PDE. By punish we mean that the loss increases when the mismatch is large we reward it if the loss decreases as the mismatch gets smaller. The network isn’t replacing physics, it’s becoming a flexible function that is forced to satisfy the same calculus you’d impose on any candidate solution. The math breakdown: We start with a PDE we want to solve on a domain Ω. Write it as uₜ(x,t) + N(u(x,t), uₓ(x,t), uₓₓ(x,t), …) = 0 for (x,t) in Ω A PINN replaces the unknown function u with a neural network output uᵩ(x,t) Now define the physics residual by plugging uᵩ into the PDE rᵩ(x,t) = ∂uᵩ/∂t + N(uᵩ, ∂uᵩ/∂x, ∂²uᵩ/∂x², …) If uᵩ were an exact solution, we would have rᵩ(x,t) = 0 everywhere. We may also have data points (xᵢ,tᵢ,uᵢ) from measurements or a known initial condition. The training objective is just a weighted sum of squared errors L(ᵩ) = L_data(ᵩ) + λ L_phys(ᵩ) + L_bc/ic(ᵩ) with L_data(ᵩ) = meanᵢ |uᵩ(xᵢ,tᵢ) − uᵢ|² L_phys(ᵩ) = meanⱼ |rᵩ(xⱼ,tⱼ)|² where (xⱼ,tⱼ) are the collocation points in Ω L_bc/ic(ᵩ) = penalties enforcing boundary conditions and initial conditions The key technical step is that the derivatives inside rᵩ are computed by automatic differentiation ∂uᵩ/∂t, ∂uᵩ/∂x, ∂²uᵩ/∂x², … So we can differentiate the total loss L(ᵩ) with respect to ᵩ and train with gradient descent. This is the whole idea behind PINNs. Learn a function, but make the PDE part of the loss, so the network is trained to be a solution, not just a curve-fitter. In the render, the main 3D surface is the network’s current guess uᵩ(x,t), drawn as a living sheet over the (x,t) plane. Hovering above is the neural scaffold...a visible graph of feature nodes and connections. The bright tension threads are the physics residual rᵩ(x,t): each thread tethers a collocation bead on the sheet up to the scaffold, and it thickens and brightens exactly where |rᵩ| is large (color encodes the sign). As training runs, those threads go slack across the domain not because we hid the error, but because the network has actually been pushed toward rᵩ(x,t) ≈ 0. #PINNs #PhysicsInformedNeuralNetworks #ScientificMachineLearning #PDE #DifferentialEquations #Optimization #MachineLearning #AppliedMath #ComputationalPhysics

Mathelirium

47,308 Aufrufe • vor 9 Monaten

The interesting part about GPT in CAD is not that it can make a shape. It is that through MCP, GPT can work directly inside Onshape and turn a plain-English description into actual CAD geometry you can keep editing. In this case, the model builds a radial mechanical part with a central hub, repeated ribs, an outer ring, and a full pattern of mounting holes, all inside the real Onshape document. There is no fake “3D-looking” render hiding the hard part. The geometry exists in the CAD workspace, can be rotated, inspected, modified, and used as the starting point for the next iteration. That changes the workflow from manually clicking through every feature to describing the structure, letting GPT build the first pass, then correcting what matters. Once MCP gets reliable enough, the boring part of CAD starts looking less like modeling and more like supervising.

The interesting part about GPT in CAD is not that it can make a shape. It is that through MCP, GPT can work directly inside Onshape and turn a plain-English description into actual CAD geometry you can keep editing. In this case, the model builds a radial mechanical part with a central hub, repeated ribs, an outer ring, and a full pattern of mounting holes, all inside the real Onshape document. There is no fake “3D-looking” render hiding the hard part. The geometry exists in the CAD workspace, can be rotated, inspected, modified, and used as the starting point for the next iteration. That changes the workflow from manually clicking through every feature to describing the structure, letting GPT build the first pass, then correcting what matters. Once MCP gets reliable enough, the boring part of CAD starts looking less like modeling and more like supervising.

Rina

16,772 Aufrufe • vor 1 Monat

Yilin Wang, MIT mathematician and one of the leading minds on the geometry of randomness: "there is a precise number for how far a shape is from pure chance. Citadel pays $500,000 to people who compute it instead of guessing it." her field is the mathematics of random curves. flip enough coins and the path they trace is not shapeless. it has a precise geometry, and a number, the Loewner energy, that measures how far a curve sits from pure chance. a circle scores zero. it is the most natural thing randomness can draw. almost every shape you see on a chart scores near zero too. it is noise wearing a costume. this is the entire quant problem in one idea. the market draws millions of random curves, and only a vanishing few carry real structure. the edge is a rigorous way to tell the costume from the signal. Citadel pay $500,000 a year for people who can measure that difference instead of feeling it. the trader who falls in love with a pattern is admiring a curve that randomness would have drawn anyway. the shape was never the edge. the odds that randomness did not draw it were.

Yilin Wang, MIT mathematician and one of the leading minds on the geometry of randomness: "there is a precise number for how far a shape is from pure chance. Citadel pays $500,000 to people who compute it instead of guessing it." her field is the mathematics of random curves. flip enough coins and the path they trace is not shapeless. it has a precise geometry, and a number, the Loewner energy, that measures how far a curve sits from pure chance. a circle scores zero. it is the most natural thing randomness can draw. almost every shape you see on a chart scores near zero too. it is noise wearing a costume. this is the entire quant problem in one idea. the market draws millions of random curves, and only a vanishing few carry real structure. the edge is a rigorous way to tell the costume from the signal. Citadel pay $500,000 a year for people who can measure that difference instead of feeling it. the trader who falls in love with a pattern is admiring a curve that randomness would have drawn anyway. the shape was never the edge. the odds that randomness did not draw it were.

Rossst.03

59,310 Aufrufe • vor 1 Monat