numpy和 pandas学习

这是我自己的学习笔记，就不要看了。

##技术篇
### numpy基础
- 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的模型在存储的时候，将训练的数据全部都存储了，所以模型很大

#### 择时策略

#### 选股策略

#### 实盘交易

#### 人工智能与量化投资