StoneData API说明文档

入门

欢迎光临

      感谢您使用StoneData数据研究平台,以下内容主要介绍StoneData数据研究平台的API使用方法,内容较多,可使用Ctrl+F进行搜索。 如果以下内容仍没有解决您的问题,请您通过社区提问或者问题反馈的方式告诉我们,或者将您的API封装后有偿提交给我们,一起构建一个更加美好数据研究的环境。

API导入

  • 所有的API使用前通过以下方式导入:
  • from stonelib import *
  • from stone_analysis import *
  • from stoneapi_get_data import *
  • from refresh import *

API 详情介绍

get_data

  • 从数据库获取存储数据
get_data(user,table,filters=[],address='127.0.0.1:8512')
user:用户名字
table:调用表名
filters:数据筛选条件,若为空或者不填则返回部分数据
address:局域网内客户端ip地址,默认为本地地址
返回:Dataframe数据格式的调用数据
#示例:
from stonelib import * 
from stoneapi_get_data import *
#展示某个表中的部分数据,查看表的数据类型
df1 = get_data(user = '用户名字',table = '表的调用名字',filters=[])
#调用某支股票某一天的数据
df2 = get_data(user = '用户名字',table = '表的调用名字',filters=['code==000001.XSHE','date ==2018-11-13'])
#调用多支股票某一天的数据
df3 = get_data(user = '用户名字',table = '表的调用名字',filters=['code in [000001.XSHE, 000002.XSHE, 000005.XSHE]','date == 2018-11-13'])
#调用多支股票所有的数据
df4 = get_data(user = '用户名字',table = '表的调用名字',filters=['code in [000001.XSHE, 000002.XSHE, 000005.XSHE]')
#调用某一天所有的数据
df5 = get_data(user = '用户名字',table = '表的调用名字',filters=['date == 2018-11-13'])
#调用某一段时间所有的数据
df6 = get_data(user = '用户名字',table = '表的调用名字',filters=['date bt [2017-11-13, 2018-11-13]')
#调用多支股票某段时间的数据
df7 = get_data(user = '用户名字',table = '表的调用名字',filters=['code in [000001.XSHE, 000002.XSHE]','date bt [2017-11-13, 2018-11-13]'])
df8 = get_data(user = '用户名字',table = '表的调用名字',filters=['code in [000001.XSHE, 000002.XSHE]','date >= 2017-11-13'])
df9 = get_data(user = '用户名字',table = '表的调用名字',filters=['code in [000001.XSHE, 000002.XSHE]','date <= 2017-11-13'])
df10 = get_data(user = '用户名字',table = '表的调用名字',filters=['code in [000001.XSHE, 000002.XSHE]','date < 2017-11-13'])
df11 = get_data(user = '用户名字',table = '表的调用名字',filters=['code in [000001.XSHE, 000002.XSHE]','date > 2017-11-13'])
#调用局域网内其他客户端的数据只需指定address便可
df11 = get_data(user = '用户名字',table = '表的调用名字',filters=['code ==000001.XSHE','date > 2017-11-13'],address='其他客户端地址')

standardize

  • 标准化函数
standardize(series,ty=2)
series为Series数据
ty为标准化方式:1 MinMax,2 Standard,3 maxabs
返回:series标准化后的数据

winsorize

  • 去极值函数
winsorize(series, std=3, have_negative = True)
series:若为因子数据建议以股票code为index,因子值为value的Series
std为几倍的标准差,have_negative 为布尔值,是否包括负值
返回:series去极值后的数据

neutralization

  • 中性化函数
neutralization(series,dummy_industry,mkt_cap = False, industry = True)
series为因子数据,以股票code为index,因子值为value的Series,
dummy_industry:行业类别数据,以股票code为columns,以股票行业类别为index,value值的确定(若某code属于某index则为1,否则为0)
mkt_cap:以股票为index,市值为value的Series,
返回:中性化后的因子值series

get_before_day

  • 获取date前n天的日期,若n为负数,则表示date后n天的日期
get_before_day(n=1,date = datetime.date.today().strftime('%Y-%m-%d'),ty = 'str',form = '%Y-%m-%d')
n:前n天
date:日期,输入如:'2018-01-01'或者'20180101',默认调用当天日期
ty:输出日期格式,ty='date'输出日期类型,ty='str'输出字符串类型
form:'%Y-%m-%d'表示'2018-01-01','%Y%m%d'表示'20180101'
返回:需要的日期

maxdrawdown

  • 计算最大回撤率
maxdrawdown(series)
series:Series类型,为资金历史数值序列(最新数据填充在最底部)
返回:最大回撤率
例:
import tushare as ts
import pandas as pd
import numpy as np
df = ts.get_k_data('000001')
df.set_index('date',inplace=True)
df = df['close']
MaxDrawdown(df)

sharpe_ratio

  • 计算夏普比率
sharpe_ratio(series,free_risk = 0.02)
series:Series类型,为资金历史日线数值序列或净值日线数值序列(最新数据填充在最底部)
free_risk:无风险收益率,默认0.02
返回:夏普比率
例:
import tushare as ts
import pandas as pd
import numpy as np
df = ts.get_k_data('000001')
df.set_index('date',inplace=True)
df = df['close']
sharpe_ratio(df)

annual_return

  • 计算年化收益率
annual_return(series,freq = 'D')
series:Series类型,为资金历史数值序列或净值数值序列(最新数据填充在最底部)
freq:默认'D',表示资金数值序列的周期,'D'表示日线级别,'W'表示周线级别,'M'表示月线级别
返回:年化收益率
例:
import tushare as ts
import pandas as pd
import numpy as np
df = ts.get_k_data('000001')
df.set_index('date',inplace=True)
df = df['close']
annual_return(df,freq = 'D')

win_rate

  • 计算胜率、盈亏比
win_rate(series)
series:Series类型,为资金历史数值序列或净值数值序列(最新数据填充在最底部)
返回:(胜率,盈亏比)
例:
import tushare as ts
import pandas as pd
import numpy as np
df = ts.get_k_data('000001')
df.set_index('date',inplace=True)
df = df['close']
win_rate(df)

stone_check_week

  • 判断当前或者某个日期属于星期几
stone_check_week(date=None)
date:输入日期,当不输入时默认是None,输出当前日期属于星期几,date格式为:'20180916'或者'2018-09-16'。
返回:int数据,0,1,2,3,4,5,6分别表示星期天、一、二、三、四、五、六。
例:
stone_check_week(date='2018-09-14')

stone_check_tradeday

  • 判断当前或者某个日期是否是交易日
stone_check_tradeday(date=None)
date:输入日期,当不输入时默认是None,输出当前日期属于星期几,date格式为:'20180916'或者'2018-09-16'。
返回:int数据,0表示是非交易日,1表示是交易日。
例:
stone_check_tradeday(date=None)

stone_get_tradedays

  • 获取交易日期
stone_get_tradedays(start='2001-01-01',end=datetime.today().strftime('%Y-%m-%d'))
start:开始日期,默认'2001-01-01',格式如:'2018-02-19'
end:结束日期,默认当天日期,格式如:'2018-09-19'返回:
返回:list类型,某个区间的交易日期序列。
例:
stone_get_tradedays(start='2018-01-01',end='2018-09-18')

stone_month_tradeday

  • 获取每个月第一个交易日或者最后一个交易日
stone_month_tradeday(need='last')
need:表示需要的数据,默认'last','first'表示获取每个月第一个交易日,'last'表示获取每个月最后一个交易日,'all'表示获取第一个交易日和最后一个交易日。
返回:一个list或者两个list
例:
first,last = stone_month_tradeday(need='all')

stone_week_tradeday

  • 获取每个星期第一个交易日或者最后一个交易日
获取每个星期第一个交易日或者最后一个交易日
need:表示需要的数据,默认'last','first'表示获取每个星期第一个交易日,'last'表示获取每个星期最后一个交易日,'all'表示获取第一个交易日和最后一个交易日。
返回:一个list或者两个list
例:
stone_week_tradeday(need='first')

stone_EMA

  • 求ema的函数
stone_EMA(df,N,islist=False)
df:输入的dataframe,必须包含'close'列,ema基于df['close’]计算,若无'close'则无法计算
N:int类型,表示ema的参数
islist:True表示返回一个list,否则返回一个dataframe。
返回:计算出的EMA数据
例:
import tushare as ts
import pandas  as pd 
df = ts.get_k_data('000001')
stone_EMA(df,N=5,islist=False)

stone_MACD

  • 计算MACD
stone_MACD(df,short=12,long=26,M=9)
df:输入的dataframe,必须包含'close'列,ema基于df['close’]计算,若无'close'则无法计算
short:int,计算MACD中'close'的短周期EMA的参数,默认12
long:int,计算MACD中'close'的长周期EMA的参数,默认26
M:int,计算长周期EMA与短周期EMA的EMA的参数,默认为9
返回:macd数据的dataframe
例:
import tushare as ts
import pandas  as pd 
df = ts.get_k_data('000001')
stone_MACD(df,short=12,long=26,M=9)

stone_MA

  • 计算移动平均
stone_MA(df,length=[5,10,20])
df:输入的dataframe,必须包含'close'列,ema基于df['close’]计算,若无'close'则无法计算
length:list或者一个int,表示需要计算的均线周期,如:[5,10,20]或10
返回:dataframe,在原输入dataframe的基础上并入需要的均线数据
例:
import tushare as ts
import pandas  as pd 
df = ts.get_k_data('000001')
stone_MA(df,length=[5,10,20])

stone_KDJ

  • 计算KDJ指标
stone_KDJ(df,N=9,M=2)
df:输入的dataframe,必须包含'close','low','high'列名,若无则无法计算
N:int,默认为9
M:int,默认为2
返回:DataFrame,在原数据上并上KDJ数据
例:
import tushare as ts
df = ts.get_k_data('000001')    
stone_KDJ(df,N=9,M=2)
--------------------------------------

stone_Binarizer

  • 对数据进行二元处理、二元化
stone_Binarizer(X,threshold=0.0)
X:表示输入list或者array,如:[[1,2,3],[3,4,5]]或者[[1,2,3]]或者np.array([[1,2,4],[2,3,4]])
threshold:一个浮点数,指定了属性阈值,低于此阈值的属性转换为0,高于此阈值的转换为1
返回:处理好的X
例:
import numpy as np
np.array([[1,2,4],[2,3,4]]) #或者 X = [[1,2,3,4],[3,4,5,6,]] 
stone_Binarizer(X,threshold=2)

stone_MaxAbsScaler

  • 对每个数据实现乘以其所在列数据的绝对值的最大值(标准化的一种方式)
stone_MaxAbsScaler(X)
X:表示输入list或者array,如:[[1,2,3],[3,4,5]]或者[[1,2,3]]或者np.array([[1,2,4],[2,3,4]])
返回:处理好的X
例:
import numpy as np
X = np.array([[1,2,4],[4,5,-6]])
Stone_MaxAbsScaler(X)
或者:
import tushare as ts
df = ts.get_k_data('000001')
Stone_MaxAbsScaler(df[['close','low']])

stone_MinMaxScaler

  • 对每个数据以列为标准实现min-max标准化(标准化的一种方式)
stone_MinMaxScaler(X,feature_range=(0,1))
X:表示输入list或者array,如:[[1,2,3],[3,4,5]]或者[[1,2,3]]或者np.array([[1,2,4],[2,3,4]])
feature_range:一个元组(min,max),指定了预期变换之后属性的取值范围,min为最小值变换后的值,max为最大值变换后的值
返回:处理好的X
例:
import numpy as np
X = np.array([[1,2,4],[4,5,-6],[3,6,8]])
stone_MinMaxScaler(X,feature_range=(0,2))
或者:
import tushare as ts
df = ts.get_k_data('000001')
stone_MinMaxScaler(df[['close','low']])

stone_StandardScaler

  • 对每个数据以列为标准实现z-score标准化(标准化的一种方式)
stone_StandardScaler(X,with_mean=True,with_std=True)
X:表示输入list或者array,如:[[1,2,3],[3,4,5]]或者[[1,2,3]]或者np.array([[1,2,4],[2,3,4]])
with_mean:一个布尔值,True表示在缩放之前先将数据中心化(及每个数据减去其所在列数据的平均值)
with_std:一个布尔值,True表示缩放数据到单位方差。
返回:处理好的X
例:
import numpy as np
X = np.array([[1,2,4],[4,5,-6],[3,6,8]])
stone_StandardScaler(X,with_mean=True,with_std=True)
或者:
import tushare as ts
df = ts.get_k_data('000001')
stone_StandardScaler(df[['close','low']])

stone_Normalizer

  • 对每个数据以列为标准实现数据正则化
stone_Normalizer(X,norm='l2')
X:表示输入list或者array,如:[[1,2,3],[3,4,5]]或者[[1,2,3]]或者np.array([[1,2,4],[2,3,4]])
norm:一个字符串,指定正则化方法,l1:采用L1范数正则化,l2:采用L2范数正则化,max:采用L∞范数正则化
返回:处理好的X
例:
import numpy as np
X = np.array([[1,2,4],[4,5,-6],[3,6,8]])
stone_Normalizer(X,norm='l2')
或者:
import tushare as ts
df = ts.get_k_data('000001')
stone_Normalizer(df[['close','low']],norm='l2')

stone_VarianceThreshold

  • 过滤式特征选取,删除方差小的列,保留方差大的列
stone_VarianceThreshold(X,threshold=0.0)
X:表示输入list或者array,如:[[1,2,3],[3,4,5]]或者[[1,2,3]]或者np.array([[1,2,4],[2,3,4]])
threshold:一个浮点数,指定方差的阈值,低于此阈值的列将被剔除
返回:处理好的和每列对应的方差
例:
X = [[1,2,3,4],[1,5,6,3],[1,0,4,3],[1,5,3,0]]
X,std = stone_VarianceThreshold(X,threshold=0.0)
或者:
import tushare as ts
df = ts.get_k_data('000001')
X,std = stone_VarianceThreshold(df[['close','low','open','high']],threshold=2)

stone_SelectKBest

  • 单变量特征提取
stone_SelectKBest(X,y,score_func=f_classif,k=10)
X:表示输入list或者array,如:[[1,2,3],[3,4,5]]或者[[1,2,3]]或者np.array([[1,2,4],[2,3,4]])
y:表示X每行数据的类别
score_func:给出统计指标的函数,主要有如下:
1、sklearn.feature_selection.f_regression:表示基于线性回归分析来计算统计指标,适用于线性回归问题。
2、sklearn.feature_selection.chi2:计算卡方统计量,适用于分类问题
3、sklearn.feature_selection.f_classif:根据方差分析的原理,依靠F-分布的依据,利用平方和与自由度所计算的组间与组内均方差估计出F值,适用于分类问题。
k:一个整数或者'all',指定保留最佳的几个列(几个特征),若为'all',则保留所有的特征。
返回:保留下来的列(特征),所有列(特征)的得分,所有列(特征)得分的p-values(表示该特征不在该得分下概率,越小就是对原得分的越支持)
例:
from sklearn.feature_selection import f_classif,chi2,f_regression
X = [[1,2,3,4],[1,5,6,3],[1,0,4,3],[1,5,3,0]]
y=[1,0,1,0]
stone_SelectKBest(X,y,score_func=f_classif,k=3)

stone_RFE

  • 包裹式特征提取REF
stone_RFE(X,y,estimator=LinearSVC(),n_features_to_select=None,step=1)
X:表示输入list或者array,如:[[1,2,3],[3,4,5]]或者[[1,2,3]]或者np.array([[1,2,4],[2,3,4]])
y:表示X每行数据的类别
estimator:一个学习器,它必须提供一个.fit方法和一个.coef_属性,其中.coef_属性中存放的是学习到的各特征的权重系数。通常使用SVM和广义线性模型作为estimator参数。
n_features_to_select:一个整数或者None,指定要选出几个特征。若为None,则默认选取一半的特征。
step:一个整数或者浮点数,指定每次迭代要剔除权重最小的几个特征,如果step大于1,则指定每次迭代要剔除权重最小的特征的数量,如果step介于0~1之间,则指定每次迭代要剔除权重最小的特征的比例。
返回:给出被选出的特征的数量,被选中特征的mask,被选中特征的排名(被选中的为1)
例:
from sklearn.svm import LinearSVC
from sklearn.datasets import load_iris
iris=load_iris()
X=iris.data
y=iris.target
n_features,support,ranking = stone_RFE(X,y,estimator=LinearSVC(),n_features_to_select=None,step=1)
////////////////////////////////////////////\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

fit_function

  • 拟合函数画图
fit_function(x,y,n=2,plot_out=False,figsize = (10,8))
x:list输入,自变量
y:list输入,因变量
n:n次拟合(1-5次拟合)
plot_out:True:显示拟合图像,False:不显示出拟合图像
figsize:(10,8),图像大小
return:拟合参数:从高次到低次排列
返回:
拟合参数(从高次到低次排列)

stone_plots

  • 画图展示
stone_plots(X,Y,types=[],subs=[],xlabels=[],ylabels=[],titles =[],labels=[],figsize=(10,8))   
X:因变量,为list的list,如:[[1,2,3,4],[1,3,4,5]],
Y:因变量,为list的list,如:[[1,2,3,4],[1,3,4,5]],
types:list,对应子图的曲线颜色和类型,['ro','g','b','b*','r.','r-','+','p']等
subs:list,[2,4]表示子图的显示是2行4列的方式。
xlabels:list,对应每个子图的x轴标签
ylabels:list,对应每个子图的y轴标签
titles:list,对应每个子图的title。
labels:list,对应每个子图曲线的标签。
figsize:表示整个图的大小尺寸
返回:无

stone_one_plot

  • 数据画在一副图内,共用坐标轴
stone_one_plot(X,Y,types=[],xlabel='',ylabel='',title ='',labels=[],figsize=(10,8))
X:因变量,为list的list,如:[[1,2,3,4],[1,3,4,5]],
Y:因变量,为list的list,如:[[1,2,3,4],[1,3,4,5]],
types:list,对应子图的曲线颜色和类型,['ro','g','b','b*','r.','r-']等
xlabel:表示x轴标签,str类型
ylabel:表示y轴标签,str类型
title:表示图名,str类型
labels:表示数据的标签,如:['a','b']
figsize:表示图的大小,如:(10,8)
返回:无

stone_twinx_plot

  • 画双坐标图
stone_twinx_plot(X,Y,types=[],xlabel='',ylabels=[],title ='',labels=[],figsize=(10,8))
X:因变量,为list的list,如:[[1,2,3,4],[1,3,4,5]],
Y:因变量,为list的list,如:[[1,2,3,4],[1,3,4,5]],
types:list,对应子图的曲线颜色和类型,['ro','g','b','b*','r.','r-']等
xlabel:表示x轴标签,str类型
ylabels:表示y轴标签,如['y1','y2']
title:表示图名,str类型
labels:表示数据的标签,如:['a','b']
figsize:表示图的大小,如:(10,8)
返回:无

stone_heatmap

  • 画热力图
stone_heatmap(df,annot=True, mask=None,xlabel='',ylabel='',title='',figsize=(8,8))
df:DataFrame格式或者array.
annot:True表示图像显示具体数值,False表示不显示
mask:英文掩饰的意思,mask=1小于df,表示掩饰df中大于1的显示,只显示1大于df的数据
xlabel:str类型,表示x轴标签
ylabel:str类型,表示y轴标签
title:str类型,表示图名
返回:无
例:
import pandas as pd
import numpy as np
np.random.seed(0)
x = np.random.randn(10, 8)
df = pd.DataFrame(x)
df.columns = ['a','b','c','d','e','f','g','h']
df.index = ['a','b','c','d','e','f','g','h','r','j']
stone_heatmap(df,annot=True, mask=None,xlabel='',ylabel='',title='',figsize=(8,8))   

stone_corr_heatmap

  • 计算相关性并画热力图
stone_corr_heatmap(df,plot=True,annot=True, mask=None,xlabel='',ylabel='',title='',figsize=(8,8))
作用:计算相关性并画热力图
df:DataFrame格式或者array.
plot:True表示画出热力图,False表示不画出热力图
annot:True表示图像显示具体数值,False表示不显示
mask:英文掩饰的意思,mask=1小于df,表示掩饰df中大于1的显示,只显示1大于df的数据
xlabel:str类型,表示x轴标签
ylabel:str类型,表示y轴标签
title:str类型,表示图名
返回:df的相关系数矩阵实例
例:
import pandas as pd
import numpy as np
np.random.seed(0)
x = np.random.randn(10, 8)
df = pd.DataFrame(x)
df.columns = ['a','b','c','d','e','f','g','h']
stone_corr_heatmap(df,plot=True,annot=True, mask=None,xlabel='',ylabel='',title='',figsize=(8,8)) 

stone_sklearn_tree

  • 决策树分类模型
stone_sklearn_tree(data,target,predict_data,test_size=0.2,criterion='gini')
data:array数据,源数据特征数据集,如:array([[5.1, 3.5, 1.4, 0.2],[4.9, 3. , 1.4, 0.2]])
target:array数据,源数据特类别,如:array([0,1])
predict_data:array数据,需要分类的数据集,如:array([[5.1, 3.53, 1.42, 0.21],[4, 3. , 1.41, 0.12]])
test_size:默认0.2,将源数据拆分成训练集和测试集,测试集是总数据的20%
criterion='gini'是决策树种的一个参数,你可以更改成entropy或者gini,这个是决策树的分类方法。
返回:需要预测数据的类别数据,array数据
例:
from sklearn import datasets
data1=datasets.load_iris()
data = data1['data']
target = data1['target']
predict_data = data[:100]
stone_sklearn_tree(data,target,predict_data,test_size=0.2,criterion='gini')

stone_linear_svm

  • 线性分类SVM分类模型
stone_linear_svm(data,target,predict_data,test_size=0.2,penalty='l2',loss='hinge',C=1.0)
data:array数据,源数据特征数据集,如:array([[5.1, 3.5, 1.4, 0.2],[4.9, 3. , 1.4, 0.2]])
target:array数据,源数据特类别,如:array([0,1])
predict_data:array数据,需要分类的数据集,如:array([[5.1, 3.53, 1.42, 0.21],[4, 3. , 1.41, 0.12]])
test_size:默认0.2,将源数据拆分成训练集和测试集,测试集是总数据的20%
penalty:字符串。指定'l1'或者'l2',罚项的范数,默认'l2'(它是标准SVC采用的)
loss:字符串,表示损失函数,可为’hinge'(为合页损失函数、为标准SVM的损失函数),可为'squared_hinge'(合页损失函数的平方)
C:浮点数,罚项参数。
返回:需要预测数据的类别数据,array数据
例:
from sklearn import datasets
data1=datasets.load_iris()
data = data1['data']
target = data1['target']
predict_data =data[:100]
stone_linear_svm(data,target,predict_data,test_size=0.2,penalty='l2',loss='squared_hinge',C=1.0)

stone_svm

  • SVM分类模型
stone_svm(data,target,predict_data,test_size=0.2,kernel='rbf',degree=3,gamma='auto',coef0=0.0)
data:array数据,源数据特征数据集,如:array([[5.1, 3.5, 1.4, 0.2],[4.9, 3. , 1.4, 0.2]])
target:array数据,源数据特类别,如:array([0,1])
predict_data:array数据,需要分类的数据集,如:array([[5.1, 3.53, 1.42, 0.21],[4, 3. , 1.41, 0.12]])
test_size:默认0.2,将源数据拆分成训练集和测试集,测试集是总数据的20%
kernel:字符串,核函数,'linear':线性核函数,'poly':多项式核函数,'rbf':(默认):高斯核函数,'sigmoid':tanh核函数,
            'precomputed':表示提供了kernel matrix。
degree:一个整数,指定当核函数为多项式的时候,多项式的参数,其他核函数该参数无效。
gamma:一个浮点数,当核函数为'rbf'、'poly'、'sigmoid'时,核函数的系数,如果为'auto',则表示系数为1/n_features.
coef0:浮点数,用于指定核函数中的自由项,左右当核函数是'poly'和'sigmoid'时有效。
返回:需要预测数据的类别数据,array数据
例:
from sklearn import datasets
data1=datasets.load_iris()
data = data1['data']
target = data1['target']
predict_data =data[:300]
stone_svm(data,target,predict_data,test_size=0.2,kernel='rbf',degree=3,gamma='auto',coef0=0.0)

stone_linear_svr

  • 线性回归SVR
stone_linear_svr(data,target,predict_data,test_size=0.2,loss='epsilon_insensitive',epsilon=0.0,C=1.0,max_iter=1000)
作用:线性回归SVR
data:array数据,源数据特征数据集,如:array([[5.1, 3.5, 1.4, 0.2],[4.9, 3. , 1.4, 0.2]])
target:array数据,源数据特类别,如:array([0,1])
predict_data:array数据,需要分类的数据集,如:array([[5.1, 3.53, 1.42, 0.21],[4, 3. , 1.41, 0.12]])
test_size:默认0.2,将源数据拆分成训练集和测试集,测试集是总数据的20%
loss:字符串,表示损失函数,可为'epsilon_insensitive'和'squared_epsilon_insensitive'
epsilon:浮点数,用于lose中的参数
C:浮点数,罚项参数。
max_iter:最大迭代次数
返回:需要预测数据的大小
例:
from sklearn import datasets
data1=datasets.load_iris()
data = data1['data']
target = data1['target']
predict_data =data[:300]
stone_linear_svr(data,target,predict_data,test_size=0.2,loss='epsilon_insensitive',epsilon=0.0,C=1.0,max_iter=1000) 

stone_svr

  • 非线性回归SVR
stone_svr(data,target,predict_data,test_size=0.2,kernel='rbf',epsilon=0.0,coef0=0.0,C=1.0,degree=3,gamma='auto',max_iter=1000)
data:array数据,源数据特征数据集,如:array([[5.1, 3.5, 1.4, 0.2],[4.9, 3. , 1.4, 0.2]])
target:array数据,源数据特类别,如:array([0,1])
predict_data:array数据,需要分类的数据集,如:array([[5.1, 3.53, 1.42, 0.21],[4, 3. , 1.41, 0.12]])
test_size:默认0.2,将源数据拆分成训练集和测试集,测试集是总数据的20%
loss:字符串,表示损失函数,可为'epsilon_insensitive'和'squared_epsilon_insensitive'
epsilon:浮点数,用于lose中的参数
coef0:浮点数,用于指定核函数中的自由项,左右当核函数是'poly'和'sigmoid'时有效。
C:浮点数,罚项参数。
degree:一个整数,指定当核函数为多项式的时候,多项式的参数,其他核函数该参数无效。
gamma:一个浮点数,当核函数为'rbf'、'poly'、'sigmoid'时,核函数的系数,如果为'auto',则表示系数为1/n_features.
max_iter:最大迭代次数
返回:需要预测数据的大小实例:
例:
from sklearn import datasets
data1=datasets.load_iris()
data = data1['data']
target = data1['target']
predict_data =data[:300]
stone_svr(data,target,predict_data,test_size=0.2,kernel='rbf',epsilon=0.0,coef0=0.0,C=1.0,degree=3,gamma='auto',max_iter=1000)

stone_KNeighborsClassifier

  • kNN分类KNeighborsClassifier
stone_KNeighborsClassifier(data,target,predict_data,test_size=0.2,n_neighbors=5,weights='uniform',algorithm='auto',p=2)
data:array数据,源数据特征数据集,如:array([[5.1, 3.5, 1.4, 0.2],[4.9, 3. , 1.4, 0.2]])
target:array数据,源数据特类别,如:array([0,1])
predict_data:array数据,需要分类的数据集,如:array([[5.1, 3.53, 1.42, 0.21],[4, 3. , 1.41, 0.12]])
test_size:默认0.2,将源数据拆分成训练集和测试集,测试集是总数据的20%
n_neighbors:一个整数,指定k值
weights:一字符串或者可调用对象,指定投票权重类型。即这些邻居投票权可以为相同或者不同,可为:'uniform'(默认,投票权重相同),'distance'(投票权重与距离成反比),[callable](一个可调用对象,传入距离的数组,返回同样形状的权重数组)
algorithm:一个字符串,指定计算最临近的算法,可为:('ball_tree':使用BallTree算法,'kd_tree':使用KDTree算法,'brube':使用暴力搜索法。 'auto':自动决定最合适的算法。)
p:整数值,指定在'Minkowski'度量上的指数。p=1对应曼哈顿距离,p=2对应欧拉距离
返回:需要预测数据的大小
例:
from sklearn import datasets
data1=datasets.load_iris()
data = data1['data']
target = data1['target']
predict_data =data[:600]
stone_KNeighborsClassifier(data,target,predict_data,test_size=0.2,n_neighbors=5,weights='uniform',algorithm='auto',p=2)

stone_KNeighborsRegressor

  • kNN分类KNeighborsRegressor
stone_KNeighborsRegressor(data,target,predict_data,test_size=0.2,n_neighbors=5,weights='uniform',algorithm='auto',p=2)
data:array数据,源数据特征数据集,如:array([[5.1, 3.5, 1.4, 0.2],[4.9, 3. , 1.4, 0.2]])
target:array数据,源数据特类别,如:array([0,1])
predict_data:array数据,需要分类的数据集,如:array([[5.1, 3.53, 1.42, 0.21],[4, 3. , 1.41, 0.12]])
test_size:默认0.2,将源数据拆分成训练集和测试集,测试集是总数据的20%
n_neighbors:一个整数,指定k值
weights:一字符串或者可调用对象,指定投票权重类型。即这些邻居投票权可以为相同或者不同,可为:'uniform'(默认,投票权重相同),
'distance'(投票权重与距离成反比),[callable](一个可调用对象,传入距离的数组,返回同样形状的权重数组)
algorithm:一个字符串,指定计算最临近的算法,可为:('ball_tree':使用BallTree算法,'kd_tree':使用KDTree算法,'brube':使用暴力搜索法。'auto':自动决定最合适的算法。)             
p:整数值,指定在'Minkowski'度量上的指数。p=1对应曼哈顿距离,p=2对应欧拉距离
返回:需要预测数据的大小
例:
from sklearn import datasets
data1=datasets.load_iris()
data = data1['data']
target = data1['target']
predict_data =data[:600]
stone_KNeighborsClassifier(data,target,predict_data,test_size=0.2,n_neighbors=5,weights='uniform',algorithm='auto',p=2)

stone_LinearRegression

  • LinearRegression线性回归模型
stone_LinearRegression(data,target,predict_data,test_size=0.2,fit_intercept=True,normalize=False,n_jobs=1)
data:array数据,源数据特征数据集,如:array([[5.1, 3.5, 1.4, 0.2],[4.9, 3. , 1.4, 0.2]])
target:array数据,源数据特类别,如:array([0,1])
predict_data:array数据,需要分类的数据集,如:array([[5.1, 3.53, 1.42, 0.21],[4, 3. , 1.41, 0.12]])
test_size:默认0.2,将源数据拆分成训练集和测试集,测试集是总数据的20%
fit_intercept:一个布尔值,指定是否需要计算b值,False表示不计算
normalize:一个布尔值,如果为True,那么训练样本会在回归之前被归一化
n_jobs:一个正数。任务并行时指定的CPU数量。如果为-1则使用所有可用的CPU
返回:需要预测数据的大小
例:
import numpy as np
from sklearn import datasets
data1=datasets.load_iris()
data = data1['data']
target = data1['target']
predict_data =data[:600]
stone_LinearRegression(data,target,predict_data,test_size=0.2,fit_intercept=True,normalize=False,n_jobs=1)

stone_Ridge

  • 岭回归模型
stone_Ridge(data,target,predict_data,test_size=0.2,alpha=1.0,fit_intercept=True,normalize=False,solver ='auto',tol = 0.001)
data:array数据,源数据特征数据集,如:array([[5.1, 3.5, 1.4, 0.2],[4.9, 3. , 1.4, 0.2]])
target:array数据,源数据特类别,如:array([0,1])
predict_data:array数据,需要分类的数据集,如:array([[5.1, 3.53, 1.42, 0.21],[4, 3. , 1.41, 0.12]])
test_size:默认0.2,将源数据拆分成训练集和测试集,测试集是总数据的20%
fit_intercept:一个布尔值,指定是否需要计算b值,False表示不计算
normalize:一个布尔值,如果为True,那么训练样本会在回归之前被归一化
solver:一个字符串,指定求解最优化问题的算法。可为:'auto':根据数据集自动选择算法;'svd':使用奇异值分解来计算回归系数;
'cholesky':使用scipy.linalg.solve函数来求解;'sparse_cg':使用scipy.sparse.linalg.cg函数来求解;'lsqr':使用scipy.sparse.linalg.lsqr函数来求解。它运算速度更快,但是可能老版本的scipy不支持。
'sag':使用'Stochastic Average Gradient descent算法,求解最优化问题。
tol:一个浮点数,指定判断迭代收敛与否的阈值。
返回:需要预测数据的大小
例:
import numpy as np
from sklearn import datasets
data1=datasets.load_iris()
data = data1['data']
target = data1['target']
predict_data =data[:600]
stone_Ridge(data,target,predict_data,test_size=0.2,alpha=1.0,fit_intercept=True,normalize=False,solver ='auto',tol = 0.001)

stone_Lasson

  • Lasson回归模型
stone_Lasson(data,target,predict_data,test_size=0.2,alpha=1.0,fit_intercept=True,normalize=False,
warm_start=False,tol= 0.0001,max_iter=1000,selection='cyclic')
data:array数据,源数据特征数据集,如:array([[5.1, 3.5, 1.4, 0.2],[4.9, 3. , 1.4, 0.2]])
target:array数据,源数据特类别,如:array([0,1])
predict_data:array数据,需要分类的数据集,如:array([[5.1, 3.53, 1.42, 0.21],[4, 3. , 1.41, 0.12]])
test_size:默认0.2,将源数据拆分成训练集和测试集,测试集是总数据的20%
fit_intercept:一个布尔值,指定是否需要计算b值,False表示不计算
normalize:一个布尔值,如果为True,那么训练样本会在回归之前被归一化
warm_start:一个布尔值。如果为True,那么使用前一次训练结果继续训练,否则从头开始
tol:一个浮点数,指定判断迭代收敛与否的阈值。
max_iter:最大迭代次数
selection:一个字符串,指定了当每轮迭代的时候,选择权重的向量的哪个分量来更新,'cyclic'表示从前向后依次选择权重向量的一个分量来更新。'random'表示从前向后依次选择权重向量的一个分量来更新。
返回:需要预测数据的大小
例:
import numpy as np
from sklearn.cross_validation import train_test_split
from sklearn import datasets,linear_model
data1=datasets.load_iris()
data = data1['data']
target = data1['target']
predict_data =data[:600]
stone_Lasson(data,target,predict_data)

相信量化的力量 点击返回顶部