np.unravel_index בjs

[יוסף בן שמעון]

@davidnead אולי תסביר להדיוט כמוני מה אתה צריך, אני לא יודע פייתון

[davidnead]

@יוסף-בן-שמעון אמר בnp.unravel_index בjs:

@davidnead אולי תסביר להדיוט כמוני מה אתה צריך, אני לא יודע פייתון

אתה מבקש שאענה על השאלה של עצמי?
השאלה שלי נובעת מפני שאיני מכיר מספיק פייתון כדי להבין את משמעות הקוד על בוריו. אם הייתי מבין - הייתי מוצא כבר דרך לממש את זה בJS.

[yossiz]

@davidnead אתה בעצם מתכוון לשאול מה הפונקציה עושה?

[davidnead]

@yossiz אמר בnp.unravel_index בjs:

@davidnead אתה בעצם מתכוון לשאול מה הפונקציה עושה?

קראתי קצת מה היא עושה, לא הבנתי לעומק, הבנתי שזה באמת קצת מסובך. האמת אני גם לא מתמקד בזה כרגע, אני מתמקד בתכל'ס. אם אדע איך לממש את זה בjs בלי להבין מה זה עושה - גם תנוח דעתי.
אני בדרך כלל לא נוהג כך, אך המקרה הזה קצת חריג.

לגבי הפונקציה המשנית (argmax) חשבתי שהבנתי מה היא עושה ומימשתי אותה בJS, אבל לפי ההתנהגות המוזרה שתיארתי נראה שיש שם משהו יותר עמוק. את זו כן אשמח להבין יותר.

[OdedDvir]

@davidnead קודם כל: סקרנת אותי. אני אנסה להסביר לך כפי הבנתי, בפוסט הבא שלי.
בינתיים, תבדוק את זה: https://github.com/fasiha/ind2sub

[yossiz]

אני לא מכיר כלל את ספריית numpy אבל מכיון שאני שמח ללמוד קצת דברים חדשים מפעם לפעם, פניתי לתיעוד וזה מה שהבנתי:

ה-tile פה זה כנראה משתנה מסוג ndarray שזה אחד מהמבנים הבסיסיים של numpy. זה מערך של n מימדים כאשר tile.shape מתאר לך את המימדים.
(במקרה שלך נראה שזה 2 מימדים, לפי התשובה של unravel_index)

במבנה זו אפשר לאנדקס אותו בצורה "שטוחה" או בצורה n-מימדית. כלומר אם יש לך טבלה של 2X3 תוכל לדבר על האיבר האחרון לפי כתובות שטוחות כאיבר מספר 6 או בכתובות 2 מימדיות כאיבר 2,3. (בדוגמה התייחסתי לאינדקס הראשון כ-1, ב-numpy הראשון זה 0)

הפעולה argmax נראה לי זה משהו מאוד פשוט, זה פשוט מביא לך את הכתובת "השטוחה" הכי גבוהה במערך. למשל מערך של 2X3 אז ה-argmax יהיה 5. שזה 2 כפול 3 מינוס 1 (כי הכתובות מתחילות מ-0).

הפעולה unravel_index לוקחת כתובת "שטוחה" והופכת אותה לכתובת n-מימדית.

כך הבנתי לבינתיים. אני יודע שלא עניתי ישירות על השאלה שלך.

כללו של דבר, נראה לי שזה יותר פשוט ממה שחשבת...

עכשיו נחכה ל- @OdedDvir להאיר את עינינו יותר

[davidnead]

@yossiz אמר בnp.unravel_index בjs:

אני לא מכיר כלל את ספריית numpy אבל מכיון שאני שמח ללמוד קצת דברים חדשים מפעם לפעם, פניתי לתיעוד וזה מה שהבנתי:

ה-tile פה זה כנראה משתנה מסוג ndarray שזה אחד מהמבנים הבסיסיים של numpy. זה מערך של n מימדים כאשר tile.shape מתאר לך את המימדים.
(במקרה שלך נראה שזה 2 מימדים, לפי התשובה של unravel_index)

