CSV verilerini yükle

TensorFlow.org'da görüntüleyin Google Colab'da çalıştırın Kaynağı GitHub'da görüntüleyinNot defterini indir

Bu öğretici, CSV verilerinin TensorFlow ile nasıl kullanılacağına ilişkin örnekler sağlar.

Bunun iki ana kısmı vardır:

  1. Verileri diskten yükleme
  2. Eğitim için uygun bir forma ön işleme.

Bu öğretici, yüklemeye odaklanır ve bazı hızlı ön işleme örnekleri verir. Bir eğitim için ön işleme yönü üzerinde odaklanır görmesini önişleme katmanları kılavuzu ve öğretici .

Kurmak

import pandas as pd
import numpy as np

# Make numpy values easier to read.
np.set_printoptions(precision=3, suppress=True)

import tensorflow as tf
from tensorflow.keras import layers
from tensorflow.keras.layers.experimental import preprocessing

hafızadaki veriler

Herhangi bir küçük CSV veri kümesi için, üzerinde bir TensorFlow modelini eğitmenin en basit yolu, onu bir panda Veri Çerçevesi veya bir NumPy dizisi olarak belleğe yüklemektir.

Nispeten basit bir örnektir kulağı veri seti .

  • Veri kümesi küçüktür.
  • Tüm giriş özelliklerinin tümü sınırlı aralıklı kayan nokta değerleridir.

İşte içine veri indirmek için nasıl Pandalar DataFrame :

abalone_train = pd.read_csv(
    "https://storage.googleapis.com/download.tensorflow.org/data/abalone_train.csv",
    names=["Length", "Diameter", "Height", "Whole weight", "Shucked weight",
           "Viscera weight", "Shell weight", "Age"])

abalone_train.head()

Veri kümesi ölçümleri kümesi içerir abalon , deniz salyangozu türü.

bir deniz kulağı kabuğu

“Abalone kabuk” ile ( Nicki Dugan Pogue , 2.0 CC ile-SA)

Bu veri kümesinin nominal görevi, yaşı diğer ölçümlerden tahmin etmektir, bu nedenle eğitim için özellikleri ve etiketleri ayırın:

abalone_features = abalone_train.copy()
abalone_labels = abalone_features.pop('Age')

Bu veri kümesi için tüm özelliklere aynı şekilde davranacaksınız. Özellikleri tek bir NumPy dizisine paketleyin.:

abalone_features = np.array(abalone_features)
abalone_features
array([[0.435, 0.335, 0.11 , ..., 0.136, 0.077, 0.097],
       [0.585, 0.45 , 0.125, ..., 0.354, 0.207, 0.225],
       [0.655, 0.51 , 0.16 , ..., 0.396, 0.282, 0.37 ],
       ...,
       [0.53 , 0.42 , 0.13 , ..., 0.374, 0.167, 0.249],
       [0.395, 0.315, 0.105, ..., 0.118, 0.091, 0.119],
       [0.45 , 0.355, 0.12 , ..., 0.115, 0.067, 0.16 ]])

Daha sonra yaşı tahmin eden bir regresyon modeli yapın. Yalnızca tek bir giriş tensör olmadığı için, bir keras.Sequential modeli burada yeterlidir.

abalone_model = tf.keras.Sequential([
  layers.Dense(64),
  layers.Dense(1)
])

abalone_model.compile(loss = tf.losses.MeanSquaredError(),
                      optimizer = tf.optimizers.Adam())

Bu modeli eğitmek için özellikler ve etiketler geçmesi Model.fit :

abalone_model.fit(abalone_features, abalone_labels, epochs=10)
Epoch 1/10
104/104 [==============================] - 1s 2ms/step - loss: 68.1297
Epoch 2/10
104/104 [==============================] - 0s 2ms/step - loss: 13.3981
Epoch 3/10
104/104 [==============================] - 0s 1ms/step - loss: 8.9458
Epoch 4/10
104/104 [==============================] - 0s 1ms/step - loss: 8.3894
Epoch 5/10
104/104 [==============================] - 0s 1ms/step - loss: 7.8835
Epoch 6/10
104/104 [==============================] - 0s 1ms/step - loss: 7.4897
Epoch 7/10
104/104 [==============================] - 0s 1ms/step - loss: 7.1716
Epoch 8/10
104/104 [==============================] - 0s 1ms/step - loss: 6.9468
Epoch 9/10
104/104 [==============================] - 0s 1ms/step - loss: 6.7714
Epoch 10/10
104/104 [==============================] - 0s 1ms/step - loss: 6.6458
<tensorflow.python.keras.callbacks.History at 0x7f7bf0178110>

CSV verilerini kullanarak bir modeli eğitmenin en temel yolunu az önce gördünüz. Ardından, sayısal sütunları normalleştirmek için ön işlemenin nasıl uygulanacağını öğreneceksiniz.

Temel ön işleme

Modelinizin girdilerini normalleştirmek iyi bir uygulamadır. experimental.preprocessing katmanları modeli bu normalleşmesini inşa etmek için uygun bir yol sağlar.

