如何利用python使用libsvm一：libsvm包下载与使用：
LIBSVM是台湾大学林智仁(Lin Chih-Jen)副教授等开发设计的一个简单、易于使用和快速有效的SVM模式识别与回归的软件包，他不但提供了编译好的可在Windows系列系统的执行文件，还提供了源代码，方便改进.
把包解压在C盘之中，如：C:\libsvm-3.18
2.
因为要用libsvm自带的脚本grid.py和easy.py,需要去官网下载绘图工具gnuplot,解压到c盘
3.
进入c:\libsvm\tools目录下，用文本编辑器（记事本 ， edit都可以）修改grid.py和easy.py两个文件，找到其中关于gnuplot路径的那项，根据实际路径进行修改，并保存
4python与libsvm的连接（参考SVM学习笔记（2）LIBSVM在python下的使用 ）
a.打开IDLE(python GUI) ， 输入
import sys
sys.version
如果你的python是32位，将出现如下字符：
‘2.7.3 (default, Apr 10 2012, 23:31:26) [MSC v.1500 32 bit (Intel)]’
这个时候LIBSVM的python接口设置将非常简单 。在libsvm-3.16文件夹下的windows文件夹中找到动态链接库libsvm.dll，将其添加到系统目录，如`C:\WINDOWS\system32\’，即可在python中使用libsvm
b.如果你是64位的请参考文献，请参考上述连接 。
5.执行一个小例子
import os
os.chdir('C:\libsvm-3.18\python')#请根据实际路径修改
from svmutil import *
y, x = svm_read_problem('../heart_scale')#读取自带数据
m = svm_train(y[:200], x[:200], '-c 4')
p_label, p_acc, p_val = svm_predict(y[200:], x[200:], m)
##出现如下结果，应该是正确安装了
optimization finished, #iter = 257
nu = 0.351161
obj = -225.628984, rho = 0.636110
nSV = 91, nBSV = 49
Total nSV = 91
Accuracy = 84.2857% (59/70) (classification)
二几个简单的例子
从下载实验数据集 。并且将数据集拷贝到C:\libsvm-3.18\windows下（因为之后我们需要利用该文件夹下的其他文件 ， 这样比较方便，当然之后你用绝对地址也可以了）
建立一个py文件，写下如下代码：
例1：
import os
os.chdir('C:\libsvm-3.18\windows')#设定路径
from svmutil import *
y, x = svm_read_problem('train.1.txt')#读入训练数据
yt, xt = svm_read_problem('test.1.txt')#训练测试数据
m = svm_train(y, x )#训练
svm_predict(yt,xt,m)#测试
执行上述代码，精度为：Accuracy = 66.925% (2677/4000) (classification)
常用接口
svm_train() : train an SVM model#训练
svm_predict() : predict testing data#预测
svm_read_problem() : read the data from a LIBSVM-format file.#读取libsvm格式的数据
svm_load_model() : load a LIBSVM model.
svm_save_model() : save model to a file.
evaluations() : evaluate prediction results.
- Function: svm_train#三种训练写法
There are three ways to call svm_train()
model = svm_train(y, x [, 'training_options'])
model = svm_train(prob [, 'training_options'])
model = svm_train(prob, param)
有关参数的设置（read me 文件夹中有详细说明）：
Usage: svm-train [options] training_set_file [model_file]
【python自回归函数 python 逻辑回归函数】options:
-s svm_type : set type of SVM (default 0)#选择哪一种svm
0 -- C-SVC (multi-class classification)
1 -- nu-SVC (multi-class classification)
2 -- one-class SVM
3 -- epsilon-SVR (regression)
4 -- nu-SVR (regression)
-t kernel_type : set type of kernel function (default 2)#是否用kernel trick
0 -- linear: u'*v
1 -- polynomial: (gamma*u'*vcoef0)^degree
2 -- radial basis function: exp(-gamma*|u-v|^2)
3 -- sigmoid: tanh(gamma*u'*vcoef0)
4 -- precomputed kernel (kernel values in training_set_file)
-d degree : set degree in kernel function (default 3)
-g gamma : set gamma in kernel function (default 1/num_features)
-r coef0 : set coef0 in kernel function (default 0)
-c cost : set the parameter C of C-SVC, epsilon-SVR, and nu-SVR (default 1)
-n nu : set the parameter nu of nu-SVC, one-class SVM, and nu-SVR (default 0.5)
-p epsilon : set the epsilon in loss function of epsilon-SVR (default 0.1)
-m cachesize : set cache memory size in MB (default 100)
-e epsilon : set tolerance of termination criterion (default 0.001)
-h shrinking : whether to use the shrinking heuristics, 0 or 1 (default 1)
-b probability_estimates : whether to train a SVC or SVR model for probability estimates, 0 or 1 (default 0)
-wi weight : set the parameter C of class i to weight*C, for C-SVC (default 1)
-v n: n-fold cross validation mode
-q : quiet mode (no outputs)
三提高预测的准确率：
通过一定的过程 ， 可以提高预测的准确率(在文献2中有详细介绍)：
a.转换数据为libsvm可用形式.(可以通过下载的数据了解格式）
b.进行一个简单的尺度变换
c.利用RBF kernel ， 利用cross-validation来查找最佳的参数 C 和 r
d.利用最佳参数C 和 r，来训练整个数据集
e.测试
再看例子1：
1.进入cmd模式下，输入如下代码，将现有数据进行适度变换，生成变换后的数据文件train.1.scale.txt
参数说明：
-l 变换后的下限
-u 变换后的上限
-s 参考上文
2执行以下代码
import os
os.chdir('C:\libsvm-3.18\windows')#设定路径
from svmutil import *
y, x = svm_read_problem('train.1.scale.txt')#读入训练数据
yt, xt = svm_read_problem('test.1.scale.txt')#训练测试数据
m = svm_train(y, x )#训练
svm_predict(yt,xt,m)#测试
精确度为Accuracy = 95.6% (3824/4000) (classification) 。
可见我们只是做了简单的尺度变换后，预测的正确率大大提升了 。
3通过选择最优参数，再次提高预测的准确率：（需要把tools文件下的grid.py拷贝到'C:\libsvm-3.18\windows'下）
import os
os.chdir('C:\libsvm-3.18\windows')#设定路径
from svmutil import *
from grid import *
rate, param = find_parameters('train.1.scale.txt', '-log2c -3,3,1 -log2g -3,3,1')
y, x = svm_read_problem('train.1.scale.txt')#读入训练数据
yt, xt = svm_read_problem('test.1.scale.txt')#训练测试数据
m = svm_train(y, x ,'-c 2 -g 4')#训练
p_label,p_acc,p_vals=svm_predict(yt,xt,m)#测试
执行上面的程序，find_parmaters函数，可以找到对应训练数据较好的参数 。后面的log2c,log2g分别设置C和r的搜索范围 。搜索机制是以2为底指数搜索 ， 如 –log2c –3 , 3,1 就是参数C,从2^-3 ， 2^-2，2^-1…搜索到2^3.
搜索到较好参数后，在训练的时候加上参数的设置 。
另外，读者可以自己试试数据集2,3.
python数据分析使用的数据1、对数据进行排序df.sort_values()
#读取数据
titanic_survival=pd.read_csv(r"C:Userspythonwandata_minepython_pandas itanic_train.csv")
#用sort_values()函数对指定列排序，默认升序排序，inplace=True表示在原来的df上排序titanic_survival.sort_values(("Age"),inplace=Tru
2、缺失值判断及统计pandas.isnull()、pandas.isnull
空值统计方法一python自回归函数：df.isnull().sum()：
#当不指定具体列时，统计整个df的缺失值个数
titanic_survival['Age'].isnull().sum()
通过len()函数统计缺失值
3、缺失值处理
处理缺失值可以分为两类：删除缺失值和缺失值插补 。而缺失值插补又分为以下几种：
均值/中位数/众数插补
使用固定值（将缺失值的属性用一个常量代替）
最近邻插补（在记录中找到与缺失值样本最接近的样本的该属性插补）
回归方法（对带有缺失值的变量 ， 根据已有数据和与其有关的其他变量建立拟合模型来预测缺失值）
插值法（利用已知点建立合适的插值函数f(x),未知值由对应点xi求出来近似代替）
下面 ， python自回归函数我们主要讨论删除缺失值，学习一些pandas缺失值删除的操作 。
1）df.dropna(),舍弃含有任意缺失值的行
#等价于titanic_survival.dropna(axis=0) axis=0表示删除行，axis=1表示删除列
dropall=titanic_survival.dropna()
删除含任意空值的行
2）df.dropna()函数删除某个列中含有空值的行
现在这个数据中age、cabin、embarked都有缺失值，如果我们直接使用df.dropna()会删除掉这三列中都有空值的所有行，但是我们希望只删除age列中有空值的数据，那该如何处理呢？
直接使用df.dropna(subset=['column_list'])
drop_age_null=titanic_survival.dropna(subset=["Age"])
删除指定列中含有缺失值的行
pandas自定义函数
python内置函数有哪些python常见的内置函数有：
1. abs()函数返回数字的绝对值 。
2. all() 函数用于判断给定的参数中的所有元素是否都为 TRUE ， 如果是返回 True，否则返回 False 。元素除了是 0、空、None、False 外都算 True；空元组、空列表返回值为True 。
3.any() 函数用于判断给定的参数是否全部为False，是则返回False，如果有一个为True，则返回True 。元素除了是 0、空、False外都算 TRUE 。
4. bin()函数返回一个整数int或者长整数long int的二进制表示 。
5. bool() 函数用于将给定参数转换为布尔类型 ， 如果参数不为空或不为0，返回True；参数为0或没有参数，返回False 。
6. bytearray()方法返回一个新字节数组 。这个数组里的元素是可变的，并且每个元素的值范围: 0 = x256（即0-255） 。即bytearray()是可修改的二进制字节格式 。
7. callable()函数用于检查一个对象是否可调用的 。对于函数、方法、lambda函式、类以及实现了 __call__ 方法的类实例, 它都返回 True 。（可以加括号的都可以调用）
8. chr()函数用一个范围在range(256)内（即0～255）的整数作参数，返回一个对应的ASCII数值 。
9. dict()函数用来将元组/列表转换为字典格式 。
10. dir()函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时 ， 返回参数的属性、方法列表 。
扩展资料：
如何查看python3.6的内置函数？
1、首先先打开python自带的集成开发环境IDLE；
2、然后我们直接输入"dir(__builtins__)",需要注意的是builtins左右的下划线都是两个；
3、回车之后我们就可以看到python所有的内置函数；
4、接下来我们学习第二种查看python内置函数的方法，我们直接在IDLE中输入"import builtins",然后输入"dir(builtins)"；
5、然后回车，同样的这个方法也可以得到所有的python内置的函数；
6、这里我们可以使用python内置函数len（）来查看python内置函数的个数 ， 这里我们直接输入"len(dir(builtins))"；
7、回车之后我们可以看到系统返回值153，说明我们现在这个版本中有153个内置函数；
8、最后我们介绍一个比较有用的内置函数"help"，python内置函数有一百多个，我们当然不能记住所有的函数 ， 这里python提供了一个"help"函数，我们来看一个例子一起来体会一下help函数的用法，这里我们直接输入"help(len)",然后回车，会看到系统给我们对于内置函数"len"的解释，当然对于其他函数可能会有更加详细的解释以及用法提示 。
Python 里为什么函数可以返回一个函数内部定义的函数“在Python中 ， 函数本身也是对象”
这一本质 。那不妨慢慢来 ， 从最基本的概念开始，讨论一下这个问题：
1. Python中一切皆对象
这恐怕是学习Python最有用的一句话 。想必你已经知道Python中的list, tuple, dict等内置数据结构，当你执行：
alist = [1, 2, 3]
时，你就创建python自回归函数了一个列表对象，并且用alist这个变量引用它：
当然你也可以自己定义一个类:
class House(object):
def __init__(self, area, city):
self.area = area
self.city = city
def sell(self, price):
[...]#other code
return price
然后创建一个类的对象：
house = House(200, 'Shanghai')
OK ， 你立马就在上海有了一套200平米的房子，它有一些属性(area, city)，和一些方法(__init__, self)：
2. 函数是第一类对象
和list, tuple, dict以及用House创建的对象一样 ， 当你定义一个函数时，函数也是对象：
def func(a, b):
return a b
在全局域，函数对象被函数名引用着，它接收两个参数a和b，计算这两个参数的和作为返回值 。
所谓第一类对象 ， 意思是可以用标识符给对象命名，并且对象可以被当作数据处理 ， 例如赋值、作为参数传递给函数，或者作为返回值return 等
因此，你完全可以用其他变量名引用这个函数对象：
add = func
这样，你就可以像调用func(1, 2)一样，通过新的引用调用函数了：
print func(1, 2)
print add(1, 2)#the same as func(1, 2)
或者将函数对象作为参数，传递给另一个函数：
def caller_func(f):
return f(1, 2)
if __name__ == "__main__":
print caller_func(func)
可以看到 ，
函数对象func作为参数传递给caller_func函数 ， 传参过程类似于一个赋值操作f=funcpython自回归函数；
于是func函数对象，被caller_func函数作用域中的局部变量f引用，f实际指向了函数func；cc
当执行return f(1, 2)的时候，相当于执行了return func(1, 2)；
因此输出结果为3 。
3. 函数对象 vs 函数调用
无论是把函数赋值给新的标识符 ， 还是作为参数传递给新的函数，针对的都是函数对象本身，而不是函数的调用 。
用一个更加简单，但从外观上看，更容易产生混淆的例子来说明这个问题 。例如定义了下面这个函数：
def func():
return "hello,world"
然后分别执行两次赋值：
ref1 = func#将函数对象赋值给ref1
ref2 = func()#调用函数，将函数的返回值("hello,world"字符串)赋值给ref2
很多初学者会混淆这两种赋值，通过Python内建的type函数，可以查看一下这两次赋值的结果：
In [4]: type(ref1)
Out[4]: function
In [5]: type(ref2)
Out[5]: str
可以看到，ref1引用了函数对象本身，而ref2则引用了函数的返回值 。通过内建的callable函数，可以进一步验证ref1是可调用的，而ref2是不可调用的：
In [9]: callable(ref1)
Out[9]: True
In [10]: callable(ref2)
Out[10]: False
传参的效果与之类似 。
4. 闭包LEGB法则
所谓闭包，就是将组成函数的语句和这些语句的执行环境打包在一起时，得到的对象
听上去的确有些复杂，还是用一个栗子来帮助理解一下 。假设我们在foo.py模块中做了如下定义：
#foo.py
filename = "foo.py"
def call_func(f):
return f()#如前面介绍的 ， f引用一个函数对象，然后调用它
在另一个func.py模块中，写下了这样的代码：
#func.py
import foo#导入foo.py
filename = "func.py"
def show_filename():
return "filename: %s" % filename
if __name__ == "__main__":
print foo.call_func(show_filename)#注意：实际发生调用的位置，是在foo.call_func函数中
当我们用python func.py命令执行func.py时输出结果为：
chiyu@chiyu-PC:~$ python func.py
filename:func.py
很显然show_filename()函数使用的filename变量的值，是在与它相同环境(func.py模块)中定义的那个 。尽管foo.py模块中也定义了同名的filename变量，而且实际调用show_filename的位置也是在foo.py的call_func内部 。
而对于嵌套函数，这一机制则会表现的更加明显：闭包将会捕捉内层函数执行所需的整个环境：
#enclosed.py
import foo
def wrapper():
filename = "enclosed.py"
def show_filename():
return "filename: %s" % filename
print foo.call_func(show_filename)#输出：filename: enclosed.py
实际上，每一个函数对象，都有一个指向了该函数定义时所在全局名称空间的__globals__属性：
#show_filename inside wrapper
#show_filename.__globals__
{
'__builtins__': module '__builtin__' (built-in),#内建作用域环境
'__file__': 'enclosed.py',
'wrapper': function wrapper at 0x7f84768b6578,#直接外围环境
'__package__': None,
'__name__': '__main__',
'foo': module 'foo' from '/home/chiyu/foo.pyc',#全局环境
'__doc__': None
}
当代码执行到show_filename中的return "filename: %s" % filename语句时，解析器按照下面的顺序查找filename变量：
Local - 本地函数(show_filename)内部，通过任何方式赋值的，而且没有被global关键字声明为全局变量的filename变量；
Enclosing - 直接外围空间(上层函数wrapper)的本地作用域，查找filename变量(如果有多层嵌套，则由内而外逐层查找，直至最外层的函数)；
Global - 全局空间(模块enclosed.py)，在模块顶层赋值的filename变量；
Builtin - 内置模块(__builtin__)中预定义的变量名中查找filename变量；
在任何一层先找到了符合要求的filename变量，则不再向更外层查找 。如果直到Builtin层仍然没有找到符合要求的变量 ， 则抛出NameError异常 。这就是变量名解析的：LEGB法则 。
总结：
闭包最重要的使用价值在于：封存函数执行的上下文环境；
闭包在其捕捉的执行环境(def语句块所在上下文)中 ， 也遵循LEGB规则逐层查找，直至找到符合要求的变量，或者抛出异常 。
5. 装饰器语法糖(syntax sugar)
那么闭包和装饰器又有什么关系呢？
上文提到闭包的重要特性：封存上下文 ， 这一特性可以巧妙的被用于现有函数的包装，从而为现有函数更加功能 。而这就是装饰器 。
还是举个例子，代码如下：
#alist = [1, 2, 3, ..., 100]-- 1 2 3 ... 100 = 5050
def lazy_sum():
return reduce(lambda x, y: x y, alist)
我们定义了一个函数lazy_sum，作用是对alist中的所有元素求和后返回 。alist假设为1到100的整数列表：
alist = range(1, 101)
但是出于某种原因 ， 我并不想马上返回计算结果，而是在之后的某个地方，通过显示的调用输出结果 。于是我用一个wrapper函数对其进行包装：
def wrapper():
alist = range(1, 101)
def lazy_sum():
return reduce(lambda x, y: x y, alist)
return lazy_sum
lazy_sum = wrapper()#wrapper() 返回的是lazy_sum函数对象
if __name__== "__main__":
lazy_sum()#5050
这是一个典型的Lazy Evaluation的例子 。我们知道，一般情况下，局部变量在函数返回时，就会被垃圾回收器回收 ， 而不能再被使用 。但是这里的alist却没有，它随着lazy_sum函数对象的返回被一并返回了(这个说法不准确，实际是包含在了lazy_sum的执行环境中，通过__globals__)，从而延长了生命周期 。
当在if语句块中调用lazy_sum()的时候 ， 解析器会从上下文中(这里是Enclosing层的wrapper函数的局部作用域中)找到alist列表，计算结果，返回5050 。
当你需要动态的给已定义的函数增加功能时，比如：参数检查，类似的原理就变得很有用：
def add(a, b):
return a b
这是很简单的一个函数：计算a b的和返回，但我们知道Python是 动态类型 强类型 的语言，你并不能保证用户传入的参数a和b一定是两个整型，他有可能传入了一个整型和一个字符串类型的值：
In [2]: add(1, 2)
Out[2]: 3
In [3]: add(1.2, 3.45)
Out[3]: 4.65
In [4]: add(5, 'hello')
---------------------------------------------------------------------------
TypeErrorTraceback (most recent call last)
/home/chiyu/ipython-input-4-f2f9e8aa5eae in module()
---- 1 add(5, 'hello')
/home/chiyu/ipython-input-1-02b3d3d6caec in add(a, b)
1 def add(a, b):
---- 2return a b
TypeError: unsupported operand type(s) for: 'int' and 'str'
于是 ， 解析器无情的抛出了一个TypeError异常 。
动态类型：在运行期间确定变量的类型，python确定一个变量的类型是在你第一次给他赋值的时候；
强类型：有强制的类型定义，你有一个整数，除非显示的类型转换，否则绝不能将它当作一个字符串(例如直接尝试将一个整型和一个字符串做 运算)；
因此，为了更加优雅的使用add函数，我们需要在执行 运算前，对a和b进行参数检查 。这时候装饰器就显得非常有用：
import logging
logging.basicConfig(level = logging.INFO)
def add(a, b):
return ab
def checkParams(fn):
def wrapper(a, b):
if isinstance(a, (int, float)) and isinstance(b, (int, float)):#检查参数a和b是否都为整型或浮点型
return fn(a, b)#是则调用fn(a, b)返回计算结果
#否则通过logging记录错误信息，并友好退出
logging.warning("variable 'a' and 'b' cannot be added")
return
return wrapper#fn引用add，被封存在闭包的执行环境中返回
if __name__ == "__main__":
#将add函数对象传入，fn指向add
#等号左侧的add，指向checkParams的返回值wrapper
add = checkParams(add)
add(3, 'hello')#经过类型检查，不会计算结果 ， 而是记录日志并退出
注意checkParams函数：
首先看参数fn，当我们调用checkParams(add)的时候 ， 它将成为函数对象add的一个本地(Local)引用；
在checkParams内部，我们定义了一个wrapper函数，添加了参数类型检查的功能 ， 然后调用了fn(a, b)，根据LEGB法则 ， 解释器将搜索几个作用域，并最终在(Enclosing层)checkParams函数的本地作用域中找到fn；
注意最后的return wrapper，这将创建一个闭包，fn变量(add函数对象的一个引用)将会封存在闭包的执行环境中 ， 不会随着checkParams的返回而被回收；
当调用add = checkParams(add)时，add指向了新的wrapper对象，它添加了参数检查和记录日志的功能，同时又能够通过封存的fn，继续调用原始的add进行 运算 。
因此调用add(3, 'hello')将不会返回计算结果，而是打印出日志：
chiyu@chiyu-PC:~$ python func.py
WARNING:root:variable 'a' and 'b' cannot be added
有人觉得add = checkParams(add)这样的写法未免太过麻烦 ， 于是python提供了一种更优雅的写法，被称为语法糖：
@checkParams
def add(a, b):
return ab
这只是一种写法上的优化，解释器仍然会将它转化为add = checkParams(add)来执行 。
6. 回归问题
def addspam(fn):
def new(*args):
print "spam,spam,spam"
return fn(*args)
return new
@addspam
def useful(a,b):
print a**2 b**2
首先看第二段代码：
@addspam装饰器 ， 相当于执行了useful = addspam(useful) 。在这里题主有一个理解误区：传递给addspam的参数，是useful这个函数对象本身，而不是它的一个调用结果；
再回到addspam函数体：
return new 返回一个闭包，fn被封存在闭包的执行环境中，不会随着addspam函数的返回被回收；
而fn此时是useful的一个引用，当执行return fn(*args)时 ， 实际相当于执行了return useful(*args)；
最后附上一张代码执行过程中的引用关系图，希望能帮助你理解：
如何用python作空间自回归模型基本形式
线性模型(linear model)就是试图通过属性的线性组合来进行预测的函数，基本形式如下：
f(x)=wTx b
许多非线性模型可在线性模型的基础上通过引入层结构或者高维映射（比如核方法）来解决 。线性模型有很好的解释性 。
线性回归
线性回归要求均方误差最小:
(w?,b?)=argmin∑i=1m(f(xi)?yi)2
均方误差有很好的几何意义，它对应了常用的欧式距离(Euclidean distance) 。基于均方误差最小化来进行模型求解称为最小二乘法(least square method)，线性回归中，最小二乘发就是试图找到一条直线 ， 使得所有样本到直线的欧式距离之和最小 。
我们把上式写成矩阵的形式：
w?=argmin(y?Xw)T(y?Xw)
这里我们把b融合到w中，X中最后再加一列1 。为了求最小值，我们对w求导并令其为0：
2XT(Xw?y)=0
当XTX为满秩矩阵(full-rank matrix)时是可逆的 。此时：
w=(XTX)?1XTy
令xi=(xi,1)，可以得到线性回归模型：
f(xi)=xTi(XTX)?1XTy
关于python自回归函数和python 逻辑回归函数的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站 。
推荐阅读
- 苹果手机信号和安卓比较，苹果手机信号和安卓比较怎么样
- 益智游戏选修课学后感想，益智游戏的心得体会
- 动作竞争类游戏，动作竞技类手游
- 怎么cmd进入mysql 怎么进入mysql命令
- 电脑节电模式什么意思，电脑节电模式什么意思,怎么解决
- 盐城电商仓储物流如何选择，盐城物流招聘网盐城仓储招聘信息
- 电视wifi怎么显示断开，电视wifi断开怎么回事
- linux命令链接 linux常用命令连接符
- 如何在新媒体做好品牌推广，如何在新媒体渠道做好品牌宣传