tensorflow/tensorflow/python/ops/random_ops.py at master · codeplaysoftware/tensorflow · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

# http://www.apache.org/licenses/LICENSE-2.0

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

# ==============================================================================

"""Operations for generating random numbers."""

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import numpy as np

from tensorflow.python.framework import dtypes

from tensorflow.python.framework import ops

from tensorflow.python.framework import random_seed

from tensorflow.python.ops import array_ops

from tensorflow.python.ops import control_flow_ops

from tensorflow.python.ops import gen_random_ops

from tensorflow.python.ops import math_ops

# go/tf-wildcard-import

# pylint: disable=wildcard-import

from tensorflow.python.ops.gen_random_ops import *

from tensorflow.python.util.tf_export import tf_export

# pylint: enable=wildcard-import

def _ShapeTensor(shape):

"""Convert to an int32 or int64 tensor, defaulting to int32 if empty."""

if isinstance(shape, (tuple, list)) and not shape:

dtype = dtypes.int32

else:

dtype = None

return ops.convert_to_tensor(shape, dtype=dtype, name="shape")

@tf_export("random_normal")

def random_normal(shape,

mean=0.0,

stddev=1.0,

dtype=dtypes.float32,

seed=None,

name=None):

"""Outputs random values from a normal distribution.

Args:

shape: A 1-D integer Tensor or Python array. The shape of the output tensor.

mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal

distribution.

stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation

of the normal distribution.

dtype: The type of the output.

seed: A Python integer. Used to create a random seed for the distribution.

See

@{tf.set_random_seed}

for behavior.

Returns:

A tensor of the specified shape filled with random normal values.

"""

with ops.name_scope(name, "random_normal", [shape, mean, stddev]) as name:

shape_tensor = _ShapeTensor(shape)

mean_tensor = ops.convert_to_tensor(mean, dtype=dtype, name="mean")

stddev_tensor = ops.convert_to_tensor(stddev, dtype=dtype, name="stddev")

seed1, seed2 = random_seed.get_seed(seed)

rnd = gen_random_ops.random_standard_normal(

shape_tensor, dtype, seed=seed1, seed2=seed2)

mul = rnd * stddev_tensor

value = math_ops.add(mul, mean_tensor, name=name)

return value

ops.NotDifferentiable("RandomStandardNormal")

def parameterized_truncated_normal(shape,

means=0.0,

stddevs=1.0,

minvals=-2.0,

maxvals=2.0,

dtype=dtypes.float32,

seed=None,

name=None):

"""Outputs random values from a truncated normal distribution.

The generated values follow a normal distribution with specified mean and

standard deviation, except that values whose magnitude is more than 2 standard

deviations from the mean are dropped and re-picked.

Args:

shape: A 1-D integer Tensor or Python array. The shape of the output tensor.

means: A 0-D Tensor or Python value of type `dtype`. The mean of the

truncated normal distribution.

stddevs: A 0-D Tensor or Python value of type `dtype`. The standard

deviation of the truncated normal distribution.

minvals: A 0-D Tensor or Python value of type `dtype`. The minimum value of

the truncated normal distribution.

maxvals: A 0-D Tensor or Python value of type `dtype`. The maximum value of

the truncated normal distribution.

dtype: The type of the output.

seed: A Python integer. Used to create a random seed for the distribution.

See

@{tf.set_random_seed}

for behavior.

Returns:

A tensor of the specified shape filled with random truncated normal values.

"""

with ops.name_scope(name, "parameterized_truncated_normal",

[shape, means, stddevs, minvals, maxvals]) as name:

shape_tensor = _ShapeTensor(shape)

means_tensor = ops.convert_to_tensor(means, dtype=dtype, name="means")

stddevs_tensor = ops.convert_to_tensor(stddevs, dtype=dtype, name="stddevs")

minvals_tensor = ops.convert_to_tensor(minvals, dtype=dtype, name="minvals")

maxvals_tensor = ops.convert_to_tensor(maxvals, dtype=dtype, name="maxvals")

seed1, seed2 = random_seed.get_seed(seed)

