Sourabh Medapati (csgator)

These findings motivate our design of a novel framework to investigate hidden representations in LLMs with LLMs, which we call Patchscopes. The key idea behind this framework is to use LLMs to provide natural language explanations of their own internal hidden representations. Patchscopes unifies and extends a broad range of existing interpretability techniques, and it enables answering questions that were difficult or impossible before. For example, it offers insights into how an LLM's hidden representations capture nuances of meaning in the model's input, making it easier to fix certain types of reasoning errors. While we initially focus the application of Patchscopes to the natural language domain and the autoregressive Transformer model family, its potential applications are broader. For example, we are excited about its applications to detection and correction of model hallucinations, the exploration of multimodal (image and text) representations, and the investigation of how models build their predictions in more complex scenarios. Google DeepMind

8

Looks like fine tuning out performs RAG and Large context LLMs for data accuracy with longer contexts Paper: https://lnkd.in/gj9-3jsK Summary of "BABILong: Testing the Limits of LLMs with Long Context Reasoning-in-a-Haystack" - Introduction to BABILong Benchmark: - Designed to test LLMs' reasoning abilities over extremely long documents. - Comprises 20 diverse reasoning tasks, such as fact chaining, induction, deduction, counting, and handling lists/sets. - Uses natural text from the PG19 corpus, extendable to document lengths up to 1 million tokens. - Current LLM Performance: - Popular LLMs utilize only 10-20% of the context effectively. - Performance declines with increased reasoning complexity. - Retrieval-Augmented Generation (RAG) methods achieve 60% accuracy on single-fact QA, independent of context length. - Top Performing Models: - Recurrent Memory Transformers (RMT) show the best performance, processing up to 11 million tokens. - Small models like Mamba (130M) and fine-tuned RMT (137M) achieve high accuracy on long-context tasks. - Evaluation Findings: - Current benchmarks (e.g., Longbench, L-Eval) are insufficient for LLMs with capabilities beyond 40,000 tokens. - BABILong tests models' efficiency in distinguishing relevant facts from irrelevant text over long contexts. - Popular LLMs fail to maintain high performance as context length and complexity increase. - Fine-Tuning Insights: - Fine-tuning improves model performance significantly. - Mamba and RMT demonstrate successful QA with long contexts, outperforming RAG models. - RMT's memory mechanism allows efficient processing of long sequences, with marginal quality degradation up to 11 million tokens. - Benchmark Significance: - BABILong provides a rigorous evaluation framework for LLMs' long-context reasoning abilities. - Highlights the limitations of current LLMs and the need for improved context processing mechanisms. - Key Contributions: - Introduction of BABILong, a scalable generative multi-task benchmark. - Evaluation of over 20 recent LLMs on various context lengths and tasks. - Demonstration of the limitations of current models in long-context utilization. - Setting a new record for sequence size processed by a single model with RMT.

4

5 Comments

Facebook just released a very different kind of LLMs. These are focused on code optimization and compiler optimization. This is super important because it can fundamentally change the way code is executed on any machine. Here's how it works right now: Programs written in many languages like C/C++ have intermediate steps before they are run on the computer. For example they are converted into Byte Code and then converted into machine code via LLVM (Low level virtual machine). But Facebook's new model can take in the byte code as input and convert it to into a more efficient representation so that when this new code is converted into machine code, it will be faster. "In theory", it could mean that all existing code might be made faster without any change by developers. Our games can have higher frame rates on the same GPUs. Photoshop might run faster on the same laptop. Our software might complete tasks faster without any changes at all. But that will probably take quite a long time. To be honest I don't expect these models to actually be used in production since unless they were 100% as good as compilers they will probably break the code. And are they 100% good? No, not even close. But the speed at which improvements are happening, they will probably reach that level eventually. And that's when we will see models like these everywhere. 

10

