अनुमानकों के साथ एक रैखिक मॉडल बनाएं

TensorFlow.org पर देखें

Google Colab में चलाएं

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

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

अवलोकन

यह एंड-टू-एंड वॉकथ्रू tf.estimator API का उपयोग करके एक लॉजिस्टिक रिग्रेशन मॉडल को प्रशिक्षित करता है। मॉडल को अक्सर अन्य, अधिक जटिल, एल्गोरिदम के लिए आधार रेखा के रूप में उपयोग किया जाता है।

सेट अप

pip install sklearn

import os
import sys

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from IPython.display import clear_output
from six.moves import urllib

टाइटैनिक डेटासेट लोड करें

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

import tensorflow.compat.v2.feature_column as fc

import tensorflow as tf

# Load dataset.
dftrain = pd.read_csv('https://storage.googleapis.com/tf-datasets/titanic/train.csv')
dfeval = pd.read_csv('https://storage.googleapis.com/tf-datasets/titanic/eval.csv')
y_train = dftrain.pop('survived')
y_eval = dfeval.pop('survived')

डेटा का अन्वेषण करें

डेटासेट में निम्नलिखित विशेषताएं हैं

dftrain.head()

dftrain.describe()

प्रशिक्षण और मूल्यांकन सेट में क्रमशः 627 और 264 उदाहरण हैं।

dftrain.shape[0], dfeval.shape[0]

(627, 264)

यात्रियों में अधिकांश की उम्र 20 और 30 के बीच है।

dftrain.age.hist(bins=20)

<AxesSubplot:>

महिला यात्रियों की तुलना में लगभग दोगुने पुरुष यात्री सवार हैं।

dftrain.sex.value_counts().plot(kind='barh')

<AxesSubplot:>

अधिकांश यात्री "तीसरी" श्रेणी में थे।

dftrain['class'].value_counts().plot(kind='barh')

<AxesSubplot:>

पुरुषों की तुलना में महिलाओं के जीवित रहने की संभावना बहुत अधिक होती है। यह स्पष्ट रूप से मॉडल के लिए एक भविष्य कहनेवाला विशेषता है।

pd.concat([dftrain, y_train], axis=1).groupby('sex').survived.mean().plot(kind='barh').set_xlabel('% survive')

Text(0.5, 0, '% survive')

मॉडल के लिए फ़ीचर इंजीनियरिंग

अनुमानक फीचर कॉलम नामक एक प्रणाली का उपयोग यह वर्णन करने के लिए करते हैं कि मॉडल को प्रत्येक कच्चे इनपुट सुविधाओं की व्याख्या कैसे करनी चाहिए। एक अनुमानक संख्यात्मक इनपुट के एक वेक्टर की अपेक्षा करता है, और फीचर कॉलम बताता है कि मॉडल को प्रत्येक सुविधा को कैसे परिवर्तित करना चाहिए।

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

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

बेस फ़ीचर कॉलम

CATEGORICAL_COLUMNS = ['sex', 'n_siblings_spouses', 'parch', 'class', 'deck',
                       'embark_town', 'alone']
NUMERIC_COLUMNS = ['age', 'fare']

feature_columns = []
for feature_name in CATEGORICAL_COLUMNS:
  vocabulary = dftrain[feature_name].unique()
  feature_columns.append(tf.feature_column.categorical_column_with_vocabulary_list(feature_name, vocabulary))

for feature_name in NUMERIC_COLUMNS:
  feature_columns.append(tf.feature_column.numeric_column(feature_name, dtype=tf.float32))

input_function निर्दिष्ट करता है कि डेटा को tf.data.Dataset में कैसे परिवर्तित किया जाता है जो स्ट्रीमिंग फैशन में इनपुट पाइपलाइन को फीड करता है। tf.data.Dataset कई स्रोतों में ले सकता है जैसे डेटाफ़्रेम, एक csv-स्वरूपित फ़ाइल, और बहुत कुछ।

def make_input_fn(data_df, label_df, num_epochs=10, shuffle=True, batch_size=32):
  def input_function():
    ds = tf.data.Dataset.from_tensor_slices((dict(data_df), label_df))
    if shuffle:
      ds = ds.shuffle(1000)
    ds = ds.batch(batch_size).repeat(num_epochs)
    return ds
  return input_function

train_input_fn = make_input_fn(dftrain, y_train)
eval_input_fn = make_input_fn(dfeval, y_eval, num_epochs=1, shuffle=False)

आप डेटासेट का निरीक्षण कर सकते हैं:

ds = make_input_fn(dftrain, y_train, batch_size=10)()
for feature_batch, label_batch in ds.take(1):
  print('Some feature keys:', list(feature_batch.keys()))
  print()
  print('A batch of class:', feature_batch['class'].numpy())
  print()
  print('A batch of Labels:', label_batch.numpy())

Some feature keys: ['sex', 'age', 'n_siblings_spouses', 'parch', 'fare', 'class', 'deck', 'embark_town', 'alone']

A batch of class: [b'Third' b'Third' b'Third' b'Third' b'Third' b'First' b'Second' b'First'
 b'First' b'Third']

A batch of Labels: [0 1 1 0 0 1 0 1 1 0]

आप tf.keras.layers.DenseFeatures लेयर का उपयोग करके किसी विशिष्ट फीचर कॉलम के परिणाम का निरीक्षण भी कर सकते हैं:

