TensorFlow 14 Mayıs'ta Google I/O'ya geri döndü! Şimdi üye Ol

Bu sayfa, Cloud Translation API ile çevrilmiştir.

Panda DataFrame yükleyin

TensorFlow.org'da görüntüleyin

Google Colab'da çalıştırın

Kaynağı GitHub'da görüntüleyin

Not defterini indir

Bu öğretici, panda DataFrame'lerinin TensorFlow'a nasıl yükleneceğine ilişkin örnekler sağlar.

UCI Machine Learning Repository tarafından sağlanan küçük bir kalp hastalığı veri setini kullanacaksınız. CSV'de birkaç yüz satır var. Her satır bir hastayı ve her sütun bir özniteliği tanımlar. Bu bilgiyi, bir ikili sınıflandırma görevi olan bir hastanın kalp hastalığı olup olmadığını tahmin etmek için kullanacaksınız.

Pandaları kullanarak verileri okuyun

import pandas as pd
import tensorflow as tf

SHUFFLE_BUFFER = 500
BATCH_SIZE = 2

Kalp hastalığı veri setini içeren CSV dosyasını indirin:

csv_file = tf.keras.utils.get_file('heart.csv', 'https://storage.googleapis.com/download.tensorflow.org/data/heart.csv')

tutucu2 l10n-yer

Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/heart.csv
16384/13273 [=====================================] - 0s 0us/step
24576/13273 [=======================================================] - 0s 0us/step

Pandaları kullanarak CSV dosyasını okuyun:

df = pd.read_csv(csv_file)

Veriler şöyle görünüyor:

df.head()

df.dtypes

tutucu6 l10n-yer

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 sütunda yer alan etiketi tahmin etmek için modeller oluşturacaksınız.

target = df.pop('target')

Dizi olarak bir DataFrame

Verilerinizin tek tip bir veri türü veya dtype varsa, bir NumPy dizisi kullanabileceğiniz her yerde bir pandas DataFrame kullanmak mümkündür. pandas.DataFrame sınıfı __array__ protokolünü desteklediği ve TensorFlow'un tf.convert_to_tensor işlevi protokolü destekleyen nesneleri kabul ettiği için bu işe yarar.

Veri kümesinden sayısal özellikleri alın (şimdilik kategorik özellikleri atlayın):

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

DataFrame, DataFrame.values özelliği veya numpy.array(df) kullanılarak bir NumPy dizisine dönüştürülebilir. Bir tensöre dönüştürmek için tf.convert_to_tensor kullanın:

tf.convert_to_tensor(numeric_features)

tutucu10 l10n-yer

<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. ]])>

Genel olarak, bir nesne tf.convert_to_tensor ile bir tensöre dönüştürülebiliyorsa, tf.convert_to_tensor iletebileceğiniz herhangi bir yere tf.Tensor .

Model.fit ile

Tek bir tensör olarak yorumlanan bir DataFrame, doğrudan Model.fit yöntemine bir argüman olarak kullanılabilir.

Aşağıda, veri kümesinin sayısal özellikleri üzerinde bir model eğitimi örneği verilmiştir.

İlk adım, giriş aralıklarını normalleştirmektir. Bunun için bir tf.keras.layers.Normalization katmanı kullanın.

Katmanın ortalamasını ve standart sapmasını çalıştırmadan önce ayarlamak için Normalization.adapt yöntemini çağırdığınızdan emin olun:

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

Bu katmandaki çıktının bir örneğini görselleştirmek için DataFrame'in ilk üç satırındaki katmanı çağırın:

normalizer(numeric_features.iloc[:3])

tutucu13 l10n-yer

<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)>

Normalleştirme katmanını basit bir modelin ilk katmanı olarak kullanın:

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'i Model.fit'e x argümanı olarak Model.fit , DataFrame'e bir NumPy dizisi gibi davranır:

model = get_basic_model()
model.fit(numeric_features, target, epochs=15, batch_size=BATCH_SIZE)

tutucu16 l10n-yer

Epoch 1/15
152/152 [==============================] - 1s 2ms/step - loss: 0.6839 - accuracy: 0.7690
Epoch 2/15
152/152 [==============================] - 0s 2ms/step - loss: 0.5789 - accuracy: 0.7789
Epoch 3/15
152/152 [==============================] - 0s 2ms/step - loss: 0.5195 - accuracy: 0.7723
Epoch 4/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4814 - accuracy: 0.7855
Epoch 5/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4566 - accuracy: 0.7789
Epoch 6/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4427 - accuracy: 0.7888
Epoch 7/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4342 - accuracy: 0.7921
Epoch 8/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4290 - accuracy: 0.7855
Epoch 9/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4240 - accuracy: 0.7987
Epoch 10/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4232 - accuracy: 0.7987
Epoch 11/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4208 - accuracy: 0.7987
Epoch 12/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4186 - accuracy: 0.7954
Epoch 13/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4172 - accuracy: 0.8020
Epoch 14/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4156 - accuracy: 0.8020
Epoch 15/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4138 - accuracy: 0.8020
<keras.callbacks.History at 0x7f1ddc27b110>

