From a3c24c3a0842cb17f000886e4f30b3c5bb06eda8 Mon Sep 17 00:00:00 2001
From: gbruno16 <72879691+gbruno16@users.noreply.github.com>
Date: Wed, 26 Jun 2024 09:47:30 +0200
Subject: [PATCH] Graph (#112)

* Add graphcast utils

* Add graph builder

* Rebase

* Add gencast loss

* Add loss test and exceptions

* Fix

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Add source

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
---
 environment_cpu.yml                           |   2 +
 environment_cuda.yml                          |   2 +
 graph_weather/models/gencast/README.md        |   1 +
 graph_weather/models/gencast/__init__.py      |   4 +
 .../models/gencast/graph/__init__.py          |   1 +
 .../models/gencast/graph/graph_builder.py     | 304 ++++++++
 .../gencast/graph/grid_mesh_connectivity.py   | 134 ++++
 .../models/gencast/graph/icosahedral_mesh.py  | 264 +++++++
 .../models/gencast/graph/model_utils.py       | 734 ++++++++++++++++++
 .../models/gencast/weighted_mse_loss.py       | 129 +++
 requirements.txt                              |   2 +
 tests/test_model.py                           |  50 ++
 train/gencast_demo.ipynb                      | 204 +++++
 13 files changed, 1831 insertions(+)
 create mode 100644 graph_weather/models/gencast/README.md
 create mode 100644 graph_weather/models/gencast/__init__.py
 create mode 100644 graph_weather/models/gencast/graph/__init__.py
 create mode 100644 graph_weather/models/gencast/graph/graph_builder.py
 create mode 100644 graph_weather/models/gencast/graph/grid_mesh_connectivity.py
 create mode 100644 graph_weather/models/gencast/graph/icosahedral_mesh.py
 create mode 100644 graph_weather/models/gencast/graph/model_utils.py
 create mode 100644 graph_weather/models/gencast/weighted_mse_loss.py

diff --git a/environment_cpu.yml b/environment_cpu.yml
index f0c312e0..5784bbb4 100644
--- a/environment_cpu.yml
+++ b/environment_cpu.yml
@@ -34,3 +34,5 @@ dependencies:
       - pysolar
       - pytorch-lightning
       - click
+      - trimesh
+      - rtree
diff --git a/environment_cuda.yml b/environment_cuda.yml
index 935ba13c..9f76251a 100644
--- a/environment_cuda.yml
+++ b/environment_cuda.yml
@@ -35,3 +35,5 @@ dependencies:
       - pysolar
       - pytorch-lightning
       - click
+      - trimesh
+      - rtree
diff --git a/graph_weather/models/gencast/README.md b/graph_weather/models/gencast/README.md
new file mode 100644
index 00000000..5d963790
--- /dev/null
+++ b/graph_weather/models/gencast/README.md
@@ -0,0 +1 @@
+# GenCast
diff --git a/graph_weather/models/gencast/__init__.py b/graph_weather/models/gencast/__init__.py
new file mode 100644
index 00000000..1edcbc86
--- /dev/null
+++ b/graph_weather/models/gencast/__init__.py
@@ -0,0 +1,4 @@
+"""Main import for GenCast"""
+
+from .graph.graph_builder import GraphBuilder
+from .weighted_mse_loss import WeightedMSELoss
diff --git a/graph_weather/models/gencast/graph/__init__.py b/graph_weather/models/gencast/graph/__init__.py
new file mode 100644
index 00000000..006e11c9
--- /dev/null
+++ b/graph_weather/models/gencast/graph/__init__.py
@@ -0,0 +1 @@
+"""Utils for graph generation."""
diff --git a/graph_weather/models/gencast/graph/graph_builder.py b/graph_weather/models/gencast/graph/graph_builder.py
new file mode 100644
index 00000000..aa29ec40
--- /dev/null
+++ b/graph_weather/models/gencast/graph/graph_builder.py
@@ -0,0 +1,304 @@
+"""Build the three graphs for GenCast.
+
+The following code is a port of several components from GraphCast's original graph generation
+(https://github.com/google-deepmind/graphcast) to PyG and PyTorch. The graphs are:
+- g2m: grid to mesh.
+- mesh: icosphere refinement.
+- m2g: mesh to grid.
+- khop: k-hop neighbours mesh.
+"""
+
+import numpy as np
+import torch
+from torch_geometric.data import Data, HeteroData
+from torch_geometric.transforms import TwoHop
+
+from graph_weather.models.gencast.graph import grid_mesh_connectivity, icosahedral_mesh, model_utils
+
+# Some configs from graphcast:
+_spatial_features_kwargs = dict(
+    add_node_positions=False,
+    add_node_latitude=True,
+    add_node_longitude=True,
+    add_relative_positions=True,
+    relative_longitude_local_coordinates=True,
+    relative_latitude_local_coordinates=True,
+)
+
+# radius_query_fraction_edge_length: Scalar that will be multiplied by the
+#   length of the longest edge of the finest mesh to define the radius of
+#   connectivity to use in the Grid2Mesh graph. Reasonable values are
+#   between 0.6 and 1. 0.6 reduces the number of grid points feeding into
+#   multiple mesh nodes and therefore reduces edge count and memory use, but
+#   1 gives better predictions.
+# mesh2grid_edge_normalization_factor: Allows explicitly controlling edge
+#   normalization for mesh2grid edges. If None, defaults to max edge length.
+#   This supports using pre-trained model weights with a different graph
+#   structure to what it was trained on.
+
+radius_query_fraction_edge_length = 0.6
+mesh2grid_edge_normalization_factor = None
+
+
+def _get_max_edge_distance(mesh):
+    senders, receivers = icosahedral_mesh.faces_to_edges(mesh.faces)
+    edge_distances = np.linalg.norm(mesh.vertices[senders] - mesh.vertices[receivers], axis=-1)
+    return edge_distances.max()
+
+
+class GraphBuilder:
+    """
+    Class for building GenCast's graphs.
+
+    Attributes:
+        g2m_graph (pyg.data.HeteroData): heterogeneous directed graph connecting the grid nodes
+            to the mesh nodes.
+        mesh_graph (pyg.data.Data): undirected graph connecting the mesh nodes.
+        m2g_graph (pyg.data.HeteroData): heterogeneous directed graph connecting the mesh nodes
+            to the grid nodes.
+        khop_mesh_graph (pyg.data.Data): augmented version of mesh_graph in which every node is
+            connected to its 2^num_hops neighbours.
+        grid_nodes_dim (int): dimension of the grid nodes features.
+        mesh_nodes_dim (int): dimension of the mesh nodes features.
+        mesh_edges_dim (int): dimension of the mesh edges features.
+        g2m_edges_dim (int): dimension of the "grid to mesh" edges features.
+        m2g_edges_dim (int): dimension of the "mesh to grid" edges features.
+    """
+
+    def __init__(
+        self,
+        grid_lon: np.ndarray,
+        grid_lat: np.ndarray,
+        splits: int = 5,
+        num_hops: int = 0,
+        device: torch.device = torch.device("cpu"),
+    ):
+        """Initialize the GraphBuilder object.
+
+        Args:
+            grid_lon: 1D np.ndarray containing the list of longitudes.
+            grid_lat: 1D np.ndarray containing the list of latitudes.
+            splits: number of times to split the icosphere to build the mesh. Defaults to 5.
+            num_hops: if num_hops=k then khop_mesh_graph will be the 2^k-neighbours version of
+                the mesh. Defaults to 0.
+            device: the device to which the graph will be moved.
+        """
+
+        self._spatial_features_kwargs = _spatial_features_kwargs
+        self.add_edge_features_to_khop = True
+        self.device = device
+
+        # Specification of the mesh.
+        _icosahedral_refinements = icosahedral_mesh.get_hierarchy_of_triangular_meshes_for_sphere(
+            splits
+        )
+        self._mesh = _icosahedral_refinements[-1]
+
+        # Obtain the query radius in absolute units for the unit-sphere for the
+        # grid2mesh model, by rescaling the `radius_query_fraction_edge_length`.
+        self._query_radius = _get_max_edge_distance(self._mesh) * radius_query_fraction_edge_length
+        self._mesh2grid_edge_normalization_factor = mesh2grid_edge_normalization_factor
+
+        self.grid_nodes_dim = None
+        self.mesh_nodes_dim = None
+        self.mesh_edges_dim = None
+        self.g2m_edges_dim = None
+        self.m2g_edges_dim = None
+
+        # A "_init_mesh_properties":
+        # This one could be initialized at init but we delay it for consistency too.
+        self._num_mesh_nodes = None  # num_mesh_nodes
+        self._mesh_nodes_lat = None  # [num_mesh_nodes]
+        self._mesh_nodes_lon = None  # [num_mesh_nodes]
+
+        # A "_init_grid_properties":
+        self._grid_lat = None  # [num_lat_points]
+        self._grid_lon = None  # [num_lon_points]
+        self._num_grid_nodes = None  # num_lat_points * num_lon_points
+        self._grid_nodes_lat = None  # [num_grid_nodes]
+        self._grid_nodes_lon = None  # [num_grid_nodes]
+
+        self._init_grid_properties(grid_lat, grid_lon)
+        self._init_mesh_properties()
+        self.g2m_graph = self._init_grid2mesh_graph()
+        self.mesh_graph = self._init_mesh_graph()
+        self.m2g_graph = self._init_mesh2grid_graph()
+
+        self.num_hops = num_hops
+        self.khop_mesh_graph = self._init_khop_mesh_graph()
+
+    def _init_grid_properties(self, grid_lat: np.ndarray, grid_lon: np.ndarray):
+        """Inits static properties that have to do with grid nodes."""
+        self._grid_lat = grid_lat.astype(np.float32)
+        self._grid_lon = grid_lon.astype(np.float32)
+        # Initialized the counters.
+        self._num_grid_nodes = grid_lat.shape[0] * grid_lon.shape[0]
+
+        # Initialize lat and lon for the grid.
+        grid_nodes_lon, grid_nodes_lat = np.meshgrid(grid_lon, grid_lat)
+        self._grid_nodes_lon = grid_nodes_lon.reshape([-1]).astype(np.float32)
+        self._grid_nodes_lat = grid_nodes_lat.reshape([-1]).astype(np.float32)
+
+    def _init_mesh_properties(self):
+        """Inits static properties that have to do with mesh nodes."""
+        self._num_mesh_nodes = self._mesh.vertices.shape[0]
+        mesh_phi, mesh_theta = model_utils.cartesian_to_spherical(
+            self._mesh.vertices[:, 0], self._mesh.vertices[:, 1], self._mesh.vertices[:, 2]
+        )
+        (
+            mesh_nodes_lat,
+            mesh_nodes_lon,
+        ) = model_utils.spherical_to_lat_lon(phi=mesh_phi, theta=mesh_theta)
+        # Convert to f32 to ensure the lat/lon features aren't in f64.
+        self._mesh_nodes_lat = mesh_nodes_lat.astype(np.float32)
+        self._mesh_nodes_lon = mesh_nodes_lon.astype(np.float32)
+
+    def _init_grid2mesh_graph(self):
+        """Build Grid2Mesh graph."""
+
+        # Create some edges according to distance between mesh and grid nodes.
+        assert self._grid_lat is not None and self._grid_lon is not None
+        (grid_indices, mesh_indices) = grid_mesh_connectivity.radius_query_indices(
+            grid_latitude=self._grid_lat,
+            grid_longitude=self._grid_lon,
+            mesh=self._mesh,
+            radius=self._query_radius,
+        )
+
+        # Edges sending info from grid to mesh.
+        senders = grid_indices
+        receivers = mesh_indices
+
+        # Precompute structural node and edge features according to config options.
+        # Structural features are those that depend on the fixed values of the
+        # latitude and longitudes of the nodes.
+        (senders_node_features, receivers_node_features, edge_features) = (
+            model_utils.get_bipartite_graph_spatial_features(
+                senders_node_lat=self._grid_nodes_lat,
+                senders_node_lon=self._grid_nodes_lon,
+                receivers_node_lat=self._mesh_nodes_lat,
+                receivers_node_lon=self._mesh_nodes_lon,
+                senders=senders,
+                receivers=receivers,
+                edge_normalization_factor=None,
+                **self._spatial_features_kwargs,
+            )
+        )
+
+        self.grid_nodes_dim = senders_node_features.shape[1]
+        self.mesh_nodes_dim = receivers_node_features.shape[1]
+        self.g2m_edges_dim = edge_features.shape[1]
+
+        g2m_graph = HeteroData()
+        g2m_graph["grid_nodes"].x = torch.tensor(
+            senders_node_features, dtype=torch.float32, device=self.device
+        )  # TODO: generate graph with torch or np?
+        g2m_graph["mesh_nodes"].x = torch.tensor(
+            receivers_node_features, dtype=torch.float32, device=self.device
+        )
+        g2m_graph["grid_nodes", "to", "mesh_nodes"].edge_index = torch.tensor(
+            np.stack([senders, receivers]), dtype=torch.long, device=self.device
+        )
+        g2m_graph["grid_nodes", "to", "mesh_nodes"].edge_attr = torch.tensor(
+            edge_features, dtype=torch.float32, device=self.device
+        )
+
+        return g2m_graph
+
+    def _init_mesh_graph(self):
+        """Build Mesh graph."""
+        # Work simply on the mesh edges.
+        senders, receivers = icosahedral_mesh.faces_to_edges(self._mesh.faces)
+
+        # Precompute structural node and edge features according to config options.
+        # Structural features are those that depend on the fixed values of the
+        # latitude and longitudes of the nodes.
+        assert self._mesh_nodes_lat is not None and self._mesh_nodes_lon is not None
+        node_features, edge_features = model_utils.get_graph_spatial_features(
+            node_lat=self._mesh_nodes_lat,
+            node_lon=self._mesh_nodes_lon,
+            senders=senders,
+            receivers=receivers,
+            **self._spatial_features_kwargs,
+        )
+
+        self.mesh_edges_dim = edge_features.shape[1]
+
+        mesh_graph = Data(
+            x=torch.tensor(node_features, dtype=torch.float32, device=self.device),
+            edge_attr=torch.tensor(edge_features, dtype=torch.float32, device=self.device),
+            edge_index=torch.tensor(
+                np.stack([senders, receivers]), dtype=torch.long, device=self.device
+            ),
+        )
+
+        return mesh_graph
+
+    def _init_mesh2grid_graph(self):
+        """Build Mesh2Grid graph."""
+
+        # Create some edges according to how the grid nodes are contained by
+        # mesh triangles.
+        (grid_indices, mesh_indices) = grid_mesh_connectivity.in_mesh_triangle_indices(
+            grid_latitude=self._grid_lat, grid_longitude=self._grid_lon, mesh=self._mesh
+        )
+
+        # Edges sending info from mesh to grid.
+        senders = mesh_indices
+        receivers = grid_indices
+
+        # Precompute structural node and edge features according to config options.
+        assert self._mesh_nodes_lat is not None and self._mesh_nodes_lon is not None
+        (senders_node_features, receivers_node_features, edge_features) = (
+            model_utils.get_bipartite_graph_spatial_features(
+                senders_node_lat=self._mesh_nodes_lat,
+                senders_node_lon=self._mesh_nodes_lon,
+                receivers_node_lat=self._grid_nodes_lat,
+                receivers_node_lon=self._grid_nodes_lon,
+                senders=senders,
+                receivers=receivers,
+                edge_normalization_factor=self._mesh2grid_edge_normalization_factor,
+                **self._spatial_features_kwargs,
+            )
+        )
+
+        self.m2g_edges_dim = edge_features.shape[1]
+
+        m2g_graph = HeteroData()
+        m2g_graph["mesh_nodes"].x = torch.tensor(
+            senders_node_features, dtype=torch.float32, device=self.device
+        )
+        m2g_graph["grid_nodes"].x = torch.tensor(
+            receivers_node_features, dtype=torch.float32, device=self.device
+        )
+        m2g_graph["mesh_nodes", "to", "grid_nodes"].edge_index = torch.tensor(
+            np.stack([senders, receivers]), dtype=torch.long, device=self.device
+        )
+        m2g_graph["mesh_nodes", "to", "grid_nodes"].edge_attr = torch.tensor(
+            edge_features, dtype=torch.float32, device=self.device
+        )
+
+        return m2g_graph
+
+    def _init_khop_mesh_graph(self):
+        """Build k-hop Mesh graph."""
+
+        transform = TwoHop()
+        khop_mesh_graph = self.mesh_graph
+        for _ in range(self.num_hops):
+            khop_mesh_graph = transform(khop_mesh_graph)
+
+        if self.add_edge_features_to_khop:
+            senders = khop_mesh_graph.edge_index[0]
+            receivers = khop_mesh_graph.edge_index[1]
+            _, edge_features = model_utils.get_graph_spatial_features(
+                node_lat=self._mesh_nodes_lat,
+                node_lon=self._mesh_nodes_lon,
+                senders=senders,
+                receivers=receivers,
+                **self._spatial_features_kwargs,
+            )
+            khop_mesh_graph.edge_attr = torch.tensor(
+                edge_features, dtype=torch.float32, device=self.device
+            )
+        return khop_mesh_graph
diff --git a/graph_weather/models/gencast/graph/grid_mesh_connectivity.py b/graph_weather/models/gencast/graph/grid_mesh_connectivity.py
new file mode 100644
index 00000000..0d0b4e6c
--- /dev/null
+++ b/graph_weather/models/gencast/graph/grid_mesh_connectivity.py
@@ -0,0 +1,134 @@
+# Copyright 2023 DeepMind Technologies Limited.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Source: https://github.com/google-deepmind/graphcast.
+"""Tools for converting from regular grids on a sphere, to triangular meshes."""
+
+import numpy as np
+import scipy
+import trimesh
+
+from graph_weather.models.gencast.graph import icosahedral_mesh
+
+
+def _grid_lat_lon_to_coordinates(
+    grid_latitude: np.ndarray, grid_longitude: np.ndarray
+) -> np.ndarray:
+    """Lat [num_lat] lon [num_lon] to 3d coordinates [num_lat, num_lon, 3]."""
+    # Convert to spherical coordinates phi and theta defined in the grid.
+    # Each [num_latitude_points, num_longitude_points]
+    phi_grid, theta_grid = np.meshgrid(np.deg2rad(grid_longitude), np.deg2rad(90 - grid_latitude))
+
+    # [num_latitude_points, num_longitude_points, 3]
+    # Note this assumes unit radius, since for now we model the earth as a
+    # sphere of unit radius, and keep any vertical dimension as a regular grid.
+    return np.stack(
+        [
+            np.cos(phi_grid) * np.sin(theta_grid),
+            np.sin(phi_grid) * np.sin(theta_grid),
+            np.cos(theta_grid),
+        ],
+        axis=-1,
+    )
+
+
+def radius_query_indices(
+    *,
+    grid_latitude: np.ndarray,
+    grid_longitude: np.ndarray,
+    mesh: icosahedral_mesh.TriangularMesh,
+    radius: float
+) -> tuple[np.ndarray, np.ndarray]:
+    """Returns mesh-grid edge indices for radius query.
+
+    Args:
+      grid_latitude: Latitude values for the grid [num_lat_points]
+      grid_longitude: Longitude values for the grid [num_lon_points]
+      mesh: Mesh object.
+      radius: Radius of connectivity in R3. for a sphere of unit radius.
+
+    Returns:
+      tuple with `grid_indices` and `mesh_indices` indicating edges between the
+      grid and the mesh such that the distances in a straight line (not geodesic)
+      are smaller than or equal to `radius`.
+      * grid_indices: Indices of shape [num_edges], that index into a
+        [num_lat_points, num_lon_points] grid, after flattening the leading axes.
+      * mesh_indices: Indices of shape [num_edges], that index into mesh.vertices.
+    """
+
+    # [num_grid_points=num_lat_points * num_lon_points, 3]
+    grid_positions = _grid_lat_lon_to_coordinates(grid_latitude, grid_longitude).reshape([-1, 3])
+
+    # [num_mesh_points, 3]
+    mesh_positions = mesh.vertices
+    kd_tree = scipy.spatial.cKDTree(mesh_positions)
+
+    # [num_grid_points, num_mesh_points_per_grid_point]
+    # Note `num_mesh_points_per_grid_point` is not constant, so this is a list
+    # of arrays, rather than a 2d array.
+    query_indices = kd_tree.query_ball_point(x=grid_positions, r=radius)
+
+    grid_edge_indices = []
+    mesh_edge_indices = []
+    for grid_index, mesh_neighbors in enumerate(query_indices):
+        grid_edge_indices.append(np.repeat(grid_index, len(mesh_neighbors)))
+        mesh_edge_indices.append(mesh_neighbors)
+
+    # [num_edges]
+    grid_edge_indices = np.concatenate(grid_edge_indices, axis=0).astype(int)
+    mesh_edge_indices = np.concatenate(mesh_edge_indices, axis=0).astype(int)
+
+    return grid_edge_indices, mesh_edge_indices
+
+
+def in_mesh_triangle_indices(
+    *, grid_latitude: np.ndarray, grid_longitude: np.ndarray, mesh: icosahedral_mesh.TriangularMesh
+) -> tuple[np.ndarray, np.ndarray]:
+    """Returns mesh-grid edge indices for grid points contained in mesh triangles.
+
+    Args:
+      grid_latitude: Latitude values for the grid [num_lat_points]
+      grid_longitude: Longitude values for the grid [num_lon_points]
+      mesh: Mesh object.
+
+    Returns:
+      tuple with `grid_indices` and `mesh_indices` indicating edges between the
+      grid and the mesh vertices of the triangle that contain each grid point.
+      The number of edges is always num_lat_points * num_lon_points * 3
+      * grid_indices: Indices of shape [num_edges], that index into a
+        [num_lat_points, num_lon_points] grid, after flattening the leading axes.
+      * mesh_indices: Indices of shape [num_edges], that index into mesh.vertices.
+    """
+
+    # [num_grid_points=num_lat_points * num_lon_points, 3]
+    grid_positions = _grid_lat_lon_to_coordinates(grid_latitude, grid_longitude).reshape([-1, 3])
+
+    mesh_trimesh = trimesh.Trimesh(vertices=mesh.vertices, faces=mesh.faces)
+
+    # [num_grid_points] with mesh face indices for each grid point.
+    _, _, query_face_indices = trimesh.proximity.closest_point(mesh_trimesh, grid_positions)
+
+    # [num_grid_points, 3] with mesh node indices for each grid point.
+    mesh_edge_indices = mesh.faces[query_face_indices]
+
+    # [num_grid_points, 3] with grid node indices, where every row simply contains
+    # the row (grid_point) index.
+    grid_indices = np.arange(grid_positions.shape[0])
+    grid_edge_indices = np.tile(grid_indices.reshape([-1, 1]), [1, 3])
+
+    # Flatten to get a regular list.
+    # [num_edges=num_grid_points*3]
+    mesh_edge_indices = mesh_edge_indices.reshape([-1])
+    grid_edge_indices = grid_edge_indices.reshape([-1])
+
+    return grid_edge_indices, mesh_edge_indices
diff --git a/graph_weather/models/gencast/graph/icosahedral_mesh.py b/graph_weather/models/gencast/graph/icosahedral_mesh.py
new file mode 100644
index 00000000..f821d274
--- /dev/null
+++ b/graph_weather/models/gencast/graph/icosahedral_mesh.py
@@ -0,0 +1,264 @@
+# Copyright 2023 DeepMind Technologies Limited.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Source: https://github.com/google-deepmind/graphcast.
+"""Utils for creating icosahedral meshes."""
+
+from typing import List, NamedTuple, Tuple
+
+import numpy as np
+from scipy.spatial import transform
+
+
+class TriangularMesh(NamedTuple):
+    """Data structure for triangular meshes.
+
+    Attributes:
+      vertices: spatial positions of the vertices of the mesh of shape
+          [num_vertices, num_dims].
+      faces: triangular faces of the mesh of shape [num_faces, 3]. Contains
+          integer indices into `vertices`.
+
+    """
+
+    vertices: np.ndarray
+    faces: np.ndarray
+
+
+def get_hierarchy_of_triangular_meshes_for_sphere(splits: int) -> List[TriangularMesh]:
+    """Returns a sequence of meshes, each with triangularization sphere.
+
+    Starting with a regular icosahedron (12 vertices, 20 faces, 30 edges) with
+    circumscribed unit sphere. Then, each triangular face is iteratively
+    subdivided into 4 triangular faces `splits` times. The new vertices are then
+    projected back onto the unit sphere. All resulting meshes are returned in a
+    list, from lowest to highest resolution.
+
+    The vertices in each face are specified in counter-clockwise order as
+    observed from the outside the icosahedron.
+
+    Args:
+       splits: How many times to split each triangle.
+
+    Returns:
+       Sequence of `TriangularMesh`s of length `splits + 1` each with:
+
+         vertices: [num_vertices, 3] vertex positions in 3D, all with unit norm.
+         faces: [num_faces, 3] with triangular faces joining sets of 3 vertices.
+             Each row contains three indices into the vertices array, indicating
+             the vertices adjacent to the face. Always with positive orientation
+             (counterclock-wise when looking from the outside).
+    """
+    current_mesh = get_icosahedron()
+    output_meshes = [current_mesh]
+    for _ in range(splits):
+        current_mesh = _two_split_unit_sphere_triangle_faces(current_mesh)
+        output_meshes.append(current_mesh)
+    return output_meshes
+
+
+def get_icosahedron() -> TriangularMesh:
+    """Returns a regular icosahedral mesh with circumscribed unit sphere.
+
+    See https://en.wikipedia.org/wiki/Regular_icosahedron#Cartesian_coordinates
+    for details on the construction of the regular icosahedron.
+
+    The vertices in each face are specified in counter-clockwise order as observed
+    from the outside of the icosahedron.
+
+    Returns:
+       TriangularMesh with:
+
+       vertices: [num_vertices=12, 3] vertex positions in 3D, all with unit norm.
+       faces: [num_faces=20, 3] with triangular faces joining sets of 3 vertices.
+           Each row contains three indices into the vertices array, indicating
+           the vertices adjacent to the face. Always with positive orientation (
+           counterclock-wise when looking from the outside).
+
+    """
+    phi = (1 + np.sqrt(5)) / 2
+    vertices = []
+    for c1 in [1.0, -1.0]:
+        for c2 in [phi, -phi]:
+            vertices.append((c1, c2, 0.0))
+            vertices.append((0.0, c1, c2))
+            vertices.append((c2, 0.0, c1))
+
+    vertices = np.array(vertices, dtype=np.float32)
+    vertices /= np.linalg.norm([1.0, phi])
+
+    # I did this manually, checking the orientation one by one.
+    faces = [
+        (0, 1, 2),
+        (0, 6, 1),
+        (8, 0, 2),
+        (8, 4, 0),
+        (3, 8, 2),
+        (3, 2, 7),
+        (7, 2, 1),
+        (0, 4, 6),
+        (4, 11, 6),
+        (6, 11, 5),
+        (1, 5, 7),
+        (4, 10, 11),
+        (4, 8, 10),
+        (10, 8, 3),
+        (10, 3, 9),
+        (11, 10, 9),
+        (11, 9, 5),
+        (5, 9, 7),
+        (9, 3, 7),
+        (1, 6, 5),
+    ]
+
+    # By default the top is an aris parallel to the Y axis.
+    # Need to rotate around the y axis by half the supplementary to the
+    # angle between faces divided by two to get the desired orientation.
+    #                          /O\  (top arist)
+    #                     /          \                           Z
+    # (adjacent face)/                    \  (adjacent face)     ^
+    #           /     angle_between_faces      \                 |
+    #      /                                        \            |
+    #  /                                                 \      YO-----> X
+    # This results in:
+    #  (adjacent faceis now top plane)
+    #  ----------------------O\  (top arist)
+    #                           \
+    #                             \
+    #                               \     (adjacent face)
+    #                                 \
+    #                                   \
+    #                                     \
+
+    angle_between_faces = 2 * np.arcsin(phi / np.sqrt(3))
+    rotation_angle = (np.pi - angle_between_faces) / 2
+    rotation = transform.Rotation.from_euler(seq="y", angles=rotation_angle)
+    rotation_matrix = rotation.as_matrix()
+    vertices = np.dot(vertices, rotation_matrix)
+
+    return TriangularMesh(
+        vertices=vertices.astype(np.float32), faces=np.array(faces, dtype=np.int32)
+    )
+
+
+def _two_split_unit_sphere_triangle_faces(triangular_mesh: TriangularMesh) -> TriangularMesh:
+    """Splits each triangular face into 4 triangles keeping the orientation."""
+
+    # Every time we split a triangle into 4 we will be adding 3 extra vertices,
+    # located at the edge centres.
+    # This class handles the positioning of the new vertices, and avoids creating
+    # duplicates.
+    new_vertices_builder = _ChildVerticesBuilder(triangular_mesh.vertices)
+
+    new_faces = []
+    for ind1, ind2, ind3 in triangular_mesh.faces:
+        # Transform each triangular face into 4 triangles,
+        # preserving the orientation.
+        #                    ind3
+        #                   /    \
+        #                /          \
+        #              /      #3       \
+        #            /                  \
+        #         ind31 -------------- ind23
+        #         /   \                /   \
+        #       /       \     #4     /      \
+        #     /    #1     \        /    #2    \
+        #   /               \    /              \
+        # ind1 ------------ ind12 ------------ ind2
+        ind12 = new_vertices_builder.get_new_child_vertex_index((ind1, ind2))
+        ind23 = new_vertices_builder.get_new_child_vertex_index((ind2, ind3))
+        ind31 = new_vertices_builder.get_new_child_vertex_index((ind3, ind1))
+        # Note how each of the 4 triangular new faces specifies the order of the
+        # vertices to preserve the orientation of the original face. As the input
+        # face should always be counter-clockwise as specified in the diagram,
+        # this means child faces should also be counter-clockwise.
+        new_faces.extend(
+            [
+                [ind1, ind12, ind31],  # 1
+                [ind12, ind2, ind23],  # 2
+                [ind31, ind23, ind3],  # 3
+                [ind12, ind23, ind31],  # 4
+            ]
+        )
+    return TriangularMesh(
+        vertices=new_vertices_builder.get_all_vertices(), faces=np.array(new_faces, dtype=np.int32)
+    )
+
+
+class _ChildVerticesBuilder(object):
+    """Bookkeeping of new child vertices added to an existing set of vertices."""
+
+    def __init__(self, parent_vertices):
+        # Because the same new vertex will be required when splitting adjacent
+        # triangles (which share an edge) we keep them in a hash table indexed by
+        # sorted indices of the vertices adjacent to the edge, to avoid creating
+        # duplicated child vertices.
+        self._child_vertices_index_mapping = {}
+        self._parent_vertices = parent_vertices
+        # We start with all previous vertices.
+        self._all_vertices_list = list(parent_vertices)
+
+    def _get_child_vertex_key(self, parent_vertex_indices):
+        return tuple(sorted(parent_vertex_indices))
+
+    def _create_child_vertex(self, parent_vertex_indices):
+        """Creates a new vertex."""
+        # Position for new vertex is the middle point, between the parent points,
+        # projected to unit sphere.
+        child_vertex_position = self._parent_vertices[list(parent_vertex_indices)].mean(0)
+        child_vertex_position /= np.linalg.norm(child_vertex_position)
+
+        # Add the vertex to the output list. The index for this new vertex will
+        # match the length of the list before adding it.
+        child_vertex_key = self._get_child_vertex_key(parent_vertex_indices)
+        self._child_vertices_index_mapping[child_vertex_key] = len(self._all_vertices_list)
+        self._all_vertices_list.append(child_vertex_position)
+
+    def get_new_child_vertex_index(self, parent_vertex_indices):
+        """Returns index for a child vertex, creating it if necessary."""
+        # Get the key to see if we already have a new vertex in the middle.
+        child_vertex_key = self._get_child_vertex_key(parent_vertex_indices)
+        if child_vertex_key not in self._child_vertices_index_mapping:
+            self._create_child_vertex(parent_vertex_indices)
+        return self._child_vertices_index_mapping[child_vertex_key]
+
+    def get_all_vertices(self):
+        """Returns an array with old vertices."""
+        return np.array(self._all_vertices_list)
+
+
+def faces_to_edges(faces: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    """Transforms polygonal faces to sender and receiver indices.
+
+    It does so by transforming every face into N_i edges. Such if the triangular
+    face has indices [0, 1, 2], three edges are added 0->1, 1->2, and 2->0.
+
+    If all faces have consistent orientation, and the surface represented by the
+    faces is closed, then every edge in a polygon with a certain orientation
+    is also part of another polygon with the opposite orientation. In this
+    situation, the edges returned by the method are always bidirectional.
+
+    Args:
+      faces: Integer array of shape [num_faces, 3]. Contains node indices
+          adjacent to each face.
+
+    Returns:
+      Tuple with sender/receiver indices, each of shape [num_edges=num_faces*3].
+
+    """
+    assert faces.ndim == 2
+    assert faces.shape[-1] == 3
+    senders = np.concatenate([faces[:, 0], faces[:, 1], faces[:, 2]])
+    receivers = np.concatenate([faces[:, 1], faces[:, 2], faces[:, 0]])
+    return senders, receivers
diff --git a/graph_weather/models/gencast/graph/model_utils.py b/graph_weather/models/gencast/graph/model_utils.py
new file mode 100644
index 00000000..a91fec51
--- /dev/null
+++ b/graph_weather/models/gencast/graph/model_utils.py
@@ -0,0 +1,734 @@
+# Copyright 2023 DeepMind Technologies Limited.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Source: https://github.com/google-deepmind/graphcast.
+"""Utilities for building models."""
+
+from typing import Mapping, Optional, Tuple
+
+import numpy as np
+import xarray
+from scipy.spatial import transform
+
+
+def get_graph_spatial_features(
+    *,
+    node_lat: np.ndarray,
+    node_lon: np.ndarray,
+    senders: np.ndarray,
+    receivers: np.ndarray,
+    add_node_positions: bool,
+    add_node_latitude: bool,
+    add_node_longitude: bool,
+    add_relative_positions: bool,
+    relative_longitude_local_coordinates: bool,
+    relative_latitude_local_coordinates: bool,
+    sine_cosine_encoding: bool = False,
+    encoding_num_freqs: int = 10,
+    encoding_multiplicative_factor: float = 1.2,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Computes spatial features for the nodes.
+
+    Args:
+      node_lat: Latitudes in the [-90, 90] interval of shape [num_nodes]
+      node_lon: Longitudes in the [0, 360] interval of shape [num_nodes]
+      senders: Sender indices of shape [num_edges]
+      receivers: Receiver indices of shape [num_edges]
+      add_node_positions: Add unit norm absolute positions.
+      add_node_latitude: Add a feature for latitude (cos(90 - lat))
+          Note even if this is set to False, the model may be able to infer the
+          longitude from relative features, unless
+          `relative_latitude_local_coordinates` is also True, or if there is any
+          bias on the relative edge sizes for different longitudes.
+      add_node_longitude: Add features for longitude (cos(lon), sin(lon)).
+          Note even if this is set to False, the model may be able to infer the
+          longitude from relative features, unless
+          `relative_longitude_local_coordinates` is also True, or if there is any
+          bias on the relative edge sizes for different longitudes.
+      add_relative_positions: Whether to relative positions in R3 to the edges.
+      relative_longitude_local_coordinates: If True, relative positions are
+          computed in a local space where the receiver is at 0 longitude.
+      relative_latitude_local_coordinates: If True, relative positions are
+          computed in a local space where the receiver is at 0 latitude.
+      sine_cosine_encoding: If True, we will transform the node/edge features
+          with sine and cosine functions, similar to NERF.
+      encoding_num_freqs: frequency parameter
+      encoding_multiplicative_factor: used for calculating the frequency.
+
+    Returns:
+      Arrays of shape: [num_nodes, num_features] and [num_edges, num_features].
+      with node and edge features.
+
+    """
+
+    num_nodes = node_lat.shape[0]
+    num_edges = senders.shape[0]
+    dtype = node_lat.dtype
+    node_phi, node_theta = lat_lon_deg_to_spherical(node_lat, node_lon)
+
+    # Computing some node features.
+    node_features = []
+    if add_node_positions:
+        # Already in [-1, 1.] range.
+        node_features.extend(spherical_to_cartesian(node_phi, node_theta))
+
+    if add_node_latitude:
+        # Using the cos of theta.
+        # From 1. (north pole) to -1 (south pole).
+        node_features.append(np.cos(node_theta))
+
+    if add_node_longitude:
+        # Using the cos and sin, which is already normalized.
+        node_features.append(np.cos(node_phi))
+        node_features.append(np.sin(node_phi))
+
+    if not node_features:
+        node_features = np.zeros([num_nodes, 0], dtype=dtype)
+    else:
+        node_features = np.stack(node_features, axis=-1)
+
+    # Computing some edge features.
+    edge_features = []
+
+    if add_relative_positions:
+        relative_position = get_relative_position_in_receiver_local_coordinates(
+            node_phi=node_phi,
+            node_theta=node_theta,
+            senders=senders,
+            receivers=receivers,
+            latitude_local_coordinates=relative_latitude_local_coordinates,
+            longitude_local_coordinates=relative_longitude_local_coordinates,
+        )
+
+        # Note this is L2 distance in 3d space, rather than geodesic distance.
+        relative_edge_distances = np.linalg.norm(relative_position, axis=-1, keepdims=True)
+
+        # Normalize to the maximum edge distance. Note that we expect to always
+        # have an edge that goes in the opposite direction of any given edge
+        # so the distribution of relative positions should be symmetric around
+        # zero. So by scaling by the maximum length, we expect all relative
+        # positions to fall in the [-1., 1.] interval, and all relative distances
+        # to fall in the [0., 1.] interval.
+        max_edge_distance = relative_edge_distances.max()
+        edge_features.append(relative_edge_distances / max_edge_distance)
+        edge_features.append(relative_position / max_edge_distance)
+
+    if not edge_features:
+        edge_features = np.zeros([num_edges, 0], dtype=dtype)
+    else:
+        edge_features = np.concatenate(edge_features, axis=-1)
+
+    if sine_cosine_encoding:
+
+        def sine_cosine_transform(x: np.ndarray) -> np.ndarray:
+            freqs = encoding_multiplicative_factor ** np.arange(encoding_num_freqs)
+            phases = freqs * x[..., None]
+            x_sin = np.sin(phases)
+            x_cos = np.cos(phases)
+            x_cat = np.concatenate([x_sin, x_cos], axis=-1)
+            return x_cat.reshape([x.shape[0], -1])
+
+        node_features = sine_cosine_transform(node_features)
+        edge_features = sine_cosine_transform(edge_features)
+
+    return node_features, edge_features
+
+
+def lat_lon_to_leading_axes(grid_xarray: xarray.DataArray) -> xarray.DataArray:
+    """Reorders xarray so lat/lon axes come first."""
+    # leading + ["lat", "lon"] + trailing
+    # to
+    # ["lat", "lon"] + leading + trailing
+    return grid_xarray.transpose("lat", "lon", ...)
+
+
+def restore_leading_axes(grid_xarray: xarray.DataArray) -> xarray.DataArray:
+    """Reorders xarray so batch/time/level axes come first (if present)."""
+
+    # ["lat", "lon"] + [(batch,) (time,) (level,)] + trailing
+    # to
+    # [(batch,) (time,) (level,)] + ["lat", "lon"] + trailing
+
+    input_dims = list(grid_xarray.dims)
+    output_dims = list(input_dims)
+    for leading_key in ["level", "time", "batch"]:  # reverse order for insert
+        if leading_key in input_dims:
+            output_dims.remove(leading_key)
+            output_dims.insert(0, leading_key)
+    return grid_xarray.transpose(*output_dims)
+
+
+def lat_lon_deg_to_spherical(
+    node_lat: np.ndarray,
+    node_lon: np.ndarray,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Convert lat and lon to spherical coordiantes."""
+    phi = np.deg2rad(node_lon)
+    theta = np.deg2rad(90 - node_lat)
+    return phi, theta
+
+
+def spherical_to_lat_lon(
+    phi: np.ndarray,
+    theta: np.ndarray,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Convert spherical coordinates to lat and lon."""
+    lon = np.mod(np.rad2deg(phi), 360)
+    lat = 90 - np.rad2deg(theta)
+    return lat, lon
+
+
+def cartesian_to_spherical(
+    x: np.ndarray,
+    y: np.ndarray,
+    z: np.ndarray,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Convert cartesian coordinates to spherical."""
+    phi = np.arctan2(y, x)
+    with np.errstate(invalid="ignore"):  # circumventing b/253179568
+        theta = np.arccos(z)  # Assuming unit radius.
+    return phi, theta
+
+
+def spherical_to_cartesian(
+    phi: np.ndarray, theta: np.ndarray
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Convert spherical coordinates to cartesian."""
+    # Assuming unit radius.
+    return (np.cos(phi) * np.sin(theta), np.sin(phi) * np.sin(theta), np.cos(theta))
+
+
+def get_relative_position_in_receiver_local_coordinates(
+    node_phi: np.ndarray,
+    node_theta: np.ndarray,
+    senders: np.ndarray,
+    receivers: np.ndarray,
+    latitude_local_coordinates: bool,
+    longitude_local_coordinates: bool,
+) -> np.ndarray:
+    """Returns relative position features for the edges.
+
+    The relative positions will be computed in a rotated space for a local
+    coordinate system as defined by the receiver. The relative positions are
+    simply obtained by subtracting sender position minues receiver position in
+    that local coordinate system after the rotation in R^3.
+
+    Args:
+      node_phi: [num_nodes] with polar angles.
+      node_theta: [num_nodes] with azimuthal angles.
+      senders: [num_edges] with indices.
+      receivers: [num_edges] with indices.
+      latitude_local_coordinates: Whether to rotate edges such that in the
+          positions are computed such that the receiver is always at latitude 0.
+      longitude_local_coordinates: Whether to rotate edges such that in the
+          positions are computed such that the receiver is always at longitude 0.
+
+    Returns:
+      Array of relative positions in R3 [num_edges, 3]
+    """
+
+    node_pos = np.stack(spherical_to_cartesian(node_phi, node_theta), axis=-1)
+
+    # No rotation in this case.
+    if not (latitude_local_coordinates or longitude_local_coordinates):
+        return node_pos[senders] - node_pos[receivers]
+
+    # Get rotation matrices for the local space space for every node.
+    rotation_matrices = get_rotation_matrices_to_local_coordinates(
+        reference_phi=node_phi,
+        reference_theta=node_theta,
+        rotate_latitude=latitude_local_coordinates,
+        rotate_longitude=longitude_local_coordinates,
+    )
+
+    # Each edge will be rotated according to the rotation matrix of its receiver
+    # node.
+    edge_rotation_matrices = rotation_matrices[receivers]
+
+    # Rotate all nodes to the rotated space of the corresponding edge.
+    # Note for receivers we can also do the matmul first and the gather second:
+    # ```
+    # receiver_pos_in_rotated_space = rotate_with_matrices(
+    #    rotation_matrices, node_pos)[receivers]
+    # ```
+    # which is more efficient, however, we do gather first to keep it more
+    # symmetric with the sender computation.
+    receiver_pos_in_rotated_space = rotate_with_matrices(
+        edge_rotation_matrices, node_pos[receivers]
+    )
+    sender_pos_in_in_rotated_space = rotate_with_matrices(edge_rotation_matrices, node_pos[senders])
+    # Note, here, that because the rotated space is chosen according to the
+    # receiver, if:
+    # * latitude_local_coordinates = True: latitude for the receivers will be
+    #   0, that is the z coordinate will always be 0.
+    # * longitude_local_coordinates = True: longitude for the receivers will be
+    #   0, that is the y coordinate will be 0.
+
+    # Now we can just subtract.
+    # Note we are rotating to a local coordinate system, where the y-z axes are
+    # parallel to a tangent plane to the sphere, but still remain in a 3d space.
+    # Note that if both `latitude_local_coordinates` and
+    # `longitude_local_coordinates` are True, and edges are short,
+    # then the difference in x coordinate between sender and receiver
+    # should be small, so we could consider dropping the new x coordinate if
+    # we wanted to the tangent plane, however in doing so
+    # we would lose information about the curvature of the mesh, which may be
+    # important for very coarse meshes.
+    return sender_pos_in_in_rotated_space - receiver_pos_in_rotated_space
+
+
+def get_rotation_matrices_to_local_coordinates(
+    reference_phi: np.ndarray,
+    reference_theta: np.ndarray,
+    rotate_latitude: bool,
+    rotate_longitude: bool,
+) -> np.ndarray:
+    """Returns a rotation matrix to rotate to a point based on a reference vector.
+
+    The rotation matrix is build such that, a vector in the
+    same coordinate system at the reference point that points towards the pole
+    before the rotation, continues to point towards the pole after the rotation.
+
+    Args:
+      reference_phi: [leading_axis] Polar angles of the reference.
+      reference_theta: [leading_axis] Azimuthal angles of the reference.
+      rotate_latitude: Whether to produce a rotation matrix that would rotate
+          R^3 vectors to zero latitude.
+      rotate_longitude: Whether to produce a rotation matrix that would rotate
+          R^3 vectors to zero longitude.
+
+    Returns:
+      Matrices of shape [leading_axis] such that when applied to the reference
+          position with `rotate_with_matrices(rotation_matrices, reference_pos)`
+
+          * phi goes to 0. if "rotate_longitude" is True.
+
+          * theta goes to np.pi / 2 if "rotate_latitude" is True.
+
+          The rotation consists of:
+          * rotate_latitude = False, rotate_longitude = True:
+              Latitude preserving rotation.
+          * rotate_latitude = True, rotate_longitude = True:
+              Latitude preserving rotation, followed by longitude preserving
+              rotation.
+          * rotate_latitude = True, rotate_longitude = False:
+              Latitude preserving rotation, followed by longitude preserving
+              rotation, and the inverse of the latitude preserving rotation. Note
+              this is computationally different from rotating the longitude only
+              and is. We do it like this, so the polar geodesic curve, continues
+              to be aligned with one of the axis after the rotation.
+
+    """
+
+    if rotate_longitude and rotate_latitude:
+        # We first rotate around the z axis "minus the azimuthal angle", to get the
+        # point with zero longitude
+        azimuthal_rotation = -reference_phi
+
+        # One then we will do a polar rotation (which can be done along the y
+        # axis now that we are at longitude 0.), "minus the polar angle plus 2pi"
+        # to get the point with zero latitude.
+        polar_rotation = -reference_theta + np.pi / 2
+
+        return transform.Rotation.from_euler(
+            "zy", np.stack([azimuthal_rotation, polar_rotation], axis=1)
+        ).as_matrix()
+    elif rotate_longitude:
+        # Just like the previous case, but applying only the azimuthal rotation.
+        azimuthal_rotation = -reference_phi
+        return transform.Rotation.from_euler("z", -reference_phi).as_matrix()
+    elif rotate_latitude:
+        # Just like the first case, but after doing the polar rotation, undoing
+        # the azimuthal rotation.
+        azimuthal_rotation = -reference_phi
+        polar_rotation = -reference_theta + np.pi / 2
+
+        return transform.Rotation.from_euler(
+            "zyz", np.stack([azimuthal_rotation, polar_rotation, -azimuthal_rotation], axis=1)
+        ).as_matrix()
+    else:
+        raise ValueError("At least one of longitude and latitude should be rotated.")
+
+
+def rotate_with_matrices(rotation_matrices: np.ndarray, positions: np.ndarray) -> np.ndarray:
+    """Rotate with matrices."""
+    return np.einsum("bji,bi->bj", rotation_matrices, positions)
+
+
+def get_bipartite_graph_spatial_features(
+    *,
+    senders_node_lat: np.ndarray,
+    senders_node_lon: np.ndarray,
+    senders: np.ndarray,
+    receivers_node_lat: np.ndarray,
+    receivers_node_lon: np.ndarray,
+    receivers: np.ndarray,
+    add_node_positions: bool,
+    add_node_latitude: bool,
+    add_node_longitude: bool,
+    add_relative_positions: bool,
+    edge_normalization_factor: Optional[float] = None,
+    relative_longitude_local_coordinates: bool,
+    relative_latitude_local_coordinates: bool,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Computes spatial features for the nodes.
+
+    This function is almost identical to `get_graph_spatial_features`. The only
+    difference is that sender nodes and receiver nodes can be in different arrays.
+    This is necessary to enable combination with typed Graph.
+
+    Args:
+      senders_node_lat: Latitudes in the [-90, 90] interval of shape
+        [num_sender_nodes]
+      senders_node_lon: Longitudes in the [0, 360] interval of shape
+        [num_sender_nodes]
+      senders: Sender indices of shape [num_edges], indices in [0,
+        num_sender_nodes)
+      receivers_node_lat: Latitudes in the [-90, 90] interval of shape
+        [num_receiver_nodes]
+      receivers_node_lon: Longitudes in the [0, 360] interval of shape
+        [num_receiver_nodes]
+      receivers: Receiver indices of shape [num_edges], indices in [0,
+        num_receiver_nodes)
+      add_node_positions: Add unit norm absolute positions.
+      add_node_latitude: Add a feature for latitude (cos(90 - lat)) Note even if
+        this is set to False, the model may be able to infer the longitude from
+        relative features, unless `relative_latitude_local_coordinates` is also
+        True, or if there is any bias on the relative edge sizes for different
+        longitudes.
+      add_node_longitude: Add features for longitude (cos(lon), sin(lon)). Note
+        even if this is set to False, the model may be able to infer the longitude
+        from relative features, unless `relative_longitude_local_coordinates` is
+        also True, or if there is any bias on the relative edge sizes for
+        different longitudes.
+      add_relative_positions: Whether to relative positions in R3 to the edges.
+      edge_normalization_factor: Allows explicitly controlling edge normalization.
+        If None, defaults to max edge length. This supports using pre-trained
+        model weights with a different graph structure to what it was trained on.
+      relative_longitude_local_coordinates: If True, relative positions are
+        computed in a local space where the receiver is at 0 longitude.
+      relative_latitude_local_coordinates: If True, relative positions are
+        computed in a local space where the receiver is at 0 latitude.
+
+    Returns:
+      Arrays of shape: [num_nodes, num_features] and [num_edges, num_features].
+      with node and edge features.
+
+    """
+
+    num_senders = senders_node_lat.shape[0]
+    num_receivers = receivers_node_lat.shape[0]
+    num_edges = senders.shape[0]
+    dtype = senders_node_lat.dtype
+    assert receivers_node_lat.dtype == dtype
+    senders_node_phi, senders_node_theta = lat_lon_deg_to_spherical(
+        senders_node_lat, senders_node_lon
+    )
+    receivers_node_phi, receivers_node_theta = lat_lon_deg_to_spherical(
+        receivers_node_lat, receivers_node_lon
+    )
+
+    # Computing some node features.
+    senders_node_features = []
+    receivers_node_features = []
+    if add_node_positions:
+        # Already in [-1, 1.] range.
+        senders_node_features.extend(spherical_to_cartesian(senders_node_phi, senders_node_theta))
+        receivers_node_features.extend(
+            spherical_to_cartesian(receivers_node_phi, receivers_node_theta)
+        )
+
+    if add_node_latitude:
+        # Using the cos of theta.
+        # From 1. (north pole) to -1 (south pole).
+        senders_node_features.append(np.cos(senders_node_theta))
+        receivers_node_features.append(np.cos(receivers_node_theta))
+
+    if add_node_longitude:
+        # Using the cos and sin, which is already normalized.
+        senders_node_features.append(np.cos(senders_node_phi))
+        senders_node_features.append(np.sin(senders_node_phi))
+
+        receivers_node_features.append(np.cos(receivers_node_phi))
+        receivers_node_features.append(np.sin(receivers_node_phi))
+
+    if not senders_node_features:
+        senders_node_features = np.zeros([num_senders, 0], dtype=dtype)
+        receivers_node_features = np.zeros([num_receivers, 0], dtype=dtype)
+    else:
+        senders_node_features = np.stack(senders_node_features, axis=-1)
+        receivers_node_features = np.stack(receivers_node_features, axis=-1)
+
+    # Computing some edge features.
+    edge_features = []
+
+    if add_relative_positions:
+        relative_position = get_bipartite_relative_position_in_receiver_local_coordinates(  # pylint: disable=line-too-long
+            senders_node_phi=senders_node_phi,
+            senders_node_theta=senders_node_theta,
+            receivers_node_phi=receivers_node_phi,
+            receivers_node_theta=receivers_node_theta,
+            senders=senders,
+            receivers=receivers,
+            latitude_local_coordinates=relative_latitude_local_coordinates,
+            longitude_local_coordinates=relative_longitude_local_coordinates,
+        )
+
+        # Note this is L2 distance in 3d space, rather than geodesic distance.
+        relative_edge_distances = np.linalg.norm(relative_position, axis=-1, keepdims=True)
+
+        if edge_normalization_factor is None:
+            # Normalize to the maximum edge distance. Note that we expect to always
+            # have an edge that goes in the opposite direction of any given edge
+            # so the distribution of relative positions should be symmetric around
+            # zero. So by scaling by the maximum length, we expect all relative
+            # positions to fall in the [-1., 1.] interval, and all relative distances
+            # to fall in the [0., 1.] interval.
+            edge_normalization_factor = relative_edge_distances.max()
+
+        edge_features.append(relative_edge_distances / edge_normalization_factor)
+        edge_features.append(relative_position / edge_normalization_factor)
+
+    if not edge_features:
+        edge_features = np.zeros([num_edges, 0], dtype=dtype)
+    else:
+        edge_features = np.concatenate(edge_features, axis=-1)
+
+    return senders_node_features, receivers_node_features, edge_features
+
+
+def get_bipartite_relative_position_in_receiver_local_coordinates(
+    senders_node_phi: np.ndarray,
+    senders_node_theta: np.ndarray,
+    senders: np.ndarray,
+    receivers_node_phi: np.ndarray,
+    receivers_node_theta: np.ndarray,
+    receivers: np.ndarray,
+    latitude_local_coordinates: bool,
+    longitude_local_coordinates: bool,
+) -> np.ndarray:
+    """Returns relative position features for the edges.
+
+    This function is equivalent to
+    `get_relative_position_in_receiver_local_coordinates`, but adapted to work
+    with bipartite typed graphs.
+
+    The relative positions will be computed in a rotated space for a local
+    coordinate system as defined by the receiver. The relative positions are
+    simply obtained by subtracting sender position minues receiver position in
+    that local coordinate system after the rotation in R^3.
+
+    Args:
+      senders_node_phi: [num_sender_nodes] with polar angles.
+      senders_node_theta: [num_sender_nodes] with azimuthal angles.
+      senders: [num_edges] with indices into sender nodes.
+      receivers_node_phi: [num_sender_nodes] with polar angles.
+      receivers_node_theta: [num_sender_nodes] with azimuthal angles.
+      receivers: [num_edges] with indices into receiver nodes.
+      latitude_local_coordinates: Whether to rotate edges such that in the
+        positions are computed such that the receiver is always at latitude 0.
+      longitude_local_coordinates: Whether to rotate edges such that in the
+        positions are computed such that the receiver is always at longitude 0.
+
+    Returns:
+      Array of relative positions in R3 [num_edges, 3]
+    """
+
+    senders_node_pos = np.stack(
+        spherical_to_cartesian(senders_node_phi, senders_node_theta), axis=-1
+    )
+
+    receivers_node_pos = np.stack(
+        spherical_to_cartesian(receivers_node_phi, receivers_node_theta), axis=-1
+    )
+
+    # No rotation in this case.
+    if not (latitude_local_coordinates or longitude_local_coordinates):
+        return senders_node_pos[senders] - receivers_node_pos[receivers]
+
+    # Get rotation matrices for the local space space for every receiver node.
+    receiver_rotation_matrices = get_rotation_matrices_to_local_coordinates(
+        reference_phi=receivers_node_phi,
+        reference_theta=receivers_node_theta,
+        rotate_latitude=latitude_local_coordinates,
+        rotate_longitude=longitude_local_coordinates,
+    )
+
+    # Each edge will be rotated according to the rotation matrix of its receiver
+    # node.
+    edge_rotation_matrices = receiver_rotation_matrices[receivers]
+
+    # Rotate all nodes to the rotated space of the corresponding edge.
+    # Note for receivers we can also do the matmul first and the gather second:
+    # ```
+    # receiver_pos_in_rotated_space = rotate_with_matrices(
+    #    rotation_matrices, node_pos)[receivers]
+    # ```
+    # which is more efficient, however, we do gather first to keep it more
+    # symmetric with the sender computation.
+    receiver_pos_in_rotated_space = rotate_with_matrices(
+        edge_rotation_matrices, receivers_node_pos[receivers]
+    )
+    sender_pos_in_in_rotated_space = rotate_with_matrices(
+        edge_rotation_matrices, senders_node_pos[senders]
+    )
+    # Note, here, that because the rotated space is chosen according to the
+    # receiver, if:
+    # * latitude_local_coordinates = True: latitude for the receivers will be
+    #   0, that is the z coordinate will always be 0.
+    # * longitude_local_coordinates = True: longitude for the receivers will be
+    #   0, that is the y coordinate will be 0.
+
+    # Now we can just subtract.
+    # Note we are rotating to a local coordinate system, where the y-z axes are
+    # parallel to a tangent plane to the sphere, but still remain in a 3d space.
+    # Note that if both `latitude_local_coordinates` and
+    # `longitude_local_coordinates` are True, and edges are short,
+    # then the difference in x coordinate between sender and receiver
+    # should be small, so we could consider dropping the new x coordinate if
+    # we wanted to the tangent plane, however in doing so
+    # we would lose information about the curvature of the mesh, which may be
+    # important for very coarse meshes.
+    return sender_pos_in_in_rotated_space - receiver_pos_in_rotated_space
+
+
+def variable_to_stacked(
+    variable: xarray.Variable,
+    sizes: Mapping[str, int],
+    preserved_dims: Tuple[str, ...] = ("batch", "lat", "lon"),
+) -> xarray.Variable:
+    """Converts an xarray.Variable to preserved_dims + ("channels",).
+
+    Any dimensions other than those included in preserved_dims get stacked into a
+    final "channels" dimension. If any of the preserved_dims are missing then they
+    are added, with the data broadcast/tiled to match the sizes specified in
+    `sizes`.
+
+    Args:
+      variable: An xarray.Variable.
+      sizes: Mapping including sizes for any dimensions which are not present in
+        `variable` but are needed for the output. This may be needed for example
+        for a static variable with only ("lat", "lon") dims, or if you want to
+        encode just the latitude coordinates (a variable with dims ("lat",)).
+      preserved_dims: dimensions of variable to not be folded in channels.
+
+    Returns:
+      An xarray.Variable with dimensions preserved_dims + ("channels",).
+    """
+    stack_to_channels_dims = [d for d in variable.dims if d not in preserved_dims]
+    if stack_to_channels_dims:
+        variable = variable.stack(channels=stack_to_channels_dims)
+    dims = {dim: variable.sizes.get(dim) or sizes[dim] for dim in preserved_dims}
+    dims["channels"] = variable.sizes.get("channels", 1)
+    return variable.set_dims(dims)
+
+
+def dataset_to_stacked(
+    dataset: xarray.Dataset,
+    sizes: Optional[Mapping[str, int]] = None,
+    preserved_dims: Tuple[str, ...] = ("batch", "lat", "lon"),
+) -> xarray.DataArray:
+    """Converts an xarray.Dataset to a single stacked array.
+
+    This takes each consistuent data_var, converts it into BHWC layout
+    using `variable_to_stacked`, then concats them all along the channels axis.
+
+    Args:
+      dataset: An xarray.Dataset.
+      sizes: Mapping including sizes for any dimensions which are not present in
+        the `dataset` but are needed for the output. See variable_to_stacked.
+      preserved_dims: dimensions from the dataset that should not be folded in
+        the predictions channels.
+
+    Returns:
+      An xarray.DataArray with dimensions preserved_dims + ("channels",).
+      Existing coordinates for preserved_dims axes will be preserved, however
+      there will be no coordinates for "channels".
+    """
+    data_vars = [
+        variable_to_stacked(dataset.variables[name], sizes or dataset.sizes, preserved_dims)
+        for name in sorted(dataset.data_vars.keys())
+    ]
+    coords = {dim: coord for dim, coord in dataset.coords.items() if dim in preserved_dims}
+    return xarray.DataArray(data=xarray.Variable.concat(data_vars, dim="channels"), coords=coords)
+
+
+def stacked_to_dataset(
+    stacked_array: xarray.Variable,
+    template_dataset: xarray.Dataset,
+    preserved_dims: Tuple[str, ...] = ("batch", "lat", "lon"),
+) -> xarray.Dataset:
+    """The inverse of dataset_to_stacked.
+
+    Requires a template dataset to demonstrate the variables/shapes/coordinates
+    required.
+    All variables must have preserved_dims dimensions.
+
+    Args:
+      stacked_array: Data in BHWC layout, encoded the same as dataset_to_stacked
+        would if it was asked to encode `template_dataset`.
+      template_dataset: A template Dataset (or other mapping of DataArrays)
+        demonstrating the shape of output required (variables, shapes,
+        coordinates etc).
+      preserved_dims: dimensions from the target_template that were not folded in
+        the predictions channels. The preserved_dims need to be a subset of the
+        dims of all the variables of template_dataset.
+
+    Returns:
+      An xarray.Dataset (or other mapping of DataArrays) with the same shape and
+      type as template_dataset.
+    """
+    unstack_from_channels_sizes = {}
+    var_names = sorted(template_dataset.keys())
+    for name in var_names:
+        template_var = template_dataset[name]
+        if not all(dim in template_var.dims for dim in preserved_dims):
+            raise ValueError(
+                f"stacked_to_dataset requires all Variables to have {preserved_dims} "
+                f"dimensions, but found only {template_var.dims}."
+            )
+        unstack_from_channels_sizes[name] = {
+            dim: size for dim, size in template_var.sizes.items() if dim not in preserved_dims
+        }
+
+    channels = {
+        name: np.prod(list(unstack_sizes.values()), dtype=np.int64)
+        for name, unstack_sizes in unstack_from_channels_sizes.items()
+    }
+    total_expected_channels = sum(channels.values())
+    found_channels = stacked_array.sizes["channels"]
+    if total_expected_channels != found_channels:
+        raise ValueError(
+            f"Expected {total_expected_channels} channels but found "
+            f"{found_channels}, when trying to convert a stacked array of shape "
+            f"{stacked_array.sizes} to a dataset of shape {template_dataset}."
+        )
+
+    data_vars = {}
+    index = 0
+    for name in var_names:
+        template_var = template_dataset[name]
+        var = stacked_array.isel({"channels": slice(index, index + channels[name])})
+        index += channels[name]
+        var = var.unstack({"channels": unstack_from_channels_sizes[name]})
+        var = var.transpose(*template_var.dims)
+        data_vars[name] = xarray.DataArray(
+            data=var,
+            coords=template_var.coords,
+            # This might not always be the same as the name it's keyed under; it
+            # will refer to the original variable name, whereas the key might be
+            # some alias e.g. temperature_850 under which it should be logged:
+            name=template_var.name,
+        )
+    return type(template_dataset)(data_vars)  # pytype:disable=not-callable,wrong-arg-count
diff --git a/graph_weather/models/gencast/weighted_mse_loss.py b/graph_weather/models/gencast/weighted_mse_loss.py
new file mode 100644
index 00000000..bded0c53
--- /dev/null
+++ b/graph_weather/models/gencast/weighted_mse_loss.py
@@ -0,0 +1,129 @@
+"""The weighted loss function for GenCast training."""
+
+from typing import Optional
+
+import numpy as np
+import torch
+
+
+class WeightedMSELoss(torch.nn.Module):
+    """Module WeightedMSELoss.
+
+    This module implement the loss described in GenCast's paper.
+    """
+
+    def __init__(
+        self,
+        grid_lat: Optional[torch.Tensor] = None,
+        pressure_levels: Optional[torch.Tensor] = None,
+        num_atmospheric_features: Optional[int] = None,
+        single_features_weights: Optional[torch.Tensor] = None,
+    ):
+        """Initialize the WeightedMSELoss Module.
+
+        More details about the features weights are reported in GraphCast's paper. In short, if the
+        single features are "2m_temperature", "10m_u_component_of_wind", "10m_v_component_of_wind",
+        "mean_sea_level_pressure" and "total_precipitation_12hr", then it's suggested to set
+        corresponding weights as 1, 0.1, 0.1, 0.1 and 0.1.
+
+        Args:
+            grid_lat (torch.Tensor, optional): 1D tensor containing all the latitudes.
+            pressure_levels (torch.Tensor, optional): 1D tensor containing all the pressure levels
+                per variable.
+            num_atmospheric_features (int, optional): number of atmospheric features.
+            single_features_weights (torch.Tensor, optional): 1D tensor containing single features
+                weights.
+        """
+        super().__init__()
+
+        self.area_weights = None
+        self.features_weights = None
+
+        if grid_lat is not None:
+            self.area_weights = torch.cos(grid_lat * np.pi / 180.0)
+
+        if (
+            pressure_levels is not None
+            and num_atmospheric_features is not None
+            and single_features_weights is not None
+        ):
+            pressure_weights = pressure_levels / torch.sum(pressure_levels)
+            self.features_weights = torch.cat(
+                (pressure_weights.repeat(num_atmospheric_features), single_features_weights), dim=-1
+            )
+        elif (
+            pressure_levels is not None
+            or num_atmospheric_features is not None
+            or single_features_weights is not None
+        ):
+            raise ValueError(
+                "Please to use features weights provide all three: pressure_levels,"
+                "num_atmospheric_features and single_features_weights."
+            )
+
+        self.sigma_data = 1  # assuming normalized data!
+
+    def _lambda_sigma(self, noise_level):
+        noise_weights = (noise_level**2 + self.sigma_data**2) / (noise_level * self.sigma_data) ** 2
+        return noise_weights  # [batch, 1]
+
+    def forward(
+        self, pred: torch.Tensor, target: torch.Tensor, noise_level: torch.Tensor
+    ) -> torch.Tensor:
+        """Compute the loss.
+
+        Args:
+            pred (torch.Tensor): prediction of the model [batch, lon, lat, var].
+            target (torch.Tensor): target tensor [batch, lon, lat, var].
+            noise_level (torch.Tensor): noise levels fed to the model for the corresponding
+                predictions [batch, 1].
+
+        Returns:
+            torch.Tensor: weighted MSE loss.
+        """
+        # check shapes
+        if not (pred.shape == target.shape):
+            raise ValueError(
+                "redictions and targets must have same shape. The actual shapes "
+                f"are {pred.shape} and {target.shape}."
+            )
+        if not (len(pred.shape) == 4):
+            raise ValueError(
+                "The expected shape for predictions and targets is "
+                f"[batch, lon, lat, var], but got {pred.shape}."
+            )
+        if not (noise_level.shape == (pred.shape[0], 1)):
+            raise ValueError(
+                f"The expected shape for noise levels is [batch, 1], but got {noise_level.shape}."
+            )
+
+        # compute square residuals
+        loss = (pred - target) ** 2  # [batch, lon, lat, var]
+        if torch.isnan(loss).any():
+            raise ValueError("NaN values encountered in loss calculation.")
+
+        # apply area and features weights to residuals
+        if self.area_weights is not None:
+            if not (len(self.area_weights) == pred.shape[2]):
+                raise ValueError(
+                    f"The size of grid_lat at initialization ({len(self.area_weights)}) "
+                    f"and the number of latitudes in predictions ({pred.shape[2]}) "
+                    "don't match."
+                )
+            loss *= self.area_weights[None, None, :, None]
+
+        if self.features_weights is not None:
+            if not (len(self.features_weights) == pred.shape[-1]):
+                raise ValueError(
+                    f"The size of features weights at initialization ({len(self.features_weights)})"
+                    f" and the number of features in predictions ({pred.shape[-1]}) "
+                    "don't match."
+                )
+            loss *= self.features_weights[None, None, None, :]
+
+        # compute means across lon, lat, var for each sample in the batch
+        loss = loss.flatten(1).mean(-1)  # [batch]
+
+        # weight each sample using the corresponding noise level, then return the mean.
+        loss *= self._lambda_sigma(noise_level).flatten()
+        return loss.mean()
diff --git a/requirements.txt b/requirements.txt
index d149908d..c8e9ca8e 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -4,3 +4,5 @@ datasets
 einops
 torch-geometric-temporal
 pyshtools
+trimesh
+rtree
diff --git a/tests/test_model.py b/tests/test_model.py
index 5959349b..bc19cc79 100644
--- a/tests/test_model.py
+++ b/tests/test_model.py
@@ -13,10 +13,12 @@
     ImageMetaModel,
 )
 from graph_weather.models.losses import NormalizedMSELoss
+
 from graph_weather.models.gencast.utils.noise import (
     generate_isotropic_noise,
     sample_noise_level,
 )
+from graph_weather.models.gencast import GraphBuilder, WeightedMSELoss
 
 
 def test_encoder():
@@ -277,3 +279,51 @@ def test_meta_model():
     assert not torch.isnan(out).any()
     assert not torch.isnan(out).any()
     assert out.size() == (batch, len(lat_lons), channels)
+
+
+def test_gencast_noise():
+    num_lat = 32
+    num_samples = 5
+    target_residuals = np.zeros((2 * num_lat, num_lat, num_samples))
+    noise_level = sample_noise_level()
+    noise = generate_isotropic_noise(num_lat=num_lat, num_samples=target_residuals.shape[-1])
+    corrupted_residuals = target_residuals + noise_level * noise
+    assert corrupted_residuals.shape == target_residuals.shape
+    assert not np.isnan(corrupted_residuals).any()
+
+
+def test_gencast_graph():
+    grid_lat = np.arange(-90, 90, 1)
+    grid_lon = np.arange(0, 360, 1)
+    graphs = GraphBuilder(grid_lon=grid_lon, grid_lat=grid_lat, splits=0, num_hops=1)
+
+    assert graphs.mesh_graph.x.shape[0] == 12
+    assert graphs.g2m_graph["grid_nodes"].x.shape[0] == 360 * 180
+    assert graphs.m2g_graph["mesh_nodes"].x.shape[0] == 12
+    assert not torch.isnan(graphs.mesh_graph.edge_attr).any()
+    assert graphs.khop_mesh_graph.x.shape[0] == 12
+    assert graphs.khop_mesh_graph.edge_attr.shape[0] == 12 * 10
+
+
+def test_gencast_loss():
+    grid_lat = torch.arange(-90, 90, 1)
+    grid_lon = torch.arange(0, 360, 1)
+    pressure_levels = torch.tensor(
+        [50.0, 100.0, 150.0, 200.0, 250, 300, 400, 500, 600, 700, 850, 925, 1000.0]
+    )
+    single_features_weights = torch.tensor([1, 0.1, 0.1, 0.1, 0.1])
+    num_atmospheric_features = 6
+    batch_size = 3
+    features_dim = len(pressure_levels) * num_atmospheric_features + len(single_features_weights)
+
+    loss = WeightedMSELoss(
+        grid_lat=grid_lat,
+        pressure_levels=pressure_levels,
+        num_atmospheric_features=num_atmospheric_features,
+        single_features_weights=single_features_weights,
+    )
+
+    preds = torch.rand((batch_size, len(grid_lon), len(grid_lat), features_dim))
+    noise_levels = torch.rand((batch_size, 1))
+    targets = torch.rand((batch_size, len(grid_lon), len(grid_lat), features_dim))
+    assert loss.forward(preds, targets, noise_levels) is not None
diff --git a/train/gencast_demo.ipynb b/train/gencast_demo.ipynb
index f8ef15d4..78c09052 100644
--- a/train/gencast_demo.ipynb
+++ b/train/gencast_demo.ipynb
@@ -275,6 +275,210 @@
     "    im = ax.imshow(plot_data[i][\"data\"].T, origin=\"lower\")\n",
     "    plt.colorbar(mappable=im, ax=ax, orientation=\"vertical\", pad=0.02, aspect=16, shrink=0.75)"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Building the graph"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's explore a small graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "from graph_weather.models.gencast import GraphBuilder\n",
+    "\n",
+    "grid_lat = np.arange(-90, 90, 1)\n",
+    "grid_lon = np.arange(0, 360, 1)\n",
+    "\n",
+    "graphs = GraphBuilder(grid_lat=grid_lat, grid_lon=grid_lon, splits=0, num_hops=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Mesh\n",
+    "import networkx as nx\n",
+    "from torch_geometric.utils import to_networkx\n",
+    "\n",
+    "g = to_networkx(graphs.mesh_graph)\n",
+    "nx.draw(g)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# khop mesh\n",
+    "import networkx as nx\n",
+    "from torch_geometric.utils import to_networkx\n",
+    "\n",
+    "g = to_networkx(graphs.khop_mesh_graph)\n",
+    "nx.draw(g)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Some 3d plots (if matplotlib widget it's available)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f069545f51224e47b0ba29791e7668f8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=640.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Mesh\n",
+    "%matplotlib widget\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from graph_weather.models.gencast.graph.model_utils import (\n",
+    "    lat_lon_deg_to_spherical,\n",
+    "    spherical_to_cartesian,\n",
+    ")\n",
+    "\n",
+    "g = graphs.mesh_graph\n",
+    "\n",
+    "node_lat = graphs._mesh_nodes_lat\n",
+    "node_lon = graphs._mesh_nodes_lon\n",
+    "node_phi, node_theta = lat_lon_deg_to_spherical(node_lat, node_lon)\n",
+    "nodes = np.stack(spherical_to_cartesian(node_phi, node_theta), axis=-1)\n",
+    "edges = np.array([(nodes[u], nodes[v]) for u, v in g.edge_index.T])\n",
+    "\n",
+    "fig = plt.figure()\n",
+    "ax = fig.add_subplot(111, projection=\"3d\")\n",
+    "ax.scatter(*nodes.T, alpha=0.2, s=100, color=\"blue\")\n",
+    "for vizedge in edges:\n",
+    "    ax.plot(*vizedge.T, color=\"gray\")\n",
+    "ax.grid(False)\n",
+    "ax.set_axis_off()\n",
+    "\n",
+    "ax.set_proj_type('ortho') \n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "53c24c8a1fb143c5ad1acaeabe412a05",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=640.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# khop mesh\n",
+    "%matplotlib widget\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "g = graphs.khop_mesh_graph\n",
+    "\n",
+    "node_lat = graphs._mesh_nodes_lat\n",
+    "node_lon = graphs._mesh_nodes_lon\n",
+    "node_phi, node_theta = lat_lon_deg_to_spherical(node_lat, node_lon)\n",
+    "nodes = np.stack(spherical_to_cartesian(node_phi, node_theta), axis=-1)\n",
+    "edges = np.array([(nodes[u], nodes[v]) for u, v in g.edge_index.T])\n",
+    "\n",
+    "fig = plt.figure()\n",
+    "ax = fig.add_subplot(111, projection=\"3d\")\n",
+    "ax.scatter(*nodes.T, alpha=0.2, s=100, color=\"blue\")\n",
+    "for vizedge in edges:\n",
+    "    ax.plot(*vizedge.T, color=\"gray\")\n",
+    "ax.grid(False)\n",
+    "ax.set_axis_off()\n",
+    "\n",
+    "ax.set_proj_type('ortho') \n",
+    "plt.tight_layout()"
+   ]
   }
  ],
  "metadata": {