एमएल समुदाय दिवस 9 नवंबर है! TensorFlow, JAX से नई जानकारी के लिए हमसे जुड़ें, और अधिक जानें

एक पांडा डेटाफ़्रेम लोड करें

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

इस ट्यूटोरियल कैसे लोड करने के लिए की उदाहरण प्रदान करता है पांडा DataFrames TensorFlow में।

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

पांडा का उपयोग करके डेटा पढ़ें

import pandas as pd
import tensorflow as tf

SHUFFLE_BUFFER = 500
BATCH_SIZE = 2

हृदय रोग डेटासेट वाली CSV फ़ाइल डाउनलोड करें:

csv_file = tf.keras.utils.get_file('heart.csv', 'https://storage.googleapis.com/download.tensorflow.org/data/heart.csv')
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/heart.csv
16384/13273 [=====================================] - 0s 0us/step
24576/13273 [=======================================================] - 0s 0us/step

पांडा का उपयोग करके CSV फ़ाइल पढ़ें:

df = pd.read_csv(csv_file)

डेटा इस तरह दिखता है:

df.head()
df.dtypes
age           int64
sex           int64
cp            int64
trestbps      int64
chol          int64
fbs           int64
restecg       int64
thalach       int64
exang         int64
oldpeak     float64
slope         int64
ca            int64
thal         object
target        int64
dtype: object

आप मॉडल का निर्माण लेबल में निहित भविष्यवाणी करने के लिए होगा target स्तंभ।

target = df.pop('target')

एक डेटाफ़्रेम एक सरणी के रूप में

अपने डेटा को एक समान डेटाप्रकार, या है, तो dtype , यह संभव उपयोग एक पांडा DataFrame कहीं भी आप एक NumPy सरणी इस्तेमाल कर सकते हैं है। यह काम करता है क्योंकि pandas.DataFrame वर्ग का समर्थन करता है __array__ प्रोटोकॉल, और TensorFlow के tf.convert_to_tensor समारोह वस्तुओं है कि प्रोटोकॉल का समर्थन स्वीकार करता है।

डेटासेट से संख्यात्मक विशेषताएं लें (अभी के लिए श्रेणीबद्ध सुविधाओं को छोड़ दें):

numeric_feature_names = ['age', 'thalach', 'trestbps',  'chol', 'oldpeak']
numeric_features = df[numeric_feature_names]
numeric_features.head()

DataFrame का उपयोग कर एक NumPy सरणी में बदला जा सकता DataFrame.values संपत्ति या numpy.array(df) । यह एक टेन्सर, उपयोग में बदलने के लिए tf.convert_to_tensor :

tf.convert_to_tensor(numeric_features)
<tf.Tensor: shape=(303, 5), dtype=float64, numpy=
array([[ 63. , 150. , 145. , 233. ,   2.3],
       [ 67. , 108. , 160. , 286. ,   1.5],
       [ 67. , 129. , 120. , 229. ,   2.6],
       ...,
       [ 65. , 127. , 135. , 254. ,   2.8],
       [ 48. , 150. , 130. , 256. ,   0. ],
       [ 63. , 154. , 150. , 407. ,   4. ]])>

सामान्य तौर पर, एक वस्तु के साथ एक टेन्सर में बदला जा सकता है, तो tf.convert_to_tensor इसे कहीं भी पारित किया जा सकता यदि आप एक पारित कर सकते हैं tf.Tensor

Model.fit . के साथ

एक DataFrame, एक भी टेन्सर रूप में व्याख्या की, करने के लिए एक तर्क के रूप सीधे इस्तेमाल किया जा सकता Model.fit विधि।

डेटासेट की संख्यात्मक विशेषताओं पर एक मॉडल को प्रशिक्षित करने का एक उदाहरण नीचे दिया गया है।

पहला कदम इनपुट रेंज को सामान्य करना है। एक का प्रयोग करें tf.keras.layers.Normalization कि के लिए परत।

इसे कहते हैं सुनिश्चित हो चलाने से पहले परत की माध्य और मानक विचलन-सेट करने के लिए Normalization.adapt विधि:

normalizer = tf.keras.layers.Normalization(axis=-1)
normalizer.adapt(numeric_features)

इस परत से आउटपुट के उदाहरण की कल्पना करने के लिए DataFrame की पहली तीन पंक्तियों पर परत को कॉल करें:

normalizer(numeric_features.iloc[:3])
<tf.Tensor: shape=(3, 5), dtype=float32, numpy=
array([[ 0.93383914,  0.03480718,  0.74578077, -0.26008663,  1.0680453 ],
       [ 1.3782105 , -1.7806165 ,  1.5923285 ,  0.7573877 ,  0.38022864],
       [ 1.3782105 , -0.87290466, -0.6651321 , -0.33687714,  1.3259765 ]],
      dtype=float32)>

एक साधारण मॉडल की पहली परत के रूप में सामान्यीकरण परत का उपयोग करें:

def get_basic_model():
  model = tf.keras.Sequential([
    normalizer,
    tf.keras.layers.Dense(10, activation='relu'),
    tf.keras.layers.Dense(10, activation='relu'),
    tf.keras.layers.Dense(1)
  ])

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

जब आप के रूप में DataFrame पारित x के लिए तर्क Model.fit के रूप में यह होगा एक NumPy सरणी, Keras व्यवहार करता है DataFrame:

model = get_basic_model()
model.fit(numeric_features, target, epochs=15, batch_size=BATCH_SIZE)
Epoch 1/15
152/152 [==============================] - 1s 2ms/step - loss: 0.6405 - accuracy: 0.7789
Epoch 2/15
152/152 [==============================] - 0s 2ms/step - loss: 0.5510 - accuracy: 0.7426
Epoch 3/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4935 - accuracy: 0.7459
Epoch 4/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4649 - accuracy: 0.7558
Epoch 5/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4492 - accuracy: 0.7624
Epoch 6/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4404 - accuracy: 0.7624
Epoch 7/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4350 - accuracy: 0.7789
Epoch 8/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4307 - accuracy: 0.7888
Epoch 9/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4291 - accuracy: 0.7756
Epoch 10/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4262 - accuracy: 0.7822
Epoch 11/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4242 - accuracy: 0.7855
Epoch 12/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4227 - accuracy: 0.7789
Epoch 13/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4229 - accuracy: 0.7987
Epoch 14/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4207 - accuracy: 0.7954
Epoch 15/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4212 - accuracy: 0.7822
<keras.callbacks.History at 0x7f52dc52b8d0>

tf.डेटा के साथ

आप लागू करना चाहते हैं tf.data एक समान का एक DataFrame के परिवर्तनों dtype , Dataset.from_tensor_slices विधि एक डाटासेट पैदा करेगा कि DataFrame की पंक्तियों पर दोहराता। प्रत्येक पंक्ति प्रारंभ में मानों का एक सदिश है। एक मॉडल को प्रशिक्षित करने के लिए, आप की जरूरत (inputs, labels) जोड़े, इसलिए पारित (features, labels) और Dataset.from_tensor_slices स्लाइस की जरूरत जोड़े वापस आ जाएगी:

numeric_dataset = tf.data.Dataset.from_tensor_slices((numeric_features, target))

for row in numeric_dataset.take(3):
  print(row)
(<tf.Tensor: shape=(5,), dtype=float64, numpy=array([ 63. , 150. , 145. , 233. ,   2.3])>, <tf.Tensor: shape=(), dtype=int64, numpy=0>)
(<tf.Tensor: shape=(5,), dtype=float64, numpy=array([ 67. , 108. , 160. , 286. ,   1.5])>, <tf.Tensor: shape=(), dtype=int64, numpy=1>)
(<tf.Tensor: shape=(5,), dtype=float64, numpy=array([ 67. , 129. , 120. , 229. ,   2.6])>, <tf.Tensor: shape=(), dtype=int64, numpy=0>)
numeric_batches = numeric_dataset.shuffle(1000).batch(BATCH_SIZE)

