Kubuxu

Using image embedding and evaluating 100s billion parameter LLM for OCR is like hunting rabbits using Yamato’s 18in naval gun.

It keeps the side from curling in and causing the irritation/cut that results in what we call ingrown toenail.

The 8x is misleading; there are 8 sets of weights (experts) per token and per layer. If it is similar to the previous MoE Mistral models, then two experts get activated per token per layer. This reduces the amount of compute and memory bandwidth you need to perform inference but doesn't reduce the amount of memory you need as you cannot load the experts into GPU memory on demand without performance impact.

Welcome in the SDAM (Severely Deficient Autobiographical Memory) club. It is highly correlated with Aphantasia.

1. Development started in 2000, and the first airframe (albeit with non-finalized parts) rolled off in 2006. 2. The pilot can make independent decisions even in the presence of overwhelming communication jamming.

The F-35 program was developed with the principle of concurrency in mind. The first aircraft rolled off the production line before the majority of the parts were finalized. Think of it as the first build from your CI/CD pipeline.

The benefits are similar to the reasoning behind setting up CI/CD in software. They are just more significant, as production takes a while to ramp up when it comes to complex hardware.

Some components of the car can be shared, others have to be shared, but break ducts IIRC are in the third category where you have to design them yourself.

We use some radio telescopes for radar astronomy. https://en.wikipedia.org/wiki/Radar_astronomy

I think of the SD3 as a further evolution of SD1.5/2/XL and StableCascade as a branching path. It is unclear which will be better in the long term, so why not cover both directions if they have the resources to do so?

I use zsh-histdb which stores the history in SQLite with context. Then I have few different queries/ways to interact with it. For example I have a line completion (which also shows as grayed out text while I type) based on most frequently used commands with give prefix with additional weighting depending how close in the directory tree they were used.

[0]: https://github.com/larkery/zsh-histdb

AFAIK it was released to "researchers" behind submitting a survey, someone filled out the survey and put it on torrents. There was no way it wouldn't leak.

You could consider something like BLIP2. There are multiple ways you could use it: embed images and match them against embeddings of text descriptors, train custom embedding of descriptors, or a classifier on top of the embedding (linear layer on top of the image embedding network).

The approaches increase in complexity. It also allows for dataset bootstrap:

Let's say you want to classify cats by breed. You could start by embedding images and text descriptors and distance-matching the embedded descriptors to the images. This gives you a dataset that might be 90% correct; you can then clean it up, which would be easier to do than manually labelling it. Based on that improved dataset, you can train a custom embedding for the labels or a classification layer on top of the image embedding network.

AFAIK the EU AI Act primarily prevents profiling, social scoring and other high risk activities from using AI.

It generally didn’t care about generative AI.

Make sure to change omnibar settings to prefer history over search.

Which is why I have disabled that functionality. I also don’t need M$ to know every app I’m running on my PC (although they probably have that data some other way).

The 3rd paragraph missed the mark but previous ones are in the right ballpark.

You take the users question either embed it directly or augment it for embedding (you can for example use LLM to extract keywords form the question), query the vector db containing the data related to the question and then feed it all of LLM as: here is question form the user and here is some data that might be related to it.

In essence batching allows for more efficient usage of memory bandwidth. Without batching for every generation you need to transfer the whole model from GPU memory to GPU core once for every image which sets an upper bound on speed. With batching the bottlenecks start showing up elsewhere.

For SD1.5 4090 is able to do ~17it/s without batching and ~90-100it/s with batching.

Although these numbers might be old at this point, I looked at it ~3mo ago.

It is two out of eight at each layer, with 32 layers independent of each other. There are no eight "sub-models".

However, this raises a question: could a slightly more complex router use output layer n-1 to choose experts for layer n+1 (vs n and n+1 today)? This way, there is more time to load the needed experts for the n+1 layer.

Nothing prevents C&C from being fronted by cloudflare.

Very LLMs are quite a different from diffusion models. The model size vs training set size is skewed the other way.

Mozilla allows for direct update of blocker lists instead of requiring that they are included in the extension and updated with it.

With a fast NVME loading a model is only 2-3s.

ggml.cpp with blast backend could be one example of it See for instance: https://github.com/ggerganov/ggml/blob/57c468b8655f3630d1749... which are the parts not available in blast

No, it can't, as it primarily supports only domain blocking.

> you get true cross-platform support

wasi_nn is just an abstraction layers for wrappers around llama.cpp/gguf.cpp/onyx/others. It is not any more cross-platform than these libraries/apps deployed themselves, or rust apps using bindings for them.

They also weren't targeting orbit but just bellow it.

Your KV cache size is linear with context size which might put you tight on memory. There is also increased cost of recalculating KV cache of context window when the window has to move but this is close to being solved with streaming LLMs.

In most tanks fuel is used as higher density voidspace to decelerate projectiles and shrapnel.

I couldn’t agree with you more. Today when we are talk with LLM it’s like we (sorry for anthropomorphism) interact with a naked mind and we rely on pure immediate recall and it’s train of thought. I wonder whether allowing LLMs to perform inner dialogue (as it was done with the through/action pattern), to stage information for latter, and then based on that making it form response will be the next step.

It will be much more compute intensive, as each response will probably require multiple context windows and distillations.

Disable memory overclock or undervolt the memory and SoC. You will see the power drop down like crazy.