[PYTHON] Essayez de dessiner un "front de type carte météorologique" par apprentissage automatique basé sur des données météorologiques (5)

Dessinons un «front de type carte météorologique» par apprentissage automatique basé sur des données météorologiques (5) Apprentissage automatique Détection automatique du front dans les données météorologiques

1. Apprendre le "front de type carte météo"

1.1 Qu'est-ce qu'un "front de type carte météorologique"?

Il semble que les premières lignes de la carte météorologique soient analysées principalement du point de vue de la prévention des catastrophes ou des parties qui ont un impact sur le Japon. Si vous regardez les cartes météorologiques d'autres pays, vous pouvez voir des lignes de front qui ne sont pas dessinées sur les cartes météorologiques du Japon. Par exemple, la colonne ci-dessous décrit les fronts qui apparaissent sur les cartes météorologiques européennes. [L'histoire du front "caché" qui ne peut pas être vu par satellite](https://oceana.ne.jp/column/53284 "L'histoire du front" caché "qui ne peut pas être vu par satellite")

À partir de ceux-ci, on peut dire que l'analyse de première ligne n'est pas toujours déterminée de manière unique et qu'il semble y avoir un style et une intention pour chaque institution. Donc, je peux dire que le dessin de première ligne d'apprentissage automatique que j'essaie de dessiner est une ** ligne de front de type carte météorologique japonaise ** tirée des données météorologiques. Si la précision d'apprentissage est améliorée et qu'il devient possible de dessiner ** une analyse de première ligne semblable à une carte météorologique japonaise ** comme l'Agence météorologique, cela peut devenir un système expert pour l'analyse des conditions météorologiques **.

[Meteorological Forecast and Disaster Prevention-Forecaster's Road (Chuko Shinsho)](https://www.amazon.co.jp/ Meteorological Forecast and Disaster Prevention-Forecaster's Road-Chuko Shinsho-Nagazawa- Yoshitsugu / dp / 4121025202) dit: «Écrivez 3 000 cartes météorologiques pour une personne». Les données utilisées pour l'apprentissage cette fois-ci sont d'environ 2000 feuilles. En tant que prévisionniste du Deep Learning, je n'ai pas fait suffisamment d'efforts pour être une personne à part entière.

À propos, bien que cet apprentissage automatique produise une carte météorologique, il ne prévoit pas ** la météo. ** ** Les prévisions météorologiques prédisent le futur à partir du présent, ** le dessin de première ligne est la conversion du présent aux données actuelles **.

2. Flux d'apprentissage automatique

2.1 Qu'allez-vous faire?

Une image est générée à partir d'une image par CNN. C'est une méthode de calcul de la probabilité de quelle couleur doit être rouge, bleu ou blanc pour chaque pixel de l'image générée et de réglage de la couleur avec la probabilité la plus élevée dans le pixel.

Cette méthode est basée sur ce qui suit. 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]

Cet article a remporté le prix ACM Gordon Bell au SC18, une conférence internationale dans le domaine du spacon qui s'est tenue à Dallas, Texas en 2018. Heureusement, j'étais en voyage d'affaires à SC18 et j'ai eu l'occasion d'écouter les conférences primées, et je me souviens avoir été confus entre public et privé et très profondément ému.

2.2 Flux d'apprentissage automatique

Je vais résumer le flux de l'apprentissage automatique par réseau de neurones. ** (1) Créer une image d'entrée ** Téléchargez et visualisez les données météorologiques. Nous avons préparé 6 types d'images couleur (2nd)

** (2) Créer une image d'enseignant ** Créez une image avec uniquement les éléments frontaux extraits de la "carte météo flash" en fonction des couleurs (3rd) J'ai également colorisé les cartes météo en noir et blanc pour augmenter les images des enseignants (4th)

