ट्यूनर टीएफएक्स पाइपलाइन घटक

ट्यूनर घटक मॉडल के लिए हाइपरपैरामीटर को ट्यून करता है।

ट्यूनर घटक और केरासट्यूनर लाइब्रेरी

ट्यूनर घटक हाइपरपैरामीटर ट्यूनिंग के लिए पायथन केरासट्यूनर एपीआई का व्यापक उपयोग करता है।

अवयव

ट्यूनर लेता है:

  • tf. उदाहरण प्रशिक्षण और eval के लिए उपयोग किया जाता है।
  • एक उपयोगकर्ता ने मॉड्यूल फ़ाइल (या मॉड्यूल fn) प्रदान की जो ट्यूनिंग तर्क को परिभाषित करता है, जिसमें मॉडल परिभाषा, हाइपरपैरामीटर खोज स्थान, उद्देश्य आदि शामिल हैं।
  • ट्रेन आर्ग और eval args की प्रोटोबफ परिभाषा।
  • (वैकल्पिक) ट्यूनिंग आर्ग की प्रोटोबफ परिभाषा।
  • (वैकल्पिक) अपस्ट्रीम ट्रांसफ़ॉर्म घटक द्वारा निर्मित ट्रांसफ़ॉर्म ग्राफ़।
  • (वैकल्पिक) एक स्कीमाजेन पाइपलाइन घटक द्वारा बनाई गई एक डेटा स्कीमा और वैकल्पिक रूप से डेवलपर द्वारा बदल दी गई।

दिए गए डेटा, मॉडल और उद्देश्य के साथ, ट्यूनर हाइपरपैरामीटर को ट्यून करता है और सर्वोत्तम परिणाम देता है।

निर्देश

ट्यूनर के लिए निम्नलिखित हस्ताक्षर के साथ एक उपयोगकर्ता मॉड्यूल फ़ंक्शन tuner_fn आवश्यक है:

...
from keras_tuner.engine import base_tuner

TunerFnResult = NamedTuple('TunerFnResult', [('tuner', base_tuner.BaseTuner),
                                             ('fit_kwargs', Dict[Text, Any])])

def tuner_fn(fn_args: FnArgs) -> TunerFnResult:
  """Build the tuner using the KerasTuner API.
  Args:
    fn_args: Holds args as name/value pairs.
      - working_dir: working dir for tuning.
      - train_files: List of file paths containing training tf.Example data.
      - eval_files: List of file paths containing eval tf.Example data.
      - train_steps: number of train steps.
      - eval_steps: number of eval steps.
      - schema_path: optional schema of the input data.
      - transform_graph_path: optional transform graph produced by TFT.
  Returns:
    A namedtuple contains the following:
      - tuner: A BaseTuner that will be used for tuning.
      - fit_kwargs: Args to pass to tuner's run_trial function for fitting the
                    model , e.g., the training and validation dataset. Required
                    args depend on the above tuner's implementation.
  """
  ...

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

ट्रेनर ट्यूनर के आउटपुट हाइपरपैरामीटर को इनपुट के रूप में ले सकता है और अपने यूजर मॉड्यूल कोड में उनका उपयोग कर सकता है। पाइपलाइन परिभाषा इस तरह दिखती है:

...
tuner = Tuner(
    module_file=module_file,  # Contains `tuner_fn`.
    examples=transform.outputs['transformed_examples'],
    transform_graph=transform.outputs['transform_graph'],
    train_args=trainer_pb2.TrainArgs(num_steps=20),
    eval_args=trainer_pb2.EvalArgs(num_steps=5))

trainer = Trainer(
    module_file=module_file,  # Contains `run_fn`.
    examples=transform.outputs['transformed_examples'],
    transform_graph=transform.outputs['transform_graph'],
    schema=schema_gen.outputs['schema'],
    # This will be passed to `run_fn`.
    hyperparameters=tuner.outputs['best_hyperparameters'],
    train_args=trainer_pb2.TrainArgs(num_steps=100),
    eval_args=trainer_pb2.EvalArgs(num_steps=5))
...

हो सकता है कि आप हर बार अपने मॉडल को फिर से प्रशिक्षित करने के लिए हाइपरपैरामीटर को ट्यून न करना चाहें। एक बार जब आप हाइपरपैरामीटर का एक अच्छा सेट निर्धारित करने के लिए ट्यूनर का उपयोग कर लेते हैं, तो आप ट्यूनर को अपनी पाइपलाइन से हटा सकते हैं और ट्रेनर को फीड करने के लिए पिछले प्रशिक्षण रन से ट्यूनर आर्टिफैक्ट को आयात करने के लिए ImporterNode का उपयोग कर सकते हैं।

hparams_importer = Importer(
    # This can be Tuner's output file or manually edited file. The file contains
    # text format of hyperparameters (keras_tuner.HyperParameters.get_config())
    source_uri='path/to/best_hyperparameters.txt',
    artifact_type=HyperParameters,
).with_id('import_hparams')

trainer = Trainer(
    ...
    # An alternative is directly use the tuned hyperparameters in Trainer's user
    # module code and set hyperparameters to None here.
    hyperparameters = hparams_importer.outputs['result'])

