Deniz Parmaksız

[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

Today's reading is Memory Layers in Large Language Models 🧠 This research shows how memory layers can take LLM performance to the next level: 🔑 Trainable key-value lookup mechanism: Adds parameters without increasing computational cost, boosting factual accuracy and task performance. 📈 Big results, small cost: Outperforms models with much larger computational budgets and even beats mixture-of-experts models! ⚙️ Scales seamlessly with up to 128 billion memory parameters The authors from Meta highlights how memory layers are a game-changing addition to future AI architectures, offering smarter, faster, and more accurate solutions. You may want to check out the paper at: https://lnkd.in/gzuqUfYe #AI #LLM #MemoryLayers #Innovation #MachineLearning #FactualAI #FutureOfAI #Meta

19

Can LLM preference tuning degrade Multi-Agent system performance? In a recent tweet, Andrej Karpathy questioned why all LLMs sound similar, prompting Sebastian Rascha to speculate about the uniformity of alignment datasets. Aligning user preferences is a last-mile step in training large language models. Regardless of the pre-training datasets used, could the preference datasets used during alignment compromise the effectiveness of LLMs? This issue could adversely affect multi-agent systems incorporating multiple LLMs in their design.

7

1 Comment

Last month, DeepMind released FACTS Grounding - a benchmark for evaluating Factuality and Quality of LLM outputs...and they avoided most of the common benchmark pitfalls that I check for! (https://lnkd.in/eT88wNHj) - ✅ *Reproducibility*: Official evaluation code is available (https://lnkd.in/exp3kP2c) - ✅ *Test Data Leakage*: About half of the evaluation examples are private - they can not accidentally be scraped or included in an instruction tuning dataset (unlike GSM8K - https://lnkd.in/ec_a87ZJ) - ✅ *Construct Validity*: The benchmark design involves a step to check if the output is "eligible" (i.e. that it contains the relevant information) - this discredits the responses that are "factual" but contain no useful information. The developers, also, did not include examples that involved creativity, mathematics, or complex reasoning to target factuality exclusively. - ✅ *Saturation*: Over time SotA Models hit a ceiling on performance, and no longer represent a useful proxy for performance. The top models currently score in the low 80s on this benchmark, which shows that there is still room for improvement. - ✅ *Process and Limitation Documentation*: The benchmark developers clearly document the process for assembling the benchmark and explain how they handled limitations. For example: Evaluation is done using LLM-as-a-Judge, and "judges" are known to favor outputs from the same model. The evaluation uses an ensemble of 3 different models to reduce this bias. - 🚫 *Variance*: Each input prompt is only run once for every model. Given that LLMs produce different outputs over multiple runs of the same input, I would have liked to see that element incorporated in evaluation. However, given that LLM-as-a-Judge methods are used during grading, the one-run outputs may be fairly reliable. I am still finalizing my checklist of common benchmark pitfalls, so stay tuned.

19

OpenCoder doesn't get enough love They open-sourced the entire pipeline to create QwenCoder-level code models. This includes: - Large datasets - High-quality models - Eval framework Tons of great lessons and observations in the paper 📝 Paper: arxiv.org/abs/2411.04905 #special #linkedin #Family #Pakistan #skills #islam #government #AI #ML #MachineLearning #tesla #microsoft #openai

5

The Nature of Large Language Models (#LLM): Discovery or Invention? Not just a Socratic debate, or philosophical discussion. If LLMs are an invention, then we really should know more about how they work, right? If Discovery, then what else do we need to uncover that is right here in front of our eyes? Arguments for Discovery: * LLMs leverage fundamental patterns and structures inherent in human language and knowledge, which we are uncovering rather than creating from scratch. * The emergent capabilities of LLMs were not fully anticipated or designed, but rather discovered through experimentation. There is an entire discipline needed to communicate with LLMs called #PromptEngineering Arguments for Invention: * The specific architectures, training methods, and implementations of LLMs are human-designed , human considered, and prone to human errors. * LLMs required significant engineering effort and novel technical approaches to create; yes, they are created. Newton and Leibniz both developed calculus independently in the late 17th century. Was Calculus discovered (as a fundamental mathematical truth) or invented (as a novel mathematical system). A fun diversion to consider this one, no? Understanding the answer will help us to chart the path forward. However, there may not be an answer, we need to consider that as well. Are LLMs on the path to #AGI ? Suggesting some reasons here, I will be 'out over my skis', and I am a good skier... That said, * LLMs demonstrate strong zero-shot and few-shot learning abilities, indicating a capacity for generalization that's crucial for AGI. * LLMs sometimes display unexpected capabilities not explicitly trained for, hinting at the potential for further emergent intelligence. I am only scratching the surface, barely - I do think about such things, call me strange, bored, or innovative, not sure which... For me, #GenerativeAI still required Human-in-the-Loop and we are still really early and only at the beginning. We all have a lot to learn. For me, I am going to enjoy the ride! #Innovation #AI

1

9 Comments

This is really awesome. I used notebookLM to summarise a recent paper that shows how o1 like model can be reproduced. After providing the pdf from Arxiv, I noticed that the generated podcast was almost 49 minutes long. Very different from the earlier 10-12 minute version. And another impressive feature was the interactive mode where you can interject the two hosts and ask a question which they very graciously respond to. I wanted to share the audio summary but YT didn’t allow me to upload the WAV file. YT expects a video mp4 file. So I found free videos from Pexels and stitched them together with ffmpeg. The videos are meditative acquarium shots of fish swimming around. And with the audio discussing reproducing o1 as an engaging podcast episode, the video keeps the distraction to the minimum. The paper itself is a great read but if you have a 30-40 minute commute, or want to watch some cool fish swimming around and learn about o1, check out

12

🎯 "The Hidden Cost of Getting Personalization Wrong: Why 67% of Recommendation Engines Are Actually Pushing Customers Away" Ever wondered why Netflix's "Because you watched..." sometimes feels like it's reading your mind, while other platforms just... don't? 🤔 Let me share some hard truths about personalization that nobody talks about: • 🔍 The "Cold Start" Paradox - Most recommendation engines fail in their first 3 months - They push generic recommendations trying to gather data - Result: 40% of users disengage before the engine becomes "smart" • 🎯 The Three Pillars of Modern Recommendation Success: - Explicit preferences (what users tell us) - Implicit behavior (what users actually do) - Contextual awareness (when and where they do it) • ⚠️ Common Pitfalls I've Seen: - Over-personalization leading to echo chambers - Not accounting for temporal relevance - Ignoring negative signals (they're as valuable as positive ones!) 🚀 Pro Tip: Start with hybrid recommendation models. Combine collaborative filtering with content-based approaches. It's like having both a personal shopper AND a trend analyst working for your users. Here's what worked for my team: 1. Begin with 20% personalization, 80% exploration 2. Flip the ratio gradually over 6 weeks 3. Always keep 15% for discovery The result? 3.2x increase in user engagement and a 47% reduction in bounce rates. Remember: The best personalization doesn't feel like personalization at all - it feels like magic. ✨ What's your experience with recommendation engines? Have you found the sweet spot between personalization and discovery? #ProductManagement #AIRecommendationSystems #PersonalizationStrategy

3

After Apple’s research saying LLMs can’t think, it’s funny that now all I’m seeing is research on teaching them to think – something most humans still struggle with. Papers: Looking Inward: Language Models Can Learn About Themselves by Introspection https://lnkd.in/gf6rgnUP On The Planning Abilities of OpenAI's o1 Models: Feasibility, Optimality, and Generalisability https://lnkd.in/gNsPtDbi Thinking LLMs: General Instruction Following with Thought Generation https://lnkd.in/guQtRnsD #AIResearch #MachineLearning #ArticificalIntelligence

24

About 2 months ago Li Yin didn't hold back in critiquing LLM application frameworks. Fast forward to 7/3/24, and her team has just released the alpha version of LiteRAG, with beta on the horizon(7/9/24). First Impressions? It's a nice balance between how I use instructor and DSPy. Instead of Pydantic, it uses the dataclasses, which is a standard library construct. The library also introduces DataClass as a wrapper to simplify generating schemas, adding examples, and loading JSON AND YAML. If you're familiar with Pytorch, or DSPy, then you'll feel at home composing your Components, which is a core abstraction. My favorite component as of now, Sequential, allows you to chain together your components input -> output. Definitely looking forward to seeing how this library grows! But, you don't need me to give you your opinion, Go check it out and make your own. LightRAG -> https://lnkd.in/g4cWDP88 If you want to see how I applied it to a current project, check out the video! Happy MonYay yall!

81

6 Comments

LLM as a solver Software involving Combinatorial optimization techniques is ubiquitous. How does LLM fare compare to a brute force method? We prompt the LLM with, 1. A distance matrix, the distance between the cities 2. Starting node/city. And expect the shortest path between the cities starting from the given start city and the distance covered. https://lnkd.in/enMkT92W 1. Create a python dataclass to describe the input and out of a TSP problem. 2. Write a prompt template to describe the input, output and few-shot examples. 3. A quick brute force TSP problem generator for n-shot examples. 4. Prompt the LLM for answer.

17

4 Comments

The hype has shifted from LLMs to Agents. The first ideas emerged right after the recent "AI-resurrection" (read: ChatGPT release 2 years back) and now it has become a buzzword on all levels. Don't get me wrong, I am an "Agent-optimist". Both consumers and businesses want to move on from "request-based assistance" ("summarize me this article") to autonomous minions helping us with everyday tasks without explicit orders given. We have already seen these attempts of introducing Agents to our email services and allowing them to take over the computer control. The explosive burst of such tools will happen in 2025, though – just scan the billboards of AI conferences' participants and ask your favorite LLM to extract the most commonly used term. What is less obvious is that Agents will eventually follow the LLM's path – huge models are great for consumers and everyday support. Still, enterprise businesses require distilled dedicated fine-tuned versions tailored to specific tasks. Think of Agents as not of a single almighty deity but more like a team of skilled professionals working on assigned projects (and later starting their own ones). Each of these "distilled Agents" will have their core competency, communicate with each other, and enrich the world picture for the whole group. The skills will not be fully isolated, though each has an area of strength. In the same way as it is now a reality in effective software development teams: an engineer or PM can draw a mock-up and it is warmly welcomed, then the final prototype work is better left to the designer. There are opportunities and challenges. Companies (or single project owners) will be able to "hire" a specific Agent from the marketplace to "join the existing A-Team". The biggest technical riddle is about having an efficient and universal protocol for Agents of various origins to effectively communicate with each other. And not drink too much coffee in the kitchen between tasks. #ai #ml #future #futureofai #aiagents

8

4 Comments

User embeddings are crucial for the downstream personalized models, but larger embedding models come with higher latency, making real-time inference challenging. This often forces a trade-off: Small embedding model for real-time updates. Or, large embedding model with offline batch updates. Meta's recent paper proposes a hybrid approach: combine stale embeddings from a feature store with real-time embeddings from a complicated user model (with a timeout). If real-time calculations exceed the timeout, use stale embeddings; otherwise, use both. Completed real-time embeddings are then flushed to the feature store, improving future requests. Paper link:

28

SimpleQA: Measuring Hallucinations in LLMs Yesterday, OpenAI released a new benchmark for evaluating model hallucinations. (Surprisingly, it’s open-source from OpenAI!) Rather than dig into the benchmark specifics, I’ll focus on some interesting takeaways and observations. I liked that hallucinations are measured through the concept of model calibration. Calibration is the process of evaluating and adjusting a model so that its confidence in its answers aligns with actual accuracy. For instance, if a model claims 75% confidence in an answer, ideally, the accuracy of its responses should also be 75% in such cases. This lets us assess whether a model “knows what it knows” — essentially, how well it evaluates its own knowledge and confidence level. Upon analyzing calibration, it’s apparent that the more confident a model is in an answer, the more accurate the answer actually is. But here’s the bad news: models (so far, all of them) consistently overestimate their confidence. So, while confidence gives a rough estimate of accuracy, it isn’t entirely reliable. In short, use it carefully. Another finding: larger models hallucinate less. GPT-4o scores higher than GPT-4o-mini, just as o1-preview outperforms o1-mini. This was somewhat surprising to me. Takeaway: one way to reduce hallucinations is to make models even larger. One calibration measurement method is to ask the model the same question 100 times. From there, you can measure the frequency of a specific answer relative to its correctness (accuracy). It turns out that the more frequent an answer is, the more likely it is to be accurate. In other words, the most common answer is the most correct. Takeaway: we get a wide range of responses when a model’s accuracy for a given question is low. This aligns with what we might intuitively expect. Another interesting point is that the benchmark uses three types of evaluation: correct, incorrect, and not attempted. The first two are clear, but the last one refers to cases where the model responds with something like, “I don’t know the answer to this question.” Here’s the intriguing part: the o1 family uses this response type more often than the GPT-4o family. The authors speculate this is due to o1’s built-in reasoning process, though this remains just a hypothesis for now. https://lnkd.in/eFsz3-6P

13

2 Comments

Determinism is practically impossible in largest, shiniest of LLMs (GPT, Claude...), even given the traditional advice of "set the temperature to 0". This isn't a secret (its in both Anthropic's and OpenAI's API documentation) or new now...but I still think its worth emphasizing because sometimes we really want reproducibility. In high-risk contexts, we don't want the AI just "changing its mind", especially if its used in contexts like reviewing insurance claims resume review or evaluating students. (Funny-but-concerning: https://lnkd.in/eVP6uC_r). Or, even, when developers are trying to debug sometime - handling random, intermittent is not fun. The only solution is to use smaller models that do not exhibit random behavior, but we need more clear and transparent education about that. Btw, the companies don't publicize the reasons behind this, but I found this theory interesting: https://lnkd.in/exPYERDw (that is where the screenshot is from).

35

18 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.

36

GeLu(Gaussian Error Linear Unit) You’ve all heard about the new darling of LLMs, right? Well, I’m talking about GELU! 🌟 Short for Gaussian Error Linear Unit, GELU has become the go-to activation function for cutting-edge neural networks, including the ones powering your favorite large language models. Let’s break it down: At its core, GELU is an activation function, a key component in neural networks that helps them learn complex patterns. Unlike older options like ReLU (which harshly cuts off negative values), GELU takes a softer, smarter approach. GELU is based on the Gaussian cumulative distribution function (CDF), which adds a dash of probability to the mix. Instead of simply deciding "pass" or "block" for inputs, it smoothly weights them based on their likelihood. Why Everyone Loves GELU 💡 1️⃣ Smooth Gradients: Forget abrupt jumps! GELU’s smooth transitions make training more stable and effective. 2️⃣ Non-Monotonic Behavior: Unlike ReLU, GELU isn’t strictly increasing, enabling it to capture more nuanced patterns. 3️⃣ Vanishing Gradient Solution: No dead neurons here—GELU ensures gradients stay informative throughout training. GELU vs. ReLU ⚔️ ReLU is simple but sharp, cutting off negatives entirely. GELU is softer and smarter, leveraging probabilistic behavior for richer outputs. GELU shines in transformer architectures (think GPT, BERT), where precision and adaptability are key. Sure, it’s a bit more computationally intensive, but the results? Totally worth it. 🚀 So, next time someone mentions "what powers the best LLMs," you’ll know the answer—GELU: the smooth operator of neural networks. 💡 #GELU #AI #MachineLearning #DeepLearning #NeuralNetworks #LLMs #ActivationFunctions #GaussianErrorLinearUnit #AIInnovation #TransformerModels #AIAlgorithms #ComputerVision #AIPerformance #SmoothGradients #AIExplained

1