עזרה להגן על שונית המחסום הגדולה עם TensorFlow על Kaggle הצטרפו אתגר

התחל עם TensorFlow Transform

מדריך זה מציג את מושגי היסוד של tf.Transform ואיך להשתמש בהם. זה יהיה:

  • הגדר פונקציית עיבוד מקדים, תיאור לוגי של צינור שמשנה את הנתונים הגולמיים לתוך הנתונים המשמשים להכשיר מודל למידת מכונה.
  • הראה את האפצ'י Beam היישום המשמש להעברת נתונים על ידי המרת הפונקציה המקדים לתוך צינור Beam.
  • הצג דוגמאות שימוש נוספות.

הגדר פונקציית עיבוד מקדים

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

  1. כל פונקציה שמקבלת ומחזירה טנסורים. אלה מוסיפים לגרף פעולות TensorFlow שהופכות נתונים גולמיים לנתונים שעברו טרנספורמציה.
  2. כול אחד המנתחים שמספקים tf.Transform . מנתחים גם לקבל ולהחזיר tensors, אבל בניגוד פונקציות TensorFlow, הם לא מוסיפים פעולות הגרף. במקום זאת, מנתחי גורם tf.Transform כדי לחשב מחוץ לפעולה מלאה pass של TensorFlow. הם משתמשים בערכי טנזור הקלט על כל מערך הנתונים כדי ליצור טנזור קבוע שמוחזר כפלט. לדוגמה, tft.min מחשב את המינימום של מותח על הנתונים. tf.Transform מספק סט של מנתחים קבוע, אבל זה יוארך בגרסות עתידיות.

דוגמה לפונקציית עיבוד מוקדם

על ידי שילוב של מנתחים ופונקציות TensorFlow רגילות, משתמשים יכולים ליצור צינורות גמישים להמרת נתונים. פונקציית העיבוד המקדים הבאה הופכת כל אחת משלוש התכונות בדרכים שונות, ומשלבת שתיים מהתכונות:

import tensorflow as tf
import tensorflow_transform as tft
import tensorflow_transform.beam as tft_beam

def preprocessing_fn(inputs):
  x = inputs['x']
  y = inputs['y']
  s = inputs['s']
  x_centered = x - tft.mean(x)
  y_normalized = tft.scale_to_0_1(y)
  s_integerized = tft.compute_and_apply_vocabulary(s)
  x_centered_times_y_normalized = x_centered * y_normalized
  return {
      'x_centered': x_centered,
      'y_normalized': y_normalized,
      'x_centered_times_y_normalized': x_centered_times_y_normalized,
      's_integerized': s_integerized
  }

הנה, x , y ו- s הם Tensor ים המייצג תכונות קלט. טנזור החדש הראשון שנוצר, x_centered , בנויה על ידי יישום tft.mean כדי x וחיסור זה מן x . tft.mean(x) מחזירה מותחת המייצג את הממוצע של המותח x . x_centered הוא המותח x עם הממוצע מופחת.

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

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

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

פונקציית העיבוד המקדים מגדירה צינור של פעולות על מערך נתונים. על מנת ליישם את הצינור, אנחנו מסתמכים על מימושו של tf.Transform API. יישום Apache Beam מספק PTransform אשר חל פונקצית העיבוד המקדימה של משתמש לנתונים. זרימת העבודה הטיפוסית של tf.Transform המשתמשים תבנה פונקצית עיבוד מקדימה, אז לשלב את זה לתוך צינור Beam גדול, יוצר את נתון לאימונים.

אצווה

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

אמנם לא ברור בדוגמה לעיל, המשתמש הגדיר עיבוד מקדים פונקציה מועבר tensors המייצגים קבוצות ולא מקרים בודדים, כפי שקורה במהלך אימון ומשרת עם TensorFlow. מצד שני, מנתחים מבצעים חישוב על כל מערך הנתונים שמחזיר ערך בודד ולא אצווה של ערכים. x הוא Tensor עם צורה של (batch_size,) , בעוד tft.mean(x) הוא Tensor עם צורה של () . חיסור x - tft.mean(x) שידורי ששווי tft.mean(x) ינוכו כל אלמנט של המנה מיוצג על ידי x .

יישום Apache Beam

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

יישום Apache Beam מספק שני PTransform המשמשים ים לעבד נתונים עבור פונקצית עיבוד מקדימה. המופעים בעקבות השימוש עבור מרוכבים PTransform AnalyzeAndTransformDataset :

