Praktikum · Databricks Free Edition · 18.11.2026

Sinu ilmamudel. Databricksis samm-sammult.

Selle töö lõpuks on sul mudel, mis ennustab Stockholmi homset keskmist temperatuuri. Ehitad selle kolme enda tehtud vihikuga, kasutades tunnis tehtud faili. Mudel töötab Databricksi veebiteenusena: saadad talle varasemate päevade temperatuurid ja saad vastu ühe arvu.

Eesti keelesSammhaavalIga samm lõpeb kontrolligakataloog workspace · skeem default
1. Õpetad mudelitTeed kolm vihikut: andmed, tunnused, mudel.
2. Salvestad valikuPaned mudeli registrisse ja annad sellele sildi.
3. Küsid prognoosiKäivitad mudeli teenusena ja saadad sellele uusi andmeid.

Mida vajad?

  • Arvutit, brauserit ja internetiühendust.
  • Databricks Free Editioni kontot või õpetaja antud tööruumi.
  • Kahte andmefaili: weather_prediction_dataset.csv ja linnade_koordinaadid.csv (lingid ülal).
  • Tunnis tehtud faili MPLRegressor_example.ipynb oma arvutis. Koodi võtad sealt. See juhend ütleb, mida teha, mis on oluline ja kuidas kontrollida.
  • Algteadmisi Pythonist: oskad käivitada lahtri ja muuta koodi.

Arvutused ja mudelite salvestamine toimuvad Databricksis. Oma arvutis kasutad brauserit.

Kõigepealt: mis on mis?

Databricks on veebikeskkond, kus saad andmeid hoida, koodi käivitada ja mudeleid kasutada. Pilv tähendab, et arvutus ja andmete hoidmine toimuvad teenusepakkuja arvutites, mitte sinu sülearvutis.

Tunnis oli ilmaandmeteks fail sinu arvutis. Siin on andmed tabel Databricksis ja töö on jaotatud kolmeks vihikuks. Vihikud annavad tulemuse üksteisele edasi tabelite kaudu: iga vihik loeb eelmise vihiku tabelid ja salvestab oma tulemuse uutesse tabelitesse.

Mida teeme?Databricksi tööriist
Hoiame andmeidTabelid kataloogis workspace, skeemis default (Unity Catalog)
Käivitame koodi ja loeme selgitusiNotebook ehk koodi ja selgitustega töövihik brauseris
Salvestame ja võrdleme katseidMLflow ehk katsete ja mudelite haldamise tööriist (vaade Experiments)
Hoiame mudelite versiooneMudeliregister Unity Catalogis
Käivitame mudeli veebiteenusenaModel Serving (menüü Serving)
Saame uued andmed ja prognoosiPrognoosileht (sammus 9) ja lisatöö vihik koos Job'iga (sammus 10)

Kõik vihikud ja tabelid

VihikLoebSalvestab
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 registris
4. Igapäevane prognoos (lisatöö)ilm_tunnused, linnade_koordinaadid, Open-Meteo, mudelilm_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 kirjutad lahtrid ise.
  3. Kood tuleb tunni failist. Ava oma arvutis tunnis tehtud MPLRegressor_example.ipynb, kopeeri sealt vajalikud lahtrid Databricksi vihikusse ja muuda neid. Juhend ütleb, mida teha, mis on oluline ja kuidas kontrollida. Valmis koodi saad ainult lisatööks (samm 10).

SAMM 1Ava oma Databricksi tööruum

Workspace tähendab tööruumi: sinu vihikute, tabelite ja teenuste ühist keskkonda.

  • Ava Databricks Free Edition ja vali tasuta konto loomine. Kui õpetaja andis kooli tööruumi lingi, kasuta seda.
  • Logi sisse ja lõpeta konto kinnitamine. Vali Free Edition, mitte piiratud ajaga tasuline prooviperiood.
  • Oota, kuni tööruum avaneb. Vasakul on menüü: Workspace, Catalog, Jobs & Pipelines, Experiments ja Serving. Kitsal ekraanil ava kõigepealt külgmenüü. Menüünimed võivad uuenduste tõttu veidi erineda.
  • Ava Catalog. Näed kataloogi workspace ja selle all skeemi default. Siin hakkavad kõik sinu tabelid olema.

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

Tasuta keskkonnal on kasutuspiirid. Free Edition kasutab serverless-arvutust: Databricks käivitab ja haldab arvutit sinu eest. Võivad olla piiratud töömaht, teenuste arv ja välised internetipäringud. Kui limiit saab täis, jätka pärast selle taastumist.

Kontroll

Näed tööruumi ja Catalogis kataloogi workspace koos skeemiga default. Kui oled kooli keskkonnas ja nime pole, küsi õpetajalt, millist kataloogi ja skeemi kasutada (siis asenda need nimed kõikjal).

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 (lat on laiuskraad, lon pikkuskraad); seda vajab alles lisatöö, aga tee tabel ära kohe. CSV on tabel tekstifailina: üks rida tähendab üht kirjet ja komad eraldavad veerge.

