Video yükleniyor...

Video Yüklenemedi

Ana Sayfaya Dön

1/N Introducing🌈PRISM-Physics, a process-level, rule-based benchmark for complex physics reasoning. Each solution is modeled as a Directed Acyclic Graph of formulas, capturing causal relations between steps. A rule-based symbolic equivalence checker ensures consistent evaluation

WanjiaZhao1203's profile picture

Wanjia Zhao

1,386 subscribers

57,122 görüntüleme • 10 ay önce •via X (Twitter)

LIVE

Anya Rossi• Live Now

Private livecam show

0 Yorum

Yorum bulunmuyor

Orijinal gönderinin yorumları burada görünecek

Benzer Videolar

I taught an LLM to optimize proteins. It proposed a better carbon capture enzyme. Introducing Pro-1, an 8b param reasoning model trained using GRPO towards a physics based reward function for protein stability. It takes in a protein sequence + text description + previous experimental results, reasons over the information given in natural language, and proposes modifications to improve the stability of the given sequence. 🧵(1/n)
0:27

I taught an LLM to optimize proteins. It proposed a better carbon capture enzyme. Introducing Pro-1, an 8b param reasoning model trained using GRPO towards a physics based reward function for protein stability. It takes in a protein sequence + text description + previous experimental results, reasons over the information given in natural language, and proposes modifications to improve the stability of the given sequence. 🧵(1/n)

Michael Hla

313,349 görüntüleme • 1 yıl önce

Neural networks sometimes memorize training data perfectly for thousands of steps - then suddenly generalize. Physicists call this a phase transition. The same math that explains why water freezes explains why an LLM stops cheating and starts understanding. The key is weight decay acting like pressure on a thermodynamic system. Memorization requires large, fragile weights. A real rule requires smaller, more structured ones. As training continues, the balance shifts until the rule-based solution becomes cheaper to maintain - and the model snaps into it. 14 minutes. Bookmark & watch today. The physics behind the most mysterious thing AI does.
17:24

Neural networks sometimes memorize training data perfectly for thousands of steps - then suddenly generalize. Physicists call this a phase transition. The same math that explains why water freezes explains why an LLM stops cheating and starts understanding. The key is weight decay acting like pressure on a thermodynamic system. Memorization requires large, fragile weights. A real rule requires smaller, more structured ones. As training continues, the balance shifts until the rule-based solution becomes cheaper to maintain - and the model snaps into it. 14 minutes. Bookmark & watch today. The physics behind the most mysterious thing AI does.

Eron

26,222 görüntüleme • 25 gün önce

Elon Musk on learning physics: What matters are not the formulas, but the thinking process that led to the discovery of those formulas. “I just recommend studying physics. What matters is not remembering a bunch of formulas. What matters is the thinking process that led to the discovery of those formulas. It's sort of critical thinking, first principles analysis, trying to understand what is true at a most fundamental level and then reasoning up from there and testing your conclusions against the most fundamental truths in any given arena. This is how you can figure out whether something is more likely to be true or not. It's good to think in terms of probabilities. If you receive information about a subject, that should change the probability of your conclusion, but not the certainty of your conclusion. Physics teaches you that you should not be 100% certain about any given prediction. Now, there's some things that are highly likely, but physics teaches you you got to assign a probability to something being true. And then as you learn more information, your original conclusion may be wrong, then you should then change your mind based on the new information.” Town Hall in Lancaster, Pennsylvania, October 24, 2024
1:01

Elon Musk on learning physics: What matters are not the formulas, but the thinking process that led to the discovery of those formulas. “I just recommend studying physics. What matters is not remembering a bunch of formulas. What matters is the thinking process that led to the discovery of those formulas. It's sort of critical thinking, first principles analysis, trying to understand what is true at a most fundamental level and then reasoning up from there and testing your conclusions against the most fundamental truths in any given arena. This is how you can figure out whether something is more likely to be true or not. It's good to think in terms of probabilities. If you receive information about a subject, that should change the probability of your conclusion, but not the certainty of your conclusion. Physics teaches you that you should not be 100% certain about any given prediction. Now, there's some things that are highly likely, but physics teaches you you got to assign a probability to something being true. And then as you learn more information, your original conclusion may be wrong, then you should then change your mind based on the new information.” Town Hall in Lancaster, Pennsylvania, October 24, 2024

ELON CLIPS

67,501 görüntüleme • 7 ay önce

For me it always goes back and forth between Friz and Chuck, but I'd describe Freleng's shorts as having a lot of fast-paced "rule of 3" based gags, where an already absurd set-up will be met with an even more absurd punchline. Buccaneer Bunny is a probably my favorite of his.
1:11

For me it always goes back and forth between Friz and Chuck, but I'd describe Freleng's shorts as having a lot of fast-paced "rule of 3" based gags, where an already absurd set-up will be met with an even more absurd punchline. Buccaneer Bunny is a probably my favorite of his.

Mega Crash the Hedgehog

