Masinõpe · Databricks Free Edition

Ilmamudel Databricksis: CSV-st tabel, tabelist mudel, mudelist veebiteenus.

Ehitad Stockholmi homse temperatuuri prognoosi kolme enda tehtud vihikuga. Aluseks on tunnis tehtud MPLRegressor_example.ipynb. Lõpuks töötab mudel veebiteenusena ja saad sellele uusi andmeid saata.

PythonDatabricksMLflowUnity Catalogkataloog workspace · skeem default

Kõigepealt: mis on mis?

Teed tunnis tehtud ilmamudeli uuesti, aga Databricksis. Erinevus tunnist: andmed ei ole enam fail sinu arvutis, vaid tabel, ja töö on jagatud kolmeks vihikuks. Iga vihik loeb tabelid, teeb oma osa ja salvestab tulemuse uutesse tabelitesse. Lõpuks muutub mudel veebiteenuseks, millele saad uusi andmeid saata.

1. CSV → tabelIlmaandmed laed Databricksi tabelina weather_prediction_dataset.
2. Vihik 1Loeb tabeli, korrastab kuupäeva, jagab treenimis- ja testandmeteks → ilm_train, ilm_test.
3. Vihik 2Teeb vastuse, valib tunnused, lisab lag'id → ilm_train_lag, ilm_test_lag, ilm_tunnused.
4. Vihik 3Treenib mudeli, salvestab katse ja paneb mudeli registrisse → stockholmi_ilm.
5. TeenusRegistri mudelist saab veebiteenus (Serving). Küsid sellelt prognoosi.
6. Lisatöö: vihik 4Iga päev uus rida Open-Meteost ja uus prognoos → ilm_igapaev, ilm_prognoosid.

Kolm reeglit

  1. Kõik asub ühes kohas: kataloog workspace, skeem default. Uut skeemi ei loo. Tabelid lisad sinna.
  2. Vihikuid ei impordi. Iga vihiku teed ise uue ja lisad lahtrid ükshaaval. Ülesandelahtrites on lüngad ___, mille täidad ise.
  3. Aluseks on tunnis tehtud fail MPLRegressor_example.ipynb. Hoia see kõrval lahti: ülesannete juures on kirjas, millised lahtrid sealt vaadata. Sealt tuleb õige asi välja kirjutada ja uue koha jaoks kohandada.

Kuidas nimed üles ehitatud on

Databricksis on tabeli täisnimi kolmeosaline: kataloog.skeem.tabel, näiteks workspace.default.ilm_train. Kataloog on suurim kaust, skeem on selle sees olev alamkaust ja tabel on andmed ise. Sama süsteem (Unity Catalog) hoiab ka mudeleid, seepärast on mudeli nimi samuti kolmeosaline.

VihikLoebKirjutab
1. Andmete ettevalmistusweather_prediction_datasetilm_train, ilm_test
2. Tunnused ja lag'idilm_train, ilm_testilm_train_lag, ilm_test_lag, ilm_tunnused
3. Mudelilm_train_lag, ilm_test_lag, ilm_tunnusedmudel workspace.default.stockholmi_ilm
4. Igapäevane (lisa)ilm_tunnused, linnade_koordinaadid, Open-Meteo, mudelilm_igapaev, ilm_prognoosid

Miks kolm vihikut? Nii on iga samm eraldi kontrollitav ja uuesti käivitatav. Tabel on vihikute vaheline „leping“: järgmine vihik ei pea teadma, kuidas eelmine töötas, vaid ainult seda, mis tabelis on.

Edenemise märkimiseks on igal sammul linnuke. See jääb meelde ainult sinu brauserisse.

SAMM 1Ava oma Databricksi tööruum

  1. Logi sisse oma Databricks Free Editioni kontoga ja ava tööruum (Workspace).
  2. Vasakul on menüü. Sul läheb vaja: Workspace (vihikud), Catalog (tabelid ja mudelid), Serving (veebiteenus) ja lisatöö jaoks Jobs & Pipelines. Menüü nimed võivad Databricksi uuenduste tõttu veidi erineda.
  3. Ava Catalog. Vali kataloog workspace ja selle all skeem default. Seal hakkavad kõik sinu tabelid olema.

Ära loo uut skeemi. Kui Databricks pakub „Create schema“, jäta see tegemata. Me kasutame ainult olemasolevat workspace.default.

Kontroll

Näed Catalogis kataloogi workspace ja selle all skeemi default.

SAMM 2Tee CSV-failidest tabelid

Vaja on kahte faili. Laadi need oma arvutisse:

Esimene fail on tunnis kasutatud ilmaandmed (3654 päeva, 18 linna). Teine fail ütleb, kus linnad asuvad; seda vajab alles lisatöö, aga tee tabel ära kohe.

Tabel on andmed ridade ja veergudena, mida Databricks hoiab sinu eest. Tabeli loomisel tuleb valida kataloog, skeem ja nimi. Nimi peab olema täpselt selline, nagu allpool kirjas, sest vihikud otsivad tabelit selle nime järgi.

Kuidas tabeli teha

Vasakul vali New → Add or upload data. Seal on kaks võimalust. Kui näed kaarti Create or modify table, kasuta A; kui seda ei ole, kasuta B.

Tee A: Create or modify table
  1. Vali Create or modify table ja lohista fail lahtrisse.
  2. Vali kataloog workspace ja skeem default.
  3. Pane tabeli nimeks weather_prediction_dataset (teise faili puhul linnade_koordinaadid).
  4. Vaata eelvaadet: esimene rida peab olema veergude nimed (DATE, MONTH, BASEL_cloud_cover …). Vajuta Create table.
Tee B: Upload files to a volume, sealt tabel
  1. Vali Upload files to a volume. Sihtkohaks vali workspace → default. Kui volume'i veel ei ole, loo seal uus volume (nimi näiteks failid). Volume on lihtsalt failikaust skeemi sees, mitte uus skeem.
  2. Lohista CSV-fail üles.
  3. Ava Catalog → workspace → default → Volumes → failid ja vali oma CSV-fail.
  4. Vajuta Create table. Vali Create new table, kataloog workspace, skeem default, tabeli nimi weather_prediction_dataset (või linnade_koordinaadid).
  5. Kontrolli eelvaadet (esimene rida = veergude nimed) ja vajuta Create table. Tabeli loomiseks peab töötama SQL warehouse: Free Editionis käivitub see ise, võib võtta minuti.

Teise faili (linnade_koordinaadid.csv) tee samamoodi tabeliks linnade_koordinaadid.

Kontroll

  • Catalogis, kataloogis workspace, skeemis default, on kaks tabelit: weather_prediction_dataset ja linnade_koordinaadid.
  • Avades weather_prediction_dataset näed vahekaarti Sample Data; veerg DATE sisaldab arve nagu 20000101. (Täpne ridade arv selgub 1. vihikus: 3654.)

