तिथि को रक्षित करें! Google I / O 18-20 मई को पंजीकृत करता है
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

Tensorflow जाली के साथ आकार की कमी

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

अवलोकन

यह ट्यूटोरियल TensorFlow Lattice (TFL) लाइब्रेरी द्वारा प्रदान की गई बाधाओं और नियमितताओं का अवलोकन है। यहां हम सिंथेटिक डेटासेट पर टीएफएल कैन्ड अनुमानक का उपयोग करते हैं, लेकिन ध्यान दें कि इस ट्यूटोरियल में सब कुछ टीएफएल केरस परतों से निर्मित मॉडल के साथ भी किया जा सकता है।

आगे बढ़ने से पहले, सुनिश्चित करें कि आपके रनटाइम में सभी आवश्यक पैकेज स्थापित हैं (जैसा कि नीचे दिए गए कोड कक्षों में आयात किया गया है)।

सेट अप

टीएफ जाली पैकेज स्थापित करना:

pip install -q tensorflow-lattice

आवश्यक पैकेज आयात करना:

import tensorflow as tf

from IPython.core.pylabtools import figsize
import itertools
import logging
import matplotlib
from matplotlib import pyplot as plt
import numpy as np
import pandas as pd
import sys
import tensorflow_lattice as tfl
logging.disable(sys.maxsize)

इस गाइड में प्रयुक्त डिफ़ॉल्ट मान:

NUM_EPOCHS = 1000
BATCH_SIZE = 64
LEARNING_RATE=0.01

रैंकिंग रेस्तरां के लिए प्रशिक्षण डेटासेट

एक सरल परिदृश्य की कल्पना करें जहां हम यह निर्धारित करना चाहते हैं कि उपयोगकर्ता किसी रेस्तरां खोज परिणाम पर क्लिक करेंगे या नहीं। कार्य क्लिकथ्रू दर (CTR) के इनपुट फीचर्स की भविष्यवाणी करना है:

  • औसत रेटिंग ( avg_rating ): रेंज में मानों के साथ एक संख्यात्मक सुविधा [1,5]।
  • समीक्षाओं की संख्या ( num_reviews ): 200 पर कैप किए गए मानों के साथ एक संख्यात्मक सुविधा, जिसे हम num_reviews माप के रूप में उपयोग करते हैं।
  • डॉलर रेटिंग ( dollar_rating ): सेट में स्ट्रिंग मानों के साथ एक dollar_rating विशेषता {"डी", "डीडी", "डीडीडी", "डीडीडी"}।

यहाँ हम एक सिंथेटिक डेटासेट बनाते हैं जहाँ सूत्र द्वारा सही CTR दिया जाता है:

$$ CTR = 1 / (1 + exp\{\mbox{b(dollar_rating)}-\mbox{avg_rating}\times log(\mbox{num_reviews}) /4 \}) $$

जहां $ ख (\ सी-डॉट) $ प्रत्येक तब्दील dollar_rating एक आधारभूत मूल्य रहे हैं:

$$ \mbox{D}\to 3,\ \mbox{DD}\to 2,\ \mbox{DDD}\to 4,\ \mbox{DDDD}\to 4.5. $$

यह सूत्र विशिष्ट उपयोगकर्ता पैटर्न को दर्शाता है। उदाहरण के लिए, बाकी सब कुछ निश्चित रूप से दिए जाने पर, उपयोगकर्ता उच्च स्टार रेटिंग वाले रेस्तरां पसंद करते हैं, और "\" $ \ "रेस्त्रां को" \ "$" से अधिक क्लिक प्राप्त होंगे, इसके बाद "$ \" $ \ "और" $ \ "$ \ "$।

def click_through_rate(avg_ratings, num_reviews, dollar_ratings):
  dollar_rating_baseline = {"D": 3, "DD": 2, "DDD": 4, "DDDD": 4.5}
  return 1 / (1 + np.exp(
      np.array([dollar_rating_baseline[d] for d in dollar_ratings]) -
      avg_ratings * np.log1p(num_reviews) / 4))

आइए इस सीटीआर फ़ंक्शन के समोच्च भूखंडों पर एक नज़र डालें।

def color_bar():
  bar = matplotlib.cm.ScalarMappable(
      norm=matplotlib.colors.Normalize(0, 1, True),
      cmap="viridis",
  )
  bar.set_array([0, 1])
  return bar


