Data Exchange Protocols

Data Exchange Protocols in AI Discoverability Architecture represent the standardized mechanisms and communication frameworks that enable AI systems, models, and datasets to be effectively discovered, accessed, and integrated across distributed environments ¹. These protocols serve as the foundational infrastructure for facilitating interoperability between heterogeneous AI systems, allowing researchers, developers, and automated agents to locate, evaluate, and utilize AI resources efficiently ². In an era where AI models and datasets are proliferating across organizations, cloud platforms, and research institutions, robust data exchange protocols are critical for preventing fragmentation and enabling collaborative AI development ³. The significance of these protocols extends beyond mere technical connectivity—they fundamentally shape how AI knowledge is shared, reused, and built upon within the broader AI ecosystem.

Overview

The emergence of Data Exchange Protocols in AI Discoverability Architecture reflects the exponential growth and diversification of AI resources across the research and industrial landscape ¹². As machine learning models evolved from isolated research experiments to production-critical assets deployed across distributed systems, the AI community confronted a fundamental challenge: how to make these proliferating resources discoverable, accessible, and reusable without creating fragmented silos ³. Early AI development operated largely in isolation, with models and datasets shared informally through academic publications or direct collaboration, creating significant barriers to reproducibility and knowledge transfer.

The fundamental challenge these protocols address is threefold: representation (how AI artifacts are described in machine-readable formats), transmission (how information flows efficiently between heterogeneous systems), and interpretation (how receiving systems understand and utilize exchanged data) ¹². Without standardized protocols, organizations face redundant development efforts, inability to leverage existing models, and significant friction in collaborative AI research. The problem intensifies as AI systems become more complex, incorporating multiple models, diverse datasets, and sophisticated pipelines that span organizational boundaries.

Over time, the practice has evolved from ad-hoc sharing mechanisms to sophisticated protocol ecosystems ³. Early efforts focused on simple model serialization formats and basic API endpoints. Contemporary approaches incorporate semantic metadata standards, federated discovery mechanisms, and comprehensive governance frameworks that address security, privacy, and compliance requirements ²³. This evolution reflects growing recognition that effective AI discoverability requires not just technical interoperability but also rich contextual information about model provenance, performance characteristics, ethical considerations, and usage constraints.

Key Concepts

Metadata Schemas

Metadata schemas are standardized structures that describe AI models and datasets using controlled vocabularies and consistent formats ¹. These schemas capture essential information including model architecture, training data provenance, performance metrics, computational requirements, licensing terms, and ethical considerations. Effective metadata schemas balance expressiveness—capturing sufficient detail about AI artifacts—with simplicity to ensure widespread adoption across diverse stakeholder communities ².

For example, a computer vision model registry might implement a metadata schema that includes fields for model architecture type (e.g., ResNet-50), training dataset characteristics (ImageNet subset with 1.2M images), performance metrics (top-5 accuracy of 92.1% on validation set), computational requirements (4GB GPU memory for inference), supported input formats (224x224 RGB images), and licensing information (Apache 2.0). This structured metadata enables automated discovery systems to match user requirements with appropriate models, while providing developers with the contextual information needed to evaluate model suitability for their specific use cases.

Model Cards and Dataset Cards

Model cards and dataset cards are structured documentation frameworks that provide comprehensive, human-readable descriptions of machine learning models and datasets respectively ¹². Model cards document critical information about model development, including intended use cases, training methodology, evaluation results across different demographic groups, known limitations, and ethical considerations. Dataset cards similarly describe dataset composition, collection methodology, preprocessing steps, potential biases, and recommended uses.

Consider a natural language processing model deployed for resume screening. Its model card would document that the model was trained on resumes from technology companies between 2015-2020, achieved 85% accuracy on held-out test data, but showed 12% lower accuracy for candidates from non-traditional educational backgrounds. The card would explicitly state that the model should not be used as the sole decision-making tool and requires human review, particularly for edge cases. This transparency enables responsible deployment and helps organizations understand potential biases and limitations before integration.