model = get_basic_model()
model.fit(numeric_batches, epochs=15)
Epoch 1/15
152/152 [==============================] - 1s 2ms/step - loss: 0.6827 - accuracy: 0.7393
Epoch 2/15
152/152 [==============================] - 0s 2ms/step - loss: 0.6239 - accuracy: 0.7327
Epoch 3/15
152/152 [==============================] - 0s 2ms/step - loss: 0.5740 - accuracy: 0.7327
Epoch 4/15
152/152 [==============================] - 0s 2ms/step - loss: 0.5316 - accuracy: 0.7360
Epoch 5/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4957 - accuracy: 0.7426
Epoch 6/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4726 - accuracy: 0.7591
Epoch 7/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4569 - accuracy: 0.7822
Epoch 8/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4482 - accuracy: 0.7723
Epoch 9/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4417 - accuracy: 0.7855
Epoch 10/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4379 - accuracy: 0.7855
Epoch 11/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4356 - accuracy: 0.7888
Epoch 12/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4326 - accuracy: 0.7888
Epoch 13/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4308 - accuracy: 0.7855
Epoch 14/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4288 - accuracy: 0.8020
Epoch 15/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4267 - accuracy: 0.7888
<keras.callbacks.History at 0x7f52dc35db10>

एक डेटाफ़्रेम एक शब्दकोश के रूप में

जब आप विषम डेटा के साथ काम करना शुरू करते हैं, तो डेटाफ़्रेम का इलाज करना अब संभव नहीं है जैसे कि यह एक एकल सरणी हो। TensorFlow tensors की आवश्यकता है कि सभी तत्वों को एक ही है dtype

तो, इस मामले में, आपको इसे कॉलम के शब्दकोश के रूप में मानना ​​​​शुरू करना होगा, जहां प्रत्येक कॉलम में एक समान प्रकार होता है। एक डेटाफ़्रेम बहुत कुछ सरणियों के शब्दकोश की तरह है, इसलिए आम तौर पर आपको केवल डेटाफ़्रेम को पायथन डिक्टेट में डालना है। कई महत्वपूर्ण TensorFlow API इनपुट के रूप में सरणियों के (नेस्टेड-) शब्दकोशों का समर्थन करते हैं।

tf.data इनपुट पाइपलाइनों काफी अच्छी तरह से इस संभाल। सभी tf.data संचालन शब्दकोशों और tuples स्वचालित रूप से संभाल। तो, एक DataFrame से शब्दकोश-उदाहरण के एक डाटासेट बनाने के लिए, बस के साथ यह टुकड़ा करने की क्रिया से पहले एक dict करने के लिए इसे डाली Dataset.from_tensor_slices :

numeric_dict_ds = tf.data.Dataset.from_tensor_slices((dict(numeric_features), target))

उस डेटासेट के पहले तीन उदाहरण यहां दिए गए हैं:

for row in numeric_dict_ds.take(3):
  print(row)
({'age': <tf.Tensor: shape=(), dtype=int64, numpy=63>, 'thalach': <tf.Tensor: shape=(), dtype=int64, numpy=150>, 'trestbps': <tf.Tensor: shape=(), dtype=int64, numpy=145>, 'chol': <tf.Tensor: shape=(), dtype=int64, numpy=233>, 'oldpeak': <tf.Tensor: shape=(), dtype=float64, numpy=2.3>}, <tf.Tensor: shape=(), dtype=int64, numpy=0>)
({'age': <tf.Tensor: shape=(), dtype=int64, numpy=67>, 'thalach': <tf.Tensor: shape=(), dtype=int64, numpy=108>, 'trestbps': <tf.Tensor: shape=(), dtype=int64, numpy=160>, 'chol': <tf.Tensor: shape=(), dtype=int64, numpy=286>, 'oldpeak': <tf.Tensor: shape=(), dtype=float64, numpy=1.5>}, <tf.Tensor: shape=(), dtype=int64, numpy=1>)
({'age': <tf.Tensor: shape=(), dtype=int64, numpy=67>, 'thalach': <tf.Tensor: shape=(), dtype=int64, numpy=129>, 'trestbps': <tf.Tensor: shape=(), dtype=int64, numpy=120>, 'chol': <tf.Tensor: shape=(), dtype=int64, numpy=229>, 'oldpeak': <tf.Tensor: shape=(), dtype=float64, numpy=2.6>}, <tf.Tensor: shape=(), dtype=int64, numpy=0>)

केरासी के साथ शब्दकोश

आमतौर पर, केरस मॉडल और परतें एक इनपुट टेंसर की अपेक्षा करती हैं, लेकिन ये वर्ग शब्दकोशों, टुपल्स और टेंसर की नेस्टेड संरचनाओं को स्वीकार और वापस कर सकते हैं। इन संरचनाओं "घोंसले" (का उल्लेख के रूप में जाना जाता है tf.nest जानकारी के लिए मॉड्यूल)।

