LogoLogo
Python SDKSlack
  • Documentation
  • Cookbooks
  • Self-Hosting
  • Release Notes
  • Reference
  • Arize AI
  • Quickstarts
  • ✨Arize Copilot
  • Concepts
    • Agent Evaluation
    • Tracing
      • What is OpenTelemetry?
      • What is OpenInference?
      • Openinference Semantic Conventions
    • Evaluation
  • 🧪Develop
    • Quickstart: Experiments
    • Datasets
      • Create a dataset
      • Update a dataset
      • Export a dataset
    • Experiments
      • Run experiment
        • Run experiment in code
        • Log experiment results via SDK
        • Experiments SDK differences in AX vs Phoenix
      • Evaluate experiment
        • Evaluate experiment in code
      • CI/CD with experiments
        • Github Action Basics
        • Gitlab CI/CD Basics
      • Download experiment
    • Prompt Playground
      • Span Replay
      • Compare Prompts Side-by-Side
      • Load a Dataset into Playground
      • Save Playground Outputs as an Experiment
      • Using Tools in Playground
      • Image Inputs in Playground
      • ✨Copilot: Prompt Builder
    • Playground Integrations
      • OpenAI
      • Azure OpenAI
      • AWS Bedrock
      • VertexAI
      • Custom LLM Models
    • Prompt Hub
  • 🧠Evaluate
    • Online Evals
      • Run evaluations in the UI
      • Run evaluations with code
      • Test LLM evaluator in playground
      • View task details & logs
      • ✨Copilot: Eval Builder
      • ✨Copilot: Eval Analysis
      • ✨Copilot: RAG Analysis
    • Experiment Evals
    • LLM as a Judge
      • Custom Eval Templates
      • Arize Templates
        • Agent Tool Calling
        • Agent Tool Selection
        • Agent Parameter Extraction
        • Agent Path Convergence
        • Agent Planning
        • Agent Reflection
        • Hallucinations
        • Q&A on Retrieved Data
        • Summarization
        • Code Generation
        • Toxicity
        • AI vs Human (Groundtruth)
        • Citation
        • User Frustration
        • SQL Generation
    • Code Evaluations
    • Human Annotations
      • Annotate spans
      • Setup labeling queues
  • 🔭Observe
    • Quickstart: Tracing
    • Tracing
      • Setup Tracing
      • How to: Trace Manually
        • Trace Function Calls
        • Instrument with OpenInference Helpers
        • How to Send to a Specific Project and Space ID
        • Get the Current Span/Context and Tracer
        • Log Prompt Templates & Variables
        • Add Attributes, Metadata and Tags to Span
        • Add Events, Exceptions and Status to Spans
        • Configure OTEL Tracer
        • Create LLM, Retriever and Tool Spans
        • Create Tool Spans
        • Log Input
        • Log Outputs
        • Mask Span Attributes
        • Redact Sensitive Data from Traces
        • Send Traces from Phoenix -> Arize
        • Log as Inferences
        • Advanced Tracing (OTEL) Examples
      • How to: Query Traces
        • Filter Traces
          • Time Filtering
        • Export Traces
        • ✨AI Powered Search & Filter
        • ✨AI Powered Trace Analysis
        • ✨AI Span Analysis & Evaluation
    • Tracing Integrations
      • OpenAI
      • OpenAI Agents SDK
      • LlamaIndex
      • LlamaIndex Workflows
      • LangChain
      • LangGraph
      • Hugging Face smolagents
      • Autogen
      • Google GenAI (Gemini)
      • Vertex AI
      • Amazon Bedrock
      • Amazon Bedrock Agents
      • MistralAI
      • Anthropic
      • LangFlow
      • Haystack
      • LiteLLM
      • CrewAI
      • Groq
      • DSPy
      • Guardrails AI
      • Prompt flow
      • Vercel AI SDK
      • Llama
      • Together AI
      • OpenTelemetry (arize-otel)
      • BeeAI
    • Evals on Traces
    • Guardrails
    • Sessions
    • Dashboards
      • Dashboard Widgets
      • Tracking Token Usage
      • ✨Copilot: Dashboard Widget Creation
    • Monitors
      • Integrations: Monitors
        • Slack
          • Manual Setup
        • OpsGenie
        • PagerDuty
      • LLM Red Teaming
    • Custom Metrics & Analytics
      • Arize Query Language Syntax
        • Conditionals and Filters
        • All Operators
        • All Functions
      • Custom Metric Examples
      • ✨Copilot: ArizeQL Generator
  • 📈Machine Learning
    • Machine Learning
      • User Guide: ML
      • Quickstart: ML
      • Concepts: ML
        • What Is A Model Schema
        • Delayed Actuals and Tags
        • ML Glossary
      • How To: ML
        • Upload Data to Arize
          • Pandas SDK Example
          • Local File Upload
            • File Upload FAQ
          • Table Ingestion Tuning
          • Wildcard Paths for Cloud Storage
          • Troubleshoot Data Upload
          • Sending Data FAQ
        • Monitors
          • ML Monitor Types
          • Configure Monitors
            • Notifications Providers
          • Programmatically Create Monitors
          • Best Practices for Monitors
        • Dashboards
          • Dashboard Widgets
          • Dashboard Templates
            • Model Performance
            • Pre-Production Performance
            • Feature Analysis
            • Drift
          • Programmatically Create Dashboards
        • Performance Tracing
          • Time Filtering
          • ✨Copilot: Performance Insights
        • Drift Tracing
          • ✨Copilot: Drift Insights
          • Data Distribution Visualization
          • Embeddings for Tabular Data (Multivariate Drift)
        • Custom Metrics
          • Arize Query Language Syntax
            • Conditionals and Filters
            • All Operators
            • All Functions
          • Custom Metric Examples
          • Custom Metrics Query Language
          • ✨Copilot: ArizeQL Generator
        • Troubleshoot Data Quality
          • ✨Copilot: Data Quality Insights
        • Explainability
          • Interpreting & Analyzing Feature Importance Values
          • SHAP
          • Surrogate Model
          • Explainability FAQ
          • Model Explainability
        • Bias Tracing (Fairness)
        • Export Data to Notebook
        • Automate Model Retraining
        • ML FAQ
      • Use Cases: ML
        • Binary Classification
          • Fraud
          • Insurance
        • Multi-Class Classification
        • Regression
          • Lending
          • Customer Lifetime Value
          • Click-Through Rate
        • Timeseries Forecasting
          • Demand Forecasting
          • Churn Forecasting
        • Ranking
          • Collaborative Filtering
          • Search Ranking
        • Natural Language Processing (NLP)
        • Common Industry Use Cases
      • Integrations: ML
        • Google BigQuery
          • GBQ Views
          • Google BigQuery FAQ
        • Snowflake
          • Snowflake Permissions Configuration
        • Databricks
        • Google Cloud Storage (GCS)
        • Azure Blob Storage
        • AWS S3
          • Private Image Link Access Via AWS S3
        • Kafka
        • Airflow Retrain
        • Amazon EventBridge Retrain
        • MLOps Partners
          • Algorithmia
          • Anyscale
          • Azure & Databricks
          • BentoML
          • CML (DVC)
          • Deepnote
          • Feast
          • Google Cloud ML
          • Hugging Face
          • LangChain 🦜🔗
          • MLflow
          • Neptune
          • Paperspace
          • PySpark
          • Ray Serve (Anyscale)
          • SageMaker
            • Batch
            • RealTime
            • Notebook Instance with Greater than 20GB of Data
          • Spell
          • UbiOps
          • Weights & Biases
      • API Reference: ML
        • Python SDK
          • Pandas Batch Logging
            • Client
            • log
            • Schema
            • TypedColumns
            • EmbeddingColumnNames
            • ObjectDetectionColumnNames
            • PromptTemplateColumnNames
            • LLMConfigColumnNames
            • LLMRunMetadataColumnNames
            • NLP_Metrics
            • AutoEmbeddings
            • utils.types.ModelTypes
            • utils.types.Metrics
            • utils.types.Environments
          • Single Record Logging
            • Client
            • log
            • TypedValue
            • Ranking
            • Multi-Class
            • Object Detection
            • Embedding
            • LLMRunMetadata
            • utils.types.ModelTypes
            • utils.types.Metrics
            • utils.types.Environments
        • Java SDK
          • Constructor
          • log
          • bulkLog
          • logValidationRecords
          • logTrainingRecords
        • R SDK
          • Client$new()
          • Client$log()
        • Rest API
    • Computer Vision
      • How to: CV
        • Generate Embeddings
          • How to Generate Your Own Embedding
          • Let Arize Generate Your Embeddings
        • Embedding & Cluster Analyzer
        • ✨Copilot: Embedding Summarization
        • Similarity Search
        • Embedding Drift
        • Embeddings FAQ
      • Integrations: CV
      • Use Cases: CV
        • Image Classification
        • Image Segmentation
        • Object Detection
      • API Reference: CV