RESTful API Endpoints

RESTful API endpoints are programmatic access points that follow REST (Representational State Transfer) architectural principles for enabling standardized communication between AI systems ². These endpoints expose model inference capabilities, dataset access, metadata retrieval, and administrative functions through HTTP-based interfaces with predictable URL structures, standard HTTP methods (GET, POST, PUT, DELETE), and consistent response formats (typically JSON or XML).

A practical implementation might include a model serving platform that exposes /api/v1/models for listing available models, /api/v1/models/{model_id}/metadata for retrieving detailed model information, and /api/v1/models/{model_id}/predict for submitting inference requests. A developer could query the metadata endpoint to understand input requirements, then POST a JSON payload containing input data to the predict endpoint, receiving predictions in a standardized response format. This consistency enables automated integration and reduces the learning curve for developers working across multiple AI platforms.

Content Negotiation

Content negotiation is the mechanism by which clients and servers agree on the optimal data format and representation for exchanged information ²³. This protocol feature allows clients to specify preferred formats (JSON, XML, Protocol Buffers, etc.) through HTTP headers, enabling the same API endpoint to serve multiple client types with different technical requirements while maintaining a single implementation.

For instance, a dataset discovery service might support both JSON for web applications and Protocol Buffers for high-performance backend systems. A web-based data science workbench would include Accept: application/json in its request headers, receiving human-readable JSON responses suitable for browser rendering. Meanwhile, a distributed training system would specify Accept: application/x-protobuf, receiving the same data in a compact binary format that minimizes network overhead and parsing time. This flexibility enables protocols to serve diverse use cases without fragmenting the ecosystem into incompatible variants.

Semantic Annotations

Semantic annotations are machine-readable descriptions that use formal ontologies and controlled vocabularies to provide rich, structured meaning to AI artifacts ¹². These annotations leverage semantic web technologies like RDF (Resource Description Framework) and OWL (Web Ontology Language) to express relationships between concepts, enabling sophisticated reasoning and discovery capabilities beyond simple keyword matching.

A biomedical AI model repository might use semantic annotations to indicate that a particular model performs "protein structure prediction" (linked to a formal ontology concept), was trained on "X-ray crystallography data" (with relationships to data modality concepts), and is applicable to "drug discovery workflows" (connected to application domain concepts). When a researcher searches for models suitable for "small molecule binding prediction," the semantic reasoning system can identify this model as relevant even though the exact search terms don't appear in the model description, because the ontology defines relationships between protein structure prediction and molecular binding analysis.

Versioning and Provenance Tracking

Versioning and provenance tracking systems maintain comprehensive lineage information about AI artifacts, documenting their evolution over time and the processes that created them ¹³. These systems record model versions, training data snapshots, hyperparameter configurations, evaluation results, and dependencies on other artifacts, creating an auditable trail crucial for reproducibility, debugging, and compliance.

In a production machine learning pipeline, a fraud detection model might progress through versions 1.0 (initial release), 1.1 (retrained with additional data), and 2.0 (architecture change). The provenance system would record that version 1.1 was trained on dataset snapshot "fraud_data_2024_Q2" using training script version 3.2, consumed 47 GPU-hours, and improved precision by 3.2% while maintaining recall. When version 1.1 exhibits unexpected behavior in production, engineers can trace back to the exact training data, code, and configuration used, enabling rapid diagnosis and potential rollback to version 1.0 if necessary.

Authentication and Authorization Frameworks

Authentication and authorization frameworks manage identity verification and access control for AI resources, ensuring that only authorized users and systems can discover, access, or modify specific models and datasets ²³. These frameworks typically implement industry-standard protocols like OAuth 2.0 for delegated authorization, API keys for service authentication, and role-based access control (RBAC) for fine-grained permissions management.

