Bu sayfa, Cloud Translation API ile çevrilmiştir.
Switch to English

TF Lattice Premade Modelleri

TensorFlow.org'da görüntüleyin Google Colab'de çalıştırın Kaynağı GitHub'da görüntüleyin Defteri indirin

Genel Bakış

Hazır Modeller, tipik kullanım durumları için TFL tf.keras.model örnekleri oluşturmanın hızlı ve kolay yollarıdır. Bu kılavuz, bir TFL Hazır Model oluşturmak ve onu eğitmek / test etmek için gereken adımları özetlemektedir.

Kurmak

TF Lattice paketinin kurulması:

pip install -q tensorflow-lattice pydot

Gerekli paketleri içe aktarma:

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)

UCI Statlog (Heart) veri kümesini indirme:

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()

Unsurları ve etiketleri ayıklayın ve tensörlere dönüştürün:

# 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

Bu kılavuzda eğitim için kullanılan varsayılan değerleri ayarlama:

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

Özellik Yapılandırmaları

Özellik kalibrasyonu ve özellik başına yapılandırmalar tfl.configs.FeatureConfig kullanılarak ayarlanır . Özellik yapılandırmaları arasında monotonluk kısıtlamaları, özellik başına düzenlilik (bkz. Tfl.configs.RegularizerConfig ) ve kafes modelleri için kafes boyutları bulunur.

Modelimizin tanımasını istediğimiz herhangi bir özellik için özellik yapılandırmasını tam olarak belirtmemiz gerektiğini unutmayın. Aksi takdirde modelin böyle bir özelliğin var olduğunu bilmesine imkân yoktur.

Nicelikleri Hesapla

pwl_calibration_input_keypoints içindeki tfl.configs.FeatureConfig için varsayılan ayar 'nicelikler' olsa da, önceden hazırlanmış modeller için giriş anahtar noktalarını manuel olarak tanımlamamız gerekir. Bunu yapmak için, önce kuantilleri hesaplamak için kendi yardımcı fonksiyonumuzu tanımlarız.

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)

Özellik Yapılandırmalarımızı Tanımlama

Artık niceliklerimizi hesaplayabildiğimize göre, modelimizin girdi olarak almasını istediğimiz her özellik için bir özellik yapılandırması tanımlıyoruz.

# 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,
    ),
]

Daha sonra, özel bir kelime dağarcığı kullandığımız (yukarıdaki 'thal' gibi) özellikler için monotonlukları doğru şekilde ayarladığımızdan emin olmalıyız.

tfl.premade_lib.set_categorical_monotonicities(feature_configs)

Kalibre Edilmiş Doğrusal Model

Önceden hazırlanmış bir TFL modeli oluşturmak için önce tfl.configs'den bir model yapılandırması oluşturun . Tfl.configs.CalibratedLinearConfig kullanılarak kalibre edilmiş bir doğrusal model oluşturulur . Girdi özelliklerine parçalı doğrusal ve kategorik kalibrasyon uygular, ardından doğrusal bir kombinasyon ve isteğe bağlı bir parçalı doğrusal kalibrasyon çıktı. Çıktı kalibrasyonu kullanılırken veya çıktı sınırları belirtildiğinde, doğrusal katman, kalibre edilmiş girdilere ağırlıklı ortalama uygulayacaktır.

Bu örnek, ilk 5 özellik üzerinde kalibre edilmiş bir doğrusal model oluşturur.

# 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')

png

Şimdi, diğer tf.keras.Model'de olduğu gibi, modeli derliyor ve verilerimize uyduruyoruz .

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>

Modelimizi eğittikten sonra test setimiz üzerinde değerlendirebiliriz.

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]

Kalibre Edilmiş Kafes Modeli

Kalibre edilmiş bir kafes modeli tfl.configs.CalibratedLatticeConfig kullanılarak oluşturulur . Kalibre edilmiş bir kafes modeli, girdi özelliklerinde parçalı doğrusal ve kategorik kalibrasyon uygular, ardından bir kafes modeli ve isteğe bağlı bir parçalı doğrusal kalibrasyon çıktı.