SAMM 3Vihik 1: andmete ettevalmistus

Eesmärk: lugeda tabel, teha kuupäev kuupäevaks, sorteerida ajajärjekorda ja jagada treenimis- ja testandmeteks. Tulemus salvestatakse kahte uude tabelisse.

Kuidas uus vihik tehakse (see kehtib kõigi vihikute kohta)

  1. Vasakul vali New → Notebook. Avaneb tühi vihik.
  2. Anna vihikule nimi: klõpsa pealkirjal (Untitled Notebook …) ja kirjuta 01_andmete_ettevalmistus.
  3. Paremal üleval vali Connect → Serverless. Serverless tähendab, et Databricks annab arvuti ise.
  4. Vihik koosneb lahtritest. Iga lahter on kast, kuhu kirjutad koodi. Uue lahtri saad nupuga + Code (hoia hiirt lahtrite vahel).
  5. Lahtri käivitamiseks vajuta Shift + Enter või lahtri kolmnurka. Käivita lahtrid ülevalt alla, üks kord igaüks.

Kopeerimine: iga koodilahtri juures on nupp Kopeeri. Kopeeri lahter vihikusse, täida lüngad ja käivita. Ülesandelahtri lüngad täidad sa ise: kuni ___ on alles, annab lahter vea. See on meelega nii.

Mida tähendab spark ja toPandas()?

Databricksi tabeleid loeb Spark: spark.table("…"). Tunnis kasutasime pandas't. Käsk toPandas() teeb Sparki tabelist tavalise pandase tabeli, nii et saad kasutada tunni koodi. Vastupidi, spark.createDataFrame(…) teeb pandase tabelist Sparki tabeli, mille saveAsTable salvestab. Spark ei luba tabeli ridade järjekorrale loota, seepärast sorteerime kuupäeva järgi alati ise.

Lahtrid

Lahter 1 · Seaded

import pandas as pd
from sklearn.model_selection import train_test_split

# Kataloog.skeem.tabel. Uut skeemi me ei loo: kasutame olemasolevat `default`.
KATALOOG = "workspace"
SKEEM = "default"
ALGANDMED = f"{KATALOOG}.{SKEEM}.weather_prediction_dataset"
TRAIN = f"{KATALOOG}.{SKEEM}.ilm_train"
TEST = f"{KATALOOG}.{SKEEM}.ilm_test"

Lahter 2 · Loe tabel

df = spark.table(ALGANDMED).toPandas()
print("Ridu:", len(df), "| veerge:", len(df.columns))
display(df.head())
Ülesanne A lahter 3

Tee kuupäev kuupäevaks, sorteeri ja viska üleliigne välja

Täida lüngad (kollased ___). Aluseks on tunnis tehtud fail: otsi sealt, kus kasutasime pd.to_datetime, sort_values ja drop.

# Aluseks tunni fail: otsi `pd.to_datetime`, `sort_values` ja `drop`.
df["PAEV"] = pd.to_datetime(df["DATE"].astype(str), format="___")
df = df.sort_values(by="___").reset_index(drop=True)
df = df.drop(columns=["___", "___"])
print(df["PAEV"].min().date(), "...", df["PAEV"].max().date())
Vihje
  • DATE on arv kujul 20000101. pd.to_datetime(…, format=…) vajab kirjeldust, kuidas arv kuupäevaks lugeda: %Y on neljakohaline aasta, %m kuu, %d päev. Kirjuta need kokku ilma eraldajata.
  • Sorteeri uue kuupäevaveeru PAEV järgi.
  • Maha jäävad vana DATE ja MONTH, sest PAEV kannab nüüd sama infot.
Ülesanne B lahter 4

Jaga andmed ajajärjekorras

Täida lüngad. Aluseks on tunni fail: otsi train_test_split.

# Aluseks tunni fail: otsi `train_test_split`.
train, test = train_test_split(df, test_size=___, shuffle=___)
print("train:", len(train), train["PAEV"].min().date(), "...", train["PAEV"].max().date())
print("test: ", len(test), test["PAEV"].min().date(), "...", test["PAEV"].max().date())
Vihje
  • test_size on osa andmetest, mis läheb testiks. Tunnis oli see 30 protsenti, kirjuta see kümnendmurruna.
  • shuffle=False hoiab päevade järjekorra. Miks see ilmaprognoosi puhul oluline on? Vasta lõpus küsimusele 1.

Lahter 5 · Salvesta kaks tabelit

for nimi, osa in [(TRAIN, train), (TEST, test)]:
    (spark.createDataFrame(osa)
          .write.mode("overwrite").option("overwriteSchema", "true")
          .saveAsTable(nimi))
    print("salvestatud:", nimi)

Kontroll (lahter 6)

Kopeeri see lahter muutmata ja käivita. Kui midagi on valesti, ütleb ta, mis.

train_t = spark.table(TRAIN).toPandas()
test_t = spark.table(TEST).toPandas()
assert len(train_t) + len(test_t) == len(df), "ridade arv ei klapi"
assert train_t["PAEV"].max() < test_t["PAEV"].min(), "treenimine peab olema enne testi"
assert "STOCKHOLM_temp_mean" in train_t.columns and "DATE" not in train_t.columns
print("Kontroll korras. Treenimisrida:", len(train_t), "| testrida:", len(test_t))
print("Selle andmestikuga peaks olema 2557 ja 1097.")
Peaksid nägema umbes:
Ridu: 3654 | veerge: 165
2000-01-01 ... 2010-01-01
train: 2557 2000-01-01 ... 2006-12-31
test:  1097 2007-01-01 ... 2010-01-01
Kontroll korras. Treenimisrida: 2557 | testrida: 1097

Kontroll Catalogis

Ava Catalog → workspace → default. Seal on nüüd tabelid ilm_train ja ilm_test.

SAMM 4Vihik 2: tunnused ja lag'id

Eesmärk: teha igale päevale järgmise päeva temperatuur vastuseks, valida tunnused korrelatsiooni järgi, lisada lag'id ja salvestada tulemus uutesse tabelitesse.

Tee uus vihik nimega 02_tunnused_ja_lagid (nagu eelmine kord, samuti Serverless).

Kolm mõistet:

  • Tunnus on üks sisendarv, näiteks Oslo eilne maksimumtemperatuur. Vastus on arv, mida tahame ennustada: Stockholmi homne keskmine temperatuur.
  • Korrelatsioon näitab, kui tihedalt kaks arvurida koos muutuvad. Jätame alles tunnused, mis käivad homse temperatuuriga tugevalt kaasas.
  • Lag on aegnihe. day_0 on viimane päev, day_1 sellele eelnev päev jne. Mudel näeb nelja päeva ajalugu.

Andmeleke. Kõik valikud (korrelatsioonid, tunnuste nimekiri) tehakse ainult treeningandmete põhjal. Kui kasutaksid ka testandmeid, näeks mudel „tulevikku“ ja tulemus oleks liiga ilus. Ülesanne E kordab seda reeglit.