A multi-tenant AI platform might implement a framework where data scientists authenticate using their corporate credentials through OAuth 2.0, receiving time-limited access tokens. These tokens encode the user's role (e.g., "data_scientist" or "model_reviewer") and organizational affiliation. When accessing a proprietary model, the authorization system checks whether the user's role and organization match the model's access control list. Public models remain discoverable to all authenticated users, while sensitive models trained on confidential data are visible only to specific teams, and production-deployed models allow inference access but restrict downloading of model weights to designated MLOps engineers.

Applications in AI Development and Deployment

Federated Model Discovery Across Research Institutions

Data exchange protocols enable federated discovery systems where multiple research institutions maintain independent model repositories while providing unified search capabilities ¹². Researchers at one institution can query across all participating repositories simultaneously, discovering relevant models regardless of their physical location. The protocol standardizes metadata formats and query interfaces, allowing a single search for "sentiment analysis models trained on social media data" to return results from university repositories, government research labs, and industry partners. This application dramatically reduces duplication of effort and accelerates research by making existing work more visible and accessible.

Automated Model Selection in MLOps Pipelines

In production machine learning operations, data exchange protocols enable automated model selection based on performance requirements and operational constraints ²³. An MLOps pipeline might programmatically query a model registry for classification models that achieve >90% accuracy on a specific validation dataset, support batch inference with <100ms latency, and fit within 2GB memory constraints. The protocol returns candidate models with detailed metadata, and the pipeline automatically selects the optimal model based on a multi-objective optimization considering accuracy, latency, and resource consumption. This automation reduces manual model selection effort and ensures consistent, data-driven deployment decisions.

Cross-Platform Model Portability

Data exchange protocols facilitate model portability across different deployment platforms and frameworks ¹³. A model trained using PyTorch can be registered in a protocol-compliant registry with standardized metadata and serialization format. Deployment systems built on TensorFlow Serving, ONNX Runtime, or cloud-specific platforms can discover this model through the protocol, retrieve it in a compatible format (potentially through automated conversion), and deploy it without manual intervention. This application is particularly valuable in hybrid cloud environments where models may need to move between on-premises infrastructure and multiple cloud providers based on cost, latency, or data residency requirements.

Compliance and Governance Automation

Organizations subject to AI regulations leverage data exchange protocols to automate compliance checking and governance workflows ²³. The protocol captures metadata about training data sources, model fairness metrics across demographic groups, and intended use cases. Automated governance systems query this metadata to verify that models meet regulatory requirements before production deployment. For example, a financial services firm might implement automated checks ensuring that credit scoring models include required fairness metrics, document training data provenance, and have completed bias testing before deployment. The protocol enables these checks to operate consistently across all models regardless of which team developed them or which tools were used.

Best Practices

Implement Comprehensive Metadata Standards

Organizations should adopt and rigorously implement comprehensive metadata standards that capture both technical and contextual information about AI artifacts ¹². The rationale is that rich metadata dramatically improves discoverability, enables informed decision-making, and supports governance requirements. Incomplete or inconsistent metadata creates friction in discovery, increases integration effort, and may lead to inappropriate model usage.

A specific implementation involves creating organizational metadata templates that extend industry standards like model cards with domain-specific fields. For a healthcare AI platform, this might include required fields for clinical validation status, applicable patient populations, contraindications, and regulatory clearances. The organization implements automated validation that prevents model registration without complete metadata, provides guided forms that help developers populate fields correctly, and maintains a metadata quality dashboard showing completion rates across teams. This systematic approach ensures consistent, high-quality metadata across the entire model portfolio.

Design for Backward Compatibility and Versioning

Protocol designers should implement semantic versioning and maintain backward compatibility to prevent breaking existing integrations as protocols evolve ²³. The rationale is that AI ecosystems involve numerous independent systems with different update cycles; breaking changes create significant friction and may prevent protocol adoption. Careful versioning enables innovation while protecting existing investments.