दो समान तरीके हैं जिनसे आप एक केरस मॉडल लिख सकते हैं जो एक शब्दकोश को इनपुट के रूप में स्वीकार करता है।

1. मॉडल-उपवर्ग शैली

आप का एक उपवर्ग लिखने tf.keras.Model (या tf.keras.Layer )। आप सीधे इनपुट को संभालते हैं, और आउटपुट बनाते हैं:

def stack_dict(inputs, fun=tf.stack):
    values = []
    for key in sorted(inputs.keys()):
      values.append(tf.cast(inputs[key], tf.float32))

    return fun(values, axis=-1)
class MyModel(tf.keras.Model):
  def __init__(self):
    # Create all the internal layers in init.
    super().__init__(self)

    self.normalizer = tf.keras.layers.Normalization(axis=-1)

    self.seq = tf.keras.Sequential([
      self.normalizer,
      tf.keras.layers.Dense(10, activation='relu'),
      tf.keras.layers.Dense(10, activation='relu'),
      tf.keras.layers.Dense(1)
    ])

  def adapt(self, inputs):
    # Stach the inputs and `adapt` the normalization layer.
    inputs = stack_dict(inputs)
    self.normalizer.adapt(inputs)

  def call(self, inputs):
    # Stack the inputs
    inputs = stack_dict(inputs)
    # Run them through all the layers.
    result = self.seq(inputs)

    return result

model = MyModel()

model.adapt(dict(numeric_features))

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

यह मॉडल प्रशिक्षण के लिए या तो स्तंभों के शब्दकोश या शब्दकोश-तत्वों के डेटासेट को स्वीकार कर सकता है:

model.fit(dict(numeric_features), target, epochs=5, batch_size=BATCH_SIZE)
Epoch 1/5
152/152 [==============================] - 2s 16ms/step - loss: 0.5968 - accuracy: 0.7261
Epoch 2/5
152/152 [==============================] - 2s 15ms/step - loss: 0.5182 - accuracy: 0.7261
Epoch 3/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4738 - accuracy: 0.7360
Epoch 4/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4515 - accuracy: 0.7525
Epoch 5/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4405 - accuracy: 0.7756
<keras.callbacks.History at 0x7f52dc165990>
numeric_dict_batches = numeric_dict_ds.shuffle(SHUFFLE_BUFFER).batch(BATCH_SIZE)
model.fit(numeric_dict_batches, epochs=5)
Epoch 1/5
152/152 [==============================] - 3s 17ms/step - loss: 0.4345 - accuracy: 0.7789
Epoch 2/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4298 - accuracy: 0.7822
Epoch 3/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4273 - accuracy: 0.7789
Epoch 4/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4246 - accuracy: 0.7855
Epoch 5/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4225 - accuracy: 0.7921
<keras.callbacks.History at 0x7f52dc0d4690>

यहां पहले तीन उदाहरणों के लिए भविष्यवाणियां दी गई हैं:

model.predict(dict(numeric_features.iloc[:3]))
array([[[ 0.14884435]],

       [[ 0.37460226]],

       [[-0.08134247]]], dtype=float32)

2. केरस कार्यात्मक शैली

inputs = {}
for name, column in numeric_features.items():
  inputs[name] = tf.keras.Input(
      shape=(1,), name=name, dtype=tf.float32)

inputs
{'age': <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'age')>,
 'thalach': <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'thalach')>,
 'trestbps': <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'trestbps')>,
 'chol': <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'chol')>,
 'oldpeak': <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'oldpeak')>}
x = stack_dict(inputs, fun=tf.concat)

normalizer = tf.keras.layers.Normalization(axis=-1)
normalizer.adapt(stack_dict(dict(numeric_features)))

x = normalizer(x)
x = tf.keras.layers.Dense(10, activation='relu')(x)
x = tf.keras.layers.Dense(10, activation='relu')(x)
x = tf.keras.layers.Dense(1)(x)

model = tf.keras.Model(inputs, x)

model.compile(optimizer='adam',
              loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
              metrics=['accuracy'],
              run_eagerly=True)
tf.keras.utils.plot_model(model, rankdir="LR", show_shapes=True)

पीएनजी