Powered by GitBook

Support

  • Chat Us On Slack
  • support@arize.com

Get Started

  • Signup For Free
  • Book A Demo

Copyright © 2025 Arize AI, Inc

On this page
  • Average Metric Value
  • Metric Over Time
  • Drift Over Time
  • Global Feature Importance
  • Get Model Schema Stats

Was this helpful?

  1. Resources
  2. GraphQL API

Metrics API

Last updated 7 months ago

Was this helpful?

For a brief overview of GraphQL itself, please consult our .

Average Metric Value

Metrics are associated with models; therefore, we utilize the model node to query for the average metric value.

AveragePerformanceQuery(
  $dataset: ModelDatasetInput, 
  $performanceMetric: PerformanceMetric!, 
  $predictionValueClass: String, 
  $timeZone: String!, 
  $id: ID!) {
  node(id: $id) {
    ... on Model {
      averagePerformanceMetric(
        performanceMetric: $performanceMetric
        positiveClass: $predictionValueClass
        timeZone: $timeZone
        dataset: $dataset
      )
    }
  }
}

Variables

{
  "dataset": {
    "startTime": "2024-06-25T06:00:00.000Z", #target start time
    "endTime": "2024-07-26T05:59:59.999Z", #target end time
    "externalModelVersionIds": [],
    "externalBatchIds": [],
    "environmentName": "production",
    "filters": []
  },
  "performanceMetric": "TargetMetric", 
  "predictionValueClass": "positiveClassValue",
  "timeZone": "time/zone", #The timezone of the request, used to determine the localized offset from UTC.
  "id": "model_id"
}
query AveragePerformanceQuery(
 $dataset: ModelDatasetInput, 
 $customMetricConfig: String, 
  $timeZone: String!, 
  $id: ID!) {
  node(id: $id) {
    __typename
    ... on Model {
      averagePerformanceMetric(
        performanceMetric: udf
        timeZone: $timeZone
        dataset: $dataset
        customMetricConfig: $customMetricConfig
      )
    }
  }
}