def plot_fns(fns, split_by_dollar=False, res=25):
  """Generates contour plots for a list of (name, fn) functions."""
  num_reviews, avg_ratings = np.meshgrid(
      np.linspace(0, 200, num=res),
      np.linspace(1, 5, num=res),
  )
  if split_by_dollar:
    dollar_rating_splits = ["D", "DD", "DDD", "DDDD"]
  else:
    dollar_rating_splits = [None]
  if len(fns) == 1:
    fig, axes = plt.subplots(2, 2, sharey=True, tight_layout=False)
  else:
    fig, axes = plt.subplots(
        len(dollar_rating_splits), len(fns), sharey=True, tight_layout=False)
  axes = axes.flatten()
  axes_index = 0
  for dollar_rating_split in dollar_rating_splits:
    for title, fn in fns:
      if dollar_rating_split is not None:
        dollar_ratings = np.repeat(dollar_rating_split, res**2)
        values = fn(avg_ratings.flatten(), num_reviews.flatten(),
                    dollar_ratings)
        title = "{}: dollar_rating={}".format(title, dollar_rating_split)
      else:
        values = fn(avg_ratings.flatten(), num_reviews.flatten())
      subplot = axes[axes_index]
      axes_index += 1
      subplot.contourf(
          avg_ratings,
          num_reviews,
          np.reshape(values, (res, res)),
          vmin=0,
          vmax=1)
      subplot.title.set_text(title)
      subplot.set(xlabel="Average Rating")
      subplot.set(ylabel="Number of Reviews")
      subplot.set(xlim=(1, 5))

  _ = fig.colorbar(color_bar(), cax=fig.add_axes([0.95, 0.2, 0.01, 0.6]))


figsize(11, 11)
plot_fns([("CTR", click_through_rate)], split_by_dollar=True)

पींग

डेटा तैयार करना

अब हमें अपने सिंथेटिक डेटासेट बनाने की आवश्यकता है। हम रेस्तरां और उनकी विशेषताओं का एक नकली डेटा जनरेट करके शुरू करते हैं।

def sample_restaurants(n):
  avg_ratings = np.random.uniform(1.0, 5.0, n)
  num_reviews = np.round(np.exp(np.random.uniform(0.0, np.log(200), n)))
  dollar_ratings = np.random.choice(["D", "DD", "DDD", "DDDD"], n)
  ctr_labels = click_through_rate(avg_ratings, num_reviews, dollar_ratings)
  return avg_ratings, num_reviews, dollar_ratings, ctr_labels


np.random.seed(42)
avg_ratings, num_reviews, dollar_ratings, ctr_labels = sample_restaurants(2000)

figsize(5, 5)
fig, axs = plt.subplots(1, 1, sharey=False, tight_layout=False)
for rating, marker in [("D", "o"), ("DD", "^"), ("DDD", "+"), ("DDDD", "x")]:
  plt.scatter(
      x=avg_ratings[np.where(dollar_ratings == rating)],
      y=num_reviews[np.where(dollar_ratings == rating)],
      c=ctr_labels[np.where(dollar_ratings == rating)],
      vmin=0,
      vmax=1,
      marker=marker,
      label=rating)
plt.xlabel("Average Rating")
plt.ylabel("Number of Reviews")
plt.legend()
plt.xlim((1, 5))
plt.title("Distribution of restaurants")
_ = fig.colorbar(color_bar(), cax=fig.add_axes([0.95, 0.2, 0.01, 0.6]))

पींग

चलो प्रशिक्षण, सत्यापन और परीक्षण डेटासेट का उत्पादन करते हैं। जब कोई रेस्तरां खोज परिणामों में देखा जाता है, तो हम नमूना बिंदु के रूप में उपयोगकर्ता की सगाई (क्लिक या नो क्लिक) रिकॉर्ड कर सकते हैं।

व्यवहार में, उपयोगकर्ता अक्सर सभी खोज परिणामों से नहीं गुजरते हैं। इसका मतलब है कि उपयोगकर्ताओं को संभवतः वर्तमान रैंकिंग मॉडल द्वारा पहले से ही "अच्छा" माना जाने वाले रेस्तरां उपयोग में दिखाई देंगे। नतीजतन, "अच्छा" रेस्तरां अधिक बार प्रभावित होते हैं और प्रशिक्षण डेटासेट में अधिक प्रतिनिधित्व करते हैं। अधिक सुविधाओं का उपयोग करते समय, प्रशिक्षण डाटासेट में सुविधा स्थान के "खराब" भागों में बड़े अंतराल हो सकते हैं।

जब मॉडल को रैंकिंग के लिए उपयोग किया जाता है, तो अक्सर सभी प्रासंगिक परिणामों पर अधिक समान वितरण के साथ मूल्यांकन किया जाता है जो प्रशिक्षण डेटासेट द्वारा अच्छी तरह से प्रतिनिधित्व नहीं किया जाता है। एक लचीला और जटिल मॉडल इस मामले में अति-प्रतिनिधित्व वाले डेटा बिंदुओं को ओवरफिट करने के कारण विफल हो सकता है और इस प्रकार सामान्यता की कमी होती है। हम इस मुद्दे को आकार ज्ञान बाधाओं को जोड़ने के लिए डोमेन ज्ञान को लागू करके संभालते हैं जो मॉडल को उचित भविष्यवाणियां करने के लिए मार्गदर्शन करते हैं जब यह उन्हें प्रशिक्षण डाटासेट से नहीं उठा सकता है।