age_column = feature_columns[7]
tf.keras.layers.DenseFeatures([age_column])(feature_batch).numpy()

array([[35.],
       [14.],
       [28.],
       [19.],
       [28.],
       [35.],
       [60.],
       [63.],
       [45.],
       [21.]], dtype=float32)

DenseFeatures केवल घने टेंसर स्वीकार करता है, एक स्पष्ट कॉलम का निरीक्षण करने के लिए आपको इसे पहले एक संकेतक कॉलम में बदलने की आवश्यकता होती है:

gender_column = feature_columns[0]
tf.keras.layers.DenseFeatures([tf.feature_column.indicator_column(gender_column)])(feature_batch).numpy()

array([[1., 0.],
       [0., 1.],
       [0., 1.],
       [1., 0.],
       [1., 0.],
       [1., 0.],
       [1., 0.],
       [0., 1.],
       [0., 1.],
       [0., 1.]], dtype=float32)

मॉडल में सभी बुनियादी सुविधाओं को जोड़ने के बाद, आइए मॉडल को प्रशिक्षित करें। एक मॉडल को प्रशिक्षित करना tf.estimator API का उपयोग करके केवल एक कमांड है:

linear_est = tf.estimator.LinearClassifier(feature_columns=feature_columns)
linear_est.train(train_input_fn)
result = linear_est.evaluate(eval_input_fn)

clear_output()
print(result)

{'accuracy': 0.7537879, 'accuracy_baseline': 0.625, 'auc': 0.8060607, 'auc_precision_recall': 0.7480768, 'average_loss': 0.5639972, 'label/mean': 0.375, 'loss': 0.5542658, 'precision': 0.7741935, 'prediction/mean': 0.25232768, 'recall': 0.4848485, 'global_step': 200}

व्युत्पन्न फ़ीचर कॉलम

अब आप 75% की सटीकता तक पहुंच गए हैं। डेटा की व्याख्या करने के लिए प्रत्येक आधार सुविधा कॉलम का अलग से उपयोग करना पर्याप्त नहीं हो सकता है। उदाहरण के लिए, उम्र और लेबल के बीच का संबंध अलग-अलग लिंग के लिए अलग हो सकता है। इसलिए, यदि आप केवल gender="Male" और gender="Female" के लिए एक मॉडल वजन सीखते हैं, तो आप प्रत्येक आयु-लिंग संयोजन (उदाहरण के लिए gender="Male" और age="30" और gender="Male" के बीच अंतर नहीं करेंगे) gender="Male" और age="40" )।

विभिन्न फीचर संयोजनों के बीच अंतर जानने के लिए, आप मॉडल में क्रॉस फीचर कॉलम जोड़ सकते हैं (आप क्रॉस कॉलम से पहले आयु कॉलम को बकेट भी कर सकते हैं):

age_x_gender = tf.feature_column.crossed_column(['age', 'sex'], hash_bucket_size=100)

मॉडल में संयोजन सुविधा जोड़ने के बाद, आइए मॉडल को फिर से प्रशिक्षित करें:

derived_feature_columns = [age_x_gender]
linear_est = tf.estimator.LinearClassifier(feature_columns=feature_columns+derived_feature_columns)
linear_est.train(train_input_fn)
result = linear_est.evaluate(eval_input_fn)

clear_output()
print(result)

{'accuracy': 0.7462121, 'accuracy_baseline': 0.625, 'auc': 0.845577, 'auc_precision_recall': 0.7873878, 'average_loss': 0.47313985, 'label/mean': 0.375, 'loss': 0.46722567, 'precision': 0.6509434, 'prediction/mean': 0.41550797, 'recall': 0.6969697, 'global_step': 200}

यह अब 77.6% की सटीकता प्राप्त करता है, जो केवल बुनियादी सुविधाओं में प्रशिक्षित की तुलना में थोड़ा बेहतर है। आप अधिक सुविधाओं और परिवर्तनों का उपयोग करके देख सकते हैं कि क्या आप बेहतर कर सकते हैं!

अब आप मूल्यांकन सेट से किसी यात्री पर भविष्यवाणी करने के लिए ट्रेन मॉडल का उपयोग कर सकते हैं। TensorFlow मॉडल एक बार में उदाहरणों के बैच, या संग्रह पर भविष्यवाणियां करने के लिए अनुकूलित हैं। इससे पहले, eval_input_fn को संपूर्ण मूल्यांकन सेट का उपयोग करके परिभाषित किया गया था।

pred_dicts = list(linear_est.predict(eval_input_fn))
probs = pd.Series([pred['probabilities'][1] for pred in pred_dicts])

probs.plot(kind='hist', bins=20, title='predicted probabilities')

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpe5vngw46/model.ckpt-200
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
<AxesSubplot:title={'center':'predicted probabilities'}, ylabel='Frequency'>

अंत में, परिणामों के रिसीवर ऑपरेटिंग विशेषता (आरओसी) को देखें, जो हमें वास्तविक सकारात्मक दर और झूठी सकारात्मक दर के बीच ट्रेडऑफ का बेहतर विचार देगा।

from sklearn.metrics import roc_curve
from matplotlib import pyplot as plt

fpr, tpr, _ = roc_curve(y_eval, probs)
plt.plot(fpr, tpr)
plt.title('ROC curve')
plt.xlabel('false positive rate')
plt.ylabel('true positive rate')
plt.xlim(0,)
plt.ylim(0,)

(0.0, 1.05)