Implementation involves adopting semantic versioning (major.minor.patch) for protocol specifications, where major version changes indicate breaking changes, minor versions add backward-compatible functionality, and patches fix bugs. The protocol includes version negotiation in API requests, allowing clients to specify supported versions. When introducing new metadata fields, they are marked as optional with sensible defaults, ensuring older clients continue functioning. Deprecated features remain supported for at least two major versions with clear migration documentation. For example, when adding support for differential privacy metrics, these appear as optional fields in version 2.1, with version 2.0 clients simply ignoring them rather than failing.

Prioritize Security and Privacy by Design

Security and privacy considerations should be integrated into protocol design from the outset rather than added retroactively ²³. The rationale is that AI models and datasets often contain sensitive information or represent valuable intellectual property; inadequate security creates legal, competitive, and ethical risks. Privacy-preserving protocols enable broader sharing while protecting sensitive information.

A concrete implementation includes mandatory encryption for data in transit (TLS 1.3 or higher), support for encryption at rest for stored metadata, and fine-grained access control at the field level. The protocol implements differential privacy mechanisms for sharing aggregate statistics about datasets without exposing individual records. For example, a medical dataset registry might expose metadata showing that a dataset contains 50,000 patient records with specific demographic distributions, but the protocol adds calibrated noise to prevent inference about individual patients. Authentication uses short-lived tokens rather than long-lived credentials, and the protocol includes comprehensive audit logging that records all access attempts for security monitoring and compliance reporting.

Provide Multi-Language Client Libraries and Documentation

Protocol adoption depends critically on reducing integration friction through comprehensive client libraries and documentation ². The rationale is that developers work in diverse programming languages and frameworks; requiring manual protocol implementation creates barriers to adoption. Well-designed client libraries abstract protocol complexity and enable rapid integration.

Implementation involves developing and maintaining official client libraries in widely-used languages (Python, JavaScript, Java, Go, R) that handle authentication, request formatting, error handling, and response parsing. These libraries follow language-specific conventions and integrate naturally with popular frameworks. Documentation includes quick-start guides with complete working examples, API reference documentation generated from code, and use-case-specific tutorials. For instance, the Python client library might provide a high-level interface where client.models.search(task='image-classification', min_accuracy=0.9) returns a list of model objects with intuitive properties, while the documentation includes a Jupyter notebook demonstrating end-to-end model discovery, evaluation, and deployment.

Implementation Considerations

Selecting Appropriate Serialization Formats

Organizations must choose serialization formats that balance human readability, parsing efficiency, schema evolution support, and ecosystem compatibility ²³. JSON offers excellent human readability and universal language support, making it ideal for metadata and configuration. Protocol Buffers provide compact binary serialization with strong schema support, suitable for high-volume data transfer. Apache Avro offers schema evolution capabilities valuable for long-term data storage.

A practical approach implements content negotiation supporting multiple formats based on use case. Public-facing discovery APIs default to JSON for accessibility, while internal high-performance model serving uses Protocol Buffers. Dataset downloads support both formats, with JSON for exploratory analysis and Avro for production data pipelines. The implementation includes schema registries that maintain canonical definitions, ensuring consistency across formats. For example, a model metadata schema defined in JSON Schema can be automatically converted to Protocol Buffer definitions, maintaining semantic equivalence while optimizing for different use cases.

Customizing for Organizational Context and Maturity

Protocol implementation should align with organizational AI maturity and specific requirements rather than adopting a one-size-fits-all approach ¹². Early-stage organizations might implement lightweight protocols focused on basic discoverability, while mature AI-native companies require sophisticated governance, compliance, and lifecycle management capabilities.

