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 defaultMida vajad?
- Arvutit, brauserit ja internetiühendust.
- Databricks Free Editioni kontot või õpetaja antud tööruumi.
- Kahte andmefaili:
weather_prediction_dataset.csvjalinnade_koordinaadid.csv(lingid ülal). - Tunnis tehtud faili
MPLRegressor_example.ipynboma 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 andmeid | Tabelid kataloogis workspace, skeemis default (Unity Catalog) |
| Käivitame koodi ja loeme selgitusi | Notebook ehk koodi ja selgitustega töövihik brauseris |
| Salvestame ja võrdleme katseid | MLflow ehk katsete ja mudelite haldamise tööriist (vaade Experiments) |
| Hoiame mudelite versioone | Mudeliregister Unity Catalogis |
| Käivitame mudeli veebiteenusena | Model Serving (menüü Serving) |
| Saame uued andmed ja prognoosi | Prognoosileht (sammus 9) ja lisatöö vihik koos Job'iga (sammus 10) |
Kõik vihikud ja tabelid
| Vihik | Loeb | Salvestab |
|---|---|---|
| 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 registris |
| 4. Igapäevane prognoos (lisatöö) | ilm_tunnused, linnade_koordinaadid, Open-Meteo, mudel | 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 kirjutad lahtrid ise.
- 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
workspaceja selle all skeemidefault. 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.
| Fail | Tabeli täisnimi |
|---|---|
weather_prediction_dataset.csv | workspace.default.weather_prediction_dataset |
linnade_koordinaadid.csv | workspace.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
- 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 (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, skeemdefaultja tabeli nimi (vt tabel ülal). - 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, skeemisdefault, on kaks tabelit:weather_prediction_datasetjalinnade_koordinaadid. - Avades
weather_prediction_datasetnäed vahekaarti Sample Data. VeergDATEsisaldab arve nagu20000101. 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.
- Vasakul vali New → Notebook. Avaneb tühi vihik. Ära impordi midagi.
- Anna vihikule nimi: klõpsa pealkirjal (Untitled Notebook …) ja kirjuta
01_andmete_ettevalmistus. Teised vihikud hiljem:02_tunnused_ja_lagid,03_mudel, lisatööks04_igapaevane_prognoos. - Paremal üleval vali Connect → Serverless. Compute tähendab arvutusressurssi ehk arvutit, mis koodi täidab; serverless tähendab, et Databricks annab selle ise.
- Lisa lahter nupuga + Code (hoia hiirt lahtrite vahel). Kopeeri tunni failist koodi ja muuda seda, nagu allpool kirjas.
- 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
- Loe tabel
workspace.default.weather_prediction_datasetSparkiga ja tee see pandase tabeliks (toPandas()). Tunnis loeti CSV-fail; siin loetakse tabel. - Korrasta kuupäev nagu tunnis.
DATEon arv kujul20000101: tee see kuupäevaks, sorteeri kasvavas järjekorras ja jätaDATEningMONTHmaha. Muudatus tunni failist: pane kuupäev uude veerguPAEVja jäta see tabelisse alles. - Jaga andmed ajajärjekorras. Tunnis kasutasime
train_test_splitkoosshuffle=Falsejatest_size=0.3. Muudatus: jaga kogu tabel korraga (koos Stockholmi temperatuuriveerugaSTOCKHOLM_temp_mean), mitte eraldi X ja y. - Salvesta kaks tabelit:
workspace.default.ilm_train(varasemad 70%) jaworkspace.default.ilm_test(hilisemad 30%). Tee pandase tabelist Sparki tabel ja salvesta see käsugasaveAsTable. Salvestamisel kasuta režiimioverwrite, et vihikut saaks uuesti käivitada, ja lisa valikoverwriteSchema=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; veergeDATEjaMONTHei ole; veergPAEVjaSTOCKHOLM_temp_meanon olemas. Veerge on 164 (165 −DATE−MONTH+PAEV). - Ava Catalog →
workspace→default: seal on uued tabelidilm_trainjailm_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_0on lähtepäev,day_1sellele eelnev päev jne.
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
- Loe tabelid
ilm_trainjailm_test, sorteeri kuupäevaPAEVjärgi ja panePAEVindeksiks (set_index). Nii jääb iga rea juurde alles tema päev. - Eralda vastus. X on kõik veerud peale
STOCKHOLM_temp_mean, y onSTOCKHOLM_temp_mean(nagu tunnis). Tee seda nii treening- kui testandmetele. - Tee vastuseks järgmise päeva temperatuur:
shift(-1)jadropna()(tunnisy_train_injay_test_in). - Esimene tunnuste valik. Arvuta treeningandmetel iga tunnuse absoluutne korrelatsioon homse temperatuuriga ja jäta alles tunnused, mille korrelatsioon on üle 0,3.
- Lag'id. Tee valitud tunnustele 4 nihet (
day_0…day_3), nagu tunnis. Muudatus: lisa veerunimedesse_day_0,_day_1jne (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 (isinvastuse indeksiga). - 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. - Sama nimekiri testandmetele. Tee testandmetele samad lag'id ja võta ainult need veerud, mis on treeningandmete nimekirjas. Testandmetel ei arvutata ühtegi korrelatsiooni.
- Joonda vastus tunnustega: võta y-st ainult need päevad, mis on X-i indeksis (nii treening- kui testandmetel).
- Salvesta kolm tabelit:
ilm_train_lagjailm_test_lag(kuupäev + 40 tunnust + vastuse veerg nimegay_homme; kuupäev on indeksis, seega enne salvestamistreset_index()) ningilm_tunnused(kaks veergu:jrk= 0, 1, 2 … jatunnus= 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_hommeja kuupäev on lisaks). - Loe tabelid tagasi ja kontrolli: tühje väärtusi ei ole; treeningandmete viimane kuupäev on enne testandmete esimest;
ilm_tunnusedon 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_lagjailm_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
championtä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
- Seadista register. Vihiku alguses kasuta
mlflow.set_registry_uri("databricks-uc"): nii läheb mudel Unity Catalogi. Mudeli täisnimi onworkspace.default.stockholmi_ilm(kolm osa: kataloog, skeem, mudel). - Loe tabelid. Loe
ilm_tunnusedja sorteeri veerujrkjärgi: see on tunnuste nimekiri. Loeilm_train_lagjailm_test_lagning sorteeri kuupäeva järgi. X on need veerud, mis on tunnuste nimekirjas, y ony_homme. - Tee mudel. Tunnis olid
StandardScalerjaMLPRegressoreraldi. Muudatus: pane need ühtePipeline'i (esimene samm skaleerija, teine närvivõrk). Seaded jäävad samaks:hidden_layer_sizes=(50, 30),max_iter=1000,random_state=42. - Tee katse. Kogu treenimine ja salvestamine käib ploki
with mlflow.start_run(run_name="…")sees: treeni (fittreeningandmetel), ennusta testandmetel ja arvuta RMSE, MAE ja R² (nagu tunnis); salvesta seaded (mlflow.log_params) ja tulemused (mlflow.log_metrics). - Salvesta mudel registrisse käsuga
mlflow.sklearn.log_model. Anna talle: mudel; niminame="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). - Pane silt
champion:MlflowClient().set_registered_model_alias(mudeli_nimi, "champion", versioon). - 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. - Vaata vigu nagu tunnis: tegelik miinus ennustus; mitu päeva eksime üle 3 kraadi?
- Tee JSON teenuse jaoks. Ühe testrea sisend on JSON kujul
{"dataframe_split": {"columns": [tunnuste nimed], "data": [[40 arvu]]}}. Pythonis tee see käsugajson.dumpsja prindi välja. Kirjuta üles ka selle rea ennustus vihikus: teenuse vastust võrdled sellega.
Mis on oluline
- Registri seadistus enne salvestamist. Ilma
databricks-ucregistrita ei jõua mudel Unity Catalogi. - Signature on kohustuslik ja
input_exampleaitab teenusel sisendit kontrollida. - Alias kirjutatakse täpselt
champion, sest sama nime kasutavad teenus ja lisatöö. - Hoiatus
ConvergenceWarningtä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
championon 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 siltichampion.
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.
- Ava vihikus Experiment ikoon (või menüü Experiments) ja ava oma katse. Vaata Parameters (seaded) ja Metrics (tulemused).
- Leia Artifacts ehk katsega salvestatud failid: seal on sinu mudel.
- 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. - Võrdle katseid Experiment lehel: märgi mõlemad ja vali Compare. Vaata RMSE-d.
- Pane silt
championsellele versioonile, mille RMSE on väiksem. Seejärel käivita registrist laadimise kontroll uuesti: nüüd laeb ta uue championi.
| Mõõdik | Lihtne tähendus | Kumb on parem? |
|---|---|---|
| RMSE | Vea suurus kraadides, kus suured eksimused mõjutavad hinnet tugevamalt. | Väiksem. |
| MAE | Prognoosi 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.
- Ava vasakul Serving. Vali Create serving endpoint.
- Pane teenuse nimeks
stockholmi-ilm. - Vali Served entities → Entity → My models – Unity Catalog. Vali mudel
workspace.default.stockholmi_ilmja versioon, millel on siltchampion. - 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.
- 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.
- 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.
- Ava oma teenus ja vali Query endpoint.
- Kustuta aknast vana tekst ja kleebi 3. vihikus tehtud JSON (või genereeri see prognoosilehel, vt samm 9).
- Vajuta Send Request. Vastuses on
predictionsehk 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. - 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
- 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?
- 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
- 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.
Kui Databricks ei pääse Open-Meteole ligi
- 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 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
- Käivita vihik lõpuni. Ava tabelid
ilm_igapaev(peaks olema umbes 7 rida, üks rida iga päeva kohta) 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 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. - 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.defaulttabelite 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
- Miks jagasime andmed ajajärjekorras (
shuffle=False), mitte juhuslikult? - Miks valisime tunnused ainult treeningandmete põhjal? Mis juhtuks, kui kasutaksime ka testandmeid?
- Mida tähendab
day_0ja miks mudelisiltchampionei uuenda töötavat teenust automaatselt? - Mida ennustas sinu teenus, kui nihutasid temperatuure +10 või −15 °C võrra? Miks mudel võib sellistes oludes eksida?
- (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_FOUND | Tabelit 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 format | Kuupä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 puudub | Vihikul pole arvutit. | Paremal üleval vali Connect → Serverless. |
| NameError | Muutuja 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 / 40 | Mõ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 usage | Tasuta 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_version | Vanem 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_CATALOG | Sul 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: plotly | Graafikupakett puudub. | Graafik on vabatahtlik. Soovi korral käivita eraldi lahtris %pip install plotly ja siis vihik uuesti. |
| ConvergenceWarning | Nä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 Ready | Teenuse 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äis | Free Editionis on aktiivseid teenuseid piiratud arv. | Kustuta mittevajalik teenus (Serving → teenus → Delete) ja proovi uuesti. |
| Model is missing inputs | Pä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 found | Selle nimega teenust pole. | Võrdle Serving-vaates olevat nime ja päringus kasutatud nime. |
| Teenuse ja vihiku arvud erinevad | Teenuses 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-Meteole | Ilmateenus 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 eile | Tabelis 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 seesmlflow.log_params,mlflow.log_metricsjamlflow.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.