Upload 7 files

src/infer.py

@@ -33,43 +33,78 @@ if not valid_categories_path.exists():
 with open(valid_categories_path, "r") as f:
     valid_categories = yaml.safe_load(f)
 
-# Load currency conversion rates
-currency_rates_path = Path("config/currency_rates.yaml")
-currency_rates = {}
-if currency_rates_path.exists():
-    with open(currency_rates_path, "r") as f:
-        currency_rates = yaml.safe_load(f) or {}
+# Load currency conversion rates, one file per survey year
+with open(Path("config/model_parameters.yaml"), "r") as f:
+    _currency_rate_paths = yaml.safe_load(f)["data"]["currency_rates"]
 
+currency_rates_by_year = {}
+for _year, _path in _currency_rate_paths.items():
+    if Path(_path).exists():
+        with open(_path, "r") as f:
+            currency_rates_by_year[str(_year)] = yaml.safe_load(f) or {}
 
-def get_local_currency(country: str, salary_usd: float) -> dict | None:
-    """Convert USD salary to local currency for a given country.
+# 2025 rates, kept under the old name for backward compatibility
+currency_rates = currency_rates_by_year.get("2025", {})
+
+
+def get_local_currency(
+    country: str, salary_usd: float, survey_year: str = "2025"
+) -> dict | None:
+    """Convert USD salary to local currency for a given country and year.
+
+    Uses that survey year's rate; if the country has no rate for that year,
+    falls back to another year's rate.
 
     Returns:
-        Dict with code, name, rate, and salary_local, or None if unavailable.
+        Dict with code, name, rate, rate_year, and salary_local, or None if
+        no rate is available for the country in any year.
+    """
+    years = [survey_year] + [y for y in currency_rates_by_year if y != survey_year]
+    for year in years:
+        info = currency_rates_by_year.get(year, {}).get(country)
+        if info is not None:
+            return {
+                "code": info["code"],
+                "name": info["name"],
+                "rate": info["rate"],
+                "rate_year": year,
+                "salary_local": round(salary_usd * info["rate"], 2),
+            }
+    return None
+
+
+def predict_salaries(data: SalaryInput) -> dict[str, float]:
+    """Predict salary for every survey year the model was trained on.
+
+    Returns:
+        Dict mapping survey year (e.g. "2025", "2026") to USD salary.
     """
-    if country not in currency_rates:
-        return None
-    info = currency_rates[country]
     return {
-        "code": info["code"],
-        "name": info["name"],
-        "rate": info["rate"],
-        "salary_local": round(salary_usd * info["rate"], 2),
+        year: predict_salary(data, survey_year=year)
+        for year in valid_categories["SurveyYear"]
     }
 
 
-def predict_salary(data: SalaryInput) -> float:
+def predict_salary(data: SalaryInput, survey_year: str = "2025") -> float:
     """Predict salary based on input features.
 
     Args:
         data: SalaryInput model with developer information
+        survey_year: Survey year to predict for (e.g. "2025", "2026")
 
     Returns:
         Predicted annual salary in USD
 
     Raises:
-        ValueError: If country or education_level is not in valid categories
+        ValueError: If any categorical input or survey_year is not in
+            valid categories
     """
+    if survey_year not in valid_categories["SurveyYear"]:
+        raise ValueError(
+            f"Invalid survey year: '{survey_year}'. "
+            f"Must be one of {valid_categories['SurveyYear']}."
+        )
+
     # Validate input against valid categories from training
     if data.country not in valid_categories["Country"]:
         raise ValueError(
@@ -140,6 +175,7 @@ def predict_salary(data: SalaryInput) -> float:
             "ICorPM": [data.ic_or_pm],
             "OrgSize": [data.org_size],
             "Employment": [data.employment],
+            "SurveyYear": [survey_year],
         }
     )
 

src/preprocess.py

@@ -4,7 +4,8 @@ Validates the raw CSV, applies the same data-cleaning steps used by
 src/train.py, then writes:
 
 - config/valid_categories.yaml  — valid input values for runtime guardrails
-- config/currency_rates.yaml    — per-country median currency conversion rates
+- config/currency_rates.yaml    — 2025 per-country median currency rates
+- config/currency_rates_2026.yaml — 2026 per-country median currency rates
 
 Run before ``make train`` to validate data and pre-generate configs, or
 standalone to inspect what categories the current dataset supports.
@@ -18,38 +19,29 @@ import yaml
 
 from src.train import (
     CATEGORICAL_FEATURES,
+    REQUIRED_COLUMNS,
     apply_cardinality_reduction,
-    compute_currency_rates,
     drop_other_rows,
     extract_valid_categories,
     filter_salaries,
+    load_survey_data,
+    save_currency_rates,
 )
 
-REQUIRED_COLUMNS = [
-    "Country",
-    "YearsCode",
-    "WorkExp",
-    "EdLevel",
-    "DevType",
-    "Industry",
-    "Age",
-    "ICorPM",
-    "OrgSize",
-    "Employment",
-    "Currency",
-    "CompTotal",
-    "ConvertedCompYearly",
-]
-
-
-def validate_columns(data_path: Path) -> None:
-    """Exit 1 if any required column is absent from the CSV header."""
-    header = pd.read_csv(data_path, nrows=0)
+
+def validate_columns(data_path: Path, renames: dict | None = None) -> None:
+    """Exit 1 if any required column is absent from the CSV header.
+
+    Args:
+        data_path: Path to a survey CSV.
+        renames: Optional {source_name: required_name} column renames.
+    """
+    header = pd.read_csv(data_path, nrows=0).rename(columns=renames or {})
     missing = [c for c in REQUIRED_COLUMNS if c not in header.columns]
     if missing:
-        print(f"Error: missing required columns: {missing}")
+        print(f"Error: missing required columns in {data_path}: {missing}")
         sys.exit(1)
-    print(f"All {len(REQUIRED_COLUMNS)} required columns present.")
+    print(f"All {len(REQUIRED_COLUMNS)} required columns present in {data_path}.")
 
 
 def print_category_summary(df: pd.DataFrame) -> None:
@@ -65,27 +57,28 @@ def main() -> None:
     with open(config_path) as f:
         config = yaml.safe_load(f)
 
-    data_path = Path("data/survey_results_public.csv")
+    renames = config["data"].get("column_renames") or {}
 
-    # Step 1 — Validate data file ------------------------------------------------
+    # Step 1 — Validate data files -----------------------------------------------
     print("=" * 60)
-    print("STEP 1 — Validate data file")
+    print("STEP 1 — Validate data files")
     print("=" * 60)
 
-    if not data_path.exists():
-        print(f"Error: {data_path} not found.")
-        print("Download from: https://insights.stackoverflow.com/survey")
-        sys.exit(1)
-
-    print(f"Checking columns in {data_path} ...")
-    validate_columns(data_path)
+    for year, path in config["data"]["sources"].items():
+        data_path = Path(path)
+        if not data_path.exists():
+            print(f"Error: {data_path} not found.")
+            print("Download from: https://survey.stackoverflow.co/")
+            sys.exit(1)
+        print(f"Checking columns in {data_path} ...")
+        validate_columns(data_path, renames.get(str(year)))
 
     # Step 2 — Load and filter salaries ------------------------------------------
     print("\n" + "=" * 60)
     print("STEP 2 — Load and filter salaries")
     print("=" * 60)
 
-    df = pd.read_csv(data_path, usecols=REQUIRED_COLUMNS)
+    df = load_survey_data(config)
     print(f"Loaded {len(df):,} rows")
 
     df = filter_salaries(df, config)
@@ -123,17 +116,7 @@ def main() -> None:
     n_total = sum(len(v) for v in valid_categories.values())
     print(f"Saved {vc_path} ({n_total} total valid values)")
 
-    currency_rates = compute_currency_rates(df, valid_categories["Country"])
-    cr_path = Path("config/currency_rates.yaml")
-    with open(cr_path, "w") as f:
-        yaml.dump(
-            currency_rates,
-            f,
-            default_flow_style=False,
-            sort_keys=True,
-            allow_unicode=True,
-        )
-    print(f"Saved {cr_path} ({len(currency_rates)} countries)")
+    save_currency_rates(df, valid_categories["Country"], config)
 
     print("\nPre-processing complete. Ready for `make train`.")
 

src/preprocessing.py

@@ -79,7 +79,7 @@ def prepare_features(df: pd.DataFrame) -> pd.DataFrame:
 
     Args:
         df: DataFrame with columns: Country, YearsCode, WorkExp, EdLevel,
-            DevType, Industry, Age, ICorPM, OrgSize, Employment.
+            DevType, Industry, Age, ICorPM, OrgSize, Employment, SurveyYear.
             NOTE: During training, cardinality reduction should be applied to df
             BEFORE calling this function. During inference, valid_categories.yaml
             ensures only valid (already-reduced) categories are used.
@@ -108,6 +108,7 @@ def prepare_features(df: pd.DataFrame) -> pd.DataFrame:
         "ICorPM",
         "OrgSize",
         "Employment",
+        "SurveyYear",
     ]
     for col in _categorical_cols:
         if col in df_processed.columns:
@@ -138,6 +139,7 @@ def prepare_features(df: pd.DataFrame) -> pd.DataFrame:
     df_processed["ICorPM"] = df_processed["ICorPM"].fillna("Unknown")
     df_processed["OrgSize"] = df_processed["OrgSize"].fillna("Unknown")
     df_processed["Employment"] = df_processed["Employment"].fillna("Unknown")
+    df_processed["SurveyYear"] = df_processed["SurveyYear"].fillna("Unknown")
 
     # NOTE: Cardinality reduction is NOT applied here
     # It should be applied during training BEFORE calling this function
@@ -155,6 +157,7 @@ def prepare_features(df: pd.DataFrame) -> pd.DataFrame:
         "ICorPM",
         "OrgSize",
         "Employment",
+        "SurveyYear",
     ]
     df_features = df_processed[feature_cols]
 

src/train.py

@@ -20,14 +20,81 @@ CATEGORICAL_FEATURES = [
     "ICorPM",
     "OrgSize",
     "Employment",
+    "SurveyYear",
 ]
 
+# Columns read from each survey CSV (after per-year column renames)
+REQUIRED_COLUMNS = [
+    "Country",
+    "YearsCode",
+    "WorkExp",
+    "EdLevel",
+    "DevType",
+    "Industry",
+    "Age",
+    "ICorPM",
+    "OrgSize",
+    "Employment",
+    "Currency",
+    "CompTotal",
+    "ConvertedCompYearly",
+]
+
+
+def load_survey_data(config: dict) -> pd.DataFrame:
+    """Load every configured survey year and stack them with SurveyYear.
+
+    For each year in config data.sources, reads REQUIRED_COLUMNS (applying
+    data.column_renames), maps answer wording via data.category_mappings,
+    and adds SurveyYear as a string.
+
+    Args:
+        config: Config dict with data.sources and optional
+                data.column_renames / data.category_mappings.
+
+    Returns:
+        Concatenated DataFrame of all years.
+
+    Raises:
+        FileNotFoundError: If a configured survey CSV does not exist.
+    """
+    data_config = config["data"]
+    renames = data_config.get("column_renames") or {}
+    mappings = data_config.get("category_mappings") or {}
+
+    frames = []
+    for year, path in data_config["sources"].items():
+        year = str(year)
+        path = Path(path)
+        if not path.exists():
+            raise FileNotFoundError(
+                f"Data file for {year} not found at {path}. Download from "
+                "https://survey.stackoverflow.co/"
+            )
+
+        year_renames = renames.get(year) or {}
+        source_names = {new: old for old, new in year_renames.items()}
+        usecols = [source_names.get(col, col) for col in REQUIRED_COLUMNS]
+        df = pd.read_csv(path, usecols=usecols).rename(columns=year_renames)
+
+        if year in mappings:
+            with open(mappings[year], "r") as f:
+                category_mapping = yaml.safe_load(f) or {}
+            for col, mapping in category_mapping.items():
+                df[col] = df[col].replace(mapping)
+
+        df["SurveyYear"] = year
+        print(f"Loaded {len(df):,} rows for {year} from {path}")
+        frames.append(df)
+
+    return pd.concat(frames, ignore_index=True)
+
 
 def filter_salaries(df: pd.DataFrame, config: dict) -> pd.DataFrame:
-    """Filter rows by minimum salary and per-country percentile outlier removal.
+    """Filter rows by minimum salary and per-year, per-country outlier removal.
 
     Args:
-        df: DataFrame with ConvertedCompYearly and Country columns.
+        df: DataFrame with ConvertedCompYearly, SurveyYear and Country columns.
         config: Config dict with data.min_salary, data.lower_percentile,
                 data.upper_percentile.
 
@@ -40,8 +107,9 @@ def filter_salaries(df: pd.DataFrame, config: dict) -> pd.DataFrame:
 
     lower_pct = config["data"]["lower_percentile"] / 100
     upper_pct = config["data"]["upper_percentile"] / 100
-    lower_bound = df.groupby("Country")[main_label].transform("quantile", lower_pct)
-    upper_bound = df.groupby("Country")[main_label].transform("quantile", upper_pct)
+    groups = df.groupby(["SurveyYear", "Country"])[main_label]
+    lower_bound = groups.transform("quantile", lower_pct)
+    upper_bound = groups.transform("quantile", upper_pct)
     df = df[(df[main_label] > lower_bound) & (df[main_label] < upper_bound)]
 
     df = df.dropna(subset=[main_label])
@@ -96,12 +164,19 @@ def extract_valid_categories(df: pd.DataFrame) -> dict:
     }
 
 
-def compute_currency_rates(df: pd.DataFrame, valid_countries: list[str]) -> dict:
+def compute_currency_rates(
+    df: pd.DataFrame,
+    valid_countries: list[str],
+    preferred_codes: dict[str, str] | None = None,
+) -> dict:
     """Compute median currency conversion rates per country.
 
     Args:
         df: DataFrame with Country, Currency, CompTotal, ConvertedCompYearly columns.
         valid_countries: List of valid country names to compute rates for.