Lahtrid

Lahter 1 · Seaded

import pandas as pd

KATALOOG = "workspace"
SKEEM = "default"
TRAIN = f"{KATALOOG}.{SKEEM}.ilm_train"
TEST = f"{KATALOOG}.{SKEEM}.ilm_test"
TRAIN_LAG = f"{KATALOOG}.{SKEEM}.ilm_train_lag"
TEST_LAG = f"{KATALOOG}.{SKEEM}.ilm_test_lag"
TUNNUSED = f"{KATALOOG}.{SKEEM}.ilm_tunnused"

SIHT = "STOCKHOLM_temp_mean"   # seda ennustame
LAGS = 4                       # mitu päeva mudel näeb: day_0, day_1, day_2, day_3
KORR1 = 0.3                    # esimene tunnuste valik
KORR2 = 0.85                   # teine valik (pärast lag'e)

Lahter 2 · Loe tabelid

train = spark.table(TRAIN).toPandas().sort_values("PAEV").set_index("PAEV")
test = spark.table(TEST).toPandas().sort_values("PAEV").set_index("PAEV")

X_train = train.drop(columns=[SIHT])
y_train = train[SIHT]
X_test = test.drop(columns=[SIHT])
y_test = test[SIHT]
print(X_train.shape, X_test.shape)
Ülesanne A lahter 3

Vastus = järgmise päeva temperatuur

Aluseks on tunni fail: otsi shift(-1) ja dropna. Tänase rea juurde tuleb homne temperatuur.

# Aluseks tunni fail: otsi `shift(-1)` (y_train_in, y_test_in). Homne temperatuur tänase rea juurde.
y_train_in = y_train.shift(___).dropna()
y_test_in = y_test.shift(___).dropna()
print(y_train_in.tail(2))
Vihje
  • shift(1) toob eelmise rea väärtuse sellesse ritta, shift(-1) aga järgmise rea väärtuse. Meil on vaja järgmist.
  • dropna() viskab välja rea, millel homset ei ole (viimane päev).
Ülesanne B lahter 4

Esimene tunnuste valik

Aluseks on tunni fail: esimene corr() ja piir 0.3. Korrelatsioon arvutatakse treeningandmetel, aga homse temperatuuriga.

# Aluseks tunni fail: esimene `corr()` ja piir 0.3. Korrelatsioon peab olema HOMSE temperatuuriga.
kor = (pd.concat([X_train, ___], axis=1)
         .corr()[SIHT].drop(SIHT).abs().sort_values(ascending=False))
filtreeri = kor[kor > ___].index.tolist()
print("Esimese valiku järel tunnuseid:", len(filtreeri))
Vihje
  • Esimene lünk on see vastus, mille juurde sa just tegid homse temperatuuri (y_train_in, mitte y_train).
  • Teine lünk on piir, mille ülal oled juba nimetanud: KORR1.
Ülesanne C lahter 5

Lag'id: eelmiste päevade väärtused

Aluseks on tunni fail: lags = 4, X_lagged, dropna, isin. Rida t peab saama päevade t, t−1, t−2, t−3 andmed.

# Aluseks tunni fail: `lags = 4`, `shift(i).add_suffix`, `dropna` ja `isin`.
def tee_lagid(X_osa):
    return pd.concat(
        [X_osa[___].shift(___).add_suffix(f"_day_{i}") for i in range(___)],
        axis=1,
    )

X_lagged = tee_lagid(X_train).___()                                # esimestel päevadel pole ajalugu
X_lagged = X_lagged[X_lagged.index.___(y_train_in.index)]          # viimasel päeval pole vastust
print(X_lagged.shape)
Vihje
  • Funktsiooni sees võetakse veerud, mille esimene valik alles jättis (filtreeri), ja nihutatakse neid i rida allapoole.
  • range(…) peab andma nii mitu nihet, kui palju päevi mudel näeb (LAGS).
  • dropna viskab ära esimesed read, millel pole piisavalt ajalugu. isin jätab alles read, millel on vastus olemas.
Ülesanne D lahter 6

Teine tunnuste valik

Aluseks on tunni fail: teine corr() ja piir 0.85. Nüüd on tunnuseid mitu korda rohkem ja valime rangema piiriga.

# Aluseks tunni fail: teine `corr()` ja piir 0.85.
kor2 = (pd.concat([X_lagged, y_train_in], axis=1)
          .corr()[SIHT].drop(SIHT).abs().sort_values(ascending=False))
tunnused = kor2[kor2 > ___].index.tolist()
print(len(tunnused), "tunnust. Esimesed:", tunnused[:4])
Vihje
  • Piir on ülal nimetatud KORR2.
Ülesanne E lahter 7

Sama valik testandmetele

Aluseks on tunni fail: X_test_lagged ja y_test_in. Testandmete põhjal ei valita midagi: kasuta treeningandmetest tulnud nimekirja.

# Aluseks tunni fail: `X_test_lagged`. TESTANDMETE põhjal ei valita midagi!
X_lagged = X_lagged[___]
X_test_lagged = tee_lagid(X_test).dropna()
X_test_lagged = X_test_lagged[X_test_lagged.index.isin(y_test_in.index)][___]

y_train_in = y_train_in.loc[___]     # sama päevad nagu X-il
y_test_in = y_test_in.loc[___]
print("train:", X_lagged.shape, "| test:", X_test_lagged.shape)
Vihje
  • Nimekiri on muutuja tunnused (kaks esimest lünka).
  • Viimased kaks lünka: võta vastus nendele kuupäevadele, mis sisendtabelisse jäid, st X-tabeli indeks: X_lagged.index ja X_test_lagged.index.

Lahter 8 · Salvesta tabelid

def salvesta(nimi, X, y):
    tabel = X.copy()
    tabel["y_homme"] = y
    (spark.createDataFrame(tabel.reset_index())
          .write.mode("overwrite").option("overwriteSchema", "true")
          .saveAsTable(nimi))
    print("salvestatud:", nimi, tabel.shape)

salvesta(TRAIN_LAG, X_lagged, y_train_in)
salvesta(TEST_LAG, X_test_lagged, y_test_in)

jrk = pd.DataFrame({"jrk": range(len(tunnused)), "tunnus": tunnused})
(spark.createDataFrame(jrk)
      .write.mode("overwrite").option("overwriteSchema", "true")
      .saveAsTable(TUNNUSED))
print("salvestatud:", TUNNUSED, len(jrk))

Kontroll (lahter 9)

Kopeeri see lahter muutmata ja käivita. Kui midagi on valesti, ütleb ta, mis.

