תחומים - פורום חרדי מקצועי

@yossiz כתב בעזרה בהבנת קוד פייתון (NCLS):

@davidnead נראה לי שהסדר של התוצאה זה השלכה של צורת המימוש של מבנה הנתונים ואלגוריתם החיפוש, כרגע לא צללתי לעומק הדברים...

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

@yossiz כתב בעזרה בהבנת קוד פייתון (NCLS):

@davidnead נראה לי שהסדר של התוצאה זה השלכה של צורת המימוש של מבנה הנתונים ואלגוריתם החיפוש, כרגע לא צללתי לעומק הדברים...

תודה! אין כמוך.

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

כעת ברור יותר. יש סך הכל 4 חפיפות. 3 הטווחים של הרשימה הראשונה (ID 21,11,10) חופפים לטווח הראשון של הרשימה השניה (ID 40. כלומר 40,40,40). בנוסף, הטווח האמצעי של הרשימה הראשונה (ID 11) חופף את הטווח האחרון של הראשוימה השניה (ID41). וההשערה שלך לגבי עד ולא עד בכלל - בטלה.

הדבר האחרון שלא מובן זה הסדר של התוצאה. הייתי מצפה לסדר כזה:
40,40,40,41
21,11,10,11

במקום זה קיבלנו:
40,40,40,41
10,11,21,11
כך שהסדר בו מתבצעות הבדיקות (וממילא הבנה של התוצאות) אינו ברור דיו.

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

    starts = np.array(([8, 5, 3]))
    ends = np.array(([9, 7, 6]))
    indexes = np.array(([21, 11, 10]))
    ncls = NCLS(starts, ends, indexes.astype("int64"))
    starts2 = np.array([1, 6])
    ends2 = np.array([10, 7])
    indexes2 = np.array([40, 41])
    ncls.all_overlaps_both(starts2, ends2, indexes2.astype("int64"))

הפלט של הדוגמה הזו הוא:

(array([40, 40, 40, 41]), array([10, 11, 21, 11]))

כעת אני מנסה להבין. הטווחים של הרשימה הראשונה הם 8-9,5-7,3-6.
הטווחים של הרשימה השניה הם 1-10,6-7.
כל הטווחים של הרשימה הראשונה נכנסים לתוך הטווח של 1-10 (שהאינדקס שלו 40) של הרשימה השניה.
לעומת זאת רק הטווח האחרון של הרשימה השניה (6-7) נכנס בתוך 2 הטווחים הראשונים של הרשימה הראשונה (שהאינדקסים שלהם 10 ו11).
אז אם היית שואל אותי (שכנראה אין לי לא בינה מלאכותית וגם לא שאינה ) הייתי מציע פלט כזה:
40,40,40
21,11
חשבתי גם על אפשרויות נוספות לעשות את זה, אבל אף אחד מהם לא מתאימה לתוצאה הרצויה.
מה פיספסתי?

@yossiz כתב בעזרה בהבנת קוד פייתון (NCLS):

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

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

@yossiz כתב בעזרה בהבנת קוד פייתון (NCLS):

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

בכל זאת ולמורת רוחי הפלט ש-@davidnead הביא סגר לי את הפינה האחרונה שעוד לא הבנתי

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

הבנאי NCLS מקבל רשימה של התחלות של טווחים, רשימה מקבילה של סיומי טווחים, ורשימה מקבילה של מזהים

הפונקציה all_overlaps_both (זה עזר לי ה-AI המטופש להבין...) היא מתודה של מבנה ncls שמקבלת דאטה של רשימת טווחים שנייה והיא מוציאה רשימה של כל הטווחים של שני הצדדים שחופפים אחד את השני

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

@חגי כתב בעזרה בהבנת קוד פייתון (NCLS):

זה עוזר לך? ביקשתי מCHATGPT להסביר את הקוד ולתרגם אותו לJS

what does this code do?

ncls = NCLS(starts, ends, ids.astype("int64"))
starts = np.arange(n)
ends = np.arange(1, n+1)
ids = starts
ids, overlaps = ncls.all_overlaps_both(starts, ends, ids.astype("int64"))

This code appears to be using an object of the NCLS class, which stands for "non-contiguous label-set" and is used to efficiently query overlapping intervals in a sequence.

The NCLS object is constructed using three arrays: starts, ends, and ids. These arrays represent the start and end positions of intervals in the sequence, and a unique identifier for each interval.

The all_overlaps_both method of the NCLS object is then called with the same starts, ends, and ids arrays as arguments. This method returns two arrays: ids and overlaps. The ids array is a subset of the input ids array, containing only the identifiers of the intervals that overlap with at least one other interval. The overlaps array is a boolean array of the same length as the input ids array, where True indicates that the corresponding interval overlaps with at least one other interval and False indicates that it does not.

