तिथि को रक्षित करें! Google I / O 18-20 मई को पंजीकृत करता है
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

केर प्रीप्रोसेसिंग लेयर्स का उपयोग करके संरचित डेटा को वर्गीकृत करें

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

यह ट्यूटोरियल दर्शाता है कि संरचित डेटा (जैसे CSV में सारणीबद्ध डेटा) को कैसे वर्गीकृत किया जाए। आप का उपयोग करेगा Keras मॉडल को परिभाषित करने के लिए, और preprocessing परतों मॉडल प्रशिक्षित करने के लिए इस्तेमाल किया सुविधाओं के लिए आप CSV में स्तंभों से मैप करने के लिए एक सेतु के रूप। इस ट्यूटोरियल में पूरा कोड शामिल है:

  • पंडों का उपयोग करके एक सीएसवी फ़ाइल लोड करें।
  • बैच के लिए एक इनपुट पाइपलाइन बनाएँ और tf.data का उपयोग करके पंक्तियों को फेरबदल करें।
  • सीएसआर में कॉलम से लेकर केरेस प्रीप्रोसेसिंग परतों का उपयोग करके मॉडल को प्रशिक्षित करने के लिए उपयोग की जाने वाली सुविधाएँ।
  • केर का उपयोग करके एक मॉडल का निर्माण, प्रशिक्षण और मूल्यांकन करें।

द डेटसेट

आप पेटींडर डेटासेट के सरलीकृत संस्करण का उपयोग करेंगे। CSV में कई हजार पंक्तियाँ हैं। प्रत्येक पंक्ति एक पालतू जानवर का वर्णन करती है, और प्रत्येक स्तंभ एक विशेषता का वर्णन करता है। आप इस जानकारी का उपयोग भविष्यवाणी करने के लिए करेंगे कि क्या पालतू जानवर को गोद लिया जाएगा।

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

स्तंभ विवरण फ़ीचर प्रकार डेटा प्रकार
प्रकार जानवर का प्रकार (कुत्ता, बिल्ली) स्पष्ट तार
उम्र पालतू जानवर की आयु न्यूमेरिकल पूर्णांक
नस्ल 1 पालतू जानवर की प्राथमिक नस्ल स्पष्ट तार
रंग 1 पालतू जानवर का रंग 1 स्पष्ट तार
रंग 2 पालतू का रंग २ स्पष्ट तार
परिपक्वता आकार परिपक्वता पर स्पष्ट तार
फुर्सत फर लंबाई स्पष्ट तार
टीका लगाया पालतू जानवरों को टीका लगाया गया है स्पष्ट तार
रोगाणु पालतू जानवरों की नसबंदी की गई है स्पष्ट तार
स्वास्थ्य स्वास्थ्य की स्थिति स्पष्ट तार
शुल्क गोद लेने की फीस न्यूमेरिकल पूर्णांक
विवरण इस पालतू जानवर के लिए प्रोफाइल राइट-अप टेक्स्ट तार
PhotoAmt इस पालतू जानवर के लिए कुल अपलोड की गई तस्वीरें न्यूमेरिकल पूर्णांक
दत्तक ग्रहण गोद लेने की गति वर्गीकरण पूर्णांक

TensorFlow और अन्य पुस्तकालयों को आयात करें

pip install -q sklearn
import numpy as np
import pandas as pd
import tensorflow as tf

from sklearn.model_selection import train_test_split
from tensorflow.keras import layers
from tensorflow.keras.layers.experimental import preprocessing

डेटाफ्रेम बनाने के लिए पंडों का उपयोग करें

पंडों एक पायथन लाइब्रेरी है जिसमें संरचित डेटा के साथ लोड करने और काम करने के लिए कई उपयोगी उपयोगिताओं हैं। आप URL से डेटासेट डाउनलोड करने के लिए पंडों का उपयोग करेंगे, और इसे डेटाफ्रेम में लोड करेंगे।

import pathlib

dataset_url = 'http://storage.googleapis.com/download.tensorflow.org/data/petfinder-mini.zip'
csv_file = 'datasets/petfinder-mini/petfinder-mini.csv'

tf.keras.utils.get_file('petfinder_mini.zip', dataset_url,
                        extract=True, cache_dir='.')
dataframe = pd.read_csv(csv_file)
Downloading data from http://storage.googleapis.com/download.tensorflow.org/data/petfinder-mini.zip
1671168/1668792 [==============================] - 0s 0us/step
dataframe.head()