rnd = gen_random_ops.parameterized_truncated_normal(

shape_tensor,

means_tensor,

stddevs_tensor,

minvals_tensor,

maxvals_tensor,

seed=seed1,

seed2=seed2)

return rnd

@tf_export("truncated_normal")

def truncated_normal(shape,

mean=0.0,

stddev=1.0,

dtype=dtypes.float32,

seed=None,

name=None):

"""Outputs random values from a truncated normal distribution.

The generated values follow a normal distribution with specified mean and

standard deviation, except that values whose magnitude is more than 2 standard

deviations from the mean are dropped and re-picked.

Args:

shape: A 1-D integer Tensor or Python array. The shape of the output tensor.

mean: A 0-D Tensor or Python value of type `dtype`. The mean of the

truncated normal distribution.

stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation

of the normal distribution, before truncation.

dtype: The type of the output.

seed: A Python integer. Used to create a random seed for the distribution.

See

@{tf.set_random_seed}

for behavior.

Returns:

A tensor of the specified shape filled with random truncated normal values.

"""

with ops.name_scope(name, "truncated_normal", [shape, mean, stddev]) as name:

shape_tensor = _ShapeTensor(shape)

mean_tensor = ops.convert_to_tensor(mean, dtype=dtype, name="mean")

stddev_tensor = ops.convert_to_tensor(stddev, dtype=dtype, name="stddev")

seed1, seed2 = random_seed.get_seed(seed)

rnd = gen_random_ops.truncated_normal(

shape_tensor, dtype, seed=seed1, seed2=seed2)

mul = rnd * stddev_tensor

value = math_ops.add(mul, mean_tensor, name=name)

return value

ops.NotDifferentiable("ParameterizedTruncatedNormal")

ops.NotDifferentiable("TruncatedNormal")

@tf_export("random_uniform")

def random_uniform(shape,

minval=0,

maxval=None,

dtype=dtypes.float32,

seed=None,

name=None):

"""Outputs random values from a uniform distribution.

The generated values follow a uniform distribution in the range

`[minval, maxval)`. The lower bound `minval` is included in the range, while

the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must

be specified explicitly.

In the integer case, the random integers are slightly biased unless

`maxval - minval` is an exact power of two. The bias is small for values of

`maxval - minval` significantly smaller than the range of the output (either

`2**32` or `2**64`).

Args:

shape: A 1-D integer Tensor or Python array. The shape of the output tensor.

minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the

range of random values to generate. Defaults to 0.

maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on

the range of random values to generate. Defaults to 1 if `dtype` is

floating point.

dtype: The type of the output: `float16`, `float32`, `float64`, `int32`,

or `int64`.

seed: A Python integer. Used to create a random seed for the distribution.

See @{tf.set_random_seed}

for behavior.

Returns:

A tensor of the specified shape filled with random uniform values.

Raises:

ValueError: If `dtype` is integral and `maxval` is not specified.

"""

dtype = dtypes.as_dtype(dtype)

if dtype not in (dtypes.float16, dtypes.bfloat16, dtypes.float32,

dtypes.float64, dtypes.int32, dtypes.int64):

raise ValueError("Invalid dtype %r" % dtype)

if maxval is None:

if dtype.is_integer:

raise ValueError("Must specify maxval for integer dtype %r" % dtype)

maxval = 1

with ops.name_scope(name, "random_uniform", [shape, minval, maxval]) as name:

shape = _ShapeTensor(shape)

minval = ops.convert_to_tensor(minval, dtype=dtype, name="min")

maxval = ops.convert_to_tensor(maxval, dtype=dtype, name="max")

seed1, seed2 = random_seed.get_seed(seed)

if dtype.is_integer:

return gen_random_ops.random_uniform_int(

shape, minval, maxval, seed=seed1, seed2=seed2, name=name)

else:

rnd = gen_random_ops.random_uniform(shape, dtype, seed=seed1, seed2=seed2)

return math_ops.add(rnd * (maxval - minval), minval, name=name)

ops.NotDifferentiable("RandomUniform")

@tf_export("random_shuffle")

def random_shuffle(value, seed=None, name=None):

