Practical Uses of Language Models

Teach your ML models to read: here’s how combining LLMs with traditional ML can boost performance. Most AI systems in fraud detection, personalization, recommendations, and decision automation have relied on structured data (i.e. numerical and categorical variables) that you can put in a spreadsheet fed into statistical models like regressions, trees, or neural networks. These models work well, but we know the pattern: after a certain scale (millions of records) and volume of training, performance plateaus. More data keeps them fresh, but rarely moves the needle. With the rise of language models, the natural question is: can we do better by combining approaches? YES - and we are already doing it. Language models convert raw text into rich, high-dimensional vectors that capture semantic meaning. These embeddings can be treated like any other feature and fed into traditional ML pipelines. Suddenly, models that once relied on sparse metadata can now ingest nuanced information from unstructured text. If there is a large amount of unstructured data, say call logs in customer service interactions, it can be preprocessed by language models from unstructured audio data into structured categorical and statistical data, for example, using customer support interactions to add a sentiment category and score into a statistical customer churn model. A practical example: In fraud detection, a model might historically rely on 10 - 20 inputs: product type, transaction amount, merchant ID, etc. But what if we also include the full product description? Suddenly, we can ask whether buying a prepaid card with a credit card is more or less risky if the description includes “Fortnite” or “Epic Games.” That nuance can matter, especially when evaluating millions or billions of transactions. Other examples include: • Adding the transaction descriptions to the consumer behavior data to identify churn risk • Adding product descriptions or reviews to the product purchase data to recommend products • Add customer communication data to prospecting data to predict the likelihood of closing This fusion of structured learning with language-based enrichment opens up a new frontier of accuracy and interpretability. It’s not just hype - it’s the next logical step.

Can large language models be used in biotech? The short answer is yes. While LLMs are often associated with chatbots, their capabilities extend beyond that. In biotech, much of the data comes in the form of sequences – like nucleotides in DNA, or amino acids in proteins. Similar to sentences in natural language, these biological sequences have unique semantic meanings based on the arrangement of their components. When input data is fed into an LLM, a transformer converts these sequences into contextual vectors using its attention mechanism. This process allows the model to understand the context and relationships within the data, enabling it to predict subsequent elements. One such use case is prediction of neoantigens that enable targeting tumor cells in personalized cancer immunotherapies. Neoantigens are tumor-specific mutated peptides presented on the surface of tumor cells because they bind to human leukocyte antigen (HLA) molecules. LLMs can predict this binding affinity. This allows the development of personalized therapies that use the patient's own immune system to kill tumor cells without damaging healthy tissues.

There’s been a lot of discussion about how Large Language Models (LLMs) power customer-facing features like chatbots. But their impact goes beyond that—LLMs can also enhance the backend of machine learning systems in significant ways. In this tech blog, Coupang’s machine learning engineers share how the team leverages LLMs to advance existing ML products. They first categorized Coupang’s ML models into three key areas: recommendation models that personalize shopping experiences and optimize recommendation surfaces, content understanding models that enhance product, customer, and merchant representation to improve shopping interactions, and forecasting models that support pricing, logistics, and delivery operations. With these existing ML models in place, the team integrates LLMs and multimodal models to develop Foundation Models, which can handle multiple tasks rather than being trained for specific use cases. These models improve customer experience in several ways. Vision-language models enhance product embeddings by jointly modeling image and text data; weak labels generated by LLMs serve as weak supervision signals to train other models. Additionally, LLMs also enable a deeper understanding of product data, including titles, descriptions, reviews, and seller information, resulting in a single LLM-powered categorizer that classifies all product categories with greater precision. The blog also dives into best practices for integrating LLMs, covering technical challenges, development patterns, and optimization strategies. For those looking to elevate ML performance with LLMs, this serves as a valuable reference. #MachineLearning #DataScience #LLM #LargeLanguageModel #AI #SnacksWeeklyonDataScience – – –  Check out the "Snacks Weekly on Data Science" podcast and subscribe, where I explain in more detail the concepts discussed in this and future posts:    -- Spotify: https://lnkd.in/gKgaMvbh   -- Apple Podcast: https://lnkd.in/gj6aPBBY    -- Youtube: https://lnkd.in/gcwPeBmR https://lnkd.in/gvaUuF4G

