标签：回归 rate oca 不包含 内存 复杂 参数 注释 learn
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‘).dtypesname category
age category
y category
dtype: objectimport 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‘}).dtypesname 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
用于转换某些列中的值的函数的字典。键可以是整数，也可以是列标签
标签：回归 rate oca 不包含 内存 复杂 参数 注释 learn
原文地址：http://blog.51cto.com/13959448/2325825
