Знакът на КАГАМИ КАГАМИ
kagami.bg/academy · lesson · machine-readable viewUPDATED 2026-10-03
IDENTITY
module
GX10-04-186 · A small financial model with scenarios: pandas and scikit-learn on CPU, optional GPU acceleration with cudf.pandas and cuml.accel
series
GX10 (local AI server class: NVIDIA GB10, e.g. ASUS Ascent GX10 / DGX Spark) · practice track: finance and modelling
level
Intermediate
duration
1.5-2 h
prerequisites
Python 3.10+ (3.11+ for the GPU wheels), pandas basics; for the GPU part a GB10-class machine with a CUDA 13 driver (580.65.06 or newer per the RAPIDS documentation); invented data only
trust_label
TESTED 2026-10-03 on a GB10 (GX10, aarch64) · Python 3.12.3, CUDA 13.0, pandas 3.0.6, scikit-learn 1.9.1, cuDF 26.8.1, cuML 26.8.0 · no model · model.py, bench.py, cudf.pandas and cuml.accel passed with identical output; for this small job the GPU was slower than the CPU · direct import cuml gave a Bus error, python -m cuml.accel works · peak 74 °C
versions
cuDF 26.8.1 and cuML 26.8.0 (PyPI, aarch64 and x86_64 wheels for CUDA 13, cp311-abi3) · pandas 3.0.6 · scikit-learn 1.9.1 (PyPI on 2026-10-03)
language
human view: bg · english edition: /en/academy/gx10/ (same file name)
previous / next
04-185 NIS2 supplier answers / 04-188 incident pattern grouping
PURPOSE

Build a small, readable financial model for a shift-based service at sites: invented shift data, monthly revenue, labour and overheads per site, a linear revenue forecast checked on the last six months against a naive forecast, and three scenarios (base, new sites, higher wages). The code is plain pandas and scikit-learn; the same unmodified code can be run on a GPU with python -m cudf.pandas and python -m cuml.accel. The lesson separates assumptions (all invented, at the top of the file) from results and teaches the learner to measure speed instead of trusting figures. NOT FINANCIAL ADVICE: a technical lesson with invented data; decisions involving real money need real data and a qualified professional.

KEY CONCEPTS
COMMANDS / PATHS
CHECKLIST
NEXT MODULE

04-188 incident pattern grouping (cuML and cuDF on aggregated data) · related: 04-134 annual accounts from Postgres to Excel · series index: kagami.bg/academy/gx10/ · offer: Quick experiment (kagami.bg/stalbata/)

SOURCES
TAGS
gx10nvidia-gb10arm64pandasscikit-learncudf-pandascuml-accelforecastingscenariosnot-financial-advice
ТЕСТВАНО · 03.10.2026 ОБНОВЕНО · 03.10.2026

Финансов модел със сценарии на GX10: pandas, прогноза и ускорение с cuDF

Малък финансов модел за услуга със смени по обекти: приходи, труд и режийни по месеци, линейна прогноза с проверка срещу най-простото предположение и три сценария (базов, нови обекти, по-високи заплати). Кодът е обикновен pandas и scikit-learn; на GPU го пускаш без промяна с cudf.pandas и cuml.accel. Данните са измислени.

