এমএল কমিউনিটি দিবস 9 নভেম্বর! TensorFlow, Jax থেকে আপডেটের জন্য আমাদের সাথে যোগ দিন, এবং আরও আরও জানুন

টিএফপি সম্ভাব্য স্তর: প্রত্যাবর্তন

TensorFlow.org এ দেখুন GitHub এ উৎস দেখুন নোটবুক ডাউনলোড করুন

এই উদাহরণে আমরা দেখাব কিভাবে TFP- এর "সম্ভাব্য স্তরগুলি" ব্যবহার করে রিগ্রেশন মডেলগুলি ফিট করা যায়।

নির্ভরতা এবং পূর্বশর্ত

আমদানি

জিনিসগুলি দ্রুত করুন!

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

এটি করার জন্য, "রানটাইম" -> "রানটাইম টাইপ পরিবর্তন করুন" -> "হার্ডওয়্যার এক্সিলারেটর" -> "জিপিইউ" নির্বাচন করুন।

নিম্নলিখিত স্নিপেট যাচাই করবে যে আমাদের GPU- এ অ্যাক্সেস আছে।

if tf.test.gpu_device_name() != '/device:GPU:0':
  print('WARNING: GPU device not found.')
else:
  print('SUCCESS: Found GPU: {}'.format(tf.test.gpu_device_name()))
WARNING: GPU device not found.

প্রেরণা

এটা কি খুব ভালো হবে না যদি আমরা একটি সম্ভাব্য মডেল নির্দিষ্ট করতে TFP ব্যবহার করতে পারি তাহলে কেবল নেতিবাচক লগ-সম্ভাবনাকে কমিয়ে আনা যায়, অর্থাৎ,

negloglik = lambda y, rv_y: -rv_y.log_prob(y)

আচ্ছা এটা শুধু সম্ভব নয়, এই কোলাব দেখায় কিভাবে! (লিনিয়ার রিগ্রেশন সমস্যার প্রেক্ষিতে।)

ডেটাসেট সংশ্লেষ করুন।

কেস 1: কোন অনিশ্চয়তা নেই

# Build model.
model = tf.keras.Sequential([
  tf.keras.layers.Dense(1),
  tfp.layers.DistributionLambda(lambda t: tfd.Normal(loc=t, scale=1)),
])

# Do inference.
model.compile(optimizer=tf.optimizers.Adam(learning_rate=0.01), loss=negloglik)
model.fit(x, y, epochs=1000, verbose=False);

# Profit.
[print(np.squeeze(w.numpy())) for w in model.weights];
yhat = model(x_tst)
assert isinstance(yhat, tfd.Distribution)
0.13032457
5.13029

চিত্র 1: কোন অনিশ্চয়তা নেই।

png

কেস 2: অ্যালিয়েটারিক অনিশ্চয়তা

# Build model.
model = tf.keras.Sequential([
  tf.keras.layers.Dense(1 + 1),
  tfp.layers.DistributionLambda(
      lambda t: tfd.Normal(loc=t[..., :1],
                           scale=1e-3 + tf.math.softplus(0.05 * t[...,1:]))),
])

# Do inference.
model.compile(optimizer=tf.optimizers.Adam(learning_rate=0.01), loss=negloglik)
model.fit(x, y, epochs=1000, verbose=False);

# Profit.
[print(np.squeeze(w.numpy())) for w in model.weights];
yhat = model(x_tst)
assert isinstance(yhat, tfd.Distribution)
[0.14738432 0.1815331 ]
[4.4812164 1.2219843]

চিত্র 2: Aleatoric অনিশ্চয়তা

png

কেস 3: মহামারী অনিশ্চয়তা

# Specify the surrogate posterior over `keras.layers.Dense` `kernel` and `bias`.
def posterior_mean_field(kernel_size, bias_size=0, dtype=None):
  n = kernel_size + bias_size
  c = np.log(np.expm1(1.))
  return tf.keras.Sequential([
      tfp.layers.VariableLayer(2 * n, dtype=dtype),
      tfp.layers.DistributionLambda(lambda t: tfd.Independent(
          tfd.Normal(loc=t[..., :n],
                     scale=1e-5 + tf.nn.softplus(c + t[..., n:])),
          reinterpreted_batch_ndims=1)),
  ])