Bu örnek, ilk 5 unsurda kalibre edilmiş bir kafes modeli oluşturur.

# 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')

png

Daha önce olduğu gibi, modelimizi derliyor, sığdırıyor ve değerlendiriyoruz.

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]

Kalibre Edilmiş Kafes Topluluk Modeli

Özelliklerin sayısı büyük olduğunda, özelliklerin alt kümeleri için birden çok küçük kafes oluşturan ve yalnızca tek bir büyük kafes oluşturmak yerine çıktılarının ortalamasını alan bir topluluk modeli kullanabilirsiniz. Ensemble lattice modelleri tfl.configs.CalibratedLatticeEnsembleConfig kullanılarak oluşturulur . Kalibre edilmiş bir kafes topluluk modeli, girdi özelliğine parçalı doğrusal ve kategorik kalibrasyon uygular, ardından bir dizi kafes modelleri ve isteğe bağlı bir parça parça doğrusal kalibrasyon çıkışı izler.

Explicit Lattice Ensemble Initialization

Kafeslerinize hangi özellik alt kümelerini beslemek istediğinizi zaten biliyorsanız, o zaman özellik adlarını kullanarak kafesleri açıkça ayarlayabilirsiniz. Bu örnek, kafes başına 5 kafes ve 3 özellik içeren kalibre edilmiş bir kafes topluluk modeli oluşturur.

# 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')

png

Daha önce olduğu gibi, modelimizi derliyor, sığdırıyor ve değerlendiriyoruz.

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]

Random Lattice Ensemble

Kafeslerinize hangi özellik alt kümelerini besleyeceğinizden emin değilseniz, başka bir seçenek de her kafes için rastgele özellik alt kümeleri kullanmaktır. Bu örnek, kafes başına 5 kafes ve 3 özellik içeren kalibre edilmiş bir kafes topluluk modeli oluşturur.

# 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')

png

Daha önce olduğu gibi, modelimizi derliyor, sığdırıyor ve değerlendiriyoruz.

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]

RTL Layer Random Lattice Ensemble

Rastgele bir kafes topluluğu kullanırken, modelin tek bir tfl.layers.RTL katmanı kullanmasını belirtebilirsiniz. tfl.layers.RTL yalnızca monotonluk kısıtlamalarını desteklediğini ve tüm özellikler için aynı kafes boyutuna sahip olması ve özellik başına düzenleme olmaması gerektiğini not ediyoruz. Bir tfl.layers.RTL katmanı kullanmanın, ayrı tfl.layers.Lattice örnekleri kullanmaktan çok daha büyük topluluklara ölçeklendirmenize izin tfl.layers.RTL unutmayın.

Bu örnek, kafes başına 5 kafes ve 3 özellik içeren kalibre edilmiş bir kafes topluluk modeli oluşturur.

# 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')

png

Daha önce olduğu gibi, modelimizi derliyor, sığdırıyor ve değerlendiriyoruz.

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]

Crystals Kafes Ensemble

Premade ayrıca Crystals adı verilen sezgisel bir özellik düzenleme algoritması sağlar. Kristaller algoritmasını kullanmak için, önce ikili özellik etkileşimlerini tahmin eden uygun bir model eğitiyoruz. Daha sonra son topluluğu, daha doğrusal olmayan etkileşimleri olan özellikler aynı kafeslerde olacak şekilde düzenleriz.

Premade Library, uygun model konfigürasyonunu oluşturmak ve kristal yapısını çıkarmak için yardımcı işlevler sunar. Önceden uyan modelin tam olarak eğitilmesi gerekmediğine dikkat edin, bu nedenle birkaç dönemin yeterli olması gerekir.

Bu örnek, kafes başına 5 kafes ve 3 özellik içeren kalibre edilmiş bir kafes topluluk modeli oluşturur.

# 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')

png

Daha önce olduğu gibi, modelimizi derliyor, sığdırıyor ve değerlendiriyoruz.

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]