and in that paper he talked about how an evolving creature should make graph node system with if else statements and the end result should result in generalizing it just like how humans have done though the history

and this was the inspiration ,Now the main goal was that to make a neural network like this which will help the body perform via a set of command instead of just letting it change all output it should command its individual places and such

The Project

Evolution-1 is a 2D Pymunk quadruped Walking bot. Its brain is an MLP with 16 hidden units, evolved by a genetic algorithm (population 50, 100 generations, 25,000 training episodes per run). Training courses are random slopes up to 5% to 8%, fresh each generation. Every 1,250 episodes, the Genetic algorithms best is kept if it beats the champion basically elitism

The final score comes from 10 held-out test courses with 5-8% slopes, which nobody saw in their training simulation so similar to a black box environment.

I compared two bodies. The kneed leg has the same total length and mass.

so the knee part was again taken inspiration from the paper and also check out - https://www.karlsims.com/evolved-virtual-creatures.html

The knee motor gets half the hip force, following Sims 1994 3.3 part since strength scales with cross-section basic physics .

now the reward per step is +2 times forward torso movement, and -0.1 for standing still after step 45 (why 45 so that it will build momentum iykyk) . A fall costs -100 ( probably need to make it more ), once. An episode ends on a fall, when the walker is stuck (still for 60+ steps, no -100), or at 600 steps.

Why it matters: A fall costs 100 and a pixel pays 2, so 50 px of progress buys back a fall, and the dive hypothesis rests on that trade.

The fall rule matters most. A "fall" is any of these: tilt above 1.2 rad, the torso sinking 25 px below ground, or the lowest corner of the torso box reaching ground height. That last check is purely geometric, so a level but low torso counts as a fall. Optional tilt and energy terms were off (default baseline mode).

you can see the condition i wrote backfired since they kill the walker

How I built the knees

Each leg is a thigh and a shin, two boxes of 20 × 10 px with mass 1, friction 1.2 and collision group 1.

The hip pivots at the torso anchor, with a ±60° limit and motor force 150,000. The knee pivots between the thigh's bottom and the shin's top. Its limit is −90° to 0, so it bends one way, and its Simplemotor gets half the hip force, 75,000. ( why 75k? its i just did it on different and this one worked)

The knee code as it was during the experiment, so you can check my description.

The brain has 8 outputs, hips first and then knees. The step function scales each output by 10 for a hip and by −10 for a knee. −1 bends the knee, putting the foot forward of it, and +1 straightens it.

and the reason why a following this is because of this particular rule am going off

Each knee adds two inputs: the relative angle (shin minus thigh) and the shin's angular velocity times 0.1. Four knees add 8, so 15 inputs become 23. Weights:

straight: 16×15 + 16 + 4×16 + 4  = 324
knees:    16×23 + 16 + 8×16 + 8  = 520

The limit is a soft RotaryLimitJoint. It corrects only after it has been crossed, which is why the motor could push the knee past 90°. That is the bug described below.

Knees is an opt-in flag, off by default, so the old creature is unchanged.

Results

Before training

I wrote down two predictions knees go further on the test courses knees fall less. I ran 10 seeds per body to test whether they are true and in fact they weren't here are the details from the run

IQM basically means the middle 50% only not top and not bottom and the

The 100 episodes per body are 10 seeds times 10 courses. A random kneed seed beats a random straight seed 24% of the time. which is not great due to a policy

And the kneed champions also fell on every easy course ,Most of them never reached a slope. Every course starts with 200 px of flat ground, and 8 of the 10 kneed champions fell on that flat start, at the same spot (within 1 px) on all 20 courses they were scored on. The gap is large but uncertain: the straight interval runs from 190 to 718 px, and the two-sided p of 0.054 does not clear 0.05.

Deviation: My pre-registration said 30 seeds per variant. I ran 10 to save laptop time ,34 core-hours, and the CPU hit 95 °C :( , and I did not record that as a deviation at the time. to properly test whethere they will perform better if given more training or even compute

x is training episodes and y is champion test distance in px

So to combat this inefficiency i toke a deep dive into the code and this is what i got

What I measured, what I found, what I'm guessing

so why is this not working , in nature those with knees run or even walk ever better then those with straight legs so

I inspected the code and replayed every champion on its held-out courses with the code that ran. Two things came out of it.

First, all 100 kneed test falls had small tilt, between 0.1 and 0.8 rad, under the 1.2 rad limit. These were low torsos, not tip-overs: the geometric check from the experiment section fired every time, never tilt or sinking basically my whole rule shooting me in my knee (hehe)

And the main thing which is breaking my experiment ,in all ten kneed seeds the knees bent to 103-143°, past the 90° limit, and up to 81° the wrong way past straight. The limit is a soft joint that corrects only after it is violated, and the 10 rad/s motor outran it. The ±60° hip limits leaked the same way, in both bodies: up to 90° with straight legs and 150°ish with knees. This was my breaking point or the hole in boat which is the reason we are sinking or whatevers

Hypothesis. Here is why I think the Genetic algorithms settles on a dive. No experiment has isolated this, so the arithmetic is hypothetical

With +2 per pixel and one -100 fall, a 200 px lunge earns about +400 minus 100, so about +300. The kneed champions' per-seed test means were 138-245 px. That beats an early clumsy walker, so the GA can settle there.

Summary of the whole thing - python kinda sucks and the knees are clipping onto each other and giving it self a lot of reward and rewarding hacking my policys

Lessons from this case

• Test what ends an episode on its own. A level torso can be "dead" under a geometric rule, and I only saw that after replaying the falls.
• Check that limits hold under full motor power. My 90° knee limit let knees reach 143°, and the hips passed their 60° limit in both bodies.
• Trust your gut as well not just numbers
• One change can be three. "Add knees" was a body, four motors and a bigger brain, so I cannot say which mattered.

What's next (Part 2)

I'm switching over to MuJoCo. It's a Python physics library that handles joint limits and collision penalties way better than what I was using and plus its what people use and can get me that novelty points :D , so it should fix the knee clipping issues and i can test it again although compute time is gonna be big

Code and data

Repo: github.com/000wahab000/Evolution. Experiment config: experiments/exp3_knees.json. Hypotheses: experiments/HYPOTHESES.md. Fall and reward code as it ran: src/environment.py at 76a2da5. Full numbers: results.md.
check this out as well great paper
https://www.karlsims.com/evolved-virtual-creatures.html