# Specify the prior over `keras.layers.Dense` `kernel` and `bias`.
def prior_trainable(kernel_size, bias_size=0, dtype=None):
  n = kernel_size + bias_size
  return tf.keras.Sequential([
      tfp.layers.VariableLayer(n, dtype=dtype),
      tfp.layers.DistributionLambda(lambda t: tfd.Independent(
          tfd.Normal(loc=t, scale=1),
          reinterpreted_batch_ndims=1)),
  ])
# Build model.
model = tf.keras.Sequential([
  tfp.layers.DenseVariational(1, posterior_mean_field, prior_trainable, kl_weight=1/x.shape[0]),
  tfp.layers.DistributionLambda(lambda t: tfd.Normal(loc=t, scale=1)),
])

# Do inference.
model.compile(optimizer=tf.optimizers.Adam(learning_rate=0.01), loss=negloglik)
model.fit(x, y, epochs=1000, verbose=False);

# Profit.
[print(np.squeeze(w.numpy())) for w in model.weights];
yhat = model(x_tst)
assert isinstance(yhat, tfd.Distribution)
[ 0.1387333  5.125723  -4.112224  -2.2171402]
[0.12476114 5.147452  ]

চিত্র 3: এপিস্টেমিক অনিশ্চয়তা

png

কেস 4: অ্যালোটিক এবং এপিস্টেমিক অনিশ্চয়তা

# Build model.
model = tf.keras.Sequential([
  tfp.layers.DenseVariational(1 + 1, posterior_mean_field, prior_trainable, kl_weight=1/x.shape[0]),
  tfp.layers.DistributionLambda(
      lambda t: tfd.Normal(loc=t[..., :1],
                           scale=1e-3 + tf.math.softplus(0.01 * t[...,1:]))),
])

# Do inference.
model.compile(optimizer=tf.optimizers.Adam(learning_rate=0.01), loss=negloglik)
model.fit(x, y, epochs=1000, verbose=False);

# Profit.
[print(np.squeeze(w.numpy())) for w in model.weights];
yhat = model(x_tst)
assert isinstance(yhat, tfd.Distribution)
[ 0.12753433  2.7504077   5.160624    3.8251898  -3.4283297  -0.8961645
 -2.2378397   0.1496858 ]
[0.14511648 2.7104297  5.1248145  3.7724588 ]

চিত্র 4: অ্যালিয়েট্রিক এবং এপিস্টেমিক অনিশ্চয়তা উভয়ই

png

কেস 5: কার্যকরী অনিশ্চয়তা

কাস্টম PSD কার্নেল

# For numeric stability, set the default floating-point dtype to float64
tf.keras.backend.set_floatx('float64')

# Build model.
num_inducing_points = 40
model = tf.keras.Sequential([
    tf.keras.layers.InputLayer(input_shape=[1]),
    tf.keras.layers.Dense(1, kernel_initializer='ones', use_bias=False),
    tfp.layers.VariationalGaussianProcess(
        num_inducing_points=num_inducing_points,
        kernel_provider=RBFKernelFn(),
        event_shape=[1],
        inducing_index_points_initializer=tf.constant_initializer(
            np.linspace(*x_range, num=num_inducing_points,
                        dtype=x.dtype)[..., np.newaxis]),
        unconstrained_observation_noise_variance_initializer=(
            tf.constant_initializer(np.array(0.54).astype(x.dtype))),
    ),
])

# Do inference.
batch_size = 32
loss = lambda y, rv_y: rv_y.variational_loss(
    y, kl_weight=np.array(batch_size, x.dtype) / x.shape[0])
model.compile(optimizer=tf.optimizers.Adam(learning_rate=0.01), loss=loss)
model.fit(x, y, batch_size=batch_size, epochs=1000, verbose=False)

# Profit.
yhat = model(x_tst)
assert isinstance(yhat, tfd.Distribution)

চিত্র 5: কার্যকরী অনিশ্চয়তা

png