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

এলোমেলো সংখ্যা জেনারেশন

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

tf.random মডিউলে সিউডো-র্যান্ডম নম্বর জেনারেটর ( tf.random ) এর একটি সেট সরবরাহ করে। আপনি কীভাবে এলোমেলো সংখ্যা জেনারেটর নিয়ন্ত্রণ করতে পারেন এবং এই জেনারেটরগুলি কীভাবে অন্যান্য টেনসরফ্লো সাব-সিস্টেমের সাথে ইন্টারেক্ট করে তা এই ডকুমেন্টটি বর্ণনা করে।

টেনসরফ্লো এলোমেলো সংখ্যা জেনারেশন প্রক্রিয়া নিয়ন্ত্রণের জন্য দুটি পন্থা সরবরাহ করে:

  1. tf.random.Generator . tf.random.Generator অবজেক্টের স্পষ্ট ব্যবহারের মাধ্যমে। এই জাতীয় প্রতিটি বস্তু একটি রাষ্ট্র বজায় রাখে ( tf.Variable পরিবর্তনশীল) যা প্রতিটি সংখ্যা তৈরির পরে পরিবর্তন করা হবে।

  2. tf.random.stateless_uniform মতো খাঁটি-কার্যকরী tf.random.stateless_uniform এলোমেলো ফাংশনগুলির tf.random.stateless_uniform । একই আর্গুমেন্ট (যা বীজ অন্তর্ভুক্ত) এবং একই ডিভাইসে এই ফাংশনগুলিতে কল করা সর্বদা একই ফলাফল উত্পন্ন করবে।

সেটআপ

 import tensorflow as tf

# Creates 2 virtual devices cpu:0 and cpu:1 for using distribution strategy
physical_devices = tf.config.experimental.list_physical_devices("CPU")
tf.config.experimental.set_virtual_device_configuration(
    physical_devices[0], [
        tf.config.experimental.VirtualDeviceConfiguration(),
        tf.config.experimental.VirtualDeviceConfiguration()
    ])
 

tf.random.Generator ক্লাস

tf.random.Generator ক্লাস এমন ক্ষেত্রে ব্যবহৃত হয় যেখানে আপনি প্রতিটি আরএনজি কল বিভিন্ন ফলাফল তৈরি করতে চান। এটি একটি অভ্যন্তরীণ অবস্থা বজায় রাখে (একটি tf.Variable অবজেক্ট দ্বারা পরিচালিত) যা এলোমেলোভাবে সংখ্যার উত্পন্ন হওয়ার সময় আপডেট করা হবে। রাজ্যটি tf.Variable দ্বারা পরিচালিত tf.Variable , এটি tf.Variable যেমন সহজ চেকপয়েন্টিং, স্বয়ংক্রিয় নিয়ন্ত্রণ-নির্ভরতা এবং থ্রেড সুরক্ষা দ্বারা সরবরাহিত সমস্ত সুবিধা উপভোগ করে।

ডিফল্ট গ্লোবাল জেনারেটর পাওয়ার জন্য আপনি ক্লাসের কোনও বস্তু নিজে হাতে তৈরি করে tf.random.get_global_generator() কল করে একটি tf.random.Generator পেতে পারেন:

 g1 = tf.random.Generator.from_seed(1)
print(g1.normal(shape=[2, 3]))
g2 = tf.random.get_global_generator()
print(g2.normal(shape=[2, 3]))
 
tf.Tensor(
[[ 0.43842274 -0.53439844 -0.07710262]
 [ 1.5658046  -0.1012345  -0.2744976 ]], shape=(2, 3), dtype=float32)
tf.Tensor(
[[-0.6078218  3.162639  -1.0558378]
 [ 1.2078347  0.6414574  0.4019502]], shape=(2, 3), dtype=float32)

জেনারেটর অবজেক্ট তৈরির একাধিক উপায় রয়েছে। সবচেয়ে সহজ হ'ল Generator.from_seed , উপরের মতো দেখানো হয়েছে যা একটি বীজ থেকে জেনারেটর তৈরি করে। একটি বীজ হ'ল যে কোনও অ-নেতিবাচক পূর্ণসংখ্যা। from_seed এছাড়াও একটি ঐচ্ছিক আর্গুমেন্ট গ্রহণ করা alg যা RNG অ্যালগরিদম যে এই জেনারেটর দ্বারা ব্যবহৃত হবে হল:

 g1 = tf.random.Generator.from_seed(1, alg='philox')