Katman, her sütunun ortalamasını ve varyansını önceden hesaplayacak ve bunları verileri normalleştirmek için kullanacaktır.

İlk önce katmanı oluşturursunuz:

normalize = preprocessing.Normalization()

Sonra kullanmak Normalization.adapt() verilerinize normalleştirme tabakasını adapte yöntemi.

normalize.adapt(abalone_features)

Ardından modelinizde normalleştirme katmanını kullanın:

norm_abalone_model = tf.keras.Sequential([
  normalize,
  layers.Dense(64),
  layers.Dense(1)
])

norm_abalone_model.compile(loss = tf.losses.MeanSquaredError(),
                           optimizer = tf.optimizers.Adam())

norm_abalone_model.fit(abalone_features, abalone_labels, epochs=10)
Epoch 1/10
104/104 [==============================] - 0s 2ms/step - loss: 91.9882
Epoch 2/10
104/104 [==============================] - 0s 2ms/step - loss: 52.3517
Epoch 3/10
104/104 [==============================] - 0s 1ms/step - loss: 16.0901
Epoch 4/10
104/104 [==============================] - 0s 1ms/step - loss: 5.8372
Epoch 5/10
104/104 [==============================] - 0s 1ms/step - loss: 5.0929
Epoch 6/10
104/104 [==============================] - 0s 2ms/step - loss: 5.0442
Epoch 7/10
104/104 [==============================] - 0s 1ms/step - loss: 5.0062
Epoch 8/10
104/104 [==============================] - 0s 1ms/step - loss: 4.9882
Epoch 9/10
104/104 [==============================] - 0s 2ms/step - loss: 4.9629
Epoch 10/10
104/104 [==============================] - 0s 2ms/step - loss: 4.9666
<tensorflow.python.keras.callbacks.History at 0x7f7be008f910>

Karışık veri türleri

"Titanic" veri kümesi, Titanik'teki yolcular hakkında bilgi içerir. Bu veri setindeki nominal görev, kimin hayatta kaldığını tahmin etmektir.

Titanik

Görüntü Wikimedia'daki dan

Ham veriler kolayca panda olarak yüklenebilir DataFrame ancak TensorFlow modele giriş olarak hemen kullanılabilir değildir.

titanic = pd.read_csv("https://storage.googleapis.com/tf-datasets/titanic/train.csv")
titanic.head()
titanic_features = titanic.copy()
titanic_labels = titanic_features.pop('survived')

Çünkü, farklı veri tipleri ve aralıkların sadece NumPy diziye özellikleri yığını olamaz ve bir onu geçmek keras.Sequential modeli. Her sütunun ayrı ayrı ele alınması gerekir.

Bir seçenek olarak, kategorik sütunları sayısal sütunlara dönüştürmek için verilerinizi çevrimdışı olarak (istediğiniz herhangi bir aracı kullanarak) önceden işleyebilir ve ardından işlenen çıktıyı TensorFlow modelinize iletebilirsiniz. Bu yaklaşımın dezavantajı, modelinizi kaydedip dışa aktarırsanız, ön işlemenin onunla birlikte kaydedilmemesidir. experimental.preprocessing onlar modelinin bir parçası olduğun için katmanları bu sorunu önlemek.

Bu örnekte, uygular ön işleme mantığı kullanarak o bir model inşa edeceğiz keras fonksiyonel API . Ayrıca bunu yapabilirdi sınıflara .

İşlevsel API, "sembolik" tensörler üzerinde çalışır. Normal "istekli" tensörlerin bir değeri vardır. Buna karşılık, bu "sembolik" tensörler yoktur. Bunun yerine, üzerlerinde hangi işlemlerin yürütüldüğünü izlerler ve daha sonra çalıştırabileceğiniz hesaplamanın temsilini oluştururlar. İşte hızlı bir örnek:

# Create a symbolic input
input = tf.keras.Input(shape=(), dtype=tf.float32)

# Do a calculation using is
result = 2*input + 1

# the result doesn't have a value
result
<KerasTensor: shape=(None,) dtype=float32 (created by layer 'tf.__operators__.add')>
calc = tf.keras.Model(inputs=input, outputs=result)
print(calc(1).numpy())
print(calc(2).numpy())
3.0
5.0

Önişleme modeli oluşturmak için sembolik bir dizi inşa ederek başlamak keras.Input , nesnelerin CSV sütunlarının isim ve veri tiplerini eşleşen.

inputs = {}

for name, column in titanic_features.items():
  dtype = column.dtype
  if dtype == object:
    dtype = tf.string
  else:
    dtype = tf.float32

  inputs[name] = tf.keras.Input(shape=(1,), name=name, dtype=dtype)