आप कार्यात्मक मॉडल को उसी तरह प्रशिक्षित कर सकते हैं जैसे मॉडल उपवर्ग:

model.fit(dict(numeric_features), target, epochs=5, batch_size=BATCH_SIZE)
Epoch 1/5
152/152 [==============================] - 2s 14ms/step - loss: 0.7151 - accuracy: 0.7030
Epoch 2/5
152/152 [==============================] - 2s 14ms/step - loss: 0.5883 - accuracy: 0.7360
Epoch 3/5
152/152 [==============================] - 2s 14ms/step - loss: 0.5205 - accuracy: 0.7360
Epoch 4/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4838 - accuracy: 0.7492
Epoch 5/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4622 - accuracy: 0.7492
<keras.callbacks.History at 0x7f52bc7b2690>
numeric_dict_batches = numeric_dict_ds.shuffle(SHUFFLE_BUFFER).batch(BATCH_SIZE)
model.fit(numeric_dict_batches, epochs=5)
Epoch 1/5
152/152 [==============================] - 2s 14ms/step - loss: 0.4487 - accuracy: 0.7723
Epoch 2/5
152/152 [==============================] - 2s 14ms/step - loss: 0.4392 - accuracy: 0.7789
Epoch 3/5
152/152 [==============================] - 2s 14ms/step - loss: 0.4339 - accuracy: 0.7789
Epoch 4/5
152/152 [==============================] - 2s 14ms/step - loss: 0.4303 - accuracy: 0.7789
Epoch 5/5
152/152 [==============================] - 2s 14ms/step - loss: 0.4269 - accuracy: 0.7855
<keras.callbacks.History at 0x7f52dc0d4910>

पूरा उदाहरण

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

प्रीप्रोसेसिंग हेड बनाएं

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

दूसरी ओर बाइनरी सुविधाओं को आम तौर पर एन्कोड या सामान्यीकृत करने की आवश्यकता नहीं होती है।

प्रत्येक समूह में आने वाली सुविधाओं की सूची बनाकर प्रारंभ करें:

binary_feature_names = ['sex', 'fbs', 'exang']
categorical_feature_names = ['cp', 'restecg', 'slope', 'thal', 'ca']

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

इस अनुभाग का उपयोग करता Keras कार्यात्मक एपीआई पूर्व प्रसंस्करण लागू करने के लिए। आप एक बना कर शुरूआत tf.keras.Input dataframe के प्रत्येक स्तंभ के लिए:

inputs = {}
for name, column in df.items():
  if type(column[0]) == str:
    dtype = tf.string
  elif (name in categorical_feature_names or
        name in binary_feature_names):
    dtype = tf.int64
  else:
    dtype = tf.float32

  inputs[name] = tf.keras.Input(shape=(), name=name, dtype=dtype)
inputs
{'age': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'age')>,
 'sex': <KerasTensor: shape=(None,) dtype=int64 (created by layer 'sex')>,
 'cp': <KerasTensor: shape=(None,) dtype=int64 (created by layer 'cp')>,
 'trestbps': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'trestbps')>,
 'chol': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'chol')>,
 'fbs': <KerasTensor: shape=(None,) dtype=int64 (created by layer 'fbs')>,
 'restecg': <KerasTensor: shape=(None,) dtype=int64 (created by layer 'restecg')>,
 'thalach': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'thalach')>,
 'exang': <KerasTensor: shape=(None,) dtype=int64 (created by layer 'exang')>,
 'oldpeak': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'oldpeak')>,
 'slope': <KerasTensor: shape=(None,) dtype=int64 (created by layer 'slope')>,
 'ca': <KerasTensor: shape=(None,) dtype=int64 (created by layer 'ca')>,
 'thal': <KerasTensor: shape=(None,) dtype=string (created by layer 'thal')>}

प्रत्येक इनपुट के लिए आप Keras परतों और TensorFlow ops का उपयोग करके कुछ परिवर्तन लागू करेंगे। प्रत्येक सुविधा scalars का एक बैच के रूप में शुरू होता है ( shape=(batch,) )। प्रत्येक के लिए उत्पादन का एक बैच होना चाहिए tf.float32 वैक्टर ( shape=(batch, n) )। अंतिम चरण उन सभी वैक्टरों को एक साथ जोड़ देगा।