Variables

{
  "dataset": {
    "startTime": "2024-06-25T06:00:00.000Z", #target start time
    "endTime": "2024-07-26T05:59:59.999Z", #target end time
    "externalModelVersionIds": [],
    "externalBatchIds": [],
    "environmentName": "production",
    "filters": []
  },
  "customMetricConfig": "select count(*) from model", #udf in SQL syntax
  "timeZone": "time/zone", #The timezone of the request, used to determine the localized offset from UTC.
  "id": "model_id"
}

Metric Over Time

To analyze metric values over time or plot reconstruction, use the following query

query AveragePerformanceQuery(
  $performanceMetric: PerformanceMetric!
  $positiveClass:String!
  $startTime: DateTime!
  $endTime: DateTime!
  $timeZone: String!, 
  $id: ID!
  $environmentName: ModelEnvironmentName!
  $timeSeriesDataGranularity:DataGranularity!
) {
  node(id: $id) {
    __typename
    ... on Model {
      performanceMetricOverTime(
        performanceMetric: $performanceMetric
        timeZone: $timeZone,
        startTime: $startTime,
        endTime: $endTime,
        externalModelVersionIds: [],
        externalBatchIds: [],
        environmentName: $environmentName,
        timeSeriesDataGranularity: $timeSeriesDataGranularity
        filters: []
        positiveClass: $positiveClass
      ){
        dataPoints{
          x
          y
        }
      }
    }
    id
  }
}