Google क्लाउड प्लेटफ़ॉर्म (GCP) पर ट्यूनिंग

Google क्लाउड प्लेटफ़ॉर्म (GCP) पर चलते समय, ट्यूनर घटक दो सेवाओं का लाभ उठा सकता है:

हाइपरपैरामीटर ट्यूनिंग के बैकएंड के रूप में एआई प्लेटफॉर्म विज़ियर

AI Platform Vizier एक प्रबंधित सेवा है जो Google Vizier तकनीक पर आधारित ब्लैक बॉक्स ऑप्टिमाइजेशन करती है।

CloudTuner , KerasTuner का एक कार्यान्वयन है जो अध्ययन बैकएंड के रूप में AI प्लेटफ़ॉर्म विज़ियर सेवा से बात करता है। चूंकि CloudTuner keras_tuner.Tuner का एक उपवर्ग है, इसे keras_tuner.Tuner मॉड्यूल में ड्रॉप-इन प्रतिस्थापन के रूप में उपयोग किया जा सकता है, और TFX ट्यूनर घटक के एक भाग के रूप में निष्पादित किया जा tuner_fn है।

नीचे एक कोड स्निपेट है जो दिखाता है कि CloudTuner का उपयोग कैसे करें। ध्यान दें कि CloudTuner के कॉन्फ़िगरेशन के लिए ऐसे आइटम की आवश्यकता होती है जो GCP के लिए विशिष्ट हों, जैसे कि project_id और region

...
from tensorflow_cloud import CloudTuner

...
def tuner_fn(fn_args: FnArgs) -> TunerFnResult:
  """An implementation of tuner_fn that instantiates CloudTuner."""

  ...
  tuner = CloudTuner(
      _build_model,
      hyperparameters=...,
      ...
      project_id=...,       # GCP Project ID
      region=...,           # GCP Region where Vizier service is run.
  )

  ...
  return TuneFnResult(
      tuner=tuner,
      fit_kwargs={...}
  )

क्लाउड एआई प्लेटफॉर्म पर समानांतर ट्यूनिंग प्रशिक्षण वितरित कार्यकर्ता झुंड

ट्यूनर घटक के अंतर्निहित कार्यान्वयन के रूप में केरासट्यूनर ढांचे में समानांतर में हाइपरपैरामीटर खोज करने की क्षमता है। जबकि स्टॉक ट्यूनर घटक में समानांतर में एक से अधिक खोज कार्यकर्ता को निष्पादित करने की क्षमता नहीं है, Google क्लाउड एआई प्लेटफ़ॉर्म एक्सटेंशन ट्यूनर घटक का उपयोग करके, यह वितरित कार्यकर्ता झुंड के रूप में एआई प्लेटफ़ॉर्म प्रशिक्षण कार्य का उपयोग करके समानांतर ट्यूनिंग चलाने की क्षमता प्रदान करता है। प्रबंधक। TuneArgs इस घटक को दिया गया कॉन्फ़िगरेशन है। यह स्टॉक ट्यूनर घटक का ड्रॉप-इन प्रतिस्थापन है।

tuner = google_cloud_ai_platform.Tuner(
    ...   # Same kwargs as the above stock Tuner component.
    tune_args=proto.TuneArgs(num_parallel_trials=3),  # 3-worker parallel
    custom_config={
        # Configures Cloud AI Platform-specific configs . For for details, see
        # https://cloud.google.com/ai-platform/training/docs/reference/rest/v1/projects.jobs#traininginput.
        TUNING_ARGS_KEY:
            {
                'project': ...,
                'region': ...,
                # Configuration of machines for each master/worker in the flock.
                'masterConfig': ...,
                'workerConfig': ...,
                ...
            }
    })
...

विस्तार ट्यूनर घटक का व्यवहार और आउटपुट स्टॉक ट्यूनर घटक के समान है, सिवाय इसके कि कई हाइपरपैरामीटर खोजों को विभिन्न कार्यकर्ता मशीनों पर समानांतर में निष्पादित किया जाता है, और परिणामस्वरूप, num_trials तेजी से पूरा हो जाएगा। यह विशेष रूप से तब प्रभावी होता है जब खोज एल्गोरिथम शर्मनाक रूप से समानांतर करने योग्य होता है, जैसे कि RandomSearch । हालाँकि, यदि खोज एल्गोरिथ्म पूर्व परीक्षणों के परिणामों से जानकारी का उपयोग करता है, जैसे कि एआई प्लेटफ़ॉर्म विज़ियर में कार्यान्वित Google विज़ियर एल्गोरिथम करता है, तो अत्यधिक समानांतर खोज खोज की प्रभावकारिता को नकारात्मक रूप से प्रभावित करेगी।

E2E उदाहरण

GCP उदाहरण पर E2E CloudTuner

केरासट्यूनर ट्यूटोरियल

क्लाउडट्यूनर ट्यूटोरियल

प्रस्ताव

अधिक विवरण ट्यूनर एपीआई संदर्भ में उपलब्ध हैं।