बाइनरी इनपुट

चूंकि बाइनरी आदानों किसी भी पूर्व प्रसंस्करण की जरूरत नहीं है, बस वेक्टर अक्ष जोड़ने के लिए, उन्हें डाली float32 और उन्हें preprocessed आदानों की सूची में जोड़ने:

preprocessed = []

for name in binary_feature_names:
  inp = inputs[name]
  inp = inp[:, tf.newaxis]
  float_value = tf.cast(inp, tf.float32)
  preprocessed.append(float_value)

preprocessed
[<KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'tf.cast_5')>,
 <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'tf.cast_6')>,
 <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'tf.cast_7')>]

संख्यात्मक इनपुट

पहले खंड में की तरह आप एक के माध्यम से इन संख्यात्मक आदानों को चलाने के लिए चाहता हूँ tf.keras.layers.Normalization उन्हें प्रयोग करने से पहले परत। अंतर यह है कि इस बार वे एक निर्देश के रूप में इनपुट कर रहे हैं। DataFrame से सांख्यिक सुविधाओं एकत्र नीचे कोड, उन्हें एक साथ स्टैक्स और करने के लिए उन गुजरता Normalization.adapt विधि।

normalizer = tf.keras.layers.Normalization(axis=-1)
normalizer.adapt(stack_dict(dict(numeric_features)))

नीचे दिया गया कोड संख्यात्मक विशेषताओं को ढेर करता है और उन्हें सामान्यीकरण परत के माध्यम से चलाता है।

numeric_inputs = {}
for name in numeric_feature_names:
  numeric_inputs[name]=inputs[name]

numeric_inputs = stack_dict(numeric_inputs)
numeric_normalized = normalizer(numeric_inputs)

preprocessed.append(numeric_normalized)

preprocessed
[<KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'tf.cast_5')>,
 <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'tf.cast_6')>,
 <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'tf.cast_7')>,
 <KerasTensor: shape=(None, 5) dtype=float32 (created by layer 'normalization_3')>]

श्रेणीबद्ध विशेषताएं

श्रेणीबद्ध सुविधाओं का उपयोग करने के लिए आपको पहले उन्हें बाइनरी वैक्टर या एम्बेडिंग में एन्कोड करना होगा। चूंकि इन केवल श्रेणियों की एक छोटी संख्या भी सम्मिलित, का उपयोग करते हुए एक गर्म वैक्टर के लिए सीधे आदानों परिवर्तित output_mode='one_hot' विकल्प, दोनों byy समर्थित tf.keras.layers.StringLookup और tf.keras.layers.IntegerLookup परतों।

यहां एक उदाहरण दिया गया है कि ये परतें कैसे काम करती हैं:

vocab = ['a','b','c']
lookup = tf.keras.layers.StringLookup(vocabulary=vocab, output_mode='one_hot')
lookup(['c','a','a','b','zzz'])
<tf.Tensor: shape=(5, 4), dtype=float32, numpy=
array([[0., 0., 0., 1.],
       [0., 1., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [1., 0., 0., 0.]], dtype=float32)>
vocab = [1,4,7,99]
lookup = tf.keras.layers.IntegerLookup(vocabulary=vocab, output_mode='one_hot')

lookup([-1,4,1])
<tf.Tensor: shape=(3, 5), dtype=float32, numpy=
array([[1., 0., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 1., 0., 0., 0.]], dtype=float32)>

प्रत्येक इनपुट के लिए शब्दावली निर्धारित करने के लिए, उस शब्दावली को एक-हॉट वेक्टर में बदलने के लिए एक परत बनाएं:

for name in categorical_feature_names:
  vocab = sorted(set(df[name]))
  print(f'name: {name}')
  print(f'vocab: {vocab}\n')

  if type(vocab[0]) is str:
    lookup = tf.keras.layers.StringLookup(vocabulary=vocab, output_mode='one_hot')
  else:
    lookup = tf.keras.layers.IntegerLookup(vocabulary=vocab, output_mode='one_hot')

  x = inputs[name][:, tf.newaxis]
  x = lookup(x)
  preprocessed.append(x)
name: cp
vocab: [0, 1, 2, 3, 4]

name: restecg
vocab: [0, 1, 2]

name: slope
vocab: [1, 2, 3]

name: thal
vocab: ['1', '2', 'fixed', 'normal', 'reversible']

name: ca
vocab: [0, 1, 2, 3]

प्रीप्रोसेसिंग हेड को इकट्ठा करें

इस बिंदु पर preprocessed बस सभी preprocessing परिणामों की एक अजगर सूची है, प्रत्येक परिणाम के आकार (batch_size, depth) :

preprocessed
[<KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'tf.cast_5')>,
 <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'tf.cast_6')>,
 <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'tf.cast_7')>,
 <KerasTensor: shape=(None, 5) dtype=float32 (created by layer 'normalization_3')>,
 <KerasTensor: shape=(None, 6) dtype=float32 (created by layer 'integer_lookup_1')>,
 <KerasTensor: shape=(None, 4) dtype=float32 (created by layer 'integer_lookup_2')>,
 <KerasTensor: shape=(None, 4) dtype=float32 (created by layer 'integer_lookup_3')>,
 <KerasTensor: shape=(None, 6) dtype=float32 (created by layer 'string_lookup_1')>,
 <KerasTensor: shape=(None, 5) dtype=float32 (created by layer 'integer_lookup_4')>]