tf.data ile

Tek tip bir dtype dtype tf.data dönüşümleri uygulamak istiyorsanız, Dataset.from_tensor_slices yöntemi DataFrame satırları üzerinde yinelenen bir veri kümesi oluşturacaktır. Her satır başlangıçta bir değerler vektörüdür. Bir modeli eğitmek için (inputs, labels) çiftlerine ihtiyacınız vardır, bu nedenle geçiş (features, labels) ve Dataset.from_tensor_slices gerekli dilim çiftlerini döndürür:

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>)

yer tutucu19 l10n-yer

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.7677 - accuracy: 0.6865
Epoch 2/15
152/152 [==============================] - 0s 2ms/step - loss: 0.6319 - accuracy: 0.7591
Epoch 3/15
152/152 [==============================] - 0s 2ms/step - loss: 0.5717 - accuracy: 0.7459
Epoch 4/15
152/152 [==============================] - 0s 2ms/step - loss: 0.5228 - accuracy: 0.7558
Epoch 5/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4820 - accuracy: 0.7624
Epoch 6/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4584 - accuracy: 0.7657
Epoch 7/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4454 - accuracy: 0.7657
Epoch 8/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4379 - accuracy: 0.7789
Epoch 9/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4324 - accuracy: 0.7789
Epoch 10/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4282 - accuracy: 0.7756
Epoch 11/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4273 - accuracy: 0.7789
Epoch 12/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4268 - accuracy: 0.7756
Epoch 13/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4248 - accuracy: 0.7789
Epoch 14/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4235 - accuracy: 0.7855
Epoch 15/15
152/152 [==============================] - 0s 2ms/step - loss: 0.4223 - accuracy: 0.7888
<keras.callbacks.History at 0x7f1ddc406510>

Sözlük olarak bir DataFrame

Heterojen verilerle uğraşmaya başladığınızda, DataFrame'i tek bir diziymiş gibi ele almak artık mümkün değildir. dtype tensörleri, tüm öğelerin aynı türe sahip olmasını gerektirir.

Dolayısıyla, bu durumda, her sütunun tek tip bir türe sahip olduğu bir sütun sözlüğü olarak ele almaya başlamanız gerekir. Bir DataFrame, diziler sözlüğüne çok benzer, bu nedenle genellikle yapmanız gereken tek şey DataFrame'i bir Python diktesine dönüştürmektir. Birçok önemli TensorFlow API'si, girdi olarak dizilerin (iç içe) sözlüklerini destekler.

tf.data giriş işlem hatları bunu oldukça iyi idare eder. Tüm tf.data işlemleri, sözlükleri ve demetleri otomatik olarak işler. Bu nedenle, bir DataFrame'den sözlük örneklerinden oluşan bir veri kümesi oluşturmak için, Dataset.from_tensor_slices ile dilimlemeden önce onu bir Dataset.from_tensor_slices :

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

İşte bu veri kümesinden ilk üç örnek:

for row in numeric_dict_ds.take(3):
  print(row)

tutucu23 l10n-yer

({'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>)

Keras içeren sözlükler

Tipik olarak, Keras modelleri ve katmanları tek bir giriş tensörü bekler, ancak bu sınıflar iç içe sözlük, tuple ve tensör yapılarını kabul edebilir ve döndürebilir. Bu yapılar "yuvalar" olarak bilinir (detaylar için tf.nest modülüne bakın).

Girdi olarak bir sözlüğü kabul eden bir keras modeli yazmanın iki eşdeğer yolu vardır.

1. Model-alt sınıf stili

tf.keras.Model (veya tf.keras.Layer ) alt sınıfını yazarsınız. Girdileri doğrudan yönetirsiniz ve çıktıları yaratırsınız:

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)

Bu model, eğitim için bir sütun sözlüğü veya sözlük öğelerinin bir veri kümesini kabul edebilir:

model.fit(dict(numeric_features), target, epochs=5, batch_size=BATCH_SIZE)

Epoch 1/5
152/152 [==============================] - 3s 17ms/step - loss: 0.6736 - accuracy: 0.7063
Epoch 2/5
152/152 [==============================] - 3s 17ms/step - loss: 0.5577 - accuracy: 0.7294
Epoch 3/5
152/152 [==============================] - 2s 16ms/step - loss: 0.4869 - accuracy: 0.7591
Epoch 4/5
152/152 [==============================] - 2s 16ms/step - loss: 0.4525 - accuracy: 0.7690
Epoch 5/5
152/152 [==============================] - 2s 16ms/step - loss: 0.4403 - accuracy: 0.7624
<keras.callbacks.History at 0x7f1de4fa9390>

yer tutucu28 l10n-yer

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 15ms/step - loss: 0.4328 - accuracy: 0.7756
Epoch 2/5
152/152 [==============================] - 2s 14ms/step - loss: 0.4297 - accuracy: 0.7888
Epoch 3/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4270 - accuracy: 0.7888
Epoch 4/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4245 - accuracy: 0.8020
Epoch 5/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4240 - accuracy: 0.7921
<keras.callbacks.History at 0x7f1ddc0dba90>

İşte ilk üç örnek için tahminler:

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

tutucu31 l10n-yer

array([[[0.00565109]],

       [[0.60601974]],

       [[0.03647463]]], dtype=float32)

2. Keras işlevsel stili

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')>}

yer tutucu34 l10n-yer

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)

