Tensorflow मॉडल विश्लेषण वास्तुकला

अवलोकन

TensorFlow मॉडल विश्लेषण (TFMA) पाइपलाइन को इस प्रकार दर्शाया गया है:

पाइपलाइन चार मुख्य घटकों से बना है:

• इनपुट पढ़ें
• निष्कर्षण
• मूल्यांकन
• परिणाम लिखें

ये घटक दो प्राथमिक प्रकारों का उपयोग करते हैं: tfma.Extracts और tfma.evaluators.Evaluation । प्रकार tfma.Extracts डेटा का प्रतिनिधित्व करता है जो पाइपलाइन प्रसंस्करण के दौरान निकाला जाता है और मॉडल के लिए एक या अधिक उदाहरणों के अनुरूप हो सकता है। tfma.evaluators.Evaluation निष्कर्षण की प्रक्रिया के दौरान विभिन्न बिंदुओं पर अर्क के मूल्यांकन से आउटपुट का प्रतिनिधित्व करता है। एक लचीला एपीआई प्रदान करने के लिए, ये प्रकार केवल डिक्ट हैं जहां विभिन्न कार्यान्वयन द्वारा कुंजियों को परिभाषित (उपयोग के लिए आरक्षित) किया जाता है। प्रकारों को निम्नानुसार परिभाषित किया गया है:

# Extracts represent data extracted during pipeline processing.
# For example, the PredictExtractor stores the data for the
# features, labels, and predictions under the keys "features",
# "labels", and "predictions".
Extracts = Dict[Text, Any]

# Evaluation represents the output from evaluating extracts at
# particular point in the pipeline. The evaluation outputs are
# keyed by their associated output type. For example, the metric / plot
# dictionaries from evaluating metrics and plots will be stored under
# "metrics" and "plots" respectively.
Evaluation = Dict[Text, beam.pvalue.PCollection]

