在使用不同的学习率训练模型后，我正在尝试更改模型的学习率。

我在这里、这里、这里和其他一些我什至找不到的地方阅读。

我试过：

model.optimizer.learning_rate.set_value(0.1)
model.optimizer.lr = 0.1
model.optimizer.learning_rate = 0.1
K.set_value(model.optimizer.learning_rate, 0.1)
K.set_value(model.optimizer.lr, 0.1)
model.optimizer.lr.assign(0.1)

......但他们都没有工作！我不明白这么简单的事情怎么会有如此混乱。我错过了什么吗？

编辑：工作示例

这是我想做的一个工作示例：

from keras.models import Sequential
from keras.layers import Dense
import keras
import numpy as np

model = Sequential()

model.add(Dense(1, input_shape=(10,)))

optimizer = keras.optimizers.Adam(lr=0.01)
model.compile(loss='mse',
              optimizer=optimizer)

model.fit(np.random.randn(50,10), np.random.randn(50), epochs=50)

# Change learning rate to 0.001 and train for 50 more epochs

model.fit(np.random.randn(50,10), np.random.randn(50), initial_epoch=50, epochs=50)

我正在使用numpy einsum对一些3维和4维张量进行相当复杂的操作.

我的实际代码是

np.einsum('oij,imj,mjkn,lnk,plk->op',phi,B,Suu,B,phi)

这就是我想要的.

使用einsum_path,结果是:

>>> path = np.einsum_path('oij,imj,mjkn,lnk,plk->op',phi,B,Suu,B,phi)

>>> print(path[0])
['einsum_path', (0, 1), (0, 3), (0, 1), (0, 1)]

>>> print(path[1])
  Complete contraction:  oij,imj,mjkn,lnk,plk->op
         Naive scaling:  8
     Optimized scaling:  5
      Naive FLOP count:  2.668e+07
  Optimized FLOP count:  1.340e+05
   Theoretical speedup:  199.136
  Largest intermediate:  7.700e+02 elements
--------------------------------------------------------------------------
scaling                  current                                remaining
--------------------------------------------------------------------------
   4                imj,oij->moj                     mjkn,lnk,plk,moj->op
   5               moj,mjkn->nok                          lnk,plk,nok->op
   4                plk,lnk->npk                              nok,npk->op
   4                 npk,nok->op                                   op->op

这表明理论加速约为200倍.

如何使用此结果来加速我的代码？我如何"实现"einsum_path告诉我的内容？

pandas.groupby.aggregate我正在尝试使用自定义聚合函数来提高操作的性能。我注意到 - 如果我错了，请纠正我 -pandas按顺序调用每个块上的聚合函数（我怀疑它是一个简单的for循环）。

由于pandas很大程度上基于，有没有办法使用 的矢量化特征numpy来加速计算？numpy

我的代码

在我的代码中，我需要将风数据平均样本聚合在一起。虽然平均风速很简单，但平均风向需要更多的临时代码（例如，1 度和 359 度的平均值是 0 度，而不是 180 度）。

我的聚合函数的作用是：

1. 删除 NaN
2. 如果不存在其他值则返回 NaN
3. 检查是否存在指示可变风向的特殊标志。如果是，则返回标志
4. 使用矢量平均算法平均风向

其功能是：

def meandir(x):
    '''
    Parameters
    ----------
    x : pandas.Series
        pandas series to be averaged

    Returns
    -------
    float
        averaged wind direction
    '''

    # Removes the NaN from the recording
    x = x.dropna()

    # If the record is empty, return NaN
    if len(x)==0:
        return np.nan

    # If the record …

我有一个干净的 Anaconda 安装，由于某种原因，它附带了 Python 3.8.8，而我知道最新的稳定版本应该是 3.10。如果我跑

conda update python

系统询问我是否要安装 3.8.12。

我知道我可以创建一个新环境

conda create -n py310 python=3.10

不过，我想用新的 3.10 环境“替换”基本的 3.8.8 环境。是否可以在基础环境中更新python？如果没有，我可以创建一个新环境，然后base用新环境替换该环境吗？

我有一个带有一小时信号的数据帧.我想在10分钟内将它们分组.问题是起始时间并不恰好是10分钟的"倍数",因此,我获得了7个,第一个和最后一个不完整,而不是获得6个组.

这个问题很容易重现

import pandas as pd
import numpy as np
import datetime as dt

rng = pd.date_range('1/1/2011 00:05:30', periods=3600, freq='1S')
ts = pd.DataFrame({'a':np.random.randn(len(rng)),'b':np.random.randn(len(rng))}, index=rng)

interval = dt.timedelta(minutes=10)

ts.groupby(pd.Grouper(freq=interval)).apply(len)

2011-01-01 00:00:00    270
2011-01-01 00:10:00    600
2011-01-01 00:20:00    600
2011-01-01 00:30:00    600
2011-01-01 00:40:00    600
2011-01-01 00:50:00    600
2011-01-01 01:00:00    330
Freq: 10T, dtype: int64

我试着像这里描述的那样解决它,但base只需要整数分钟.对于上面的示例(从00:05之后的30秒开始),下面的代码仍然不起作用

ts.groupby(pd.Grouper(freq=interval, base=ts.index[0].minute)).apply(len)