A startup with a small data science team might implement a simple model registry with basic metadata (model name, version, accuracy metrics, owner) and straightforward REST APIs for registration and discovery. As the organization matures and regulatory requirements emerge, the protocol evolves to include fairness metrics, data lineage, and approval workflows. The implementation uses extensible metadata schemas that allow adding fields without breaking existing integrations. For instance, the initial schema might include only required fields for model identification and basic performance, with optional extension points. As compliance needs emerge, new fields for bias testing results and regulatory approvals are added as optional extensions, gradually becoming required as organizational processes mature.

Balancing Centralized and Federated Architectures

Organizations must decide between centralized registries that provide strong consistency and simple governance versus federated architectures that offer autonomy and scalability ²³. Centralized approaches simplify access control and ensure metadata consistency but create single points of failure and potential bottlenecks. Federated systems distribute load and enable organizational autonomy but complicate discovery and governance.

A hybrid implementation might maintain a centralized metadata index for discovery while storing actual models and datasets in distributed repositories. The central index aggregates metadata from departmental registries, enabling organization-wide search while allowing teams to manage their own resources. The protocol includes federation APIs where departmental registries periodically sync metadata to the central index, and discovery queries are routed to appropriate repositories based on access permissions. For example, a global enterprise might implement regional model registries for data residency compliance, with a central discovery service that federates searches across regions while respecting geographic access restrictions.

Implementing Effective Caching and Performance Optimization

Protocol performance significantly impacts user experience and system scalability, requiring careful caching strategies and optimization ². Metadata queries, which are read-heavy, benefit from aggressive caching, while model downloads require efficient transfer mechanisms for large files.

Implementation includes multi-tier caching with short TTLs (time-to-live) for frequently changing data like model availability and longer TTLs for stable metadata like model architecture descriptions. Content delivery networks (CDNs) cache popular model artifacts geographically close to users. The protocol supports conditional requests using ETags, allowing clients to verify cache freshness without transferring data. For large model downloads, the protocol implements resumable transfers and chunked downloads. For example, a model serving platform might cache model metadata in Redis with a 5-minute TTL, serve model weights through a CDN with edge caching, and implement HTTP range requests allowing interrupted downloads to resume from the last successful chunk rather than restarting from the beginning.

Common Challenges and Solutions

Challenge: Schema Evolution and Breaking Changes

As AI capabilities advance and organizational requirements evolve, metadata schemas must expand to capture new information types, such as emerging fairness metrics, environmental impact measurements, or novel model architectures ²³. However, schema changes risk breaking existing integrations, creating tension between innovation and stability. Organizations frequently encounter situations where adding required fields would break existing clients, while making all new fields optional reduces data quality and governance effectiveness.

Solution:

Implement a structured schema evolution process with clear governance and migration paths ². Adopt semantic versioning for schemas, where major versions indicate breaking changes, minor versions add backward-compatible fields, and patches fix errors. New fields are initially introduced as optional in minor version updates, with clear documentation and migration guides. After a deprecation period (e.g., six months), fields may become required in the next major version. The protocol includes version negotiation where clients specify supported schema versions, and the server provides data in the requested format or the closest compatible version. Implement automated schema validation tools that test new schema versions against existing client code, identifying potential breaking changes before deployment. For example, when introducing carbon footprint metrics for model training, these are added as optional fields in schema version 2.3, with documentation and examples. Monitoring dashboards track adoption rates, and after six months with >90% client support, the fields become required in version 3.0, with a clear migration guide and automated validation tools helping teams update their integrations.

Challenge: Metadata Quality and Completeness

Organizations frequently struggle with incomplete, inconsistent, or outdated metadata that undermines discoverability and governance ¹². Data scientists may view metadata documentation as overhead rather than value-adding work, leading to minimal or inaccurate information. Without comprehensive metadata, discovery systems return irrelevant results, governance checks fail, and users cannot make informed decisions about model suitability.

Solution:

