tensorflow:: אופס

העלה חריגה כדי לבטל את התהליך כאשר נקרא.

מחשב את הערך המוחלט של טנזור.

מחזירה את הסכום מבחינת האלמנט של רשימת טנסורים.

מחיל שיפוע על מצבר נתון.

מחזירה את מספר ההדרגות המצטברות במצטברים הנתונים.

מעדכן את המצבר עם ערך חדש עבור global_step.

מחלץ את השיפוע הממוצע ב- ConditionalAccumulator הנתון.

מחשבת acos של x מבחינת אלמנטים.

מחשב קוסינוס היפרבולי הפוך של x מבחינת אלמנט.

מחזירה x + y מבחינת אלמנט.

הוסף N -minibatch SparseTensor ל- SparseTensorsMap , החזר N ידיות.

הוסף את כל טנסור הקלט מבחינת אלמנט.

הוסף SparseTensor למפת SparseTensorsMap מחזיר את הידית שלו.

מחזירה x + y מבחינת אלמנט.

התאם את הניגודיות של תמונה אחת או יותר.

התאם את הגוון של תמונה אחת או יותר.

התאם את הרוויה של תמונה אחת או יותר.

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

יוצר תוויות לדגימת מועמדים עם התפלגות אוניגרמה נלמדת.

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

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

עדכן את '*var' בהתאם לתוכנית adadelta.

עדכן את '*var' בהתאם לתכנית adgrad.

עדכן את '*var' בהתאם לתוכנית adgrad הפרוקסימלית.

עדכן את '*var' לפי אלגוריתם Adam.

עדכן את '*var' בהתאם לעדכון AddSign.

עדכן את '*var' לפי אלגוריתם RMSProp המרוכז.

עדכן את '*var' לפי סכימת Ftrl-proximal.

עדכן את '*var' לפי סכימת Ftrl-proximal.

עדכן את '*var' על ידי הפחתת 'alpha' * 'delta' ממנו.

עדכן את '*var' לפי סכימת המומנטום.

עדכן את '*var' בהתאם לעדכון AddSign.

עדכן את '*var' ו-'*accum' לפי FOBOS עם קצב הלמידה של Adagrad.

עדכן את '*var' בתור אלגוריתם FOBOS עם קצב למידה קבוע.

עדכן את '*var' לפי אלגוריתם RMSProp.

מחזירה את ערך האמת של abs(xy) < סובלנות מבחינת אלמנט.

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

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

ממירה כל ערך בטנזור הנתון למחרוזות.

מחשב את הסינוס ההיפוך הטרינומטרי של x מבחינת אלמנט.

מחשב סינוס היפרבולי הפוך של x מבחינת אלמנט.

טוען שהתנאי הנתון נכון.

עדכן את 'ref' על ידי הקצאת 'ערך' לו.

עדכן את 'ref' על ידי הוספת 'ערך' אליו.

עדכן את 'ref' על ידי הפחתת 'ערך' ממנו.

מחשב את הטנגנס ההופכי הטרינומטרי של x מבחינת אלמנט.

מחשב arctangent של y/x מבחינת אלמנט, תוך כיבוד סימני הטיעונים.

מחשב טנגנס היפרבולי הפוך של x מבחינת אלמנט.

מבצע איגום ממוצע על הקלט.

מבצע איגום ממוצע בתלת מימד על הקלט.

מחשב שיפועים של פונקציית איגום ממוצעת.

מגדיר מחסום שנמשך על פני ביצועי גרפים שונים.

סוגר את המחסום הנתון.

מחשב את מספר האלמנטים הלא שלמים במחסום הנתון.

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

מחשב את מספר האלמנטים השלמים במחסום הנתון.

לוקח את המספר הנתון של אלמנטים שהושלמו ממחסום.

מכפיל פרוסות של שני טנסורים בקבוצות.

מכפיל פרוסות של שני טנסורים בקבוצות.

BatchToSpace עבור טנסור 4-D מסוג T.

BatchToSpace עבור טנסור ND מסוג T.

מחשב את הפונקציה Bessel i0e של x מבחינה אלמנט.

מחשב את הפונקציה Bessel i1e של x מבחינה אלמנט.

חשב את אינטגרל הבטא הבלתי שלם המוסדר \(I_x(a, b)\).

מוסיף bias value .

הפעולה לאחור עבור "BiasAdd" בטנזור "הטיה".

סופר את מספר המופעים של כל ערך במערך שלמים.

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

החזר את הצורה של s0 op s1 עם שידור.

שדר מערך לקבלת צורה תואמת.

מרכזת 'קלט' בהתבסס על 'גבולות'.

העבר x מסוג SrcT ל-y של DstT.

מחזירה את המספר השלם הקטן ביותר מבחינת אלמנט לא פחות מ-x.