लक्ष्य चर बनाएं

कागल प्रतियोगिता में कार्य उस गति की भविष्यवाणी करना है जिस पर एक पालतू जानवर को अपनाया जाएगा (जैसे, पहले सप्ताह में, पहले महीने, पहले तीन महीने, और इसी तरह)। आइए इसे हमारे ट्यूटोरियल के लिए सरल करें। यहां, आप इसे एक द्विआधारी वर्गीकरण समस्या में बदल देंगे, और बस यह अनुमान लगाएंगे कि क्या पालतू को अपनाया गया था या नहीं।

लेबल कॉलम को संशोधित करने के बाद, 0 इंगित करेगा कि पालतू को नहीं अपनाया गया था, और 1 इंगित करेगा कि यह था।

# In the original dataset "4" indicates the pet was not adopted.
dataframe['target'] = np.where(dataframe['AdoptionSpeed']==4, 0, 1)

# Drop un-used columns.
dataframe = dataframe.drop(columns=['AdoptionSpeed', 'Description'])

डेटाफ़्रेम को ट्रेन, सत्यापन और परीक्षण में विभाजित करें

आपके द्वारा डाउनलोड किया गया डेटासेट एक एकल CSV फ़ाइल थी। आप इसे ट्रेन, सत्यापन और परीक्षण सेटों में विभाजित करेंगे।

train, test = train_test_split(dataframe, test_size=0.2)
train, val = train_test_split(train, test_size=0.2)
print(len(train), 'train examples')
print(len(val), 'validation examples')
print(len(test), 'test examples')
7383 train examples
1846 validation examples
2308 test examples

Tf.data का उपयोग करके एक इनपुट पाइपलाइन बनाएं

इसके बाद, आप डेटा को फेरबदल करने और बैच करने के लिए tf.data के साथ डेटाफ्रेम लपेटेंगे । यदि आप एक बहुत बड़ी CSV फ़ाइल (इतनी बड़ी कि यह मेमोरी में फिट नहीं होती है) के साथ काम कर रहे थे, तो आप इसे सीधे डिस्क से पढ़ने के लिए tf.data का उपयोग करेंगे। यह इस ट्यूटोरियल में शामिल नहीं है।

# A utility method to create a tf.data dataset from a Pandas Dataframe
def df_to_dataset(dataframe, shuffle=True, batch_size=32):
  dataframe = dataframe.copy()
  labels = dataframe.pop('target')
  ds = tf.data.Dataset.from_tensor_slices((dict(dataframe), labels))
  if shuffle:
    ds = ds.shuffle(buffer_size=len(dataframe))
  ds = ds.batch(batch_size)
  ds = ds.prefetch(batch_size)
  return ds

अब जब आपने इनपुट पाइपलाइन बना ली है, तो इसे उस डेटा के प्रारूप को देखने के लिए कॉल करें, जो इसे लौटाता है। आपने आउटपुट को पठनीय रखने के लिए एक छोटे बैच आकार का उपयोग किया है।

batch_size = 5
train_ds = df_to_dataset(train, batch_size=batch_size)
[(train_features, label_batch)] = train_ds.take(1)
print('Every feature:', list(train_features.keys()))
print('A batch of ages:', train_features['Age'])
print('A batch of targets:', label_batch )
Every feature: ['Type', 'Age', 'Breed1', 'Gender', 'Color1', 'Color2', 'MaturitySize', 'FurLength', 'Vaccinated', 'Sterilized', 'Health', 'Fee', 'PhotoAmt']
A batch of ages: tf.Tensor([ 2  2 18  2  1], shape=(5,), dtype=int64)
A batch of targets: tf.Tensor([1 1 0 1 1], shape=(5,), dtype=int64)

आप देख सकते हैं कि डेटासेट में डेटा से पंक्तियों में कॉलम मानों के लिए डेटासेट (डेटाफ़्रेम से) का एक शब्दकोश लौटाता है।

प्रीप्रोसेसिंग परतों के उपयोग का प्रदर्शन।