Implement a multi-faceted approach combining technical enforcement, process integration, and incentive alignment ¹². Deploy automated validation that prevents model registration without required metadata fields, using schema validation to ensure structural correctness and business rule validation for semantic correctness (e.g., accuracy metrics must be between 0 and 1). Integrate metadata creation into existing workflows rather than treating it as a separate step—for example, training scripts automatically capture technical metadata like hyperparameters and training duration, while deployment pipelines require human-provided contextual information like intended use cases and known limitations. Create metadata templates and guided forms that reduce documentation burden through sensible defaults and contextual help. Implement quality scoring that ranks models in discovery results based on metadata completeness and freshness, creating incentives for thorough documentation. Establish metadata review as part of model approval workflows, where incomplete documentation blocks production deployment. For instance, an MLOps platform might automatically extract 70% of required metadata from training logs and model artifacts, present a guided form for the remaining 30% contextual information, validate completeness before allowing registry submission, and display metadata quality scores in search results, with higher-quality documentation receiving better visibility.

Challenge: Balancing Openness with Security and IP Protection

Organizations need to enable broad discovery and sharing to maximize AI resource utilization while protecting sensitive information, proprietary models, and confidential datasets ²³. Overly restrictive access controls limit collaboration and create silos, while insufficient protection risks intellectual property loss, privacy violations, or competitive disadvantage. The challenge intensifies in collaborative environments involving multiple organizations with different trust levels and security requirements.

Solution:

Implement fine-grained access control with tiered metadata visibility and secure computation capabilities ²³. Design metadata schemas with public, protected, and private tiers—public metadata (model task, general domain, license type) is visible to all authenticated users for discovery, protected metadata (detailed performance metrics, architecture specifics) requires explicit permissions, and private metadata (training data details, proprietary techniques) is restricted to model owners and designated reviewers. Implement attribute-based access control (ABAC) that grants permissions based on user attributes (organization, role, clearance level) and resource attributes (sensitivity classification, data residency requirements). For sensitive models, support secure enclaves or federated learning approaches where models can be used for inference without exposing weights. Implement comprehensive audit logging that records all access attempts, enabling detection of unauthorized access patterns. For example, a pharmaceutical company sharing models with research partners might expose public metadata showing that a model performs "molecular property prediction" with "90% accuracy on standard benchmarks," while detailed architecture information and training data specifics remain restricted to internal teams. External researchers can submit inference requests through secure APIs without accessing model weights, and all interactions are logged for compliance auditing.

Challenge: Interoperability Across Heterogeneous AI Ecosystems

The AI landscape encompasses diverse frameworks (TensorFlow, PyTorch, JAX), deployment platforms (cloud providers, edge devices, on-premises infrastructure), and programming languages, creating significant interoperability challenges ¹³. Models trained in one framework may not be directly usable in another, metadata formats vary across platforms, and integration requires substantial custom development. This fragmentation increases costs, limits model portability, and creates vendor lock-in risks.

Solution:

Adopt open standards and implement abstraction layers that bridge heterogeneous systems ¹³. Leverage format-agnostic standards like ONNX (Open Neural Network Exchange) for model serialization, enabling conversion between frameworks. Implement protocol adapters that translate between different metadata formats and API conventions, presenting a unified interface to clients while supporting diverse backend systems. Develop comprehensive client libraries that abstract platform-specific details, allowing developers to work with a consistent API regardless of underlying infrastructure. Support multiple serialization formats through content negotiation, enabling each system to use its preferred format while maintaining interoperability. Participate in and contribute to open standards development through organizations like the Linux Foundation AI & Data and MLCommons, ensuring protocols align with emerging industry standards. For example, a multi-cloud AI platform might implement a unified model registry API that internally translates to AWS SageMaker, Google Vertex AI, and Azure ML native formats. Models are stored in ONNX format alongside framework-specific versions, metadata follows a common schema mapped to platform-specific fields, and client libraries provide consistent interfaces across Python, Java, and JavaScript while handling platform-specific authentication and API conventions transparently.

Challenge: Performance and Scalability at Enterprise Scale

