在我们通过 d3 操作的 SVG 中需要文本元素的情况并不少见，例如分类刻度标签。这有点不幸，因为<text>SVG 中的元素不是最好的......渲染的字体大小通常略大于人们认为字体应该占用的大小。例如，如果选择宽度/高度比为 0.6 的等宽字体（例如，如果字体大小为 12px，则字符的宽度应为 7.2px），则元素的计算边界矩形可能为 14.2px x n *8px其中n是字符数。

使问题进一步复杂化的事实是，人们通常使用非等宽字体。

很容易截断一个“太长”的字符串

string.slice(0, numChars-3)+'...'

但是知道适合固定宽度的正确字符数似乎并非易事。

function truncateText(t, text, space) {
  // make sure it is a string
  text = String(text)
  // set text
  t.text(text)
  // get space it takes up
  var rect = t.node().getBoundingClientRect()

  while (Math.max(rect.width, rect.height) > space) {
    text = text.slice(0, text.length - 1)
    t.text(text + '...')
    rect = t.node().getBoundingClientRect()
    if (text.length == 0) break
  }
}

上面的函数需要一个 d3.selection，文本和文本应该适合的空间。通过不断操作 DOM，我们可以得到完美的拟合，但是这在计算上非常昂贵。 …

我正在尝试创建一个具有拖动和单击事件的元素。我已经阅读并尝试了事件修饰符的组合。

但是，无论我尝试什么，当拖动停止时我都会听到一声点击。

请注意，在 MWE 中，这是在组件本身上完成的，但在我的实际应用程序中，我使用.native修改器来拖动组件

如何在不点击的情况下拖动？

成分Draggable：

<template>
  <div
    @pointerdown="handleDown"
    @pointerup="handleUp"
    @pointercancel="handleUp"
    @click="click = !click;"
    :style="style"
    ref="draggableRoot"
    class="draggable"
  >
    drag me!<br />
    am dragged? {{ drag }}<br />
    am clicked? {{ click }}<br />
  </div>