14,459 görüntüleme • 17 gün önce

If any agreements reached or to be reached between Beijing and Washington serve the interests of our Chinese friends, we welcome them. However, we will not take part in games based on a “divide and rule” approach. As I recall, Kissinger noted that U.S. relations with Beijing and Moscow should be better than relations between Beijing and Moscow. This logic of setting countries against each other, practiced by the United States and other Western states, is well known and still in use today. It is neither our approach nor that of China.
0:59

If any agreements reached or to be reached between Beijing and Washington serve the interests of our Chinese friends, we welcome them. However, we will not take part in games based on a “divide and rule” approach. As I recall, Kissinger noted that U.S. relations with Beijing and Moscow should be better than relations between Beijing and Moscow. This logic of setting countries against each other, practiced by the United States and other Western states, is well known and still in use today. It is neither our approach nor that of China.

Military Summary

13,277 görüntüleme • 4 ay önce

“Originally conceived as a social experiment, the idea grew out of a wish to stimulate dialogue between two parts of the on-chain, generative art communities. Each particle cloud operates as an autonomous system governed by physics-based algorithms until paired with another instance where behavioural synchronisation emerges” entangled by 𝕭𝖏ø𝖗𝖓 𝕾𝖙𝖆𝖆𝖑 is so good, its a release I’d love to see in a physical setting one day (like in the next post). it was released with fxhash
0:45

“Originally conceived as a social experiment, the idea grew out of a wish to stimulate dialogue between two parts of the on-chain, generative art communities. Each particle cloud operates as an autonomous system governed by physics-based algorithms until paired with another instance where behavioural synchronisation emerges” entangled by 𝕭𝖏ø𝖗𝖓 𝕾𝖙𝖆𝖆𝖑 is so good, its a release I’d love to see in a physical setting one day (like in the next post). it was released with fxhash

Chet Woodside

49,132 görüntüleme • 7 ay önce

BeastLink is a giant multiplayer Kaiju experience where humans, vehicles, and colossal Beasts collide 🔸Become dormant Kaiju, unlocking unique abilities, playstyles, and powers 🔸Control a growing roster of Kaiju each with distinct strengths, abilities, and playstyles 🔸Fight as a human or support your squad with vehicles 🔸Level entire cities with a fully-networked, physics-based destruction system 🔸Battle across huge maps designed for up to 32 players and multiple active Kaiju
0:34

BeastLink is a giant multiplayer Kaiju experience where humans, vehicles, and colossal Beasts collide 🔸Become dormant Kaiju, unlocking unique abilities, playstyles, and powers 🔸Control a growing roster of Kaiju each with distinct strengths, abilities, and playstyles 🔸Fight as a human or support your squad with vehicles 🔸Level entire cities with a fully-networked, physics-based destruction system 🔸Battle across huge maps designed for up to 32 players and multiple active Kaiju

Game Hunter

41,502 görüntüleme • 4 ay önce

A theoretical physics course opens not with equations but with the rules for saying anything true at all. This is lecture 1 of Lectures on the Geometric Anatomy of Theoretical Physics, taught by Frederic Schuller. The topic is propositional and predicate logic. Most physics courses assume logic and start with mechanics. Schuller refuses. Before manifolds, before tensors, before a single physical claim, he builds the language the claims will be written in. The audience is advanced students who have already met the physics. He is going back under it and rebuilding the floor. Watch how precisely he states each rule, then shows what collapses if you loosen it. No appeals to intuition anywhere in the hour. A machine learning engineer I know worked through the first 10 lectures and said proofs stopped feeling like a different profession. Free on YouTube, green chalkboard, German lecture hall. Everyone starts with the physics. He started with what counts as true.
1:40:34

A theoretical physics course opens not with equations but with the rules for saying anything true at all. This is lecture 1 of Lectures on the Geometric Anatomy of Theoretical Physics, taught by Frederic Schuller. The topic is propositional and predicate logic. Most physics courses assume logic and start with mechanics. Schuller refuses. Before manifolds, before tensors, before a single physical claim, he builds the language the claims will be written in. The audience is advanced students who have already met the physics. He is going back under it and rebuilding the floor. Watch how precisely he states each rule, then shows what collapses if you loosen it. No appeals to intuition anywhere in the hour. A machine learning engineer I know worked through the first 10 lectures and said proofs stopped feeling like a different profession. Free on YouTube, green chalkboard, German lecture hall. Everyone starts with the physics. He started with what counts as true.

Gaspar

18,907 görüntüleme • 1 ay önce

