আপনার স্থানীয় টেনসরফ্লো সর্বত্র সর্বত্র ইভেন্টের জন্য আরএসভিপি!
This page was translated by the Cloud Translation API.
Switch to English

টিএফ ল্যাটিক্স কাস্টম অনুমানকারী

টেনসরফ্লো.অর্গ.এ দেখুন গুগল কোলাবে চালান গিটহাবের উত্স দেখুন নোটবুক ডাউনলোড করুন

ওভারভিউ

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

সেটআপ

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

pip install -q 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

বৈশিষ্ট্য কলাম

অন্য কোনও টিএফ অনুমানকারী হিসাবে, ডেটাটি অনুমানকারীকে প্রেরণ করা প্রয়োজন যা সাধারণত ইনপুট_ফএন এর মাধ্যমে হয় এবং ফিচার কলামগুলি ব্যবহার করে পার্স করা হয়

0 বি 9ced9320

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

ইনপুট_ফএন তৈরি করা হচ্ছে

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

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 নির্মাণ করব যা পার্সড ইনপুট model_fn কেরাস মডেলকে কল করে। ইনপুট বৈশিষ্ট্যগুলি বিশ্লেষণ করতে, আপনি tf.feature_column.input_layer , tf.keras.layers.DenseFeatures , বা tfl.estimators.transform_features ব্যবহার করতে পারেন। আপনি যদি দ্বিতীয়টি ব্যবহার করেন তবে আপনাকে ঘন বৈশিষ্ট্য কলামগুলি সহ শ্রেণীবদ্ধ বৈশিষ্ট্যগুলি মোড়ানো প্রয়োজন হবে না, এবং ফলস্বরূপ টেনারগুলি সংযুক্ত করা হবে না, যা ক্রমাঙ্কন স্তরগুলির বৈশিষ্ট্যগুলি ব্যবহার করা সহজ করে।

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

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']))
AUC: 0.6416040062904358