इस उदाहरण में, प्रशिक्षण डाटासेट में ज्यादातर अच्छे और लोकप्रिय रेस्तरां के साथ उपयोगकर्ता की बातचीत शामिल है। परीक्षण डेटासेट में ऊपर चर्चा की गई मूल्यांकन सेटिंग का अनुकरण करने के लिए एक समान वितरण है। ध्यान दें कि ऐसे परीक्षण डेटासेट वास्तविक समस्या सेटिंग में उपलब्ध नहीं होंगे।

def sample_dataset(n, testing_set):
  (avg_ratings, num_reviews, dollar_ratings, ctr_labels) = sample_restaurants(n)
  if testing_set:
    # Testing has a more uniform distribution over all restaurants.
    num_views = np.random.poisson(lam=3, size=n)
  else:
    # Training/validation datasets have more views on popular restaurants.
    num_views = np.random.poisson(lam=ctr_labels * num_reviews / 50.0, size=n)

  return pd.DataFrame({
      "avg_rating": np.repeat(avg_ratings, num_views),
      "num_reviews": np.repeat(num_reviews, num_views),
      "dollar_rating": np.repeat(dollar_ratings, num_views),
      "clicked": np.random.binomial(n=1, p=np.repeat(ctr_labels, num_views))
  })


# Generate datasets.
np.random.seed(42)
data_train = sample_dataset(500, testing_set=False)
data_val = sample_dataset(500, testing_set=False)
data_test = sample_dataset(500, testing_set=True)

# Plotting dataset densities.
figsize(12, 5)
fig, axs = plt.subplots(1, 2, sharey=False, tight_layout=False)
for ax, data, title in [(axs[0], data_train, "training"),
                        (axs[1], data_test, "testing")]:
  _, _, _, density = ax.hist2d(
      x=data["avg_rating"],
      y=data["num_reviews"],
      bins=(np.linspace(1, 5, num=21), np.linspace(0, 200, num=21)),
      density=True,
      cmap="Blues",
  )
  ax.set(xlim=(1, 5))
  ax.set(ylim=(0, 200))
  ax.set(xlabel="Average Rating")
  ax.set(ylabel="Number of Reviews")
  ax.title.set_text("Density of {} examples".format(title))
  _ = fig.colorbar(density, ax=ax)

पींग

प्रशिक्षण और मूल्यांकन के लिए प्रयुक्त input_fns को परिभाषित करना:

train_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(
    x=data_train,
    y=data_train["clicked"],
    batch_size=BATCH_SIZE,
    num_epochs=NUM_EPOCHS,
    shuffle=False,
)

# feature_analysis_input_fn is used for TF Lattice estimators.
feature_analysis_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(
    x=data_train,
    y=data_train["clicked"],
    batch_size=BATCH_SIZE,
    num_epochs=1,
    shuffle=False,
)

val_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(
    x=data_val,
    y=data_val["clicked"],
    batch_size=BATCH_SIZE,
    num_epochs=1,
    shuffle=False,
)

test_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(
    x=data_test,
    y=data_test["clicked"],
    batch_size=BATCH_SIZE,
    num_epochs=1,
    shuffle=False,
)

फिटिंग ग्रेडेड बूस्टेड पेड़

चलो केवल दो सुविधाओं के साथ शुरू करते हैं: avg_rating और num_reviews

हम सत्यापन और परीक्षण मैट्रिक्स की साजिश रचने और गणना के लिए कुछ सहायक कार्य बनाते हैं।

def analyze_two_d_estimator(estimator, name):
  # Extract validation metrics.
  metric = estimator.evaluate(input_fn=val_input_fn)
  print("Validation AUC: {}".format(metric["auc"]))
  metric = estimator.evaluate(input_fn=test_input_fn)
  print("Testing AUC: {}".format(metric["auc"]))

  def two_d_pred(avg_ratings, num_reviews):
    results = estimator.predict(
        tf.compat.v1.estimator.inputs.pandas_input_fn(
            x=pd.DataFrame({
                "avg_rating": avg_ratings,
                "num_reviews": num_reviews,
            }),
            shuffle=False,
        ))
    return [x["logistic"][0] for x in results]

  def two_d_click_through_rate(avg_ratings, num_reviews):
    return np.mean([
        click_through_rate(avg_ratings, num_reviews,
                           np.repeat(d, len(avg_ratings)))
        for d in ["D", "DD", "DDD", "DDDD"]
    ],
                   axis=0)

  figsize(11, 5)
  plot_fns([("{} Estimated CTR".format(name), two_d_pred),
            ("CTR", two_d_click_through_rate)],
           split_by_dollar=False)

