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

টিএফ ল্যাটিক্স প্রিমেড মডেল

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

ওভারভিউ

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

সেটআপ

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


!pip install -q tensorflow-lattice pydot

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

import tensorflow as tf

import copy
import logging
import numpy as np
import pandas as pd
import sys
import tensorflow_lattice as tfl
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)
train_size = int(len(df) * 0.8)
train_dataframe = df[:train_size]
test_dataframe = df[train_size:]
df.head()

বৈশিষ্ট্য এবং লেবেলগুলি টেনসরগুলিতে সরান এবং রূপান্তর করুন:

# Features:
# - 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
#
# This ordering of feature names will be the exact same order that we construct
# our model to expect.
feature_names = [
    'age', 'sex', 'cp', 'chol', 'fbs', 'trestbps', 'thalach', 'restecg',
    'exang', 'oldpeak', 'slope', 'ca', 'thal'
]
feature_name_indices = {name: index for index, name in enumerate(feature_names)}
# This is the vocab list and mapping we will use for the 'thal' categorical
# feature.
thal_vocab_list = ['normal', 'fixed', 'reversible']
thal_map = {category: i for i, category in enumerate(thal_vocab_list)}
# Custom function for converting thal categories to buckets
def convert_thal_features(thal_features):
  # Note that two examples in the test set are already converted.
  return np.array([
      thal_map[feature] if feature in thal_vocab_list else feature
      for feature in thal_features
  ])


# Custom function for extracting each feature.
def extract_features(dataframe,
                     label_name='target',
                     feature_names=feature_names):
  features = []
  for feature_name in feature_names:
    if feature_name == 'thal':
      features.append(
          convert_thal_features(dataframe[feature_name].values).astype(float))
    else:
      features.append(dataframe[feature_name].values.astype(float))
  labels = dataframe[label_name].values.astype(float)
  return features, labels
train_xs, train_ys = extract_features(train_dataframe)
test_xs, test_ys = extract_features(test_dataframe)
# Let's define our label minimum and maximum.
min_label, max_label = float(np.min(train_ys)), float(np.max(train_ys))
# Our lattice models may have predictions above 1.0 due to numerical errors.
# We can subtract this small epsilon value from our output_max to make sure we
# do not predict values outside of our label bound.
numerical_error_epsilon = 1e-5

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

LEARNING_RATE = 0.01
BATCH_SIZE = 128
NUM_EPOCHS = 500
PREFITTING_NUM_EPOCHS = 10

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

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

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

গণনা কোয়ান্টাইলস

যদিও pwl_calibration_input_keypointstfl.configs.FeatureConfig জন্য ডিফল্ট সেটিংটি রয়েছে tfl.configs.FeatureConfig এটি করতে, আমরা প্রথমে কোয়ান্টাইলগুলি গণনা করার জন্য আমাদের নিজস্ব সহায়ক ফাংশনটি সংজ্ঞায়িত করি।

def compute_quantiles(features,
                      num_keypoints=10,
                      clip_min=None,
                      clip_max=None,
                      missing_value=None):
  # Clip min and max if desired.
  if clip_min is not None:
    features = np.maximum(features, clip_min)
    features = np.append(features, clip_min)
  if clip_max is not None:
    features = np.minimum(features, clip_max)
    features = np.append(features, clip_max)
  # Make features unique.
  unique_features = np.unique(features)
  # Remove missing values if specified.
  if missing_value is not None:
    unique_features = np.delete(unique_features,
                                np.where(unique_features == missing_value))
  # Compute and return quantiles over unique non-missing feature values.
  return np.quantile(
      unique_features,
      np.linspace(0., 1., num=num_keypoints),
      interpolation='nearest').astype(float)

আমাদের ফিচার কনফিগগুলি সংজ্ঞায়িত করা হচ্ছে

এখন যেহেতু আমরা আমাদের কোয়ান্টাইলগুলি গণনা করতে পারি, আমরা প্রতিটি বৈশিষ্ট্যের জন্য একটি বৈশিষ্ট্য কনফিগারকে সংজ্ঞায়িত করি যা আমরা আমাদের মডেলটিকে ইনপুট হিসাবে নিতে চাই।