Variables

{
  "performanceMetric": "metric",
  "positiveClass": "positive_class_value",
  "timeZone": "time/zome", #The timezone of the request, used to determine the localized offset from UTC.
  "id": "model_id",
  "startTime": "2024-06-25T06:00:00.000Z",
  "endTime": "2024-07-26T05:59:59.999Z",
  "environmentName": "production",
  "timeSeriesDataGranularity": "month", #desired granularity 
}
query AveragePerformanceQuery(
  $startTime: DateTime!
  $endTime: DateTime!
  $timeZone: String!, 
  $id: ID!
  $environmentName: ModelEnvironmentName!
  $timeSeriesDataGranularity:DataGranularity!
  $customMetricConfig:String
) {
  node(id: $id) {
    __typename
    ... on Model {
      performanceMetricOverTime(
        performanceMetric: udf
        timeZone: $timeZone,
        startTime: $startTime,
        endTime: $endTime,
        externalModelVersionIds: [],
        externalBatchIds: [],
        environmentName: $environmentName,
        timeSeriesDataGranularity: $timeSeriesDataGranularity
        filters: []
        customMetricConfig: $customMetricConfig
      ){
        dataPoints{
          x
          y
        }
      }
    }
    id
  }
}

variables

{
  "timeZone": "time/zone",
  "id": "model_id",
  "startTime": "2024-06-25T06:00:00.000Z", #target start time
  "endTime": "2024-07-26T05:59:59.999Z", #target end time
  "environmentName": "production", #The timezone of the request, used to determine the localized offset from UTC.
  "timeSeriesDataGranularity": "month", #target granularity for points
  "customMetricConfig": "select count(*) from model" #udf in SQL syntax
}

Drift Over Time

This endpoint allows you to query drift data points for a specific model within a given time interval. You can use it to monitor feature drift using metrics like PSI (Population Stability Index), KL (Kullback-Leibler divergence), or JS (Jensen-Shannon divergence). Your model baseline is defaulted as the baseline in this query but you can optionally specify a referenceDataset.

query GetDriftOverTime {
  node(id: "MODEL ID") {
    ... on Model {
      dimension(
        startTime: "2024-08-20T00:00:00Z" 
        endTime: "2024-08-30T00:00:00Z" 
        category: featureLabel 
        name: "annual_income"
        environmentName: production
      ) {
        name
        driftHistory(
          startTime: "2024-08-20T00:00:00Z"
          endTime: "2024-08-30T00:00:00Z"
          driftMetric: psi 
          timeSeriesDataGranularity: day 
          timeZone: "UTC"
        ) {
          ... on TimeSeriesWithThresholdDataType {
            dataPoints {
              x
              y
            }
          }
        }
      }
    }
  }
}query
query GetDriftWithCustomBaseline {
  node(id: "model_id") {
    ... on Model {
      dimension(
        startTime: "2024-08-20T00:00:00Z"
        endTime: "2024-08-30T00:00:00Z"
        category: featureLabel
        name: "state" 
        environmentName: production
      ) {
        name
        driftHistory(
          referenceDataset:{
            startTime: "2024-08-01T00:00:00Z"
            endTime: "2024-08-15T00:00:00Z"
            environmentName:production 
            externalBatchIds: []
            externalModelVersionIds:[]
            filters:[]
          }
        
          startTime: "2024-08-20T00:00:00Z"
          endTime: "2024-08-30T00:00:00Z"
          driftMetric: psi
          timeSeriesDataGranularity: hour
          timeZone: "UTC"
        ) {
          ... on TimeSeriesWithThresholdDataType {
            dataPoints {
              x
              y
            }
          }
        }
      }
    }
  }
}

