সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

টিএফ জাল কাস্টম এস্টিমেটর

TensorFlow.org এ দেখুন Google Colab-এ চালান GitHub-এ উৎস দেখুন নোটবুক ডাউনলোড করুন

ওভারভিউ

আপনি TFL স্তরগুলি ব্যবহার করে নির্বিচারে একঘেয়ে মডেল তৈরি করতে কাস্টম অনুমানকারী ব্যবহার করতে পারেন। এই নির্দেশিকা এই ধরনের অনুমানকারী তৈরি করার জন্য প্রয়োজনীয় পদক্ষেপগুলির রূপরেখা দেয়৷

সেটআপ

টিএফ ল্যাটিস প্যাকেজ ইনস্টল করা হচ্ছে:

pip install tensorflow-lattice

প্রয়োজনীয় প্যাকেজ আমদানি করা হচ্ছে:

import tensorflow as tf

import logging
import numpy as np
import pandas as pd
import sys
import tensorflow_lattice as tfl
from tensorflow import feature_column as fc

from tensorflow_estimator.python.estimator.canned import optimizers
from tensorflow_estimator.python.estimator.head import binary_class_head
logging.disable(sys.maxsize)

ইউসিআই স্ট্যাটলগ (হার্ট) ডেটাসেট ডাউনলোড করা হচ্ছে:

csv_file = tf.keras.utils.get_file(
    'heart.csv', 'http://storage.googleapis.com/download.tensorflow.org/data/heart.csv')
df = pd.read_csv(csv_file)
target = df.pop('target')
train_size = int(len(df) * 0.8)
train_x = df[:train_size]
train_y = target[:train_size]
test_x = df[train_size:]
test_y = target[train_size:]
df.head()

এই নির্দেশিকায় প্রশিক্ষণের জন্য ব্যবহৃত ডিফল্ট মান সেট করা:

LEARNING_RATE = 0.1
BATCH_SIZE = 128
NUM_EPOCHS = 1000

ফিচার কলাম

অন্য কোন মেমরি মূল্নির্ধারক হিসাবে, তথ্য চাহিদা মূল্নির্ধারক, যা একটি input_fn মাধ্যমে সাধারণত হয় উত্তীর্ণ হন এবং ব্যবহার বিশ্লেষণ হতে FeatureColumns

# Feature columns.
# - age
# - sex
# - ca        number of major vessels (0-3) colored by flourosopy
# - thal      3 = normal; 6 = fixed defect; 7 = reversable defect
feature_columns = [
    fc.numeric_column('age', default_value=-1),
    fc.categorical_column_with_vocabulary_list('sex', [0, 1]),
    fc.numeric_column('ca'),
    fc.categorical_column_with_vocabulary_list(
        'thal', ['normal', 'fixed', 'reversible']),
]

লক্ষ্য করুন শ্রেণীগত বৈশিষ্ট্য, সাল থেকে ঘন বৈশিষ্ট্য কলাম দ্বারা আবৃত করা প্রয়োজন হবে না tfl.laysers.CategoricalCalibration স্তর সরাসরি গ্রাস করতে পারেন বিভাগ সূচকের।

input_fn তৈরি করা হচ্ছে

অন্য কোনো অনুমানকারী হিসাবে, আপনি প্রশিক্ষণ এবং মূল্যায়নের জন্য মডেলে ডেটা ফিড করতে input_fn ব্যবহার করতে পারেন।

train_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(
    x=train_x,
    y=train_y,
    shuffle=True,
    batch_size=BATCH_SIZE,
    num_epochs=NUM_EPOCHS,
    num_threads=1)

test_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(
    x=test_x,
    y=test_y,
    shuffle=False,
    batch_size=BATCH_SIZE,
    num_epochs=1,
    num_threads=1)

মডেল_এফএন তৈরি করা হচ্ছে

