Gibt es eine Möglichkeit, die Vorhersage eines Modells zu beschleunigen? ⇐ Python

[Anonymous]

Wir bauen derzeit ein neuronales Netzwerk auf, das Keras und Tensorflow zur Bewertung von Schachpositionen verwendet. Und wir sind auf das Problem der Vorhersagegeschwindigkeit bei einer einzelnen Stichprobe gestoßen, die in unserem Suchbaum verwendet wird. Die Verwendung im Suchbaum besteht darin, nach zulässigen Zügen in einer bestimmten Position zu suchen, jede Position zu bewerten und den besten Zug gemäß der besten Bewertung zu erhalten.
Bei höheren Tiefen ist es die Vorhersagegeschwindigkeit, die es langsam macht. Es ist erwähnenswert, dass unser neuronales Netzwerk eher flach ist – 3CNN-Schichten und 2 dichte Schichten. Wir haben das Modell auf der CPU trainiert und nutzen die CPU auch für die Vorhersage. Wir sind davon ausgegangen, dass dies in diesem speziellen (flachen) Netzwerk keinen Einfluss auf die Leistung hat. Obwohl es in unserem Anwendungsfall keine Parallelität gibt, ist daher kein GPU-Computing erforderlich.
Versionen:
Python 3.12.4
Tensorflow 2.16.1
Keras 3.3.3
Wir werten jeweils eine einzelne Stichprobe mit entweder model.predict() oder model(x) aus. Wir haben herausgefunden, dass die Funktion „predict_on_batch()“ ungefähr so ​​schnell ist wie die Vorhersage einer einzelnen Stichprobe. Unser Ziel ist es, die Vorhersage so schnell wie möglich zu erhalten und dabei die Vorhersage beizubehalten, die jeweils für eine einzelne Stichprobe verwendet wird.
Wir haben versucht, das Modell in TFLite zu konvertieren, da dies vorgeschlagen wurde, um eine etwas bessere Leistung zu erzielen. Aufgrund der Inkompatibilität mit den neuesten Versionen konnten wir das Modell jedoch nicht konvertieren, und auch das Downgrade funktionierte nicht.
Wir haben die Geschwindigkeiten jeder Vorhersagefunktion bei verschiedenen Stapelgrößen beobachtet.

Code: Select all

model = keras.models.load_model('firstModel.keras')

print("Durations using model __call__() on small batch")
for i in range(5):
start = time.time()
prediction = model(bitboard)
end = time.time()
print(end - start)

print("Durations using model.predict_on_batch() on small batch")
for i in range(5):
start = time.time()
prediction = model.predict_on_batch(bitboard)
end = time.time()
print(end - start)

print("Durations using model.predict() on small batch")
for i in range(5):
start = time.time()
prediction = model.predict(bitboard, batch_size=1, verbose=0)
end = time.time()
print(end - start)

print("Durations using model.__call__() on larger batch (100 samples)")
for i in range(5):
start = time.time()
prediction = model(bitboards)
end = time.time()
print(end - start)

print("Durations using model.predict_on_batch() on larger batch (100 samples)")
for i in range(5):
start = time.time()
prediction = model.predict_on_batch(bitboards)
end = time.time()
print(end - start)

print("Durations using model.predict() on larger batch (100 samples)")
for i in range(5):
start = time.time()
prediction = model.predict(bitboards, batch_size=1, verbose=0)
end = time.time()
print(end - start)

Und die Geschwindigkeiten waren wie folgt:

Code: Select all

Durations using model __call__() on small batch
0.055520057678222656
0.007033586502075195
0.006206035614013672
0.007121562957763672
0.005555391311645508
Durations using model.predict_on_batch() on small batch
0.06325101852416992
0.0020132064819335938
0.0010013580322265625
0.0009975433349609375
0.0025305747985839844
Durations using model.predict() on small batch
0.1571955680847168
0.05691671371459961
0.05576348304748535
0.05414080619812012
0.05917525291442871
Durations using model.__call__() on larger batch (100 samples)
0.01164698600769043
0.00638890266418457
0.007528543472290039
0.006807804107666016
0.00751185417175293
Durations using model.predict_on_batch() on larger batch (100 samples)
0.04664158821105957
0.0025255680084228516
0.0010013580322265625
0.0020008087158203125
0.0025064945220947266
Durations using model.predict() on larger batch (100 samples)
0.05106091499328613
0.04923701286315918
0.06421136856079102
0.0651085376739502
0.055069923400878906

Was uns beunruhigt, und dennoch verstehen wir nicht, wie es möglich ist, Vorhersagen für größere Batchgrößen in kürzerer Ausführungszeit zu erhalten, als Vorhersagen für einzelne Stichproben. Wir sind davon ausgegangen, dass es an einer falschen Verwendung von Keras/Tensorflow liegen könnte.
Hauptfragen:
Irgendwelche Vorschläge, wie man die Vorhersage beschleunigen kann?
Gibt es eine Möglichkeit, dass die Ausführung des Codes mit der GPU die Leistung steigern würde?
Würden Sie einen anderen Ansatz für das Problem oder einen anderen Anwendungsfall empfehlen, der für unser Problem geeignet wäre?
BEARBEITEN:

Wir haben versucht, das Modell in das .onnx-Format zu konvertieren. Das hat die Zeitleistung der Bewertungsfunktion wirklich verbessert und das ist großartig, aber wir sind auf ein weiteres Leistungsproblem gestoßen. Das Problem ist, dass unsere Baumsuche (basierend auf Alpha-Beta-Beschneidung) ebenfalls sehr langsam ist. Wir erreichen jetzt kaum Tiefe 6 ohne Störung des Modells (durchsuchen etwa 2.500.000 Knoten in einer Minute, mit noch weniger Störungen), was schrecklich ist.

Bisher haben wir noch nichts wie eine Transpositionstabelle oder Zugreihenfolge hinzugefügt, es handelt sich einfach nur um eine einfache Baumsuche. Wir überlegen jetzt, es in C/C++ zu übersetzen. Wir haben sehr wenig Erfahrung mit der Leistungsoptimierung, daher lautet unsere Frage: Wie viel wird es helfen und wie viele Knoten pro Sekunde können wir erhalten?

Wir fragen uns auch, ob es eine gute Idee ist, unsere mit Python trainierten Modelle in unseren zukünftigen C-Programmen zu verwenden?