साथ सभी preprocessed सुविधाओं को श्रेणीबद्ध depth अक्ष, इसलिए प्रत्येक शब्दकोश-उदाहरण के लिए एक एकल वेक्टर में बदल जाती है। वेक्टर में श्रेणीबद्ध विशेषताएं, संख्यात्मक विशेषताएं और श्रेणीबद्ध एक-गर्म विशेषताएं शामिल हैं:

preprocesssed_result = tf.concat(preprocessed, axis=-1)
preprocesssed_result
<KerasTensor: shape=(None, 33) dtype=float32 (created by layer 'tf.concat_1')>

अब उस गणना से एक मॉडल बनाएं ताकि उसका पुन: उपयोग किया जा सके:

preprocessor = tf.keras.Model(inputs, preprocesssed_result)
tf.keras.utils.plot_model(preprocessor, rankdir="LR", show_shapes=True)

पीएनजी

पूर्वप्रक्रमक परीक्षण करने के लिए, का उपयोग DataFrame.iloc DataFrame से पहला उदाहरण काट करने के लिए एक्सेसर। फिर इसे डिक्शनरी में बदलें और डिक्शनरी को प्रीप्रोसेसर में पास करें। परिणाम एक एकल वेक्टर है जिसमें बाइनरी फीचर्स, सामान्यीकृत संख्यात्मक विशेषताएं और एक-गर्म श्रेणीबद्ध विशेषताएं हैं, उस क्रम में:

preprocessor(dict(df.iloc[:1]))
<tf.Tensor: shape=(1, 33), dtype=float32, numpy=
array([[ 1.        ,  1.        ,  0.        ,  0.93383914, -0.26008663,
         1.0680453 ,  0.03480718,  0.74578077,  0.        ,  0.        ,

         1.        ,  0.        ,  0.        ,  0.        ,  0.        ,
         0.        ,  0.        ,  1.        ,  0.        ,  0.        ,
         0.        ,  1.        ,  0.        ,  0.        ,  0.        ,
         1.        ,  0.        ,  0.        ,  0.        ,  1.        ,
         0.        ,  0.        ,  0.        ]], dtype=float32)>

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

अब मॉडल की मुख्य बॉडी बनाएं। पिछले उदाहरण में के रूप में ही विन्यास का उपयोग करें: के एक जोड़े Dense सुधारा रेखीय परतों और एक Dense(1) वर्गीकरण के लिए उत्पादन परत।

body = tf.keras.Sequential([
  tf.keras.layers.Dense(10, activation='relu'),
  tf.keras.layers.Dense(10, activation='relu'),
  tf.keras.layers.Dense(1)
])

अब केरस फंक्शनल एपीआई का उपयोग करके दो टुकड़ों को एक साथ रखें।