As AI adoption grows, discovery systems must handle thousands of models, petabytes of datasets, and millions of queries while maintaining low latency and high availability ²³. Naive implementations that query databases directly for each request or transfer large model files synchronously create performance bottlenecks. The challenge intensifies with global deployments requiring low latency across geographic regions and high-frequency automated queries from MLOps pipelines.

Solution:

Implement a multi-layered architecture with aggressive caching, asynchronous processing, and geographic distribution ²³. Deploy multi-tier caching with in-memory caches (Redis, Memcached) for hot metadata, CDN edge caching for model artifacts, and client-side caching with appropriate TTLs. Implement asynchronous processing for expensive operations like model validation, metadata extraction, and large file transfers, using message queues to decouple request handling from processing. Design APIs with pagination, filtering, and field selection to minimize data transfer—clients request only needed fields rather than complete metadata objects. Deploy geographically distributed infrastructure with regional registries and global metadata replication, routing requests to the nearest region while maintaining eventual consistency. Implement rate limiting and quota management to prevent individual clients from overwhelming the system. Use database indexing and query optimization for metadata searches, potentially implementing specialized search engines like Elasticsearch for complex queries. For example, a global model registry might cache frequently accessed metadata in Redis with 5-minute TTLs, serve model downloads through CloudFront CDN with edge locations worldwide, implement asynchronous model validation that processes uploads in background workers, provide GraphQL APIs allowing clients to request specific metadata fields, deploy regional instances in North America, Europe, and Asia with cross-region metadata replication, and implement per-client rate limits of 1000 requests per hour with burst allowances for legitimate high-frequency use cases.

References

1. Mitchell, M., Wu, S., Zaldivar, A., Barnes, P., Vasserman, L., Hutchinson, B., Spitzer, E., Raji, I. D., & Gebru, T. (2018). Model Cards for Model Reporting. https://arxiv.org/abs/1810.03993
2. Gebru, T., Morgenstern, J., Vecchione, B., Vaughan, J. W., Wallach, H., Daumé III, H., & Crawford, K. (2018). Datasheets for Datasets. https://arxiv.org/abs/1803.09010
3. Noy, N., Gao, Y., Jain, A., Narayanan, A., Patterson, A., & Taylor, J. (2019). Industry-scale Knowledge Graphs: Lessons and Challenges. https://research.google/pubs/pub46555/
4. Paleyes, A., Urma, R. G., & Lawrence, N. D. (2021). Challenges in Deploying Machine Learning: A Survey of Case Studies. https://arxiv.org/abs/2108.07258
5. Schelter, S., Lange, D., Schmidt, P., Celikel, M., Biessmann, F., & Grafberger, A. (2019). Automating Large-Scale Data Quality Verification. https://arxiv.org/abs/1908.07069
6. Polyzotis, N., Zinkevich, M., Roy, S., Breck, E., & Whang, S. (2020). Data Lifecycle Challenges in Production Machine Learning. https://arxiv.org/abs/2010.03467
7. Raji, I. D., Smart, A., White, R. N., Mitchell, M., Gebru, T., Hutchinson, B., Smith-Loud, J., Theron, D., & Barnes, P. (2020). Closing the AI Accountability Gap: Defining an End-to-End Framework for Internal Algorithmic Auditing. https://www.springer.com/gp/book/9783030637156
8. Baylor, D., Breck, E., Cheng, H. T., Fiedel, N., Foo, C. Y., Haque, Z., Haykal, S., Ispir, M., Jain, V., Koc, L., Koo, C. Y., Lew, L., Mewald, C., Modi, A. N., Polyzotis, N., Ramesh, S., Roy, S., Whang, S. E., Wicke, M., Wilkiewicz, J., Zhang, X., & Zinkevich, M. (2017). TFX: A TensorFlow-Based Production-Scale Machine Learning Platform. https://research.google/pubs/pub49953/