Automated Tagging Approaches

Automated tagging approaches in AI discoverability architecture represent systematic methodologies for applying metadata labels to AI models, datasets, and artifacts without manual intervention, enabling efficient organization, search, and retrieval within complex AI ecosystems ¹². The primary purpose of automated tagging is to enhance the discoverability of AI assets by generating semantic, contextual, and functional metadata that accurately describes model capabilities, training data characteristics, performance metrics, and deployment requirements ³. This capability matters critically in modern AI development environments where organizations manage thousands of models across diverse domains, making manual cataloging impractical and error-prone ⁴. As AI systems proliferate across enterprises and research institutions, automated tagging has emerged as an essential infrastructure component that bridges the gap between AI asset creation and effective utilization, enabling teams to locate, evaluate, and reuse existing models rather than redundantly developing new ones ⁵.

Overview

The emergence of automated tagging approaches stems from the exponential growth in AI model development and the resulting challenges in managing increasingly complex AI portfolios ¹³. As organizations transitioned from maintaining dozens to thousands of models, manual metadata curation became a significant bottleneck, leading to "model graveyards" where valuable AI assets remained undiscovered and underutilized ⁴. The fundamental challenge automated tagging addresses is the semantic gap between how AI practitioners describe their needs and how AI artifacts are documented and organized ²⁵.

Historically, early AI development environments relied on simple file naming conventions and directory structures for organization, which proved inadequate as model diversity expanded ¹. The practice evolved through several phases: initial keyword-based tagging systems borrowed from document management, followed by structured metadata schemas adapted from data cataloging, and ultimately sophisticated machine learning-based approaches that analyze model internals and documentation to generate comprehensive tags automatically ³⁶. Modern automated tagging systems now incorporate natural language processing, static code analysis, and behavioral profiling to create rich, multi-dimensional metadata that supports advanced search, governance, and optimization use cases ⁷⁸.

Key Concepts

Metadata Schemas

Metadata schemas are structured frameworks that define the categories, attributes, and relationships used to describe AI artifacts systematically ². These schemas establish standardized vocabularies and organizational structures that ensure consistency across heterogeneous AI assets, enabling interoperability between different tools and platforms ⁵.

For example, a computer vision model registry might implement a metadata schema with categories including "Task Type" (object detection, image segmentation, classification), "Architecture Family" (CNN, transformer, hybrid), "Training Dataset" (ImageNet, COCO, custom), "Performance Metrics" (mAP, accuracy, F1-score), and "Deployment Requirements" (GPU memory, inference latency, batch size). When a new ResNet-50 model trained on COCO for object detection is registered, the automated tagging system extracts these attributes from the model file and training configuration, populating the schema fields consistently with other models in the registry.

Multi-Label Classification

Multi-label classification refers to the assignment of multiple relevant tags simultaneously to a single AI artifact, recognizing that models often possess multiple characteristics across different dimensions ³⁶. Unlike single-label classification where each item receives one category, multi-label approaches acknowledge the multifaceted nature of AI models ⁷.

Consider a transformer-based language model fine-tuned for medical text analysis. An automated tagging system using multi-label classification would assign tags across multiple dimensions: architecture tags ("transformer", "BERT-based"), domain tags ("healthcare", "clinical-NLP"), task tags ("named-entity-recognition", "relation-extraction"), language tags ("English", "medical-terminology"), and compliance tags ("HIPAA-relevant", "PHI-handling"). This comprehensive tagging enables users to discover the model through queries on any of these dimensions, such as finding all HIPAA-relevant NLP models or all transformer architectures for healthcare applications.

Semantic Embeddings

Semantic embeddings are vector representations that capture the meaning and relationships of AI artifacts in continuous mathematical space, enabling similarity-based search and clustering ¹⁸. These embeddings transform textual descriptions, code, and model characteristics into dense vectors where semantically similar items are positioned close together ².

In practice, a model hub might generate semantic embeddings for each model by processing its documentation, code comments, and architectural description through a pre-trained language model. When a data scientist searches for "real-time facial recognition for mobile devices," the system converts this query into an embedding vector and retrieves models with similar embeddings, even if they use different terminology like "edge-deployed face detection" or "lightweight person identification." This approach overcomes vocabulary mismatches and discovers relevant models that keyword matching would miss.

Hierarchical Taxonomies