inputs
{'sex': <KerasTensor: shape=(None, 1) dtype=string (created by layer 'sex')>,
 'age': <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'age')>,
 'n_siblings_spouses': <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'n_siblings_spouses')>,
 'parch': <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'parch')>,
 'fare': <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'fare')>,
 'class': <KerasTensor: shape=(None, 1) dtype=string (created by layer 'class')>,
 'deck': <KerasTensor: shape=(None, 1) dtype=string (created by layer 'deck')>,
 'embark_town': <KerasTensor: shape=(None, 1) dtype=string (created by layer 'embark_town')>,
 'alone': <KerasTensor: shape=(None, 1) dtype=string (created by layer 'alone')>}

Ön işleme mantığınızdaki ilk adım, sayısal girdileri bir araya getirmek ve bunları bir normalleştirme katmanından geçirmektir:

numeric_inputs = {name:input for name,input in inputs.items()
                  if input.dtype==tf.float32}

x = layers.Concatenate()(list(numeric_inputs.values()))
norm = preprocessing.Normalization()
norm.adapt(np.array(titanic[numeric_inputs.keys()]))
all_numeric_inputs = norm(x)

all_numeric_inputs
<KerasTensor: shape=(None, 4) dtype=float32 (created by layer 'normalization_1')>

Daha sonra birleştirmek için tüm sembolik ön işleme sonuçlarını toplayın.

preprocessed_inputs = [all_numeric_inputs]

Dize için girişler kullanmak preprocessing.StringLookup bir kelime tamsayı indeksleri dizelerden haritaya işlevini. Sonra, kullanım preprocessing.CategoryEncoding içine dizinleri dönüştürmek için float32 modeli için veri uygun.

Varsayılan ayarları preprocessing.CategoryEncoding tabakasının her giriş için tek sıcak vektör oluşturun. Bir layers.Embedding da çalışacak. Bkz önişleme katmanları kılavuzu ve öğretici bu konu hakkında daha fazla bilgi için.

for name, input in inputs.items():
  if input.dtype == tf.float32:
    continue

  lookup = preprocessing.StringLookup(vocabulary=np.unique(titanic_features[name]))
  one_hot = preprocessing.CategoryEncoding(max_tokens=lookup.vocab_size())

  x = lookup(input)
  x = one_hot(x)
  preprocessed_inputs.append(x)
WARNING:tensorflow:vocab_size is deprecated, please use vocabulary_size.
WARNING:tensorflow:max_tokens is deprecated, please use num_tokens instead.
WARNING:tensorflow:vocab_size is deprecated, please use vocabulary_size.
WARNING:tensorflow:max_tokens is deprecated, please use num_tokens instead.
WARNING:tensorflow:vocab_size is deprecated, please use vocabulary_size.
WARNING:tensorflow:max_tokens is deprecated, please use num_tokens instead.
WARNING:tensorflow:vocab_size is deprecated, please use vocabulary_size.
WARNING:tensorflow:max_tokens is deprecated, please use num_tokens instead.
WARNING:tensorflow:vocab_size is deprecated, please use vocabulary_size.
WARNING:tensorflow:max_tokens is deprecated, please use num_tokens instead.

Toplanması ile inputs ve processed_inputs , birlikte tüm ön işlenmiş girdileri bitiştirmek ve kolları önişleme bir modeli inşa edebilirsiniz:

preprocessed_inputs_cat = layers.Concatenate()(preprocessed_inputs)

titanic_preprocessing = tf.keras.Model(inputs, preprocessed_inputs_cat)

tf.keras.utils.plot_model(model = titanic_preprocessing , rankdir="LR", dpi=72, show_shapes=True)

png

Bu model sadece giriş ön işlemeyi içerir. Verilerinize ne yaptığını görmek için çalıştırabilirsiniz. Keras modelleri otomatik Pandalar dönüştürmeyin DataFrames o bir tensör ya tensörlerinin sözlükten dönüştürülmesi gerekir eğer açık değil çünkü. Öyleyse onu bir tensör sözlüğüne dönüştürün:

titanic_features_dict = {name: np.array(value) 
                         for name, value in titanic_features.items()}

İlk eğitim örneğini dilimleyin ve bu ön işleme modeline iletin, sayısal özellikleri ve tek-sıcaklık dizisini bir araya getirilmiş olarak görürsünüz:

features_dict = {name:values[:1] for name, values in titanic_features_dict.items()}
titanic_preprocessing(features_dict)
<tf.Tensor: shape=(1, 33), dtype=float32, numpy=
array([[-0.61 ,  0.395, -0.479, -0.497,  0.   ,  0.   ,  0.   ,  1.   ,

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

Şimdi modeli bunun üzerine kurun:

def titanic_model(preprocessing_head, inputs):
  body = tf.keras.Sequential([
    layers.Dense(64),
    layers.Dense(1)
  ])

  preprocessed_inputs = preprocessing_head(inputs)
  result = body(preprocessed_inputs)
  model = tf.keras.Model(inputs, result)

  model.compile(loss=tf.losses.BinaryCrossentropy(from_logits=True),
                optimizer=tf.optimizers.Adam())
  return model

titanic_model = titanic_model(titanic_preprocessing, inputs)

Eğer modeli eğitmek zaman olduğu gibi özelliklerin sözlüğünü geçmesi x ve aynı etiketi y .

titanic_model.fit(x=titanic_features_dict, y=titanic_labels, epochs=10)
Epoch 1/10
20/20 [==============================] - 1s 3ms/step - loss: 0.5665
Epoch 2/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4980
Epoch 3/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4643
Epoch 4/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4463
Epoch 5/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4333
Epoch 6/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4297
Epoch 7/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4252
Epoch 8/10
20/20 [==============================] - 0s 4ms/step - loss: 0.4234
Epoch 9/10
20/20 [==============================] - 0s 4ms/step - loss: 0.4213
Epoch 10/10
20/20 [==============================] - 0s 4ms/step - loss: 0.4202
<tensorflow.python.keras.callbacks.History at 0x7f7c8ff43510>

Ön işleme, modelin bir parçası olduğundan, modeli kaydedebilir ve başka bir yere yeniden yükleyebilir ve aynı sonuçları alabilirsiniz:

titanic_model.save('test')
reloaded = tf.keras.models.load_model('test')
INFO:tensorflow:Assets written to: test/assets
features_dict = {name:values[:1] for name, values in titanic_features_dict.items()}

before = titanic_model(features_dict)
after = reloaded(features_dict)
assert (before-after)<1e-3
print(before)
print(after)
tf.Tensor([[-1.843]], shape=(1, 1), dtype=float32)
tf.Tensor([[-1.843]], shape=(1, 1), dtype=float32)

tf.data'yı kullanma

Önceki bölümde, modeli eğitirken modelin yerleşik veri karıştırma ve gruplandırmasına güvendiniz.

Kullanım: Eğer giriş veri boru hattı veya kolayca bellek sığmayan veriyi kullanmaya gerek üzerinde daha fazla kontrol gerekiyorsa tf.data .

Daha fazla örnek için bkz tf.data kılavuzu .

Açık bellek verisi

Uygulanması İlk örnek olarak tf.data CSV verilerine önceki bölümden özelliklerin sözlüğe kadar elle dilim için aşağıdaki kodu düşünün. Her dizin için, her özellik için o dizini alır:

import itertools

def slices(features):
  for i in itertools.count():
    # For each feature take index `i`
    example = {name:values[i] for name, values in features.items()}
    yield example

Bunu çalıştırın ve ilk örneği yazdırın:

for example in slices(titanic_features_dict):
  for name, value in example.items():
    print(f"{name:19s}: {value}")
  break
sex                : male
age                : 22.0
n_siblings_spouses : 1
parch              : 0
fare               : 7.25
class              : Third
deck               : unknown
embark_town        : Southampton
alone              : n

En temel tf.data.Dataset bellek veri yükleyici olan Dataset.from_tensor_slices yapıcı. Bu döner bir tf.data.Dataset olduğunu uygular yukarıda bir genelleştirilmiş sürümü slices TensorFlow işlev.

features_ds = tf.data.Dataset.from_tensor_slices(titanic_features_dict)

Bir adımlayabilirsiniz tf.data.Dataset başka piton iterable gibi:

for example in features_ds:
  for name, value in example.items():
    print(f"{name:19s}: {value}")
  break
sex                : b'male'
age                : 22.0
n_siblings_spouses : 1
parch              : 0
fare               : 7.25
class              : b'Third'
deck               : b'unknown'
embark_town        : b'Southampton'
alone              : b'n'

from_tensor_slices işlev iç içe sözlükler ya dizilerini herhangi yapısını işleyebilir. Aşağıdaki kod içeren bir veritabanı yapar (features_dict, labels) çiftleri:

titanic_ds = tf.data.Dataset.from_tensor_slices((titanic_features_dict, titanic_labels))

Bu kullanarak bir model eğitmek Dataset , sen en azından gerekir shuffle ve batch verileri.

titanic_batches = titanic_ds.shuffle(len(titanic_labels)).batch(32)

Yerine geçen features ve labels için Model.fit , veri kümesini geçmesi:

titanic_model.fit(titanic_batches, epochs=5)
Epoch 1/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4199
Epoch 2/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4199
Epoch 3/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4192
Epoch 4/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4189
Epoch 5/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4185
<tensorflow.python.keras.callbacks.History at 0x7f7c8e8ee810>

Tek bir dosyadan

Şimdiye kadar bu öğretici, bellek içi verilerle çalıştı. tf.data veri boru hattı inşa etmek için son derece ölçeklenebilir bir araç olduğunu ve yükleme CSV dosyalarını başa çıkmak için birkaç fonksiyonları sağlar.

titanic_file_path = tf.keras.utils.get_file("train.csv", "https://storage.googleapis.com/tf-datasets/titanic/train.csv")
Downloading data from https://storage.googleapis.com/tf-datasets/titanic/train.csv
32768/30874 [===============================] - 0s 0us/step

Şimdi dosyadan CSV verilerini okumak ve oluşturmak tf.data.Dataset .

(Tam dokümantasyon için bkz tf.data.experimental.make_csv_dataset )

titanic_csv_ds = tf.data.experimental.make_csv_dataset(
    titanic_file_path,
    batch_size=5, # Artificially small to make examples easier to show.
    label_name='survived',
    num_epochs=1,
    ignore_errors=True,)

Bu işlev, verilerle çalışmanın kolay olması için birçok kullanışlı özellik içerir. Bu içerir:

  • Sütun başlıklarını sözlük anahtarları olarak kullanma.
  • Her sütunun türünü otomatik olarak belirleme.
for batch, label in titanic_csv_ds.take(1):
  for key, value in batch.items():
    print(f"{key:20s}: {value}")
  print()
  print(f"{'label':20s}: {label}")
sex                 : [b'male' b'female' b'male' b'male' b'male']
age                 : [28. 28. 70.  1. 28.]
n_siblings_spouses  : [1 0 1 5 1]
parch               : [0 0 1 2 0]
fare                : [82.171  7.225 71.    46.9   15.85 ]
class               : [b'First' b'Third' b'First' b'Third' b'Third']
deck                : [b'unknown' b'unknown' b'B' b'unknown' b'unknown']
embark_town         : [b'Cherbourg' b'Cherbourg' b'Southampton' b'Southampton' b'Southampton']
alone               : [b'n' b'y' b'n' b'n' b'n']

label               : [0 1 0 0 0]

Ayrıca, verileri anında açabilir. İşte içeren gzip'li CSV dosyası var metro devletlerarası trafik veri kümesini

Trafik sıkışıklığı.

Görüntü Wikimedia'daki dan

traffic_volume_csv_gz = tf.keras.utils.get_file(
    'Metro_Interstate_Traffic_Volume.csv.gz', 
    "https://archive.ics.uci.edu/ml/machine-learning-databases/00492/Metro_Interstate_Traffic_Volume.csv.gz",
    cache_dir='.', cache_subdir='traffic')
Downloading data from https://archive.ics.uci.edu/ml/machine-learning-databases/00492/Metro_Interstate_Traffic_Volume.csv.gz
409600/405373 [==============================] - 1s 2us/step

Set compression_type sıkıştırılmış dosyadan doğrudan okumak için argüman:

traffic_volume_csv_gz_ds = tf.data.experimental.make_csv_dataset(
    traffic_volume_csv_gz,
    batch_size=256,
    label_name='traffic_volume',
    num_epochs=1,
    compression_type="GZIP")

for batch, label in traffic_volume_csv_gz_ds.take(1):
  for key, value in batch.items():
    print(f"{key:20s}: {value[:5]}")
  print()
  print(f"{'label':20s}: {label[:5]}")
holiday             : [b'None' b'None' b'None' b'None' b'None']
temp                : [275.36 264.13 265.53 278.63 289.91]
rain_1h             : [0.   0.   0.   0.   1.52]
snow_1h             : [0. 0. 0. 0. 0.]
clouds_all          : [90 90 75 90 80]
weather_main        : [b'Rain' b'Clouds' b'Clouds' b'Rain' b'Mist']
weather_description : [b'light rain' b'overcast clouds' b'broken clouds' b'light rain' b'mist']
date_time           : [b'2013-03-10 19:00:00' b'2013-01-02 19:00:00' b'2012-12-06 06:00:00'
 b'2013-04-25 18:00:00' b'2013-07-31 04:00:00']

label               : [2743 2687 5545 5020  822]

Önbelleğe almak

csv verilerini ayrıştırmak için biraz ek yük var. Küçük modeller için bu, eğitimdeki darboğaz olabilir.

Senin kullanım durumuna bağlı olarak, kullanmak için iyi bir fikir olabilir Dataset.cache veya data.experimental.snapshot csv verileri yalnızca ilk dönemi üzerine ayrıştırılacak şekilde.

Arasındaki temel fark cache ve snapshot yöntemlerinin olmasıdır cache dosyaları yalnızca onları yaratan TensorFlow işlemi tarafından kullanılabilir, ancak snapshot dosyalar diğer süreçler tarafından okunabilir.

Örneğin, yineleme traffic_volume_csv_gz_ds 20 kez, önbelleğe alma ~ 2s önbelleğe alma olmadan ~ 15 saniye sürer, ya da.

%%time
for i, (batch, label) in enumerate(traffic_volume_csv_gz_ds.repeat(20)):
  if i % 40 == 0:
    print('.', end='')
print()
...............................................................................................
CPU times: user 14.9 s, sys: 3.58 s, total: 18.5 s
Wall time: 11 s
%%time
caching = traffic_volume_csv_gz_ds.cache().shuffle(1000)

for i, (batch, label) in enumerate(caching.shuffle(1000).repeat(20)):
  if i % 40 == 0:
    print('.', end='')
print()
...............................................................................................
CPU times: user 1.42 s, sys: 115 ms, total: 1.53 s
Wall time: 1.22 s
%%time
snapshot = tf.data.experimental.snapshot('titanic.tfsnap')
snapshotting = traffic_volume_csv_gz_ds.apply(snapshot).shuffle(1000)

for i, (batch, label) in enumerate(snapshotting.shuffle(1000).repeat(20)):
  if i % 40 == 0:
    print('.', end='')
print()
...............................................................................................
CPU times: user 2.26 s, sys: 431 ms, total: 2.69 s
Wall time: 1.62 s

Veri yükleme yükleme csv dosyaları ve yavaşladığını ise cache ve snapshot senin kullanım örneği için yetersizdir, daha aerodinamik biçime verileri yeniden kodlamayı düşünün.

Birden çok dosya

Şimdiye kadar bu bölümdeki tüm örnekler kolayca olmadan yapılabilir tf.data . Bir yerde tf.data dosyaların koleksiyonları ile uğraşırken gerçekten şeyleri kolaylaştırabilir olduğunu.

Örneğin, karakter font görüntüleri csv dosyaları, yazı başına bir topluluğu olarak dağıtılır veri kümesi.

Yazı Tipleri

Tarafından Görüntü Willi Heidelbach dan Pixabay

Veri kümesini indirin ve içindeki dosyalara bir göz atın:

fonts_zip = tf.keras.utils.get_file(
    'fonts.zip',  "https://archive.ics.uci.edu/ml/machine-learning-databases/00417/fonts.zip",
    cache_dir='.', cache_subdir='fonts',
    extract=True)
Downloading data from https://archive.ics.uci.edu/ml/machine-learning-databases/00417/fonts.zip
160317440/160313983 [==============================] - 8s 0us/step
import pathlib
font_csvs =  sorted(str(p) for p in pathlib.Path('fonts').glob("*.csv"))

font_csvs[:10]
['fonts/AGENCY.csv',
 'fonts/ARIAL.csv',
 'fonts/BAITI.csv',
 'fonts/BANKGOTHIC.csv',
 'fonts/BASKERVILLE.csv',
 'fonts/BAUHAUS.csv',
 'fonts/BELL.csv',
 'fonts/BERLIN.csv',
 'fonts/BERNARD.csv',
 'fonts/BITSTREAMVERA.csv']
len(font_csvs)
153

Dosyaların bir grup ile uğraşırken bir gıdım bile tarzı geçebilir file_pattern için experimental.make_csv_dataset fonksiyonu. Dosyaların sırası her yinelemede karıştırılır.

Kullanım num_parallel_reads sayıda dosya paralel olarak okunan ve birlikte biçimde birbirinin arasına nasıl setine argüman.

fonts_ds = tf.data.experimental.make_csv_dataset(
    file_pattern = "fonts/*.csv",
    batch_size=10, num_epochs=1,
    num_parallel_reads=20,
    shuffle_buffer_size=10000)

Bu csv dosyaları, görüntüleri tek bir sıra halinde düzleştirir. Sütun adları biçimlendirilir r{row}c{column} . İşte ilk parti:

for features in fonts_ds.take(1):
  for i, (name, value) in enumerate(features.items()):
    if i>15:
      break
    print(f"{name:20s}: {value}")
print('...')
print(f"[total: {len(features)} features]")
font                : [b'GLOUCESTER' b'REFERENCE' b'TREBUCHET' b'MONEY' b'GLOUCESTER' b'MONEY'
 b'GLOUCESTER' b'JUICE' b'CAMBRIA' b'BRUSH']
fontVariant         : [b'GLOUCESTER MT EXTRA CONDENSED' b'MS REFERENCE SANS SERIF'
 b'TREBUCHET MS' b'scanned' b'GLOUCESTER MT EXTRA CONDENSED' b'scanned'
 b'GLOUCESTER MT EXTRA CONDENSED' b'JUICE ITC' b'CAMBRIA'
 b'BRUSH SCRIPT MT']
m_label             : [  116 63521   507    53   402    54  8747   213 10766  8776]
strength            : [0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4]
italic              : [1 0 0 0 0 0 0 1 0 1]
orientation         : [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
m_top               : [41 21 23  0 31  0 22 20 25 44]
m_left              : [25 26 23  0 15  0 20 27 23 24]
originalH           : [42 68 64 32 63 27 68 61 73 25]
originalW           : [18 30 30 19 22 16 18 33 32 36]
h                   : [20 20 20 20 20 20 20 20 20 20]
w                   : [20 20 20 20 20 20 20 20 20 20]
r0c0                : [1 1 1 1 1 1 1 1 1 1]
r0c1                : [ 1  1  1 91  1  1  1  1  1  1]
r0c2                : [  1   1   1 239   1   1   1   1   1  40]
r0c3                : [  1   1   1 255   1   1   1   1   1  74]
...
[total: 412 features]

İsteğe bağlı: Paketleme alanları

Muhtemelen her pikselle bunun gibi ayrı sütunlarda çalışmak istemezsiniz. Bu veri kümesini kullanmaya çalışmadan önce pikselleri bir görüntü tensörüne yerleştirdiğinizden emin olun.

Her örnek için görüntüler oluşturmak üzere sütun adlarını ayrıştıran kod:

import re

def make_images(features):
  image = [None]*400
  new_feats = {}

  for name, value in features.items():
    match = re.match('r(\d+)c(\d+)', name)
    if match:
      image[int(match.group(1))*20+int(match.group(2))] = value
    else:
      new_feats[name] = value

  image = tf.stack(image, axis=0)
  image = tf.reshape(image, [20, 20, -1])
  new_feats['image'] = image

  return new_feats

Bu işlevi veri kümesindeki her toplu iş için uygulayın:

fonts_image_ds = fonts_ds.map(make_images)

for features in fonts_image_ds.take(1):
  break

Ortaya çıkan görüntüleri çizin:

from matplotlib import pyplot as plt

plt.figure(figsize=(6,6), dpi=120)

for n in range(9):
  plt.subplot(3,3,n+1)
  plt.imshow(features['image'][..., n])
  plt.title(chr(features['m_label'][n]))
  plt.axis('off')

png

Alt seviye fonksiyonlar

Şimdiye kadar bu öğretici, csv verilerini okumak için en üst düzey yardımcı programlara odaklandı. Kullanım durumunuz temel kalıplara uymuyorsa, ileri düzey kullanıcılar için yararlı olabilecek başka iki API vardır.

Tarafından temin edilen bu bölüm yeniden yaratmaktadır işlevsellik make_csv_dataset , bu alt düzeyinde işlevsellik kullanılabilir göstermek için.

tf.io.decode_csv

Bu işlev, bir dizeyi veya dize listesini bir sütun listesine çözer.

Aksine make_csv_dataset bu işlev sütun veri tiplerini tahmin etmeye çalışmaz. Sen bir listesini sunarak sütun türlerini belirtmek record_defaults her sütun için doğru türde bir değer içeren.

Kullanarak dizeleri olarak Titanik verilerini okumak için decode_csv diyebilirsiniz:

text = pathlib.Path(titanic_file_path).read_text()
lines = text.split('\n')[1:-1]

all_strings = [str()]*10
all_strings
['', '', '', '', '', '', '', '', '', '']
features = tf.io.decode_csv(lines, record_defaults=all_strings) 

for f in features:
  print(f"type: {f.dtype.name}, shape: {f.shape}")
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)

Gerçek türleri ile bunları ayrıştırmak için bir liste oluşturmak record_defaults tekabül türleri:

print(lines[0])
0,male,22.0,1,0,7.25,Third,unknown,Southampton,n
titanic_types = [int(), str(), float(), int(), int(), float(), str(), str(), str(), str()]
titanic_types
[0, '', 0.0, 0, 0, 0.0, '', '', '', '']
features = tf.io.decode_csv(lines, record_defaults=titanic_types) 

for f in features:
  print(f"type: {f.dtype.name}, shape: {f.shape}")
type: int32, shape: (627,)
type: string, shape: (627,)
type: float32, shape: (627,)
type: int32, shape: (627,)
type: int32, shape: (627,)
type: float32, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)

tf.data.experimental.CsvDataset

tf.data.experimental.CsvDataset sınıfı en az bir CSV içerir Dataset kolaylık özelliklerine sahip olmayan bir arayüz make_csv_dataset sütun başlığı ayrıştırma, sütun türü çıkarımı, otomatik karıştırma, dosya serpiştirmesi: işlevi.

Bu yapıcı kullanımları aşağıdaki record_defaults aynı şekilde io.parse_csv :

simple_titanic = tf.data.experimental.CsvDataset(titanic_file_path, record_defaults=titanic_types, header=True)

for example in simple_titanic.take(1):
  print([e.numpy() for e in example])
[0, b'male', 22.0, 1, 0, 7.25, b'Third', b'unknown', b'Southampton', b'n']

Yukarıdaki kod temelde şuna eşdeğerdir:

def decode_titanic_line(line):
  return tf.io.decode_csv(line, titanic_types)

manual_titanic = (
    # Load the lines of text
    tf.data.TextLineDataset(titanic_file_path)
    # Skip the header row.
    .skip(1)
    # Decode the line.
    .map(decode_titanic_line)
)

for example in manual_titanic.take(1):
  print([e.numpy() for e in example])
[0, b'male', 22.0, 1, 0, 7.25, b'Third', b'unknown', b'Southampton', b'n']

Birden çok dosya

Kullanarak veri kümesi yazı tiplerini ayrıştırmak için experimental.CsvDataset için sütun türlerini belirlemek için, önce ihtiyacı record_defaults . Bir dosyanın ilk satırını inceleyerek başlayın:

font_line = pathlib.Path(font_csvs[0]).read_text().splitlines()[1]
print(font_line)
AGENCY,AGENCY FB,64258,0.400000,0,0.000000,35,21,51,22,20,20,1,1,1,21,101,210,255,255,255,255,255,255,255,255,255,255,255,255,255,255,1,1,1,93,255,255,255,176,146,146,146,146,146,146,146,146,216,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,141,141,141,182,255,255,255,172,141,141,141,115,1,1,1,1,163,255,255,255,255,255,255,255,255,255,255,255,255,255,255,209,1,1,1,1,163,255,255,255,6,6,6,96,255,255,255,74,6,6,6,5,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255

Yalnızca ilk iki alan dizedir, geri kalanı ints veya float'tır ve virgülleri sayarak toplam özellik sayısını elde edebilirsiniz:

num_font_features = font_line.count(',')+1
font_column_types = [str(), str()] + [float()]*(num_font_features-2)

CsvDatasaet yapıcı girdi dosyaların bir listesini alır, ama bunları sırayla okur edebilirsiniz. CSV'lerden listesinde ilk dosyadır AGENCY.csv :

font_csvs[0]
'fonts/AGENCY.csv'

Eğer dosyaların listesini iletmek geçtiğinde Yani CsvDataaset kayıtları AGENCY.csv ilk okunur:

simple_font_ds = tf.data.experimental.CsvDataset(
    font_csvs, 
    record_defaults=font_column_types, 
    header=True)
for row in simple_font_ds.take(10):
  print(row[0].numpy())
b'AGENCY'
b'AGENCY'
b'AGENCY'
b'AGENCY'
b'AGENCY'
b'AGENCY'
b'AGENCY'
b'AGENCY'
b'AGENCY'
b'AGENCY'

Birden fazla dosya serpiştirmek için kullanın Dataset.interleave .

İşte csv dosya adlarını içeren bir ilk veri kümesi:

font_files = tf.data.Dataset.list_files("fonts/*.csv")

Bu, her dönem dosya adlarını karıştırır:

print('Epoch 1:')
for f in list(font_files)[:5]:
  print("    ", f.numpy())
print('    ...')
print()

print('Epoch 2:')
for f in list(font_files)[:5]:
  print("    ", f.numpy())
print('    ...')
Epoch 1:
     b'fonts/BROADWAY.csv'
     b'fonts/COPPERPLATE.csv'
     b'fonts/STENCIL.csv'
     b'fonts/COOPER.csv'
     b'fonts/GABRIOLA.csv'
    ...

Epoch 2:
     b'fonts/MONOSPAC821.csv'
     b'fonts/ONYX.csv'
     b'fonts/HARLOW.csv'
     b'fonts/TIMES.csv'
     b'fonts/JOKERMAN.csv'
    ...

interleave yöntem alır map_func içinde bir çocuk yaratır Dataset ebeveyn her bir öğesi için Dataset .

Burada, bir oluşturmak istediğiniz CsvDataset dosyalarının veri kümesinin her öğeden:

def make_font_csv_ds(path):
  return tf.data.experimental.CsvDataset(
    path, 
    record_defaults=font_column_types, 
    header=True)

Dataset çocuk-bir dizi devir daim ile boş yaprak döner elemanlar tarafından döndürülen Dataset s. Not Aşağıda, üzerinde veri kümesi döngüleri nasıl cycle_length)=3 üç yazı tipi dosyalarını:

font_rows = font_files.interleave(make_font_csv_ds,
                                  cycle_length=3)
fonts_dict = {'font_name':[], 'character':[]}

for row in font_rows.take(10):
  fonts_dict['font_name'].append(row[0].numpy().decode())
  fonts_dict['character'].append(chr(row[2].numpy()))

pd.DataFrame(fonts_dict)

Verim

Daha önce, o kaydedildi io.decode_csv dizeleri toplu olarak çalıştırdığınızda daha verimlidir.

O (ama denemek büyük parti büyüklüklerini kullanırken CSV yükleme performansını iyileştirmek için, bu gerçeği yararlanmak mümkündür önbelleğe önce).

Yerleşik 20 yükleyici ile 2048 örnek partiler yaklaşık 17 saniye sürer.

BATCH_SIZE=2048
fonts_ds = tf.data.experimental.make_csv_dataset(
    file_pattern = "fonts/*.csv",
    batch_size=BATCH_SIZE, num_epochs=1,
    num_parallel_reads=100)
%%time
for i,batch in enumerate(fonts_ds.take(20)):
  print('.',end='')

print()
....................
CPU times: user 26.8 s, sys: 1.75 s, total: 28.6 s
Wall time: 11.1 s

Metin hatlarının toplu Geçme decode_csv Yaklaşık 5 saniye içinde, daha hızlı çalışır:

fonts_files = tf.data.Dataset.list_files("fonts/*.csv")
fonts_lines = fonts_files.interleave(
    lambda fname:tf.data.TextLineDataset(fname).skip(1), 
    cycle_length=100).batch(BATCH_SIZE)

fonts_fast = fonts_lines.map(lambda x: tf.io.decode_csv(x, record_defaults=font_column_types))
%%time
for i,batch in enumerate(fonts_fast.take(20)):
  print('.',end='')

print()
....................
CPU times: user 9.29 s, sys: 0 ns, total: 9.29 s
Wall time: 1.48 s

Büyük grupları kullanarak CSV performansı artırmak için başka bir örnek için bkz overfit ve underfit öğretici .

Yaklaşımın Bu tür çalışır ancak benzeri diğer seçenekleri dikkate alabilir cache ve snapshot bir daha aerodinamik biçime veya verilerinizi yeniden enncoding.