Kritulių dabartinė transliacija naudojant mašininį mokymąsi

Šiais laikais meteorologai apskaičiavo, kad 90% orų prognozių yra teisingos per 5 dienų laikotarpį. Prognozės paprastai yra pagrįstos dviem skirtingais metodais:

Fizikomis pagrįsti metodai: šie metodai naudoja modelius, kurie integruoja išmatuojamus dydžius, tokius kaip slėgis, debesų judėjimas, dangaus sąlygos... Tokie modeliai gerai prognozuoja ateinančių dienų ar savaičių orą.
Nefiziniai (duomenimis pagrįsti) metodai: šie metodai naudoja istorinius duomenis, kad sukurtų modelius, kurie gali sudaryti prognozes. Tokie modeliai rodo gerus rezultatus numatant orą iki 6 valandų arba vadinamą orų dabarties prognoze.

Šiame straipsnyje aptarsime antrąją metodų kategoriją. Aptarsime skirtingus orų duomenų formatus, kaip mašininį mokymąsi galima panaudoti atliekant orų prognozę ir kaip sukurtos architektūros gali būti naudingos sprendžiant panašias problemas.

Klimato prognozavimo duomenys

Kadangi metodai be fizikos naudoja istorinius duomenis, pradėkime nuo turimų duomenų.

Naudosime du pagrindinius duomenų šaltinius:

Vaizdo duomenys: šie duomenys yra radaro arba palydovinių vaizdų iš nurodytos geografinės srities. Jis naudojamas nuspėti kritulius, vėjo judėjimą ar drėgmę.

Lenteliniai duomenys : šie duomenys pateikiami išmatuojamų dydžių, pvz., temperatūros, drėgmės ar vėjo greičio, įrašų forma.

Nors abu duomenų šaltiniai yra svarbūs kuriant galingus modelius, dėl paprastumo sutelksime dėmesį į pirmąjį (vaizdo duomenis, surinktus iš radarų ar palydovų). Dažniausiai naudojami modeliai su vaizdo duomenimis yra Convolutional Neural Networks (CNN ).

Atlikę šį darbą, naudosime U-Net architektūrą, kad sukurtume savo dabarties perdavimo modelį.

Architektūra

Pradėti nuo esamos architektūros naudinga dėl daugelio priežasčių, tarp kurių:

Architektūros yra gairės kuriant naujus modelius. Žmonės, kuriantys naujas architektūras, taiko bandymų ir klaidų metodą, kad pasiektų galutinius rezultatus. Pakartotinai panaudoję galutinius rezultatus, galime sutaupyti daug laiko.

Iš anksto paruoštus modelius paprastai galima naudoti nedelsiant. Kai mokslininkai paskelbia savo naujas architektūras, jie paprastai skelbia ir išmoktus parametrus, kad vartotojams nereikėtų treniruotis / optimizuoti nuo nulio. Tai ypač naudinga labai dideliems, išteklių ištroškusiems modeliams.

Garsios vizijos architektūros pavyzdžiai:

„LeNet“ (60 000 parametrų)

AlexNet (60 m parametrai)

VGG-16 (138 m parametrai)

U-Net

U-Net yra architektūra, pagrįsta visiškai konvoliuciniu tinklu, tai reiškia, kad jame nėra visiškai sujungtų sluoksnių. Pirmą kartą jis buvo pristatytas medicininio vaizdo segmentavimo užduočiai. Šie rezultatai paskatino tyrėjus išplėsti tai ir kitoms kompiuterinio regėjimo užduotims.

2019 m. „Google“ naudojo U-Net architektūrą, kad sukurtų kritulių prognozavimo modelį.

Pavadinimas „U-Net“ kilęs iš jo architektūros „U“ formos.

Mes nustatome tris pagrindinius komponentus:

Sutraukimas / kodavimo priemonė: sujungimo / sujungimo sluoksnių, suglaudinančių įvesties vaizdą į mažesnio dydžio vaizdą, paeiliui.
Tiltas / kliūtis: apatinė „U“ raidės dalis jungia kodavimo įrenginį su dekoderiu. Jį sudaro daugybė konvoliucijos operacijų.
Decontracting / Dekoderis: aukštyn konvoliucijos ir konvoliucijos sluoksnių, kurie "išskleidžia" kliūties išvestį, seka.

Iki šiol U-Net architektūra atrodo kaip automatinis kodavimo įrenginys. Tačiau skirtumas yra informacija, perduodama tarp kodavimo įrenginio ir dekoderio. Ši informacija perduodama sujungiant kodavimo įrenginio konvoliucijos rezultatus su dekoderio konvoliucijos rezultatais. Ši modifikacija padidina skiriamąją gebą ir leidžia modeliui pateikti tikslesnę erdvinę išvestį (pikselių vieta išvestyje bus tikslesnė, išspręsdama problemą, iškilusią modeliuose, kuriuose nebuvo sujungimo). Sujungimas atliekamas simetriškai.

Sukurkite U-Net modelį kritulių dabartinei transliacijai

