notebook.community

Edit and run 





In [ ]:



    


#@title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

Muat data CSV

Lihat di TensorFlow.org Lihat kode di GitHub Unduh notebook

Note: Komunitas TensorFlow kami telah menerjemahkan dokumen-dokumen ini. Tidak ada jaminan bahwa translasi ini akurat, dan translasi terbaru dari Official Dokumentasi - Bahasa Inggris karena komunitas translasi ini adalah usaha terbaik dari komunitas translasi. Jika Anda memiliki saran untuk meningkatkan terjemahan ini, silakan kirim pull request ke tensorflow/docs repositori GitHub. Untuk menjadi sukarelawan untuk menulis atau memeriksa terjemahan komunitas, hubungi daftar docs@tensorflow.org.

Tutorial ini memberikan contoh cara memuat data CSV dari file ke tf.data.Dataset.

Data yang digunakan dalam tutorial ini diambil dari daftar penumpang Titanic. Model akan memprediksi kemungkinan penumpang selamat berdasarkan karakteristik seperti usia, jenis kelamin, kelas tiket, dan apakah orang tersebut bepergian sendirian.

Setup





In [ ]:



    


import functools

import numpy as np
import tensorflow as tf



    











In [ ]:



    


TRAIN_DATA_URL = "https://storage.googleapis.com/tf-datasets/titanic/train.csv"
TEST_DATA_URL = "https://storage.googleapis.com/tf-datasets/titanic/eval.csv"

train_file_path = tf.keras.utils.get_file("train.csv", TRAIN_DATA_URL)
test_file_path = tf.keras.utils.get_file("eval.csv", TEST_DATA_URL)



    











In [ ]:



    


# Membuat nilai numpy agar lebih mudah dibaca.
np.set_printoptions(precision=3, suppress=True)

Memuat data

Untuk memulai, mari kita lihat bagian atas file CSV untuk melihat formatnya.





In [ ]:



    


!head {train_file_path}

Anda dapat [memuat ini menggunakan panda] (pandas.ipynb), dan meneruskan array NumPy ke TensorFlow. Jika Anda perlu meningkatkan ke file dengan skala besar, atau membutuhkan loader yang terintegrasi dengan [TensorFlow dan tf.data] (../../panduan/data.ipynb) kemudian gunakan fungsi tf.data.experimental.make_csv_dataset:

Satu-satunya kolom yang perlu Anda identifikasi secara eksplisit adalah kolom dengan nilai yang dimaksudkan untuk diprediksi oleh model.





In [ ]:



    


LABEL_COLUMN = 'survived'
LABELS = [0, 1]

Sekarang baca data CSV dari file dan buat sebuah dataset.

(Untuk dokumentasi lengkap, lihat tf.data.experimental.make_csv_dataset)





In [ ]:



    


def get_dataset(file_path, **kwargs):
  dataset = tf.data.experimental.make_csv_dataset(
      file_path,
      batch_size=5, # Artifisial kecil untuk membuat contoh lebih mudah ditampilkan.
      label_name=LABEL_COLUMN,
      na_value="?",
      num_epochs=1,
      ignore_errors=True, 
      **kwargs)
  return dataset

raw_train_data = get_dataset(train_file_path)
raw_test_data = get_dataset(test_file_path)



    











In [ ]:



    


def show_batch(dataset):
  for batch, label in dataset.take(1):
    for key, value in batch.items():
      print("{:20s}: {}".format(key,value.numpy()))

Setiap item dalam dataset adalah batch, direpresentasikan sebagai tuple dari (banyak contoh, banyak label). Data dari contoh-contoh tersebut disusun dalam tensor berbasis kolom (bukan tensor berbasis baris), masing-masing dengan elemen sebanyak ukuran batch (dalam kasus ini 5).

Dengan melihat sendiri, mungkin akan membantu Anda untuk memahami.





In [ ]:



    


show_batch(raw_train_data)

Seperti yang Anda lihat, kolom dalam file CSV diberi nama. Konstruktor dataset akan mengambil nama-nama ini secara otomatis. Jika file yang sedang Anda kerjakan tidak mengandung nama kolom di baris pertama, berikan mereka dalam daftar string ke argumen column_names dalam fungsimake_csv_dataset.





In [ ]:



    