tr = spark.table(TRAIN_LAG).toPandas()
te = spark.table(TEST_LAG).toPandas()
tn = spark.table(TUNNUSED).toPandas().sort_values("jrk")["tunnus"].tolist()
assert tn == tunnused, "tunnuste nimekiri tabelis ei klapi"
assert set(tn) <= set(tr.columns) and "y_homme" in tr.columns
assert not tr.isna().any().any() and not te.isna().any().any(), "tabelites ei tohi olla tühje väärtusi"
assert tr["PAEV"].max() < te["PAEV"].min()
print("Kontroll korras. Tunnuseid:", len(tn), "| train:", len(tr), "| test:", len(te))
print("Selle andmestikuga peaks olema 40 tunnust, 2553 ja 1093 rida.")
Peaksid nägema umbes:
Esimese valiku järel tunnuseid: 94
40 tunnust. Esimesed: ['STOCKHOLM_temp_max_day_0', 'OSLO_temp_mean_day_0', ...]
train: (2553, 40) | test: (1093, 40)
Kontroll korras. Tunnuseid: 40 | train: 2553 | test: 1093

Tunnistes oli lag'i veerunimi _day-0. Siin on _day_0: tabeli veerunimes sidekriipsu ei kasuta, sest SQL-is peaks see olema erimärkidega ümbritsetud. See on väike kohandus, mida Databricksi tabelid nõuavad.

Kontroll Catalogis

Uued tabelid: ilm_train_lag, ilm_test_lag ja ilm_tunnused. Ava ilm_tunnused: seal on 40 rida, igaühel on tunnuse nimi.

SAMM 5Vihik 3: mudel, MLflow ja register

Eesmärk: treenida närvivõrk, mõõta tulemust testandmetel, salvestada katse MLflow'sse ja panna mudel registrisse, et sellest saaks teha veebiteenuse.

Tee uus vihik nimega 03_mudel.

Mõisted:

  • MLflow jätab meelde, mida sa tegid: seaded, tulemused ja mudeli fail. Üks treenimine koos kõigega on katse (run).
  • Register on mudelite loend. Iga uus salvestus on mudeli uus versioon (1, 2, 3 …).
  • Alias on silt versioonil. Silt champion tähendab „see versioon on praegu kasutusel“. Teenus ja lisatöö küsivad mudelit selle sildi järgi.
  • Pipeline paneb StandardScaler'i ja MLPRegressor'i ühte objekti. Teenus saab sisendiks toored temperatuurid ja peab skaleerimise ise ära tegema. Tunnis olid need eraldi, siin on ühes.
  • Signature kirjeldab, millised veerud mudel ootab. Registri jaoks on see kohustuslik.

Lahtrid

Lahter 1 · Seaded

import json
import numpy as np
import pandas as pd
import mlflow
from mlflow import MlflowClient
from mlflow.models import infer_signature
from sklearn.neural_network import MLPRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

KATALOOG = "workspace"
SKEEM = "default"
TRAIN_LAG = f"{KATALOOG}.{SKEEM}.ilm_train_lag"
TEST_LAG = f"{KATALOOG}.{SKEEM}.ilm_test_lag"
TUNNUSED = f"{KATALOOG}.{SKEEM}.ilm_tunnused"
MUDEL = f"{KATALOOG}.{SKEEM}.stockholmi_ilm"      # mudeli nimi registris

mlflow.set_registry_uri("databricks-uc")           # register = Unity Catalog

Lahter 2 · Loe 2. vihikus tehtud tabelid

tunnused = spark.table(TUNNUSED).toPandas().sort_values("jrk")["tunnus"].tolist()
tr = spark.table(TRAIN_LAG).toPandas().sort_values("PAEV")
te = spark.table(TEST_LAG).toPandas().sort_values("PAEV")

X_train, y_train = tr[tunnused], tr["y_homme"]
X_test, y_test = te[tunnused], te["y_homme"]
print(X_train.shape, X_test.shape)
Ülesanne A lahter 3

Mudel: skaleerija ja närvivõrk ühes Pipeline'is

Aluseks on tunni fail: StandardScaler ja MLPRegressor. Seadistused jäävad samaks, aga skaleerija ja mudel pannakse ühte Pipeline'i.

# Aluseks tunni fail: `StandardScaler` ja `MLPRegressor(...)`. Sama mudel, aga ühes Pipeline'is.
parameetrid = dict(hidden_layer_sizes=(___, ___), max_iter=___, random_state=42)

mudel = Pipeline([
    ("scaler", ___()),
    ("mlp", ___(**parameetrid)),
])
Vihje
  • hidden_layer_sizes=(50, 30) ja max_iter=1000 olid tunnis.
  • Skaleerija oli StandardScaler, mudel MLPRegressor. Kirjuta klassi nimi ilma sulgudeta: sulud on juba olemas.
Ülesanne B lahter 4

Treeni, mõõda ja salvesta MLflow'sse

Lüngad on treenimisandmetes, testandmetes, mõõdikutes ja mudeli nimes registris.

with mlflow.start_run(run_name="mlp-50-30"):
    mudel.fit(___, ___)                     # treenimisandmed

    y_pred = mudel.predict(___)             # testandmed
    rmse = float(np.sqrt(mean_squared_error(y_test, y_pred)))
    mae = float(mean_absolute_error(y_test, y_pred))
    r2 = float(r2_score(y_test, y_pred))

    mlflow.log_params({"lags": 4, "korr1": 0.3, "korr2": 0.85,
                       "tunnuste_arv": len(tunnused),
                       **{k: str(v) for k, v in parameetrid.items()}})
    mlflow.log_metrics({"rmse": ___, "mae": ___, "r2": ___})

    info = mlflow.sklearn.log_model(
        mudel,
        name="mudel",
        signature=infer_signature(X_train, mudel.predict(X_train)),
        input_example=X_train.head(3),
        registered_model_name=___,          # mudeli nimi registris
        serialization_format="cloudpickle",
    )

versioon = info.registered_model_version
print(f"RMSE {rmse:.2f} °C | MAE {mae:.2f} °C | R² {r2:.2f} | mudeli versioon {versioon}")
Vihje
  • fit(X, y) võtab treenimisandmed, predict testandmete tunnused.
  • log_metrics sõnastikku lähevad vihikus juba arvutatud rmse, mae, r2.
  • Registri nimi on ülal muutuja MUDEL.
Ülesanne C lahter 5

Pane silt `champion`

Alias on silt, mille järgi teenus ja järgmised vihikud mudelit leiavad.

MlflowClient().set_registered_model_alias(MUDEL, "___", versioon)
print("champion =", versioon)
Vihje
  • Silt on inglise keeles champion (väiketähtedega).

Kontroll (lahter 6)

Kopeeri see lahter muutmata ja käivita. Kui midagi on valesti, ütleb ta, mis.

laetud = mlflow.pyfunc.load_model(f"models:/{MUDEL}@champion")
ennustus = laetud.predict(X_test.head(3))
print("mudel :", np.round(ennustus, 2))
print("tegelik:", y_test.head(3).round(2).values)
assert np.allclose(ennustus, mudel.predict(X_test.head(3)), atol=1e-6)
print("Kontroll korras: registri mudel annab sama vastuse kui vihikus olev mudel.")