हम डेटासेट पर TensorFlow ग्रेडिएंट बूस्टेड डिसाइड ट्री को फिट कर सकते हैं:

feature_columns = [
    tf.feature_column.numeric_column("num_reviews"),
    tf.feature_column.numeric_column("avg_rating"),
]
gbt_estimator = tf.estimator.BoostedTreesClassifier(
    feature_columns=feature_columns,
    # Hyper-params optimized on validation set.
    n_batches_per_layer=1,
    max_depth=2,
    n_trees=50,
    learning_rate=0.05,
    config=tf.estimator.RunConfig(tf_random_seed=42),
)
gbt_estimator.train(input_fn=train_input_fn)
analyze_two_d_estimator(gbt_estimator, "GBT")
Validation AUC: 0.6333084106445312
Testing AUC: 0.774649977684021

पींग

भले ही मॉडल ने सही CTR के सामान्य आकार पर कब्जा कर लिया है और इसमें सभ्य सत्यापन मीट्रिक है, यह इनपुट स्पेस के कई हिस्सों में काउंटर-सहज व्यवहार है: अनुमानित CTR औसत रेटिंग या समीक्षाओं की संख्या में वृद्धि के रूप में घट जाती है। यह प्रशिक्षण डेटासेट द्वारा अच्छी तरह से कवर नहीं किए गए क्षेत्रों में नमूना बिंदुओं की कमी के कारण है। मॉडल के पास केवल डेटा से सही व्यवहार को कम करने का कोई तरीका नहीं है।

इस समस्या को हल करने के लिए, हम आकार की कसौटी को लागू करते हैं कि मॉडल को औसत रेटिंग और समीक्षाओं की संख्या दोनों के संबंध में नीरस रूप से बढ़ते हुए मूल्यों का उत्पादन करना चाहिए। हम बाद में देखेंगे कि इसे टीएफएल में कैसे लागू किया जाए।

एक DNN फिटिंग

हम DNN क्लासिफायर के साथ समान चरणों को दोहरा सकते हैं। हम एक समान पैटर्न का पालन कर सकते हैं: कम संख्या में समीक्षाओं के साथ पर्याप्त नमूना अंक न होने के कारण निरर्थक एक्सट्रपलेशन में परिणाम। ध्यान दें कि भले ही सत्यापन मीट्रिक पेड़ के समाधान से बेहतर है, परीक्षण मीट्रिक बहुत खराब है।

feature_columns = [
    tf.feature_column.numeric_column("num_reviews"),
    tf.feature_column.numeric_column("avg_rating"),
]
dnn_estimator = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    # Hyper-params optimized on validation set.
    hidden_units=[16, 8, 8],
    optimizer=tf.keras.optimizers.Adam(learning_rate=LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42),
)
dnn_estimator.train(input_fn=train_input_fn)
analyze_two_d_estimator(dnn_estimator, "DNN")
Validation AUC: 0.6696228981018066
Testing AUC: 0.750156044960022

पींग

आकार की कमी

TensorFlow Lattice (TFL) प्रशिक्षण डेटा से परे मॉडल व्यवहार को सुरक्षित करने के लिए आकार की बाधाओं को लागू करने पर केंद्रित है। ये आकार की बाधाएं टीएफएल केरस परतों पर लागू होती हैं। उनका विवरण हमारे जेएमएलआर पेपर में पाया जा सकता है।

इस ट्यूटोरियल में हम विभिन्न आकार की बाधाओं को कवर करने के लिए TF कैन्ड अनुमानक का उपयोग करते हैं, लेकिन ध्यान दें कि इन सभी चरणों को टीएफएल केरस परतों से निर्मित मॉडल के साथ किया जा सकता है।

किसी भी अन्य TensorFlow अनुमानक के साथ, TFL कैन्ड अनुमानक इनपुट स्वरूप को परिभाषित करने के लिए फीचर कॉलम का उपयोग करते हैं और डेटा में पास होने के लिए एक प्रशिक्षण input_fn का उपयोग करते हैं। TFL डिब्बाबंद अनुमानकों का उपयोग करना भी आवश्यक है:

  • एक मॉडल विन्यास : मॉडल वास्तुकला और प्रति-सुविधा आकार की बाधाओं और नियमितताओं को परिभाषित करना।
  • एक विशेषता विश्लेषण input_fn : एक TF input_fn TFL आरंभीकरण के लिए डेटा गुजर रहा है।

अधिक गहन विवरण के लिए, कृपया डिब्बाबंद अनुमानक ट्यूटोरियल या एपीआई डॉक्स देखें।

दिष्टता

हम पहले दोनों विशेषताओं में एकरूपता आकार की बाधाओं को जोड़कर एकरूपता की चिंताओं को संबोधित करते हैं।

