yacine_

that's why i'm writing my own cad software, dingcad at dingcad.com

it will be free and open source

unfortunately that one requires considerably more care

yes

yeah its a pretty bad job. i never held a gun in real life and they kind of scare me tbh

I do! And we're hiring! x.com/jobs

lmao you really think this took me more than 15 minutes to do?

i've been using sokol.h and it just works :)

it's monkey-ohio-wrath

good luck hopefully you use it before anyone else does

Am I crazy? is it really that hard? I built a web design product that rivals figma in a web browser in like a month, and bootstrapped the whole thing lmao

I'd imagine you feel quite upset that you are paying to be silently toyed with by a software company :P I definitely do

Infuriating and is only accelerating my basement cluster

It's not. They pushed another "update" this monday that fixed the problem. Of course, we'll never know, because openAI isn't only closed weights, architecture, and research, but it's also closed as in there is no transparency at all.

YOU ARE ON THE WRONG WEBSITE!!!

Looks like you need to be o(europe) sized to bully big tech companies

sign me up lmao

Here's an example: https://paperswithcode.com/task/coreference-resolution

Bloated does not mean bad. It means bloated. Which, for my purposes, makes it not the best choice.

yes, unfortunately :(

did you know that the weight adapter happens on demand, on inference, in the LoRA forward pass function?

leaky, leaky, leaky

GGML will save us, surely

If you fine tune them to be task specific, they'll perform well. In my experience, this control loop is a better investment than "prompt engineering". (When I say task specific, I mean very task specific)

GPT4 over the API is too fine tuned, which constrains its behavior. It fails to capture nuance in instructions. When you have the bag of weights, you can actually control your model. Having actual control over the model, and understanding the infrastructure that it's running on helps you meet actual SLAs.

And it's cheaper, if you're not backed by infinite venture money.

https://arxiv.org/abs/2307.13269

This is an ad. You'd be best served avoiding additional dependencies. At this point, you don't want to be trading off simplicity for ease. Even transformers + huggingface feels like too much bloat.

You can use this https://github.com/PygmalionAI/training-code

Or, you can use this; for QLoRA https://github.com/artidoro/qlora

The tools and mechanisms to get a model to do what you want is ever so changing, ever so quickly. Build and understand a notebook yourself, and reduce dependencies. You will need to switch them.

The right way to leverage AI is to use it to do ye olde engineering, faster. Actually, most AI use cases are in fact that! Ye olde engineering - data pipelines, automation. Stuff we've been doing since before I was born.

Everything else - transformative tech, will hit the open domain fairly quickly, is my bet. Similar to databases.

so true

incredible work dvj!

It's always nice when you pick up an old project that magically (with some grinding) works

came across this poking around the internet when looking for some math JS animations. A goldmine!

OAuth isn't an SSO system :P

I'm running 30b quant on my 3090. that many 4bits fortunately fit into my precious vram

fsreadfilesync and json

very simple, just don't read the email

More like: the accessibility is what will make it go around. The accessibility is what changes everything! Getting an easy to use interface (instructions) over python changes the accessibility from the denizens of this website to ~anyone with a computer

If you're interested, see this paper that argues that point: https://arxiv.org/abs/2302.06541

Essentially, being label efficient is more important than being compute efficient, because the biggest computing constraint we have is enough humans doing the labeling (and knowing how to work a jupyter notebook), not tensor smashing nvidia cards

I was able to run a LLaMa on my personal machine to run some labeling on my documents, as a test of its capabilities. It was instruct tune. 30b parameters

4 example labels, and I had a binary classifier in seconds. Sure, semantic text classifiers were possible for a while, but making it accessible changes everything. Giving anyone who can use a spreadsheet the power of a local LLM (or, basically free LLMs) can make them much, much more productive. A lot of office work is clicking through sheets and doing manual labeling.

It's truly wild what is becoming accessible! Really excited to see the next gen software that the open community comes up with :)

What I appreciate about karpathy's videos is that it doesn't make things any more complicated than they need to be. Simple, engineering language is used. No gatekeeping! It's reassuring, and lets everyone know that anyone can do it.

Thanks karpathy!