\documentclass{article}
\usepackage[UTF8, heading = false, scheme = plain]{ctex}
\usepackage{palatino}
\usepackage{url}
\usepackage{subfigure}
\usepackage{pifont}
\usepackage{geometry}
\usepackage{lipsum}%%
\usepackage{algorithm}%%
\usepackage{algorithmic}
\usepackage{array}
%\usepackage{algorithm}
%\usepackage{algorithmic}
\usepackage{booktabs}
\usepackage{multirow}
\usepackage{titlesec} %设置页眉页脚的宏包
\usepackage{changepage}
\usepackage{tabularx, booktabs}
\usepackage{listings}
\usepackage{xcolor}
\usepackage{blindtext}
\title{ Private Note : Machine Learning\\ in Practice}
\date{2018\\ February}
\author{Lianda Duan }
%\tableofcontents
%\date{\today}
\begin{document}
\newpagestyle{main}{
\sethead{ Lianda Duan}{}{\today} %设置页眉
\setfoot{}{\thepage}{} %设置页脚，可以在页脚添加 \thepage 显示页数
\headrule % 添加页眉的下划线
\footrule %添加页脚的下划线
}
\pagestyle{main} %使用该style
\newpage
\maketitle
\tableofcontents
\newpage
%\centering标题
%\begin{center}
%\Huge
%\par \textbf{Private Note : Machine Learning\\ in Practice}
%\end{center}
\begin{center}
\par Author: Duanlianda \\Mail: [email protected]
\end{center}
%
\section{第一章：DeepLearning 发展}
\subsection{人工智能 Outline}
\begin{itemize}
\item 所谓的机器的意识是什么?（图灵测试）
\item 人工智能的目标：解决人容易执行，但是形式化很难描述的任务
\item 机器从\textbf{经验}中\textbf{学习}通过\textbf{层次化概念}理解世界：
\\1.\textbf{经验}避免了人手工化理解电脑学习到的知识
\\2.\textbf{层次化： }允许电脑从更\textbf{简单}的概念中学习更加\textbf{抽象}的概念。
\\3.\textbf{简单的学习行为： }调整数据特征各自的重要性。
\\4.\textbf{表征学习（Representation Learning）}
\\5.\textbf{几个针对GPU的编程库：}Theano、Torch、 TensorFlow。
\\6.\textbf{Further Knowledge：}Autoencoder(自动编码器)、RBM（受限玻尔兹曼机）\\--（Unsupervised Learning）
\\7.\textbf{Reference Material：}Ian Goodfellow， Yoshua Bengio，Aaron Courville $Deep Learning$. 斯坦福大学 CS231课程。
\end{itemize}
\subsection{历史}
\subsubsection{三段历史：}
\begin{itemize}
\item \textbf{1940-1960} Dl被称为\textbf{控制论}随着生物学习理论和感知机的实现爆发了\textbf{第一次热潮}。
\item \textbf{1980-1995}Dl $\rightarrow$ \textbf{联结主义、反向传播} 训练1-2层隐层的神经网络迅速膨胀。
\item \textbf{2006 逐层贪婪非监督式预训练} 初始化深层权重，使得在数据较少的时候仍有较好表现
\item \textbf{2012} Deep learning 彻底被工业界接纳。
\end{itemize}
在算法级别理解大脑是如何工作的$\rightarrow$"计算神经学"。DeepLearning主要关心的问题：\textbf{怎样构建计算机系统，来成功解决所需要的智能任务}。计算神经学主要关心的问题：\textbf{构建更精确的模型，模拟大脑的真实工作。}联结主义的核心思想是\textbf{大量的简单神经元连接在一起能产生智能的行为。}
$$We\ can\ only\ see\ a\ short\ distance\ ahead,\ but\ we \ can \ see\ plenty \ there \ that\ needs \ to\ be\ done.$$
%\begin{figure}[H]
% \begin{adjustwidth}{-5cm}{-6cm}
% \begin{center}
% \includegraphics[width=10cm]{fff.jpeg}
%% \caption{default}
% \label{default}
% \end{center}
% \end{adjustwidth}
% \end{figure}
%\begin{table}[H]
%\caption{Notations}
%\centering
%\begin{tabular}{ccc}
%\toprule
%Symbol&Definition&Notes\\
%\midrule
%$\textbf{F}_{kj}$&The $j^{th}$ indicator value of the $k^{th}$ country. &$(k=1,2,...,20; j=1,2,...,7). $\\
%$\alpha_{kj}$&The weight of the $j^{th}$ element in the $k^{th}$ country.&\\
%$\textbf{A}_{ij}$&The $j^{th}$ index value of the $i^{th}$ region&\\
%$\textbf{N}_{i}$&The number of countries in the $i^{th}$ region&\\
%$v_{i}$&The region numbered $i$&\\
%$p_{ij}$&Transferring proportion from region i to j&\\
%$s_{i}$&The attraction index of the $i^{th}$ region&\\
%
%\bottomrule
%\end{tabular}
%\end{table}
%%------
\subsection{Python 基础拾遗（Stanford cs228 ）}
内容清单：
\begin{itemize}
\item \textbf{Python基本数据类型：}（Containers、Lists、dictionaries、Sets、Tuples），函数 、类
\item \textbf{NumPy：}数组、数组索引、数据类型、数组运算、广播*。
\item \textbf{Matplotlib：}Plotting、Subplots、images。
\end{itemize}
\subsubsection{一些算法的例子}
\textbf{快速排序（使用递归函数）：}
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
def quicksort(arr):
if len(arr)<=1:#判断长度
return arr#如果太短返回原数组
pivot=arr[len(arr)/2];#参照物
left=[x for x in arr if x < pivot]#左
middle=[x for x in arr if x==pivot]#中
right=[x for x in arr if x>pivot]#右
return quicksort(left)+middle+quicksort(right)#递归调用进行排序（神秘）
print quicksort([3,6,8,10,1,2])#输入测试数据并且打印排序结果
输出结果：[1, 2, 3, 6, 8, 10]
\end{lstlisting}
\textbf{输入输出（拼接、格式）：}
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
hw='hello'+' '+'world'#字符串拼接
print hw
hw5='%s%s%d'%('hello',' world ',5)#按照格式输出
print hw5
输出结果：hello world
hello world5
\end{lstlisting}
\textbf{python不支持x++操作}
\textbf{python逻辑运算 and、or、!=（异或）}
\textbf{字符串操作：}
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
s='hello'#input
print s.capitalize()#首字母大写Hello
print s.upper()#全大写HELLO
print s.rjust(7)#字符串向右对其，空格站位‘ hello’
print s.center(7)#字符串居中，左右占位
print s.replace('l',' replace ')#'he replace replace o'字符替换
print ' wo rld '.strip()#删除头尾空白字符打印'wo rld'
\end{lstlisting}
\newpage
\textbf{Python的四种容器类型 Lists、Dictionaries、Sets、Tuples}\\
\textbf{1-Lists：}
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
#1：基本操作
#Lists 相当于数组， 长度可变 ，元素类型多样
xs=[0,1,2,3]#创建一个Lists
print xs,xs[2]#打印、访问下标为2 （第3个元素）
#输出：[3, 1, 2] 2
#负下标->反向索引
print xs[-1]
xs[2]='foot'#指定位置添加字符串类型的元素
#[0, 1, 'foot', 3]
print xs
xs.append('bar')#末尾附加元素（改变了长度）
# [0, 1, 'foot', 3, 'bar']
print xs
x=xs.pop()# 移除末端的元素
print xs#[0, 1, 'foot', 3]
#2：切片
#目标：同时获取多个元素
nums=range(5)#[0, 1, 2, 3, 4]
print nums[2:4]#[2, 3]获取下标2、3（不包括4）
print nums[2:]#[2, 3, 4]获取下标2-末尾的元素
print nums[:2]#[0, 1]获取下标2（不包括下标2）之前的元素
print nums[:-1]#**[0, 1, 2, 3]负向索引
nums[2:4]=['L','D']#[0, 1, 'L', 'D', 4]替换
print nums[:]#打印整个List
#3.循环（Loops）
animals=['cats','dogs','monkey']
for animal in animals:#遍历整个列表（记住最后的semicolon）
print animal#前边是space、tab都可以
#输出：
# cats
# dogs
# monkey
#3.1循环（Loops）内访问元素的指针
animals=['cats','dogs','monkey']
for idx,animal in enumerate(animals):
print '#%d:%s'%(idx+1,animal)
#1:cats
#2:dogs
#3:monkey
#4.列表的解析（Comprehension）——遍历转换
nums=[0,1,2,3,4]
squares=[]
for x in nums:#每个元素编程其平方
squares.append(x**2)
print squares#[0, 1, 4, 9, 16]
#4.1.解析（Comprehension）的更简单方式
nums=[0,1,2,3,4]
squares=[x**2 for x in nums]
print squares
#4.2.包含条件的解析（Comprehension）
nums=[0,1,2,3,4]
squares=[x**2 for x in nums if x%2==0]
print squares#[0, 4, 16]
\end{lstlisting}
\subsubsection{四中常用结构：字典、元组、集合、列表}
%================
\textbf{2-Dictionaries：}
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
#1.字典结构储存（键-值）对，与java中的Map类似
# 输入：
d={'cat':'cute','dog':'furry'}
print d['cat']#cute 根据cat查找对应的内容
print 'cat'in d#True 是否有cat词条
d['fish']='wet'
print d['fish']#wet
#获取字典中元素的默认值
print d.get('monkey','Default hahahaha2333')#Default hahahaha2333
print d.get('fish','Default hahahaha2333')#wet
#使用del来移除
del d['fish']#此后fish不再是字典的关键字
print d.get('fish','Default hahahaha2333')#Default hahahaha2333
#2.字典结构的迭代
d={'people':2,'cat':4,'spider':8}
for animal in d:
legs=d[animal]
print '%s has %d legs'%(animal,legs)
# cat has 4 legs
# spider has 8 legs
# people has 2 legs
#2.1字典结构的迭代(使用iteritem)
d={'people':2,'cat':4,'spider':8}
for animal,legs in d.iteritems():
# legs=d[animal]
print '%s has %d legs'%(animal,legs)
# cat has 4 legs
# spider has 8 legs
# people has 2 legs
#3.字典的解析
nums=[0,1,2,3,4]
#解析使用简单解析并且带有条件
even_num_to_square={x:x**2 for x in nums if x%2==0}
print even_num_to_square
# {0: 0, 2: 4, 4: 16}
\end{lstlisting}
%===================
\textbf{3-Sets：}
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
#集合是无序的不同元素组成的东西
#如果一个东西变成集合，重复的元素会被剔除掉
animals={'cats','dogs'}
print 'cats' in animals#True
print 'spiders' in animals#False
animals.add('fish')#True 加入新成员
print 'fish' in animals#查看是否存在
print len(animals)#3
animals.add('cat')#添加一个已经存在的元素，元素长度不会变化
print len(animals)#3
animals.remove('cat')#移除元素
print len(animals)#2
#1.集合的循环(由于集合是无序的，不能做关于顺序的假设)
animals={'cat','dog','fish'}
for idx,animal in enumerate(animals):
print '#%d:%s'%(idx,animal)#or: idx+1显示下标从1开始
#0:fish
#1:dog
#2:cat
#2.集合的解析
from math import sqrt
print{int(sqrt(x)) for x in range(100)}
# set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
\end{lstlisting}
%================
\textbf{4-Tuples：}
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
#元组：不可改变的有序列表
#可以像字典一样使用键值对 可以作为集合中的元素（列表不行）
d={(x,x+1):x for x in range(3)}
t=(1,2)#创建元组
print d#{(0, 1): 0, (1, 2): 1, (2, 3): 2}
print d[t]#1标签为(1,2) 的内容->对应为：1
\end{lstlisting}
\subsubsection{Function and Class(函数、类)}
\textbf{函数}
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
#函数
#Python使用关键词def来定义函数
def hello(name,loud=False):
if loud:
print 'Hello,%s'%name.upper()
else:
print 'Hello,%s'%name
hello('Duan')#Hello,Duan
hello('Duan',loud=True)#Hello,DUAN
#注意if for折线后面的冒号 下一行空一个space
def zhengfu(x):
if x>=0:
print '正'
else:
print '负'
for x in [-1,0,1]:
zhengfu(x)
# 负
# 正
# 正
\end{lstlisting}
\textbf{类}
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
#Python中类的定义比较明确
class Greeter:
#构造函数
def _init_(self,name):#这个好像要单独调用不知道为什么
self.name=name#创建name变量的实例化
#实例方法
def greet(self,loud=False):
if loud:
print 'Hello,%s!'%self.name.upper()
else:
print 'Hello,%s'%self.name
g=Greeter()
g._init_('duanlianda')
g.greet()
g.greet(loud=True)
# Hello,duanlianda
# Hello,DUANLIANDA!
\end{lstlisting}
\
\subsubsection{Numpy}
%\textbf{Numpy}
Numpy是python中科学计算的核心，提供了多维数组对象和相关工具。
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
import numpy as np
a = np.array([0,1,3,4,5,6])#定义一个数组
a[1]=11#更改下标为1 的元素
a[1]#11
print a#[ 0 11 3 4 5 6]
b = np.array([[1,2,3],[4,5,6]])#多维数组注意格式([[第一行],[第二行]])
print b
# [[1 2 3]
# [4 5 6]]
print b.shape#(2, 3)#打印行列的情况
print b[0,0],b[0,1],b[1,0]#1 2 4#多维数组的访问print b.shape#(2, 3)
print b[0,0],b[0,1],b[1,0]#1 2 4\end{lstlisting}
一些创建数组的便捷方法：
%\textbf{Numpy}
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
#创建2*2的零矩阵
a=np.zeros((2,2))
print a;
# [[ 0. 0.]
# [ 0. 0.]]
#创建各元素值为1 的1*2矩阵
b=np.ones((1,2))
print b
# [[ 1. 1.]]
#创建各元素值为7 的2*2矩阵
c=np.full((2,2),7)
print c
# [[7 7]
# [7 7]]
#创建3*3的单位矩阵
d=np.eye(3)
print d
# [[ 1. 0. 0.]
# [ 0. 1. 0.]
# [ 0. 0. 1.]]
#使用随机数创建3*3的矩阵
e=np.random.random((3,3))
print e
# [[ 0.60953609 0.87677255 0.13511552]
# [ 0.88487673 0.63783902 0.30111991]
# [ 0.74261468 0.86668638 0.28474936]]
\end{lstlisting}
数组的索引:
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
import numpy as np
#创建一个矩阵（rank=2 ，（3，4））
a=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print a
# [[ 1 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
#取出第1行，第二列开始的形状为（2，2）的子数组
b=a[:2,1:3]
print b
# [[2 3]
#另一个例子
# [6 7]]
b=a[1:2,1:3]
print b
# [[6 7]]
\end{lstlisting}
\textbf{注意}：Numpy中数组的切片b实际上是原数组a的子备份，如果修改b中的元素
a中对应的元素也是会变的：
%\textcircled{1} \textcircled{2}
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
a=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print a
# [[ 1 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
b=a[:2,1:3]
# [[2 3]
# [6 7]]
print b
print '原始的a【0，1】： ',a[0,1]
b[0,0]=250#这里对应的是a中的a【0，1】
print '更改后的的a【0，1】： ',a[0,1]
# 原始的a【0，1】： 2
# 更改后的的a【0，1】： 250
\end{lstlisting}
\subsubsection{BroadCasting}
广播机制允许NumPy在不同形状的数组中执行数学操作。
\\
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
#广播机制的应用
v=np.array([1,2,3])
w=np.array([4,5])
print v.reshape(3,1)+w
# [[5 6]
# [6 7]
# [7 8]]
print v.reshape(3,1)*w
# [[ 4 5]
# [ 8 10]
# [12 15]]
\end{lstlisting}
%\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
% rulesepcolor=\color{red!20!green!20!blue!20},
% keywordstyle=\color{green!70!black},
%commentstyle=\color{blue!90!}, %注释颜色越大越深
%basicstyle=\ttfamily]
%#Numpy python中科学计算的核心
%
%
%
%\end{lstlisting}
\subsubsection{作图：matplotlib}
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
import matplotlib.pyplot as plt
x=np.arange(0,3*np.pi,0.1)#值域范围
y=np.sin(x)#计算sine
z=np.cos(x)#计算cossine
plt.plot(x,y)#实例化作图
plt.plot(x,z)
plt.xlabel('x')#坐标轴标注
plt.ylabel('y')
plt.legend(['sine','cosine'])
plt.title('y=sin(x) and y=cos(x)')#图例
plt.grid()#加上网格
plt.savefig('/Users/dlp/Desktop/test.png')
plt.show()
\end{lstlisting}
作图结果：
\begin{figure}[H]
\begin{adjustwidth}{-5cm}{-6cm}
\begin{center}
\includegraphics[width=7cm]{test_1.png}
% \caption{default}
\label{default}
\end{center}
\end{adjustwidth}
\end{figure}
绘制子图的方法：
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
import matplotlib.pyplot as plt
x=np.arange(0,3*np.pi,0.1)#值域范围
y=np.sin(x)#计算sine
z=np.cos(x)#计算cossine
plt.subplot(2,1,1)
plt.plot(x,y)#实例化作图
plt.grid()#加上网格
plt.xlabel('x')#坐标轴标注
plt.ylabel('y')
plt.subplot(2,1,2)
plt.plot(x,z)
plt.xlabel('x')#坐标轴标注
plt.ylabel('y')
plt.xlabel('x')#坐标轴标注
plt.ylabel('y')
plt.grid()#加上网格
plt.savefig('/Users/dlp/Desktop/test_2.png')
plt.show()
\end{lstlisting}
作图结果：
\begin{figure}[H]
\begin{adjustwidth}{-5cm}{-6cm}
\begin{center}
\includegraphics[width=8cm]{test_2.png}
% \caption{default}
\label{default}
\end{center}
\end{adjustwidth}
\end{figure}
%=====================
\section{第二章：机器学习基石}
\subsubsection{Learning algorithm}
\textcircled{a}:学习算法：能够从数据中学习的算法。\\\textcircled{b}:Mitchell(1997)给出的定义：对于某类任务T（task）和性能度量P（Performance Measure），如果程序在任务T中，其性能P能够随着经验E（Experience）自我完善，那么这个程序能在经验中学习。\\\textcircled{c}:学习的前提是要有潜在的规律
\subsubsection{学习任务}学习指的是获得执行任务的能力。通常把一条数据描述为一条$n$维实数向量$x\in \textbf{R}^{n}$。其中$x_{i}$是向量$x$的一个特征。向量可以理解为一个一维数组，其中每个元素就是一个特征。特别地，对于一张图片，一个像素就是一个特征。下面列举几类机器学习最常见的任务：
\begin{itemize}
\item{分类（Classification）：}
学习算法学习一个函数$f$。实际执行中执行$f$,将输入数据$x$映射到一个k维的空间。符号化表示为:$$f:\textbf{R}^{n}\to \{1,...,k\}$$ 注意$f$的输出可以使表示类别的离散值，也可以是表示概率的连续值，比如“此邮件是垃圾邮件的概率为$0.8$”。
\item{回归（Regression）：}
回归可以理解为预测，符号化表述为：$$f:\textbf{R}^{n}\to \textbf{R}$$ 除了输出格式的不一样，回归问题与分类问题没有本质的区别。
\item{机器翻译{Machine translation}：}
输入一串序列信号转换为另一串序列信号。可以是语音也可以是文本。
\item{结构化输出（Structured output）}
指的是输出的结果为一个向量。具体的应用案例是Google的看图说话。前几层使用CNN提取图像的特征，后几层为循环神经网络，最终输出为文字信号。符号化表述为：
$$Picture\to CNN \to feature \to RNN \to output \to text$$
\item{异常检测（Anomaly detection）}
用程序检测利群数据。（金融诈骗）
\item{降噪（Denoising）}
已知数据与未知数据之间存在噪声，为了增强系统的抗噪声性能，需要降噪。
\end{itemize}
机器学习的最终目的：\textbf{替代或者辅助人的智能行为}。
\subsubsection{性能的度量}
\begin{itemize}
\item{精度（accuracy）与错误率(error rate)}正确/错误分类样本占总分类样本的比值。通常称错误率为$0-1$期望，将错误分类记为1 ，错误记为0，累加所有错误分类再除以全部分类的数据就得到了$0-1$期望的期望值。
\item{测试数据集（test set of data)}:数据有训练（家庭作业）、验证（期中考试）、测试（实战）三种。
\item{查全率（recall）与查准率（precision）}:四种情况的随机组合：正例（正确、非正确），反例（正确、非正确）。由True False Positive Negative 组合为:$$TP\ FP\ TN\ FN$$
于是有混淆矩阵（Confusion Matrix）:
$$
\left[
\begin{array}{ccc}
\ & T& F\\
P &TP & FN\\
N &TN & FN
\end{array}
\right]
$$\\
查准率（precision）P就是预测结果为“1”中预测正确的比例：$$P=\frac{TP}{TP+FP}$$
查全率（recall）就是本来全部为“1”的数据中分类器预测正确的比例$$P=\frac{TP}{TP+FN}$$
\end{itemize}
\subsubsection{Cost function}
梯度下降是寻找“下山”的方向。寻找这个方向需要求“梯度”，多元函数的导数称为“梯度”。计算代价函数的一种形式如下:$$J(w)=\frac{1}{2m}\sum_{i=1}^{m}(y^{(i)}-f(x^{(i)};w))$$
这里，前面有一个$\frac{1}{2}$是为了之后求偏导的时候抵消掉求偏导数产生的$2$.
%$\frac{\partial^2 y}{\partial x^2} $
对这样一个$J(w)$求偏导数。假设任务为二维的数据，表示为$f(x;w)=w_{1}x_{1}+w_{2}x_{2}$。那么对于第一个参数$w_{1}$学偏导数有：
$$\frac{\partial J(w)}{\partial w_{1}}=\frac{\partial J(w)}{\partial f(w)}*\frac{\partial f(w)}{\partial w_{1}}=-\frac{1}{m}\sum_{i=1}^{m}(y^{(i)}-f(x^{(i)};w))*x_{1}^{(i)} $$
同样，对于第一个参数$w_{2}$学偏导数有：
$$\frac{\partial J(w)}{\partial w_{2}}=\frac{\partial J(w)}{\partial f(w)}*\frac{\partial f(w)}{\partial w_{2}}=-\frac{1}{m}\sum_{i=1}^{m}(y^{(i)}-f(x^{(i)};w))*x_{2}^{(i)} $$
具体的算法可以描述如下：
%
%\begin{algorithm}
%\caption{A}
%\label{alg:A}
%\begin{algorithmic}
%\STATE {set $r(t)=x(t)$}
%\REPEAT
%\STATE set $h(t)=r(t)$
%\REPEAT
%\STATE set $h(t)=r(t)$
%\UNTIL{B}
%\UNTIL{B}
%\end{algorithmic}
%\end{algorithm}
\begin{algorithm}
\caption{Gradient Decent}
\label{alg:A}
\begin{algorithmic}
\STATE {st:Training data set: $X=\{x^{1},x^{2},x^{3},...,x^{n}\}$}
%\REPEAT
\STATE We have a learning machine denoted as： $f(x;w)=w_{1}x_{1}+w_{2}x_{2}+w_{3}x_{3}$
\REPEAT
\STATE $w_{i}=w_{i}+\alpha\frac{1}{m}\sum_{j=1}^{m}(y^{(j)}-f(x^{(i)};w))*x_{i}^{j}$
\UNTIL{Convergence}
%\UNTIL{B}
\end{algorithmic}
\end{algorithm}
其中$\alpha $是学习效率，指的是学习的步长。太大会导致“来回抖动”收敛缓慢，太小会导致收敛缓慢但是没有“抖动”的现象。注意$\alpha$隐含了一个负号，也就是训练的过程实际上是Cost function减小的过程。每次修正$w_{j}$就是在下降的方向上下降一个距离$\alpha$。
查一下我们国家工业出口的工业构成，华为手机真正的利润构成
\subsubsection{Gradient Decent}
如何使用matlab求代价函数的梯度？
\subsubsection{Gradient Decent}
使用matlab进行梯度下降的具体实现？
\subsubsection{Over/Under Fitting}
这个地方简单了解Over/Under Fitting对模型泛化性能的影响。
\subsubsection{Super Parameter $\&$ Validation set}
待定
\section{第三章:前馈神经网络（BP）}
\section{一个使用TensorFlow搭建神经网络的过程}
\subsection{一些有关TensorFlow的基础}
\subsubsection{Tensorflow简单计算}
%=============
%\begin{itemize}
在python中，使用TensorFlow进行简单的相乘运算时，使用生成运算图的方法来规划具体的计算方法，使用启动with tf.Session() as sess: print sess.run(yy) 的语句来执行计算图。
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,
frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
import tensorflow as tf
# a=tf.constant([1.0,2.0])
# b=tf.constant([3.0,4.0])
x=tf.constant([[1.0,2.0]])#不论如何都要把变量括起来([....])
xx=tf.constant([[3.0],[4.0]])
yy=tf.matmul(x,xx)
# c=tf.constant
# result=tf.add(a,b) #sameresult
# y=a+b
with tf.Session() as sess:
print sess.run(yy)
输出结果：[[ 11.]]
\end{lstlisting}
\ \\
1.构建数据集，提取特征\\2.构建计算图\\3.使用前向传播计算输出\\3.使用优化好的模型进行使用
\section{第四章：深度学习Normaliztion}
\section{第五章：深度学习优化}
\section{第六章：卷积神经网络（CNN）}
\section{第七章：循环神经网络（RNN）}
\section{第八章：TensorFlow}
\section{Reference}
\section{Latex}
%\begin{itemize}
\begin{lstlisting}[language={Tex},numbers=left,numberstyle=\tiny,
frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!90!}, %注释颜色越大越深
basicstyle=\ttfamily]
%插入代码块：
\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,
%frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!10!},
basicstyle=\ttfamily]
def quicksort(arr):%这里是代码
\ end{lstlisting}
print quicksort([3,6,8,10,1,2])#输入测试数据并且打印排序结果
输出结果：[1, 2, 3, 6, 8, 10]
\end{lstlisting}
%\newpage
\begin{lstlisting}[language={Tex},numbers=left,numberstyle=\tiny,
frame=shadowbox,
rulesepcolor=\color{red!20!green!20!blue!20},
keywordstyle=\color{green!70!black},
commentstyle=\color{blue!60!},
basicstyle=\ttfamily]
%插入图片
\begin{figure}[H]
\begin{adjustwidth}{-5cm}{-6cm}
\begin{center}
\includegraphics[width=10cm]{fff.jpeg}
% \caption{default}
\label{default}
\end{center}
\end{adjustwidth}
\end{figure}
\ end{lstlisting}
print quicksort([3,6,8,10,1,2])#输入测试数据并且打印排序结果
输出结果：[1, 2, 3, 6, 8, 10]
\end{lstlisting}
\end{document}
%一些模板：\\
%\begin{itemize}
%\item 所谓的机器的意识是什么?
%\item
%\end{itemize}
%插入图片
%\begin{figure}[H]
% \begin{adjustwidth}{-5cm}{-6cm}
% \begin{center}
% \includegraphics[width=10cm]{fff.jpeg}
%% \caption{default}
% \label{default}
% \end{center}
% \end{adjustwidth}
% \end{figure}
%代码模板
%\begin{lstlisting}[language={Python},numbers=left,numberstyle=\tiny,%frame=shadowbox,
% rulesepcolor=\color{red!20!green!20!blue!20},
% keywordstyle=\color{green!70!black},
%commentstyle=\color{blue!10!},
%basicstyle=\ttfamily]
%def quicksort(arr):%这里是代码
%\end{lstlisting}
