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

টেনসরফ্লো ল্যাটিসের সাথে আকারের সীমাবদ্ধতা

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

ওভারভিউ

এই টিউটোরিয়ালটি টেনসরফ্লো ল্যাটিস (টিএফএল) লাইব্রেরি দ্বারা সরবরাহিত প্রতিবন্ধকতা এবং নিয়ামকগুলির একটি ওভারভিউ। এখানে আমরা সিন্থেটিক ডেটাসেটগুলিতে টিএফএল ক্যান অনুমানক ব্যবহার করি তবে নোট করুন যে এই টিউটোরিয়ালের সমস্ত কিছুই টিএফএল কেরাস স্তরগুলি থেকে নির্মিত মডেলগুলির সাহায্যেও করা যেতে পারে।

এগিয়ে যাওয়ার আগে, আপনার রানটাইমটিতে সমস্ত প্রয়োজনীয় প্যাকেজ ইনস্টল করা আছে তা নিশ্চিত করুন (নীচের কোড সেলগুলিতে আমদানি করা হয়েছে)।

সেটআপ

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

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 = 500
BATCH_SIZE = 64
LEARNING_RATE=0.001

র‌্যাঙ্কিংয়ের রেস্তোঁরাগুলির জন্য ডেটাসেট প্রশিক্ষণ

সরলিকৃত দৃশ্যের কল্পনা করুন যেখানে ব্যবহারকারীরা রেস্তোঁরা অনুসন্ধানের ফলাফলটিতে ক্লিক করবেন কিনা তা আমরা নির্ধারণ করতে চাই। কাজটি হল ক্লিকথ্রু হার (সিটিআর) প্রদত্ত ইনপুট বৈশিষ্ট্যগুলির পূর্বাভাস দেওয়া:

  • গড় রেটিং ( avg_rating ): পরিসীমা [1,5] এ মান সঙ্গে একটি সাংখ্যিক বৈশিষ্ট্য।
  • পর্যালোচনার সংখ্যা ( num_reviews ): 200 এর সাথে ক্যাপ করা মান সহ একটি সংখ্যাসূচক বৈশিষ্ট্য, যা আমরা প্রবণতার পরিমাপ হিসাবে ব্যবহার করি।
  • ডলার রেটিং ( dollar_rating ): {"ডি", "ডিডি", "ডিডিডি", "ডিডিডিডি" set সেটে স্ট্রিং মান সহ একটি শ্রেণীবদ্ধ বৈশিষ্ট্য}

এখানে আমরা একটি সিনথেটিক ডেটাसेट তৈরি করি যেখানে সূত্রের দ্বারা সত্য সিটিআর দেওয়া হয়:

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

যেখানে $ বি (\ dollar_rating ) dollar_rating প্রতিটি dollar_rating একটি বেসলাইন dollar_rating অনুবাদ করে:

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

এই সূত্রটি সাধারণ ব্যবহারকারীর নিদর্শনগুলি প্রতিফলিত করে। উদাহরণস্বরূপ, অন্য সমস্ত কিছু স্থির করে দেওয়া, ব্যবহারকারীরা উচ্চতর স্টার রেটিং সহ রেস্তোঁরাগুলি পছন্দ করেন এবং "\ $ \ $" রেস্তোঁরাগুলি "\ $" এর চেয়ে বেশি ক্লিক পাবেন, তারপরে "\ $ \ $ \ $" এবং "\ $ \ $ \ by । $ "।

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

পিএনজি

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

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

যখন মডেলটি র‌্যাঙ্কিংয়ের জন্য ব্যবহৃত হয়, তখন প্রায়শই এটি সম্পর্কিত সমস্ত ফলাফলের উপর আরও ইউনিফর্ম বিতরণ দিয়ে মূল্যায়ন করা হয় যা প্রশিক্ষণ ডেটাসেট দ্বারা ভালভাবে উপস্থাপিত হয় না। একটি নমনীয় এবং জটিল মডেল অত্যধিক-উপস্থাপিত ডেটা পয়েন্টগুলিকে অতিরিক্ত ফিট করার কারণে এক্ষেত্রে ব্যর্থ হতে পারে এবং এর ফলে সাধারণীকরণের অভাব হয়। আমরা এই সমস্যাটি হ'ল ডোমেন জ্ঞানকে আকারের সীমাবদ্ধতাগুলি যুক্ত করতে যা মডেলটিকে প্রশিক্ষণ ডেটাसेट থেকে বাছাই করতে না পারলে যুক্তিসঙ্গত পূর্বাভাস দেয় guide

এই উদাহরণে, প্রশিক্ষণ ডেটাসেট বেশিরভাগ ক্ষেত্রেই ভাল এবং জনপ্রিয় রেস্তোঁরাগুলির সাথে ব্যবহারকারীর ইন্টারঅ্যাকশন ধারণ করে। উপরে বর্ণিত মূল্যায়ন সেটিং অনুকরণের জন্য টেস্টিং ডেটাসেটের অভিন্ন বিতরণ রয়েছে। নোট করুন যে এই জাতীয় টেস্টিং ডেটাসেট একটি আসল সমস্যা সেটিংসে উপলব্ধ হবে না।

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(2000, testing_set=False)
data_val = sample_dataset(1000, testing_set=False)
data_test = sample_dataset(1000, 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)

