फीचर कॉलम के साथ स्ट्रक्चर्ड डेटा को वर्गीकृत करें

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

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

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

डेटासेट

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

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

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

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

pip install sklearn
import numpy as np
import pandas as pd

import tensorflow as tf

from tensorflow import feature_column
from tensorflow.keras import layers
from sklearn.model_selection import train_test_split

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

पांडा लदान और संरचित डेटा के साथ कार्य करने के लिए कई उपयोगी उपयोगिताओं के साथ एक अजगर पुस्तकालय है। हम 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
1679360/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 का उपयोग करके एक इनपुट पाइपलाइन बनाएं

इसके बाद, हम साथ dataframes लपेटो जाएगा 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)
  return ds
batch_size = 5 # A small batch sized is used for demonstration purposes
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)
2021-08-12 05:35:14.232343: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 05:35:14.240910: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 05:35:14.241897: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 05:35:14.244078: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-08-12 05:35:14.244713: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 05:35:14.245783: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 05:35:14.246715: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 05:35:14.858272: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 05:35:14.859347: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 05:35:14.860347: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 05:35:14.861291: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1510] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 14648 MB memory:  -> device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0

इनपुट पाइपलाइन को समझें

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

for feature_batch, label_batch in train_ds.take(1):
  print('Every feature:', list(feature_batch.keys()))
  print('A batch of ages:', feature_batch['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([3 1 7 3 2], shape=(5,), dtype=int64)
A batch of targets: tf.Tensor([0 0 0 1 1], shape=(5,), dtype=int64)

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

कई प्रकार के फीचर कॉलम प्रदर्शित करें

TensorFlow कई प्रकार के फीचर कॉलम प्रदान करता है। इस खंड में, हम कई प्रकार के फीचर कॉलम बनाएंगे, और प्रदर्शित करेंगे कि वे डेटाफ्रेम से कॉलम को कैसे बदलते हैं।

# We will use this batch to demonstrate several types of feature columns
example_batch = next(iter(train_ds))[0]
# A utility method to create a feature column
# and to transform a batch of data
def demo(feature_column):
  feature_layer = layers.DenseFeatures(feature_column)
  print(feature_layer(example_batch).numpy())

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

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

photo_count = feature_column.numeric_column('PhotoAmt')
demo(photo_count)
[[1.]
 [1.]
 [6.]
 [2.]
 [1.]]

पेटफ़ाइंडर डेटासेट में, डेटाफ़्रेम के अधिकांश स्तंभ श्रेणीबद्ध होते हैं।

बकेटाइज़्ड कॉलम

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

age = feature_column.numeric_column('Age')
age_buckets = feature_column.bucketized_column(age, boundaries=[1, 3, 5])
demo(age_buckets)
[[0. 0. 0. 1.]
 [0. 1. 0. 0.]
 [0. 0. 0. 1.]
 [0. 0. 0. 1.]
 [0. 0. 0. 1.]]

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

इस डेटासेट में, प्रकार को एक स्ट्रिंग (जैसे 'डॉग', या 'कैट') के रूप में दर्शाया जाता है। हम किसी मॉडल को सीधे तार नहीं खिला सकते। इसके बजाय, हमें पहले उन्हें संख्यात्मक मानों पर मैप करना चाहिए। श्रेणीबद्ध शब्दावली कॉलम एक-हॉट वेक्टर के रूप में स्ट्रिंग्स का प्रतिनिधित्व करने का एक तरीका प्रदान करते हैं (जैसा कि आपने ऊपर आयु बकेट के साथ देखा है)। शब्दावली का उपयोग कर एक सूची के रूप में पारित किया जा सकता categorical_column_with_vocabulary_list , या का उपयोग करते हुए एक फ़ाइल से भरी हुई categorical_column_with_vocabulary_file

animal_type = feature_column.categorical_column_with_vocabulary_list(
      'Type', ['Cat', 'Dog'])

animal_type_one_hot = feature_column.indicator_column(animal_type)
demo(animal_type_one_hot)
[[0. 1.]
 [1. 0.]
 [1. 0.]
 [1. 0.]
 [0. 1.]]

कॉलम एम्बेड करना

मान लीजिए कि केवल कुछ संभावित तार होने के बजाय, हमारे पास प्रति श्रेणी हजारों (या अधिक) मान हैं। कई कारणों से, जैसे-जैसे श्रेणियों की संख्या बड़ी होती जाती है, एक-हॉट एनकोडिंग का उपयोग करके तंत्रिका नेटवर्क को प्रशिक्षित करना संभव नहीं होता है। हम इस सीमा को पार करने के लिए एक एम्बेडिंग कॉलम का उपयोग कर सकते हैं। इसके बजाय कई आयामों के एक एक गर्म वेक्टर के रूप में डेटा का प्रतिनिधित्व करने के लिए, एक embedding स्तंभ एक कम आयामी, घने वेक्टर जिसमें प्रत्येक कोशिका किसी भी संख्या शामिल कर सकते हैं, बस 0 नहीं या 1. एम्बेडिंग के आकार के रूप में उस डेटा (का प्रतिनिधित्व करता है 8, नीचे दिए गए उदाहरण में) एक पैरामीटर है जिसे ट्यून किया जाना चाहिए।

# Notice the input to the embedding column is the categorical column
# we previously created
breed1 = feature_column.categorical_column_with_vocabulary_list(
      'Breed1', dataframe.Breed1.unique())
breed1_embedding = feature_column.embedding_column(breed1, dimension=8)
demo(breed1_embedding)
[[-0.29149556  0.14527628 -0.14971544 -0.03371305 -0.18008554 -0.1355874
   0.07782566 -0.25116035]
 [ 0.17409092 -0.5352956   0.17639622  0.14120959  0.06684854 -0.1125162
  -0.29759833  0.13288419]
 [-0.54347     0.12352454  0.2705486   0.38947123  0.03339173 -0.00610726
  -0.07117687 -0.01907084]
 [ 0.42062348  0.62146646 -0.16005716  0.08512937  0.19332875  0.24204789
  -0.03377973  0.47258624]
 [ 0.06813324  0.28805184  0.02640903 -0.05147618  0.6982352  -0.06342584
  -0.1650086  -0.06650425]]

हैशेड फीचर कॉलम

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

breed1_hashed = feature_column.categorical_column_with_hash_bucket(
      'Breed1', hash_bucket_size=10)
demo(feature_column.indicator_column(breed1_hashed))
[[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
 [0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]

क्रॉस्ड फीचर कॉलम

किसी एक सुविधा, बेहतर रूप में जाना जाता में सुविधाओं का मेल सुविधा पार , सुविधाओं में से प्रत्येक संयोजन के लिए अलग वजन में जानने के लिए एक मॉडल के लिए सक्षम बनाता है। यहां, हम एक नई सुविधा बनाएंगे जो कि आयु और प्रकार का क्रॉस है। ध्यान दें कि crossed_column सभी संभव संयोजनों से भरा तालिका (जो बहुत बड़े हो सकता है) का निर्माण नहीं करता है। इसके बजाय, यह एक के द्वारा समर्थित है hashed_column है, तो आप चुन सकते हैं कि बड़ी मेज है।

crossed_feature = feature_column.crossed_column([age_buckets, animal_type], hash_bucket_size=10)
demo(feature_column.indicator_column(crossed_feature))
[[0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]
 [0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]]

चुनें कि किस कॉलम का इस्तेमाल करना है

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

feature_columns = []

# numeric cols
for header in ['PhotoAmt', 'Fee', 'Age']:
  feature_columns.append(feature_column.numeric_column(header))
# bucketized cols
age = feature_column.numeric_column('Age')
age_buckets = feature_column.bucketized_column(age, boundaries=[1, 2, 3, 4, 5])
feature_columns.append(age_buckets)
# indicator_columns
indicator_column_names = ['Type', 'Color1', 'Color2', 'Gender', 'MaturitySize',
                          'FurLength', 'Vaccinated', 'Sterilized', 'Health']
for col_name in indicator_column_names:
  categorical_column = feature_column.categorical_column_with_vocabulary_list(
      col_name, dataframe[col_name].unique())
  indicator_column = feature_column.indicator_column(categorical_column)
  feature_columns.append(indicator_column)
# embedding columns
breed1 = feature_column.categorical_column_with_vocabulary_list(
      'Breed1', dataframe.Breed1.unique())
breed1_embedding = feature_column.embedding_column(breed1, dimension=8)
feature_columns.append(breed1_embedding)
# crossed columns
age_type_feature = feature_column.crossed_column([age_buckets, animal_type], hash_bucket_size=100)
feature_columns.append(feature_column.indicator_column(age_type_feature))

एक फीचर लेयर बनाएं

अब जब कि हम अपनी फ़ीचर स्तंभों को परिभाषित किया है, हम एक का उपयोग करेगा DenseFeatures हमारे Keras मॉडल करने के लिए उन्हें इनपुट करने के लिए परत।

feature_layer = tf.keras.layers.DenseFeatures(feature_columns)

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

batch_size = 32
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)

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

model = tf.keras.Sequential([
  feature_layer,
  layers.Dense(128, activation='relu'),
  layers.Dense(128, activation='relu'),
  layers.Dropout(.1),
  layers.Dense(1)
])

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

model.fit(train_ds,
          validation_data=val_ds,
          epochs=10)
Epoch 1/10
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor, but we receive a <class 'dict'> input: {'Type': <tf.Tensor 'ExpandDims_11:0' shape=(None, 1) dtype=string>, 'Age': <tf.Tensor 'ExpandDims:0' shape=(None, 1) dtype=int64>, 'Breed1': <tf.Tensor 'ExpandDims_1:0' shape=(None, 1) dtype=string>, 'Gender': <tf.Tensor 'ExpandDims_6:0' shape=(None, 1) dtype=string>, 'Color1': <tf.Tensor 'ExpandDims_2:0' shape=(None, 1) dtype=string>, 'Color2': <tf.Tensor 'ExpandDims_3:0' shape=(None, 1) dtype=string>, 'MaturitySize': <tf.Tensor 'ExpandDims_8:0' shape=(None, 1) dtype=string>, 'FurLength': <tf.Tensor 'ExpandDims_5:0' shape=(None, 1) dtype=string>, 'Vaccinated': <tf.Tensor 'ExpandDims_12:0' shape=(None, 1) dtype=string>, 'Sterilized': <tf.Tensor 'ExpandDims_10:0' shape=(None, 1) dtype=string>, 'Health': <tf.Tensor 'ExpandDims_7:0' shape=(None, 1) dtype=string>, 'Fee': <tf.Tensor 'ExpandDims_4:0' shape=(None, 1) dtype=int64>, 'PhotoAmt': <tf.Tensor 'ExpandDims_9:0' shape=(None, 1) dtype=int64>}
Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor, but we receive a <class 'dict'> input: {'Type': <tf.Tensor 'ExpandDims_11:0' shape=(None, 1) dtype=string>, 'Age': <tf.Tensor 'ExpandDims:0' shape=(None, 1) dtype=int64>, 'Breed1': <tf.Tensor 'ExpandDims_1:0' shape=(None, 1) dtype=string>, 'Gender': <tf.Tensor 'ExpandDims_6:0' shape=(None, 1) dtype=string>, 'Color1': <tf.Tensor 'ExpandDims_2:0' shape=(None, 1) dtype=string>, 'Color2': <tf.Tensor 'ExpandDims_3:0' shape=(None, 1) dtype=string>, 'MaturitySize': <tf.Tensor 'ExpandDims_8:0' shape=(None, 1) dtype=string>, 'FurLength': <tf.Tensor 'ExpandDims_5:0' shape=(None, 1) dtype=string>, 'Vaccinated': <tf.Tensor 'ExpandDims_12:0' shape=(None, 1) dtype=string>, 'Sterilized': <tf.Tensor 'ExpandDims_10:0' shape=(None, 1) dtype=string>, 'Health': <tf.Tensor 'ExpandDims_7:0' shape=(None, 1) dtype=string>, 'Fee': <tf.Tensor 'ExpandDims_4:0' shape=(None, 1) dtype=int64>, 'PhotoAmt': <tf.Tensor 'ExpandDims_9:0' shape=(None, 1) dtype=int64>}
Consider rewriting this model with the Functional API.
2021-08-12 05:35:16.625423: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)
225/231 [============================>.] - ETA: 0s - loss: 0.6541 - accuracy: 0.6914WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor, but we receive a <class 'dict'> input: {'Type': <tf.Tensor 'ExpandDims_11:0' shape=(None, 1) dtype=string>, 'Age': <tf.Tensor 'ExpandDims:0' shape=(None, 1) dtype=int64>, 'Breed1': <tf.Tensor 'ExpandDims_1:0' shape=(None, 1) dtype=string>, 'Gender': <tf.Tensor 'ExpandDims_6:0' shape=(None, 1) dtype=string>, 'Color1': <tf.Tensor 'ExpandDims_2:0' shape=(None, 1) dtype=string>, 'Color2': <tf.Tensor 'ExpandDims_3:0' shape=(None, 1) dtype=string>, 'MaturitySize': <tf.Tensor 'ExpandDims_8:0' shape=(None, 1) dtype=string>, 'FurLength': <tf.Tensor 'ExpandDims_5:0' shape=(None, 1) dtype=string>, 'Vaccinated': <tf.Tensor 'ExpandDims_12:0' shape=(None, 1) dtype=string>, 'Sterilized': <tf.Tensor 'ExpandDims_10:0' shape=(None, 1) dtype=string>, 'Health': <tf.Tensor 'ExpandDims_7:0' shape=(None, 1) dtype=string>, 'Fee': <tf.Tensor 'ExpandDims_4:0' shape=(None, 1) dtype=int64>, 'PhotoAmt': <tf.Tensor 'ExpandDims_9:0' shape=(None, 1) dtype=int64>}
Consider rewriting this model with the Functional API.
231/231 [==============================] - 4s 11ms/step - loss: 0.6513 - accuracy: 0.6929 - val_loss: 0.5530 - val_accuracy: 0.7172
Epoch 2/10
231/231 [==============================] - 2s 9ms/step - loss: 0.5726 - accuracy: 0.7142 - val_loss: 0.5061 - val_accuracy: 0.7481
Epoch 3/10
231/231 [==============================] - 2s 10ms/step - loss: 0.5145 - accuracy: 0.7249 - val_loss: 0.5066 - val_accuracy: 0.7557
Epoch 4/10
231/231 [==============================] - 2s 10ms/step - loss: 0.5018 - accuracy: 0.7345 - val_loss: 0.4926 - val_accuracy: 0.7405
Epoch 5/10
231/231 [==============================] - 2s 9ms/step - loss: 0.4950 - accuracy: 0.7332 - val_loss: 0.4997 - val_accuracy: 0.7600
Epoch 6/10
231/231 [==============================] - 2s 9ms/step - loss: 0.4852 - accuracy: 0.7425 - val_loss: 0.4907 - val_accuracy: 0.7443
Epoch 7/10
231/231 [==============================] - 2s 9ms/step - loss: 0.4791 - accuracy: 0.7436 - val_loss: 0.4965 - val_accuracy: 0.7411
Epoch 8/10
231/231 [==============================] - 2s 9ms/step - loss: 0.4779 - accuracy: 0.7471 - val_loss: 0.4956 - val_accuracy: 0.7356
Epoch 9/10
231/231 [==============================] - 2s 9ms/step - loss: 0.4700 - accuracy: 0.7479 - val_loss: 0.4910 - val_accuracy: 0.7394
Epoch 10/10
231/231 [==============================] - 2s 9ms/step - loss: 0.4621 - accuracy: 0.7528 - val_loss: 0.5080 - val_accuracy: 0.7248
<keras.callbacks.History at 0x7f4a784c4d90>
loss, accuracy = model.evaluate(test_ds)
print("Accuracy", accuracy)
73/73 [==============================] - 0s 6ms/step - loss: 0.5444 - accuracy: 0.6919
Accuracy 0.6919410824775696

अगला कदम

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