# AI学习笔记

##技术篇
 ### pytorch搭建模型
    out = nn.Linear(hidden_size,output_size) 定义全连接输入维度hidden_size，输出维度output_size
    embed = nn.Embedding(input_size, embed_size) 定义维度为input_size，embed_size的词向量层，input_size时词的个数
    softmax = nn.LogSoftmax(dim = 1) 定义logSoftmax，根据维度1来计算
    drop_out = nn.Dropout(0.9) 定义dropout层
    v = nn.Parameter(torch.rand(8)) 定义大小为8的向量，可以有梯度
    clip_grad_norm_(model.encoder.parameters(),config.max_grad_norm) 梯度剪裁

 ### 函数类
    output = F.sigmoid(output) sigmoid函数
    output = F.relu(output) relu函数
    output,hidden = self.gru(output,hidden) gru的调用
    torch.cat((embedded[0], hidden[0]), 1) 将embedded[0], hidden[0]按照维度1拼接
    hidden.repeat(8, 1, 1) hidden向量进行复制，0维度复制8次
    hidden.transpose(0, 1) hidden向量的维度0，1互换为，hidden.transpose(1, 0)效果一样
    hidden.unsqueeze(0) 添加维度0
    hidden.squeeze(0) 删除维度0
    x.view(2,1,3) x.view(2,3)
    x.view((2,1,3)) x.view((2,3))
    s_t.expand_as(encoder_output) 将s_t扩展成和encoder_output相同的形状，沿着每个维度复制 s_t 的元素
    x.contiguous() 可以确保张量在内存中是连续的，有利于后续的计算操作。
    x_copy = torch.where(x>len(self.v)-1,oov_token,x) 如果x>len(self.v)-1的条件满足，则为oov_token，不满足则为x
    torch.ne(x_copy,0) x_copy中的每个元素和0是否不同，不同则为False，相同则为True
    torch.gather(input,dim,index) 从张量input中收集指定位置的值
    torch.stack(step_list,1) step_list是一个list,[[1,2],[3,4],[5,6]] -> [[1,3,5],[2,4,6]]

 ### 定义张量
     oov_token = torch.full(x.shape,self.v.UNK).long().to(self.DEVICE) 定义size为x的张量

 ### 计算类
     相同size的矩阵 +-*/
     torch.mean(input, dim=1) 维度为1的方向做平均

 ### numpy基础
-   一些特殊的数字
    np.inf 无穷大
    np.nan 不是数字

-   numpy生成随机数据
    np.random.normal(0, 10, 1024) 标准正态分布 平均数0，标准差10，1024个数据,正态分布也叫高斯分布
    np.random.randn(2,3) 标准正态分布， 平均数0，方差1，变成2X3的矩阵
    np.random.uniform(0,1,1024) 随机取值，从0开始到1，1024个数据
    np.random.randint(100,200,(3,3)) 获得100-200的随机整数，变成3X3的矩阵
    np.random.RandomState.rand(2,3) 返回2X3的[0,1)的数组

-   创建数组
    np.zeros([3,3],dtype = np.int) 创建一个3X3的int全0矩阵
    np.ones([4,4],dtype = np.float) 创建一个4X4的float全1矩阵
    np.arange(10,20,2,np.int8) 创建一个矩阵[10,12,14,16,18]
    np.eye(5) 创建5X5的单位矩阵
    np.asarray([1,2,3,4,5],dtype=np.int64) 根据list生成矩阵
    np.array(list) 根据list生成矩阵
    np.linespace(1,10,10) 起点1，终点10，数列个数10 等差数列
    np.logspace(0,9,num=10,base=2) 开始值：0X2，一共10个值，base是log的底数 的等比数列

-   切片和索引
    a = np.arange(10)
    b = a[2:7:2] 索引2开始到索引6停止，间隔2
    c = a[a>5] 获得大于5的元素
    d = a[~np.isnan(a)] ~是取补的操作，获得不是nan的元素

-   生成网格坐标点
    x,y = np.mgrid([1:3:1,2:4:0.5]) x是1开始3不包含结束的步长1的数组，y是2开始4不包含结束的步长0.5的数组
    np.ravel() 把多维数组转换成1维数组
    np.c_[数组1，数组2...] 配对输出  ,即[(x1,y1),(x2,y2)]

-   循环每个元素
    for x in np.iter(a):
        print(x)
    循环元素的时候，如果想进行修改： for x in np.nditer(a, op_flags=['readwrite']):

-   循环每个元素2
    for x in a.flat:
        print(x)

-   循环每一行
    a = np.arange(10).reshape(2,5)
    for row in a:
        print(a)

-   数组操作
    a.reshape(2,5) 改变形状
    b = a.flatten() 返回数组的拷贝，修改之后不会影响原数组
    b = a.ravel() 返回数组，修改之后会影响原数组
    a.T 矩阵的转置
    a.transpose() 矩阵的转置

-   维度操作
    y = np.expand_dims(x, axis = 0) x的基础上新增一个维度
    y = np.squeeze(x, axis = 0) x的基础上删除一个维度

-   连接数组
    c = np.concatenate((a,b),axis = 1) 沿axis=1的轴连接a和b
    np.stack((a,b),0) 沿着axis=0的新轴连接a和b
    np.hstack((a,b)) 水平连接 列数增多
    np.vstack((a,b)) 竖直连接 行数增多