"""Randomly shuffles a tensor along its first dimension.

The tensor is shuffled along dimension 0, such that each `value[j]` is mapped

to one and only one `output[i]`. For example, a mapping that might occur for a

3x2 tensor is:

```python

[[1, 2], [[5, 6],

[3, 4], ==> [1, 2],

[5, 6]] [3, 4]]

```

Args:

value: A Tensor to be shuffled.

seed: A Python integer. Used to create a random seed for the distribution.

See

@{tf.set_random_seed}

for behavior.

Returns:

A tensor of same shape and type as `value`, shuffled along its first

dimension.

"""

seed1, seed2 = random_seed.get_seed(seed)

return gen_random_ops.random_shuffle(

value, seed=seed1, seed2=seed2, name=name)

@tf_export("random_crop")

def random_crop(value, size, seed=None, name=None):

"""Randomly crops a tensor to a given size.

Slices a shape `size` portion out of `value` at a uniformly chosen offset.

Requires `value.shape >= size`.

If a dimension should not be cropped, pass the full size of that dimension.

For example, RGB images can be cropped with

`size = [crop_height, crop_width, 3]`.

Args:

value: Input tensor to crop.

size: 1-D tensor with size the rank of `value`.

seed: Python integer. Used to create a random seed. See

@{tf.set_random_seed}

for behavior.

Returns:

A cropped tensor of the same rank as `value` and shape `size`.

"""

# TODO(shlens): Implement edge case to guarantee output size dimensions.

# If size > value.shape, zero pad the result so that it always has shape

# exactly size.

with ops.name_scope(name, "random_crop", [value, size]) as name:

value = ops.convert_to_tensor(value, name="value")

size = ops.convert_to_tensor(size, dtype=dtypes.int32, name="size")

shape = array_ops.shape(value)

check = control_flow_ops.Assert(

math_ops.reduce_all(shape >= size),

["Need value.shape >= size, got ", shape, size],

summarize=1000)

shape = control_flow_ops.with_dependencies([check], shape)

limit = shape - size + 1

offset = random_uniform(

array_ops.shape(shape),

dtype=size.dtype,

maxval=size.dtype.max,

seed=seed) % limit

return array_ops.slice(value, offset, size, name=name)

@tf_export("multinomial")

def multinomial(logits, num_samples, seed=None, name=None, output_dtype=None):

"""Draws samples from a multinomial distribution.

Example:

```python

# samples has shape [1, 5], where each value is either 0 or 1 with equal

# probability.

samples = tf.multinomial(tf.log([[10., 10.]]), 5)

```

Args:

logits: 2-D Tensor with shape `[batch_size, num_classes]`. Each slice

`[i, :]` represents the unnormalized log-probabilities for all classes.

num_samples: 0-D. Number of independent samples to draw for each row slice.

seed: A Python integer. Used to create a random seed for the distribution.

See

@{tf.set_random_seed}

for behavior.

output_dtype: integer type to use for the output. Defaults to int64.

Returns:

The drawn samples of shape `[batch_size, num_samples]`.

"""

with ops.name_scope(name, "multinomial", [logits]):

logits = ops.convert_to_tensor(logits, name="logits")

seed1, seed2 = random_seed.get_seed(seed)

return gen_random_ops.multinomial(

logits, num_samples, seed=seed1, seed2=seed2, output_dtype=output_dtype)

ops.NotDifferentiable("Multinomial")

@tf_export("random_gamma")

def random_gamma(shape,

alpha,

beta=None,

dtype=dtypes.float32,

seed=None,

name=None):

