Yardım Kaggle üzerinde TensorFlow ile Büyük Bariyer Resifi korumak Meydan Üyelik

Rastgele sayı üretimi

TensorFlow.org'da görüntüleyin Google Colab'da çalıştırın Kaynağı GitHub'da görüntüleyin Not defterini indir

TensorFlow olarak, rastlantısal-taklidi sayı üreteçleri (RNG) bir dizi sağlar tf.random modülü. Bu belge, rasgele sayı üreteçlerini nasıl kontrol edebileceğinizi ve bu oluşturucuların diğer tensorflow alt sistemleriyle nasıl etkileşime girdiğini açıklamaktadır.

TensorFlow, rastgele sayı üretme sürecini kontrol etmek için iki yaklaşım sunar:

  1. Açık kullanımı sayesinde tf.random.Generator nesneler. Bu tür her bir nesne (bir durumunu korur tf.Variable her numara nesil sonra değiştirilecek).

  2. Gibi tamamen işlevsel vatansız rasgele fonksiyonları sayesinde tf.random.stateless_uniform . Bu işlevleri aynı argümanlarla (tohum dahil) ve aynı cihazda çağırmak her zaman aynı sonuçları verecektir.

Kurmak

import tensorflow as tf

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

tf.random.Generator sınıfı

tf.random.Generator sınıfı her RNG çağrı farklı sonuçlar üretmek isteyen durumlarda kullanılır. O (bir tarafından yönetilen bir iç durumunu korur tf.Variable rasgele sayılar oluşturulur her zaman güncellenecektir nesne). Devlet tarafından yönetilen Çünkü tf.Variable , bu tarafından sağlanan tüm olanakları sahiptir tf.Variable böyle kolay kontrol noktalarını denetleme, otomatik kontrol-bağımlılık ve iplik güvenliği gibi.

Bir alabilirsiniz tf.random.Generator elle sınıf veya çağrı bir nesne oluşturarak tf.random.get_global_generator() varsayılan küresel jeneratör almak için:

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.43842277 -0.53439844 -0.07710262]
 [ 1.5658046  -0.1012345  -0.2744976 ]], shape=(2, 3), dtype=float32)
tf.Tensor(
[[-0.5496427   0.24263908 -1.1436267 ]
 [ 1.861458   -0.6756685  -0.9900103 ]], shape=(2, 3), dtype=float32)

Bir üreteç nesnesi yaratmanın birden çok yolu vardır. En kolay Generator.from_seed , yukarıda gösterildiği gibi, bu bir tohumdan bir jeneratör oluşturur. Tohum, negatif olmayan herhangi bir tam sayıdır. from_seed , isteğe bağlı bağımsız değişken alır alg , bu jeneratör tarafından kullanılacak RNG algoritması:

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

Bu konuda daha fazla bilgi için aşağıdaki Algoritmalar bölümüne bakın.

Bir jeneratör oluşturmak için diğer bir yolu ile Generator.from_non_deterministic_state . Bu şekilde oluşturulan bir jeneratör, örneğin zamana ve işletim sistemine bağlı olarak deterministik olmayan bir durumdan başlayacaktır.

g = tf.random.Generator.from_non_deterministic_state()
print(g.normal(shape=[2, 3]))
tf.Tensor(
[[-0.9078738   0.11009752  1.037219  ]
 [ 0.661036    0.4169741   1.4539026 ]], shape=(2, 3), dtype=float32)

Bu kılavuzda kapsanmayan, açık durumlardan olduğu gibi, oluşturucular oluşturmanın başka yolları da vardır.

Kullanırken tf.random.get_global_generator küresel jeneratör almak için, cihaz yerleştirme konusunda dikkatli olmak gerekir. İlk kez de (non-deterministik durumdan) yaratılır küresel jeneratör tf.random.get_global_generator denir ve bu çağrıdan varsayılan cihazına yerleştirilir. Aradığınızda ilk site Yani eğer, örneğin, tf.random.get_global_generator bir dahilindedir tf.device("gpu") olacaktır kapsamı, küresel jeneratör GPU yerleştirilecek ve CPU'dan daha sonra küresel jeneratör kullanarak GPU'dan CPU'ya bir kopyaya neden olur.

Bir işlev de vardır tf.random.set_global_generator başka jeneratör nesne ile küresel jeneratör değiştirilmesi için. Eski küresel jeneratörü bir tarafından yakalanan olabilir, çünkü bu işlev, dikkatli ile olsa kullanılmalıdır tf.function (zayıf referans olarak) ve kırılma, çöp toplanan olmasına neden olacaktır değiştirmeyi tf.function . Küresel jeneratör sıfırlamak için daha iyi bir yolu gibi "reset" işlevlerden birini kullanmaktır Generator.reset_from_seed yeni jeneratör nesneleri oluşturmaz.

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