-   分割数组
    b = np.split(a,3) 将a分割成3个一样的数组
    b = np.split(a,[4,7]) 将a分割成 0-3 4-6 7: 这样的数组
    b = np.hsplit(a,3) 水平分割 按照列分
    b = np.vsplit(a,[3,7]) 竖直分割 按照行分

-   数组元素的添加和删除
    np.append(a, [[7,8,9]],axis = 0) 轴0添加元素
    np.insert(a,1,[11],axis = 0)    轴0添加的位置1添加元素
    np.delete(a,1,axis = 1) 轴0的位置1的元素删除

-   数组去重
    np.unique(a)

-   位运算bitwise_
    bitwise_and 数组元素按位与 简写 &
    bitwise_or  数组元素按位或 简写 |
    left_shift  向左移动2进制表示的位 简写 <<
    right_shift 向右移动2进制表示的位 简写 >>
    invert按位取反             简写 ~
    ^ 异或 相同是0，不相同是1

-   三角函数
    np.pi 获得π
    np.sin()  np.cos() np.tan()
    np.arcsin() np.arccos() np.arctan()
    numpy.degrees() 里面传arc的结果，展示角度

-   四舍五入
    np.around(a,dicimals=2)保存2位小数
    np.floor(a)向下取整
    np.ceil(a)向上取整

-   算数函数
    np.add(a,b)两个数组相加
    np.substract(a,b)两个数组相减
    np.multiply(a,b)两个数组相乘
    np.divide(a,b)两个数组相除
    np.reciprocal(a)取倒数
    np.power(a,2) 获得数组a的平方
    np.power(a,b) 数组a的b次方
    np.mod(a,b) 等价于 np.remainder(a,b) 获得a除以b的余数

-   统计函数
    np.sum(a) a的所有元素之和
    np.prod(a) a的所有元素乘积
    np.amin(a,axis=0) 轴0的最小值
    np.amax(a,axis=1) 轴1的最小值
    np.max([-2,-1,0,1,2]) # 2 返回最大值
    np.maximum([-3,-2,-1,0,1,2],0) #array[0,0,0,0,1,2] X和Y逐位比较，选择最大值
    np.ptp(a,axis=1) 轴1的最大值和最小值的差值
    np.percentile(a,50,axis=0) 在0轴上获得大小50%的百分位数
    np.median(a axis=0) 在0轴上获得中位数
    np.mean(a,axis=1)  在1轴获得平均值(算数平均值)
    np.average([1,2,3,4],weights=[4,3,2,1])获得(加权)平均值 加权平均值 = (1*4+2*3+3*2+4*1)/(4+3+2+1)
    np.var(a)获得方差 var = mean((x - x.mean())**2)
    np.std(a)获得标准差 std = sqrt(mean((x - x.mean())**2))

-   排序
    np.sort(a,axis=0)按照0轴排序
    np.argsort(a)返回排序的序列号
    np.msort() 按照数据的0轴排序，等价于np.sort(a,axis=0)
    np.sort_complex() 按照复数排序
    np.argmin()返回最小值的下标
    np.argmax()返回最大值的下标

-   筛选
    np.nonzero(a) 不为0的返回1，为0的范围0
    np.where(x>3) 返回x的元素大于3的元素的索引
    np.extract() 返回满足的元素

-   副本和视图
    对副本的修改不会影响原始数据，对视图的修改会影响原始数据
    情况1：
    a = np.arange(6)
    b = a  表示 内存地址的赋值，a和b其实是同一个东西
    情况2：
    b = a.view()
    浅拷贝，他们的ndarray是同一个，但是修改维度是独自的
    情况3：
    b = a.copy()
    深拷贝，完全独立

-   矩阵Matrix初始化
    a.T = a.transpose() 矩阵转置
    np.matlib.zeros((2,2)) 返回0填充的2X2的矩阵
    np.matlib.ones((2,2)) 返回1填充的2X2的矩阵
    np.matlib.eye(n =  3, M =  4, k =  0, dtype =  float) 3行4列的矩阵
    np.matlib.identity(5, dtype =  float) 返回5X5的单位阵，对角线是1
    np.matlib.rand(3,3) 返回3X3的随机矩阵
    np.matrix('1,2;3,4') 返回2X2的矩阵 [[1 2][3 4]]

-   数组运算
    np.unique(x) 去重
    np.intersect1d(x,y) 计算x和y中的（交集）公共元素
    np.union1d(x,y) 计算x和y重的并集（共同元素）
    np.in1d(x,y) x是否包含于y的布尔数组
    setdiff1d(x,y) 集合的差，元素在x中，且不在y中
    setxor1d(x,y) 在一个集合中，不在两个集合中的元素

-   线性代数
    np.dot(a,b) 两个数组相乘
    np.vdot(a,b) 两个向量的点积，对应位置相乘
    np.matmul(a,b) 两个数组相乘，和np.dot()一样
    np.linalg.det(a) 返回行列式a的值
    np.linalg.solve() 获得矩阵线性方程的解
    np.linalg.inv(a) 获得矩阵a的逆矩阵 等价于np.dot(ainv,a)

