antimatter15

No

I remember looking trying to build something like this 6 years ago[0]. There are some interesting APIs for injecting click/keystroke events directly into Cocoa, and other APIs for reading framebuffers for apps that aren't in the foreground.

In particular there was some prior art that I found for doing it from the OpenQwaQ project, which was a GPLv2 3D virtual world project in Squeak/Smalltalk started by Alan Kay[1] back in 2011.

If I recall correctly, it worked well for native apps, but didn't work well for Chromium/Electron apps because they would use an API for grabbing the global mouse position rather than reading coordinates from events.

[0]: https://github.com/antimatter15/microtask/blob/master/cocoa/... [1]: https://github.com/OpenFora/openqwaq/blob/189d6b0da1fb136118...

This reminds me of the original patents that Magic Leap had, which involved pumping light through a single optical fiber that was wiggled by piezoelectrics into a spiral to project light (https://kguttag.com/2018/01/06/magic-leap-fiber-scanning-dis...).

Another fun calculation is that due to special relativity, a hard drive that is spinning gains a certain amount of mass due to the rotational kinetic energy and E=mc^2.

Assuming the platter is 100g, 42mm, spinning at 7200RPM, there is about 25J of rotational kinetic energy, whose mass equivalent is 2.8x10^-13g (0.28 femtograms).

Assuming 200 electrons per NAND floating gate with 3bits/cell TLC on a 2TB SSD, there would be 5.3x10^14 electrons, weighing about 0.5 femtograms.

The `ccusage` npm package pulls prices and other information from LiteLLM which has a lot of diferent models: https://raw.githubusercontent.com/BerriAI/litellm/main/model...

Note that this doesn't represent a general break of RSA-2048, and doesn't affect the security of RSA-2048 as it's used anywhere.

The paper only applies to "special integers" where the prime factors are known to only differ by two bits.

It's hardly even illicit- at least in the United States, the output of an AI isn't copyrightable.

Looking at the source code with web inspector it seems to be powered by 3D gaussian splatting and BabylonJS (https://doc.babylonjs.com/features/featuresDeepDive/mesh/gau...).

Maybe look into implicit in-order forests (https://thume.ca/2021/03/14/iforests/)

Figure 3 on p.40 of the paper seems to show that their LLM based model does not statistically significantly outperform a 3 layer neural network using 59 variables from 1989.

  This figure compares the prediction performance of GPT and quantitative models based on machine learning. Stepwise Logistic follows Ou and Penman (1989)’s structure with their 59 financial predictors. ANN is a three-layer artificial neural network model using the same set of variables as in Ou and Penman (1989). GPT (with CoT) provides the model with financial statement information and detailed chain-of-thought prompts. We report average accuracy (the percentage of correct predictions out of total predictions) for each method (left) and F1 score (right). We obtain bootstrapped standard errors by randomly sampling 1,000 observations 1,000 times and include 95% confidence intervals.

For dimly-lit environments, the human eye's peak sensitivity for scoptopic vision is around 498nm (https://en.wikipedia.org/wiki/Scotopic_vision) which is blueish-green.

It looks like Llama 2 7B took 184,320 A100-80GB GPU-hours to train[1]. This one says it used a 96×H100 GPU cluster for 2 weeks, for 32,256 hours. That's 17.5% of the number of hours, but H100s are faster than A100s [2] and FP16/bfloat16 performance is ~3x better.

If they had tried to replicate Llama 2 identically with their hardware setup, it'd cost a little bit less than twice their MoE model.

[1] https://github.com/meta-llama/llama/blob/main/MODEL_CARD.md#...

[2] https://blog.ori.co/choosing-between-nvidia-h100-vs-a100-per...

They cite straight through estimators in the previous work with many of the same authors on (actual binary) BitNet

Looks like it is possible to download it locally, but as far as I can tell you have to manually copy all the various files from the Artifacts folder individually

The code generation tool better be called "Tcl me NeMo"

Author here- I'm sorry about the camera controls! Happy to accept pull requests that replace it with something more sensible

The original idea was to be able to navigate around with just arrow keys (conceptually by turning yourself around in place and being able to walk back and forward).

Seems interesting that there appears to have been a patent application for LK-99 (https://patents.google.com/patent/KR20230030188A/en?oq=WO202...) filed two years ago in August 2021 (a year earlier than the article suggests).

If true, it seems wild to sit on this kind of discovery for over two years.

Update: Seems like there might be even more history given the name LK-99 apparently comes from the names of its discoverers Dr. Lee and Dr. Kim, and the year of its discovery, 1999 (https://kr.linkedin.com/in/ji-hoon-kim-03508b80).

I've recently been enjoying OrbStack (https://orbstack.dev/), which I've found easier to get started with than Lima, starts up faster, and automatically mounts volumes so you can access things from Finder

It's unfortunately not fully open source

Just from playing around with it, the fine tuned model (stabilityai/stablelm-tuned-alpha-7b) doesn't seem to work very well either.

     User: What is 12 + 12?
     StableLM: Yes, that is correct! 12 + 12 is equal to 18.

     User: Write me a python program that calculates the nth fibonacci number
     StableLM: Here is a python program that calculates the nth fibonacci number
          def nth_fibonacci(n):
              # base case
              if n==0:
                  return 0
              else:
                  return 1 + n - 1

Looks like Nolano.org's "cformers" includes a fork of llama.cpp/ggml by HCBlackFox that supports the GPT-NeoX architecture that powers EleutherAI's Pythia family of open LLMs (which also powers Databrick's new Dolly 2.0), as well as StabilityAI's new StableLM.

I quantized the weights to 4-bit and uploaded it to HuggingFace: https://huggingface.co/cakewalk/ggml-q4_0-stablelm-tuned-alp...

Here are instructions for running a little CLI interface on the 7B instruction tuned variant with llama.cpp-style quantized CPU inference.

    pip install transformers wget
    git clone https://github.com/antimatter15/cformers.git
    cd cformers/cformers/cpp && make && cd ..
    python chat.py -m stability

That said, I'm getting pretty poor performance out of the instruction tuned variant of this model. Even without quantization and just running their official Quickstart, it doesn't give a particularly coherent answer to "What is 2 + 2"

    This is a basic arithmetic operation that is 2 times the result of 2 plus the result of one plus the result of 2. In other words, 2 + 2 is equal to 2 + (2 x 2) + 1 + (2 x 1).

Note that as a result of some llama drama associated with this change, @jart (author of this post) and @anzz1 are apparently no longer welcome as collaborators on llama.cpp: https://github.com/ggerganov/llama.cpp/pull/711#issuecomment...

Looking at their charts it seems like their 6.7B model is considerably worse than GPT-J which is an existing open 6B model from several years ago.

I wish rather than stopping training early they would have run more data through a small model so we could have something more competitive with LLaMA 7B.

From my experimentation I suspect there's some subtle bug in llama.cpp that especially degrades code related prompts- even without quantizing

There's a script in the alpaca-lora repo for converting the weights back into a PyTorch dump- and my changes have since been merged https://github.com/tloen/alpaca-lora/pull/19

It reworks the interactive mode into a chat interface, which -if my code was cleaner- could have just been a pull request.

From my experimentation it seems like there's some significant loss in accuracy running the tuned LoRa models through llama.cpp (due to bugs/differences in inference or tokenization), even aside from losses due to quantization.

It inherits from ARM NEON optimizations in llama.cpp but I believe it should also work on x86.

There are already open source LLMs with comparable parameter counts (Facebook's OPT-175B, BLOOM), but you'll need ~10x A100 GPUs to run them (which would cost ~$100K+).

I suspect a big part of why stable diffusion managed to consume so much mindshare is that it can run on ordinary consumer hardware. On that point, I would be excited about an open-source RETRO (https://arxiv.org/pdf/2112.04426.pdf) model with comparable performance to GPT-3 that could run on consumer hardware with an NVMe SSD.

I wonder if it'd be possible to build a more compact and power efficient version of this using electrostatics on a flexible PCB

For those interested in trying this out without dusting off their DOS machine, there's an online Javascript emulator here: https://www.pcjs.org/software/pcx86/app/other/visicalc/1981/