raw_data = [
    {'x': 1, 'y': 1, 's': 'hello'},
    {'x': 2, 'y': 2, 's': 'world'},
    {'x': 3, 'y': 3, 's': 'hello'}
]

raw_data_metadata = ...
transformed_dataset, transform_fn = (
    (raw_data, raw_data_metadata) | tft_beam.AnalyzeAndTransformDataset(
        preprocessing_fn))
transformed_data, transformed_metadata = transformed_dataset

transformed_data תוכן מוצג למטה והוא מכיל את העמודות טרנספורמציה באותה מתכונת כמו את הנתונים הגולמיים. בפרט, את הערכים של s_integerized הם [0, 1, 0] ערכים -these תלוי איך את המילים hello ו world מופו אל מספרים שלמים, המהווה דטרמיניסטית. עבור העמודה x_centered , אנו מפחיתים את הממוצע לכן הערכים של עמודת x , אשר היו [1.0, 2.0, 3.0] , הפכו [-1.0, 0.0, 1.0] . באופן דומה, שאר העמודות תואמות את הערכים הצפויים שלהן.

[{u's_integerized': 0,
  u'x_centered': -1.0,
  u'x_centered_times_y_normalized': -0.0,
  u'y_normalized': 0.0},
 {u's_integerized': 1,
  u'x_centered': 0.0,
  u'x_centered_times_y_normalized': 0.0,
  u'y_normalized': 0.5},
 {u's_integerized': 0,
  u'x_centered': 1.0,
  u'x_centered_times_y_normalized': 1.0,
  u'y_normalized': 1.0}]

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

AnalyzeAndTransformDataset הוא בהרכב של שתי תמרות היסוד שמספקות היישום AnalyzeDataset ו TransformDataset . אז שני קטעי הקוד הבאים שווים:

transformed_data, transform_fn = (
    my_data | tft_beam.AnalyzeAndTransformDataset(preprocessing_fn))
transform_fn = my_data | tft_beam.AnalyzeDataset(preprocessing_fn)
transformed_data = (my_data, transform_fn) | tft_beam.TransformDataset()

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

תכונה חשובה של tf.Transform היא transform_fn מייצג מפה מעל שורות -היא היא פונקציה טהורה להחיל כל שורה בנפרד. כל החישוב עבור שורות צבירה נעשית AnalyzeDataset . יתר על כן, transform_fn מיוצג TensorFlow Graph שיכול להיות מוטבע לתוך גרף ההגשה.

AnalyzeAndTransformDataset מסופק אופטימיזציות במקרה המיוחד הזה. זוהי אותה תבנית בשימוש scikit-ללמוד , מתן fit , transform , ו fit_transform שיטות.

פורמטים וסכימה של נתונים

יישום TFT Beam מקבל שני פורמטים שונים של נתוני קלט. הפורמט "למשל dict" (כפי שניתן לראות בדוגמה לעיל וב simple_example.py ) הוא פורמט אינטואיטיבי והוא מתאים מערכי נתונים קטנים בעוד TFXIO ( Apache חץ פורמט) מספק ביצועים משופרים הוא suitble עבור מערכי נתונים גדולים.

היישום Beam אומר באיזה פורמט יהיה הקלט PCollection על ידי ה"מטא נתונים" הנלווים ל- PCollection:

(raw_data, raw_data_metadata) | tft.AnalyzeDataset(...)
  • אם raw_data_metadata הוא dataset_metadata.DatasetMetadata (ראה להלן, "הפורמט 'למשל dict'" סעיף), אז raw_data צפויה להיות בפורמט "למשל dict".
  • אם raw_data_metadata הוא tfxio.TensorAdapterConfig (ראה להלן, "הפורמט TFXIO" סעיף), אז raw_data צפויה להיות בפורמט TFXIO.

הפורמט של "instance dict".

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

הנה ההגדרה של הסכימה עבור הנתונים לדוגמה:

from tensorflow_transform.tf_metadata import dataset_metadata
from tensorflow_transform.tf_metadata import schema_utils

raw_data_metadata = dataset_metadata.DatasetMetadata(
      schema_utils.schema_from_feature_spec({
        's': tf.io.FixedLenFeature([], tf.string),
        'y': tf.io.FixedLenFeature([], tf.float32),
        'x': tf.io.FixedLenFeature([], tf.float32),
    }))

