kairusama/ubpr-one

UBPR One

Analysis-ready snapshots of FFIEC UBPR (Uniform Bank Performance Report) bulk data, produced by a companion Hugging Face Space. Each reporting period is delivered as one canonical wide parquet plus a set of labeled narrow views tailored for researchers who want to get from download to plot in five minutes.

What is UBPR?

The UBPR is published by the Federal Financial Institutions Examination Council (FFIEC) and is derived from the quarterly Call Report (Consolidated Reports of Condition and Income, forms FFIEC 031/041/051). Where the Call Report is the raw balance-sheet and income submission, UBPR is its ratio overlay: thousands of derived metrics — profitability, capital adequacy, credit quality, liquidity — computed on a common basis across every insured U.S. commercial bank and savings institution. The bulk source underlying this dataset is the FFIEC Central Data Repository's public bulk-download page (https://cdr.ffiec.gov/public/PWS/DownloadBulkData.aspx).

FFIEC UBPR fields are identified by codes like UBPR4340 (Net Income), UBPR7206 (Tier 1 Risk-Based Capital Ratio), UBPR5459 (Noncurrent Loans to Total Loans). This dataset preserves those codes and carries their short and long human labels as both a standalone JSON dictionary and per-field parquet metadata, so you never need the codes memorized.

Use cases

Common applications in academic and regulatory research:

• Peer-group benchmarking — UBPR's own comparative framing, reproduced over arbitrary peer definitions.
• CAMELS proxies — Capital, Asset quality, Management, Earnings, Liquidity, Sensitivity indicators as regressors in bank-health models.
• Failure / distress prediction — survival analysis over institutions tracked by ID RSSD across reporting periods.
• Systemic-risk and concentration studies — cross-sectional analysis by asset tier, charter type, or geography.
• Stress-test research — ratio-level responses to macro shocks.

Quickstart (thematic views — recommended)

The dataset is configured so each thematic view is a named HF config. The default config is earnings — it loads out of the box, has human-labeled columns, and covers every published period via a single train split.

from datasets import load_dataset

# default = earnings view, all periods concatenated
ds = load_dataset("kairusama/ubpr-one")
df = ds["train"].to_pandas()
df.head()
# Reporting Period | ID RSSD | Net Income | Net Interest Margin | ...

Switch to another view by naming the config:

capital = load_dataset("kairusama/ubpr-one", "capital")["train"].to_pandas()
liquidity = load_dataset("kairusama/ubpr-one", "liquidity")["train"].to_pandas()

Available views: earnings (default), capital, asset_quality, liquidity. Which codes belong to each view is defined in space/views.json in the companion Space; per-period coverage (which requested codes were actually present) is recorded in each run log under curated.views.

Quickstart (canonical wide parquet)

The canonical config ships the full 2,800+-column joined parquet, raw UBPR codes preserved. It exceeds HF's 1000-column viewer cap so browser preview of canonical won't render, but programmatic access is identical.

from datasets import load_dataset

ds = load_dataset("kairusama/ubpr-one", "canonical")
df = ds["train"].to_pandas()  # all periods; filter via df["Reporting Period"]

With pandas directly (pick a single period):

import pandas as pd
from huggingface_hub import hf_hub_download

local = hf_hub_download(
    repo_id="kairusama/ubpr-one",
    repo_type="dataset",
    filename="data/ubpr_2024.parquet",
)
df = pd.read_parquet(local)

With duckdb (streams from Hugging Face without materializing locally):

import duckdb

duckdb.sql("""
  SELECT "ID RSSD", UBPR4340 AS net_income, UBPR7206 AS tier1_rb
  FROM 'hf://datasets/kairusama/ubpr-one/data/ubpr_2024.parquet'
  WHERE UBPR7206 IS NOT NULL
  ORDER BY UBPR7206 DESC
  LIMIT 20
""").df()

Resolving UBPR codes

Two equivalent paths. Pick whichever fits your workflow.

From the parquet itself (labels travel with the file):

import pyarrow.parquet as pq

schema = pq.read_schema(local)
meta = schema.field("UBPR4340").metadata or {}
short = meta.get(b"short_label", b"").decode()  # e.g. "Net Income"
long_text = meta.get(b"long_label", b"").decode()

From the repo-level dictionary (one JSON per repo, always the latest run):

from huggingface_hub import hf_hub_download
import json

path = hf_hub_download(
    repo_id="kairusama/ubpr-one",
    repo_type="dataset",
    filename="metadata/column_dictionary.json",
)
with open(path, encoding="utf-8") as fh:
    dictionary = json.load(fh)["fields"]

dictionary["UBPR4340"]
# {"short": "Net Income", "long": "Net income (loss) attributable to ..."}

Discovering what's available

metadata/periods.json is the single index of "what's in this repo right now" — one entry per reporting period, with row/column counts, the matching canonical parquet, and every available view:

import json
from huggingface_hub import hf_hub_download

index = json.load(open(hf_hub_download(
    repo_id="<ns>/ubpr-one",
    repo_type="dataset",
    filename="metadata/periods.json",
)))

for entry in index["periods"]:
    print(entry["period"], entry["rows"], "rows,", entry["columns"], "cols")

Use this when building cross-period time series — you get the ground-truth set of periods without walking metadata/run_log_*.json by hand.

Layout

data/
  ubpr_<period>.parquet              # canonical wide snapshot, raw UBPR codes
  views/
    capital_<period>.parquet         # labeled thematic views, viewer-friendly
    earnings_<period>.parquet
    asset_quality_<period>.parquet
    liquidity_<period>.parquet
metadata/
  column_dictionary.json             # {code: {short, long}} for every FFIEC field
  periods.json                       # cross-period index / manifest
  run_log_<timestamp>.json           # per-run ETL record (append-only)

Reproducibility

• Each ETL commit on this repo is a stable citation handle — cite the commit SHA alongside the period, not just the period.
• metadata/run_log_<timestamp>.json captures the exact source archive filename, FFIEC period_value, row/column counts, join diagnostics, inferred column types, and ETL duration for every run.
• FFIEC silently restates historical UBPR data. This dataset does not preserve historical revisions: rerunning a period overwrites its canonical parquet. If you need point-in-time data for a prior run, look up the commit SHA from the run log.

Known limitations

• HF Data Studio viewer cap (1000 columns). The canonical parquet is wider than the cap, so in-browser preview of data/ubpr_*.parquet may fail even though the parquet itself is valid. Use the narrow views for interactive exploration, or pull the wide file down for analysis.
• FFIEC code drift. Codes are occasionally renamed, consolidated, or retired. The curated.views block of each run log lists which codes were included vs. missing per view, so you can audit coverage.
• Join keys. All members inside a given period's source archive join cleanly on Reporting Period + ID RSSD. This dataset inherits FFIEC's identifier semantics — ID RSSD is the canonical Federal Reserve institution identifier and is stable across time.
• No historical revisions. See "Reproducibility" above.

Licensing

FFIEC UBPR data is a public-domain work of the United States government. This derivative is released under CC0-1.0 — no attribution required, though citing the commit SHA is appreciated for reproducibility.

Regeneration

Open the companion Space and click Run ETL for a period. One run rewrites that period's canonical parquet, refreshes the views, and appends a new run log in one atomic commit. For batch rebuilds, the Space ships a backfill.py CLI.