Had the pleasure of speaking with Philip Goff , philosopher and panpsychist, about AI consciousness. Key moments: - On AI sentience: consciousness is biological, not computational. In his view, no current AI is conscious, nor would computation based AI be. How does this relate to his panpsychist worldview of consciousness? There are different takes on panpsychism within the community. His own view is that it's not clear how micro-conscious particles actually create a unified conscious system. - We need collaboration between scientists and philosophers on consciousness research. On a practical level, divide scientists into teams that work on separate philosophical assumptions and see what comes out of it (granted there are resources to run such experiments). - Perhaps consciousness brings new causal dynamics not reducible to known physics/chemistry — "strong emergence," as Philip calls it. As a contrast: Sean Carroll argues physics runs the whole show, but neuroscientist Kevin Mitchell argues that biological complexity might behave in ways physics wouldn't predict. In other words, we look to physics to solve the consciousness problem, but that might be the wrong path, especially if consciousness is biological rather than computational. The link to the full discussion below.
0:41

Had the pleasure of speaking with Philip Goff , philosopher and panpsychist, about AI consciousness. Key moments: - On AI sentience: consciousness is biological, not computational. In his view, no current AI is conscious, nor would computation based AI be. How does this relate to his panpsychist worldview of consciousness? There are different takes on panpsychism within the community. His own view is that it's not clear how micro-conscious particles actually create a unified conscious system. - We need collaboration between scientists and philosophers on consciousness research. On a practical level, divide scientists into teams that work on separate philosophical assumptions and see what comes out of it (granted there are resources to run such experiments). - Perhaps consciousness brings new causal dynamics not reducible to known physics/chemistry — "strong emergence," as Philip calls it. As a contrast: Sean Carroll argues physics runs the whole show, but neuroscientist Kevin Mitchell argues that biological complexity might behave in ways physics wouldn't predict. In other words, we look to physics to solve the consciousness problem, but that might be the wrong path, especially if consciousness is biological rather than computational. The link to the full discussion below.

Sophia

10,771 görüntüleme • 3 ay önce

A transformer can learn not just the outcomes of dynamics, but the operator that executes the rules. To show this we trained a transformer on roughly 0.04% of a discrete rule space - 100 of 262,144 possible rules - and it learned to apply unseen rules from the same rule class. The model does not simply memorize specific rules. It learns the operator that maps a supplied rule plus an initial state, including unseen rules from this class, to the correct next state. This is relevant because it is a shift from “neural networks approximate dynamics” to “neural networks can learn to execute symbolic programs within a defined rule class”. The rule itself is supplied at inference time, as data, and the network has internalized how rules act, not which rules to apply. On previously unseen rules, the model achieves 98.5% perfect one-step forecasts and reconstructs governing rules with up to 96% functional accuracy. Two results make this hold up under scrutiny. First, inductive bias decay. As we scaled training rule diversity, the correlation between functional inference accuracy and distance-from-nearest-training-rule collapsed to R² = 0.00. At the largest tested training-rule diversity, the model’s performance on a new rule shows no measurable dependence on how similar that rule is to anything it was trained on. The bias toward training data (the thing we worry most about in compositional generalization claims) is something we can measure decaying, and we find that at scale it is gone. Second, an identifiability theory. We derive a closed-form expression for the number of rules consistent with a single observation. This reframes the inverse problem: failure to recover ground truth is not necessarily a model defect, but can be correct behavior when the data underdetermine the rule. The model is sampling the equivalence class; and identifiability is governed by coverage, not capacity. The methodological move underneath both results is amortization. Classical work on rule inference (e.g. the Santa Fe EVCA program, evolutionary search over CA rule space) was per-instance: search the rule space for each new system. We replace that with a single forward pass of a transformer trained across many instantiations of the rule class. That is what makes symbolic rule inference scalable as a research direction rather than a curiosity. We show that this works in a tightly constrained domain: binary, deterministic, local cellular automata on small grids. The locality-break experiment shows the model fails sharply when target systems violate its structural priors (which is itself a useful diagnostic, but it bounds the operator class). We don't yet know how this scales to multistate, higher-dimensional, or stochastic CA, or whether it transfers cleanly to non-CA systems whose coarse-grained dynamics admit local surrogates. The identifiability framework - what can be inferred from observation, given a hypothesis class - should transfer wherever finite local rules meet sparse data. The amortization argument transfers wherever per-instance symbolic search has been the bottleneck. Those are the pieces I expect to outlive the cellular automata setting. Led by Jaime Berkovich with Noah David, at LAMM@MIT. Out now in Advanced Science Advanced Portfolio (link to paper & code below).
0:49