केरस प्रीप्रोसेसिंग लेयर एपीआई आपको केरस-देशी इनपुट प्रोसेसिंग पाइपलाइन बनाने की अनुमति देता है। सुविधा प्रीप्रोसेसिंग कोड प्रदर्शित करने के लिए आप 3 प्रीप्रोसेसिंग परतों का उपयोग करेंगे।

  • Normalization - डेटा का फ़ीचर-वार सामान्यीकरण।
  • CategoryEncoding - श्रेणी एन्कोडिंग परत।
  • StringLookup - मैप्स एक शब्दावली से पूर्णांक सूचकांकों तक StringLookup
  • IntegerLookup - एक शब्दावली से पूर्णांक सूचकांकों में पूर्णांक को मैप करता है।

आप यहां उपलब्ध प्रीप्रोसेसिंग परतों की एक सूची पा सकते हैं।

संख्यात्मक स्तंभ

प्रत्येक न्यूमेरिक फीचर के लिए, आप एक नॉरमलाइजेशन () लेयर का उपयोग करेंगे ताकि यह सुनिश्चित किया जा सके कि प्रत्येक फीचर का माध्य 0 है और इसका मानक विचलन 1 है।

get_normalization_layer फ़ंक्शन एक परत देता है जो संख्यात्मक विशेषताओं में फ़ीचरवाइज़ सामान्यीकरण लागू करता है।

def get_normalization_layer(name, dataset):
  # Create a Normalization layer for our feature.
  normalizer = preprocessing.Normalization()

  # Prepare a Dataset that only yields our feature.
  feature_ds = dataset.map(lambda x, y: x[name])

  # Learn the statistics of the data.
  normalizer.adapt(feature_ds)

  return normalizer
photo_count_col = train_features['PhotoAmt']
layer = get_normalization_layer('PhotoAmt', train_ds)
layer(photo_count_col)
<tf.Tensor: shape=(5, 1), dtype=float32, numpy=
array([[ 1.045485  ],
       [-1.1339161 ],
       [-0.19988704],
       [ 0.11145599],
       [ 0.42279902]], dtype=float32)>

श्रेणीबद्ध स्तंभ

इस डेटासेट में, टाइप को एक स्ट्रिंग (जैसे 'डॉग', या 'कैट') के रूप में दर्शाया गया है। आप सीधे किसी मॉडल को स्ट्रिंग्स नहीं खिला सकते हैं। प्रीप्रोसेसिंग परत एक-गर्म वेक्टर के रूप में तारों का प्रतिनिधित्व करने का ख्याल रखती है।

get_category_encoding_layer फ़ंक्शन एक परत देता है जो एक शब्दावली से पूर्णांक सूचकांकों तक मानों को मैप करता है और एक-गर्म सुविधाओं को एन्कोड करता है।

def get_category_encoding_layer(name, dataset, dtype, max_tokens=None):
  # Create a StringLookup layer which will turn strings into integer indices
  if dtype == 'string':
    index = preprocessing.StringLookup(max_tokens=max_tokens)
  else:
    index = preprocessing.IntegerLookup(max_values=max_tokens)

  # Prepare a Dataset that only yields our feature
  feature_ds = dataset.map(lambda x, y: x[name])

  # Learn the set of possible values and assign them a fixed integer index.
  index.adapt(feature_ds)

  # Create a Discretization for our integer indices.
  encoder = preprocessing.CategoryEncoding(max_tokens=index.vocab_size())

  # Prepare a Dataset that only yields our feature.
  feature_ds = feature_ds.map(index)

  # Learn the space of possible indices.
  encoder.adapt(feature_ds)

  # Apply one-hot encoding to our indices. The lambda function captures the
  # layer so we can use them, or include them in the functional model later.
  return lambda feature: encoder(index(feature))
type_col = train_features['Type']
layer = get_category_encoding_layer('Type', train_ds, 'string')
layer(type_col)
<tf.Tensor: shape=(5, 4), dtype=float32, numpy=
array([[0., 0., 0., 1.],
       [0., 0., 0., 1.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.],
       [0., 0., 1., 0.]], dtype=float32)>

अक्सर, आप सीधे मॉडल में एक नंबर फीड नहीं करना चाहते हैं, लेकिन इसके बजाय उन इनपुट के एक-गर्म एन्कोडिंग का उपयोग करें। कच्चे डेटा पर विचार करें जो एक पालतू जानवर की उम्र का प्रतिनिधित्व करता है।

type_col = train_features['Age']
category_encoding_layer = get_category_encoding_layer('Age', train_ds,
                                                      'int64', 5)
