1.基础

支持向量机(SVMs)是一套用于分类、回归和异常值检测的监督学习方法。

支持向量机的优点是:

在高维空间中有效。
在维度数量大于样本数量的情况下仍然有效。
在决策函数中使用一个训练点子集(称为支持向量),因此它也是内存高效的。
通用的:可以为决策函数指定不同的内核函数。提供了通用的内核,但也可以指定定制的内核。
支持向量机的缺点包括:

如果特征数远大于样本数,则在选择核函数时避免过拟合,正则项至关重要。
如果特征数远大于样本数,则在选择核函数时避免过拟合,正则项至关重要。
SVMs不直接提供概率估计,这些估计是使用昂贵的五倍交叉验证
scikit-learn中的支持向量机既支持密集(numpy)又支持密集(numpy)。ndarray和可转换为它的numpy.asarray)和稀疏(任何scipy.稀疏)样本向量作为输入。然而,要使用支持向量机对稀疏数据进行预测,它必须与这些数据相匹配。为了获得最佳性能,请使用C-ordered numpy。ndarray(稠密)或scipy.稀疏。csrmatrix(稀疏),dtype=float64。
SVC和NuSVC是相似的方法,但接受的参数集略有不同,有不同的数学公式(见数学公式部分)。另一方面,LinearSVC是线性核情况下支持向量分类的另一种实现。注意,LinearSVC不接受关键字kernel,因为这被认为是线性的。它也缺少一些SVC和NuSVC成员,比如support

作为其他分类器,SVC、NuSVC和LinearSVC以两个数组作为输入:一个大小为[n_samples, n_features]的数组X和一个类别标签(字符串或整数)的数组y,大小为[n_samples]:

from sklearn import svm
X = [[0, 0], [1, 1]]
y = [0, 1]
clf = svm.SVC(gamma='scale')
clf.fit(X, y)  
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)

基础
模型拟合后,可用于预测新的值:

>>> clf.predict([[2., 2.]])
array([1])

SVMs决策函数依赖于训练数据的某个子集,称为支持向量。这些支持向量的一些属性可以在supportvectors、support_和n_support成员中找到:


 # get support vectors
clf.support_vectors_
​
array([[0., 0.],
       [1., 1.]])
# get indices of support vectors
clf.support_ 
array([0, 1], dtype=int32)
 # get number of support vectors for each class
clf.n_support_
array([1, 1], dtype=int32)

SVC和NuSVC实现了“one-against-one”方法(Knerr et al., 1990)用于多类分类。如果n_class是类的数量,则构造n_class * (n_class - 1) / 2分类器,每个分类器训练来自两个类的数据。为了与其他分类器提供一致的接口,decision_function_shape选项允许将“一对一”分类器的结果聚合到shape的决策函数(n_samples, n_classes):

>>> X = [[0], [1], [2], [3]]
>>> Y = [0, 1, 2, 3]
>>> clf = svm.SVC(gamma='scale', decision_function_shape='ovo')
>>> clf.fit(X, Y) 
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape='ovo', degree=3, gamma='scale', kernel='rbf',
    max_iter=-1, probability=False, random_state=None, shrinking=True,
    tol=0.001, verbose=False)
>>> dec = clf.decision_function([[1]])
>>> dec.shape[1] # 4 classes: 4*3/2 = 6
6
>>> clf.decision_function_shape = "ovr"
>>> dec = clf.decision_function([[1]])
>>> dec.shape[1] # 4 classes
4

另一方面,LinearSVC实现“一vs其他”多类策略,从而训练n_class模型。如果只有两个类,只培训一个模型:

>>> lin_clf = svm.LinearSVC()
>>> lin_clf.fit(X, Y) 
LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,
     intercept_scaling=1, loss='squared_hinge', max_iter=1000,
     multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,
     verbose=0)
>>> dec = lin_clf.decision_function([[1]])
>>> dec.shape[1]
4

注意,LinearSVC还使用multi_class='crammer_singer'选项实现了另一种多类策略,即Crammer和Singer制定的所谓多类支持向量机。这种方法是一致的,但对于one-vs-rest分类则不是这样。在实践中,通常首选1 -vs-rest分类,因为结果大部分是相似的,但是运行时要少得多。

对于“one-vs-rest”LinearSVC的属性coef_和intercept_分别具有形状[n_class、n_features]和[n_class]。系数的每一行都对应于n_class中的一个“one-vs-rest”分类器,对于截取程序也类似,顺序是“one”类。