Schema פרוטו מכיל את המידע הדרוש כדי לנתח את הנתונים על-דיסק שלה או ב-זיכרון בפורמט, לתוך tensors. הוא בד"כ נבנה על ידי התקשרות schema_utils.schema_from_feature_spec עם מפתחות תכונה מיפוי dict כדי tf.io.FixedLenFeature , tf.io.VarLenFeature , ו tf.io.SparseFeature ערכים. עיין בתיעוד tf.parse_example לפרטים נוספים.

מעל נשתמש tf.io.FixedLenFeature לציין כי כל תכונה מכיל מספר קבוע של ערכים, במקרה זה ערך סקלרי יחיד. מכיוון tf.Transform מקרים אצוות, הממשי Tensor המייצג את התכונה תהיה צורה (None,) כאשר המאפיין ידוע הוא הממד אצווה.

פורמט TFXIO

בפורמט זה, הנתונים צפוי להיות הכלול pyarrow.RecordBatch . לקבלת נתונים טבלאיים, יישום Beam Apache שלנו מקבל חץ RecordBatch es המורכבת של עמודות מהסוגים הבאים:

  • pa.list_(<primitive>) , שבו <primitive> הוא pa.int64() , pa.float32() pa.binary() או pa.large_binary() .

  • pa.large_list(<primitive>)

בסיס הנתונים קלט צעצוע השתמשנו לעיל, כאשר ייצג בתור RecordBatch , נראית כך:

raw_data = [
    pa.record_batch([
        pa.array([[1], [2], [3]], pa.list_(pa.float32())),
        pa.array([[1], [2], [3]], pa.list_(pa.float32())),
        pa.array([['hello'], ['world'], ['hello']], pa.list_(pa.binary())),
    ], ['x', 'y', 's'])
]

בדומה DatasetMetadata שהם זקוקים לה ללוות את הפורמט "למשל dict", A tfxio.TensorAdapterConfig נדרש ללוות את RecordBatch es. זה מורכב של סכימת החץ של RecordBatch es, ו TensorRepresentations כדי לקבוע באופן ייחודי איך עמודות RecordBatch es יכולות להתפרש TensorFlow tensors (כולל אך לא מוגבלת tf.Tensor, tf.SparseTensor).

TensorRepresentations הוא Dict[Text, TensorRepresentation] אשר קובע את היחסים בין מותח כי preprocessing_fn מקבלת ועמודות ב RecordBatch es. לדוגמה:

tensor_representation = {
    'x': text_format.Parse(
        """dense_tensor { column_name: "col1" shape { dim { size: 2 } } }"""
        schema_pb2.TensorRepresentation())
}

כלומר inputs['x'] ב preprocessing_fn צריך להיות צפוף tf.Tensor, שערכיה באו טור של שם 'col1' בקלט RecordBatch es, ו שלה (לכלכה) צורה צריך להיות [batch_size, 2] .

TensorRepresentation הוא Protobuf שהוגדר TensorFlow Metadata .

תאימות עם TensorFlow

tf.Transform מספק תמיכה עבור ייצוא transform_fn מעל או כמו 1.x TF או SavedModel 2.x TF. התנהגות ברירת המחדל לפני 0.30 שחרור ייצאה SavedModel 1.x TF. החל 0.30 שחרורו, שברירת המחדל היא לייצא SavedModel 2.x TF אלא התנהגויות 2.x TF מושבתים במפורש (על ידי התקשרות tf.compat.v1.disable_v2_behavior() למשל).

אם באמצעות מושגי 1.x TF כגון Estimators ו Sessions , אתה יכול לשמור את ההתנהגות הקודמת על ידי העברת force_tf_compat_v1=True כדי tft_beam.Context אם באמצעות tf.Transform כספריה עצמאית או Transform רכיב ב TFX.

כאשר ייצוא transform_fn בתור SavedModel 2.x TF, את preprocessing_fn צפוי להיות למעקב באמצעות tf.function . בנוסף, אם פועל צינור שלכם מרחוק (למשל עם DataflowRunner ), להבטיח כי preprocessing_fn וכל תלות ארוזים כראוי כפי שתואר כאן .

בעיות מוכרות עם שימוש tf.Transform לייצא 2.x TF SavedModel מתועד כאן .

קלט ופלט עם Apache Beam

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

PCollection הוא ייצוג נתונים המהווה חלק צינור Beam. צינור קרן נוצר על ידי יישום שונה PTransform ים, כולל AnalyzeDataset ו TransformDataset , וריצה בצנרת. PCollection לא הוקם לזכרו של בינארי העיקרי, אלא מופץ בקרב העובדים (אם כי סעיף זה משתמש במצב להורג ב-זיכרון).

טרום משומר PCollection מקורות ( TFXIO )