𝟔 𝐓𝐲𝐩𝐞𝐬 𝐨𝐟 𝐋𝐋𝐌𝐬 𝐔𝐬𝐞𝐝 𝐢𝐧 𝐀𝐈 𝐀𝐠𝐞𝐧𝐭𝐬 Not all LLMs are created equal. Each type serves different purposes in agentic systems.  Here is what you need to know: 1. GPT (GENERATIVE PRE-TRAINED TRANSFORMER) • What it is: Trained on large-scale text data to generate human-like responses based on context. • Best for: General-purpose tasks like writing, reasoning, coding, and conversation. • Use in agents: Core language understanding and generation capabilities. • Examples: GPT-4, GPT-3.5, Claude 2. MoE (MIXTURE OF EXPERTS) • What it is: Routes inputs to a subset of specialized expert networks instead of using the full model every time. • Best for: Compute-efficient processing while scaling to very large parameter counts. • Use in agents: High-performance systems needing efficiency at scale. • Architecture: Input routes to specialized expert networks via gating mechanism. • Examples: GPT-4 (rumored), Mixtral 3. VLM (VISION-LANGUAGE MODEL) • What it is: Combines visual understanding with natural language processing. • How it works: Image encoder + Text decoder → Multimodal fusion layer → Text output • Best for: Interpreting images, diagrams, screenshots, and videos alongside text. • Use in agents: Multi-modal tasks requiring vision + language understanding. • Examples: GPT-4V, Claude 3, Gemini 4. LRM (LARGE REASONING MODEL) • What it is: Designed to handle multi-step reasoning, planning, and logical problem-solving. • Best for: Complex thinking and decision-making tasks. • Focus: Less on fluent text generation, more on structured thinking and decision-making. • Use in agents: Planning, strategy, logical problem-solving. • Examples: o1, o3-mini (OpenAI reasoning models) 5. SLM (SMALL LANGUAGE MODEL) • What it is: Lightweight models optimized for speed, cost, and on-device deployment. • Best for: Edge devices, private systems, or latency-sensitive AI agents. • Architecture: Transformer with training optimizations for specific tasks. • Use in agents: Fast, local processing without cloud dependency. • Examples: Phi-3, Llama 3.2 (small variants), Gemini Nano 6. LAM (LARGE ACTION MODEL) • What it is: Built to not just generate text, but to take actions using tools, APIs, or environments. • Best for: Autonomous AI agents that can plan, execute tasks, and adapt based on outcomes. • Capabilities: Plan workflows, call APIs, use tools, interact with environments. • Use in agents: Core of agentic systems—execution, not just generation. • Examples: Action-oriented models in AutoGPT, Agent frameworks WHEN TO USE EACH GPT: General-purpose language tasks (chatbots, content, coding) MoE: Need efficiency at massive scale (enterprise deployments) VLM: Multi-modal tasks (image analysis, visual understanding) LRM: Complex reasoning and planning (strategy, logic) SLM: Edge deployment, low-latency, privacy (on-device agents) LAM: Autonomous execution (workflow automation, task completion)