# Feature configs are used to specify how each feature is calibrated and used.
feature_configs = [
    tfl.configs.FeatureConfig(
        name='age',
        lattice_size=3,
        monotonicity='increasing',
        # We must set the keypoints manually.
        pwl_calibration_num_keypoints=5,
        pwl_calibration_input_keypoints=compute_quantiles(
            train_xs[feature_name_indices['age']],
            num_keypoints=5,
            clip_max=100),
        # Per feature regularization.
        regularizer_configs=[
            tfl.configs.RegularizerConfig(name='calib_wrinkle', l2=0.1),
        ],
    ),
    tfl.configs.FeatureConfig(
        name='sex',
        num_buckets=2,
    ),
    tfl.configs.FeatureConfig(
        name='cp',
        monotonicity='increasing',
        # Keypoints that are uniformly spaced.
        pwl_calibration_num_keypoints=4,
        pwl_calibration_input_keypoints=np.linspace(
            np.min(train_xs[feature_name_indices['cp']]),
            np.max(train_xs[feature_name_indices['cp']]),
            num=4),
    ),
    tfl.configs.FeatureConfig(
        name='chol',
        monotonicity='increasing',
        # Explicit input keypoints initialization.
        pwl_calibration_input_keypoints=[126.0, 210.0, 247.0, 286.0, 564.0],
        # 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)],
        num_buckets=2,
    ),
    tfl.configs.FeatureConfig(
        name='trestbps',
        monotonicity='decreasing',
        pwl_calibration_num_keypoints=5,
        pwl_calibration_input_keypoints=compute_quantiles(
            train_xs[feature_name_indices['trestbps']], num_keypoints=5),
    ),
    tfl.configs.FeatureConfig(
        name='thalach',
        monotonicity='decreasing',
        pwl_calibration_num_keypoints=5,
        pwl_calibration_input_keypoints=compute_quantiles(
            train_xs[feature_name_indices['thalach']], num_keypoints=5),
    ),
    tfl.configs.FeatureConfig(
        name='restecg',
        # Partial monotonicity: output(0) <= output(1), output(0) <= output(2)
        monotonicity=[(0, 1), (0, 2)],
        num_buckets=3,
    ),
    tfl.configs.FeatureConfig(
        name='exang',
        # Partial monotonicity: output(0) <= output(1)
        monotonicity=[(0, 1)],
        num_buckets=2,
    ),
    tfl.configs.FeatureConfig(
        name='oldpeak',
        monotonicity='increasing',
        pwl_calibration_num_keypoints=5,
        pwl_calibration_input_keypoints=compute_quantiles(
            train_xs[feature_name_indices['oldpeak']], num_keypoints=5),
    ),
    tfl.configs.FeatureConfig(
        name='slope',
        # Partial monotonicity: output(0) <= output(1), output(1) <= output(2)
        monotonicity=[(0, 1), (1, 2)],
        num_buckets=3,
    ),
    tfl.configs.FeatureConfig(
        name='ca',
        monotonicity='increasing',
        pwl_calibration_num_keypoints=4,
        pwl_calibration_input_keypoints=compute_quantiles(
            train_xs[feature_name_indices['ca']], num_keypoints=4),
    ),
    tfl.configs.FeatureConfig(
        name='thal',
        # Partial monotonicity:
        # output(normal) <= output(fixed)
        # output(normal) <= output(reversible)
        monotonicity=[('normal', 'fixed'), ('normal', 'reversible')],
        num_buckets=3,
        # We must specify the vocabulary list in order to later set the
        # monotonicities since we used names and not indices.
        vocabulary_list=thal_vocab_list,
    ),
]

এরপরে আমাদের এমন বৈশিষ্ট্যগুলির জন্য একঘেয়েমি সঠিকভাবে সেট করা দরকার যেখানে আমরা একটি কাস্টম ভোকাবুলারি (যেমন উপরে 'থাল') ব্যবহার করেছি।

tfl.premade_lib.set_categorical_monotonicities(feature_configs)

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

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

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

