Wie Rohr binären Daten in numpy-arrays ohne tmp-Speicher?

Gibt es mehrere ähnliche Fragen, aber keiner von Ihnen beantwortet diese einfache Frage direkt:

Wie kann ich catch a-Befehle output und Streams, die Inhalte in numpy-arrays ohne erstellen eines temporären string-Objekt zum Lesen aus?

So, was ich tun möchte, ist dies:

import subprocess
import numpy
import StringIO

def parse_header(fileobject):
    # this function moves the filepointer and returns a dictionary
    d = do_some_parsing(fileobject)
    return d

sio = StringIO.StringIO(subprocess.check_output(cmd))
d = parse_header(sio)
# now the file pointer is at the start of data, parse_header takes care of that.
# ALL of the data is now available in the next line of sio
dt = numpy.dtype([(key, 'f8') for key in d.keys()])

# i don't know how do make this work:
data = numpy.fromxxxx(sio , dt)

# if i would do this, I create another copy besides the StringIO object, don't I?
# so this works, but isn't this 'bad' ?
datastring = sio.read()
data = numpy.fromstring(datastring, dtype=dt)

Versuchte ich es mit StringIO und cStringIO aber beide werden nicht akzeptiert, von numpy.frombuffer und numpy.fromfile.

Mit StringIO-Objekt, die ich zuerst Lesen müssen, um den stream in einen string und verwenden Sie dann numpy.fromstring, aber ich möchte vermeiden, erstellen die Mittelstufe-Objekt (mehrere Gigabyte).

Alternative für mich wäre, wenn ich stream sys.stdin in numpy-arrays, aber das funktioniert nicht mit numpy.fromfile entweder (suchen muss umgesetzt werden).

Gibt es irgendwelche Workarounds für diese? Ich kann nicht die erste sein, die dies versuchen, (es sei denn, dies ist ein PEBKAC Fall?)

Lösung:
Dies ist die aktuelle Lösung, es ist eine Mischung aus unutbu Anleitung wie die Popen, die mit PFEIFE und den Hauch von eryksun zu verwenden bytearray, also ich weiß nicht, wer zu akzeptieren!? :S

proc = sp.Popen(cmd, stdout = sp.PIPE, shell=True)
d = parse_des_header(proc.stdout)
rec_dtype = np.dtype([(key,'f8') for key in d.keys()])
data = bytearray(proc.stdout.read())
ndata = np.frombuffer(data, dtype = rec_dtype)

Ich nicht prüfen, ob die Daten wirklich nicht das erstellen einer weiteren Kopie nicht wissen, wie. Was ich aber bemerkt, dass dies funktioniert viel schneller, als alles was ich vorher versucht, also vielen Dank an beide Antworten " Autoren!

  • Haben Sie als numpy.fromiter?
  • Könnte Sie post ein (Vereinfachtes) Beispiel, welche Art von Funktion (oder-Eingang) beschäftigen wir uns mit?
  • getan, mehr klar jetzt?
  • Vielleicht verwenden Popen mit stdout=subprocess.PIPE (d.h. keine temporären string mit check_output), Lesen Sie in der Kopfzeile, dann laden Sie den rest in eine bytearray zu verwenden mit np.frombuffer. Die NumPy-array teilen sich den gleichen Speicher wie die bytearray.
  • Ihre Methode funktioniert, @eryksun. legen Sie es in eine Antwort zu bekommen, einige Akzeptanzstellen. 😉
InformationsquelleAutor K.-Michael Aye | 2012-10-24
  1. 5

    Können Sie Popen mit stdout=subprocess.PIPE. Lesen Sie in der Kopfzeile, dann laden Sie den rest in eine bytearray zu verwenden mit np.frombuffer.

    Zusätzliche Kommentare nach deinem edit:

    Wenn du gehst zu nennen proc.stdout.read(), es ist gleichbedeutend mit check_output(). Beide erstellen Sie einen temporären string. Wenn Sie preallocate data könnten Sie proc.stdout.readinto(data). Dann, wenn die Anzahl der gelesenen bytes in data ist weniger als len(data), befreien Sie den überschüssigen Speicher, sonst verlängern data von was auch immer übrig ist, um zu Lesen. 

    data = bytearray(2**32) # 4 GiB
n = proc.stdout.readinto(data)
if n < len(data):
    data[n:] = ''        