-   numpy的io操作
    np.save('名字',arr)保存数据
    np.load('名字.npy')加载数据
    np.savez('名字.npz',a=arr,b=arr2)多个数组保存到一个文件里面
    np.loadtxt('array_ex.txt',delimiter=',')加载txt文件的数据
    np.savetxt()保存成txt文件

### dataframe 数据格式
- 基本概念
    - colums 列名
    - index 获取指定列所有元素
    - colums和index，作为列的名字和行的名字，统称为表格的label,除了label之外，也可以把整个表格当成一个矩阵
    矩阵有行列编号，这边编号叫postion,通过postion定位元素，比如[5,3]
    - df.shape  # 输出dataframe有多少行、多少列
    - df.shape[0]  # 取行数量，相应的列数量就是df.shape[1]
    - df.columns  # 顺序输出每一列的名字，演示如何for语句遍历
    - df.index  # 顺序输出每一行的名字，可以for语句遍历
    - df.dtypes  # 数据每一列的类型不一样，比如数字、字符串、日期等。该方法输出每一列变量类型
    - df.head(3)  # 看前3行的数据，默认是5。与自然语言很接近
    - df.tail(3)  # 看最后3行的数据，默认是5
    - df.sample(n=3)  # 随机抽取3行，想要去固定比例的话，可以用frac参数
    - df.describe()  # 非常方便的函数，对每一列数据有直观感受；只会对数字类型的列有效
    - pd.set_option('expand_frame_repr', False)  # 当列太多时不换行
    - pd.set_option('max_colwidth', 8) # 设定每一列的最大宽度，恢复原设置的方法
    - df['股票代码']  # 根据列名称来选取，读取的数据是Series类型
    - df[['股票代码', '收盘价']]  # 同时选取多列，需要两个括号，读取的数据是DataFrame类型
    - df[[0, 1, 2]]  # 也可以通过列的position来选取

- loc 操作
    - df.loc['12/12/2016']  # 选取指定的某一行，读取的数据是Series类型
    - df.loc['13/12/2016': '06/12/2016']  # 选取在此范围内的多行，和在list中slice操作类似，读取的数据是DataFrame类型
    - df.loc[:, :]  # 读取所有行、所有列，读取的数据是DataFrame类型
    - df.at['12/12/2016', '股票代码']  # 使用at读取指定的某个元素。loc也行，但是at更高效
- iloc操作：通过position来读取数据
    - df.iloc[0]  # 以index选取某一行，读取的数据是Series类型
    - df.iloc[1:3]  # 选取在此范围内的多行，读取的数据是DataFrame类型
    - df.iloc[:, 1:3]  # 选取在此范围内的多列，读取的数据是DataFrame类型
    - df.iloc[1:3, 1:3]  # 读取指定的多行、多列，读取的数据是DataFrame类型
    - df.iloc[:, :]  # 读取所有行、所有列，读取的数据是DataFrame类型
- 读取某个字段然后转换成str
    - df.iloc[0]['code'] 返回str
- 重置索引
    - df.set_index('某一列的名字',inplace = True)
- 列操作
- 行列加减乘除
    - df['股票名称'] + '_地产'  # 字符串列可以直接加上字符串，对整列进行操作
    - df['收盘价'] * 100  # 数字列直接加上或者乘以数字，对整列进行操作。
    - df['收盘价'] * df['成交量']  # 两列之间可以直接操作。收盘价*成交量计算出的是什么？
    - df['股票名称+行业'] = df['股票名称'] + '_地产' 新增一列
- 统计函数
    - df['收盘价'].mean()  # 求一整列的均值，返回一个数。会自动排除空值。
    - df[['收盘价', '成交量']].mean()  # 求两列的均值，返回两个数，Series
    - df[['收盘价', '成交量']].mean(axis=1)  # 求两列的均值，返回DataFrame。axis=0或者1要搞清楚。
- 函数
    - df['收盘价'].max()  # 最大值
    - df['收盘价'].min()  # 最小值
    - df['收盘价'].std()  # 标准差
    - df['收盘价'].count()  # 非空的数据的数量
    - df['收盘价'].median()  # 中位数
    - df['收盘价'].quantile(0.25)  # 25%分位数
- shift类函数、删除列的方式
    - df['昨天收盘价'] = df['收盘价'].shift(1)  # 读取上一行的数据，若参数设定为3，就是读取上三行的数据；若参数设定为-1，就是读取下一行的数据；
    - del df['昨天收盘价']  # 删除某一列的方法
    - df['涨跌'] = df['收盘价'].diff(-1)  # 求本行数据和上一行数据相减得到的值
    - df[['收盘价', '涨跌']]
    - df.drop(['涨跌'], axis=1, inplace=True)  # 删除某一列的另外一种方式，inplace参数指是否替代原来的df
    - df['涨跌幅_计算'] = df['收盘价'].pct_change(-1)  # 类似于diff，但是求的是两个数直接的比例，相当于求涨跌幅
- cum(cumulative)类函数
    - df['成交量_cum'] = df['成交量'].cumsum()  # 该列的累加值
    - (df['涨跌幅'] + 1.0).cumprod()  # 该列的累乘值，此处计算的就是资金曲线，假设初始1元钱
- 其他列函数
    - df['收盘价_排名'] = df['收盘价'].rank(ascending=True, pct=False)  # 输出排名。ascending参数代表是True顺序还是False逆序。pct参数代表输出的是排名还是排名比例
    - print df[['收盘价', '收盘价_排名']]
    - del df['收盘价_排名']
