This page was translated by the Cloud Translation API.
Switch to English

টিএফ ল্যাটিস ক্যানড প্রাক্কলনকারী

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

ওভারভিউ

সাধারণ ব্যবহারের ক্ষেত্রে টিএফএল মডেলগুলিকে প্রশিক্ষণের দ্রুত এবং সহজ উপায় হ'ল টিনজাত অনুমানকারী। এই গাইডে টিএফএল ক্যানড অনুমানকারী তৈরি করার জন্য প্রয়োজনীয় পদক্ষেপগুলির রূপরেখা দেওয়া হয়েছে।

সেটআপ

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


!pip install -q tensorflow-lattice

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

import tensorflow as tf

import copy
import logging
import numpy as np
import pandas as pd
import sys
import tensorflow_lattice as tfl
from tensorflow import feature_column as fc
logging.disable(sys.maxsize)

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

csv_file = tf.keras.utils.get_file(
    'heart.csv', 'http://storage.googleapis.com/applied-dl/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.01
BATCH_SIZE = 128
NUM_EPOCHS = 500
PREFITTING_NUM_EPOCHS = 10

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

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

# Feature columns.
# - age
# - sex
# - cp        chest pain type (4 values)
# - trestbps  resting blood pressure
# - chol      serum cholestoral in mg/dl
# - fbs       fasting blood sugar > 120 mg/dl
# - restecg   resting electrocardiographic results (values 0,1,2)
# - thalach   maximum heart rate achieved
# - exang     exercise induced angina
# - oldpeak   ST depression induced by exercise relative to rest
# - slope     the slope of the peak exercise ST segment
# - 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('cp'),
    fc.numeric_column('trestbps', default_value=-1),
    fc.numeric_column('chol'),
    fc.categorical_column_with_vocabulary_list('fbs', [0, 1]),
    fc.categorical_column_with_vocabulary_list('restecg', [0, 1, 2]),
    fc.numeric_column('thalach'),
    fc.categorical_column_with_vocabulary_list('exang', [0, 1]),
    fc.numeric_column('oldpeak'),
    fc.categorical_column_with_vocabulary_list('slope', [0, 1, 2]),
    fc.numeric_column('ca'),
    fc.categorical_column_with_vocabulary_list(
        'thal', ['normal', 'fixed', 'reversible']),
]

টিএফএল ডাবিত অনুমানকারীরা কী ধরনের ক্যালিগ্রেশন স্তর ব্যবহার করবেন তা সিদ্ধান্ত নিতে বৈশিষ্ট্য কলামের ধরণটি ব্যবহার করে। আমরা একটি ব্যবহার tfl.layers.PWLCalibration সাংখ্যিক বৈশিষ্ট্য কলামের জন্য স্তর এবং একটি tfl.layers.CategoricalCalibration শ্রেণীগত বৈশিষ্ট্য কলামের জন্য স্তর।

নোট করুন যে শ্রেণীবদ্ধ বৈশিষ্ট্য কলামগুলি এমবেডিং বৈশিষ্ট্য কলাম দ্বারা মোড়ানো নয়। তারা সরাসরি অনুমানকারী খাওয়ানো হয়।

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

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

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

# feature_analysis_input_fn is used to collect statistics about the input.
feature_analysis_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(
    x=train_x,
    y=train_y,
    shuffle=False,
    batch_size=BATCH_SIZE,
    # Note that we only need one pass over the data.
    num_epochs=1,
    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)

# Serving input fn is used to create saved models.
serving_input_fn = (
    tf.estimator.export.build_parsing_serving_input_receiver_fn(
        feature_spec=fc.make_parse_example_spec(feature_columns)))

বৈশিষ্ট্য কনফিজ

tfl.configs.FeatureConfig ব্যবহার করে বৈশিষ্ট্য ক্রমাঙ্কন এবং প্রতি বৈশিষ্ট্য কনফিগারেশন সেট করা tfl.configs.FeatureConfig । বৈশিষ্ট্য কনফিগারেশনে একঘেয়েমি বাধা, প্রতি-বৈশিষ্ট্য নিয়মিতকরণ ( tfl.configs.RegularizerConfig ), এবং জাল মডেলগুলির জন্য জাল আকার রয়েছে।