Bağımsız rastgele sayı akışları oluşturma

Birçok uygulamada, örtüşmeyecekleri ve istatistiksel olarak saptanabilir korelasyonları olmayacakları anlamında bağımsız, birden fazla bağımsız rastgele sayı akışına ihtiyaç vardır. Bu kullanılarak elde edilir Generator.split birbirlerine (yani üreten bağımsız akışlar) bağımsız olduğu garanti edilir birden fazla jeneratör oluşturmak için kullanılır.

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.43842277, 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 bu (çağrıldığı üretecinin durumunu değiştirir g gibi bir RNG yöntemine benzer Yukarıdaki örnekte), normal . Birbirinden bağımsız olmasının yanı sıra, yeni jeneratörler ( new_gs ) aynı zamanda eski bir (bağımsız olmasını garanti altına alınmıştır g ).

Yeni oluşturucular oluşturmak, kullandığınız jeneratörün diğer hesaplamalarla aynı cihazda olduğundan emin olmak istediğinizde, cihazlar arası kopyalamanın ek yükünden kaçınmak için de yararlıdır. Örneğin:

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(0.4142675, shape=(), dtype=float32)

Sen çağırarak, yinelemeli bölme yapabileceği split parçalı jeneratörlerini. Özyinelemelerin derinliğinde (tamsayı taşmasını engelleyerek) bir sınır yoktur.

Etkileşim tf.function

tf.random.Generator aynı kurallara uymak tf.Variable ile kullanıldığında tf.function . Bu, üç yönü içerir.

Oluşturma jeneratörler dışında tf.function

tf.function dışında bunun yarattığı bir jeneratör kullanabilirsiniz.

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

Kullanıcı, işlev çağrıldığında üreteç nesnesinin hala canlı olduğundan (çöp toplanmadığından) emin olmalıdır.

İçindeki jeneratör oluşturma tf.function

Bir iç jeneratörler oluşturulması tf.function sadece fonksiyonun ilk çalıştırma esnasında happend edebilirsiniz.

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())
tf.Tensor(0.43842277, shape=(), dtype=float32)
tf.Tensor(1.6272374, shape=(), dtype=float32)

Argümanları olarak jeneratörleri geçirilmesi tf.function

Bir argüman olarak kullanıldığında tf.function farklı jeneratör nesneler takip edilebilmesini neden olur tf.function .

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

Bu izini süren davranışı ile tutarlı olduğunu unutmayın tf.Variable :

num_traces = 0
@tf.function
def foo(v):
  global num_traces
  num_traces += 1
  return v.read_value()
foo(tf.Variable(1))
foo(tf.Variable(2))
print(num_traces)
2

Dağıtım stratejileriyle etkileşim

Hangi iki yolu vardır Generator dağıtım stratejileri ile etkileşime girer.

Dağıtım stratejileri dışında jeneratörler oluşturmak

Bir oluşturucu strateji kapsamları dışında oluşturulursa, tüm kopyaların oluşturucuya erişimi serileştirilir ve bu nedenle kopyalar farklı rasgele sayılar alır.

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)

Jeneratörün cihazı kopyalardan farklı olduğu için bu kullanımın performans sorunları olabileceğini unutmayın.

Dağıtım stratejileri içinde jeneratörler oluşturma

Bir strateji kapsamında bir oluşturucu oluşturulursa, her replika farklı ve bağımsız bir rastgele sayı akışı alır.

strat = tf.distribute.MirroredStrategy(devices=["cpu:0", "cpu:1"])
with strat.scope():
  g = tf.random.Generator.from_seed(1)
  print(strat.run(lambda: g.normal([])))
  print(strat.run(lambda: g.normal([])))
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.
PerReplica:{
  0: tf.Tensor(-0.87930447, shape=(), dtype=float32),
  1: tf.Tensor(0.020661574, shape=(), dtype=float32)
}
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.
PerReplica:{
  0: tf.Tensor(-1.5822568, shape=(), dtype=float32),
  1: tf.Tensor(0.77539235, shape=(), dtype=float32)
}

Jeneratör (örn yarattığı seribaşı ise Generator.from_seed ), rastgele sayılar farklı kopyaları farklı ve ilintisiz numaralarını almak rağmen tohum tarafından belirlenir. Bir kopyada oluşturulan rastgele bir sayı, kopya kimliğinin bir karması ve tüm kopyalarda ortak olan bir "birincil" rastgele sayı olarak düşünülebilir. Bu nedenle, tüm sistem hala deterministiktir.