TFL को आकार की बाधाओं को लागू करने का निर्देश देने के लिए, हम सुविधा कॉन्फ़िगरेशन में बाधाओं को निर्दिष्ट करते हैं। निम्न कोड दिखाता है कि हम दोनों को num_reviews और avg_rating संबंध में नीरसता से वृद्धि करने के लिए आउटपुट की आवश्यकता कैसे हो सकती है और monotonicity="increasing" सेट करके avg_rating

feature_columns = [
    tf.feature_column.numeric_column("num_reviews"),
    tf.feature_column.numeric_column("avg_rating"),
]
model_config = tfl.configs.CalibratedLatticeConfig(
    feature_configs=[
        tfl.configs.FeatureConfig(
            name="num_reviews",
            lattice_size=2,
            monotonicity="increasing",
            pwl_calibration_num_keypoints=20,
        ),
        tfl.configs.FeatureConfig(
            name="avg_rating",
            lattice_size=2,
            monotonicity="increasing",
            pwl_calibration_num_keypoints=20,
        )
    ])
tfl_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=LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42),
)
tfl_estimator.train(input_fn=train_input_fn)
analyze_two_d_estimator(tfl_estimator, "TF Lattice")
Validation AUC: 0.6565533876419067
Testing AUC: 0.7784258723258972

पींग

CalibratedLatticeConfig का उपयोग करना एक डिब्बाबंद क्लासिफायरियर बनाता है जो पहले प्रत्येक इनपुट के लिए एक अंशशोधक (संख्यात्मक विशेषताओं के लिए एक टुकड़ा-वार रैखिक कार्य) को लागू करता है और उसके बाद एक जाली परत द्वारा गैर-रैखिक रूप से अंशों को फ्यूज करने के लिए परत बनाता है। हम मॉडल की कल्पना करने के लिए tfl.visualization का उपयोग कर सकते हैं। विशेष रूप से, निम्नलिखित प्लॉट कैन्ड क्लासिफायर में शामिल दो प्रशिक्षित कैलिब्रेटर्स को दर्शाता है।

def save_and_visualize_lattice(tfl_estimator):
  saved_model_path = tfl_estimator.export_saved_model(
      "/tmp/TensorFlow_Lattice_101/",
      tf.estimator.export.build_parsing_serving_input_receiver_fn(
          feature_spec=tf.feature_column.make_parse_example_spec(
              feature_columns)))
  model_graph = tfl.estimators.get_model_graph(saved_model_path)
  figsize(8, 8)
  tfl.visualization.draw_model_graph(model_graph)
  return model_graph

_ = save_and_visualize_lattice(tfl_estimator)

पींग

जोड़े गए अवरोधों के साथ, अनुमानित CTR हमेशा बढ़ती रहेगी क्योंकि औसत रेटिंग बढ़ती है या समीक्षाओं की संख्या बढ़ती है। यह सुनिश्चित करके किया जाता है कि कैलिब्रेटर्स और जाली मोनोटोनिक हैं।

न्यासियों का बोर्ड

रिटर्न कम होने का मतलब यह है कि जैसे-जैसे हम वैल्यू बढ़ाएंगे एक निश्चित फीचर वैल्यू बढ़ने का मार्जिन बढ़ेगा। हमारे मामले में हम उम्मीद करते हैं कि num_reviews सुविधा इस पैटर्न का अनुसरण करती है, इसलिए हम इसके num_reviews इसके अनुसार कॉन्फ़िगर कर सकते हैं। ध्यान दें कि हम दो पर्याप्त परिस्थितियों में रिटर्न घटा सकते हैं:

  • अंशशोधक नीरस रूप से बढ़ रहा है, और
  • अंशांकन अवतल है।
feature_columns = [
    tf.feature_column.numeric_column("num_reviews"),
    tf.feature_column.numeric_column("avg_rating"),
]
model_config = tfl.configs.CalibratedLatticeConfig(
    feature_configs=[
        tfl.configs.FeatureConfig(
            name="num_reviews",
            lattice_size=2,
            monotonicity="increasing",
            pwl_calibration_convexity="concave",
            pwl_calibration_num_keypoints=20,
        ),
        tfl.configs.FeatureConfig(
            name="avg_rating",
            lattice_size=2,
            monotonicity="increasing",
            pwl_calibration_num_keypoints=20,
        )
    ])
tfl_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=LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42),
)
tfl_estimator.train(input_fn=train_input_fn)
analyze_two_d_estimator(tfl_estimator, "TF Lattice")
_ = save_and_visualize_lattice(tfl_estimator)
Validation AUC: 0.6409633755683899
Testing AUC: 0.7891247272491455

पींग

पींग

गौर करें कि समवर्ती बाधा को जोड़कर परीक्षण मीट्रिक में कैसे सुधार होता है। भविष्यवाणी की साजिश भी जमीनी सच्चाई से मिलती-जुलती है।

