उदाहरण कुंजी के साथ प्रशिक्षण और भविष्यवाणी

Question

मैं अपने मॉडल को प्रशिक्षित करने और भविष्यवाणी के लिए एमएल इंजन का उपयोग करने में सक्षम हूं लेकिन मेरे परिणामों में कोई पहचान जानकारी शामिल नहीं है। भविष्यवाणी के लिए एक समय में एक पंक्ति सबमिट करते समय यह ठीक काम करता है लेकिन एकाधिक पंक्तियों को सबमिट करते समय मेरे पास भविष्यवाणी को मूल इनपुट डेटा से जोड़ने का कोई तरीका नहीं है। GCP documentation इंस्टेंस कुंजियों का उपयोग करके चर्चा करता है लेकिन मुझे कोई उदाहरण कोड नहीं मिल रहा है जो एक आवृत्ति कुंजी का उपयोग करके ट्रेनों और भविष्यवाणी करता है। जीसीपी जनगणना उदाहरण लेना उदाहरण के लिए मैं ग्राफ़ के माध्यम से एक अद्वितीय आईडी पास करने के लिए इनपुट फ़ंक्शंस को कैसे अपडेट करूं और प्रशिक्षण के दौरान इसे अनदेखा करूँगा फिर भी भविष्यवाणी के साथ अद्वितीय आईडी वापस करूँगा? या वैकल्पिक रूप से यदि कोई भी पहले से ही चाबियों का उपयोग कर एक अलग उदाहरण के बारे में जानता है जो भी मदद करेगा।

Census Estimator Sample से

def serving_input_fn(): 
    feature_placeholders = { 
     column.name: tf.placeholder(column.dtype, [None]) 
     for column in INPUT_COLUMNS 
    } 

    features = { 
     key: tf.expand_dims(tensor, -1) 
     for key, tensor in feature_placeholders.items() 
    } 

    return input_fn_utils.InputFnOps(
     features, 
     None, 
     feature_placeholders 
    ) 


def generate_input_fn(filenames, 
        num_epochs=None, 
        shuffle=True, 
        skip_header_lines=0, 
        batch_size=40): 

    def _input_fn(): 
     files = tf.concat([ 
      tf.train.match_filenames_once(filename) 
      for filename in filenames 
     ], axis=0) 

     filename_queue = tf.train.string_input_producer(
      files, num_epochs=num_epochs, shuffle=shuffle) 
     reader = tf.TextLineReader(skip_header_lines=skip_header_lines) 

     _, rows = reader.read_up_to(filename_queue, num_records=batch_size) 

     row_columns = tf.expand_dims(rows, -1) 
     columns = tf.decode_csv(row_columns, record_defaults=CSV_COLUMN_DEFAULTS) 
     features = dict(zip(CSV_COLUMNS, columns)) 

     # Remove unused columns 
     for col in UNUSED_COLUMNS: 
      features.pop(col) 

     if shuffle: 
      features = tf.train.shuffle_batch(
      features, 
      batch_size, 
      capacity=batch_size * 10, 
      min_after_dequeue=batch_size*2 + 1, 
      num_threads=multiprocessing.cpu_count(), 
      enqueue_many=True, 
      allow_smaller_final_batch=True 
      ) 
     label_tensor = parse_label_column(features.pop(LABEL_COLUMN)) 
     return features, label_tensor 

    return _input_fn 

अद्यतन: मैं यह थोड़ा परिवर्तन करने के लिए सिर्फ भविष्यवाणी dict के बजाय model_fn_ops में उत्पादन विकल्प अद्यतन करने के लिए मैं बस जरूरत this answer below से सुझाव कोड का उपयोग करने में सक्षम था। हालांकि, यह केवल तभी काम करता है जब मेरा सेवारत इनपुट फ़ंक्शन this जैसा जेसन इनपुट के लिए कोड किया गया हो। मेरा सेवारत इनपुट फ़ंक्शन पहले Census Core Sample में CSV सेवारत इनपुट फ़ंक्शन के बाद मॉडलिंग किया गया था।

मुझे लगता है कि मेरी समस्या build_standardized_signature_def फ़ंक्शन से आ रही है और इससे भी अधिक is_classification_problem फ़ंक्शन जो कॉल करता है। Csv सेवारत फ़ंक्शन का उपयोग करते हुए इनपुट dict लंबाई 1 है इसलिए यह तर्क classification_signature_def का उपयोग करके समाप्त होता है जो केवल स्कोर प्रदर्शित करता है (जो वास्तव में probabilities है) जबकि इनपुट dict की लंबाई जेसन सेवा इनपुट फ़ंक्शन के साथ 1 से अधिक है और इसके बजाय predict_signature_def का उपयोग किया जाता है जिसमें सभी आउटपुट शामिल होते हैं।