RecordBatch פורמט כי היישום שלנו מקבל הוא פורמט נפוץ כי ספריות TFX אחרות לקבל. לכן TFX הצעות נוח "מקורות" (aka TFXIO ) כי לקרוא קבצים בפורמטים שונים בדיסק ותוצרת RecordBatch es וגם יכול לתת TensorAdapterConfig , כולל להסיק TensorRepresentations .

אלה TFXIO ניתן למצוא ים בחבילה tfx_bsl ( tfx_bsl.public.tfxio ).

דוגמה: מערך נתונים של "הכנסה ממפקד האוכלוסין".

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

הנתונים הם בפורמט CSV, להלן שתי השורות הראשונות:

39, State-gov, 77516, Bachelors, 13, Never-married, Adm-clerical, Not-in-family, White, Male, 2174, 0, 40, United-States, <=50K
50, Self-emp-not-inc, 83311, Bachelors, 13, Married-civ-spouse, Exec-managerial, Husband, White, Male, 0, 0, 13, United-States, <=50K

העמודות של מערך הנתונים הן קטגוריות או מספריות. מערך נתונים זה מתאר בעיית סיווג: חיזוי העמודה האחרונה שבה האדם מרוויח יותר או פחות מ-50K בשנה. עם זאת, מנקודת המבט של tf.Transform , תווית זו היא רק עוד טור קטגורי.

אנו משתמשים טרום משומר TFXIO , BeamRecordCsvTFXIO לתרגם את קווי CSV לתוך RecordBatches . TFXIO דורש שתי פיסת מידע חשוב:

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

  • רשימה של שמות העמודות, לפי סדר הופעתן בקובץ ה-CSV. שים לב ששמות אלה חייבים להתאים לשמות התכונות בסכימה.

בדוגמה זו אנו מאפשרים education-num תכונה להיות חסר. אמצעי זה כי זה מיוצג tf.io.VarLenFeature ב feature_spec, וכתוצאה tf.SparseTensor ב preprocessing_fn . תכונות אחרות תהפוכנה tf.Tensor s באותו השם של preprocessing_fn .

csv_tfxio = tfxio.BeamRecordCsvTFXIO(
    physical_format='text', column_names=ordered_columns, schema=SCHEMA)

record_batches = (
    p
    | 'ReadTrainData' >> textio.ReadFromText(train_data_file)
    | ...  # fix up csv lines
    | 'ToRecordBatches' >> csv_tfxio.BeamSource())

tensor_adapter_config = csv_tfxio.TensorAdapterConfig()

. שים לב כי היינו צריכה לעשות כמה קופץ לתקן נוסף אחרי קווי CSV נקראות אחר, היינו יכולים לסמוך על CsvTFXIO לטפל היא קריאת קבצי תרגום ל RecordBatch es:

csv_tfxio = tfxio.CsvTFXIO(train_data_file, column_name=ordered_columns,
                           schema=SCHEMA)
record_batches = p | 'TFXIORead' >> csv_tfxio.BeamSource()
tensor_adapter_config = csv_tfxio.TensorAdapterConfig()

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

def preprocessing_fn(inputs):
  """Preprocess input columns into transformed columns."""
  # Since we are modifying some features and leaving others unchanged, we
  # start by setting `outputs` to a copy of `inputs.
  outputs = inputs.copy()

  # Scale numeric columns to have range [0, 1].
  for key in NUMERIC_FEATURE_KEYS:
    outputs[key] = tft.scale_to_0_1(outputs[key])

  for key in OPTIONAL_NUMERIC_FEATURE_KEYS:
    # This is a SparseTensor because it is optional. Here we fill in a default
    # value when it is missing.
      sparse = tf.sparse.SparseTensor(outputs[key].indices, outputs[key].values,
                                      [outputs[key].dense_shape[0], 1])
      dense = tf.sparse.to_dense(sp_input=sparse, default_value=0.)
    # Reshaping from a batch of vectors of size 1 to a batch to scalars.
    dense = tf.squeeze(dense, axis=1)
    outputs[key] = tft.scale_to_0_1(dense)

  # For all categorical columns except the label column, we generate a
  # vocabulary but do not modify the feature.  This vocabulary is instead
  # used in the trainer, by means of a feature column, to convert the feature
  # from a string to an integer id.
  for key in CATEGORICAL_FEATURE_KEYS:
    tft.vocabulary(inputs[key], vocab_filename=key)

  # For the label column we provide the mapping from string to index.
  initializer = tf.lookup.KeyValueTensorInitializer(
      keys=['>50K', '<=50K'],
      values=tf.cast(tf.range(2), tf.int64),
      key_dtype=tf.string,
      value_dtype=tf.int64)
  table = tf.lookup.StaticHashTable(initializer, default_value=-1)

  outputs[LABEL_KEY] = table.lookup(outputs[LABEL_KEY])

  return outputs