print(g1.normal(shape=[2, 3]))
 
tf.Tensor(
[[ 0.43842274 -0.53439844 -0.07710262]
 [ 1.5658046  -0.1012345  -0.2744976 ]], shape=(2, 3), dtype=float32)

এটি সম্পর্কে আরও তথ্যের জন্য নীচের অ্যালগরিদম বিভাগটি দেখুন।

জেনারেটরের তৈরি করতে আরেকটি উপায় সাথে আছেন Generator.from_non_deterministic_state । সময় এবং OS এর উপর নির্ভর করে এইভাবে তৈরি করা একটি জেনারেটর একটি অ-নিরস্তকারী অবস্থা থেকে শুরু হবে।

 g = tf.random.Generator.from_non_deterministic_state()
print(g.normal(shape=[2, 3]))
 
tf.Tensor(
[[ 1.1436943  1.729618   1.0391121]
 [-0.8502223 -1.8823647 -1.4051851]], shape=(2, 3), dtype=float32)

জেনারেটর তৈরির অন্যান্য উপায় রয়েছে যেমন সুস্পষ্ট রাজ্য থেকে, যা এই গাইডের আওতায় নেই।

গ্লোবাল জেনারেটরটি পেতে tf.random.get_global_generator ব্যবহার করার সময়, আপনাকে ডিভাইস স্থাপন সম্পর্কে সতর্ক হওয়া দরকার। প্রথমবারে tf.random.get_global_generator বলা হয়ে গ্লোবাল জেনারেটর তৈরি করা হয় (একটি অ- tf.random.get_global_generator রাষ্ট্র থেকে) এবং tf.random.get_global_generator সেই ডিফল্ট ডিভাইসে স্থাপন করা হয়। সুতরাং, উদাহরণস্বরূপ, প্রথম সাইটটি আপনি যদি tf.random.get_global_generator কল tf.random.get_global_generator একটি tf.device("gpu") স্কোপের মধ্যে থাকে তবে গ্লোবাল জেনারেটরটি জিপিইউতে স্থাপন করা হবে এবং সিপিইউ থেকে পরবর্তীকালে গ্লোবাল জেনারেটর ব্যবহার করা হবে একটি জিপিইউ-থেকে-সিপিইউ অনুলিপি করতে হবে।

গ্লোবাল জেনারেটরকে অন্য জেনারেটরের সাথে প্রতিস্থাপনের জন্য tf.random.set_global_generator একটি ফাংশনও tf.random.set_global_generator । এই ফাংশনটি সতর্কতার সাথে ব্যবহার করা উচিত, কারণ পুরানো গ্লোবাল জেনারেটর tf.function (একটি দুর্বল রেফারেন্স হিসাবে) দ্বারা ক্যাপচার করা হয়েছে এবং এটি প্রতিস্থাপনের ফলে tf.function ভেঙে আবর্জনা সংগ্রহ করা হবে। বিশ্বব্যাপী জেনারেটরের পুনরায় সেট করতে একটি ভাল উপায় যেমন "রিসেট" ফাংশন ব্যবহার করতে হয় Generator.reset_from_seed , যা নতুন জেনারেটর বস্তু তৈরী করবে না।

 g = tf.random.Generator.from_seed(1)
print(g.normal([]))
print(g.normal([]))
g.reset_from_seed(1)
print(g.normal([]))
 
tf.Tensor(0.43842274, shape=(), dtype=float32)
tf.Tensor(1.6272374, shape=(), dtype=float32)
tf.Tensor(0.43842274, shape=(), dtype=float32)

স্বতন্ত্র এলোমেলো-নম্বর স্ট্রিম তৈরি করা

অনেক অ্যাপ্লিকেশনগুলিতে একের জন্য একাধিক স্বতন্ত্র এলোমেলো-নম্বর স্ট্রিমের প্রয়োজন হয়, এই অর্থে স্বতন্ত্র যে এগুলি ওভারল্যাপ করবে না এবং কোনও পরিসংখ্যানগতভাবে সনাক্তযোগ্য পারস্পরিক সম্পর্ক থাকবে না। একে অপরের থেকে স্বাধীন হওয়ার নিশ্চয়তা প্রাপ্ত একাধিক জেনারেটর তৈরি করতে Generator.split ব্যবহার করে এটি অর্জন করা হয়েছে (অর্থাত স্বাধীন স্ট্রিম তৈরি করা)।

 g = tf.random.Generator.from_seed(1)
