सहायता Kaggle पर TensorFlow साथ ग्रेट बैरियर रीफ की रक्षा चैलेंज में शामिल हों

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

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

इस ट्यूटोरियल को दर्शाता है इस तरह के सारणीबद्ध डेटा के रूप में संरचित डेटा, वर्गीकृत करने के लिए कैसे, का एक सरलीकृत संस्करण का उपयोग कर एक Kaggle प्रतियोगिता से Petfinder डाटासेट एक CSV फ़ाइल में संग्रहीत।

आप का उपयोग करेगा Keras मॉडल को परिभाषित करने के लिए, और Keras परतों preprocessing एक पुल मॉडल प्रशिक्षित करने के लिए इस्तेमाल किया सुविधाओं के लिए एक CSV फ़ाइल में स्तंभों से मैप करने के लिए के रूप में। लक्ष्य भविष्यवाणी करना है कि क्या एक पालतू जानवर को अपनाया जाएगा।

इस ट्यूटोरियल में इसके लिए पूरा कोड है:

  • एक में एक CSV फ़ाइल लोड हो रहा है DataFrame का उपयोग कर पांडा
  • बैच के लिए एक इनपुट पाइपलाइन का निर्माण और का उपयोग कर पंक्तियों शफ़ल tf.data । (यात्रा tf.data: बिल्ड TensorFlow इनपुट पाइपलाइनों अधिक जानकारी के लिए।)
  • केरस प्रीप्रोसेसिंग परतों के साथ मॉडल को प्रशिक्षित करने के लिए उपयोग की जाने वाली सुविधाओं के लिए सीएसवी फ़ाइल में कॉलम से मैपिंग।
  • केरस बिल्ट-इन विधियों का उपयोग करके एक मॉडल का निर्माण, प्रशिक्षण और मूल्यांकन।

PetFinder.my मिनी डेटासेट

PetFinder.my मिनी की CSV डेटासेट फ़ाइल में कई हज़ार पंक्तियाँ हैं, जहाँ प्रत्येक पंक्ति एक पालतू जानवर (कुत्ते या बिल्ली) का वर्णन करती है और प्रत्येक स्तंभ एक विशेषता का वर्णन करता है, जैसे कि उम्र, नस्ल, रंग, और इसी तरह।

नीचे दिए गए डेटासेट के सारांश में, ध्यान दें कि ज्यादातर संख्यात्मक और श्रेणीबद्ध कॉलम हैं। इस ट्यूटोरियल में, आप केवल उन दो फीचर प्रकार के साथ काम कर दिया जाएगा, छोड़ने Description (एक नि: शुल्क पाठ सुविधा) और AdoptionSpeed डेटा पूर्व प्रसंस्करण के दौरान (एक वर्गीकरण सुविधा)।

स्तंभ पालतू विवरण फ़ीचर प्रकार डाटा प्रकार
Type जानवर के प्रकार ( Dog , Cat ) स्पष्ट डोरी
Age उम्र न्यूमेरिकल पूर्णांक
Breed1 प्राथमिक नस्ल स्पष्ट डोरी
Color1 रंग 1 स्पष्ट डोरी
Color2 रंग 2 स्पष्ट डोरी
MaturitySize परिपक्वता पर आकार स्पष्ट डोरी
FurLength फर की लंबाई स्पष्ट डोरी
Vaccinated पालतू को टीका लगाया गया है स्पष्ट डोरी
Sterilized पालतू जानवर की नसबंदी कर दी गई है स्पष्ट डोरी
Health स्वास्थ्य की स्थिति स्पष्ट डोरी
Fee गोद लेने का शुल्क न्यूमेरिकल पूर्णांक
Description प्रोफाइल राइट-अप मूलपाठ डोरी
PhotoAmt कुल अपलोड की गई तस्वीरें न्यूमेरिकल पूर्णांक
AdoptionSpeed गोद लेने की स्पष्ट गति वर्गीकरण पूर्णांक

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

import numpy as np
import pandas as pd
import tensorflow as tf

from tensorflow.keras import layers
tf.__version__
'2.7.0'

डेटासेट लोड करें और इसे पांडा में पढ़ें DataFrame