পিএনজি

প্রশিক্ষণ এবং মূল্যায়নের জন্য ব্যবহৃত ইনপুট_ফ্যান্স সংজ্ঞায়িত:

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)

আমরা ডেটাসেটে টেনসরফ্লো গ্রেডিয়েন্ট বুস্টড ডিসিশন ট্রি ফিট করতে পারি:

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=3,
    n_trees=20,
    min_node_weight=0.1,
    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.7248634099960327
Testing AUC: 0.6980501413345337

পিএনজি

যদিও মডেলটি সত্যিকারের সিটিআরের সাধারণ আকার ধারণ করেছে এবং শালীন বৈধতা মেট্রিক্স রয়েছে তবে এর ইনপুট স্পেসের বেশ কয়েকটি অংশে প্রতি-স্বজ্ঞাত আচরণ রয়েছে: গড় রেটিং বা পর্যালোচনার সংখ্যা বাড়ার সাথে সাথে আনুমানিক সিটিআর হ্রাস পায়। প্রশিক্ষণ ডেটাসেটের আচ্ছাদন নয় এমন অঞ্চলে নমুনা পয়েন্টের অভাবের কারণে এটি ঘটে। কেবলমাত্র ডেটা থেকে সঠিক আচরণটি হ্রাস করার কোনও উপায় নেই মডেলের।

এই সমস্যাটি সমাধান করার জন্য, আমরা সেই আকারের সীমাবদ্ধতাটি প্রয়োগ করি যে গড় রেটিং এবং পর্যালোচনার সংখ্যা উভয়কেই মডেলকে একচেটিয়াভাবে মান বাড়িয়ে তুলতে হবে। টিএফএলে কীভাবে এটি বাস্তবায়ন করা যায় তা আমরা পরে দেখব।

একটি ডিএনএন ফিট করা

আমরা ডিএনএন শ্রেণিবদ্ধের সাথে একই পদক্ষেপগুলি পুনরাবৃত্তি করতে পারি। আমরা অনুরূপ প্যাটার্নটি পর্যবেক্ষণ করতে পারি: অল্প সংখ্যক পর্যালোচনার সাথে পর্যাপ্ত নমুনা পয়েন্ট না থাকায় অযৌক্তিক এক্সট্রোপোলেশন হয়। মনে রাখবেন যে গাছের সমাধানের চেয়ে বৈধতা মেট্রিক আরও ভাল, পরীক্ষার মেট্রিকটি আরও খারাপ।

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.7518489956855774
Testing AUC: 0.745200514793396

পিএনজি

আকার সীমাবদ্ধতা

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

এই টিউটোরিয়ালে আমরা বিভিন্ন আকারের সীমাবদ্ধতাগুলি কাভার করতে টিএফ ক্যানড অনুমানক ব্যবহার করি তবে নোট করুন যে এই সমস্ত পদক্ষেপগুলি টিএফএল কেরাস স্তরগুলি থেকে তৈরি মডেলগুলির সাহায্যে করা যেতে পারে।

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

  • একটি মডেল কনফিগারেশন : মডেল আর্কিটেকচার এবং প্রতি-বৈশিষ্ট্য আকৃতির সীমাবদ্ধতা এবং নিয়ামককে সংজ্ঞায়িত করে।
  • একটি বৈশিষ্ট্য বিশ্লেষণ ইনপুট_ফএন : টিএফএল সূচনার জন্য একটি টিএফ ইনপুট_ফএন পাস করার ডেটা।

আরও পুঙ্খানুপুঙ্খ বিবরণের জন্য দয়া করে ক্যানড অনুমানকারী টিউটোরিয়াল বা এপিআই ডক্স পড়ুন।

একঘেয়েমি

আমরা প্রথমে উভয় বৈশিষ্ট্যে একঘেয়েতা আকৃতির সীমাবদ্ধতা যুক্ত করে একঘেয়েমি সম্পর্কিত উদ্বেগগুলির সমাধান করি।

আকৃতির সীমাবদ্ধতাগুলি প্রয়োগ করতে টিএফএলকে নির্দেশ দেওয়ার জন্য, আমরা বৈশিষ্ট্যটির কনফিগারেশনে সীমাবদ্ধতাগুলি নির্দিষ্ট করি। নীচের কোডটি দেখায় যে কীভাবে আমরা আউটপুটটিকে একঘেয়েভাবে বৃদ্ধি করতে উভয় num_reviews সাথে num_reviews avg_rating num_reviews এবং 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.740505039691925
Testing AUC: 0.7356159687042236

পিএনজি

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)

পিএনজি