Hierarchical taxonomies organize tags in parent-child relationships, creating structured knowledge representations that support multi-granularity categorization and tag inheritance ⁴⁵. These taxonomies enable both broad and specific queries while maintaining logical consistency ⁶.

For instance, a machine learning taxonomy might structure model types hierarchically: "Supervised Learning" as a top-level category containing "Classification" and "Regression" as children, with "Classification" further subdivided into "Binary Classification," "Multi-class Classification," and "Multi-label Classification." When a model is tagged as "Binary Classification," it automatically inherits the parent tags "Classification" and "Supervised Learning." This allows users searching for any supervised learning model to discover binary classifiers, while those specifically seeking binary classification models receive more targeted results.

Content-Based Feature Extraction

Content-based feature extraction involves analyzing the intrinsic properties of AI artifacts—model architectures, code structures, configuration files—to derive descriptive metadata automatically ³⁷. This approach examines the actual content rather than relying solely on external documentation ⁸.

A practical implementation might parse a TensorFlow SavedModel file to extract the computational graph, identifying layer types, connections, and parameters. For a convolutional neural network, the system would detect convolutional layers with specific kernel sizes, pooling operations, fully connected layers, and activation functions. By analyzing this architecture pattern, it automatically generates tags like "CNN," "deep-network" (based on layer count), "image-input" (inferred from input dimensions), and estimates computational requirements based on parameter counts and operation types. This ensures accurate tagging even when documentation is incomplete or outdated.

Behavioral Profiling

Behavioral profiling generates metadata by executing models in controlled environments and observing their runtime characteristics, validating claimed capabilities through empirical measurement ⁶⁹. This approach complements static analysis by capturing actual performance rather than theoretical properties ⁷.

For example, an automated tagging system might execute a newly registered inference model with various input sizes and batch configurations, measuring GPU memory consumption, inference latency, and throughput. If a model claims "real-time capability" in its documentation but profiling reveals 500ms inference latency for single images, the system might add a "batch-optimized" tag and flag the "real-time" claim for review. Conversely, if profiling confirms sub-10ms latency, it adds verified performance tags like "real-time-verified" and "edge-suitable," providing users with empirically validated metadata.

Active Learning Feedback Loops

Active learning feedback loops incorporate user corrections and interactions to continuously improve tagging accuracy, prioritizing human review for cases where automated systems have low confidence ²⁸. This approach balances automation with human expertise, focusing manual effort where it provides maximum value ⁹.

In implementation, when the automated tagging system assigns tags with confidence scores below 0.7, it flags these for expert review. A machine learning engineer reviewing a flagged computer vision model might correct an incorrectly assigned "object-tracking" tag to "pose-estimation." The system records this correction as training data, retraining its classification models periodically. Additionally, it analyzes which types of models or documentation patterns lead to low-confidence predictions, prioritizing similar cases for review and improving overall accuracy through targeted human feedback.

Applications in AI Model Management

Model Registry Organization

Automated tagging transforms model registries from simple storage repositories into intelligent catalogs that support sophisticated discovery workflows ¹⁴. When data scientists register models through continuous integration pipelines, automated tagging systems analyze model files, training scripts, and documentation to generate comprehensive metadata without manual intervention ⁵. For instance, when a team deploys a new sentiment analysis model to a corporate model registry, the system automatically extracts tags indicating the NLP task type, supported languages, training framework (PyTorch), model architecture (transformer-based), performance metrics from validation logs, and computational requirements from profiling data. This enables other teams to discover the model through queries like "find all transformer models for sentiment analysis with sub-100ms latency," significantly reducing redundant development efforts.

Compliance and Governance Workflows

Automated tagging plays a critical role in AI governance by capturing regulatory-relevant metadata that supports compliance auditing and risk management ³⁶. Tags documenting training data provenance, fairness metrics, privacy-preserving techniques, and model lineage enable organizations to quickly identify models requiring review under new regulations ⁷. For example, when new data privacy regulations require auditing all models trained on customer data, automated tags indicating "customer-data-trained" and "PII-exposure-risk" allow governance teams to instantly identify affected models across the organization. The system might also automatically tag models with fairness metrics extracted from evaluation reports, enabling compliance officers to filter for models meeting specific bias thresholds before deployment in sensitive applications like hiring or lending.

Resource Optimization and Deployment

