Lyft's Spatial-Temporal Forecasting Framework

AxLearn, Agent S, Guardrails, PIT

Lyft has written about their real-time spatial-temporal forecasting system that provides predictions for their dynamic pricing and driver incentives across millions of geohashes in North America. This system addresses the main challenge of balancing supply (driver availability) and demand (ride requests) at hyper-local levels, even in scenarios influenced by unexpected events like concerts or protests.

The system uses a three-layered architecture:

1. Time-Series Foundation Layer

   • ARIMA variants handle baseline periodicity (daily/weekly cycles)

   • Exponential smoothing state space models (ETS) adapt to short-term trends

   • Integrated with causal factors via PyTorch-based IndexTensors that enable differentiable operations over spatiotemporal indices

2. Graph Neural Network Layer

   • Captures spatial dependencies using adjacency matrices based on:

     • Geohash centroids (H3 grid system)

     • Road network connectivity

     • Historical ride flow patterns

   • Implements attention mechanisms to weight influential neighboring geohashes

3. Online Learning Layer

   • Continuously updates model weights

   • Uses model slicing to retain long-term patterns while adapting to real-time signals

In order to build predictions against temporal and spatial domain; they adopt a geo hash based spatial processing where they create spatial grid and uses hierarchical forecasting to do coarse to finer granular level of predictions in spatial domain.

• H3 Hexagonal Grid (resolution 10 ~ 0.15 km² cells)

  • Enables efficient neighbor lookups via built-in hierarchy

• Hierarchical Forecasting:

  • Aggregates predictions from fine to coarse resolutions (geohash 10 → 9 → 8)

  • Uses Sparse Tensor Representations to handle 4M+ geohashes efficiently

They adopt the following model optimization and latency reduction techniques to make the inference flow to be real-time and low latency:

• Model Quantization: FP16 → INT8 conversion using NVIDIA TensorRT framework under the hood

• Hotspot Prediction: Pre-warms Redis cache for geohashes with >100 requests/min

• Dynamic Batching: Groups geo-hash requests using Flink's session windows

The system accounts for external factors through a bayesian structural time-series structure:

Forecast = BaseModel(History) × CausalImpact(Events) + RealTimeAdjustment

where:

• Causal Impact uses Bayesian structural time-series to measure:

  • Weather changes (precipitation, temperature)

  • Local events (concerts, protests)

  • Road closures

• Implemented as PyTorch modules with custom backward passes

Libraries

VectorVFS is a lightweight Python package that transforms your Linux filesystem into a vector database by leveraging the native VFS (Virtual File System) extended attributes. Rather than maintaining a separate index or external database, VectorVFS stores vector embeddings directly alongside each file—turning your existing directory structure into an efficient and semantically searchable embedding store.

VectorVFS currently uses Meta's Perception Encoders (PE) [arxiv] which includes image/video encoders for vision language understanding, it outperforms InternVL3, Qwen2.5VL and SigLIP2 for zero-shot image tasks.

• Zero-overhead indexing
  Embeddings are stored as extended attributes (xattrs) on each file, eliminating the need for external index files or services.

• Seamless retrieval
  Perform searches across your filesystem, retrieving files by embedding similarity.

• Flexible embedding support
  Plug in any embedding model—from pre-trained transformers to custom feature extractors—and let VectorVFS handle storage and lookup.

• Lightweight and portable
  Built on native Linux VFS functionality, VectorVFS requires no additional daemons, background processes, or databases.

AXLearn is a library built on top of JAX and XLA to support the development of large-scale deep learning models.

AXLearn takes an object-oriented approach to the software engineering challenges that arise from building, iterating, and maintaining models. The configuration system of the library lets users compose models from reusable building blocks and integrate with other libraries such as Flax and Hugging Face transformers.

AXLearn is built to scale. It supports the training of models with up to hundreds of billions of parameters across thousands of accelerators at high utilization. It is also designed to run on public clouds and provides tools to deploy and manage jobs and data. Built on top of GSPMD, AXLearn adopts a global computation paradigm to allow users to describe computation on a virtual global computer rather than on a per-accelerator basis.

Agent S is an open-source framework designed to enable autonomous interaction with computers through Agent-Computer Interface. Our mission is to build intelligent GUI agents that can learn from past experiences and perform complex tasks autonomously on your computer.

Vision Transformer (ViT) extends the application range of transformers from language processing to computer vision tasks as being an alternative architecture against the existing convolutional neural networks (CNN). Since the transformer-based architecture has been innovative for computer vision modeling, the design convention towards an effective architecture has been less studied yet. From the successful design principles of CNN, we investigate the role of the spatial dimension conversion and its effectiveness on the transformer-based architecture. If articularly attend the dimension reduction principle of CNNs; as the depth increases, a conventional CNN increases channel dimension and decreases spatial dimensions. Such a spatial dimension reduction is beneficial to a transformer architecture as well, and proposed a novel Pooling-based Vision Transformer (PiT) upon the original ViT model. The paper accompanied by the library is also available in Arxiv.

Guardrails is a Python framework that helps build reliable AI applications by performing two key functions:

1. Guardrails runs Input/Output Guards in your application that detect, quantify and mitigate the presence of specific types of risks. To look at the full suite of risks, check out Guardrails Hub.

2. Guardrails help you generate structured data from LLMs.

   

GPTSwarm is a graph-based framework for LLM-based agents, providing two high-level features:

• It lets you build LLM-based agents from graphs.

• It enables the customized and automatic self-organization of agent swarms with self-improvement capabilities.

Seed-Coder (previously known as Doubao-Coder) is a family of lightweight yet powerful open-source code LLMs comprising base, instruct and reasoning models of 8B size.

Seed-Coder demonstrates that, with minimal human effort, LLMs can effectively curate code training data by themselves to drastically enhance coding capabilities.

Seed-Coder represents our initial step towards contributing to the open-source LLM ecosystem. We look forward to seeing Seed-Coder drive advances in code intelligence and empower broader applications in the open-source LLM community!

Kuzu is an embedded graph database built for query speed and scalability. Kuzu is optimized for handling complex analytical workloads on very large databases and provides a set of retrieval features, such as a full text search and vector indices. Our core feature set includes:

• Flexible Property Graph Data Model and Cypher query language

• Embeddable, serverless integration into applications

• Native full text search and vector index

• Columnar disk-based storage

• Columnar sparse row-based (CSR) adjacency list/join indices

• Vectorized and factorized query processor

• Novel and very fast join algorithms

• Multi-core query parallelism

• Serializable ACID transactions

• Wasm (WebAssembly) bindings for fast, secure execution in the browser

Below The Fold

Scrapling is a high-performance, intelligent web scraping library for Python that automatically adapts to website changes while significantly outperforming popular alternatives. For both beginners and experts, Scrapling provides powerful features while maintaining simplicity.

PgDog is a transaction pooler and logical replication manager that can shard PostgreSQL. Written in Rust, PgDog is fast, secure and can manage hundreds of databases and hundreds of thousands of connections.

CoreControl is the only dashboard you'll ever need to manage your entire server infrastructure. Keep all your server data organized in one central place, easily add your self-hosted applications with quick access links, and monitor their availability in real-time with built-in uptime tracking. Designed for simplicity and control, it gives you a clear overview of your entire self-hosted setup at a glance.