Large language models (LLMs) show early promise in easing clinician workload and improving patient communication, but real-world healthcare integration remains limited and inconsistent. 1️⃣ Only four real-world studies met criteria, all using GPT models across diverse tasks like patient messaging, mental health support, and clinical data extraction. 2️⃣ LLMs consistently improved workflow efficiency, reduced staff burden, and enhanced communication quality, but effects varied by task, setting, and user role. 3️⃣ Success depended on embedding models into existing workflows, using tools like retrieval-augmented generation (RAG), and including human oversight and escalation paths. 4️⃣ Clinical benefits included higher therapy adherence, reduced negative patient emotions, and fewer repetitive interactions in outpatient settings. 5️⃣ However, limitations emerged, such as message tone mismatches, variable accuracy across data types, and app retention drop-offs after six weeks. 6️⃣ Challenges to scale include lack of standard evaluation metrics, inconsistent EHR integration, regulatory delays, and absence of robust post-deployment monitoring. 7️⃣ Studies emphasized the need for local model adaptation, cross-site validation, and standardized outcome definitions to ensure relevance and comparability. 8️⃣ Proposed solutions include human-centered design, version tracking, real-time safety overrides, and clear metrics for usability, safety, and clinical impact. 9️⃣ Most studies were in high-resource settings, limiting generalizability to low- and middle-income contexts. 🔟 Implementation success depends less on model power and more on clinical fit, workflow timing, and active human supervision. ✍🏻 Yaara Artsi, Vera Sorin, MD, CIIP, Ben Glicksberg, Panagiotis Korfiatis, Girish Nadkarni, Eyal Klang. Large language models in real-world clinical workflows: a systematic review of applications and implementation. Frontiers in Digital Health. 2025. DOI: 10.3389/fdgth.2025.1659134

Thank you to the University of Toronto Machine Intelligence Student Team for inviting me to present a keynote on augmenting human-labeled datasets using Large Language Models (LLMs). Human-labeled data is crucial for testing, tuning, customizing, and validating LLMs in organizations. This is because human labeled data provides the ground truth for developing trustworthy #GenerativeAI applications and #AgenticAI systems. Yet acquiring sufficient human labeled data is often a bottleneck in many organizations. Subject matter experts and domain specialists typically have limited time for labeling tasks due to competing professional demands, making large-scale manual labeling difficult to sustain. My talk focused on how LLMs can be used not to substitute human labels, but to systematically augment them—extending the utility of existing human labeled data and improving model robustness without proportionally increasing manual labeling effort. I described practical methods for implementing two augmentation techniques with strong empirical grounding: • Negative Reinforcement with Counterfactual Examples – This technique involves analyzing labeled examples to generate counterfactual examples—outputs that are intentionally incorrect or undesirable—and using them to teach the model about what not to generate. By guiding the model using these negative samples, the model learns sharper decision boundaries, increasing robustness against hallucinations and confabulations. • Contrastive Learning with Controlled Perturbations – This technique creates diverse, label-preserving variants of human-labeled examples by introducing controlled modifications to the prompts and/or completions. These perturbations maintain core semantic meaning while varying surface-level features such as syntax, phrasing, or structure, encouraging the model to generalize beyond shallow lexical or syntactic cues. These techniques have been shown to drive measurable improvements in model behavior: • Lower Perplexity → More predictable completions and improved alignment with ground-truth targets. • Reduced Token Entropy → More focused and efficient completions, reducing inference complexity. • Higher Self-Consistency → More stable completions across repeated generations of the same prompt—a key requirement for dependable downstream use. These are not theoretical constructs—they are practical techniques for overcoming constraints in human-labeled data availability and scaling of #LLM applications with greater efficiency and rigor. Appreciate the University of Toronto Machine Intelligence Student Team (UTMIST) for a well-curated conference, and the UofT AI group for their initiatives in the space. Grateful to my research partner, Olga, for her contributions in collaboratively developing content for this presentation. Kudos to my PwC Canada teammates including Michelle B, Annie, Chris M, Michelle G, Chris D, Brenda, Bahar, Danielle, and Abhinav for their partnership on our PwC #AI portfolio.