+        preferred_codes: Optional {country: currency code} to keep (e.g. the
+            previous survey year's code) when it still appears in the data;
+            otherwise the most common code is used.
 
     Returns:
         Dict mapping country to {code, name, rate}.
@@ -121,10 +196,11 @@ def compute_currency_rates(df: pd.DataFrame, valid_countries: list[str]) -> dict
         country_data = currency_df[currency_df["Country"] == country]
         if country_data.empty:
             continue
-        most_common = country_data["CurrencyCode"].mode()
-        if most_common.empty:
-            continue
-        code = most_common.iloc[0]
+        preferred = (preferred_codes or {}).get(country)
+        if preferred in set(country_data["CurrencyCode"]):
+            code = preferred
+        else:
+            code = country_data["CurrencyCode"].mode().iloc[0]
         name_row = country_data[country_data["CurrencyCode"] == code].iloc[0]
         full_name = name_row["CurrencyName"]
         rates = country_data[country_data["CurrencyCode"] == code]["rate"]
@@ -138,6 +214,43 @@ def compute_currency_rates(df: pd.DataFrame, valid_countries: list[str]) -> dict
     return currency_rates
 
 
+def save_currency_rates(
+    df: pd.DataFrame, valid_countries: list[str], config: dict
+) -> dict:
+    """Compute currency rates per survey year and write one YAML per year.
+
+    Each year's rates use only that year's rows; output paths come from
+    config data.currency_rates. A country keeps the previous year's currency
+    while that currency still appears in the data (e.g. Argentina stays on
+    ARS even if as many respondents report USD), so years stay comparable.
+
+    Returns:
+        Dict mapping survey year to its {country: {code, name, rate}} dict.
+    """
+    rates_by_year = {}
+    previous_codes = {}
+    for year, path in sorted(config["data"]["currency_rates"].items()):
+        year = str(year)
+        year_df = df[df["SurveyYear"] == year]
+        rates = compute_currency_rates(year_df, valid_countries, previous_codes)
+        previous_codes = {country: info["code"] for country, info in rates.items()}
+        with open(path, "w") as f:
+            yaml.dump(
+                rates,
+                f,
+                default_flow_style=False,
+                sort_keys=True,
+                allow_unicode=True,
+            )
+        print(f"Saved currency rates for {len(rates)} countries to {path}")
+        for country, info in sorted(rates.items()):
+            print(
+                f"  {country:45s} -> {info['code']} ({info['name']}, rate: {info['rate']})"
+            )
+        rates_by_year[year] = rates
+    return rates_by_year
+
+
 def main():
     """Train and save the salary prediction model."""
     # Load configuration
@@ -147,36 +260,12 @@ def main():
         config = yaml.safe_load(f)
 
     print("Loading data...")
-    data_path = Path("data/survey_results_public.csv")
-
-    if not data_path.exists():
-        print(f"Error: Data file not found at {data_path}")
-        print(
-            "Please download the Stack Overflow Developer Survey CSV and place it in the data/ directory."
-        )
-        print("Download from: https://insights.stackoverflow.com/survey")
+    try:
+        df = load_survey_data(config)
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
         return
 
-    # Load only required columns to save memory
-    df = pd.read_csv(
-        data_path,
-        usecols=[
-            "Country",
-            "YearsCode",
-            "WorkExp",
-            "EdLevel",
-            "DevType",
-            "Industry",
-            "Age",
-            "ICorPM",
-            "OrgSize",
-            "Employment",
-            "Currency",
-            "CompTotal",
-            "ConvertedCompYearly",
-        ],
-    )
-
     print(f"Loaded {len(df):,} rows")
 
     print("Removing null, extremely small and large reported salaries")
@@ -215,27 +304,9 @@ def main():
         f"\nSaved {len(valid_categories['Country'])} valid countries, {len(valid_categories['EdLevel'])} valid education levels, {len(valid_categories['DevType'])} valid developer types, {len(valid_categories['Industry'])} valid industries, {len(valid_categories['Age'])} valid age ranges, and {len(valid_categories['ICorPM'])} valid IC/PM values to {valid_categories_path}"
     )
 
