What you will learn in Machine Learning Platform Engineering
Build an internal developer platform for ML and AI systems
Chapter by chapter
Chapter 1: Getting started with MLOps and ML engineering
The chapter introduction sets out a practical, project-based path from ML experimentation to production systems.
What you learn in chapter 1 →Chapter 2: What is MLOps?
The chapter introduction frames MLOps around the gap between a useful model and a reliable ML system, then previews the iterative life cycle and the chapter’s scope.
What you learn in chapter 2 →Chapter 3: Building applications on Kubernetes
This chapter introduces the infrastructure tools and practices that support reliable ML systems, from packaging applications to deploying, automating, and monitoring them.
What you learn in chapter 3 →Chapter 4: Designing reliable ML systems
This introduction maps the tools in a small ML platform, focusing the chapter on MLflow experiment tracking and Feast feature storage while previewing deployment and monitoring.
What you learn in chapter 4 →Chapter 5: Orchestrating ML pipelines
This introduction explains why MLflow and Feast need pipeline orchestration and previews an income-classification batch inference workflow built with Kubeflow Pipelines.
What you learn in chapter 5 →Chapter 6: Productionizing ML models
The chapter introduces production deployment with BentoML and data drift monitoring with Evidently, using the income classification model as its running example.
What you learn in chapter 6 →Chapter 7: Data analysis and preparation
This introduction explains why data preparation matters and previews how Kubeflow notebooks and pipelines will be used for two capstone ML projects.
What you learn in chapter 7 →Chapter 8: Model training and validation: Part 1
This chapter introduction shifts the pipeline from data preparation to reproducible model training and validation, using object detection as the main example.
What you learn in chapter 8 →Chapter 9: Model training and validation: Part 2
The chapter introduces production-oriented ways to manage pipeline data, observe training, and trace model versions in the ID card detection and movie recommendation projects.
What you learn in chapter 9 →Chapter 10: Model inference and serving
The chapter introduces the move from trained, validated models to serving them as APIs, outlines the BentoML deployment path, and explains the value and limits of self-service deployment.
What you learn in chapter 10 →Chapter 11: Monitoring and explainability
This chapter introduces operational monitoring, data drift detection, and explainability as ways to keep deployed ML services reliable and understand their decisions.
What you learn in chapter 11 →Chapter 12: Designing LLM-powered systems
The chapter introduces LLMOps as an extension of existing MLOps infrastructure and previews building an observable RAG application before hardening it for production.
What you learn in chapter 12 →Chapter 13: Production LLM system design
This chapter introduction explains why production LLM applications need disciplined prompt management, semantic evaluation, safety controls, and cost monitoring beyond traditional ML practices.
What you learn in chapter 13 →Concepts explained in this book
- monitoringLogging is the recording of timestamped events, states, and diagnostic information produced by a software system.
- KubeflowKubeflow Pipelines is a Kubeflow component and software development kit for defining, executing, and orchestrating machine-learning pipelines.
- validationModel validation is the process of evaluating a trained machine learning model on data or tests intended to estimate its performance and suitability.
- MLflowMLflow is an open-source platform for managing the machine learning lifecycle, including experiment tracking, model packaging, registry, and deployment.
- driftData drift is a change over time in the statistical distribution or characteristics of input data relative to the data used to develop a model.
- language modelA large language model is a neural language model trained on extensive text data to generate or transform natural-language content.
- performanceAn evaluation metric is a quantitative measure of the quality, relevance, correctness, or safety of a model output or retrieval result.
- prompt injectionA jailbreaking attempt is an effort to bypass a language model's safety constraints or guardrails through specially crafted inputs.
- experiment trackingAn experiment tracker is a software component that records machine-learning experiment configurations, results, and artifacts.
- mlopsMLOps is the practice of applying software engineering, automation, and operational processes to develop, deploy, and maintain machine-learning systems.
- retrieval-augmented generationRetrieval-augmented generation is a method that supplies retrieved external information to a generative model when producing an output.
- pipeline componentA pipeline component is a discrete, executable stage in a machine learning workflow that can consume and produce data artifacts.
- MinIOMinIO is an open-source object-storage server that provides an Amazon S3-compatible interface for storing unstructured data.
- object detectionObject detection is a computer-vision task that identifies objects in an image or other visual input and locates them with bounding regions.
- experimentationA/B testing is a controlled comparison of two or more variants by assigning them to different users or inputs and measuring their outcomes.
- versioningThe systematic recording and management of changes to files, code, or other managed artifacts over time.
- LangfuseLangfuse is an observability and analytics tool for tracing, evaluating, and monitoring large language model applications.
- provenanceData lineage is the record of an artifact's origins, transformations, dependencies, and movement through a data or machine-learning workflow.
- guardrailA safety filter is a model-level mechanism that blocks or restricts generated content belonging to configured harmful-content categories.
- pipelineAn orchestrated pipeline is a coordinated sequence of automated data and machine learning workflow steps, including iteration and dependencies.
- dsl.component decoratorThe dsl.component decorator is a Kubeflow Pipelines Python decorator that converts a function into a pipeline component and configures its execution environment.
- BentoMLBentoML is an open-source framework for packaging and serving machine learning models as production APIs.
- promptA system prompt is an instruction supplied to a language model to establish its role, behavioral constraints, and response requirements.
- YOLOv8YOLOv8n is the nano-sized YOLOv8 model variant designed to reduce computation and memory requirements.
- model registryA model registry is a centralized system for storing, versioning, and promoting machine learning models across deployment stages.
- BentoML serviceA BentoML service is an application object that defines model-serving logic and exposes it through API endpoints.
- token limitA token budget is a limit on the number of language-model tokens allocated to an input, output, or operation.
- train_test_splittrain_test_split is a scikit-learn function that partitions arrays or datasets into random training and test subsets.
- feature storeA feature store is a system that centrally stores, manages, and serves curated machine-learning features for training and inference.
- BentoML runnerA BentoML runner is a unit of computation that executes on Python worker processes and can be scaled independently within a service.
- deploymentThe process of releasing software into an environment where it can execute and serve its intended users or workloads.
- dataset splitDataset splitting is the partitioning of a dataset into subsets for separate training, validation, testing, or other processing purposes.
- prompt managementPrompt management is the controlled creation, versioning, evaluation, and deployment of prompts for language-model applications.
- prompt engineeringPrompt engineering is the deliberate design and refinement of inputs provided to generative models to influence their outputs.
- bentoA Bento is a unified package and file format that bundles a machine-learning application, its model, serving logic, dependencies, and configuration.
- async/awaitAsync/await is a programming-language feature for expressing asynchronous operations in a sequential-looking form.
- streamingResponse streaming delivers generated output incrementally as it becomes available instead of waiting for the complete response.
- similarity searchRetrieval is the process of finding and returning relevant information from a collection or information store.
- Kubernetes resourceA Kubernetes object is a declarative resource record that describes the desired or observed state of an application or infrastructure component.
- MIDV-500MIDV-500 is a dataset of video clips depicting multiple types of identity documents for document analysis and detection tasks.
- Ultralytics YOLO formatThe Ultralytics YOLO format is a dataset organization and annotation convention used by Ultralytics YOLO models for object detection.
- FeastAn open-source feature store for managing and serving machine learning features consistently across training and inference.
- G-EvalG-Eval is an evaluation technique that uses a large language model to judge another model’s outputs against natural-language criteria.
- vector databaseA vector database is a database system that stores numerical vector representations and supports similarity-based retrieval.
- machine learning workflowThe end-to-end sequence of activities through which a machine learning solution progresses from problem formulation and experimentation through deployment, operation, and retirement.
- evaluationModel evaluation is the measurement of a trained model's performance on data separate from the data used for fitting.
- podA Kubernetes pod is the smallest deployable execution unit, encapsulating one or more containers that share network and storage resources.
- meanLatency is the elapsed time between a request or input and the corresponding response or output.
- interpretabilityModel interpretability is the degree to which a model's behavior and predictions can be understood by people or analysis methods.
- multi-step reasoningA multistep reasoning chain is an orchestrated sequence of intermediate operations that transforms a user query into a final model response.
- PromptfooPromptfoo is an open-source tool for testing and evaluating prompts and large language model applications, including systematic safety probing.
- dashboardA dashboard is a visual interface that presents queried operational measurements and other status information.
- vector indexA vector index is an indexing structure that organizes numerical vector representations to support efficient similarity search.
- trainingModel training is the process of fitting a machine learning model to data by optimizing its parameters according to a training objective.
- model artifactA model artifact type is a KFP artifact type representing a trained machine-learning model and its framework-specific metadata.
- vectorizationAn embedding model is a machine learning model that maps inputs such as text or images to numerical vector representations.
- ChainlitChainlit is an open-source Python framework for building conversational user interfaces for language-model applications.
- templateA user prompt template is a parameterized structure for formatting user-provided content into a language-model request.
- object storeAn object store is a storage system that manages data as objects identified by keys, typically including their content and metadata.
- Helm chartA Helm chart is a packaged collection of Kubernetes resource templates and configuration values used to define an application deployment.
- FAISSFAISS is a software library for efficient similarity search and clustering of dense numerical vectors.
- natural language interfaceA chat interface is an interaction interface that exchanges conversational messages between a user or client and an AI application.
- sanitizationInput sanitation is the validation, filtering, and normalization of externally supplied data before it is processed by a system.
- jobA Kubernetes job is a workload resource that runs a task to completion and terminates after the task succeeds.
- asynchronous generatorAn async generator is a Python construct that asynchronously yields a sequence of values as they become available.
- lazy initializationLazy initialization is a pattern that postpones expensive resource creation or setup until the resource is first needed.
- separation of concernsSeparation of concerns is a software design principle that isolates distinct responsibilities into separate components or layers.
- Singleton patternThe singleton pattern restricts a component to one shared instance and provides a common access point to it.
- tracking serverA tracking server is a service that centrally records and provides access to machine learning experiment parameters, metrics, data references, and artifacts.
- feature retrievalFeature retrieval is the process of obtaining the feature values required for model training or inference at a specified entity and time.
- containerA software container is an isolated, portable execution unit that packages an application with its dependencies.
- rollbackA rollback is the restoration of a deployed application to a previously functioning version.
- DockerDocker is a platform and toolset for building, packaging, distributing, and running containerized applications.
- Evidently AIEvidently is an open-source tool for evaluating, testing, and monitoring machine-learning models and data.
- endpointAn API endpoint is a network-accessible interface that receives requests and returns responses according to an API contract.
- evaluation datasetA validation dataset is a held-out dataset used to assess or tune a model during development.
- AlertmanagerAlertmanager is the Prometheus component that groups, routes, and delivers alerts to notification channels.
- PromQLPromQL is Prometheus's query language for selecting, aggregating, and transforming time-series data.
- observabilityObservability is the ability to infer the internal state and behavior of a deployed system from its outputs and telemetry, including application-specific information flows.
- kubectlkubectl is the command-line client for communicating with the Kubernetes API and managing cluster resources.
- PrometheusPrometheus is an open-source monitoring system that collects, stores, and queries time-series metrics.
- KubernetesKubernetes is an open-source platform for automating the deployment, scaling, scheduling, and management of containerized applications.
- hallucinationA hallucination is generated content that is unsupported by the available evidence or factually incorrect despite being presented as an answer.
- traceabilityTraceability is the ability to follow an artifact or result back to its originating inputs, configurations, and processing steps.
- LLM applicationAn LLM application is a software system whose functionality uses a large language model to process inputs and produce outputs.
- Kubernetes DeploymentA Deployment is a Kubernetes resource that declaratively manages application updates, scaling, and the ReplicaSets underlying its pods.
- ReplicaSetA Kubernetes ReplicaSet is a controller that maintains a specified number of identical pod replicas.
- rolling updateA rolling update is a gradual replacement of running application instances with instances of a newer version while maintaining service availability.
- ParquetApache Parquet is a column-oriented, binary file format designed for efficient storage and retrieval of structured data.
- data driftDrift detection is the identification of changes in data distributions or related model-serving conditions over time.
- reproducibilityReproducibility is the ability to obtain consistent results when repeating an operation under the same inputs, configuration, and environment.
- preprocessingData preparation is the process of cleaning, transforming, organizing, and otherwise making data suitable for model development.
- reference datasetA reference dataset is a feature dataset containing the features associated with users across the training and testing populations.
- machine learning infrastructureAn integrated set of infrastructure and services that supports the development, deployment, orchestration, and operation of machine learning workloads.
- health checkA diagnostic test that determines whether a service or execution unit is functioning and able to handle requests.
- text chunkA text splitter is a component that divides text into smaller chunks according to specified or semantic boundary rules.
- nondeterminismNondeterminism is behavior in which identical inputs can produce different valid outputs across executions.
- model architectureA model architecture is the structural design of a machine learning model, including its computational components and their arrangement.
- metric endpointA metrics endpoint is an HTTP endpoint that exposes an application's operational measurements for collection by a monitoring system.
- attributionSource attribution is the association of generated or retrieved information with the documents or sources that support it.
- bentoml runnableA BentoML base class for defining runnable units of model or application computation.
- liveness checkA periodic check that determines whether a running workload should be restarted because its process is no longer healthy.
- multi-runner serviceA service architecture that composes multiple independently executable BentoML runners into one workflow.
- readiness checkA periodic check that determines whether a workload is ready to receive traffic.
- alertingAlerting is the process of generating and delivering notifications when monitored application, system, or infrastructure conditions require attention.
- Model ServingA model serving framework is software that packages, exposes, operates, and scales machine learning models for inference.
- component specificationA component specification is a declarative definition of a pipeline component's inputs, outputs, container image, command, and arguments.
- parameterizationParameterization is the practice of exposing configurable values so behavior can be customized without changing implementation code.
- cost optimizationCost optimization is the systematic reduction of computational and operational expenses while maintaining required system performance and quality.
- Guardrails AIGuardrails AI is a framework for defining and applying validators that check, constrain, and correct generative-model inputs and outputs.
- token countToken usage is the quantity of language-model input and output tokens consumed during an interaction or application operation.
- containerized Python componentA containerized Python component is a Kubeflow pipeline component whose dependencies and code run in a built container image.
- counterA counter is a monotonically nondecreasing metric intended to count occurrences such as requests.
- histogramA histogram is a metric that counts observations in predefined value buckets for distributional analysis.
- pay-per-token pricingA token-based cost model prices language-model usage according to the number or type of input and output tokens processed.
- metadataKubernetes metadata is the descriptive portion of an object definition containing identity and organizational information such as names and labels.
- scalabilityThe ability of a system to maintain suitable operation as workload volume or resource demand increases.
- serviceA Kubernetes service is an abstraction that provides stable network access to a changing set of pods.
- automationAutomation is the execution of workflow activities by systems rather than through repeated manual intervention.
- detectionHallucination detection is the identification of generated claims that are fabricated, unsupported, or absent from trusted context.
- input guardAn input guard is a pre-processing protection component that screens or transforms user input before model processing.
- OnFailActionOnFailAction is a Guardrails AI failure-handling setting that specifies what a validator does when content violates its criteria.
- output guardAn output guard is a post-processing protection component that checks or transforms generated responses before delivery.
- personal dataPersonally identifiable information is information that can identify or be used to identify an individual.
- PII detectionPersonally identifiable information detection is the identification of information that can identify an individual in text or other content.
- validatorA validator is a software component that evaluates content against defined criteria and may reject, modify, regenerate, or allow it.
- batch sizeA batch size is the number of training samples processed in one iteration of model training.
- learning rateA learning rate is a training hyperparameter that controls the step size used to update model parameters during optimization.
- configmapA Kubernetes ConfigMap is an API object that stores non-sensitive configuration data as key-value pairs for consumption by workloads.
- recommender systemA recommendation system is a software system that predicts or ranks items, content, or actions for users or other entities.
- machine learningMachine learning is the computational discipline of learning patterns from data to make predictions or decisions.
- context windowA context window is the maximum amount of tokenized input and output that a language model can process in one interaction.
- DeepEvalDeepEval is an open-source evaluation framework for testing and measuring the quality of large language model applications.
- testA testing loop is an iterative procedure that evaluates a model on test inputs during or between training steps.
- RetrieverA retrieval component is a system stage that finds information relevant to a query and supplies it to downstream processing.
- bentofile.yamlA bentofile.yaml file is a declarative BentoML configuration file specifying a service, included files, dependencies, labels, and environment variables for building a Bento.
- migrationExtract-transform-load is a data-processing technique that extracts data from sources, transforms it, and loads it into a target system.
- temperatureTemperature is a generation setting that adjusts how strongly token selection favors high-probability alternatives.
- samplingA sampling strategy is a rule for selecting generated tokens from a model's probability distribution.
- Deepchecksdeepchecks is an open-source Python library for validating and monitoring the quality, integrity, and behavior of machine-learning data and models.
- datasetA dataset is a collection of data instances, optionally paired with labels for supervised learning.
- Wasserstein distanceWasserstein distance is a measure of dissimilarity between probability distributions based on the minimum cost of transforming one distribution into another.
- evaluatorLLM-as-judge is an evaluation technique in which one large language model assesses the outputs of another model.
- security boundary testingSecurity boundary testing evaluates whether an AI application appropriately restricts responses and access at sensitive security boundaries.
- LLMOpsLLMOps is the set of engineering and operational practices for developing, deploying, monitoring, and managing large language model applications.
- clusterip service typeA ClusterIP service is a Kubernetes service that provides an internal cluster-scoped IP address for accessing selected pods.
- loadbalancer serviceA LoadBalancer service is a Kubernetes service that provisions or uses an external load balancer to expose selected pods to external clients.
- node portA NodePort service is a Kubernetes service that exposes an application through a designated port on each cluster node.
- DirectoryLoaderDirectoryLoader is a document-loading component that recursively discovers files in directories and converts them into standardized document objects.
- distanceA distance metric is a function that quantifies separation between vectors in a mathematical space.
- embedding wrapperAn embedding wrapper is an adapter that presents a stable application interface around an embedding provider's API.
- cosine similarityCosine similarity measures the angular alignment of two vectors independently of their magnitudes.
- RecursiveCharacterTextSplitterRecursiveCharacterTextSplitter is a text-splitting utility that recursively divides documents at progressively smaller structural boundaries.
- task-specific embeddingsTask-specific embeddings are vector representations optimized differently for distinct input types, such as document content and search queries.
- training datasetData used to fit the parameters of a machine learning model.
- LangChainLangChain is a software framework for building applications that compose language models with prompts, tools, retrieval, and other processing components.
- LangGraphLangGraph is a framework extension for orchestrating language-model applications as graphs with branching, loops, and stateful transitions.
- continuous deploymentContinuous deployment is a software-delivery practice that automatically releases verified changes to a target execution environment.
- semantic evaluationSemantic correctness is the degree to which generated content conveys the intended meaning accurately.
- time to first tokenTime-to-first-token is the elapsed time from a request until the first generated token is delivered to the user.
- data annotationAn annotation is metadata attached to an input example that identifies or describes a target property for machine learning.
- retrainingModel retraining is the process of training a machine-learning model again using newly available or updated data.
- metricA custom metric is an application-defined quantitative measurement exposed for monitoring a specific behavior or outcome.
- batchingMicrobatching is the processing of a small group of newly arrived inputs together for analysis or computation.
- Kubernetes namespaceA Kubernetes namespace is a logical partition within a cluster for organizing and isolating resource names and workloads.
- gaugeA gauge is a metric whose value can increase or decrease to represent a current level or quantity.
- GrafanaGrafana is an open-source observability and dashboard platform for querying, visualizing, and exploring operational data.
- scrapingMetrics scraping is the periodic retrieval of metric data from an application's exposed endpoint.
- service discoveryService discovery is the automatic identification of available application services and their network locations.
- starlette_exporterstarlette_exporter is a Python library that exposes basic metrics for Starlette-based web applications.
- time-series databaseA time-series database stores measurements indexed by time so that temporal queries and retrieval are efficient.
- run identifierA run identifier is a unique identifier assigned to a particular machine learning experiment run.
- data passingComponent data passing is the transfer of parameters and data artifacts between executable stages of a machine learning pipeline.
- runtime prompt resolutionRuntime prompt resolution is the pattern of retrieving a deployed prompt and its configuration during request processing rather than embedding the prompt in application code.
- boundary promptA boundary prompt is a fallback prompt that provides guidance when a request is outside an application's supported knowledge domain.
- artifact typeAn artifact type is the base KFP type for generic files and data outputs that do not fit a specialized artifact category.
- dataset artifact typeA dataset artifact type is a KFP artifact type representing machine-learning datasets and their associated metadata.
- metrics artifact typeA metrics artifact type is a KFP artifact type that stores numerical measurements as key-value data.
- epochAn epoch is one complete pass through the training dataset during model training.
- cachingA caching strategy is a method for storing and reusing computational results to avoid repeating expensive processing.
- productionThe live execution environment in which a software system or machine-learning model serves real users or business workloads.
- TensorBoardTensorBoard is a visualization and experiment-tracking tool for inspecting machine-learning metrics, graphs, and artifacts.
- dashboard panelDashboardPanelPlot is an Evidently dashboard component that displays a measurement as a plot.
- data drift presetDataDriftPreset is an Evidently preset that generates a report for detecting distributional changes across dataset columns.
- data drift reportA data drift report is a generated analysis that compares feature distributions in reference and current datasets and reports statistical test results.
- metric presetA metric preset is a prebuilt Evidently report definition that aggregates metrics for a specific analysis use case.
- projectAn Evidently project is an organizational container for dashboard configuration, data snapshots, and monitoring results.
- snapshotA data snapshot is a persisted representation of data captured at a particular point in time.
- GitLab PipelinesGitLab CI is a continuous integration and continuous delivery service for automating software build, test, and deployment workflows.
- Kubeflow notebookA Kubeflow notebook is a web-accessible interactive development environment that runs notebook or code-editor workloads on a Kubeflow cluster.
- environment variableAn environment variable is a named value supplied through a process environment to configure or provide information to an application.
- semantic cachingSemantic caching is a caching method that reuses results for inputs judged equivalent or sufficiently similar in meaning rather than identical in text.
- Kubernetes SecretA Kubernetes Secret is an API object for storing and supplying sensitive data to workloads.
- context assemblyContext assembly is the organization, formatting, and combination of retrieved information into context suitable for a language model.
- DockerfileA Dockerfile is a text file containing instructions for building a Docker image and configuring the application environment inside it.
- model selectionModel selection is the process of choosing among candidate machine learning models or architectures based on their suitability and measured performance.
- MLflow clientThe programmatic MLflow interface for logging machine-learning runs, parameters, metrics, artifacts, and model information.
- top-k samplingTop-K sampling generates each token by restricting selection to the K most probable next tokens.
- top-p filteringTop-P sampling generates each token from the smallest set of candidates whose cumulative probability reaches a specified threshold.
- deployment pipelineContinuous integration is a software-development practice that automatically builds and verifies changes as they are integrated into a shared codebase.
- LLM gatewayAn LLM gateway is an intermediary service that routes language-model requests across providers or models while applying provider-specific policies.
- confidenceA confidence score is a model-produced value indicating the estimated certainty of a particular prediction or detection.
- manual evaluationManual inspection is the deliberate examination of a model's outputs and behavior on selected inputs.
- red-teamingAdversarial testing is the deliberate evaluation of a system with challenging, manipulative, or harmful inputs to expose weaknesses.
- autologgingAutologging is the automatic recording of model parameters, metrics, artifacts, and related information during machine learning training and evaluation.
- decision treeA decision tree is a predictive model that recursively partitions input data using feature-based decision rules.
- categorical encodingOne-hot encoding is a technique that represents each value of a categorical variable with a separate binary indicator feature.
- random forestA random forest is an ensemble model that combines predictions from multiple decision trees trained with randomized sampling or feature selection.
- XGBoostAn XGBoost model is a gradient-boosted decision-tree model trained using the XGBoost algorithm.
- absent functionThe absent function is a PromQL function that returns a value indicating whether a specified metric is absent from queried data.
- up metricThe up metric is a Prometheus metric whose value indicates whether a monitored target is successfully providing scrape data.
- privacyThe protection of information about individuals or sensitive entities from inappropriate disclosure or use.
- securitySecurity is the protection of software, models, data, and infrastructure from unauthorized access, misuse, compromise, or attack.
- machine learning systemA software system that incorporates machine learning models and the data, computation, and operational components required to deliver their outputs.
- problem definitionProblem formulation is the process of translating a real-world objective into a precisely defined machine learning problem with suitable inputs, outputs, and success criteria.
- affinityA Kubernetes affinity configuration expresses scheduling preferences or requirements that influence which nodes may run a pod.
- base imageA base image is the foundational Docker image whose filesystem and metadata are used as the starting point for another image.
- offline storeAn offline store is a persistent repository of historical machine-learning features intended for batch access and model training.
- online storeAn online store is a feature-storage system optimized for low-latency retrieval of current feature values during inference.
- data leakageData leakage is the unintended inclusion or reuse of information in a dataset that compromises valid model development or evaluation.
- machine learning engineeringMachine learning engineering that satisfies the reliability, maintainability, and operational requirements of production systems.
- RedisVLRedisVL is a library for building Redis-based vector search and semantic caching applications.
- error propagationError propagation analysis identifies how failures introduced at one processing stage affect subsequent stages and final outputs.
- resource utilizationResource utilization is a measurement of the computational resources consumed by a running application, such as CPU, memory, or capacity.
- heuristicA heuristic is a rule-based method that produces a practical solution without learning a model from data.
- Artifact HubArtifact Hub is a repository service for discovering and distributing Helm charts and other cloud-native artifacts.
- HelmHelm is a package manager for defining, installing, upgrading, and managing applications on Kubernetes.
- Kubernetes object templateA Kubernetes object template is a parameterized YAML definition of a Kubernetes object with customizable properties.
- values.yaml fileA Helm values file is a configuration file containing values that customize templates in a Helm chart.
- Kubernetes manifestA Kubernetes manifest is a declarative document that specifies the desired state of one or more Kubernetes resources.
- pytestpytest is a Python testing framework for writing and running automated tests.
- yqyq is a command-line processor for querying and modifying YAML documents.
- persistent volume claimA persistent volume claim is a Kubernetes resource that requests storage with specified capacity and access characteristics for use by workloads.
- trajectoryTracing is the recording and correlation of operations across a system to reveal execution paths, timings, and intermediate results.
- synthetic dataSynthetic data is artificially generated data designed to resemble observations from a target domain.
- ImagePropertyDriftImagePropertyDrift is a deepchecks analysis that compares distributions of image properties between reference and current vision datasets.
- MonitoringServiceMonitoringService is a BentoML service component that maintains a window of observed data and generates monitoring reports when configured conditions are met.
- share of drifted featuresShare of drifted features is the proportion of monitored feature columns whose distributions are identified as having drifted.
- bentoml buildbentoml build is a BentoML command that builds a Bento from its application definition and dependencies.
- data analysisData analysis is the systematic examination and interpretation of data to discover patterns, assess quality, and support decisions.
- data collectionData collection is the process of acquiring data relevant to a defined modeling problem and its target domain.
- DakkaBotDakkaBot is an internal documentation assistant for querying company documentation with natural language.
- MLflow UIThe MLflow UI is a web interface for browsing experiments, runs, parameters, metrics, datasets, and artifacts recorded by MLflow.
- structured dataStructured data is data organized according to a defined schema that makes its fields and relationships machine-readable.
- fine-tuningFine-tuning is the additional training of a pretrained model on task-specific data to adapt its behavior to a new task or domain.
- hyperparameter tuningHyperparameter optimization is the process of selecting hyperparameter values by evaluating configurations within a defined search space against an objective such as a loss function.
- object detection modelAn object detector is a machine learning model that identifies object instances and estimates their locations in visual input.
- container imageA Docker image is a packaged, executable filesystem containing an application and its dependencies for creating containers.
- PodMonitorA PodMonitor is a Prometheus Operator custom resource that specifies how to discover pods and scrape their exposed metrics.
- data qualityData quality is the degree to which data is accurate, complete, consistent, timely, valid, and fit for its intended purpose.
- YOLOYOLO is a family of real-time object-detection models that predict object classes and locations from an image in a single inference pass.
- model-based explainabilityA model-based explanation is an explanation method that derives an account of predictions from the internal structure or behavior of the predictive model.
- latent spaceA latent space is a learned lower-dimensional representation space in which entities are positioned according to underlying characteristics inferred by a model.
- directed acyclic graphA directed acyclic graph is a graph whose directed edges connect nodes without forming any cycle.
- Kubeflow runA Kubeflow run is one execution instance of a Kubeflow pipeline.
- batch inferenceBatch inference is the process of applying a trained machine-learning model to a finite collection of inputs in grouped execution rather than one request at a time.
- ArgoCDArgo CD is a declarative continuous delivery tool that synchronizes Kubernetes application resources with desired-state definitions stored in a version-controlled repository.
- fallbackA fallback strategy defines an alternative provider, model, or execution path used when the preferred path fails or cannot satisfy a request.
- training-serving skewTraining-serving skew is a discrepancy between the feature transformations or data seen during model training and those applied during inference.
- advanced ragA composite RAG system is a retrieval-augmented application assembled from multiple cooperating components such as embedding, retrieval, generation, and interface stages.
- context utilizationContext utilization measures the portion of an available language-model context window that provides useful information.
- input/output token ratioAn input/output token ratio compares the number of input tokens processed with the number of output tokens generated.
- YataiYatai is the BentoML component for deploying, operating, scaling, and monitoring machine-learning services on Kubernetes.
- factualityFactual accuracy is the degree to which generated content agrees with verifiable facts.
- OCROptical character recognition is the automated extraction of written or printed text from images.
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.