Graphcore

Overview

Graphcore, founded in 2016, develops Intelligence Processing Units (IPUs) and associated software, including the Poplar SDK, designed specifically for artificial intelligence workloads. The company's hardware architecture is distinct from traditional CPUs and GPUs, focusing on parallel processing and efficient data flow for machine learning algorithms. Graphcore's IPU systems are targeted at high-performance computing environments that require accelerated training and inference for large-scale AI models.

The IPU architecture emphasizes massive parallelism and in-processor memory, aiming to reduce data movement bottlenecks that can limit the performance of AI models on other hardware platforms. This design choice is intended to be particularly beneficial for models with complex graph structures, such as graph neural networks (GNNs). Developers interact with Graphcore hardware through the Poplar SDK, which provides tools and libraries for integrating with popular machine learning frameworks like TensorFlow and PyTorch. This allows researchers and engineers to adapt existing AI models to run on IPU systems or develop new models optimized for the architecture.

Graphcore positions its IPUs as a solution for organizations engaged in advanced AI research and deployment, where computational efficiency and performance are critical. Use cases span various domains, including natural language processing, computer vision, and scientific simulation, particularly where large datasets and complex model architectures are involved. The specialized nature of the IPU architecture means that while it can offer significant performance gains for specific workloads, it may require a different approach to model development and optimization compared to more general-purpose accelerators like those offered by NVIDIA.

The company's focus on a dedicated AI processor aims to address the growing computational demands of state-of-the-art AI models. By designing hardware from the ground up for AI, Graphcore seeks to overcome limitations encountered when running these workloads on hardware not primarily designed for them. This includes optimizing for sparse computations, irregular data access patterns, and the massive parallelism inherent in neural network operations. The Poplar SDK provides the necessary abstraction layer, allowing developers to map their AI models onto the IPU's unique computational graph efficiently.

Key features

• Intelligence Processing Unit (IPU) Architecture: A purpose-built processor designed to accelerate machine learning workloads, featuring massive parallelism and in-processor memory to reduce data movement bottlenecks.
• Poplar SDK: A comprehensive software development kit that enables developers to build, optimize, and deploy AI models on Graphcore IPU systems, supporting integration with popular frameworks. Graphcore documentation provides details on the SDK.
• Graph Neural Network (GNN) Optimization: The IPU architecture is particularly well-suited for efficiently processing graph-structured data and accelerating the training and inference of GNNs.
• Scalable Systems: Graphcore offers systems that can scale from individual accelerators to large-scale clusters, enabling the training of very large AI models and high-throughput inference.
• Framework Compatibility: Supports integration with widely used machine learning frameworks such as TensorFlow and PyTorch, allowing developers to leverage existing model codebases.
• High-Performance AI Inference: Designed to deliver low-latency and high-throughput inference for deployed AI applications, critical for real-time decision-making.

Pricing

Graphcore's products are typically offered through custom enterprise agreements, reflecting the specialized nature of their hardware and solutions for large-scale AI deployments. Specific pricing details are not publicly available on their website and are instead determined through direct consultation with the Graphcore sales team.

Pricing as of May 7, 2026. For current pricing information, contact Graphcore directly.

Common integrations

• TensorFlow: Graphcore's Poplar SDK provides an extensive backend for TensorFlow, allowing models defined in TensorFlow to be compiled and executed on IPU hardware. TensorFlow integration documentation.
• PyTorch: The Poplar SDK also includes support for PyTorch, enabling researchers and developers to leverage the PyTorch ecosystem for IPU-accelerated development. PyTorch integration documentation.
• ONNX: Graphcore supports the Open Neural Network Exchange (ONNX) format, facilitating model interoperability across different frameworks and hardware.
• Hugging Face Transformers: Compatibility with models from the Hugging Face Transformers library allows for accelerating state-of-the-art NLP models on IPUs.
• Kubernetes: Graphcore IPU resources can be managed and orchestrated within Kubernetes environments, enabling containerized AI workloads.

Alternatives

• NVIDIA: Offers a broad range of GPUs (e.g., A100, H100) and CUDA software platform, widely used for general-purpose AI acceleration.
• Cerebras Systems: Develops the Wafer-Scale Engine (WSE), a single, large chip designed for massive AI model training, emphasizing very large models and simplified parallelism.
• Groq: Specializes in a Language Processor Unit (LPU) architecture designed for ultra-low-latency inference, particularly for large language models.
• Google Cloud TPUs: Google's Tensor Processing Units are custom-designed ASICs optimized for machine learning workloads, available through Google Cloud.
• AWS Inferentia/Trainium: Amazon's custom-designed AI accelerators available as EC2 instances for high-performance inference and training workloads on AWS.

Getting started

To begin developing with Graphcore IPUs, you would typically set up your environment with the Poplar SDK and integrate it with your chosen machine learning framework. The following Python example demonstrates a simplified conceptual workflow using a hypothetical Poplar-enabled PyTorch model. This code assumes the Poplar SDK is installed and configured to communicate with an available IPU device.

import torch
import torch.nn as nn
import poptorch

# 1. Define a simple neural network model
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc1 = nn.Linear(10, 20)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(20, 2)

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

# 2. Instantiate the model
model = SimpleModel()

# 3. Create a PopTorch options object (configures IPU execution)
opts = poptorch.Options()
opts.deviceIterations(1) # Run one iteration per device step

# 4. Wrap the model with PopTorch for IPU execution
# This compiles the model for the IPU and handles data transfer
ipu_model = poptorch.trainingModel(model, opts)

# 5. Define dummy input data and labels
input_data = torch.randn(64, 10) # Batch size 64, 10 features
target_labels = torch.randint(0, 2, (64,))

# 6. Define a loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = poptorch.optim.SGD(ipu_model.parameters(), lr=0.01)

# 7. Perform a training step on the IPU
print("Starting IPU training step...")
output = ipu_model(input_data)
loss = criterion(output, target_labels)

# Backpropagation and weight update on IPU
ipu_model.setOptimizer(optimizer)
ipu_model.setCriterion(criterion)
loss = ipu_model(input_data, target_labels)

print(f"Loss after IPU training step: {loss.item():.4f}")

# 8. Detach the model from the IPU (optional, for cleanup or host-side ops)
ipu_model.detachFromDevice()
print("IPU model detached.")

This example initializes a simple PyTorch model, configures it for IPU execution using poptorch.trainingModel, and then performs a single forward pass and backpropagation step on the IPU. For detailed setup instructions, including Poplar SDK installation and environment configuration, refer to the Graphcore installation guides.