# Model config defines the model structure for the premade model.
linear_model_config = tfl.configs.CalibratedLinearConfig(
    feature_configs=feature_configs[:5],
    use_bias=True,
    # We must set the output min and max to that of the label.
    output_min=min_label,
    output_max=max_label,
    output_calibration=True,
    output_calibration_num_keypoints=10,
    output_initialization=np.linspace(min_label, max_label, num=10),
    regularizer_configs=[
        # Regularizer for the output calibrator.
        tfl.configs.RegularizerConfig(name='output_calib_hessian', l2=1e-4),
    ])
# A CalibratedLinear premade model constructed from the given model config.
linear_model = tfl.premade.CalibratedLinear(linear_model_config)
# Let's plot our model.
tf.keras.utils.plot_model(linear_model, show_layer_names=False, rankdir='LR')

পিএনজি

এখন, অন্য কোনও tf.keras.Model এর মতো , আমরা আমাদের ডেটাতে মডেলটি সংকলন এবং ফিট করি।

linear_model.compile(
    loss=tf.keras.losses.BinaryCrossentropy(),
    metrics=[tf.keras.metrics.AUC()],
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE))
linear_model.fit(
    train_xs, train_ys, epochs=NUM_EPOCHS, batch_size=BATCH_SIZE, verbose=False)
<tensorflow.python.keras.callbacks.History at 0x7fd5c079a1d0>

আমাদের মডেলটিকে প্রশিক্ষণের পরে, আমরা এটি আমাদের পরীক্ষার সেটটিতে মূল্যায়ন করতে পারি।

print('Test Set Evaluation...')
print(linear_model.evaluate(test_xs, test_ys))
Test Set Evaluation...
2/2 [==============================] - 0s 1ms/step - loss: 0.4644 - auc: 0.8459
[0.46442732214927673, 0.8458647131919861]

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

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

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

# This is a calibrated lattice model: inputs are calibrated, then combined
# non-linearly using a lattice layer.
lattice_model_config = tfl.configs.CalibratedLatticeConfig(
    feature_configs=feature_configs[:5],
    output_min=min_label,
    output_max=max_label - numerical_error_epsilon,
    output_initialization=[min_label, max_label],
    regularizer_configs=[
        # Torsion regularizer applied to the lattice to make it more linear.
        tfl.configs.RegularizerConfig(name='torsion', l2=1e-2),
        # Globally defined calibration regularizer is applied to all features.
        tfl.configs.RegularizerConfig(name='calib_hessian', l2=1e-2),
    ])
# A CalibratedLattice premade model constructed from the given model config.
lattice_model = tfl.premade.CalibratedLattice(lattice_model_config)
# Let's plot our model.
tf.keras.utils.plot_model(lattice_model, show_layer_names=False, rankdir='LR')

পিএনজি

আগের মতো, আমরা আমাদের মডেলটি সংকলন, ফিট করি এবং মূল্যায়ন করি।

lattice_model.compile(
    loss=tf.keras.losses.BinaryCrossentropy(),
    metrics=[tf.keras.metrics.AUC()],
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE))
lattice_model.fit(
    train_xs, train_ys, epochs=NUM_EPOCHS, batch_size=BATCH_SIZE, verbose=False)
print('Test Set Evaluation...')
print(lattice_model.evaluate(test_xs, test_ys))
Test Set Evaluation...
2/2 [==============================] - 0s 2ms/step - loss: 0.4789 - auc_1: 0.8409
[0.4789487421512604, 0.8408521413803101]

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

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

সুস্পষ্ট ল্যাটিস এনসেম্বল ইনিশিয়ালেশন

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

# This is a calibrated lattice ensemble model: inputs are calibrated, then
# combined non-linearly and averaged using multiple lattice layers.
explicit_ensemble_model_config = tfl.configs.CalibratedLatticeEnsembleConfig(
    feature_configs=feature_configs,
    lattices=[['trestbps', 'chol', 'ca'], ['fbs', 'restecg', 'thal'],
              ['fbs', 'cp', 'oldpeak'], ['exang', 'slope', 'thalach'],
              ['restecg', 'age', 'sex']],
    num_lattices=5,
    lattice_rank=3,
    output_min=min_label,
    output_max=max_label - numerical_error_epsilon,
    output_initialization=[min_label, max_label])