Lahter 7 · Vaata vigu

res = pd.DataFrame({"tegelik": y_test.values, "ennustus": y_pred})
res["viga"] = res["tegelik"] - res["ennustus"]
print(res["viga"].describe().round(2))
print("Päevi, kus eksisime üle 3 kraadi:", int((res["viga"].abs() > 3).sum()), "/", len(res))

try:
    import plotly.express as px
    px.line(res[["tegelik", "ennustus"]]).show()
except ImportError:
    display(res.head(30))        # plotly puudub: näita tabelit

Lahter 8 · Päring teenusele

paring = {"dataframe_split": {"columns": tunnused, "data": [X_test.iloc[0].tolist()]}}
print(json.dumps(paring))
print("Selle rea ennustus siin vihikus:", round(float(laetud.predict(X_test.head(1))[0]), 4), "°C")
Peaksid nägema umbes:
(2553, 40) (1093, 40)
RMSE 2.07 °C | MAE 1.59 °C | R² 0.92 | mudeli versioon 1
champion = 1
Kontroll korras: registri mudel annab sama vastuse kui vihikus olev mudel.

Mõõdikute väike erinevus (kümnendikud) on normaalne: Databricksis võivad tarkvaraversioonid õppimist veidi muuta. Hoiatus ConvergenceWarning tähendab, et õppimine jõudis kordade ülempiirini; see ei ole viga.

Vaata, mida MLflow meelde jättis

  1. Vihiku paremas servas on ikoon Experiment (kolb). Ava see: seal on sinu katse koos RMSE, MAE ja R²-ga.
  2. Ava Catalog → workspace → default → Models → stockholmi_ilm. Näed versiooni 1 ja silti champion.
Ülesanne D (lisa)

Tee teine katse ja vali parem

Kopeeri ülesande B lahter uude lahtrisse, muuda hidden_layer_sizes=(100, 50) ja run_name="mlp-100-50". Käivita. Registrisse tekib versioon 2.

Võrdle katsete RMSE-d Experiment lehel. Pane silt champion sellele versioonile, mille RMSE on väiksem. Viimane versioon ei ole automaatselt parim. Seejärel käivita kontrolllahter uuesti.

SAMM 6Tee mudelist veebiteenus