-    # Compute currency conversion rates per country
-    print("\nComputing currency conversion rates per country...")
-    currency_rates = compute_currency_rates(df, valid_categories["Country"])
-
-    currency_rates_path = Path("config/currency_rates.yaml")
-    with open(currency_rates_path, "w") as f:
-        yaml.dump(
-            currency_rates,
-            f,
-            default_flow_style=False,
-            sort_keys=True,
-            allow_unicode=True,
-        )
-
-    print(
-        f"Saved currency rates for {len(currency_rates)} countries to {currency_rates_path}"
-    )
-    for country, info in sorted(currency_rates.items()):
-        print(
-            f"  {country:45s} -> {info['code']} ({info['name']}, rate: {info['rate']})"
-        )
+    # Compute currency conversion rates per country, separately per year
+    print("\nComputing currency conversion rates per country and year...")
+    save_currency_rates(df, valid_categories["Country"], config)
 
     print(f"\nFeature matrix shape: {X.shape}")
     print(f"Total features: {X.shape[1]}")
@@ -287,6 +358,11 @@ def main():
     for emp, count in top_employment.items():
         print(f"  - {emp}: {count:,} ({count / len(df) * 100:.1f}%)")
 
+    # Show survey year distribution
+    print("\n📅 Survey Year Distribution:")
+    for year, count in df["SurveyYear"].value_counts().sort_index().items():
+        print(f"  - {year}: {count:,} ({count / len(df) * 100:.1f}%)")
+
     # Show YearsCode statistics
     print("\n💼 Years of Coding Experience:")
     print(f"  - Min: {df['YearsCode'].min():.1f}")

src/tune.py

@@ -15,6 +15,7 @@ from src.train import (
     apply_cardinality_reduction,
     drop_other_rows,
     filter_salaries,
+    load_survey_data,
 )
 
 
@@ -128,33 +129,11 @@ def main():
 
     # Load and preprocess data
     print("Loading data...")
-    data_path = Path("data/survey_results_public.csv")
-    if not data_path.exists():
-        print(f"Error: Data file not found at {data_path}")
-        print(
-            "Please download the Stack Overflow Developer Survey CSV "
-            "and place it in the data/ directory."
-        )
+    try:
+        df = load_survey_data(config)
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
         return
-
-    df = pd.read_csv(
-        data_path,
-        usecols=[
-            "Country",
-            "YearsCode",
-            "WorkExp",
-            "EdLevel",
-            "DevType",
-            "Industry",
-            "Age",
-            "ICorPM",
-            "OrgSize",
-            "Employment",
-            "Currency",
-            "CompTotal",
-            "ConvertedCompYearly",
-        ],
-    )
     print(f"Loaded {len(df):,} rows")
 
     df = filter_salaries(df, config)