Trenutno napovedovanje padavin s strojnim učenjem

Dandanes meteorologi ocenjujejo, da je 90 % vremenskih napovedi pravilnih v 5-dnevnem obdobju. Napovedi, ki so narejene, običajno temeljijo na dveh ločenih metodah:

Pristopi, ki temeljijo na fiziki: Ti pristopi uporabljajo modele, ki združujejo merljive količine, kot so tlak, gibanje oblakov, stanje neba ... Takšni modeli so dobri pri napovedovanju vremena za prihajajoče dni ali tedne.
Pristopi brez fizike (na podlagi podatkov): Ti pristopi uporabljajo zgodovinske podatke za ustvarjanje modelov, ki lahko dajejo napovedi. Takšni modeli kažejo dobre rezultate pri napovedovanju vremena do 6 ur ali tako imenovanem napovedovanju vremena.

V tem članku bomo obravnavali drugo kategorijo pristopov. Razpravljali bomo o različnih formatih vremenskih podatkov, o tem, kako je mogoče strojno učenje uporabiti za napovedovanje vremena in kako so lahko razvite arhitekture koristne za reševanje podobnih problemov.

Podatki za napovedovanje podnebja

Ker pristopi brez fizike uporabljajo zgodovinske podatke, začnimo z ogledom razpoložljivih podatkov.

Uporabili bomo dva glavna vira podatkov:

Slikovni podatki: Ti podatki so v obliki radarskih ali satelitskih slik določenega geografskega območja. Uporablja se za napovedovanje padavin, gibanja vetra ali vlažnosti.

Tabelarni podatki : Ti podatki so v obliki zapisov merljivih količin, kot so temperatura, vlažnost ali hitrost vetra.

Medtem ko sta oba vira podatkov pomembna za izdelavo zmogljivih modelov, se bomo zaradi enostavnosti osredotočili na prvega (slikovni podatki, zbrani iz radarjev ali satelitov). Najpogosteje uporabljeni modeli s slikovnimi podatki so konvolucijska nevronska omrežja (CNN ).

Po tem delu bomo uporabili arhitekturo U-Net za izgradnjo lastnega modela napovedovanja trenutnih časov.

Arhitektura

Začeti z obstoječo arhitekturo je koristno iz več razlogov, med katerimi so:

Arhitekture služijo kot smernice za ustvarjanje novih modelov. Ljudje, ki ustvarjajo nove arhitekture, uporabljajo pristop poskusov in napak, da pridejo do svojih končnih rezultatov. S ponovno uporabo njihovih končnih rezultatov lahko prihranimo veliko časa.

Vnaprej pripravljeni modeli so običajno na voljo za takojšnjo uporabo. Ko raziskovalci objavijo svoje nove arhitekture, običajno objavijo tudi usposobljene parametre, tako da uporabnikom ne bo treba iti skozi težave z usposabljanjem/optimiziranjem od začetka. To je še posebej uporabno za zelo velike modele, željne virov.

Primeri znanih vizijskih arhitektur vključujejo:

LeNet (60k parametrov)

AlexNet (60m parametrov)

VGG-16 (parametri 138m)

U-Net

U-Net je arhitektura, ki temelji na popolnoma konvolucijskem omrežju, kar pomeni, da nima nobene popolnoma povezane plasti. Prvič je bil predstavljen za nalogo segmentacije medicinske slike. Ti rezultati so navdihnili raziskovalce, da so ga razširili na druge naloge v računalniškem vidu.

Leta 2019 je Google uporabil na U-Netu arhitekturo za ustvarjanje modela napovedovanja padavin.

Ime "U-Net" izhaja iz oblike "U" njegove arhitekture.

Prepoznamo tri glavne komponente:

Krčenje/Kodirnik: Zaporedje konvolucijskih/združenih plasti, ki stisnejo vhodno sliko v predstavitev manjše velikosti.
Most / ozko grlo: Spodnji del "U" povezuje kodirnik z dekoderjem. Oblikuje se z nizom konvolucijskih operacij.
Dekontraktiranje/dekoder: zaporedje navzgornjih in konvolucijskih slojev, ki "dekompresirajo" izhod ozkega grla.

Arhitektura U-Neta je zaenkrat videti kot samodejni kodirnik. Vendar pa je razlika v informacijah, ki potekajo med kodirnikom in dekodirnikom. Te informacije se posredujejo z združevanjem rezultatov konvolucij iz kodirnika z rezultati konvolucije navzgor dekoderja. Ta sprememba izboljša ločljivost in omogoča, da model oddaja bolj prostorsko natančen izhod (lokacija slikovnih pik v izhodu bo natančnejša, kar bo rešilo težavo, ki se je pojavila pri modelih, ki niso vključevali veriženja). Združevanje poteka simetrično.