# A CalibratedLatticeEnsemble premade model constructed from the given
# model config.
explicit_ensemble_model = tfl.premade.CalibratedLatticeEnsemble(
    explicit_ensemble_model_config)
# Let's plot our model.
tf.keras.utils.plot_model(
    explicit_ensemble_model, show_layer_names=False, rankdir='LR')

পিএনজি

আগের মতো, আমরা আমাদের মডেলটি সংকলন, ফিট করি এবং মূল্যায়ন করি।

explicit_ensemble_model.compile(
    loss=tf.keras.losses.BinaryCrossentropy(),
    metrics=[tf.keras.metrics.AUC()],
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE))
explicit_ensemble_model.fit(
    train_xs, train_ys, epochs=NUM_EPOCHS, batch_size=BATCH_SIZE, verbose=False)
print('Test Set Evaluation...')
print(explicit_ensemble_model.evaluate(test_xs, test_ys))
Test Set Evaluation...
2/2 [==============================] - 0s 2ms/step - loss: 0.4373 - auc_2: 0.8615
[0.437343567609787, 0.8615288734436035]

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

যদি আপনি নিশ্চিত না হন যে কোন বৈশিষ্ট্যের সাবসেটগুলি আপনার ল্যাটিসগুলিতে ফিড করবে, তবে অন্য একটি বিকল্প হ'ল প্রতিটি জালির জন্য বৈশিষ্ট্যগুলির এলোমেলো উপসেটগুলি ব্যবহার করা। এই উদাহরণটি একটি ক্যালিব্রেটেড ল্যাটিস এনসেম্বল মডেল তৈরি করে যাতে প্রতি জালটিতে 5 টি ল্যাটিস এবং 3 টি বৈশিষ্ট্য রয়েছে।

# This is a calibrated lattice ensemble model: inputs are calibrated, then
# combined non-linearly and averaged using multiple lattice layers.
random_ensemble_model_config = tfl.configs.CalibratedLatticeEnsembleConfig(
    feature_configs=feature_configs,
    lattices='random',
    num_lattices=5,
    lattice_rank=3,
    output_min=min_label,
    output_max=max_label - numerical_error_epsilon,
    output_initialization=[min_label, max_label],
    random_seed=42)
# Now we must set the random lattice structure and construct the model.
tfl.premade_lib.set_random_lattice_ensemble(random_ensemble_model_config)
# A CalibratedLatticeEnsemble premade model constructed from the given
# model config.
random_ensemble_model = tfl.premade.CalibratedLatticeEnsemble(
    random_ensemble_model_config)
# Let's plot our model.
tf.keras.utils.plot_model(
    random_ensemble_model, show_layer_names=False, rankdir='LR')

পিএনজি

আগের মতো, আমরা আমাদের মডেলটি সংকলন, ফিট করি এবং মূল্যায়ন করি।

random_ensemble_model.compile(
    loss=tf.keras.losses.BinaryCrossentropy(),
    metrics=[tf.keras.metrics.AUC()],
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE))
random_ensemble_model.fit(
    train_xs, train_ys, epochs=NUM_EPOCHS, batch_size=BATCH_SIZE, verbose=False)
print('Test Set Evaluation...')
print(random_ensemble_model.evaluate(test_xs, test_ys))
Test Set Evaluation...
2/2 [==============================] - 0s 2ms/step - loss: 0.4034 - auc_3: 0.9223
[0.40344616770744324, 0.9223057627677917]

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

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

এই উদাহরণটি একটি ক্যালিব্রেটেড ল্যাটিস এনসেম্বল মডেল তৈরি করে যাতে প্রতি জালটিতে 5 টি ল্যাটিস এবং 3 টি বৈশিষ্ট্য রয়েছে।

# 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 a calibrated lattice ensemble model: inputs are calibrated, then
# combined non-linearly and averaged using multiple lattice layers.
rtl_layer_ensemble_model_config = tfl.configs.CalibratedLatticeEnsembleConfig(
    feature_configs=rtl_layer_feature_configs,
    lattices='rtl_layer',
    num_lattices=5,
    lattice_rank=3,
    output_min=min_label,
    output_max=max_label - numerical_error_epsilon,
    output_initialization=[min_label, max_label],
    random_seed=42)