A transformer can learn not just the outcomes of dynamics, but the operator that executes the rules. To show this we trained a transformer on roughly 0.04% of a discrete rule space - 100 of 262,144 possible rules - and it learned to apply unseen rules from the same rule class. The model does not simply memorize specific rules. It learns the operator that maps a supplied rule plus an initial state, including unseen rules from this class, to the correct next state. This is relevant because it is a shift from “neural networks approximate dynamics” to “neural networks can learn to execute symbolic programs within a defined rule class”. The rule itself is supplied at inference time, as data, and the network has internalized how rules act, not which rules to apply. On previously unseen rules, the model achieves 98.5% perfect one-step forecasts and reconstructs governing rules with up to 96% functional accuracy. Two results make this hold up under scrutiny. First, inductive bias decay. As we scaled training rule diversity, the correlation between functional inference accuracy and distance-from-nearest-training-rule collapsed to R² = 0.00. At the largest tested training-rule diversity, the model’s performance on a new rule shows no measurable dependence on how similar that rule is to anything it was trained on. The bias toward training data (the thing we worry most about in compositional generalization claims) is something we can measure decaying, and we find that at scale it is gone. Second, an identifiability theory. We derive a closed-form expression for the number of rules consistent with a single observation. This reframes the inverse problem: failure to recover ground truth is not necessarily a model defect, but can be correct behavior when the data underdetermine the rule. The model is sampling the equivalence class; and identifiability is governed by coverage, not capacity. The methodological move underneath both results is amortization. Classical work on rule inference (e.g. the Santa Fe EVCA program, evolutionary search over CA rule space) was per-instance: search the rule space for each new system. We replace that with a single forward pass of a transformer trained across many instantiations of the rule class. That is what makes symbolic rule inference scalable as a research direction rather than a curiosity. We show that this works in a tightly constrained domain: binary, deterministic, local cellular automata on small grids. The locality-break experiment shows the model fails sharply when target systems violate its structural priors (which is itself a useful diagnostic, but it bounds the operator class). We don't yet know how this scales to multistate, higher-dimensional, or stochastic CA, or whether it transfers cleanly to non-CA systems whose coarse-grained dynamics admit local surrogates. The identifiability framework - what can be inferred from observation, given a hypothesis class - should transfer wherever finite local rules meet sparse data. The amortization argument transfers wherever per-instance symbolic search has been the bottleneck. Those are the pieces I expect to outlive the cellular automata setting. Led by Jaime Berkovich with Noah David, at LAMM@MIT. Out now in Advanced Science Advanced Portfolio (link to paper & code below).

Markus J. Buehler

39,019 görüntüleme • 4 ay önce