- 计数
    - print df['股票代码'].value_counts()  # 计数。统计该列中每个元素出现的次数。返回的数据是Series
- 通用函数
    - df.apply(f,axix=0)
    - df.applymap(f) 元素级别函数
- 筛选操作，根据指定的条件，筛选出相关拿数据
    - df['股票代码'] == 'sh000002'  # 判断股票代码是否等于sz000002
    - df[ df['股票代码'] == 'sh000002']  # 将判断为True的输出：选取股票代码等于sz000002的行
    - df[df['股票代码'].isin(['sz000002', 'sz000003 ', 'sz000004'])]  # 选取股票代码等于sz000002的行
    - df[df['收盘价'] >= 24.0]  # 选取收盘价大于24的行
    - df[(df.index >= '03/12/2016') & (df.index <= '06/12/2016')]  # 两个条件，或者的话就是|
    - df.query("year >= 2010 and ages == 'total'") 条件查询
    - df.groupby('某字段').resample('M').mean()  按月求某字段的平均值
    - df.groupby(['职业'])['捐款'].sum() 根据职业获得全款的总和
- 直接画图
    - df['AdjClose'].plot() 画出折线图，横坐标是索引，如果横坐标是日期类型则可以显示
- 查询某个字段所有去重数据
    - df['标志字段'].unique()
- 缺失值处理：原始数据中存在缺失值，如何处理？
    - 查询是否有空值
        - df.isnull().any()  查看是否有某一列是否有空值
        - condition = df['aaa'].isnull() aaa列的所有行是否为空 这个作为条件去查询
        - df[condition]['index_name'].unique() 我们就知道某个字段的什么是空值了 标志字段为index的时候不需要unique
    - 删除缺失值
        - df.dropna(how='any')  # 将带有空值的行删除。how='any'意味着，该行中只要有一个空值，就会删除，可以改成all。
        - df.dropna(subset=['MACD_金叉死叉', '涨跌幅'], how='all')  # subset参数指定在特定的列中判断空值。all代表全部为空，才会删除该行；any只要一个为空，就删除该行
    -  补全缺失值
        - df.notnull()  # 判断是否为空值，反向函数为isnull()
        - df[df['MACD_金叉死叉'].notnull()]  # 将'MACD_金叉死叉'列为空的行输出
- 排序函数
    - df.reset_index(inplace=True)
    - df.sort_values(by=['交易日期'], ascending=1)  # by参数指定按照什么进行排序，acsending参数指定是顺序还是逆序，1顺序，0逆序
    - df.sort_values(by=['股票名称', '交易日期'], ascending=[1, 1])  # 按照多列进行排序
    - df.sort_index(by=['交易日期'])
- 合并操作
    - df.reset_index(inplace=True)
    - df1 = df.iloc[0:10][['交易日期', '股票代码', '收盘价', '涨跌幅']]
    - df2 = df.iloc[5:15][['交易日期', '股票名称', '收盘价', '涨跌幅']]
    - df1.append(df2) # append操作，将df1和df2上下拼接起来。注意观察拼接之后的index
    - pd.concat([df1,df2,df3],axis=0)
    - df3 = df1.append(df2, ignore_index=True)  # ignore_index参数，用户重新确定index
    - df = pd.merge(left=df1, right=df2, on="ts_code", how="left") 左右两个根据on的字段合并
    - df = pd.merge(left=df1, right=df2, left_on="ts_code", right_on="aaa", how="outter") 左边根据left_on，右边根据right_on合并，用于合并字段不同的情况
    how可以：inner outer left right
- 删除列
    - df1.drop(labels = 'aaa',axis = 1) 删除index = aaa列
    - 用法：index = df1[df1['total']<2000].index
    - df1.drop(labels = index) 删除 total<2000 的数据
- 数据去重
    - df3.drop_duplicates(
         subset=['收盘价', '交易日期'],  # subset参数用来指定根据哪类类数据来判断是否重复。若不指定，则用全部列的数据来判断是否重复
         keep='first',  # 在去除重复值的时候，我们是保留上面一行还是下面一行？first保留上面一行，last保留下面一行，False就是一行都不保留
         inplace=True
     )
- 重要函数
    - df.rename(columns={'MACD_金叉死叉': '金叉死叉', '涨跌幅': '涨幅'})  # rename函数给变量修改名字。使用dict将要修改的名字传给columns参数
    - df.empty  # 判断一个df是不是为空，此处输出不为空
    - pd.DataFrame().empty  # pd.DataFrame()创建一个空的DataFrame，此处输出为空
    - df.T  # 将数据转置，行变成列，很有用

- 字符串处理
    - df['股票代码']
    - 'sz000002'[:2]
    - df['股票代码'].str[:2]
    - df['股票代码'].str.upper()  # 加上str之后可以使用常见的字符串函数对整列进行操作
    - print df['股票代码'].str.lower()
    - print df['股票代码'].str.len()  # 计算字符串的长度,length
    - df['股票代码'].str.strip()  # strip操作，把字符串两边的空格去掉
    - df['股票代码'].str.contains('sh')
    - df['股票代码'].str.replace('sz', 'sh') # 进行替换，将sz替换成sh
    - df['新浪概念'].str.split('；')  # 对字符串进行分割
    - df['新浪概念'].str.split('；').str[:2]  # 分割后取第一个位置
    - df['新浪概念'].str.split('；', expand=True)  # 分割后并且将数据分列

