in Bezug auf die Einrichtung Ogrid und füllen Sie die entsprechenden mehrdimensionalen Array in numpy

Question

Ich versuche, das folgende Python-Segment zu verstehen.

def upsample_filt(size): 
    factor = (size + 1) // 2 
    if size % 2 == 1: 
     center = factor - 1 
    else: 
     center = factor - 0.5 
    og = np.ogrid[:size, :size] 
    return (1 - abs(og[0] - center)/factor) * \ 
      (1 - abs(og[1] - center)/factor) 

Nach numpy, ogrid returns a mesh-grid ndarrys with only one dimension.I think the program want to generate Größe * Größe array. Why is it be written as og = np.ogrid [: Größe,: size] Or what does: size` bedeuten?

Als Test, ich Setup size=4 und print((1 - abs(og[0] - center)/factor)*(1 - abs(og[1] - center)/factor)) wird die Ausgabe wie folgt:

[[ 0.0625 0.1875 0.1875 0.0625] 
[ 0.1875 0.5625 0.5625 0.1875] 
[ 0.1875 0.5625 0.5625 0.1875] 
[ 0.0625 0.1875 0.1875 0.0625]] 

ich nicht ganz klar bin wie funktioniert (1 - abs(og[0] - center)/factor)*(1 - abs(og[1] - center)/factor) fillup dieses mehrdimensionales Array?

Answer 1

Ermöglicht es einfacher machen:

In [264]: og=np.ogrid[:3,:2] 
In [265]: og 
Out[265]: 
[array([[0], 
     [1], 
     [2]]), array([[0, 1]])] 

Die Form dieser 2 ist (3,1) und (1,2). Sie sind 2d; "o" für "offen".

In [266]: og[0]*og[1] 
Out[266]: 
array([[0, 0], 
     [0, 1], 
     [0, 2]]) 

Sie senden zusammen

(3,1), (1,2) => (3,2), (3,2) => ein (3,2) Anordnung zu bilden (3,2)

Blick auf, was mgrid produziert:

In [271]: np.mgrid[:3,:2] 
Out[271]: 
array([[[0, 0], 
     [1, 1], 
     [2, 2]], 

     [[0, 1], 
     [0, 1], 
     [0, 1]]]) 

2 (3,2) Anordnungen, welche die gleiche Kombination erzeugen

ogrid und mgrid sind Klassenobjekte mit eindeutiger Indizierungsmethode. [:3, :2] betrachtet Python als reguläre Indizierung.

meshgrid erzeugt das Gleiche, aber mit einem normalen Funktionssyntax

In [275]: np.meshgrid(np.arange(3), np.arange(2),sparse=True,indexing='ij') 
Out[275]: 
[array([[0], 
     [1], 
     [2]]), array([[0, 1]])] 

Eine andere Möglichkeit, die gleiche Berechnung durchzuführen - von [:,None] unter Verwendung des ersten Bereichs in eine (3,1) -Matrix zu drehen. Hier wird der Rundfunk ist (3,1), (2) => (3,1), (1,2) => (3,2)

In [276]: np.arange(3)[:,None]*np.arange(2) 
Out[276]: 
array([[0, 0], 
     [0, 1], 
     [0, 2]]) 

========= ==========

(1 - abs(og[0] - center)/factor) * 
(1 - abs(og[1] - center)/factor) 

diese skaliert nur die 2 Bereiche und sie multipliziert sie zusammen

In [292]: a=(1-abs(np.arange(4)-1.5)/2) 
In [293]: a[:,None]*a 
Out[293]: 
array([[ 0.0625, 0.1875, 0.1875, 0.0625], 
     [ 0.1875, 0.5625, 0.5625, 0.1875], 
     [ 0.1875, 0.5625, 0.5625, 0.1875], 
     [ 0.0625, 0.1875, 0.1875, 0.0625]])