ध्यान दें कि tfma.Extracts को कभी भी सीधे नहीं लिखा जाता है, उन्हें हमेशा एक tfma.evaluators.Evaluation तैयार करने के लिए एक मूल्यांकनकर्ता के माध्यम से जाना चाहिए। मूल्यांकन जो तब लिखा जाता है। यह भी ध्यान दें कि tfma.Extracts ऐसे dicts होते हैं जो एक बीम. beam.pvalue.PCollection में संग्रहीत होते हैं (अर्थात beam.PTransform s इनपुट beam.pvalue.PCollection[tfma.Extracts] के रूप में tfma.evaluators.Evaluation हैं। बीम हैं beam.pvalue.PCollection s (अर्थात बीम। beam.PTransform s स्वयं को बीम के लिए तर्क के रूप में लेते हैं। beam.value.PCollection इनपुट)। दूसरे शब्दों में tfma.evaluators.Evaluation का उपयोग पाइपलाइन निर्माण के समय किया जाता है, लेकिन tfma.Extracts का उपयोग पाइपलाइन रनटाइम पर किया जाता है।

इनपुट पढ़ें

ReadInputs चरण एक परिवर्तन से बना है जो कच्चे इनपुट (tf.train.Example, CSV, ...) लेता है और उन्हें अर्क में परिवर्तित करता है। आज अर्क को tfma.INPUT_KEY के तहत संग्रहीत कच्चे इनपुट बाइट्स के रूप में दर्शाया जाता है, हालांकि अर्क किसी भी रूप में हो सकता है जो निष्कर्षण पाइपलाइन के साथ संगत है - जिसका अर्थ है कि यह tfma.Extracts बनाता है। आउटपुट के रूप में अर्क, और यह कि वे अर्क डाउनस्ट्रीम के साथ संगत हैं निकालने वाले यह अलग-अलग एक्सट्रैक्टर्स पर निर्भर करता है कि वे स्पष्ट रूप से दस्तावेज करें कि उन्हें क्या चाहिए।

निष्कर्षण

निष्कर्षण प्रक्रिया बीम की एक सूची है। beam.PTransform एस जो श्रृंखला में चलाए जाते हैं। एक्सट्रैक्टर्स tfma.Extracts को इनपुट के रूप में लेते हैं और tfma.Extracts को आउटपुट के रूप में वापस करते हैं। प्रोटो-टिपिकल एक्सट्रैक्टर tfma.extractors.PredictExtractor है जो रीड इनपुट ट्रांसफॉर्म द्वारा उत्पादित इनपुट एक्सट्रैक्ट का उपयोग करता है और इसे एक मॉडल के माध्यम से प्रेडिक्शन एक्सट्रैक्ट्स का उत्पादन करने के लिए चलाता है। अनुकूलित एक्सट्रैक्टर्स को किसी भी बिंदु पर डाला जा सकता है बशर्ते उनके ट्रांसफॉर्म tfma.Extracts in और tfma.Extracts आउट API के अनुरूप हों। एक एक्सट्रैक्टर को निम्नानुसार परिभाषित किया गया है:

# An Extractor is a PTransform that takes Extracts as input and returns
# Extracts as output. A typical example is a PredictExtractor that receives
# an 'input' placeholder for input and adds additional 'predictions' extracts.
Extractor = NamedTuple('Extractor', [
    ('stage_name', Text),
    ('ptransform', beam.PTransform)])  # Extracts -> Extracts

इनपुट एक्सट्रैक्टर

tfma.extractors.InputExtractor का उपयोग tf.train.Example से कच्ची विशेषताओं, कच्चे लेबल और कच्चे उदाहरण भार को निकालने के लिए किया जाता है। मेट्रिक्स स्लाइसिंग और कंप्यूटेशंस में उपयोग के लिए उदाहरण रिकॉर्ड। डिफ़ॉल्ट रूप से मानों को क्रमशः एक्स्ट्रेक्ट कुंजी features , labels , और example_weights के अंतर्गत संग्रहीत किया जाता है। एकल-आउटपुट मॉडल लेबल और उदाहरण भार सीधे np.ndarray मानों के रूप में संग्रहीत किए जाते हैं। बहु-आउटपुट मॉडल लेबल और उदाहरण भार np.ndarray मानों (आउटपुट नाम से कुंजीबद्ध) के डिक्ट्स के रूप में संग्रहीत किए जाते हैं। यदि बहु-मॉडल मूल्यांकन किया जाता है तो लेबल और उदाहरण भार को एक और निर्देश (मॉडल नाम से कुंजीबद्ध) के भीतर एम्बेड किया जाएगा।

प्रेडिक्ट एक्सट्रैक्टर

tfma.extractors.PredictExtractor मॉडल भविष्यवाणियों को चलाता है और उन्हें tfma.Extracts dict में प्रमुख predictions के तहत संग्रहीत करता है। एकल-आउटपुट मॉडल भविष्यवाणियों को सीधे अनुमानित आउटपुट मानों के रूप में संग्रहीत किया जाता है। बहु-आउटपुट मॉडल भविष्यवाणियों को आउटपुट मानों (आउटपुट नाम से कुंजीबद्ध) के एक निर्देश के रूप में संग्रहीत किया जाता है। यदि बहु-मॉडल मूल्यांकन किया जाता है, तो भविष्यवाणी को एक और तानाशाही (मॉडल नाम से कुंजीबद्ध) के भीतर और एम्बेड किया जाएगा। उपयोग किया गया वास्तविक आउटपुट मान मॉडल पर निर्भर करता है (उदाहरण के लिए TF अनुमानक का रिटर्न आउटपुट एक तानाशाही के रूप में जबकि केरस np.ndarray मान देता है)।

स्लाइसकी एक्सट्रैक्टर

tfma.extractors.SliceKeyExtractor यह निर्धारित करने के लिए स्लाइसिंग स्पेक का उपयोग करता है कि कौन से स्लाइस निकाले गए फीचर्स के आधार पर प्रत्येक उदाहरण इनपुट पर लागू होते हैं और मूल्यांकनकर्ताओं द्वारा बाद में उपयोग के लिए संबंधित स्लाइसिंग मानों को निष्कर्षों में जोड़ते हैं।

मूल्यांकन

मूल्यांकन एक उद्धरण लेने और उसका मूल्यांकन करने की प्रक्रिया है। जबकि निष्कर्षण पाइपलाइन के अंत में मूल्यांकन करना आम बात है, ऐसे उपयोग-मामले हैं जिन्हें निष्कर्षण प्रक्रिया में पहले मूल्यांकन की आवश्यकता होती है। इस तरह के मूल्यांकनकर्ता उन एक्सट्रैक्टर्स से जुड़े होते हैं जिनके आउटपुट के खिलाफ उनका मूल्यांकन किया जाना चाहिए। एक मूल्यांकनकर्ता को निम्नानुसार परिभाषित किया गया है:

# An evaluator is a PTransform that takes Extracts as input and
# produces an Evaluation as output. A typical example of an evaluator
# is the MetricsAndPlotsEvaluator that takes the 'features', 'labels',
# and 'predictions' extracts from the PredictExtractor and evaluates
# them using post export metrics to produce metrics and plots dictionaries.
Evaluator = NamedTuple('Evaluator', [
  ('stage_name', Text),
  ('run_after', Text),              # Extractor.stage_name
  ('ptransform', beam.PTransform)]) # Extracts -> Evaluation

ध्यान दें कि एक मूल्यांकनकर्ता एक बीम है। beam.PTransform जो tfma.Extracts लेता है। इनपुट के रूप में निकालता है। मूल्यांकन प्रक्रिया के हिस्से के रूप में अर्क पर अतिरिक्त परिवर्तन करने से कार्यान्वयन को कोई रोक नहीं सकता है। एक्सट्रैक्टर्स के विपरीत जिन्हें tfma.Extracts dict वापस करना होगा, एक मूल्यांकनकर्ता द्वारा उत्पादित आउटपुट के प्रकारों पर कोई प्रतिबंध नहीं है, हालांकि अधिकांश मूल्यांकनकर्ता एक निर्देश भी लौटाते हैं (उदाहरण के लिए मीट्रिक नाम और मान)।

MetricsAndPlotsEvaluator

tfma.evaluators.MetricsAndPlotsEvaluator इनपुट के रूप में features , labels और predictions को लेता है, उन्हें tfma.slicer.FanoutSlices के माध्यम से स्लाइस द्वारा समूहित करने के लिए चलाता है, और फिर मेट्रिक्स और प्लॉट गणना करता है। यह मेट्रिक्स और प्लॉट कुंजियों और मूल्यों के शब्दकोशों के रूप में आउटपुट उत्पन्न करता है (इन्हें बाद में tfma.writers.MetricsAndPlotsWriter द्वारा आउटपुट के लिए क्रमबद्ध प्रोटो में परिवर्तित किया जाता है)।

परिणाम लिखें

WriteResults चरण वह जगह है जहां मूल्यांकन आउटपुट डिस्क पर लिखा जाता है। WriteResults आउटपुट कुंजियों के आधार पर डेटा लिखने के लिए लेखकों का उपयोग करता है। उदाहरण के लिए, एक tfma.evaluators.Evaluation में metrics और plots के लिए कुंजियाँ हो सकती हैं। इसके बाद ये मेट्रिक्स और प्लॉट डिक्शनरी से जुड़े होंगे जिन्हें 'मेट्रिक्स' और 'प्लॉट' कहा जाता है। लेखक निर्दिष्ट करते हैं कि प्रत्येक फ़ाइल को कैसे लिखना है:

# A writer is a PTransform that takes evaluation output as input and
# serializes the associated PCollections of data to a sink.
Writer = NamedTuple('Writer', [
  ('stage_name', Text),
  ('ptransform', beam.PTransform)])    # Evaluation -> PDone

MetricsAndPlotsWriter

हम एक tfma.writers.MetricsAndPlotsWriter प्रदान करते हैं जो मेट्रिक्स और प्लॉट शब्दकोशों को क्रमबद्ध प्रोटो में परिवर्तित करता है और उन्हें डिस्क पर लिखता है।

यदि आप एक अलग क्रमांकन प्रारूप का उपयोग करना चाहते हैं, तो आप एक कस्टम लेखक बना सकते हैं और इसके बजाय उसका उपयोग कर सकते हैं। चूंकि tfma.evaluators.Evaluation लेखकों को पास किया गया है, इसमें सभी मूल्यांकनकर्ताओं के लिए आउटपुट शामिल है, एक tfma.writers.Write सहायक रूपांतरण प्रदान किया जाता है कि लेखक उपयुक्त बीम का चयन करने के लिए अपने ptransform कार्यान्वयन में उपयोग कर सकते हैं। एक पर आधारित beam.PCollection s आउटपुट कुंजी (उदाहरण के लिए नीचे देखें)।

अनुकूलन

tfma.run_model_analysis पद्धति पाइपलाइन द्वारा उपयोग किए जाने वाले एक्सट्रैक्टर्स, मूल्यांकनकर्ताओं और लेखकों को अनुकूलित करने के लिए extractors , evaluators और writers के तर्क लेती है। यदि कोई तर्क प्रदान नहीं किया जाता है तो tfma.default_extractors , tfma.default_evaluators , और tfma.default_writers डिफ़ॉल्ट रूप से उपयोग किए जाते हैं।

कस्टम एक्सट्रैक्टर्स

एक कस्टम एक्स्ट्रेक्टर बनाने के लिए, एक tfma.extractors.Extractor प्रकार बनाएं जो एक बीम को लपेटता है। tfma.Extracts beam.PTransform ले रहा है। इनपुट के रूप में अर्क और tfma.Extracts लौटा रहा है। आउटपुट के रूप में अर्क। एक्सट्रैक्टर्स के उदाहरण tfma.extractors के अंतर्गत उपलब्ध हैं।

कस्टम मूल्यांकनकर्ता

एक कस्टम मूल्यांकनकर्ता बनाने के लिए, एक tfma.evaluators.Evaluator प्रकार बनाएं जो एक बीम को लपेटता है। beam.PTransform tfma.Extracts को इनपुट के रूप में लेता है और tfma.evaluators.Evaluation को आउटपुट के रूप में लौटाता है। एक बहुत ही बुनियादी मूल्यांकनकर्ता आने वाले tfma.Extracts को ले सकता है। उन्हें एक तालिका में संग्रहीत करने के लिए निकालें और आउटपुट करें। ठीक यही tfma.evaluators.AnalysisTableEvaluator करता है। एक अधिक जटिल मूल्यांकनकर्ता अतिरिक्त प्रसंस्करण और डेटा एकत्रीकरण कर सकता है। एक उदाहरण के रूप में tfma.evaluators.MetricsAndPlotsEvaluator देखें।

ध्यान दें कि tfma.evaluators.MetricsAndPlotsEvaluator को कस्टम मेट्रिक्स का समर्थन करने के लिए अनुकूलित किया जा सकता है (अधिक विवरण के लिए मेट्रिक्स देखें)।

कस्टम लेखक

एक कस्टम लेखक बनाने के लिए, एक tfma.writers.Writer प्रकार बनाएं जो एक बीम को लपेटता है। beam.PTransform को इनपुट के रूप में beam.pvalue.PDone tfma.evaluators.Evaluation । मेट्रिक्स युक्त TFRecords लिखने के लिए एक लेखक का मूल उदाहरण निम्नलिखित है:

tfma.writers.Writer(
  stage_name='WriteTFRecord(%s)' % tfma.METRICS_KEY,
  ptransform=tfma.writers.Write(
    key=tfma.METRICS_KEY,
    ptransform=beam.io.WriteToTFRecord(file_path_prefix=output_file))

एक लेखक का इनपुट संबद्ध मूल्यांकनकर्ता के आउटपुट पर निर्भर करता है। उपरोक्त उदाहरण के लिए, आउटपुट tfma.evaluators.MetricsAndPlotsEvaluator द्वारा निर्मित एक क्रमबद्ध प्रोटो है। tfma.evaluators.AnalysisTableEvaluator के लिए एक लेखक एक बीम लिखने के लिए जिम्मेदार होगा। beam.pvalue.PCollection का tfma.Extracts ।

ध्यान दें कि एक लेखक उपयोग की गई आउटपुट कुंजी (जैसे tfma.METRICS_KEY , tfma.ANALYSIS_KEY , आदि) के माध्यम से मूल्यांकनकर्ता के आउटपुट से जुड़ा होता है।

चरण दर चरण उदाहरण

निम्नलिखित निष्कर्षण और मूल्यांकन पाइपलाइन में शामिल चरणों का एक उदाहरण है जब tfma.evaluators.MetricsAndPlotsEvaluator और tfma.evaluators.AnalysisTableEvaluator दोनों का उपयोग किया जाता है:

run_model_analysis(
    ...
    extractors=[
        tfma.extractors.InputExtractor(...),
        tfma.extractors.PredictExtractor(...),
        tfma.extractors.SliceKeyExtrator(...)
    ],
    evaluators=[
        tfma.evaluators.MetricsAndPlotsEvaluator(...),
        tfma.evaluators.AnalysisTableEvaluator(...)
    ])

ReadInputs

# Out
Extracts {
  'input': bytes                 # CSV, Proto, ...
}

ExtractAndEvaluate

• tfma.extractors.InputExtractor

# In:  ReadInputs Extracts
# Out:
Extracts {
  'input': bytes                    # CSV, Proto, ...
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
}

• tfma.extractors.PredictExtractor

# In:  InputExtractor Extracts
# Out:
Extracts {
  'input': bytes                    # CSV, Proto, ...
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
  'predictions': tensor_like        # Predictions
}

• tfma.extractors.SliceKeyExtractor

# In: PredictExtractor Extracts
# Out:
Extracts {
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
  'predictions': tensor_like        # Predictions
  'slice_key': Tuple[bytes...]      # Slice
}

• tfma.evaluators.MetricsAndPlotsEvaluator (run_after: SLICE_KEY_EXTRACTOR_STAGE_NAME )

# In: SliceKeyExtractor Extracts
# Out:
Evaluation {
  'metrics': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from metric key to metric values)
  'plots': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from plot key to plot values)
}

• tfma.evaluators.AnalysisTableEvaluator (run_after: LAST_EXTRACTOR_STAGE_NAME )

# In: SliceKeyExtractor Extracts
# Out:
Evaluation {
  'analysis': PCollection[Extracts] # Final Extracts
}

WriteResults

# In:
Evaluation {
  'metrics': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from metric key to metric values)
  'plots': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from plot key to plot values)
  'analysis': PCollection[Extracts] # Final Extracts
}
# Out: metrics, plots, and analysis files