新普金娱乐网址


笑着说再见《冰川时代5》如初见时的疯狂!

暂且抱佛脚–努力不够,行动来凑

Oracl Over函数数学

  • 二月 14, 2019
  • 数学
  • 没有评论

Oracl Over函数

前瞻模型

简介

在介绍Over在此之前, 必须提到开窗函数, 与 聚 合函数一样,
开窗函数也是对行集组举办联谊总结,
但是它不像普通聚合函数那么每组只回去二个值,
开窗函数可以为每组再次来到多少个值.

开窗函数用于为行定义一个窗口(那里的窗口是指运算将要操作的行的聚合),它对一组值举办操作,不须要采纳GROUP
BY子句对数据开展分组,

可以在同等行中并且再次回到基础行的列和聚合列。

在 Oracle中则被称作分析函数,而在DB2中则被称为OLAP函数。

Over
关键字表示把函数当成开窗函数而不是聚合函数。SQL标准允许将享有聚合函数用做开窗函数,使用OVE大切诺基关键字来区分那三种用法。

开窗函数的调用格式为:

函数名(列) OVER(选项)

1、简介

猜测建模(Predictive
modeling)是一种用来预测系统今后一颦一笑的解析技术,它由一群能够分辨独立输入变量与报告目的关联关系的算法构成。依据观测值创立一个数学模型,然后用那几个模型去预测今后时有暴发的工作。
预测模型是用多少个或然对系统行为暴发震慑的特征营造的,当处理系统难题时,须要先判断哪些因素或然会潜移默化系统的一言一动,然后在练习模型从前将那几个成分添加进特征中。

案例及解释

开创一张简略的表, 同时在表内插入15条数据:

create table classInfo(
studentName varchar2(20),
classNumber number(2),
score number(2)
);

INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('1', '1', '11');
INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('2', '1', '22');
INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('3', '1', '33');
INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('4', '1', '44');
INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('5', '1', '55');
INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('6', '2', '1');
INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('7', '2', '2');
INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('8', '2', '3');
INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('9', '2', '4');
INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('10', '2', '5');
INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('11', '3', '10');
INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('12', '3', '20');
INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('13', '3', '30');
INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('14', '3', '40');
INSERT INTO CLASSINFO (STUDENTNAME, CLASSNUMBER, SCORE) VALUES ('15', '3', '50');

