新普金娱乐网址


【重读.转】黑客帝国哲学入门

数学人生之公式

数学Oracl Over函数

  • 十月 09, 2018
  • 数学
  • 没有评论

Oracl Over函数

展望模型

简介

于介绍Over之前, 必须提到开窗函数, 与 聚 合函数一样,
开窗函数也是对准行集组进行联谊计算,
但是它不像平常聚合函数那么每组只回一个价值,
开窗函数可以吧每组返回多独值.

开窗函数用于为行定义一个窗口(这里的窗口是据运算将要操作的实践之联谊),它对同样组值进行操作,不需要动用GROUP
BY子句子针对数据开展分组,

能够当一如既往行中还要返回基础实施的排列和聚合列。

以 Oracle中虽让喻为分析函数,而当DB2中尽管为称为OLAP函数。

Over
关键字表示将函数当成开窗函数而未是聚合函数。SQL标准允许以具有聚合函数用做开窗函数,使用OVER
关键字来区别这片栽用法。

开窗函数的调用格式为:

函数名(列) 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;
    
    --结果与上述相同, 就不再展示
    

    透过 PARTITION BY CLASSNUMBER 进行分组

  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)
    

    好察觉, 这种增长方式, 求和艺术是 根据DATENUMBER 连续求和

    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. 注意

    但是需要小心的一个地方是: 在这边以 Order By,计算方式是:
    会根据后面的字段, 首先进行分组, 然后再行进行添加:

    如若: ORDER BY SALE, 则类似于 SUM(SALE) FROM TABLE GROUP BY SALE,
    对求得的结果集还展开劳动加. 而在 DATENUMBER
    累加的时候从不起这种场面, 是因为 DATENUMBER都是唯一值.

    甚至 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
    

    事后再次来拘禁 PARTITION BY COLUMN_A ORDER BY COLUMN_B, 则是先经
    COLUMB_A 进行分组, 而后 在 分组的结果集内, 根据 COLUMN_B
    还展开添加操作.

  7. 总结

    于 Over() 中, 会根据 Over前底聚合函数控制所用之操作, 同时依据
    Partition By 的排列进行分组, 对于 分组后底数量, 再度通过 Order By
    后的字段 进行对应的 累加 等操作.

    当地方的案例中说来:

    首先根据 CLASSNUMBER 班级编号, 对负有数据分组, 分成三组数:

    --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通过对数学方程组求解,可以搜寻来点儿组数里的最佳分割边界。下面先采用第2章的创始简单分类器将数据分类并打来。

# 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 名, 随后连下去就是 第6名叫, 是的, 你从未想错,
在同样的上, 会将名次并列, 然后过了下一个名次.

但是还要会产出同样种比较大的景况:

考查的时刻, 总分相同者, 以数学论名次, 再同, 语文…这样的同等仿规则

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的解释, 理解这段也未到底难. 就不再赘述.

3、用SVM建立非线性分类器

自从者的分类报告可知,我们的归类情况并无地道,而且,最开始的多寡可视化也可看到,实心完全受空心包围在,所以,我们需要尝试非线性分类器。
SVM为建非线性分类器提供了过多挑选,需要因此不同之核函数建立费线性分类器。为了简单起见,考虑一下两栽情况。

DENSE_RANK( )

需是边的, 如果主任又说, 我们学校排名, 并列第二号称,
下一个子女便该是第三誉为, 虽然才生四只人, 但好歹让 家长开心下.

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.1、多项式函数

直接以线性中之params={‘kernel’:’linear’}替换成params={‘kernel’:’poly’,’degree’:3},其中degree表示三不行多项式,随着次数多,可于曲线变得重复别,但是训练日也会越长,计算强度进一步充分。结果如下图:

数学 3

3.2、径向基函数(Radial Basis Function,RBF)

直拿线性中之params={‘kernel’:’linear’}替换成params={‘kernel’:’rbf’},结果而下图:

数学 4

4、解决项目数量不平衡问题

当现实生活中,我们收获的多寡或者会见面世某类数据较任何类数据差不多浩大的景象,在这种情况下分类器会生出错,边界线也非会见影响数据的实际,所以用针对数据开展疏通。
改换一个数,以上面线性SVM为例,将数据换成data_multivar_imbalance.txt之后,显示为

数学 5

出于图能够,没有边界线,这是盖分类器不克分这点儿栽类型,所以,将参数改也params={‘kernel’:’linear’,’class_weight’:’balanced’}即可。结果如下:

数学 6

5、提取置信度

当一个信之数据点被分门别类也有一个既掌握路时,我们只是训练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))

6、寻找最好优超参数

跳参数对分类器的性质至关重要。寻找步骤如下:

# 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都是为此作分类器,现在来得一个回归器的例证:

# 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地图