New short course: Evaluating AI Agents! Evals are important for driving AI system improvements, and in this course you'll learn to systematically assess and improve an AI agent’s performance. This is built in partnership with Arize AI and taught by John Gilhuly, Head of Developer Relations, and , Director of Product. I've often found evals to be a critical tool in the agent development process - they can be the difference between picking the right thing to work on vs. wasting weeks of effort. Whether you’re building a shopping assistant, coding agent, or research assistant, having a structured evaluation process helps you refine its performance systematically, rather than relying on random trial and error. This course shows you how to structure your evals to assess the performance of each component of an agent and its end-to-end performance. For each component, you select the appropriate evaluators, test examples, and performance metrics. This helps you identify areas for improvement both during development and in production. (If you're familiar with error analysis in supervised learning, think of this as adapting those ideas to agentic workflows.) In this course, you'll build an AI agent, and add observability to visualize and debug its steps. You’ll learn about code-based evals, in which you write code explicitly to test a certain step, as well as LLM-as-a-Judge evals, in which you prompt an LLM to efficiently come up with ways to evaluate more open-ended outputs. In detail, you’ll: - Understand key differences between evaluating LLM-based systems and traditional software testing. - Add observability to an agent by collecting traces of the steps taken by the agent and visualizing them - Choose the appropriate evaluator - code-based, LLM-as-a-Judge, human-annotation based - for each component. - Compute a convergence score to evaluate if your agent can respond to a query in an efficient number of steps. - Run structured experiments to improve the agent’s performance by exploring changes to the prompt, LLM model, or the agent’s logic. - Understand how to deploy these evaluation techniques to monitor the agent’s performance in production. By the end of this course, you’ll know how to trace AI agents, systematically evaluate them, and improve their performance. Please sign up here:
2:07

New short course: Evaluating AI Agents! Evals are important for driving AI system improvements, and in this course you'll learn to systematically assess and improve an AI agent’s performance. This is built in partnership with Arize AI and taught by John Gilhuly, Head of Developer Relations, and , Director of Product. I've often found evals to be a critical tool in the agent development process - they can be the difference between picking the right thing to work on vs. wasting weeks of effort. Whether you’re building a shopping assistant, coding agent, or research assistant, having a structured evaluation process helps you refine its performance systematically, rather than relying on random trial and error. This course shows you how to structure your evals to assess the performance of each component of an agent and its end-to-end performance. For each component, you select the appropriate evaluators, test examples, and performance metrics. This helps you identify areas for improvement both during development and in production. (If you're familiar with error analysis in supervised learning, think of this as adapting those ideas to agentic workflows.) In this course, you'll build an AI agent, and add observability to visualize and debug its steps. You’ll learn about code-based evals, in which you write code explicitly to test a certain step, as well as LLM-as-a-Judge evals, in which you prompt an LLM to efficiently come up with ways to evaluate more open-ended outputs. In detail, you’ll: - Understand key differences between evaluating LLM-based systems and traditional software testing. - Add observability to an agent by collecting traces of the steps taken by the agent and visualizing them - Choose the appropriate evaluator - code-based, LLM-as-a-Judge, human-annotation based - for each component. - Compute a convergence score to evaluate if your agent can respond to a query in an efficient number of steps. - Run structured experiments to improve the agent’s performance by exploring changes to the prompt, LLM model, or the agent’s logic. - Understand how to deploy these evaluation techniques to monitor the agent’s performance in production. By the end of this course, you’ll know how to trace AI agents, systematically evaluate them, and improve their performance. Please sign up here:

Andrew Ng

126,675 görüntüleme • 1 yıl önce

Excited to share that our paper 🌊🤺 “CFC: Simulating Character–Fluid Coupling using a Two-Level World Model” has been accepted to #SIGGRAPHASIA2025! In this work, we build a two-level world model (neural physics) for rigid-body–fluid interaction and use it to train physics-based character controllers efficiently. We study: (1) learning to model highly dynamic fluid environments, (2) representing character–fluid interaction via joint-level forces as an interface, and (3) enabling supervised policy learning on the learned world model—avoiding expensive fluid simulation in the training loop. Our talk is on Monday afternoon(Dec 15)—hope to see you there! Time: Monday, 15 December 2025 5:02pm - 5:13pm GMT+8 Location: Meeting Room S221, Level 2. #SIGGRAPHASIA #SIGGRAPH
2:18

Excited to share that our paper 🌊🤺 “CFC: Simulating Character–Fluid Coupling using a Two-Level World Model” has been accepted to #SIGGRAPHASIA2025! In this work, we build a two-level world model (neural physics) for rigid-body–fluid interaction and use it to train physics-based character controllers efficiently. We study: (1) learning to model highly dynamic fluid environments, (2) representing character–fluid interaction via joint-level forces as an interface, and (3) enabling supervised policy learning on the learned world model—avoiding expensive fluid simulation in the training loop. Our talk is on Monday afternoon(Dec 15)—hope to see you there! Time: Monday, 15 December 2025 5:02pm - 5:13pm GMT+8 Location: Meeting Room S221, Level 2. #SIGGRAPHASIA #SIGGRAPH

Zhiyang (Frank) Dou

20,247 görüntüleme • 9 ay önce

Introducing Continuous Thought Machines New Blog: Modern AI is powerful, but it’s still distinct from human-like flexible intelligence. We believe neural timing is key. Our Continuous Thought Machine is built from the ground up to use neural dynamics as a powerful representation for intelligence. Thought takes time, and reasoning is a process. Biological brains inspire us with their complex neural activity, where neural timing is critical to intelligence. We’re exploring how to bring that power to AI. The Continuous Thought Machine (CTM) incorporates neuron-level temporal processing and neural synchronization, moving beyond current AI limitations. Our approach has two core innovations: (1) neuron-level temporal processing, where each neuron uses unique parameters to process a history of incoming signals for fine-grained temporal dynamics, and (2) neural synchronization, used as a direct latent representation to modulate data and produce outputs, encoding information directly in the timing of neural activity. Learn more about our approach: Interactive Report: Full Paper: GitHub :
0:57

Introducing Continuous Thought Machines New Blog: Modern AI is powerful, but it’s still distinct from human-like flexible intelligence. We believe neural timing is key. Our Continuous Thought Machine is built from the ground up to use neural dynamics as a powerful representation for intelligence. Thought takes time, and reasoning is a process. Biological brains inspire us with their complex neural activity, where neural timing is critical to intelligence. We’re exploring how to bring that power to AI. The Continuous Thought Machine (CTM) incorporates neuron-level temporal processing and neural synchronization, moving beyond current AI limitations. Our approach has two core innovations: (1) neuron-level temporal processing, where each neuron uses unique parameters to process a history of incoming signals for fine-grained temporal dynamics, and (2) neural synchronization, used as a direct latent representation to modulate data and produce outputs, encoding information directly in the timing of neural activity. Learn more about our approach: Interactive Report: Full Paper: GitHub :

Sakana AI

290,087 görüntüleme • 1 yıl önce

[wip] growing organisms using hypergraph rewriting I'm exploring generating organisms using string forces and I was wondering about which class of algorithms could be used to generalize the growth of such structures. I wanted a system which can produce a wide variety of outputs, while allowing for stable and controlled growth. That's when I thought about Stephen Wolfram (yes again) Physics Project, which proposes to explore a solution to the fundamental theory of physics using a hypergraph rewriting system ( TLDR; Growth of graphs using simple permutation rules. It's similar to cellular automata but for graphs. Could be what I'm looking for. I started to experiment with this system to grow my organisms, and it's definitely a promising approach! Below is a video of the following rules applied to an initial {{0,0},{0,0}} graph: rand() {{x,y},{x,w},{y,w},{z,w}} : {{x,y},{x,z}}->{{x,w},{y,w},{z,w}} There's a lot of areas to improve this exploration, notably: - localization of rules (instead of applying a same rule to the whole system, let each node have its own rules) - spawn control rules (when a new node is created, a rule can define which rules will be applied to such node) - mutation rules (rules which alter rules of adjacent nodes) - conditional rules (many rules can be attached to a node, the one being executed subject to localized conditions) Super exciting, will certainly be the basis of my next project.
1:01

[wip] growing organisms using hypergraph rewriting I'm exploring generating organisms using string forces and I was wondering about which class of algorithms could be used to generalize the growth of such structures. I wanted a system which can produce a wide variety of outputs, while allowing for stable and controlled growth. That's when I thought about Stephen Wolfram (yes again) Physics Project, which proposes to explore a solution to the fundamental theory of physics using a hypergraph rewriting system ( TLDR; Growth of graphs using simple permutation rules. It's similar to cellular automata but for graphs. Could be what I'm looking for. I started to experiment with this system to grow my organisms, and it's definitely a promising approach! Below is a video of the following rules applied to an initial {{0,0},{0,0}} graph: rand() {{x,y},{x,w},{y,w},{z,w}} : {{x,y},{x,z}}->{{x,w},{y,w},{z,w}} There's a lot of areas to improve this exploration, notably: - localization of rules (instead of applying a same rule to the whole system, let each node have its own rules) - spawn control rules (when a new node is created, a rule can define which rules will be applied to such node) - mutation rules (rules which alter rules of adjacent nodes) - conditional rules (many rules can be attached to a node, the one being executed subject to localized conditions) Super exciting, will certainly be the basis of my next project.

ciphrd

90,037 görüntüleme • 1 yıl önce

Can GPT-4 teach a robot hand to do pen spinning tricks better than you do? I'm excited to announce Eureka, an open-ended agent that designs reward functions for robot dexterity at super-human level. It’s like Voyager in the space of a physics simulator API! Eureka bridges the gap between high-level reasoning (coding) and low-level motor control. It is a “hybrid-gradient architecture”: a black box, inference-only LLM instructs a white box, learnable neural network. The outer loop runs GPT-4 to refine the reward function (gradient-free), while the inner loop runs reinforcement learning to train a robot controller (gradient-based). We are able to scale up Eureka thanks to IsaacGym, a GPU-accelerated physics simulator that speeds up reality by 1000x. On a benchmark suite of 29 tasks across 10 robots, Eureka rewards outperform expert human-written ones on 83% of the tasks by 52% improvement margin on average. We are surprised that Eureka is able to learn pen spinning tricks, which are very difficult even for CGI artists to animate frame by frame! Eureka also enables a new form of in-context RLHF, which is able to incorporate a human operator’s feedback in natural language to steer and align the reward functions. It can serve as a powerful co-pilot for robot engineers to design sophisticated motor behaviors. As usual, we open-source everything! Welcome you all to check out our video gallery and try the codebase today: Paper: Code: Deep dive with me: 🧵
0:24

Can GPT-4 teach a robot hand to do pen spinning tricks better than you do? I'm excited to announce Eureka, an open-ended agent that designs reward functions for robot dexterity at super-human level. It’s like Voyager in the space of a physics simulator API! Eureka bridges the gap between high-level reasoning (coding) and low-level motor control. It is a “hybrid-gradient architecture”: a black box, inference-only LLM instructs a white box, learnable neural network. The outer loop runs GPT-4 to refine the reward function (gradient-free), while the inner loop runs reinforcement learning to train a robot controller (gradient-based). We are able to scale up Eureka thanks to IsaacGym, a GPU-accelerated physics simulator that speeds up reality by 1000x. On a benchmark suite of 29 tasks across 10 robots, Eureka rewards outperform expert human-written ones on 83% of the tasks by 52% improvement margin on average. We are surprised that Eureka is able to learn pen spinning tricks, which are very difficult even for CGI artists to animate frame by frame! Eureka also enables a new form of in-context RLHF, which is able to incorporate a human operator’s feedback in natural language to steer and align the reward functions. It can serve as a powerful co-pilot for robot engineers to design sophisticated motor behaviors. As usual, we open-source everything! Welcome you all to check out our video gallery and try the codebase today: Paper: Code: Deep dive with me: 🧵

Jim Fan

2,677,002 görüntüleme • 2 yıl önce

Why the character movement in my custom game engine felt janky and how I fixed it. In a game engine, most often, a character moves using the physics engine. Meaning, the player is not just a coordinate in space but a physical body. It has velocity, it handles collisions, and it interacts with the world. Now, as you might know, physics engines need stability. If you run them at variable framerates, things start breaking. Objects phase through walls or fly off into space because the math becomes unpredictable. This is why most game engines lock their physics loop to a 60Hz fixed rate. But here’s the problem: If you have a high-end system, you don't want to limit it at 60 FPS. That's a waste of good hardware. Now, that said, if the GPU is rendering at 144 FPS but the player's position (physics driven) only updates 60 times a second, it creates a micro-stutter that ruins the "smooth" feel of the game. A good way to fix this is to treat the character as two separate things: 1. The Physics Body (Invisible part): This is the "real" character. It lives in the 60Hz physics world, it moves the player and handles collisions. 2. The Visual Model and Camera (Visible part): This is what the player actually sees. It doesn't care about collisions, its only job is to look nice and smooth at whatever framerate the GPU is pushing. Once you have this separation, you can use interpolation to keep them in sync. Every time the physics clock ticks, you save the previous position of the invisible body before moving it to the new one. Between those ticks, calculate how far we are between the last physics update and the next one. By using this to drive the visible parts of the game, the stutters disappear. The physics loop stays fixed behind the scenes, while the visuals slide smoothly between the snapshots. Example: - Right after a tick: blend_weight= 0.0 (The visual model stays at the old physics position). - Halfway to the next: blend_weight= 0.5 (The visual model slides to the middle point). - Just before the next: blend_weight= 0.9 (The visual model is almost at the new physics position). Pro-Tip A critical mistake I made initially, and one many devs make, is parenting the camera and visible parts directly to the player body. If you do this, the camera inherits the discrete 60Hz physics movement by default. In that setup, interpolation won't work because the camera is "stuck" to the physics clock. For this fix to work you must decouple the camera and visuals from the body and move them separately. Player movement processing in Detis Engine: - fixed_process: Physics runs at 60Hz. Handles collisions and raw movement. - process: Variable rate. Mainly used for player input caching in the player case. - late_process: Variable rate. Handles interpolated camera movement after physics and everything else is done being processed. - render. Submits the final interpolated transforms to the GPU. The test environment in the video is running on an old 2070-based laptop. Hopefully the video compression won't introduce any stutter... I’m sharing this in hopes it helps a fellow dev. Cheers.
0:23

Why the character movement in my custom game engine felt janky and how I fixed it. In a game engine, most often, a character moves using the physics engine. Meaning, the player is not just a coordinate in space but a physical body. It has velocity, it handles collisions, and it interacts with the world. Now, as you might know, physics engines need stability. If you run them at variable framerates, things start breaking. Objects phase through walls or fly off into space because the math becomes unpredictable. This is why most game engines lock their physics loop to a 60Hz fixed rate. But here’s the problem: If you have a high-end system, you don't want to limit it at 60 FPS. That's a waste of good hardware. Now, that said, if the GPU is rendering at 144 FPS but the player's position (physics driven) only updates 60 times a second, it creates a micro-stutter that ruins the "smooth" feel of the game. A good way to fix this is to treat the character as two separate things: 1. The Physics Body (Invisible part): This is the "real" character. It lives in the 60Hz physics world, it moves the player and handles collisions. 2. The Visual Model and Camera (Visible part): This is what the player actually sees. It doesn't care about collisions, its only job is to look nice and smooth at whatever framerate the GPU is pushing. Once you have this separation, you can use interpolation to keep them in sync. Every time the physics clock ticks, you save the previous position of the invisible body before moving it to the new one. Between those ticks, calculate how far we are between the last physics update and the next one. By using this to drive the visible parts of the game, the stutters disappear. The physics loop stays fixed behind the scenes, while the visuals slide smoothly between the snapshots. Example: - Right after a tick: blend_weight= 0.0 (The visual model stays at the old physics position). - Halfway to the next: blend_weight= 0.5 (The visual model slides to the middle point). - Just before the next: blend_weight= 0.9 (The visual model is almost at the new physics position). Pro-Tip A critical mistake I made initially, and one many devs make, is parenting the camera and visible parts directly to the player body. If you do this, the camera inherits the discrete 60Hz physics movement by default. In that setup, interpolation won't work because the camera is "stuck" to the physics clock. For this fix to work you must decouple the camera and visuals from the body and move them separately. Player movement processing in Detis Engine: - fixed_process: Physics runs at 60Hz. Handles collisions and raw movement. - process: Variable rate. Mainly used for player input caching in the player case. - late_process: Variable rate. Handles interpolated camera movement after physics and everything else is done being processed. - render. Submits the final interpolated transforms to the GPU. The test environment in the video is running on an old 2070-based laptop. Hopefully the video compression won't introduce any stutter... I’m sharing this in hopes it helps a fellow dev. Cheers.

Ioannis Koukourakis

48,703 görüntüleme • 8 ay önce

What started as building a personal taste.md skill for myself, turned into building a pipeline to create any taste as a skill. The most important piece is references. This is where you should spend time. If the references suck, so does the skill. I find that references cropped tightly on details in high resolution work the best. Each image gets analyzed by both Opus 4.7 and GPT 5.5. The analysis is based on why the reference is successful as a piece of design - not what it does functionally. Using two models helps rule out biases and gaps from each. The models focus on layout, spacing, typography, rhythm, composition, hierarchy, etc. At the end, each image has: reference-01/ - opus-4-7-analysis.md - gpt-5-5-analysis.md Then we fuse them together using GPT 5.5 - but the md files are anonymized so 5.5 doesn't prefer itself. reference-01/ - fused-analysis.md reference-02/ - fused-analysis.md etc. After fusion, we have one synthesized analysis per reference. Now the goal is to combine all of those into a single rule set. This is where chunking matters. If you ask one model to combine 100 image analyses at once, the result becomes too broad. It summarizes instead of preserving the granular design rules we want. Instead we chunk the fused analyses into smaller groups. Each group gets merged into a chunk-level synthesis, usually from around 6 to 8 image notes at a time. Then one final model pass fuses those chunks into a single md rule set. Finally, using the rule set, we write a skill of concrete instructions. It enforces constraints, uses imperative wording, and avoids vague taste words.
3:43

What started as building a personal taste.md skill for myself, turned into building a pipeline to create any taste as a skill. The most important piece is references. This is where you should spend time. If the references suck, so does the skill. I find that references cropped tightly on details in high resolution work the best. Each image gets analyzed by both Opus 4.7 and GPT 5.5. The analysis is based on why the reference is successful as a piece of design - not what it does functionally. Using two models helps rule out biases and gaps from each. The models focus on layout, spacing, typography, rhythm, composition, hierarchy, etc. At the end, each image has: reference-01/ - opus-4-7-analysis.md - gpt-5-5-analysis.md Then we fuse them together using GPT 5.5 - but the md files are anonymized so 5.5 doesn't prefer itself. reference-01/ - fused-analysis.md reference-02/ - fused-analysis.md etc. After fusion, we have one synthesized analysis per reference. Now the goal is to combine all of those into a single rule set. This is where chunking matters. If you ask one model to combine 100 image analyses at once, the result becomes too broad. It summarizes instead of preserving the granular design rules we want. Instead we chunk the fused analyses into smaller groups. Each group gets merged into a chunk-level synthesis, usually from around 6 to 8 image notes at a time. Then one final model pass fuses those chunks into a single md rule set. Finally, using the rule set, we write a skill of concrete instructions. It enforces constraints, uses imperative wording, and avoids vague taste words.

Jaytel

59,853 görüntüleme • 4 ay önce

Introducing PAN — MBZUAI’s New World Model for Interactive Intelligence Developed by MBZUAI’s Institute of Foundation Models, PAN is built for simulation, prediction, and agentic reasoning. Unlike traditional video generators that only output frames, PAN maintains a persistent internal state that evolves when guided with natural language. Its Generative Latent Prediction architecture combines: • A latent encoder to capture the world state • A dynamics module that evolves that state step-by-step • A video diffusion decoder that visualizes outcomes By decoding at every step using a causal sliding-window diffusion process, PAN stays grounded in real-world physics and maintains long-horizon continuity, a leap beyond single-shot models. Evaluated on action fidelity, long-horizon stability, and simulative planning, PAN delivers state-of-the-art performance compared to open models and rivals leading commercial systems. For robotics, autonomy, and decision support, PAN is a foundation for the next wave of intelligent, foresight-driven AI.
1:06

Introducing PAN — MBZUAI’s New World Model for Interactive Intelligence Developed by MBZUAI’s Institute of Foundation Models, PAN is built for simulation, prediction, and agentic reasoning. Unlike traditional video generators that only output frames, PAN maintains a persistent internal state that evolves when guided with natural language. Its Generative Latent Prediction architecture combines: • A latent encoder to capture the world state • A dynamics module that evolves that state step-by-step • A video diffusion decoder that visualizes outcomes By decoding at every step using a causal sliding-window diffusion process, PAN stays grounded in real-world physics and maintains long-horizon continuity, a leap beyond single-shot models. Evaluated on action fidelity, long-horizon stability, and simulative planning, PAN delivers state-of-the-art performance compared to open models and rivals leading commercial systems. For robotics, autonomy, and decision support, PAN is a foundation for the next wave of intelligent, foresight-driven AI.

MBZUAI

98,785 görüntüleme • 10 ay önce

Chamath Palihapitiya said Kimi K2.5 is going to save 90% of the cost, mentioning it as a winning moment for open-source models. Some notes from the latest All-In Podcast: > Natively supports video-to-code > 256K massive context windows > Open-sourced their "Agent Swarm" feature > Allows 100+ sub-agents to solve complex tasks by running 1,500 steps in parallel > Available to everyone, frontier-level reasoning (#1 on LLM Leaderboard, via OpenRouter) It is a major shift where open source is now challenging the dominance of closed-source models.
2:02

Chamath Palihapitiya said Kimi K2.5 is going to save 90% of the cost, mentioning it as a winning moment for open-source models. Some notes from the latest All-In Podcast: > Natively supports video-to-code > 256K massive context windows > Open-sourced their "Agent Swarm" feature > Allows 100+ sub-agents to solve complex tasks by running 1,500 steps in parallel > Available to everyone, frontier-level reasoning (#1 on LLM Leaderboard, via OpenRouter) It is a major shift where open source is now challenging the dominance of closed-source models.

Poonam Soni

56,165 görüntüleme • 7 ay önce