Tabel on andmed ridade ja veergudena, mida Databricks hoiab sinu eest. Tabeli täisnimi on kolmeosaline: kataloog.skeem.tabel. Tabeli nimi peab olema täpselt selline, nagu allpool kirjas, sest vihikud leiavad tabeli selle nime järgi.

FailTabeli täisnimi
weather_prediction_dataset.csvworkspace.default.weather_prediction_dataset
linnade_koordinaadid.csvworkspace.default.linnade_koordinaadid

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 (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 ja tabeli nimi (vt tabel ülal).
  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.

Tee samamoodi ka teise faili tabel.

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. Veerge on 165 (täpse ridade arvu, 3654, näed 1. vihikus).

SAMM 3Tee esimene vihik

Notebook ehk vihik on töövihik, milles selgitused ja kood paiknevad üksteise all. Lahter on üks kast selles vihikus. Koodilahtri käivitamisel täidetakse selle käsud. Selle sammu teed iga vihiku jaoks ühtemoodi.

  1. Vasakul vali New → Notebook. Avaneb tühi vihik. Ära impordi midagi.
  2. Anna vihikule nimi: klõpsa pealkirjal (Untitled Notebook …) ja kirjuta 01_andmete_ettevalmistus. Teised vihikud hiljem: 02_tunnused_ja_lagid, 03_mudel, lisatööks 04_igapaevane_prognoos.
  3. Paremal üleval vali Connect → Serverless. Compute tähendab arvutusressurssi ehk arvutit, mis koodi täidab; serverless tähendab, et Databricks annab selle ise.
  4. Lisa lahter nupuga + Code (hoia hiirt lahtrite vahel). Kopeeri tunni failist koodi ja muuda seda, nagu allpool kirjas.
  5. Lahtri käivitamiseks vajuta Shift + Enter või lahtri kolmnurka. Käivita lahtrid ülevalt alla. Vea korral vaata esimest veaga lahtrit; järgmised lahtrid vajavad sageli eelmise tulemust.

Mis on spark ja toPandas()?

Databricksi tabeleid loeb Spark (andmetöötlusvahend): spark.table("kataloog.skeem.tabel"). 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("kataloog.skeem.tabel") salvestab.

Spark ei luba tabeli ridade järjekorrale loota. Seepärast on tabelis kuupäev ja iga vihik sorteerib andmed kuupäeva järgi ise.

Kontroll

Esimene vihik on avatud, Serverless on valitud ja lahtri käivitamine töötab (näiteks lahter, mis prindib print(1+1)).

SAMM 4Vihik 1: andmete ettevalmistus

Eesmärk: lugeda tabel, korrastada kuupäev, jagada andmed treeningandmeteks (õppimiseks) ja testandmeteks (kontrolliks) ning salvestada need kahte uude tabelisse. Aluseks on tunni faili algus: andmete lugemine, kuupäev ja jagamine.

Mida teha

  1. Loe tabel workspace.default.weather_prediction_dataset Sparkiga ja tee see pandase tabeliks (toPandas()). Tunnis loeti CSV-fail; siin loetakse tabel.
  2. Korrasta kuupäev nagu tunnis. DATE on arv kujul 20000101: tee see kuupäevaks, sorteeri kasvavas järjekorras ja jäta DATE ning MONTH maha. Muudatus tunni failist: pane kuupäev uude veergu PAEV ja jäta see tabelisse alles.
  3. Jaga andmed ajajärjekorras. Tunnis kasutasime train_test_split koos shuffle=False ja test_size=0.3. Muudatus: jaga kogu tabel korraga (koos Stockholmi temperatuuriveeruga STOCKHOLM_temp_mean), mitte eraldi X ja y.
  4. Salvesta kaks tabelit: workspace.default.ilm_train (varasemad 70%) ja workspace.default.ilm_test (hilisemad 30%). Tee pandase tabelist Sparki tabel ja salvesta see käsuga saveAsTable. Salvestamisel kasuta režiimi overwrite, et vihikut saaks uuesti käivitada, ja lisa valik overwriteSchema = true, et uuesti salvestamine ei kukuks veerukomplekti muutumisel.

Mis on oluline

  • Ajajärjekord. Mudel peab ennustama tulevikku, seega treeningandmed on varasemad päevad ja testandmed hilisemad. Ära sega ridu juhuslikuks (shuffle=False).
  • Kuupäev jääb tabelisse (PAEV). Spark ei hoia ridade järjekorda; järgmine vihik taastab järjekorra kuupäeva järgi.
  • Tabelinimed täpselt nii, nagu ülal: järgmine vihik otsib neid nime järgi.

Kuidas kontrollida, et on õige

  • Prindi vihikus kuupäevade vahemik ja ridade arv. Treeningandmeid peaks olema 2557 rida (2000-01-01 … 2006-12-31) ja testandmeid 1097 rida (2007-01-01 … 2010-01-01).
  • Loe mõlemad tabelid tabelist tagasi (spark.table(…).toPandas()) ja kontrolli: ridu on kokku 3654; treeningandmete viimane kuupäev on enne testandmete esimest; veerge DATE ja MONTH ei ole; veerg PAEV ja STOCKHOLM_temp_mean on olemas. Veerge on 164 (165 − DATE − MONTH + PAEV).
  • Ava Catalog → workspace → default: seal on uued tabelid ilm_train ja ilm_test.

Kontroll

Kaks uut tabelit on olemas ja ridade arvud klapivad (2557 ja 1097).

SAMM 5Vihik 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. Aluseks on tunni faili osa tunnuste valikust ja lag'idest.

Mõisted

  • Tunnus on üks sisendarv, näiteks Oslo temperatuur kaks päeva tagasi. Sihtmuutuja ehk vastus on väärtus, mida ennustame: järgmise päeva Stockholmi keskmine temperatuur.
  • Korrelatsioon näitab, kui sarnaselt kaks arvujada muutuvad. Jätame alles tunnused, mis käivad homse temperatuuriga tugevalt kaasas. Seos ei tõesta, et üks temperatuur põhjustab teist.
  • Lag on ajaline nihe: tunnus pärineb varasemast päevast. day_0 on lähtepäev, day_1 sellele eelnev päev jne.
4 päeva tagasiday_3
3 päeva tagasiday_2
Üleeileday_1
Eileday_0
Tänaennustatav päev

Tänase ennustamisel on lähtepäev eile. Treeningandmetes tähendab day_0 rea enda päeva ja vastuseks on selle järgmine päev.

Mida teha

  1. Loe tabelid ilm_train ja ilm_test, sorteeri kuupäeva PAEV järgi ja pane PAEV indeksiks (set_index). Nii jääb iga rea juurde alles tema päev.
  2. Eralda vastus. X on kõik veerud peale STOCKHOLM_temp_mean, y on STOCKHOLM_temp_mean (nagu tunnis). Tee seda nii treening- kui testandmetele.
  3. Tee vastuseks järgmise päeva temperatuur: shift(-1) ja dropna() (tunnis y_train_in ja y_test_in).
  4. Esimene tunnuste valik. Arvuta treeningandmetel iga tunnuse absoluutne korrelatsioon homse temperatuuriga ja jäta alles tunnused, mille korrelatsioon on üle 0,3.
  5. Lag'id. Tee valitud tunnustele 4 nihet (day_0 … day_3), nagu tunnis. Muudatus: lisa veerunimedesse _day_0, _day_1 jne (tunnis oli _day-0); tabeli veerunimes ei kasuta sidekriipsu, sest SQL-is peaks see olema erimärkidega ümbritsetud. Viska ära esimesed read, millel puudub ajalugu (dropna), ja jäta alles ainult need read, millele on vastus olemas (isin vastuse indeksiga).
  6. Teine tunnuste valik. Arvuta lag-tunnuste korrelatsioon homse temperatuuriga (jälle ainult treeningandmetel) ja jäta alles need, mille korrelatsioon on üle 0,85. Tulemus on nimekiri tunnused, tugevaimast nõrgemani.
  7. Sama nimekiri testandmetele. Tee testandmetele samad lag'id ja võta ainult need veerud, mis on treeningandmete nimekirjas. Testandmetel ei arvutata ühtegi korrelatsiooni.
  8. Joonda vastus tunnustega: võta y-st ainult need päevad, mis on X-i indeksis (nii treening- kui testandmetel).
  9. Salvesta kolm tabelit: ilm_train_lag ja ilm_test_lag (kuupäev + 40 tunnust + vastuse veerg nimega y_homme; kuupäev on indeksis, seega enne salvestamist reset_index()) ning ilm_tunnused (kaks veergu: jrk = 0, 1, 2 … ja tunnus = tunnuse nimi). Tunnuste nimekirja vajab järgmine vihik ja lisatöö.

Mis on oluline

  • Andmeleke. Kõik valikud (korrelatsioonid, tunnuste nimekiri) tehakse ainult treeningandmete põhjal. Kui kasutaksid ka testandmeid, näeks mudel „tulevikku“ ja tulemus oleks eksitavalt hea.
  • Õige vastus. Korrelatsiooni arvutad alati homse temperatuuriga (nihutatud y), mitte tänasega.
  • Tunnuste nimekiri läheb tabelisse, sest mudel ootab täpselt neid veerge ja lisatöö ehitab sisendi nime järgi.
  • Tabelites ei tohi olla tühje väärtusi.

Kuidas kontrollida, et on õige

  • Esimese valiku järel peaks tunnuseid olema 94, teise järel 40.
  • Need 40 on kõik temperatuurid üheksast linnast, nimed on kujul STOCKHOLM_temp_max_day_0, OSLO_temp_mean_day_0 …
  • Treeningtabel on 2553 × 40 tunnust ja testtabel 1093 × 40 tunnust (veerg y_homme ja kuupäev on lisaks).
  • Loe tabelid tagasi ja kontrolli: tühje väärtusi ei ole; treeningandmete viimane kuupäev on enne testandmete esimest; ilm_tunnused on 40 rida.
  • Kui arv on teine, kontrolli: piirid 0,3 ja 0,85; vastus on shift(-1); korrelatsioonid on arvutatud treeningandmetel ja homse temperatuuriga; lag'id on tehtud pärast esimest valikut.
  • Catalogis on uued tabelid ilm_train_lag, ilm_test_lag ja ilm_tunnused.

Kontroll

Kolm uut tabelit on olemas, tunnuseid on 40 ja ridade arvud klapivad (2553 ja 1093).

SAMM 6Vihik 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. Aluseks on tunni faili mudeli ja mõõdikute osa.

Mõisted

  • MLflow jätab meelde, mida sa tegid: seaded, tulemused ja mudeli. Üks treenimine koos kõigega on katse (run). Parameeter on valitud seade, mõõdik on mõõdetud tulemus.
  • Register on mudelite loend. Iga uus salvestus on mudeli uus versioon (1, 2, 3 …).
  • Alias on silt versioonil. Silt champion tähendab „seda versiooni kasutame“.
  • Pipeline paneb skaleerija ja mudeli üheks tervikuks. Teenus saab sisendiks toored temperatuurid ja peab skaleerimise ise tegema.
  • Signature kirjeldab, millised veerud mudel ootab ja mis tuleb välja. Registri jaoks on see kohustuslik.

Mida teha

  1. Seadista register. Vihiku alguses kasuta mlflow.set_registry_uri("databricks-uc"): nii läheb mudel Unity Catalogi. Mudeli täisnimi on workspace.default.stockholmi_ilm (kolm osa: kataloog, skeem, mudel).
  2. Loe tabelid. Loe ilm_tunnused ja sorteeri veeru jrk järgi: see on tunnuste nimekiri. Loe ilm_train_lag ja ilm_test_lag ning sorteeri kuupäeva järgi. X on need veerud, mis on tunnuste nimekirjas, y on y_homme.
  3. Tee mudel. Tunnis olid StandardScaler ja MLPRegressor eraldi. Muudatus: pane need ühte Pipeline'i (esimene samm skaleerija, teine närvivõrk). Seaded jäävad samaks: hidden_layer_sizes=(50, 30), max_iter=1000, random_state=42.
  4. Tee katse. Kogu treenimine ja salvestamine käib ploki with mlflow.start_run(run_name="…") sees: treeni (fit treeningandmetel), ennusta testandmetel ja arvuta RMSE, MAE ja R² (nagu tunnis); salvesta seaded (mlflow.log_params) ja tulemused (mlflow.log_metrics).
  5. Salvesta mudel registrisse käsuga mlflow.sklearn.log_model. Anna talle: mudel; nimi name="mudel"; signature=infer_signature(X_train, mudel.predict(X_train)); input_example (X-i mõned esimesed read); registered_model_name = mudeli täisnimi; serialization_format="cloudpickle" (lihtne salvestusvorming meie enda mudeli jaoks). Käsk annab tulemuseks ka registri versiooninumbri (registered_model_version).
  6. Pane silt champion: MlflowClient().set_registered_model_alias(mudeli_nimi, "champion", versioon).
  7. Kontrolli laadimist. Lae mudel registrist sildi järgi (mlflow.pyfunc.load_model("models:/workspace.default.stockholmi_ilm@champion")), ennusta mõne esimese testrea jaoks ja võrdle vastust oma Pipeline'i vastusega.
  8. Vaata vigu nagu tunnis: tegelik miinus ennustus; mitu päeva eksime üle 3 kraadi?
  9. Tee JSON teenuse jaoks. Ühe testrea sisend on JSON kujul {"dataframe_split": {"columns": [tunnuste nimed], "data": [[40 arvu]]}}. Pythonis tee see käsuga json.dumps ja prindi välja. Kirjuta üles ka selle rea ennustus vihikus: teenuse vastust võrdled sellega.

Mis on oluline

  • Registri seadistus enne salvestamist. Ilma databricks-uc registrita ei jõua mudel Unity Catalogi.
  • Signature on kohustuslik ja input_example aitab teenusel sisendit kontrollida.
  • Alias kirjutatakse täpselt champion, sest sama nime kasutavad teenus ja lisatöö.
  • Hoiatus ConvergenceWarning tähendab, et õppimine jõudis korduste ülempiirini; see ei ole viga.

Kuidas kontrollida, et on õige

  • Mõõdikud testandmetel on ligikaudu: RMSE ≈ 2,07 °C, MAE ≈ 1,59 °C, R² ≈ 0,92. Väike erinevus (kümnendikud) on normaalne, sest Databricksi tarkvaraversioonid võivad õppimist veidi muuta. Üle 3 kraadi eksib mudel umbes 160 päeval 1093-st.
  • Esimesel korral on mudeli versioon 1 ja champion on 1.
  • Registrist laetud mudeli vastus on täpselt sama, mis vihikus oleva Pipeline'i vastus.
  • Vihiku paremas servas on ikoon Experiment: seal on sinu katse koos RMSE, MAE ja R²-ga.
  • Ava Catalog → workspace → default → Models → stockholmi_ilm: näed versiooni 1 ja silti champion.

Kontroll

Mudel on registris, sildil champion on versioon, ja registrist laetud mudel annab sama vastuse kui oma mudel.

SAMM 7Vaata, mida MLflow meelde jättis, ja vali versioon

Experiment on katsete kaust, run on üks katse. Alias champion ütleb, millist versiooni kasutame.

  1. Ava vihikus Experiment ikoon (või menüü Experiments) ja ava oma katse. Vaata Parameters (seaded) ja Metrics (tulemused).
  2. Leia Artifacts ehk katsega salvestatud failid: seal on sinu mudel.
  3. Tee teine katse: kopeeri 3. vihiku mudeli- ja katselahter, muuda peidetud kihtide suuruseks (100, 50) ja anna katsele uus nimi (run_name). Käivita. Registrisse tekib versioon 2.
  4. Võrdle katseid Experiment lehel: märgi mõlemad ja vali Compare. Vaata RMSE-d.
  5. Pane silt champion sellele versioonile, mille RMSE on väiksem. Seejärel käivita registrist laadimise kontroll uuesti: nüüd laeb ta uue championi.
MõõdikLihtne tähendusKumb on parem?
RMSEVea suurus kraadides, kus suured eksimused mõjutavad hinnet tugevamalt.Väiksem.
MAEPrognoosi ja õige vastuse absoluutsete erinevuste keskmine, kraadides.Väiksem.
R²Võrdlus meetodiga, mis ennustaks igal päeval testandmete keskmist temperatuuri.Suurem; 1 on parim. Võib olla negatiivne.

Viimane ei tähenda parim. Uus versioon võib olla halvem. Sildi pane mõõdiku, mitte versiooninumbri järgi. Kui valid mudelit testandmete tulemuse järgi, ei ole testandmed enam puutumata lõppkontroll; see on selles harjutuses lubatud, aga pea seda meeles.

Peatu ja mõtle. Ühe mudeli RMSE on 2,1 °C ja teisel 2,8 °C. Kumba eelistaksid ning miks? Need on selgitavad näidisarvud, mitte ette antud oodatavad tulemused.

Kontroll

Oskad näidata, millised seaded kahel katsel erinesid ja kummal on väiksem RMSE. Silt champion on parema versiooni küljes.

SAMM 8Käivita mudel veebiteenusena

Deploy ehk kasutuselevõtt tähendab siin mudeli käivitamist veebiteenusena. Model Serving hoiab mudelit töös ja vastab küsimustele. Endpoint on selle teenuse nime ja aadressiga ühenduspunkt.

  1. Ava vasakul Serving. Vali Create serving endpoint.
  2. Pane teenuse nimeks stockholmi-ilm.
  3. Vali Served entities → Entity → My models – Unity Catalog. Vali mudel workspace.default.stockholmi_ilm ja versioon, millel on silt champion.
  4. Vali arvutuseks CPU ja väikseim sobiv suurus (Small). CPU on tavaline protsessor; GPU on paljude paralleelarvutuste jaoks ja meie väikese mudeli jaoks ei ole vaja.
  5. Jäta kogu liiklus sellele ühele mudelile (100%). Kui näed valikut Scale to zero, lülita see sisse: jõude olev teenus võib ajutiselt peatuda ja uus päring võib alguses oodata käivitumist.
  6. Vajuta Create. Olek on Not Ready, kuni teenus on valmis. Oota, kuni olek on Ready; esimene loomine võib võtta mitu minutit. Ära loo ootamise ajal uusi teenuseid. Selle aja saad kasutada lisatööks.

Saada esimene päring

Päring on teenusele saadetud küsimus koos sisendandmetega. JSON on tekstivorming, milles andmetel on nimed ja väärtused. Meie päringus on columns veerunimed ja data nende väärtused samas järjekorras.

  1. Ava oma teenus ja vali Query endpoint.
  2. Kustuta aknast vana tekst ja kleebi 3. vihikus tehtud JSON (või genereeri see prognoosilehel, vt samm 9).
  3. Vajuta Send Request. Vastuses on predictions ehk prognooside loend; ühe sisendrea korral on selles üks arv, näiteks {"predictions": [5.8]}. See on ainult vastuse kuju näide: sinu arv ei pea olema 5,8.
  4. Võrdle vastust selle rea ennustusega, mille kirjutasid üles 3. vihikus. Need peavad olema samad.

Mudelisilt ja töötav teenus on eri asjad. Teenus kasutab kindlat versiooninumbrit. Kui tõstad hiljem sildi champion teisele versioonile, ei uuene töötav teenus ise: ava teenuse seadistus, vali uus versioon ja kinnita. Oota uuesti olekut Ready.

Free Editionis on aktiivsete teenuste arv piiratud. Kui oled töö esitanud, ava Serving ja kustuta ainult enda loodud teenus. Mudeliregistri versioonid ja tabelid jäävad alles.

Kui minu keskkond ei luba teenust luua

Kontrolli, et oled valinud oma registreeritud mudeli, mitte üldise keelemudeli. Kui kuvatakse limiidi- või õiguste viga, kirjuta see üles. Kooli keskkonnas küsi õpetajalt teenuse loomise õigust; tasuta keskkonnas oota limiidi taastumist. Registrist mudeli laadimist saad siiski kontrollida (samm 6). Märgi teenuseosa lõpetamata, kuni saad päris endpoint'ilt vastuse.

Kontroll

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

SAMM 9Uued andmed ja prognoos veebis

Teenusele andmete käsitsi kirjutamine on tüütu: sisendis on 40 arvu. Selleks on prognoosileht:

  • Genereerib andmeid: juhuslik päev ajaloost (koos tegeliku vastusega), sünteetilised andmed valitud hooajaks või eilsed päris andmed Open-Meteost. Võid ka ise väärtusi muuta ja liuguriga nihutada kõiki temperatuure.
  • Annab prognoosi kohe: arvutab õpetaja näidismudel, mis töötab sinu brauseris.
  • Annab valmis JSON-i, mille kopeerid oma teenuse Query endpoint aknasse. Nii võrdled oma mudeli vastust.

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. Nihuta liugurit +10 °C või −15 °C ja vaata vastust.

Leht ei ole ühendatud sinu Databricksi kontoga ega küsi paroole. Tema prognoos tuleb õpetaja näidismudelist, mis on treenitud samade sammudega nagu sinu vihikud; sinu teenuse vastus võib seetõttu veidi erineda. Open-Meteo nupp küsib päris ilmaandmeid ja ei saada sinu kohta midagi.

Kontroll

Oled saatnud oma teenusele vähemalt ühe lehelt kopeeritud JSON-i ja saanud vastuse.

LISATÖÖ · SAMM 10Vihik 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

  • Open-Meteo on ilmateenus. Selle API võimaldab programmil küsida ilmaandmeid; API on kokkulepitud suhtlusviis, mitte inimesele mõeldud ilmaleht. Teenus on mittekaubanduslikuks kasutuseks tasuta, andmed on litsentsiga CC BY 4.0.
  • Job ehk töö on Databricksi ajastatud käivitusjuhis: vihik käivitub iga päev ise.

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

See on ainus vihik, mille koodi saad siit kopeerida. Tee uus vihik 04_igapaevane_prognoos (samm 3) ja lisa allolevad lahtrid ülevalt alla. Lahtreid ei pea muutma: sinu töö on käivitada, tabeleid vaadata ja ajastada.

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

Lahter 1

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

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

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

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

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

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

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

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

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.

Kui Databricks ei pääse Open-Meteole ligi

  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 vihiku teises lahtris ALLIKAS = "tabel" ja käivita uuesti. Kõik edasine on sama. Iga uue päeva jaoks laadi uus fail.

Pane see tööle

  1. Käivita vihik lõpuni. Ava tabelid ilm_igapaev (peaks olema umbes 7 rida, üks rida iga päeva kohta) 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 esmalt Run now ja kontrolli, et töö õnnestub. Alles seejärel Add trigger → Scheduled: iga päev, ajavöönd Europe/Stockholm. Õppetöö lõpus keela ajakava.
  4. Vaata paari 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 andmejaotuse nihkeks ehk triiviks. Open-Meteo tänane arv on samuti prognoos, mitte päeva lõplik temperatuur; kahe prognoosi vahe ei ole mudeli tegelik viga.

Ära käivita iga päev 3. vihikut: muidu treenid asjatult uusi mudeleid ja tekitad uusi versioone. Igapäevaseks ennustamiseks piisab 4. vihikust.

Kontroll

Tabelites ilm_igapaev ja ilm_prognoosid on read, teine käivitus ei tekita topeltridu ja Job on ajastatud (või varuvariant töötab).

SAMM 11Mida esitada?

Esita lühike vastus ja pildid (ekraanitõmmised), millelt tulemus on loetav. Salajasi juurdepääsutõendeid ei ole vaja luua ega esitada.

  • Tabelid: Catalog, workspace.default tabelite loend (weather_prediction_dataset, linnade_koordinaadid, ilm_train, ilm_test, ilm_train_lag, ilm_test_lag, ilm_tunnused).
  • Katsed: kahe katse kihtide suurused ja RMSE. Kirjuta ühe lausega, miks valisid selle versiooni.
  • Register: mudeli täielik nimi, valitud versioon ja silt champion.
  • Mõõdikud: RMSE, MAE ja R² testandmetel.
  • Teenus: teenuse nimi, versioon ja päris päringu vastus (Query endpoint). Kui keskkonna piirang takistas loomist, esita täpne veateade ja ütle, et teenuseosa jäi lõpetamata.
  • Veebileht: üks prognoos genereeritud andmetega ja sama JSON-iga saadud teenuse vastus.
  • 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 tähendab day_0 ja miks mudelisilt champion ei uuenda töötavat teenust automaatselt?
  4. Mida ennustas sinu teenus, kui nihutasid temperatuure +10 või −15 °C võrra? Miks mudel võib sellistes oludes eksida?
  5. (Lisatöö) Miks kahe prognoosi vahe ei ole tegelik ennustusviga?

Kontroll

Oskad kirjeldada kogu teekonda: CSV → tabel → tunnused ja lag'id → mudel → katse → registri versioon → teenus → prognoos.


Linnukesed salvestatakse ainult sellesse brauserisse. Neid ei saadeta õpetajale.

Kui midagi ei tööta

Vaata esimest veaga lahtrit. Ära käivita järjest kõiki järgmisi lahtreid: need võivad vajada eelmise lahtri tulemust. Vea teksti viimane rida ütleb tavaliselt, mis valesti läks.

Mida näed?Mida see tähendab?Mida teha?
TABLE_OR_VIEW_NOT_FOUNDTabelit selle nimega ei leitud.Kontrolli Catalogist, et tabel on kataloogis workspace, skeemis default ja nimi on täpselt õige (väiketähed, alakriipsud).
ValueError: time data … doesn't match formatKuupäev ei ole sellises kujus, nagu kood ootab.Vaata, mis tüüpi on DATE (df.dtypes["DATE"]). Kui see on juba kuupäev, tee pd.to_datetime ilma format-ita; kui arv või tekst, kasuta format="%Y%m%d".
Notebook is not connected / kernel puudubVihikul pole arvutit.Paremal üleval vali Connect → Serverless.
NameErrorMuutuja pole loodud.Käivita vajalikud varasemad lahtrid järjekorras. Kui vihik taaskäivitus, kaovad muutujad mälust, aga tabelid jäävad.
Mudeli tunnuseid on mitte 94 / 40Mõni valik või piir erineb tunni failist.Kontrolli piire (0,3 ja 0,85), vastuse nihet shift(-1) ja seda, et korrelatsioonid on arvutatud ainult treeningandmetel.
Quota / fair usageTasuta kasutuse piir on täis.Ära loo uusi ressursse. Oota piiri taastumist ja teavita õpetajat. Vihikud kirjutavad tabelid üle, seega võid hiljem uuesti käivitada.
TypeError … unexpected keyword argument 'name'Sinu keskkonnas on vanem MLflow.Asenda name="mudel" koodiga artifact_path="mudel".
AttributeError … registered_model_versionVanem MLflow ei anna versiooni kaasa.Leia versioon registrist: kõige suurem versiooninumber käsuga MlflowClient().search_model_versions(…) sinu mudeli nime järgi.
PERMISSION_DENIED / NO_CATALOGSul pole selles asukohas õigust või nimi on vale.Kontrolli, et mudeli nimi on kolmeosaline workspace.default.stockholmi_ilm ja et registri seadistus databricks-uc on tehtud.
ModuleNotFoundError: plotlyGraafikupakett puudub.Graafik on vabatahtlik. Soovi korral käivita eraldi lahtris %pip install plotly ja siis vihik uuesti.
ConvergenceWarningNärvivõrk jõudis õppimise korduste piirini.See ei ole viga. Vaata mõõdikuid ja märgi hoiatus üles.
Teenus jääb kauaks olekusse Not ReadyTeenuse keskkonna ehitamine võtab aega või ebaõnnestus.Oota mitu minutit. Ava teenuse Logs ja Events; kui seal on viga, salvesta esimene veateade.
Teenuse loomisel limiit täisFree Editionis on aktiivseid teenuseid piiratud arv.Kustuta mittevajalik teenus (Serving → teenus → Delete) ja proovi uuesti.
Model is missing inputsPäringus puudub mõni mudeli veerg.Kasuta 3. vihikus tehtud JSON-i (või prognoosilehe JSON-i, kui sul on samad 40 tunnust).
Endpoint not foundSelle nimega teenust pole.Võrdle Serving-vaates olevat nime ja päringus kasutatud nime.
Teenuse ja vihiku arvud erinevadTeenuses on teine versioon või sisend.Vali teenuses sama versioon, mis on sildil champion, oota Ready ja saada täpselt sama JSON.
Lisatöö: ConnectionError / timeout Open-MeteoleIlmateenus on kättesaamatu või väline ühendus piiratud.Kasuta varuvarianti (prognoosileht → CSV → tabel ilm_openmeteo_fail → ALLIKAS = "tabel").
Lisatöö: Tabeli viimane päev on …, oodatud eileTabelis on vanad päevad.Käivita uuesti (API-ga uuendub) või lae varutabeli jaoks värske CSV. Ära muuda kuupäeva käsitsi.

Sõnastik

Siin on ka koodis ja Databricksi nuppudel esinevad sõnad. Sa ei pea kõiki pähe õppima.

Alias
Silt, mis viitab ühele mudeliversioonile. Meie silt on champion.
API
Kokkulepitud suhtlusviis programmide vahel: millise küsimuse saab saata ja millise vastuse saab tagasi.
Andmeleke
Mudel on testandmeid „näinud“ enne testimist (näiteks tunnuste valikul). Siis näib tulemus paremana, kui see päriselt on.
Catalog / kataloog
Andmete ja mudelite kõige suurem nimega jaotus. Meil: workspace.
Compute
Arvutusressurss ehk arvuti, millega koodi käivitatakse.
CSV
Tabel tekstifailis. Komad eraldavad veerge.
DataFrame
Ridade ja veergudega tabel Pythoni mälus.
Deploy
Kasutuselevõtt, siin mudeli käivitamine veebiteenusena.
Endpoint
Nime ja aadressiga teenus, millele saad sisendi saata.
Experiment / run
Experiment on katsete kogum, run on üks konkreetne katse.
JSON
Tekstivorming, kus väärtused on seotud nimedega. Loendid on nurksulgudes, nime–väärtuse kogumid looksulgudes.
Job / task / schedule
Job on salvestatud töö, task on üks selle samm ja schedule on käivitamise ajakava.
Korrelatsioon
Arvujadade koos muutumise mõõt. Ei tõesta põhjuslikku seost.
Lag / shift
Lag on ajaline nihe; shift on käsk, mis nihutab tabeli väärtusi ridade vahel.
MAE / RMSE / R²
Mudeli hindamise mõõdikud. MAE ja RMSE on siin kraadides (väiksem on parem); R² on ühikuta (1 on parim).
MLflow
Tööriist, mis salvestab katsete seaded, tulemused ja mudelid.
MLPRegressor
Mitmekihiline närvivõrk, mis ennustab arvu.
Mudeliregister
Koht, kus mudelitel on nimi, versioonid ja kasutusõigused.
Notebook (vihik)
Töövihik, kus selgitused ja käivitatavad koodilahtrid on ühes failis.
pandas
Pythoni pakett tabelitega töötamiseks. Tunnis kasutatud.
Pipeline
Järjestikused töötlussammud ühe tervikuna, siin skaleerija ja mudel.
Predictions
Teenuse vastuses olev prognooside loend.
Query endpoint
Teenuse lehe vorm, kuhu kleebid JSON-i ja saad vastuse.
Regressioon
Arvulise vastuse ennustamine, näiteks temperatuur kraadides.
Scale to zero
Jõudeolekul teenuse arvutusressursi peatamine. Uus päring võib alguses oodata käivitumist.
Schema / skeem
Kataloogi sees olev jaotus. Meil: default.
Serverless
Teenusepakkuja haldab arvuteid; sina käivitad töö. See ei tähenda, et arvutit pole olemas.
Signature
Mudeli sisendi ja väljundi kirjeldus: veergude nimed ja andmetüübid.
Skaleerimine
Arvude teisendamine võrreldavale skaalale (StandardScaler).
Spark
Andmetöötlusvahend. Databricksi tabeleid loeb ja kirjutab Spark; toPandas() viib tabeli pandasesse.
Tabel
Andmed ridade ja veergudega, mida Databricks hoiab. Nimi on kujul kataloog.skeem.tabel.
Target / feature
Target ehk sihtmuutuja on ennustatav vastus, feature ehk tunnus on üks mudeli sisend.
Train / test
Treeningandmetest mudel õpib, testandmetel kontrollime tulemust. Ilmaprognoosis on testandmed ajas hilisemad.
Unity Catalog
Databricksi süsteem andmete ja mudelite nimede ning kasutusõiguste haldamiseks.
Version
Üks nummerdatud mudeli salvestus. Uus versioon ei pruugi olla eelmisest parem.
Workspace
Databricksi tööruum, kus näed vihikuid, andmeid ja teenuseid.

Väike spikker: nimed, mida selles töös vaja läheb

Kood tuleb tunni failist. Alles on vaid mõned Databricksi-spetsiifilised nimed, mida tunnis ei olnud:

  • spark.table("kataloog.skeem.tabel") loeb tabeli; .toPandas() teeb selle pandase tabeliks.
  • spark.createDataFrame(pandase_tabel) teeb pandase tabelist Sparki tabeli; .write.mode("overwrite").option("overwriteSchema", "true").saveAsTable("kataloog.skeem.tabel") salvestab selle tabelina.
  • display(tabel) näitab tabelit Databricksis mugavalt.
  • mlflow.set_registry_uri("databricks-uc") valib registriks Unity Catalogi.
  • with mlflow.start_run(run_name="…"): alustab katset; selle sees mlflow.log_params, mlflow.log_metrics ja mlflow.sklearn.log_model.
  • infer_signature(X, ennustus) teeb mudeli sisendi ja väljundi kirjelduse (from mlflow.models import infer_signature).
  • MlflowClient().set_registered_model_alias(nimi, "champion", versioon) paneb versioonile sildi (from mlflow import MlflowClient).
  • mlflow.pyfunc.load_model("models:/kataloog.skeem.mudel@champion") laeb mudeli sildi järgi; .predict(X) ennustab.