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

TensorFlow বিতরণ: একটি মৃদু ভূমিকা

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

এই নোটবুকে, আমরা TensorFlow Distributions (সংক্ষেপে TFD) অন্বেষণ করব। এই নোটবুকের লক্ষ্য হল TFD- এর টেনসার শেপগুলি পরিচালনা করা বোঝা সহ আপনাকে শেখার বক্ররেখাকে আস্তে আস্তে নিয়ে যাওয়া। এই নোটবুক বিমূর্ত ধারণার পরিবর্তে আগে উদাহরণ উপস্থাপন করার চেষ্টা করে। আমরা প্রথমে জিনিসগুলি করার সহজ উপায়গুলি উপস্থাপন করব এবং শেষ পর্যন্ত সর্বাধিক সাধারণ বিমূর্ত দৃষ্টিভঙ্গি সংরক্ষণ করব। আপনি টাইপ এমন একজন বিমূর্ত এবং রেফারেন্স-শৈলী টিউটোরিয়াল পছন্দ হন, তাহলে খুঁজে বার করো বুঝুন TensorFlow ডিস্ট্রিবিউশন আকার । আপনি এখানে উপাদান সম্পর্কে কোনো প্রশ্ন থাকে, তাহলে সাথে যোগাযোগ বিব্রত বোধ করবেন না (অথবা যোগদানের) TensorFlow সম্ভাব্যতা মেইলিং লিস্ট । আমরা সাহায্য করতে পেরে খুশি।

আমরা শুরু করার আগে, আমাদের উপযুক্ত লাইব্রেরি আমদানি করতে হবে। আমাদের সার্বিক লাইব্রেরী tensorflow_probability । কনভেনশন দ্বারা, আমরা সাধারণভাবে ডিস্ট্রিবিউশন গ্রন্থাগার পড়ুন tfd

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

import collections

import tensorflow as tf
import tensorflow_probability as tfp
tfd = tfp.distributions

try:
  tf.compat.v1.enable_eager_execution()
except ValueError:
  pass

import matplotlib.pyplot as plt

বেসিক ইউনিভারিয়েট ডিস্ট্রিবিউশন

আসুন ডানদিকে ডুব দেই এবং একটি স্বাভাবিক বিতরণ তৈরি করি:

n = tfd.Normal(loc=0., scale=1.)
n
<tfp.distributions.Normal 'Normal' batch_shape=[] event_shape=[] dtype=float32>

আমরা এটি থেকে একটি নমুনা আঁকতে পারি:

n.sample()
<tf.Tensor: shape=(), dtype=float32, numpy=0.25322816>

আমরা একাধিক নমুনা আঁকতে পারি:

n.sample(3)
<tf.Tensor: shape=(3,), dtype=float32, numpy=array([-1.4658079, -0.5653636,  0.9314412], dtype=float32)>

আমরা একটি লগ সমস্যা মূল্যায়ন করতে পারি:

n.log_prob(0.)
<tf.Tensor: shape=(), dtype=float32, numpy=-0.9189385>

আমরা একাধিক লগ সম্ভাব্যতা মূল্যায়ন করতে পারি:

n.log_prob([0., 2., 4.])
<tf.Tensor: shape=(3,), dtype=float32, numpy=array([-0.9189385, -2.9189386, -8.918939 ], dtype=float32)>

আমাদের বিস্তৃত বিতরণ রয়েছে। আসুন একটি বার্নোলি চেষ্টা করি:

b = tfd.Bernoulli(probs=0.7)
b
<tfp.distributions.Bernoulli 'Bernoulli' batch_shape=[] event_shape=[] dtype=int32>
b.sample()
<tf.Tensor: shape=(), dtype=int32, numpy=1>
b.sample(8)
<tf.Tensor: shape=(8,), dtype=int32, numpy=array([1, 0, 0, 0, 1, 0, 1, 0], dtype=int32)>
b.log_prob(1)
<tf.Tensor: shape=(), dtype=float32, numpy=-0.35667497>
b.log_prob([1, 0, 1, 0])
<tf.Tensor: shape=(4,), dtype=float32, numpy=array([-0.35667497, -1.2039728 , -0.35667497, -1.2039728 ], dtype=float32)>

বহুবিধ বিতরণ

