小编Phy*_*ade的帖子

甲Keras模型可以用作一个张量一个Tensorflow功能,通过所述功能API,如所描述这里.

所以我们可以这样做:

from keras.layers import InputLayer

a = tf.placeholder(dtype=tf.float32, shape=(None, 784))

model = Sequential()
model.add(InputLayer(input_tensor=a, input_shape=(None, 784)))
model.add(Dense(32, activation='relu'))
model.add(Dense(10, activation='softmax'))

output = model.output

这是一个张量:

<tf.Tensor 'dense_24/Softmax:0' shape=(?, 10) dtype=float32>

但是,这也没有任何作用InputLayer:

a = tf.placeholder(dtype=tf.float32, shape=(None, 784))

model = Sequential()
model.add(Dense(32, activation='relu', input_shape=(784,)))
model.add(Dense(10, activation='softmax'))

output = model(a)

工作,并output具有与以前相同的形状:

<tf.Tensor 'sequential_9/dense_22/Softmax:0' shape=(?, 10) dtype=float32>

我假设第一种形式允许:

• 明确地附加inputs和outputs作为模型(相同名称)的属性,因此我们可以在其他地方重用它们.例如与其他TF操作.
• 转化给定为投入Keras输入的张量,用另外的元数据(例如_keras_history在所述源代码中).