Šiame skyriuje mes sukursime U-Net modelį, skirtą numatyti orą iš palydovinių vaizdų. Naudosime iš anksto paruoštą modelį, pavadintą Rain-Net.

Toliau pateiktas kodas pasiekiamas šioje colab.

Pirmiausia įdiegiame wradlib, atvirojo kodo biblioteką, skirtą orų radarų duomenų apdorojimui

!pip install wradlib
import wradlib as wrl

Tada parašome dvi paslaugų funkcijas, skirtas palydoviniams duomenims atsisiųsti iš DWD atvirųjų duomenų serverio


import urllib.request
import io
import numpy as np
import datetime

def download_and_read_RY(RY_timestamp):
   url = f"https://opendata.dwd.de/weather/radar/radolan/ry/raa01-ry_10000-{RY_timestamp}-dwd---bin"
   data_binary = urllib.request.urlopen(url).read()
   data, attr = wrl.io.read_radolan_composite(io.BytesIO(data_binary), missing = 0)
   data = data.astype("float32")
   return data,attr

def download_data():
   latest_scan, latest_attr = download_and_read_RY("latest")
   latest_datetime = latest_attr["datetime"]
   list_for_downloading = [ts.strftime("%y%m%d%H%M") for ts in
       [latest_datetime - datetime.timedelta(minutes=t) for t in [15, 10, 5]]]
   previous_scans = np.array([download_and_read_RY(ts)[0] for ts in list_for_downloading])
   print(list_for_downloading)
   scans = np.concatenate([previous_scans, latest_scan[np.newaxis, ::, ::]], axis = 0)

   return scans, latest_datetime

Šios komunalinės paslaugos leidžia atsisiųsti naujausius 4 palydovinius vaizdus, tai yra palydovinių vaizdų skaičius, kurio mums reikia, kad galėtume numatyti mūsų iš anksto paruoštą modelį.

Tada galime naudoti sukurtas funkcijas, kad gautume naujausius 4 vaizdus


RY_latest, RY_latest_timestep = download_data()

Gavę vaizdus, mes naudojame wradlib vis.plot_ppi metodą duomenims nubraižyti

for i in range(RY_latest.shape[0]):
   wrl.vis.plot_ppi(RY_latest[i])

Dabar mes įkėlėme savo duomenis. Toliau įkelkime modelį.

Pradedame importuodami atitinkamas klases. Šiame straipsnyje naudosime TensorFlow.

iš tensorflow.keras.layers importuoti įvestį, Conv2D, aktyvinimą, sujungimą, Conv2DTranspose, MaxPool2D

iš tensorflow.keras.models importo Modelis

Pastatykime 3 primityvius statybinius blokus. Šie „statybiniai blokai“ bus naudojami kuriant visą architektūrą pagal šį diegimą.

Pirmasis blokas atitinka konvoliucinių sluoksnių eilę, vadiname „conv_block“

def conv_block(input, num_filters):
   x = Conv2D(num_filters, 3, padding ="same", kernel_initializer="he_normal"(input))
   x = Activation("relu")(x)
   x = Conv2D(num_filters, 3, padding ="same", kernel_initializer="he_normal"(x))
   x = Activation("relu")(x)
   return x

Antrasis blokas naudojamas sukurti iš kodavimo dalies (konvoliucinis blokas + maksimalus telkimas). Mes tai vadiname „encoder_block“

def encoder_block(input, num_filters):
   x = conv_block(input, num_filters)
   p = MaxPool2D((2,2))(x)
   return x,p

Trečiasis ir paskutinis blokas yra „decoder_block“ (aukštyn konvoliucija + sujungimas + konvoliucija).

def decoder_block(input, skip_features, num_filters):
   x = Conv2DTranspose(num_filters, (2,2), strides=2, padding="same", kernel_initializer="he_normal")
   x = Concatenate()([x, skip_features])
   x = conv_block(x, num_filters)
   return x

Sujungiame šiuos blokus, kad sukurtume U-Net modelį

def build_unet(input_shape = (928, 928, 4)):

   inputs = Input(input_shape)
   e1, p1 = encoder_bock(inputs, 64)
   e2, p2 = encoder_bock(p1, 128)
   e3, p3 = encoder_bock(p2, 256)
   e4, p4 = encoder_bock(p3, 512)

   b1 = conv_block(p4, 1024)

   d1 = decoder_block(b1, e4, 512)
   d2 = decoder_block(d1, e3, 256)
   d3 = decoder_block(d2, e2, 128)
   d4 = decoder_block(d3, e1, 64)

   outputs = Conv2D(1, 1, padding="same", activation="linear")(d4)

   unet = Model(inputs, outputs, name="U-Net")

   return unet

Nedvejodami žaiskite su diegimu, patobulinkite jį arba pritaikykite jį savo poreikiams, jei norite jį panaudoti kažkam kitam.

Šio modelio mokymas gali užtrukti daug laiko. Laimei, yra modelis, vadinamas Rain-Net, kuris buvo sukurtas remiantis U-Net architektūra ir specializuojasi kritulių numetimo srityje.

Klonuokime jos „GitHub“ saugyklą