inputs
{'age': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'age')>,
 'sex': <KerasTensor: shape=(None,) dtype=int64 (created by layer 'sex')>,
 'cp': <KerasTensor: shape=(None,) dtype=int64 (created by layer 'cp')>,
 'trestbps': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'trestbps')>,
 'chol': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'chol')>,
 'fbs': <KerasTensor: shape=(None,) dtype=int64 (created by layer 'fbs')>,
 'restecg': <KerasTensor: shape=(None,) dtype=int64 (created by layer 'restecg')>,
 'thalach': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'thalach')>,
 'exang': <KerasTensor: shape=(None,) dtype=int64 (created by layer 'exang')>,
 'oldpeak': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'oldpeak')>,
 'slope': <KerasTensor: shape=(None,) dtype=int64 (created by layer 'slope')>,
 'ca': <KerasTensor: shape=(None,) dtype=int64 (created by layer 'ca')>,
 'thal': <KerasTensor: shape=(None,) dtype=string (created by layer 'thal')>}
x = preprocessor(inputs)
x
<KerasTensor: shape=(None, 33) dtype=float32 (created by layer 'model_1')>
result = body(x)
result
<KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'sequential_3')>
model = tf.keras.Model(inputs, result)

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

यह मॉडल इनपुट के शब्दकोश की अपेक्षा करता है। यह डेटा पास करने का सबसे सरल तरीका एक dict को DataFrame बदलने और के रूप में है कि dict पारित करने के लिए है x करने के लिए तर्क Model.fit :

history = model.fit(dict(df), target, epochs=5, batch_size=BATCH_SIZE)
Epoch 1/5
152/152 [==============================] - 1s 4ms/step - loss: 0.5340 - accuracy: 0.7558
Epoch 2/5
152/152 [==============================] - 1s 4ms/step - loss: 0.4038 - accuracy: 0.7789
Epoch 3/5
152/152 [==============================] - 1s 4ms/step - loss: 0.3515 - accuracy: 0.8218
Epoch 4/5
152/152 [==============================] - 1s 4ms/step - loss: 0.3262 - accuracy: 0.8482
Epoch 5/5
152/152 [==============================] - 1s 4ms/step - loss: 0.3087 - accuracy: 0.8680

का उपयोग करते हुए tf.data साथ ही काम करता है:

ds = tf.data.Dataset.from_tensor_slices((
    dict(df),
    target
))

ds = ds.batch(BATCH_SIZE)
import pprint

for x, y in ds.take(1):
  pprint.pprint(x)
  print()
  print(y)
{'age': <tf.Tensor: shape=(2,), dtype=int64, numpy=array([63, 67])>,
 'ca': <tf.Tensor: shape=(2,), dtype=int64, numpy=array([0, 3])>,
 'chol': <tf.Tensor: shape=(2,), dtype=int64, numpy=array([233, 286])>,
 'cp': <tf.Tensor: shape=(2,), dtype=int64, numpy=array([1, 4])>,
 'exang': <tf.Tensor: shape=(2,), dtype=int64, numpy=array([0, 1])>,
 'fbs': <tf.Tensor: shape=(2,), dtype=int64, numpy=array([1, 0])>,
 'oldpeak': <tf.Tensor: shape=(2,), dtype=float64, numpy=array([2.3, 1.5])>,
 'restecg': <tf.Tensor: shape=(2,), dtype=int64, numpy=array([2, 2])>,
 'sex': <tf.Tensor: shape=(2,), dtype=int64, numpy=array([1, 1])>,
 'slope': <tf.Tensor: shape=(2,), dtype=int64, numpy=array([3, 2])>,
 'thal': <tf.Tensor: shape=(2,), dtype=string, numpy=array([b'fixed', b'normal'], dtype=object)>,
 'thalach': <tf.Tensor: shape=(2,), dtype=int64, numpy=array([150, 108])>,
 'trestbps': <tf.Tensor: shape=(2,), dtype=int64, numpy=array([145, 160])>}

tf.Tensor([0 1], shape=(2,), dtype=int64)
history = model.fit(ds, epochs=5)
Epoch 1/5
152/152 [==============================] - 1s 4ms/step - loss: 0.2982 - accuracy: 0.8581
Epoch 2/5
152/152 [==============================] - 1s 5ms/step - loss: 0.2898 - accuracy: 0.8647
Epoch 3/5
152/152 [==============================] - 1s 5ms/step - loss: 0.2831 - accuracy: 0.8680
Epoch 4/5
152/152 [==============================] - 1s 5ms/step - loss: 0.2772 - accuracy: 0.8680
Epoch 5/5
152/152 [==============================] - 1s 4ms/step - loss: 0.2720 - accuracy: 0.8680