从那边分别观察其特点:

  1. 数学,好端端查询, 不一样班级分数的总和

    SELECT CLASSNUMBER, SUM(SCORE) FROM CLASSINFO GROUP BY CLASSNUMBER;
    
        --结果如下
        1   165
        2   15
        3   150
    

    那是我们平时会用到的分组函数, 分歧班级的总分.

    但假如大家还想见见各类人的 name 和 分数呢?简单想出如下代码:

    SELECT STUDENTNAME, SCORE, A.CLASSNUMBER CLASSNUMBER, TOTALSCORE FROM CLASSINFO A
    LEFT OUTER JOIN
    (SELECT CLASSNUMBER, SUM(SCORE) TOTALSCORE FROM CLASSINFO GROUP BY CLASSNUMBER) B
    ON A.CLASSNUMBER = B.CLASSNUMBER
    ORDER BY CLASSNUMBER;
    
    --结果如下
    1   11  1   165
    2   22  1   165
    3   33  1   165
    4   44  1   165
    5   55  1   165
    6   1   2   15
    7   2   2   15
    8   3   2   15
    9   4   2   15
    10  5   2   15
    11  10  3   150
    12  20  3   150
    13  30  3   150
    14  40  3   150
    
  2. 使用Over之后:

    SELECT STUDENTNAME, SCORE, CLASSNUMBER, SUM(SCORE) OVER(PARTITION BY CLASSNUMBER ) TOTALSCORE
    FROM CLASSINFO ORDER BY CLASSNUMBER;
    
    --结果与上述相同, 就不再展示
    

    透过 PA卡宴TITION BY CLASSNUMBE兰德酷路泽 举行分组

  3. 让大家尝试下边二种用法, 就不在那张表上做操作:

    create table overDemo(
    dateNumber number(2),
    sale number(5)
    );
    INSERT INTO OVERDEMO (DATENUMBER, SALE) VALUES ('1', '10');
    INSERT INTO OVERDEMO (DATENUMBER, SALE) VALUES ('2', '10');
    INSERT INTO OVERDEMO (DATENUMBER, SALE) VALUES ('3', '20');
    INSERT INTO OVERDEMO (DATENUMBER, SALE) VALUES ('4', '20');
    INSERT INTO OVERDEMO (DATENUMBER, SALE) VALUES ('5', '30');
    INSERT INTO OVERDEMO (DATENUMBER, SALE) VALUES ('6', '30');
    INSERT INTO OVERDEMO (DATENUMBER, SALE) VALUES ('7', '40');
    INSERT INTO OVERDEMO (DATENUMBER, SALE) VALUES ('8', '40');
    INSERT INTO OVERDEMO (DATENUMBER, SALE) VALUES ('9', '50');
    INSERT INTO OVERDEMO (DATENUMBER, SALE) VALUES ('10', '50');
    
    SELECT * FROM OVER DEMO;
    
    --表中数据如下
    DATENUMBER      SALE
        1           10
        2           10
        3           20
        4           20
        5           30
        6           30
        7           40
        8           40
        9           50
        10          50
    
    SELECT DATENUMBER, SUM(SALE)
    OVER (ORDER BY DATENUMBER )
    TATLESALE FROM OVERDEMO ORDER BY DATENUMBER;
    
    --结果如下
        1   10      -- sale(1)
        2   20      -- sale(1) + sale(2)
        3   40      -- sale(1) + sale(2) + sale(3)
        4   60      --...
        5   90      --...
        6   120     --...
        7   160     --...
        8   200     --...
        9   250     --...
        10  300     --sale(1) + sale(2) + ... + sale(10)
    

    探囊取物察觉, 这种增加格局, 求和艺术是 依据DATENUMBE奥迪Q7 一连求和

    SELECT DATENUMBER, SUM(SALE)
    OVER (ORDER BY DATENUMBER
     DESC )
    TATLESALE FROM OVERDEMO ORDER BY DATENUMBER;
    
    --结果如下
    
        1   300
        2   290
        3   280
        4   260
        5   240
        6   210
        7   180
        8   140
        9   100
        10  50
    
    SELECT DATENUMBER, SUM(SALE)
    OVER ()
    TATLESALE FROM OVERDEMO ORDER BY DATENUMBER;
    
    --结果如下
    
        1   300
        2   300
        3   300
        4   300
        5   300
        6   300
        7   300
        8   300
        9   300
    
    SELECT DATENUMBER, SUM(SALE)
    OVER (ORDER BY SALE)
    TATLESALE FROM OVERDEMO ORDER BY DATENUMBER;
    
    --结果如下
    
        1   20
        2   20
        3   60
        4   60
        5   120
        6   120
        7   200
        8   200
        9   300
        10  300
    
  4. 小结

    SUM() Over(ORDER BY COLUMN_NAME) 三番五次增进

    SUM() Over(ORDER BY COLUMN_NAME DESC) 倒序累加

    SUM() Over() 全部求和

  5. 注意

    但须求小心的2个地方是: 在那里运用 Order By,总结办法是:
    会依据前边的字段, 首先进行分组, 然后重新展开添加:

    如: O安德拉DEHaval BY SALE, 则类似于 SUM(SALE) FROM TABLE GROUP BY SALE,
    对求得的结果集再一次进行累加. 而在 DATENUMBEENVISION累加的时候从不出现这种景观, 是因为 DATENUMBE君越都以唯一值.

    甚至 OVER(ORDER BY COLUMN_A, COLUMN_B), 也是先依照
    SUM(COLUMN_AIM) FROM TABLE GROUP BY COLUMN_A, COLUMN_B,
    对求得的结果集举办累加.

  6. PARTITION BY

    SELECT STUDENTNAME, SCORE, CLASSNUMBER, SUM(SCORE) 
    OVER(PARTITION BY CLASSNUMBER  ORDER BY STUDENTNAME) TOTALSCORE
    FROM CLASSINFO ORDER BY CLASSNUMBER;
    
    --结果
    
        1   11  1   11
        2   22  1   33
        3   33  1   66
        4   44  1   110
        5   55  1   165
        10  5   2   5
        6   1   2   6
        7   2   2   8
        8   3   2   11
        9   4   2   15
        11  10  3   10
        12  20  3   30
        13  30  3   60
        14  40  3   100
        15  50  3   150
    

    其后再来看 PASportageTITION BY COLUMN_A ORDER BY COLUMN_B, 则是先经过
    COLUMB_A 进行分组, 而后 在 分组的结果集内, 依据 COLUMN_B
    再一次展开添加操作.

  7. 总结

    在 Over() 中, 会依照 Over前的聚合函数控制所急需的操作, 同时依照Partition By 的列举办分组, 对于 分组后的数据, 再一次通过 Order By
    后的字段 进行相应的 累加 等操作.

    在上面的案例中说来:

    率先依据 CLASSNUMBESportage 班级编号, 对具备数据分组, 分成三组数据:

    --1
    S   C   SCORE
    1   1   11
    2   1   22
    3   1   33
    4   1   44
    5   1   55
    --2
    6   2   1
    7   2   2
    8   2   3
    9   2   4
    10  2   5
    --3
    11  3   10
    12  3   20
    13  3   30
    14  3   40
    15  3   50
    

    日后各自按照三组数据中的 STUDENTNAME 举行分组,
    分组结果与地点一样,差异的是在 当前的每一组内 又分为 5 组数据, 而后在
    每一组内, 依照新分出来的 5 组数据举办 累加 求和.

    若果将 Order By StudentName 改为 ClassNumber, 能够臆想结果:

    依照刚才的申辩来说: 照旧是分成上面三组数据,
    在其次次分组中又有所不一样, 三组中每一组内的 ClassNumber都无异, 因此归纳为一组数据.在组内累加求和 也单独举行三回 累加结果个别为 165
    15 150. 就此最后的结果简单猜测:

        1   11  1   165
        2   22  1   165
        3   33  1   165
        4   44  1   165
        5   55  1   165
        10  5   2   15
        6   1   2   15
        7   2   2   15
        8   3   2   15
        9   4   2   15
        11  10  3   150
        12  20  3   150
        13  30  3   150
        14  40  3   150
        15  50  3   150
    

    友好测试了三回, 结果一致.

