[PYTHON] Ich habe versucht, die Verschlechterung des Lithium-Ionen-Akkus mithilfe des Qore SDK vorherzusagen
Einführung
Hallo, es ist kon2: sunny :: sunny: Ich bin ein Student, der normalerweise an der Universität Negativmaterial für Lithiumbatterien studiert.
Lithium-Ionen-Batterien sind im Alltag weit verbreitet, beispielsweise in Mobiltelefonen und Elektrofahrzeugen. Nachdem Sie kürzlich den Nobelpreis gewonnen haben, haben Sie Ihren Namen oft gehört.
Obwohl Lithium-Ionen-Batterien seit mehr als 40 Jahren auf dem Markt sind, sind sie immer noch ein aktives Forschungsfeld, und der Einsatz von maschinellem Lernen hat in letzter Zeit Aufmerksamkeit erregt. Zum Beispiel die Entwicklung neuer Elektrodenmaterialien und Elektrolyte, die Optimierung der Batteriekonfiguration (Elektrodenfilmdicke, Elektrolytkonzentration, Additive ...), die Vorhersage der Batterielebensdauer usw.
Dieses Mal werde ich das von Quantum Core Co., Ltd. bereitgestellte Qore SDK für eine begrenzte Zeit verwenden, um die Entladekapazität von Lithium-Ionen-Batterien über die Zeit vorherzusagen: v :: v :: v:
Die Einführung und Verwendung des Qore SDK wird im folgenden Artikel erläutert. Die Welt des Reservoir Computing ~ mit Qore ~ Einführung des Qore SDK und Erkennung von Arrhythmien mit Qore
Da es eine große Sache war, habe ich das gleiche Lernen mit LSTM gemacht, was eine Art tiefes Lernen ist, und die Ergebnisse verglichen.
Erfassung von Lade- / Entladedaten
Verwenden Sie für Lade- / Entladedaten die Daten, die auf der folgenden Seite von CALCE (Center for Advanced Life Cycle Engineering) der University of Maryland veröffentlicht wurden.
https://calce.umd.edu/data#CS2
Bei dieser Analyse werden die Lade- / Entladedaten der CS2-Batterie (CS2-35, CS2-36, CS2-37, CS2-38) verwendet. Nach dem Herunterladen im Zip-Format enthält die XLSX-Datei im entpackten Ordner die Lade- / Entladedaten.
Da es in mehrere Daten unterteilt ist und auch die Anzahl der Zyklen unterschiedlich ist, werden die Daten entsprechend formatiert und vorverarbeitet.
Ich werde die Vorverarbeitung in diesem Artikel nicht erklären, aber ich habe sie auf GitHub im Jupyter-Notebook-Format gepostet. Bitte beziehen Sie sich darauf: point_down :: point_down :: point_down:
https://github.com/konkon3249/BatteryDatasetPreprocessing/blob/master/Preprocessing_CS2_35.ipynb
Hier ist die Lade- / Entladekurve der Batterie CS2-35 nach der Vorbehandlung. Die Gesamtzahl der Zyklen betrug 887.
Die Ladekurve erstreckt sich nach rechts oben und die Entladekurve nach links unten. Wenn sich die Farbe von blau nach lila ändert, zeigt dies an, dass der Zyklus fortschreitet.
Was Sie hier wissen möchten, ist die maximale Entladekapazität jedes Batteriezyklus. Die folgende Abbildung zeigt dies gegen die Anzahl der Zyklen.
Sie können sehen, dass die Entladekapazität mit dem Zyklus immer kleiner wird. Im Allgemeinen ist der Lebensstandard, wenn die Kapazität um 20% reduziert wird (diesmal 1,1 x 0,8 = 0,88 Ah), sodass diese Batterie eine Lebensdauer von etwa 580 Zyklen hat.
Zeitreihenanalyse mit Qore
Da die Beziehung zwischen der Entladekapazität der Sekundärbatterie und der Anzahl der Zyklen als Zeitreihendaten betrachtet werden kann, wurden Vorhersagen von ARIMA (nicht Deep Learning) oder LSTM (Deep Learning) getroffen.
Vorhersage der verbleibenden Lebensdauer von Lithium-Ionen-Batterien basierend auf einer Mischung aus empirischer Modenzerlegung und ARIMA-Modell (Artikel mit ARIMA) ) Wiederkehrendes neuronales Netzwerk mit langem Kurzzeitgedächtnis zur Vorhersage der verbleibenden Nutzungsdauer von Lithium-Ionen-Batterien (Artikel mit LSTM) Assessing the Health of LiFePO4 Traction Batteries through Monotonic Echo State Networks (Artikel mit Echo State Network)
Das letzte Papier ist ein Papier, das Echo State Networks, eine Art Reservoir-Computing, zur Vorhersage verwendet. Ich hätte nicht gedacht, dass es schon jemand tut.
Wie auch immer, es wird gesagt, dass das von Qore SDK bereitgestellte Reservoir-Computing gut für die Zeitreihenanalyse geeignet ist, daher werde ich dies verwenden, um eine ähnliche Zeitreihenanalyse durchzuführen.
Klicken Sie hier, um eine Liste der diesmal verwendeten Trainingsdaten anzuzeigen.
Aus den Lade- / Entladedaten dieser vier Lithium-Ionen-Batterien werden drei Typen (Nr. 35, 37, 38) als Lehrerdaten und ein Typ (Nr. 36) als Testdaten für die Zeitreihenanalyse verwendet.
Die Zeitreihenanalyse wird auch auf dem Jupyter-Notizbuch veröffentlicht. Schauen Sie also bitte vorbei.
https://github.com/konkon3249/BatteryLifePrediction
Nachfolgend finden Sie eine kurze Erklärung.
Daten lesen und Lehrerdaten erstellen
Lesen Sie zuerst die Daten im CSV-Format. Ich werde auch fehlende Werte für alle Fälle behandeln.
df_35 = pd.read_csv('CS2_35.csv',index_col=0).dropna()
df_36 = pd.read_csv('CS2_36.csv',index_col=0).dropna()
df_37 = pd.read_csv('CS2_37.csv',index_col=0).dropna()
df_38 = pd.read_csv('CS2_38.csv',index_col=0).dropna()
Erstellen Sie Lehrerdaten für die Zeitreihenanalyse mit der folgenden Funktion. Ich habe auch auf den folgenden Artikel verwiesen, der das Qore SDK verwendet: thumbsup :: thumbsup :: thumbsup:
Aufgabe mit Qore SDK zurückgeben
def ConvertData(dataset,t_width):
X_trains = []
y_trains = []
for df in dataset:
t_length = len(df)
train_x = np.arange(t_length)
capacity = np.array(df['capacity'])
train_y = capacity
for i in range(t_length - t_width):
X_trains.append(train_y[i:i + t_width])
y_trains.append(train_y[i + t_width])
X_trains = np.array(X_trains)
y_trains = np.array(y_trains)
return X_trains,y_trains
X_train,y_train = ConvertData([df_35,df_37,df_38],50)
X_test,y_test = ConvertData([df_36],50)
Überprüfen Sie die Abmessungen der Lehrerdaten, die durch diesen Prozess erhalten wurden.
print(X_train.shape,X_test.shape,y_train.shape,y_test.shape)
>> (2588, 50) (873, 50) (2588,) (873,)
Es gibt zu viele Daten, um sie in die API zu werfen. Reduzieren Sie daher die Anzahl der Lehrerdaten auf 500. Die Daten werden zufällig ausgewählt.
idx = np.arange(0,X_train.shape[0],1)
idx = np.random.permutation(idx)
idx_lim = idx[:500]
X_train = X_train[idx_lim]
y_train = y_train[idx_lim]
Wandeln Sie schließlich die Lehrerdaten in Dimensionen um (Anzahl der Daten, Zeit, reale Daten). Die letzte Dimension ist jedoch 1, da sie nicht multivariat ist.
X_train = X_train.reshape([X_train.shape[0], X_train.shape[1], 1])
X_test = X_test.reshape([X_test.shape[0], X_test.shape[1], 1])
print(X_train.shape,X_test.shape,y_train.shape,y_test.shape)
>> (500, 50, 1) (873, 50, 1) (500,) (873,)
Ich fühle mich so.
Lernen von Zeitreihendaten mit dem Qore SDK
Das Lernen erfordert keine Optimierung der Netzwerkstruktur oder -parameter. Es ist sehr einfach, da es nur in die API geworfen wird.
%%time
client = WebQoreClient(username, password, endpoint=endpoint)
time_ = client.regression_train(X_train, y_train)
print('Time:', time_['train_time'], 's')
>> Time: 1.784491777420044 s
>> Wall time: 2.26 s
Darüber hinaus wird das Ergebnis sofort zurückgegeben. Es ist so schnell, dass ich mir Sorgen mache, wenn ich wirklich lerne.
Lass uns nachsehen. Zunächst aus den Trainingsdaten.
#Inferenz
res = client.regression_predict(X_train)
#Handlung
fig=plt.figure(figsize=(12, 4),dpi=150)
plt.plot(res['Y'],alpha=0.7,label='Prediction')
plt.plot(y_train,alpha=0.7,label='True')
plt.legend(loc='upper right',fontsize=12)
Betrachtet man die vorhergesagten Werte der Trainingsdaten, so scheint das Lernen ordnungsgemäß durchgeführt zu werden. Als nächstes wird das Vorhersageergebnis der Entladekapazität der Batterie (Nr. 36) für 300 bis 800 Zyklen, dh die Testdaten, angezeigt.
Blau ist der vorhergesagte Wert und Orange ist der experimentelle Wert. Ist es nicht ziemlich gut vorherzusagen?
Ich habe scikit-learn verwendet, um den Fehler (MSE) anzuzeigen (für einen späteren Vergleich mit LSTM).
from sklearn.metrics import mean_squared_error
print(mean_squared_error(y_test[300:800], res['Y']))
>> 0.00025365167122575003
Lassen Sie uns nun die Entladekapazität von 500 bis 550 Zyklen wie folgt vorhersagen.
#Zukünftige Vorhersage der Entladekapazität
initial = X_test[500]
results = []
for i in tqdm(range(50)):
if(i == 0):
res = client.regression_predict([initial])['Y']
results.append(res[0])
time.sleep(1)
else:
initial = np.vstack((initial[1:],np.array(res)))
res = client.regression_predict([initial])['Y']
results.append(res[0])
time.sleep(1)
#Handlung
fig=plt.figure(figsize=(12,4),dpi=150)
plt.plot(np.linspace(501,550,50),results,'o-',ms=4,lw=1,label='predict')
plt.plot(np.linspace(401,550,150),y_test[400:550],'o-',lw=1,ms=4,label='true')
plt.legend(loc='upper right',fontsize=12)
plt.xlabel('Number of Cycle',fontsize=13)
plt.ylabel('Discharge Capacity (Ah)',fontsize=13)
Das Ergebnis ist wie folgt.
Ich kann es mit einem guten Gefühl vorhersagen!
Lernen mit LSTM
Da es eine große Sache ist, werde ich es mit LSTM vergleichen. Ändern Sie zunächst die Dimension der richtigen Antwortdaten von (N,) in (N, 1).
X_train = X_train.reshape([X_train.shape[0], X_train.shape[1], 1])
X_test = X_test.reshape([X_test.shape[0], X_test.shape[1], 1])
y_train = y_train.reshape([y_train.shape[0], 1])
y_test = y_test.reshape([y_test.shape[0], 1])
print(X_train.shape,X_test.shape,y_train.shape,y_test.shape)
>> (500, 50, 1) (873, 50, 1) (500, 1) (873, 1)
Die Parameter von LSTM sind wie folgt.
hidden layer：3 optimizer：rmsprop loss function：mean squared error batch size：50 epochs:100
Das Modell zu bauen und zu lernen ist so.
#LSTM Modellbau
length_of_sequence = X_train.shape[1]
in_out_neurons = 1
n_hidden = 3
model = Sequential()
model.add(LSTM(n_hidden, batch_input_shape=(None, length_of_sequence, in_out_neurons),
return_sequences=False))
model.add(Dense(1))
model.add(Activation("linear"))
model.compile(loss="mean_squared_error", optimizer="rmsprop")
#Modelllernen
%%time
early_stopping = EarlyStopping(monitor='val_loss', mode='auto', patience=20)
history = model.fit(X_train, y_train,
batch_size=50,
epochs=100,
validation_split=0.1,
callbacks=[early_stopping,PlotLossesKeras()]
)
Bei Verwendung einer GPU (GTX1070) betrug die Berechnungszeit 1 min 27 s. Der Übergang des Verlusts während des Lernens ist wie folgt.
Klicken Sie hier, um das Ergebnis der Vorhersage der Entladekapazität der Testdaten (CS2-36) unter Verwendung dieses Modells wie im Fall von Qore anzuzeigen.
Sie können auf die gleiche Weise vorhersagen. Die MSE ist 0,00021017. Sagen Sie nun wie zuvor die Entladekapazität von 500 bis 550 Zyklen wie folgt voraus.
initial = X_test[500]
results = []
for i in tqdm(range(50)):
if(i == 0):
initial = initial.reshape(1,50,1)
res = model.predict(initial)
results.append(res[0][0])
else:
initial = initial.reshape(50,1)
initial = np.vstack((initial[1:],np.array(res)))
initial = initial.reshape(1,50,1)
res = model.predict([initial])
results.append(res[0][0])
Es scheint, dass es getan wurde, aber es scheint, dass es besser vorhersehbar ist, wenn Qore verwendet wird.
Schließlich ist hier ein Diagramm, das die Ergebnisse der Zeitreihenprognose mit dem Fall Qore darstellt.
Zusammenfassung
In diesem Artikel haben wir eine Zeitreihenvorhersage des Verschlechterungsprozesses (Abnahme der Entladekapazität) einer Lithium-Ionen-Batterie unter Verwendung des Qore SDK gemacht und diese mit dem Fall der Verwendung des üblicherweise verwendeten LSTM verglichen.
Infolgedessen sind der Fehler (mse) aus den Testdaten und die Berechnungszeit wie folgt.
| QoreSDK | LSTM | |
|---|---|---|
| MSE | 2.5365e-4 | 2.1017e-4 |
| Lernzeit | 1.78 s | 87 s |
Der Fehler ist in LSTM etwas kleiner, aber die Lernzeit ist in Qore überwältigend kürzer. Es ist erstaunlich, dass Sie bisher lernen können, ohne die Lernparameter anzupassen.
Schließlich
Die diesmal gemachte Vorhersage der Batterieverschlechterung ist tatsächlich immer noch unzureichend. Dies scheint auf die Tatsache zurückzuführen zu sein, dass nur die Entladekapazität für die Vorhersage von Zeitreihen verwendet wird.
Tatsächlich gibt es viele andere Parameter, die sich auf die Batteriekapazität beziehen. Die folgenden Daten können beispielsweise aus diesem Datensatz abgerufen werden.
Von links oben die Beziehung zwischen Entladekapazität, Innenwiderstand, Ladezeit bei konstantem Strom, Ladezeit bei konstanter Spannung und Lade- / Entladezyklus. Wenn Sie eine multivariate Zeitreihenanalyse einschließlich der hier enthaltenen Daten durchführen, sollten Sie in der Lage sein, die Verschlechterung genauer vorherzusagen. (Diesmal war ich nicht stark ...)
Quantum Core, vielen Dank, dass Sie diesmal eine solche API bereitgestellt haben. Die Zeitreihenanalyse war ein Amateur, aber sehr interessant! Für eine begrenzte Zeit, wenn Sie spielen möchten: point_down :: point_down :: point_down:
Na dann ~~.
Recommended Posts