Language model
A language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
Software Testing with Generative AI
A large language model is a machine-learning model trained on extensive text data to generate and transform language from an input prompt.
- How it is used
- Supports focused testing and development tasks by generating, transforming, or enhancing information through prompts or APIs.
- How deep it goes
- Explains prompts, probabilistic prediction, training data, risks, and prompt tactics, but stops short of deep model internals.
- Examples
- Uses phone keyboard predictions, file-upload test design, code transformation, synthetic data, and Java booking-API code generation.
- What you can do after
- Apply it via prompt engineering to accelerate focused testing work while verifying outputs and retaining human direction.
Read how Software Testing with Generative AI explains language model →
LLMs in Production
A large language model is an artificial intelligence model trained on large text collections to predict and generate human language.
- How it is used
- Uses language models to automate communication and frame production deployment decisions.
- How deep it goes
- Explains pretraining, prompting, fine-tuning, evaluation, and deployment trade-offs, including a training-from-scratch procedure.
- Examples
- Uses an API chatbot call, BLOOM text generation, and AI Dungeon’s vendor-control experience as concrete examples.
- What you can do after
- Apply it via Transformers to generate text and evaluate candidates using task datasets and metrics.
How Large Language Models Work
A machine-learning model trained on very large text collections to understand and generate human language or other sequential content such as source code.
- How it is used
- Explains how generative language systems work and helps users, developers, and decision makers judge suitable applications.
- How deep it goes
- Traces tokenization, embeddings, attention, autoregressive generation, and training objectives, but stops short of building a model from scratch.
- Examples
- Uses haiku generation, summarization, word games, drug names, pi code, and Modula-3 translation to illustrate capabilities and failures.
- What you can do after
- Evaluate/understand LLM outputs, constrain practical use cases, verify results, and recognize when novelty or risk makes deployment unsuitable.
Read how How Large Language Models Work explains language model →
Natural Language Processing in Action, Second Edition
A large language model is a neural language model trained on very large text corpora to model and generate language.
- How it is used
- Uses language models to generate chatbot responses and support question answering and other language tasks.
- How deep it goes
- Explains conditional next-token generation and scaling, with word-level RNN data preparation and pretrained-model experiments.
- Examples
- Uses WikiText-2 word IDs and a Llama 2 arithmetic response to illustrate training data and output reliability.
- What you can do after
- Apply it via PyTorch and Hugging Face Transformers to prepare word-level data and generate text with a pretrained model.
Read how Natural Language Processing in Action, Second Edition explains language model →
Introduction to Generative AI, Second Edition
A large language model is a language model trained on very large amounts of data with many parameters to understand and generate natural language across tasks.
- How it is used
- Introduces large language models as general-purpose systems for conversation, question answering, and other language tasks.
- How deep it goes
- Explains token prediction, attention, training phases, applications, and risks at an intuitive level.
- Examples
- Uses a camera sentence-completion test and ChatGPT conversations to illustrate language-model capabilities.
- What you can do after
- Evaluate and understand language-model applications alongside risks such as bias, fabricated answers, privacy exposure, and energy use.
Read how Introduction to Generative AI, Second Edition explains language model →
Deep Learning with R, Third Edition
A large language model is a machine-learning model trained on large text corpora to understand and generate natural-language text.
- How it is used
- Introduces language modeling as a practical way to generate sequences through next-token prediction.
- How deep it goes
- Defines the conditional next-token distribution and motivates it against whole-sequence classification.
- Examples
- Uses character prediction for Shakespeare-like text and a 20,000-word vocabulary to illustrate sequence complexity.
- What you can do after
- Evaluate and understand why predicting one token at a time makes text generation tractable.
Read how Deep Learning with R, Third Edition explains language model →
Grokking AI Algorithms, Second Edition
A large language model is a neural language model trained on large text corpora to process and generate human language.
- How it is used
- Introduces language models through autocomplete and extends the idea to language generation, translation, question answering, and code.
- How deep it goes
- Explains Transformer components and architectural trade-offs, using a small example configuration alongside real-world model sizes.
- Examples
- Uses phone autocomplete for “Hey, what are” and compares a toy Transformer configuration with larger models.
- What you can do after
- Evaluate/understand it by relating next-word prediction, Transformer components, and resource trade-offs to LLM capabilities.
Read how Grokking AI Algorithms, Second Edition explains language model →
The Art of AI Product Development
A machine-learning model trained on large text corpora to understand and generate natural language.
- How it is used
- Uses language models as adaptable components of products, from content generation and backend tasks to tool-using agents.
- How deep it goes
- Explains training data, capabilities, deployment patterns, selection, and evaluation, while leaving fine-tuning’s technical challenges to engineers.
- Examples
- Follows a personalized content-generation app and considers natural-language questions translated into SQL queries.
- What you can do after
- Evaluate and understand language models for product selection, adaptation, risk management, and iterative assessment.
Read how The Art of AI Product Development explains language model →
Deep Learning with Python, Third Edition
A language model trained on large text corpora that can generate human-sounding responses, mentioned here as an example of a system that may be modular but still lacks recombination ability.
- How it is used
- Uses next-token prediction as the foundation for text generation and related language tasks.
- How deep it goes
- Develops character-level autoregressive inference and compares masked and sequence-to-sequence models with Transformer attention.
- Examples
- Demonstrates Shakespeare-like character generation and a randomly sampled word-problem response from Gemma.
- What you can do after
- Builds a character-level language model with Keras and runs an autoregressive generation loop.
Read how Deep Learning with Python, Third Edition explains language model →
Grokking AI Applications
A large language model is a machine-learning model trained on large text collections to predict and generate sequences of natural-language tokens.
- How it is used
- Places the language model at the center of generative AI workflows, contrasting probabilistic natural-language interaction with traditional programming.
- How deep it goes
- Explains token generation, training stages, embeddings, and GPT-3 scale through simplified comparisons without requiring mastery of architectural details.
- Examples
- Uses a name-recall conversation, a small embedding dictionary, and a calculator-equipped agent to make model behavior concrete.
- What you can do after
- Apply it via Langflow to configure an agent that uses a calculator for arithmetic.
Generative AI in Action
A large language model is a neural model trained on large text corpora to understand and generate natural language, including source code in code-focused variants.
- How it is used
- Uses language models for enterprise text generation, extraction, chat, and data-assisted applications.
- How deep it goes
- Explains tokenization, iterative generation, prompting, and configuration at a practical level without detailed machine-learning derivations.
- Examples
- Illustrates entity extraction from a customer message and text generation followed by translation using an OpenAI API call.
- What you can do after
- Apply it via OpenAI and Azure OpenAI APIs to enterprise language tasks, while considering output reliability and operational constraints.
Investing for Programmers
A large language model is an artificial-intelligence model trained on extensive text data to understand and generate human language.
- How it is used
- Deploys language generation for company research, document summarization, risk assessment, code generation, and structured investment workflows.
- How deep it goes
- Explains generative use, attention, prompting, APIs, parameters, and limitations, but defers detailed transformer internals.
- Examples
- Demonstrates stock-strategy comparisons, company-risk scoring, document summaries, Python API calls, and LangChain agents using financial news.
- What you can do after
- Apply LLMs through OpenAI, Gemini, Anthropic, Mistral, Hugging Face, or LangChain APIs while reviewing outputs for reliability.
Read how Investing for Programmers explains language model →
Effective Conversational AI
A large language model is a machine learning model trained on very large text datasets to model and generate sequences of language.
- How it is used
- Supports chatbot answers and assists builders with dialogue, training data, and other conversational AI tasks.
- How deep it goes
- Defines next-word prediction and works through API routing, prompts, model selection, and guardrails without detailing model internals.
- Examples
- Uses a generated pie recipe, password-related utterances, and an insurance-claim dialogue flow.
- What you can do after
- Apply it via a chatbot API for selected requests, while testing outputs and retaining controls over user-facing answers.
Read how Effective Conversational AI explains language model →
Knowledge Graphs and LLMs in Action
A large language model is a neural language model trained on very large text corpora to understand and generate natural-language content.
- How it is used
- Supports knowledge extraction, natural-language querying, summarization, conversational interfaces, and interpretation of structured analytical results.
- How deep it goes
- Explains scaling, transfer learning, prompting, fine-tuning, grounding, and several implementation pipelines, while deferring full model-training internals.
- Examples
- Uses drug discovery, customer support, pathway interpretation, clinical decision support, and ontology-grounded biomedical entity disambiguation.
- What you can do after
- Build domain-specific extraction and question-answering systems using prompts, fine-tuning, knowledge graphs, and validation workflows.
Read how Knowledge Graphs and LLMs in Action explains language model →
Sutskever's List
A language model assigns probabilities to sequences of linguistic tokens and can generate or evaluate text.
- How it is used
- Defines the probability model underlying generative language models and next-token training.
- How deep it goes
- Explains sentence probabilities and next-token training, including shifted labels and causal masking.
- Examples
- Contrasts grammatical and plausible text with broken grammar and grammatically correct but semantically odd text.
- What you can do after
- Evaluate how syntax and meaning affect text probabilities and understand how autoregressive models generate text.
The Complete Obsolete Guide to Generative AI
A machine-learning model trained on large text corpora to process and generate natural-language text.
- How it is used
- Accelerates language-driven work through prompts, data querying, automation, and productivity-tool integrations.
- How deep it goes
- Defines prediction-based language generation and response controls, while deferring deeper model theory to separate definitions and later model work.
- Examples
- Uses hotel chat responses, PDF sales totals, Python help, spreadsheet formulas, sentiment labels, and banking-data queries.
- What you can do after
- Apply it via chat tools and APIs to generate, analyze, automate, and verify language-based work.
Read how The Complete Obsolete Guide to Generative AI explains language model →
Machines that Think
A computational model of patterns in language that can assign probabilities to or generate language sequences.
- How it is used
- Uses language models as a practical lens for examining machine intelligence and its consequences for organizational judgment.
- How deep it goes
- Explains probabilistic continuation, scale, representations, and reliability at an overview level, while leaving the question of machine understanding open.
- Examples
- Uses a medical-treatment explanation to distinguish fluent responses from verified, case-specific knowledge.
- What you can do after
- Evaluate language-model outputs by distinguishing plausible language from verified claims and recognizing context limits and bias.
Deep Learning with PyTorch, Second Edition
A language model with enough scale to generate and answer with fluent text from prompts.
- How it is used
- Uses language generation to motivate deep learning and frame a hands-on model-building project.
- How deep it goes
- Introduces generated responses and probabilistic output, while identifying a model-building project without showing its implementation.
- Examples
- Illustrates a prompt asking ChatGPT to introduce itself through a poem and quotes its generated verses.
- What you can do after
- Evaluate and understand fluent model responses as probabilistic outputs learned from examples, rather than proof of machine self-awareness.
Read how Deep Learning with PyTorch, Second Edition explains language model →
Inside AI
A large language model is a machine-learning model trained on large text corpora to process and generate human-language text.
- How it is used
- Introduces language models as generative AI tools for conversation, content creation, and other language tasks.
- How deep it goes
- Explains pretraining, fine-tuning, and next-token prediction through an example without detailed implementation.
- Examples
- Uses an electric-vehicle sentence continuation alongside summarization, translation, coding assistance, and customer-support scenarios.
- What you can do after
- Evaluate language-model applications by weighing useful outputs against hallucinations, data quality, computational costs, and misuse.
Starting Data Analytics with Generative AI and Python
A machine-learning model trained on large text collections to understand and generate natural language.
- How it is used
- Supports data analytics through planning, code generation, interpretation, and initial text analysis.
- How deep it goes
- Defines LLMs and demonstrates their use in analytics workflows while deliberately avoiding architecture details.
- Examples
- Uses customer-review sentiment, idiomatic language, and interpretation of e-commerce charts to illustrate applications.
- What you can do after
- Apply it via an API or editor integration to support analysis, while checking generated code and interpretations.
Read how Starting Data Analytics with Generative AI and Python explains language model →
Build an Advanced RAG Application (From Scratch)
A large language model is a neural language model with a very large number of learned parameters and extensive training data that generates or evaluates text.
- How it is used
- Generates natural responses that turn retrieved search results into conversational explanations and personalized recommendations.
- How deep it goes
- Defines next-word prediction and training updates, while deferring Transformer components to a separate treatment.
- Examples
- Uses relationship-based next-word prediction, Paris-hotel prompts, travel-assistant responses, and fabricated Mars-walker answers.
- What you can do after
- Apply it via an API by sending structured prompts and configuring model, temperature, and output-token settings.
Read how Build an Advanced RAG Application (From Scratch) explains language model →
AI-Powered Search
A large language model is a neural language model trained on large text corpora to predict and generate language and perform related language-understanding tasks.
- How it is used
- Uses language models to interpret queries, represent documents, personalize results, and generate search responses.
- How deep it goes
- Explains Transformer representations and training, then applies pretrained and fine-tuned models without demonstrating pretraining from scratch.
- Examples
- Uses product-name embeddings for user profiles and an outdoors question-answering application.
- What you can do after
- Applies pretrained models via Sentence Transformers and fine-tunes a Transformer-based model for extractive question answering.
Learn Generative AI with PyTorch
A large language model trained beforehand on broad textual data and reused for downstream tasks.
- How it is used
- Uses pretrained language models as reusable components for downstream text tasks and tool-assisted applications.
- How deep it goes
- Explains Transformer and token-processing mechanics and walks through a smaller GPT-style model, alongside pretrained-model access.
- Examples
- Illustrates a 5.12-million-parameter GPT-style generator and an assistant using Wolfram Alpha and Wikipedia.
- What you can do after
- Apply pretrained models via LangChain to create a zero-shot assistant that selects external tools for queries.
Read how Learn Generative AI with PyTorch explains language model →
Machine Learning Platform Engineering
A large language model is a neural language model trained on extensive text data to generate or transform natural-language content.
- How it is used
- Uses an LLM to generate answers in a retrieval-augmented documentation assistant.
- How deep it goes
- Explains integration, model choice, observability, and cost; stops short of language-model training internals.
- Examples
- Uses a company-documentation chatbot, a manual-versus-LangChain retrieval pipeline, and token-cost comparisons across model options.
- What you can do after
- Apply it via LangChain in a retrieval-augmented assistant, then monitor responses and spending.
Read how Machine Learning Platform Engineering explains language model →
Data Analysis with LLMs
A language model with a very large number of learned parameters, trained on broad text data for general-purpose language tasks.
- How it is used
- Connects natural-language instructions to direct data analysis or to queries executed by specialized tools.
- How deep it goes
- Explains prompting, reusable templates, query generation, and cost choices through workflows; does not develop neural-network internals.
- Examples
- Uses laptop-review classification, survey questions translated to SQL, and questions about graph data translated to Cypher.
- What you can do after
- Apply it via a Python model library to classify reviews or generate queries, then evaluate model choices on sample data.
Build AI-Enhanced Web Apps
A large language model is a machine-learning model trained on large amounts of text to understand and generate natural-language content.
- How it is used
- Powers natural-language generation within web applications, from conversational interfaces to document summarization.
- How deep it goes
- Explains next-sequence prediction and application workflows, emphasizing integration rather than model-training internals.
- Examples
- Uses a chat interface, document question-answering pipeline, and interview assistant to demonstrate model-driven features.
- What you can do after
- Apply it via LangChain.js to generate answers from retrieved document context and return source documents.
Read how Build AI-Enhanced Web Apps explains language model →
Effective Data Analysis
A large language model is a machine-learning model trained on extensive text data to process and generate human language.
- How it is used
- Positions LLMs as generative AI assistants for drafting and analytical workflows, while retaining the analyst’s judgment.
- How deep it goes
- Defines LLMs and illustrates iterative prompting and evaluation, without explaining model architecture or training procedures.
- Examples
- Uses customer login statistics and a rat-sightings modeling exercise to illustrate chatbot-assisted analysis.
- What you can do after
- Practice using a chatbot to refine prompts, request analytical code and models, and compare its results with an independent analysis.
Build Python Web Apps with Streamlit
An LLM is a large language model that generates or transforms text from input sequences.
- How it is used
- Uses language models to power trivia features and customer-service assistants.
- How deep it goes
- Explains API calls, message roles, structured responses, and graph integration rather than model internals.
- Examples
- Builds a trivia quizmaster, a Streamlit chatbot, and a one-node conversation graph.
- What you can do after
- Apply language models via the OpenAI Python library and LangChain to generate responses in applications.
Read how Build Python Web Apps with Streamlit explains language model →
Vibe Engineering
A language model is a machine-learning model that processes and generates text by predicting sequences of tokens.
- How it is used
- Uses LLMs to assist software development and data analysis while keeping verification and operational boundaries in human workflows.
- How deep it goes
- Explains prompting tradeoffs, failure controls, and model-selection costs without detailing language-model internals.
- Examples
- Uses a legacy-code migration, a drug-price prediction notebook, and a production data-deletion incident.
- What you can do after
- Evaluate and understand LLM output by checking assumptions, generated behavior, and operational risks before relying on it.
Fight Fraud with Machine Learning
A large language model is a language model trained on a very large text corpus, typically with many learned parameters, to process and generate human language.
- How it is used
- Applies LLMs to classify email phishing and support phishing-detection applications.
- How deep it goes
- Explains next-word probabilities and prompting, then demonstrates hosted and local inference rather than building an LLM from scratch.
- Examples
- Uses ChatGPT conversations, next-word completion, a missed phishing email, one-shot prompting, and a locally loaded Mistral model.
- What you can do after
- Apply it via ChatGPT, HuggingFace, LangChain, or LlamaCpp to classify phishing emails and tune confidence-based decisions.
Read how Fight Fraud with Machine Learning explains language model →
AI Agents and Applications
A large language model is a neural language model trained on extensive text data to understand and generate language and perform text-based reasoning.
- How it is used
- Uses language models as the language-processing component of engines, chatbots, and tool-using agents.
- How deep it goes
- Explains model calls and application workflows, then develops retrieval and generation rather than model training internals.
- Examples
- Demonstrates a phishing-reminder prompt and a research engine that searches, summarizes web pages, and compiles a report.
- What you can do after
- Apply it via OpenAI and LangChain to execute prompts and incorporate models into retrieval or summarization workflows.
Read how AI Agents and Applications explains language model →
Causal AI
A large language model is a deep neural language model with billions of parameters trained on vast amounts of text and other data.
- How it is used
- Uses LLMs as resources for sourcing and checking causal information needed to formulate assumptions about a data-generating process.
- How deep it goes
- Defines their scale, generative role, and foundation-model status, then offers a high-level causal primer rather than detailed language-model internals.
- Examples
- Uses GPT-4 through ChatGPT for causal-information queries and names GPT, Gemini, Llama, and Microsoft 365 Copilot as model or product examples.
- What you can do after
- Apply it via ChatGPT to seek causal information while assessing proposed assumptions and allowing for variable responses.
Coding with AI
A large language model is a neural language model trained on extensive data to understand and generate language, including programming-language text.
- How it is used
- Uses LLMs to support software development from planning and coding through testing and documentation.
- How deep it goes
- Explains probabilistic generation, Transformer context processing, and failure modes without a detailed mathematical treatment.
- Examples
- Uses a Python CSV filtering and averaging prompt to illustrate generation followed by developer review and testing.
- What you can do after
- Apply it via GitHub Copilot or ChatGPT to development tasks while reviewing and testing generated results.
Delivering Machine Learning Projects: From design to deployment
A language model is a computational model that represents patterns in language to estimate, generate, or evaluate sequences of text.
- How it is used
- Uses large language models as an example of ML’s text-generation potential and the risks of applying models in practice.
- How deep it goes
- Mentions GPT-3 and explains general ML model learning and inference, without detailing language-model internals.
- Examples
- Cites GPT-3 as a large language model capable of producing text that is hard to distinguish from human writing.
- What you can do after
- Evaluate and understand language models as examples of ML capabilities, while recognizing the potential harms of model errors and unsuitable applications.
Read how Delivering Machine Learning Projects: From design to deployment explains language model →
Understanding AI
A large language model is a machine-learning model trained on extensive text data to generate and transform natural language.
- How it is used
- Frames LLMs as everyday AI tools whose behavior becomes easier to use safely and steer when understood.
- How deep it goes
- Explains next-token generation, tokens, embeddings, attention, context windows, and assistant training without deep mathematics.
- Examples
- Uses the France capital completion, familiar phrase continuations, and raw-model continuations of a performance sentence.
- What you can do after
- Diagnose and steer LLM responses by considering likelihood, prompt phrasing, context limits, and imperfect guardrails.
Time Series Forecasting Using Foundation Models
A large language model is a neural-network model trained on large text corpora to perform language understanding and generation tasks.
- How it is used
- Extends natural-language generation capabilities to time-series forecasting by converting numerical prediction into a prompted language task.
- How deep it goes
- Defines language-model capabilities and details prompt construction and output parsing, but stops short of making LLMs forecasting-specific.
- Examples
- Uses Flan-T5, Llama-3.2-3b-instruct, natural-language prompts, generated strings, and extracted forecast values.
- What you can do after
- Apply it via prompting to forecast time series, while evaluating whether preprocessing, computation, and accuracy trade-offs justify its use.
Read how Time Series Forecasting Using Foundation Models explains language model →
AI Model Evaluation
A neural language model trained on large text corpora to understand, generate, or transform natural-language content.
- How it is used
- Uses LLM chatbots as an entry point to AI models and their evaluation in user-facing products.
- How deep it goes
- Defines model anatomy and lifecycle at a high level, while assuming familiarity with model basics rather than developing an LLM architecture.
- Examples
- Illustrates LLM use with chatbot questions about a dripping faucet and making tomato sauce.
- What you can do after
- Evaluate/understand model quality by distinguishing offline promise from online user impact and recognizing feedback-loop risks.
The AI Pocket Book
A neural language model trained on large text corpora to predict and generate natural language.
- How it is used
- Explains how conversational and generative AI turns prompts into outputs one token at a time.
- How deep it goes
- Traces tokenization, embeddings, contextualization, probabilities, and wrapper-driven generation, but defers exact internal calculations.
- Examples
- Uses Eiffel Tower completion, arithmetic, translation, token probability tables, and system-prompt date responses.
- What you can do after
- Evaluate how prompts, token probabilities, wrappers, and injected context shape an LLM’s response.
Deep Learning with JAX
A large neural language model used for language-modeling tasks such as generation, training, fine-tuning, and serving.
- How it is used
- Deploys pretrained language models or supports their training, fine-tuning, evaluation, and serving.
- How deep it goes
- Surveys model families and JAX tooling but stops short of explaining transformer internals or language-model training algorithms.
- Examples
- Uses Llama, Gemma, GPT-J, GPT-Neo, BLOOM, GPT-2, T5, BERT, EasyLM, Pax, and MaxText as concrete examples.
- What you can do after
- Operate pretrained models and evaluate JAX-based options for training, fine-tuning, scaling, or serving LLMs.
Build a Reasoning Model (From Scratch)
A neural language model trained on large text corpora to predict and generate text.
- How it is used
- Uses next-token prediction to generate fluent text and support later reasoning-training or preference-tuning stages.
- How deep it goes
- Explains pretraining, prompt continuation, reasoning simulation, scaling, and failure modes, but stops short of neural architecture or optimization details.
- Examples
- Demonstrates Germany’s capital, penguin contradictions, GPT-4o responses, and staged LLM training workflows.
- What you can do after
- Evaluate whether an LLM response reflects learned statistical association or explicit rule-based reasoning.
Read how Build a Reasoning Model (From Scratch) explains language model →
Learn AI-Assisted Python Programming, Second Edition
A large language model is a machine-learning model that represents statistical relationships among language elements and predicts sequences of text from context.
- How it is used
- Deploys natural-language prompts as an interface for generating Python programs with Copilot.
- How deep it goes
- Explains contextual next-word prediction, nondeterminism, and limited understanding, but does not descend into model implementation.
- Examples
- Uses next-word completion, Copilot-generated Python, classroom-seat prompts, and doctests to illustrate prediction and verification.
- What you can do after
- Evaluate generated responses by refining prompts, comparing alternatives, testing code, and checking correctness and security.
Read how Learn AI-Assisted Python Programming, Second Edition explains language model →
Data Without Labels
A large language model is a machine-learning model trained on very large text collections to understand and generate language.
- How it is used
- Uses language models to connect word-sequence prediction with text analysis and LLM applications.
- How deep it goes
- Works through n-gram probabilities and context lengths, but does not explain LLM internals or implement an LLM.
- Examples
- Compares unigrams, bigrams, and trigrams using “It is raining heavily,” then names document summarization and customer support.
- What you can do after
- Evaluate/understand it by distinguishing an n-gram’s limited preceding-word context from the LLM applications described here.
Essential GraphRAG
A large language model is a neural language model trained on extensive text data to generate human-like text by predicting token sequences.
- How it is used
- Supports language generation, instruction following, retrieval-augmented answering, structured extraction, and natural-language query generation.
- How deep it goes
- Explains transformer-based prediction, capabilities, limitations, and application patterns, but defers detailed neural-network internals and training procedures.
- Examples
- Uses next-word completion, haiku generation, outdated ownership information, fabricated legal citations, and incorrect WikiData identifiers.
- What you can do after
- Evaluate/understand generated language and apply LLMs through RAG, structured extraction, or text-to-Cypher workflows.
Build AI Drug Discovery Pipelines
A language model assigns probabilities to sequences or predicts the next token from preceding tokens.
- How it is used
- Places sequence-trained foundation models in multimodal drug-discovery workflows.
- How deep it goes
- Mentions sequence-trained foundation models and their applications without explaining language-model training or next-token prediction.
- Examples
- Uses protein-sequence embeddings for structure prediction and function annotation.
Read how Build AI Drug Discovery Pipelines explains language model →
Outlier Detection in Python
A large language model is a neural model trained on very large text corpora to process and generate natural language.
- How it is used
- Uses models to identify records that depart from learned patterns, without establishing a role for language models.
- How deep it goes
- Explains fitting and predictive failure in outlier detectors, but does not define language-model training or operation.
- Examples
- Uses breast-cancer records and a decision tree distinguishing real from synthetic data, rather than a language-model example.
- What you can do after
- Evaluate/understand model fit for outlier detection, but not build or operate a language model.
Read how Outlier Detection in Python explains language model →
Machine Learning System Design
A large language model is a machine learning model trained on large text corpora to generate or transform language and perform related language tasks.
- How it is used
- Uses generative response variability to frame a production monitoring problem.
- How deep it goes
- Illustrates nondeterministic responses and update effects without explaining language-model internals.
- Examples
- Shows four similar but nonidentical ChatGPT replies to repeated input.
- What you can do after
- Evaluate/understand how response variation complicates system health checks.
Read how Machine Learning System Design explains language model →
First-Party Data Activation
A machine-learning model trained on large text collections to understand and generate natural language.
- How it is used
- Places large language models in a governed marketing intelligence layer that turns customer data into actionable insights.
- How deep it goes
- Identifies LLMs as analytical tools alongside other ML algorithms, but does not explain their training or internal workings.
- Examples
- Lists customer demographics, purchase history, website interactions, and market trends as data analyzed by LLMs and other ML algorithms.
- What you can do after
- Evaluate/understand how LLMs and other ML tools can inform marketing decisions using governed customer data.
Read how First-Party Data Activation explains language model →
Inside Deep Learning: Math, Algorithms, Models
A subfield of machine learning that uses layered neural-network models.
- How it is used
- Establishes general neural-network model and training mechanics as a foundation for building more complex models.
- How deep it goes
- Defines model notation, loss minimization, and a PyTorch linear model, then connects layers to nonlinear modeling.
- Examples
- Uses linear regression on toy data, an nn.Linear module, and prediction plots to demonstrate model training and inference.
- What you can do after
- Build and train a PyTorch neural-network model by combining a model, loss function, dataset, and training loop.
Read how Inside Deep Learning: Math, Algorithms, Models explains language model →
Build an AI Agent (From Scratch)
A large language model is a neural language model trained on extensive text data that generates and interprets language.
- How it is used
- Uses LLMs as the decision-making core of agents that interpret requests and choose actions.
- How deep it goes
- Explains next-token prediction and generalization, then compares model selection and tool-free performance without detailing training implementation.
- Examples
- Illustrates prediction with a vacation sentence and compares model accuracy and self-assessment on 20 GAIA problems.
- What you can do after
- Evaluate/understand when an LLM needs tools and when simpler logic may be preferable.
Read how Build an AI Agent (From Scratch) explains language model →
Crack Any Codebase with AI
A large language model is a machine-learning model trained on large amounts of text to generate and transform language from prompts.
- How it is used
- Turns repository questions into repeatable API-driven workflows for mapping architecture and investigating code.
- How deep it goes
- Explains context limits, repository filtering, file triage, and staged analysis, but stops short of model-training internals.
- Examples
- Uses Flask, Django, VS Code, HuggingFace Transformers, and a two-phase crawl-and-select pipeline as concrete repository examples.
- What you can do after
- Operate/configure an LLM through an API to filter repositories, select files, and generate layered architectural analyses.
Read how Crack Any Codebase with AI explains language model →
Build a Large Language Model (From Scratch)
A large neural language model trained on text to understand and generate language, typically using transformer self-attention.
- How it is used
- Frames language generation as a pipeline from text preparation through transformer prediction, pretraining, evaluation, and task-specific fine-tuning.
- How deep it goes
- Explains parameters, next-token prediction, tokenization, transformer modules, and training stages, while deferring detailed self-attention implementation.
- Examples
- Uses translation completion, ChatGPT-style assistants, GPT-3 datasets, token sampling, and zero-shot or few-shot task prompts.
- What you can do after
- Build it from scratch by preparing text, implementing attention and a GPT-like model, pretraining it educationally, and fine-tuning task behavior.
Read how Build a Large Language Model (From Scratch) explains language model →
Digital Twins in Action
A large language model is a machine-learning model trained on large text corpora to process and generate natural language, optionally incorporating visual inputs.
- How it is used
- Uses LLMs as contextual interfaces and agents for querying and acting on digital twin state.
- How deep it goes
- Explains grounding, supervisory control, and cost tradeoffs without detailing LLM training or implementation.
- Examples
- Illustrates equipment-specific answers for a pump and a cost comparison between a home energy agent and a rule engine.
- What you can do after
- Evaluate LLM use for a digital twin by considering context, safety boundaries, and inference cost.
Hugging Face in Action
A large language model is a high-capacity neural model trained on large text corpora to process and generate language.
- How it is used
- Connects pretrained or hosted language models to application workflows, prompts, private data, retrieval systems, and tools.
- How deep it goes
- Defines training, parameters, and tokens, then demonstrates API-based use; it stops short of neural-network mathematics and model construction.
- Examples
- Demonstrates question answering, translation, invoice and receipt queries, private-document retrieval, and tabular-data analysis.
- What you can do after
- Build it from scratch with LangChain or LlamaIndex, then operate local or hosted models in question-answering and private-data workflows.
A Pythonic Adventure: From Python basics to a working web app
A language model is a computational model trained on text or other language data to represent patterns and relationships in language.
- How it is used
- Uses language models as assistants for generating answers and improving Python code.
- How deep it goes
- Explains training on text, word relationships, and text similarity, but stops short of detailed model internals.
- Examples
- Uses Python list indexing, error explanations, code review, comments, and the Paris–France/Madrid–Spain analogy.
- What you can do after
- Apply it via ChatGPT to explain errors, review code, suggest fixes, and generate programming answers, while reviewing and testing the results.
Read how A Pythonic Adventure: From Python basics to a working web app explains language model →
Snowflake Data Engineering
A large language model is a model trained to process, generate, and transform human language.
- How it is used
- Augments Snowflake pipelines by classifying reviews and extracting structured order data from unstructured text.
- How deep it goes
- Defines LLMs and details prompting, stored-procedure calls, data-frame conversion, persistence, and output evaluation without model internals.
- Examples
- Uses bakery reviews and order emails, including CSV extraction into COLLECTED_ORDERS_FROM_EMAIL and ambiguous French-bread requests.
- What you can do after
- Apply it via Snowflake Cortex functions and stored procedures to convert email content into reviewable Snowflake table rows.
Read how Snowflake Data Engineering explains language model →
AI-Powered Developer: Build software with ChatGPT and Copilot
A large language model is a deep learning model trained to process and generate human language and other text-like sequences.
- How it is used
- Accelerates software tasks through natural-language generation, debugging suggestions, refactoring, documentation, and exploratory examples.
- How deep it goes
- Defines LLMs and sketches training, parameters, Transformers, and self-attention while deferring deeper neural-network theory.
- Examples
- Uses Flask scaffolding, Python session management, memory-leak analysis, code refactoring, and a Dash stock-price dashboard.
- What you can do after
- Apply it via AI tools to draft, inspect, refine, and verify code while protecting sensitive data.
Read how AI-Powered Developer: Build software with ChatGPT and Copilot explains language model →
Data-Driven Cybersecurity
A neural model trained on extensive text data to predict and generate language.
- How it is used
- Uses language models to generate synthetic cybersecurity data, analyze incidents, and support security reporting.
- How deep it goes
- Works through model-selection criteria and an analysis pipeline rather than language-model internals.
- Examples
- Shows a synthetic-data pipeline and an incident exercise with a frequency chart and generated response table.
- What you can do after
- Apply it via LM Studio or a cloud API to analyze cybersecurity data, then verify outputs before acting.
Read how Data-Driven Cybersecurity explains language model →
Microsoft Azure in Action
A large language model is a machine-learning model trained on large text corpora to generate or transform natural-language content.
- How it is used
- Powers book recommendations, summaries, content creation, and conversational applications through Azure OpenAI Service.
- How deep it goes
- Explains selection trade-offs and input limits, then shows deployment and invocation rather than model internals.
- Examples
- Uses customer-review recommendations, technical-book summaries, an AI Foundry model comparison, and an Azure CLI completions request.
- What you can do after
- Apply it via Azure AI Foundry and Azure CLI to select, deploy, test, and invoke a model for text tasks.
Read how Microsoft Azure in Action explains language model →
Domain-Specific Small Language Models
A very large neural language model trained on broad text corpora to predict or generate language, used here for code generation and assistance.
- How it is used
- Frames choices between general-purpose generation, domain specialization, and production inference.
- How deep it goes
- Explains model tradeoffs, memory estimation, and latency benchmarking, but does not develop model training from scratch here.
- Examples
- Uses GPT-Neo for resource estimates and GPT-2 variants for a serving-oriented latency comparison.
- What you can do after
- Evaluate/understand model choices by comparing specialization needs, memory demands, and measured inference latency.
Read how Domain-Specific Small Language Models explains language model →
Enterprise RAG
A large language model is a machine-learning model trained on extensive text data to understand and generate natural language.
- How it is used
- Deploys as the answer-generating component in enterprise RAG, where retrieval quality, latency, consistency, and uncertainty affect trust.
- How deep it goes
- Explains hallucination as plausible but false generation, while stopping short of model internals or implementation procedures.
- Examples
- Uses product availability, product features, and an airline chatbot promise to illustrate factual and legal failure modes.
- What you can do after
- Evaluate outputs for factuality, communicate limitations, and design retrieval-backed responses with graceful no-answer behavior.
Writing for Developers: Blogs that get read
A machine-learning model trained on large text corpora to predict and generate natural-language sequences.
- How it is used
- Uses generative AI to uncover omissions and logical gaps in engineering blog drafts before focused peer review.
- How deep it goes
- Defines association-based behavior and demonstrates prompting, but stops short of explaining model internals or generation mechanics.
- Examples
- Uses ChatGPT feedback on an engineering blog post and prompts about logical gaps, problems, and paragraphs needing detail.
- What you can do after
- Apply it via a generative-AI tool to identify possible draft omissions, then judge which suggestions deserve revision.
Read how Writing for Developers: Blogs that get read explains language model →
AI Agents in Action, Second Edition
A large language model is a machine-learning model that generates and interprets language using patterns learned from extensive text data.
- How it is used
- Uses language models as text generators and reasoning components within tool-using agents.
- How deep it goes
- Explains training, tokenization, next-token probabilities, sampling, and alignment without descending into detailed model internals.
- Examples
- Uses a constrained time-travel story prompt and an internal-versus-public search workflow.
- What you can do after
- Evaluate and understand how prompting, token measurement, and generation settings influence model output and cost.
Read how AI Agents in Action, Second Edition explains language model →
Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI
A large language model is a machine-learning model trained on large text corpora to understand and generate language sequences.
- How it is used
- Supports text-processing and tabular-data workflows as an assistant for feature engineering, coding, analysis, visualization, and reporting.
- How deep it goes
- Explains major task categories and practical analytics uses, but does not detail training procedures or model internals.
- Examples
- Uses textual dataset fields, Python functions, regular expressions, CSV files, charts, tables, and generated analytical reports as concrete applications.
- What you can do after
- Apply it via ChatGPT's Advanced Data Analytics API to preprocess, analyze, visualize, and summarize CSV data.
Read how Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI explains language model →
Learn AI Data Engineering
A large language model is a machine-learning model trained on large text corpora to understand and generate language and related sequences such as code.
- How it is used
- Supports coding assistance and pipeline enrichment for language-based, unstructured, or variable-source data tasks.
- How deep it goes
- Explains practical prompting, schema-guided extraction, validation, cost, and fallback decisions rather than model internals.
- Examples
- Demonstrates sentiment-label enrichment for news articles and schema-constrained product extraction from cleaned HTML.
- What you can do after
- Apply it via an API as a validated pipeline step for classification or structured extraction.
Read how Learn AI Data Engineering explains language model →
AI for Everyday IT
A generative AI model that produces textual content from learned language patterns and inputs.
- How it is used
- Uses language models to assist with IT support, document handling, and routine management work.
- How deep it goes
- Defines language models as learned-pattern text generators and surveys applications, without explaining model internals.
- Examples
- Illustrates use with product documentation, scanned documents, technical translation, and management meeting minutes.
- What you can do after
- Apply language-model chatbots to support IT writing and documentation tasks while retaining human judgment.
Spring AI in Action
A large language model is a machine-learning model trained on extensive text data to understand and generate natural-language content.
- How it is used
- Uses LLMs to add natural-language generation, question answering, classification, summarization, moderation, and conversational capabilities to Spring applications.
- How deep it goes
- Explains prompt submission, client abstraction, statelessness, memory, and tool interactions, but does not descend into model-training internals.
- Examples
- Demonstrates question answering, sentiment analysis, summarization, moderation, classification, image descriptions, conversation history, and tool results.
- What you can do after
- Apply it via Spring AI by building a REST-backed ChatClient service that submits prompts and returns generated content.
AI Agents for Offensive Security
A large language model is a machine-learning model trained on large text corpora to interpret and generate natural language.
- How it is used
- Interprets security artifacts such as scanner output into structured insights, anomaly cues, and suggested next steps.
- How deep it goes
- Defines token prediction and operational limitations, then defers autonomous behavior to agent orchestration, memory, and tools.
- Examples
- Uses log summarization, code rewriting, attack-surface description, and scanner or API-output interpretation as examples.
- What you can do after
- Evaluate/understand when generated security interpretations require validation and controlled agent-pipeline boundaries.
Read how AI Agents for Offensive Security explains language model →
Data Pipelines with Apache Airflow, Second Edition
A large language model is a machine learning model trained on extensive text data to understand and generate natural-language text.
- How it is used
- Generates recipe answers from retrieved documents after an Airflow-supported data-preparation workflow makes family recipes searchable.
- How deep it goes
- Explains text corpora, compares fine-tuning with retrieval, and shows an application call; does not detail model architecture or training algorithms.
- Examples
- Uses a family-recipe chat, a chocolate-cookie question, translation, ingredient-based suggestions, and a Python retrieval-chain listing.
- What you can do after
- Apply it via AzureChatOpenAI and a retrieval chain to answer questions using recipes stored in a vector database.
Read how Data Pipelines with Apache Airflow, Second Edition explains language model →
Grokking Bayes
- How it is used
- Shows how Bayesian probability applies to building and refining large language models.
- How deep it goes
- Explains probabilistic next-word prediction and contextual conditioning, then defers the calculation of conditional probabilities.
- Examples
- Uses possible continuations of “Bayesian probability” to contrast plausible predictions with an unlikely one.
- What you can do after
- Understand how next-word prediction uses probabilities and context, and how this relates to Bayesian thinking.
Transformers in Action
A large language model is a neural language model trained on large text corpora to predict and generate natural-language sequences.
- How it is used
- Frames LLMs as transformer-based systems for tasks from translation to content generation.
- How deep it goes
- Explains architectural variants and training strategies, then demonstrates inference without deriving the full training procedure.
- Examples
- Uses a freedom-symbol prompt for text generation and audio prompts for music analysis and speech transcription.
- What you can do after
- Apply it through tokenization, model generation, and output decoding for a trained model.
LLM Evaluation and Alignment, The Foundational Ideas
A large language model is a neural language model trained on large text corpora to generate or evaluate natural-language content.
- How it is used
- Generates natural-language text and supplies the behavior evaluated and aligned for production AI systems.
- How deep it goes
- Defines probabilistic next-token generation and discusses evaluation, hallucination, alignment, and reward modeling, but does not detail model architecture.
- Examples
- Uses summarization, full-response preference comparisons, pirate roleplay, sycophancy, and confident hallucinations as concrete cases.
- What you can do after
- Evaluate model behavior against accuracy, reliability, edge cases, and human goals, then identify alignment or mitigation needs.
Read how LLM Evaluation and Alignment, The Foundational Ideas explains language model →
Data Storytelling with Altair and AI
A large language model is a neural language model with many learned parameters that generates or transforms text based on input context.
- How it is used
- Uses LLMs to generate textual context, especially commentaries and annotations for audience-calibrated data stories.
- How deep it goes
- Defines prediction and transformer foundations, then stops short of explaining how LLMs work technically.
- Examples
- Demonstrates ChatGPT-generated commentaries and annotations, domain-tailored models, vector-database retrieval, and a fabricated political scandal.
- What you can do after
- Apply ChatGPT for data-story context, extend it with fine-tuning or RAG, and validate generated content before publication.
Read how Data Storytelling with Altair and AI explains language model →
AI Agents in Action
A large language model is a neural language model trained on extensive text data to generate and transform natural-language content.
- How it is used
- Uses language models to generate content and power chatbots, assistants, and agents.
- How deep it goes
- Defines data, architecture, use-case training, and fine-tuning, and describes transformer scaling to billions of parameters.
- Examples
- Illustrates chat completions with ChatGPT and describes API access and local use with LM Studio.
- What you can do after
- Apply language models through the OpenAI API SDK or local tools such as LM Studio.
Building Specialized AI Systems
A large language model trained to perform a broad range of tasks rather than being specialized for one domain.
- How it is used
- Supports broad language tasks before organizations choose specialized models or adaptation strategies.
- How deep it goes
- Explains parameters, tokens, training phases, and adaptation methods, but stops short of detailed architecture implementation.
- Examples
- Uses GPT-4, Claude 3 Opus, LLaMA 2 70B, tokens, and a two-phase training pipeline as concrete examples.
- What you can do after
- Evaluate model scale, generality, training stages, and trade-offs before selecting specialization or fine-tuning.
Read how Building Specialized AI Systems explains language model →
Automating API Delivery
A large language model is a machine-learning model trained on extensive text data to generate and transform natural-language or code-based content.
- How it is used
- Supports coding assistance and automated API linting when conventional rules are difficult or costly to write.
- How deep it goes
- Explains training, transformers, language capabilities, and linting workflows, but defers model internals and requires output validation.
- Examples
- Uses coding assistants, Claude prompts, monetary OpenAPI properties, pagination checks, and Optic LintGPT configuration.
- What you can do after
- Apply it via Anthropic Claude or Optic’s LintGPT to generate code suggestions or lint OpenAPI documents with natural-language rules.
MongoDB 8.0 in Action, Third Edition
A large language model is a machine learning model with many parameters trained to process and generate natural language.
- How it is used
- Supports chatbots, customer support, and technical assistance by generating natural-language responses from learned patterns.
- How deep it goes
- Explains pattern-based generation, hallucinations, and the eight-step RAG workflow without detailing model internals.
- Examples
- Uses chatbot, customer-support, and technical-assistance scenarios grounded in retrieved documents.
- What you can do after
- Apply RAG to generate responses informed by retrieved, verified information and reduce hallucinations.
Read how MongoDB 8.0 in Action, Third Edition explains language model →
AI Governance
A large language model is a machine-learning model trained on large text corpora to process and generate natural language.
- How it is used
- Frames natural-language interpretation as a source of instruction-injection exposure in GenAI deployments.
- How deep it goes
- Explains weight-based behavior and fine-tuning-related safety degradation, but offers no method for inspecting model weights.
- Examples
- Uses an email-summary prompt, the EchoLeak attack, and fine-tuning studies to illustrate model risks.
- What you can do after
- Understand why prompts resist rigid command-data separation and why fine-tuning can weaken safety behavior.
Just Use Postgres!
An LLM is a large language model trained to understand and generate natural-language text.
- How it is used
- Powers question answering, chatbots, task automation, and RAG-based movie recommendations.
- How deep it goes
- Explains capabilities, tool use, prompt context, and statelessness, but stops short of model internals or mathematical treatment.
- Examples
- Uses a DreamWorks movie question, a Postgres movie catalog, and a TinyLlama RAG notebook prototype.
- What you can do after
- Builds a prompt-based application that invokes an LLM with user questions and retrieved context.
Build a DeepSeek Model (From Scratch)
A neural language model that learns statistical patterns from large text corpora to generate and understand human language.
- How it is used
- Generates text during inference by predicting the next token from learned statistical relationships.
- How deep it goes
- Explains pretraining, inference, Transformer components, and efficiency-oriented replacements, but defers complete production-scale training.
- Examples
- Uses a travel-plan prompt, GPT-style Transformer systems, and a scaled-down DeepSeek implementation as concrete examples.
- What you can do after
- Build it from scratch by implementing core language-model architecture and training innovations in a scaled-down model.
Read how Build a DeepSeek Model (From Scratch) explains language model →
Build a Text-to-Image Generator (from Scratch)
A language model is a model that processes or generates human language, typically as sequences of text.
- How it is used
- Uses autoregressive sequence generation to turn encoded text prompts into image-token sequences for image synthesis.
- How deep it goes
- Traces tokenization, BART encoding, autoregressive decoding of 256 image tokens, and VQGAN reconstruction without detailing language-model internals.
- Examples
- Follows a text prompt through BART to 256 image tokens, then decodes them into a high-resolution image.
- What you can do after
- Understand how autoregressive language-model-style decoding can generate image tokens from a text prompt.
Read how Build a Text-to-Image Generator (from Scratch) explains language model →
Everyday Data Visualization
A large language model is a machine-learning model trained on extensive text data to process and generate human language.
- How it is used
- Uses large-language models to generate realistic test data for visualization prototypes when real data is unavailable.
- How deep it goes
- Defines the model through a practical use case but stops short of explaining training, architecture, or language-generation internals.
- Examples
- Uses a ChatGPT-generated survey containing two respondents, three questions, and numerical rating responses.
- What you can do after
- Apply via ChatGPT to generate structured, realistic test data for prototypes before production data becomes available.
Read how Everyday Data Visualization explains language model →
Data for All
A model is a computational or mathematical representation of relationships in data that transforms inputs into estimates, classifications, or predictions.
- How it is used
- Uses historical data and related features to predict future business processes and environments.
- How deep it goes
- Explains training data, feature inputs, and maintenance after abrupt shifts, but does not detail model internals.
- Examples
- Uses COVID-19 disruption and seasonal or holiday behavior shifts to illustrate prediction changes.
- What you can do after
- Evaluate model reliability as behavior shifts and recognize when retraining, recalibration, or rebuilding may be needed.
Build a Website with ChatGPT
A large language model is a machine-learning model trained on extensive text data to generate and transform natural-language content.
- How it is used
- Uses language generation and transformation to support conversational requests for web-page content and code.
- How deep it goes
- Explains the name GPT, pretraining, next-word prediction, and transformers without descending into model implementation details.
- Examples
- Uses essays, stories, poems, web-page code, and next-word prediction as concrete examples.
- What you can do after
- Apply it via conversational interfaces to request natural-language content or web-page code.
Read how Build a Website with ChatGPT explains language model →
Authorization in Action
A large language model is a machine-learning model trained on extensive text data to process and generate language.
- How it is used
- Supports policy creation, analysis, explanation, and incident triage without becoming the final authorization decision point.
- How deep it goes
- Explains advisory uses and authority boundaries, but stops short of model internals or generative-model implementation.
- Examples
- Uses policy explanation, hypothetical access exploration, flagged-event grouping, tenant identification, and incident-narrative drafting.
- What you can do after
- Diagnose access patterns with language-model summaries while preserving authoritative findings in deterministic checks and human review.
Kafka for Architects
Inference is the generation of model predictions from input data using a trained machine-learning model.
- How it is used
- Uses trained models to generate predictions from fresh event data in real-time applications.
- How deep it goes
- Explains data preparation, train/test evaluation, and serving predictions, but stops short of algorithm internals.
- Examples
- Uses ad-click prediction and fraud detection to illustrate model targets and real-time inference.
- What you can do after
- Apply it via a deployed model server to produce predictions from incoming event data.
Statistics Every Programmer Needs
A mathematical model represents relationships in a system using mathematical structures to analyze or predict its behavior.
- How it is used
- Uses mathematical models to support decisions by optimizing outcomes, forecasting behavior, or simulating possible scenarios.
- How deep it goes
- Defines models as decision tools and sketches objectives and constraints through linear programming.
- Examples
- Uses supply chains, transportation, manufacturing, and portfolio construction as optimization applications.
- What you can do after
- Understand how objectives and constraints turn resource-limited decisions into an optimization problem.
Read how Statistics Every Programmer Needs explains language model →
Retrieval Augmented Generation, The Foundational Ideas
A language model generates or evaluates sequences of natural-language tokens.
- How it is used
- Generates grounded responses from retrieved evidence within a real-time RAG query pipeline.
- How deep it goes
- Explains generation, grounding, and production limitations, but stops short of model architecture or training internals.
- Examples
- Uses warranty-support questions, company policy documents, and the Air Canada failure to illustrate generation risks.
- What you can do after
- Diagnose outdated knowledge, hallucination, and private-data gaps, then assess whether retrieval and grounding address them.
Read how Retrieval Augmented Generation, The Foundational Ideas explains language model →
Building Reliable AI Systems
A model that represents patterns in language to predict or generate sequences of text.
- How it is used
- Provides language understanding and generation as the passive core that agents extend with tools and actions.
- How deep it goes
- Defines its practical role and production limits, but does not explain model internals or training.
- Examples
- Uses flight search and booking, plus a customer request combining image understanding, product search, and return-policy lookup.
- What you can do after
- Evaluate standalone language models by distinguishing text understanding and generation from external action.
Read how Building Reliable AI Systems explains language model →
Building LLM Applications with DSPy
A language model is a machine-learning model that generates or evaluates language based on textual context.
- How it is used
- Configures the language model used by subsequent DSPy calls.
- How deep it goes
- Defines the LM object and explains model selection and configuration, without detailing model internals.
- Examples
- Configures gpt-4o-mini and describes trial-and-error prompt testing for article summaries.
- What you can do after
- Apply it via DSPy by creating an LM object and configuring it for subsequent calls.
Read how Building LLM Applications with DSPy explains language model →
Also covered in
- Math and Architectures of Deep Learning
- Grokking Machine Learning
- Classic Computer Science Problems in Swift: Essential techniques for practicing programmers
- Causal Inference for Data Science
- Collaborative Software Design: How to facilitate domain modeling decisions
- Optimization Algorithms: AI techniques for design, planning, and control problems
- Experimentation for Engineers
- Grokking Machine Learning, Second EditionIn early access (MEAP)
- Designing Deep Learning Systems: A guide for software engineers
- Demand Forecasting Best Practices
- Acing the CCNA Exam: Volume 2 Advanced Networking and Security
- Machine Learning Algorithms in Depth
What to know first
- machine learningMachine learning is a field of computational methods in which systems learn patterns or relationships from data to make predictions, decisions, or other outputs.
- ChatGPTChatGPT is OpenAI’s conversational AI service, which lets users interact with generative AI models and related tools through natural-language prompts.
- embeddingAn embedding is a numerical vector representation of an item in a feature space, encoding selected properties or relationships for computational tasks such as comparison or retrieval.
- PythonPython is a high-level, general-purpose, dynamically typed programming language with readable syntax and support for multiple programming paradigms.
Related concepts
- retrieval-augmented generationused by · Retrieval-augmented generation is a technique that retrieves relevant information from external sources and supplies it as context to a generative model when producing an output.
- promptused by · A prompt is text or other input supplied to an AI model to provide instructions, context, or other information that guides its response or generated output.
- AI agentused by · An AI agent is a computational system that uses artificial intelligence to interpret information and select or perform actions toward goals while interacting with an environment.
- generationproduces · Generation is the production of an output by a computational model from supplied input or context, often using patterns learned from data.
- ChatGPTincludes · ChatGPT is OpenAI’s conversational AI service, which lets users interact with generative AI models and related tools through natural-language prompts.
- machine learningkind of · Machine learning is a field of computational methods in which systems learn patterns or relationships from data to make predictions, decisions, or other outputs.
Questions about language model
What is language model?
A language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
Which Manning books explain language model?
Software Testing with Generative AI, LLMs in Production, How Large Language Models Work, Natural Language Processing in Action, Second Edition, Introduction to Generative AI, Second Edition, Deep Learning with R, Third Edition, Grokking AI Algorithms, Second Edition, The Art of AI Product Development and 81 more.
What should I know before learning language model?
Manning books that teach language model usually introduce machine learning, ChatGPT, embedding and Python first.
What kinds of language model are there?
Kinds of language model include ChatGPT.
What is language model a kind of?
Language model is a kind of machine learning. Machine learning is a field of computational methods in which systems learn patterns or relationships from data to make predictions, decisions, or other outputs.
What is language model also called?
Language model is also called LM or lms.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
























































