पांडा लोड करने के लिए और संरचित डेटा के साथ काम कर कई उपयोगी उपयोगिताओं के साथ एक अजगर पुस्तकालय है। उपयोग tf.keras.utils.get_file डाउनलोड करने के लिए और PetFinder.my मिनी डाटासेट साथ CSV फ़ाइल निकालने, और एक में इसे लोड DataFrame साथ pandas.read_csv :

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
1679360/1668792 [==============================] - 0s 0us/step

डेटाफ़्रेम की पहली पाँच पंक्तियों की जाँच करके डेटासेट का निरीक्षण करें:

dataframe.head()

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

Kaggle के दशक में मूल कार्य PetFinder.my दत्तक ग्रहण भविष्यवाणी प्रतियोगिता जिस गति से एक पालतू जानवर अपनाई जाएगी भविष्यवाणी करने के लिए किया गया था (पहले सप्ताह में जैसे, पहले महीने, पहले तीन महीनों, और इतने पर)।

इस ट्यूटोरियल में, आप इसे बाइनरी वर्गीकरण समस्या में बदलकर कार्य को सरल बना देंगे, जहां आपको केवल यह अनुमान लगाना होगा कि पालतू जानवर को अपनाया गया था या नहीं।

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

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

# Drop unused features.
dataframe = dataframe.drop(columns=['AdoptionSpeed', 'Description'])

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

डेटासेट एकल पांडा डेटाफ़्रेम में है। उदाहरण के लिए, क्रमशः 80:10:10 अनुपात का उपयोग करके इसे प्रशिक्षण, सत्यापन और परीक्षण सेट में विभाजित करें:

train, val, test = np.split(dataframe.sample(frac=1), [int(0.8*len(dataframe)), int(0.9*len(dataframe))])
print(len(train), 'training examples')
print(len(val), 'validation examples')
print(len(test), 'test examples')
9229 training examples
1154 validation examples
1154 test examples

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

इसके बाद, एक उपयोगिता समारोह बनाने कि धर्मान्तरित एक में प्रत्येक प्रशिक्षण, सत्यापन, और परीक्षण सेट DataFrame tf.data.Dataset , तो शफ़ल और बैचों डेटा।

def df_to_dataset(dataframe, shuffle=True, batch_size=32):
  df = dataframe.copy()
  labels = df.pop('target')
  df = {key: value[:,tf.newaxis] for key, value in dataframe.items()}
  ds = tf.data.Dataset.from_tensor_slices((dict(df), labels))
  if shuffle:
    ds = ds.shuffle(buffer_size=len(dataframe))
  ds = ds.batch(batch_size)
  ds = ds.prefetch(batch_size)
  return ds

अब, नव निर्मित समारोह (का उपयोग df_to_dataset प्रशिक्षण डेटा पर फोन करके डेटा इनपुट पाइपलाइन सहायक समारोह रिटर्न के प्रारूप की जांच, और एक छोटे बैच आकार का उपयोग करने के उत्पादन पठनीय रखने के लिए):

batch_size = 5
train_ds = df_to_dataset(train, batch_size=batch_size)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:4: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version.  Convert to a numpy array before indexing instead.
  after removing the cwd from sys.path.