My experience so far in accelerating PyTorch Performance with Rust Bindings: Expectations, Reality, and Future Work: Expectations: - Integrating Rust with PyTorch through bindings will significantly accelerate the execution of computationally heavy operations. - Rust's memory safety, zero-cost abstractions, and fine-grained control over system resources will enable highly optimized code that ca n approach or surpass C/C++ performance. - The hybrid approach of using Rust for performance-critical parts and PyTorch in Python for model definition and training will offer the best of both worlds. - Rust-PyTorch integration will greatly benefit real-world applications that demand real-time, low-latency deep learning inference. Reality: - Rust-PyTorch integration does improve performance for certain computationally intensive tasks, but the speedup may vary depending on the specific operation and model architecture. - While Rust's memory safety and fine-grained control are beneficial, the learning curve for Rust can be steep for engineers primarily experienced in Python. - Integrating Rust with PyTorch requires careful design and implementation of bindings, which can be time-consuming and complex. - The maturity of the Rust ecosystem for machine learning is still evolving, with some libraries and tools not as comprehensive as their Python counterparts. - Debugging and profiling Rust code integrated with PyTorch can be more challenging compared to pure Python implementations. Future Work: - Develop more efficient and user-friendly libraries and tools to streamline the integration process between Rust and PyTorch. - Investigate and optimize the performance of Rust-PyTorch bindings for a wider range of deep learning models and architectures. - Explore the integration of Rust with other deep learning frameworks beyond PyTorch, such as TensorFlow or MXNet. https://lnkd.in/gf-XTqfW #rustlang #pytorch #deeplearning #softwareengineering #performanceoptimization

9

I've made improvements and here is the release: here is what has been updated: Core Functionality: neural style transfer : Applies artistic styles to audio signals using neural networks. architecture specific optimizations : Optimizations for specific hardware architectures. binaural audio simulator : Simulates 3D audio experiences. binding design patterns: Design patterns for integrating Rust with other languages. binding generation tools: Tools for automating the generation of bindings. concurrency and parallelism: Utilizes concurrency and parallelism for better performance. custom operators: Defines custom operators for specialized audio tasks. deployment and packaging: Methods for efficient packaging and deployment. distributed training: Supports distributed training of AI models. Leveraging LLM Capabilities: Modules like real-time translation, smart audio editing, and enhanced user interaction utilize large language models (LLMs). Performance Benchmarking: benchmarks.py: Scripts for benchmarking the performance of audio processing tasks. Robust Testing: Extensive test suites ensure reliability and accuracy. Continuous integration is set up to automatically run tests on each code change. Improvements to be made: Comprehensive Documentation: Detailed setup instructions, configuration details, and usage guidelines are provided in the `README.md` and will be worked on in the upcoming days. Educational Resources: Additional Rust tutorials and command-line application examples are included to help developers get started and integrate the modules into their projects. #AudioProcessing #AI #MachineLearning #OpenSource #HighPerformanceComputing #Innovation

2

A recent breakthrough titled "Matrix Multiplication-Free LLMs" demonstrates a huge advancement in the area of Large Language Models (LLMs) by reducing computational costs. The authors have eliminated MatMul operations from LLMs, claiming to 10 times reduction in memory usage and a 25.6% increase in training speed, all while maintaining strong performance at billion-parameter scales. Paper link: https://lnkd.in/ggph8qXc #AI #machinelearning #deeplearning #LLMs

16

LLMs can take gigabytes of memory to store, which limits what can be run on consumer hardware. But quantization can dramatically compress models, making a wider selection of models available to developers. You can often reduce model size by 4x or more while maintaining reasonable performance. In our new short course Quantization Fundamentals taught by Hugging Face's Younes Belkada and Marc Sun, you'll: - Learn how to quantize nearly any open source model - Use int8 and bfloat16 (Brain float 16) data types to load and run LLMs using PyTorch and the Hugging Face Transformers library - Dive into the technical details of linear quantization to map 32-bit floats to 8-bit integers As models get bigger and bigger, quantization becomes more important for making models practical and accessible. Please check out the course here: https://lnkd.in/g66yNW8W

10,609

143 Comments