2 डी आकार बाधा: ट्रस्ट

केवल एक या दो समीक्षाओं वाले रेस्तरां के लिए 5-स्टार रेटिंग एक अविश्वसनीय रेटिंग है (रेस्तरां वास्तव में अच्छा नहीं हो सकता है), जबकि सैकड़ों समीक्षाओं के साथ रेस्तरां के लिए 4-स्टार रेटिंग बहुत अधिक विश्वसनीय है (रेस्तरां है) इस मामले में अच्छी संभावना है)। हम देख सकते हैं कि एक रेस्तरां की समीक्षाओं की संख्या प्रभावित करती है कि हम इसकी औसत रेटिंग में कितना भरोसा करते हैं।

हम मॉडल को सूचित करने के लिए टीएफएल ट्रस्ट बाधाओं का उपयोग कर सकते हैं कि एक सुविधा का बड़ा (या छोटा) मूल्य अधिक निर्भरता या किसी अन्य सुविधा के भरोसे को इंगित करता है। इस सेटिंग के द्वारा किया जाता है reflects_trust_in सुविधा config में विन्यास।

feature_columns = [
    tf.feature_column.numeric_column("num_reviews"),
    tf.feature_column.numeric_column("avg_rating"),
]
model_config = tfl.configs.CalibratedLatticeConfig(
    feature_configs=[
        tfl.configs.FeatureConfig(
            name="num_reviews",
            lattice_size=2,
            monotonicity="increasing",
            pwl_calibration_convexity="concave",
            pwl_calibration_num_keypoints=20,
            # Larger num_reviews indicating more trust in avg_rating.
            reflects_trust_in=[
                tfl.configs.TrustConfig(
                    feature_name="avg_rating", trust_type="edgeworth"),
            ],
        ),
        tfl.configs.FeatureConfig(
            name="avg_rating",
            lattice_size=2,
            monotonicity="increasing",
            pwl_calibration_num_keypoints=20,
        )
    ])
tfl_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=LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42),
)
tfl_estimator.train(input_fn=train_input_fn)
analyze_two_d_estimator(tfl_estimator, "TF Lattice")
model_graph = save_and_visualize_lattice(tfl_estimator)
Validation AUC: 0.6409633755683899
Testing AUC: 0.7891043424606323

पींग

पींग

निम्नलिखित कथानक प्रशिक्षित जाली कार्य प्रस्तुत करता है। विश्वास बाधा के कारण, हम उम्मीद करते हैं कि कैलिब्रेटेड के बड़े मान num_reviews कैलिब्रेटेड के संबंध में उच्च ढलान मजबूर होना पड़ा avg_rating , जाली उत्पादन में और अधिक महत्वपूर्ण कदम हो जाती है।

lat_mesh_n = 12
lat_mesh_x, lat_mesh_y = tfl.test_utils.two_dim_mesh_grid(
    lat_mesh_n**2, 0, 0, 1, 1)
lat_mesh_fn = tfl.test_utils.get_hypercube_interpolation_fn(
    model_graph.output_node.weights.flatten())
lat_mesh_z = [
    lat_mesh_fn([lat_mesh_x.flatten()[i],
                 lat_mesh_y.flatten()[i]]) for i in range(lat_mesh_n**2)
]
trust_plt = tfl.visualization.plot_outputs(
    (lat_mesh_x, lat_mesh_y),
    {"Lattice Lookup": lat_mesh_z},
    figsize=(6, 6),
)
trust_plt.title("Trust")
trust_plt.xlabel("Calibrated avg_rating")
trust_plt.ylabel("Calibrated num_reviews")
trust_plt.show()

पींग

चिकनाई करने वाले अंशशोधक

चलो अब avg_rating के अंशशोधक पर एक नज़र avg_rating । यद्यपि यह एकात्मक रूप से बढ़ रहा है, इसकी ढलानों में परिवर्तन अचानक और व्याख्या के लिए कठिन हैं। यही कारण है कि पता चलता है कि हम इस अंशशोधक में एक regularizer सेटअप का उपयोग चौरसाई विचार करना चाह सकते regularizer_configs

यहां हम वक्रता में परिवर्तन को कम करने के लिए एक wrinkle नियमितता लागू करते हैं। आप कैलिब्रेटर और hessian laplacian को अधिक रैखिक बनाने के लिए laplacian रेग्युलर का उपयोग कर सकते हैं।