category_encoding_layer(type_col)
<tf.Tensor: shape=(5, 5), dtype=float32, numpy=
array([[0., 0., 1., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 0., 1.]], dtype=float32)>

चुनें कि कौन से कॉलम का उपयोग करना है

आपने देखा है कि कई प्रकार की प्रीप्रोसेसिंग परतों का उपयोग कैसे करें। अब आप उन्हें एक मॉडल को प्रशिक्षित करने के लिए उपयोग करेंगे। मॉडल बनाने के लिए आप केरस-कार्यात्मक एपीआई का उपयोग करेंगे। केरस कार्यात्मक एपीआई मॉडल बनाने का एक तरीका है जो tf.keras.Sequential API से अधिक लचीला है।

इस ट्यूटोरियल का लक्ष्य आपको प्रीप्रोसेसिंग परतों के साथ काम करने के लिए आवश्यक पूरा कोड (जैसे यांत्रिकी) दिखाना है। हमारे मॉडल को प्रशिक्षित करने के लिए कुछ कॉलम मनमाने ढंग से चुने गए हैं।

इससे पहले, आपने इनपुट पाइपलाइन को प्रदर्शित करने के लिए एक छोटे बैच आकार का उपयोग किया था। आइए अब एक बड़े बैच आकार के साथ एक नई इनपुट पाइपलाइन बनाएं।

batch_size = 256
train_ds = df_to_dataset(train, batch_size=batch_size)
val_ds = df_to_dataset(val, shuffle=False, batch_size=batch_size)
test_ds = df_to_dataset(test, shuffle=False, batch_size=batch_size)
all_inputs = []
encoded_features = []

# Numeric features.
for header in ['PhotoAmt', 'Fee']:
  numeric_col = tf.keras.Input(shape=(1,), name=header)
  normalization_layer = get_normalization_layer(header, train_ds)
  encoded_numeric_col = normalization_layer(numeric_col)
  all_inputs.append(numeric_col)
  encoded_features.append(encoded_numeric_col)
# Categorical features encoded as integers.
age_col = tf.keras.Input(shape=(1,), name='Age', dtype='int64')
encoding_layer = get_category_encoding_layer('Age', train_ds, dtype='int64',
                                             max_tokens=5)
encoded_age_col = encoding_layer(age_col)
all_inputs.append(age_col)
encoded_features.append(encoded_age_col)
# Categorical features encoded as string.
categorical_cols = ['Type', 'Color1', 'Color2', 'Gender', 'MaturitySize',
                    'FurLength', 'Vaccinated', 'Sterilized', 'Health', 'Breed1']
for header in categorical_cols:
  categorical_col = tf.keras.Input(shape=(1,), name=header, dtype='string')
  encoding_layer = get_category_encoding_layer(header, train_ds, dtype='string',
                                               max_tokens=5)
  encoded_categorical_col = encoding_layer(categorical_col)
  all_inputs.append(categorical_col)
  encoded_features.append(encoded_categorical_col)

मॉडल बनाएं, संकलित करें और प्रशिक्षित करें

अब आप हमारा एंड-टू-एंड मॉडल बना सकते हैं।

all_features = tf.keras.layers.concatenate(encoded_features)
x = tf.keras.layers.Dense(32, activation="relu")(all_features)
x = tf.keras.layers.Dropout(0.5)(x)
output = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(all_inputs, output)
model.compile(optimizer='adam',
              loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
              metrics=["accuracy"])

आइए हमारे कनेक्टिविटी ग्राफ की कल्पना करें:

# rankdir='LR' is used to make the graph horizontal.
tf.keras.utils.plot_model(model, show_shapes=True, rankdir="LR")

पींग

मॉडल को प्रशिक्षित करें