একটি কাস্টম অনুমানক তৈরি করার বিভিন্ন উপায় আছে। এখানে আমরা একটি গঠন করা হবে model_fn যা পার্স ইনপুট tensors একটি Keras মডেল কল। ইনপুট বৈশিষ্ট্য বিশ্লেষণ করতে, আপনি ব্যবহার করতে পারেন tf.feature_column.input_layer , tf.keras.layers.DenseFeatures , অথবা tfl.estimators.transform_features । আপনি যদি পরবর্তীটি ব্যবহার করেন, তবে আপনাকে ঘন বৈশিষ্ট্যযুক্ত কলামগুলির সাথে শ্রেণীবদ্ধ বৈশিষ্ট্যগুলি মোড়ানোর প্রয়োজন হবে না এবং ফলে টেনসরগুলি সংযুক্ত হবে না, যা ক্রমাঙ্কন স্তরগুলিতে বৈশিষ্ট্যগুলি ব্যবহার করা সহজ করে তোলে।

একটি মডেল তৈরি করতে, আপনি টিএফএল স্তর বা অন্য কোন কেরাস স্তরগুলিকে মিশ্রিত করতে এবং মেলাতে পারেন। এখানে আমরা টিএফএল স্তরগুলির মধ্যে একটি ক্যালিব্রেটেড জালি কেরাস মডেল তৈরি করি এবং বেশ কয়েকটি একঘেয়েতার সীমাবদ্ধতা আরোপ করি। আমরা তারপর কাস্টম অনুমানক তৈরি করতে Keras মডেল ব্যবহার করি।

def model_fn(features, labels, mode, config):
  """model_fn for the custom estimator."""
  del config
  input_tensors = tfl.estimators.transform_features(features, feature_columns)
  inputs = {
      key: tf.keras.layers.Input(shape=(1,), name=key) for key in input_tensors
  }

  lattice_sizes = [3, 2, 2, 2]
  lattice_monotonicities = ['increasing', 'none', 'increasing', 'increasing']
  lattice_input = tf.keras.layers.Concatenate(axis=1)([
      tfl.layers.PWLCalibration(
          input_keypoints=np.linspace(10, 100, num=8, dtype=np.float32),
          # The output range of the calibrator should be the input range of
          # the following lattice dimension.
          output_min=0.0,
          output_max=lattice_sizes[0] - 1.0,
          monotonicity='increasing',
      )(inputs['age']),
      tfl.layers.CategoricalCalibration(
          # Number of categories including any missing/default category.
          num_buckets=2,
          output_min=0.0,
          output_max=lattice_sizes[1] - 1.0,
      )(inputs['sex']),
      tfl.layers.PWLCalibration(
          input_keypoints=[0.0, 1.0, 2.0, 3.0],
          output_min=0.0,
          output_max=lattice_sizes[0] - 1.0,
          # You can specify TFL regularizers as tuple
          # ('regularizer name', l1, l2).
          kernel_regularizer=('hessian', 0.0, 1e-4),
          monotonicity='increasing',
      )(inputs['ca']),
      tfl.layers.CategoricalCalibration(
          num_buckets=3,
          output_min=0.0,
          output_max=lattice_sizes[1] - 1.0,
          # Categorical monotonicity can be partial order.
          # (i, j) indicates that we must have output(i) <= output(j).
          # Make sure to set the lattice monotonicity to 'increasing' for this
          # dimension.
          monotonicities=[(0, 1), (0, 2)],
      )(inputs['thal']),
  ])
  output = tfl.layers.Lattice(
      lattice_sizes=lattice_sizes, monotonicities=lattice_monotonicities)(
          lattice_input)

  training = (mode == tf.estimator.ModeKeys.TRAIN)
  model = tf.keras.Model(inputs=inputs, outputs=output)
  logits = model(input_tensors, training=training)

  if training:
    optimizer = optimizers.get_optimizer_instance_v2('Adagrad', LEARNING_RATE)
  else:
    optimizer = None

  head = binary_class_head.BinaryClassHead()
  return head.create_estimator_spec(
      features=features,
      mode=mode,
      labels=labels,
      optimizer=optimizer,
      logits=logits,
      trainable_variables=model.trainable_variables,
      update_ops=model.updates)

প্রশিক্ষণ এবং অনুমানকারী

ব্যবহার model_fn আমরা তৈরি এবং মূল্নির্ধারক প্রশিক্ষণ পারবেন না।

estimator = tf.estimator.Estimator(model_fn=model_fn)
estimator.train(input_fn=train_input_fn)
results = estimator.evaluate(input_fn=test_input_fn)
print('AUC: {}'.format(results['auc']))
2021-09-30 20:51:11.094402: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
AUC: 0.5946115255355835