Frasaíocht Anois le Foghlaim Meaisín

Sa lá atá inniu ann, measann meitéareolaithe go bhfuil 90% de na réamhaisnéisí aimsire i gceart laistigh de thréimhse 5 lá. De ghnáth bíonn na tuartha a dhéantar bunaithe ar dhá mhodh ar leith :

Cur chuige atá bunaithe ar an bhfisic: Úsáideann na cineálacha cur chuige seo samhlacha a chomhtháthaíonn cainníochtaí intomhaiste mar bhrú, gluaiseacht na scamaill, coinníollacha spéire… Bíonn samhlacha den sórt sin go maith chun an aimsir a thuar do na laethanta nó na seachtainí atá le teacht.
Cur chuige saor ó fhisic (bunaithe ar shonraí): Úsáideann na cuir chuige seo sonraí stairiúla chun samhlacha a chruthú ar féidir leo tuartha a dhéanamh. Léiríonn samhlacha den sórt sin torthaí maithe maidir leis an aimsir a thuar ar feadh suas le 6 uair an chloig nó rud ar a dtugtar aimsir nowcasting.

San Airteagal seo, déanfaimid plé ar an dara catagóir cur chuige. Beidh muid ag plé na formáidí éagsúla de shonraí aimsire, conas is féidir meaisín-fhoghlaim a ghiaráil chun an aimsir a chraoladh anois, agus conas is féidir leis na hailtireachtaí a fhorbraítear a bheith tairbheach chun fadhbanna comhchosúla a réiteach.

Sonraí um Thuar Aeráide

Ós rud é go n-úsáideann na cineálacha cur chuige saor ó fhisic sonraí stairiúla, cuirimis tús le breathnú ar na sonraí atá ar fáil.

Beidh dhá phríomhfhoinse sonraí á n-úsáid againn:

Sonraí íomhá: Is i bhfoirm íomhánna radair nó satailíte de limistéar sonraithe geografach atá na sonraí seo. Úsáidtear é chun deascadh, gluaiseacht gaoithe nó taise a thuar.

Sonraí tábla: Is i bhfoirm taifead atá na sonraí seo ar chainníochtaí intomhaiste amhail teocht, bogthaise nó luas na gaoithe.

Cé go bhfuil an dá fhoinse sonraí tábhachtach chun samhlacha cumhachtacha a thógáil, beimid ag díriú ar an gcéad cheann (sonraí íomhá a bhailítear ó radair nó ó shatailítí) ar chúiseanna simplíochta. Is iad na samhlacha is coitianta a úsáidtear le sonraí íomhá Convolutional Neural Networks (CNNs ).

