小编Eng*_*ero的帖子

我对张量流很困惑tf.layers.batch_normalization.

我的代码如下:

def my_net(x, num_classes, phase_train, scope):
    x = tf.layers.conv2d(...)
    x = tf.layers.batch_normalization(x, training=phase_train)
    x = tf.nn.relu(x) 
    x = tf.layers.max_pooling2d(...)

    # some other staffs
    ...

    # return 
    return x

def train():
    phase_train = tf.placeholder(tf.bool, name='phase_train')
    image_node = tf.placeholder(tf.float32, shape=[batch_size, HEIGHT, WIDTH, 3])
    images, labels = data_loader(train_set)
    val_images, val_labels = data_loader(validation_set)
    prediction_op = my_net(image_node, num_classes=2,phase_train=phase_train, scope='Branch1')

    loss_op = loss(...)
    # some other staffs
    optimizer = tf.train.AdamOptimizer(base_learning_rate)
    update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
    with tf.control_dependencies(update_ops):
        train_op = optimizer.minimize(loss=total_loss, global_step=global_step)
    sess = ...
    coord …

手头的简单任务:运行N个时期的训练,在每个时期之后执行计算精确的验证准确性.时期大小可以等于完整训练集或某些预定义的迭代次数.在验证期间,每个验证集输入必须只进行一次评估.

将one_shot_iterators,初始化迭代器和/或句柄混合在一起的最佳方法是什么？

这是我认为它应该如何工作的脚手架:

def build_training_dataset():
    pass

def build_validation_dataset():
    pass

def construct_train_op(dataset):
    pass

def magic(iterator):
    pass

USE_CUSTOM_EPOCH_SIZE = True
CUSTOM_EPOCH_SIZE = 60
MAX_EPOCHS = 100


training_dataset = build_training_dataset()
validation_dataset = build_validation_dataset()


# Magic goes here to build a nice one-instance dataset
dataset = magic(training_dataset, validation_dataset)

train_op = construct_train_op(dataset)

# Run N epochs in which the training dataset is traversed, followed by the
# validation dataset.
with tf.Session() as sess:
    for epoch in MAX_EPOCHS:

        # train
        if USE_CUSTOM_EPOCH_SIZE:
            for _ in range(CUSTOM_EPOCH_SIZE): …

我想重新采样一个包含日期时间列和其他键的多索引的DataFrame.Dataframe看起来像:

import pandas as pd
from StringIO import StringIO

csv = StringIO("""ID,NAME,DATE,VAR1
1,a,03-JAN-2013,69
1,a,04-JAN-2013,77
1,a,05-JAN-2013,75
2,b,03-JAN-2013,69
2,b,04-JAN-2013,75
2,b,05-JAN-2013,72""")

df = pd.read_csv(csv, index_col=['DATE', 'ID'], parse_dates=['DATE'])
df.columns.name = 'Params'

因为重新采样只允许在数据时间索引上,所以我认为取消堆叠其他索引列会有所帮助.事实确实如此,但事后再也无法再叠加了.

print df.unstack('ID').resample('W-THU')

Params      VAR1      
ID               1     2
DATE                    
2013-01-03      69  69.0
2013-01-10      76  73.5

但是再次堆叠 'ID'会导致索引错误:

print df.unstack('ID').resample('W-THU').stack('ID')

IndexError: index 0 is out of bounds for axis 0 with size 0

奇怪的是,我可以将两个列级别堆叠起来:

print df.unstack('ID').resample('W-THU').stack(0)

和

print df.unstack('ID').resample('W-THU').stack('Params')

如果我重新排序(交换)两个列级别,也会发生索引错误.有谁知道如何克服这个问题？

我有一个通用函数,它定义了我计划使用的ODE形式scipy.integrate.odeint,例如:

def my_ode(K, tau, y, u):
  return K*u/tau - y/tau  # dydt

我的代码中有几个对象,它们都具有定义的形式的动态my_ode,但具有唯一的参数K和tau.我希望能够my_ode在我初始化对象时使用已设置的参数传递一个独特的句柄,这样当我更新我的对象时,我所要做的就是soln = odeint(my_ode, t, y, u)模拟时间t.

例如,如果我定义一个类:

class MyThing:
  def __init__(self, ode, y0):
    # I would rather not maintain K and tau in the objects, I just want the ODE with unique parameters here.
    self.ode = ode
    self.y = y0
    self.time = 0.0

  def update(self, t, u):
    # I want this to look something …

在张量流上的cifar10示例中,卷积层似乎没有重量衰减.实际上除了两个完全连接的层之外,任何层都没有重量衰减.这是一种常见做法吗？我认为重量衰减适用于所有重量(偏差除外).