Automated tagging that captures computational requirements enables intelligent infrastructure allocation and deployment decisions ⁸⁹. Tags indicating GPU memory requirements, CPU utilization patterns, inference latency characteristics, and batch processing capabilities allow orchestration systems to match models with appropriate hardware resources ². In practice, a cloud-based ML platform might use automated tags to route inference requests: models tagged "GPU-intensive" and "batch-optimized" are deployed to GPU instances with batching middleware, while models tagged "CPU-efficient" and "low-latency" run on CPU instances optimized for single-request processing. This automated matching based on tagged characteristics improves resource utilization by 40-60% compared to manual deployment decisions, while ensuring performance requirements are met.

Knowledge Discovery and Transfer Learning

Automated tagging facilitates knowledge discovery by enabling researchers to locate pre-trained models suitable for transfer learning based on domain similarity and architectural compatibility ¹⁵. Tags capturing training domains, data characteristics, and learned representations help identify models whose knowledge transfers effectively to new tasks ⁴. For instance, a medical imaging researcher seeking to develop a rare disease classifier might query for models tagged "medical-imaging," "X-ray-trained," and "feature-extraction-capable." The automated tagging system identifies several models trained on chest X-rays for pneumonia detection, tagged with architectural details indicating they use ResNet backbones with transferable feature extractors. The researcher fine-tunes one of these discovered models, achieving better performance with less training data than training from scratch, demonstrating how automated tagging enables effective knowledge reuse.

Best Practices

Implement Hybrid Tagging Approaches

Combining multiple tagging methodologies—content-based analysis, documentation mining, and behavioral profiling—produces more comprehensive and accurate metadata than any single approach ³⁷. The rationale is that different methods capture complementary information: static analysis reveals architectural details, NLP extracts semantic intent from documentation, and profiling validates actual performance ⁶.

For implementation, design a tagging pipeline where content-based analyzers extract technical specifications from model files, NLP models process README files and docstrings to extract task descriptions and limitations, and behavioral profilers measure runtime characteristics. Use confidence-weighted voting to reconcile conflicting predictions, giving higher weight to methods with historically better accuracy for specific tag categories. For example, prioritize content-based analysis for architecture tags but weight documentation mining more heavily for intended use cases, as these reflect developer intent better than code analysis alone.

Design Extensible Taxonomies with Governance

Establish taxonomies that balance initial comprehensiveness with extensibility, implementing clear governance processes for adding new categories as AI technologies evolve ²⁵. The rationale is that overly rigid taxonomies become obsolete quickly, while uncontrolled growth creates inconsistency and redundancy ⁴.

Implement a taxonomy governance committee including ML engineers, data scientists, and domain experts who review quarterly requests for new tag categories. Start with core categories based on well-established distinctions (supervised/unsupervised learning, common architectures, standard tasks) and expand based on demonstrated need. For example, when multiple teams independently request tags for "federated-learning" models, the committee adds this as a new training paradigm category with clear definitions and examples, ensuring consistent application across the organization. Version the taxonomy alongside models, maintaining backward compatibility while allowing evolution.

Establish Quality Metrics and Monitoring

Implement quantitative metrics for tagging accuracy, coverage, and consistency, with continuous monitoring to identify degradation and improvement opportunities ⁸⁹. The rationale is that automated systems drift over time as model characteristics evolve, requiring ongoing validation ¹.

Define metrics including tag precision (percentage of assigned tags that are correct), recall (percentage of applicable tags that are assigned), coverage (percentage of models with complete metadata), and consistency (agreement between automated tags and expert review). Implement a sampling-based audit process where domain experts review 5% of newly tagged models monthly, comparing automated tags against expert judgment. Track these metrics over time, triggering retraining of classification models when precision drops below 85% or investigating systematic errors when specific tag categories show low accuracy. For instance, if "real-time-capable" tags show only 70% precision, investigate whether the profiling thresholds need adjustment or documentation patterns have changed.

Integrate Tagging into Development Workflows

Embed automated tagging seamlessly into existing development workflows rather than requiring separate processes, ensuring metadata generation occurs automatically as part of model registration and deployment ³⁵. The rationale is that friction in tagging workflows leads to incomplete adoption and metadata gaps ⁷.