Tar éis an [obair] seo (https://colab.research.google.com/drive/1jHzESsHAWKPPxIqGmWLIBY7JLhgThCZ5?usp=sharing), táimid ag dul a úsáid ailtireacht U-Net chun ár samhail nowcasting féin a thógáil.

Ailtireacht

Tá go leor cúiseanna le tosú ó ailtireacht atá ann cheana féin, ina measc:

Feidhmíonn ailtireachta mar threoirlínte chun samhlacha nua a chruthú. Glacann daoine a chruthaíonn ailtireachtaí nua cur chuige trialach agus earráide chun a dtorthaí deiridh a bhaint amach. Trí na torthaí deiridh a athúsáid, is féidir linn go leor ama a shábháil.

De ghnáth bíonn samhlacha réamhoilte ar fáil le húsáid láithreach. Nuair a fhoilsíonn taighdeoirí a n-ailtireacht nua, is gnách go bhfoilsíonn siad na paraiméadair oilte freisin, ionas nach mbeidh ar úsáideoirí dul tríd an trioblóid oiliúna / optamaithe ón tús. Tá sé seo úsáideach go háirithe do samhlacha an-mhóra a bhfuil tart orthu ó thaobh acmhainní de.

I measc na n-ailtireachtaí físe cáiliúla tá:

LeNet (paraiméadar 60k)

AlexNet (paraiméadar 60m)

VGG-16 (paraiméadar 138m)

U-Net

Is ailtireacht é U-Net atá bunaithe ar líonra lán-raonta, rud a chiallaíonn nach bhfuil aon sraitheanna lán-nasctha aige. Tugadh isteach é den chéad uair le haghaidh tasc deighilte íomhá leighis. Spreag na torthaí seo taighdeoirí chun é a leathnú chuig tascanna eile i bhfís ríomhaireachta.

In 2019, d’úsáid Google ailtireacht U-Net-bhunaithe chun samhail réamhaisnéise deascadh a chruthú.

Tagann an t-ainm “U-Net” as cruth “U” a ailtireachta.

Aithnímid trí phríomhchuid:

Conraitheoireacht / Ionchódóir: Comharbas ar shraitheanna convolution/comhthiomsaithe a chomhbhrúigh an íomhá ionchuir isteach i léiriú méide níos lú.
Droichead / Scragall: Ceanglaíonn an chuid íochtair den “U” an t-ionchódóir leis an díchódóir. Tá sé déanta ag sraith oibríochtaí convolution.
Díchonraitheoireacht / Díchódóir : Comharbas ar upconvolutions agus sraitheanna convolution, a "dhí-chomhbhrú" aschur an scrogaill.

Tá cuma uath-ionchódóra ar ailtireacht U-Net go dtí seo. Mar sin féin, baineann an difríocht leis an bhfaisnéis a théann idir an t-ionchódóir agus an díchódóir. Cuirtear an t-eolas seo ar aghaidh trí thorthaí na dtréimhsí ón ionchódóir a chomhchatú le torthaí athraonta an díchódóra. Cuireann an modhnú seo feabhas ar an taifeach, agus ceadaíonn sé don mhúnla aschur níos beaichte ó thaobh spásúlachta de (beidh suíomh na bpicteilín san aschur níos cruinne, ag réiteach fadhb a tharla i múnlaí nár chuimsigh comhtháthú). Déantar an comhghatánú go siméadrach.

Samhail U-Net a Thógáil le haghaidh Frasaíocht Anois

Sa chuid seo, tógfaimid samhail U-Net chun an aimsir a thuar ó íomhánna satailíte. Úsáidfimid múnla réamh-oilte ar a dtugtar Rain-Net.

Tá an cód thíos ar fáil sa [colab] seo(https://drive.google.com/uc?export=view&id=1EsQsWnQBSdutke1m3cHYZqcROqlvuDJ3).

Ar dtús suiteálaimid wradlib, Leabharlann Foinse Oscailte do Phróiseáil Sonraí Radar Aimsire

!pip install wradlib
import wradlib as wrl

Ansin scríobhaimid dhá fheidhm fóntais chun sonraí satailíte a íoslódáil ón freastalaí sonraí oscailte 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

Ligeann na fóntais seo dúinn na 4 íomhá satailíte is déanaí a íoslódáil, is é sin líon na n-íomhánna satailíte a theastaíonn uainn chun tuar a dhéanamh lenár múnla réamhoilte.

Is féidir linn ansin na feidhmeanna a cruthaíodh a úsáid chun na 4 íomhá is déanaí a fháil


RY_latest, RY_latest_timestep = download_data()

Tar éis na híomhánna a fháil, úsáidimid modh wradlib vis.plot_ppi chun na sonraí a bhreacadh

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

Tá ár sonraí lódáilte againn anois. Íoslódáil an múnla seo chugainn.

Tosaímid trí na ranganna ábhartha a allmhairiú. Beimid ag úsáid TensorFlow san Airteagal seo.

ó tensorflow.keras.layers allmhairiú Ionchur, Conv2D, Gníomhachtaithe, Comhcheangail, Conv2DTtranspose, MaxPool2D

ó shamhail allmhairithe tensorflow.keras.models

Déanaimis 3 bhloc tógála primitive. Bainfear úsáid as na "bloic thógála" seo chun an ailtireacht iomlán a chruthú, de réir an cur i bhfeidhm.

Freagraíonn an chéad bhloc le comharbas na sraitheanna conbhlóideacha, tugaimid "conv_block" air

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

Úsáidtear an dara bloc chun an chuid ón ionchódóir a thógáil (bloc comhthiomsaithe + comhthiomsú uasta). Tugtar “ionchódóir_bloc” air

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

Is é an tríú bloc agus an bloc deiridh ná “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

Cuirimid na bloic thógála seo le chéile chun an tsamhail U-Net a thógáil

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

Thig leat imirt timpeall leis an gcur i bhfeidhm, é a fheabhsú nó é a oiriúnú do do chuid riachtanas más mian leat é a úsáid le haghaidh rud éigin eile.

Is féidir go leor ama a ghlacadh chun an múnla seo a oiliúint. Ar ámharaí an tsaoil, tá samhail ar a dtugtar Rain-Net, atá cruthaithe bunaithe ar ailtireacht U-Net, agus atá speisialaithe i bhfrascadh anois.

Déanaimis a stór GitHub a chlónáil

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

Íoslódáil muid ansin na meáchain réamhoilte don mhúnla seo

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

Is é an chéad chéim eile ná múnla a chruthú bunaithe ar an ailtireacht a aimsítear ar an stór agus ansin na meáchain a íoslódálfar go dtí an tsamhail seo a luchtú

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

Tá méid 900 *900 picteilín ag na híomhánna a d’íoslódálamar. Táimid chun na híomhánna seo a athmhúnlú chun an t-ionchur ionchais Rain-Net a mheaitseáil

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

Ansin cruthaímid feidhm a dhéanann na tuar.

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

Glaoimid an fheidhm seo ansin ar na sonraí a d'íoslódálamar níos luaithe

Y_pred = prediction(model, RY_latest)

Is féidir linn na tuartha a bhreacadh, agus iad a shábháil chun na torthaí a shábháiltear a úsáid chun íomhá gif a chruthú a ligeann dúinn na tuartha a shamhlú

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

Comhghairdeachas as é a dhéanamh go dtí seo! Is féidir leat Rain-Net a úsáid anois chun tuartha a dhéanamh agus iad a shamhlú.

Conclúid

San Airteagal seo, tá múnla meaisínfhoghlama (Rain-Net) in úsáid againn chun deascadh a dhéanamh anois. Bhaineamar úsáid as ailtireacht U-Net, a thógamar le TensorFlow. Lódáileamar múnla réamhoilte chun íomhánna satailíte a thuar.

Is féidir an cur i bhfeidhm seo a fheabhsú ar go leor bealaí. Mar shampla:

Miontune an tsamhail ar do thacair sonraí
Bain úsáid as modúl aird-bhunaithe, mar shampla CBAM (Modúl Aire Bloc Convolutional) san ailtireacht.

Tagairtí

Tar Chuig Ceann dár gCeardlanna Saor in Aisce!

Cuir tús le do ghairm bheatha mar eolaí sonraí lenár ceardlanna saor in aisce, atá bunaithe ar churaclam inoiriúnaithe agus á threorú ag saineolaithe tionscail.