בודק טנזור לערכי NaN ו-Inf.

חותך ערכי טנסור למינימום ומקסימום שצוינו.

בוחר בתאוותנות קבוצת משנה של תיבות תוחמות בסדר יורד של הניקוד,.

השווה ערכי input threshold וארוז את הסיביות המתקבלות לתוך uint8 .

ממירה שני מספרים ממשיים למספר מרוכב.

מחשב את הערך המוחלט המורכב של טנזור.

מחשב את המזהים של המיקומים ב- sampled_candidates התואמים ל-true_labels.

משרשרת טנסורים לאורך מימד אחד.

מצבר מותנה לצבירה של שיפועים.

מחזירה את הצימוד המרוכב של מספר מרוכב.

ערבבו מידות של x לפי תמורה וצמידו את התוצאה.

לא עושה כלום.

מחשב קונבולוציה דו-ממדית בהינתן טנסורי קלט 4- input filter .

מחשב את דרגות הפיתול ביחס למסנן.

מחשב את דרגות הקונבולציה ביחס לקלט.

מחשב קונבולוציה תלת-ממדית בהינתן input 5-D filter .

מחשב את הגרדיאנטים של פיתול תלת מימדי ביחס למסנן.

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

מחשבת cos של x מבחינה אלמנט.

מחשב קוסינוס היפרבולי של x מבחינת אלמנט.

מגדיל את 'ref' עד שהוא מגיע ל-'limit'.

מחלץ חיתולים מטנסור תמונת הקלט ומשנה את גודלם.

מחשב את השיפוע של ההפעלה crop_and_resize מול טנסור תיבות הקלט.

מחשב את השיפוע של האופציה crop_and_resize מול טנסור תמונת הקלט.

חשב את תוצר הצלב הזוגי.

חשב את המכפלה המצטברת של הטנזור x לאורך axis .

חשב את הסכום המצטבר של הטנזור x לאורך axis .

מחזירה את אינדקס הממדים בפורמט נתוני היעד בהינתן זה ב.

מחזירה את הווקטור/טנזור המותמר בפורמט נתוני היעד בהינתן.

אופציה של זהות עבור ניפוי שגיאות שיפוע.

אופציה של זהות עבור ניפוי שגיאות שיפוע.

פענוח וחיתוך תמונה מקודדת JPEG לטנזור uint8.

פענוח מחרוזות מקודדות base64 בטוחות באינטרנט.

פענח את המסגרת הראשונה של תמונה מקודדת BMP לטנזור uint8.

המרת רשומות CSV לטנזורים.

דחוס מחרוזות.

פענח את המסגרת/ים של תמונה מקודדת GIF לטנזור uint8.

המר רשומות דוגמה מקודדות JSON למחרוזות חיץ של פרוטוקול בינארי.

פענוח תמונה מקודדת JPEG לטנזור uint8.

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

פענוח תמונה מקודדת PNG לטנזור uint8 או uint16.

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

יוצר עותק של x .

מחק את הטנזור שצוין על ידי הידית שלו בסשן.

DepthToSpace עבור טנסורים מסוג T.

מחשב קונבולוציית עומק דו-ממדית בהינתן input 4-ממד filter .

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

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

הפוך את טנסור 'הקלט' ל-float או bfloat16 Tensor .

הסר ושרשר SparseTensors ממיני-אצט סידורי.

דה-סריאליזציה של אובייקטים SparseTensor .

הורס את המשתנה הזמני ומחזיר את הערך הסופי שלו.

מחזירה טנזור אלכסוני עם ערכי אלכסון נתונים.

מחזירה את החלק האלכסוני של הטנזור.