feature_columns = [
    tf.feature_column.numeric_column("num_reviews"),
    tf.feature_column.numeric_column("avg_rating"),
]
model_config = tfl.configs.CalibratedLatticeConfig(
    feature_configs=[
        tfl.configs.FeatureConfig(
            name="num_reviews",
            lattice_size=2,
            monotonicity="increasing",
            pwl_calibration_convexity="concave",
            pwl_calibration_num_keypoints=20,
            regularizer_configs=[
                tfl.configs.RegularizerConfig(name="calib_wrinkle", l2=1.0),
            ],
            reflects_trust_in=[
                tfl.configs.TrustConfig(
                    feature_name="avg_rating", trust_type="edgeworth"),
            ],
        ),
        tfl.configs.FeatureConfig(
            name="avg_rating",
            lattice_size=2,
            monotonicity="increasing",
            pwl_calibration_num_keypoints=20,
            regularizer_configs=[
                tfl.configs.RegularizerConfig(name="calib_wrinkle", l2=1.0),
            ],
        )
    ])
tfl_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=LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42),
)
tfl_estimator.train(input_fn=train_input_fn)
analyze_two_d_estimator(tfl_estimator, "TF Lattice")
_ = save_and_visualize_lattice(tfl_estimator)
Validation AUC: 0.6465646028518677
Testing AUC: 0.7948372960090637

पींग

पींग

अंशांकन अब सुचारू हैं, और समग्र अनुमानित सीटीआर बेहतर जमीनी सच्चाई से मेल खाता है। यह परीक्षण मीट्रिक और समोच्च भूखंडों दोनों में परिलक्षित होता है।

श्रेणीबद्ध अंशांकन के लिए आंशिक एकरसता

अब तक हम मॉडल में केवल दो संख्यात्मक विशेषताओं का उपयोग कर रहे हैं। यहां हम एक श्रेणीगत अंशांकन परत का उपयोग करके एक तीसरी विशेषता जोड़ेंगे। फिर से हम प्लॉटिंग और मीट्रिक गणना के लिए सहायक कार्यों को स्थापित करके शुरू करते हैं।

def analyze_three_d_estimator(estimator, name):
  # Extract validation metrics.
  metric = estimator.evaluate(input_fn=val_input_fn)
  print("Validation AUC: {}".format(metric["auc"]))
  metric = estimator.evaluate(input_fn=test_input_fn)
  print("Testing AUC: {}".format(metric["auc"]))

  def three_d_pred(avg_ratings, num_reviews, dollar_rating):
    results = estimator.predict(
        tf.compat.v1.estimator.inputs.pandas_input_fn(
            x=pd.DataFrame({
                "avg_rating": avg_ratings,
                "num_reviews": num_reviews,
                "dollar_rating": dollar_rating,
            }),
            shuffle=False,
        ))
    return [x["logistic"][0] for x in results]

  figsize(11, 22)
  plot_fns([("{} Estimated CTR".format(name), three_d_pred),
            ("CTR", click_through_rate)],
           split_by_dollar=True)

तीसरी विशेषता, dollar_rating को शामिल करने के लिए, हमें यह याद रखना चाहिए कि स्पष्ट विशेषताओं को टीएफएल में एक अलग कॉलम और फीचर dollar_rating रूप में थोड़ा अलग उपचार की आवश्यकता होती है। यहां हम आंशिक मोनोटोनिकिटी बाधा को लागू करते हैं जो "डीडी" रेस्तरां के लिए आउटपुट "डी" रेस्तरां से बड़ा होना चाहिए जब अन्य सभी इनपुट तय हो जाते हैं। यह सुविधा कॉन्फिग में monotonicity सेटिंग का उपयोग करके किया जाता है।

feature_columns = [
    tf.feature_column.numeric_column("num_reviews"),
    tf.feature_column.numeric_column("avg_rating"),
    tf.feature_column.categorical_column_with_vocabulary_list(
        "dollar_rating",
        vocabulary_list=["D", "DD", "DDD", "DDDD"],
        dtype=tf.string,
        default_value=0),
]
model_config = tfl.configs.CalibratedLatticeConfig(
    feature_configs=[
        tfl.configs.FeatureConfig(
            name="num_reviews",
            lattice_size=2,
            monotonicity="increasing",
            pwl_calibration_convexity="concave",
            pwl_calibration_num_keypoints=20,
            regularizer_configs=[
                tfl.configs.RegularizerConfig(name="calib_wrinkle", l2=1.0),
            ],
            reflects_trust_in=[
                tfl.configs.TrustConfig(
                    feature_name="avg_rating", trust_type="edgeworth"),
            ],
        ),
        tfl.configs.FeatureConfig(
            name="avg_rating",
            lattice_size=2,
            monotonicity="increasing",
            pwl_calibration_num_keypoints=20,
            regularizer_configs=[
                tfl.configs.RegularizerConfig(name="calib_wrinkle", l2=1.0),
            ],
        ),
        tfl.configs.FeatureConfig(
            name="dollar_rating",
            lattice_size=2,
            pwl_calibration_num_keypoints=4,
            # Here we only specify one monotonicity:
            # `D` resturants has smaller value than `DD` restaurants
            monotonicity=[("D", "DD")],
        ),
    ])