在“one vs-one”SVC中,属性的布局要稍微复杂一些。在具有线性内核的情况下,属性coef_和intercept_分别具有[n_class (n_class - 1) / 2、n_features]和[n_class (n_class - 1) / 2]。这与上面描述的LinearSVC的布局类似,每一行对应一个二进制分类器。0到n的顺序是“0 vs 1”、“0 vs 2”、“0 vs n”、“1 vs 2”、“1 vs 3”、“1 vs n”……“n - 1与n”。

dual_coef_的形状是[n_class-1, n_SV],布局有点难以把握。列对应于任何n_class * (n_class - 1) / 2“one-vs-one”分类器中涉及的支持向量。在n_class - 1分类器中使用每个支持向量。每一行中的n_class - 1项对应于这些分类器的对偶系数。

from sklearn import svm
clf = svm.LinearSVC()
x = [[0.], [1.], [0.2], [1.]]
y = [0,1,0,1] #5*x-2>0
clf.fit(x,y)
clf.predict([[0.3], [2.]])

线性svm分类:(5x-2>0=>1 | 5x-2<0=>0)

array([0, 1])

非线性SVM分类

import numpy as np
from sklearn import svm
clf = svm.SVC(gamma='scale')
x=np.random.random(size=(50,1))
y=5*pow(x,2)+3>5
clf.fit(x,y.ravel())
x_test=np.random.random(size=(5,1))
y_test=5*pow(x_test,2)+3>5
y_pred=clf.predict(x_test)
print y_pred
print y_test
[False  True False  True False]
[[False]
 [ True]
 [False]
 [ True]
 [False]]

读取csv

import pandas as pd
df_list=[]
for df in pd.read_csv(
    "winequality-white.csv",
    sep=';',
    encoding="utf-8",
    chunksize=200,
    usecols=["fixedacidity","volatileacidity","citricacid","residualsugar","chlorides","freesulfurdioxide","totalsulfurdioxide","density","pH","sulphates","alcohol","quality"]
):
    df_list.append(df)
