কেরাস প্রিপ্রসেসিং স্তরগুলি ব্যবহার করে কাঠামোগত ডেটা শ্রেণিবদ্ধ করুন

TensorFlow.org এ দেখুন

Google Colab-এ চালান

GitHub-এ উৎস দেখুন

নোটবুক ডাউনলোড করুন

এই টিউটোরিয়ালটি দেখায় কিভাবে একটি CSV ফাইলে সঞ্চিত একটি Kaggle প্রতিযোগিতা থেকে PetFinder ডেটাসেটের একটি সরলীকৃত সংস্করণ ব্যবহার করে স্ট্রাকচার্ড ডেটা, যেমন ট্যাবুলার ডেটা শ্রেণীবদ্ধ করা যায়।

আপনি মডেলটিকে সংজ্ঞায়িত করতে কেরাস ব্যবহার করবেন এবং কেরাস প্রিপ্রসেসিং স্তরগুলিকে একটি সেতু হিসাবে একটি CSV ফাইলের কলাম থেকে মডেলকে প্রশিক্ষণের জন্য ব্যবহৃত বৈশিষ্ট্যগুলিতে মানচিত্র হিসাবে ব্যবহার করবেন। লক্ষ্য একটি পোষা দত্তক করা হবে যদি ভবিষ্যদ্বাণী করা হয়.

এই টিউটোরিয়ালটিতে সম্পূর্ণ কোড রয়েছে:

• পান্ডা ব্যবহার করে একটি ডেটাফ্রেমে একটি CSV ফাইল লোড করা হচ্ছে।
• tf.data ব্যবহার করে সারিগুলি ব্যাচ এবং এলোমেলো করার জন্য একটি ইনপুট পাইপলাইন তৈরি করা। (আরো বিস্তারিত জানার জন্য tf.data দেখুন : TensorFlow ইনপুট পাইপলাইন তৈরি করুন।)
• CSV ফাইলের কলাম থেকে কেরাস প্রিপ্রসেসিং স্তরগুলির সাথে মডেলকে প্রশিক্ষণ দিতে ব্যবহৃত বৈশিষ্ট্যগুলিতে ম্যাপিং।
• কেরাস বিল্ট-ইন পদ্ধতি ব্যবহার করে একটি মডেল তৈরি, প্রশিক্ষণ এবং মূল্যায়ন করা।

PetFinder.my মিনি ডেটাসেট

PetFinder.my মিনির CSV ডেটাসেট ফাইলে কয়েক হাজার সারি রয়েছে, যেখানে প্রতিটি সারি একটি পোষা প্রাণী (একটি কুকুর বা একটি বিড়াল) বর্ণনা করে এবং প্রতিটি কলাম একটি বৈশিষ্ট্য বর্ণনা করে, যেমন বয়স, জাত, রঙ ইত্যাদি৷

নীচের ডেটাসেটের সারাংশে, লক্ষ্য করুন বেশিরভাগ সংখ্যাসূচক এবং শ্রেণীবদ্ধ কলাম রয়েছে। এই টিউটোরিয়ালে, আপনি ডেটা প্রিপ্রসেসিংয়ের সময় Description (একটি বিনামূল্যের পাঠ্য বৈশিষ্ট্য) এবং AdoptionSpeed (একটি শ্রেণিবিন্যাস বৈশিষ্ট্য) বাদ দিয়ে শুধুমাত্র এই দুটি বৈশিষ্ট্যের ধরন নিয়ে কাজ করবেন।

TensorFlow এবং অন্যান্য লাইব্রেরি আমদানি করুন

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

from tensorflow.keras import layers

tf.__version__

'2.8.0-rc1'

ডেটাসেট লোড করুন এবং এটি একটি পান্ডাস ডেটাফ্রেমে পড়ুন