print(g.normal([]))
new_gs = g.split(3)
for new_g in new_gs:
  print(new_g.normal([]))
print(g.normal([]))
 
tf.Tensor(0.43842274, shape=(), dtype=float32)
tf.Tensor(2.536413, shape=(), dtype=float32)
tf.Tensor(0.33186463, shape=(), dtype=float32)
tf.Tensor(-0.07144657, shape=(), dtype=float32)
tf.Tensor(-0.79253083, shape=(), dtype=float32)

split এমন জেনারেটরের অবস্থার পরিবর্তন করবে যার উপর এটি বলা হয় (উপরের উদাহরণে g ), একটি আরএনজি পদ্ধতির মতো normal । একে অপরের সাথে স্বাধীন হওয়ার সাথে সাথে, নতুন জেনারেটর ( new_gs ) এছাড়াও পুরানো ( g ) থেকে স্বতন্ত্র হওয়ার গ্যারান্টিযুক্ত।

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

 with tf.device("cpu"):  # change "cpu" to the device you want
  g = tf.random.get_global_generator().split(1)[0]  
  print(g.normal([]))  # use of g won't cause cross-device copy, unlike the global generator
 
tf.Tensor(-1.7580209, shape=(), dtype=float32)

আপনি split জেনারেটরগুলিতে বিভাজন কল করে পুনরাবৃত্তভাবে বিভাজন করতে পারেন। পুনরাবৃত্তির গভীরতার কোনও সীমা নেই (পূর্ণসংখ্যার ওভারফ্লো ব্যতীত)।

tf.function সাথে tf.function

tf.random.Generator যেমন একই নিয়ম মেনে চলে tf.Variable যখন সঙ্গে ব্যবহার tf.function । এর মধ্যে তিনটি দিক অন্তর্ভুক্ত রয়েছে।

tf.function বাইরে জেনারেটর তৈরি করা tf.function

tf.function বাইরে তৈরি জেনারেটর ব্যবহার করতে পারে।

 g = tf.random.Generator.from_seed(1)
@tf.function
def foo():
  return g.normal([])
print(foo())
 
tf.Tensor(0.43842274, shape=(), dtype=float32)

ব্যবহারকারীটিকে ফাংশনটি কল করার সময় জেনারেটর অবজেক্টটি এখনও বেঁচে আছে (আবর্জনা-সংগৃহীত নয়) তা নিশ্চিত করা দরকার।

tf.function ভিতরে জেনারেটর তৈরি করা tf.function

একটি tf.function ভিতরে জেনারেটর তৈরি শুধুমাত্র ফাংশন প্রথম রান চলাকালীন tf.function হতে পারে।

 g = None
@tf.function
def foo():
  global g
  if g is None:
    g = tf.random.Generator.from_seed(1)
  return g.normal([])
print(foo())
print(foo())
 
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/resource_variable_ops.py:1817: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.
Instructions for updating:
If using Keras pass *_constraint arguments to layers.
tf.Tensor(0.43842274, shape=(), dtype=float32)
tf.Tensor(1.6272374, shape=(), dtype=float32)

tf.function আর্গুমেন্ট হিসাবে জেনারেটরগুলি পাস করা

যখন tf.function তে আর্গুমেন্ট হিসাবে ব্যবহৃত হয়, একই রাষ্ট্র আকারের সাথে বিভিন্ন জেনারেটর অবজেক্ট (রাষ্ট্রের আকার tf.function অ্যালগরিদম দ্বারা নির্ধারিত হয়) tf.function করতে পারে না, যখন বিভিন্ন রাষ্ট্রের আকারের তারা with

 num_traces = 0
@tf.function
def foo(g):
  global num_traces
  num_traces += 1
  return g.normal([])
foo(tf.random.Generator.from_seed(1))
foo(tf.random.Generator.from_seed(2))
print(num_traces)
 
1

বিতরণের কৌশলগুলির সাথে মিথস্ক্রিয়া

Generator বিতরণ কৌশলগুলির সাথে ইন্টারঅ্যাক্ট করে এমন তিনটি উপায় রয়েছে।

বিতরণ কৌশল বাইরে জেনারেটর তৈরি

যদি কোনও জেনারেটর কৌশলগত স্কোপের বাইরে তৈরি করা হয়, তবে জেনারেটরে সমস্ত প্রতিরূপের অ্যাক্সেস সিরিয়ালাইজড হবে, এবং তাই প্রতিলিপিগুলি বিভিন্ন এলোমেলো সংখ্যা পাবে।

 g = tf.random.Generator.from_seed(1)
