我知道Python中的函数是一等公民，这意味着它们是function类的对象，就像类5的对象一样int。这意味着在它们生命周期的某个时刻会调用构造函数。对于大多数函数，我希望在定义它们时会发生这种情况（因为大多数函数大概只定义一次），这样无论我们使用多少次，我们只支付一次构建价格。
但是嵌套函数呢？每次调用它们的父级时，它们都会被重新定义。这是否意味着我们每次都会重新构造该对象？如果是的话，那不是效率很低吗？私有方法（假设父函数是一个方法）或另一个函数不是更高效吗？我忽略了支持嵌套讨论的范围论点。
我进行了一个简单的实验，似乎支持我上述的论点，因为内部函数版本较慢：
import time
def f(x, y):
def defined_inside(x, y):
return x + y
return defined_inside(x, y)
def defined_outside(x, y):
return x + y
def g(x, y):
return defined_outside(x, y)
start = time.time()
for i in range(10000000):
_ = f(3, 4)
end = time.time()
print("Using inner function it took {} seconds".format(end - start))
start = time.time()
for i in range(10000000):
_ = g(3, 4)
end = time.time()
print("Using outer function it took {} …我收集了大量文档，每个文档由大约 10 个句子组成。对于每个文档，我希望找到最大化困惑度的句子，或者等效于微调因果 LM 的损失。我决定使用 Hugging Face 和distilgpt2模型来实现此目的。当尝试以有效（矢量化）方式进行操作时，我遇到两个问题：
分词器需要填充才能在批处理模式下工作，但是在计算填充的损失时，input_ids这些填充标记会造成损失。因此，给定句子的损失取决于批次中最长句子的长度，这显然是错误的。
当我将一批输入 ID 传递给模型并计算损失时，我得到一个标量，因为它（意思是？）跨批次池化。相反，我需要的是每件物品的损失，而不是汇总的损失。
我制作了一个逐句运行的版本，虽然正确，但速度非常慢（我想总共处理约 2500 万个句子）。有什么建议吗？
下面的最小示例：
# Init
tokenizer = AutoTokenizer.from_pretrained("distilgpt2")
tokenizer.pad_token = tokenizer.eos_token
model = AutoModelForCausalLM.from_pretrained("clm-gpu/checkpoint-138000")
segmenter = spacy.load('en_core_web_sm')
# That's the part I need to vectorise, surely within a document (bsize ~ 10)
# and ideally across documents (bsize as big as my GPU can handle)
def select_sentence(sentences):
"""We pick the sentence that maximizes perplexity"""
max_loss, best_index = 0, 0
for i, sentence in …python nlp huggingface-transformers large-language-model huggingface-evaluate
我最近开始使用dash开发我的第一个仪表板应用程序。
教程很容易理解，但是，我很难处理前端细节，因为我找不到 API 参考。具体来说，每个元素都接受一个style参数，让我们修改一些 CSS 细节，比如文本对齐、字体等。我在教程中看到了一些例子，但我很想有一个我可以在那里传递的所有内容的详尽列表。
例如，我想创建一个表，但列太靠近。我需要控制它们之间的间距，我想应该有一个像padding, spacing, borderSize...这样的论点，你明白了。我在哪里可以找到这些详细信息？
在学习有关 Scala 的一些教程时，我想到了这个问题，但我认为一般来说，在函数式编程方面很有趣。
我不确定 FP 中不变性的重要性。我可以想到两种不同的情况：
1) 类方法不返回实际字段，而是返回它们的副本。例如，如果我们有一个需要保持不可变的类 Dog，那么它的功能：
getToys() { return new ArrayList(this.toys); }
代替：
getToys() { return this.toys; }
这种情况对我来说很有意义，在第二种情况下，客户端代码实际上可能会损坏对象。我的怀疑在于第二种情况：
2) 在 Scala 和大多数其他 FP 语言中，我们更喜欢递归调用：
sum(x: List[Int], acc: Int) {
if(x.isEmpty) return acc;
sum(x.tail, acc + x.head);
}
与传统的 for 循环递增累加器相反。原因是这个累加器是一个可变变量。
那个变量永远不会暴露在函数之外，所以为什么要让它不可变呢？
编辑：
似乎最重要的最佳实践是引用透明性而不是严格的不变性，这意味着我们不关心可变状态，只要它不能被客户端代码发现。然而，人们仍然声称，即使可变状态影响局部变量（如我的第一个示例），代码也更具可读性或更易于推理。
就个人而言，我认为循环比递归更具可读性。
所以真正的问题是：为什么使用不可变变量的代码更容易阅读/推理？