[research update] use a Transformer's multi-head attention activations to fetch RAG style, to augment multi faceted problem breakdown for LLMs in ."Multi-Head RAG: Solving Multi-Aspect Problems with LLMs": 1. Enhances LLMs by integrating document retrieval (RAG) into the LLM context. 2. Challenge: Existing RAG solutions struggle with queries needing multiple documents with varied contents due to distant embeddings. 3. Multi-Head RAG (MRAG): Introduces a novel approach using Transformer's multi-head attention activations to fetch diverse documents. 4. Activation Utilization: Different attention heads capture varied data aspects, improving complex query retrieval. 5. Improved Relevance: MRAG shows up to 20% improvement in relevance over standard RAG baselines. 6. Evaluation Methodology: Provides metrics, synthetic datasets, and real-world use cases to demonstrate effectiveness. 7. Seamless Integration: MRAG can be integrated with existing RAG frameworks and benchmarking tools like RAGAS. 8. Multi-Aspect Problem Solving: Designed specifically to handle multi-aspect queries more effectively. 9. Data Stores Compatibility: Compatible with various data store classes. 10. Potential Applications: Benefits scenarios requiring diverse information retrieval, enhancing LLM responses. Experiment The paper introduces MRAG and evaluates it using synthetic datasets and real-world data. It compares MRAG's performance against standard RAG models. The experiment focuses on the model's ability to retrieve relevant documents across various query aspects, demonstrating up to a 20% improvement in relevance over baselines. Use Case MRAG is tested on real-world scenarios like customer support, where queries often require information from multiple documents with diverse contents. The model's capability to retrieve and integrate multi-aspect data enhances the quality of responses.

81

5 Comments

April was an exciting month for AI at Meta! We launched MTIA v2 https://lnkd.in/gvC-UgVN, Llama3 https://lnkd.in/gdbfXa-6, presented a tutorial and paper on the PyTorch2 compiler at ASPLOS https://lnkd.in/gsT9DUr5, released PyTorch 2.3 https://lnkd.in/gYn3Vnzm and, to top it off, we launched the PyTorch ecosystem solution for mobile and edge deployments, ExecuTorch Alpha https://lnkd.in/gWv96jpm optimized for Large Language Models. What better than to combine all of these... running Llama3 on an a mobile phone exported with the PT2 Compiler's torch.export, and optimized for mobile deployment. And you can do all of this in an easy-to-use self-service format starting today, for both iPhone and Android as well as many other mobile/edge devices. The video below shows Llama3 running on an iPhone. (Makers will love how well models run on Raspberry Pi 5!) PyTorch is being developed by a multi-disciplinary team comprising ML engineers, accelerator experts, compiler developers, hardware architects, chip designers, HPC developers, mobile developers, and specialists and generalists that are comfortable across many of the layers involved in building end-to-end solutions. Even better -- if you're excited by the possibilities of AI, and solving the system design challenges of making AI run well across all hardware types, we are looking for YOU! The Pytorch team has openings across PyTorch core, compilers, accelerators and HW/SW co-design https://lnkd.in/gu2Y_KpY https://lnkd.in/gQVXBP6P and a broad range of positions that involve PyTorch from model development all the way to hardware deployments https://lnkd.in/gjDdUh5w #PyTorch #ExecuTorch #Llama3 #AICompilers #MTIA #AcceleratedAI #MetaAI #Meta

64

Our survey titled "Reasoning and Planning with Large Language Models in Code Development" is now available on the Amazon Science website: https://lnkd.in/d8a8H9yQ. This publication accompanies our lecture-style tutorial at KDD 2024 (late August in Barcelona Spain), delving into how LLMs are transforming the code development landscape. Our survey explores LLM's understanding of code patterns, syntax, and semantics to assist developers in tasks ranging from code generation and testing to documentation and interactive reasoning. #KDD2024 #LLM #CodeDevelopment #AI #MachineLearning #AmazonScience

79

3 Comments