# A CalibratedLatticeEnsemble premade model constructed from the given
# model config. Note that we do not have to specify the lattices by calling
# a helper function (like before with random) because the RTL Layer will take
# care of that for us.
rtl_layer_ensemble_model = tfl.premade.CalibratedLatticeEnsemble(
    rtl_layer_ensemble_model_config)
# Let's plot our model.
tf.keras.utils.plot_model(
    rtl_layer_ensemble_model, show_layer_names=False, rankdir='LR')

পিএনজি

আগের মতো, আমরা আমাদের মডেলটি সংকলন, ফিট করি এবং মূল্যায়ন করি।

rtl_layer_ensemble_model.compile(
    loss=tf.keras.losses.BinaryCrossentropy(),
    metrics=[tf.keras.metrics.AUC()],
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE))
rtl_layer_ensemble_model.fit(
    train_xs, train_ys, epochs=NUM_EPOCHS, batch_size=BATCH_SIZE, verbose=False)
print('Test Set Evaluation...')
print(rtl_layer_ensemble_model.evaluate(test_xs, test_ys))
Test Set Evaluation...
2/2 [==============================] - 0s 2ms/step - loss: 0.4287 - auc_4: 0.8684
[0.42873889207839966, 0.8684210777282715]

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

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

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

এই উদাহরণটি একটি ক্যালিব্রেটেড ল্যাটিস এনসেম্বল মডেল তৈরি করে যাতে প্রতি জালটিতে 5 টি ল্যাটিস এবং 3 টি বৈশিষ্ট্য রয়েছে।

# This is a calibrated lattice ensemble model: inputs are calibrated, then
# combines non-linearly and averaged using multiple lattice layers.
crystals_ensemble_model_config = tfl.configs.CalibratedLatticeEnsembleConfig(
    feature_configs=feature_configs,
    lattices='crystals',
    num_lattices=5,
    lattice_rank=3,
    output_min=min_label,
    output_max=max_label - numerical_error_epsilon,
    output_initialization=[min_label, max_label],
    random_seed=42)
# Now that we have our model config, we can construct a prefitting model config.
prefitting_model_config = tfl.premade_lib.construct_prefitting_model_config(
    crystals_ensemble_model_config)
# A CalibratedLatticeEnsemble premade model constructed from the given
# prefitting model config.
prefitting_model = tfl.premade.CalibratedLatticeEnsemble(
    prefitting_model_config)
# We can compile and train our prefitting model as we like.
prefitting_model.compile(
    loss=tf.keras.losses.BinaryCrossentropy(),
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE))
prefitting_model.fit(
    train_xs,
    train_ys,
    epochs=PREFITTING_NUM_EPOCHS,
    batch_size=BATCH_SIZE,
    verbose=False)
# Now that we have our trained prefitting model, we can extract the crystals.
tfl.premade_lib.set_crystals_lattice_ensemble(crystals_ensemble_model_config,
                                              prefitting_model_config,
                                              prefitting_model)
# A CalibratedLatticeEnsemble premade model constructed from the given
# model config.
crystals_ensemble_model = tfl.premade.CalibratedLatticeEnsemble(
    crystals_ensemble_model_config)
# Let's plot our model.
tf.keras.utils.plot_model(
    crystals_ensemble_model, show_layer_names=False, rankdir='LR')

পিএনজি

আগের মতো, আমরা আমাদের মডেলটি সংকলন, ফিট করি এবং মূল্যায়ন করি।

crystals_ensemble_model.compile(
    loss=tf.keras.losses.BinaryCrossentropy(),
    metrics=[tf.keras.metrics.AUC()],
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE))
crystals_ensemble_model.fit(
    train_xs, train_ys, epochs=NUM_EPOCHS, batch_size=BATCH_SIZE, verbose=False)
print('Test Set Evaluation...')
print(crystals_ensemble_model.evaluate(test_xs, test_ys))
Test Set Evaluation...
2/2 [==============================] - 0s 2ms/step - loss: 0.4039 - auc_5: 0.8853
[0.40386414527893066, 0.885338306427002]