যদি কোনও ইনপুট বৈশিষ্ট্যের জন্য কোনও কনফিগারেশন সংজ্ঞায়িত না করা হয় তবে tfl.config.FeatureConfig এ ডিফল্ট কনফিগারেশন ব্যবহৃত হয় tfl.config.FeatureConfig

# Feature configs are used to specify how each feature is calibrated and used.
feature_configs = [
    tfl.configs.FeatureConfig(
        name='age',
        lattice_size=3,
        # By default, input keypoints of pwl are quantiles of the feature.
        pwl_calibration_num_keypoints=5,
        monotonicity='increasing',
        pwl_calibration_clip_max=100,
        # Per feature regularization.
        regularizer_configs=[
            tfl.configs.RegularizerConfig(name='calib_wrinkle', l2=0.1),
        ],
    ),
    tfl.configs.FeatureConfig(
        name='cp',
        pwl_calibration_num_keypoints=4,
        # Keypoints can be uniformly spaced.
        pwl_calibration_input_keypoints='uniform',
        monotonicity='increasing',
    ),
    tfl.configs.FeatureConfig(
        name='chol',
        # Explicit input keypoint initialization.
        pwl_calibration_input_keypoints=[126.0, 210.0, 247.0, 286.0, 564.0],
        monotonicity='increasing',
        # Calibration can be forced to span the full output range by clamping.
        pwl_calibration_clamp_min=True,
        pwl_calibration_clamp_max=True,
        # Per feature regularization.
        regularizer_configs=[
            tfl.configs.RegularizerConfig(name='calib_hessian', l2=1e-4),
        ],
    ),
    tfl.configs.FeatureConfig(
        name='fbs',
        # Partial monotonicity: output(0) <= output(1)
        monotonicity=[(0, 1)],
    ),
    tfl.configs.FeatureConfig(
        name='trestbps',
        pwl_calibration_num_keypoints=5,
        monotonicity='decreasing',
    ),
    tfl.configs.FeatureConfig(
        name='thalach',
        pwl_calibration_num_keypoints=5,
        monotonicity='decreasing',
    ),
    tfl.configs.FeatureConfig(
        name='restecg',
        # Partial monotonicity: output(0) <= output(1), output(0) <= output(2)
        monotonicity=[(0, 1), (0, 2)],
    ),
    tfl.configs.FeatureConfig(
        name='exang',
        # Partial monotonicity: output(0) <= output(1)
        monotonicity=[(0, 1)],
    ),
    tfl.configs.FeatureConfig(
        name='oldpeak',
        pwl_calibration_num_keypoints=5,
        monotonicity='increasing',
    ),
    tfl.configs.FeatureConfig(
        name='slope',
        # Partial monotonicity: output(0) <= output(1), output(1) <= output(2)
        monotonicity=[(0, 1), (1, 2)],
    ),
    tfl.configs.FeatureConfig(
        name='ca',
        pwl_calibration_num_keypoints=4,
        monotonicity='increasing',
    ),
    tfl.configs.FeatureConfig(
        name='thal',
        # Partial monotonicity:
        # output(normal) <= output(fixed)
        # output(normal) <= output(reversible)        
        monotonicity=[('normal', 'fixed'), ('normal', 'reversible')],
    ),
]

ক্যালিব্রেটেড লিনিয়ার মডেল

একটি টিএফএল টিনজাত tfl.configs থেকে একটি মডেল কনফিগারেশন tfl.configs । একটি ক্যালিব্রেটেড রৈখিক মডেল tfl.configs.CalibratedLinearConfig ব্যবহার করে tfl.configs.CalibratedLinearConfig । এটি ইনপুট বৈশিষ্ট্যগুলিতে অংশবিশেষ-লিনিয়ার এবং শ্রেণিবদ্ধ ক্যালিব্রেশন প্রয়োগ করে, এর পরে একটি রৈখিক সংমিশ্রণ এবং একটি alচ্ছিক আউটপুট টুকরোজ-লিনিয়ার ক্যালিগ্রেশন থাকে। আউটপুট ক্যালিব্রেশন ব্যবহার করার সময় বা আউটপুট সীমানা নির্দিষ্ট করা হলে, লিনিয়ার স্তরটি ক্যালিব্রেটেড ইনপুটগুলিতে গড় ওজনের গড় প্রয়োগ করে।