Izdelava modela U-Net za trenutno napovedovanje padavin

V tem razdelku bomo zgradili model U-Net za napovedovanje vremena iz satelitskih posnetkov. Uporabili bomo vnaprej pripravljen model, imenovan Rain-Net.

Spodnja koda je na voljo v tej colab.

Najprej namestimo wradlib, odprtokodno knjižnico za obdelavo podatkov o vremenskih radarjih

!pip install wradlib
import wradlib as wrl

Nato napišemo dve uporabni funkciji za prenos satelitskih podatkov iz odprtega podatkovnega strežnika DWD


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

Ti pripomočki nam omogočajo prenos najnovejših 4 satelitskih slik, kar je število satelitskih slik, ki jih potrebujemo za napovedovanje z našim predhodno usposobljenim modelom.

Nato lahko uporabimo ustvarjene funkcije za pridobitev najnovejših 4 slik


RY_latest, RY_latest_timestep = download_data()

Ko dobimo slike, uporabimo wradlibovo metodo vis.plot_ppi za izris podatkov

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

Zdaj smo naložili svoje podatke. Nato naložimo model.

Začnemo z uvozom ustreznih razredov. V tem članku bomo uporabljali TensorFlow.

iz tensorflow.keras.layers uvoz Input, Conv2D, Activation, Concatenate, Conv2DTranspose, MaxPool2D

iz tensorflow.keras.models uvozite model

Izdelajmo 3 primitivne gradnike. Ti "gradniki" bodo uporabljeni za ustvarjanje celotne arhitekture v skladu s to implementacijo.

Prvi blok ustreza zaporedju konvolucijskih plasti, imenujemo ga "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

Drugi blok se uporablja za izdelavo dela kodirnika (konvolucijski blok + maksimalno združevanje). Imenujemo ga »encoder_block«

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

Tretji in zadnji blok je »decoder_block« (upconvolution + concatenation + convolution).

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

Te gradnike združimo za izdelavo modela U-Net

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

Poigrajte se z izvedbo, jo izboljšajte ali prilagodite svojim potrebam, če jo želite uporabiti za kaj drugega.

Usposabljanje tega modela lahko traja veliko časa. Na srečo obstaja model, imenovan Rain-Net, ki je bil ustvarjen na podlagi arhitekture U-Net in je specializiran za trenutno napovedovanje padavin.

Klonirajmo njegovo skladišče GitHub

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

Nato prenesemo vnaprej pripravljene uteži za ta model

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

Naslednji korak je ustvariti model, ki temelji na arhitekturi, najdeni v repozitoriju, nato pa naložiti uteži, prenesene v ta model

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

Slike, ki smo jih prenesli, imajo velikost 900*900 slikovnih pik. Te slike bomo preoblikovali tako, da bodo ustrezale pričakovanemu vložku Rain-Neta

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

Nato ustvarimo funkcijo, ki naredi napovedi.

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

To funkcijo nato pokličemo za podatke, ki smo jih prenesli prej

Y_pred = prediction(model, RY_latest)

Napovedi lahko narišemo in jih shranimo, da shranjene rezultate uporabimo za ustvarjanje gif slike, ki nam omogoča vizualizacijo napovedi

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')

Čestitke, ker si uspel tako daleč! Zdaj lahko uporabite Rain-Net za napovedi in njihovo vizualizacijo.

Zaključek

V tem članku smo uporabili model strojnega učenja (Rain-Net) za napovedovanje padavin. Uporabili smo arhitekturo U-Net, ki smo jo zgradili s pomočjo TensorFlow. Naložili smo vnaprej pripravljen model za napovedovanje satelitskih posnetkov.

To izvedbo je mogoče izboljšati na več načinov. Na primer:

Natančno prilagodite model na svojem naboru podatkov
V arhitekturi uporabite modul, ki temelji na pozornosti, kot je CBAM (Convolutional Block Attention Module).

Reference

– Colab

Izvirni dokument U-Net

– Googlov spletni dnevnik o njihovem modelu za napovedovanje vremena, ki temelji na U-Netu

Izvedba Rain-Net

– Implementacija U-Net

Pridite na eno od naših brezplačnih delavnic!

Začnite svojo kariero podatkovnega znanstvenika z našimi brezplačnimi delavnicami, ki temeljijo na prilagodljivem učnem načrtu in jih vodijo strokovnjaki iz industrije.