מחשב את Psi, הנגזרת של Lgamma (לוג הערך המוחלט של.

מחשב את הרחבת גווני האפור של input filter 4-D ומסנן 3-D.

מחשב את השיפוע של התרחבות דו-ממדית מורפולוגית ביחס למסנן.

מחשב את השיפוע של הרחבה דו-ממדית מורפולוגית ביחס לקלט.

מחזירה x / y מבחינת אלמנט.

מחזירה 0 אם המכנה הוא אפס.

צייר תיבות תוחמות על קבוצת תמונות.

צייר תיבות תוחמות על קבוצת תמונות.

מחלק data לטנזורים num_partitions באמצעות מדדים partitions .

שזור את הערכים מטנסור data לטנזור בודד.

מחשב את מרחק העריכה של Levenshtein (אולי מנורמל).

מחשב ליניארי מעריכי: exp(features) - 1 אם < 0, features אחרות.

יוצר טנזור עם הצורה הנתונה.

מקודד מחרוזות לפורמט base64 בטוח באינטרנט.

JPEG-קודד תמונה.

תמונת קלט מקודד JPEG עם איכות דחיסה מסופקת.

PNG-קודד תמונה.

מבטיח שצורת הטנזור תואמת את הצורה הצפויה.

מחזירה את ערך האמת של (x == y) מבחינה אלמנט.

מחשב את פונקציית השגיאה גאוס של x מבחינה אלמנט.

מחשב את פונקציית השגיאה המשלימה של x מבחינה אלמנט.

TODO: הוסף מסמך.

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

מחשב אקספוננציאלי של x מבחינת אלמנט.

מכניס ממד של 1 לצורת טנזור.

מחשב exp(x) - 1 מבחינת אלמנט.

מחלץ הצצה מטנסור הקלט.

חלץ patches images ושם אותם בממד הפלט "עומק".

חלץ את מידע הצורה של תמונה מקודדת JPEG.

חלץ טלאים patches ושם אותם בממד הפלט "עומק input .

תור שמייצר אלמנטים בסדר ראשון נכנס ראשון יוצא.

פלט עובדה על פקטוריאלים.

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

חישוב מעברי צבע עבור פעולת FakeQuantWithMinMaxArgs .

לכמת מזויף את טנסור 'הכניסות' מסוג צף באמצעות סקלרים גלובליים של ציפה min

חישוב מעברי צבע עבור פעולת FakeQuantWithMinMaxVars .

לכמת מזויף את טנסור 'הכניסות' מסוג float ואחת הצורות: [d] ,.

חישוב מעברי צבע עבור פעולת FakeQuantWithMinMaxVarsPerChannel .

יוצר טנזור מלא בערך סקלרי.

מייצר ערכי טביעת אצבע.

קורא שמוציא רשומות באורך קבוע מקובץ.

יוצר תוויות לדגימת מועמדים עם התפלגות אוניגרמה נלמדת.

מחזירה את המספר השלם הגדול ביותר מבחינת האלמנט שאינו גדול מ-x.

מחזירה x // y מבחינה אלמנט.

מחזירה את שארית החלוקה מבחינת הרכיב.

מבצע איגום ממוצע חלקי על הקלט.

מבצע איגום מקסימלי חלקי על הקלט.

נורמליזציה של אצווה.

שיפוע לנורמליזציה של אצווה.

שיפוע לנורמליזציה של אצווה.

שיפוע לנורמליזציה של אצווה.

נורמליזציה של אצווה.

נורמליזציה של אצווה.

מבצע ריפוד כתהליך מקדים במהלך פיתול.

מבצע שינוי גודל וריפוד כתהליך מקדים במהלך פיתול.

אספו פרוסות params לפי indices .

אסוף פרוסות params לתוך Tensor עם צורה שצוינה על ידי indices .

אסוף פרוסות מציר axis params לפי indices .

אחסן את טנסור הקלט במצב ההפעלה הנוכחית.

אחסן את טנסור הקלט במצב ההפעלה הנוכחית.

קבל את הערך של הטנזור שצוין על ידי הידית שלו.

מחזירה את ערך האמת של (x > y) מבחינה אלמנט.

מחזירה את ערך האמת של (x >= y) מבחינה אלמנט.

נותן ערובה לזמן הריצה של TF שטנסור הקלט הוא קבוע.

המר תמונה אחת או יותר מ-HSV ל-RGB.

החזר היסטוגרמה של ערכים.

פלט מאגר פרוטוקול Summary עם היסטוגרמה.

החזר טנזור עם אותה צורה ותוכן כמו טנזור הקלט או הערך.

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

קורא שמוציא את העבודה בתור הן כמפתח והן כערך.

חשב את פונקציית הגמא הבלתי-שלמה המוסדרת הנמוכה יותר P(a, x) .

חשב את פונקציית הגמא הבלתי שלמה המוסדרת העליונה Q(a, x) .

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

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

אומר אם המטרות נמצאות בתחזיות K העליון.

אומר אם המטרות נמצאות בתחזיות K העליון.

מוסיף v לשורות שצוינו של x.

מוריד v לשורות שצוינו של x .

מעדכן שורות שצוינו עם ערכים ב- v .

מחשב את ההדדיות של x מבחינה אלמנט.

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

מחזירה אילו אלמנטים של x הם סופיים.

מחזירה אילו רכיבים של x הם Inf.

מחזירה אילו אלמנטים של x הם NaN.

בודק אם טנזור אותחל.

הפסד L2.

קורא שמוציא את הרשומות מקובץ LMDB.

נורמליזציה של תגובה מקומית.

יוצר תוויות לדגימת מועמדים עם התפלגות אוניגרמה נלמדת.

מחזירה את ערך האמת של (x < y) מבחינה אלמנט.

מחזירה את ערך האמת של (x <= y) מבחינה אלמנט.

מחשב את היומן של הערך המוחלט של Gamma(x) מבחינה אלמנט.

יוצר ערכים במרווח.

מחשב לוגריתם טבעי של x מבחינת אלמנטים.

מחשב לוגריתם טבעי של (1 + x) מבחינת אלמנט.

מחשב הפעלת יומן softmax.

יוצר תוויות לדגימת מועמדים עם התפלגות אחידה ביומן.

מחזירה את ערך האמת של x ו-y מבחינה אלמנט.

מחזירה את ערך האמת של NOT x מבחינה אלמנט.

מחזירה את ערך האמת של x או y מבחינה אלמנט.

מעביר את הקלט לפלט.

Op מסיר את כל האלמנטים במיכל הבסיסי.

Op מחזירה את מספר האלמנטים הלא שלמים במיכל הבסיסי.

אופ מציץ בערכים במפתח שצוין.

Op מחזירה את מספר האלמנטים במיכל הבסיסי.

שלב (מפתח, ערכים) במיכל הבסיסי שמתנהג כמו טבל hashable.

Op מסיר ומחזיר את הערכים המשויכים למפתח.

Op מסיר ומחזיר אקראי (מפתח, ערך)

הכפל את המטריצה ​​"a" במטריצה ​​"b".

מחזירה את קבוצת הקבצים התואמים לדפוס גלוב אחד או יותר.

העתק טנזור שמגדיר הכל מחוץ לרצועה מרכזית בכל מטריצה ​​הפנימית ביותר.

מחזירה טנזור אלכסוני אצווה עם ערכי אלכסון אצווה נתון.

מחזירה את החלק האלכסוני המצטבר של טנזור אצווה.

מחזירה את החלק האלכסוני המצטבר של טנזור אצווה.

מחזירה את החלק האלכסוני המצטבר של טנזור אצווה.

מחזירה טנזור אלכסוני אצווה עם ערכי אלכסון אצווה נתונים.

מחזירה טנזור אלכסוני אצווה עם ערכי אלכסון אצווה נתונים.

מחזירה טנזור מטריצה ​​אצווה עם ערכי אלכסון אצווה חדשים.

מחזירה טנזור מטריצה ​​אצווה עם ערכי אלכסון אצווה חדשים.

מחזירה טנזור מטריצה ​​אצווה עם ערכי אלכסון אצווה חדשים.

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

מבצע איגוד מקסימלי בקלט.

מבצע 3D max pooling על הקלט.

מחשב גרדיאנטים של פונקציית איסוף מקסימלית.

מחשב גרדיאנטים מסדר שני של פונקציית maxpooling.

מחשב גרדיאנטים מסדר שני של פונקציית maxpooling.

מחשב גרדיאנטים מסדר שני של פונקציית maxpooling.

מחשב גרדיאנטים מסדר שני של פונקציית maxpooling.

מחשב גרדיאנטים של פונקציית maxpooling.

מבצע איגוד מקסימלי בקלט.

מבצע איגוד מקסימלי על הקלט ומוציא גם ערכי מקסימום וגם מדדים.

מחזירה את המקסימום של x ו-y (כלומר

מחשב את הממוצע של אלמנטים על פני מימדים של טנזור.

מעביר את הערך של טנזור זמין inputs output .

ממזג סיכומים.

פורמט V2 ספציפי: ממזג את קובצי המטא נתונים של נקודות ביקורת מרוסקות.

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

מחזירה את המינימום של x ו-y (כלומר

מרפד טנזור עם ערכי שיקוף.

מחזירה את שארית החלוקה מבחינת הרכיב.

מחזירה x * y מבחינת אלמנט.

שואב דוגמאות מהתפלגות רב-נומית.

מחזירה x * y מבחינת אלמנט.

TODO: הוסף מסמך.

מחשב ערך שלילי מספרי לפי אלמנט.

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

הופך את הקלט שלו לזמין לאיטרציה הבאה.

לא עושה כלום.

בוחר בתאוותנות קבוצת משנה של תיבות תוחמות בסדר יורד של הניקוד,.

בוחר בתאוותנות קבוצת משנה של תיבות תוחמות בסדר יורד של הניקוד,.

בוחר בתאוותנות קבוצת משנה של תיבות תוחמות בסדר יורד של הניקוד,.

בוחר בתאוותנות קבוצת משנה של תיבות תוחמות בסדר יורד של הניקוד,.

בוחר בתאוותנות קבוצת משנה של תיבות תוחמות בסדר יורד של הניקוד,.

בוחר בתאוותנות קבוצת משנה של תיבות תוחמות בסדר יורד של הניקוד,.

מחזירה את ערך האמת של (x != y) מבחינת אלמנט.

מוצא ערכים של סטטיסטיקת הסדר n עבור הממד האחרון.

מחזיר טנסור חם אחד.

מחזירה טנסור של אלה עם אותה צורה וסוג כמו x.

Op מסיר את כל האלמנטים במיכל הבסיסי.

Op מחזירה את מספר האלמנטים הלא שלמים במיכל הבסיסי.

אופ מציץ בערכים במפתח שצוין.

Op מחזירה את מספר האלמנטים במיכל הבסיסי.

שלב (מפתח, ערכים) במיכל הבסיסי שמתנהג כמו הזמנה.

Op מסיר ומחזיר את הערכים המשויכים למפתח.

Op מסיר ומחזיר את האלמנט (מפתח, ערך) עם הקטן ביותר.

מרפד טנזור באפסים.

מרפד טנזור.

תור שמייצר אלמנטים בסדר ראשון נכנס ראשון יוצא.

משרשרת רשימה של N טנסורים לאורך הממד הראשון.

שזור את הערכים מטנסור data לטנזור בודד.

מוציא ערכים אקראיים מהתפלגות נורמלית.

הופך וקטור של מוח. פרוטו לדוגמא (כמחרוזות) לטנזורים מוקלדים.

הופך וקטור של פרוטו tf.Example (כמחרוזות) לטנזורים מוקלדים.

הופך וקטור של מוח. פרוטו דוגמה לרצף (כמחרוזות) לטנזורים מוקלדים.

הופך וקטור של פרוטו tf.io.SequenceExample (כמחרוזות) לטנזורים מוקלדים.

הופך פרוטו tf.Example (כמחרוזת) לטנזורים מוקלדים.

הופך מוח סקלרי. פרוטו לדוגמה (כמחרוזות) לטנזורים מוקלדים.

הופך פרוטו של tensorflow.TensorProto מסודר ל- Tensor .

מציין מיקום עבור ערך שיוזן לחישוב.

מציין מיקום שעובר דרך input כאשר הפלט שלו לא מוזן.

חשב את פונקציית הפוליגמה \(^{(n)}(x)\).

מחשב את העוצמה של ערך אחד למשנהו.

הפעלת זהות שמפעילה שגיאה אם ​​מתבקש שיפוע.

מדפיס רשימה של טנסורים.

מדפיס מחרוזת סקלרית.

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

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

מכונס ואז מבטל טנזור.

מכונס ואז מבטל טנזור.

המר את טנסור ה-'קלט' המכומתי ל'פלט' בעל דיוק נמוך יותר, באמצעות ה-.

כוונט את טנסור ה"קלט" מסוג float לטנסור "פלט" מסוג "T".

מחזירה x + y מבחינת אלמנטים, עובדת על מאגרים כמותיים.

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

נורמליזציה של אצווה כמותית.

מוסיף 'הטיה' של Tensor ל'קלט' של Tensor עבור סוגים קוונטיים.

משרשרת טנזורים כמותיים לאורך מימד אחד.

מחשב קונבולוציה דו-ממדית בהינתן טנסור קלט 4-ממד 4D מקומת.

נורמליזציה של מופע כמותי.

בצע כפל מטריצה ​​כמותית של a במטריצה b .

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

מחזירה x * y מבחינת אלמנטים, עובדת על מאגרים כמותיים.

מחשב Quantized Rectified Linear: max(features, 0)

מחשב Quantized Rectified Linear 6: min(max(features, 0), 6)

מחשבת X Quantized Rectified Linear: min(max(features, 0), max_value)

שנה את גודל images הקוונטיות size באמצעות אינטרפולציה בילינארית כמותית.

סוגר את התור הנתון.

מוציא תור של טנסור אחד או יותר מהתור הנתון.

מעביר n tuples של טנסור אחד או יותר מהתור הנתון.

מעביר n tuples של טנסור אחד או יותר מהתור הנתון.

מעמיד בתור טופלה של טנסור אחד או יותר בתור הנתון.

מעמיד בתור אפס או יותר tuples של טנסור אחד או יותר בתור הנתון.

מחזירה true אם התור נסגר.

מחזירה true אם התור נסגר.

מחשב את מספר האלמנטים בתור הנתון.

ממיר תמונה אחת או יותר מ-RGB ל-HSV.

מוציא ערכים אקראיים מהתפלגות גמא המתוארות על ידי אלפא.

מוציא ערכים אקראיים מהתפלגות נורמלית.

מוציא ערכים אקראיים מהתפלגות ה-Poisson המתוארות לפי קצב.

מערבב באופן אקראי טנזור לאורך הממד הראשון שלו.

תור שהופך את סדר האלמנטים באקראי.

מוציא ערכים אקראיים מהתפלגות אחידה.

מוציא מספרים שלמים אקראיים מהתפלגות אחידה.

יוצר רצף של מספרים.

קורא ומוציא את כל התוכן של שם קובץ הקלט.

מחזירה את מספר הרשומות שהקורא הזה הפיק.

מחזירה את מספר יחידות העבודה שהקורא הזה סיים לעבד.

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

מחזיר עד num_records (מפתח, ערך) זוגות שנוצרו על ידי Reader.

שחזר קורא למצב הניקיון הראשוני שלו.

שחזר קורא למצב שנשמר קודם לכן.

הפק טנזור מיתר המקודד את המצב של Reader.

מחזירה את החלק האמיתי של מספר מרוכב.

מחזירה x / y מבחינת אלמנטים עבור טיפוסים אמיתיים.

מחשב את ההדדיות של x מבחינה אלמנט.

פולט רשומות אקראיות.

מצטרף למחרוזת Tensor על פני המידות הנתונות.

הופך את הקלט שלו לזמין לאיטרציה הבאה.

מעביר את המרכיב של inputs index output .

מעביר את data ה- Ref Tensor ליציאת הפלט שנקבעו על ידי pred .

בדוק אם הקלט תואם את דפוס regex.

מחליף התאמות של הביטוי הרגיל של pattern input עם מחרוזת החלפה המסופקת בשכתוב rewrite .

מחשב לינארי מתוקן: max(features, 0) .

מחשב לינארי 6: min(max(features, 0), 6) .

מחשב טווח המכסה את הערכים בפועל הקיימים במתחם כמותי.

ממיר את טנזור input הכמותי output דיוק נמוך יותר.

שינוי גודל images size באמצעות אינטרפולציה של אזור.

שינוי גודל images size באמצעות אינטרפולציה דו -קובית.

שינוי גודל images size באמצעות אינטרפולציה דו -צדדית.

שינוי גודל images size באמצעות אינטרפולציה של השכנים הקרובה ביותר.

עדכן '*var' בהתאם לתכנית Adadelta.

עדכן '*var' בהתאם לתכנית Adagrad.

עדכן '*var' בהתאם לתכנית Adagrad הפרוקסימלית.

עדכן את '*var' לפי אלגוריתם Adam.

עדכן את '*var' לפי אלגוריתם Adam.

עדכן '*var' בהתאם לעדכון ההוספות.

עדכן את '*var' לפי אלגוריתם RMSProp המרוכז.

עדכן '*var' בהתאם לתכנית FTRL-proximal.

עדכן '*var' בהתאם לתכנית FTRL-proximal.

עדכן את ' * var' על ידי הפחתת 'אלפא' * 'דלתא' ממנה.

עדכן '*var' בהתאם לתכנית המומנטום.

עדכן '*var' בהתאם לתכנית המומנטום.

עדכן '*var' בהתאם לעדכון ההוספות.

עדכן '*var' ו- '*Quect' על פי FOBOs עם קצב הלמידה של Adagrad.

עדכן '*var' כאלגוריתם FOBOS עם קצב למידה קבוע.

עדכן '*var' בהתאם לאלגוריתם RMSPROP.

מרחבים משתנים שהצביעו על ידי 'משאב' עד שהוא מגיע 'גבול'.

מיישם תוספת דלילה על ערכים או פרוסות בודדות במשתנה .

מיישם חיסור דליל על ערכים או פרוסות בודדות במשתנה .

מיישם updates דלילים על ערכים או פרוסות בודדות בתוך נתון.

var: צריך להיות מ-Variable().

עדכן רשומות רלוונטיות ב- '*var' ו- '*Quect' על פי תוכנית Adagrad.

עדכן רשומות ב- '*var' ו- '*quet' על פי סכמת ה- Adagrad הפרוקסימלית.

עדכן את '*var' לפי אלגוריתם RMSProp המרוכז.

עדכן רשומות רלוונטיות ב- '*var' בהתאם לתכנית FTRL-proximal.

עדכן רשומות רלוונטיות ב- '*var' בהתאם לתכנית FTRL-proximal.

עדכן רשומות רלוונטיות ב- '*var' ו- '*Quect' על פי תוכנית המומנטום.

עדכן רשומות רלוונטיות ב- '*var' ו- '*Quect' על פי תוכנית המומנטום.

ערכי עדכון דלילים ב'*var 'ו-'*Quect 'על פי אלגוריתם FOBOS.

עדכון דליל '*var' כאלגוריתם FOBOS עם קצב למידה קבוע.

עדכן '*var' בהתאם לאלגוריתם RMSPROP.

משחזר טנזור מקבצי מחסום.

משחזר טנזור מקבצי מחסום.

משחזר טנסורים ממחסום V2.

מחזיר מספר שלם שלם אלמנט הקרוב ביותר ל- x.

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

מחשבת הדדיות של שורש מרובע של X-Element-for Element.

צור תיבת גבול מעוותת באופן אקראי לתמונה.

צור תיבת גבול מעוותת באופן אקראי לתמונה.

שומר את טנזורי הקלט לדיסק.

שומר פרוסות טנסור קלט לדיסק.

שומר טנסורים בפורמט מחסום V2.

מוציא מאגר פרוטוקול Summary עם ערכי סקלר.

TODO: הוסף את DOC.

מוסיף עדכונים דלילים להפניה למשתנה.

מחלקים הפניה משתנה על ידי עדכונים דלילים.

מצמצם עדכונים דלילים להתייחסות משתנה באמצעות פעולת max .

מפחית עדכונים דלילים להתייחסות משתנה באמצעות פעולת min .

מכפיל עדכונים דלילים להתייחסות משתנה.

מיישם תוספת דלילה על ערכים או פרוסות בודדות במשתנה .

מיישם חיסור דליל על ערכים או פרוסות בודדות במשתנה .

מיישם updates דלילים על ערכים או פרוסות בודדות בתוך נתון.

מחסור עדכונים דלילים להפניה משתנה.

מיישם עדכונים דלילים על הפניה משתנה.

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

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

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

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

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

TODO: הוסף את DOC.

מחשב ליניארי אקספוננציאלי בקנה מידה: scale * alpha * (exp(features) - 1)

סדרה סדרת SparseTensor N -minibatch לאובייקט Tensor [N, 3] .

סידורי סדרה SparseTensor לאובייקט Tensor [3] .

הופך טנזור לפרוטו TensorProto בהמשכים.

מחשב את ההבדל בין שתי רשימות של מספרים או מחרוזות.

ליצור שם קובץ מסורבל.

צור תבנית גלובית המתאימה לכל שמות הקבצים המנוסחים.

מחשב סיגמואיד של x Element-for Element.

מחזירה אינדיקציה מבצעת אלמנט לסימן למספר.

מחשב סינוס של X-Element-Element.

מחשב סינוס היפרבולי של X-Element-Element.

מחשב הפעלות SOFTMAX.

מחשב עלות אנטרופיה צולבת של SoftMax ומדרגות לניתוח אחורי.

מחשבות את Softplus: log(exp(features) + 1) .

מחשב SoftSign: features / (abs(features) + 1) .

מיישם שיפוע דליל על מצבר נתון.

מחלץ את המדרגה הדלילה הממוצעת במתחם sparseconditionalaccumulator .

מוסיף שני אובייקטים SparseTensor לייצור SparseTensor אחר.

מפעיל השיפוע של ה- SparSeadd Op.

var: צריך להיות מ-Variable().

עדכן רשומות רלוונטיות ב- '*var' ו- '*Quect' על פי תוכנית Adagrad.

עדכן רשומות ב- '*var' ו- '*quet' על פי סכמת ה- Adagrad הפרוקסימלית.

עדכן את '*var' לפי אלגוריתם RMSProp המרוכז.

עדכן רשומות רלוונטיות ב- '*var' בהתאם לתכנית FTRL-proximal.

עדכן רשומות רלוונטיות ב- '*var' בהתאם לתכנית FTRL-proximal.

עדכן רשומות רלוונטיות ב- '*var' ו- '*Quect' על פי תוכנית המומנטום.

ערכי עדכון דלילים ב'*var 'ו-'*Quect 'על פי אלגוריתם FOBOS.

עדכון דליל '*var' כאלגוריתם FOBOS עם קצב למידה קבוע.

עדכן '*var' בהתאם לאלגוריתם RMSPROP.

משרשר רשימה של SparseTensor לאורך הממד שצוין.

מצבר מותנה לצבירת שיפועים דלילים.

מייצר צלב דליל מרשימה של טנזורים דלילים וצפופים.

מוסיף SparSetensor ומתחם צפוף, תוך שימוש בכללים מיוחדים אלה:

מבחינה רכיב מחלקת מחלקה על ידי טנזור צפוף.

מבחינה רכיב מכפיל את SparSetensor על ידי טנזור צפוף.

ממלא שורות ריקות בקלט הדו-ממדי SparseTensor עם ערך ברירת מחדל.

שיפוע ה- SparseftempemptyRows .

הכפל מטריקס "A" על ידי מטריקס "B".

מחשב את המקסימום של האלמנטים על פני מידות של Sparsetensor.

מחשב את המקסימום של האלמנטים על פני מידות של Sparsetensor.

מחשב את סכום האלמנטים על פני מידות של Sparsetensor.

מחשב את סכום האלמנטים על פני מידות של Sparsetensor.

מסדר מחדש את Sparsetensor לסדר הקאנוני, שורה-מג'ור.

מעצב מחדש SPARSETENSOR לייצוג ערכים בצורה צפופה חדשה.

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

מחשב שיפועים עבור SparseSegmentmean .

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

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

מחשב שיפועים עבור SparSesegmentsQrtn .

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

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

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

פורסים SparseTensor בהתבסס על start size .

מפעיל השיפוע של Sparseslice OP.

מחיל SoftMax על SparseTensor ND מקושק.

מחשב עלות אנטרופיה צולבת של SoftMax ומדרגות לניתוח אחורי.

מחזיר את המקסימום החכם אלמנט של שני Sparsetensors.

מחזיר את הדקות החכמות של שני Sparsetensors.

חילקו SparseTensor ל- num_split tensors לאורך ממד אחד.

מוסיף SparseTensor צפוף ומייצר Tensor Tensor .

הכפל SparSetensor (של דרגה 2) "A" על ידי מטריצה ​​צפופה "B".

מחשב שורש מרובע של X-Element-Element.

מחושב ריבוע של X-Element-Element.

חוזר (x - y) (x - y) מבחינת אלמנט.

אורזת רשימה של טנזורי R N לדרגה אחת (R+1) טנזור.

ערכי שלב הדומים לאינקוי קל משקל.

OP מסיר את כל האלמנטים במכולה הבסיסית.

OP מציץ בערכים באינדקס שצוין.

OP מחזירה את מספר האלמנטים במכולה הבסיסית.

פורמט תבנית מחרוזת באמצעות רשימת טנזורים.

מצטרף למיתרים ברשימה הנתונה של טנזורי מיתרים לטנסור אחד;

אורכי מיתר של input .

ממיר את כל הדמויות הגדולות להחלפות אותיות קטנות בהתאמה.

יוצר Ngrams מנתוני מחרוזת סמרטוטים.

אלמנטים מפוצלים של input המבוסס על delimiter SparseTensor .

אלמנטים מפוצלים של source המבוסס על sep ל- SparseTensor .

רצועה מובילה ונגררת מרחב לבן מהטנזור .

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

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

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

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

ממיר את כל הדמויות הקטנות להחלפות אותיות גדולות בהתאמה.

החזרת מצעי מחזיר מ- Tensor of Strings.

מחזיר x - y אלמנט -חכמה.

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

מעביר data יציאת הפלט שנקבע על ידי pred .

קורא שמוצא את הרשומות מקובץ רשומות TensorFlow.

ממיר ייצוג דליל למתחם צפוף.

מחשב שיזוף של X-Element-Element.

מחשבת משיק היפרבולית של x -Element-Element.

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

מערך של טנזורים בגודל נתון.

מחק את TensorArray ממכולה המשאבים שלו.

הסתכמו באלמנטים מה- TensorArray לערך value .

אסוף אלמנטים ספציפיים מה- TensorArray value הפלט.

יוצר טנסורריי לאחסון שיפועי הערכים בידית הנתונה.

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

קרא אלמנט מה- TensorArray value הפלט.

מפזרים את הנתונים מערך הקלט לרכיבי TensorArray ספציפיים.

קבל את הגודל הנוכחי של TensorArray .

פצל את הנתונים מערך הקלט לרכיבי TensorArray .

דחף אלמנט אל Tensor_array.

מוציא מאגר פרוטוקול Summary עם טנזור.

מוציא מאגר פרוטוקול Summary עם נתוני טנזור ונתונים לכל פלוגין.

קורא שמוצא את שורות הקובץ שתוחם על ידי '
'.

מספק את הזמן מאז התקופה בשניות.

מוצא ערכים ומדדים של האלמנטים הגדולים ביותר k עבור הממד האחרון.

מחזיר את ה- X / Y-Element-Element עבור סוגים שלמים.

מחזיר את שארית החלוקה החכמה.

מוציא ערכים אקראיים מהפצה נורמלית קטועה.

קבע את קודי הסקריפט של טנזור נתון של נקודות קוד שלם של unicode.

מעבר לקוד את טקסט הקלט ממקור המקודד לקידוד יעד.

מייצר תוויות לדגימה של מועמדים עם תפוצה אחידה.

מצטרף לאלמנטים של inputs המבוססות על segment_ids .

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

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

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

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

OP דומה לטיפול קל משקל.

מחזיק במדינה בצורה של טנזור שנמשך על פני הצעדים.

מעצב מחדש טנזור כמותי לפי ה- RESHAPE OP.

בוחר אלמנטים מ- x או y , תלוי condition .

קורא שמוצא את כל תוכן הקובץ כערך.

כותב תוכן לקובץ בשם קובץ קלט.

מחזיר 0 אם x == 0, ו- x / y אחרת, ElementWise.

מחזיר 0 אם x == 0, ו- x * log1p (y) אחרת, ElementWise.

מחזיר 0 אם x == 0, ו- x * log (y) אחרת, ElementWise.

מחזיר טנזור של אפסים באותה צורה וסוג זהה ל- x.

חישוב פונקציית Hurwitz Zeta \((x, q)\).