שדות קרינה עצביים, הידועים בשפת העם NeRFs היכו את העולם בסערה בשנת 2020, פורסם לצד העיתון "NeRF: ייצוג סצינות כשדות זוהר עצבי לסינתזת מבט", והם עדיין אבן הפינה של סינתזה באיכות גבוהה של תצוגות חדשות, בהינתן תמונות דלילות ומצבי מצלמה.
מאז, הם מצאו יישומים רבים, אבל כנראה בעיקר במידול נפחי גיאו-מרחבי, כאשר חברות כמו גוגל מסתמכות על NeRFs ליצירת מבנים תלת-ממדיים של מבנים ואתרי מורשת מזוויות שונות של תמונות לווין, וחברות המתמחות בביצוע שחזור תלת-ממדי. דיגיטציה של אתרי תרבות ידועים.
במדריך זה, נאמן מודל של שדה קרינה עצבית (NeRF) על מערך הנתונים המקורי של Tiny NeRF, באמצעות TensorFlow/Keras ו-DeepVision, כדי לבצע סינתזת תצוגה חדשה/שחזור תלת-ממד.
תוך שעה אחת, במכונה מסחרית, תציג תצוגות חדשות של תמונות ממערך הנתונים של TinyNeRF:
סינתזת נוף רומן ושדות זוהר עצבי
סעיף זה מספק תקציר/מבוא מופשט לאופן שבו פועלים שדות קרינה עצבית, אך ייתכן שייקח קצת זמן כדי לעכל באופן אינטואיטיבי באמת איך הם עובדים אם אתה חדש בתחום.
הערה: המאמר המקורי כמו גם וידאו חינוכי וגרפיקה הקשורים אליו הם חומרי למידה נהדרים. אם אתה מעוניין להבין את הרעיון הבסיסי של שדות זוהר שעליהם מסתמכים NeRFs כדי לייצג סצנה, ה ערך בוויקיפדיה עבור "שדות אור" מספק הקדמה נהדרת, אך ניתן לסכם אותם ברמה גבוהה כמו
"שדה האור הוא פונקציה וקטורית המתארת את כמות האור הזורמת לכל כיוון דרך כל נקודה בחלל".
NeRFs משמשים עבור סינתזה של נוף חדש - יצירת תצוגות חדשות של אובייקטים ותמונות, בהינתן כמה תצוגות. למעשה, אתה יכול לחשוב על סינתזת תצוגה חדשה כהמרת דו-ממד->תלת-ממד, וקיימות גישות רבות לפתרון בעיה זו, חלקן מוצלחות יותר מאחרות.
מבחינה היסטורית בעיה מאתגרת, הפתרון המוצע על ידי NeRFs הוא פשוט ביותר אך מניב תוצאות מתקדמות ביותר, ומייצר תמונות באיכות גבוהה מאוד מזוויות חדשות:
זה, מטבע הדברים, מיקם אותם כגישה בסיסית לפתרון סינתזה של השקפות חדשות, עם מאמרים רבים לאחר מכן שחקרו, התאימו ושפרו את הרעיונות הקיימים בו.
עֵצָה: השמיים אתר אינטרנט שוחרר לצד העיתון מכיל תצוגה מדהימה של השיטה ותוצאותיה, ו סרטון חינוכי זה בונה אינטואיציה טובה לאופן פעולת הרשתות הללו שוחרר באופן רשמי.
ניתן לסכם את הצינור מנתונים לתוצאות כך:
איפה הרשת העצבית לומדת מתמונות דלילות שנוצרות באופן סינתטי קרניים שמוקרנים ונדגמים במרווחי זמן קבועים. התמונות ממוקמות בחלל בהתחשב במטא נתונים על התמונות, כגון מיקומי המצלמה כאשר התמונות צולמו. בגלל זה - אתה לא יכול להזין סתם תמונות, ו לדרוש מיקומי מצלמה כדי להיות מסוגלים למקם במדויק את התמונות בחלל עבור הקרניים כדי ליצור קבוצה ניתנת להבנה של נקודות. הנקודות שנדגמו יוצרות קבוצה תלת-ממדית של נקודות המייצגות את הסצנה הנפחית:
הרשת העצבית מתקרבת ל-a פונקציית סצנה נפחית – ערכי RGB וצפיפות (σ) של סצנה. למעשה, אנו מאמנים את הרשת ל לְשַׁנֵן הצבע והצפיפות של כל נקודת קלט, על מנת להיות מסוגל לשחזר את התמונות מנקודות מבט חדשות. עם זאת נאמר - NeRFs אינם מאומנים על סט של תמונות ויכולים לבצע אקסטרפולציה לתמונות חדשות. NeRFs מאומנים לקודד סצנה, ולאחר מכן משמשים רק לסצנה אחת, שכן משקלי הרשת עצמה מייצגים את הסצנה.
זהו ה"חיסרון" העיקרי של NeRFs - אתה צריך לאמן רשת עבור כל סצנה שאתה רוצה לקודד, ותהליך האימון הוא איטי במקצת ודורש הרבה זיכרון לכניסות גדולות. שיפורים בזמן האימון הם תחום מחקר, עם טכניקות חדשות כגון "אופטימיזציה ישירה של רשת ווקסל" המשפרים באופן משמעותי את זמן האימון מבלי להתפשר על איכות התמונה בתהליך.
שדות קרינה עצבית ב-DeepVision ו-TensorFlow
יישומי NeRF יכולים להיות מעט מרתיעים עבור אלה שחדשים בעיבוד נפחי, ומאגרי הקוד כוללים בדרך כלל שיטות עוזרות רבות להתמודדות עם נתונים נפחיים, שעלולים להיראות לא אינטואיטיביים לחלקם. DeepVision היא ספריית ראייה ממוחשבת חדשנית שמטרתה לאחד ראייה ממוחשבת תחת API משותף, עם קצה אחורי הניתנים להחלפה (TensorFlow ו-PyTorch), המרות משקל אוטומטיות בין דגמים ומודלים עם יישומים זהים על פני מסגרות אחוריות.
כדי להוריד את מחסום הכניסה, DeepVision מציעה יישום פשוט אך נאמן למקור של דגמי Neural Radiance Field, עם הגדרות מרובות כדי להכיל מכונות חזקות יותר ופחות עם הגדרות חומרה שונות:
NeRFTiny
NeRFSmall
NeRFMedium
NeRF
NeRFLarge
שני פרמטרים משמשים ליצירת הגדרות אלה - width
ו depth
. מאז NeRFs הם, בעצם, רק מודל MLP המורכב tf.keras.layers.Dense()
שכבות (עם שרשור בודד בין שכבות), ה depth
מייצג ישירות את המספר של Dense
שכבות, תוך כדי width
מייצג את מספר היחידות בשימוש בכל אחת מהן.
NeRF
מתאימה להגדרה המשמשת בנייר המקורי, אך ייתכן שיהיה קשה להפעיל אותו במכונות מקומיות מסוימות, ובמקרה זה, NeRFMedium
מספק ביצועים דומים מאוד עם דרישות זיכרון קטנות יותר.
בואו נתחיל להתקין עם DeepVision pip
:
$ pip install deepvision-toolkit
יצירת מודל קלה כמו:
import deepvision
model = deepvision.models.NeRFMedium(input_shape=(num_pos, input_features), backend='tensorflow') model.summary()
הדגם עצמו פשוט ביותר:
Model: "ne_rftf"
__________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_1 (InputLayer) [(None, 640000, 195 0 [] )] dense (Dense) (None, 640000, 128) 25088 ['input_1[0][0]'] dense_1 (Dense) (None, 640000, 128) 16512 ['dense[0][0]'] dense_2 (Dense) (None, 640000, 128) 16512 ['dense_1[0][0]'] dense_3 (Dense) (None, 640000, 128) 16512 ['dense_2[0][0]'] dense_4 (Dense) (None, 640000, 128) 16512 ['dense_3[0][0]'] concatenate (Concatenate) (None, 640000, 323) 0 ['dense_4[0][0]', 'input_1[0][0]'] dense_5 (Dense) (None, 640000, 128) 41472 ['concatenate[0][0]'] dense_6 (Dense) (None, 640000, 4) 516 ['dense_5[0][0]'] ==================================================================================================
Total params: 133,128
Trainable params: 133,124
Non-trainable params: 4
__________________________________________________________________________________________________
עיין במדריך המעשי והמעשי שלנו ללימוד Git, עם שיטות עבודה מומלצות, סטנדרטים מקובלים בתעשייה ודף רמאות כלול. תפסיק לגוגל פקודות Git ולמעשה ללמוד זה!
נסקור מקרוב כיצד להתמודד עם התפוקות של הדגם וכיצד לעבד את התמונות המופקות על ידי משקלי הדגם, בעוד רגע.
טעינת ערכת הנתונים של TinyNeRF
מכיוון ש-Nerfs יכול להיות מעט יקר לאימון על תמונות קלט גדולות יותר, הם שוחררו עם מערך נתונים קטן של 100×100 תמונות, שכונה TinyNeRF כדי להקל על בדיקות ואיטרציות. לאחר מכן, זה הפך למערך נתונים קלאסי לניסוי NeRFs על וכניסה לתחום, בדומה לאופן שבו MNIST הפך ל"Hello World" של זיהוי ספרות.
מערך הנתונים זמין כ- .npz
קובץ, ומכיל תמונות, נקודות מוקד (המשמשות לנורמליזציה) ותנוחות מצלמה, וניתן להשיג מהדורת הקוד הרשמית:
import requests
import numpy as np
import matplotlib.pyplot as plt url = "https://people.eecs.berkeley.edu/~bmild/nerf/tiny_nerf_data.npz"
save_path = 'tiny_nerf.npz' file_data = requests.get(url).content
with open(save_path, "wb") as file: file.write(file_data) data = np.load(save_path) images, poses, focal = data["images"], data["poses"], data["focal"] print(images.shape) print(poses.shape) print(focal)
יש 106 תמונות, 100×100 כל אחת, עם 3 ערוצים (RGB). כל התמונות הן של דחפור לגו קטן. בואו נתווה את חמש התמונות הראשונות:
fig, ax = plt.subplots(1, 5, figsize=(20, 12))
for i in range(5): ax[i].imshow(images[i])
השמיים עמדות המצלמה המסופק במערך הנתונים חיוניים ליכולת לשחזר את החלל בו צולמו התמונות, מה שמאפשר לנו להקרין קרניים דרך התמונות וליצור חלל נפחי עם הנקודות שנדגמו בכל הקרנה.
עם זאת, מכיוון שמערך נתונים זה דורש הכנה רבה לשלב ההדרכה - DeepVision מציעה א load_tiny_nerf()
טוען נתונים, שיבצע עבורך את ההכנה, עם אופציונלי validation_split
, pos_embed
ו num_ray_samples
, ומחזיר וניל tf.data.Dataset
שאתה יכול ליצור צינורות בעלי ביצועים גבוהים עם:
import deepvision train_ds, valid_ds = deepvision.datasets.load_tiny_nerf(pos_embed=16, num_ray_samples=32, save_path='tiny_nerf.npz', validation_split=0.2, backend='tensorflow')
אתה בהחלט לא צריך ליצור ערכת אימות כאן, מכיוון שהנקודה היא is כדי להתאים יתר על המידה ולשנן את התמונות, וערכת האימות כאן נוצרת בעיקר כבדיקת שפיות.
בואו נסתכל על האורך וצורות הקלט במערך ההדרכה:
print('Train dataset length:', len(train_ds))
print(train_ds)
זו התוצאה:
Train dataset length: 84
<ZipDataset element_spec=(TensorSpec(shape=(100, 100, 3), dtype=tf.float32, name=None), (TensorSpec(shape=(320000, 99), dtype=tf.float32, name=None), TensorSpec(shape=(100, 100, 32), dtype=tf.float32, name=None)))>
השמיים pos_embed
ארגומנט קובע את המספר של הטבעות מיקום משמש להמרת קואורדינטות 5D (x, y, z וזוויות צפייה תטא ו-פי). ההטבעות המיקוםיות היו מכריע כדי שהרשת תוכל לייצג פונקציות בתדר גבוה יותר, מה שהיה "מרכיב חסר" בהפיכת טכניקה מסוג זה לעבודה בעבר, מכיוון שרשתות נאבקו להעריך פונקציות המייצגות שונות בתדר גבוה בצבע ובגיאומטריה, בשל הטייתן ללימוד פונקציות בתדר נמוך במקום זאת:
השמיים num_ray_samples
מייצג את מספר הדגימות שנלקחו לאורכה של כל קרן המוקרנת בתמונה.
באופן טבעי, ככל שתשתמש בהטמעות מיקומיות ודגימות קרניים, כך הרזולוציה של הסצנה הנפחית שאתה מתקרב תהיה גבוהה יותר, ולפיכך, התמונות הסופיות יהיו מפורטות יותר, במחיר של עלויות חישוב גבוהות יותר.
אימון NeRF עם TensorFlow/Keras ו-DeepVision
בואו נסתכל על דוגמה מקצה לקצה של טעינת הנתונים, הכנת מערך הנתונים, יצירת מודל והכשרתו באמצעות DeepVision והאקולוגית TensorFlow/Keras:
import deepvision
from deepvision.datasets import load_tiny_nerf
import tensorflow as tf config = { 'img_height': 100, 'img_width': 100, 'pos_embed': 32, 'num_ray_samples': 64, 'batch_size': 1
} num_pos = config['img_height'] * config['img_width'] * config['num_ray_samples']
input_features = 6 * config['pos_embed'] + 3 train_ds, valid_ds = load_tiny_nerf(pos_embed=config['pos_embed'], num_ray_samples=config['num_ray_samples'], save_path='tiny_nerf.npz', validation_split=0.2, backend='tensorflow') train_ds = train_ds.batch(config['batch_size']).prefetch(tf.data.AUTOTUNE)
valid_ds = valid_ds.batch(config['batch_size']).prefetch(tf.data.AUTOTUNE) model = deepvision.models.NeRFMedium(input_shape=(num_pos, input_features), backend='tensorflow') model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3), loss=tf.keras.losses.MeanSquaredError()) callbacks = [tf.keras.callbacks.ReduceLROnPlateau()] history = model.fit(train_ds, epochs=50, validation_data=valid_ds, callbacks=callbacks)
ב-Nvidia GTX1660Super, אימון עם 32 הטמעות מיקום ו-64 דגימות קרניים לוקח ~1 דקות לכל תקופה, אבל הגדרות קטנות יותר, כגון 8-16 הטמעות מיקום ו-32 דגימות קרניים עשויות להימשך עד ~7 שניות לכל תקופה:
Epoch 1/50
84/84 [==============================] - 65s 746ms/step - loss: 0.0603 - psnr: 12.6432 - val_loss: 0.0455 - val_psnr: 13.7601 - lr: 0.0010
...
Epoch 50/50
84/84 [==============================] - 55s 658ms/step - loss: 0.0039 - psnr: 24.1984 - val_loss: 0.0043 - val_psnr: 23.8576 - lr: 0.0010
לאחר כשעה בודדת, ב-GPU מסחרי בודד, הדגם משיג ~24 PSNR. העניין עם NeRFs הוא - ככל שתתאמנו זמן רב יותר, כך זה יתקרב לייצוגים של התמונות המקוריות, כלומר, בדרך כלל תראה את המדדים גדלים עם הזמן ככל שאתה מתאמן יותר. זה עוזר שיש א ReduceLROnPlateau
התקשרות חוזרת לטיפול בהפחתת קצב הלמידה כדי לכוונן את התוצאות לקראת סוף האימון.
המודל מדווח על שני מדדים - loss
ו psnr
. ההפסד הוא השגיאה הממוצעת בריבוע עבור כל פיקסל, ופועל כפונקציית הפסד נהדרת עבור NeRFs, אך קשה לפרש.
יחס אות לרעש שיא (PSNR) הוא היחס בין האות (הספק המרבי של אות) לבין הרעש (הספק של הרעש שמשחית את נאמנות האות) אשר משפיל את התמונה. יחס אות לרעש שיא יכול לשמש כ איכות תמונה מדד, והוא מאוד אינטואיטיבי לפרש עבור בני אדם.
כבר ב-PSNR של 24, התמונות הופכות ברורות למדי, ו-Nerfs יכולים להגיע ל-PSNR של למעלה מ-40 ב-TinyNeRF בהינתן מספיק זמן אימון.
הדמיית פלטים
הרשת מוציאה טנסור של צורה [batch_size, 640000, 4]
כאשר הערוצים מייצגים RGB וצפיפות, ו-640000 הנקודות מקודדות את הסצנה. כדי לייצג את אלה כתמונות, נרצה לעצב מחדש את הטנזור לצורה של (batch_size, img_height, img_width, num_ray_samples, 4)
, ולאחר מכן לנתח את 4 הערוצים לתוך RGB ו-sigma ולעבד אותם לתמונה (ואופציונלי, מפת עומק/דיוק).
באופן ספציפי, ערוצי RGB מועברים דרך a סיגמואיד הפעלה, בעוד ערוץ הסיגמא מועבר דרך a ReLU הפעלה, לפני עיבוד נוסף וצמצום לטנסור של צורה (batch_size, img_height, img_width, rgb_channels)
, ושני טנסורים של צורה (batch_size, img_height, img_width, depth_channel)
ו (batch_size, img_height, img_width, accuracy)
.
כדי להקל על תהליך זה, אנו יכולים להשתמש ב- nerf_render_image_and_depth_tf()
פונקציה מ volumetric_utils
, שמקבל את המודל לניבוי RGB וסיגמא מכניסות, ומחזיר אצווה של תמונות, מפות עומק ומפות דיוק:
import matplotlib.pyplot as plt
from deepvision.models.volumetric.volumetric_utils import nerf_render_image_and_depth_tf for batch in train_ds.take(5): (images, rays) = batch (rays_flat, t_vals) = rays image_batch, depth_maps, _ = nerf_render_image_and_depth_tf(model=model, rays_flat=rays_flat, t_vals=t_vals, img_height=config['img_height'], img_width=config['img_width'], num_ray_samples=config['num_ray_samples']) fig, ax = plt.subplots(1, 2) ax[0].imshow(tf.squeeze(image_batch[0])) ax[1].imshow(tf.squeeze(depth_maps[0]))
כאן, אנו משרטטים 5 קבוצות (כל אחת עם תמונה אחת) ומפות העומק שלהן.
במהלך האימון, המודל עצמו מסתמך על nerf_render_image_and_depth_tf()
פונקציה להמרת תחזיות לתמונות ולחשב שגיאה בריבוע ממוצעת ו-PSNR עבור התוצאות. הפעלת קוד זה מביאה ל:
סיכום
במדריך זה – ריכזנו כמה ממרכיבי המפתח של שדות קרינה עצבית, כהקדמה קצרה לנושא, ולאחר מכן טעינה והכנה של מערך הנתונים TinyNeRF ב-TensorFlow, באמצעות tf.data
, והכשרת מודל NeRF עם המערכות האקולוגיות של Keras ו-DeepVision.
- הפצת תוכן ויחסי ציבור מופעל על ידי SEO. קבל הגברה היום.
- Platoblockchain. Web3 Metaverse Intelligence. ידע מוגבר. גישה כאן.
- מקור: https://stackabuse.com/training-a-neural-radiance-field-nerf-model-with-keras-tensorflow-and-deepvision/
- 1
- 100
- 1984
- 2020
- 3d
- 7
- 84
- 9
- a
- יכול
- אודות
- בהחלט
- מקבל
- דיוק
- במדויק
- משיגה
- לרוחב
- הפעלה
- למעשה
- קדימה
- מטרות
- ערני
- תעשיות
- מאפשר
- בַּצַד
- מדהים
- כמות
- ו
- API
- יישומים
- גישה
- גישות
- AREA
- טענה
- אמנות
- המשויך
- מכני עם סלילה אוטומטית
- זמין
- קצה אחורי
- מחסום
- לחבוט
- כי
- להיות
- לפני
- להיות
- ברקלי
- בֵּין
- הטיה
- קצת
- גבול
- בונה
- לחשב
- חדר
- מקרה
- אתגר
- ערוץ
- ערוצים
- לבדוק
- קלאסי
- ברור
- קרוב יותר
- קוד
- צֶבַע
- מסחרי
- Common
- חברות
- המחשב
- ראייה ממוחשבת
- מושג
- מסקנה
- מחובר
- מורכב
- מכיל
- תוכן
- המרה
- המרות
- להמיר
- מתכתב
- עלות
- עלויות
- לִיצוֹר
- נוצר
- יוצרים
- מכריע
- תרבותי
- נתונים
- מערכי נתונים
- עסקה
- התמודדות
- עומק
- מְפוֹרָט
- קשה
- תקציר
- דיגיטציה
- ישיר
- כיוון
- ישירות
- דיבוב
- כל אחד
- קל יותר
- המערכת האקולוגית
- מערכות אקולוגיות
- חינוך
- השפעה
- אלמנטים
- מקצה לקצה
- מספיק
- כניסה
- תקופה
- שגיאה
- מַהוּת
- כל
- דוגמה
- יקר
- היכרות
- למדי
- אופנה
- דיוק
- שדה
- שדות
- שלח
- סופי
- סוף
- ראשון
- זורם
- להתמקד
- בעקבות
- טופס
- מצא
- מסגרות
- תדר
- החל מ-
- לגמרי
- פונקציה
- פונקציות
- נוסף
- נוצר
- יצירת
- לקבל
- Git
- GitHub
- נתן
- Go
- טוב
- GPU
- גרפיקה
- גדול
- רֶשֶׁת
- מדריך
- לטפל
- ידות על
- חומרה
- לעזור
- כאן
- מורשת
- גָבוֹהַ
- תדר גבוה
- ברמה גבוהה
- ביצועים גבוהים
- גבוה יותר
- היסטוריה
- לרחף
- איך
- איך
- HTTPS
- בני אדם
- ICON
- רעיונות
- זהה
- תמונה
- תמונות
- הפעלה
- לשפר
- שיפורים
- שיפור
- in
- לכלול
- כלול
- גדל
- קלט
- להתקין
- במקום
- מעוניין
- מבוא
- אינטואיטיבי
- IT
- איטרציות
- עצמו
- keras
- מפתח
- ידוע
- גָדוֹל
- גדול יותר
- שכבה
- שכבות
- למידה
- אורך
- LG
- סִפְרִיָה
- אוֹר
- שדות אור
- קְצָת
- מטעין
- טוען
- מקומי
- עוד
- נראה
- את
- אבדות
- מכונה
- מכונה
- ראשי
- לעשות
- עשייה
- רב
- מַפָּה
- מפות
- חומרים
- matplotlib
- מקסימום
- משמעות
- זכרון
- מידע נוסף
- שיטה
- שיטות
- מטרי
- מדדים
- חסר
- מודל
- מודלים
- רֶגַע
- יותר
- רוב
- מספר
- מתקרב
- צורך
- Nerf
- רשת
- רשתות
- רשת עצבית
- חדש
- רעש
- רומן
- מספר
- רב
- קהות
- Nvidia
- אובייקטים
- מושג
- המיוחדות שלנו
- רשמי
- רשמית
- ONE
- אופטימיזציה
- להזמין
- מְקוֹרִי
- אחרים
- מאמר
- ניירות
- פרמטרים
- עבר
- עבר
- שִׂיא
- לְבַצֵעַ
- ביצועים
- ביצוע
- שלב
- צינור
- פיקסל
- אפלטון
- מודיעין אפלטון
- אפלטון נתונים
- נקודה
- נקודות
- תנוחות
- עמדה
- מיקום
- עמדות
- כּוֹחַ
- חזק
- מעשי
- לחזות
- התחזיות
- העריכה
- להציג
- בראש ובראשונה
- כנראה
- בעיה
- תהליך
- מעובד
- מיוצר
- פּרוֹיֶקט
- מוקרן
- הקרנה
- מוּצָע
- מספק
- פיטורך
- איכות
- ציון
- יחס
- RAY
- RE
- לְהַגִיעַ
- הכרה
- מופחת
- רגיל
- לשחרר
- שוחרר
- טיוח
- דוחות לדוגמא
- לייצג
- המייצג
- מייצג
- בקשות
- דרישות
- דורש
- מחקר
- החלטה
- תוצאות
- החזרות
- RGB
- טַבַּעַת
- בערך
- הפעלה
- ריצה
- אמר
- סצינה
- סצנות
- סעיף
- סט
- סטים
- התקנה
- Shadow
- צוּרָה
- צורות
- ראווה
- סיגמא
- לאותת
- באופן משמעותי
- דומה
- פָּשׁוּט
- פשוט
- since
- יחיד
- אתרים
- להאט
- קטן
- קטן יותר
- פִּתָרוֹן
- לפתור
- פותר
- כמה
- במידה מסוימת
- מֶרחָב
- מתמחה
- מרובע
- Stackabuse
- תקנים
- מדינה
- עוד
- עצור
- סטורם
- נושא
- לאחר מכן
- כתוצאה מכך
- מוצלח
- כזה
- שסופק
- SVG
- באופן סינתטי
- לקחת
- לוקח
- טכניקות
- tensorflow
- בדיקות
- השמיים
- העולם
- שֶׁלָהֶם
- בו
- תטא
- דבר
- דרך
- זמן
- ל
- סה"כ
- לקראת
- מסחר
- רכבת
- מְאוּמָן
- הדרכה
- לשנות
- מַעֲבָר
- נָכוֹן
- בדרך כלל
- תחת
- בְּסִיסִי
- להבין
- לא אינטואיטיבי
- יחידות
- כתובת האתר
- us
- להשתמש
- אימות
- ערכים
- שונים
- Ve
- וִידֵאוֹ
- לצפיה
- נופים
- חזון
- Voxel
- מִשׁקָל
- אשר
- בזמן
- ויקיפדיה
- יצטרך
- לְלֹא
- תיק עבודות
- עובד
- עוֹלָם
- X
- תשואות
- אתה
- YouTube
- זפירנט