Answer 1

अद्यतन: ऑनलाइन भविष्यवाणी के लिए आप की तरह एक JSON अनुरोध के साथ ऊपर ग्राफ query हैं संस्करण 1.3 योगदान आकलनकर्ता (उदाहरण के लिए tf.contrib.learn.DNNClassifier) ​​में, कोर आकलनकर्ता से विरासत के लिए बदले गये क्लास tf.estimator.Estimator जो इसके पूर्ववर्ती के विपरीत है, मॉडल फ़ंक्शन को एक निजी श्रेणी के सदस्य के रूप में छुपाता है, इसलिए आपको के साथ नीचे दिए गए समाधान में estimator.model_fn को प्रतिस्थापित करने की आवश्यकता होगी।

जोश का जवाब आपको फूल उदाहरण के लिए इंगित करता है, जो एक कस्टम अनुमानक का उपयोग करना चाहते हैं, तो यह एक अच्छा समाधान है। यदि आप डिब्बाबंद अनुमानक के साथ रहना चाहते हैं, (उदा। tf.contrib.learn.DNNClassifiers) तो आप इसे एक कस्टम अनुमानक में लपेट सकते हैं जो कुंजी के लिए समर्थन जोड़ता है। (नोट: मुझे लगता है कि जब संभवतः वे कोर में जाते हैं तो डिब्बाबंद अनुमानक मुख्य समर्थन प्राप्त करेंगे)।

KEY = 'key' 
def key_model_fn_gen(estimator): 
    def _model_fn(features, labels, mode, params): 
     key = features.pop(KEY, None) 
     model_fn_ops = estimator.model_fn(
      features=features, labels=labels, mode=mode, params=params) 
     if key: 
      model_fn_ops.predictions[KEY] = key 
      # This line makes it so the exported SavedModel will also require a key 
      model_fn_ops.output_alternatives[None][1][KEY] = key 
     return model_fn_ops 
    return _model_fn 

my_key_estimator = tf.contrib.learn.Estimator(
    model_fn=key_model_fn_gen(
     tf.contrib.learn.DNNClassifier(model_dir=model_dir...) 
    ), 
    model_dir=model_dir 
) 

my_key_estimator तो, वास्तव में की तरह अपने DNNClassifier इस्तेमाल किया जाएगा इस्तेमाल किया जा सकता को छोड़कर यह input_fns (भविष्यवाणी, मूल्यांकन और प्रशिक्षण) से नाम 'key' साथ एक सुविधा की उम्मीद होगी।

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

def json_serving_input_fn(): 
    inputs = # ... input_dict as before 
    inputs[KEY] = tf.placeholder([None], dtype=tf.int64) 
    features = # .. feature dict made from input_dict as before 
    tf.contrib.learn.InputFnOps(features, None, inputs) 

(1,2 और 1.3 के बीच थोड़ा अलग, के रूप में tf.contrib.learn.InputFnOpstf.estimator.export.ServingInputReceiver साथ बदल दिया है, और गद्दी tensors 2 रैंक करने के लिए अब 1.3 में आवश्यक है)

फिर एमएल इंजन आपके पूर्वानुमान अनुरोध के साथ "कुंजी" नामक एक टेंसर भेज देगा, जो आपके मॉडल को और आपकी भविष्यवाणियों के माध्यम से पारित किया जाएगा।

EDIT3: संशोधित key_model_fn_gen अनुपलब्ध कुंजी मानों को अनदेखा करने के समर्थन में। EDIT4: भविष्यवाणी के लिए जोड़ा गया कुंजी

Answer 2

शानदार सवाल। क्लाउड एमएल इंजन flowers sample यह इनपुट से आउटपुट के माध्यम से सीधे एक स्ट्रिंग पास करने के लिए tf.identity ऑपरेशन का उपयोग करके करता है। graph construction के दौरान प्रासंगिक रेखाएं यहां दी गई हैं। "Some_key_value" अपने उदाहरण रिकॉर्ड में:

keys_placeholder = tf.placeholder(tf.string, shape=[None]) 
inputs = { 
    'key': keys_placeholder, 
    'image_bytes': tensors.input_jpeg 
} 

# To extract the id, we need to add the identity function. 
keys = tf.identity(keys_placeholder) 
outputs = { 
    'key': keys, 
    'prediction': tensors.predictions[0], 
    'scores': tensors.predictions[1] 
} 

बैच भविष्यवाणी के लिए आप "कुंजी" डालने के लिए की जरूरत है।

{'instances' : [ 
    {'key': 'first_key', 'image_bytes' : {'b64': ...}}, 
    {'key': 'second_key', 'image_bytes': {'b64': ...}} 
    ] 
}