注意

以上理论唯有是依据结果本人思疑, 方便明白. 并从未官方文档的 表明来支撑.

2、用SVM建立线性分类器

SVM是用来营造分类器和回归器的监控学习模型,SVM通过对数学方程组求解,可以找出两组数据里面的特等分割边界。上面先使用第3章的创导不难分类器将数据分类并画出。

# 1、加载数据
import numpy as np
import matplotlib.pyplot as plt
input_file = 'data_multivar.txt'

def load_data(input_file):
    X = []
    y = []
    with open(input_file, 'r') as f:
        for line in f.readlines():
            data = [float(x) for x in line.split(',')]
            X.append(data[:-1])
            y.append(data[-1])
    X=np.array(X)
    y = np.array(y)
    return X,y
X,y=load_data(input_file)

# 2、分类
class_0=np.array([X[i] for i in range(len(X)) if y[i]==0])
class_1=np.array([X[i] for i in range(len(X)) if y[i]==1])
print(class_0)
# 3、画图
plt.figure()
plt.scatter(class_0[:,0],class_0[:,1],facecolor='black',edgecolors='black',marker='s')
plt.scatter(class_1[:,0],class_1[:,1],facecolor='none',edgecolors='black',marker='s')
plt.show()

# 定义画图函数
def plot_classifier(classifier, X, y):
    # 获取x,y的最大最小值,并设置余值
    x_min, x_max = min(X[:, 0]) - 1.0, max(X[:, 0] + 1.0)
    y_min, y_max = min(X[:, 1]) - 1.0, max(X[:, 1] + 1.0)
    # 设置网格步长
    step_size = 0.01
    # 设置网格
    x_values, y_values = np.meshgrid(np.arange(x_min, x_max, step_size), np.arange(y_min, y_max, step_size))
    # 计算出分类器的分类结果
    mesh_output = classifier.predict(np.c_[x_values.ravel(), y_values.ravel()])
    mesh_output = mesh_output.reshape(x_values.shape)
    # 画图
    plt.figure()
    # 选择配色方案
    plt.pcolormesh(x_values, y_values, mesh_output, cmap=plt.cm.gray)
    # 画点
    plt.scatter(X[:, 0], X[:, 1], c=y, s=80, edgecolors='black', linewidths=1, cmap=plt.cm.Paired)
    # 设置图片取值范围
    plt.xlim(x_values.min(), x_values.max())
    plt.ylim(y_values.min(), y_values.max())
    # 设置x与y轴
    plt.xticks((np.arange(int(min(X[:, 0]) - 1), int(max(X[:, 0]) + 1), 1.0)))
    plt.yticks((np.arange(int(min(X[:, 1]) - 1), int(max(X[:, 1]) + 1), 1.0)))
    plt.show()

