Prevedere i terremoti con Python e il Machine Learning

In questo articolo, vedremo come creare un modello per l'attività di previsione dei terremoti utilizzando l'apprendimento automatico e il linguaggio di programmazione Python. La previsione dei terremoti è uno dei grandi problemi irrisolti nelle scienze della terra.

Con l'aumento dell'uso della tecnologia, molte stazioni di monitoraggio sismico sono aumentate, quindi possiamo utilizzare l'apprendimento automatico e altri metodi basati sui dati per prevedere i terremoti.

Prevedere i terremoti con Python e il Machine Learning

Prevedere i terremoti con Machine Python e il Machine Learning

È risaputo che se si verifica un disastro in una regione, è probabile che si ripeta. Alcune regioni hanno frequenti terremoti, ma questo è solo un importo comparativo rispetto ad altre regioni.

Quindi, prevedere il terremoto con data e ora, latitudine e longitudine dai dati precedenti non è una tendenza che segue come le altre cose, accade naturalmente.

Inizieremo questa progetto " creare un modello per la previsione dei terremoti " importando le librerie Python necessarie:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

Ora carichiamo e leggiamo il set di dati. Il set di dati che sto usando qui può essere facilmente scaricato qui , insieme al codice dell'articolo ! :

data = pd.read_csv("database.csv")
data.columns

Output:

Index(['Date', 'Time', 'Latitude', 'Longitude', 'Type', 'Depth', 'Depth Error',
       'Depth Seismic Stations', 'Magnitude', 'Magnitude Type',
       'Magnitude Error', 'Magnitude Seismic Stations', 'Azimuthal Gap',
       'Horizontal Distance', 'Horizontal Error', 'Root Mean Square', 'ID',
       'Source', 'Location Source', 'Magnitude Source', 'Status'],
      dtype='object')

Vediamo ora le principali caratteristiche dei dati dei terremoti e creiamo un oggetto con queste caratteristiche, ovvero data, ora, latitudine, longitudine, profondità, magnitudo:

data=data[['Date', 'Time', 'Latitude', 'Longitude', 'Depth', 'Magnitude']]

data.head()

Output:

Prevedere i terremoti con Python e il Machine Learning

Poiché i dati non sono "formattati", è necessario ridimensionarli in base agli input del modello. Quindi, convertiamo la data e l'ora specificate nell'ora Unix che è in secondi e un numero. Questo può essere facilmente utilizzato come feature per la rete che abbiamo costruito:

import datetime
import time

timestamp = []
for d, t in zip(data['Date'], data['Time']):
    try:
        ts = datetime.datetime.strptime(d+' '+t, '%m/%d/%Y %H:%M:%S')
        timestamp.append(time.mktime(ts.timetuple()))
    except ValueError:
        # print('ValueError')
        timestamp.append('ValueError')
timeStamp = pd.Series(timestamp)
data['Timestamp'] = timeStamp.values
final_data = data.drop(['Date', 'Time'], axis=1)
final_data = final_data[final_data.Timestamp != 'ValueError']
final_data.head()

Output:

Prevedere i terremoti con Python e il Machine Learning

Visualizzazione dati dei terremoti

Ora, prima di creare il modello di previsione dei terremoti, visualizziamo i dati su una mappa del mondo che mostra una chiara rappresentazione di dove sarà maggiore la frequenza del terremoto:

from mpl_toolkits.basemap import Basemap

m = Basemap(projection='mill',llcrnrlat=-80,urcrnrlat=80, llcrnrlon=-180,urcrnrlon=180,lat_ts=20,resolution='c')

longitudes = data["Longitude"].tolist()
latitudes = data["Latitude"].tolist()
#m = Basemap(width=12000000,height=9000000,projection='lcc',
            #resolution=None,lat_1=80.,lat_2=55,lat_0=80,lon_0=-107.)
x,y = m(longitudes,latitudes)

fig = plt.figure(figsize=(12,10))
plt.title("All affected areas")
m.plot(x, y, "o", markersize = 2, color = 'blue')
m.drawcoastlines()
m.fillcontinents(color='coral',lake_color='aqua')
m.drawmapboundary()
m.drawcountries()
plt.show()

Output:

Prevedere i terremoti con Python e il Machine Learning

Suddivisione del set di dati sui terremoti

Ora, per creare il modello di previsione dei terremoti, dobbiamo dividere i dati in Xs e ys che verranno rispettivamente inseriti nel modello come input per ricevere l'output dal modello.

Qui gli input sono TIMestamp, Latitude e Longitude e le uscite sono Magnitude e Depth. Dividerò xs e ys in treno e testerò con la convalida. Il set di allenamento contiene l'80% e il set di test contiene il 20%:

