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.
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.
weather_prediction_dataset.ilm_train, ilm_test.ilm_train_lag, ilm_test_lag, ilm_tunnused.stockholmi_ilm.ilm_igapaev, ilm_prognoosid.Kolm reeglit
- Kõik asub ühes kohas: kataloog
workspace, skeemdefault. Uut skeemi ei loo. Tabelid lisad sinna. - Vihikuid ei impordi. Iga vihiku teed ise uue ja lisad lahtrid ükshaaval. Ülesandelahtrites on lüngad ___, mille täidad ise.
- 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.
| Vihik | Loeb | Kirjutab |
|---|---|---|
| 1. Andmete ettevalmistus | weather_prediction_dataset | ilm_train, ilm_test |
| 2. Tunnused ja lag'id | ilm_train, ilm_test | ilm_train_lag, ilm_test_lag, ilm_tunnused |
| 3. Mudel | ilm_train_lag, ilm_test_lag, ilm_tunnused | mudel workspace.default.stockholmi_ilm |
| 4. Igapäevane (lisa) | ilm_tunnused, linnade_koordinaadid, Open-Meteo, mudel | ilm_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
- Logi sisse oma Databricks Free Editioni kontoga ja ava tööruum (Workspace).
- 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.
- Ava Catalog. Vali kataloog
workspaceja selle all skeemdefault. 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
- Vali Create or modify table ja lohista fail lahtrisse.
- Vali kataloog
workspaceja skeemdefault. - Pane tabeli nimeks
weather_prediction_dataset(teise faili puhullinnade_koordinaadid). - 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
- Vali Upload files to a volume. Sihtkohaks vali
workspace→default. Kui volume'i veel ei ole, loo seal uus volume (nimi näiteksfailid). Volume on lihtsalt failikaust skeemi sees, mitte uus skeem. - Lohista CSV-fail üles.
- Ava Catalog →
workspace→default→ Volumes →failidja vali oma CSV-fail. - Vajuta Create table. Vali Create new table, kataloog
workspace, skeemdefault, tabeli nimiweather_prediction_dataset(võilinnade_koordinaadid). - 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, skeemisdefault, on kaks tabelit:weather_prediction_datasetjalinnade_koordinaadid. - Avades
weather_prediction_datasetnäed vahekaarti Sample Data; veergDATEsisaldab arve nagu20000101. (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)
- Vasakul vali New → Notebook. Avaneb tühi vihik.
- Anna vihikule nimi: klõpsa pealkirjal (Untitled Notebook …) ja kirjuta
01_andmete_ettevalmistus. - Paremal üleval vali Connect → Serverless. Serverless tähendab, et Databricks annab arvuti ise.
- Vihik koosneb lahtritest. Iga lahter on kast, kuhu kirjutad koodi. Uue lahtri saad nupuga + Code (hoia hiirt lahtrite vahel).
- 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())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
DATEon arv kujul20000101.pd.to_datetime(…, format=…)vajab kirjeldust, kuidas arv kuupäevaks lugeda:%Yon neljakohaline aasta,%mkuu,%dpäev. Kirjuta need kokku ilma eraldajata.- Sorteeri uue kuupäevaveeru
PAEVjärgi. - Maha jäävad vana
DATEjaMONTH, sestPAEVkannab nüüd sama infot.
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_sizeon osa andmetest, mis läheb testiks. Tunnis oli see 30 protsenti, kirjuta see kümnendmurruna.shuffle=Falsehoiab 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.")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_0on viimane päev,day_1sellele 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)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).
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, mittey_train). - Teine lünk on piir, mille ülal oled juba nimetanud:
KORR1.
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 neidirida allapoole. range(…)peab andma nii mitu nihet, kui palju päevi mudel näeb (LAGS).dropnaviskab ära esimesed read, millel pole piisavalt ajalugu.isinjätab alles read, millel on vastus olemas.
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.
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.indexjaX_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.")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
championtähendab „see versioon on praegu kasutusel“. Teenus ja lisatöö küsivad mudelit selle sildi järgi. - Pipeline paneb
StandardScaler'i jaMLPRegressor'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 CatalogLahter 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)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)jamax_iter=1000olid tunnis.- Skaleerija oli
StandardScaler, mudelMLPRegressor. Kirjuta klassi nimi ilma sulgudeta: sulud on juba olemas.
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,predicttestandmete tunnused.log_metricssõnastikku lähevad vihikus juba arvutatudrmse,mae,r2.- Registri nimi on ülal muutuja
MUDEL.
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 tabelitLahter 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")(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
- Vihiku paremas servas on ikoon Experiment (kolb). Ava see: seal on sinu katse koos RMSE, MAE ja R²-ga.
- Ava Catalog →
workspace→default→ Models →stockholmi_ilm. Näed versiooni 1 ja siltichampion.
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.
- Vasakul vali Serving → Create serving endpoint.
- Nimeks pane
stockholmi-ilm. - Lahtris Served entities vali My models – Unity Catalog, siis
workspace.default.stockholmi_ilmja versioon, millel on siltchampion. - 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).
- 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.
- Kui teenus on Ready, vajuta Query endpoint.
- 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.
Proovi oma teenust uute andmetega
- Ava prognoosileht ja vajuta Genereeri sünteetilised andmed (hooaeg: talv).
- Vajuta Kopeeri JSON. Kleebi see oma teenuse Query endpoint aknasse ja saada.
- Võrdle oma teenuse vastust lehe prognoosiga. Peaks olema sama või väga lähedane.
- Tee sama hooajaga suvi. Kas prognoos muutub mõistlikult?
- Vajuta Võta eilsed andmed Open-Meteost ja saada need oma teenusele. Mida ennustab sinu teenus tänaseks ja mida ütleb Open-Meteo?
- 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
- Vasakul vali Jobs & Pipelines → Create → Job.
- Lisa Task: tüüp Notebook, vali see vihik, arvutus Serverless.
- Add trigger → Scheduled: iga päev, näiteks 09:00, ajavöönd
Europe/Stockholm. - Vajuta Run now ja vaata pärast tabeleid
ilm_igapaevjailm_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
- Ava prognoosileht ja vajuta Võta eilsed andmed Open-Meteost.
- Vajuta lehe lõpus Laadi alla ilm_openmeteo_fail.csv.
- Tee sellest Databricksis tabel
workspace.default.ilm_openmeteo_fail(nagu samm 2). - Pane vihikus
ALLIKAS = "tabel"ja käivita uuesti. Kõik edasine on sama.
Pane see tööle
- Käivita vihik lõpuni. Ava tabelid
ilm_igapaev(peaks olema umbes 7 rida) jailm_prognoosid(1 rida). - Käivita sama vihik uuesti. Miks ridu juurde ei tule? (Vihje: tabel hoiab ühe rea päeva kohta.)
- 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. - 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.
- Tabelid: Catalog,
workspace.defaulttabelite loend (weather_prediction_dataset,linnade_koordinaadid,ilm_train,ilm_test,ilm_train_lag,ilm_test_lag,ilm_tunnused). - Mudel: vihiku 3 väljund (RMSE, MAE, R², versioon) ja registri leht, kus on näha silt
champion. - Teenus: Serving leht (Ready) ja Query endpoint koos vastusega.
- Veebileht: üks prognoos genereeritud andmetega ja sama JSON-iga saadud teenuse vastus.
- Lisatöö (kui tegid): Job'i ajastus ja tabel
ilm_prognoosid.
Küsimused
- Miks jagasime andmed ajajärjekorras (
shuffle=False), mitte juhuslikult? - Miks valisime tunnused ainult treeningandmete põhjal? Mis juhtuks, kui kasutaksime ka testandmeid?
- 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?
- (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:
workspacejadefault. - 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_1on 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.