bigattichouse

Is the distribution because of taking time to look/equipment? or is that actually related to the distribution (clumps in various directions).. I would guess the lines and things are "that's where we've looked" vs. "that's all there is".. I wonder if it's gonna line up with the CBR.

I'm hoping the current oil-war will cause people to re-assess fossil fuel use as expense becomes untenable and we start choosing electric vehicles and renewables.. which will just become "normal" and oil can stick around for synthetic chemistry routes.

When is a heap of sand a heap of sand? The answer isn't in the heap of sand, it's in the observer. LLMs are a VERY heap-like pile of sand, and people are starting to see a mind where one might not yet be. I'm trying out a new word for this phenomenon...

(Link is paywall removed)

Good enough for me. I created the project because I love terminal, and wanted to make something using Claude (to learn how this tool works, strictly for personal enrichment) that solves a small problem I had with some overlapping cron job management.

just pushed a change so now it's:

waitlock myapp & #... do stuff waitlock --done myapp

Sometimes you have a cron job that takes longer than it should (but inconsistently so), and another cron job that clobbers what that cron job is doing.

A lot of people throw around 5% efficiency for Peltiers, and it's just not true - it depends heavily on the temperature differential and current vs. IMax. You can (with care) drive them >2.0 COP.

This isn't anything like a compressor or heatpump system, but Peltiers get a bad rap... they move heat really well if you're not pushing them to the edge.

Here's a nice chart. At 10k difference and 0.1 current max, you're over 2.5 COP. https://www.meerstetter.ch/customer-center/compendium/71-pel...

I've spent an afternoon attempting to compile and run RWKV7 locally.. and I just don't get it. lotta errors in compiling... and it's a lot. Like a lot, a lot... it's walls of versions and sub projects.

Any kind of quickstart guide?

Also found.tried rwkv.cpp, and I can't seem to compile that either.

Good work!

I've been working on a similar BF CPU (Mine's called simple mind). I'd love to see a breakdown of how each of your commands get processed.

You can add a little calcium carbonate to these inks to give them a little shine and offset some of the acidity.

The really neat thing about these inks is that they are soluble when made, and you can write on a document, then - as they dry - , the soluble iron tannates that work into the fibers form an Fe3+ tannate, which is insoluble - you aren't writing on the surface, you're dying the fibers. This is why palimpsest can occur when documents where scraped and re-used (so you can read the originals with Xray methods)

Source: I have a battery patent based on iron-gall inks (US10749168B1), and it's fun stuff to play with! (see more @ http://bigattichouse.com )

My wife makes a fist and counts her knuckles and divots on her left hand:

pinky Jan 31

divot Feb (28/29)

ring March 31

divot April 30

middle May 31

divot June 30

pointer July 31

(now head back the other way)

pointer August 31

divot September 30

middle October 31

divot November 30

ring December 31

I don't know where she learned it, but it's genius.

I've been fascinated by a small mention in the 1.58bit quantization article that mentioned 0.68 quantization , which I believe to mean 0,1 instead of 1.58's -1,0,1. When I read https://www.reddit.com/r/LocalLLaMA/comments/1bpa6ol/unoffic... great experiment of making their own unofficial 1.58b quantization, I began to wonder if I could squeeze a vector down to 1 bit. And.. I can! (with some caveats in the discussion)

It was when I realized that XNOR and population count could basically score 32 dimensions at a time.

While this isn't ANYTHING like an actual quantized LLM, I thought it was a really nice proof-of-concept, and could be very useful for smaller machines running RAG applications.

My Code: https://github.com/bigattichouse/bitvector_research

NOTE: I'm not saying 30X faster than GPUs, but CPU implementations could be 30X faster.

I've been fascinated by a small mention in the 1.58bit quantization article that mentioned 0.68 quantization , which I believe to mean 0,1 instead of 1.58's -1,0,1. When I read https://www.reddit.com/r/LocalLLaMA/comments/1bpa6ol/unoffic... great experiment of making their own unofficial 1.58b quantization, I began to wonder if I could squeeze a vector down to 1 bit. And.. I can! (with some caveats in the discussion)

It was when I realized that XNOR and population count could basically score 32 dimensions at a time.

While this isn't ANYTHING like an actual quantized LLM, I thought it was a really nice proof-of-concept, and could be very useful for smaller machines running RAG applications.

My Code: https://github.com/bigattichouse/bitvector_research

My Write Up: https://bigattichouse.medium.com/dreamcoat-cosine-similarity...

NOTE: I'm not saying 30X faster than GPUs, but CPU implementations could be 30X faster. Good enough for little machines like Arduino at least.

I believe Bart Kosko, in his book on Fuzzy logic, said to expect the division of use of FL techniques to break down on cultural lines - that western thought would resist using it when "more granular binary logic" and cpu speed would prevail.

Ownership. This is literally why the employees should own the company, or at least get significant ownership in terms of stock.

In every one of these cases, especially the AWS waste case, an employee with ownership in the company could see a direct monetary benefit from fixing the problem, especially at a small company.

Hackernews hug of death.

Only farmers?

Been thinking about using webassembly to compile something like this, then you build the callouts to do the actual rendering... could potentially be even smaller. Compile TinyVG > Wasm > Wasm to bytecode.

Edit the make file and add

-Wno-unused-result

to each of the final compile steps

if you want to compile and run under Ubuntu 22.04.2 LTS

I've been waiting for this so long.

I think.

"Asks"

I failed to make a sodium ion battery, but succeeded in making a pretty nice Iron Alkaline battery!

Decided to spend the day last Saturday and create a PCB from scratch with a copper sheet, some paint, and my laser cutter. Worked really well.

I've never made a PCB before, so I was pretty happy with the results, and learned a lot.

If you take the "4x4 ordered dithering" image, and copy it, use a "mean curvature blur" filter (I used gimp - similarly for gaussian with low enough width) and overlay it on the dither at 50% opacity, the image actually looks pretty good. This could probably be done in CSS/JS on a client machine. a 14k image comes across passably, even on my desktop.

(OP here) - the backplane is already a resistor, we're plating aluminum differentially along the resistive backplane to alter resistance depending on current flow. The resistor is X Ohms/cm.. when we plate out Aluminum near the negative terminal, that shorts a section of the resistor, lowering resistance there (making a "shorter" resistor). The aluminum is forced back and forth depending on current flow.

(OP/Author here) In a way it is, but there's a resistor in a U shape between the two plates (so the open side of the U is our connection points, and there's a voltage gradient due to the resistor, which causes a charge/pH gradient in the electrolyte, which causes differential plating/stripping of Al on the resistor - altering the "connection point" as you run a charge through it.