小编Ove*_*gon的帖子

N, M = 1000, 4000000
a = np.random.uniform(0, 1, (N, M))
k = np.random.randint(0, N, (N, M))

out = np.zeros((N, M))
for i in range(N):
    for j in range(M):
        out[k[i, j], j] += a[i, j]

我使用很长的 for 循环；%%timeit在上面pass替换操作产量

1min 19s ± 663 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

这在上下文中是不可接受的（C++ 耗时 6.5 秒）。没有理由使用 Python 对象完成上述操作；数组具有明确定义的类型。在 C/C++ 中实现它作为扩展对开发人员和用户端来说都是一种矫枉过正；我只是将数组传递给循环并进行算术运算。

有没有办法告诉 Numpy“将此逻辑移至 C”，或其他可以处理仅涉及数组的嵌套循环的库？我在一般情况下寻求它，而不是针对这个特定示例的解决方法（但如果你有一个，我可以打开一个单独的问答）。

在回答这个问题之后，我在 tensorflow 2.0 中遇到了一些有趣但令人困惑的发现。logits对我来说看起来不正确的渐变。假设我们有logits和labels这里。

logits = tf.Variable([[0.8, 0.1, 0.1]], dtype=tf.float32)
labels = tf.constant([[1, 0, 0]],dtype=tf.float32)

with tf.GradientTape(persistent=True) as tape:
    loss = tf.reduce_sum(tf.keras.losses.categorical_crossentropy(labels, logits, 
                                                                  from_logits=False))
grads = tape.gradient(loss, logits)
print(grads)

由于logits已经是概率分布，所以我设置from_logits=False了损失函数。

我认为 tensorflow 将用于loss=-\Sigma_i(p_i)\log(q_i)计算损失，如果我们推导q_i，我们将得到导数-p_i/q_i。因此，预期的成绩应该是 [-1.25,0,0]。但是，tensorflow 将返回 [-0.25,1,1]。

阅读 的源代码后tf.categorical_crossentropy，我发现即使我们设置了from_logits=False，它仍然对概率进行了归一化。这将改变最终的梯度表达式。具体来说，梯度将为-p_i/q_i+p_i/sum_j(q_j)。如果p_i=1和sum_j(q_j)=1，最终梯度将加一。这就是梯度为 -0.25 的原因，但是，我还没有弄清楚为什么最后两个梯度为 1。

为了证明所有的梯度都增加了1/sum_j(q_j)，我做了一个 logits，它不是概率分布，并设置为from_logits=False静止。