Teenus (serving endpoint) on mudel, mis töötab Databricksis ja vastab päringutele. Sa saadad talle tunnused JSON-ina, ta vastab prognoosiga. JSON on andmevorming, kus on nimed ja väärtused.

  1. Vasakul vali Serving → Create serving endpoint.
  2. Nimeks pane stockholmi-ilm.
  3. Lahtris Served entities vali My models – Unity Catalog, siis workspace.default.stockholmi_ilm ja versioon, millel on silt champion.
  4. Arvutuse tüübiks vali CPU, suuruseks Small ja lülita sisse Scale to zero (teenus puhkab, kui keegi ei küsi: nii kulub vähem).
  5. Vajuta Create. Olek on Not Ready, kuni teenus on valmis. Oota, kuni olek on Ready (võib võtta mitu minutit). Selle ajal võid teha lisatööd.
  6. Kui teenus on Ready, vajuta Query endpoint.
  7. Kustuta aknas olev tekst ja kleebi vihiku 3 viimase lahtri väljund (rida, mis algab {"dataframe_split"…). Vajuta Send Request.

Vastus on kujul {"predictions": [ … ]}. See arv peab olema sama, mis vihiku 3 viimane rida „Selle rea ennustus siin vihikus“.

Registrist laadimine pole sama mis teenus. Kontrolllahter vihikus 3 näitas, et mudel laeb registrist. Teenus on eraldi asi, mis kasutab kindlat versiooni. Kui panid hiljem sildi champion teisele versioonile, ei uuene töötav teenus ise: muuda teenuses mudeliversiooni.

Free Editionis on aktiivsete teenuste arv piiratud. Kui oled töö esitanud, kustuta oma teenus (Serving → teenus → Delete). Andmed ja register jäävad alles.

Kontroll

Teenuse olek on Ready ja Query endpoint annab sama arvu nagu vihik.

SAMM 7Uued andmed ja prognoos veebis

Teenusele andmete käsitsi kirjutamine on tüütu: sisendis on 40 arvu. Selleks on veebileht, mis aitab:

  • Genereerib andmeid: juhuslik päev ajaloost (koos tegeliku vastusega), sünteetilised andmed valitud hooajaks, või eilsed päris andmed Open-Meteost.
  • Annab prognoosi kohe ära (õpetaja näidismudel, mis töötab brauseris).
  • Annab sulle valmis JSON-i, mille kopeerid oma teenuse Query endpoint aknasse. Nii saad oma mudeli vastust võrrelda.
Ülesanne

Proovi oma teenust uute andmetega

  1. Ava prognoosileht ja vajuta Genereeri sünteetilised andmed (hooaeg: talv).
  2. Vajuta Kopeeri JSON. Kleebi see oma teenuse Query endpoint aknasse ja saada.
  3. Võrdle oma teenuse vastust lehe prognoosiga. Peaks olema sama või väga lähedane.
  4. Tee sama hooajaga suvi. Kas prognoos muutub mõistlikult?
  5. Vajuta Võta eilsed andmed Open-Meteost ja saada need oma teenusele. Mida ennustab sinu teenus tänaseks ja mida ütleb Open-Meteo?
  6. Mänguks: nihuta liugurit +10 °C või −15 °C. Vasta lõpus küsimusele 3.

Leht ei ole ühendatud sinu Databricksi kontoga ega küsi sinu paroole. Ta ei saada sinu andmeid kuhugi, välja arvatud Open-Meteo nupu puhul, mis küsib päris ilmaandmeid ja ei saada sinu kohta midagi.

LISATÖÖVihik 4: iga päev uus rida ja prognoos

Seni oli andmeid kindel hulk. Päris süsteemis tuleb iga päev uus rida. Selles vihikus küsid Open-Meteo API-lt eilse ilma, lisad selle uue reana tabelisse, ehitad sellest mudeli sisendi ja ennustad tänase Stockholmi temperatuuri. Prognoos salvestatakse tabelisse. Siis paned vihiku käima iga päev ise.

Mõisted:

  • API on viis, kuidas üks programm küsib teiselt andmeid. Open-Meteo vastab JSON-ina. Teenus on mittekaubanduslikuks kasutuseks tasuta, andmed on litsentsiga CC BY 4.0.
  • Job on Databricksi ajastatud töö: vihik käivitub iga päev ise ja sa ei pea midagi tegema.

Enne alustamist: vaja on 2. vihiku tabelit ilm_tunnused, tabelit linnade_koordinaadid (samm 2) ja registris olevat mudelit sildiga champion (samm 5). Teenust ei ole vaja.

Free Edition võib välisühendusi piirata. Kui vihiku teine osa annab ühendusvea või ootab liiga kaua, kasuta allpool olevat varuvarianti.

Tee uus vihik 04_igapaevane_prognoos ja lisa allolevad lahtrid ülevalt alla. Kogu kood on valmis: sinu töö on käivitada, tabeleid vaadata ja ajastada.

Lahter 1 · kood

import re
from datetime import timedelta, datetime
from zoneinfo import ZoneInfo
import numpy as np
import pandas as pd
import mlflow
from mlflow import MlflowClient

KATALOOG = "workspace"
SKEEM = "default"
TUNNUSED = f"{KATALOOG}.{SKEEM}.ilm_tunnused"
KOORD = f"{KATALOOG}.{SKEEM}.linnade_koordinaadid"
ILM = f"{KATALOOG}.{SKEEM}.ilm_igapaev"                 # üks rida = üks päev
PROGNOOSID = f"{KATALOOG}.{SKEEM}.ilm_prognoosid"       # iga päeva prognoos
VARUTABEL = f"{KATALOOG}.{SKEEM}.ilm_openmeteo_fail"    # kasutusel ainult ALLIKAS = "tabel"
MUDEL = f"{KATALOOG}.{SKEEM}.stockholmi_ilm"

ALLIKAS = "api"            # "api" = küsi Open-Meteost; "tabel" = loe varutabelist (kui Databricks internetti ei luba)
KASUTA_TEENUST = False     # False = lae mudel registrist; True = küsi Serving-teenuselt
TEENUS = "stockholmi-ilm"  # teenuse nimi Serving lehel (kasutusel ainult kui KASUTA_TEENUST = True)

LAGS = 4
TZ = "Europe/Stockholm"
SIHT = "STOCKHOLM_temp_mean"
TANA = datetime.now(ZoneInfo(TZ)).date()                # „täna“ Stockholmi ajas

mlflow.set_registry_uri("databricks-uc")
print("Täna on", TANA)

1. Mida mudel vajab?

Tunnuste nimed on kujul OSLO_temp_max_day_1: linn, suurus ja mitu päeva tagasi. day_0 on eilne päev. Nime järgi saame teada, millised linnad ja veerud tuleb Open-Meteost võtta.

Lahter 2 · kood

tunnused = spark.table(TUNNUSED).toPandas().sort_values("jrk")["tunnus"].tolist()
MUSTER = re.compile(r"^(?P<linn>.+)_(?P<suurus>temp_mean|temp_max|temp_min)_day_(?P<lag>\d+)$")
for t in tunnused:
    if not MUSTER.match(t):
        raise ValueError(f"Tunnust {t} ei saa Open-Meteost võtta (toetatud on ainult temp_mean/max/min).")

veerud = sorted({f"{m['linn']}_{m['suurus']}" for m in map(MUSTER.match, tunnused)} | {SIHT})
linnad = sorted({v.rsplit("_temp_", 1)[0] for v in veerud})

koord = spark.table(KOORD).toPandas().set_index("linn")
puudu = set(linnad) - set(koord.index)
if puudu:
    raise ValueError(f"Tabelis {KOORD} puuduvad linnad: {puudu}")
koord = koord.loc[linnad]
print(len(tunnused), "tunnust;", len(linnad), "linna:", linnad)

2. Küsi ilm

API on viis, kuidas programm küsib teiselt programmilt andmeid. Open-Meteo vastab JSON-ina. Saame iga linna kohta mitu viimast päeva. Tänane päev on veel pooleli (osaliselt prognoos), seega seda uue reana ei salvesta.

Lahter 3 · kood

OM = {"temp_mean": "temperature_2m_mean", "temp_max": "temperature_2m_max", "temp_min": "temperature_2m_min"}

def lae_open_meteo(paevi=LAGS + 3):
    import requests
    vastus = requests.get(
        "https://api.open-meteo.com/v1/forecast",
        params={
            "latitude": ",".join(str(x) for x in koord["lat"]),
            "longitude": ",".join(str(x) for x in koord["lon"]),
            "daily": ",".join(OM.values()),
            "past_days": paevi, "forecast_days": 1,
            "timezone": TZ, "temperature_unit": "celsius",
        },
        timeout=60,
    )
    vastus.raise_for_status()
    andmed = vastus.json()
    if isinstance(andmed, dict):        # ühe linna korral tuleb objekt, mitme korral loend
        andmed = [andmed]
    if len(andmed) != len(linnad):
        raise ValueError("Open-Meteo vastuses on vale arv linnu.")
    tabel = {}
    for linn, a in zip(linnad, andmed):
        paevad = pd.to_datetime(a["daily"]["time"])
        for suurus, om_nimi in OM.items():
            tabel[f"{linn}_{suurus}"] = pd.Series(a["daily"][om_nimi], index=paevad, dtype="float64")
    return pd.DataFrame(tabel).rename_axis("PAEV")[veerud]

def loe_varutabelist():
    t = spark.table(VARUTABEL).toPandas()
    t["PAEV"] = pd.to_datetime(t["PAEV"].astype(str))
    return t.set_index("PAEV").sort_index()[veerud].astype("float64")

Lahter 4 · kood

if ALLIKAS == "api":
    kogu = lae_open_meteo()
else:
    kogu = loe_varutabelist()

valmis = kogu[kogu.index < pd.Timestamp(TANA)]            # ainult lõppenud päevad
open_meteo_tana = float(kogu.loc[pd.Timestamp(TANA), SIHT]) if pd.Timestamp(TANA) in kogu.index else float("nan")
print("Uusi päevi:", [d.date().isoformat() for d in valmis.index])
display(valmis.tail(3)[[SIHT, "STOCKHOLM_temp_max", "STOCKHOLM_temp_min"]])

3. Lisa uus rida tabelisse

Tabelis ilm_igapaev on üks rida iga päeva kohta. Kui päev on juba olemas, asendame selle värskema väärtusega; kui ei ole, lisame uue rea. Nii võib vihikut käivitada mitu korda päevas ja tabel ei saa topeltridu. (Suurema süsteemi puhul kasutataks SQL-i MERGE INTO; siin piisab lihtsast pandase lahendusest.)

Lahter 5 · kood

def lisa_ridu(uus):
    uus = uus.reset_index()
    if spark.catalog.tableExists(ILM):
        vana = spark.table(ILM).toPandas()
        vana["PAEV"] = pd.to_datetime(vana["PAEV"])
        koos = pd.concat([vana, uus]).drop_duplicates("PAEV", keep="last")
        lisandus = len(koos) - len(vana)
    else:
        koos, lisandus = uus, len(uus)
    koos = koos.sort_values("PAEV").reset_index(drop=True)
    (spark.createDataFrame(koos)
          .write.mode("overwrite").option("overwriteSchema", "true")
          .saveAsTable(ILM))
    return koos, lisandus

ilm, lisandus = lisa_ridu(valmis)
print(f"Tabelis {ILM} on nüüd {len(ilm)} päeva, neist uusi: {lisandus}")

4. Tee mudeli sisend

Võtame tabeli viimased LAGS päeva ja paneme need day_0 … day_3 veergudeks. Enne kontrollime, et päevad on järjest ja viimane päev on eile. Vana andmeseisuga me ennustada ei taha: parem viga kui vale prognoos.

Lahter 6 · kood

ilm_i = ilm.set_index("PAEV").sort_index()
viimased = ilm_i.tail(LAGS)
if len(viimased) < LAGS:
    raise ValueError(f"Tabelis on liiga vähe päevi: {len(viimased)} < {LAGS}")
if not (viimased.index.to_series().diff().dropna() == pd.Timedelta(days=1)).all():
    raise ValueError("Viimased päevad ei ole järjest. Lae puuduvad päevad (suurenda paevi lae_open_meteo funktsioonis).")
eile = viimased.index[-1].date()
if eile != TANA - timedelta(days=1):
    raise ValueError(f"Tabeli viimane päev on {eile}, oodatud eile ({TANA - timedelta(days=1)}).")

rida = {}
for t in tunnused:
    m = MUSTER.match(t)
    rida[t] = viimased[f"{m['linn']}_{m['suurus']}"].iloc[-1 - int(m["lag"])]
X = pd.DataFrame([rida], columns=tunnused).astype("float64")
if X.isna().any().any():
    raise ValueError("Sisendis on tühje väärtusi:\n" + str(X.T[X.isna().T[0]]))
display(X.T.head(8))

5. Ennusta

Vaikimisi laeme mudeli registrist aliase champion järgi (sama, mida tegi 3. vihik). Kui tahad proovida oma teenust, pane eespool KASUTA_TEENUST = True. Salajast võtit sa kirjutama ei pea: vihik kasutab sinu sisselogimist.

Lahter 7 · kood

if KASUTA_TEENUST:
    import mlflow.deployments
    klient = mlflow.deployments.get_deploy_client("databricks")
    vastus = klient.predict(endpoint=TEENUS,
                            inputs={"dataframe_split": {"columns": tunnused, "data": X.values.tolist()}})
    prognoos = float(np.asarray(vastus["predictions"]).reshape(-1)[0])
    versioon = f"teenus:{TEENUS}"
else:
    laetud = mlflow.pyfunc.load_model(f"models:/{MUDEL}@champion")
    prognoos = float(np.asarray(laetud.predict(X)).reshape(-1)[0])
    versioon = str(MlflowClient().get_model_version_by_alias(MUDEL, "champion").version)

print(f"Meie mudeli prognoos {TANA} jaoks, Stockholmi keskmine temperatuur: {prognoos:.1f} °C  (mudel: {versioon})")
print("Võrdluseks Open-Meteo enda tänane prognoos:", open_meteo_tana)

6. Salvesta prognoos

Üks rida iga päeva kohta. Kui käivitad uuesti, asendub tänane rida.

Lahter 8 · kood

uus = pd.DataFrame([{
    "PAEV_SIHT": pd.Timestamp(TANA),
    "prognoos": round(prognoos, 2),
    "mudeli_versioon": versioon,
    "open_meteo_prognoos": open_meteo_tana,
    "loodud": pd.Timestamp.now(tz=TZ).tz_localize(None),
}])
if spark.catalog.tableExists(PROGNOOSID):
    vana = spark.table(PROGNOOSID).toPandas()
    vana["PAEV_SIHT"] = pd.to_datetime(vana["PAEV_SIHT"])
    prog = pd.concat([vana, uus]).drop_duplicates("PAEV_SIHT", keep="last")
else:
    prog = uus
prog = prog.sort_values("PAEV_SIHT").reset_index(drop=True)
(spark.createDataFrame(prog)
      .write.mode("overwrite").option("overwriteSchema", "true")
      .saveAsTable(PROGNOOSID))
print(f"Tabelis {PROGNOOSID} on {len(prog)} prognoosi")

7. Kui hästi eksime?

Tänase päeva tegelik temperatuur selgub alles homme. Seega vaata siin eelmiste päevade prognoose koos tegeliku väärtusega. Esimestel päevadel on tegelikke väärtusi veel vähe.

Lahter 9 · kood

vrd = prog.merge(ilm[["PAEV", SIHT]], left_on="PAEV_SIHT", right_on="PAEV", how="left")
vrd = vrd.rename(columns={SIHT: "tegelik"})
vrd["viga"] = vrd["tegelik"] - vrd["prognoos"]
display(vrd[["PAEV_SIHT", "prognoos", "open_meteo_prognoos", "tegelik", "viga"]].tail(10))

Ajasta: käivita iga päev

  1. Vasakul vali Jobs & Pipelines → Create → Job.
  2. Lisa Task: tüüp Notebook, vali see vihik, arvutus Serverless.
  3. Add trigger → Scheduled: iga päev, näiteks 09:00, ajavöönd Europe/Stockholm.
  4. Vajuta Run now ja vaata pärast tabeleid ilm_igapaev ja ilm_prognoosid.

Proovi ka: pane ALLIKAS = "tabel" ja käivita varuvariandiga (vt õpetus), kui Databricks ei saa Open-Meteole ligi.

Varuvariant, kui Databricks Open-Meteole ligi ei pääse

  1. Ava prognoosileht ja vajuta Võta eilsed andmed Open-Meteost.
  2. Vajuta lehe lõpus Laadi alla ilm_openmeteo_fail.csv.
  3. Tee sellest Databricksis tabel workspace.default.ilm_openmeteo_fail (nagu samm 2).
  4. Pane vihikus ALLIKAS = "tabel" ja käivita uuesti. Kõik edasine on sama.
Lisaülesanded

Pane see tööle

  1. Käivita vihik lõpuni. Ava tabelid ilm_igapaev (peaks olema umbes 7 rida) ja ilm_prognoosid (1 rida).
  2. Käivita sama vihik uuesti. Miks ridu juurde ei tule? (Vihje: tabel hoiab ühe rea päeva kohta.)
  3. Ajasta: vasakul Jobs & Pipelines → Create → Job. Lisa ülesanne (Notebook), vali oma vihik ja Serverless. Vajuta Add trigger → Scheduled: iga päev, ajavöönd Europe/Stockholm. Proovi nuppu Run now.
  4. Vaata kahe päeva pärast tabelit ilm_prognoosid: lahtris „viga“ on tegeliku ja ennustatud temperatuuri vahe.

Miks erineb Open-Meteo prognoos meie omast? Meie mudel õppis kursuse andmetel (2000–2006), Open-Meteo andmed tulevad teisest allikast ja on uuemast ajast. Kui uute andmete jaotus erineb õppeandmetest, võib mudel halvemini ennustada. Seda nimetatakse andmete triiviks ja see on päris masinõppesüsteemides igapäevane mure. Open-Meteo enda arv on samuti prognoos, mitte päeva lõplik temperatuur.

SAMM 9Mida esitada?

Pildid (ekraanitõmmised) ja lühikesed vastused.

  1. Tabelid: Catalog, workspace.default tabelite loend (weather_prediction_dataset, linnade_koordinaadid, ilm_train, ilm_test, ilm_train_lag, ilm_test_lag, ilm_tunnused).
  2. Mudel: vihiku 3 väljund (RMSE, MAE, R², versioon) ja registri leht, kus on näha silt champion.
  3. Teenus: Serving leht (Ready) ja Query endpoint koos vastusega.
  4. Veebileht: üks prognoos genereeritud andmetega ja sama JSON-iga saadud teenuse vastus.
  5. Lisatöö (kui tegid): Job'i ajastus ja tabel ilm_prognoosid.

Küsimused

  1. Miks jagasime andmed ajajärjekorras (shuffle=False), mitte juhuslikult?
  2. Miks valisime tunnused ainult treeningandmete põhjal? Mis juhtuks, kui kasutaksime ka testandmeid?
  3. Mida ennustas sinu teenus, kui nihutasid kõiki temperatuure +10 või −15 °C võrra? Kas vastus on usutav? Miks mudel võib sellistes oludes eksida?
  4. (Lisatöö) Miks võib mudeli prognoos erineda Open-Meteo omast ja mida see ütleb mudeli kohta?

Kui midagi ei tööta

TABLE_OR_VIEW_NOT_FOUND: tabelit ei leitud

Tabeli nimi peab olema täpselt weather_prediction_dataset (väiketähed, alakriipsud) kataloogis workspace, skeemis default. Kontrolli Catalogist. Kui sinu kataloog on teine, muuda KATALOOG kõigis vihikutes.

1. vihikus: ValueError: time data … doesn't match format

Vaata, mis tüüpi on DATE: lisa lahtrisse df.dtypes["DATE"]. Kui see on kuupäev (datetime64) ja mitte arv, kirjuta pd.to_datetime(df["DATE"]) ilma format-ita. Kui see on sõne või arv, on %Y%m%d õige.

NameError: name '___' is not defined

Mõni lünk on täitmata. Otsi lahtrist kollast ___ ja kirjuta selle asemele õige asi.

Notebook is not connected / kernel puudub

Paremal üleval vali Connect → Serverless.

Quota / fair usage: arvuti lülitati välja

Free Edition piirab kasutust. Oota järgmise päevani ja käivita vihik uuesti: iga vihik kirjutab tabeli üle, seega võid alati uuesti käivitada.

3. vihikus: TypeError … unexpected keyword argument 'name'

Sinu keskkonnas on vanem MLflow. Asenda name="mudel" koodiga artifact_path="mudel".

3. vihikus: AttributeError … registered_model_version

Vanem MLflow ei anna versiooni kaasa. Asenda rida versioon = info.registered_model_version reaga versioon = max(int(v.version) for v in MlflowClient().search_model_versions(f"name='{MUDEL}'")).

3. vihikus: PERMISSION_DENIED, NO_CATALOG, cannot create model

Kontrolli, et MUDEL on kolmeosaline workspace.default.stockholmi_ilm ja et mudeli registreerimisel on seatud mlflow.set_registry_uri("databricks-uc") (1. lahter).

ModuleNotFoundError: plotly

Graafik on vabatahtlik: lahter näitab ka tabelit. Soovi korral käivita eraldi lahtris %pip install plotly ja siis uuesti.

Teenus jääb kauaks olekusse Not Ready

Ava teenuse leht ja vaata vahekaarte Logs / Events. Oota esialgu mitu minutit. Kui seal on viga, kopeeri see õpetajale.

Teenuse loomisel ütleb, et limiit on täis

Free Editionis on aktiivseid teenuseid piiratud arv. Kustuta endale mittevajalik teenus (Serving → teenus → Delete) ja proovi uuesti.

Query endpoint: Model is missing inputs / columns

JSON-i veerud ei klapi mudeli omadega. Kasuta 3. vihiku viimast lahtrit (või prognoosilehe JSON-i; see eeldab, et sul on 40 tunnust).

Lisatöös: ConnectionError / timeout Open-Meteole

Free Edition piirab välisühendusi. Kasuta varuvarianti (prognoosileht → CSV → tabel ilm_openmeteo_fail → ALLIKAS = "tabel").

Lisatöös: ValueError: Tabeli viimane päev on …, oodatud eile

Tabelis on vanad päevad. Käivita uuesti (API-ga uuendub) või lae varutabeli jaoks värske CSV.

Vea teksti loe lõpuni: enamasti on viimane rida see, mis ütleb, mis valesti läks. Võid vihiku alati uuesti käivitada, sest tabelid kirjutatakse üle.

Sõnastik

Tabel
Andmed ridade ja veergudena, mida Databricks hoiab. Nimi on kujul kataloog.skeem.tabel.
Kataloog, skeem
Kataloog on kõige suurem kaust, skeem on selle alamkaust. Meil: workspace ja default.
Unity Catalog
Databricksi koht, kus on tabelid ja mudelid, õigustega.
Vihik (notebook)
Dokument, mis koosneb lahtritest. Iga lahter on kood või tekst.
Serverless
Databricks annab arvuti ise ja sa ei pea midagi seadistama.
Spark, pandas
Mõlemad töötlevad tabeleid. Spark loeb Databricksi tabeleid, pandas on tunnis tuttav. toPandas() viib esimesest teise.
Treeningandmed, testandmed
Treeningandmetest mudel õpib, testandmetel kontrollime tulemust. Ilmaprognoosis on testandmed ajas hilisemad.
Andmeleke
Mudel on „näinud“ testandmeid enne testimist. Siis näib tulemus paremana, kui see päriselt on.
Tunnus, vastus
Tunnus on sisendarv, vastus on see, mida ennustame.
Lag
Aegnihe: day_1 on tunnus päeva võrra varasemast ajast.
Korrelatsioon
Arv, mis kirjeldab kahe rea koos muutumist. See ei tõesta põhjuslikku seost.
Pipeline
Mitu sammu (skaleerimine ja mudel) ühes objektis.
RMSE, MAE, R²
Mõõdikud. RMSE ja MAE on keskmine viga kraadides (väiksem on parem); R² on 1 juures parim.
MLflow, katse (run)
Tööriist, mis salvestab seaded, tulemused ja mudeli. Üks treenimine on üks katse.
Register, versioon, alias
Register on mudelite loend, versioon on selle number (1, 2, …), alias on silt versioonil (champion).
Serving endpoint
Mudel veebiteenusena, mis vastab päringutele.
JSON
Tekst, kus on nimed ja väärtused, näiteks {"a": 1}.
API
Viis, kuidas programm küsib teiselt programmilt andmeid.
Job
Ajastatud töö: Databricks käivitab vihiku ise.