পান্ডাস হল একটি পাইথন লাইব্রেরি যেখানে স্ট্রাকচার্ড ডেটা লোড করার এবং কাজ করার জন্য অনেক সহায়ক ইউটিলিটি রয়েছে। PetFinder.my মিনি ডেটাসেট দিয়ে CSV ফাইল ডাউনলোড ও এক্সট্র্যাক্ট করতে tf.keras.utils.get_file ব্যবহার করুন এবং 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 ব্যবহার করে একটি ইনপুট পাইপলাইন তৈরি করুন

এর পরে, একটি ইউটিলিটি ফাংশন তৈরি করুন যা প্রতিটি প্রশিক্ষণ, বৈধতা এবং টেস্ট সেট ডেটাফ্রেমকে একটি 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(
[[84]
 [ 1]
 [ 5]
 [ 1]
 [12]], shape=(5, 1), dtype=int64)
A batch of targets: tf.Tensor([1 1 0 1 0], shape=(5,), dtype=int64)

আউটপুট যেমন দেখায়, প্রশিক্ষণ সেটটি কলাম নামের একটি অভিধান (ডেটাফ্রেম থেকে) প্রদান করে যা সারি থেকে কলামের মানগুলিতে মানচিত্র তৈরি করে।

কেরাস প্রিপ্রসেসিং স্তরগুলি প্রয়োগ করুন

কেরাস প্রিপ্রসেসিং স্তরগুলি আপনাকে কেরাস-নেটিভ ইনপুট প্রসেসিং পাইপলাইনগুলি তৈরি করতে দেয়, যা কেরাস মডেলের সাথে সরাসরি মিলিত হয়ে নন-কেরাস ওয়ার্কফ্লোতে স্বাধীন প্রিপ্রসেসিং কোড হিসাবে ব্যবহার করা যেতে পারে এবং কেরাস সেভড মডেলের অংশ হিসাবে রপ্তানি করা যেতে পারে।

এই টিউটোরিয়ালে, আপনি প্রিপ্রসেসিং, স্ট্রাকচার্ড ডেটা এনকোডিং এবং ফিচার ইঞ্জিনিয়ারিং কীভাবে সম্পাদন করবেন তা প্রদর্শন করতে নিম্নলিখিত চারটি প্রিপ্রসেসিং স্তর ব্যবহার করবেন:

• tf.keras.layers.Normalization : ইনপুট বৈশিষ্ট্যগুলির বৈশিষ্ট্য অনুসারে স্বাভাবিককরণ সম্পাদন করে।
• tf.keras.layers.CategoryEncoding : পূর্ণসংখ্যা শ্রেণীগত বৈশিষ্ট্যগুলিকে এক-হট, মাল্টি-হট, বা tf-idf ঘন উপস্থাপনে পরিণত করে।
• tf.keras.layers.StringLookup : স্ট্রিং ক্যাটাগরিকাল মানকে পূর্ণসংখ্যা সূচকে পরিণত করে।
• tf.keras.layers.IntegerLookup : পূর্ণসংখ্যার শ্রেণীগত মানকে পূর্ণসংখ্যা সূচকে পরিণত করে।

আপনি প্রিপ্রসেসিং লেয়ার গাইডের সাথে কাজ করে উপলব্ধ স্তরগুলি সম্পর্কে আরও শিখতে পারেন।

• PetFinder.my মিনি ডেটাসেটের সংখ্যাগত বৈশিষ্ট্যগুলির জন্য, আপনি ডেটা বিতরণকে মানসম্মত করতে একটি tf.keras.layers.Normalization স্তর ব্যবহার করবেন৷
• স্বতন্ত্র বৈশিষ্ট্যগুলির জন্য, যেমন পোষা প্রাণীর Type ( Dog এবং Cat স্ট্রিং), আপনি তাদের tf.keras.layers.CategoryEncoding সহ বহু-হট এনকোডেড 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.8272058 ],
       [-0.19125296],
       [ 1.3986291 ],
       [-0.19125296],
       [-0.50922936]], dtype=float32)>