Hello All! It is great to be back with another article in my series “Neural Networks Intuitions - 18. Generative Pretrained Transformer(GPT) Series". The past 1.5-2 years have been very much dominated by Large Language Models(LLMs) ever since the release of GPT-3.5 and GPT-4, their fantastic ability to solve wide range of natural language tasks — right from question answering, summarization, visual QA and even code generation. And anyone who has followed this recent trend would know about the talks regarding the emergence of AGI which led to two school of thoughts — one set of people who truly believe that Language Models can lead us to AGI, while the other set sharply denies this statement by arguing that although there are a few signs of reasoning, there is no true extrapolation as such and all of it comes down to the training data(and its scale). The latter group's criticism is that unless there is visibility into the training data distribution and having a test set(without contaminating the test data with train set) along with a proper evaluation methodology, it is unfair to say that these LLMs can actually lead to AGI. Now in order to truly validate some of these closed source GPT models(such as GPT-4, Gemini, Claude etc), we need to be aware of the training data distribution — which is highly unlikely. But another way to understand if LLMs or more specifically instructed tuned LLMs can actually generalize to novel distribution or not is by actually digging deep into the evolution of these architectures/algorithms — more specifically the evolution of GPT models. In this article, I will be going over a series of GPT papers - GPT-1, GPT-2, GPT-3 and InstructGPT, and try to understand what makes these models truly generalizable or universal. Do read and comment your thoughts/opinions :) https://lnkd.in/di8_VpJA #neuralnetworks #largelanguagemodels #GPT #incontextlearning #nlp

23

1 Comment

An amazing article on using  Low Rank Adaptation (LoRA) and QLoRA (Quantized Low-Rank Adaptation)  for fine-tuning LLMs. https://lnkd.in/gHu7hfAE #lora #qlora #machinelearning #llms

16

There is a lot of interest in combining Graph Models and Language Models recently. In 2022, I led an initiative at Twitter (now X) in collaboration with Vivek Kulkarni, Ahmed El-Kishky, Sneha Mehta, and executed by our wonderful summer intern Jinning Li called "NTULM: Enriching Social Media Text Representations with Non-Textual Units" on combining large scale graph content at Twitter with Tweet's text content for building better quality Tweet Embeddings. The internal version of the project required addressing quite a few challenges: 1. Finding the node embeddings for NTUs using Twitter Scale Heterogeneous Graph 2. Training BERT with the above scale node embeddings This work was a follow up to my previous collaboration led by Vivek Kulkarni in 2021 on combining social context like time and geography in language models called "LMSOC: An Approach for Socially Sensitive Pretraining". There are a lot of interesting follow ups in this area and combining Graphs with generative LLMs is something which is very effective on real world datasets. NTULM Talk: https://lnkd.in/g2zvmnhh NTULM Paper: https://lnkd.in/gQq6VCQP LMSOC: https://lnkd.in/ghamVwVk

29

1 Comment

Quentin H. and Yanwei (Wayne) Zhang on the Faire Data team recently did some great work fine-tuning Llama3 model to enhance search relevance. Here are some key insights from the work: • While prompt engineering is valuable, LLM fine-tuning is essential for a domain specific task like understanding semantic search relevance. • Fine-tuned open-source LLMs like Llama3 can deliver impressive performance, scalability, and cost-efficiency compared to using proprietary models. • Effective application of a fine-tuned LLM demands a well-defined problem, robust, high-quality labeled data, and ongoing model refinement. Ground-truth labeled data is crucial for maximizing model performance. • Fine-tuned Llama3-8b achieves performance on par with the larger Llama2–13b model. Read the blog post to dive deeper into these findings! https://lnkd.in/ecP_3E7S We are also hiring (https://lnkd.in/dHfRZcPi) #LLM #AI #Finetuning #LLAMA3 #SearchRelevance #Hiring

88

3 Comments

