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

TensorFlow.org पर देखें

Google Colab में चलाएं

GitHub पर स्रोत देखें

नोटबुक डाउनलोड करें

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

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

डेटासेट

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

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

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 का उपयोग करके एक इनपुट पाइपलाइन बनाएं

इसके बाद, हम डेटाफ्रेम को 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)

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

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

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([ 6  2 36  2  2], shape=(5,), dtype=int64)
A batch of targets: tf.Tensor([1 1 1 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)

[[2.]
 [4.]
 [4.]
 [1.]
 [2.]]

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

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

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

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. 1. 0.]
 [0. 1. 0. 0.]]

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

इस डेटासेट में, प्रकार को एक स्ट्रिंग (जैसे 'डॉग', या 'कैट') के रूप में दर्शाया जाता है। हम किसी मॉडल को सीधे तार नहीं खिला सकते हैं। इसके बजाय, हमें पहले उन्हें संख्यात्मक मानों पर मैप करना चाहिए। श्रेणीबद्ध शब्दावली कॉलम एक-हॉट वेक्टर के रूप में स्ट्रिंग्स का प्रतिनिधित्व करने का एक तरीका प्रदान करते हैं (जैसा कि आपने ऊपर आयु बकेट के साथ देखा है)। शब्दावली को 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)

[[1. 0.]
 [1. 0.]
 [1. 0.]
 [1. 0.]
 [0. 1.]]

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

मान लीजिए कि केवल कुछ संभावित तार होने के बजाय, हमारे पास प्रति श्रेणी हजारों (या अधिक) मान हैं। कई कारणों से, जैसे-जैसे श्रेणियों की संख्या बड़ी होती जाती है, एक-हॉट एनकोडिंग का उपयोग करके तंत्रिका नेटवर्क को प्रशिक्षित करना संभव नहीं होता है। हम इस सीमा को पार करने के लिए एक एम्बेडिंग कॉलम का उपयोग कर सकते हैं। कई आयामों के एक-हॉट वेक्टर के रूप में डेटा का प्रतिनिधित्व करने के बजाय, एक एम्बेडिंग कॉलम उस डेटा को निम्न-आयामी, घने वेक्टर के रूप में दर्शाता है जिसमें प्रत्येक सेल में कोई भी संख्या हो सकती है, न कि केवल 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.22380038 -0.09379731  0.21349265  0.33451992 -0.49730566  0.05174963
   0.2668497   0.27391028]
 [-0.5484653  -0.03492585  0.05648395 -0.09792244  0.02530896 -0.15477926
  -0.10695003 -0.45474145]
 [-0.22380038 -0.09379731  0.21349265  0.33451992 -0.49730566  0.05174963
   0.2668497   0.27391028]
 [ 0.10050306  0.43513173  0.375823    0.5652766   0.40925583 -0.03928828
   0.4901914   0.20637617]
 [-0.2319875  -0.21874283  0.12272807  0.33345345 -0.4563055   0.21609035
  -0.2410521   0.4736915 ]]

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

बड़ी संख्या में मानों के साथ एक श्रेणीबद्ध कॉलम का प्रतिनिधित्व करने का दूसरा तरीका एक 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))

[[0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]
 [0. 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. 0. 1. 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))