CSV_COLUMNS = ['survived', 'sex', 'age', 'n_siblings_spouses', 'parch', 'fare', 'class', 'deck', 'embark_town', 'alone']

temp_dataset = get_dataset(train_file_path, column_names=CSV_COLUMNS)

show_batch(temp_dataset)

Contoh ini akan menggunakan semua kolom yang tersedia. Jika Anda perlu menghilangkan beberapa kolom dari dataset, buat daftar hanya kolom yang Anda rencanakan untuk digunakan, dan kirimkan ke argumen select_columns (opsional) dari konstruktor.





In [ ]:



    


SELECT_COLUMNS = ['survived', 'age', 'n_siblings_spouses', 'class', 'deck', 'alone']

temp_dataset = get_dataset(train_file_path, select_columns=SELECT_COLUMNS)

show_batch(temp_dataset)

Data pre-processing

File CSV dapat berisi berbagai tipe data. Biasanya Anda ingin mengonversi dari berbagai tipe ke vektor dengan panjang tetap sebelum memasukkan data ke dalam model Anda.

TensorFlow memiliki sistem bawaan untuk menjelaskan konversi input umum: tf.feature_column, lihat tutorial ini untuk detailnya.

Anda dapat memproses data Anda menggunakan alat apa pun yang Anda suka (seperti nltk atau sklearn), dan kemudian memberikan output yang telah diproses ke TensorFlow.

Keuntungan utama melakukan preprocessing di dalam model Anda adalah ketika Anda mengekspor model itu termasuk dengan proses preprocessing. Dengan cara ini Anda bisa mengirimkan data mentah langsung ke model Anda.

Continuous data

Jika data Anda sudah dalam format numerik yang sesuai, Anda bisa mengemas data ke dalam vektor sebelum meneruskannya ke model:





In [ ]:



    


SELECT_COLUMNS = ['survived', 'age', 'n_siblings_spouses', 'parch', 'fare']
DEFAULTS = [0, 0.0, 0.0, 0.0, 0.0]
temp_dataset = get_dataset(train_file_path, 
                           select_columns=SELECT_COLUMNS,
                           column_defaults = DEFAULTS)

show_batch(temp_dataset)



    











In [ ]:



    


example_batch, labels_batch = next(iter(temp_dataset))

Berikut adalah fungsi sederhana yang akan menyatukan semua

kolom:





In [ ]:



    


def pack(features, label):
  return tf.stack(list(features.values()), axis=-1), label

Terapkan ini ke setiap elemen dataset:





In [ ]:



    


packed_dataset = temp_dataset.map(pack)

for features, labels in packed_dataset.take(1):
  print(features.numpy())
  print()
  print(labels.numpy())

Jika Anda memiliki data dengan berbagai tipe, Anda mungkin ingin memisahkan data simple-numeric fields. Api tf.feature_column dapat menanganinya, tetapi hal ini menimbulkan beberapa overhead dan harus dihindari kecuali benar-benar diperlukan. Kembali ke kumpulan data campuran:





In [ ]:



    


show_batch(raw_train_data)



    











In [ ]:



    


example_batch, labels_batch = next(iter(temp_dataset))

Jadi tentukan preprosesor yang lebih umum yang memilih daftar fitur numerik dan mengemasnya ke dalam satu kolom:





In [ ]:



    


class PackNumericFeatures(object):
  def __init__(self, names):
    self.names = names

  def __call__(self, features, labels):
    numeric_freatures = [features.pop(name) for name in self.names]
    numeric_features = [tf.cast(feat, tf.float32) for feat in numeric_freatures]
    numeric_features = tf.stack(numeric_features, axis=-1)
    features['numeric'] = numeric_features

    return features, labels



    











In [ ]:



    


NUMERIC_FEATURES = ['age','n_siblings_spouses','parch', 'fare']

packed_train_data = raw_train_data.map(
    PackNumericFeatures(NUMERIC_FEATURES))

packed_test_data = raw_test_data.map(
    PackNumericFeatures(NUMERIC_FEATURES))



    











In [ ]:



    


show_batch(packed_train_data)



    











In [ ]:



    


example_batch, labels_batch = next(iter(packed_train_data))

Normalisasi Data

Data kontinu (continues data) harus selalu dinormalisasi.





In [ ]:



    


import pandas as pd
desc = pd.read_csv(train_file_path)[NUMERIC_FEATURES].describe()
desc



    











In [ ]:



    


