jxl.js
TinyLlama
jxl.js | TinyLlama | |
---|---|---|
25 | 14 | |
296 | 6,818 | |
- | - | |
0.0 | 8.7 | |
about 1 year ago | 18 days ago | |
JavaScript | Python | |
Apache License 2.0 | Apache License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
jxl.js
-
JPEG XL and the Pareto Front
> It's so frustrating how the chromium team is ending up as a gatekeeper of the Internet by pick and choosing what gets developed or not.
https://github.com/niutech/jxl.js is based on Chromium tech (Squoosh from GoogleChromeLabs) and provides an opportunity to use JXL with no practical way for Chromium folks to intervene.
Even if that's a suboptimal solution, JXL's benefits supposedly should outweight the cost of integrating that, and yet I haven't seen actual JXL users running to that in droves.
So JXL might not be a good support for your theory: where people could do they still don't. Maybe the format isn't actually that important, it's just a popular meme to rehash.
-
Still no love for JPEG XL: Browser maker love-in snubs next-gen image format
https://github.com/niutech/jxl.js a javascript polyfill taken from the main page https://jpegxl.info/
There are other decoders [0] written in a "safe language" (rust) listed as well. So no there are many "safe" implementations
[0] https://github.com/tirr-c/jxl-oxide
- CVE-2023-4863: Heap buffer overflow in WebP (Chrome)
-
Apple Safari 17 beta release notes: JPEG XL support added
> If you care about JXL, and only want to support JXL, and you put a JXL in your picture tag, then the browser still won't render it, even if you use a picture tag.
Is this true if you provide a polyfill? Have you tried it and it failed? (Serious question.)
https://github.com/niutech/jxl.js
-
FSF Slams Google over Dropping JPEG-XL in Chrome
All of the people here who are so passionate about JPEG-XL will be happy to learn that there's nothing preventing them from using it on their sites right now:
https://github.com/niutech/jxl.js
If you want Chrome to ship with JPEG-XL support, use it. At some point, browser makers will decide it's worth the cost to them and all users to add it.
-
Nvenc vs. QSV: Who Has the Best Hardware AV1 Encoder?
> Please be aware that some images may not load on this page unless your browser supports JPEG-XL
The site could provide a WebAssembly decoder to make the JPEG-XL images work for everyone.
For example, here's a WebAssembly decoder: https://github.com/niutech/jxl.js
Demo: https://niutech.github.io/jxl.js/
-
Question: Is there a list anywhere of which browsers support JPG-XL by default?
at this point, I'd consider just using a polyfill library to decode jpegxl data client-side, like JXL https://github.com/niutech/jxl.js
-
Efficient and performance-portable vector software
:) There are some wasm vs native benchmarks in the context of JPEG XL (for example https://github.com/niutech/jxl.js#benchmark)
-
Adding JPEG XL & QOI Support to my Website OS
For adding JPEG XL support I went with jxl.js which I modified for my use case. After looking through the main file, which is also called jxl.js, I decided I only needed 2 relevant code blocks. The one to decode the image and the one to turn the ImageData into something I could display in my existing codebase (which I already partially had implemented for another use case).
-
JXL.js decoder now features multithreading and SIMD
It's easy - you'll get ReferenceError: SharedArrayBuffer is not defined when the COOP and COEP headers are not set. Multithreading is enabled by default if you use the scripts from multithread folder. If only SIMD is supported, it is being used. Oh, and progressive decoding is also enabled by default.
TinyLlama
-
What are LLMs? An intro into AI, models, tokens, parameters, weights, quantization and more
Small models: Less than ~1B parameters. TinyLlama and tinydolphin are examples of small models.
- FLaNK Stack Weekly 22 January 2024
-
TinyLlama: An Open-Source Small Language Model
GitHub repo with links to the checkpoints: https://github.com/jzhang38/TinyLlama
-
NLP Research in the Era of LLMs
> While LLM projects typically require an exorbitant amount of resources, it is important to remind ourselves that research does not need to assemble full-fledged massively expensive systems in order to have impact.
Check out TinyLlama; https://github.com/jzhang38/TinyLlama
Four research students from Singapore University of Technology and Design are pretraining a 1.1B Llama model on 3 trillion token using a handful of A100's.
They're also providing the source code, training data, and fine-tuned checkpoints for anyone to run.
-
TinyLlama - Any news?
The first one was that the minimum learning rate was mistakenly set to the same value as the maximum learning rate in cosine decay, so the learning rate wasn't decreasing. This was discovered relatively early during training and discussed in this issue: https://github.com/jzhang38/TinyLlama/issues/27
-
Llamafile lets you distribute and run LLMs with a single file
Which is a smaller model, that gives good output and that works best with this. I am looking to run this on lower end systems.
I wonder if someone has already tried https://github.com/jzhang38/TinyLlama, could save me some time :)
- FLaNK Stack Weekly for 20 Nov 2023
- New 1.5T token checkpoint of TinyLLaMa got released!
-
What Every Developer Should Know About GPU Computing
I thought I'd share something with my experience with HPC that applies to many areas, especially in the rise of GPUs.
The main bottleneck isn't compute, it is memory. If you go to talks you're gonna see lots of figures like this one[0] (typically also showing disk speeds, which are crazy small).
Compute is increasing so fast that at this point we finish our operations long faster than it takes to save those simulations or even create the visualizations and put on disk. There's a lot of research going into this, with a lot of things like in situ computing (asynchronous operations, often pushing to a different machine, but needing many things like flash buffers. See ADIOS[1] as an example software).
What I'm getting at here is that we're at a point where we have to think about that IO bottleneck, even for non-high performance systems. I work in ML now, which we typically think of as compute bound, but being in the generative space there are still many things where the IO bottlenecks. This can be loading batches into memory, writing results to disk, or communication between distributed processes. It's one beg reason we typically want to maximize memory usage (large batches).
There's a lot of low hanging fruit in these areas that aren't going to be generally publishable works but are going to have lots of high impact. Just look at things like LLaMA CPP[2], where in the process they've really decreased the compute time and memory load. There's also projects like TinyLLaMa[3] who are exploring training a 1B model and doing so on limited compute, and are getting pretty good results. But I'll tell you from personal experience, small models and limited compute experience doesn't make for good papers (my most cited work did this and has never been published, gotten many rejections for not competing with models 100x it's size, but is also quite popular in the general scientific community who work with limited compute). Wfiw, companies that are working on applications do value these things, but it is also noise in the community that's hard to parse. Idk how we can do better as a community to not get trapped in these hype cycles, because real engineering has a lot of these aspects too, and they should be (but aren't) really good areas for academics to be working in. Scale isn't everything in research, and there's a lot of different problems out there that are extremely important but many are blind to.
And one final comment, there's lots of code that is used over and over that are not remotely optimized and can be >100x faster. Just gotta slow down and write good code. The move fast and break things method is great for getting moving but the debt compounds. It's just debt is less visible, but there's so much money being wasted from writing bad code (and LLMs are only going to amplify this. They were trained on bad code after all)
[0] https://drivenets.com/wp-content/uploads/2023/05/blog-networ...
[1] https://github.com/ornladios/ADIOS2
[2] https://github.com/ggerganov/llama.cpp
[3] https://github.com/jzhang38/TinyLlama
-
Mistral 7B Paper on ArXiv
As discussed in the original GPT3 paper (https://twitter.com/gneubig/status/1286731711150280705?s=20)
TinyLlama is trying to do that for 1.1B: https://github.com/jzhang38/TinyLlama
As long as we are not at the capacity limit, we will have a few of these 7B beats 13B (or 7B beats 70B) moments.
What are some alternatives?
jxl-wasm - WebAssembly-compiled JPEG XL command line tool for Node.js
langchain - 🦜🔗 Build context-aware reasoning applications
ImageMagick - 🧙♂️ ImageMagick 7
text-generation-webui - A Gradio web UI for Large Language Models. Supports transformers, GPTQ, AWQ, EXL2, llama.cpp (GGUF), Llama models.
jpeg-xl - jpeg-xl for the Windows build of ImageMagick
public - A collection of my cources, lectures, articles and presentations
squoosh - Make images smaller using best-in-class codecs, right in the browser.
llamafile - Distribute and run LLMs with a single file.
libiamf - Reference Software for IAMF
ADIOS2 - Next generation of ADIOS developed in the Exascale Computing Program
node-unblocker - Web proxy for evading internet censorship, and general-purpose Node.js library for proxying and rewriting remote webpages
airoboros - Customizable implementation of the self-instruct paper.