LLMs and GPT: Some of my favorite learning materials
gist.github.com
gist.github.com
I have a pytorch ml llm gpt-style model and it has many layers, called "attention" and "feed forward". Can you explain to somehow who is highly technical, understands software engineering, but isn't deeply familiar with ML terms or linear algebra what these layers are for?
Where I can get all the jargon for this AI/ML stuff? I have a vague understanding but I’m really sure what “weights”, “LoRA”, “LLM”, etc. are to really understand where each tool and concept fit in. Explain to a knowledgeable software engineer with limited context on ML and linear algebra.
In gpt/llm world, what's pre-training vs fine-tuning?
in huggingface transformers what's the difference bertween batch size vs microbatch size when training?
how do I free cuda memory after training using huggingface transformers?
I'm launching gradio with `demo.queue().launch()` from `main.py`. How can I allow passing command line arguments for port and share=True?
Comment each of these arguments with explanations of what they do (this is huggingface transformers)
args=transformers.TrainingArguments(
per_device_train_batch_size=micro_batch_size,
gradient_accumulation_steps=gradient_accumulation_steps,
warmup_steps=100, #
max_steps=max_steps,
num_train_epochs=epochs,
learning_rate=learning_rate,
fp16=True,
logging_steps=20,
output_dir=output_dir,
save_total_limit=3,
),
In the context of ML, can you explain with examples what "LoRA", "LLM", "weights" are in relation to machine learning, specifically gpt-style language models?It just gets to the point immediately.
No chapters of books you need to read first, where there is no clear view of how it comes together or if it ever will.
No documentation to deal with, which is notorious for never solving your specific question and just requires you to conform to that developer’s attempt at being a teacher of their own concept.
No long winded youtube video or video educational course.
Just “explain this concept” and it goes out of its way to explain answers to things you didn't even ask well.
I'm pretty sceptical of people using it to learn a foreign language or something they aren't familiar enough with.
I know prompt engineering is a lesser art, but I think some of the literature on in-context, self-consistency, self ask, CoT, etc might be useful. Here's my favorite lit review on the subject (no affiliation): https://lilianweng.github.io/posts/2023-03-15-prompt-enginee...
Would it even make sense if one's interest is not image or text generation?
It might take a PhD to build the JVM, but you don't need one to understand what it does (at least most parts of it).
Part of what's eluded public awareness so far is that these algorithms are simple.
AI accelerators are important.
I found an interesting counter perspective on the Mindscape podcast[0]:
And Ted Chiang, in that article, suggests that ChatGPT and language models generally can be thought of as a kind of blurry jpeg of the web, where they get trained to compress the web and then at inference time, when you're generating a text with these models, it's a form of lossy decompression that involves interpolation in the same way. And I think it's a very interesting test case for intuitions because I think this metaphor, this analogy, parts of it are pumping the right intuitions.
There is definitely a deep connection between machine learning and compression that has long been observed and studied. [...] I think comparing it to lossy image decompression is pumping the wrong intuitions because, again, that suggests that all it's doing is this kind of shallow interpolation that amounts to a form of approximate memorization where you have memorized some parts of the data and then you are loosely interpolating what's in between.
[...] the intuition is that there would be a way, presumably, to characterize what large language models and image generation models are doing when they generate images and texts as involving a form of interpolation but this form of interpolation would be very very different from what we might think of when we think of nearest neighbour pixel interpolation in lossy image decompression. So different, in fact, that this analogy is very unhelpful to understand what generative models are doing because, again, instead of being analogous to brute force memorization, there's something much more generally novel and generative about the process of inference in these models.