הבדל אחד מהדוגמה הקודמת הוא שעמודת התווית מציינת באופן ידני את המיפוי מהמחרוזת לאינדקס. אז '>50' ממופה 0 ו '<=50K' ממופה 1 כי זה שימושי לדעת אילו מדד התואם המודל המאומן אשר תווית.

record_batches משתנה מייצג PCollection של pyarrow.RecordBatch es. tensor_adapter_config ניתנת על ידי csv_tfxio , אשר להסיק SCHEMA (ובסופו של דבר, בדוגמה זו, מן המשקפיים ניתוח TF).

השלב האחרון הוא לכתוב את הנתונים שעברו טרנספורמציה לדיסק ויש לו צורה דומה לקריאת הנתונים הגולמיים. הסכימה נהגה לעשות זאת היא חלק הפלט של AnalyzeAndTransformDataset שבה הפרעות סכמה עבור נתון התפוקה. הקוד לכתיבה לדיסק מוצג להלן. הסכימה היא חלק metadata אלא משתמשת שני לסירוגין ב tf.Transform API (כלומר להעביר את מטה אל ExampleProtoCoder ). שים לב שזה כותב בפורמט אחר. במקום textio.WriteToText , להשתמש המובנה של Beam תמיכה TFRecord בפורמט ולהשתמש המתכנת כדי לקודד את הנתונים כפי Example Protos. זהו פורמט טוב יותר לשימוש לאימון, כפי שמוצג בסעיף הבא. transformed_eval_data_base מספק את שם קובץ בסיס לפיצולים הבודדים שהיה כתוב.

transformed_data | "WriteTrainData" >> tfrecordio.WriteToTFRecord(
    transformed_eval_data_base,
    coder=tft.coders.ExampleProtoCoder(transformed_metadata))

בנוסף לנתוני אימונים, transform_fn נכתבת מתוך גם עם מטה:

_ = (
    transform_fn
    | 'WriteTransformFn' >> tft_beam.WriteTransformFn(working_dir))
transformed_metadata | 'WriteMetadata' >> tft_beam.WriteMetadata(
    transformed_metadata_file, pipeline=p)

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

הורד את מערך הנתונים של המפקד

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

  wget https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data
  wget https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test

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

השתלב עם TensorFlow Training

החלק האחרון של census_example.py להראות כיצד הנתונים מעובדים משמש לאמן מודל. עיין בתיעוד האומד לפרטים. השלב הראשון הוא לבנות Estimator מחייב תיאור של עמודות מעובד. כל עמודה מספרית מתוארת real_valued_column כי הוא מעטפת סביב וקטור צפופה עם גודל קבוע ( 1 בדוגמה זו). הטור קטגורי כל ממופה מן מחרוזת מספרים שלמים ולאחר מכן מועברת לתוך indicator_column . tft.TFTransformOutput משמש כדי למצוא את נתיב קובץ אוצר מילים לכול תכונת קטגורים.

real_valued_columns = [feature_column.real_valued_column(key)
                       for key in NUMERIC_FEATURE_KEYS]

one_hot_columns = [
    tf.feature_column.indicator_column(
        tf.feature_column.categorical_column_with_vocabulary_file(
            key=key,
            vocabulary_file=tf_transform_output.vocabulary_file_by_name(
                vocab_filename=key)))
    for key in CATEGORICAL_FEATURE_KEYS]

estimator = tf.estimator.LinearClassifier(real_valued_columns + one_hot_columns)

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

def _make_training_input_fn(tf_transform_output, transformed_examples,
                            batch_size):
  ...
  def input_fn():
    """Input function for training and eval."""
    dataset = tf.data.experimental.make_batched_features_dataset(
        ..., tf_transform_output.transformed_feature_spec(), ...)

    transformed_features = tf.compat.v1.data.make_one_shot_iterator(
        dataset).get_next()
    ...

  return input_fn

קוד הנותרים זהה באמצעות Estimator בכיתה. הדוגמא מכילה גם קוד לייצא את המודל ב SavedModel הפורמט. המודל המיוצא יכול להיות בשימוש על ידי הצגת Tensorflow או מנוע ענן ML .