else:
    data += proc.stdout.read()

    Könnten Sie nicht auch kommen an dieser beginnend mit einer pre-allocated ndarray ndata und verwenden buf = np.getbuffer(ndata). Dann readinto(buf) wie oben.

    Hier ist ein Beispiel, um zu zeigen, dass der Speicher freigegeben, zwischen den bytearray und die np.ndarray:

    >>> data = bytearray('\x01')
>>> ndata = np.frombuffer(data, np.int8)
>>> ndata
array([1], dtype=int8)
>>> ndata[0] = 2
>>> data
bytearray(b'\x02')
    InformationsquelleAutor Eryk Sun
  2. 2

    Da Ihre Daten können leicht in den Arbeitsspeicher passen, ich denke, der einfachste Weg, um zum laden der Daten in ein numpy-array ist die Verwendung eines ramfs.

    Unter Linux, 

    sudo mkdir /mnt/ramfs
sudo mount -t ramfs -o size=5G ramfs /mnt/ramfs
sudo chmod 777 /mnt/ramfs

    Dann zum Beispiel, wenn dies der Hersteller der binären Daten:

    writer.py:

    from __future__ import print_function
import random
import struct
N = random.randrange(100)
print('a b')
for i in range(2*N):
    print(struct.pack('<d',random.random()), end = '')

    Dann könnten Sie laden Sie Sie in ein numpy-array wie dieses:

    reader.py:

    import subprocess
import numpy

def parse_header(f):
    # this function moves the filepointer and returns a dictionary
    header = f.readline()
    d = dict.fromkeys(header.split())
    return d

filename = '/mnt/ramfs/data.out'
with open(filename, 'w') as f:  
    cmd = 'writer.py'
    proc = subprocess.Popen([cmd], stdout = f)
    proc.communicate()
with open(filename, 'r') as f:      
    header = parse_header(f)
    dt = numpy.dtype([(key, 'f8') for key in header.keys()])
    data = numpy.fromfile(f, dt)
    • Haben Sie überprüft, die Speicherauslastung, wenn Sie diese verwenden, um eine sehr große Arrays? Beachten Sie, dass fromiter hat eine count Schlagwort (überprüfen Sie die docstring). Wenn Sie es nicht verwenden, wird das array verkleinert, wie es gebaut ist. Sie könnte immer noch das problem der zeitweise mit sehr viel mehr Speicher als die endgültige Größe des Arrays.
    • Ist dies nicht unmöglich, weil die Prämisse ist, dass nach dem Parsen der header, die Daten in die nächste Zeile. Es gibt keine weitere Zeile Endungen geparst werden können!
    • Ich glaube nicht, dass wir verwenden können, die count parameter ist in diesem Fall, weil wir nicht wissen, wie viele Zeilen von Daten werden ausgegeben, indem der Prozess.
    • In den Kommentaren unter der Frage, die Sie Staat Sie nicht wissen, "wie viele Zeilen, die ich erhalten werde". Aber in dem Kommentar unter meinem post Stand, "nach dem Parsen der header, die Daten in die nächste Zeile." Ich bin verwirrt. Welches ist es?
    • Recht. Ich wollte nicht unterstellen, dass Sie es verwenden können.
    • Ich gebe zu, es ist noch nicht ganz klar, aber der Beispiel-code zeigt eindeutig, dass alle Daten in die nächste Zeile. die Größe der "dtype" bestimmt die Größe der Linie, aber kein EOL-Zeichen werden aus dem stream. die read () - Befehl ist zu bemessen nach der Größe der dtype. Und numpy.fromfile schön, tut das richtig beim Lesen dieser stream von der Festplatte, nachdem Sie es Pipe in eine Datei. Es will einfach nicht funktionieren mit einem direkten sys.stdin leider.
    • ich verstehe nicht, die scheinbare doppelte Verwendung von Iterationen, einmal über den iter () - Funktion und einmal über den generator? Was bedeutet das?
    • Die 2-argument nennen zu iter(readline, "") gibt einen iterator, welches die Folge von readline() bis es den Wert erreicht, den "". So ist es nur ein Weg, um Zuleitungen zu process_data. Nun, ich verstehe das problem, das nutzlos ist 🙂
    • Etwa, was ist die Größe der Daten kommen aus cmd? Können es alle in den Arbeitsspeicher passen? Wenn ja, könnten Sie vielleicht eine ramfs, leiten die Ausgabe in eine Datei im ramfs, und verwenden Sie dann np.fromfile laden Sie ein numpy-array...
    • Ja, es sollte passen. Es ist 3,6 GB Binär, alle Doppelzimmer und ich habe 94 GB RAM. Werde versuchen, dass man.

    InformationsquelleAutor unutbu
Schreibe einen Kommentar