In Vorheriger Artikel habe ich eine Exe erstellt, die .png aus der Nicht-Python-Ausführungsumgebung Windows für das Diagramm von Matplotlib + Seaborn in Python generiert. Da die Ausführungszeit jedoch lang ist (4 Sekunden), habe ich .exe im Voraus gestartet und mit der Richtlinie erstellt, die Kommunikation zwischen Prozessen zu akzeptieren.

Die erwartete Verbesserung ist

Die Überladezeit wird reduziert, da der Import weggelassen wird.
Da es sich um eine prozessübergreifende Kommunikation handelt, kann sie direkt mit BYTE-Daten anstatt als Datei ausgetauscht werden. → Aber machen Sie zuerst nur den einen in 1.

Prozessübergreifende Kommunikation (Socket-Kommunikation)

Erstellen Sie eine prozessübergreifende Kommunikation unter Bezugnahme auf diesen Artikel.

Die Richtlinie besteht darin, die Ausführung mit Argumenten und Anweisungen vom Socket-Kommunikationsclient zu stoppen. (Das Komma wird einfach durch .split (",") getrennt.)

Serverseite

import socket
#Define the host and port
host = 'localhost'
port = 64123 #Geeigneter Hafen

#socket connect
serversock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

serversock.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
serversock.bind((host,port))
serversock.listen(1)

if __name__ == '__main__':
 client_socket, client_address = serversock.accept()

 while True:
     #Warten auf Nachricht
     rcvMsg = client_socket.recv(2048)

     #Nachrichtenempfang
     print('Receive data : %s' % (rcvMsg))
     rcvMsg = rcvMsg.decode('utf-8').split(',')

     #Überprüfen Sie, ob das Format korrekt ist

     Args1 = rcvMsg[0] 
     Args2 = rcvMsg[1] 
     Args3 = rcvMsg[2] 

     ###Beschreibung des Verarbeitungsabschnitts###

     s_msg = 'Finish'
     s_msg = s_msg.encode('utf-8')
     client_socket.sendall(s_msg)
     print('Send finish')
 client_socket.close()

Client-Seite

import socket

host = 'localhost'  
port = 64123        #Beliebiger lokaler Port. Mit Server abgleichen.

#Socket-Kommunikation gestartet
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((host, port)) 

while True:
    print('input command...')
    massage = input().encode('utf-8')    
    
    client.send(massage) 
    response = client.recv(4096) 

    #Bitte geben Sie die Unterbrechungsbedingung von While ein
client.close()

Machen Sie einen Server und Client wie folgt: Nachricht vom Client durch Kommas getrennt senden → Verarbeitung auf dem Server ausführen Ich habe es so gemacht.

Seaborn ist langsam (-_-;), also wechseln Sie zu Imshow

Da der Overhead beseitigt wurde, [Messen Sie die Zeit], bis das Diagramm generiert wird (https://qiita.com/fantm21/items/3dc7fbf4e935311488bc). Erstellen Sie zunächst Server + Client mit Python und überprüfen Sie den Vorgang. Über 0,2-0,4 Sekunden. Dies kann weiterhin verwendet werden, aber wenn Sie möchten, möchte ich es etwas schneller machen.

Wo ist es langsam?

1. Heatmap-Erstellung bei Seegeborenen


def Heatmap(data):

 ax = sns.heatmap(data)

 return ax

~ 0,1 Sekunden 2. filesave

plt.savefig(os.path.join(save_path,save_name),facecolor="blue")

~ 0,15 Sekunden

Zunächst 1. Ich fand heraus, dass Seaborn langsam ist, also entschied ich mich, es mit der Imshow von Matplotlib zu tun.

3. Generieren Sie eine Heatmap mit der Imshow von Matplotlib


def HeatMapFast(data):
    plt.figure()
    plt.imshow(data,interpolation='nearest',vmin=0,vmax=15,cmap='rainbow')
    plt.colorbar()
    #bx = plt.show()
    return plt

~0.05 Damit ist der Heatmap-Erstellungsteil einmal in Ordnung.

Weiter ist etwa 2. [Untersuchen, wie der Speicher erweitert werden kann, ohne savefig zu speichern] (https://qiita.com/kaito__/items/9aa63cccc99261814065)

Diese Methode hat den Ausführungsprozess überhaupt nicht geändert. Es scheint, dass es einige Zeit dauert, den Vorgang auszuführen, bevor das Diagramm gespeichert wird. Dieser Teil ist eine zukünftige Aufgabe.

Verwendete Pakete und Bibliotheken

import time
import socket
import os
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

Referenz zum tatsächlichen Verarbeitungsteil des Servers


#Daten sind ein zweidimensionales Array.CSV-Datei
data = np.loadtxt(load_path,delimiter=",")

#Seaborn Heat Map
hoge = Heatmap(data)
hoge.plot()
plt.savefig(os.path.join(save_path,save_name),facecolor="blue")

#Matplotlib Heat Map
hogehoge = HeatMapFast(data)
hogehoge.savefig(os.path.join(save_path,save_name2))

Ergebnis

loadCSV:0.000997781753540039[sec]
HeatMap():0.09075665473937988[sec]
SaveFig:0.115692138671875[sec]
HeatMapFast():0.05684828758239746[sec]
SaveFig2:0.13364338874816895[sec]

Das ist es. HeatMap () ist Seaborn und HeatMapFast () ist imshow. Beide haben in Kombination mit savefig ein Bild von 0,2 Sekunden oder weniger. Ich möchte es etwas schneller machen.

Da die Messung mit time.time () durchgeführt wird, scheinen Genauigkeit und Auflösung nicht sehr gut zu sein.

Verwenden der Diagrammzeichnung mit Matplotlib + Seaborn von Python für die Kommunikation zwischen Prozessen unter Windows, einer Nicht-Python-Ausführungsumgebung