** (3) Ceci et celui de CNN ** ** - Données d'entrée: Trier ** L'entrée de CNN est un tenseur de 18 canaux qui «concatène» les 6 types d'images d'entrée (le nombre de canaux est de 3). Dans le mini-lot CNN, si toutes les données sont proches les unes des autres, elles seront biaisées pendant l'apprentissage, de sorte que la paire de données d'entrée et l'image de l'enseignant doivent être triées de manière aléatoire dans le temps.

** ・ Données d'entrée: vecteur one-hot ** Puisque CNN est créé pour que chaque pixel calcule la ** probabilité ** correspondant à chacun des rouges, bleus et blancs **, la bonne réponse est 1 et les autres sont 0 ** pour l'image RVB du professeur. Convertissez-le en tableau. En d'autres termes, le blanc est (1,0,0), le rouge est (0,1,0) et le bleu est (0,0,1).

·des données de sortie Par exemple, CNN affiche (0,1, 0,7, 0,2) la valeur d'un certain pixel. Dans ce cas, ce pixel est rouge et l'image est prise.

·réseau neuronal CNN crée une route de branche compatible U-Net.

** ・ Fonction de perte ** Utilisez categorical_cross_entropy. Cela calculera la probabilité de rouge, bleu et blanc.

** (4) Apprenons! ** ** Apprenons enfin CNN. Cette fois, de janvier 2017 à octobre 2019, nous apprenons à l'aide de deux feuilles (données de 6h00 UTC et 18h00 UTC) de chaque jour. Puisque les données de l'enseignant sont un vecteur unique dans lequel l'un des rouges, bleus et blancs est égal à 1, il devient possible de reproduire la couleur de l'élément avant au fur et à mesure que l'apprentissage progresse.

Mon Mac mini sera ** intouchable ** pendant quelques jours. Je pense que c'est l'un des individus les plus gourmands en CPU du Mac mini, et il sera épuisé par le processeur.

** (5) Faites une prédiction! (Laissez les données de premier regard tracer une ligne de front) ** Lorsque la formation a convergé, utilisez le réseau formé pour tracer la première ligne des données de premier regard. Cette fois, comme données de premier regard, la ligne de front a été tracée sur les données de novembre 2019 à janvier 2020.

3. Quoi qu'il en soit le résultat

3.1 Données d'entraînement

Ceci est un exemple de données d'entraînement. Il semble que les éléments frontaux ont convergé jusqu'à ce qu'ils puissent être générés à des positions similaires aux fronts de la carte météorologique de rupture.

De haut de gauche à droite,