strat = tf.distribute.MirroredStrategy(devices=["cpu:0", "cpu:1"])
with strat.scope():
  def f():
    print(g.normal([]))
  results = strat.run(f)
 
WARNING:tensorflow:There are non-GPU devices in `tf.distribute.Strategy`, not using nccl allreduce.
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:CPU:0', '/job:localhost/replica:0/task:0/device:CPU:1')
WARNING:tensorflow:Using MirroredStrategy eagerly has significant overhead currently. We will be working on improving this in the future, but for now please wrap `call_for_each_replica` or `experimental_run` or `run` inside a tf.function to get the best performance.
tf.Tensor(0.43842274, shape=(), dtype=float32)
tf.Tensor(1.6272374, shape=(), dtype=float32)

নোট করুন যে এই ব্যবহারের কার্যকারিতা সংক্রান্ত সমস্যা থাকতে পারে কারণ জেনারেটরের ডিভাইসটি প্রতিরূপ থেকে পৃথক।

বিতরণ কৌশল ভিতরে জেনারেটর তৈরি

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

 strat = tf.distribute.MirroredStrategy(devices=["cpu:0", "cpu:1"])
with strat.scope():
  try:
    tf.random.Generator.from_seed(1)
  except ValueError as e:
    print("ValueError:", e)
 
WARNING:tensorflow:There are non-GPU devices in `tf.distribute.Strategy`, not using nccl allreduce.
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:CPU:0', '/job:localhost/replica:0/task:0/device:CPU:1')
ValueError: Creating a generator within a strategy scope is disallowed, because there is ambiguity on how to replicate a generator (e.g. should it be copied so that each replica gets the same random numbers, or 'split' so that each replica gets different random numbers).

নোট করুন যে Strategy.run তার Strategy.run যুক্তিতে তার যুক্তি ফাংশনটি Strategy.run চালাবে:

 strat = tf.distribute.MirroredStrategy(devices=["cpu:0", "cpu:1"])
def f():
  tf.random.Generator.from_seed(1)
try:
  strat.run(f)
except ValueError as e:
  print("ValueError:", e)
 
WARNING:tensorflow:There are non-GPU devices in `tf.distribute.Strategy`, not using nccl allreduce.
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:CPU:0', '/job:localhost/replica:0/task:0/device:CPU:1')
WARNING:tensorflow:Using MirroredStrategy eagerly has significant overhead currently. We will be working on improving this in the future, but for now please wrap `call_for_each_replica` or `experimental_run` or `run` inside a tf.function to get the best performance.
INFO:tensorflow:Error reported to Coordinator: Creating a generator within a strategy scope is disallowed, because there is ambiguity on how to replicate a generator (e.g. should it be copied so that each replica gets the same random numbers, or 'split' so that each replica gets different random numbers).
Traceback (most recent call last):
  File "/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/coordinator.py", line 297, in stop_on_exception
    yield
  File "/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/distribute/mirrored_strategy.py", line 998, in run
    self.main_result = self.main_fn(*self.main_args, **self.main_kwargs)
  File "/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/autograph/impl/api.py", line 282, in wrapper
    return func(*args, **kwargs)
  File "<ipython-input-14-2cd7806456bd>", line 3, in f
    tf.random.Generator.from_seed(1)
  File "/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/stateful_random_ops.py", line 444, in from_seed
    return cls(state=state, alg=alg)
  File "/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/stateful_random_ops.py", line 386, in __init__
    trainable=False)
  File "/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/stateful_random_ops.py", line 272, in _create_variable
    "Creating a generator within a strategy scope is disallowed, because "
ValueError: Creating a generator within a strategy scope is disallowed, because there is ambiguity on how to replicate a generator (e.g. should it be copied so that each replica gets the same random numbers, or 'split' so that each replica gets different random numbers).
ValueError: Creating a generator within a strategy scope is disallowed, because there is ambiguity on how to replicate a generator (e.g. should it be copied so that each replica gets the same random numbers, or 'split' so that each replica gets different random numbers).

আর্গুমেন্ট হিসাবে জেনারেটর পাসিং Strategy.run

