ทำซ้ำ แต่เป็นชิ้นขนาดแปรผันเป็นตัวเลข

Question

ฉันมีอาร์เรย์ที่เป็นการเชื่อมต่อของส่วนต่างๆ:

a = np.array([0, 1, 2, 10, 11, 20, 21, 22, 23])
#             >     <  >    <  >            <
chunks = np.array([3, 2, 4])
repeats = np.array([1, 3, 2])

แต่ละกลุ่มที่เริ่มต้นด้วยทศวรรษใหม่ในตัวอย่างข้างต้นเป็น "กลุ่ม" ที่แยกจากกันซึ่งฉันอยากจะพูดซ้ำ ขนาดชิ้นและจำนวนการทำซ้ำเป็นที่ทราบกันดีสำหรับแต่ละประเภท ฉันไม่สามารถสร้างรูปร่างใหม่ตามด้วยkronหรือrepeatเนื่องจากชิ้นส่วนมีขนาดต่างกัน

ผลลัพธ์ที่ฉันต้องการคือ

np.array([0, 1, 2, 10, 11, 10, 11, 10, 11, 20, 21, 22, 23, 20, 21, 22, 23])
# repeats:>  1  <  >         3          <  >              2             <

การทำแบบวนซ้ำทำได้ง่าย:

in_offset = np.r_[0, np.cumsum(chunks[:-1])]
out_offset = np.r_[0, np.cumsum(chunks[:-1] * repeats[:-1])]
output = np.zeros((chunks * repeats).sum(), dtype=a.dtype)
for c in range(len(chunks)):
    for r in range(repeats[c]):
        for i in range(chunks[c]):
            output[out_offset[c] + r * chunks[c] + i] = a[in_offset[c] + i]

สิ่งนี้นำไปสู่การสร้างเวกเตอร์ต่อไปนี้:

regions = chunks * repeats
index = np.arange(regions.sum())

segments = np.repeat(chunks, repeats)
resets = np.cumsum(segments[:-1])
offsets = np.zeros_like(index)
offsets[resets] = segments[:-1]
offsets[np.cumsum(regions[:-1])] -= chunks[:-1]

index -= np.cumsum(offsets)

output = a[index]

มีวิธีที่มีประสิทธิภาพมากขึ้นในการกำหนดปัญหานี้หรือไม่? ดังนั้นเราจึงชัดเจนฉันไม่ได้ขอให้ตรวจสอบโค้ด ฉันมีความสุขกับการเรียกใช้ฟังก์ชันเหล่านี้ร่วมกัน ฉันต้องการทราบว่ามีการเรียกฟังก์ชันที่แตกต่างกันโดยสิ้นเชิง (มีประสิทธิภาพมากกว่า) ที่ฉันสามารถใช้เพื่อให้ได้ผลลัพธ์เดียวกันหรือไม่

คำถามนี้ได้รับแรงบันดาลใจจากคำตอบของฉันไปที่คำถามนี้

Answer 1

วิธีแก้" numpythonic " ที่มากกว่าคำตอบอื่นคือ -

np.concatenate(np.repeat(np.split(a, np.cumsum(chunks))[:-1], repeats))

array([ 0,  1,  2, 10, 11, 10, 11, 10, 11, 20, 21, 22, 23, 20, 21, 22, 23])

โปรดสังเกตว่าไม่มีความชัดเจนสำหรับลูป

( np.splitมีการวนซ้ำโดยปริยายตามที่ @Divakar ชี้ให้เห็น)

---

แก้ไข: Benchmarks (MacBook pro 13) -

โซลูชันของ Divakar ปรับขนาดได้ดีขึ้นสำหรับอาร์เรย์ขนาดใหญ่ชิ้นและการทำซ้ำตามที่ @Mad Physicist ชี้ให้เห็นในโพสต์ของเขา

Answer 2

วิธีที่เป็นตัวเลขมากกว่าในการทำงานของคุณ (มากกว่าคำตอบอื่น ๆ ) คือ:

result = np.concatenate([ np.tile(tbl, rpt) for tbl, rpt in
    zip(np.split(a, np.cumsum(chunks[:-1])), repeats) ])

ผลลัพธ์คือ:

array([ 0,  1,  2, 10, 11, 10, 11, 10, 11, 20, 21, 22, 23, 20, 21, 22, 23])