• Résultat de sortie: élément avant généré (superposé à l'image visualisée de la pression au sol) Image de l'enseignant: carte météorologique de rupture Entrée: température équivalente 850hPa Entrée: température / pression / vent (sol) *

De bas gauche à droite,

• Entrée: température / altitude / vent (850hPa) Entrée: Humidité (700hPa) Entrée: plomb DC (700hPa) Entrée: température / altitude / vent (500hPa) *

3.2 Données générées (données de premier regard)

En 3.1, nous avons généré la première ligne en utilisant le réseau formé à partir des données de janvier 2017 à octobre 2019.

Exemple de génération réussie

Il y a une dépression sur la mer à l'est du Japon, avec un front froid s'étendant vers le sud-ouest. ** Le réseau de neurones peut également générer ce front froid. ** De plus, des fronts chauds sont générés, bien qu'interrompus.

Un très mauvais exemple

Dans la carte météorologique préliminaire, un front froid s'étend au sud-ouest à partir de la dépression près des îles Chishima. De plus, le front de stagnation est analysé presque le long de la ligne de latitude nord à 30 degrés. D'un autre côté, ** les réseaux de neurones peuvent difficilement générer l'un ou l'autre front. ** **

Quelles données contribuent?

En regardant les données en un coup d'œil, il semble que la ligne de front soit dessinée dans la zone ** où les courbes de niveau sont encombrées au niveau de température équivalent de ** 850 hPa dans les données d'entrée. Dans un mauvais exemple, il semble un peu moins encombré, mais qu'en est-il?

La taille du filtre de ce CNN est de 3x3. Vous pouvez essayer d'utiliser un filtre légèrement plus grand ou réduire l'image.

Soit dit en passant, c'est le résultat de la génération de première ligne pour janvier 2020. C'est juste une animation qui génère des données comme celle-ci.

3.3 Progression de l'apprentissage

Transitions de perte et de précision. La situation est jusqu'à 800 époques qui ont été recyclées pour retrouver ces données.

J'ai arrêté d'apprendre toutes les 200 époques et je l'ai redémarré, mais à ce moment-là, en randomisant l'image d'entrée (décrite plus tard), certaines des données à apprendre sont remplacées, donc la perte et la précision sont mauvaises une fois. Devenir.

Il s'agit d'un changement de l'image générée par rapport à l'exemple qui a été généré avec succès précédemment. De la gauche, 200, 400, 600, 800 images générées d'époque avec des paramètres au moment de l'apprentissage, enfin 1500 époques ou plus Image générée lors de l'exécution. Il semble que la précision des symboles de première ligne (tels que les marques en chevron) s'améliore car il est possible de tracer la ligne de front à l'endroit où elle devrait être dessinée à un stade précoce.

C'est un mauvais exemple. Hmm? Peut-être valait-il encore mieux le générer avec les paramètres les moins appris?

Quant au temps d'apprentissage, il a fallu environ 580 secondes pour une époque sur mon Mac mini. Avec cela, j'ai continué à l'exécuter pendant environ 4 jours. Je me demande si j'ai un GPU et que je veux l'exécuter davantage.

3.4 Au fait ...

Je ne suis pas arrivé au point où je peux faire une erreur claire en première ligne, mais je pense que si j'augmente le nombre d'exemples de données et augmente les ressources informatiques, je pense que je peux atteindre un assez bon point. Alors ** est-ce utile pour quelque chose? ** ** L'analyse de première ligne peut être obtenue à partir des résultats de l'Agence météorologique, il est donc préférable de la laisser à un professionnel.

Si cela a du sens, cela signifie-t-il qu'il trace automatiquement une ligne de front dans les résultats des prévisions numériques et les résultats des calculs climatiques?

Par exemple, ce qui précède est une ligne de front tracée pour le résultat du calcul des prévisions GSM avec la valeur initiale de 12h00 UTC le 18 février 2020. Puisque la carte météorologique est annoncée à des intervalles de 24 heures et 48 heures, nous dessinons une ligne de front pour les résultats du GSM toutes les 6 heures.

4. TL; DR CNN

Ce qui suit est une description du CNN lui-même et des conseils pour certaines parties addictives.

4.1 Données d'entrée

4.1.1 Trier au hasard l'ensemble de l'image d'entrée / image de l'enseignant

L'image d'entrée et l'image de l'enseignant sont classées par ordre chronologique immédiatement après le chargement. Si vous vous entraînez tel quel, on suppose que les conditions météorologiques seront proches les unes des autres à temps pour chaque mini-lot, de sorte que la liste sera triée au hasard pour faire du lot un mélange de différentes conditions météorologiques.

randomize.py

# i_datalist_train n arrangé par date et heure_datalist Données d'images météorologiques pour l'entrée
# t_datalist_train n arrangé par date et heure_données d'image d'enseignant datalist

#0 à n_datalist-Aléatoirement n à partir d'une séquence de nombres jusqu'à 1_Générer un index de liste de données
#Traitement en boucle

for c_list in random.sample(range(n_datalist), n_datalist ):

  t_datalist_train.append(t_datalist[c_list])
  #Liste d'images des enseignants triées

  i_datalist_train.append(i_datalist[c_list])
  #Liste d'images d'entrée triées

4.1.2 Conversion one-hot de l'image de première ligne

Dans l'image de l'élément avant de l'image de l'enseignant créée jusqu'à la dernière fois, chaque pixel est rouge, bleu ou blanc. L'arrière-plan qui occupe la majeure partie de la zone est blanc, le symbole du front froid et de la haute pression sont bleus, et le front chaud et le front de blocage et le symbole de basse pression sont rouges. Puisque l'image est générée par CNN et que la fonction d'erreur par categorical_cross_entropy est calculée avec l'image de l'enseignant, ces données d'image d'élément avant sont converties en un vecteur à un seul point. Afin d'utiliser la méthode numpy appelée to_categorical, le tableau RVB est une fois converti en un tableau qui prend 0, 1 ou 2. Puis utilisez to_categorical pour le convertir en un vecteur one-hot. La source suivante tourne autour de cela.

one-hot.py

    # t_img Fichier image avant chargé
    # img_size     t_Taille d'image de l'img

    t_data = np.empty((img_size[1],img_size[0]))
    # t_data one-0 pour faire chaud,1,Préparer un tableau pour la ternation 2

    #1 pour le rouge par pixel,Le bleu est 2,Sinon mis à 0
    for x in range(img_size[1]):
      for y in range(img_size[0]):
        r,g,b = t_img.getpixel((y,x))
        #Stocker respectivement les valeurs RVB dans r g b
        if(r>g+20):
          if(r>b+20):
            t_data[x,y]=1 #Pixel rouge
          else:
            if(b>g+20):
              t_data[x,y]=2 #Pixel bleu
            else:
              t_data[x,y]=0 #Pixels blancs
        else:
          if(b>r+20):
            if(b>g+20):
              t_data[x,y]=2 #Pixel bleu
            else:
              t_data[x,y]=0 #Pixels blancs
          else:
            t_data[x,y]=0 #Pixels blancs
    
    # t_À partir des données, 3 élément un-matrice de vecteurs chauds T_Convertir en données
    T_data = np_utils.to_categorical(t_data[:,:],3)

4.2 Données de sortie

A partir des données de sortie prédites, celle avec la probabilité la plus élevée est adoptée et convertie en une image en trois couleurs. Lorsque les données sont sorties, une valeur est plus grande comme indiqué ci-dessous. Place la couleur correspondante sur le 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]
  ...