</template>
<script>
export default {
  computed: {
    style() {
      return {
        left: `${this.x}px`,
        top: `${this.y}px`
      };
    }
  },
  data() {
    return {
      x: 100,
      y: 100,
      left: 0,
      top: 0,
      drag: false,
      click: false
    };
  },
  methods: …

在几乎所有关于 vuex 模块注册的指南、教程、帖子等中，如果模块由组件注册，则createNamespacedHelpers在export default组件语句之前导入和定义，例如：

import {createNamespacedHelpers} from 'vuex'
const {mapState} = createNamespacedHelpers('mymod')

import module from '@/store/modules/mymod'

export default {
  beforeCreated() {
    this.$store.registerModule('mymod', module)
  }
}

这按预期工作，但是如果我们希望模块具有唯一的或用户定义的命名空间怎么办？

import {createNamespacedHelpers} from 'vuex'
import module from '@/store/modules/mymod'

export default {
  props: { namespace: 'mymod' },
  beforeCreated() {
    const ns = this.$options.propData.namespace
    this.$store.registerModule(ns, module)
    const {mapState} = createNamespacedHelpers(ns)
    this.$options.computed = {
      ...mapState(['testVar'])
    }
  }
}

我认为这会起作用，但它没有。

为什么需要这样的东西？因为

export default {
  ...
  computed: {
    ...mapState(this.namespace, ['testVar']), 
    ...
  },
  ...
}

不起作用

我有一个相当简单的类，类似于：

class Tick:
    def __init__():
        self.val = Value('i', 0)
        self.lock = Lock()

    def tick(self):
        self.lock().acquire()
        try:
            self.val.value = self.val.value  + 1
        finally:
            self.lock.release()

我想将它与星图一起使用：

def mp_tick(a, t):
    t.tick()

tick = Tick()

with Pool(processes=4) as pool:
    pool.starmap(mp_tick, [(i, tick) for i in range(100)]

抛出：

RuntimeError: Synchronized objects should only be shared between processes through inheritance

然而：

RuntimeError: Synchronized objects should only be shared between processes through inheritance

才不是。我知道为什么第二个有效。我不明白为什么第一个失败。

理想情况下，我希望有一个Tick可以传递给多个线程的实例，并Tick处理锁定和设置自己的值。我不希望函数必须假设存在全局变量。

假设你正在训练的自定义tf.estimator.Estimator与tf.estimator.train_and_evaluate在类似的设置使用验证数据集@ simlmx的:

classifier = tf.estimator.Estimator(
    model_fn=model_fn,
    model_dir=model_dir,
    params=params)

train_spec = tf.estimator.TrainSpec(
    input_fn = training_data_input_fn,
)

eval_spec = tf.estimator.EvalSpec(
    input_fn = validation_data_input_fn,
)

tf.estimator.train_and_evaluate(
    classifier,
    train_spec,
    eval_spec
)

通常,当训练数据集的损失继续改善而不是验证数据集时,使用验证数据集来切断训练以防止过度拟合.

目前,tf.estimator.EvalSpec允许用户指定steps评估模型的数量(默认为100).

一个(如果可能不使用tf.contrib函数)如何指定在评估丢失n数量(n * steps)之后终止训练,其中评估损失没有改善,然后将"最佳"模型/检查点(由验证数据集确定)保存到唯一文件名(例如best_validation.checkpoint)

语境

我有一个带有非常简单演示的colab，Estimator目的是学习/理解EstimatorAPI，目的是为即插即用模型制定一个约定，其中包含有用的交易技巧（例如，如果验证通过，则提前停止）设置停止改进，导出模型等）。

这三个的Estimator模式（TRAIN，EVAL，和PREDICT）返回EstimatorSpec。

根据文档：

__new__(
    cls,
    mode,
    predictions=None,          # required by PREDICT
    loss=None,                 # required by TRAIN and EVAL
    train_op=None,             # required by TRAIN
    eval_metric_ops=None,
    export_outputs=None,
    training_chief_hooks=None,
    training_hooks=None,
    scaffold=None,
    evaluation_hooks=None,
    prediction_hooks=None.     
)

在这些命名参数中，我想提请注意predictions和export_outputs，它们在文档中被描述为：

• predictions：预测张量或张量的字典。
• export_outputs：描述要导出到SavedModel并在服务期间使用的输出签名。一个字典{name: output}，其中：
  • name：此输出的任意名称。
  • output: 一个ExportOutput对象，例如ClassificationOutput, RegressionOutput, 或PredictOutput。单头模型只需要在这个字典中指定一个条目。多头模型应该为每个头指定一个条目，其中之一必须使用 …

我正在重新阅读有关环境变量的文档，但有点困惑。

MWE 仓库：https : //gitlab.com/SumNeuron/docker-nf

我做了一个插件 /plugins/axios.js 来创建一个自定义的 axios 实例：

import axios from 'axios'

const apiVersion = 'v0'
const api = axios.create({
  baseURL: `${process.env.PUBLIC_API_URL}/api/${apiVersion}/`
})

export default api

并相应地将其添加到 nuxt.config.js

import colors from 'vuetify/es5/util/colors'

import bodyParser from 'body-parser'
import session from 'express-session'
console.log(process.env.PUBLIC_API_URL)
export default {
  mode: 'spa',
  env: {
    PUBLIC_API_URL: process.env.PUBLIC_API_URL || 'http://localhost:6091'
  },
  //  ...
   plugins: [
   //...
   '@/plugins/axios.js'
  ]
}

我在文件中设置PUBLIC_API_URL为。奇怪的是，日志语句是正确的（端口），但是当尝试访问该站点时，有一个对端口的 api 调用（后备）http://localhost:9061.env90616091

系统设置

project/
|-- backend (flask …

简而言之，我使用 Yaml 文件作为我正在使用的某些管道/函数的参数配置。在Python中，这是一个嵌套字典，参数本身可以是数组/字典。迭代所有配置文件并搜索指定的值子集将很有帮助，例如

# toy example of all parameters a config file might have
- param_a: 1
- param_b: 
  - b1: 'a'
  - b2: [1,2,3]

# want all configs with these values
- param_a: 1
- param_b: 
  - b2: [1,2,3]

当然，可以对每个嵌套字典进行递归，但我想知道是否有一个经过验证的真实解决方案，而不是重新发明轮子。

我看到了一些相关的问题（希望确认相同的词典）并且弹出Deep Diff 。然而，尚不清楚在测试子集时，DeepDiff 是否会返回所有丢失的键。想法？

现在我正在使用它并假设 yaml 已作为嵌套字典正确加载

def is_config_subset(truth, params):
    '''
    Arguments:
    ----------
        truth (dict): dictionary of parameters to compare to
        params (dict): dictionary of parameters to test
    Returns:
    ----------
        result (bool) whether or not `params` is …

语境

这是一个关于效率的一般问题。我有一个列表，我需要一个列表中的连续运行/子列表。通常，这是通过切片完成的：

my_list[start:end]

但是， slice 生成原始列表的副本（至少是原始列表的引用）。因此，此操作可能比不执行此操作要慢。

islice是替代迭代器的替代方法。由于我只关心将所有值放在一个位置，而不是遍历它们，因此我将不得不进行类型转换：

list(islice(my_list, start, end))

背景工作

为了进行一些比较，我将大小从 1 增加到 10,000 的列表随机切片/切片 10 次：

is_vals = []
s_vals = []
for l in range(1, 10000):

    my_list = [random.random() for k in range(l)]

    for p in range(10):
        i = random.randint(0, l)
        j = random.randint(0, l)

        if i < j:

            start_time = time.clock()
            list(islice(my_list, i, j))
            is_vals.append(time.clock() - start_time)
            start_time = time.clock()
            my_list[i:j]
            s_vals.append(time.clock() - start_time)

        else:
            start_time = time.clock()
            list(islice(my_list, j, i))
            is_vals.append(time.clock() - start_time)
            start_time …

注意：

我是MXNet的新手。

看来该Gluon模块是要替换（？）Symbol作为高级神经网络（nn）接口的模块。因此这个问题专门利用Gluon模块寻求答案。

语境

残差神经网络（res-NNs）是相当流行的体系结构（该链接提供了对res-NNs的回顾）。简而言之，res-NN是一种架构，其中输入经历（一系列）转换（例如，通过标准nn层），最后在激活功能之前将其与纯净的自身组合：

因此，这里的主要问题是“如何使用自定义实现res-NN结构gluon.Block？” 以下是：

1. 我的尝试（不完整，可能有错误）
2. 作为子问题突出显示为整体问题。

通常，子问题被视为并发主要问题，导致帖子被标记为过于笼统。在这种情况下，它们是合法的子问题，因为我无法解决我的主要问题是由这些子问题引起的，并且胶子模块的部分/初稿文档不足以回答这些问题。

主要问题

“如何通过自定义实现res-NN结构gluon.Block？”

首先让我们进行一些导入：

import mxnet as mx
import numpy as np
import math
import random
gpu_device=mx.gpu()
ctx = gpu_device

在定义res-NN结构之前，首先我们定义一个通用的卷积NN（cnn）架构；即卷积？批处理规范。？坡道。

class CNN1D(mx.gluon.Block):
    def __init__(self, channels, kernel, stride=1, padding=0, **kwargs):
        super(CNN1D, self).__init__(**kwargs) 
        with self.name_scope():
            self.conv = mx.gluon.nn.Conv1D(channels=channels, kernel_size=kernel, strides=1, padding=padding)      
            self.bn = mx.gluon.nn.BatchNorm()
            self.ramp = mx.gluon.nn.Activation(activation='relu')

    def forward(self, x):
        x = self.conv(x) …