但这不是我们不能用第二种形式做的事情,所以,是否有特殊用法InputLayer(和Input一个更好的)(除了多个输入)？
此外,这InputLayer很棘手,因为它input_shape与其他keras层的使用方式不同:我们指定批量大小( …

根据keras 文档:

predict_on_batch(self, x)
Returns predictions for a single batch of samples.

但是,predict在批处理调用时,标准方法似乎没有任何差别,无论是使用一个还是多个元素.

model.predict_on_batch(np.zeros((n, d_in)))

是相同的

model.predict(np.zeros((n, d_in)))

(一个numpy.ndarray形状(n, d_out)

根据文档，dlopen与dlopen一起dlsym用于加载库，并获取指向符号的指针。

但这已经是动态加载器/链接器所做的。此外，这两种方法都基于ld.so。

使用时实际上似乎有两个不同之处dlopen：

1. 该库可以有条件地加载。
2. 编译器不知道我们正在使用的符号（类型、原型...），因此不会检查潜在的错误。顺便说一下，这是实现自省的一种方式。

但是，它似乎并没有激发使用dlopen超标准加载，除了边际示例：

1. 就内存占用优化而言，当共享库已被另一个程序使用时，条件加载并不是很有趣：加载已使用的库不会增加内存占用。
2. 避免编译器监督是不安全的，也是编写错误的好方法......我们也错过了潜在的编译器优化。

那么，是否有其他用途dlopen比标准动态链接/加载更受欢迎？

Tensorflow 2.0的官方文档建议tf.data.Dataset与tf.function.

这种用途有两个例子：

• 使用Dataset作为的参数tf.function，如描述在这里：

@tf.function
def train(model, dataset, optimizer):
  for x, y in dataset:
      ....

• 创建本地Dataset的tf.function身体，描述在这里：

@tf.function
def train(model, optimizer):
  train_ds = mnist_dataset()
  ...

最后，签名文档指出对 a 的迭代Dataset是由 优化的tf.function。 这个 SO 答案确实表明使用 aDataset作为tf.function提高性能的参数。

那么，如何tf.data.Dataset从中受益tf.function，以及它如何解释这个 SO 答案的加速：

• “for循环优化”如何自己创造加速？
• 跟踪器如何Dataset处理对象tf.function。就像在参数中或作为局部变量的例子一样，我们如何Dataset在 a …

在 Tensorflow 2.0 中，我们看到的主要“张量”实际上是EagerTensors（tensorflow.python.framework.ops.EagerTensor更准确地说）：

x = [[2.]]
m = tf.matmul(x, x)
type(m)
# returns tensorflow.python.framework.ops.EagerTensor

但是，在某些情况下，我们有符号Tensor对象 ( tensorflow.python.framework.ops.Tensor)，就像在 TF1.X 中一样。
例如在 keras 中：

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential()
model.add(Dense(units=64, activation='relu', input_dim=100))
model.add(Dense(units=10, activation='softmax'))
type(model.outputs[0])
# returns tensorflow.python.framework.ops.Tensor

那么，这些符号有什么用：tensorflow.python.framework.ops.Tensor在 Tensorflow 中：

• 在 TF 库内部：Keras 至少使用了这些张量，但它是否在其他地方使用（使用图形，如 tf.function 或 tf.data.Dataset）？
• 在 API 中：这些最终用户是否有实际用途？

作为这个问题的后续，似乎 (C)Python 中的小变量和大变量有不同的分配/释放策略。
更准确地说，对象大小似乎存在一个边界，超过该边界，分配的对象使用的内存可以返回给操作系统。低于此大小，内存不会返回给操作系统。

引用 Numpy 内存释放策略中的答案：

例外情况是，对于大型单个分配（例如，如果您创建多兆字节数组），则使用不同的机制。如此大的内存分配可以释放回操作系统。因此，可能是程序中的非 numpy 部分产生了您看到的问题。

事实上，这两种分配策略很容易显示。例如：

• 第一个策略：不将内存返还给操作系统

import numpy as np
import psutil
import gc

# Allocate  array
x = np.random.uniform(0,1, size=(10**4))

# gc
del x
gc.collect()
# We go from 41295.872 KB to 41295.872 KB
# using psutil.Process().memory_info().rss / 10**3; same behavior for VMS

=> 没有内存返回给操作系统

• 第二种策略：释放的内存返回给操作系统

当做相同的实验，但使用更大的数组时：

x = np.random.uniform(0,1, size=(10**5))

del x
gc.collect()
# We go from 41582.592 KB to 41017.344 KB

=> 内存被释放给操作系统

似乎8*10**4使用第二种策略分配大约大于字节的对象。

所以：

• 这种行为有记录吗？（分配策略发生变化的确切边界是什么？）
• 这些策略的内部原理是什么（不仅仅是假设使用mmap …

当使用射线框架，还有是选择该任务所需的CPU数量的选项，如解释在这里。

前任：

@ray.remote(num_cpus=4)
def f():
    return 1

然而，目前还不清楚是否会有实际的 CPU 分配：

1. 该函数将逐字分配4CPU（使用例如 CPU 亲和性，如在tasksetlinux 命令中，或cpusetdocker 参数）
2. 或者调度程序将num_cpus仅在内部使用它，作为调度元数据。让 ex 决定他是否可以开始一个需要 16 个 cpu 的新任务，这里只剩下 10 个了。该任务仍然可以访问所有 CPU，并且可以“使用”比请求更多的 CPU 时间num_cpus

选项 2 似乎更有可能，但这在文档中没有说明。此外，GPU 似乎有一种选项 1，这使得调度程序的意图不明确：

Ray 将自动为该进程设置环境变量 CUDA_VISIBLE_DEVICES。

该进程被配置为使用某个 GPU（但可以绕过它，通过重置CUDA_VISIBLE_DEVICES）

那么，num_cpus在ray中是如何使用的呢？

在 Python 中，list该类似乎是collections.abc.Sequence（完全有道理的）的子类：

from collections.abc import Sequence
issubclass(list, Sequence)
# returns True

但列表类型似乎没有继承自Sequence：

dict.__mro__
# returns (dict, object)

那么，这issubclass(list, Sequence)是如何工作的呢？它如何返回True？

在Tensorflow 2.0中，一些变量可以描述为'UnreadVariable'

例如：

b = tf.Variable([4,5], name="test")
print(b.assign([7, 9]))
# Will print
# <tf.Variable 'UnreadVariable' shape=(2,) dtype=int32, numpy=array([7, 9], dtype=int32)>

这是什么意思？

为了设置轴对象的标签，可以使用以下xticklabels方法：

fig, ax = plt.subplots()
ax.imshow(np.eye(101))
labels = np.linspace(2, 4, 4)
ax.set_xticks([0, 33, 66, 100])
ax.set_xticklabels(labels)

这使：

也可以使用格式化程序来格式化标签：

fig, ax = plt.subplots()
labels = np.linspace(2, 4, 4)
ax.imshow(np.eye(101))
ax.set_xticks([0, 33, 66, 100])
ax.set_xticklabels(labels)
ax.xaxis.set_major_formatter(FormatStrFormatter('%.2f'))

但是格式化程序仅使用刻度位置，而不使用其标签：

解决方法是在使用之前手动格式化标签set_xticklabels：

fig, ax = plt.subplots()
labels = ["{0:.1f}".format(x) for x in np.linspace(2, 4, 4)]
ax.imshow(np.eye(101))
ax.set_xticks([0, 33, 66, 100])
ax.set_xticklabels(labels)

因此，有两个问题：

1. 使用set_xticklabels功能时是否可以格式化标签？例如，通过使用格式字符串。
2. set_xticklabels和Formatter之间有什么联系？看来Formatter根本没有考虑set_xticklabels到问题，而是自己产生标签。

当在 Joblib 中使用处理全局变量的函数时，在 Linux 上无需任何副本即可从该函数访问全局变量。

我们可以在以下脚本中对此进行测试：

import joblib
import numpy as np

print("Initializing global")
# Let's create a global that is big, so it takes time to create it
my_global = np.random.uniform(0,100, size=(10**4, 10**4))
print("done")

# A simple function working on the global variable
def fun_with_global():
    return id(my_global)

print("starting // loop")
joblib.Parallel(n_jobs=3, backend="multiprocessing", verbose=100)((joblib.delayed(fun_with_global)() for i in range(1000)))
joblib.Parallel(n_jobs=3, backend="loky", verbose=100)((joblib.delayed(fun_with_global)() for i in range(1000)))
# We get that the two last parallel calls execute almost instantly, even for 1000 …

Numpy数组,即扩展类型(也称为使用扩展C API定义),声明Python解释器范围之外的其他字段(例如data属性Buffer Structure,如Numpy的数组接口中所记录的那样.
能够序列化它,Python 2曾经使用该__reduce__函数作为pickle协议的一部分,如文档中所述,并在此解释.

但是,即使__reduce__仍然存在于Python 3中,该Pickle protocol部分(以及更为Pickling and unpickling extension types复杂的部分)已从文档中删除,因此不清楚它是做什么的.
此外,还有与酸洗扩展类型相关的其他条目:

• copyreg,描述为a Pickle interface constructor registration for extension types,但copyreg模块本身没有提及扩展类型.
• PEP 3118 - 修改缓冲协议,为Python 3发布了一个新的缓冲协议(并且可能自动为这个缓冲协议进行酸洗).
• 新式课程:可以假设新式课程对酸洗过程有影响.

那么,所有这些与Numpy数组有什么关系:

1. Numpy数组是否实现了特殊方法,例如__reduce__告知Python如何腌制它们(或copyreg)？Numpy对象仍然暴露一个__reduce__方法,但可能是出于兼容性原因.
2. Numpy是否使用了Pickle开箱即用的Python的C-API结构(就像新的一样buffer protocol),所以为了挑选numpy数组,不需要任何补充吗？

通过tf.function和可以获得类似的结果autograph.to_graph。
但是，这似乎取决于版本。

例如，函数（取自官方指南）：

def square_if_positive(x):
  if x > 0:
    x = x * x
  else:
    x = 0.0
  return x

可以使用图形模式进行评估：

• autograph.to_graph 在 TF 1.14

tf_square_if_positive = autograph.to_graph(square_if_positive)

with tf.Graph().as_default():
  g_out = tf_square_if_positive(tf.constant( 9.0))
  with tf.Session() as sess:
    print(sess.run(g_out))

• tf.function 在 TF2.0

@tf.function
def square_if_positive(x):
  if x > 0:
    x = x * x
  else:
    x = 0.0
  return x

square_if_positive(tf.constant( 9.0))

所以：

• tf.function和之间是什么关系autograph.to_graph？可以假设tf.function在内部使用autograph.to_graph（以及autograph.to_code），但这远非显而易见。
• autograph.to_graphTF2.0 中是否仍支持该代码段（因为它需要 …