এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

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

TensorFlow.org এ দেখুন

Google Colab-এ চালান

GitHub-এ উৎস দেখুন

নোটবুক ডাউনলোড করুন

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

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

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

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>

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

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

একাধিক বিতরণ

আমাদের প্রথম বার্নোলি বিতরণ একটি একক ন্যায্য মুদ্রার ফ্লিপ প্রতিনিধিত্ব করে। আমরা স্বাধীন বের্নুলির ডিস্ট্রিবিউশন একটি ব্যাচ তৈরি করতে পারেন, তাদের নিজস্ব পরামিতি সঙ্গে প্রতিটি, একটি একক মধ্যে 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)>

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

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

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

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

কিভাবে আমরা এই কাজ করা সম্ভব না? আমরা একটি "উচ্চ-অর্ডার" ডিস্ট্রিবিউশন নামক ব্যবহার 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 = (). .
দ্বি-মাত্রিক বহুচলকীয় লম্ব জন্য nd । BE = (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 , সহজে নতুন ডিস্ট্রিবিউশন সেই বিদ্যমান ডিস্ট্রিবিউশন এর বিপরীত রূপান্তরের হয় তৈরি করতে একটি নমনীয় রচনা উপায় উৎপাদ। আমরা এই শীঘ্রই উপর একটি টিউটোরিয়াল লিখতে চেষ্টা করব, কিন্তু এরই মধ্যে খুঁজে বার করো ডকুমেন্টেশন