- 时间处理
    - df['交易日期'] = pd.to_datetime(df['交易日期'])  # 将交易日期由字符串改为时间变量
    - df.iloc[0]['交易日期']
    - df.dtypes
    - pd.to_datetime('1999年01月01日') 将字符串转变为时间变量
    - df.at[0, '交易日期']
    - df['交易日期'].dt.year  # 输出这个日期的年份。相应的month是月份，day是天数，还有hour, minute, second
    - ['交易日期'].dt.week  # 这一天是一年当中的第几周
    - ['交易日期'].dt.dayofyear  # 这一天是一年当中的第几天
    - ['交易日期'].dt.dayofweek  # 这一天是这一周当中的第几天，0代表星期一
    - ['交易日期'].dt.weekday  # 和上面函数相同，更加常用
    - ['交易日期'].dt.weekday_name  # 和上面函数相同，返回的是星期几的英文，用于报表的制作。
    - df['交易日期'].dt.days_in_month  # 这一天是这一月当中的第几天
    - df['交易日期'].dt.is_month_end  # 这一天是否是该月的开头，是否存在is_month_end？
    - df['交易日期'] + pd.Timedelta(days=1)  # 增加一天，Timedelta用于表示时间差数据
    - (df['交易日期'] + pd.Timedelta(days=1)) - df['交易日期']  # 增加一天然后再减去今天的日期
    - df.groupby(['交易日期']).resample('M')['交易金额'].sum() #重采样，高频数据变成低频数据，按月汇总


-  均价操作
    - df['收盘价_3天均值'] = df['收盘价'].rolling(5).mean() 最近5天收盘价的均值 rolling(n)即为取最近n行数据的意思，只计算这n行数据。后面可以接各类计算函数，例如max、min、std等
    - df['收盘价'].rolling(3).max()
    - df['收盘价'].rolling(3).min()
    - df['收盘价'].rolling(3).std()
    - df['收盘价_至今均值'] = df['收盘价'].expanding().mean() 计算每天的最近3天的均值，如果想计算每天的从一开始至今的均值
    - df['收盘价'].expanding().max() expanding即为取从头至今的数据。后面可以接各类计算函数
    - df['收盘价'].expanding().min()
    - df['收盘价'].expanding().std()

- 读取
    - df = pd.read_csv(filepath_or_buffer, encoding='gbk')

- 输出
    - df.to_csv('output.csv', encoding='gbk', index=False)

-去掉一列，根据这一列新增三列
    origin = dataset.pop('Origin')
    # 根据 origin 列来写入新的 3 个列
    dataset['USA'] = (origin == 1)*1.0
    dataset['Europe'] = (origin == 2)*1.0
    dataset['Japan'] = (origin == 3)*1.0

### scipy
-   插值案例
    x = np.linspace(0,13.0,20)
    y = np.sin(x)
    xnew = np.linspace(1.0,13.0,1000)
    ynew = scipy.interpolate.spline(x,y,xnew,order=1) 先获得x和y的数组，然后再定义出xnew的数组，得到插值数组ynew，order=1，2，3

### 画图
-   样式
    plt.plot(x,y,color='red',linewidth=1.0,linstyle='--') 红色，虚线，宽度1
    plt.plot([x0, x0,], [0, y0,], 'k--', linewidth=2.5) (x0,0)到(x0,y0)的虚线
    plt.scatter([x0, ], [y0, ], s=50, color='b') (x0,y0)蓝色的点

-   设置坐标轴的格式
    plt.title("我是标题")
    plt.xlabel("这个是x轴")
    plt.ylabel("这个是y轴")
    plt.xlim((-1,2)) x轴的范围(-1,2)
    plt.ylim((0,100)) y轴的范围(0,100)
    new_ticks = np.linspace(-1, 2, 5)
    plt.xticks(new_ticks) 设置x轴的范围(-1,2)且中间有5个格子
    plt.yticks([-2, -1.8, -1, 1.22, 3],[r'$really\ bad$', r'$bad$', r'$normal$', r'$good$', r'$really\ good$']) #设置y轴，是对应的字符的
    ax=plt.gca()获得坐标轴对象ax
    ax.xaxis.set_ticks_position("bottom") 设置x轴的刻度的位置居中：top bottom both default none
    ax.yaxis.set_ticks_position("bottom") 设置y轴的刻度的位置居中

-   设置坐标轴的位置
    ax.spines["buttom"].set_position(('data',0)) 底部的x轴的水平位置是y=0
    ax.spines['left'].set_position(('data',0)) 设置左边的y轴的竖直位置是x=0
    ax.spines['right'].set_color('none') 右侧不显示框
    ax.spines['top'].set_color('none')  上侧不显示框

-   普通画图(线图)
    #plt.figure(num=3,figsize=(8,5))定义一个编号为3，大小为(8,5)的窗口
    plt.figure()定义一个窗口
    plt.plot(x,y) x和y的数据画进去
    plt.show()展示