It's worth noting that the input ids array is cast to the int64 data type before being passed to the NCLS object constructor and the all_overlaps_both method. This is likely because the NCLS class and its methods expect integer values as input.

can you convert that to javascript
Sure! Here is a possible implementation of the NCLS class and the all_overlaps_both method in JavaScript:

class NCLS {
  constructor(starts, ends, ids) {
    // Check that the input arrays have the same length
    if (starts.length !== ends.length || starts.length !== ids.length) {
      throw new Error("Input arrays must have the same length");
    }
    this.starts = starts;
    this.ends = ends;
    this.ids = ids;
  }

  allOverlapsBoth(starts, ends, ids) {
    // Check that the input arrays have the same length
    if (starts.length !== ends.length || starts.length !== ids.length) {
      throw new Error("Input arrays must have the same length");
    }
    const overlaps = new Array(starts.length).fill(false);
    const overlappingIds = [];
    for (let i = 0; i < starts.length; i++) {
      for (let j = 0; j < starts.length; j++) {
        if (i === j) continue; // Don't compare an interval with itself
        if (starts[i] < ends[j] && starts[j] < ends[i]) {
          // The intervals i and j overlap
          overlaps[i] = true;
          overlaps[j] = true;
          if (!overlappingIds.includes(ids[i])) overlappingIds.push(ids[i]);
          if (!overlappingIds.includes(ids[j])) overlappingIds.push(ids[j]);
        }
      }
    }
    return { ids: overlappingIds, overlaps };
  }
}

// Example usage:
const ncls = new NCLS([0, 5, 10], [5, 10, 15], [1, 2, 3]);
const { ids, overlaps } = ncls.allOverlapsBoth([0, 5, 10], [5, 10, 15], [1, 2, 3]);
console.log(ids); // [1, 2, 3]
console.log(overlaps); // [true, true, true]

This implementation creates an NCLS object with three properties: starts, ends, and ids. The allOverlapsBoth method compares each pair of intervals and sets the corresponding element in the overlaps array to true if the intervals overlap. It also adds the identifiers of the overlapping intervals to the overlappingIds array. Finally, the method returns an object with two properties: ids, containing the overlapping identifiers, and overlaps, containing a boolean array indicating which intervals overlap.

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

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

@חגי איזה קטע, כנראה כל עם ישראל מדבר על זה לאחרונה. גם אני בדיוק עלה בדעתי לנסות שם את מזלי, שאלתי שאלה קצת יותר ממוקדת, ואני באמצע לנסות להבין אם התשובה עזרה לי. הנה:
The all_overlaps_both function is a part of the NCLS (Nested Containment List Structures) library in Python. NCLS is a data structure that allows for fast overlap queries between intervals (also known as ranges).

The all_overlaps_both function takes in two NCLS objects and returns a list of tuples, where each tuple represents an overlap between an interval from the first NCLS object and an interval from the second NCLS object. Each tuple contains four elements: the start and end indices of the overlapping interval from the first NCLS object, and the start and end indices of the overlapping interval from the second NCLS object.

For example, if you have two NCLS objects ncls1 and ncls2, you can use the all_overlaps_both function as follows:

Copy code

overlaps = ncls1.all_overlaps_both(ncls2)

The overlaps variable will now contain a list of tuples representing the overlaps between the intervals in ncls1 and ncls2.

It's important to note that the all_overlaps_both function only returns overlaps between intervals that are present in both NCLS objects. If you want to find all overlaps between the intervals in two NCLS objects, regardless of whether the intervals are present in both NCLS objects, you can use the all_overlaps function instead.

@חגי כתב בעזרה בהבנת קוד פייתון (NCLS):

@davidnead
אפשר את הקוד המלא?

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

from ncls import NCLS

import pickle
import pandas as pd
import numpy as np


starts = np.array(list(reversed([3, 5, 8])), dtype=np.int)
ends = np.array(list(reversed([6, 7, 9])), dtype=np.int)
indexes = np.array(list(reversed([0, 1, 2])), dtype=np.int)

# starts = np.array([3, 5, 8], dtype=np.int)
# ends = np.array([6, 7, 9], dtype=np.int)
# indexes = np.array([0, 1, 2], dtype=np.int)

ncls = NCLS(starts, ends, indexes)

starts2 = np.array([1, 6])
ends2 = np.array([10, 7])
indexes2 = np.array([0, 1])

print(ncls.all_overlaps_both(starts2, ends2, indexes2))

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

ncls = NCLS(starts, ends, ids.astype("int64"))
starts = np.arange(n)
ends = np.arange(1, n+1)
ids = starts
ids, overlaps = ncls.all_overlaps_both(starts, ends, ids.astype("int64"))

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

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

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

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