"""Draws `shape` samples from each of the given Gamma distribution(s).

`alpha` is the shape parameter describing the distribution(s), and `beta` is

the inverse scale parameter(s).

Example:

samples = tf.random_gamma([10], [0.5, 1.5])

# samples has shape [10, 2], where each slice [:, 0] and [:, 1] represents

# the samples drawn from each distribution

samples = tf.random_gamma([7, 5], [0.5, 1.5])

# samples has shape [7, 5, 2], where each slice [:, :, 0] and [:, :, 1]

# represents the 7x5 samples drawn from each of the two distributions

samples = tf.random_gamma([30], [[1.],[3.],[5.]], beta=[[3., 4.]])

# samples has shape [30, 3, 2], with 30 samples each of 3x2 distributions.

Note: Because internal calculations are done using `float64` and casting has

`floor` semantics, we must manually map zero outcomes to the smallest

possible positive floating-point value, i.e., `np.finfo(dtype).tiny`. This

means that `np.finfo(dtype).tiny` occurs more frequently than it otherwise

should. This bias can only happen for small values of `alpha`, i.e.,

`alpha << 1` or large values of `beta`, i.e., `beta >> 1`.

Args:

shape: A 1-D integer Tensor or Python array. The shape of the output samples

to be drawn per alpha/beta-parameterized distribution.

alpha: A Tensor or Python value or N-D array of type `dtype`. `alpha`

provides the shape parameter(s) describing the gamma distribution(s) to

sample. Must be broadcastable with `beta`.

beta: A Tensor or Python value or N-D array of type `dtype`. Defaults to 1.

`beta` provides the inverse scale parameter(s) of the gamma

distribution(s) to sample. Must be broadcastable with `alpha`.

dtype: The type of alpha, beta, and the output: `float16`, `float32`, or

`float64`.

seed: A Python integer. Used to create a random seed for the distributions.

See

@{tf.set_random_seed}

for behavior.

Returns:

samples: a `Tensor` of shape `tf.concat(shape, tf.shape(alpha + beta))`

with values of type `dtype`.

"""

with ops.name_scope(name, "random_gamma", [shape, alpha, beta]):

shape = ops.convert_to_tensor(shape, name="shape", dtype=dtypes.int32)

alpha = ops.convert_to_tensor(alpha, name="alpha", dtype=dtype)

beta = ops.convert_to_tensor(

beta if beta is not None else 1, name="beta", dtype=dtype)

alpha_broadcast = alpha + array_ops.zeros_like(beta)

seed1, seed2 = random_seed.get_seed(seed)

return math_ops.maximum(

np.finfo(dtype.as_numpy_dtype).tiny,

gen_random_ops.random_gamma(

shape, alpha_broadcast, seed=seed1, seed2=seed2) / beta)

ops.NotDifferentiable("RandomGamma")

@tf_export("random_poisson")

def random_poisson(lam, shape, dtype=dtypes.float32, seed=None, name=None):

"""Draws `shape` samples from each of the given Poisson distribution(s).

`lam` is the rate parameter describing the distribution(s).

Example:

samples = tf.random_poisson([0.5, 1.5], [10])

# samples has shape [10, 2], where each slice [:, 0] and [:, 1] represents

# the samples drawn from each distribution

samples = tf.random_poisson([12.2, 3.3], [7, 5])

# samples has shape [7, 5, 2], where each slice [:, :, 0] and [:, :, 1]

# represents the 7x5 samples drawn from each of the two distributions

Args:

lam: A Tensor or Python value or N-D array of type `dtype`.

`lam` provides the rate parameter(s) describing the poisson

distribution(s) to sample.

shape: A 1-D integer Tensor or Python array. The shape of the output samples

to be drawn per "rate"-parameterized distribution.

dtype: The type of the output: `float16`, `float32`, `float64`, `int32` or

`int64`.

seed: A Python integer. Used to create a random seed for the distributions.

See

@{tf.set_random_seed}

for behavior.

Returns:

samples: a `Tensor` of shape `tf.concat(shape, tf.shape(lam))` with

values of type `dtype`.

"""

with ops.name_scope(name, "random_poisson", [lam, shape]):

shape = ops.convert_to_tensor(shape, name="shape", dtype=dtypes.int32)

seed1, seed2 = random_seed.get_seed(seed)

return gen_random_ops.random_poisson_v2(

shape, lam, dtype=dtype, seed=seed1, seed2=seed2)

tensorflow/tensorflow/python/ops/random_ops.py at master · codeplaysoftware/tensorflow · GitHub

Repository navigation

Expand file tree

Breadcrumbs

random_ops.py

Latest commit

History

Breadcrumbs

random_ops.py

File metadata and controls