⏱ 1,5–2 ч Средно GX10 NVIDIA GB10 · 128 GB обща памет pandas · scikit-learn · cuDF · cuML
pandas · scikit-learn (процесор)🔒 локално cudf.pandas · cuml.accel (GPU)🔒 локално
⚖️
Не е финансов съвет
Урокът е технически: показва как се подрежда един модел и как се пуска на GPU, с измислени данни и измислени предположения. Не е финансов, инвестиционен, счетоводен или данъчен съвет и не препоръчва цени, наемане или разширяване. Решения с реални пари се вземат по реални данни и с отговорен специалист.
🔄
ОБНОВЕНО · 03.10.2026 — какво
Урокът е преработен изцяло. Махнахме: имената на обекти и клиенти, плановете за конкретни нови обекти, адресите на машината (Jupyter и графова база), стартирането на Jupyter на 0.0.0.0, закачената остаряла conda среда, твърденията „20–50 пъти по-бързо“ и „46× ускорение“, „90 секунди в Excel срещу 2 секунди“ и „минималната заплата 2026 е 560 EUR“ — това бяха числа без източник. Махнахме и примерната „прогноза“ със само обучение върху същите данни (така R² е винаги красив). Добавихме: кодът е обикновен pandas, който върви и без GPU; ускорение с cudf.pandas и cuml.accel, както го описва документацията на NVIDIA; проверка на прогнозата върху последните месеци и сравнение с наивна прогноза; сценарии с ясни предположения; „Измери сам“ вместо чужди проценти; кутия „Не е финансов съвет“.
🧪
Какво пуснахме на GB10
03.10.2026 · пуснато на GB10 (GX10, aarch64) от Клодет · Python 3.12.3 · CUDA 13.0 · pandas 3.0.6 · scikit-learn 1.9.1 · cuDF 26.8.1 · cuML 26.8.0 · във виртуална среда. Модел: не се ползва (урокът е без езиков модел). Минаха model.py (16 116 смени, 150 реда, 3 сценария), bench.py, python -m cudf.pandas и python -m cuml.accel — с идентичен изход. Измерено (n = 2 млн. реда, данни / модел): процесор 0,83 / 0,66 s; cudf.pandas 0,57 / 2,06 s; cuml.accel 0,73 / 1,06 s; при n = 20 000 процесорът е най-бърз. За тази работа (150 агрегирани точки, LinearRegression) видеокартата е по-бавна — превозът на данни и стартът ѝ тежат повече от изчислението. Температура до 74 °C. Две бележки: import cuml директно даде Bus error, а python -m cuml.accel работи; cuML 26.8.0 е тестван със scikit-learn ≤ 1.9.0, инсталиран е 1.9.1 (предупреждение, работи). Таблиците в урока по-долу са от по-ранен пуск на обикновена машина само с процесор (pandas 2.3, scikit-learn 1.7). Остава непроверено: набори над ~50 млн. реда, където видеокартата би ускорила.

01Какво ще научиш

02Преди да започнеш

💡
Версии към 03.10.2026
cuDF 26.8.1 и cuML 26.8.0 (PyPI, колела за ARM64 и x86-64 за CUDA 13), pandas 3.0.6, scikit-learn 1.9.1 на PyPI. Ние пуснахме модела с pandas 2.3 и scikit-learn 1.7: ако при по-нови версии числата се различават, започни със сравняване на версиите. RAPIDS вече е под името NVIDIA CUDA-X; библиотеките и командите са същите.

