[PYTHON] Versuchen Sie, durch maschinelles Lernen basierend auf Wetterdaten eine "wetterkartenähnliche Front" zu zeichnen (5)
Zeichnen wir eine "wetterkartenähnliche Front" durch maschinelles Lernen basierend auf Wetterdaten. (5) Maschinelles Lernen Automatische Fronterkennung in Wetterdaten
1. Lernen "Wetterkarten-ähnliche Front"
1.1 Was ist eine "Wetterkarten-ähnliche Front"?
Es scheint, dass die Frontlinien der Wetterkarte hauptsächlich unter dem Gesichtspunkt der Katastrophenverhütung oder der Teile analysiert werden, die Auswirkungen auf Japan haben. Wenn Sie sich die Wetterkarten anderer Länder ansehen, sehen Sie möglicherweise Frontlinien, die nicht auf japanischen Wetterkarten gezeichnet sind. In der folgenden Spalte werden beispielsweise die Fronten beschrieben, die in europäischen Wetterkarten angezeigt werden. [Die Geschichte der "verborgenen" Front, die vom Satelliten nicht gesehen werden kann](https://oceana.ne.jp/column/53284 "Die Geschichte der" verborgenen "Front, die vom Satelliten nicht gesehen werden kann")
Daraus lässt sich ableiten, dass die Frontline-Analyse nicht immer eindeutig bestimmt ist und es für jede Institution einen Stil und eine Absicht zu geben scheint. Ich kann also sagen, dass die maschinell lernende Frontlinie, die ich zu zeichnen versuche, eine ** japanische wetterkartenähnliche Frontline ** ist, die aus Wetterdaten gezeichnet wurde. Wenn die Lerngenauigkeit verbessert wird und es möglich wird, ** japanische wetterkartenähnliche Frontlinienanalysen ** wie die Meteorologische Agentur zu zeichnen, kann dies zu einem Expertensystem für die Wetterzustandsanalyse ** werden.
[Meteorologische Prognose und Katastrophenschutz - Straße des Prognostikers (Chuko Shinsho)](https://www.amazon.co.jp/ Meteorologische Prognose und Katastrophenschutz - Straße des Straßenforschers - Chuko Shinsho-Nagasawa- Yoshitsugu / dp / 4121025202) sagt: "Schreiben Sie 3.000 Wetterkarten für eine Person." Die Daten, die zum Lernen dieses Mal verwendet werden, betragen ungefähr 2000 Blätter. Als Deep Learning-Prognostiker habe ich mich nicht genug bemüht, um eine vollwertige Person zu sein.
Übrigens, obwohl dieses maschinelle Lernen eine Wetterkarte erzeugt, sagt es das Wetter nicht voraus. ** ** ** Wettervorhersagen sagen die Zukunft aus der Gegenwart voraus, ** Frontline-Zeichnung ist die Umrechnung von der Gegenwart in die Gegenwart **.
2. Fluss des maschinellen Lernens
2.1 Was wirst du tun?
Ein Bild wird von CNN aus einem Bild erzeugt. Es ist eine Methode zum Berechnen der Wahrscheinlichkeit, welche Farbe für jedes Pixel des erzeugten Bildes rot, blau oder weiß sein sollte, und zum Einstellen der Farbe mit der höchsten Wahrscheinlichkeit im Pixel.
Diese Methode basiert auf Folgendem. Exascale Deep Learning for Climate Analytics Thorsten Kurth, Sean Treichler, Joshua Romero, Mayur Mudigonda, Nathan Luehr, Everett Phillips, Ankur Mahesh, Michael Matheson, Jack Deslippe, Massimiliano Fatica, Prabhat, Michael Houston arXiv:1810.01993 [cs.DC]
Dieses Papier wurde mit dem ACM Gordon Bell-Preis bei SC18 ausgezeichnet, einer internationalen Konferenz im Bereich Spacon, die 2018 in Dallas, Texas, stattfand. Glücklicherweise war ich auf einer Geschäftsreise zu SC18 und hatte die Gelegenheit, die preisgekrönten Vorträge zu hören, und ich erinnere mich, dass ich zwischen öffentlich und privat verwechselt und tief bewegt war.
2.2 Fluss des maschinellen Lernens
Ich werde den Fluss des maschinellen Lernens nach neuronalen Netzen zusammenfassen. ** (1) Erstellen Sie ein Eingabebild ** Laden Sie Wetterdaten herunter und visualisieren Sie sie. Wir haben 6 Arten von Farbbildern vorbereitet (2nd)
** (2) Machen Sie ein Lehrerbild ** Erstellen Sie ein Bild mit nur den Frontelementen, die basierend auf den Farben aus der "Flash-Wetterkarte" extrahiert wurden (3.). Ich habe auch Schwarz-Weiß-Wetterkarten eingefärbt, um die Bilder der Lehrer zu verbessern (4.).
** (3) Dies und das von CNN ** ** - Eingabedaten: Sortieren ** Der Eingang von CNN ist ein 18-Kanal-Tensor, der die 6 Arten von Eingangsbildern "verkettet" (die Anzahl der Kanäle beträgt 3). Wenn im CNN-Minibatch alle Daten nahe beieinander liegen, werden sie zum Zeitpunkt des Lernens verzerrt, sodass das Paar aus Eingabedaten und Lehrerbild zeitlich zufällig sortiert werden sollte.
** ・ Eingabedaten: One-Hot-Vektor ** Da CNN so erstellt wird, dass jedes Pixel die ** Wahrscheinlichkeit ** berechnet, die jedem von Rot, Blau und Weiß entspricht, ist die richtige Antwort 1 und die anderen sind 0 ** für das RGB-Lehrerbild. Konvertieren Sie es in ein Array. Mit anderen Worten, Weiß ist (1,0,0), Rot ist (0,1,0) und Blau ist (0,0,1).
·Ausgabedaten Beispielsweise gibt CNN (0,1, 0,7, 0,2) als Wert eines bestimmten Pixels aus. In diesem Fall ist dieses Pixel rot und das Bild wird erstellt.
·neurales Netzwerk CNN erstellt eine U-Net-fähige Verzweigungsroute.
** · Verlustfunktion ** Verwenden Sie categoryical_cross_entropy. Dadurch wird die Wahrscheinlichkeit von Rot, Blau und Weiß berechnet.
** (4) Lass uns lernen! ** ** ** Lassen Sie uns endlich CNN lernen. Dieses Mal lernen wir von Januar 2017 bis Oktober 2019 mit zwei Blättern (Daten von 6:00 UTC und 18:00 UTC) von jedem Tag. Da die Lehrerdaten ein One-Hot-Vektor sind, bei dem einer von Rot, Blau und Weiß 1 ist, wird es möglich, die Farbe des vorderen Elements im Verlauf des Lernens zu reproduzieren.
Mein Mac mini wird für ein paar Tage ** unantastbar **. Ich denke, dass es eine der CPU-intensivsten Personen des Mac mini ist, und es wird für die CPU erschöpft sein.
** (5) Machen Sie eine Vorhersage! (Lassen Sie die Daten des ersten Blicks eine Frontlinie zeichnen) ** Wenn das Training konvergiert hat, verwenden Sie das trainierte Netzwerk, um die Frontlinie der First-Look-Daten zu zeichnen. Dieses Mal wurde als erster Blick auf die Daten von November 2019 bis Januar 2020 die Frontlinie gezogen.
3. Wie auch immer das Ergebnis
3.1 Trainingsdaten
Dies ist ein Beispiel für Trainingsdaten. Es scheint, dass es konvergiert hat, bis es ein Frontelement erzeugen kann, das einer Position ähnlich der Vorderseite der vorläufigen Wetterkarte entspricht.
Von oben links nach rechts,
- Ausgabeergebnis: Generiertes Frontelement (überlagert das visualisierte Bild des Bodendrucks) Lehrerbild: Wetterkarte brechen Eingang: Äquivalente Temperatur 850hPa Eingabe: Temperatur / Druck / Wind (Masse) *
Von links unten nach rechts,
- Eingabe: Temperatur / Höhe / Wind (850hPa) Eingang: Luftfeuchtigkeit (700hPa) Eingang: Blei DC (700hPa) Eingabe: Temperatur / Höhe / Wind (500hPa) *
3.2 Generierte Daten (First-Look-Daten)
In 3.1 haben wir die Frontlinie mithilfe des Netzwerks generiert, das aus den Daten von Januar 2017 bis Oktober 2019 trainiert wurde.
Beispiel für eine erfolgreiche Generierung
Über dem Meer östlich von Japan herrscht ein niedriger Druck, und eine Kaltfront erstreckt sich nach Südwesten. ** Das neuronale Netzwerk kann auch diese Kaltfront erzeugen. ** Außerdem werden Warmfronten erzeugt, wenn auch unterbrochen.
Ein ziemlich schlechtes Beispiel
In der vorläufigen Wetterkarte erstreckt sich eine Kaltfront südwestlich vom Niederdruck in der Nähe der Chishima-Inseln. Zusätzlich wird die Stagnationsfront fast entlang der 30-Grad-Nord-Breitengrad-Linie analysiert. Andererseits können ** neuronale Netze kaum eine der beiden Fronten erzeugen. ** ** **
Welche Daten tragen dazu bei?
Wenn man die Daten auf einen Blick betrachtet, scheint es, dass die Frontlinie in dem Bereich ** gezeichnet ist, in dem die Konturlinien bei dem äquivalenten Temperaturniveau von ** 850 hPa in den Eingabedaten überfüllt sind. In einem schlechten Beispiel sieht es etwas weniger überfüllt aus, aber was ist mit?
Die Filtergröße dieses CNN beträgt 3x3. Möglicherweise möchten Sie versuchen, einen etwas größeren Filter zu verwenden oder das Bild zu verkleinern.
Übrigens ist es das Ergebnis der Front-Line-Generierung für Januar 2020. Es ist nur eine Animation, die solche Daten generiert.
3.3 Lernfortschritt
Verlust- und Genauigkeitsübergänge. Die Situation umfasst bis zu 800 Epochen, die umgeschult wurden, um diese Daten wiederzugewinnen.
Ich habe alle 200 Epochen aufgehört zu lernen und es neu gestartet, aber zu diesem Zeitpunkt werden durch Zufälligkeit des Eingabebildes (später beschrieben) einige der zu lernenden Daten ersetzt, sodass Verlust und Genauigkeit einmal schlecht sind. Werden.
Es handelt sich um eine Änderung des generierten Bildes in Bezug auf das Beispiel, das zuvor erfolgreich generiert wurde. Von links erzeugten 200, 400, 600, 800 Epochen Bilder mit Parametern zum Zeitpunkt des Lernens, schließlich 1500 Epochen oder mehr Generiertes Bild bei Ausführung. Es scheint, dass sich die Genauigkeit von Frontliniensymbolen (wie z. B. Chevron-Markierungen) verbessert, da es möglich ist, die Frontlinie an der Stelle zu zeichnen, an der sie frühzeitig gezeichnet werden sollte.
Dies ist ein schlechtes Beispiel. Hmm? Vielleicht war es noch besser, es mit den Parametern zu generieren, die weniger gelernt sind?
Die Lernzeit für eine Epoche auf meinem Mac mini dauerte ungefähr 580 Sekunden. Damit ließ ich es ungefähr 4 Tage lang laufen. Ich frage mich, ob ich eine GPU habe und sie weiter ausführen möchte.
3.4 Übrigens ...
Ich bin noch nicht an einem Punkt angelangt, an dem ich an der Front einen klaren Fehler machen kann, aber ich denke, wenn ich die Anzahl der Datenbeispiele und die Rechenressourcen erhöhe, denke ich, dass ich einen ziemlich guten Punkt erreichen kann. Also ** ist das für irgendetwas nützlich? ** ** ** Die Frontline-Analyse kann aus den Ergebnissen der Meteorologischen Agentur entnommen werden. Es ist daher besser, sie einem Fachmann zu überlassen.
Wenn es sinnvoll ist, bedeutet dies, dass bei numerischen Prognoseergebnissen und Klimaberechnungsergebnissen automatisch eine Frontlinie gezogen wird?
Das Obige ist beispielsweise eine Frontlinie für das Berechnungsergebnis der GSM-Prognose mit dem Anfangswert von 12:00 UTC am 18. Februar 2020. Da die Wettervorhersage in Intervallen von 24 Stunden und 48 Stunden angekündigt wird, ziehen wir alle 6 Stunden eine Frontlinie für die Ergebnisse von GSM.
4. TL; DR CNN
Das Folgende ist eine Beschreibung des CNN selbst und Tipps für einige süchtig machende Teile.
4.1 Daten eingeben
4.1.1 Sortieren Sie den Satz von Eingabebildern / Lehrerbildern nach dem Zufallsprinzip
Das Eingabebild und das Lehrerbild sind unmittelbar nach dem Laden in chronologischer Reihenfolge angeordnet. Wenn Sie so trainieren, wie es ist, wird davon ausgegangen, dass die Wetterbedingungen für jede Mini-Charge rechtzeitig nahe beieinander liegen. Daher wird die Liste nach dem Zufallsprinzip sortiert, um die Charge zu einer Mischung verschiedener Wetterbedingungen zu machen.
randomize.py
# i_datalist_Zug n in der Reihenfolge von Datum und Uhrzeit angeordnet_Datenliste Meteorologische Bilddaten zur Eingabe
# t_datalist_Zug n in der Reihenfolge von Datum und Uhrzeit angeordnet_Bilddaten des Datenlehrerlehrers
#0 bis n_datalist-Zufällig n aus einer Folge von Zahlen bis zu 1_Generieren Sie einen Datenlistenindex
#Schleifenverarbeitung
for c_list in random.sample(range(n_datalist), n_datalist ):
t_datalist_train.append(t_datalist[c_list])
#Sortierte Lehrerbildliste
i_datalist_train.append(i_datalist[c_list])
#Liste der sortierten Eingabebilder
4.1.2 One-Hot-Konvertierung des Front-Line-Bildes
In dem Frontelementbild für das Lehrerbild, das bis zum letzten Mal erstellt wurde, ist jedes Pixel rot, blau oder weiß.
Der Hintergrund, der den größten Teil des Bereichs einnimmt, ist weiß, die Kaltfront und das Hochdrucksymbol sind blau und die Warmfront- und Blockierungsfront sowie das Niederdrucksymbol sind rot.
Da das Bild von CNN erzeugt wird und die Fehlerfunktion von "categoryical_cross_entropy" mit dem Lehrerbild berechnet wird, werden diese Frontelementbilddaten in einen One-Hot-Vektor konvertiert. Um die numpy-Methode "to_categorical" zu verwenden, wird das RGB-Array einmal in ein Array konvertiert, das entweder 0, 1 oder 2 akzeptiert. Verwenden Sie dann to_categorical, um es in einen One-Hot-Vektor zu konvertieren. Die folgende Quelle läuft darum herum.
one-hot.py
# t_img Geladene Frontbilddatei
# img_size t_Bildgröße von img
t_data = np.empty((img_size[1],img_size[0]))
# t_data one-0, um es heiß zu machen,1,Bereiten Sie ein Array für das Ternieren vor 2
#1 für Rot pro Pixel,Blau ist 2,Andernfalls auf 0 setzen
for x in range(img_size[1]):
for y in range(img_size[0]):
r,g,b = t_img.getpixel((y,x))
#Speichern Sie die RGB-Werte jeweils in r g b
if(r>g+20):
if(r>b+20):
t_data[x,y]=1 #Rotes Pixel
else:
if(b>g+20):
t_data[x,y]=2 #Blaues Pixel
else:
t_data[x,y]=0 #Weiße Pixel
else:
if(b>r+20):
if(b>g+20):
t_data[x,y]=2 #Blaues Pixel
else:
t_data[x,y]=0 #Weiße Pixel
else:
t_data[x,y]=0 #Weiße Pixel
# t_Aus Daten, 3 Element eins-heißes Vektorarray T._In Daten konvertieren
T_data = np_utils.to_categorical(t_data[:,:],3)
4.2 Ausgabedaten
Aus den vorhergesagten Ausgabedaten wird die mit der höchsten Wahrscheinlichkeit übernommen und in ein dreifarbiges Bild umgewandelt. Wenn die Daten ausgegeben werden, ist ein Wert größer, wie unten gezeigt. Platziert die entsprechende Farbe auf dem Pixel.
python
w_array
(256, 256, 3)
[[[9.99969959e-01 1.26371087e-05 1.73822737e-05]
[1.00000000e+00 8.79307649e-09 8.33461922e-09]
[1.00000000e+00 1.22459204e-12 8.95228910e-16]
...
[9.99985695e-01 6.48013793e-06 7.86928376e-06]
[9.99960303e-01 8.51386540e-06 3.12020056e-05]
[9.99833941e-01 2.61777150e-05 1.39806682e-04]]
[[9.99999881e-01 8.55169304e-08 1.83308195e-08]
[1.00000000e+00 9.66997732e-11 1.11044485e-12]
[1.00000000e+00 4.26908814e-16 1.04265986e-22]
...
Quelle für die Farbplatzierung auf Pixeln. In "w_array" ist der Wahrscheinlichkeitswertvektor von (R, G, B) in Breite x Länge angeordnet. Darauf aufbauend werden Bilddaten mask1 erstellt.
rasterize.py
# w_Array Nd der vorhergesagten Ausgabedaten_Array Ein Bildschirm des Arrays wird gespeichert
s_img = array_to_img(w_array[:,:,:].reshape(i_dmlat,i_dmlon,3))
# s_img Bilddaten
new_img_size = [w_array.shape[1], w_array.shape[0]]
mask1 = Image.new('RGB', new_img_size)
#mask1 Array für die Ausgabe
for x in range(new_img_size[1]):
for y in range(new_img_size[0]):
# w_Das dritte Element des Arrays ist w1/r1/In b1 speichern
w1 = w_array[x,y,0]
r1 = w_array[x,y,1]
b1 = w_array[x,y,2]
if(r1>w1):
if(r1>b1): # r1>w1, r1>b1
r,g,b=255,0,0
#Stellen Sie Rot als RGB ein, wenn r1 maximal ist
else: # r1=<w1
if(b1>w1): # r1=<w1<b1
r,g,b=0,0,255
#Stellen Sie Blau als RGB ein, wenn b1 maximal ist
else: # r1=<w1, b1=<w1
r,g,b=255,255,255
#Stellen Sie Weiß als RGB ein, wenn w1 maximal ist
else: # w1>=r1
if(b1>r1):
if(b1>w1): # b1>w1>r1
r,g,b=0,0,255
#Stellen Sie Blau als RGB ein, wenn b1 maximal ist
else: # w1>=b1>r1
r,g,b=255,255,255
#Stellen Sie Weiß als RGB ein, wenn w1 maximal ist
else: # w1>=r1 w>=b1
r,g,b=255,255,255
#Stellen Sie Weiß als RGB ein, wenn w1 maximal ist
mask1.putpixel((y,x),(r,g,b))
#Setzen Sie den RBG-Wert auf mask1
4.3 Faltungsneurales Netz
4.3.1 Netzwerkstruktur
Die Struktur von CNN hat einen Zweig wie U-Net und wird von mir selbst erstellt.
Ein Eingang ist ein 18x256x256 Tensor und ein Ausgang ist ein 3x256x256 Tensor.
Die Bildgröße wird durch Angabe des Parameters stride = (2,2) von Conv2D halbiert und wird schließlich 120x16x16.
In normalem U-Net wird die Anzahl der Kanäle verdoppelt, wenn die Bildgröße halbiert wird. Diesmal wird sie jedoch aufgrund der Speichermenge nicht sauber verdoppelt.
4.3.2 Netzwerkdefinition durch Keras
Die Quelle von Python-Keras für den Netzwerkdefinitionsteil ist unten angegeben. Die Art und Weise, das Keras-Netzwerk zu definieren, besteht darin, die Ausgabe jeder Schicht mit der nächsten Schicht oder dem Verbindungsteil am Ende mit der ** Funktions-API ** zu verbinden.
cnv2dtra = concatenate([cnv2dtra , cnv2d14 ], axis=1)
Der Teil wie ist der Teil, in dem "cnv2d14", der zu "cnv2dtra" verzweigt ist, durch das erste Element (Kanal) verbunden ist.
cnn.py
#- Neural Network Definition
num_hidden1 = 18
num_hidden2 = 32
num_hidden3 = 48
num_hidden3a = 72
num_hidden3b = 120
num_hidden4 = 128
num_hidden5 = 16
num_hidden6 = 16
num_itter = int(_num_itter) #Anzahl des Lernens
#--- seting Neural Network using Keras
in_ch = 18 #Eingabebild RGB x 6 Kanaltypen
cnn_input = Input(shape=(in_ch, i_dmlat, i_dmlon))
# i_dmlat, i_Anzahl der Pixel in Breiten- und Längenrichtung des dmlon-Bildes
# 1st hidden layer
cnv2d1 = Conv2D(num_hidden1, data_format='channels_first', kernel_size=(3,3), dilation_rate=(3,3), activation='relu', padding='same')(cnn_input)
cnv2d2 = Conv2D(num_hidden1, data_format='channels_first', kernel_size=(3,3), dilation_rate=(3,3), activation='relu', padding='same')(cnv2d1)
cnv2d4 = Conv2D(num_hidden1, data_format='channels_first', strides=(2,2) , kernel_size=(3,3), activation='relu', padding='same')(cnv2d2)
# 2nd hidden layer
cnv2d5 = Conv2D(num_hidden2, data_format='channels_first', kernel_size=(3,3), dilation_rate=(3,3), activation='relu', padding='same')(cnv2d4)
cnv2d6 = Conv2D(num_hidden2, data_format='channels_first', kernel_size=(3,3), dilation_rate=(3,3), activation='relu', padding='same')(cnv2d5)
cnv2d8 = Conv2D(num_hidden2, data_format='channels_first', strides=(2,2) , kernel_size=(3,3), activation='relu', padding='same')(cnv2d6)
# 3rd hidden layer
cnv2d9 = Conv2D(num_hidden3, data_format='channels_first', kernel_size=(3,3), activation='relu', padding='same')(cnv2d8)
cnv2d10 = Conv2D(num_hidden3, data_format='channels_first', kernel_size=(3,3), activation='relu', padding='same')(cnv2d9)
cnv2d12 = Conv2D(num_hidden3, data_format='channels_first', strides=(2,2) , kernel_size=(3,3), activation='relu', padding='same')(cnv2d10)
# 4th hidden layer
cnv2d13 = Conv2D(num_hidden3a, data_format='channels_first', kernel_size=(3,3), activation='relu', padding='same')(cnv2d12)
cnv2d14 = Conv2D(num_hidden3a, data_format='channels_first', kernel_size=(3,3), activation='relu', padding='same')(cnv2d13)
cnv2d16 = Conv2D(num_hidden3a, data_format='channels_first', strides=(2,2) , kernel_size=(3,3), activation='relu', padding='same')(cnv2d14)
cnv2d17 = Conv2D(num_hidden3b, data_format='channels_first', kernel_size=(3,3), activation='relu', padding='same')(cnv2d16)
cnv2d19 = Conv2D(num_hidden3b, data_format='channels_first', kernel_size=(3,3), activation='relu', padding='same')(cnv2d17)
#--- decode start
cnv2dtra = Conv2DTranspose(num_hidden3a, data_format='channels_first', kernel_size=(3,3), strides=(2,2), activation='relu', padding='same')(cnv2d19)
cnv2dtra = concatenate([cnv2dtra , cnv2d14 ], axis=1)
#Zweig verbinden
cnv2dtrb = Conv2D(num_hidden3a, data_format='channels_first', kernel_size=(3,3), activation='relu', padding='same')(cnv2dtra)
cnv2dtr1 = Conv2DTranspose(num_hidden3, data_format='channels_first', kernel_size=(3,3), strides=(2,2), activation='relu', padding='same')(cnv2dtrb)
cnv2dtr1 = concatenate([cnv2dtr1 , cnv2d10 ], axis=1)
#Zweig verbinden
cnv2dtr2 = Conv2D(num_hidden3, data_format='channels_first', kernel_size=(3,3), activation='relu', padding='same')(cnv2dtr1)
cnv2dtr4 = Conv2DTranspose(num_hidden2, data_format='channels_first', kernel_size=(3,3), strides=(2,2), activation='relu', padding='same')(cnv2dtr2)
cnv2dtr4 = concatenate([cnv2dtr4, cnv2d6], axis=1)
#Zweig verbinden
cnv2dtr5 = Conv2D(num_hidden2, data_format='channels_first', kernel_size=(3,3), activation='relu', padding='same')(cnv2dtr4)
cnv2dtr7 = Conv2DTranspose(num_hidden1, data_format='channels_first', kernel_size=(3,3), strides=(2,2), activation='relu', padding='same')(cnv2dtr5)
cnv2dtr7 = concatenate([cnv2dtr7, cnv2d2], axis=1)
#Zweig verbinden
cnv2dtr8 = Conv2D(num_hidden1, data_format='channels_first', kernel_size=(3,3), activation='relu', padding='same')(cnv2dtr7)
cnv2dtr9 = Conv2D(num_hidden1, data_format='channels_first', kernel_size=(3,3), activation='relu', padding='same')(cnv2dtr8)
cnv2dtr10 = Conv2D(3, data_format='channels_first', kernel_size=(1,1), activation=softMaxAxis , padding='same')(cnv2dtr8)
#Machen Sie schließlich ein ternäres Bild
NN_1 = Model( input=cnn_input , output=cnv2dtr10 )
#Eingabe ist cnn_Erstellen Sie ein Netzwerk mit dem letzten cnv2dtr10 als Ausgabe am Eingang
NN_1.compile(optimizer='adam', loss='categorical_crossentropy' , metrics=['accuracy'])
#Verlustfunktion kategorisch_crossentropy
4.4 Softmax der letzten Schicht
In der letzten Ebene berechnet softmax für jedes Pixel Rot, Blau und Weiß. Da der Standard-Softmax keinen Teil des Arrays angeben kann, definieren wir eine Funktion namens softMaxAxis. Diese Methode Stack Over flow:"How to specify the axis when using the softmax activation in a Keras layer?" Wird bezeichnet.
softMaxAxis.py
def softMaxAxis(x):
return softmax(x,axis=1)
Zu diesem Zeitpunkt scheint es notwendig zu sein, den Namen des benutzerdefinierten Objekts beim Speichern und erneuten Laden des Modells anzugeben.
load_model
NN_1 = load_model( paramfile , custom_objects={'softMaxAxis': softMaxAxis })
4.5 Überlagerung des erzeugten Bildes und des isobaren Diagramms
Verwenden Sie ImageMagick.
convert -compose multiply ist der Befehl zum Überlagern.
Gibt an, dass die Mittelpunkte der beiden Bilder ohne vertikalen oder horizontalen Versatz durch "Schwerkraftmittelpunkt-Geometrie + 0 + 0" ausgerichtet sind.
Image_Overlay.sh
# m_Datei Generiertes Frontbild (PNG)
# s_Datei isobares Diagramm (PNG)
composite -gravity center -geometry +0+0 -compose multiply ${m_file} ${s_file} out.png
5. Zusammenfassung
Ich habe ein neuronales Netzwerk erstellt, das das Bild der Wetterdatenvisualisierung erkennt und ein "Frontbild generiert, das von der Japan Meteorological Agency analysiert wird", und versucht, die Front automatisch zu zeichnen.
Ich denke, dass diese Methode nicht nur für das Zeichnen von Frontlinien wirksam ist, sondern auch für alle Daten, die auf der Karte aufgezeichnet sind und sich auf das Wetter beziehen. Andererseits denke ich, dass es ziemlich schwierig ist, den Trefferverlust zu bewerten. Selbst wenn Sie den Unterschied in den Pixelwerten mechanisch betrachten, fühlt es sich anders an, und was machen Sie mit der Bewertung der Erfassung der Form der Frontlinie? Wie bei der Wettervorhersageprüfung kann es für eine Person unerwartet richtig sein, ein Tor zu erzielen.
Derzeit arbeiten wir daran, aus MSM-Wetterdaten ein zusammengesetztes Radarbild zu erstellen, und erwägen, es als korrekte Antwortdaten auszuwerten. Ich denke darüber nach, dies auch bald zu veröffentlichen.
Dies war Qiitas erster Beitrag, aber ich habe fünf Mal einen langen Satz geschrieben. Vielen Dank an alle, die es gelesen haben.
Recommended Posts