如图:

数学 1

从下边的结果可以观看,空心和虔诚分别为不一样类。上面选拔SVM将不一致类分开。结果如下图:

数学 2
代码如下:

# 使用SVM
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=5)
params = {'kernel': 'linear'}
classifier = SVC(**params)
# 训练线性SVM分类器,并查看结果边界
classifier.fit(X_train, y_train)
plot_classifier(classifier, X_train, y_train)
# 测试数据集
y_test_pred = classifier.predict(X_test)
plot_classifier(classifier, X_test, y_test)
# 查看数据的精准性,训练数据集的分类报告
from sklearn.metrics import classification_report
print(classification_report(y_train,classifier.predict(X_train),target_names=['Class-'+str(int(i)) for i in set(y)]))
# 测试数据集的分类报告
print(classification_report(y_test,classifier.predict(X_test),target_names=['Class-'+str(int(i)) for i in set(y)]))

Rank( )

亟待再涉及的一些是:

比较常用到的另三个地点是 Rank() Over();

它的作用也相比简单, 排序, 做排名的时候会用到.

--在此之前先对之前的 CLASSINFO 表数据略做修改

UPDATE CLASSINFO SET SCORE = '11' WHERE STUDENTNAME = '6';
UPDATE CLASSINFO SET SCORE = '22' WHERE STUDENTNAME = '7';
UPDATE CLASSINFO SET SCORE = '33' WHERE STUDENTNAME = '8';

SELECT STUDENTNAME, SCORE, CLASSNUMBER,
RANK() OVER(ORDER BY SCORE) AS 名次 FROM CLASSINFO;

    --结果
    9   4   2   1
    10  5   2   2
    11  10  3   3
    1   11  1   4
    6   11  2   4
    12  20  3   6
    7   22  2   7
    2   22  1   7
    13  30  3   9
    3   33  1   10
    8   33  2   10
    14  40  3   12
    4   44  1   13
    15  50  3   14
    5   55  1   15

名次的结果依旧比较的清晰明了, 但在此处要求留意的一个地点是,
在查询的时候, 出现了八个 第 4 名, 随后接下去便是 第四名, 是的, 你没想错,
在同一的时候, 会将排名并列, 然后跳过下1个排名.

但又会冒出一种相比宽泛的情事:

考查的时候, 总分相同者, 以数学论名次, 再相同, 语文…那样的一套规则

SELECT STUDENTNAME, SCORE, CLASSNUMBER,
RANK() OVER(ORDER BY SCORE, STUDENTNAME) AS 名次 FROM CLASSINFO;

    --结果
    9   4   2   1
    10  5   2   2
    11  10  3   3
    1   11  1   4
    6   11  2   5
    12  20  3   6
    2   22  1   7
    7   22  2   8
    13  30  3   9
    3   33  1   10
    8   33  2   11
    14  40  3   12
    4   44  1   13
    15  50  3   14
    5   55  1   15

如上, 在order之后, 当相同时以所给的 STUDENTNAME进行排序,
即使您想说规则不创设, 但 作者是规则的制定者.

又有老师提议须要拉, 作者单独向看大家班的排名该如何是好吧?

SELECT STUDENTNAME, SCORE, CLASSNUMBER,
RANK() OVER(PARTITION BY CLASSNUMBER ORDER BY SCORE) AS 名次 FROM CLASSINFO;