tf.random.Generator Ayrıca içinde oluşturulabilir Strategy.run :

strat = tf.distribute.MirroredStrategy(devices=["cpu:0", "cpu:1"])
with strat.scope():
  def f():
    g = tf.random.Generator.from_seed(1)
    a = g.normal([])
    b = g.normal([])
    return tf.stack([a, b])
  print(strat.run(f))
  print(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.
PerReplica:{
  0: tf.Tensor([-0.87930447 -1.5822568 ], shape=(2,), dtype=float32),
  1: tf.Tensor([0.02066157 0.77539235], shape=(2,), dtype=float32)
}
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.
PerReplica:{
  0: tf.Tensor([-0.87930447 -1.5822568 ], shape=(2,), dtype=float32),
  1: tf.Tensor([0.02066157 0.77539235], shape=(2,), dtype=float32)
}

Biz artık geçen tavsiye tf.random.Generator argüman olarak Strategy.run çünkü Strategy.run genellikle argümanlar tansörler değil jeneratörler olmasını bekler.

Jeneratörleri kaydetme

Genellikle kaydetme veya bir işleyebilir seri hale tf.random.Generator bir idare ediyorum aynı şekilde tf.Variable veya tf.Module (veya alt sınıfları). : TF olarak serileştirme için iki mekanizma vardır Checkpoint ve SavedModel .

kontrol noktası

Jeneratörler serbestçe kullanılarak kaydedilmesi geri yüklenebilir tf.train.Checkpoint . Geri yükleme noktasından gelen rastgele sayı akışı, kaydetme noktasından gelen ile aynı olacaktır.

filename = "./checkpoint"
g = tf.random.Generator.from_seed(1)
cp = tf.train.Checkpoint(generator=g)
print(g.normal([]))
tf.Tensor(0.43842277, shape=(), dtype=float32)
cp.write(filename)
print("RNG stream from saving point:")
print(g.normal([]))
print(g.normal([]))
RNG stream from saving point:
tf.Tensor(1.6272374, shape=(), dtype=float32)
tf.Tensor(1.6307176, shape=(), dtype=float32)
cp.restore(filename)
print("RNG stream from restoring point:")
print(g.normal([]))
print(g.normal([]))
RNG stream from restoring point:
tf.Tensor(1.6272374, shape=(), dtype=float32)
tf.Tensor(1.6307176, shape=(), dtype=float32)

Ayrıca bir dağıtım stratejisi içinde kaydedebilir ve geri yükleyebilirsiniz:

filename = "./checkpoint"
strat = tf.distribute.MirroredStrategy(devices=["cpu:0", "cpu:1"])
with strat.scope():
  g = tf.random.Generator.from_seed(1)
  cp = tf.train.Checkpoint(my_generator=g)
  print(strat.run(lambda: g.normal([])))
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')
PerReplica:{
  0: tf.Tensor(-0.87930447, shape=(), dtype=float32),
  1: tf.Tensor(0.020661574, shape=(), dtype=float32)
}
with strat.scope():
  cp.write(filename)
  print("RNG stream from saving point:")
  print(strat.run(lambda: g.normal([])))
  print(strat.run(lambda: g.normal([])))
RNG stream from saving point:
PerReplica:{
  0: tf.Tensor(-1.5822568, shape=(), dtype=float32),
  1: tf.Tensor(0.77539235, shape=(), dtype=float32)
}
PerReplica:{
  0: tf.Tensor(-0.5039703, shape=(), dtype=float32),
  1: tf.Tensor(0.1251838, shape=(), dtype=float32)
}
with strat.scope():
  cp.restore(filename)
  print("RNG stream from restoring point:")
  print(strat.run(lambda: g.normal([])))
  print(strat.run(lambda: g.normal([])))
RNG stream from restoring point:
PerReplica:{
  0: tf.Tensor(-1.5822568, shape=(), dtype=float32),
  1: tf.Tensor(0.77539235, shape=(), dtype=float32)
}
PerReplica:{
  0: tf.Tensor(-0.5039703, shape=(), dtype=float32),
  1: tf.Tensor(0.1251838, shape=(), dtype=float32)
}

Kaydetmeden önce, replikaların RNG arama geçmişlerinde ayrılmadığından emin olmalısınız (örneğin, bir replika bir RNG araması yaparken diğeri iki RNG araması yapar). Aksi takdirde, kendi iç RNG devletler sapmak ve tf.train.Checkpoint (sadece ilk yinelemenin durumunu kaydeder) düzgün bütün kopyaları geri olmayacaktır.

Ayrıca, kaydedilmiş bir kontrol noktasını farklı sayıda kopya ile farklı bir dağıtım stratejisine geri yükleyebilirsiniz. Bir Çünkü tf.random.Generator bir strateji oluşturulmuş nesne yalnızca farklı stratejiye geri yüklemek için aynı strateji kullanılabilir, yeni bir oluşturmak zorunda tf.random.Generator hedef stratejisi ve yeni bir yer tf.train.Checkpoint , bu örnekte gösterildiği gibi, bunun için:

filename = "./checkpoint"
strat1 = tf.distribute.MirroredStrategy(devices=["cpu:0", "cpu:1"])
with strat1.scope():
  g1 = tf.random.Generator.from_seed(1)
  cp1 = tf.train.Checkpoint(my_generator=g1)
  print(strat1.run(lambda: g1.normal([])))
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')
PerReplica:{
  0: tf.Tensor(-0.87930447, shape=(), dtype=float32),
  1: tf.Tensor(0.020661574, shape=(), dtype=float32)
}
with strat1.scope():
  cp1.write(filename)
  print("RNG stream from saving point:")
  print(strat1.run(lambda: g1.normal([])))
  print(strat1.run(lambda: g1.normal([])))
RNG stream from saving point:
PerReplica:{
  0: tf.Tensor(-1.5822568, shape=(), dtype=float32),
  1: tf.Tensor(0.77539235, shape=(), dtype=float32)
}
PerReplica:{
  0: tf.Tensor(-0.5039703, shape=(), dtype=float32),
  1: tf.Tensor(0.1251838, shape=(), dtype=float32)
}
strat2 = tf.distribute.MirroredStrategy(devices=["cpu:0", "cpu:1", "cpu:2"])
with strat2.scope():
  g2 = tf.random.Generator.from_seed(1)
  cp2 = tf.train.Checkpoint(my_generator=g2)
  cp2.restore(filename)
  print("RNG stream from restoring point:")
  print(strat2.run(lambda: g2.normal([])))
  print(strat2.run(lambda: g2.normal([])))
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', '/job:localhost/replica:0/task:0/device:CPU:2')
RNG stream from restoring point:
PerReplica:{
  0: tf.Tensor(-1.5822568, shape=(), dtype=float32),
  1: tf.Tensor(0.77539235, shape=(), dtype=float32),
  2: tf.Tensor(0.6851049, shape=(), dtype=float32)
}
PerReplica:{
  0: tf.Tensor(-0.5039703, shape=(), dtype=float32),
  1: tf.Tensor(0.1251838, shape=(), dtype=float32),
  2: tf.Tensor(-0.58519536, shape=(), dtype=float32)
}

Her ne kadar g1 ve cp1 farklı nesnelerdir g2 ve cp2 , ortak denetim noktası dosyası ile irtibatlı olan filename ve nesne adı my_generator . (Örneğin stratejileri arasındaki kopyaları Çakışan cpu:0 ve cpu:1 üzerinde) kendi RNG düzgün önceki örneklerde olduğu gibi restore akışlarını sahip olacaktır. Bu garanti, bir oluşturucunun bir strateji kapsamına kaydedildiği ve herhangi bir strateji kapsamının dışında geri yüklendiği veya bunun tersi olduğu durumları kapsamaz, çünkü stratejiler dışındaki bir cihaz, bir stratejideki herhangi bir kopyadan farklı olarak değerlendirilir.

Kayıtlı Model

tf.random.Generator bir SavedModel kaydedilebilir. Oluşturucu bir strateji kapsamında oluşturulabilir. Tasarruf, bir strateji kapsamında da gerçekleşebilir.

filename = "./saved_model"

class MyModule(tf.Module):

  def __init__(self):
    super(MyModule, self).__init__()
    self.g = tf.random.Generator.from_seed(0)

  @tf.function
  def __call__(self):
    return self.g.normal([])

  @tf.function
  def state(self):
    return self.g.state

strat = tf.distribute.MirroredStrategy(devices=["cpu:0", "cpu:1"])
with strat.scope():
  m = MyModule()
  print(strat.run(m))
  print("state:", m.state())
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')
PerReplica:{
  0: tf.Tensor(-1.4154755, shape=(), dtype=float32),
  1: tf.Tensor(-0.113884404, shape=(), dtype=float32)
}
state: tf.Tensor([256   0   0], shape=(3,), dtype=int64)
with strat.scope():
  tf.saved_model.save(m, filename)
  print("RNG stream from saving point:")
  print(strat.run(m))
  print("state:", m.state())
  print(strat.run(m))
  print("state:", m.state())
INFO:tensorflow:Assets written to: ./saved_model/assets
RNG stream from saving point:
PerReplica:{
  0: tf.Tensor(-0.68758255, shape=(), dtype=float32),
  1: tf.Tensor(0.8084062, shape=(), dtype=float32)
}
state: tf.Tensor([512   0   0], shape=(3,), dtype=int64)
PerReplica:{
  0: tf.Tensor(-0.27342677, shape=(), dtype=float32),
  1: tf.Tensor(-0.53093255, shape=(), dtype=float32)
}
state: tf.Tensor([768   0   0], shape=(3,), dtype=int64)
2021-09-22 20:45:46.222281: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
imported = tf.saved_model.load(filename)
print("RNG stream from loading point:")
print("state:", imported.state())
print(imported())
print("state:", imported.state())
print(imported())
print("state:", imported.state())
RNG stream from loading point:
state: tf.Tensor([256   0   0], shape=(3,), dtype=int64)
tf.Tensor(-1.0359411, shape=(), dtype=float32)
state: tf.Tensor([512   0   0], shape=(3,), dtype=int64)
tf.Tensor(-0.06425078, shape=(), dtype=float32)
state: tf.Tensor([768   0   0], shape=(3,), dtype=int64)

İhtiva eden bir SavedModel yükleme tf.random.Generator kopyaları Tüm (çoğaltma İD SavedModel en grafik dondurulur çünkü) aynı rasgele sayı akışı oluşturmak çünkü bir dağıtım stratejisine tavsiye edilmez.

Dağıtılmış yükleme tf.random.Generator olmayan bir strateji ortamına (bir dağıtım stratejisi içinde oluşturulmuş bir jeneratör), yukarıdaki örnekte olduğu gibi, aynı zamanda bir uyarı bulunmaktadır. RNG durumu düzgün bir şekilde geri yüklenecektir, ancak oluşturulan rasgele sayılar stratejisindeki orijinal oluşturucudan farklı olacaktır (yine stratejilerin dışındaki bir cihaz, bir stratejideki herhangi bir kopyadan farklı olarak ele alındığından).

Durum bilgisi olmayan RNG'ler

Durum bilgisi olmayan RNG'lerin kullanımı basittir. Yalnızca saf işlevler olduklarından, ilgili herhangi bir durum veya yan etki yoktur.

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.30159    -0.95385665]], shape=(2, 3), dtype=float32)
tf.Tensor(
[[ 0.5441101   0.20738031  0.07356433]
 [ 0.04643455 -1.30159    -0.95385665]], shape=(2, 3), dtype=float32)