-   图例
    l1 = plt.plot(x, y1, label='linear line')  label就是图例，此时未显示
    plt.legend(loc='upper right') 在右上角显示图例

-   标注annotation
    plt.annotate(r'$2x+1=%s$' % y0, xy=(x0, y0), xycoords='data', xytext=(+30, -30),
             textcoords='offset points', fontsize=16,
             arrowprops=dict(arrowstyle='->', connectionstyle="arc3,rad=.2"))
             标注的点是(x0,y0) 在这个点的右边30下边30的地方 写 “2x+1=3”

-   标注text
    plt.text(-3.7, 3, r'$This\ is\ the\ some\ text. \mu\ \sigma_i\ \alpha_t$',
         fontdict={'size': 16, 'color': 'r'})
         在(-3.7,3) 的位置上开始写 “This is the some text ... \mu\ \sigma_i\ \alpha_t$ 是三个字母”

-   一张图里面放两张图
    plt.subplot(2,1,1) 高2宽1的第一个图
    plt.plt(x,y_sin)
    plt.subplot(2,1,2) 高1宽1的第二个图
    plt.plt(x,y_cos)
    plt.show()

-   柱状图bar
    plt.bar(x,y,align='center',color='g') 绿色居中的柱状图
    plt.bar(x,y,facecolor='g',edgecolor='white') 主体颜色是绿色，外部边框是白色
    for x, y in zip(X, Y1):
    plt.text(x + 0.4, y + 0.05, '%.2f' % y, ha='center', va='bottom') 前边是字的位置，打印的字是y

-   频率统计柱状图hist
    a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
    plt.hist(a, bins =  [0,20,40,60,80,100])

-   散点图Scatter
    plt.scatter(X, Y, s=75, c=T, alpha=.5) X Y是两个矩阵，s是点的大小size，c是颜色solor，alpha是透明度

-   等高线图Contours

### tensortflow学习
-   张量精度 tf.int16,tf.int32,tf.int64,   tf.float32,tf.float64=tf.double tf.bool
    tf.constant([1.2,2,3.333],dtype = tf.int16)
    tf.cast(a,tf.float32) 将a的精度转换成tf.float32

-   创建分布的张量
    tf.random.normal([1, 10],5,1) 生成正态分布/高斯分布随机数，均值5，标准差1，形状时[1,10]
    tf.random.uniform([1,10],minval=0,maxval=100) 均匀分布0-100的随机值
    tf.truncated_normal 和tf.random.normal大致相同，只是生成的随机数会在均值附近

-   生成张量tensor。张量的数据载体：标量scalar，向量vector，矩阵matrix
    tf.constant(1.2) #生成标量
    tf.constant([1.2,1.3,2.2])生成3X1的张量
    tf.constant('hello deep learning')生成字符串的张量
    tf.constant(True) 生成True或者False的张量
    tf.constant([True,False])

-   待优化张量
    待优化张量 = tf.variable(普通张量) 拥有属性name,trainable等属性
    tf.variable([[1,2],[3,4]])

    -   转换张量
    tf.convert_to_tensor([1,2,3],dtype=tf.float32)
    y = tf.convert_to_tensor(np.array([1,2,3]))

-   创建全0全1的张量
    tf.zeros([3,3])
    tf.ones([3,3])
    tf.zeros_like(a) 创建和a形状相同的全0张量
    tf.ones_like(a) 创建和a形状相同的全1张量
    tf.fill([3,3],99) 创建一个3X3的值为99的张量

-   处理字符串的张量
    tf.strings.lower(a)
    tf.strings.length(a)
    tf.strings.join(a)
    tf.strings.split(a)

-   创建序列
    tf.range(10) 0,1,2,3,4,5,6,7,8,9
    tf.range(1,10,2) 1,3,5,7,9

-   one-hot编码
    tf.one_hot(y, depth=10) # one-hot 编码

-   数学运算
    tf.pow(x,3) 获得x*x*x的值 等价于 X ** 3
    2 ** x 等价于指数运算2的x次方
    tf.exp(3) 表示e的3次方
    tf.math.log(x) 自然对数e为底的log x
    tf.math.log(x) / tf.math.log(10) 表示以10为底的log x
    w.assign_sub(1) 执行w = w-1

-   张量合并和分割
    tf.concat([a,b],axis=0) 按照0轴合并a和b
    tf.stack([a,b],axis=0) 新增0轴，合并a和b
    tf.split(x,axis=0,num_or_size_splits=10) 10个分割成1份，返回一个list
    tf.unstack(x,axis = 0)根据0轴分割，分割长度是1，返回一个list，且0轴维度消失了

-   获得相关系数
    tf.norm(x,ord = 1) ord=1,2,np.inf 获得向量的范数
    tf.reduce_max(x,axis = 1) 统计维度1上面最大值
    tf.reduce_min(x,axis = 1) 统计维度1上面的最小值
    tf.reduce_mean(x,axis = 1) 统计维度1上面的平均值
    tf.reduce_sum(x,axis = 1)统计维度1上面的和
    tf.nn.softmax(x,axis=1) 1轴上的最大值可以代表样本的类型的概率
    tf.argmax(x,axis = 1) 1轴上最大值的索引
    tf.argmin(x,axis = 1) 1轴上最小值的索引