LLM literacy is now part of modern UX practice. It is not about turning researchers into engineers. It is about getting cleaner insights, predictable workflows, and safer use of AI in everyday work. A large language model is a Transformer based language system with billions of parameters. Most production models are decoder only, which means they read tokens and generate tokens as text in and text out. The model lifecycle follows three stages. Pretraining learns broad language regularities. Finetuning adapts the model to specific tasks. Preference tuning shapes behavior toward what reviewers and policies consider desirable. Prompting is a control surface. Context length sets how much material the model can consider at once. Temperature and sampling set how deterministic or exploratory generation will be. Fixed seeds and low temperature produce stable, reproducible drafts. Higher temperature encourages variation for exploration and ideation. Reasoning aids can raise reliability when tasks are complex. Chain of Thought asks for intermediate steps. Tree of Thoughts explores alternatives. Self consistency aggregates multiple reasoning paths to select a stronger answer. Adaptation options map to real constraints. Supervised finetuning aligns behavior with high quality input and output pairs. Instruction tuning is the same process with instruction style data. Parameter efficient finetuning adds small trainable components such as LoRA, prefix tuning, or adapter layers so you do not update all weights. Quantization and QLoRA reduce memory and allow training on modest hardware. Preference tuning provides practical levers for quality and safety. A reward model can score several candidates so Best of N keeps the highest scoring answer. Reinforcement learning from human feedback with PPO updates the generator while staying close to the base model. Direct Preference Optimization is a supervised alternative that simplifies the pipeline. Efficiency techniques protect budgets and service levels. Mixture of Experts activates only a subset of experts per input at inference which is fast to run although the routing is hard to train well. Distillation trains a smaller model to match the probability outputs of a larger one so most quality is retained. Quantization stores weights in fewer bits to cut memory and latency. Understanding these mechanics pays off. You get reproducible outputs with fixed parameters, bias-aware judging by checking position and verbosity, grounded claims through retrieval when accuracy matters, and cost control by matching model size, context window, and adaptation to the job. For UX, this literacy delivers defensible insights, reliable operations, stronger privacy governance, and smarter trade offs across quality, speed, and cost.

In 2024–2025, the AI race was simple: bigger models meant better results. In 2026, that thinking is changing fast. Enter Small Language Models (SLMs) - lightweight, task-focused models that deliver faster responses, lower costs, stronger privacy, and more predictable production behavior. Instead of sending every request to massive cloud LLMs, enterprises now use smaller models for everyday tasks like classification, extraction, summarization, routing, and drafting — while reserving large models only for complex reasoning and creative workloads. This shift is driven by real-world constraints. SLMs run locally on laptops, edge devices, or low-cost servers, making them ideal for latency-sensitive and privacy-critical applications. They’re optimized for speed, cost efficiency, on-device privacy, and task specialization - exactly what production systems need today. What’s surprising in 2026 is how capable these models have become. Modern SLM families can summarize documents, answer questions accurately, generate meaningful content, and handle reasoning-style tasks - all while running locally. In simple terms: yesterday’s enterprise AI now fits on your laptop. Architecturally, teams are moving to a small-first, big-when-needed approach. SLMs handle most operational workloads like extraction, classification, summarization, and routing. Larger models step in only for deep reasoning, long conversations, or creative synthesis. Around this, companies build local AI stacks with runtimes, vector databases for RAG, embeddings, tool calling, guardrails, and monitoring - turning SLMs into full internal AI platforms, not just models. The takeaway is simple: 2024–2025 was about model size. 2026 is about efficiency. Small Language Models aren’t a trend. They’re becoming the default for production AI because modern systems care about usability, scalability, affordability, and security more than raw parameter counts. If you’re building AI for real-world use, SLMs should already be on your architecture diagram. Save this for later and share it with your platform or AI team.