Her durum bilgisi rng bir gerektirir seed şekli arasında bir tamsayıdır tensör olması gerekmektedir bağımsız değişken, [2] . Operasyonun sonuçları tamamen bu tohum tarafından belirlenir.

Durum bilgisi olmayan RNG'ler tarafından kullanılan RNG algoritması cihaza bağlıdır, yani aynı işlemin farklı bir cihazda çalışması farklı çıktılar üretebilir.

algoritmalar

Genel

Hem tf.random.Generator sınıf ve stateless fonksiyonları (şeklinde yazılır Philox algoritmasını destekleyen "philox" veya tf.random.Algorithm.PHILOX tüm cihazlarda).

Aynı algoritmayı kullanıyorsa ve aynı durumdan başlıyorsa, farklı cihazlar aynı tamsayı sayıları üretecektir. Cihazların kayan nokta hesaplamasını gerçekleştirmesinin farklı yollarından (örneğin, indirgeme sırası) kaynaklanan küçük sayısal tutarsızlıklar olsa da, "neredeyse aynı" kayan nokta sayılarını da üreteceklerdir.

XLA cihazları

(Aynı zamanda, TPU olarak ve XLA etkin CPU / grafik işlemcisi) XLA-kontrollü aletler (yazılır ThreeFry algoritma üzerinde "threefry" veya tf.random.Algorithm.THREEFRY ) de desteklenir. Bu algoritma TPU'da hızlıdır ancak Philox'a kıyasla CPU/GPU'da yavaştır.

Gazetenin Bkz : '1, 2, 3 kadar kolay Paralel Rastgele Sayılar' Bu algoritmalar hakkında daha fazla ayrıntı için.