במבנה זו אפשר לאנדקס אותו בצורה "שטוחה" או בצורה n-מימדית. כלומר אם יש לך טבלה של 2X3 תוכל לדבר על האיבר האחרון לפי כתובות שטוחות כאיבר מספר 6 או בכתובות 2 מימדיות כאיבר 2,3. (בדוגמה התייחסתי לאינדקס הראשון כ-1, ב-numpy הראשון זה 0)

הפעולה argmax נראה לי זה משהו מאוד פשוט, זה פשוט מביא לך את הכתובת "השטוחה" הכי גבוהה במערך. למשל מערך של 2X3 אז ה-argmax יהיה 5. שזה 2 כפול 3 מינוס 1 (כי הכתובות מתחילות מ-0).

הפעולה unravel_index לוקחת כתובת "שטוחה" והופכת אותה לכתובת n-מימדית.

כך הבנתי לבינתיים. אני יודע שלא עניתי ישירות על השאלה שלך.

עכשיו נחכה ל- @OdedDvir להאיר את עינינו יותר

תודה! כבר החכמת אותי מאוד.
ראשית לא תפסתי שargmax מחזיר בעצם את הkey (בערך, באמת זו כתובת כמו שאמרת) ולא את הvalue .
שנית לא הבנתי שהunravel_index עושה פעולה הפוכה, ומהסיבה הפשוטה שלא הבנתי שהארגומנט המתקבל הוא כתובת בזיכרון ולא ערך.

אגב, אם תעשה גוגל על הפונקציה תראה שיש לא מעט נסיונות להסביר אותה בצורה בהירה - אבל אף אחד לא עשה את זה קצר וברור כמוך! (טוב, גם האנגלית קצת הפריעה).

אז בעיקרון יש לי את ההבנה עכשיו מה קורה ואני יכול להתחיל לשבור את הראש איך לממש בJS, אבל כמובן שאם יש משהו מוכן שיחסוך לי את זה - מצויין.
אגב יש ספריות numpy לjs, לא מלאות כמובן. בכל שאר הפעולות שעשיתי על הtile הזה הסתדרתי בלעדיהם כי js נותן מספיק אפשרויות, אבל פה יתכן שהפתרון נעוץ בשימוש בספריה הזו. (את הפונקציות הספציפיות האלו היא לא מספקת).

[OdedDvir]

אז ככה:
אודה שלא התעמקתי עד הסוף, אבל כפי הבנתי הפונקציה ממירה אינדקס לינארי לאינדקס N מימדי, בהנתן גודל המימדים הרצוי.

אני אנסה להמחיש על ידי דוגמא:

נניח שאני רוצה לבנות בנין הדומה למבנה קוביה הונגרית, מימדי הקוביה הן 3x3x3.
אם כן, הבניין יכיל 3 קומות ובכל קומה 9 דירות: 3 לאורך ו-3 לרוחב. סה"כ 27 דירות.

אני רוצה לתת מספר לכל דירה.
אני אתחיל בסריקה קומה אחר קומה מ-1 עד 3, ובכל קומה אני אסרוק את הדירות שורה שורה, בכל פעם אני אתן מספר עוקב מ-1 עד 27.
(למעשה, מספרי הקומות הן 0 עד 2 ומספרי הדירות יהיו 0-26. למה? כי מתכנתים אמיתיים לא סופרים מ-1...)

בוא נראה, מה האינדקס של כל דירה? הוא תלת מימדי [x,y,z]
X – קומה
Y – שורה
Z - טור

מספר דירה	אינדקס
0	[0,0,0]
1	[0,0,1]
2	[0,0,2]
3	[0,1,0]
4	[0,1,1]
5	[0,1,2]

כעת אני אשאל: היכן נמצאת דירה מספר 12 בקוביה? האינדקס הלינארי של הדירה הוא 12, אבל מה האינדקס התלת מימדי שלה?

נכון, היא בקומה השניה (1) בשורה השניה (1) ובטור הראשון (0)
כלומר באינדקס [1,1,0]
(שים לב שוב שהיא הדירה ה-13 כי מתחילים מ-0...)

הפונקציה unravel_index מבצעת את הפעולה שעשיתי למעלה: היא מקבלת שני ארגומנטים, א. האינדקס הלינארי, ב. מימדי התחום
ומחזירה את האינדקס ה-N מימדי.

