tensorflow语法【tf.random.categorical()、tf.clip_by_value()、tf.placeholder()、tf.Session()】

相关文章：

【一】tensorflow安装、常用python镜像源、tensorflow 深度学习强化学习教学

【二】tensorflow调试报错、tensorflow 深度学习强化学习教学

【三】tensorboard安装、使用教学以及遇到的问题

【四】超级快速pytorch安装

---

trick1---实现tensorflow和pytorch迁移环境教学

---

tf.multinomial()/tf.random.categorical()用法解析

tf.multinomial()在tensorflow2.0版本已经被移除，取而代之的就是tf.random.categorical()

tf.random.categorical 从一个分类分布中抽取样本（tf.multinomial()是多项分布）例子

tf.random.categorical(
    logits,
    num_samples,
    dtype=None,
    seed=None,
    name=None
)

demo：

# samples has shape [1, 5], where each value is either 0 or 1 with equal
# probability.
samples = tf.random.categorical(tf.math.log([[10., 10.]]), 5)

参数:

logits: 形状为 [batch_size, num_classes]的张量. 每个切片 [i, :] 代表对于所有类的未正规化的log概率。
num_samples: 0维，从每一行切片中抽取的独立样本的数量。
dtype: 用于输出的整数类型，默认为int64。
seed: 一个Python整数，用于创建分布的随机种子。See tf.compat.v1.set_random_seedfor behavior.
name: 操作的可选名字
Returns:

形状为[batch_size, num_samples]的抽取样本.、

参考博客：https://blog.csdn.net/a845717607/article/details/99701349

1. 这个函数的意思就是，你给了一个batch_size × num_classes的矩阵，这个矩阵是这样的：每一行相当于log(p(x))，这里假设p(x)=[0.4,0.3,0.2,0.1]，（p(x)的特性就是和为1），
然后再取log，那么log(p(x))就等于[-0.9162907 -1.20397282 -1.60943794 -2.30258512]函数利用你给的分布概率，从其中的每一行中抽取num_samples次，最终形成的矩阵就是batch_szie × num_samples了。

2. 这里的抽样方法可以再详细解释一下，举个例子（请不要考虑真实性），给一行[1.0,2.0,2.0,2.0,6.0]，采样4次，那么结果很大可能都是[4,4,4,4]（不信可以试一下），因为下标为4的概率（6.0）远远高于其他的概率，当然也会出现比如[4,4,2,4]这样的情况，就是说其他的下标因为给定的概率就低，所以被采样到的概率也就低了。

3. 官网解释中logits，也就是你给的矩阵，每个切片 [i, :] 代表对于所有类的未正规化的log概率（即其和不为1），但必须是小数，就像官网的样例一样，就算是整数，后面也要加一个小数点，否则会报错。

4. 返回值是什么的问题，返回的其实不是抽取到的样本，而是抽取样本在每一行的下标。

import tensorflow as tf;
for i in tf.range(10):
    samples = tf.random.categorical([[1.0,1.0,1.0,1.0,4.0],[1.0,1,1,1,1]], 6)
    tf.print(samples)

输出结果

[[4 4 4 4 4 1]
 [3 1 3 0 4 3]]
[[4 0 4 4 4 1]
 [1 0 2 4 1 2]]
[[0 4 4 0 4 4]
 [3 0 0 1 1 4]]
[[4 4 4 4 4 0]
 [2 1 4 3 4 4]]
[[4 4 2 4 4 4]
 [1 3 1 0 4 0]]
[[4 4 4 4 4 4]
 [3 0 4 1 1 1]]
[[4 4 0 0 4 4]
 [3 3 0 3 2 2]]
[[1 4 4 4 4 4]
 [2 2 1 3 0 2]]
[[4 4 4 4 4 4]
 [2 4 4 3 2 2]]
[[4 4 4 4 3 4]
 [2 4 2 2 1 0]]

看到这估计你就能理解了，其中[[1.0,1.0,1.0,1.0,4.0],[1.0,1,1,1,1]]就是需要进行采样的矩阵，这里加小数点其实可以只加一个，只要让程序知道你用的是概率就行（当然实际都是通过tf.log()得到的不用手动输入），输出结果自然就是样本所在行的下标，多运行几次，就能更直观的感受到，设定的概率和采样结果之间的关系。（比如这里第一行的采样结果很多都是最后一个样本，第二行因为概率相同，采样结果就很均匀）。

super(Student,self).__init__()作用

class Person(object):
    def __init__(self, name, gender, age):
        self.name = name.upper()
        self.gender = gender.upper()
        self.age = age
class Student(Person):
    def __init__(self, name, gender, age, school, score):
        super(Student,self).__init__(name,gender,age)    # 用父类的初始化方法初始化Students的name, gender, age三个属性
        # self.name = name
        # self.gender = gender
        # self.age = age
        self.school = school
        self.score = score
s = Student('Alice', 'female', 18, 'Middle school', 87)
print(s.school)
print(s.name)

这是对继承自父类的属性进行初始化。而且是用父类的初始化方法来初始化继承的属性。也就是说，子类继承了父类的所有属性和方法，父类属性自然会用父类方法来进行初始化。当然，如果初始化的逻辑与父类的不同，不使用父类的方法，自己重新初始化也是可以的。