作为参考,这里是相关代码(wd是重量衰减因子):

  # conv1
  with tf.variable_scope('conv1') as scope:
    kernel = _variable_with_weight_decay('weights', shape=[5, 5, 3, 64],
                                         stddev=1e-4, wd=0.0)
    conv = tf.nn.conv2d(images, kernel, [1, 1, 1, 1], padding='SAME')
    biases = _variable_on_cpu('biases', [64], tf.constant_initializer(0.0))
    bias = tf.nn.bias_add(conv, biases)
    conv1 = tf.nn.relu(bias, name=scope.name)
    _activation_summary(conv1)

  # pool1
  pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
                         padding='SAME', name='pool1')
  # norm1
  norm1 = tf.nn.lrn(pool1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75,
                    name='norm1')

  # conv2
  with tf.variable_scope('conv2') as scope:
    kernel = _variable_with_weight_decay('weights', …

这可能是Tensorflow的重复:如何在批处理中获得每个实例的渐变？.无论如何,我问它,因为没有一个令人满意的答案,这里的目标有点不同.

我有一个非常大的网络,我可以放在我的GPU上,但我可以提供的最大批量大小是32.任何大于此的东西都会导致GPU耗尽内存.我想使用更大的批次以获得更精确的渐变近似值.

具体来说,假设我想通过依次喂3批32个来计算大批量96的梯度.我所知道的最好方法是使用Optimizer.compute_gradients()和Optimizer.apply_gradients().这是一个小例子,它是如何工作的

import tensorflow as tf
import numpy as np

learn_rate = 0.1

W_init = np.array([ [1,2,3], [4,5,6], [7,8,9] ], dtype=np.float32)
x_init = np.array([ [11,12,13], [14,15,16], [17,18,19] ], dtype=np.float32)

X = tf.placeholder(dtype=np.float32, name="x")
W = tf.Variable(W_init, dtype=np.float32, name="w")
y = tf.matmul(X, W, name="y")
loss = tf.reduce_mean(y, name="loss")

opt = tf.train.GradientDescentOptimizer(learn_rate)
grad_vars_op = opt.compute_gradients(loss)

sess = tf.Session()
sess.run(tf.global_variables_initializer())

# Compute the gradients for each batch
grads_vars1 = sess.run(grad_vars_op, feed_dict = {X: x_init[None,0]}) …

在TensorFlow对象检测的示例管道配置文件中,有以下代码段:

  eval_config: {
    num_examples: 2000
    # Note: The below line limits the evaluation process to 10 evaluations.
    # Remove the below line to evaluate indefinitely.
    max_evals: 10
  }

"num_examples"是否表示每个评估运行使用相同的前2000个图像,或者它将测试集视为循环缓冲区并且每次使用不同的2000个图像？

这个问题更具概念性/理论性（与非常大的数据集的运行时间有关），所以我很抱歉没有一个最小的例子来展示。

我有一堆来自两个不同传感器的数据帧，我需要最终将它们连接成来自两个不同传感器（和）的两个非常大的数据帧，然后左连接成一个数据帧。我的数据是这样的，我也可以先加入，然后连接，或某种组合。我试图找出最有效的方法来做到这一点。df_snsr1df_snsr2

通过阅读这个 SO 答案，我知道它会pandas.concat为其所有数据帧的串联分配空间，如果您在循环中执行此操作，则可能会导致O(N**2)复制和一些主要的减速。因此，我目前首先构建一个大的数据帧列表（从文件加载），一次连接它们，然后加入两个大数据帧：

df_list = []
for file in my_pickle_files_snsr1:  # O(M) loop over M files
    df_list.append(pd.read_pickle(file))  # O(1) append, M times
df_snsr1 = pd.concat(df_list)  # O(N) copies of N records
# repeat for sensor 2 (df_snsr2)
df_snsr1.join(df_snsr2, on=['some', 'columns'])  # O(dunno, maybe bears?)

我无法在pandas.DataFrame.join. 是O(N)吗？O(N**2)? 我的想法是，如果它的顺序与 相似pandas.concat，那么我执行这两个操作的顺序真的无关紧要。O(N**2)但是，如果是，那么加入许多小数据帧然后连接对我来说可能会更有效他们而不是 concat 然后加入。整个操作需要足够长的时间，值得我在这里提出问题，所以“运行它并查看”是行不通的。

有人知道join正在使用什么算法以及它的执行大 O 顺序是什么吗？或者有人对获得最有效的join和组合有任何其他建议concat …

在 Andrew Ng 对 ML 进行 MOOC 时，他在理论上解释了theta'*X给我们假设，而在做课程时我们使用theta*X. 为什么会这样？

为什么链接器找不到absl引用？

配置：

树莓派 4 B 型 (AArch64) | Ubuntu 服务器 20.04 | Clang++ (llvm 13.0.0) | GRPC v1.41.1（libprotoc 3.17.3）

使用以下选项安装 GRPC：

cmake -DgRPC_INSTALL=ON -DCMAKE_BUILD_TYPE=Release -DgRPC_ABSL_PROVIDER=module -DgRPC_CARES_PROVIDER=module -DgRPC_PROTOBUF_PROVIDER=module -DgRPC_RE2_PROVIDER=module -DgRPC_SSL_PROVIDER=module -DgRPC_ZLIB_PROVIDER=module -j4 ../

sudo make install

命令：

clang++ -std=c++17 -iquote /home/ubuntu/gameserver/server/include -include /usr/local/include/grpcpp/support/method_handler.h -L /usr/local/lib src/gameserver.pb.cc src/gameserver.grpc.pb.cc server_test.cpp -lprotobuf -lpthread -ljsoncpp -lgrpc -lgrpc++ -lgrpc++_reflection -labsl_base -labsl_synchronization -labsl_malloc_internal -labsl_stacktrace -labsl_raw_logging_internal -labsl_time -labsl_graphcycles_internal -labsl_spinlock_wait -lgrpc_unsecure -lz -labsl_symbolize -lgpr -labsl_status -labsl_statusor -o server_test -v -Wl,--verbose

链接器找到基类（在此 [header][1] 中找到）：

/usr/local/lib/libabsl_base.a

错误：

/usr/bin/ld: /usr/local/lib/libabsl_synchronization.a(mutex.cc.o): in function …