Source pour le placement des couleurs sur les pixels. Dans w_array, le vecteur de valeur de probabilité de (R, G, B) est arrangé en latitude x longitude. Sur cette base, les données d'image «mask1» sont créées.

rasterize.py

  # w_tableau Nd de données de sortie prédites_matrice Un écran de matrice est stocké

  s_img = array_to_img(w_array[:,:,:].reshape(i_dmlat,i_dmlon,3))
  # s_img Données imagées

  new_img_size = [w_array.shape[1], w_array.shape[0]]
  mask1 = Image.new('RGB', new_img_size)
  #mask1 Array pour la sortie

  for x in range(new_img_size[1]):
    for y in range(new_img_size[0]):

      # w_Le troisième élément du tableau est w1/r1/Magasin dans b1
      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
          #Définir le rouge comme RVB lorsque r1 est maximum
        else: # r1=<w1
          if(b1>w1):  # r1=<w1<b1
            r,g,b=0,0,255
            #Définir le bleu comme RVB lorsque b1 est au maximum
          else: # r1=<w1, b1=<w1
            r,g,b=255,255,255
            #Définir le blanc comme RVB lorsque w1 est maximum
      else: # w1>=r1
        if(b1>r1):
          if(b1>w1): # b1>w1>r1
            r,g,b=0,0,255
            #Définir le bleu comme RVB lorsque b1 est au maximum
          else: # w1>=b1>r1
            r,g,b=255,255,255
            #Définir le blanc comme RVB lorsque w1 est maximum
        else: # w1>=r1 w>=b1
          r,g,b=255,255,255
          #Définir le blanc comme RVB lorsque w1 est maximum

      mask1.putpixel((y,x),(r,g,b))
      #Définissez la valeur RBG sur mask1

4.3 Réseau neuronal convolutif

4.3.1 Structure du réseau