בדוגמא שלנו, הקריאה

unravel_index(12,(3,3,3))

אמורה להחזיר את האינדקס התלת מימדי: (1,1,0)

[davidnead]

@odeddvir אמר בnp.unravel_index בjs:

אז ככה:
אודה שלא התעמקתי עד הסוף, אבל כפי הבנתי הפונקציה ממירה אינדקס לינארי לאינדקס N מימדי, בהנתן גודל המימדים הרצוי.

אני אנסה להמחיש על ידי דוגמא:

נניח שאני רוצה לבנות בנין הדומה למבנה קוביה הונגרית, מימדי הקוביה הן 3x3x3.
אם כן, הבניין יכיל 3 קומות ובכל קומה 9 דירות: 3 לאורך ו-3 לרוחב. סה"כ 27 דירות.

אני רוצה לתת מספר לכל דירה.
אני אתחיל בסריקה קומה אחר קומה מ-1 עד 3, ובכל קומה אני אסרוק את הדירות שורה שורה, בכל פעם אני אתן מספר עוקב מ-1 עד 27.
(למעשה, מספרי הקומות הן 0 עד 2 ומספרי הדירות יהיו 0-26. למה? כי מתכנתים אמיתיים לא סופרים מ-1...)

בוא נראה, מה האינדקס של כל דירה? הוא תלת מימדי [x,y,z]
X – קומה
Y – שורה
Z - טור

מספר דירה	אינדקס
0	[0,0,0]
1	[0,0,1]
2	[0,0,2]
3	[0,1,0]
4	[0,1,1]
5	[0,1,2]

כעת אני אשאל: היכן נמצאת דירה מספר 12 בקוביה? האינדקס הלינארי של הדירה הוא 12, אבל מה האינדקס התלת מימדי שלה?

נכון, היא בקומה השניה (1) בשורה השניה (1) ובטור הראשון (0)
כלומר באינדקס [1,1,0]
(שים לב שוב שהיא הדירה ה-13 כי מתחילים מ-0...)

הפונקציה unravel_index מבצעת את הפעולה שעשיתי למעלה: היא מקבלת שני ארגומנטים, א. האינדקס הלינארי, ב. מימדי התחום
ומחזירה את האינדקס ה-N מימדי.

בדוגמא שלנו, הקריאה

unravel_index(12,(3,3,3))

אמורה להחזיר את האינדקס התלת מימדי: (1,1,0)

תודה רבה! הסבר מושקע, וברור. אחרי שהבנתי את יוסי זה חידד בצורה פשוטה עוד יותר. אינדקס לינארי לעומד אינדקס n-מימדי.

[OdedDvir]

@davidnead אם מדובר תמיד במערך דו מימדי, אפשר על ידי מניפולציה פשוטה של חילוק שלם ומודולוס לקבל את האינדקסים, בלי צורך בפונקציה המורכבת הנ"ל.
אבל עדיין לא נחה דעתי ממה שכתבת:

ואם אני מדפיס את אותה שורה לעיל ושם בה את המספר הזה (הלא סביר) במקום הפונקציה שיוצרת אותו - אני מקבל שגיאה.

[davidnead]

@odeddvir אמר בnp.unravel_index בjs:

@davidnead אם מדובר תמיד במערך דו מימדי, אפשר על ידי מניפולציה פשוטה של חילוק שלם ומודולוס לקבל את האינדקסים, בלי צורך בפונקציה המורכבת הנ"ל.
אבל עדיין לא נחה דעתי ממה שכתבת:

ואם אני מדפיס את אותה שורה לעיל ושם בה את המספר הזה (הלא סביר) במקום הפונקציה שיוצרת אותו - אני מקבל שגיאה.

השגיאה - לא מצליח לשחזר אותה. כנראה היה ממשהו שלא הבנתי מה אני עושה.

חילוק ומודולוס-אני בדיוק מנסה לעשות את זה כעת.

[davidnead]

