Algorithm
https://zh.wikipedia.org/wiki/A*%E6%90%9C%E5%B0%8B%E6%BC%94%E7%AE%97%E6%B3%95 #
Backpropagation(向后传播算法)
希腊符号读音
希腊字母 汉字注音 汉语拼音 |
Back Bropagation(向后传播)
其中: \[ net_i: 第i个神经元的输入 \\\\ o_i: 第i个神经元的输出 \\\\ \omega_{i, j}: 第i个神经元到下一层第j个神经元的权重 \\\\ \]
因此可得: \[ o_i = \gamma(net_i) \\\\ E = \sum[t\cdot\log(y) + (1-t)\cdot\log(1-y)] \]
其中: - \(\gamma\) 是激活函数 - E 是误差(这里使用Cross Entropy Loss), y是为输出神经元的实际输出， t为样本的预期输出
所以求误差对于权重的偏微分: \[ \begin{align} \dfrac{\sigma(E)}{\sigma(\omega_{i, j})} &= \dfrac{\sigma(E)}{\sigma(o_j)} \cdot \dfrac{\sigma(o_j)}{\sigma(net_j)} \cdot \dfrac{\sigma(net_j)}{\sigma(\omega_{i, j})} \\\\ \end{align} \]
其中: \[ \begin{align} \dfrac{\sigma(o_j)}{\sigma(net_j)} &= \dfrac{\sigma(\gamma(net_j))}{\sigma(net_j)} \\\\ &= \gamma(net_j) \cdot (1 - \gamma(net_j)) \\\\ &= o_j \cdot (1 - o_j) \end{align} \]
\[ \begin{align} \dfrac{\sigma(net_j)}{\sigma(\omega_{i, j})} &= \dfrac{\sigma}{\sigma(\omega_{i, j})}(\omega_{i, j} \cdot o_i + b_i) \\\\ &= o_i \end{align} \]
输出层
因为当\(o_j\)是最后一层输出层时: \[ \begin{align} \dfrac{\sigma(E)}{\sigma(o_j)} &= \dfrac{\sigma}{\sigma(y)} \cdot [t \cdot \log(y) + (1-t)\cdot\log(1-y)] \\\\ &= \dfrac{t}{y} - \dfrac{1-t}{1-y} \\\\ &= \dfrac{t - y}{y\cdot(1 - y)} \end{align} \]
隐藏层
当\(o_j\)为任意一层隐藏层的时: \[ \begin{align} \dfrac{\sigma(E)}{\sigma(o_j)} &= \dfrac{\sum_{l \in L}E_l}{\sigma(o_j)} \\\\ &= \sum_{l \in L}\dfrac{E}{\sigma(o_j)} \\\\ &= \sum_{l \in L}\dfrac{E}{\sigma(o_l)} \cdot \dfrac{\sigma(o_l)}{\sigma(net_l)} \cdot \dfrac{\sigma(net_l)}{\sigma(o_j)} \\\\ &= \sum_{l \in L}\dfrac{E}{\sigma(o_l)} \cdot \dfrac{\sigma(o_l)}{\sigma(net_l)} \cdot \dfrac{(\omega_{j, l} \cdot o_j + b_j)}{\sigma(o_j)} \\\\ &= \sum_{l \in L}\dfrac{E}{\sigma(o_l)} \cdot \dfrac{\sigma(o_l)}{\sigma(net_l)} \cdot \omega_{j, l} \\\\ \end{align} \] 其中: - \(L\)是下一层神经层, \(l \in L\)神经层的神经元
这里设: \[ \begin{align} \delta_j &= \dfrac{E}{\sigma(o_j)} \cdot \dfrac{\sigma(o_j)}{\sigma(net_j)} \end{align} \]
所以有: \[ \begin{align} \delta_j &= \begin{cases} \dfrac{t - y}{y\cdot(1 - y)} \cdot o_j \cdot (1 - o_j) , &当j是输出层的神经元时 \\\\ \sum_{l \in L}(\delta_l \cdot \omega_{j, l} ) \cdot o_j \cdot (1 - o_j), &当j是隐藏层的神经元时 \\\\ \end{cases} \end{align} \]
更新参数
\[ \begin{align} \omega_{i, j} &= \omega_{i, j} - \eta \cdot \dfrac{\sigma(E)}{\sigma(\omega_{i, j})} \\\\ &= \omega_{i, j} - \eta \cdot \delta_j \cdot o_i \end{align} \]
其中: - \(\eta\) 是学习率，也就是步长
同理: \[ \begin{align} b_{i, j} &= b_{i, j} - \eta \cdot \dfrac{\sigma(E)}{\sigma(b_{i, j})} \\\\ &= b_{i, j} - \eta \cdot \delta_j \end{align} \]
TODO_ReadList
TODO list
- [ ][Batch Normal](https://arxiv.org/pdf/1502.03167.pdf)
- [ ][A*搜索算法](https://zh.wikipedia.org/wiki/A*%E6%90%9C%E5%B0%8B%E6%BC%94%E7%AE%97%E6%B3%95)
- [ ][数据结构Graph](https://en.wikipedia.org/wiki/Graph_(abstract_data_type))
AlexNet
non-saturating neurons(非饱和神经元) 和 saturating neurons(饱和神经元)
https://stats.stackexchange.com/questions/174295/what-does-the-term-saturating-nonlinearities-mean 使用非压缩性的激活函数的神经元是非饱和神经元 例如： Relu 使用压缩性的激活函数的神经元是饱和神经元 例如： tanh, sigmod
PyQt5 and Pycharm
参考:https://www.jianshu.com/p/8066e8d4f187
PyQt5
常用工具
- Qt Designer
- PyUIC5
pyqt5的工具链配置
配置Qt Designer(mac 环境下)
使用 brew 安装pyqt5之后， designer一般路径为: /usr/local/Cellar/qt/5.11.0/libexec/Designer.app,可以自行搜索Designer.app
Tools->External Tools-> + |
配置好以后, 在.ui文件右键"External Tools->Qt Designer", 可以在Qt Designer中编辑这个.ui文件
配置PyUIC5
Tools->External Tools-> + |
配置好以后, 在.ui文件右键"External Tools->PyUIC5", 可以调用命令转成.py文件
使用pyinstaller打包
pyinstaller -F main.py |
Loss Function
http://yeephycho.github.io/2017/09/16/Loss-Functions-In-Deep-Learning/ http://www.csuldw.com/2016/03/26/2016-03-26-loss-function/ http://thegrandjanitor.com/2015/08/20/gradient-descent-for-logistic-regression/ https://blog.csdn.net/happyer88/article/details/46772347 https://zh.wikipedia.org/wiki/%E5%8F%8D%E5%90%91%E4%BC%A0%E6%92%AD%E7%AE%97%E6%B3%95 https://www.cnblogs.com/charlotte77/p/5629865.html # Loss Function 顾名思义，误差损失函数, 用于计算预测和实际值得误差的函数.
前期知识
似然函数[WiKi]
似然函数是一种对于统计模型中参数的估计
似然性 和 概率
概率是指在已知一些条件的情况下预估结果 似然性则是用于在已知某些观测所得到的结果时，对有关事物的性质的参数进行估计
在这种意义上，似然函数可以理解为条件概率的逆反。在已知某个参数B时，事件A会发生的概率写作： \[ P(A|B) = \dfrac{P(A, B)}{P(B)} \] 根据贝叶斯定理 \[ P(B|A) = \dfrac{P(A|B) \cdot P(B)}{P(A)} \]
例子： 假设投掷硬币2次得到正面,记 H为得到正面的事件, pH为得到正面的概率 则 \[ P(HH|pH) = pH^2 = 0.5^2 \] 因此2次正面的结果的似然函数为: \[ L(pH|HH) = P(HH|pH) = pH^2 \] 所以，当 * pH = 0.5 * 时，似然函数的值是0.25(注意这里的0.25并不是pH取值0.5的概率),这个大小并不重要 当 * pH = 0.6 * 时， L(pH|HH) = 0.36, 0.36 > 0.25. 注意到这里似然函数的值变大了。 所以根据观测的结果，2次正面朝上，pH=0.6比pH=0.5的概率更大，似然函数值更大，更为合理. 似然函数的重要性不是它的具体取值，而是当参数变化时函数到底变小还是变大 对同一个似然函数，如果存在一个参数值，使得它的函数值达到最大的话，那么这个值就是最为“合理”的参数值。
Mean Sequared Error(L2 Loss)
\[ MSG = \dfrac{1}{n} \sum{e^2} \]
Cross Entropy Loss
\[ J(\theta) = \dfrac{1}{m} \sum_{i=1}^m Cost(h_\theta(x_i), y_i) \] \[ Cost(h_\theta(x_i), y_i) = \begin{cases} -y_i \cdot \log(h_\theta(x_i)) , y=1 \\\\ -(1 - y_i) \cdot (1 - \log(h_\theta(x_i))) , x=0 \\\\ \end{cases} \] \[ J(\theta) = - \dfrac{1}{m} \sum_{i=1}^m[yi \cdot log(h_\theta(x_i)) + (1-y_i) \cdot log(1 - h_\theta(x_i))] \]
\(h_\theta(x_i) = sigmod(x_i)\) \(Sigmod = (1 + e^{-x})^{-1}\)
L1 Loss
面试中的一些常见的问题
这里挖坑
python
python 的 GIL
GIL(Global Interpreter Lock),全局解释器锁.
python的解释器，py文件的运行需要解释器。在cpython中，这个解释器不是线程安全的，他有一个全局锁，用于保证对象的线程安全。当多线程情况下运行时候。每次其实只有一个线程在运行,其他的线程都是在等待。这就导致python中的多线程并不能完全利用全部的cpu资源（如果是多核处理器的话）.所以GIL的存在，使得python处理cpu密集型的任务时候效率低下，因为要不断切换浪费时间切换线程，而且无法利用所有的cpu资源。而在I/O密集型的任务有比较好的效率，因为处理耗时的I/O任务时，线程会释放GIL给其他线程.
关于解释器和编译器的区别: - 代码 -运行-> 解释器 --> cpu - 代码 -->编译器 -运行-> cpu
# coding=utf8 |
上面python3.6为什么将近慢了一倍？ > python3 的 int 都默认为 long integer.所以会稍微慢一些. > 这里有一个python3 和python2 的表现的对比。部分对比中python3比python2快8%到48%。部分慢25%到54%[Speed] Benchmarks: Comparison between Python 2.7 and Python 3.6 performance
python的多线程，多进程， 协程
几种排序
快速排序 def sort_fast(alist):
pass
数据库
mysql 的索引
mysql 的 when case
先创建测试数据 create table testScore
(
tname varchar(30) null,
ttype varchar(10) null,
tscor int null
);
insert into testScore values ('张三','语文',80);
insert into testScore values ('张三','数学',98);
insert into testScore values ('张三','英语',65);
insert into testScore values ('李四','语文',70);
insert into testScore values ('李四','数学',80);
insert into testScore values ('李四','英语',90);
查询每个人的分数 select
`tname`,
max(case `ttype` when '语文' then `tscor` else 0 end) '语文',
max(case `ttype` when '数学' then `tscor` else 0 end) '数学',
max(case `ttype` when '英语' then `tscor` else 0 end) '英语'
from testScore group by `tname`;
group 中的case when select
`tname`,
case `ttype`
when '数学' then '理科'
else '文科'
end as '科别',
sum(`tscor`) as '总分'
from `testScore`
Group by
`tname`,
case `ttype`
when '数学' then '理科'
else '文科'
end;
orm 的 n + 1问题
缓存、队列
redis 的 持久化策略
- RDB 在指定的时间间隔内生成数据集的时间点快照
- AOF 持久化记录数据库的所有操作命令，并在服务器重启时重新执行
缓存击穿、雪崩、穿透
- 缓存雪崩：指大量缓存同时失效，使得查询直接落到数据库上，造成数据库短时间内承受大量请求而崩掉。
- 缓存击穿：指某个热点key，短时间大量请求都在访问，当他过期时，所有的请求会突然都直接落到数据库上，造成数据库短时间内承受大量请求而崩掉。
- 缓存穿透：当用户访问的数据，既不在缓存中，也不在数据库中，导致请求在访问缓存时，发现缓存缺失，再去访问数据库时，发现数据库中也没有要访问的数据，没办法构建缓存数据，来服务后续的请求。那么当有大量这样的请求到来时，数据库的压力骤增。
其他基础
tcp/ip协议，tcp的三次握手等
tcp/ip 是一个协议簇的统称，
tcp(transport control protocol)传输控制协议 udp(user datagram protocol)
http协议
Hyper Text Transfer Protocol(超文本传输协议) Hypertext Transfer Protocol -- HTTP/1.1
包括方法: GET,POST,HEAD,OPTIONS,DELETE,PUT,TRACE,CONNECT
url, uri 的区别
url(uniform resource locator) uri(uniform resource identifier) 从名字可以看出来uri是资源的唯一标识，而url是资源的定位 url是uri的一种
死锁
restful 规范
An overview of gradient descent optimization algorithms
梯度下降优化算法的概览
Gradient Descent Variants
主要有3种梯度下降，分别是Batch Gradient Descent, SGD, Mini-Batch Gradient Desceng
Batch Gradient Descent
\[ \theta = \theta - \eta \cdot \nabla_\theta J( \theta) \]
其中: \(\theta\) :参数 \(\eta\) :学习率(步长) \(J()\) :误差方程
参数 = 参数 - 学习率 * 参数变化率 for i in range(num_epochs):
params_grad = evaluate_gradient(loss_function, datas, params)
params = params - learning_rate * params_grad
SGD (Stochastic Gradient Descent)
每个样本训练时候都更新参数
for i in range(num_epochs): |
Mini-Batch Gradient Descent
每个小的训练集更新参数 for i in range(num_epochs):
np.random.shuffle(datas)
for mini_batch in get_batches(datas, batch_size=50):
params_grad = evaluate_gradient(loss_function, mini_batch, params)
params = params - learning_rage * params_grad
Algorithms
梯度下降的一些优化算法，就是更新梯度下降过程中更新参数的算法。
Momentum
普通的算法的缺点是计算梯度和更新参数完全依靠当前batch的数据，这样容易使得梯度很不稳定，并且容易陷入局部最优(local optima) 于是Momentum引入物理中惯性的概念, 计算梯度时候一定程度上依赖之前的轨迹
\[ \begin{align} \begin{split} v_t &= \gamma v_{t-1} + \eta \nabla_\theta J( \theta) \\ \theta &= \theta - v_t \end{split} \end{align} \]
其中 \(\gamma\) 一般被设置为0.9
NAG(Nesterov Accelerated Gradient)
Momentum方法比喻为物理中的惯性，小球滚下坡。但是我们希望小球更加的聪明，能够预知什么地方该减速什么地方该加速，在上坡之前就开始减速。Momentum中我们对 \(\theta\) 求导，这里我们对 \(\theta - \eta v_{t-1}\) 求导
$$ \[\begin{align} \begin{split} v_t = \gamma v_{t-1} + \eta \nabla_\theta J(\theta - \gamma v_{t-1}) \\ \theta = \theta - v_t \end{split} \end{align}\] $$
Adagrad
前面的方法中，所有的参数都同时使用同一个学习率更新，这里我们每个参数在不同的时间使用不同的学习率更新,我们设新的梯度下降目标函数 \(g_{t, i}\) 对于参数 \(\theta_i\) ，时间 t 为：
\[ g_{t, i} = \nabla_\theta J(\theta_{t,i}) \] 所以 \[ \theta_{t+1, i} = \theta_{t, i} - \eta \cdot g_{t, i} \] 最后： \[ \theta_{t+1, i} = \theta_{t, i} - \dfrac{\eta}{\sqrt{G_{t, ii} + \epsilon}} \cdot g_{t, i} \]
其中 \(G_{t, ii} \in \mathbb{R}^{i \times i}\) 是一个对角矩阵(diagonal matrix),对角线上的值 i,i是步数, \(\epsilon\) 是用于平滑曲线的，防止分母是0，一般取值为 1e-8
出现频繁的学习率小，不频繁的学习率大，因此适合应用在分散的数据。 但是因为分母计算每个参数的平方和，所以容易出现参数爆炸
Adadelta
RMSprop
Adam
AdaMax
Nadam
AMSGrad
Word2Vec阅读(一)
原文地址Word2Vec Tutorial - The Skip-Gram Model
Word2Vec Tutorial - The Skip-Gram Model
This tutorial covers the skip gram neural network architecture for Word2Vec. My intention with this tutorial was to skip over the usual introductory and abstract insights about Word2Vec, and get into more of the details. Specifically here I’m diving into the skip gram neural network model.
这个教程涵盖了Skip gram nenural network 的 Word2Vec 的结构, 我做这个教程的想法是跳过Word2Vec常见的介绍和抽象的概念，直接获取更多的细节。这里我开始潜入Skip gram neural network 模型.
The Model
The skip-gram neural network model is actually surprisingly simple in its most basic form; I think it’s the all the little tweaks and enhancements that start to clutter the explanation.
skip-gram neural network 模型的基本形式惊人的简单。我认为所有的苦恼都源于杂糅解释。
Let’s start with a high-level insight about where we’re going. Word2Vec uses a trick you may have seen elsewhere in machine learning. We’re going to train a simple neural network with a single hidden layer to perform a certain task, but then we’re not actually going to use that neural network for the task we trained it on! Instead, the goal is actually just to learn the weights of the hidden layer–we’ll see that these weights are actually the “word vectors” that we’re trying to learn.
让我们从高阶的视角开始。Word2Vec使用了一个你可能会在其他机器学习里面见过的技巧。我们将会训练一个简单的只有一层隐藏层的神经网络，用来代表一个任务，但是我们不会真的使用那个神经网络在我们的训练的任务上。取而代之的是，我们的目标实际是学习得到隐藏层的权重，我们将会见到这些权重其实才是“word vectors”我们想要学习得到的。
The Fake Task
So now we need to talk about this “fake” task that we’re going to build the neural network to perform, and then we’ll come back later to how this indirectly gives us those word vectors that we are really after.
We’re going to train the neural network to do the following. Given a specific word in the middle of a sentence (the input word), look at the words nearby and pick one at random. The network is going to tell us the probability for every word in our vocabulary of being the “nearby word” that we chose.
所以现在我们需要讨论一下这个将会建立神经网络模型模拟的“假”的任务。
我们将会训练神经网络做以下的事情。给定一个句子中间的字，在这个字的旁边随机取一个另一个字。神经网络将要告诉我们每一个在字典中的字，成为这个旁边的字的可能性。
The output probabilities are going to relate to how likely it is find each vocabulary word nearby our input word. For example, if you gave the trained network the input word “Soviet”, the output probabilities are going to be much higher for words like “Union” and “Russia” than for unrelated words like “watermelon” and “kangaroo”.
输出的可能性需要与每一个字典中发 有关联。 例如，如果你训练网络的输入字“soviet”, “Union” 和 “Russia”的可能性就要远大于“watermelon” and “kangaroo”。
We’ll train the neural network to do this by feeding it word pairs found in our training documents. The below example shows some of the training samples (word pairs) we would take from the sentence “The quick brown fox jumps over the lazy dog.” I’ve used a small window size of 2 just for the example. The word highlighted in blue is the input word.
我们将会训练这个神经网络完成这些通过给他一对在训练文档中找到的字。 下面的例子展示了一些训练的示例，我们将会从句子“The quick brown fox jumps over the lazy dog.”中取字。我用了一个小的窗口大小-2，仅仅用于示范。蓝色高亮的部分是输入的字。
Hupu Api
获取比赛列表
URL
https://games.mobileapi.hupu.com/1/7.1.15/nba/getGames
params
{ |
response
{ |
python中几个get
class Dept(object): |
__get__
__get__将对象作为数据描述符
class Company: |
__getattribute__
适用 '.' 运算符
d = Dept(15) |
__getattr__
当 __getattribute__ 找不到触发
d = Dept(15) |
__getitem__
适用 '[]' 运算符
d = Dept(15) |