03Стъпки

  1. Какво строим

    ФункцияКакво прави
    make_shiftsИзмислени смени: обект, вид смяна, хора, часове, месец.
    monthlyПриход, труд и режийни по обект и месец.
    forecastЛинейна прогноза на прихода за 12 месеца и проверка върху последните 6.
    scenariosБазов сценарий, нови обекти и по-високи заплати.

    Моделът е малък нарочно: колкото по-малко части, толкова по-лесно е да видиш кое предположение движи резултата.

  2. Среда на процесора

    bash · на машината
    python3 -m venv ~/fin-model
    source ~/fin-model/bin/activate
    pip install -U pip
    pip install pandas scikit-learn
  3. Предположенията са отделно и на видно място

    В началото на model.py са всички числа, които не идват от данни: цени, цена на труда, коефициенти за нощ и уикенд, дял на режийните и разход за пускане на нов обект. Всички са измислени. Ако в реалната работа ги скриеш дълбоко в кода, никой не може да ги оспори — а резултатът е толкова добър, колкото са те.

    python · model.py
    """Финансов модел на услуга по обекти със смени. Всички данни са измислени."""
    import numpy as np
    import pandas as pd
    from sklearn.linear_model import LinearRegression
    
    SEED = 42
    SITES = ["S-01", "S-02", "S-03", "S-04", "S-05"]
    
    # ── ПРЕДПОЛОЖЕНИЯ (всичко тук е измислено — сложи свои) ──────────────
    PRICE_EUR_PER_HOUR = {"S-01": 9.5, "S-02": 8.8, "S-03": 10.2, "S-04": 9.1, "S-05": 8.5}
    WAGE_EUR_PER_HOUR = 5.4                                # цена на труда на човекочас
    SHIFT_COEF = {"day": 1.0, "night": 1.35, "weekend": 1.5}
    OVERHEAD_SHARE = 0.18                                   # режийни като дял от приходите
    NEW_SITE_SETUP_EUR = 4000                               # еднократен разход за пускане на нов обект
    FIRST_YEAR = 2024
    
    
    def make_shifts(n: int, seed: int = SEED) -> pd.DataFrame:
        """Измислени смени: обект, ден, вид смяна, хора, часове."""
        rng = np.random.default_rng(seed)
        days = rng.integers(0, 30 * 30, n)                  # 30 месеца по 30 дни
        df = pd.DataFrame({
            "site": rng.choice(SITES, n),
            "shift": rng.choice(["day", "night", "weekend"], n, p=[0.5, 0.3, 0.2]),
            "staff": rng.integers(1, 4, n),
            "hours": rng.choice([8, 10, 12], n),
            "t": days // 30 + 1,                            # номер на месеца: 1..30
        })
        # лек растеж във времето: повече смени към края
        keep = rng.random(n) < (0.6 + 0.4 * df["t"] / 30)
        return df[keep].reset_index(drop=True)
    
    
    def monthly(df: pd.DataFrame) -> pd.DataFrame:
        """Приход, труд и режийни по обект и месец."""
        price = df["site"].map(PRICE_EUR_PER_HOUR)
        coef = df["shift"].map(SHIFT_COEF)
        work = df["staff"] * df["hours"]
        out = pd.DataFrame({
            "site": df["site"], "t": df["t"],
            "revenue": work * price,
            "labour": work * WAGE_EUR_PER_HOUR * coef,
        })
        out = out.groupby(["site", "t"], as_index=False).sum()
        out["overhead"] = out["revenue"] * OVERHEAD_SHARE
        return out
    
    
    def forecast(m: pd.DataFrame, horizon: int = 12, holdout: int = 6):
        """Линейна прогноза на прихода по обект + проверка върху последните месеци."""
        rows, back = [], []
        for site, g in m.groupby("site"):
            g = g.sort_values("t")
            X, y = g[["t"]].to_numpy(dtype=float), g["revenue"].to_numpy()
            # проверка: учим без последните месеци и сравняваме с наивна прогноза
            Xtr, ytr, Xte, yte = X[:-holdout], y[:-holdout], X[-holdout:], y[-holdout:]
            lr = LinearRegression().fit(Xtr, ytr)
            err_lr = np.mean(np.abs(lr.predict(Xte) - yte) / yte) * 100
            err_naive = np.mean(np.abs(ytr[-3:].mean() - yte) / yte) * 100
            back.append({"site": site, "model_err_pct": round(err_lr, 1), "naive_err_pct": round(err_naive, 1)})
            # окончателен модел върху всички данни
            lr = LinearRegression().fit(X, y)
            future = np.arange(g["t"].max() + 1, g["t"].max() + 1 + horizon, dtype=float).reshape(-1, 1)
            rows.append({"site": site, "revenue_next": float(lr.predict(future).sum())})
        return pd.DataFrame(rows), pd.DataFrame(back)
    
    
    def scenarios(m: pd.DataFrame, fc: pd.DataFrame, new_sites: int = 2, wage_up: float = 0.10, ramp: float = 0.5):
        """Три сценария за следващите 12 месеца. Разходите следват дела от последните 12 месеца."""
        last = m[m["t"] > m["t"].max() - 12].groupby("site")[["revenue", "labour"]].sum()
        labour_share = (last["labour"] / last["revenue"]).reindex(fc["site"]).to_numpy()
        rev = fc["revenue_next"].to_numpy()
        base_rev = rev.sum()
        base_lab = (rev * labour_share).sum()
    
        def row(name, revenue, labour, extra=0.0):
            overhead = revenue * OVERHEAD_SHARE + extra
            margin = revenue - labour - overhead
            return {"scenario": name, "revenue": revenue, "labour": labour, "overhead": overhead,
                    "margin": margin, "margin_pct": 100 * margin / revenue}
    
        avg_rev, avg_lab = base_rev / len(rev), base_lab / len(rev)
        return pd.DataFrame([
            row("базов", base_rev, base_lab),
            row(f"+{new_sites} обекта (първата година на {int(ramp*100)}%)", base_rev + new_sites * avg_rev * ramp,
                base_lab + new_sites * avg_lab * ramp, extra=new_sites * NEW_SITE_SETUP_EUR),
            row(f"заплати +{int(wage_up*100)}%", base_rev, base_lab * (1 + wage_up)),
        ]).round(1)
    
    
    if __name__ == "__main__":
        shifts = make_shifts(20_000)
        m = monthly(shifts)
        fc, back = forecast(m)
        print(f"смени: {len(shifts):,} · месечни реда: {len(m)}")
        print(back.to_string(index=False))
        print(scenarios(m, fc).to_string(index=False))

    Три неща в кода си струва да се запомнят:

    • Месецът е цяло число (t), а не дата — така линейната регресия има проста ос и кодът върви еднакво на CPU и GPU.
    • Проверката на прогнозата учи модела без последните 6 месеца и го сравнява с „наивна“ прогноза — средното от последните три месеца преди тях. Ако моделът не бие наивната, няма за какво да го слушаш.
    • В сценариите разходите следват дела на труда от последните 12 месеца. Това е предположение, не закон: ако договорите или заплатите се променят, делът се променя.
  4. Пусни и прочети резултата

    bash
    python model.py
    python bench.py

    Ето какво получихме на обикновена машина с измислените данни (16 116 смени, 150 реда по обект и месец). Първата таблица е проверката на прогнозата: средна процентна грешка върху последните 6 месеца.

    ОбектЛинейна прогноза, грешка %Наивна прогноза, грешка %
    S-0115,212,7
    S-025,812,5
    S-038,310,3
    S-045,77,4
    S-0510,010,8

    Линейната прогноза е по-добра при четири от петте обекта и по-лоша при S-01. Затова не я смятаме за „доказана“ — а данните са измислени, с вграден тренд и шум, така че това не казва нищо за реалния живот.

    Сценарий (12 месеца)Приход EURТруд EURРежийни EURМарж EURМарж %
    базов1 570 3761 108 629282 668179 07911,4
    +2 обекта (първата година на 50%)1 884 4511 330 355347 201206 89511,0
    заплати +10%1 570 3761 219 492282 66868 2164,3

    Прочети ги като „какво става, ако предположенията са верни“. По-високите заплати свалят марджа от 11,4% на 4,3% — защото в модела цените към клиентите остават същите. Дали реално е така, е въпрос към договорите, не към модела. (Числата са закръглени; ако пуснеш кода с други версии на библиотеките, може да видиш малка разлика.)

  5. Ускоряване на GPU без промяна на кода

    По документацията на NVIDIA cudf.pandas ускорява pandas код на GPU и сам се връща към обикновения pandas за операциите, които не поддържа. cuml.accel прави същото за scikit-learn. И двете се пускат от командния ред, без да пипаш model.py:

    bash · само за GPU варианта
    # Само за GPU вариант (пуснато от нас на GB10 на 03.10.2026). Точната команда е в селектора на NVIDIA.
    pip install cudf-cu13 cuml-cu13
    
    python -m cudf.pandas model.py     # pandas кодът върви на GPU, където е възможно
    python -m cuml.accel model.py      # scikit-learn кодът върви на GPU, където е възможно
    ⚠️
    Пуснато на GB10 (03.10.2026)
    Инсталацията на ARM64 и двете команди минаха на GB10. За точната инсталационна команда за твоята версия на CUDA ползвай селектора в документацията на RAPIDS. Ако част от кода се върне към процесора, резултатът е същият, но не е по-бърз; за този малък модел видеокартата е по-бавна от процесора (виж кутията „Какво пуснахме на GB10“). Директен import cuml даде Bus error; ползвай python -m cuml.accel.
  6. Измери сам: кога GPU има смисъл

    Скриптът bench.py пуска целия модел върху 20 хиляди и върху 2 милиона измислени смени. На нашата обикновена машина (само процесор, не GB10) втората стойност се изпълни за под секунда. Този модел е толкова лек, че GPU няма какво да ускори: ускорението има смисъл при много по-големи данни или много по-тежки изчисления. Пусни bench.py веднъж така, веднъж с python -m cudf.pandas bench.py и сравни със своите данни — без да вярваш на чужди проценти.

    python · bench.py
    import time
    from model import make_shifts, monthly, forecast, scenarios
    
    for n in (20_000, 2_000_000):
        t0 = time.perf_counter()
        shifts = make_shifts(n)
        t1 = time.perf_counter()
        m = monthly(shifts)
        fc, back = forecast(m)
        sc = scenarios(m, fc)
        t2 = time.perf_counter()
        print(f"n={n:,}: данни {t1 - t0:.2f} s, модел {t2 - t1:.2f} s")
  7. Какво моделът не знае

    • Линейният тренд не знае за сезонност, инфлация, смяна на договори и загубени клиенти.
    • Разходите в сценариите са пропорционални на приходите; реалните разходи имат и твърда част.
    • Резултатът е толкова добър, колкото са предположенията и данните. Проверявай входа, не само изхода.
    • Решенията с реални пари не се вземат по една таблица: покажи модела и предположенията му на счетоводител или финансов специалист.

04Проверка

Тест

1. Как пускаш непроменен pandas код на GPU?

2. Защо сравняваме линейната прогноза с „наивна“?

3. Защо при проверката моделът се учи без последните 6 месеца?

4. Какво показват сценариите?

05Какво следва

06Източници

  1. NVIDIA cuDF: cudf.pandas 🔒 локално — ускорение без промяна на кода, връщане към pandas.
  2. cuML: cuml.accel 🔒 локално — python -m cuml.accel.
  3. NVIDIA CUDA-X за наука за данните: инсталация — изисквания, драйвери, pip.
  4. PyPI: cudf-cu13 · PyPI: cuml-cu13 — версии и колела за ARM64.
  5. pandas: документация · scikit-learn: LinearRegression — функциите, които ползва model.py.