Parameters

  • "MODEL ID": The unique identifier for your model.

  • dimension: Specifies the feature or dimension you want to analyze.

    • startTime: The start of the interval for querying data (in UTC).

    • endTime: The end of the interval for querying data (in UTC).

    • category: The type of data you are querying. Options include:

      • featureLabel

      • prediction

      • actuals

      • actualScore

      • actualClass

      • predictionClass

      • predictionScore

      • tag

    • name: The specific feature or dimension name you want to query.

    • environmentName: The environment for which the data is being queried, such as 'production'.

  • driftHistory: Retrieves the drift data over the specified time period.

    • driftMetric: The metric used to measure drift. Options include:

      • psi (Population Stability Index)

      • kl (Kullback-Leibler divergence)

      • js (Jensen-Shannon divergence)

    • timeSeriesDataGranularity: The granularity of the data points in the time series. Options include:

      • day

      • hour

      • week

      • month

    • timeZone: The time zone for the data points, e.g., "UTC".

Global Feature Importance

This endpoint allows you to query the global feature importance for all your feautres.

query GloablShapQuery($modelId: ID!,
  $startTimeA: DateTime!,
  $endTimeA: DateTime!,
  $globalFilters: [FilterItemInputType!]!, 
  $externalModelVersionIdsGlobal: [String!]!) {
  node(id: $modelId) {
    id
    __typename
    ... on Model {
      modelExplainability(
        startTime: $startTimeA
        endTime: $endTimeA
        externalModelVersionIds: $externalModelVersionIdsGlobal
        filters: $globalFilters
      ) {
        featureImportanceValues {
          dimension {
            name
          }
          importanceValue
        }
      }
    }
  }
}

Variables

{
  "modelId": "MODEL_ID",
  "startTimeA": "2024-09-07T06:00:00.000Z",
  "endTimeA": "2024-10-08T05:59:59.999Z",
  "globalFilters": [],
  "externalModelVersionIdsGlobal": []
}

Get Model Schema Stats

You can query the model schema to gather key statistics such as cardinality, percent empty, and drift. The query below retrieves data on features and predictions, including percentEmpty, cardinality, and drift metrics.

query GetSchemaStats(
  $id: ID!, 
  $startTime: DateTime!, 
  $endTime: DateTime!,
  $environmentName: ModelEnvironmentName!, 
  ) {
  node(id: $id) {
    __typename
    ... on Model {
      id
      modelSchema(
        startTime: $startTime
        endTime: $endTime
        modelEnvironmentName: $environmentName
        modelVersionEnvironmentMetadataIds: []
        
      ) {
        features(
          first: 10
        ) {
          edges {
            node {
              id
              dimension {
                name
              }
              dimensionStats{
                percentEmpty
                cardinality
              }
               dimensionDriftStats(
                driftMetric: psi, 
                externalModelVersionIds: [], 
                externalBatchIds:[], 
                filters: []
            ) {
            __typename
            ... on DimensionDriftStats {
              driftValue
              threshold
              operator
            }
                ... on DriftCalculationError {
              errorCode: code
            }
              }
              }
            }
        }
        predictions(first:10){
          edges{
            node{
              dimensionStats{
                percentEmpty
                cardinality
              }
               dimensionDriftStats(
                driftMetric: psi, 
                externalModelVersionIds: [], 
                externalBatchIds:[], 
                filters: []) {
            __typename
            ... on DimensionDriftStats {
              driftValue
              threshold
              operator
            }
                ... on DriftCalculationError {
              errorCode: code
            }
              }
              }
            }
        }
            }
          }
        }
      }

Variables

{
  "id": "MODEL_ID",
  "startTime": "2024-09-08T06:00:00.000Z",
  "endTime": "2024-10-09T05:59:59.999Z",
  "environmentName": "production"
}
📚
introduction