এই উদাহরণটি প্রথম 5 টি বৈশিষ্ট্যে একটি ক্রমাঙ্কিত রৈখিক মডেল তৈরি করে। ক্যালিব্রেটার প্লটের সাথে মডেল গ্রাফ প্লট করতে আমরা tfl.visualization ব্যবহার tfl.visualization

# Model config defines the model structure for the estimator.
model_config = tfl.configs.CalibratedLinearConfig(
    feature_configs=feature_configs,
    use_bias=True,
    output_calibration=True,
    regularizer_configs=[
        # Regularizer for the output calibrator.
        tfl.configs.RegularizerConfig(name='output_calib_hessian', l2=1e-4),
    ])
# A CannedClassifier is constructed from the given model config.
estimator = tfl.estimators.CannedClassifier(
    feature_columns=feature_columns[:5],
    model_config=model_config,
    feature_analysis_input_fn=feature_analysis_input_fn,
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42))
estimator.train(input_fn=train_input_fn)
results = estimator.evaluate(input_fn=test_input_fn)
print('Calibrated linear test AUC: {}'.format(results['auc']))
saved_model_path = estimator.export_saved_model(estimator.model_dir,
                                                serving_input_fn)
model_graph = tfl.estimators.get_model_graph(saved_model_path)
tfl.visualization.draw_model_graph(model_graph)
Calibrated linear test AUC: 0.834586501121521

পিএনজি

ক্যালিব্রেটেড ল্যাটিস মডেল

ক্যালিব্রেটেড ল্যাটিস মডেলটি tfl.configs.CalibratedLatticeConfig ব্যবহার করে tfl.configs.CalibratedLatticeConfig । একটি ক্যালিব্রেটেড ল্যাটিস মডেলটি ইনপুট বৈশিষ্ট্যগুলিতে টুকরোজ-লিনিয়ার এবং শ্রেণিবদ্ধ ক্যালিগ্রেশন প্রয়োগ করে, তার পরে একটি জাল মডেল এবং একটি alচ্ছিক আউটপুট টুকরোজ-লিনিয়ার ক্যালিগ্রেশন থাকে।

এই উদাহরণটি প্রথম 5 টি বৈশিষ্ট্যে ক্যালিব্রেটেড ল্যাটিস মডেল তৈরি করে।

# This is calibrated lattice model: Inputs are calibrated, then combined
# non-linearly using a lattice layer.
model_config = tfl.configs.CalibratedLatticeConfig(
    feature_configs=feature_configs,
    regularizer_configs=[
        # Torsion regularizer applied to the lattice to make it more linear.
        tfl.configs.RegularizerConfig(name='torsion', l2=1e-4),
        # Globally defined calibration regularizer is applied to all features.
        tfl.configs.RegularizerConfig(name='calib_hessian', l2=1e-4),
    ])
# A CannedClassifier is constructed from the given model config.
estimator = tfl.estimators.CannedClassifier(
    feature_columns=feature_columns[:5],
    model_config=model_config,
    feature_analysis_input_fn=feature_analysis_input_fn,
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42))
estimator.train(input_fn=train_input_fn)
results = estimator.evaluate(input_fn=test_input_fn)
print('Calibrated lattice test AUC: {}'.format(results['auc']))
saved_model_path = estimator.export_saved_model(estimator.model_dir,
                                                serving_input_fn)
model_graph = tfl.estimators.get_model_graph(saved_model_path)
tfl.visualization.draw_model_graph(model_graph)
Calibrated lattice test AUC: 0.8433583974838257

পিএনজি

ক্যালিব্রেটেড ল্যাটিস এনসেম্বল