আপনি যদি প্রতি প্রতিলিপিটির নিজস্ব জেনারেটর ব্যবহার করতে চান তবে আপনাকে n জেনারেটর তৈরি করতে হবে (হয় অনুলিপি বা বিভাজন দ্বারা), যেখানে n প্রতিরূপের সংখ্যা, এবং তারপরে সেগুলি Strategy.run যুক্তি হিসাবে পাস করুন।

 strat = tf.distribute.MirroredStrategy(devices=["cpu:0", "cpu:1"])
gs = tf.random.get_global_generator().split(2)
# to_args is a workaround for the absence of APIs to create arguments for 
# run. It will be replaced when such APIs are available.
def to_args(gs):  
  with strat.scope():
    def f():
      return [gs[tf.distribute.get_replica_context().replica_id_in_sync_group]]
    return strat.run(f)
args = to_args(gs)
def f(g):
  print(g.normal([]))
results = strat.run(f, args=args)
 
WARNING:tensorflow:There are non-GPU devices in `tf.distribute.Strategy`, not using nccl allreduce.
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:CPU:0', '/job:localhost/replica:0/task:0/device:CPU:1')
WARNING:tensorflow:Using MirroredStrategy eagerly has significant overhead currently. We will be working on improving this in the future, but for now please wrap `call_for_each_replica` or `experimental_run` or `run` inside a tf.function to get the best performance.
WARNING:tensorflow:Using MirroredStrategy eagerly has significant overhead currently. We will be working on improving this in the future, but for now please wrap `call_for_each_replica` or `experimental_run` or `run` inside a tf.function to get the best performance.
tf.Tensor(-0.15682742, shape=(), dtype=float32)
tf.Tensor(-0.38042808, shape=(), dtype=float32)

রাজ্যহীন আরএনজি

রাষ্ট্রবিহীন আরএনজির ব্যবহার সহজ। যেহেতু তারা কেবল খাঁটি ফাংশন, তাই কোনও রাজ্য বা পার্শ্ব প্রতিক্রিয়া জড়িত নেই।

 print(tf.random.stateless_normal(shape=[2, 3], seed=[1, 2]))
print(tf.random.stateless_normal(shape=[2, 3], seed=[1, 2]))
 
tf.Tensor(
[[ 0.5441101   0.20738031  0.07356433]
 [ 0.04643455 -1.3015898  -0.95385665]], shape=(2, 3), dtype=float32)
tf.Tensor(
[[ 0.5441101   0.20738031  0.07356433]
 [ 0.04643455 -1.3015898  -0.95385665]], shape=(2, 3), dtype=float32)

প্রতিটি রাষ্ট্রবিহীন আরএনজির জন্য একটি seed যুক্তি প্রয়োজন, যা আকারের একটি পূর্ণসংখ্যার টেনসর হওয়া দরকার [2] । অপের ফলাফলগুলি এই বীজ দ্বারা সম্পূর্ণ নির্ধারিত হয়।

আলগোরিদিম

সাধারণ

উভয় tf.random.Generator শ্রেণী এবং stateless ফাংশন Philox আলগোরিদিম (হিসাবে লিখিত সমর্থন "philox" বা tf.random.Algorithm.PHILOX সমস্ত ডিভাইসেই)।

একই অ্যালগরিদম ব্যবহার করে এবং একই অবস্থা থেকে শুরু করে বিভিন্ন ডিভাইস একই সংখ্যার সংখ্যা তৈরি করবে। তারা "প্রায় একই" ফ্ল্যাট-পয়েন্ট সংখ্যাও উত্পন্ন করবে, যদিও ডিভাইসগুলি বিভিন্নভাবে ভাসমান-পয়েন্ট গণনা সম্পাদন করে (উদাহরণস্বরূপ হ্রাসের ক্রম) দ্বারা সংখ্যাসূচক তাত্পর্যপূর্ণ হতে পারে।

এক্সএলএ ডিভাইস

এক্সএলএ-চালিত ডিভাইসগুলিতে (যেমন টিপিইউ, এবং সিপিইউ / জিপিইউ যখন এক্সএলএ সক্ষম করা থাকে) থ্রিফ্রি অ্যালগরিদম ( "threefry" বা tf.random.Algorithm.THREEFRY হিসাবে লেখা )ও সমর্থিত। এই অ্যালগরিদম টিপিইউতে দ্রুত তবে ফিলক্সের তুলনায় সিপিইউ / জিপিইউতে ধীর।

এই অ্যালগোরিদম সম্পর্কে আরও তথ্যের জন্য কাগজটি 'সমান্তরাল এলোমেলো সংখ্যা: 1, 2, 3 হিসাবে সহজ' দেখুন।