In a sense, Adrian Thompson kicked this off in the 90's when he applied an evolutionary algorithm to FPGA hardware. Using a "survival of the fittest" approach, he taught a board to discern the difference between a 1kHz and 10KHz tone.
The final generation of the circuit was more compact than anything a human engineer would ever come up with (reducible to a mere 37 logic gates), and utilized all kinds of physical nuances specific to the chip it evolved on - including feedback loops, EMI effects between unconnected logic units, and (if I recall) operating transistors outside their saturation region.
Article: https://www.damninteresting.com/on-the-origin-of-circuits/
Paper: https://www.researchgate.net/publication/2737441_An_Evolved_...
Reddit: https://www.reddit.com/r/MachineLearning/comments/2t5ozk/wha...
Related. Others?
The origin of circuits (2007) - https://news.ycombinator.com/item?id=18099226 - Sept 2018 (25 comments)
On the Origin of Circuits: GA Exploits FPGA Batch to Solve Problem - https://news.ycombinator.com/item?id=17134600 - May 2018 (1 comment)
On the Origin of Circuits (2007) - https://news.ycombinator.com/item?id=9885558 - July 2015 (12 comments)
An evolved circuit, intrinsic in silicon, entwined with physics (1996) - https://news.ycombinator.com/item?id=8923902 - Jan 2015 (1 comment)
On the Origin of Circuits (2007) - https://news.ycombinator.com/item?id=8890167 - Jan 2015 (1 comment)
That's not a lot of discussion—we should have another thread about this sometime. If you want to submit it in (say) a week or two, email hn@ycombinator.com and we'll put it in the second-chance pool (https://news.ycombinator.com/pool, explained at https://news.ycombinator.com/item?id=26998308), so it will get a random placement on HN's front page.
If you’re up for sharing, I’m curious to know approximately how many hours each week you spend working on HN. It seems like it would be an enormous amount of time, but I’m just guessing.
Dang leads HN: https://www.newyorker.com/news/letter-from-silicon-valley/th...
I suspect cloning tech is out there and Dang(s) are one of the first successful iterations. I just dont get how there is seemingly no time off, no vacations, sick days etc. Talk about passion.
Other alternative is the image of pale guy with laptop on some beautiful beach or climbing some crazy peak. Same passion, just concentrated in 1 body.
Dang is the end product of an evolutionary algorithm.
@dang has a neuralink implant directly feeding HN to his brain...
I don't count them so I'm afraid I don't know. The hours get sort of fractally sprayed across my days (and weeks).
Did something funky happen to the timestamps in this thread? I could've sworn I was reading it last night (~12h ago)
It looks like we put the thread in HN's second-chance pool (https://news.ycombinator.com/item?id=26998308), so it got re-upped and given a random slot on the frontpage.
The relativized timestamps are an artifact of the re-upping system. There are past explanations here: https://hn.algolia.com/?dateRange=all&page=0&prefix=true&que....
Sorry for the confusion! I know it's weird but the alternative turns out to be even more confusing and we've never figured out how to square that circle.
I think dang did something manual to push it back to the frontpage, and that reset the timestamps on everyone’s existing comments…
There is a comment here by me which says “2 hours ago”, I swear I wrote it longer ago than that - indeed, my threads page still says I wrote it 20 hours ago, so it is like part of the code knows when I really wrote it, another part now thinks I wrote it 18 hours later than I did…
Yes, the relativized timestamps only show on /news (i.e. the frontpage) and /item pages. You can always see the original timestamps on other pages, like /submitted, /from, or (as you say) /threads.
Edit: I checked the code and the actual list is:
Fascinating paper. Thanks for the ref.
Operating transistors outside the linear region (the saturated "on") on a billion+ scale is something that we as engineers and physicists haven't quite figured out, and I am hoping that this changes in future, especially with the advent of analog neuromorphic computing. The quadratic region (before the "on") is far more energy efficient and the non-linearity could actually help with computing, not unlike the activation function in an NN.
Of course, the modeling the nonlinear behavior is difficult. My prof would say for every coefficient in SPICE's transistor models, someone dedicated his entire PhD (and there are a lot of these coefficients!).
I haven't been in touch with the field since I moved up the stack (numerical analysis/ML) I would love to learn more if there has been recent progress in this field.
I believe neuromorphic spiking hardware will be the step to truly revolutionize the field of anthropod contagion issues.
Can’t tell if this is a joke or not
I came in already knowing what neuromorphic hardware is and I'm also unsure
joke I think, anthropod is probably another way of saying bugs/ants haha
Oh christ you're right, they were actually being really funny. I was being super literal and imagined them being very excited about futuristic advances in giant isopod diagnosis and care
Yeah, anthropic bugs. The planet is infested with them.
*arthropod, as in "joint(ed) leg" (cf. arthritis), GP misspelled it. "Anthropod" would mean something like "human leg".
AI-created chips will be so weird, instead of bugs they'll have aliens: https://monster.fandom.com/wiki/Anthropod
Bug zapper
at last, something possibly more buggy than vibe coding!
My thoughts, exactly.
The machine learning model didn’t discover something that humans didn’t know about. It abused some functions specific to the chip that could not be repeated in production or even on other chips or other configurations of the same chip.
That is a common problem with fully free form machine learning solutions: They can stumble upon something that technically works in their training set, but any human who understood the full system would never actually use due to the other problems associated with it.
> The quadratic region (before the "on") is far more energy efficient
Take a look at the structure of something like CMOS and you’ll see why running transistors in anything other than “on” or “off” is definitely not energy efficient. In fact, the transitions are where the energy usage largely goes. We try to get through that transition period as rapidly as possible because minimal current flows when the transistors reach the on or off state.
There are other logic arrangements, but I don’t understand what you’re getting at by suggesting circuits would be more efficient. Are you referring to the reduced gate charge?
The previous poster was probably thinking about very low power analog circuits or extremely slow digital circuits (like those used in wrist watches), where the on-state of the MOS transistors is in the subthreshold conduction region (while the off state is the same off state as in any other CMOS circuits, ensuring a static power consumption determined only by leakage).
Such circuits are useful for something powered by a battery that must have a lifetime measured in years, but they cannot operate at high speeds.
In other words, optimization algorithms in general are prone to overfitting. Fortunately there are techniques to deal with that. Thing is, once you find a solution that generalize better to different chips, it probably won't be as small as the solution found.
> Take a look at the structure of something like CMOS and you’ll see why running transistors in anything other than “on” or “off” is definitely not energy efficient. In fact, the transitions are where the energy usage largely goes. We try to get through that transition period as rapidly as possible because minimal current flows when the transistors reach the on or off state.
Sounds like you might be thinking of power electronic circuits rather than CMOS. In a CMOS logic circuit, current does not flow from Vdd to ground as long as either the p-type or the n-type transistor is fully switched off. The circuit under discussion was operated in subthreshold mode, in which one transistor in a complementary pair is partially switched on and the other is fully switched off. So it still only uses power during transitions, and the energy consumed in each transition is lower than in the normal mode because less voltage is switched at the transistor gate.
> In a CMOS logic circuit, current does not flow from Vdd to ground as long as either the p-type or the n-type transistor is fully switched off.
Right, but how do you get the transistor fully switched off? Think about what happens during the time when it’s transitioning between on and off.
You can run the transistors from the previous stage in a different part of the curve, but that’s not an isolated effect. Everything that impacts switching speed and reduces the current flowing to turn the next gate on or off will also impact power consumption.
There might be some theoretical optimization where the transistors are driven differently, but at what cost of extra silicon and how delicate is the balance between squeezing a little more efficiency and operating too close to the point where minor manufacturing changes can become outsized problems?
Seems like this overfitting problem could have been trivially fixed by running it on more than one chip, no?
Unfortunately not. This is analogous to writing a C program that relied on undefined behavior on the specific architecture and CPU of your developer machine. It’s not portable.
The behavior could change from one manufacturing run to another. The behavior could disappear altogether in a future revision of the chip.
The behavior could even disappear if you change some other part of the design that then relocated the logic to a different set of cells on the chip. This was noted in the experiment where certain behavior depended on logic being placed in a specific location, generating certain timings.
If you rely on anything other than the behavior defined by the specifications, you’re at risk of it breaking. This is a problem with arriving at empirical solutions via guess and check, too.
Ideally you’d do everything in simulation rather than on-chip where possible. The simulator would only function in ways supported by the specifications of the chip without allowing undefined behavior.
>The behavior could change from one manufacturing run to another. The behavior could disappear altogether in a future revision of the chip.
That's the overfitting they were referring to. Relying on the individual behaviour is the overfit. Running on multiple chips (at learning time) reduces the benefit of using an improvement that is specific to one chip.
You are correct that simulation is the better solution, but you have to do more than just limit to the operating range of the components, you have to introduce variances similar to the specified production precision. If the simulator made assumptions that the behaviour of two similar components was absolutely identical to each other then within tolerance manufacturing errors could be magnified.
If you simply buy multiple chips at once and train on them, you may overfit because they are all likely from the same wafer. If you spent an effort and bought chips from multiple sources, they might end up being all the same hardware revision. And even if you got all existing hardware revisions, there is no guarantees that the code will keep working on new hardware revisions which has not came out yet.
There is also problems with chips aging, related circuitry (filtering capacitors age too, and the power gets worse over time), operating temperature, faster degradation from unusual conditions...
As long as all you look at is inputs and outputs, it is impossible to not to overfit. For a robust system, you need to look at the official, published spec, because that's what the manufacturer guarantees and tests for - and AI cannot do this.
> For a robust system, you need to look at the official, published spec, because that's what the manufacturer guarantees and tests for - and AI cannot do this.
Why not? All you have to do is run it in a simulator.
I'm having trouble understanding. Chips with very high transistor counts tend to use saturation/turn-off almost exclusively. Very little is done in the linear region because it burns a lot of power and it's less predictable.
> Operating transistors outside the linear region (the saturated "on")
Do fuzz pedals count?
To be fair, we know they work and basically how they work, but the sonic nuances can be very hard to predict from a schematic.
>Operating transistors outside the linear region (the saturated "on") on a billion+ scale
The whole point of switching transistors is that we _only_ operate them in the fully saturated on or totally off IV-curve region?
Subthreshold circuits are commercially available, just unpopular since all the tools are designed for regular circuits. And the overlap between people who understand semiconductors and people who can make computational tools is very limited, or it's just cheaper to throw people+process shrinks at the problem.
I really wish I still had the link, but there used to be a website that listed a bunch of times in which machine learning was used (mostly via reinforcement learning) to teach a computer how to play a video game and it ended up using perverse strategies that no human would do. Like exploiting weird glitches (https://www.youtube.com/watch?v=meE5aaRJ0Zs shows this with Q*bert)
Closest I've found to the old list I used to go to is this: https://heystacks.com/doc/186/specification-gaming-examples-...
Make no mistake most humans will exploit any glitches and bugs they can find for personal advantage in game. It’s just machines can exploit timing bugs better.
Some people are able to do frame perfect inputs semi consistently from what I understand. I don’t understand how, as my own performance is around hitting 100ms window once, every other time
Maybe they have better equipment?
If you're using a typical PC (or $deity forbid, a phone) with a typical consumer OS, there's several sources of variability between your controller and the visual feedback you receive from the game, each of which could randomly introduce delays on the order of milliseconds or more. That "randomly" here is the key phrase - lag itself is not a problem, the variability is.
Better equipment or not, frame-perfect input is just hard to do and I'm impressed with people being able to do it.
on youtube, codebullet remakes games so that he can try different AI techniques to beat them.
My favorite example was a game of pong with the goal of staying alive as long as possible. One ML algo just paused the game and left it like that.
Is that Learnfun/Playfun that tom7 made? That one paused just before losing on tetris and left it like that, because any other input would make it lose
No I want to say this was ~10 years ago. Happened to a university researcher IIRC.
My favorite was the ML learning how to optimally make the lowest-impact landing in a flight simulator— it discovered that it could wrap the impact float value if the impact was high enough so instead of figuring out the optimal landing, it started figuring out the optimal path to the highest-impact crashes.
This comment ought to be higher up. Such a perfect summary of what I have struggled to understand, which is the “danger” of AI once we allow it to control things
And yes you can fix the bug but the bike wheel guy shows you there will always be another bug. We need a paper/proof that invents a process that can put an AI-supported (non human intervention) finite cap or limiter or something on the possible bug surface
Is AI the danger, or is our inability to simplify a problem down to an objective function the problem?
If anything, AI could help by "understanding" the real objective, so we don't have to code these simplified goals that ML models end up gaming no?
>simplify a problem down to an objective function
Yes, I have an intuition that this is NP hard though
Simplification is the problem here, arguably. Even a simple-sounding objective (say, a bicycle wheel that holds load the best) has at least one implicit assumption - it will be handled and used in the real world. Which means it'll be subject of sloppy handling and thermal spikes and weather and abuse and all kinds of things that are not just meeting the goal. Any of those cheesy AI designs, if you were to 3D-print/replicate them, they'd fall apart as you picked them up. So the problem seems to be, ML algorithm is getting too simple goal function - one lacking the "used in the real world" part.
I feel that a good first step would be to introduce some kind of random jitter into the simulation. Like, in case of the wheels, introduce road bumps, and perhaps start each run by simulating dropping the wheel from a short distance. This should quickly weed out "too clever" solutions - as long as the jitter is random enough, so RL won't pick up on it and start to exploit its non-randomness.
Speaking of road bumps: there is no such thing in reality as a perfectly flat road; if the wheel simulator is just rolling wheels on mathematically perfect roads, that's a big deviation from reality - precisely the kind that allows for "hacky" solutions that are not possible in the real world.
You would have to introduce jitter to every possible dimension, when the dimensions themselves are continually expanding (as illuminated by the bike wheel example).. the combination of jitter x dimensions leads to an undefined problem (AKA theory of everything) in exponential fashion
How would more AI help? "given this goal with these parameters, figure out if another AI will ever game it into eventual thermonuclear war. "
Feels halting problem-esque.
My point was that instead of blaming ML - or optimisation tools really - for gaming objective functions and coming up with non-solutions that do maximise reward, AI could instead be used to measure the reward/fitness of the solution.
So to the OP's example "optimise a bike wheel", technically an AI should be able to understand whether a proposed wheel is good or not, in a similar way to a human.
Humans don't simplify problems by reducing them to objective functions: we simplify them by reducing them to specific instances of abstract concepts. Human thought is fundamentally different to the alien processes of naïve optimising agents.
We do understand the "real objectives", and our inability to communicate this understanding to hill-climbing algorithms is a sign of the depth of our understanding. There's no reason to believe that anything we yet call "AI" is capable of translating our understanding into a form that, magically, makes the hill-climbing algorithm output the correct answer.
There is an apocryphal story about AI:
Conglomerate developed an AI and vision system that you could hook up to your Anti-aircraft systems to eliminate any chance of friendly fire. DARPA and the Pentagon went wild, pushing the system through test so they could get to the live demonstration.
They hook up a live and load up dummy rounds system, fly a few friendly planes over and everything looks good however when they fly a captured Mig-21 over the system fails to respond. The Brass is upset and the engineers are all scratching their heads trying to figure out what is going on but as the sun sets the system lights up, trying to shoot down anything in the sky.
They quickly shut down the system and do a postmortem, in the review they find that all the training data for friendly planes are perfect weather, blue sky overflights and all the training data for the enemy are nighttime/ low light pictures. The AI determined that anything fling during the day is friendly and anything at night is terminate with extreme prejudiced.
we used synthetic data for training a (sort of) similar system. not gonna get into the exact specifics, but we didn't have a lot of images of one kind of failure use-case.
like they're just not that many pictures of this stuff. we needed hundreds, ideally thousands, and had, maybe, a dozen or so.
okay, so we'll get a couple of talented picture / design guys from the UI teams to come out and do a little photoshop of the images. take some of the existing ones, play with photoshop, make a couple of similar-but-not-quite-the-same ones, and then hack those in a few ways. load those into the ML and tell em they're targets and to flag on those, etc. etc.
took a week or two, no dramas, early results were promising. then it just started failing.
turns out we ran into issues with two (2) pixels, black pixels against a background of darker black shades, that the human eye basically didn't see or notice; these were artifacts from photoshopping, and then re-using parts of a previous image multiple times. the ML started determining that 51% or more of the photos had those 2 pixels in there, and that photos lacking those -- even when painfully obvious to the naked eye -- were fails.
like, zooming in at it directly you're like yea, okay, those pixels might be different, but otherwise you'd never see it. thankfully output highlighting flagged it reasonably quickly but still took 2-3 weeks to nail down the issue.
It wouldn’t be cheap but I could see 3D modeling and physically based rendering (I’ve been working with Octane but others should do the job fine) being a really good use case for this. Having a bazillion years in 2D but getting into 3D at a professional level a few years ago, I don’t think I’d even suggest using a purely 2D approach if I was looking for optimal results. Match all the camera specs, simulate all sorts of lighting and weather patterns from all sorts of angles, etc.
That likely is an urban legend. See https://gwern.net/tank
Yes.
>apocryphal
>of doubtful authenticity
https://www.merriam-webster.com/dictionary/apocryphal
Humans have the same vulnerability
https://en.wikipedia.org/wiki/Perverse_incentive
Ummm, I'm going to hold off on that FSD subscription for a bit longer...
All these claims are like "programming is impossible because I typed in a program and it had a bug". Yes, everyone's first attempt at a reward function is hackable. So you have to tighten up the reward function to exclude solutions you don't want.
What claim would that be? It’s a hilarious, factual example of unintended consequences in model training. Of course they fixed the freaking bug in about two seconds.
The recent nvidia AI cuda engineer was also similar: https://news.ycombinator.com/item?id=43113941
I'm almost 100% sure this is the link you're looking for: https://docs.google.com/spreadsheets/d/e/2PACX-1vRPiprOaC3Hs...
Haha that was actually the same one I posted in my comment.
This was some old website. A coworker sent it to me on Hipchat at my previous job about 10 years ago. And finding anything online older than like 5 years is nearly impossible unless you have the exact URL on hand.
Oh sorry! I recognized the description but since I recalled mine being a Google Sheets link, I just went straight into search mode - and yep, it actually took me a bit to find.
There’s a few very cool examples where someone recently used RL to solve trackmania, and ends up having to add all sorts of constraints/penalties to prevent extremely strange exploits/glitches that are discovered IIRC… been a while since I watched.
https://youtu.be/Dw3BZ6O_8LY?si=VUcJa_hfCxjZhhfR
https://youtu.be/NUl6QikjR04?si=DpZ-iqVdqjzahkwy
Well, in the case of the latter, there was a vaguely known glitch for driving on the nose that allowed for better speeds than possible on 4 wheels, but it would be completely uncontrollable to a human. He figured out how to break the problem down into steps that the NN could gradually learn piecewise, until he had cars racing around tracks while balancing on their nose.
It turned out to have learned to keep the car spinning on its nose for stability, and timing inputs to upset the spinning balance at the right moment to touch the ground with the tire to shoot off in a desired direction.
I think the overall lesson is that, to make useful machine learning, we must break our problems down into pieces small enough that an algorithm can truly "build up skills" and learn naturally, under the correct guidance.
One of the games that I stumbled across on Steam recently was "AI Learns to Drive" - https://store.steampowered.com/app/3312030/AI_Learns_To_Driv...
It's a neat toy (not really "useful" nor too much of a "game") for generating interest in how neural nets work.
> using perverse strategies that no human would do
Of course we do use perverse strategies and glitches in adversarial multiplayer all the time.
Case in point chainsaw glitch, tumblebuffs, early hits and perfect blocks in Elden Ring
In my thesis many years ago [0] I used EAs to build bicycle wheels. They were so annoyingly good at exploiting whatever idiosyncrasies in my wheel-simulator. Like, the first iterations of my simulator it managed to evolve wheels that would slowly oscillate due to floating point instability or something, and when applied forces to it would increase and increase until the whole simulator exploded and the recorded forces were all over the place, of course then out-competing any wheel in at least some objective dimension.
After fixing those bugs, I mostly struggled with it taunting me. Like building a wheel with all the spokes going from the hub and straight up to the rim. It of course would break down when rolling, but on the objective of "how much load can it handle on the bike" it again out-competed every other wheel, and thus was at the pareto-front of that objective and kept showing up through all my tests. Hated that guy, heh. I later changed it to test all wheels in at least 4 orientations, it would then still taunt me with wheels like (c) in this figure[1], exploiting that.
[0]: https://news.ycombinator.com/item?id=10410813 [1]: https://imgur.com/a/LsONTGc
For the model, the weird glitches are just another element of the game. As they can't reason, have no theory of world or even any real knowledge of what is doing, the model don't have the prior assumptions a human would have about how the game is supposed to be played.
If you think about it, even using the term "perverse" is a result of us antropomorphizing any object in the universe that does anything we believe is on the realm of things humans do.
Not quite what you're describing, but no one has yet linked the classic Tom7 series where he applies deep learning to classic NES games: https://youtu.be/xOCurBYI_gY
I've referenced this paper many times here; it's easily in my top 10 of papers I've ever read. It's one of those ones that, if you go into it blind, you have several "Oh no f'king way" moments.
The interesting thing to me now is... that research is very much a product of the right time. The specific Xilinx FPGA he was using was incredibly simple by today's standards and this is actually what allowed it to work so well. It was 5v, and from what I remember, the binary bitstream to program it was either completely documented, or he was able to easily generate the bitstreams by studying the output of the Xilinx router- in that era Xilinx had a manual PnR tool where you could physically draw how the blocks connected by hand if you wanted. All the blocks were the same and laid out physically how you'd expect. And the important part is that you couldn't brick the chip with an invalid binary bitstream programming. So if a generation made something wonky, it still configured the chip and ran it, no harm.
Most all, if not all modern FPGAs just cannot be programmed like this anymore. Just randomly mutating a bitstream would, at best, make an invalid binary that the chip just won't burn. Or, at worst, brick it.
I remember this paper being discussed in the novel "Science of Discworld" -- a super interesting book involving collaboration between a fiction author and some real world scientists -- where the fictional characters in the novel discover our universe and its rules ... I always thought there was some deep insight to be had about the universe within this paper. Now moreso I think the unexpectedness says something instead about the nature of engineering and control and human mechanisms for understanding these sorts of systems ... -- sort of by definition human engineering relies on linearized approximations to characterize the effects being manipulated -- so something which operates in modes far outside those models is basically inscrutable. I think that's kind of expected but the results still provoke the fascination to ponder the solutions super human engineering methods might yet find with the modern technical substrates.
Xe highly recommend the series! Xe keep going back to them for bedtime audio book listening. Chapters alternate between fact and fiction and the mix of intriguing narrative and drier but compelling academic talk help put xir otherwise overly busy mind to rest. In fact, xe bought softcover copies of two of them just last week.
The science is no longer cutting edge (some are over twenty years old) but the deeper principles hold and Discworld makes for an excellent foil to our own Roundworld, just as Sir Pratchett intended.
Indeed, the series says more about us as humans and our relationship to the universe than the universe itself and xe love that.
IIRC the flip-side was that it was hideously specific to a particular model and batch of hardware, because it relied on something that would otherwise be considered a manufacturing flaw.
long time ago, maybe in russian journal "Radio" ~198x, there was someone there describing that if one gets certain transistor from particular batch of particular factory/date, and connect it in whatever weird way, will make a full FM radio (or similar-complex-thing).. because they've wronged the yields. No idea how they had figured that out.
But mistakes aside, what would it be if the chips from the factory could learn / fine-tune how to work (better) , on the run..
AM radio can be "detected" with a semiconductor, so this kinda makes sense if you squint. If you can find it, someday, update this!
you can detect FM with an AM radio - "slope detection". This was in the back of my head when i typed this comment. A memory of picking up KFI on a tooth filling when licking the lid from a pudding when i was a kid. I had the real silver colored fillings. I used to get zapped, every time, and it was painful. It had to have been the semi-conductive amalgam, my arms acting as a dipole, and my skull and body the ground plane. But ancillary to that, i remembered the little electronic hobby kits we had, and a wire, a resistor, and a speaker was about all you needed to hear KNX 1070, a clear channel broadcast AM station in Orange County, CA.
At my highschool, we had FM radio transmitter on the other side of street. Pretty often you could hear one of the stations in computer speakers in library, so FM radio can be detected by simple analog circuits.
You need a PLL somewhere, because the audio signal is encoded in the frequency shift of the carrier (e.g. 98 MHz +/- 150 kHz).
Or maybe you were getting a leak from the audio signal before modulation, e.g. via power lines or something.
Interestingly, radios used to be called transistors colloquially.
Not even one batch. It was specific to that exact one chip it was evolved on. Trying to move it to another chip of the same model would produce unreliable results.
There is actually a whole lot of variance between individual silicon chips, even two chips right next to each other on the wafer will preform slightly differently. They will all meet the spec on the datasheet, but datasheets always specify ranges, not exact values.
If I recall the original article, I believe it even went a step further. While running on the same chip it evolved on, if you unplugged the lamp that was in the closest outlet the chip the chip stopped working. It was really fascinating how environmentally specific it evolved.
That said, it seems like it would be very doable to first evolve a chip with the functionality you need in a single environment, then slowly vary parameters to evolve it to be more robust.
Or vice versa begin evolving the algorithm using a fitness function that is the average performance across 5 very different chips to ensure some robustness is built in from the beginning.
Yeah, if you took it outside the temperature envelope of the lab it failed. I guess thermal expansion?
There were also a bunch of cells that had inputs, but no outputs. When you disconnected them... the circuit stopped working. Shades of "magic" and "more magic".
I've never worked with it, but I've had a fascination with GA/GP ever since this paper/the Tierra paper. I do wonder why it's such an attractive technique - simulated annealing or hill climbing just don't have the same appeal. It's the biological metaphor, I think.
> slowly vary parameters to evolve it to be more robust
Injecting noise and other constraints (like forcing it place circuits in different parts of the device) are totally valid when it needs to evolve in-place.
For the most part, I think it would be better to run in a simulator where it can evolve against an abstract model, then it couldn't overfit to the specific device and environment. This doesn't work if the best simulator of the system is the system itself.
https://en.wikipedia.org/wiki/Robust_optimization
https://www2.isye.gatech.edu/~nemirovs/FullBookDec11.pdf
Robust Optimization https://www.youtube.com/watch?v=-tagu4Zy9Nk
Agreed, but to some degree relying on a simulator means it can no longer evolve truly novel solutions. No simulator would have accurately simulated many of the effects it was leveraging in the lab. Essentially you would only generate efficient uses of concepts we already know how to model / engineer well. Using the setup he used, it can generate things we don't understand well and can take advantage of. Or begin to study better.
That's was truly interesting about it to me.
I remember talking about this with my friend and fellow EE grad Connor a few years ago. The chip's design really feels like a biological approach to electrical engineering, in the way that all of the layers we humans like to neatly organize our concepts into just get totally upended and messed with.
Biology also uses tons of redundancy and error correction that the generative algorithm approach lacks.
Though, the algorithm might plausibly evolve it if it were trained in a more hostile environment.
I should have read the comments because I just spent 20 minutes trying to find the article in Discover magazine about this exact thing: https://www.discovermagazine.com/technology/evolving-a-consc...
The part that I always remember is that if they changed the temperature in the room by a couple degrees the chip would stop working.
Relying on nuances of the abstraction and undefined or variable characteristics sounds like a very very bad idea to me.
The one thing you generally want for circuits is reproducibility.
Yeah also given that I don't know any further attempts to do this, looks like it remains just an intellectual curiosity.
I read the damn interesting post back when it came out and seeing the title of the post immediately led me to thinking of Thompson's post as well.
Yup, was coming here to basically say the same thing. Amazing innovations happen when you let a computer just do arbitrary optimization/hill climbing.
Now, you can impose additional constraints to the problem if you want to keep it using transistors properly or to not use EM side effects, etc.
This headline is mostly engagement bait as it is first nothing new and second, it is actually fully controllable.
“More compact than anything a human engineer would ever come up with” … sounds more like they built an artificial Steve Wozniak
The interesting thing about this project is that it shouldn’t even be possible if the chip behaved as an abstract logical circuit since then it would simply implement a finite automation. You must abuse the underlying physics to make the logic gates behave like something else.
Abstract logical circuits are still leaky abstractions, for example hazards are possible.
https://en.wikipedia.org/wiki/Hazard_(logic)
Yes you can go even more abstract and ignore time flow completely and have pure boolean logic, but then it can't be practically implemented at all.
So, the future is reliance on undefined but reproducible behavior
Not sure that's working out well for democracy
That's exactly what I thought of too when I saw the title.
Basically brute force + gradient descent.
Reminds of disassembled executables, unintelligible to the untrained eye.
It's even more convoluted when also re-interpreted into C language.
Designs nobody would ever come up with, but equivalent and even with compiler tricks we'd not have known.
Thompson is who I immediately thought of. Thanks for digging up the actual cite.
And this is the kind of technology we use to decide if someone should get a loan, or if something is a human about to be run over by a car.
I think I'm going to simply climb up a tree and wait this one out.
What if it invented a new kind of human, or a different kind of running over?
classic thank you! I've been trying to find this recently. I first heard about this in my genetic algorithms class more than 15 years ago.
A classic. What's old is new again