אז הנה המימוש לכל השורה השלמה הנ"ל. למען הפשטות הוא מתאים למערך דו-מימדי כי זה מה שאני צריך.
כ"כ לא טיפלתי בביצועים.
אני מניח שהחוזק של הפונקציות המובנות הנ"ל זה הטיפול במימדים שונים, וכן ביצועים.

        let maxarg = 0, max = 0
        tile.forEach((t, i) => {
            return t.reduce((p, c, ii) => {
                if (c > max) {
                    max = c
                    maxarg = (i * t.length) + ii;
                }
                return c
            })
        })

        const unravel_index = (arr, indices) => {
            const shape = [arr.length, arr[0].length];
            const [x, y] = [indices % shape[1], (indices - (indices % shape[1])) / shape[1]]
            return { x, y }
        }
        const { x, y } = unravel_index(tile, maxarg);

[davidnead]

אם כבר יש לי עוד בעיה עם שורה בפייתון. אין ספק שלפייתון יש כוח מדהים לעשות המון בשורה אחת. אבל לי שאיני מנוסה בפייתון וצריך לשכתב משם כרגע אלוגריתם מסויים - זה סיפור מההפטרה.
לא נשמע לי לפתוח עוד נושא בשביל זה אז אני מכניס את זה פה:
זו השורה:

tile[i*x_size:(i+1)*x_size, j*x_size:(j+1)*x_size] = el

הtile הוא מערך עם shape של (7200,7200), בעוד הel הוא מערך עם shape של (3600,3600).

יש פה איזושהי השמה דו-מימדית אל תוך טווחים מסויימים (המוגדרים בסלייס ע"י הנקודותיים) בתוך הtile.

אני מבין שטווחים מסוימים בtile משתנים באיזושהי התאמה יחסית לel, אבל התאמה של ממש אין כאן בגלל הגודל השונה של המערכים.
אז מה בדיוק הלוגיקה כאן?
אני רואה שגם אי אפשר לשים כל מערך דו-מימדי, לא כל shape עובר, כנראה צריך להתחלק איכשהו (כמו בדוגמה, 3600 זה חצי מ7200). אבל מה תכל'ס, איזו תוצאה זה נותן?

[yossiz]

@davidnead אמר בnp.unravel_index בjs:

לא נשמע לי לפתוח עוד נושא בשביל זה

אולי כן כדאי. ר' @dovid בד"כ מעדיף לפתוח נושאים חופשי, זה לא עולה כסף.

לעצם השאלה:
כדאי לקרוא דף זה: https://numpy.org/doc/stable/user/basics.indexing.html

לנתח את השורה שהבאת:
הצד הימני של ההשמה לוקח

• בציר Y (זה החלק של האינדקס עד ה-,) :
  נתח מ-i*x_size עד (i+1)*x_size

• בציר X (זה החלק שאחרי ה-,) :
  נתח מ-j*x_size עד (j+1)*x_size

יוצא שיש לך חלון לתוך הדאטה בצורה של ריבוע בגודל x_size שהפינה השמאלית עליונה שלו זה במיקום i*x_size, j*xsize

הצד הימני של ההשמה מכניס לתוך חלון זה את הערכים של el. אם הבנתי נכון, יוצא לי שהשמה זו חייבת שה-shape של el יהיה זהה ל-shape של החלון שחצבת ב-tile
אחרת (אם ה-shapes לא מתאימים) תקבל שגיאה כזו:
ValueError: could not broadcast input array from shape (n,n) into shape (n,n)

[davidnead]

וואו! תודה רבה. ההסברים שלך בהירים ואתה גם טורח עליהם להגיש אותם היטב.
בהתחלה הייתי בטוח שפיספסת את נקודת השאלה, עד שתפסתי שאני פיספסתי את הנקודה בתשובה:

אם הבנתי נכון, יוצא לי שהשמה זו חייבת שה-shape של el יהיה זהה ל-shape של החלון שחצבת ב-tile

בקיצור לא צריך להוית קשר בין הצורה של המערך הימני והשמאלי, אך צריך להיות זהות מוחלטת בין הצורה של המערך הימני לצורה של החיתוך שאליו אני מציב את הנתונים. הגיוני.

כללית, ברגע שאתה חושב על זה במונחים של טבלאות וריבועים (רב-מימדי) זה הרבה יותר קל. זו לא חשיבה שאני מתורגל בה.