這是我自己的學習筆記，就不要看了。
##技術篇
### 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的模型在存儲的時候，將訓練的數據全部都存儲了，所以模型很大
#### 擇時策略
#### 選股策略
#### 實盤交易
#### 人工智能與量化投資