Comment: the IC carries three timesteps (T-12h, T-6h, T0)

6b8b7a9 verified about 1 month ago

3.75 kB

"""Persistence: tomorrow is the same as today.
The simplest forecast there is. It copies the T+0 initial condition forward,
unchanged, to every declared lead hour.
This is not a joke entry. Persistence is the standard reference forecast in
meteorology, and on this platform it does two jobs:
1. **A skill floor.** Any model worth ranking must beat it beyond the first step
   or two. A submission that cannot is not forecasting, whatever it costs to
   run.
2. **A pipeline oracle.** Its error curve is known in advance -- small at +6h,
   climbing steadily, bad by +120h. That makes it the one model whose score can
   be checked rather than merely believed, which is why it is what the platform
   is proven with. Weather forecasts fail plausibly: a latitude flip, a
   Kelvin/Celsius slip, or an off-by-one in lead hours all produce output that
   still looks like weather. Against persistence those show up immediately:
       flat error across leads   -> lead hours are not being applied
       error around 273          -> a unit conversion was missed
       large error at +6h        -> grid sampling is wrong (lat or lon)
       beats AIFS at long leads  -> scoring or window alignment is broken
Keeping it permanently on the leaderboard means any future regression of that
kind is visible on the board itself rather than needing a diagnostic run.
"""

from __future__ import annotations

import numpy as np

# The unit the arrays below are in.
#
# The harness reads this to convert once, at the boundary. Persistence returns a
# slice of the IC untouched, and the IC stores 2m temperature in Kelvin, so that
# is what this says. Getting it wrong is the "confident RMSE of 273" failure --
# which is precisely the failure this model exists to make visible, so it would
# be poor form to commit it here.
OUTPUT_UNITS = {"temperature_2m": "K"}

# Index of T+0 within the IC's time axis.
#
# The IC carries three timesteps, T-12h, T-6h and T+0, in that order
# (`INPUT_STEP_HOURS = (-12, -6, 0)` in the spec). Persistence forecasts from the
# most recent one, so it is the last, not the first. Using index 0 would
# forecast from twelve hours before the init and quietly lose that much skill at
# every lead.
T_ZERO = -1


def run(inputs, declaration, init_time):
    """Copy the analysis forward to every lead hour.
    Args:
        inputs: IC fields as numpy arrays, keyed by ERA5 name. Surface fields
            are (time, lat, lon).
        declaration: the parsed earthboi.yaml -- lead_hours, grid_shape, etc.
        init_time: the init as an aware datetime (unused; persistence has no
            time dependence beyond the analysis it starts from).
    Returns:
        {"temperature_2m": (lead, lat, lon) float32}
    """
    analysis = np.asarray(inputs["2m_temperature"])[T_ZERO]

    rows, cols = declaration["grid_shape"]
    if analysis.shape != (rows, cols):
        # The IC is 0.25 degrees; a 1 degree declaration would need subsampling.
        # Persistence does not implement that -- a wrong-shaped array would be
        # caught by the harness anyway, but failing here names the actual reason.
        raise ValueError(
            f"IC grid {analysis.shape} does not match the declared grid "
            f"{(rows, cols)}. This baseline only runs at the IC's native resolution."
        )

    leads = len(declaration["lead_hours"])
    # `broadcast_to` returns a read-only view over one grid rather than N copies;
    # `np.array` then makes the one contiguous array the harness writes. At 0.25
    # degrees and 28 leads that is ~116 MB, which is worth not doubling.
    return {
        "temperature_2m": np.array(
            np.broadcast_to(analysis, (leads, rows, cols)), dtype="float32"
        )
    }

	"""Persistence: tomorrow is the same as today.

	The simplest forecast there is. It copies the T+0 initial condition forward,
	unchanged, to every declared lead hour.

	This is not a joke entry. Persistence is the standard reference forecast in
	meteorology, and on this platform it does two jobs:

	1. A skill floor. Any model worth ranking must beat it beyond the first step
	or two. A submission that cannot is not forecasting, whatever it costs to
	run.

	2. A pipeline oracle. Its error curve is known in advance -- small at +6h,
	climbing steadily, bad by +120h. That makes it the one model whose score can
	be checked rather than merely believed, which is why it is what the platform
	is proven with. Weather forecasts fail plausibly: a latitude flip, a
	Kelvin/Celsius slip, or an off-by-one in lead hours all produce output that
	still looks like weather. Against persistence those show up immediately:

	flat error across leads -> lead hours are not being applied
	error around 273 -> a unit conversion was missed
	large error at +6h -> grid sampling is wrong (lat or lon)
	beats AIFS at long leads -> scoring or window alignment is broken

	Keeping it permanently on the leaderboard means any future regression of that
	kind is visible on the board itself rather than needing a diagnostic run.
	"""

	from __future__ import annotations

	import numpy as np

	# The unit the arrays below are in.
	#
	# The harness reads this to convert once, at the boundary. Persistence returns a
	# slice of the IC untouched, and the IC stores 2m temperature in Kelvin, so that
	# is what this says. Getting it wrong is the "confident RMSE of 273" failure --
	# which is precisely the failure this model exists to make visible, so it would
	# be poor form to commit it here.
	OUTPUT_UNITS = {"temperature_2m": "K"}

	# Index of T+0 within the IC's time axis.
	#
	# The IC carries three timesteps, T-12h, T-6h and T+0, in that order
	# (`INPUT_STEP_HOURS = (-12, -6, 0)` in the spec). Persistence forecasts from the
	# most recent one, so it is the last, not the first. Using index 0 would
	# forecast from twelve hours before the init and quietly lose that much skill at
	# every lead.
	T_ZERO = -1


	def run(inputs, declaration, init_time):
	"""Copy the analysis forward to every lead hour.

	Args:
	inputs: IC fields as numpy arrays, keyed by ERA5 name. Surface fields
	are (time, lat, lon).
	declaration: the parsed earthboi.yaml -- lead_hours, grid_shape, etc.
	init_time: the init as an aware datetime (unused; persistence has no
	time dependence beyond the analysis it starts from).

	Returns:
	{"temperature_2m": (lead, lat, lon) float32}
	"""
	analysis = np.asarray(inputs["2m_temperature"])[T_ZERO]

	rows, cols = declaration["grid_shape"]
	if analysis.shape != (rows, cols):
	# The IC is 0.25 degrees; a 1 degree declaration would need subsampling.
	# Persistence does not implement that -- a wrong-shaped array would be
	# caught by the harness anyway, but failing here names the actual reason.
	raise ValueError(
	f"IC grid {analysis.shape} does not match the declared grid "
	f"{(rows, cols)}. This baseline only runs at the IC's native resolution."
	)

	leads = len(declaration["lead_hours"])
	# `broadcast_to` returns a read-only view over one grid rather than N copies;
	# `np.array` then makes the one contiguous array the harness writes. At 0.25
	# degrees and 28 leads that is ~116 MB, which is worth not doubling.
	return {
	"temperature_2m": np.array(
	np.broadcast_to(analysis, (leads, rows, cols)), dtype="float32"
	)
	}