! git clone https://github.com/hydrogo/rainnet.git

Tada atsisiunčiame iš anksto paruoštus šio modelio svorius

!wget -O /content/rainnet/rainnet_weights.h5 https://zenodo.org/record/3630429/files/rainnet_weights.h5

Kitas žingsnis yra sukurti modelį, pagrįstą saugykloje esančia architektūra, tada įkelti į šį modelį atsisiųstus svorius.

import sys
from rainnet import rainnet
model = rainnet.rainnet()
model.load_weights('/content/rainnet/rainnet_weights.h5')
model.summary()

Atsisiųstų vaizdų dydis yra 900*900 pikselių. Šiuos vaizdus pakeisime taip, kad jie atitiktų numatomą Rain-Net įvestį

def Scaler(array):
   return np.log(array+0.01)


def invScaler(array):
   return np.exp(array) - 0.01


def pad_to_shape(array, from_shape=900, to_shape=928, how="mirror"):
   # calculate how much to pad in respect with native resolution
   padding = int( (to_shape - from_shape) / 2)
   # for input shape as (batch, W, H, channels)
   if how == "zero":
       array_padded = np.pad(array, ((0,0),(padding,padding),(padding,padding),(0,0)), mode="constant", constant_values=0)
   elif how == "mirror":
       array_padded = np.pad(array, ((0,0),(padding,padding),(padding,padding),(0,0)), mode="reflect")
   return array_padded


def pred_to_rad(pred, from_shape=928, to_shape=900):
   # pred shape 12,928,928
   padding = int( (from_shape - to_shape) / 2)
   return pred[::, padding:padding+to_shape, padding:padding+to_shape].copy()

'''
the spatial extent of input data has to be a multiple of 2n+1
where n is the number of max pooling layers
'''

def data_preprocessing(X):

   # 0. Right shape for batch
   X = np.moveaxis(X, 0, -1)
   X = X[np.newaxis, ::, ::, ::]
   # 1. To log scale
   '''
   We use a log scale to respond to skewness towards large values
   '''
   X = Scaler(X)
   # 2. from 900x900 to 928x928
   X = pad_to_shape(X)

   return X


def data_postprocessing(nwcst):

   # 0. Squeeze empty dimensions
   nwcst = np.squeeze(np.array(nwcst))
   # 1. Convert back to rainfall depth
   nwcst = invScaler(nwcst)
   # 2. Convert from 928x928 back to 900x900
   nwcst = pred_to_rad(nwcst)
   # 3. Return only positive values
   nwcst = np.where(nwcst>0, nwcst, 0)
   return nwcst

Tada sukuriame funkciją, kuri daro prognozes.

def prediction(model_instance, input_data, lead_time=24):

   input_data = data_preprocessing(input_data)
   nwcst = []

   for _ in range(lead_time):
       pred = model_instance.predict(input_data)
       nwcst.append(pred)
       input_data = np.concatenate([input_data[::, ::, ::, 1:], pred], axis = -1)

   nwcst = data_postprocessing(nwcst)

   return nwcst

Tada šią funkciją iškviečiame pagal anksčiau atsisiųstus duomenis

Y_pred = prediction(model, RY_latest)

Galime nubraižyti prognozes ir jas išsaugoti, kad panaudotume išsaugotus rezultatus, kad sukurtume gif vaizdą, leidžiantį vizualizuoti prognozes.

import matplotlib.pyplot as plt
names = []
for i in range(0, 19):
   im = wrl.vis.plot_ppi(Y_pred[i])
   name = '/content/image'+str(i)+'.png'
   names.append(name)
   plt.savefig(name)

import imageio
from google.colab import files

imgs = []

for name in names:
   imgs.append(imageio.imread(name))

imageio.mimsave('/content/pred.gif', imgs, fps=4)
files.download('/content/pred.gif')

Sveikiname, kad taip toli pavyko! Dabar galite naudoti Rain-Net prognozes ir jas vizualizuoti.

Išvada

Šiame straipsnyje naudojome mašininio mokymosi modelį (Rain-Net), kad atliktume kritulių dabartinį liejimą. Naudojome U-Net architektūrą, kurią sukūrėme naudodami TensorFlow. Įkėlėme iš anksto paruoštą modelį, kad galėtume numatyti palydovinius vaizdus.

Šį įgyvendinimą galima patobulinti įvairiais būdais. Pavyzdžiui:

Tiksliai sureguliuokite modelį duomenų rinkinyje
Architektūroje naudokite dėmesiu pagrįstą modulį, pvz., CBAM (Convolutional Block Attention Module).

Nuorodos

– Colab

– Originalus U-Net popierius

– „Google“ tinklaraštis apie U-Net pagrįstą orų prognozavimo modelį

– Rain-Net diegimas

– U-Net diegimas

Ateikite į vieną iš mūsų nemokamų seminarų!

Pradėkite savo, kaip duomenų mokslininko, karjerą mūsų nemokamuose seminaruose, kurie yra pagrįsti pritaikoma mokymo programa ir vadovaujami pramonės ekspertų.