আমরা একটি তির্যক সহবাসের সাথে একটি বহুমুখী স্বাভাবিক তৈরি করব:

nd = tfd.MultivariateNormalDiag(loc=[0., 10.], scale_diag=[1., 4.])
nd
<tfp.distributions.MultivariateNormalDiag 'MultivariateNormalDiag' batch_shape=[] event_shape=[2] dtype=float32>

এটিকে আমরা আগে তৈরি করা অসামঞ্জস্যপূর্ণ স্বাভাবিকের সাথে তুলনা করছি, ভিন্ন কি?

tfd.Normal(loc=0., scale=1.)
<tfp.distributions.Normal 'Normal' batch_shape=[] event_shape=[] dtype=float32>

আমরা যে univariate স্বাভাবিক একটি হয়েছে দেখতে event_shape এর () , যা নির্দেশ এটি একটি স্কেলার বন্টন করে। বহুচলকীয় স্বাভাবিক একটি হয়েছে event_shape এর 2 , মৌলিক [ঘটনা স্থান] (https://en.wikipedia.org/wiki/Event_ (probability_theory)) এই বিতরণের নির্দেশ দ্বি-মাত্রিক হয়।

নমুনা ঠিক আগের মত কাজ করে:

nd.sample()
<tf.Tensor: shape=(2,), dtype=float32, numpy=array([-1.2489667, 15.025171 ], dtype=float32)>
nd.sample(5)
<tf.Tensor: shape=(5, 2), dtype=float32, numpy=
array([[-1.5439653 ,  8.9968405 ],
       [-0.38730723, 12.448896  ],
       [-0.8697963 ,  9.330035  ],
       [-1.2541095 , 10.268944  ],
       [ 2.3475595 , 13.184147  ]], dtype=float32)>
nd.log_prob([0., 10])
<tf.Tensor: shape=(), dtype=float32, numpy=-3.2241714>

মাল্টিভেরিয়েট নরমালের সাধারণভাবে তির্যক সহবাস নেই। টিএফডি মাল্টিভারিয়েট নরমাল তৈরির একাধিক উপায় অফার করে, যার মধ্যে রয়েছে পূর্ণ-সহবাস স্পেসিফিকেশন, যা আমরা এখানে ব্যবহার করি।

nd = tfd.MultivariateNormalFullCovariance(
    loc = [0., 5], covariance_matrix = [[1., .7], [.7, 1.]])
data = nd.sample(200)
plt.scatter(data[:, 0], data[:, 1], color='blue', alpha=0.4)
plt.axis([-5, 5, 0, 10])
plt.title("Data set")
plt.show()

png

একাধিক বিতরণ

আমাদের প্রথম Bernoulli বিতরণ একটি একক ন্যায্য মুদ্রা একটি উল্টো প্রতিনিধিত্ব। আমরা স্বাধীন বের্নুলির ডিস্ট্রিবিউশন একটি ব্যাচ তৈরি করতে পারেন, তাদের নিজস্ব পরামিতি সঙ্গে প্রতিটি, একটি একক মধ্যে Distribution বস্তু:

b3 = tfd.Bernoulli(probs=[.3, .5, .7])
b3
<tfp.distributions.Bernoulli 'Bernoulli' batch_shape=[3] event_shape=[] dtype=int32>

এর অর্থ কী তা স্পষ্ট হওয়া গুরুত্বপূর্ণ। উপরে কল তিনটি স্বাধীন বের্নুলির ডিস্ট্রিবিউশন, যা একই পাইথন অন্তর্ভুক্ত করা ঘটতে সংজ্ঞায়িত Distribution অবজেক্ট। তিনটি বিতরণ পৃথকভাবে ম্যানিপুলেট করা যাবে না। নোট কিভাবে batch_shape হয় (3,) , তিন ডিস্ট্রিবিউশন একটি ব্যাচ ইঙ্গিত, এবং event_shape হয় () , যা নির্দেশ পৃথক ডিস্ট্রিবিউশন একটি univariate ঘটনা স্থান আছে।

আমরা যদি কল sample , আমরা সব তিনটি থেকে একটি নমুনা পাবেন:

b3.sample()
<tf.Tensor: shape=(3,), dtype=int32, numpy=array([0, 1, 1], dtype=int32)>
b3.sample(6)
<tf.Tensor: shape=(6, 3), dtype=int32, numpy=
array([[1, 0, 1],
       [0, 1, 1],
       [0, 0, 1],
       [0, 0, 1],
       [0, 0, 1],
       [0, 1, 0]], dtype=int32)>

আমরা যদি কল prob , (এই হিসাবে একই আকৃতি শব্দার্থবিদ্যা হয়েছে log_prob ; আমরা ব্যবহার prob স্বচ্ছতার জন্য এই ছোট বের্নুলির উদাহরণ, যদিও log_prob সাধারণত অ্যাপ্লিকেশন অগ্রাধিকারপ্রাপ্ত) আমরা এটা একটি ভেক্টর পাস করতে পারেন এবং যে মান ফলনশীল প্রতিটি মুদ্রা সম্ভাবনা নির্ণয় :

b3.prob([1, 1, 0])
<tf.Tensor: shape=(3,), dtype=float32, numpy=array([0.29999998, 0.5       , 0.29999998], dtype=float32)>

কেন এপিআই ব্যাচ আকৃতি অন্তর্ভুক্ত করে? শব্দার্থিক ভাবে এক ডিস্ট্রিবিউশন একটি তালিকা তৈরি এবং তাদের উপর একটি সঙ্গে iterating একই কম্পিউটেশন সঞ্চালন পারে for (যদি আপনি প্রয়োজন চাই উৎসুক মোডে অন্তত মেমরি গ্রাফ মোডে, লুপ tf.while লুপ)। যাইহোক, অভিন্ন প্যারামিটারাইজড ডিস্ট্রিবিউশনের একটি (সম্ভাব্য বড়) সেট থাকা খুবই সাধারণ, এবং যখনই সম্ভব ভেক্টরাইজড গণনার ব্যবহার হার্ডওয়্যার এক্সিলারেটর ব্যবহার করে দ্রুত গণনা করতে সক্ষম হওয়ার মূল উপাদান।

ইভেন্টগুলিতে ব্যাচগুলিকে একত্রিত করার জন্য স্বাধীন ব্যবহার করা

পূর্ববর্তী বিভাগে, আমরা নির্মিত b3 , একটি একক Distribution যে প্রতিনিধিত্ব তিন মুদ্রা ফ্লিপ অবজেক্ট। আমরা যদি বলা b3.prob একটি ভেক্টর $ বনাম $ উপর, $ i এর $ 'ম এন্ট্রি সম্ভাব্যতা $ যে আমি ম মুদ্রা $ লাগে মান $ বনাম [আমি] $ ছিল।

ধরুন আমরা পরিবর্তে একই অন্তর্নিহিত পরিবার থেকে স্বাধীন র্যান্ডম ভেরিয়েবলের উপর একটি "যৌথ" বন্টন নির্দিষ্ট করতে চাই। এই বিভিন্ন বস্তুর গাণিতিকভাবে হয়, যে এই নতুন বিতরণের জন্য, prob একটি ভেক্টর $ বনাম $ উপর সম্ভাব্যতা যে কয়েন সমগ্র সেট সাথে মেলে ভেক্টর $ বনাম $ প্রতিনিধিত্বমূলক একটি একক মান ফিরে আসবে।

কিভাবে আমরা এই কাজ করা সম্ভব না? আমরা একটি "উচ্চ-অর্ডার" ডিস্ট্রিবিউশন নামক ব্যবহার Independent , যা একটি বন্টন নেয় এবং ব্যাচ আকৃতি ঘটনা আকৃতি সরানো সঙ্গে একটি নতুন বন্টন উৎপাদ:

b3_joint = tfd.Independent(b3, reinterpreted_batch_ndims=1)
b3_joint
<tfp.distributions.Independent 'IndependentBernoulli' batch_shape=[] event_shape=[3] dtype=int32>

মূল যে আকৃতি তুলনা b3 :

b3
<tfp.distributions.Bernoulli 'Bernoulli' batch_shape=[3] event_shape=[] dtype=int32>

প্রতিশ্রুত, আমরা দেখতে যে যে Independent ঘটনা আকৃতি মধ্যে ব্যাচ আকৃতি সরানো হয়েছে: b3_joint একটি একক বন্টন (হয় batch_shape = () ) একটি ত্রিমাত্রিক ঘটনা স্থান (ওভার event_shape = (3,) )।

আসুন শব্দার্থ পরীক্ষা করি:

b3_joint.prob([1, 1, 0])
<tf.Tensor: shape=(), dtype=float32, numpy=0.044999998>

একই ফলাফল পেতে একটি বিকল্প উপায় ব্যবহার কম্পিউট সম্ভাব্যতা হবে b3 এবং রিডাকশন (summing, বা আরো স্বাভাবিক ক্ষেত্রে যেখানে লগ সম্ভাব্যতা ব্যবহার করা হয় মধ্যে) গুন দ্বারা ম্যানুয়ালি করুন:

tf.reduce_prod(b3.prob([1, 1, 0]))
<tf.Tensor: shape=(), dtype=float32, numpy=0.044999994>

Indpendent ব্যবহারকারী আরো স্পষ্টভাবে আকাঙ্ক্ষিত ধারণা প্রতিনিধিত্ব করতে পারেন। আমরা এটিকে অত্যন্ত দরকারী হিসাবে দেখি, যদিও এটি কঠোরভাবে প্রয়োজনীয় নয়।

মজার ঘটনা:

  • b3.sample এবং b3_joint.sample স্বাধীন ডিস্ট্রিবিউশন একটি ব্যাচ এবং ব্যবহার ব্যাচ থেকে স্বয়ংক্রিয়ভাবে তৈরি একটি একক বন্টন মধ্যে পার্থক্য: বিভিন্ন ধারণাগত বাস্তবায়নের কিন্তু আলাদা করে চেনা আউটপুট আছে Independent শো আপ probabilites কম্পিউটিং না যখন স্যাম্পলিং যখন।
  • MultivariateNormalDiag জাভাস্ক্রিপ্টে গার্বেজ স্কালে ব্যবহার করে বাস্তবায়ন করা যেতে পারে Normal এবং Independent ডিস্ট্রিবিউশন (এটা আসলে এই ভাবে বাস্তবায়িত হয়নি, কিন্তু এটা হতে পারে)।

মাল্টিভারিয়েট ডিস্টার্বিউশনের ব্যাচ

আসুন তিনটি পূর্ণ-সহবাসের দ্বিমাত্রিক বহুমুখী স্বাভাবিকের একটি ব্যাচ তৈরি করি:

nd_batch = tfd.MultivariateNormalFullCovariance(
    loc = [[0., 0.], [1., 1.], [2., 2.]],
    covariance_matrix = [[[1., .1], [.1, 1.]], 
                         [[1., .3], [.3, 1.]],
                         [[1., .5], [.5, 1.]]])
nd_batch
<tfp.distributions.MultivariateNormalFullCovariance 'MultivariateNormalFullCovariance' batch_shape=[3] event_shape=[2] dtype=float32>

আমরা দেখি batch_shape = (3,) , তাই তিনটি স্বাধীন বহুচলকীয় লম্ব হয়, এবং event_shape = (2,) , তাই প্রতিটি বহুচলকীয় স্বাভাবিক দ্বি-মাত্রিক হয়। এই উদাহরণে, পৃথক বিতরণের স্বাধীন উপাদান নেই।

নমুনা কাজ:

nd_batch.sample(4)
<tf.Tensor: shape=(4, 3, 2), dtype=float32, numpy=
array([[[ 0.7367498 ,  2.730996  ],
        [-0.74080074, -0.36466932],
        [ 0.6516018 ,  0.9391426 ]],

       [[ 1.038303  ,  0.12231752],
        [-0.94788766, -1.204232  ],
        [ 4.059758  ,  3.035752  ]],

       [[ 0.56903946, -0.06875849],
        [-0.35127294,  0.5311631 ],
        [ 3.4635801 ,  4.565582  ]],

       [[-0.15989424, -0.25715637],
        [ 0.87479895,  0.97391707],
        [ 0.5211419 ,  2.32108   ]]], dtype=float32)>

যেহেতু batch_shape = (3,) এবং event_shape = (2,) , আমরা আকৃতি একটি টেন্সর পাস (3, 2) থেকে log_prob :

nd_batch.log_prob([[0., 0.], [1., 1.], [2., 2.]])
<tf.Tensor: shape=(3,), dtype=float32, numpy=array([-1.8328519, -1.7907217, -1.694036 ], dtype=float32)>

সম্প্রচার, ওরফে এটা এত বিভ্রান্তিকর কেন?

আমরা এতদূর কি করেছো আউট সংক্ষেপ, যে বন্টন একটি ব্যাচ আকৃতি আছে B এবং একটি ঘটনা আকৃতি E । দিন BE ঘটনা আকার সংযুক্তকরণের হতে:

  • Univariate স্কালে ডিস্ট্রিবিউশন n এবং b , BE = ().
  • দ্বি-মাত্রিক বহুচলকীয় লম্ব জন্য ndBE = (2).
  • উভয় জন্য b3 এবং b3_joint , BE = (3).
  • বহুচলকীয় লম্ব এর ব্যাচ জন্য ndb , BE = (3, 2).

আমরা এখন পর্যন্ত যে "মূল্যায়নের নিয়ম" ব্যবহার করছি তা হল:

  • কোন যুক্তি সহ নমুনা আকৃতি সঙ্গে একটি টেন্সর ফেরৎ BE ; স্কেলের এন আয় একটি "দ্বারা এন সঙ্গে স্যাম্পলিং BE " টেন্সর।
  • prob এবং log_prob আকৃতি একটি টেন্সর নেওয়া BE এবং আকৃতি ফলে আসতে B

জন্য প্রকৃত "মূল্যায়ন রুল" prob এবং log_prob আরো জটিল, একটি ভাবে অফার করে সম্ভাব্য ক্ষমতা এবং গতি কিন্তু জটিলতা ও চ্যালেঞ্জ। প্রকৃত শাসন (মূলত) যে যুক্তি log_prob হওয়া আবশ্যক broadcastable বিরুদ্ধে BE ; যে কোন "অতিরিক্ত" মাত্রা আউটপুটে সংরক্ষিত আছে।

আসুন এর প্রভাবগুলি অন্বেষণ করি। Univariate স্বাভাবিক জন্য n , BE = () , তাই log_prob স্কেলের প্রত্যাশা করে। আমরা পাস যদি log_prob খালি নয় এমন আকৃতি সঙ্গে একটি টেন্সর, ঐ আউটপুটে ব্যাচ মাত্রা হিসাবে দেখা:

n = tfd.Normal(loc=0., scale=1.)
n
<tfp.distributions.Normal 'Normal' batch_shape=[] event_shape=[] dtype=float32>
n.log_prob(0.)
<tf.Tensor: shape=(), dtype=float32, numpy=-0.9189385>
n.log_prob([0.])
<tf.Tensor: shape=(1,), dtype=float32, numpy=array([-0.9189385], dtype=float32)>
n.log_prob([[0., 1.], [-1., 2.]])
<tf.Tensor: shape=(2, 2), dtype=float32, numpy=
array([[-0.9189385, -1.4189385],
       [-1.4189385, -2.9189386]], dtype=float32)>

আসুন দ্বি-মাত্রিক বহুচলকীয় স্বাভাবিক পালা nd (পরামিতি অর্থবোধক উদ্দেশ্যে পরিবর্তন):

nd = tfd.MultivariateNormalDiag(loc=[0., 1.], scale_diag=[1., 1.])
nd
<tfp.distributions.MultivariateNormalDiag 'MultivariateNormalDiag' batch_shape=[] event_shape=[2] dtype=float32>

log_prob "আশা" আকৃতি সঙ্গে একটি আর্গুমেন্ট (2,) , কিন্তু এটা কোনো আর্গুমেন্ট গ্রহণ করবে এই আকৃতি বিরুদ্ধে সম্প্রচার:

nd.log_prob([0., 0.])
<tf.Tensor: shape=(), dtype=float32, numpy=-2.337877>

কিন্তু আমরা "আরো" উদাহরণ মধ্যে পাস করতে পারেন, এবং তাদের সব মূল্যায়নের log_prob 'একবারে S:

nd.log_prob([[0., 0.],
             [1., 1.],
             [2., 2.]])
<tf.Tensor: shape=(3,), dtype=float32, numpy=array([-2.337877 , -2.337877 , -4.3378773], dtype=float32)>

সম্ভবত কম আকর্ষণীয়, আমরা ইভেন্টের মাত্রাগুলি সম্প্রচার করতে পারি:

nd.log_prob([0.])
<tf.Tensor: shape=(), dtype=float32, numpy=-2.337877>
nd.log_prob([[0.], [1.], [2.]])
<tf.Tensor: shape=(3,), dtype=float32, numpy=array([-2.337877 , -2.337877 , -4.3378773], dtype=float32)>

এইভাবে সম্প্রচার করা আমাদের "যখনই সম্ভব সম্প্রচার সক্ষম করুন" ডিজাইনের একটি ফলাফল; এই ব্যবহার কিছুটা বিতর্কিত এবং ভবিষ্যতে TFP সংস্করণে এটিকে সরিয়ে ফেলা যেতে পারে।

এখন আবার তিনটি কয়েনের উদাহরণ দেখি:

b3 = tfd.Bernoulli(probs=[.3, .5, .7])

এখানে, সম্প্রচার ব্যবহার সম্ভাব্যতা প্রতিনিধিত্ব করতে প্রতিটি মুদ্রা মাথা আসে আপ বেশ স্বজ্ঞাত হল:

b3.prob([1])
<tf.Tensor: shape=(3,), dtype=float32, numpy=array([0.29999998, 0.5       , 0.7       ], dtype=float32)>

(এই তুলনা b3.prob([1., 1., 1.]) , যা আমরা ব্যবহৃত ফিরে যেখানে থাকবে b3 চালু করা হয়।)

এখন অনুমান করা আমরা জানতে চাই, প্রতিটি মুদ্রা, সম্ভাব্যতা মুদ্রা সতর্কতা এসে সম্ভাব্যতা এটা মুদ্রার উলটা পিঠ ছেড়ে আসে। আমরা চেষ্টা করার কল্পনা করতে পারি:

b3.log_prob([0, 1])

দুর্ভাগ্যবশত, এটি একটি দীর্ঘ এবং খুব বেশি পঠনযোগ্য স্ট্যাক ট্রেস সহ একটি ত্রুটি তৈরি করে। b3 হয়েছে BE = (3) তাই আমরা পাস করতে হবে, b3.prob বিরুদ্ধে কিছু broadcastable (3,)[0, 1] আকৃতি আছে (2) , তাই এটি সম্প্রচার না এবং একটি ত্রুটি সৃষ্টি করে। পরিবর্তে, আমাদের বলতে হবে:

b3.prob([[0], [1]])
<tf.Tensor: shape=(2, 3), dtype=float32, numpy=
array([[0.7, 0.5, 0.3],
       [0.3, 0.5, 0.7]], dtype=float32)>

কেন? [[0], [1]] আকৃতি আছে (2, 1) , তাই এটি আকৃতি বিরুদ্ধে সম্প্রচারের (3) এর একটি সম্প্রচার আকৃতি করতে (2, 3)

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

আরো দূরে যাচ্ছি

এই টিউটোরিয়ালে, আমরা (আশা করি) একটি সহজ ভূমিকা প্রদান করেছি। আরও এগিয়ে যাওয়ার জন্য কয়েকটি নির্দেশক:

  • event_shape , batch_shape এবং sample_shape নির্বিচারে র্যাঙ্ক হতে পারে (এই টিউটোরিয়াল-এ তারা সবসময় পারেন স্কালে বা র্যাঙ্ক 1 আছে)। এটি শক্তি বৃদ্ধি করে কিন্তু আবার প্রোগ্রামিং চ্যালেঞ্জের দিকে নিয়ে যেতে পারে, বিশেষ করে যখন সম্প্রচার জড়িত থাকে। আকৃতি ম্যানিপুলেশন মধ্যে একটি অতিরিক্ত গভীর ডুব জন্য, দেখুন বোঝাপড়া TensorFlow ডিস্ট্রিবিউশন আকার
  • TFP একটি শক্তিশালী হিসাবে পরিচিত বিমূর্ততা অন্তর্ভুক্ত Bijectors , যা সাথে TransformedDistribution , সহজে নতুন ডিস্ট্রিবিউশন সেই বিদ্যমান ডিস্ট্রিবিউশন এর বিপরীত রূপান্তরের হয় তৈরি করতে একটি নমনীয় রচনা উপায় উৎপাদ। আমরা এই শীঘ্রই উপর একটি টিউটোরিয়াল লিখতে চেষ্টা করব, কিন্তু এরই মধ্যে খুঁজে বার করো ডকুমেন্টেশন