শ্রেণীবদ্ধ কলাম

ডেটাসেটে পোষা প্রাণীর Type স্ট্রিং হিসাবে উপস্থাপিত করা হয়- Dog এবং Cat যা মডেলে খাওয়ানোর আগে বহু-হট এনকোড করা প্রয়োজন৷ Age বৈশিষ্ট্য

আরেকটি নতুন ইউটিলিটি ফাংশন সংজ্ঞায়িত করুন যা একটি স্তর প্রদান করে যা একটি শব্দভান্ডার থেকে পূর্ণসংখ্যা সূচকে মান ম্যাপ করে এবং tf.keras.layers.StringLookup , tf.keras.layers.IntegerLookup , এবং tf.keras.CategoryEncoding প্রিপ্রসেসিং ব্যবহার করে বৈশিষ্ট্যগুলিকে মাল্টি-হট এনকোড করে স্তর:

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' বৈশিষ্ট্যগুলিতে কল করে পরীক্ষা করুন যাতে সেগুলিকে বহু-হট এনকোডেড টেনসরে পরিণত করা যায়:

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., 1., 0.],
       [0., 1., 0.],
       [0., 1., 0.],
       [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([[1., 0., 0., 0., 0.],
       [0., 0., 0., 1., 0.],
       [1., 0., 0., 0., 0.],
       [0., 0., 0., 1., 0.],
       [1., 0., 0., 0., 0.]], dtype=float32)>

মডেলকে প্রশিক্ষণ দেওয়ার জন্য নির্বাচিত বৈশিষ্ট্যগুলি পূর্ব-প্রসেস করুন

আপনি শিখেছেন কিভাবে বিভিন্ন ধরনের কেরাস প্রিপ্রসেসিং লেয়ার ব্যবহার করতে হয়। পরবর্তী, আপনি করবেন:

• PetFinder.my মিনি ডেটাসেট থেকে 13টি সংখ্যাসূচক এবং শ্রেণীগত বৈশিষ্ট্যগুলিতে পূর্বে সংজ্ঞায়িত প্রিপ্রসেসিং ইউটিলিটি ফাংশনগুলি প্রয়োগ করুন৷
• একটি তালিকায় সমস্ত বৈশিষ্ট্য ইনপুট যোগ করুন।

যেমন শুরুতে উল্লেখ করা হয়েছে, মডেলটি প্রশিক্ষণের জন্য, আপনি PetFinder.my মিনি ডেটাসেটের সংখ্যাসূচক ( 'PhotoAmt' , 'Fee' ) এবং শ্রেণীগত ( 'Age' , 'Type' , 'Color1' , 'Color2' , 'Gender' ব্যবহার করবেন। '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)

মডেল তৈরি করুন, কম্পাইল করুন এবং প্রশিক্ষণ দিন

পরবর্তী ধাপ হল কেরাস ফাংশনাল API ব্যবহার করে একটি মডেল তৈরি করা। আপনার মডেলের প্রথম স্তরের জন্য, tf.keras.layers.concatenate এর সাথে সংযুক্তির মাধ্যমে বৈশিষ্ট্য ইনপুটগুলির তালিকা— encoded_features একটি ভেক্টরে মার্জ করুন।

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 দিয়ে মডেলটি কনফিগার করুন:

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 19ms/step - loss: 0.6524 - accuracy: 0.5034 - val_loss: 0.5887 - val_accuracy: 0.6941
Epoch 2/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5906 - accuracy: 0.6648 - val_loss: 0.5627 - val_accuracy: 0.7218
Epoch 3/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5697 - accuracy: 0.6924 - val_loss: 0.5463 - val_accuracy: 0.7504
Epoch 4/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5558 - accuracy: 0.6978 - val_loss: 0.5346 - val_accuracy: 0.7504
Epoch 5/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5502 - accuracy: 0.7105 - val_loss: 0.5272 - val_accuracy: 0.7487
Epoch 6/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5415 - accuracy: 0.7123 - val_loss: 0.5210 - val_accuracy: 0.7608
Epoch 7/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5354 - accuracy: 0.7171 - val_loss: 0.5152 - val_accuracy: 0.7435
Epoch 8/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5301 - accuracy: 0.7214 - val_loss: 0.5113 - val_accuracy: 0.7513
Epoch 9/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5286 - accuracy: 0.7189 - val_loss: 0.5087 - val_accuracy: 0.7574
Epoch 10/10
37/37 [==============================] - 0s 8ms/step - loss: 0.5252 - accuracy: 0.7260 - val_loss: 0.5058 - val_accuracy: 0.7539
<keras.callbacks.History at 0x7f5f9fa91c50>

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

5/5 [==============================] - 0s 6ms/step - loss: 0.5012 - accuracy: 0.7626
Accuracy 0.762565016746521

অনুমান সঞ্চালন

আপনি যে মডেলটি ডেভেলপ করেছেন তা এখন সরাসরি একটি CSV ফাইল থেকে একটি সারিকে শ্রেণীবদ্ধ করতে পারে আপনি মডেলের ভিতরেই প্রিপ্রসেসিং স্তরগুলি অন্তর্ভুক্ত করার পরে।

আপনি এখন নতুন ডেটাতে অনুমান করার আগে Model.save এবং Model.load_model এর সাথে কেরাস মডেলটি সংরক্ষণ এবং পুনরায় লোড করতে পারেন:

model.save('my_pet_classifier')
reloaded_model = tf.keras.models.load_model('my_pet_classifier')

2022-01-26 06:20:08.013613: 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

একটি নতুন নমুনার জন্য একটি ভবিষ্যদ্বাণী পেতে, আপনি কেবল Model.predict পদ্ধতিতে কল করতে পারেন৷ আপনাকে শুধুমাত্র দুটি জিনিস করতে হবে:

1. স্ক্যালারগুলিকে একটি তালিকায় মোড়ানো যাতে একটি ব্যাচের মাত্রা থাকে ( 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 77.7 percent probability of getting adopted.

পরবর্তী পদক্ষেপ

স্ট্রাকচার্ড ডেটা শ্রেণীবদ্ধ করার বিষয়ে আরও জানতে, অন্যান্য ডেটাসেটের সাথে কাজ করার চেষ্টা করুন। প্রশিক্ষণ এবং আপনার মডেল পরীক্ষা করার সময় নির্ভুলতা উন্নত করতে, আপনার মডেলে কোন বৈশিষ্ট্যগুলি অন্তর্ভুক্ত করতে হবে এবং সেগুলি কীভাবে উপস্থাপন করা উচিত সে সম্পর্কে সাবধানতার সাথে চিন্তা করুন।

নীচে ডেটাসেটের জন্য কিছু পরামর্শ দেওয়া হল:

• টেনসরফ্লো ডেটাসেট: মুভিলেন্স : একটি মুভি সুপারিশ পরিষেবা থেকে মুভি রেটিংগুলির একটি সেট৷
• টেনসরফ্লো ডেটাসেট: ওয়াইন কোয়ালিটি : পর্তুগিজ "ভিনহো ভার্দে" ওয়াইনের লাল এবং সাদা রূপের সাথে সম্পর্কিত দুটি ডেটাসেট। আপনি Kaggle এ রেড ওয়াইন কোয়ালিটির ডেটাসেটও খুঁজে পেতে পারেন।
• Kaggle: arXiv ডেটাসেট : আরএক্সিভ থেকে 1.7 মিলিয়ন পণ্ডিত নিবন্ধের একটি কর্পাস, যা পদার্থবিদ্যা, কম্পিউটার বিজ্ঞান, গণিত, পরিসংখ্যান, বৈদ্যুতিক প্রকৌশল, পরিমাণগত জীববিজ্ঞান এবং অর্থনীতিকে কভার করে।