model.fit(train_ds, epochs=10, validation_data=val_ds)
Epoch 1/10
29/29 [==============================] - 0s 15ms/step - loss: 0.6088 - accuracy: 0.5924 - val_loss: 0.5623 - val_accuracy: 0.7302
Epoch 2/10
29/29 [==============================] - 0s 6ms/step - loss: 0.5766 - accuracy: 0.6833 - val_loss: 0.5459 - val_accuracy: 0.7356
Epoch 3/10
29/29 [==============================] - 0s 6ms/step - loss: 0.5579 - accuracy: 0.6981 - val_loss: 0.5364 - val_accuracy: 0.7362
Epoch 4/10
29/29 [==============================] - 0s 6ms/step - loss: 0.5467 - accuracy: 0.7127 - val_loss: 0.5287 - val_accuracy: 0.7313
Epoch 5/10
29/29 [==============================] - 0s 6ms/step - loss: 0.5401 - accuracy: 0.7059 - val_loss: 0.5240 - val_accuracy: 0.7329
Epoch 6/10
29/29 [==============================] - 0s 6ms/step - loss: 0.5362 - accuracy: 0.7222 - val_loss: 0.5203 - val_accuracy: 0.7313
Epoch 7/10
29/29 [==============================] - 0s 6ms/step - loss: 0.5290 - accuracy: 0.7189 - val_loss: 0.5172 - val_accuracy: 0.7297
Epoch 8/10
29/29 [==============================] - 0s 6ms/step - loss: 0.5273 - accuracy: 0.7172 - val_loss: 0.5151 - val_accuracy: 0.7286
Epoch 9/10
29/29 [==============================] - 0s 6ms/step - loss: 0.5236 - accuracy: 0.7210 - val_loss: 0.5127 - val_accuracy: 0.7291
Epoch 10/10
29/29 [==============================] - 0s 6ms/step - loss: 0.5200 - accuracy: 0.7219 - val_loss: 0.5112 - val_accuracy: 0.7297
<tensorflow.python.keras.callbacks.History at 0x7f6fc8e61f98>
loss, accuracy = model.evaluate(test_ds)
print("Accuracy", accuracy)
10/10 [==============================] - 0s 4ms/step - loss: 0.5232 - accuracy: 0.7370
Accuracy 0.7370017170906067

नए डेटा पर आक्रमण

अब आप Keras मॉडल को सहेज और पुनः लोड कर सकते हैं। TensorFlow मॉडल के बारे में अधिक जानकारी के लिए यहाँ ट्यूटोरियल का अनुसरण करें।

model.save('my_pet_classifier')
reloaded_model = tf.keras.models.load_model('my_pet_classifier')
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: my_pet_classifier/assets
WARNING:tensorflow:5 out of the last 5 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6fc8b82400> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:6 out of the last 6 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6fc8b82d08> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:7 out of the last 7 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6fc8b611e0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:8 out of the last 8 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6fc8b857b8> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:9 out of the last 9 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6f6870b158> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:10 out of the last 10 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6f6870bd08> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:11 out of the last 11 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6fc8b6abf8> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.

एक नए नमूने के लिए एक भविष्यवाणी प्राप्त करने के लिए, आप बस model.predict() कह सकते हैं। आपको बस दो काम करने हैं:

  1. एक सूची में स्केल लपेटें ताकि बैच आयाम हो (मॉडल केवल डेटा के बैचों को संसाधित करते हैं, एकल नमूने नहीं)
  2. प्रत्येक सुविधा पर convert_to_tensor को कॉल करें
sample = {
    'Type': 'Cat',
    'Age': 3,
    'Breed1': 'Tabby',
    'Gender': 'Male',
    'Color1': 'Black',
    'Color2': 'White',
    'MaturitySize': 'Small',
    'FurLength': 'Short',
    'Vaccinated': 'No',
    'Sterilized': 'No',
    'Health': 'Healthy',
    'Fee': 100,
    'PhotoAmt': 2,
}

input_dict = {name: tf.convert_to_tensor([value]) for name, value in sample.items()}
predictions = reloaded_model.predict(input_dict)
prob = tf.nn.sigmoid(predictions[0])

print(
    "This particular pet had a %.1f percent probability "
    "of getting adopted." % (100 * prob)
)
This particular pet had a 83.4 percent probability of getting adopted.

अगले कदम

संरचित डेटा को वर्गीकृत करने के बारे में अधिक जानने का सबसे अच्छा तरीका यह है कि आप इसे स्वयं आजमाएँ। आप के साथ काम करने के लिए एक और डेटासेट ढूंढना चाहते हैं, और ऊपर के समान कोड का उपयोग करके इसे वर्गीकृत करने के लिए एक मॉडल को प्रशिक्षित कर सकते हैं। सटीकता में सुधार करने के लिए, ध्यान से सोचें कि आपके मॉडल में किन विशेषताओं को शामिल किया जाना चाहिए, और उनका प्रतिनिधित्व कैसे किया जाना चाहिए।