如何设置Grouper的通用开始时间？我的预期产量是

2011-01-01 00:05:30    600
2011-01-01 00:15:30    600
2011-01-01 00:25:30    600
2011-01-01 00:35:30    600
2011-01-01 00:45:30    600
2011-01-01 00:55:30    600

是否可以从另一个静态方法中调用静态方法？

我试过这个:

class MyClass(object):

    @staticmethod
    def static_method_1(x):
        x = static_method_2(x)
        print x

    @staticmethod
    def static_method_2(x):
        return 2*x

这回来了

NameError: name 'static_method_2' is not defined

matplotlib.figure.Figure.add_subplots()( doc ) 应该返回一个轴。

然而，做

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot()
print(ax)

返回None。

同样的情况发生在ax = fig.add_axes()

为什么会发生这种情况以及如何获取轴句柄？

我有一个多标签分类，其中每个目标都是一个不互斥的 1 和 0 向量（为了清楚起见，我的目标类似于[0, 1, 0, 0, 1, 1, ... ]）。

到目前为止我的理解是：

• 我应该使用二元交叉熵函数。（如本答案所述）

• 另外，我知道这tf.keras.losses.BinaryCrossentropy()是围绕 tensorflow 的sigmoid_cross_entropy_with_logits. 这可以与from_logits True或一起使用False。（如本问题所述）

• 由于sigmoid_cross_entropy_with_logits自己执行 sigmoid，它期望输入在 [-inf,+inf] 范围内。

• tf.keras.losses.BinaryCrossentropy()，当网络实现自己最后一层的 sigmoid 激活时，必须与 一起使用from_logits=False。然后它将推断 sigmoid 函数并将输出传递给sigmoid_cross_entropy_with_logits将再次执行 sigmoid的输出。然而，由于 sigmoid/logit 函数的渐近线，这可能会导致数值问题。

• 为了提高数值稳定性，我们可以避免最后一个 sigmoid 层并使用 tf.keras.losses.BinaryCrossentropy(from_logits=False)

题：

如果我们使用tf.keras.losses.BinaryCrossentropy(from_logits=False)，我应该使用什么目标？我是否需要更改 one-hot 向量的目标？

我想我应该在推理时将 sigmoid 激活应用于网络输出。有没有办法添加仅在推理模式下而不是在训练模式下活动的 sigmoid 层？

我想检索存储在 FTP 服务器上的压缩 gz 文件中的数据，而不将该文件写入本地存档。

目前我已经完成了

from ftplib import FTP
import gzip

ftp = FTP('ftp.server.com')
ftp.login()  
ftp.cwd('/a/folder/')

fileName = 'aFile.gz'

localfile = open(fileName,'wb')
ftp.retrbinary('RETR '+fileName, localfile.write, 1024)

f = gzip.open(localfile,'rb')
data = f.read()

但是，这会将文件“localfile”写入当前存储。

我试图改变这一点

from ftplib import FTP
import zlib

ftp = FTP('ftp.server.com')
ftp.login()  
ftp.cwd('/a/folder/')

fileName = 'aFile.gz'

data = ftp.retrbinary('RETR '+fileName, zlib.decompress, 1024)

但是，ftp.retrbinary不输出其回调的输出。有没有办法做到这一点？

我有一个包含对象列表的字典作为

objects = {'A1': obj_1,
    'A2': obj_2,
    }

然后我有一个字符串

cmd = '(1.3A1 + 2(A2 + 0.7A3)) or 2(A4 to A6)'

我想把它翻译成一个命令

max( 1.3*objects['A1'] + 2*(objects['A2'] + 0.73*objects['A3']), 2*max(objects['A4'], objects['A5'], objects['A6']))

我的尝试

由于没有找到更好的选择，我开始从头开始编写解析器。

个人注意：我不认为将 150 行代码附加到 SO 问题是好的做法，因为这意味着读者应该阅读并理解它，这是一项艰巨的任务。尽管如此，我之前的问题被否决了，因为我没有提出我的解决方案。所以你来了...

import re
from more_itertools import stagger

def comb_to_py(string, objects):

    # Split the line
    toks = split_comb_string(string)

    # Escape for empty string
    if toks[0] == 'none':
        return []

    # initialize iterator
    # I could use a deque here. Let's see what works the best …

在执行脚本期间查看资源监视器，我注意到我的 PC 的所有核心都在工作，即使我没有实现任何形式的多处理。numpy为了查明原因，我发现使用's matmult（或者如下例中的二元运算符@）时代码是并行的。

import numpy as np

A = np.random.rand(10,500)
B = np.random.rand(500,50000)
while True:
    _ = A @ B

看看这个问题，看起来原因是numpy调用了BLAS/LAPACK确实并行的例程。

尽管我的代码运行得更快并且使用了所有可用资源，这很好，但当我在PBS队列管理器管理的共享集群上提交代码时，这给我带来了麻烦。与集群 IT 经理一起，我们注意到，即使我在集群节点上请求 N 个 CPU，numpy仍然会产生与该节点上的 CPU 数量相等的线程数。

这导致节点过载，因为我使用的 CPU 数量多于分配给我的 CPU 数量。

有没有办法“控制”这种行为并告诉numpy它可以使用多少个CPU？