যখন বৈশিষ্ট্যের সংখ্যাটি বড় হয়, আপনি একটি নকশাকৃত মডেল ব্যবহার করতে পারেন, যা বৈশিষ্ট্যগুলির সাবটেটগুলির জন্য একাধিক ছোট ল্যাটিস তৈরি করে এবং কেবলমাত্র একটি বিশাল বিশাল জাল তৈরির পরিবর্তে তাদের আউটপুট গড় দেয়। এনসেমবল tfl.configs.CalibratedLatticeEnsembleConfig মডেলগুলি tfl.configs.CalibratedLatticeEnsembleConfig ব্যবহার করে tfl.configs.CalibratedLatticeEnsembleConfig । একটি ক্যালিব্রেটেড ল্যাটিস এনসেম্বল মডেলটি ইনপুট বৈশিষ্ট্যে টুকরোচক-লিনিয়ার এবং শ্রেণিবদ্ধ ক্যালিব্রেশন প্রয়োগ করে, তার পরে জালির মডেলগুলির একটি সংকলন এবং একটি optionচ্ছিক আউটপুট টুকরোজ-লিনিয়ার ক্যালিগ্রেশন।

র‌্যান্ডম ল্যাটিস এনসেম্বল

নিম্নলিখিত মডেল কনফিগারেশন প্রতিটি জালির জন্য বৈশিষ্ট্যগুলির এলোমেলো উপসেট ব্যবহার করে।

# This is random lattice ensemble model with separate calibration:
# model output is the average output of separately calibrated lattices.
model_config = tfl.configs.CalibratedLatticeEnsembleConfig(
    feature_configs=feature_configs,
    num_lattices=5,
    lattice_rank=3)
# A CannedClassifier is constructed from the given model config.
estimator = tfl.estimators.CannedClassifier(
    feature_columns=feature_columns,
    model_config=model_config,
    feature_analysis_input_fn=feature_analysis_input_fn,
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42))
estimator.train(input_fn=train_input_fn)
results = estimator.evaluate(input_fn=test_input_fn)
print('Random ensemble test AUC: {}'.format(results['auc']))
saved_model_path = estimator.export_saved_model(estimator.model_dir,
                                                serving_input_fn)
model_graph = tfl.estimators.get_model_graph(saved_model_path)
tfl.visualization.draw_model_graph(model_graph, calibrator_dpi=15)
Random ensemble test AUC: 0.8991228342056274

পিএনজি

আরটিএল লেয়ার র‌্যান্ডম ল্যাটিস এনসেম্বল

নিম্নলিখিত মডেল কনফিগারেশনে একটি tfl.layers.RTL স্তর ব্যবহার করা হয় যা প্রতিটি tfl.layers.RTL জন্য বৈশিষ্ট্যগুলির এলোমেলো উপসেট ব্যবহার করে। আমরা নোট করি যে tfl.layers.RTL কেবল একঘেয়েমি tfl.layers.RTL সমর্থন করে এবং সমস্ত বৈশিষ্ট্যের জন্য একই জাল আকার থাকতে হবে এবং প্রতি-বৈশিষ্ট্য নিয়মিতকরণের কোনও প্রয়োজন নেই। নোট করুন যে একটি tfl.layers.RTL স্তর ব্যবহার করে আপনাকে পৃথক tfl.layers.Lattice দৃষ্টান্ত ব্যবহারের চেয়ে অনেক বড় ensemble স্কেল করতে দেয়।

# Make sure our feature configs have the same lattice size, no per-feature
# regularization, and only monotonicity constraints.
rtl_layer_feature_configs = copy.deepcopy(feature_configs)
for feature_config in rtl_layer_feature_configs:
  feature_config.lattice_size = 2
  feature_config.unimodality = 'none'
  feature_config.reflects_trust_in = None
  feature_config.dominates = None
  feature_config.regularizer_configs = None
# This is RTL layer ensemble model with separate calibration:
# model output is the average output of separately calibrated lattices.
model_config = tfl.configs.CalibratedLatticeEnsembleConfig(
    lattices='rtl_layer',
    feature_configs=rtl_layer_feature_configs,
    num_lattices=5,
    lattice_rank=3)