Answer 3

สำหรับชิ้นส่วนเหล่านั้นเป็นอาร์เรย์ช่วงเราสามารถทำงานกับอาร์เรย์อินพุตได้โดยตรงและหลีกเลี่ยงขั้นตอนการจัดทำดัชนีขั้นสุดท้ายและควรปรับปรุงสิ่งต่างๆ -

# https://stackoverflow.com/a/47126435/ @Divakar
def create_ranges(starts, ends, l):
    clens = l.cumsum()
    ids = np.ones(clens[-1],dtype=int)
    ids[0] = starts[0]
    ids[clens[:-1]] = starts[1:] - ends[:-1]+1
    out = ids.cumsum()
    return out

s = np.r_[0,chunks.cumsum()]
starts = a[np.repeat(s[:-1],repeats)]
l = np.repeat(chunks, repeats)
ends = starts+l
out = create_ranges(starts, ends, l)

Answer 4

เพื่อจุดประสงค์ในการให้ข้อมูลฉันได้เปรียบเทียบโซลูชันการทำงานที่นี่:

def MadPhysicist1(a, chunks, repeats):
    in_offset = np.r_[0, np.cumsum(chunks[:-1])]
    out_offset = np.r_[0, np.cumsum(chunks[:-1] * repeats[:-1])]
    output = np.zeros((chunks * repeats).sum(), dtype=a.dtype)
    for c in range(len(chunks)):
        for r in range(repeats[c]):
            for i in range(chunks[c]):
                output[out_offset[c] + r * chunks[c] + i] = a[in_offset[c] + i]
    return output

def MadPhysicist2(a, chunks, repeats):
    regions = chunks * repeats
    index = np.arange(regions.sum())

    segments = np.repeat(chunks, repeats)
    resets = np.cumsum(segments[:-1])
    offsets = np.zeros_like(index)
    offsets[resets] = segments[:-1]
    offsets[np.cumsum(regions[:-1])] -= chunks[:-1]

    index -= np.cumsum(offsets)

    output = a[index]
    return output

def create_ranges(starts, ends, l):
    clens = l.cumsum()
    ids = np.ones(clens[-1],dtype=int)
    ids[0] = starts[0]
    ids[clens[:-1]] = starts[1:] - ends[:-1]+1
    out = ids.cumsum()
    return out

def Divakar(a, chunks, repeats):
    s = np.r_[0, chunks.cumsum()]
    starts = a[np.repeat(s[:-1], repeats)]
    l = np.repeat(chunks, repeats)
    ends = starts+l
    return create_ranges(starts, ends, l)

def Valdi_Bo(a, chunks, repeats):
    return np.concatenate([np.tile(tbl, rpt) for tbl, rpt in
                           zip(np.split(a, np.cumsum(chunks[:-1])), repeats)])

def AkshaySehgal(a, chunks, repeats):
    return np.concatenate(np.repeat(np.split(a, np.cumsum(chunks))[:-1], repeats))

ฉันได้ดูการกำหนดเวลาสำหรับขนาดอินพุตสามขนาด: ~ 100, ~ 1,000 และ ~ 10k องค์ประกอบ:

np.random.seed(0xA)
chunksA = np.random.randint(1, 10, size=20)   # ~100 elements
repeatsA = np.random.randint(1, 10, size=20)
arrA = np.random.randint(100, size=chunksA.sum())

np.random.seed(0xB)
chunksB = np.random.randint(1, 100, size=20)  # ~1000 elements
repeatsB = np.random.randint(1, 10, size=20)
arrB = np.random.randint(100, size=chunksB.sum())

np.random.seed(0xC)
chunksC = np.random.randint(1, 100, size=200)  # ~10000 elements
repeatsC = np.random.randint(1, 10, size=200)
arrC = np.random.randint(100, size=chunksC.sum())

นี่คือผลลัพธ์บางส่วน:

|               |    A    |    B    |    C    |
+---------------+---------+---------+---------+
| MadPhysicist1 | 1.92 ms |   16 ms |  159 ms |
| MadPhysicist2 | 85.5 µs |  153 µs |  744 µs |
| Divakar       | 75.9 µs | 95.9 µs |  312 µs |
| Valdi_Bo      |  370 µs |  369 µs |  3.4 ms |
| AkshaySehgal  |  163 µs |  165 µs | 1.24 ms |