print df_list
[     fixedacidity  volatileacidity  citricacid  residualsugar  chlorides  \
0             6.6            0.170        0.38           1.50      0.032   
1             6.3            0.480        0.04           1.10      0.046   
2             6.2            0.660        0.48           1.20      0.029   
3             7.4            0.340        0.42           1.10      0.033   
4             6.5            0.310        0.14           7.50      0.044   
5             6.2            0.660        0.48           1.20      0.029   
6             6.5            0.390        0.23           5.40      0.051   
7             7.0            0.330        0.32           1.20      0.053   
...
...
...
import pandas as pd
import StringIO
x="name,age,y\n'zhangsang',32,1\n'lisi',29,2\n'wangwu',30,1"
pd.read_csv(StringIO.StringIO(x))#StringIO — Read and write strings as files

在这里插入图片描述
当指定为dtype (GH10153)时,read_csv()函数现在支持解析类别(Categorical)列。根据数据的结构不同,与解析后转换为category的方法相比,这会导致更快的解析时间和更低的内存使用量。请参阅这里的io文档。

import pandas as pd
import StringIO
x="name,age,y\n'zhangsang',32,1\n'lisi',29,2\n'wangwu',30,1"
pd.read_csv(StringIO.StringIO(x))#StringIO — Read and write strings as files
pd.read_csv(StringIO.StringIO(x), dtype='category').dtypes
name    category
age     category
y       category
dtype: object
import pandas as pd
import StringIO
x="name,age,y\n'zhangsang',32,1\n'lisi',29,2\n'wangwu',30,1"
pd.read_csv(StringIO.StringIO(x))#StringIO — Read and write strings as files
pd.read_csv(StringIO.StringIO(x), dtype={'y': 'category'}).dtypes
name      object
age        int64
y       category
dtype: object
>>>df["y"].cat.categories
Index([u'1', u'2'], dtype='object')

>>>pd.to_numeric(df["y"].cat.categories)
Int64Index([1, 2], dtype='int64')

继续读取csv基础

import pandas as pd
import StringIO
x="name,age,y\n'zhangsang',32,1\n'lisi',29,2\n'wangwu',30,1"
df=pd.read_csv(StringIO.StringIO(x), dtype={'y': 'category'})
df["name"],df["y"]
(0    'zhangsang'
 1         'lisi'
 2       'wangwu'
 Name: name, dtype: object, 0    1
 1    2
 2    1
 Name: y, dtype: category
 Categories (2, object): [1, 2])
pandas.read_csv(filepath_or_buffer, sep=’, ’, delimiter=None, header=’infer’, names=None, in- dex_col=None, usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skipinitialspace=False, skiprows=None, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=False, skip_blank_lines=True, parse_dates=False, infer_datetime_format=False, keep_date_col=False, date_parser=None, dayfirst=False, iterator=False, chunksize=None, compres- sion=’infer’, thousands=None, decimal=b’.’, lineterminator=None, quotechar=’"’, quoting=0, escapechar=None, comment=None, encoding=None, dialect=None, tupleize_cols=None, error_bad_lines=True, warn_bad_lines=True, skipfooter=0, dou- blequote=True, delim_whitespace=False, low_memory=True, memory_map=False,
float_precision=None)

Read CSV (comma-separated) file into DataFrame
还支持可选地迭代或分割文件为块。
panda I/O API是一组顶级读取器函数,如pandas.read_csv(),通常返回一个panda对象。相应的writer函数是对象方法,可以像DataFrame.to_csv()那样访问。下面是一个包含可用readers 和 writers的表。
在这里插入图片描述
参数
filepath_or_buffer [str, pathlib.Path, py._path.local.LocalPath or any ]
具有read()方法的对象(如文件句柄或StringIO)
字符串可以是URL。有效的URL方案包括http、ftp、s3和文件。对于文件url,需要一台主机。例如,一个本地文件可以是 file://localhost/path/to/table. csv

sep : str, default ‘,’
分隔符使用。如果sep为空,C引擎无法自动检测分离器,
但是Python解析引擎可以,这意味着后者将被自动使用。
通过Python的内置嗅探工具csv.Sniffer检测分离器。此外,与'\s+'不同,大于1个字符的sep- arators将被解释为正则表达式,并将强制使用Python解析引擎。注意,regex分隔符很容易忽略引用的数据。正则表达式的例子:“\ r \ t”
delimiter : str, default None
sep的替代参数名。
delim_whitespace : boolean, default False
指定是否使用空格(例如。' '或'\t')将用作sep.等效于设置sep='\s+'。如果将此选项设置为True,则不应该为分隔符参数传递任何内容。
0.18.1版的新特性:对Python解析器的支持。
header : int or list of ints, default ‘infer’
行号(行数)要用作列名和数据的头。默认值是- havior,用于推断列名:如果没有传递列名,则行为与header=0相同,并且从文件的第一行推断列名,如果显式传递列名,则行为与header=None相同。显式传递header=0以替换现有名称。头可以是一个整数列表,它为列上的多个索引指定行位置,例如[0,1,3]。未指定的中间行将被跳过(例如,例如本例中跳过了2)。注意,如果skip_blank_lines=True,则该参数将忽略注释的行和空行,因此header=0表示数据的第一行,而不是文件的第一行。
names : array-like, default None
要使用的列名列表。如果文件不包含头行,那么应该显式地执行
通过header = None。此列表中的重复项将导致发出用户警告。
index_col : int or sequence or False, default None
要用作DataFrame的行标签的列。如果给定一个序列,则使用一个多索引。如果在每行末尾有一个带分隔符的格式不正确的文件,那么可以考虑使用index_col=False强制panda _not_使用第一列作为索引(行名)
usecols : list-like or callable, default None
返回列的子集。如果类似于列表,则所有元素必须是位置的(即文档列中的整数索引),或者是与用户提供的列名相对应的字符串,或者是从文档头行推断出来的。例如,一个有效的类列表的usecols参数将是[0,1,2]或[' foo ', ' bar ', ' baz ']。元素顺序被忽略,所以usecols=[0,1]与[1,0]相同。
用保留的顺序从data实例化DataFrame元素
pd.read_csv(data, usecols=['foo', 'bar'])[['foo', 'bar']]
按照['foo', 'bar']的列顺序,或pd.read_csv(data, usecols=['foo', 'bar'])[['bar', 'foo']]for['bar', 'foo']的顺序
如果可调用,可调用函数将根据列名求值,返回可调用函数求值为True时的名称。一个有效的可调用参数的例子是['AAA', 'BBB', 'DDD']中的lambda x: x.upper()。使用这个参数会导致更快的解析时间和更低的内存使用。
squeeze : boolean, default False
如果解析后的数据只包含一列,则返回一个系列
prefix : str, default None
在没有标题的情况下向列数添加前缀,例如“X”表示X0、X1、…
mangle_dupe_cols : boolean, default True
重复列将被指定为‘X’, ‘X.1’, . . . ’X.N’,而不是‘X’. . . ’X’。如果列中有重复的名称,则False中的传递将导致数据覆盖。
dtype : Type name or dict of column -> type, default None
数据或列的数据类型。{‘a’: np.float64, ‘b’: np.int32},使用str或对象以及适当的na_values设置来保存和不解释dtype。如果指定了转换器,将应用dtype转换的INSTEAD。
engine : {‘c’, ‘python’}, optional
要使用的解析器引擎。C引擎更快,而python引擎目前功能更完备。
converters : dict, default None
用于转换某些列中的值的函数的字典。键可以是整数,也可以是列标签