png

İşlevsel modeli, model alt sınıfıyla aynı şekilde eğitebilirsiniz:

model.fit(dict(numeric_features), target, epochs=5, batch_size=BATCH_SIZE)

Epoch 1/5
152/152 [==============================] - 2s 15ms/step - loss: 0.6529 - accuracy: 0.7492
Epoch 2/5
152/152 [==============================] - 2s 15ms/step - loss: 0.5448 - accuracy: 0.7624
Epoch 3/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4935 - accuracy: 0.7756
Epoch 4/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4650 - accuracy: 0.7789
Epoch 5/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4486 - accuracy: 0.7855
<keras.callbacks.History at 0x7f1ddc0d0f90>

yer tutucu38 l10n-yer

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 15ms/step - loss: 0.4398 - accuracy: 0.7855
Epoch 2/5
152/152 [==============================] - 2s 15ms/step - loss: 0.4330 - accuracy: 0.7855
Epoch 3/5
152/152 [==============================] - 2s 16ms/step - loss: 0.4294 - accuracy: 0.7921
Epoch 4/5
152/152 [==============================] - 2s 16ms/step - loss: 0.4271 - accuracy: 0.7888
Epoch 5/5
152/152 [==============================] - 2s 16ms/step - loss: 0.4231 - accuracy: 0.7855
<keras.callbacks.History at 0x7f1d7c5d5d10>

Tam örnek

Heterojen bir DataFrame , her sütun benzersiz bir ön işleme gerektirebilir. Bu ön işlemeyi doğrudan DataFrame'de yapabilirsiniz, ancak bir modelin doğru çalışması için girdilerin her zaman aynı şekilde önceden işlenmesi gerekir. Bu nedenle, en iyi yaklaşım, ön işlemeyi modele inşa etmektir. Keras ön işleme katmanları birçok yaygın görevi kapsar.

Ön işleme kafasını oluşturun

Bu veri kümesinde, ham verilerdeki bazı "tamsayı" özellikleri aslında Kategorik dizinlerdir. Bu indeksler gerçekten sıralı sayısal değerler değildir (detaylar için veri seti açıklamasına bakın). Bunlar sırasız oldukları için doğrudan modele beslenmeleri uygun değildir; model onları sipariş edilmiş olarak yorumlayacaktır. Bu girdileri kullanmak için, onları tek-sıcak vektörler veya gömme vektörleri olarak kodlamanız gerekir. Aynısı string-kategorik özellikler için de geçerlidir.

Öte yandan ikili özelliklerin genellikle kodlanmasına veya normalleştirilmesine gerek yoktur.

Her gruba giren özelliklerin bir listesini oluşturarak başlayın:

binary_feature_names = ['sex', 'fbs', 'exang']

tutucu41 l10n-yer

categorical_feature_names = ['cp', 'restecg', 'slope', 'thal', 'ca']

Sonraki adım, her bir girdiye uygun ön işleme uygulayacak ve sonuçları birleştirecek bir ön işleme modeli oluşturmaktır.

Bu bölüm, ön işlemeyi uygulamak için Keras İşlevsel API'sini kullanır. Veri çerçevesinin her sütunu için bir tf.keras.Input oluşturarak başlarsınız:

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

-yer tutucu44 l10n-yer

{'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')>}

Her girdi için Keras katmanlarını ve TensorFlow işlemlerini kullanarak bazı dönüşümler uygulayacaksınız. Her özellik bir toplu skaler olarak başlar ( shape=(batch,) ). Her birinin çıktısı, bir grup tf.float32 vektörü olmalıdır ( shape=(batch, n) ). Son adım, tüm bu vektörleri bir araya getirecektir.

ikili girişler

İkili girişler herhangi bir ön işlemeye ihtiyaç duymadığından, vektör eksenini ekleyin, bunları float32 ve önceden işlenmiş girişler listesine ekleyin:

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

tutucu46 l10n-yer

