小编tan*_*ngy的帖子

GridSearchCV 实现了一种拟合方法，在该方法中执行 n 重交叉验证以确定最佳参数。之后，我们可以使用 Predict() 直接将最佳估计器应用于测试数据 - 点击此链接： - http://scikit-learn.org/stable/auto_examples/grid_search_digits.html

这里说“该模型在完整的开发集上进行了训练”

然而，我们在这里只应用了 n 折交叉验证。分类器是否也在整个数据上进行自我训练？或者只是在应用预测时选择 n 倍中具有最佳参数的训练有素的最佳估计器？

我们到底如何通过索引设置特征向量或矩阵的值。我正在尝试做类似的事情：

// Assume row major
matrix[i][j] = value
// or
vector[i] = value

我可能错过了，但在快速参考指南中找不到任何内容。

此代码段中显示了一个示例，该示例说明了在没有概念的情况下如何重载模板类的模板成员函数。

现在粗略尝试使用概念编写类似的东西：

template <typename T>
struct Foo{
    Foo(T elem): elem_(elem) {}
    template <typename U = T>  requires Integral<U>
    int get() {
        return -1;
    }
    template <typename U = T>  requires Bool<U>
    int get() {
        return 0;
    }
    T elem_;
};

有两种方法可以组织这种情况：
1.将声明和定义保持在一起：这可以按预期工作。代码段
2。声明和定义分开：无法编译（代码段）

鉴于以上所述，我有两个问题：
1. template <typename T> template <typename U=T> member_fn...由于SFINAE，最初需要该原因。有没有办法用Concepts来避免这种情况来进一步简化代码？
2.如何正确区分声明和定义？

我读到过有关 CUDA 的新版本支持动态并行性的信息，并且我可以像thrush::exclusive_scan在带有参数的内核函数内部一样调用推力函数thrust::device。

__global__ void kernel(int* inarray, int n, int *result) {
  extern __shared__ int s[];
  int t = threadIdx.x;

  s[t] = inarray[t];
  __syncthreads();

  thrust::exclusive_scan(thrust::device, s, n, result);
  __syncthreads();
}

int main() {
  // prep work

  kernel<<<1, n, n * sizeof(int)>>>(inarray, n, result);
}

我感到困惑的是：

1. 当在内核内部调用推力函数时，每个线程是否调用该函数一次，并且它们都对数据进行动态并行处理？
2. 如果他们这样做了，我只需要一个线程来调用thrust，这样我就可以做一个ifto threadIdx；如果没有，块中的线程如何相互通信，以确保对推力的调用已完成，并且它们应该忽略它（这似乎有点想象，因为没有系统的方法来确保用户的代码）。总结一下，当我thrust::device在内核中调用带参数的推力函数时到底发生了什么？

该公式在文档中可用并在此答案中指出。但是，当我尝试应用它时，我没有得到匹配的答案。我确定我在某处犯了一些愚蠢的错误，所以感谢您的支持：

设置

假设我有 2 个矩阵：

X: array([[0, 1, 0],
       [1, 1, 1]])
X2: array([[1, 1, 0],
       [1, 1, 1],
       [1, 2, 0]])

现在申请Xans = scipy.spatial.distance.cdist(X, X2, 'seuclidean')给出：

Xans: array([[2.23606798, 2.88675135, 3.16227766],
       [1.82574186, 0.        , 2.88675135]])

我们只关注Xans[0][0] = 2.23606798，这应该是通过申请获得的seuclidean(X[0], X2[0])。

方法 1：使用 pdist

我尝试通过这样做pdist但得到一个 NaN：

In [104]: scipy.spatial.distance.pdist([X[0], X2[0]], metric='seuclidean')
Out[104]: array([nan])

为什么会这样？

方法二：直接公式申请

我尝试使用上面答案中链接的公式手动尝试，如下所示：

In [107]: (((X[0] - X2[0])**2).sum()/(np.var([X[0], X2[0]])))**0.5
Out[107]: 2.0

可以看出这是给 2.0？

我显然做错了什么 - 这是什么？

我有两个关于std::shared_ptr控制块的问题:

(1)关于大小:我如何以编程方式找到控制块的确切大小std::shared_ptr？

(2)关于逻辑:另外,boost::shared_ptr提到它们在控制块的变化方面是完全无锁的.(从Boost版本1.33.0开始,shared_ptr在大多数常见平台上使用无锁实现.)我没有想一想std::shared_ptr- 是否计划用于任何未来的C++版本？这不也意味着boost::shared_ptr多线程案例更好吗？

我写了一个像下面这样的谷歌测试，它将一些计算值与预期存储在 CSV 文件中的值进行比较。

class SampleTest : public ::testing::Test{
public:

    void setupFile(const std::string& filename) {
       // open csv file here
    }

    void checkRow(ComputedRowValue val) {
        CSVParsedOutput out;
        m_csv_f.readAndParseLine(out);
        EXPECT_EQ(out.field1, val.field1);
        EXPECT_EQ(out.field2, val.field2);
        EXPECT_EQ(out.field3, val.field3);
        m_csv_line++;
    }


protected:
    CSVFile m_csv_f; // CSV file with expected results
    int m_csv_line = 0;
};

这将运行在一些巨大的文件大小和 EXPECT_EQ 失败时只会告诉我哪个值不匹配。如何覆盖 EXPECT_EQ 输出的错误消息也打印m_csv_line？

遵循此处提供的一些解决方案如何在可变参数模板中包含多个参数包？，我希望将多个参数包应用于一个类并使用 CTAD 使该类更有用。

这是我想出的（在Coliru 上），但这给出了：

错误：类模板参数推导失败

这是我试过的代码：

// A template to hold a parameter pack
template < typename... >
struct Typelist {};

// Declaration of a template
template< typename TypeListOne 
        , typename TypeListTwo
        > 
struct Foo;     

// A template to hold a parameter pack
template <typename... Args1, typename... Args2>
struct Foo< Typelist < Args1... >
                 , Typelist < Args2... >
                 >{
    template <typename... Args>
    struct Bar1{
        Bar1(Args... myArgs) {
            _t = std::make_tuple(myArgs...);
        }
        std::tuple<Args...> _t;
    }; …

这是以下先前问题的组合：将函数应用于所有特征矩阵元素和根据任意分布设置特征::矩阵的系数。基本上我试图生成一个特征矩阵，其系数是从高斯分布中采样的。

这是我执行此操作的代码（静态类方法），它返回一条相当神秘的错误消息：

matrix_eig EigenUtil::GaussianNoise(size_t rows, size_t cols,
                                    float mean, float std) {
  matrix_eig m(rows, cols);
  std::mt19937 rng;
  std::normal_distribution<float> nd(mean, std);
  auto sampler = [&]() { return nd(rng); };
  return matrix_eig::Zero(rows, cols).unaryExpr(sampler);
}

返回错误：错误：

no type named 'type' in 'std::__1::result_of<(lambda at eigen_util.cpp:101:18) (const float &)>'
  typedef typename std::result_of<T>::type type1;

我正在尝试在 Eigen 中实现一个 Normalizer。

它试图实现的功能如下：

Xnorm = (X - np.mean(X, axis=0))/(np.std(X, axis=0))（相当于 numpy）

在主要的归一化步骤中，我有一个函数如下：

typedef Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>
    matrix_eig;
typedef Eigen::Matrix<float, Eigen::Dynamic, Eigen::RowMajor> vector_eig;

matrix_eig Normalizer::Transform(const matrix_eig &X) {
  // mean_ and std_ are vector_eig types
  matrix_eig centered = X.rowwise() - mean_.transpose();
  // Below line doesnt work since '/' is not allowed for matrices
  return centered.rowwise()/std_;
}

我的问题是我到底该怎么做centered.rowwise().array()？

我正在尝试使用 Eigen3 生成一个 2d 浮点矩阵，(num_samples, num_ranges)这样每一列都是与[0, num_samples)like的连续间隔范围[0, 1, 2 ... num_samples - 1]。

我目前正在通过创建一个类似的 2d std::vectorwithstd::iota然后将其转换为 Eigen 2d 矩阵来实现这一点。

在 Eigen 中有更快更简单的方法吗？