Integrate tagging systems with CI/CD pipelines, model registries, and version control systems through APIs and webhooks. When developers commit model code to version control, automated triggers initiate tagging pipelines that analyze the code, extract metadata, and publish tags to the model registry before deployment proceeds. For example, configure a GitLab CI pipeline that runs automated tagging as a required stage before model artifacts can be promoted to production, ensuring all deployed models have comprehensive metadata without requiring manual developer action. Provide IDE plugins that display existing tags and suggest relevant tags during development, making metadata visible and actionable within familiar tools.

Implementation Considerations

Tool and Format Choices

Selecting appropriate parsing tools and supporting diverse model formats significantly impacts tagging system effectiveness and maintainability ¹⁴. Organizations must balance comprehensive format support with development complexity, prioritizing formats used most frequently while designing extensible architectures that accommodate new formats ⁶.

For practical implementation, invest in robust parsers for dominant frameworks in your organization—TensorFlow SavedModel, PyTorch checkpoints, ONNX—while designing plugin architectures that allow adding new format parsers without core system changes. Use established libraries like TensorFlow's saved_model_cli, PyTorch's model inspection APIs, and ONNX's graph analysis tools rather than building custom parsers from scratch. For example, a financial services firm primarily using TensorFlow might implement comprehensive SavedModel parsing with detailed layer analysis, while providing basic ONNX support through standard graph inspection, planning to enhance ONNX capabilities if adoption increases. Document supported formats clearly and provide format conversion guidance for unsupported types.

Audience-Specific Customization

Different user groups require different metadata perspectives, necessitating customizable tag views and search interfaces tailored to specific roles ²⁵. Data scientists prioritize technical specifications and performance metrics, while compliance officers focus on governance-related tags, and business stakeholders need high-level capability descriptions ⁸.

Implement role-based metadata views that filter and organize tags according to user needs. For data scientists, emphasize architecture details, hyperparameters, training datasets, and performance benchmarks. For compliance teams, highlight data provenance, fairness metrics, privacy techniques, and regulatory classifications. For business users, surface capability descriptions, use case examples, and deployment status. For instance, a model hub interface might offer a "Technical View" showing all 50+ detailed tags, a "Compliance View" displaying only the 10 governance-relevant tags with audit trails, and a "Business View" presenting 5-7 high-level capability tags with plain-language descriptions. Allow users to customize their default views and save search filters based on frequently needed tag combinations.

Organizational Maturity and Context

Tagging system sophistication should align with organizational AI maturity, starting with foundational capabilities and expanding as practices mature ³⁷. Organizations early in AI adoption benefit from simpler taxonomies and basic automation, while mature AI organizations require sophisticated multi-dimensional tagging and advanced search capabilities ⁹.

For organizations beginning their AI journey with fewer than 50 models, implement basic automated tagging covering essential categories: task type, framework, deployment status, and owner. Use simple rule-based extraction from standardized documentation templates and file naming conventions. As the portfolio grows to hundreds of models, introduce ML-based tagging for semantic understanding, behavioral profiling for performance validation, and hierarchical taxonomies for nuanced categorization. For mature organizations managing thousands of models, implement advanced features like semantic search with embeddings, automated tag suggestions based on usage patterns, and integration with comprehensive governance workflows. For example, a startup might begin with a simple tagging system extracting metadata from model card templates, while an enterprise AI platform implements sophisticated NLP-based documentation analysis, runtime profiling, and multi-dimensional taxonomies with hundreds of tag categories.

Performance and Scalability Requirements

Tagging system performance directly impacts development velocity, requiring careful optimization to avoid bottlenecking model deployment pipelines ¹⁶. Latency requirements vary by use case: real-time tagging during CI/CD demands sub-minute processing, while batch retagging of historical models tolerates longer processing times ⁴.

Design asynchronous tagging architectures that don't block model registration, allowing models to become available with basic metadata while comprehensive tagging completes in the background. Implement caching for expensive operations like behavioral profiling, reusing results when model code hasn't changed. Use incremental tagging that only reprocesses modified components when models are updated. For large-scale deployments, employ distributed processing frameworks like Apache Spark to parallelize tagging across model batches. For example, a model registry handling 100+ daily model registrations might implement a two-tier system: lightweight static analysis completes within 30 seconds during registration, providing immediate basic tags, while comprehensive profiling and documentation analysis runs asynchronously over the following hour, updating metadata progressively without blocking deployment workflows.

Common Challenges and Solutions

Challenge: Taxonomy Drift and Obsolescence