[<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')>]

Sayısal girişler

Önceki bölümde olduğu gibi, bu sayısal girdileri kullanmadan önce bir tf.keras.layers.Normalization katmanında çalıştırmak isteyeceksiniz. Aradaki fark, bu sefer dikte olarak girilmeleridir. Aşağıdaki kod, DataFrame'den sayısal özellikleri toplar, bunları bir araya toplar ve bunları Normalization.adapt yöntemine iletir.

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

Aşağıdaki kod, sayısal özellikleri yığınlar ve bunları normalleştirme katmanında çalıştırır.

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

tutucu49 l10n-yer

[<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')>]

kategorik özellikler

Kategorik özellikleri kullanmak için önce bunları ikili vektörler veya gömmeler olarak kodlamanız gerekir. Bu özellikler yalnızca az sayıda kategori içerdiğinden, hem tf.keras.layers.StringLookup hem de tf.keras.layers.IntegerLookup katmanları tarafından desteklenen output_mode='one_hot' seçeneğini kullanarak girdileri doğrudan one-hot vektörlere dönüştürün.

İşte bu katmanların nasıl çalıştığına dair bir örnek:

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)>

yer tutucu52 l10n-yer

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)>

Her girdi için kelime dağarcığını belirlemek için, bu kelime dağarcığını tek-sıcak bir vektöre dönüştürmek için bir katman oluşturun:

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)

tutucu55 l10n-yer

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]

Ön işleme kafasını monte edin

Bu noktada preprocessed , tüm ön işleme sonuçlarının yalnızca bir Python listesidir, her sonucun bir şekli vardır (batch_size, depth) :

preprocessed

tutucu57 l10n-yer

[<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')>]

depth ekseni boyunca önceden işlenmiş tüm özellikleri birleştirin, böylece her sözlük örneği tek bir vektöre dönüştürülür. Vektör, kategorik özellikler, sayısal özellikler ve kategorik one-hot özellikleri içerir:

preprocesssed_result = tf.concat(preprocessed, axis=-1)
preprocesssed_result

tutucu59 l10n-yer

<KerasTensor: shape=(None, 33) dtype=float32 (created by layer 'tf.concat_1')>

Şimdi yeniden kullanılabilecek şekilde bu hesaplamadan bir model oluşturun:

preprocessor = tf.keras.Model(inputs, preprocesssed_result)

tutucu61 l10n-yer

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

png

Önişlemciyi test etmek için DataFrame'den ilk örneği dilimlemek için DataFrame.iloc erişimcisini kullanın. Ardından onu bir sözlüğe dönüştürün ve sözlüğü önişlemciye iletin. Sonuç, bu sırayla ikili özellikleri, normalleştirilmiş sayısal özellikleri ve one-hot kategorik özellikleri içeren tek bir vektördür:

preprocessor(dict(df.iloc[:1]))

tutucu63 l10n-yer

<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)>

Bir model oluşturun ve eğitin

Şimdi modelin ana gövdesini oluşturun. Önceki örnektekiyle aynı konfigürasyonu kullanın: Sınıflandırma için bir çift Dense doğrultulmuş doğrusal katman ve bir Dense(1) çıktı katmanı.

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

Şimdi Keras işlevsel API'sini kullanarak iki parçayı bir araya getirin.

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'])

Bu model bir girdi sözlüğü beklemektedir. Verileri iletmenin en basit yolu, DataFrame'i bir dikteye dönüştürmek ve bu dikti x argümanı olarak Model.fit :

history = model.fit(dict(df), target, epochs=5, batch_size=BATCH_SIZE)

tutucu73 l10n-yer

Epoch 1/5
152/152 [==============================] - 1s 4ms/step - loss: 0.6911 - accuracy: 0.6997
Epoch 2/5
152/152 [==============================] - 1s 4ms/step - loss: 0.5073 - accuracy: 0.7393
Epoch 3/5
152/152 [==============================] - 1s 4ms/step - loss: 0.4129 - accuracy: 0.7888
Epoch 4/5
152/152 [==============================] - 1s 4ms/step - loss: 0.3663 - accuracy: 0.7921
Epoch 5/5
152/152 [==============================] - 1s 4ms/step - loss: 0.3363 - accuracy: 0.8152

tf.data kullanmak da işe yarar:

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 5ms/step - loss: 0.3150 - accuracy: 0.8284
Epoch 2/5
152/152 [==============================] - 1s 5ms/step - loss: 0.2989 - accuracy: 0.8449
Epoch 3/5
152/152 [==============================] - 1s 5ms/step - loss: 0.2870 - accuracy: 0.8449
Epoch 4/5
152/152 [==============================] - 1s 5ms/step - loss: 0.2782 - accuracy: 0.8482
Epoch 5/5
152/152 [==============================] - 1s 5ms/step - loss: 0.2712 - accuracy: 0.8482