MEAN = np.array(desc.T['mean'])
STD = np.array(desc.T['std'])



    











In [ ]:



    


def normalize_numeric_data(data, mean, std):
  # Center the data
  return (data-mean)/std

Sekarang buat kolom angka. API tf.feature_columns.numeric_column menerima argumen normalizer_fn, yang akan dijalankan pada setiap batch.

Bundlekan MEAN dan STD ke normalizer fn menggunakan functools.partial.





In [ ]:



    


# Lihat apa yang baru saja Anda buat.
normalizer = functools.partial(normalize_numeric_data, mean=MEAN, std=STD)

numeric_column = tf.feature_column.numeric_column('numeric', normalizer_fn=normalizer, shape=[len(NUMERIC_FEATURES)])
numeric_columns = [numeric_column]
numeric_column

Saat Anda melatih model, sertakan kolom fitur ini untuk memilih dan memusatkan blok data numerik ini:





In [ ]:



    


example_batch['numeric']



    











In [ ]:



    


numeric_layer = tf.keras.layers.DenseFeatures(numeric_columns)
numeric_layer(example_batch).numpy()

Normalisasi berdasarkan rata-rata yang digunakan di sini mewajibkan kita untuk mengetahui rata-rata setiap kolom sebelumnya.

Kategori data

Beberapa kolom dalam data CSV adalah kolom kategorikal. Artinya, kontennya harus menjadi salah satu dari opsi yang ada.

Gunakan API tf.feature_column untuk membuat koleksi dengan tf.feature_column.indicator_column untuk setiap kolom kategorikal.





In [ ]:



    


CATEGORIES = {
    'sex': ['male', 'female'],
    'class' : ['First', 'Second', 'Third'],
    'deck' : ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
    'embark_town' : ['Cherbourg', 'Southhampton', 'Queenstown'],
    'alone' : ['y', 'n']
}



    











In [ ]:



    


categorical_columns = []
for feature, vocab in CATEGORIES.items():
  cat_col = tf.feature_column.categorical_column_with_vocabulary_list(
        key=feature, vocabulary_list=vocab)
  categorical_columns.append(tf.feature_column.indicator_column(cat_col))



    











In [ ]:



    


# See what you just created.
categorical_columns



    











In [ ]:



    


categorical_layer = tf.keras.layers.DenseFeatures(categorical_columns)
print(categorical_layer(example_batch).numpy()[0])

Ini akan menjadi bagian dari pemrosesan input data ketika Anda membangun model.

Layer preprocessing gabungan

Tambahkan dua koleksi kolom fitur dan teruskan ke tf.keras.layers.DenseFeatures untuk membuat lapisan input yang akan mengekstraksi dan memproses kedua jenis input:





In [ ]:



    


preprocessing_layer = tf.keras.layers.DenseFeatures(categorical_columns+numeric_columns)



    











In [ ]:



    


print(preprocessing_layer(example_batch).numpy()[0])

Membangun Model

Jalankan tf.keras.Sequential, mulai dari preprocessing_layer.





In [ ]:



    


model = tf.keras.Sequential([
  preprocessing_layer,
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dense(1, activation='sigmoid'),
])

model.compile(
    loss='binary_crossentropy',
    optimizer='adam',
    metrics=['accuracy'])

Latih, evaluasi, dan prediksi

Sekarang model dapat dipakai dan dilatih.





In [ ]:



    


train_data = packed_train_data.shuffle(500)
test_data = packed_test_data



    











In [ ]:



    


model.fit(train_data, epochs=20)

Setelah model dilatih, Anda dapat memeriksa akurasinya pada set test_data.





In [ ]:



    


test_loss, test_accuracy = model.evaluate(test_data)

print('\n\nTest Loss {}, Test Accuracy {}'.format(test_loss, test_accuracy))

Gunakan tf.keras.Model.predict untuk menyimpulkan pada label batch atau dataset batch.





In [ ]:



    


predictions = model.predict(test_data)

# Tampilkan beberapa hasil
for prediction, survived in zip(predictions[:10], list(test_data)[0][1][:10]):
  print("Predicted survival: {:.2%}".format(prediction[0]),
        " | Actual outcome: ",
        ("SURVIVED" if bool(survived) else "DIED"))

Content source: tensorflow/docs-l10n

Similar notebooks:

notebook.community | gallery | about