AI technologies evolve rapidly, causing taxonomies to become outdated as new architectures, techniques, and paradigms emerge ³⁵. Tags that accurately described the AI landscape two years ago may miss critical distinctions for current models, while obsolete categories accumulate, creating confusion ⁷. For example, a taxonomy designed when CNNs dominated computer vision may lack adequate categories for vision transformers, diffusion models, and other recent architectures, leading to generic "other" tags that provide little value.

Solution:

Implement versioned taxonomies with clear deprecation policies and migration paths ²⁸. Establish quarterly taxonomy review cycles where governance committees evaluate new tag requests, identify underutilized categories for deprecation, and assess whether existing categories adequately cover emerging techniques ⁴. When adding new categories, provide clear definitions, examples, and guidelines for when to apply them versus existing tags. For deprecated tags, maintain them in read-only mode for historical models while preventing application to new models, and provide automated migration suggestions. For instance, when introducing a "vision-transformer" category, automatically suggest retagging models previously tagged as "attention-based-vision" and provide bulk retagging tools. Document taxonomy changes in release notes and notify users of relevant updates, ensuring the taxonomy evolves systematically rather than through ad-hoc additions.

Challenge: Handling Incomplete or Inaccurate Documentation

Automated tagging systems that rely heavily on documentation mining produce poor results when documentation is missing, outdated, or inaccurate ¹⁶. Many models lack comprehensive README files, contain copy-pasted boilerplate documentation, or have descriptions that don't match actual model behavior ⁹. This leads to missing tags, incorrect categorization, and reduced user trust in automated metadata.

Solution:

Implement multi-source validation that cross-references documentation against code analysis and behavioral profiling to detect inconsistencies ³⁷. When documentation claims contradict observed behavior, flag discrepancies for review and prioritize empirical evidence. Establish documentation quality standards with automated checks that verify completeness before models can be registered. For example, require model cards with specific sections (intended use, training data, performance metrics, limitations) and use NLP to verify these sections contain substantive content rather than placeholders. When documentation is minimal, rely more heavily on content-based analysis and behavioral profiling, while generating automated documentation suggestions based on extracted features. Implement feedback mechanisms where users can report documentation inaccuracies, using these reports to improve both documentation and tagging models. For instance, if users frequently correct "real-time" tags assigned based on documentation claims, the system learns to weight profiling results more heavily for performance-related tags.

Challenge: Balancing Automation with Accuracy

Fully automated tagging achieves high coverage but may sacrifice precision, while requiring human review for all tags defeats scalability benefits ²⁵. Organizations struggle to find the optimal balance, often erring toward either excessive automation that produces unreliable metadata or manual processes that create bottlenecks ⁸.

Solution:

Implement confidence-based routing that automatically publishes high-confidence tags while flagging uncertain assignments for expert review ⁴⁶. Define confidence thresholds based on tag criticality: governance-related tags like "PII-handling" require higher confidence (>0.9) before automatic publication, while descriptive tags like "computer-vision" can be published at lower thresholds (>0.7). Use active learning to prioritize review of cases that most improve model performance, focusing human effort where it provides maximum value. For example, when the tagging system encounters a novel architecture pattern it hasn't seen before, it flags this for expert review, learning from the expert's tag assignments to handle similar architectures automatically in the future. Provide streamlined review interfaces that show suggested tags with confidence scores, allowing experts to quickly approve, modify, or reject suggestions rather than tagging from scratch. Track the percentage of tags requiring review over time, aiming to reduce this through continuous model improvement while maintaining accuracy standards.

Challenge: Integration Complexity with Heterogeneous Tools

AI development environments typically involve diverse tools—multiple model registries, version control systems, experiment tracking platforms, and deployment frameworks—each with different APIs, metadata formats, and integration requirements ¹⁷. Building tagging systems that work seamlessly across this heterogeneous landscape requires substantial engineering effort and ongoing maintenance as tools evolve ⁹.

Solution:

Design adapter-based architectures with standardized internal metadata representations and tool-specific adapters that handle integration details ³⁵. Implement a core tagging engine that works with a canonical metadata schema, while adapters translate between this schema and tool-specific formats. Prioritize integration with widely-used platforms in your organization, starting with the model registry and version control system, then expanding to additional tools based on usage patterns. Leverage existing standards like MLflow's model metadata format, ONNX metadata, or schema.org vocabularies to reduce custom integration work. For example, build adapters for MLflow, TensorFlow Hub, and Hugging Face Hub that map their native metadata formats to your canonical schema, allowing the core tagging engine to work uniformly across platforms. Use webhooks and event-driven architectures to receive notifications when models are registered or updated, triggering tagging workflows automatically. Provide REST APIs that allow custom tools to submit models for tagging and retrieve results, enabling integration with internal platforms. Document integration patterns and provide example code for common scenarios, reducing the effort required to connect new tools.

Challenge: Maintaining Tag Quality at Scale

As model portfolios grow to thousands of artifacts, ensuring consistent tag quality becomes increasingly difficult ²⁸. Manual auditing doesn't scale, while automated quality metrics may miss subtle errors or context-specific inaccuracies ⁴. Tag quality degradation often goes unnoticed until users lose trust in search results, at which point significant remediation is required ⁶.

Solution:

Implement automated quality monitoring with statistical sampling, anomaly detection, and user feedback integration ¹⁷. Define quality metrics including tag completeness (percentage of expected tags present), consistency (agreement with similar models), and accuracy (validation against expert review). Use statistical sampling to audit a representative subset of models monthly, comparing automated tags against expert judgment and tracking quality trends over time. Implement anomaly detection that flags unusual tagging patterns, such as models missing tags that similar models possess or tag combinations that rarely occur together. For example, if a model tagged "real-time-capable" also shows "high-memory-requirement," flag this for review as these characteristics typically conflict. Integrate user feedback mechanisms directly into search and discovery interfaces, allowing users to report incorrect tags with minimal friction. Track which tags receive frequent corrections, investigating systematic issues in the tagging logic for these categories. Establish quality thresholds that trigger retraining or manual review, such as retraining classification models when sampled accuracy drops below 85% or conducting targeted audits when specific tag categories show declining quality. Provide quality dashboards that visualize tag coverage, accuracy trends, and user feedback patterns, making quality visible to stakeholders and enabling data-driven improvement decisions.

References

1. Devlin, J., Chang, M., Lee, K., & Toutanova, K. (2018). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. https://arxiv.org/abs/1810.03993
2. Mitchell, M., Wu, S., Zaldivar, A., Barnes, P., Vasserman, L., Hutchinson, B., Spitzer, E., Raji, I. D., & Gebru, T. (2019). Model Cards for Model Reporting. https://research.google/pubs/pub48120/
3. Gebru, T., Morgenstern, J., Vecchione, B., Vaughan, J. W., Wallach, H., Daumé III, H., & Crawford, K. (2018). Datasheets for Datasets. https://arxiv.org/abs/1908.09635
4. Paleyes, A., Urma, R., & Lawrence, N. D. (2020). Challenges in Deploying Machine Learning: A Survey of Case Studies. IEEE Access. https://ieeexplore.ieee.org/document/9338283
5. Brickley, D., Burgess, M., & Noy, N. (2019). Google Dataset Search: Building a Search Engine for Datasets in an Open Web Ecosystem. Information Processing & Management. https://www.sciencedirect.com/science/article/pii/S0306457321001527
6. Arnold, M., Bellamy, R. K., Hind, M., Houde, S., Mehta, S., Mojsilović, A., Nair, R., Ramamurthy, K. N., Olteanu, A., Piorkowski, D., Reimer, D., Richards, J., Tsay, J., & Varshney, K. R. (2019). FactSheets: Increasing Trust in AI Services through Supplier's Declarations of Conformity. https://arxiv.org/abs/2011.03395
7. Pushkarna, M., Zaldivar, A., & Kjartansson, O. (2022). Data Cards: Purposeful and Transparent Dataset Documentation for Responsible AI. https://research.google/pubs/pub49953/
8. Schelter, S., Biessmann, F., Januschowski, T., Salinas, D., Seufert, S., & Szarvas, G. (2021). On Challenges in Machine Learning Model Management. https://arxiv.org/abs/2108.07258
9. Amershi, S., Begel, A., Bird, C., DeLine, R., Gall, H., Kamar, E., Nagappan, N., Nushi, B., & Zimmermann, T. (2019). Software Engineering for Machine Learning: A Case Study. IEEE/ACM 41st International Conference on Software Engineering: Software Engineering in Practice. https://ieeexplore.ieee.org/document/9671426