X=final_data[['Timestamp', 'Latitude', 'Longitude']]
y=final_data[['Magnitude', 'Depth']]

from sklearn.cross_validation import train_test_split

X_train, X_test, y_train, y_test=train_test_split(X, y, test_size=0.2, random_state=42)

print(X_train.shape, X_test.shape, y_train.shape, X_test.shape)

Output:

(18727, 3) (4682, 3) (18727, 2) (4682, 3)

Rete neurale per la previsione dei terremoti

Ora creerò una rete neurale per adattare i dati del set di addestramento. La nostra rete neurale sarà composta da tre strati densi ciascuno con 16, 16, 2 nodi e riletti. Relu e softmax verranno utilizzati come funzioni di attivazione:

from keras.models import Sequential
from keras.layers import Dense

def create_model(neurons, activation, optimizer, loss):
    model = Sequential()
    model.add(Dense(neurons, activation=activation, input_shape=(3,)))
    model.add(Dense(neurons, activation=activation))
    model.add(Dense(2, activation='softmax'))
    
    model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])
    
    return model

Ora definirò gli iperparametri con due o più opzioni per trovare la soluzione migliore:

from keras.wrappers.scikit_learn import KerasClassifier

model = KerasClassifier(build_fn=create_model, verbose=0)

# neurons = [16, 64, 128, 256]
neurons = [16]
# batch_size = [10, 20, 50, 100]
batch_size = [10]
epochs = [10]
# activation = ['relu', 'tanh', 'sigmoid', 'hard_sigmoid', 'linear', 'exponential']
activation = ['sigmoid', 'relu']
# optimizer = ['SGD', 'RMSprop', 'Adagrad', 'Adadelta', 'Adam', 'Adamax', 'Nadam']
optimizer = ['SGD', 'Adadelta']
loss = ['squared_hinge']

param_grid = dict(neurons=neurons, batch_size=batch_size, epochs=epochs, activation=activation, optimizer=optimizer, loss=loss)

Ora dobbiamo trovare il miglior adattamento del modello sopra e ottenere il punteggio medio del test e la deviazione standard del modello di miglior adattamento:

grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1)
grid_result = grid.fit(X_train, y_train)

print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) with: %r" % (mean, stdev, param))

Output:

Best: 0.957655 using {'activation': 'relu', 'batch_size': 10, 'epochs': 10, 'loss': 'squared_hinge', 'neurons': 16, 'optimizer': 'SGD'} 

0.333316 (0.471398) with: {'activation': 'sigmoid', 'batch_size': 10, 'epochs': 10, 'loss': 'squared_hinge', 'neurons': 16, 'optimizer': 'SGD'} 

0.000000 (0.000000) with: {'activation': 'sigmoid', 'batch_size': 10, 'epochs': 10, 'loss': 'squared_hinge', 'neurons': 16, 'optimizer': 'Adadelta'} 

0.957655 (0.029957) with: {'activation': 'relu', 'batch_size': 10, 'epochs': 10, 'loss': 'squared_hinge', 'neurons': 16, 'optimizer': 'SGD'} 

0.645111 (0.456960) with: {'activation': 'relu', 'batch_size': 10, 'epochs': 10, 'loss': 'squared_hinge', 'neurons': 16, 'optimizer': 'Adadelta'}

Nel passaggio seguente, i parametri best-fit vengono utilizzati per lo stesso modello per calcolare il punteggio con i dati di allenamento e i dati di test:

model = Sequential()
model.add(Dense(16, activation='relu', input_shape=(3,)))
model.add(Dense(16, activation='relu'))
model.add(Dense(2, activation='softmax'))

model.compile(optimizer='SGD', loss='squared_hinge', metrics=['accuracy'])
model.fit(X_train, y_train, batch_size=10, epochs=20, verbose=1, validation_data=(X_test, y_test))

[test_loss, test_acc] = model.evaluate(X_test, y_test)
print("Risultato della valutazione sui dati del test : Perdita = {}, accuratezza = {}".format(test_loss, test_acc))

Risultato della valutazione sui dati del test: 
Perdita = 0,5038455790406056, accuratezza = 0,92417777017858995

Quindi possiamo vedere nell'output di cui sopra che il nostro modello di rete neurale per la previsione dei terremoti funziona bene. Spero che questo articolo ti sia piaciuto su come creare un modello di previsione dei terremoti con l'apprendimento automatico e il linguaggio di programmazione Python. Sentiti libero di porre le tue preziose domande nella sezione commenti qui sotto.

SCARICA GRATIS IL PROGETTO CON DATASET E CODICE