La structure de CNN a une branche comme U-Net et est faite par moi-même. Une entrée est un tenseur de 18x256x256 et une sortie est un tenseur de 3x256x256. La taille de l'image est divisée par deux en spécifiant le paramètre stride = (2,2) de Conv2D, et devient finalement 120x16x16. Dans U-Net normal, le nombre de canaux est doublé lors de la réduction de moitié de la taille de l'image, mais cette fois, il n'est pas doublé proprement en raison de la quantité de mémoire.

4.3.2 Définition du réseau par Keras

La source de Python-Keras pour la partie de définition de réseau est ci-dessous. La façon de définir le réseau de Keras est d'utiliser ** l'API fonctionnelle ** pour connecter la sortie de chaque couche à la couche suivante ou à la partie connexion à la fin.

cnv2dtra = concatenate([cnv2dtra , cnv2d14 ], axis=1) La partie telle que celle où «cnv2d14», qui s'est ramifié à «cnv2dtra», est connectée par le premier élément (canal).

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) #Nombre d'apprentissage

#--- seting Neural Network using Keras

in_ch = 18　#Image d'entrée RVB x 6 types de canaux

cnn_input = Input(shape=(in_ch, i_dmlat, i_dmlon))
# i_dmlat, i_Nombre de pixels dans les directions de latitude et de longitude de l'image dmlon

# 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)
#Rejoindre une succursale

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)
#Rejoindre une succursale

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)
#Rejoindre une succursale

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)
#Rejoindre une succursale

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)
#Enfin faire une image ternaire


NN_1 = Model( input=cnn_input , output=cnv2dtr10 )
#L'entrée est cnn_Construisez un réseau avec le dernier cnv2dtr10 en sortie en entrée

NN_1.compile(optimizer='adam', loss='categorical_crossentropy' , metrics=['accuracy'])
#Fonction de perte catégorique_crossentropy

4.4 Couche finale softmax

Dans la couche finale, softmax calcule le rouge, le bleu et le blanc pour chaque pixel. Puisque le softmax standard ne peut pas spécifier une partie du tableau, nous définissons une fonction appelée softMaxAxis. Cette méthode Stack Over flow:"How to specify the axis when using the softmax activation in a Keras layer?" C'est en rapport avec.

softMaxAxis.py

def softMaxAxis(x):
        return softmax(x,axis=1)

À ce stade, il semble nécessaire d'indiquer le nom de l'objet personnalisé lors de l'enregistrement et du rechargement du modèle.

load_model

NN_1 = load_model( paramfile , custom_objects={'softMaxAxis': softMaxAxis })

4.5 Superposition de l'image générée et du diagramme isobare

Utilisez ImageMagick. convert -compose multiply est la commande à superposer. Spécifie que les centres des deux images sont alignés sans décalage vertical ou horizontal par -gravity center -geometry + 0 + 0.

Image_Overlay.sh

# m_fichier Image avant générée (PNG)
# s_diagramme isobare de fichier (PNG)
composite -gravity center -geometry +0+0 -compose multiply  ${m_file} ${s_file} out.png

5. Résumé

J'ai créé un réseau de neurones qui reconnaît l'image de visualisation des données météorologiques et génère une "image de face que l'Agence météorologique japonaise analyse", et j'ai essayé de dessiner le front automatiquement.

Je pense que cette méthode est efficace non seulement pour le dessin de première ligne, mais aussi pour toutes les données tracées sur la carte qui sont liées à la météo. Par contre, j'estime qu'il est assez difficile d'évaluer la perte de succès. Même si vous regardez la différence des valeurs de pixels mécaniquement, cela semble différent, et que faites-vous de l'évaluation de la capture de la forme de la ligne de front? À l'instar de l'examen des prévisions météorologiques, il peut être inopinément correct pour une personne de marquer.

Actuellement, nous travaillons à générer une image radar composite à partir des données météorologiques MSM, et nous envisageons de l'évaluer comme des données correctes. Je pense aussi le publier bientôt.

C'était le premier message de Qiita, mais j'ai posté une longue phrase cinq fois. Merci à tous ceux qui l'ont lu.