[[1. 0. 0. 0. 0. 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.]
 [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0. 0. 0. 0. 0. 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))

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

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

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. Received: inputs={'Type': <tf.Tensor 'IteratorGetNext:11' shape=(None,) dtype=string>, 'Age': <tf.Tensor 'IteratorGetNext:0' shape=(None,) dtype=int64>, 'Breed1': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=string>, 'Gender': <tf.Tensor 'IteratorGetNext:6' shape=(None,) dtype=string>, 'Color1': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'Color2': <tf.Tensor 'IteratorGetNext:3' shape=(None,) dtype=string>, 'MaturitySize': <tf.Tensor 'IteratorGetNext:8' shape=(None,) dtype=string>, 'FurLength': <tf.Tensor 'IteratorGetNext:5' shape=(None,) dtype=string>, 'Vaccinated': <tf.Tensor 'IteratorGetNext:12' shape=(None,) dtype=string>, 'Sterilized': <tf.Tensor 'IteratorGetNext:10' shape=(None,) dtype=string>, 'Health': <tf.Tensor 'IteratorGetNext:7' shape=(None,) dtype=string>, 'Fee': <tf.Tensor 'IteratorGetNext:4' shape=(None,) dtype=int64>, 'PhotoAmt': <tf.Tensor 'IteratorGetNext:9' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'Type': <tf.Tensor 'IteratorGetNext:11' shape=(None,) dtype=string>, 'Age': <tf.Tensor 'IteratorGetNext:0' shape=(None,) dtype=int64>, 'Breed1': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=string>, 'Gender': <tf.Tensor 'IteratorGetNext:6' shape=(None,) dtype=string>, 'Color1': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'Color2': <tf.Tensor 'IteratorGetNext:3' shape=(None,) dtype=string>, 'MaturitySize': <tf.Tensor 'IteratorGetNext:8' shape=(None,) dtype=string>, 'FurLength': <tf.Tensor 'IteratorGetNext:5' shape=(None,) dtype=string>, 'Vaccinated': <tf.Tensor 'IteratorGetNext:12' shape=(None,) dtype=string>, 'Sterilized': <tf.Tensor 'IteratorGetNext:10' shape=(None,) dtype=string>, 'Health': <tf.Tensor 'IteratorGetNext:7' shape=(None,) dtype=string>, 'Fee': <tf.Tensor 'IteratorGetNext:4' shape=(None,) dtype=int64>, 'PhotoAmt': <tf.Tensor 'IteratorGetNext:9' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
231/231 [==============================] - ETA: 0s - loss: 0.6759 - accuracy: 0.6802WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'Type': <tf.Tensor 'IteratorGetNext:11' shape=(None,) dtype=string>, 'Age': <tf.Tensor 'IteratorGetNext:0' shape=(None,) dtype=int64>, 'Breed1': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=string>, 'Gender': <tf.Tensor 'IteratorGetNext:6' shape=(None,) dtype=string>, 'Color1': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'Color2': <tf.Tensor 'IteratorGetNext:3' shape=(None,) dtype=string>, 'MaturitySize': <tf.Tensor 'IteratorGetNext:8' shape=(None,) dtype=string>, 'FurLength': <tf.Tensor 'IteratorGetNext:5' shape=(None,) dtype=string>, 'Vaccinated': <tf.Tensor 'IteratorGetNext:12' shape=(None,) dtype=string>, 'Sterilized': <tf.Tensor 'IteratorGetNext:10' shape=(None,) dtype=string>, 'Health': <tf.Tensor 'IteratorGetNext:7' shape=(None,) dtype=string>, 'Fee': <tf.Tensor 'IteratorGetNext:4' shape=(None,) dtype=int64>, 'PhotoAmt': <tf.Tensor 'IteratorGetNext:9' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
231/231 [==============================] - 4s 10ms/step - loss: 0.6759 - accuracy: 0.6802 - val_loss: 0.5361 - val_accuracy: 0.7351
Epoch 2/10
231/231 [==============================] - 2s 9ms/step - loss: 0.5742 - accuracy: 0.7054 - val_loss: 0.5178 - val_accuracy: 0.7411
Epoch 3/10
231/231 [==============================] - 2s 9ms/step - loss: 0.5369 - accuracy: 0.7231 - val_loss: 0.5031 - val_accuracy: 0.7438
Epoch 4/10
231/231 [==============================] - 2s 9ms/step - loss: 0.5161 - accuracy: 0.7214 - val_loss: 0.5115 - val_accuracy: 0.7259
Epoch 5/10
231/231 [==============================] - 2s 9ms/step - loss: 0.5034 - accuracy: 0.7296 - val_loss: 0.5173 - val_accuracy: 0.7237
Epoch 6/10
231/231 [==============================] - 2s 8ms/step - loss: 0.4983 - accuracy: 0.7301 - val_loss: 0.5153 - val_accuracy: 0.7254
Epoch 7/10
231/231 [==============================] - 2s 9ms/step - loss: 0.4912 - accuracy: 0.7412 - val_loss: 0.5258 - val_accuracy: 0.7010
Epoch 8/10
231/231 [==============================] - 2s 9ms/step - loss: 0.4890 - accuracy: 0.7360 - val_loss: 0.5066 - val_accuracy: 0.7221
Epoch 9/10
231/231 [==============================] - 2s 9ms/step - loss: 0.4824 - accuracy: 0.7443 - val_loss: 0.5091 - val_accuracy: 0.7481
Epoch 10/10
231/231 [==============================] - 2s 9ms/step - loss: 0.4758 - accuracy: 0.7466 - val_loss: 0.5159 - val_accuracy: 0.7492
<keras.callbacks.History at 0x7f06b52a1810>

loss, accuracy = model.evaluate(test_ds)
print("Accuracy", accuracy)

73/73 [==============================] - 0s 6ms/step - loss: 0.4812 - accuracy: 0.7543
Accuracy 0.7543327808380127

अगले कदम

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