--结果

    1   11  1   1
    2   22  1   2
    3   33  1   3
    4   44  1   4
    5   55  1   5
    9   4   2   1
    10  5   2   2
    6   11  2   3
    7   22  2   4
    8   33  2   5
    11  10  3   1
    12  20  3   2
    13  30  3   3
    14  40  3   4
    15  50  3   5

相信看过作者对 Over的诠释, 通晓这段也不算难. 就不再赘述.

三,用SVM建立非线性分类器

从地点的分类报告可见,我们的分类情状并不美丽,而且,最初始的数据可视化也可知到,实心完全被空心包围着,所以,大家须要尝试非线性分类器。
SVM为建立非线性分类器提供了累累选项,需求用不同的核函数建立费线性分类器。为了简单起见,考虑一下二种状态。

DENSE_RANK( )

需假若无尽的, 即便经理又说, 大家学校排名, 并列第叁,名,
下2个亲血肉就该是第壹名, 尽管唯有五人, 但好歹让 家长欢天喜地下.

SELECT STUDENTNAME, SCORE, CLASSNUMBER,
DENSE_RANK() OVER(ORDER BY SCORE) AS 名次 FROM CLASSINFO;

    --结果
    9   4   2   1
    10  5   2   2
    11  10  3   3
    1   11  1   4
    6   11  2   4
    12  20  3   5
    7   22  2   6
    2   22  1   6
    13  30  3   7
    3   33  1   8
    8   33  2   8
    14  40  3   9
    4   44  1   10
    15  50  3   11
    5   55  1   12

那样查询下来, 一共15 私家, 我们家儿女 考了个 12 名, 还算不错, 不是倒一.
老人得多心花怒放呀.

在 DENSE_RANK() 中, 在 Rank() 中涉及的规则 同样适用.

到此地, Over() 的描述也大抵告一段落.

3.一,多项式函数

直白将线性中的params={‘kernel’:’linear’}替换来params={‘kernel’:’poly’,’degree’:3},其中degree表示五次多项式,随着次数增加,可让曲线变得更弯,不过训练时间也会越长,统计强度越大。结果如下图:

数学 3

3.贰,径向基函数(Radial Basis Function,RBF)

直接将线性中的params={‘kernel’:’linear’}替换来params={‘kernel’:’rbf’},结果如下图:

数学 4

肆,化解项目数量不平衡难点

在现实生活中,我们得到的数据恐怕会出现某类数据比其它种类数据多众多的情景,在那种情景下分类器会有错误,边界线也不会影响数据的真正,所以需求对数码举行斡旋。
换一个数额,以下边线性SVM为例,将数据换到data_multivar_imbalance.txt之后,显示为

数学 5

由图可以,没有边界线,那是因为分类器不可以分别这两连串型,所以,将参数改为params={‘kernel’:’linear’,’class_weight’:’balanced’}即可。结果如下:

数学 6

伍,提取置信度

当3个信的数据点被分类为某多少个已知序列时,我们可操练SVM来计量输出类型的置信度。

input_datapoints = np.array([[2, 1.5], [8, 9], [4.8, 5.2], [4, 4], [2.5, 7], [7.6, 2], [5.4, 5.9]])

for i in input_datapoints:
    print(i, '-->', classifier.decision_function(i)[0])# 测量点到边界的距离

params = {'kernel': 'rbf', 'probability': True}
classifier = SVC(**params)
classifier.fit(X_train, y_train)

for i in input_datapoints:
    print(i, '-->', classifier.predict_proba(i)[0])# 这里要求params中probability必须为True,计算输入数据点的置信度

plot_classifier(classifier, input_datapoints, [0]*len(input_datapoints))

陆,寻找最优超参数

超参数对分类器的性质相当主要。寻找步骤如下:

# 1、加载数据,通过交叉验证
parameter_grid = [{'kernel': ['linear'], 'C': [1, 10, 50, 600]},
                  {'kernel': ['poly'], 'degree': [2, 3]},
                  {'kernel': ['rbf'], 'gamma': [0.01, 0.001], 'C': [1, 10, 50, 600]},
                  ]

metrics = ['precision', 'recall_weighted']