𝗟𝗹𝗮𝗺𝗮 𝟯 𝘂𝗻𝘃𝗲𝗶𝗹 𝗮 𝗳𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹 𝗰𝗼𝗺𝗽𝘂𝘁𝗶𝗻𝗴 𝘁𝗿𝗮𝗱𝗲𝗼𝗳𝗳 𝘁𝗵𝗮𝘁 𝗳𝗲𝘄 𝗮𝗿𝗲 𝘀𝗲𝗲𝗶𝗻𝗴⬇️ 🦙Llama 3 just came out and to the surprise of many people, the L3-8B version can match the L2-70B one on several benchmarks. Several people also argued that the chinchilla paper (https://lnkd.in/dXaRqyea) was wrong because the llama 3 scaling is very far from chinchilla-optimal. 🤔 In my opinion, this is due to a misunderstanding of what the chinchilla paper is about and more generally of the effects of scale in deep learning. The bitter lesson (https://lnkd.in/d3sVYYgp) has become common knowledge in the field thanks to the GPT family that popularized it. We hear everywhere that "bigger models are better": Yes it's true, but in what sense? Many people have a mental model along the lines of "bigger models are more capable" meaning they would be able to achieve levels of performance that smaller models can't. ❌ This is not true with LLMs and is mainly because we train only once on tokens (most of them at least) and therefore overfitting is not possible. The 𝘳𝘦𝘢𝘭 advantage of bigger models over smaller ones is that they converge *faster*. In other words, you can reach a given level of NLL (modeling performance) with fewer training iterations. ❔ Then a natural question arises: Should I train a smaller model with more or a bigger model with fewer iterations? That's where the chinchilla paper brings a response. They say that the question they are answering is: "Given a fixed FLOPs budget, how should one trade-off model size and the number of training tokens?" (implying "to achieve the best possible NLL"). 🧐 Coming back to Llama 3, it's obvious that the Llama team is aware of this work and there is a reason why they didn't follow this recipe. My guess is that they are taking into account the inference cost in the balance (which is completely out of the scope of the chinchilla paper). When one "overtrains" an 8B model, one ends up with a worse "NLL to training compute" ratio, but also with a better "NLL to inference compute" ratio. ✅ Now if we think about it from a business perspective, it's a very powerful tradeoff because you can choose to buy performance either at a fixed cost (training) or at a variable one (inference). Hope this post helped you! #Llama3 #Meta #LLM #AI

9

3 Comments

My take is that the training process performs a kind of negative sampling to filter out samples that have low information, hence improving training efficiency.

5

3 Comments

Just read Farquhar et al's Nature paper on detecting hallucinations in large language models using semantic entropy. Interesting result on quantifying uncertainty in LLMs. When you ask an LLM a question, its answers may look correct, but be made up - a confabulation. For example, the LLM may answer incorrectly that the STARD10 protein is a "negative regulator of the mTOR pathway" instead of its true role as a lipid transfer protein. When an answer is confabulated, multiple subsequent generations will have different meanings. For example, a second answer of the LLM may incorrectly say that STARD10 is a "negative regulator of the meiotic recombination process". The variability in meaning can be quantified using semantic entropy, which measures variability over multiple generated answers. Higher entropy suggests greater variability and potential confabulation. The LLM can then refuse questions with high semantic entropy. To calculate semantic entropy, you generate 5-10 answers. You then cluster the answers based on semantic meaning using bi-directional entailment. Two answers are part of the same cluster if they entail - or imply - each other (e.g. "Joe buys a red apple" implies "A red apple was bought by Joe" and vice-versa). The entailment is calculated using another, possibly less powerful LLM, so it's an interesting applications of using language models to correct other language models. After clustering, the probabilities of each cluster are calculated from the output probabilities of the LLM, and then the resulting entropy. Thresholding the entropy can classify a question as likely to produce confabulations with an AUROC of around 0.75. Link to paper below.

62

2 Comments

Hallucination is Inevitable in LLMs An important new paper out that shows that even with perfect data and an idealized architecture “LLMs will always hallucinate”. I suspect that this will over time be linked to Gödel’s Incompleteness Theorem [1] and Turing’s Halting Problem [2]. Every technology has trade-offs. We love LLMs but they need to be used in the right way. [1] Good pop science depiction in Oppenheimer (Gödel was Einstein’s walking companion) or also see Rebecca Goldstein’s book Incompleteness [2] Turing is depicted in The Imitation Game and also the progenitor of the famed Turing Test.

31