小编fat*_*yte的帖子

我想比较两个std :: weak_ptr或一个std :: weak_ptr和一个std :: shared_ptr的相等性.

我想知道的是weak_ptr/shared_ptr指向的每个对象是否相同.比较应该产生负面结果,不仅如果地址不匹配,而且如果基础对象被删除然后偶然使用相同地址重建.

所以基本上,即使分配器保留相同的地址,我也希望这个断言成立:

auto s1 = std::make_shared<int>(43);
std::weak_ptr<int> w1(s1);

s1.reset();

auto s2 = std::make_shared<int>(41);
std::weak_ptr<int> w2(s2);

assert(!equals(w1,w2));

weak_ptr模板不提供相等的运算符,正如我所理解的那样,这是有充分理由的.

所以一个天真的实现看起来像这样:

template <typename T, typename U>
inline bool naive_equals(const std::weak_ptr<T>& t, const std::weak_ptr<U>& u)
{
    return !t.expired() && t.lock() == u.lock();
}

template <typename T, typename U>
inline bool naive_equals(const std::weak_ptr<T>& t, const std::shared_ptr<U>& u)
{
    return !t.expired() && t.lock() == u;
}

如果第一个weak_ptr在此期间到期,则它会产生0.如果不是,我将weak_ptr升级为shared_ptr并比较地址.

这个问题是我必须锁定weak_ptr两次(一次)!我担心花费太多时间.

我想出了这个:

template <typename T, typename U>
inline bool equals(const …

我目前正在玩ANN,这是Udactity DeepLearning课程的一部分.

我成功建立并培训了网络,并在所有权重和偏差上引入了L2正则化.现在我正在尝试隐藏图层的丢失,以便改进泛化.我想知道,将L2正则化引入隐藏层并在同一层上丢失是否有意义？如果是这样,如何正确地做到这一点？

在辍学期间,我们实际上关闭了隐藏层的一半激活并使其余神经元输出的量加倍.在使用L2时,我们计算所有隐藏权重的L2范数.但我不知道如何使用dropout来计算L2.我们关闭了一些激活,我们不应该从L2计算中删除现在"未使用"的权重吗？关于这个问题的任何参考都会有用,我还没有找到任何信息.

如果您有兴趣,我的具有L2正规化的ANN代码如下:

#for NeuralNetwork model code is below
#We will use SGD for training to save our time. Code is from Assignment 2
#beta is the new parameter - controls level of regularization. Default is 0.01
#but feel free to play with it
#notice, we introduce L2 for both biases and weights of all layers

beta = 0.01

#building tensorflow graph
graph = tf.Graph()
with graph.as_default():
      # Input data. For the training data, we use a placeholder …

我正在尝试创建类似于元组的东西,但是我遇到了编写构造函数的问题.

这是代码:

#include <tuple>

template <typename... Ts>
struct B {
    template <typename... ArgTypes>
    explicit B(ArgTypes&&... args)
    {
        static_assert(sizeof...(Ts) == sizeof...(ArgTypes),
            "Number of arguments does not match.");
    }
};

struct MyType {
    MyType() = delete;
    MyType(int x, const char* y) {}
};

int main()
{
   B         <int, char>               a{2, 'c'};                      // works
   B         <int, bool, MyType, char> b{2, false, {4, "blub"}, 'c'};  // fails
   std::tuple<int, bool, MyType, char> t{2, false, {4, "blub"}, 'c'};  // works
}

现在,如果将简单类型作为初始化器传递,则可以正常工作,但如果我尝试在大括号括号初始化器列表中传递参数,则不会.

GCC-4.7发出以下信息:

vararg_constr.cpp:21:67: error: no …

我有一个Base类方法,我想在Derived类中重写.

只要从"外部"或派生类访问具有相同名称的方法,就应调用派生类方法.当从基类内部访问该方法时,我希望使用基类方法.请考虑以下代码:

public class TestBaseMethod
{
    static class Basic {
        public Basic()
        {
            Basic.this.doSomething(); // <<---- This should call Basic version
        }

        public void doSomething()
        {
            System.out.println("Doing something old");
        }
    }

    static class Derived extends Basic {
        Object ressource = new Object();

        @Override
        public void doSomething()
        {
            System.out.println("Doing something completely new");
            // ressource.toString(); // <<---- explosion
        }
    }

    public static void main(String[] args)
    {
        Basic d = new Derived();
        System.out.println("-------------------------------");
        d.doSomething(); // <<---- This should call Derived version
    }
} …