add some

ForrestPi · ForrestPi · commit ba9195012339 · 2016-08-09T23:30:26.000+08:00
add some
diff --git a/Code/ObjectPool.md b/Code/ObjectPool.md
@@ -0,0 +1,206 @@
+# ObjectPool
+
+##                                                        一个超级对象池的实现
+
+
+
+对象池对于创建开销比较大的对象来说很有意义，为了避免重复创建开销比较大的对象，我们可以通过对象池来优化。对象池的思路比较简单，事先创建好一批对
+象，放到一个集合中，以后每当程序需要新的对象时候，都从对象池里获取，每当程序用完该对象后，都把该对象归还给对象池。这样会避免重复的对象创建，提高
+程序性能。先来看看对象池的简单实现：
+
+```c++
+#include <list>
+ 
+template<typename Object>
+class ObjectPool
+{
+public:
+ 
+    ObjectPool(size_t unSize) :
+        m_unSize(unSize)
+    {
+        for (size_t unIdx = 0; unIdx < m_unSize; ++ unIdx)
+    {
+        m_oPool.push_back(new Object());
+    }
+    }
+ 
+    ~ObjectPool()
+    {
+    typename std::list<Object *>::iterator oIt = m_oPool.begin();
+    while (oIt != m_oPool.end())
+    {
+        delete (*oIt);
+        ++ oIt;
+    }
+    m_unSize = 0;
+    }
+ 
+    Object * GetObject()
+    {
+        Object * pObj = NULL;
+        if (0 == m_unSize)
+        {
+            pObj = new Object();
+        }
+        else
+        {
+            pObj = m_oPool.front();
+            m_oPool.pop_front();
+            -- m_unSize;
+        }
+ 
+        return pObj;
+    }
+ 
+    void ReturnObject(Object * pObj)
+    {
+        m_oPool.push_back(pObj);
+        ++ m_unSize;
+    }
+ 
+private:
+    size_t m_unSize;
+    std::list<object *> m_oPool;
+};
+```
+
+这个object pool的实现很典型，初始创建一定数量的对象，取的时候就直接从池子中取，用完之后再回收到池子。一般的对象池的实现思路和这个类似，这种实现方式虽然能达到目的，但是存在以下不足：
+
+1. 对象池ObjectPool<T>只能容纳特定类型的对象，不能容纳所有类型的对象，可以支持重载的和参数不同的构造函数；
+2. 对象用完之后需要手动回收，用起来不够方便，更大的问题是存在忘记回收的风险；
+
+　　我希望能有一个更强大的对象池，这个对象池能容纳所有的对象，还能自动回收用完了对象，不需要手动回收，用起来更方便。要实现这样的对象池需要解决前面提到的两个问题，通过c++11就可以解决这两个问题。
+
+　　对于问题1：容纳所有的对象。本质上需要将对象池中的对象类型擦除，这里用Any类型就可以解决。
+
+　　对于问题2：自动回收用完的对象。这里用智能指针就可以解决，在创建智能指针时可以指定删除器，在删除器中不删除对象，而是回收到对象池中，而这个过程对外界来说是看不见的，由智能指针自己完成。
+
+```c++
+#include <string>
+#include <functional>
+#include <tuple>
+#include <map>
+
+#include "Any.hpp"
+
+const int MaxObjectNum = 10;
+
+class ObjectPool
+{
+    template<typename T, typename... Args>
+    using Constructor = std::function<std::shared_ptr<T>(Args...)>;
+public:
+
+    ObjectPool() : needClear(false)
+    {
+    }
+
+    ~ObjectPool()
+    {
+        needClear = true;
+    }
+
+    //默认创建多少个对象
+    template<typename T, typename... Args>
+    void Create(int num)
+    {
+        if (num <= 0 || num > MaxObjectNum)
+            throw std::logic_error("object num errer");
+
+        auto constructName = typeid(Constructor<T, Args...>).name();
+
+        Constructor<T, Args...> f = [constructName, this](Args... args)
+        {
+            return createPtr<T>(string(constructName), args...);
+        };
+
+        m_map.emplace(typeid(T).name(), f);
+
+        m_counter.emplace(constructName, num);
+    }
+
+    template<typename T, typename... Args>
+    std::shared_ptr<T> createPtr(std::string& constructName, Args... args)
+    {
+        return std::shared_ptr<T>(new T(args...), [constructName, this](T* t)
+        {
+            if (needClear)
+                delete[] t;
+            else
+                m_object_map.emplace(constructName, std::shared_ptr<T>(t));
+        });
+    }
+
+    template<typename T, typename... Args>
+    std::shared_ptr<T> Get(Args... args)
+    {
+        using ConstructType = Constructor<T, Args...>;
+
+        std::string constructName = typeid(ConstructType).name();
+        auto range = m_map.equal_range(typeid(T).name());
+
+        for (auto it = range.first; it != range.second; ++it)
+        {
+            if (it->second.Is<ConstructType>())
+            {
+                auto ptr = GetInstance<T>(constructName, args...);
+
+                if (ptr != nullptr)
+                    return ptr;
+
+                return CreateInstance<T, Args...>(it->second, constructName, args...);
+            }
+        }
+
+        return nullptr;
+    }
+
+private:
+    template<typename T, typename... Args>
+    std::shared_ptr<T> CreateInstance(Any& any,
+        std::string& constructName, Args... args)
+    {
+        using ConstructType = Constructor<T, Args...>;
+        ConstructType f = any.AnyCast<ConstructType>();
+
+        return createPtr<T, Args...>(constructName, args...);
+    }
+
+    template<typename T, typename... Args>
+    void InitPool(T& f, std::string& constructName, Args... args)
+    {
+        int num = m_counter[constructName];
+
+        if (num != 0)
+        {
+            for (int i = 0; i < num - 1; i++)
+            {
+                m_object_map.emplace(constructName, f(args...));
+            }
+            m_counter[constructName] = 0;
+        }
+    }
+
+    template<typename T, typename... Args>
+    std::shared_ptr<T> GetInstance(std::string& constructName, Args... args)
+    {
+        auto it = m_object_map.find(constructName);
+        if (it == m_object_map.end())
+            return nullptr;
+
+        auto ptr = it->second.AnyCast<std::shared_ptr<T>>();
+        if (sizeof...(Args)>0)
+            *ptr.get() = std::move(T(args...));
+
+        m_object_map.erase(it);
+        return ptr;
+    }
+
+private:
+    std::multimap<std::string, Any> m_map;
+    std::multimap<std::string, Any> m_object_map;
+    std::map<std::string, int> m_counter;
+    bool needClear;
+};
+```
diff --git a/ML/深度学习框架自动求导.md b/ML/深度学习框架自动求导.md
@@ -0,0 +1,54 @@
+# 深度学习框架自动求导
+
+推荐一个更好用的自动求导工具。[autograd](https://link.zhihu.com/?target=https%3A//github.com/HIPS/autograd)
+
+Just run pip install autograd
+
+缺陷是，你需要特别注意，这个自动求导的功能指的是对函数第一个参数求导。 所以，所有需要求导的都得以第一个参数传进去
+
+比如这个[A Step by Step Backpropagation Example](https://mattmazur.com/2015/03/17/a-step-by-step-backpropagation-example/)， 可以写成
+
+```python
+import autograd.numpy as np
+from autograd import grad
+
+def sigmoid(x):
+    return 1.0/(np.exp(-x) + 1)
+
+def predict(params,input):
+    (W1,B1),(W2,B2) = params
+    hidden = sigmoid(np.dot(W1,input) + B1)
+    output = sigmoid(np.dot(W2,hidden) + B2)
+    return output
+
+def loss(params,input,target):
+    return (0.5*(target-predict(params,input))**2).sum()
+
+loss_grad = grad(loss)
+
+def train(params, input, target):
+    grad = loss_grad(params,input,target)
+    return [(W-0.5*dW,B-0.5*dB) for ((dW,dB),(W,B)) in zip(grad,params)]
+
+W1 = np.array(
+    [ [0.15,0.20],
+      [0.25,0.30]])
+
+B1 = 0.35
+
+W2 = np.array(
+    [ [0.40,0.45],
+      [0.50,0.55]])
+
+B2 = 0.60
+
+PARAMS = [(W1,B1),(W2,B2)]
+INPUT = np.array([0.05,0.10])
+TARGET = np.array([0.01,0.99])
+
+while True:
+    PARAMS = train(PARAMS,INPUT,TARGET)
+```
+
+这可比一堆数学公式容易理解多了。
+