@אוריי כתב בחלום \ אתגר | זיהוי ראשי תיבות של סימני מקורות בקבצי וורד:

@davidnead כתב בחלום \ אתגר | זיהוי ראשי תיבות של סימני מקורות בקבצי וורד:

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

@אוריי כתב בחלום \ אתגר | זיהוי ראשי תיבות של סימני מקורות בקבצי וורד:

לעבור על למעלה מכמה מיליוני מילים ואין הצר שווה ...

השאלה כמה חשוב לך המטרה ואתה מוכן להשקיע בשבילה.

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

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

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

אני מצאתי את המודול הזה כנוח ויעיל ביותר:
https://www.npmjs.com/package/gematriya

פשוט ויעיל לגימטריא של מספרים ושנים.

לפי מה שכתוב שם זה קשור לHEBCAL באיזושהי צורה, אבל תכל'ס זה לא כלול בחבילה המודרנית שלהם, יש שם משהו הרבה פחות טוב.

@yossiz אמר בהרצת פרוייקט פייתון מnodejs:

@davidnead אני לא חושב שזה כל כך בעייתי כמו שאתה מתאר
הכי קל, והדבר שאתה מן הסתם הכי מכיר, זה לעשות שרת flask פשוט ביותר ולשלוח לו את הבקשות דרך localhost

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

מן הסתם יש דרכים קלילים יותר דרך pipe אבל עם סיריאליזציה שתדאג שהבקשות והתשובות לא יתערבבו (אולי לא מתאים, תלוי מה בדיוק הסיטואציה, ומה המקסימום זמן שאורך כל בקשה)

זהו שאני לא מעלה דעתי איך לעשות את הסיראליזציה הזו כמו שצריך, ובכלל לא מכיר את הדרכים הקלילות הללו.

עריכה: נראה לי שהכי מתאים לכזה התקשרות בין תהליכים הוא unix domain socket אבל אני לא יודע מה המצב של זה בווינדוס, נראה לי שבעקרון flask יודע להאזין על unix socket, וזה מוריד כל התקורה של TCP/IP

טוב, כאן כבר איבדתי אותך.

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

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

@yossiz אמר בהרצת פרוייקט פייתון מnodejs:

@davidnead סליחה על ההתווכחות שאולי לא עוזר לך כלל, אבל הבדיקה שעשית לא מצביע על כך שזה בעיית ה-venv אלא שיש תהליך איטי לפני הרצת השורה הראשונה של פייתון שכתבת, זה יכול להיות טעינת ספריות וכדומה

בכל מקרה, השאלה שלך עומדת, איך מריצים פייתון מנוד בצורה יעילה

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

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

@yossiz אני לא בדיוק יודע. לכאורה אתה צודק. בפועל סקריפט שלוקח בפייתוח פחות משניה לוקח 3 שניות בצורת ההרצה הבאה:

  let cmd = `cd ${pyPath}  && venv\\scripts\\activate && python script.py arg1 arg2 `;
  stdout = await exec(cmd);

בדקתי את זה ע"י שעשיתי טיימר פנימי בתוך הפייתון מתחילת עד סוף פעולת הסקריפט והדפסתי אותו לstdout שקראת בJS תוך הפעלת טיימר מקביל בJS.

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

שלום
אני רוצה להפעיל סקריפט פייתון מNODEJS. מה הדרך היעילה לעשות את זה?
יצויין שהפרוייקט זקוק לVENV.
בתור התחלה פחות הכנתי שרשור של פקודות שורת פקודה שנכנסות לתיקיה הנכונה, מפעילים את הVENV ואז מפעילים את הסקריפט, והפעלתי אותם באמצעות child_process.exec. אבל אני חושש שזה מאוד איטי.

הכי טוב אם יכולתי איכשהו לקמפל את הפייתון ולהשתמש בפונקציות ממנו כAPI, אבל זה נשמע לי דורש עבודה רצינית.
אם לא, אז אולי יעזור גם לקמפל את הפייתון ולהריץ אותו כEXE, כי נראה לי שמה שלוקח את זהמן זה הפעלת הסביבה הוירטואלית כל פעם. אבל איך מקפלים פייתון שתלוי בVENV?
דרך שלישית שחשבתי היא להפעיל תהליך מNODEJS שמפעיל את הסביבה וירטואלית פעם אחת ואז כל פעם להשתמש באותו תהליך לקרוא לסקריפט, אבל אין לי מושג איך עושים את זה, אם אפשרי. כל זה בהנחה שמה שגוזל את הזמן זה הפעלת הVENV (מה שבטוח שהסקריפט נטו לוקח הרבה פחות מהפרוצדורה ברוטו, בדקתי)

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