[(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', 'target']
A batch of ages: tf.Tensor(
[[ 4]
 [ 1]
 [15]
 [ 3]
 [ 1]], shape=(5, 1), dtype=int64)
A batch of targets: tf.Tensor([0 1 1 0 1], shape=(5,), dtype=int64)

जैसा कि आउटपुट दर्शाता है, प्रशिक्षण सेट कॉलम नामों (डेटाफ़्रेम से) का एक शब्दकोश देता है जो पंक्तियों से कॉलम मानों को मैप करता है।

केरस प्रीप्रोसेसिंग लेयर्स लागू करें

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

इस ट्यूटोरियल में, आप प्रीप्रोसेसिंग, स्ट्रक्चर्ड डेटा एन्कोडिंग, और फ़ीचर इंजीनियरिंग को प्रदर्शित करने के लिए निम्नलिखित चार प्रीप्रोसेसिंग परतों का उपयोग करेंगे:

  • tf.keras.layers.Normalization : निष्पादित की सुविधा के लिहाज से इनपुट सुविधाओं को सामान्य।
  • tf.keras.layers.CategoryEncoding : स्पष्ट सुविधाओं पूर्णांक बदल जाता है, एक गर्म बहु गर्म, या में tf-आईडीएफ घने अभ्यावेदन।
  • tf.keras.layers.StringLookup : पूर्णांक सूचकांक में स्ट्रिंग स्पष्ट मूल्यों कर देता है।
  • tf.keras.layers.IntegerLookup : वे मोड़ पूर्णांक सूचकांक में स्पष्ट मूल्यों पूर्णांक।

आप में उपलब्ध परतों के बारे में अधिक सीख सकते हैं परतों preprocessing के साथ कार्य गाइड।

  • PetFinder.my मिनी डाटासेट के संख्यात्मक सुविधाओं के लिए, यदि आप एक का उपयोग करेगा tf.keras.layers.Normalization डेटा के वितरण के मानकीकरण के लिए परत।
  • इस तरह के पालतू जानवर के रूप स्पष्ट सुविधाओं, के लिए Type है ( Dog और Cat तार), तो आप उन लोगों के साथ बहु गर्म एन्कोडेड tensors को बदलना होगा tf.keras.layers.CategoryEncoding

संख्यात्मक कॉलम

PetFinder.my मिनी डेटासेट में हर सांख्यिक सुविधा के लिए, आप एक का उपयोग करेगा tf.keras.layers.Normalization डेटा के वितरण के मानकीकरण के लिए परत।

एक नई उपयोगिता फ़ंक्शन को परिभाषित करें जो एक परत लौटाती है जो कि केरस प्रीप्रोसेसिंग परत का उपयोग करके संख्यात्मक सुविधाओं के लिए सुविधा-वार सामान्यीकरण लागू करती है:

def get_normalization_layer(name, dataset):
  # Create a Normalization layer for the feature.
  normalizer = layers.Normalization(axis=None)

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

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

  return normalizer

इसके बाद, यह बुला कुल पालतू फ़ोटो अपलोड की गई पर से नए कार्य का परीक्षण सुविधाओं के लिए सामान्य 'PhotoAmt' :

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([[-0.8390221 ],
       [ 2.3774517 ],
       [ 0.12592004],
       [-0.5173747 ],
       [-0.19572733]], dtype=float32)>

श्रेणीबद्ध कॉलम

पालतू पशु Type रों डेटासेट में के रूप में strings- प्रतिनिधित्व कर रहे हैं Dog और Cat एस जो मॉडल में खिलाया जा रहा से पहले बहु गर्म इनकोडिंग होने की जरूरत है। Age सुविधा

एक और नया उपयोगिता फ़ंक्शन निर्धारित करें कि रिटर्न एक परत जो पूर्णांक सूचकांक और बहु गर्म encodes का उपयोग कर सुविधाओं के लिए एक शब्दावली से मूल्यों को नक्शे tf.keras.layers.StringLookup , tf.keras.layers.IntegerLookup , और tf.keras.CategoryEncoding preprocessing परतें:

def get_category_encoding_layer(name, dataset, dtype, max_tokens=None):
  # Create a layer that turns strings into integer indices.
  if dtype == 'string':
    index = layers.StringLookup(max_tokens=max_tokens)
  # Otherwise, create a layer that turns integer values into integer indices.
  else:
    index = layers.IntegerLookup(max_tokens=max_tokens)

  # Prepare a `tf.data.Dataset` that only yields the 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)

  # Encode the integer indices.
  encoder = layers.CategoryEncoding(num_tokens=index.vocabulary_size())

  # Apply multi-hot encoding to the indices. The lambda function captures the
  # layer, so you can use them, or include them in the Keras Functional model later.
  return lambda feature: encoder(index(feature))

टेस्ट get_category_encoding_layer पालतू पर फोन करके समारोह 'Type' उन्हें बहु गर्म एन्कोडेड tensors में बदल जाने की विशेषताएं:

test_type_col = train_features['Type']
test_type_layer = get_category_encoding_layer(name='Type',
                                              dataset=train_ds,
                                              dtype='string')
test_type_layer(test_type_col)
<tf.Tensor: shape=(5, 3), dtype=float32, numpy=
array([[0., 1., 0.],
       [0., 0., 1.],
       [0., 1., 0.],
       [0., 0., 1.],
       [0., 1., 0.]], dtype=float32)>

पालतू पर प्रक्रिया को दोहराएं 'Age' विशेषताएं:

test_age_col = train_features['Age']
test_age_layer = get_category_encoding_layer(name='Age',
                                             dataset=train_ds,
                                             dtype='int64',
                                             max_tokens=5)
test_age_layer(test_age_col)
<tf.Tensor: shape=(5, 5), dtype=float32, numpy=
array([[0., 0., 0., 0., 1.],
       [0., 0., 0., 1., 0.],
       [1., 0., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.]], dtype=float32)>

मॉडल को प्रशिक्षित करने के लिए चयनित सुविधाओं को प्रीप्रोसेस करें

आपने सीखा कि कई प्रकार के केरस प्रीप्रोसेसिंग लेयर्स का उपयोग कैसे किया जाता है। अगला, आप करेंगे:

  • PetFinder.my मिनी डेटासेट से 13 संख्यात्मक और श्रेणीबद्ध विशेषताओं पर पहले परिभाषित प्रीप्रोसेसिंग उपयोगिता कार्यों को लागू करें।
  • एक सूची में सभी फीचर इनपुट जोड़ें।

के रूप में शुरुआत में उल्लेख किया है, मॉडल प्रशिक्षित करने के लिए, आप PetFinder.my मिनी डाटासेट के संख्यात्मक (का उपयोग करेगा 'PhotoAmt' , 'Fee' ) और श्रेणीबद्ध ( 'Age' , 'Type' , 'Color1' , 'Color2' , 'Gender' , 'MaturitySize' , 'FurLength' , 'Vaccinated' , 'Sterilized' , 'Health' , 'Breed1' ) की सुविधा है।

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

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)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:4: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version.  Convert to a numpy array before indexing instead.
  after removing the cwd from sys.path.

संख्यात्मक सुविधाओं (पालतू फ़ोटो की संख्या और गोद लेने शुल्क) को सामान्य है, और उन्हें आदानों कहा जाता है में से एक सूची में जोड़ने के encoded_features :

all_inputs = []
encoded_features = []

# Numerical 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)

डाटासेट (पालतू उम्र) पूर्णांक सूचकांक में से बारी पूर्णांक स्पष्ट मूल्यों, बहु गर्म एन्कोडिंग करते हैं, और करने के लिए जिसके परिणामस्वरूप सुविधा आदानों जोड़ने encoded_features :

age_col = tf.keras.Input(shape=(1,), name='Age', dtype='int64')

encoding_layer = get_category_encoding_layer(name='Age',
                                             dataset=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_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(name=header,
                                               dataset=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)

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

अगले कदम के लिए एक मॉडल का उपयोग कर बनाने के लिए है Keras कार्यात्मक एपीआई । अपने मॉडल में पहली परत के लिए, inputs- सुविधा की सूची विलय encoded_features साथ संयोजन के माध्यम से एक वेक्टर -into tf.keras.layers.concatenate

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)

Keras साथ मॉडल कॉन्फ़िगर Model.compile :

model.compile(optimizer='adam',
              loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
              metrics=["accuracy"])

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

# Use `rankdir='LR'` 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
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/engine/functional.py:559: UserWarning: Input dict contained keys ['target'] which did not match any model input. They will be ignored by the model.
  inputs = self._flatten_to_reference_inputs(inputs)
37/37 [==============================] - 2s 18ms/step - loss: 0.6231 - accuracy: 0.5496 - val_loss: 0.5638 - val_accuracy: 0.7409
Epoch 2/10
37/37 [==============================] - 0s 7ms/step - loss: 0.5758 - accuracy: 0.6770 - val_loss: 0.5473 - val_accuracy: 0.7400
Epoch 3/10
37/37 [==============================] - 0s 7ms/step - loss: 0.5544 - accuracy: 0.7043 - val_loss: 0.5377 - val_accuracy: 0.7383
Epoch 4/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5482 - accuracy: 0.7098 - val_loss: 0.5309 - val_accuracy: 0.7348
Epoch 5/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5424 - accuracy: 0.7100 - val_loss: 0.5268 - val_accuracy: 0.7253
Epoch 6/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5336 - accuracy: 0.7130 - val_loss: 0.5221 - val_accuracy: 0.7331
Epoch 7/10
37/37 [==============================] - 0s 7ms/step - loss: 0.5289 - accuracy: 0.7258 - val_loss: 0.5189 - val_accuracy: 0.7357
Epoch 8/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5280 - accuracy: 0.7146 - val_loss: 0.5165 - val_accuracy: 0.7374
Epoch 9/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5221 - accuracy: 0.7264 - val_loss: 0.5142 - val_accuracy: 0.7331
Epoch 10/10
37/37 [==============================] - 0s 7ms/step - loss: 0.5200 - accuracy: 0.7235 - val_loss: 0.5128 - val_accuracy: 0.7357
<keras.callbacks.History at 0x7f1667fe7790>
loss, accuracy = model.evaluate(test_ds)
print("Accuracy", accuracy)
5/5 [==============================] - 0s 6ms/step - loss: 0.5032 - accuracy: 0.7513
Accuracy 0.7512997984886169

अनुमान करें

आपके द्वारा मॉडल के अंदर प्रीप्रोसेसिंग परतों को शामिल करने के बाद आपके द्वारा विकसित किया गया मॉडल अब सीधे CSV फ़ाइल से एक पंक्ति को वर्गीकृत कर सकता है।

अब आप कर सकते हैं बचाने के लिए और Keras मॉडल को फिर से लोड के साथ Model.save और Model.load_model नए डेटा पर अनुमान प्रदर्शन से पहले:

model.save('my_pet_classifier')
reloaded_model = tf.keras.models.load_model('my_pet_classifier')
2021-11-06 01:29:25.921254: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
WARNING:absl:Function `_wrapped_model` contains input name(s) PhotoAmt, Fee, Age, Type, Color1, Color2, Gender, MaturitySize, FurLength, Vaccinated, Sterilized, Health, Breed1 with unsupported characters which will be renamed to photoamt, fee, age, type, color1, color2, gender, maturitysize, furlength, vaccinated, sterilized, health, breed1 in the SavedModel.
INFO:tensorflow:Assets written to: my_pet_classifier/assets
INFO:tensorflow:Assets written to: my_pet_classifier/assets

एक नया नमूना के लिए एक भविष्यवाणी प्राप्त करने के लिए, तो आप बस Keras कॉल कर सकते हैं Model.predict विधि। आपको केवल दो चीजें करने की ज़रूरत है:

  1. एक सूची में लपेटें scalars इतनी के रूप में एक बैच आयाम (के लिए Model डेटा की ही प्रक्रिया बैचों, नहीं एकल नमूने)।
  2. कॉल tf.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 74.4 percent probability of getting adopted.

अगला कदम

संरचित डेटा को वर्गीकृत करने के बारे में अधिक जानने के लिए, अन्य डेटासेट के साथ काम करने का प्रयास करें। अपने मॉडलों के प्रशिक्षण और परीक्षण के दौरान सटीकता में सुधार करने के लिए, ध्यान से सोचें कि आपके मॉडल में कौन सी विशेषताएं शामिल हैं और उनका प्रतिनिधित्व कैसे किया जाना चाहिए।

नीचे डेटासेट के लिए कुछ सुझाव दिए गए हैं:

  • TensorFlow डेटासेट: MovieLens : एक फिल्म सिफारिश सेवा से फिल्म रेटिंग्स का एक सेट।
  • TensorFlow डेटासेट: शराब गुणवत्ता : पुर्तगाली "Vinho वर्डे" शराब के लाल और सफेद वेरिएंट से संबंधित दो डेटासेट। तुम भी पर रेड वाइन गुणवत्ता डाटासेट पा सकते हैं Kaggle
  • Kaggle: arXiv डेटासेट : 17 लाख arXiv से विद्वानों के लेख, कवर भौतिक विज्ञान, कंप्यूटर विज्ञान, गणित, सांख्यिकी, इलेक्ट्रिकल इंजीनियरिंग, मात्रात्मक जीव विज्ञान, और अर्थशास्त्र के एक कोष।