প্রতিবন্ধকতা যুক্ত হওয়ার সাথে সাথে গড় রেটিং বৃদ্ধি বা পর্যালোচনার সংখ্যা বৃদ্ধি পাওয়ায় আনুমানিক সিটিআর সর্বদা বৃদ্ধি পাবে। ক্যালিব্রেটার এবং জালগুলি একঘেয়ে আছে কিনা তা নিশ্চিত করে এটি করা হয়।

আয় কমা

রিটার্ন হ্রাস করার অর্থ হ'ল আমরা মূল্য বাড়ানোর সাথে সাথে একটি নির্দিষ্ট বৈশিষ্ট্য মান বাড়ানোর প্রান্তিক লাভ হ্রাস পাবে। আমাদের ক্ষেত্রে আমরা প্রত্যাশা করি যে 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.7382562756538391
Testing AUC: 0.7399928569793701

পিএনজি

পিএনজি

লক্ষ্য করুন কীভাবে পরীক্ষার মেট্রিক গতিবন্ধন সীমাবদ্ধতা যোগ করে উন্নতি করে। ভবিষ্যদ্বাণী করা প্লটটি আরও ভাল স্থল সত্যের সাথে সাদৃশ্যপূর্ণ।

2 ডি শেপ সীমাবদ্ধতা: বিশ্বাস

মাত্র এক বা দু'টি পর্যালোচনা সহ একটি রেস্তোরাঁর জন্য 5-তারকা রেটিং সম্ভবত অবিশ্বাস্য রেটিং (রেস্তোঁরাটি সম্ভবত আসলে ভাল নাও হতে পারে), যেখানে কয়েকশ পর্যালোচনা সহ একটি রেস্তোঁরাটির জন্য একটি 4-তারা রেটিং অনেক বেশি নির্ভরযোগ্য (রেস্তোঁরাটি এই ক্ষেত্রে সম্ভবত ভাল)। আমরা দেখতে পাচ্ছি যে রেস্তোঁরাটির পর্যালোচনার সংখ্যাটি এর গড় রেটিংয়ে আমরা কতটা বিশ্বাস রেখেছি তা প্রভাবিত করে।

আমরা মডেলটিকে জানাতে টিএফএল বিশ্বাসের সীমাবদ্ধতাগুলি প্রয়োগ করতে পারি যে একটি বৈশিষ্ট্যের বৃহত্তর (বা ছোট) মানটি অন্য বৈশিষ্ট্যের আরও নির্ভরতা বা বিশ্বাসকে নির্দেশ করে। এটি বৈশিষ্ট্য কনফিগারেশনে reflects_trust_in কনফিগারেশন সেট reflects_trust_in সম্পন্ন করা হয়।

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.7382063269615173
Testing AUC: 0.73994380235672

পিএনজি

পিএনজি

নিম্নলিখিত প্লট প্রশিক্ষিত জাল ফাংশন উপস্থাপন করে। বিশ্বাসের প্রতিবন্ধকতার কারণে, আমরা প্রত্যাশা করি যে num_reviews বৃহত্তর মানগুলি num_reviews প্রতি সম্মানের সাথে উচ্চতর 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 । যদিও এটি একঘেয়েভাবে বাড়ছে, এর opালু পরিবর্তনগুলি হঠাৎ হঠাৎ এবং ব্যাখ্যা করা শক্ত। যে প্রস্তাব দেওয়া আমরা এই ক্যালিব্রেটর একটি 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.7512326836585999
Testing AUC: 0.754392147064209

পিএনজি

পিএনজি

ক্যালিব্রেটারগুলি এখন মসৃণ, এবং সামগ্রিকভাবে অনুমান করা সিটিআর আরও ভাল স্থল সত্যের সাথে মেলে। এটি টেস্টিং মেট্রিক এবং কনট্যুর প্লটে উভয়ই প্রতিফলিত হয়।

শ্রেণিবদ্ধ ক্যালিব্রেশন জন্য আংশিক একঘেয়েমি

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

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 সাথে জড়িত হওয়ার জন্য আমাদের স্মরণ করা উচিত যে শ্রেণিবদ্ধ বৈশিষ্ট্যগুলির জন্য টিএফএল-তে কিছু বৈশিষ্ট্য কলাম এবং বৈশিষ্ট্য কনফিগার হিসাবে কিছুটা আলাদা চিকিত্সা প্রয়োজন require এখানে আমরা আংশিক একঘেয়েমি বাধা প্রয়োগ করি যে "ডিডি" রেস্তোঁরাগুলির আউটপুটগুলি "ডি" রেস্তোঁরাগুলির চেয়ে বড় হওয়া উচিত যখন অন্য সমস্ত ইনপুট স্থির হয়। এটি বৈশিষ্ট্য কনফিগারেশনে 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.8137159943580627
Testing AUC: 0.8294374942779541

পিএনজি

পিএনজি

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

এখানে আমরা 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.8130996227264404
Testing AUC: 0.8300802707672119

পিএনজি

পিএনজি

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