tfl_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=LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42),
)
tfl_estimator.train(input_fn=train_input_fn)
analyze_three_d_estimator(tfl_estimator, "TF Lattice")
_ = save_and_visualize_lattice(tfl_estimator)
Validation AUC: 0.7699775695800781
Testing AUC: 0.8594040274620056

पींग

पींग

यह श्रेणीबद्ध अंशांकन मॉडल आउटपुट की वरीयता दर्शाता है: DD> D> DDD> DDDD, जो हमारे सेटअप के अनुरूप है। ध्यान दें कि लापता मानों के लिए एक कॉलम भी है। हालांकि हमारे प्रशिक्षण और परीक्षण डेटा में कोई अनुपलब्ध विशेषता नहीं है, लेकिन मॉडल हमें उस अनुपलब्ध मूल्य के लिए प्रदान करता है जो डाउनस्ट्रीम मॉडल सेवारत के दौरान होना चाहिए।

यहां हम इस मॉडल की अनुमानित CTR को भी dollar_rating आधार पर dollar_rating । ध्यान दें कि हमारे द्वारा आवश्यक सभी बाधाओं को प्रत्येक स्लाइस में पूरा किया गया है।

आउटपुट अंशांकन

अब तक हमने जिन सभी टीएफएल मॉडलों को प्रशिक्षित किया है, उनके लिए जाली परत (मॉडल ग्राफ में "जाली" के रूप में इंगित की गई है) सीधे मॉडल भविष्यवाणी का उत्पादन करती है। कभी-कभी हमें यकीन नहीं होता है कि जाली आउटपुट को आउटपुट आउटपुट के लिए रीकॉल किया जाना चाहिए:

  • सुविधाएँ $ लॉग $ काउंट हैं जबकि लेबल मायने रखता है।
  • जाली को बहुत कम कोणों के लिए कॉन्फ़िगर किया गया है लेकिन लेबल वितरण अपेक्षाकृत जटिल है।

उन मामलों में हम मॉडल लचीलापन बढ़ाने के लिए जाली आउटपुट और मॉडल आउटपुट के बीच एक और अंशशोधक जोड़ सकते हैं। यहाँ हम अभी बनाए गए मॉडल में 5 कीपॉइंट्स के साथ एक अंशांकन परत जोड़ते हैं। हम फ़ंक्शन को सुचारू रखने के लिए आउटपुट कैलिब्रेटर के लिए एक नियमित रूप से जोड़ते हैं।

feature_columns = [
    tf.feature_column.numeric_column("num_reviews"),
    tf.feature_column.numeric_column("avg_rating"),
    tf.feature_column.categorical_column_with_vocabulary_list(
        "dollar_rating",
        vocabulary_list=["D", "DD", "DDD", "DDDD"],
        dtype=tf.string,
        default_value=0),
]
model_config = tfl.configs.CalibratedLatticeConfig(
    output_calibration=True,
    output_calibration_num_keypoints=5,
    regularizer_configs=[
        tfl.configs.RegularizerConfig(name="output_calib_wrinkle", l2=0.1),
    ],
    feature_configs=[
    tfl.configs.FeatureConfig(
        name="num_reviews",
        lattice_size=2,
        monotonicity="increasing",
        pwl_calibration_convexity="concave",
        pwl_calibration_num_keypoints=20,
        regularizer_configs=[
            tfl.configs.RegularizerConfig(name="calib_wrinkle", l2=1.0),
        ],
        reflects_trust_in=[
            tfl.configs.TrustConfig(
                feature_name="avg_rating", trust_type="edgeworth"),
        ],
    ),
    tfl.configs.FeatureConfig(
        name="avg_rating",
        lattice_size=2,
        monotonicity="increasing",
        pwl_calibration_num_keypoints=20,
        regularizer_configs=[
            tfl.configs.RegularizerConfig(name="calib_wrinkle", l2=1.0),
        ],
    ),
    tfl.configs.FeatureConfig(
        name="dollar_rating",
        lattice_size=2,
        pwl_calibration_num_keypoints=4,
        # Here we only specify one monotonicity:
        # `D` resturants has smaller value than `DD` restaurants
        monotonicity=[("D", "DD")],
    ),
])
tfl_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=LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42),
)
tfl_estimator.train(input_fn=train_input_fn)
analyze_three_d_estimator(tfl_estimator, "TF Lattice")
_ = save_and_visualize_lattice(tfl_estimator)
Validation AUC: 0.7697908878326416
Testing AUC: 0.861327052116394

पींग

पींग

अंतिम परीक्षण मीट्रिक और प्लॉट दिखाते हैं कि सामान्य-बोध बाधाओं का उपयोग करके मॉडल को अनपेक्षित व्यवहार से बचने और पूरे इनपुट स्थान पर बेहतर रूप से एक्सट्रपलेट करने में मदद मिल सकती है।