np.random.choice()的用法

#numpy.random.choice(a, size=None, replace=True, p=None)
#从a(只要是ndarray都可以，但必须是一维的)中随机抽取数字，并组成指定大小(size)的数组
#replace:True表示可以取相同数字，False表示不可以取相同数字
#数组p：与数组a相对应，表示取数组a中每个元素的概率，默认为选取每个元素的概率相同。
除了numpy中的数组，python内建的list（列表）、tuple（元组）也可以使用。

详解及代码举例

产生随机数

>>>np.random.choice(5)#从[0, 5)中随机输出一个随机数
#相当于np.random.randint(0, 5)
	2
>>>np.random.choice(5, 3)#在[0, 5)内输出五个数字并组成一维数组（ndarray）
#相当于np.random.randint(0, 5, 3)
	array([1, 4, 1])

从数组、列表或元组中随机抽取---必须一维

L = [1, 2, 3, 4, 5]#list列表
T = (2, 4, 6, 2)#tuple元组
A = np.array([4, 2, 1])#numpy,array数组,必须是一维的
A0 = np.arange(10).reshape(2, 5)#二维数组会报错
>>>np.random.choice(L, 5)
	array([3, 5, 2, 1, 5])
>>>np.random.choice(T, 5)
	array([2, 2, 2, 4, 2])
>>>np.random.choice(A, 5)
	array([1, 4, 2, 2, 1])
>>>np.random.choice(A0, 5)#如果是二维数组，会报错
	ValueError: 'a' must be 1-dimensional

• 参数replace
  用来设置是否可以取相同元素：
  True表示可以取相同数字；
  False表示不可以取相同数字。
  默认是True

np.random.choice(5, 6, replace=True)#可以看到有相同元素
	array([3, 4, 1, 1, 0, 3])
np.random.choice(5, 6, replace=False)#会报错，因为五个数字中取六个，不可能不取到重复的数字
	ValueError: Cannot take a larger sample than population when 'replace=False'

• 参数p

p实际是个数组，大小（size）应该与指定的a相同，用来规定选取a中每个元素的概率，默认为概率相同

>>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']
>>> np.random.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])
	array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'], dtype='|S11')
#可以看到，‘pooh’被选取的概率明显比其他几个高很多

tf.clip_by_value()函数

tf.clip_by_value(A, min, max)：输入一个张量A，把A中的每一个元素的值都压缩在min和max之间。小于min的让它等于min，大于max的元素的值等于max。

tf.placeholder()函数解析

tf.placeholder()函数作为一种占位符用于定义过程，可以理解为形参，在执行的时候再赋具体的值。

tf.placeholder(
    dtype,
    shape=None,
    name=None
)

参数：

dtype：数据类型。常用的是tf.float32，tf.float64等数值类型
shape：数据形状。默认是None，就是一维值，也可以多维，比如：[None，3]，表示列是3，行不一定
name：名称
返回：

Tensor类型

此函数可以理解为形参，用于定义过程，在执行的时候再赋具体的值。

不必指定初始值，可在运行时，通过 Session.run 的函数的 feed_dict 参数指定。这也是其命名的原因所在，仅仅作为一种占位符。

demo：

import tensorflow as tf
import numpy as np
# 定义placeholder
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)
# 定义乘法运算
output = tf.multiply(input1, input2)
# 通过session执行乘法运行
with tf.Session() as sess:
    # 执行时要传入placeholder的值
    print sess.run(output, feed_dict = {input1:[7.], input2: [2.]})

结果> [14.]

import tensorflow as tf
import numpy as np
x = tf.placeholder(tf.float32, shape=(1024, 1024))
y = tf.matmul(x, x)
with tf.Session() as sess:
#  print(sess.run(y))  # ERROR: 此处x还没有赋值.
  rand_array = np.random.rand(1024, 1024)
  print(sess.run(y, feed_dict={x: rand_array}))  # Will succeed.

> [[240.76114 244.46692 263.50317 ... 262.20663 263.7563  249.67624]
   [242.09816 253.64767 268.32532 ... 264.11237 260.7736  250.82085]
   [242.47516 245.25845 262.3011  ... 256.1698  254.3529  250.21765]
   ...
   [256.5986  265.0628  276.57742 ... 272.2212  277.17657 266.4881 ]
   [246.27658 250.78848 262.4334  ... 258.74762 259.81946 249.15094]
   [243.97534 254.9902  264.48654 ... 262.31183 260.91547 256.02576]]

tf.Session()

Session 是 Tensorflow 为了控制,和输出文件的执行的语句. 运行 session.run() 可以获得你要得知的运算结果, 或者是你所要运算的部分.

import tensorflow as tf
# create two matrixes
matrix1 = tf.constant([[3,3]])
matrix2 = tf.constant([[2],
                       [2]])
product = tf.matmul(matrix1,matrix2)

因为 product 不是直接计算的步骤, 所以我们会要使用 Session 来激活 product 并得到计算结果. 有两种形式使用会话控制 Session 。

# method 1
sess = tf.Session()
result = sess.run(product)
print(result)
sess.close()

# method 2
with tf.Session() as sess:
result2 = sess.run(product)
print(result2)