-   张量的使用
    tf.equal(pre,y) 比较两个张量是否相等，相等的是True不相等的是False
    tf.math.greater(pre,y)
    tf.math.less(pre,y)
    tf.math.greater_equal(pre,y)
    tf.math.less_equal(pre,y)
    tf.math.not_equal(pre,y)
    tf.math.is_nan(y)
    tf.pad(x,[[0,2]]) 表示在x左边不加，右边两个加0
    tf.maximum(x,2) 将x中小于2的值都改为2
    tf.minimum(x,7) 将x中大于7的值都改为7
    tf.clip_by_value(x,2,7) 将x固定到2<=x<=7内

-   筛选数据
    tf.gather(x,[0,1],axis=0) x的维度是[4,33,56]，返回[2,33,56] ，将0轴的索引为0和1的加在一起
    tf.gather_nd(x,[[1,1],[2,2],[3,3]]) 获得x[1,1] x[2,2] x[3,3]然后叠加在一起
    tf.boolean_mask(x,[True,False,False,True],axis=0)通过掩码来取样，掩码长度必须和轴上数据长度一致
    cond = tf.constant([[True,True,True],[False,False,False],[True,True,True]])
    tf.where(cond,a,b)当cond为True时返回a，cond为False时返回b。cond是3X3，a和b也得是3X3
    tf.scatter_nd(indices, updates, [8]) 新建一个8X1的全0张量，updates中的数据根据indices放到全0张量中
    tf.meshgrid() 生成二维网格采样点坐标


-   查询找到能反映类别的特征
    out = tf.nn.softmax(out, axis=1) # 输出可以反映类别的概率
    pred = tf.argmax(out, axis=1) # 输出这个索引

-   数据处理
    train_db = tf.data.Dataset.from_tensor_slices((x,y)) # x，y转换成dataset类型
    train_db.shuffle(1000) 数据打散 或者用 train_db.shuffle().step2().step3()
    train_db.batch(128) 一次训练128个样本，提高训练速度
    train_db = train_db.map(process) 执行某个process函数
    def process(x,y):
        x = tf.cast(x,dtype = tf.float32) / 255.0  #归一化
        x = tf.reshape(x,[-1,28*28]) 将[b,28,28]转换成[b,28*28]
        y = tf.cast(y,dtype = tf.int32) y转换成int
        y = tf.one_hot(y,depth=10) 将y转换成ont_hot类型
    return x,y
    循环训练：
    for epoch in range(20): 20个整体迭代
    for step,(x,y) in enumerate(train_db):
    for (x,y) in train_db:
    一个batch训练叫做一个step，多个step完成整个训练集的一次迭代，叫做一个epoch

-   误差计算
    loss = tf.keras.losses.mse(真实y,预测y) 返回每个样本的误差
    loss_mean = tf.reduce_mean(loss)  误差平均值

-   构建神经网络，也叫构建全连接网络
    第一种构建方式：
    fc1 = layers.Dense(256, activation=tf.nn.relu) # 隐藏层 1
    fc2 = layers.Dense(128, activation=tf.nn.relu) # 隐藏层 2
    fc3 = layers.Dense(64, activation=tf.nn.relu) # 隐藏层 3
    fc4 = layers.Dense(10, activation=None) # 输出层
    x = tf.random.normal([4,28*28]) #定义输入
    h1 = fc1(x) # 通过隐藏层 1 得到输出  x ——>h1
    h2 = fc2(h1) # 通过隐藏层 2 得到输出 h1——>h2
    h3 = fc3(h2) # 通过隐藏层 3 得到输出 h2——>h3
    h4 = fc4(h3) # 通过输出层得到网络输出h3——>h4

    第二种构建方式：
    model = layers.Sequential([
        layers.Dense(256, activation=tf.nn.relu) , # 创建隐藏层 1
        layers.Dense(128, activation=tf.nn.relu) , # 创建隐藏层 2
        layers.Dense(64, activation=tf.nn.relu) , # 创建隐藏层 3
        layers.Dense(10, activation=None) , # 创建输出层
    ])
    out = model(x)

    fc.variables 返回所有参数列表
    fc.trainable_variables 返回所有待优化参数列表
    fc.kernel 获得w
    fc.bias 获得b

-   超参数如何选择：AutoML技术搜索出最优设定

-   索引
    a[0]

-   维度
    tf.reshape(x,[3,4,5]) 改变维度的视图
    tf.expand_dims(x,axis = 2) 轴2增加维度
    tf.squeeze(x,axis = 2) 轴2删除维度，只能删除长度为1的维度
    tf.transpose(x,perm=[0,3,1,2]) 0,1,2,3的维度改成0,3,1,2
    tf.tile(x,multiples = [2,1]) 数据复制，维度1将数据复制2份，维度2不变

-   求导
    a = tf.constant(1.0) #创建张量
    b = tf.constant(2.0)
    c = tf.constant(3.0)
    w = tf.constant(4.0)
    with tf.GradientTape() as type: #构建梯度求导环境
        type.watch([w]) #将w加入梯度跟踪列表
        y = a * w ** 2 + b * w + c #构建计算过程
        [dy_dw] = type.gradient(y,[w]) #y对w求导
        print(dy_dw)

