Numpy Elemente basierend auf Schwellenwert ändern und dann Element für Element hinzufügen

Question

Ich habe 3247 197x10 Dimension Matrizen. Ich muss sie durchsuchen, und wenn ein Wert über 1 liegt, setze ihn gleich 1. Wenn ein Wert kleiner oder gleich 1 ist, möchte ich ihn auf Null setzen. Dann muss ich diese modifizierte Matrix nehmen und sie zu den modifizierten Matrizen der anderen 3246-Sätze hinzufügen. Hier ist, was ich bisher:

for i in range(LOWER, UPPER + 1): 
    fname = file_name+str(i)+".txt" 
    cur_resfile = np.genfromtxt(fname, delimiter = ",", skiprows = 1) 
    m_cur = cur_resfile 

    m_cur[m_cur <= 1] = 0 
    m_cur[m_cur > 1 ] = 1 

    m_ongoing = m_ongoing + m_cur 

Ich möchte m_ongoing die laufenden laufenden Summen zu halten, so dass ich diese in einer Datei speichern kann. Es funktioniert jedoch nicht und scheint nur das letzte m_cur in der Schleife zu schreiben. Wenn ich die Schleife insgesamt 3 mal laufen lasse, gibt es einige Zellen, die alle 1s haben, also würde ich ein paar Dreier erwarten. Ich erwarte definitiv viele 2s, aber ich sehe nur 1s und 0s.

Was ist der beste Weg zu tun, was ich versuche zu tun?

-Change Werte basieren auf Bedingung

-Take viele Matrizen und fügen Sie alle Element für Element für jede Zelle laufenden Summen zu erstellen.

Answer 1

Sie numpy.clip()

for i in range(LOWER, UPPER + 1): 
    fname = file_name+str(i)+".txt" 

    cur_resfile = np.genfromtxt(fname, delimiter = ",", skiprows = 1) 

    m_ongoing += cur_resfile.clip(0,1) 

EDIT Die Beantwortung der Frage verwenden könnte, die gestellt wurde:

m_ongoing = np.zeros((197,10)) 

for i in range(LOWER, UPPER + 1): 
    fname = file_name+str(i)+".txt" 
    cur_resfile = np.genfromtxt(fname, delimiter = ",", skiprows = 1) 

    # add one to the places where cur_file > 1 
    m_ongoing[cur_resfile > 1] += 1 

Answer 2

Wie @RootTwo schon sagt, Clip() ist ein schönes numpy eingebaut. Aus Leistungsgründen können Sie jedoch vektorisierte Operationen auf einem 3D- "Stapel" Ihrer Daten verwenden.

Beispiel:

import numpy as np 
#simulating your data as a list of 3247 2D matrices, each 197x10 
some_data = [np.random.randint(-2,2,(197,10)) for _i in range(3247)] 
#stack the matrices 
X = np.dstack(some_data) 
print(X.shape) 

(197, 10, 3247)

Y = X.clip(0,1) 
Z = Y.sum(axis=2) 
#Z is now the output you want! 
print(Z.shape) 

(197, 10)

EDIT: Hinzufügen von Timing-Re sult, und meine Antwort ändern

So scheint es mein Rat, einen Tiefenstapel zu erstellen und eine einzige Anwendung der Clip- und Summenfunktionen zu verwenden, war schlecht beraten. Ich habe einige Timing-Tests durchgeführt und festgestellt, dass die inkrementelle Methode schneller ist, wahrscheinlich aufgrund des zusätzlichen Zeitaufwands für die Zuteilung des großen 3D-Arrays.

Hier sind die Tests, bei denen ich den Aspekt des Ladens von Daten ausklammere, wie es in jedem Fall derselbe wäre. Hier sind die Ergebnisse, die die beiden Methoden in ipython mit %timeit Makro vergleichen.

import numpy as np 
# some_data is simulated as in the above code sample 
def f1(some_data): 
    x = some_data[0] 
    x = x.clip(0,1) 
    for y in some_data[1:]: 
     x += y.clip(0,1) 
    return x 

def f2(some_data): 
    X = np.dstack(some_data) 
    X = X.clip(0,1) 
    X = X.sum(axis=2) 
    return X 

%timeit x1 = f1(some_data) 

10 Schleifen, am besten von 3: 28.1 ms pro Schleife

%timeit x2 = f2(some_data) 

10 Schleifen, am besten von 3: 103 ms pro Schleife

Damit ist eine 3.7x Beschleunigung durch den Prozess inkrementell vs. als eine einzelne Operation zu tun, nachdem Stapeln der Daten.