update

Author: imhuay

code/my_tensorflow/Untitled.ipynb

@@ -0,0 +1,98 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import tensorflow as tf\n",
+    "from src.utils import get_wb, foo\n",
+    "\n",
+    "from src.layers import dense\n",
+    "\n",
+    "foo()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tf.reset_default_graph()\n",
+    "\n",
+    "x = tf.constant(np.arange(16, dtype=np.float32).reshape([4,4]))\n",
+    "\n",
+    "o = dense(x, 16)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(11, 12)\n",
+      "(12,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "sess = tf.Session()\n",
+    "sess.run(tf.global_variables_initializer())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

code/my_tensorflow/main.py

@@ -0,0 +1,2 @@
+from .dense import *
+from .highway import *

code/my_tensorflow/src/__init__.py

@@ -0,0 +1,28 @@
+"""
+全连接层
+
+References:
+    tensorlayer.layers.DenseLayer
+"""
+
+import tensorflow as tf
+
+from ..utils import get_wb
+from ..activations import relu
+
+
+def dense(x, n_unit, act_fn=relu, name=None):
+    """
+    Args:
+        x: need `tf.Tensor` to use `x.get_shape()`
+        n_unit(int): 
+        act_fn:
+        name(str):
+    """
+    # n_in = tf.shape(x)[-1]  # err: need int but tensor
+    n_in = int(x.get_shape()[-1])
+    with tf.variable_scope(name or "dense"):
+        W, b = get_wb([n_in, n_unit])
+        o = act_fn(tf.matmul(x, W) + b)
+    return o
+

code/my_tensorflow/src/activations/__init__.py

@@ -0,0 +1,35 @@
+"""
+工具函数
+"""
+import tensorflow as tf
+from ..regularizers import l2_regularizer
+
+tf_dtype = tf.float32
+zeros = tf.initializers.zeros
+truncated_normal = tf.initializers.truncated_normal
+
+
+def foo():
+    print(1)
+
+
+def get_wb(shape,
+           w_initializer=truncated_normal,
+           b_initializer=zeros,
+           w_regularizer=l2_regularizer,
+           b_regularizer=l2_regularizer):
+    """"""
+    n_in, n_unit = shape
+    W = tf.get_variable('W', shape=[n_in, n_unit],
+                        dtype=tf_dtype, initializer=truncated_normal, regularizer=l2_regularizer)
+    b = tf.get_variable('b', shape=[n_unit], 
+                        dtype=tf_dtype, initializer=zeros, regularizer=l2_regularizer)
+    return W, b
+
+
+def get_w(shape,
+          w_initializer=truncated_normal,
+          w_regularizer=l2_regularizer):
+    n_in, n_unit = shape
+    W = tf.get_variable('W', [n_in, n_unit], dtype=tf_dtype, initializer=w_initializer, regularizer=w_regularizer)
+    return W

code/my_tensorflow/src/activations/relu.py

@@ -0,0 +1,14 @@
+"""Highway network
+
+References:
+    fomorians/highway-fcn https://github.com/fomorians/highway-fcn/blob/master/main.py
+"""
+
+import tensorflow as tf
+from keras.layers import *
+import keras.backend as K
+from keras.layers.convolutional import _Conv
+
+
+def highway_layer():
+    """"""

code/my_tensorflow/src/activations/selu.py

@@ -0,0 +1,99 @@
+备忘-必备算法
+===
+- 一些必备算法，主要是 C++ 版本
+Index
+---
+<!-- TOC -->
+
+- [二分查找](#二分查找)
+  - [离散版](#离散版)
+    - [`my_binary_search(vector<int>, int)`](#my_binary_searchvectorint-int)
+    - [`my_lower_bound(vector<int>, int)`](#my_lower_boundvectorint-int)
+    - [`my_upper_bound(vector<int>, int)`](#my_upper_boundvectorint-int)
+- [排序](#排序)
+  - [堆排序](#堆排序)
+    - [建堆的时间复杂度](#建堆的时间复杂度)
+
+<!-- /TOC -->
+
+
+## 二分查找
+
+### 离散版
+
+#### `my_binary_search(vector<int>, int)`
+- 没有重复元素时，目标值若存在，则返回索引；若不存在，返回 -1
+- 存在重复元素时，目标值若存在，则返回最小索引；若不存在，返回 -1
+  ```C++
+  int my_binary_search(vector<int>& nums, int v) {
+      if (nums.size() < 1) return - 1;
+
+      int lo = -1, hi = nums.size();  // hi = nums.size() - 1
+
+      while (hi - lo > 1) {
+          int mid = lo + (hi - lo) / 2;
+          if (nums[mid] < v)
+              lo = mid;
+          else
+              hi = mid;
+      }
+
+      return nums[lo + 1] == v ? lo + 1 : -1;
+  }
+  ```
+
+#### `my_lower_bound(vector<int>, int)`
+- 返回大于、等于目标值的最小索引（第一个大于或等于目标值的索引）
+  ```C++
+  int my_lower_bound(vector<int>& nums, int v) {
+      if (nums.size() < 1) return -1;
+
+      int lo = -1, hi = nums.size();  // hi = nums.size() - 1
+
+      while (hi - lo > 1) {                       // 退出循环时有：lo + 1 == hi
+          int mid = lo + (hi - lo) / 2;
+          if (nums[mid] < v)
+              lo = mid;                           // 因为始终将 lo 端当做开区间，所以没有必要 `lo = mid + 1;`
+          else
+              hi = mid;                           // 而在 else 中，mid 可能就是最后的结果，所以不能 `hi = mid - 1`
+      }
+
+      return lo + 1; // 相比 binary_search，只有返回值不同
+  }
+  ```
+- **为什么返回 `lo + 1`？**
+  - 模板开始时将 (lo, hi) 看做是一个开区间，通过不断二分，最终这个区间中只会含有一个值，即 (lo, hi]
+  - 返回 lo+1 的含义是，结果就在 lo 的下一个；
+  - 在迭代的过程中，hi 会从开区间变为闭区间，而 lo 始终是开区间，返回 lo+1 显得更加统一。
+  - 当然，这跟迭代的写法是相关的，你也可以使最终的结果区间是 [lo, hi)，这取决于个人习惯。
+
+#### `my_upper_bound(vector<int>, int)`
+- 返回大于目标值的最小索引（第一个大于目标值的索引）
+  ```C++
+  int my_upper_bound(vector<int>& nums, int v) {
+      if (nums.size() < 1) return -1;
+
+      int lo = -1, hi = nums.size();  // hi = nums.size() - 1
+
+      while (hi - lo > 1) {
+          int mid = lo + (hi - lo) / 2;
+
+          if (nums[mid] <= v)                     // 相比 lower_bound，唯一不同点：`<` -> `<=`
+              lo = mid;
+          else
+              hi = mid;
+      }
+
+      return lo + 1;
+  }
+  ```
+
+## 排序
+
+### 堆排序
+```C++
+
+```
+
+#### 建堆的时间复杂度
+> [为什么建立一个二叉堆的时间为O(N)而不是O(Nlog(N))?](https://www.zhihu.com/question/264693363/answer/291397356) - 知乎