logits = tf.Variable([[0.5, 0.1, 0.1]], …

我遇到了严重的不兼容性问题，因为相同的代码在一个代码与另一个代码之间却发生了冲突。例如：

• 获得张量值
• 编译模型
• 保存优化器

从Github的源代码来看，这些模块及其导入看起来完全相同，tf.keras甚至从中导入也是如此tf.python.keras。在教程中，我看到两者都经常使用。例如，下面的代码将失败tf.python.keras。

这是怎么回事？有什么区别，什么时候应该使用其中一个？

from tensorflow.keras.layers import Input, Dense
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Nadam
import numpy as np

ipt   = Input(shape=(4,))
out   = Dense(1, activation='sigmoid')(ipt)
model = Model(ipt, out)
model.compile(optimizer=Nadam(lr=1e-4), loss='binary_crossentropy')

X = np.random.randn(32,4)
Y = np.random.randint(0,2,(32,1))
model.train_on_batch(X,Y)

附加信息：

• CUDA 10.0.130，cuDNN 7.4.2，Python 3.7.4，Windows 10
• tensorflow，tensorflow-gpuv2.0.0和Keras 2.3.0（通过pip），其他所有通过Anaconda 3

我正在使用（keras-self-attention）在KERAS中实现注意力LSTM。训练模型后如何可视化注意力部位？这是一个时间序列预测案例。

from keras.models import Sequential
from keras_self_attention import SeqWeightedAttention
from keras.layers import LSTM, Dense, Flatten

model = Sequential()
model.add(LSTM(activation = 'tanh' ,units = 200, return_sequences = True, 
               input_shape = (TrainD[0].shape[1], TrainD[0].shape[2])))
model.add(SeqSelfAttention())
model.add(Flatten())    
model.add(Dense(1, activation = 'relu'))

model.compile(optimizer = 'adam', loss = 'mse')

我想在tensorflow2.0的SGD优化器中降低学习率，我使用了这行代码：tf.keras.optimizers.SGD(learning_rate, decay=lr_decay, momentum=0.9) 但是我不知道我的学习率是否下降了，我怎样才能得到我当前的学习率？

import numpy as np

a = np.array([.4], dtype='float32')
b = np.array([.4, .6])

print(a > b)
print(a > b[0], a > b[1])
print(a[0] > b[0], a[0] > b[1])

[ True False]
[False] [False]
True False

这是怎么回事？是的，b.dtype == 'float64'但是它的切片b[0]&b[1]和a仍然是'float32'。

注意：我问的是为什么会发生这种情况，而不是如何规避它，我知道（例如将两者都转换为'float64'）。

我实现了一个简单的 LSTM 和 GRU 网络来进行时间序列预测：

def LSTM1(T0, tau0, tau1, optimizer):
    model = Sequential()
    model.add(Input(shape=(T0,tau0), dtype="float32", name="Input"))
    model.add(LSTM(units=tau1, activation="tanh", recurrent_activation="tanh", name="LSTM1"))
    model.add(Dense(units=1, activation="exponential", name="Output"))
    model.compile(optimizer=optimizer, loss="mse")
    return model

def GRU1(T0, tau0, tau1, optimizer):
    model = Sequential()
    model.add(Input(shape=(T0,tau0), dtype="float32", name="Input"))
    model.add(GRU(units=tau1, activation="tanh", recurrent_activation="tanh", reset_after=False, name="GRU1"))
    model.add(Dense(units=1, activation="exponential", name="Output"))
    model.compile(optimizer=optimizer, loss="mse")
return model

LSTM 模型的参数明显多于 GRU 模型：

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
LSTM1 (LSTM)                 (None, 5)                 180       
_________________________________________________________________
Output (Dense)               (None, 1)                 6         
=================================================================
Total params: 186
Trainable params: 186 …

我正在使用 PrimeNG 完整日历组件开发一个 Angular 应用程序，这个：https ://primefaces.org/primeng/showcase/#/fullcalendar

那是基于 Angular FullCalendar 组件，这个：https ://fullcalendar.io/

在这里你可以找到我的完整代码：https : //bitbucket.org/dgs_poste_team/soc_calendar/src/master/

所以我有一个这样的日历：

我在这个阶段试图实现的是，当用户点击一个特定的事件时，这个日历中的所有事件都将被删除（在第二阶段我将实现只删除特定的点击事件，但在时刻我保持逻辑尽可能简单）。

所以这是控制我的日历组件的类：

import { Component, OnInit, ViewChild, ElementRef } from '@angular/core';
import { EventService } from '../event.service';
import dayGridPlugin from '@fullcalendar/daygrid';
import timeGridPlugin from '@fullcalendar/timegrid';
import listPlugin from '@fullcalendar/list';
import interactionPlugin, { Draggable } from '@fullcalendar/interaction';
import { FullCalendar } from 'primeng';

@Component({
  selector: 'app-fullcalendar',
  templateUrl: './fullcalendar.component.html',
  styleUrls: ['./fullcalendar.component.css']
})
export class FullcalendarComponent implements OnInit {

  events: any[];
  options: any;
  header: any; …

我检查了.__code__对象的两个我认为不同但发现相同的函数，用于各种表达式。如果代码对象相同，据我所知，它们编译为相同的字节码，因此是“相同”的函数。

下表是之前插入的东西，; pass这使得g有不同的__code__。由于f是一个“什么都不做”的函数，这表明“相同”下的所有内容都不要执行，包括长算术。此外，元组是“相同的”，但列表和字符串是“差异”的——所以我们可能会得出结论，涉及不可变文字的未分配表达式不会被评估。但是，由于引发异常，这可能是“异常” - 那么vs.呢？ 不会引发异常并且可以分配。1/010**9910**910**99

def compare(fn1, fn2):
    for name in dir(fn1.__code__):
        if (name.startswith("co_") …