# A CannedClassifier is constructed from the given model config.
estimator = tfl.estimators.CannedClassifier(
    feature_columns=feature_columns,
    model_config=model_config,
    feature_analysis_input_fn=feature_analysis_input_fn,
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42))
estimator.train(input_fn=train_input_fn)
results = estimator.evaluate(input_fn=test_input_fn)
print('Random ensemble test AUC: {}'.format(results['auc']))
saved_model_path = estimator.export_saved_model(estimator.model_dir,
                                                serving_input_fn)
model_graph = tfl.estimators.get_model_graph(saved_model_path)
tfl.visualization.draw_model_graph(model_graph, calibrator_dpi=15)
Random ensemble test AUC: 0.9241854548454285

পিএনজি

স্ফটিক জালিয়াতি ensemble

টিএফএল একটি হিউরিস্টিক বৈশিষ্ট্য বিন্যাস অ্যালগরিদমও সরবরাহ করে যার নাম স্ফটিক । স্ফটিকগুলি অ্যালগোরিদম প্রথমে একটি পছন্দসই মডেল প্রশিক্ষণ দেয় যা জুটিওয়ালা বৈশিষ্ট্যযুক্ত মিথস্ক্রিয়াটিকে অনুমান করে। এরপরে এটি চূড়ান্ত নকশাগুলির ব্যবস্থা করে যাতে আরও অ-রৈখিক ইন্টারঅ্যাকশন সহ বৈশিষ্ট্যগুলি একই জালিতে থাকে।

স্ফটিকের মডেলগুলির জন্য, আপনাকে পূর্বনির্ধারিত মডেলটি প্রশিক্ষণের জন্য ব্যবহৃত একটি prefitting_input_fn করতে হবে যা উপরে বর্ণিত আছে। পছন্দসই মডেলটিকে পুরোপুরি প্রশিক্ষণ দেওয়ার দরকার নেই, তাই কয়েকটি যুগের যথেষ্ট হওয়া উচিত।

prefitting_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(
    x=train_x,
    y=train_y,
    shuffle=False,
    batch_size=BATCH_SIZE,
    num_epochs=PREFITTING_NUM_EPOCHS,
    num_threads=1)

তারপরে আপনি মডেল কনফিগারেশনে lattice='crystals' সেট করে একটি স্ফটিক মডেল তৈরি করতে পারেন।

# This is Crystals ensemble model with separate calibration: model output is
# the average output of separately calibrated lattices.
model_config = tfl.configs.CalibratedLatticeEnsembleConfig(
    feature_configs=feature_configs,
    lattices='crystals',
    num_lattices=5,
    lattice_rank=3)
# A CannedClassifier is constructed from the given model config.
estimator = tfl.estimators.CannedClassifier(
    feature_columns=feature_columns,
    model_config=model_config,
    feature_analysis_input_fn=feature_analysis_input_fn,
    # prefitting_input_fn is required to train the prefitting model.
    prefitting_input_fn=prefitting_input_fn,
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),
    prefitting_optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42))
estimator.train(input_fn=train_input_fn)
results = estimator.evaluate(input_fn=test_input_fn)
print('Crystals ensemble test AUC: {}'.format(results['auc']))
saved_model_path = estimator.export_saved_model(estimator.model_dir,
                                                serving_input_fn)
model_graph = tfl.estimators.get_model_graph(saved_model_path)
tfl.visualization.draw_model_graph(model_graph, calibrator_dpi=15)
Crystals ensemble test AUC: 0.8853383660316467

পিএনজি

আপনি tfl.visualization মডিউলটি ব্যবহার করে আরও বিশদ সহ বৈশিষ্ট্য ক্যালিব্রেটার প্লট করতে পারেন।

_ = tfl.visualization.plot_feature_calibrator(model_graph, "age")
_ = tfl.visualization.plot_feature_calibrator(model_graph, "restecg")

পিএনজি

পিএনজি