Large language models: a primer for economists (https://lnkd.in/eJschCjr) & Systematic Interpretation of Central Bank Communication Large Language Models (LLMs) have revolutionized economic research by enabling advanced analysis of unstructured textual data such as policy statements, financial reports, and news articles. These models transform text into structured numerical representations, facilitating tasks like sentiment analysis, forecasting, and topic modeling. Their contextual understanding, enabled by transformer-based architectures, makes them particularly effective in analyzing economic narratives. For instance, LLMs can evaluate market sentiment or interpret the tone of central bank communications, offering valuable insights into monetary policy impacts. A study of US equity markets demonstrated this by analyzing over 60,000 news articles to identify key drivers such as fundamentals, monetary policy, and market sentiment, linking these themes to stock market movements. Before the explosion of LLMs, I conducted research with my colleagues at Morgan Stanley to systematically analyze central bank communication using earlier machine-learning techniques. Specifically, we trained a Convolutional Neural Network (CNN) to assess the degree of hawkishness or dovishness in FOMC communications. This effort led to the development of the MNLPFEDS Index, which proved to be a powerful tool for anticipating monetary policy actions up to a year in advance. The index provided valuable insights into potential inflection points in the monetary cycle and their effects on rates, the yield curve, and the USD. This work highlighted the predictive power of communication analysis, even before the advent of the sophisticated transformer models now driving advancements in LLMs. LLMs and earlier machine-learning approaches, like CNN-based analysis, each bring unique strengths to understanding monetary policy and market dynamics. While LLMs excel in processing vast and complex datasets with contextual depth, their capabilities can be further enhanced through fine-tuning for domain-specific tasks. This adaptability allows LLMs to specialize in areas like central bank communication, where nuances in tone and context are crucial. Combined with the foundational contributions of earlier models like the MNLPFEDS Index, fine-tuned LLMs provide economists with a comprehensive toolkit to analyze qualitative insights and integrate them into robust quantitative frameworks, enriching the understanding of policy effects and broader economic trends. #EconomicResearch #MonetaryPolicy #CentralBankCommunication #MachineLearning #ArtificialIntelligence #NaturalLanguageProcessing #LLMs #DeepLearning #EconomicForecasting #SentimentAnalysis #TextAnalysis #DataScience #MacroEconomics #QuantitativeResearch

Language models like ChatGPT are amazing for jumpstarting new software projects - but they’re not a substitute for professional developers. Instead, think of these tools as accelerators that help lay the groundwork for your next application. Here’s how engineering teams are (or should be) starting to integrate language models into their workflows: 1 - Crafting the Project Vision Before writing any code, teams could use a language model to collaboratively develop thorough documentation. This includes the project’s overall purpose, target user profiles, typical user flows, and an outline of all major components - such as back-end servers, front-end interfaces, databases, frameworks, and application programming interfaces (APIs). 2 - Defining the Technical Blueprint Once the vision is set, the next step is to establish design principles using the language model. This might include picking an architectural approach - like microservices (breaking up the app into smaller services, each with a specific job), monolithic (one large codebase), or serverless (where a cloud provider handles the underlying server infrastructure). Teams also clarify their approach to error handling, security protocols, logging, testing, and scalability. Having a clear technical plan prevents confusion later on. For instance, “microservices” can reduce interdependencies between different parts of the app, while a “monolithic” structure can be simpler to manage for smaller or early-stage projects. 3 - Auto-Generating a Project Skeleton Next, the language model can produce an initial folder structure along with placeholder files. This is like giving architects a ready-made foundation for a building - everything’s laid out, but not yet furnished. 4 - Filling in the Blanks With the skeleton in place, teams direct the model to add minimal, functional code. It’s not production-ready - think of it like a rough draft that compiles and runs but still needs completion. At this point, the application might be anywhere between 30% to 70% complete. That’s where software engineers step in to handle complex logic, optimize performance, and ensure a polished user experience. In other words, the model does the heavy lifting on setup, but expert developers bring the final product to life. Language models are not about replacing software engineers; they’re tools that can save time and energy during the earliest stages of development. By outlining requirements, proposing architectures, and generating initial code, these models free up talented engineers to focus on creative problem-solving and delivering high-quality software. Have you experimented with using language models to kick off new projects? #innovation #technology #future #management #startups