-   激活函数
    tf.nn.sigmoid(x) x∈R 转换成[0,1]范围内，但是输入较小或较大时梯度无限接近0
    tf.nn.tanh(x) x属于R转换成[-1,1]范围内
    tf.nn.relu(x)  x<0则返回0，正数直接输出
    tf.nn.leaky_relu(x,alpha=0.01) 这个是lelu的进化版本
    tf.nn.softmax(x) 输出概率，概率和是1  keras.losses.categorical_crossentropy

-   输出层的设计
    o∈R，o∈[0,1]，o∈[-1,1]

-   误差计算
    均方差
    keras.losses.MSE(真实，预测)  需要使用tf.reduce_mean来获得每个样本的均方差 loss_mse = tf.reduce_mean(tf.square(真实-预测))
    keras.losses.MeanSquaredError()
    交叉熵：深度学习，表达不确定性大小
    KL散度
    Hinge Loss 函数

-   神经网络的类型
    全连接层
    卷积神经网络CNN
    循环神经网络RNN
    注意力机制网络

-   学习率
    指数衰减学习率
    lr = lr_base * lr_decay ** (epoch / step)


#### tensortflow学习杂项
-   判断cpu和gpu时否能工作
    with tf.device('/cpu:0'):
        cpu_a = tf.random.normal([1,n])
        cpu_b = tf.random.normal([n,1])
        print(cpu_a.device,cpu_b.device)
    with tf.device('/gpu:0'):
        gpu_a = tf.random.normal([1,n])
        gpu_b = tf.random.normal([n,1])
        print(gpu_a.device,gpu_b.device)

-   查询运行时间
    timeit.timeit(functionName,number=10)运行某个方法10次的平均时间


#### math库函数

-   数字获取
    math.ceil(4.12) # 5 向上取整
    math.floor(4.12) # 4 向下取整
    math.tunc(6.77) # 6 获得整数部分
    math.copysign(2,-3) # -2 把y的正负号放到x上
    math.cos(math.pi) # 获得余弦
    math.sin(math.pi) # 获得正弦
    math.tan(math.pi) # 获得正切
    math.degree(math.pi) # 获得角度
    math.radians(45) 角度转换成弧度
    math.e() # 获得e
    math.pi() #获得pi
-   数字计算
    -log函数
    math.log(x,a) 返回log函数，以a为底，x的对数，如果不指定a，则为e
    math.log10(x) 返回log函数，以10为底，x的对数
    math.log2(x) 返回log函数，以2为底，x的对数

    math.sqrt(100) # 10 获得x的平方根
    math.pow(3,4) # 81 返回x的y次方
    math.exp(2) # 获得e的平方的值
    math.fabs(-0.03) # 0.03 获得绝对值
    math.factorial(3) # 6 1X2X3=6，获得3的阶乘
    math.fmod(20,3) # 2 20/3=6····2 获得余数
    math.fsum((1,2,3,4)) # 10 返回1+2+3+4=10 求和
    math.gcd(8,6) 返回最大公约数 2
    math.hypot(3,4) 5 获得3的平方+4的平方，再开方的结果
    math.ldexp(5,5) 160 获得x*(2**i)

-   数字判断
    math.isfinite(0.1) True  无穷大返回False，其他返回True
    math.inf(0.1) True 无穷大或者无穷小则False，其他返回True
    math.isnan(23) False 不是数字则True，其他False

#### scipy库函数
    -傅里叶变换fft

#### KNN算法
-   分类问题 from sklearn.neighbors import KNeighborsClassifier
             from sklearn.model_selection import train_test_split
    knn = KNeighborsClassifier(5) 选择最近的5个邻居作为判断依据的分类器
    knn.fit(X,Y) 训练，x是数据，y是已知的数据的结果
    knn.predict(X_test) 预测，x_test是测试数据
    knn.score(x_test,y_test) 计算准确率
    a_train,a_test = train_test_split(a,test_size=0.2) 区分训练数据和测试数据

-   线性回归问题 from sklearn.neighbors import KNeighborsRegressor
    from sklearn.linear_model import LinearRegression
    lr =  LinearRegression()
    lr.fit(x_train,y_train)
    lr.predict(x_test).round(2) 保留2位小数的预测
    w_ = lr.coef_

-   线性回归的岭回归
    ridge = Ridge()

-   优化
    str类型不能计算距离，通过map转换成数值的类型--》数据归一化
    修改算法的参数
    数据挖掘，即添加一列，自由组合(age * workclass等)未知的列

####   数据归一化
-   最大值最小值归一化
    v_min = X.min()
    v_max = X.max()
    X2 = (X - v_min) / (v_max - v_min)
-   Z-score归一化,也叫标准归一化
    v_mean = X.mean() 均值
    v_std = X.std() 标准差
    X3 = (X-v_mean) / v_std
-   sklearn的归一化
    from  sklearn.preprocessing import StandardScaler,MinMaxScaler
    s = StandardScaler() Z-score归一化
    X4 = s.fit_transform(s)
    s2 = MinMaxScaler() 最大值最小值归一化
    X5 = s2.fit_transform(s)

####    保存模型
    from  sklearn.externals import joblib
-   joblib.dump(knn,'./model',compress = '9') .z .gz .bz2 .xz .lzma  保存模型 compress表示压缩等级
-   knn2 = joblib.load('./model') 加载数据
    knn的模型在存储的时候，将训练的数据全部都存储了，所以模型很大