from sklearn import svm, grid_search, cross_validation
from sklearn.metrics import classification_report
# 2、为每个指标搜索最优超参数
for metric in metrics:
    classifier = grid_search.GridSearchCV(svm.SVC(C=1), parameter_grid, cv=5, scoring=metric)# 获取对象
    classifier.fit(X_train, y_train)# 训练
    for params, avg_score, _ in classifier.grid_scores_:# 看指标得分
        print(params, '-->', round(avg_score, 3))
    print('最好参数集:',classifier.best_params_)# 最优参数集
    y_true, y_pred = y_test, classifier.predict(X_test)
    print(classification_report(y_true, y_pred))# 打印一下性能报告

7、建立即间预测器

本条例子和前边的大都,紧假使时刻不忘步骤。

# 1、读取数据
input_file='building_event_multiclass.txt'
# input_file='building_event_binary.txt'

X=[]
y=[]
with open(input_file,'r') as f:
    for line in f.readlines():
        data=line[:-1].split(',')
        X.append([data[0]]+data[2:])
X=np.array(X)
# 2、编码器编码
from sklearn import preprocessing
label_encoder=[]
X_encoder=np.empty(X.shape)
for i,item in enumerate(X[0]):
    if item.isdigit():
        X_encoder[:,i]=X[:,i]
    else:
        label_encoder.append(preprocessing.LabelEncoder())
        X_encoder[:,i]=label_encoder[-1].fit_transform(X[:,i])
X=np.array(X_encoder[:,:-1]).astype(int)
y=np.array(X_encoder[:,-1]).astype(int)
# 3、进行分类
from sklearn.svm import SVC
params={'kernel':'rbf','probability':True,'class_weight':'balanced'}
classifier=SVC(**params)
classifier.fit(X,y)
# 4、交叉验证
from sklearn.model_selection import cross_val_score
accuracy=cross_val_score(classifier,X,y,scoring='accuracy',cv=3)
print('accuracy:',accuracy.mean())
# 5、对新数据进行验证
input_data = ['Tuesday', '12:30:00','21','23']
input_data_encoder=[-1]*len(input_data)
count=0

for i,item in enumerate(input_data):
    if item.isdigit():
        input_data_encoder[i]=int(input_data[i])
    else:
        label=[]
        label.append(input_data[i])
        input_data_encoder[i]=label_encoder[count].transform(label)
        count=count+1

result=int(classifier.predict(np.array(input_data_encoder)))
print('result:',label_encoder[-1].inverse_transform(result))

8、估量交通流量

在事先的SVM都是用作分类器,未来彰显3个回归器的例子:

# 1、获取数据
X=[]
input_file='traffic_data.txt'
with open(input_file,'r') as f:
    for line in f.readlines():
        data=line[:-1].split(',')
        X.append(data)

X=np.array(X)

# 2、编码
from sklearn import preprocessing
label_encoder=[]
X_encoder=np.empty(X.shape)
for i,item in enumerate(X[0]):
    if item.isdigit():
        X_encoder[:,i]=X[:,i]
    else:
        label_encoder.append(preprocessing.LabelEncoder())
        X_encoder[:,i]=label_encoder[-1].fit_transform(X[:,i])

X=X_encoder[:,:-1].astype(int)
y=X_encoder[:,-1].astype(int)

# 3、线性回归
from sklearn.svm import SVR
# params = {'kernel': 'rbf', 'C': 10.0, 'epsilon': 0.2}
params={'kernel':'rbf','C':10.0,'epsilon':0.2}# C表示对分类的惩罚,参数epsilon表示不使用惩罚的限制
regressor=SVR(**params)
regressor.fit(X,y)
# 4、验证
from sklearn.metrics import mean_absolute_error
y_pred=regressor.predict(X)
print('mean_absolute_error:',mean_absolute_error(y,y_pred))
# 5、预测新值
input_data = ['Tuesday', '13:35', 'San Francisco', 'yes']
input_data_encoder=[-1]*len(input_data)
count=0
for i,item in enumerate(input_data):
    if item.isdigit():
        input_data_encoder[i]=int(input_data[i])
    else:
        label=[]
        label.append(input_data[i])
        input_data_encoder[i]=int(label_encoder[count].transform(label))
        count=count+1

result=regressor.predict(input_data_encoder)
print(result)

相关文章

No Comments, Be The First!
近期评论
    分类目录
    功能
    网站地图xml地图