python建立模型

① 如何用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建立abaqus框架模型

能abaqus自身带sqlite3与python2.6所带sqlite3冲突
import优先搜索abaqus自带sqlite3
import sqlite3前先指定确sqlite3所位置：比c:\\python26\\lib\\sqlite3
import sys
sys.path.insert(0,"c:\\python26\\lib\\sqlite3")
sys.path.insert(0,"c:\\python26\\dlls")
import sqlite3
或者python2.6所带sqlite3复制覆盖abaqussqlite3
sqlite3包括两部要漏掉sqlite3.dll态链接库

③ 怎样用python构建一个卷积神经网络模型

上周末利用python简单实现了一个卷积神经网络，只包含一个卷积层和一个maxpooling层，pooling层后面的多层神经网络采用了softmax形式的输出。实验输入仍然采用MNIST图像使用10个feature map时，卷积和pooling的结果分别如下所示。

部分源码如下：

[python]view plain

• #coding=utf-8

• '''''

• Createdon2014年11月30日

• @author:Wangliaofan

• '''

• importnumpy

• importstruct

• importmatplotlib.pyplotasplt

• importmath

• importrandom

• import

• #test

• defsigmoid(inX):

• if1.0+numpy.exp(-inX)==0.0:

• return999999999.999999999

• return1.0/(1.0+numpy.exp(-inX))

• defdifsigmoid(inX):

• returnsigmoid(inX)*(1.0-sigmoid(inX))

• deftangenth(inX):

• return(1.0*math.exp(inX)-1.0*math.exp(-inX))/(1.0*math.exp(inX)+1.0*math.exp(-inX))

• defcnn_conv(in_image,filter_map,B,type_func='sigmoid'):

• #in_image[num,featuremap,row,col]=>in_image[Irow,Icol]

• #featuresmap[kfilter,row,col]

• #type_func['sigmoid','tangenth']

• #out_feature[kfilter,Irow-row+1,Icol-col+1]

• shape_image=numpy.shape(in_image)#[row,col]

• #print"shape_image",shape_image

• shape_filter=numpy.shape(filter_map)#[kfilter,row,col]

• ifshape_filter[1]>shape_image[0]orshape_filter[2]>shape_image[1]:

• raiseException

• shape_out=(shape_filter[0],shape_image[0]-shape_filter[1]+1,shape_image[1]-shape_filter[2]+1)

• out_feature=numpy.zeros(shape_out)

• k,m,n=numpy.shape(out_feature)

• fork_idxinrange(0,k):

• #rotate180tocalculateconv

• c_filter=numpy.rot90(filter_map[k_idx,:,:],2)

• forr_idxinrange(0,m):

• forc_idxinrange(0,n):

• #conv_temp=numpy.zeros((shape_filter[1],shape_filter[2]))

• conv_temp=numpy.dot(in_image[r_idx:r_idx+shape_filter[1],c_idx:c_idx+shape_filter[2]],c_filter)

• sum_temp=numpy.sum(conv_temp)

• iftype_func=='sigmoid':

• out_feature[k_idx,r_idx,c_idx]=sigmoid(sum_temp+B[k_idx])

• eliftype_func=='tangenth':

• out_feature[k_idx,r_idx,c_idx]=tangenth(sum_temp+B[k_idx])

• else:

• raiseException

• returnout_feature

• defcnn_maxpooling(out_feature,pooling_size=2,type_pooling="max"):

• k,row,col=numpy.shape(out_feature)

• max_index_Matirx=numpy.zeros((k,row,col))

• out_row=int(numpy.floor(row/pooling_size))

• out_col=int(numpy.floor(col/pooling_size))

• out_pooling=numpy.zeros((k,out_row,out_col))

• fork_idxinrange(0,k):

• forr_idxinrange(0,out_row):

• forc_idxinrange(0,out_col):

• temp_matrix=out_feature[k_idx,pooling_size*r_idx:pooling_size*r_idx+pooling_size,pooling_size*c_idx:pooling_size*c_idx+pooling_size]

• out_pooling[k_idx,r_idx,c_idx]=numpy.amax(temp_matrix)

• max_index=numpy.argmax(temp_matrix)

• #printmax_index

• #printmax_index/pooling_size,max_index%pooling_size

• max_index_Matirx[k_idx,pooling_size*r_idx+max_index/pooling_size,pooling_size*c_idx+max_index%pooling_size]=1

• returnout_pooling,max_index_Matirx

• defpoolwithfunc(in_pooling,W,B,type_func='sigmoid'):

• k,row,col=numpy.shape(in_pooling)

• out_pooling=numpy.zeros((k,row,col))

• fork_idxinrange(0,k):

• forr_idxinrange(0,row):

• forc_idxinrange(0,col):

• out_pooling[k_idx,r_idx,c_idx]=sigmoid(W[k_idx]*in_pooling[k_idx,r_idx,c_idx]+B[k_idx])

• returnout_pooling

• #out_featureistheoutputofconv

• defbackErrorfromPoolToConv(theta,max_index_Matirx,out_feature,pooling_size=2):

• k1,row,col=numpy.shape(out_feature)

• error_conv=numpy.zeros((k1,row,col))

• k2,theta_row,theta_col=numpy.shape(theta)

• ifk1!=k2:

• raiseException

• foridx_kinrange(0,k1):

• foridx_rowinrange(0,row):

• foridx_colinrange(0,col):

• error_conv[idx_k,idx_row,idx_col]=

• max_index_Matirx[idx_k,idx_row,idx_col]*

• float(theta[idx_k,idx_row/pooling_size,idx_col/pooling_size])*

• difsigmoid(out_feature[idx_k,idx_row,idx_col])

• returnerror_conv

• defbackErrorfromConvToInput(theta,inputImage):

• k1,row,col=numpy.shape(theta)

• #print"theta",k1,row,col

• i_row,i_col=numpy.shape(inputImage)

• ifrow>i_roworcol>i_col:

• raiseException

• filter_row=i_row-row+1

• filter_col=i_col-col+1

• detaW=numpy.zeros((k1,filter_row,filter_col))

• #thesamewithconvvalidinmatlab

• fork_idxinrange(0,k1):

• foridx_rowinrange(0,filter_row):

• foridx_colinrange(0,filter_col):

• subInputMatrix=inputImage[idx_row:idx_row+row,idx_col:idx_col+col]

• #print"subInputMatrix",numpy.shape(subInputMatrix)

• #rotatetheta180

• #printnumpy.shape(theta)

• theta_rotate=numpy.rot90(theta[k_idx,:,:],2)

• #print"theta_rotate",theta_rotate

• dotMatrix=numpy.dot(subInputMatrix,theta_rotate)

• detaW[k_idx,idx_row,idx_col]=numpy.sum(dotMatrix)

• detaB=numpy.zeros((k1,1))

• fork_idxinrange(0,k1):

• detaB[k_idx]=numpy.sum(theta[k_idx,:,:])

• returndetaW,detaB

• defloadMNISTimage(absFilePathandName,datanum=60000):

• images=open(absFilePathandName,'rb')

• buf=images.read()

• index=0

• magic,numImages,numRows,numColumns=struct.unpack_from('>IIII',buf,index)

• printmagic,numImages,numRows,numColumns

• index+=struct.calcsize('>IIII')

• ifmagic!=2051:

• raiseException

• datasize=int(784*datanum)

• datablock=">"+str(datasize)+"B"

• #nextmatrix=struct.unpack_from('>47040000B',buf,index)

• nextmatrix=struct.unpack_from(datablock,buf,index)

• nextmatrix=numpy.array(nextmatrix)/255.0

• #nextmatrix=nextmatrix.reshape(numImages,numRows,numColumns)

• #nextmatrix=nextmatrix.reshape(datanum,1,numRows*numColumns)

• nextmatrix=nextmatrix.reshape(datanum,1,numRows,numColumns)

• returnnextmatrix,numImages

• defloadMNISTlabels(absFilePathandName,datanum=60000):

• labels=open(absFilePathandName,'rb')

• buf=labels.read()

• index=0

• magic,numLabels=struct.unpack_from('>II',buf,index)

• printmagic,numLabels

• index+=struct.calcsize('>II')

• ifmagic!=2049:

• raiseException

• datablock=">"+str(datanum)+"B"

• #nextmatrix=struct.unpack_from('>60000B',buf,index)

• nextmatrix=struct.unpack_from(datablock,buf,index)

• nextmatrix=numpy.array(nextmatrix)

• returnnextmatrix,numLabels

• defsimpleCNN(numofFilter,filter_size,pooling_size=2,maxIter=1000,imageNum=500):

• decayRate=0.01

• MNISTimage,num1=loadMNISTimage("F:\train-images-idx3-ubyte",imageNum)

• printnum1

• row,col=numpy.shape(MNISTimage[0,0,:,:])

• out_Di=numofFilter*((row-filter_size+1)/pooling_size)*((col-filter_size+1)/pooling_size)

• MLP=BMNN2.MuiltilayerANN(1,[128],out_Di,10,maxIter)

• MLP.setTrainDataNum(imageNum)

• MLP.loadtrainlabel("F:\train-labels-idx1-ubyte")

• MLP.initialweights()

• #MLP.printWeightMatrix()

• rng=numpy.random.RandomState(23455)

• W_shp=(numofFilter,filter_size,filter_size)

• W_bound=numpy.sqrt(numofFilter*filter_size*filter_size)

• W_k=rng.uniform(low=-1.0/W_bound,high=1.0/W_bound,size=W_shp)

• B_shp=(numofFilter,)

• B=numpy.asarray(rng.uniform(low=-.5,high=.5,size=B_shp))

• cIter=0

• whilecIter<maxIter:

• cIter+=1

• ImageNum=random.randint(0,imageNum-1)

• conv_out_map=cnn_conv(MNISTimage[ImageNum,0,:,:],W_k,B,"sigmoid")

• out_pooling,max_index_Matrix=cnn_maxpooling(conv_out_map,2,"max")

• pool_shape=numpy.shape(out_pooling)

• MLP_input=out_pooling.reshape(1,1,out_Di)

• #printnumpy.shape(MLP_input)

• DetaW,DetaB,temperror=MLP.backwardPropogation(MLP_input,ImageNum)

• ifcIter%50==0:

• printcIter,"Temperror:",temperror

• #printnumpy.shape(MLP.Theta[MLP.Nl-2])

• #printnumpy.shape(MLP.Ztemp[0])

• #printnumpy.shape(MLP.weightMatrix[0])

• theta_pool=MLP.Theta[MLP.Nl-2]*MLP.weightMatrix[0].transpose()

• #printnumpy.shape(theta_pool)

• #print"theta_pool",theta_pool

• temp=numpy.zeros((1,1,out_Di))

• temp[0,:,:]=theta_pool

• back_theta_pool=temp.reshape(pool_shape)

• #print"back_theta_pool",numpy.shape(back_theta_pool)

• #print"back_theta_pool",back_theta_pool

• error_conv=backErrorfromPoolToConv(back_theta_pool,max_index_Matrix,conv_out_map,2)

• #print"error_conv",numpy.shape(error_conv)

• #printerror_conv

• conv_DetaW,conv_DetaB=backErrorfromConvToInput(error_conv,MNISTimage[ImageNum,0,:,:])

• #print"W_k",W_k

• #print"conv_DetaW",conv_DetaW

④ 如何利用python实现多元ARIMAX建模

可以在Python中将其实现为一个新的独立函数，名为evaluate_arima_model（），它将时间序列数据集作为输入，以及具有p，d和q参数的元组作为输入。
数据集分为两部分：初始训练数据集为66％，测试数据集为剩余的34％。

⑤ python代码如何应用系统聚类和K-means聚类法进行聚类分析 然后选择变量，建立适当的模型

-Means聚类算法
k-means算法以k为参数，把n个对象分成k个簇，使簇内具有较高的相似度，而簇间的相似度较低。

随机选择k个点作为初始的聚类中心。
对于剩下的点，根据其与聚类中心的距离，将其归入最近的簇。
对每个簇，计算所有点的均值作为新的聚类中心。
重复2，3直到聚类中心不再发生改变

Figure 1

K-means的应用
数据介绍：
现有1999年全国31个省份城镇居民家庭平均每人全年消费性支出的八大主要变量数据，这八大变量分别是：食品、衣着、家庭设备用品及服务、医疗保健、交通和通讯、娱乐教育文化服务、居住以及杂项商品和服务。利用已有数据，对31个省份进行聚类。

实验目的：
通过聚类，了解1999年各个省份的消费水平在国内的情况。

技术路线：
sklearn.cluster.Kmeans

数据实例：

⑥ Python 数学建模极简入门（一）

我们选择的入门书籍是叶其孝和姜启源咐首拦翻译的《数学建模》，原着是Frank R. Giordano和William P. Fox编着的 《A First Course in Mathematical Modeling（Fifth Edition） 》
从名字就能看出这是一本数学建模的入门书籍，由浅入深，很适合数学基础薄弱的人学习。接下来我们将会把这本书中的建模实例用Python3来实现。

初用，没有找到编辑公式的方法，求帮助，公式暂时先用其他软件编辑，采用截图的方式插入文章

首先是最简单的弹簧拉伸模型，学过胡克定律的同学们应该都芹棚知道这是啥，这个炒鸡简单， 不愿看的同学可以跳过。
这是一个研究弹簧伸长与所吊重物质量之间关系的模型。

从图中我们可以明显地看到这是一个线性关系。然后我们就可衡胡以对数据进行线性拟合（非线性拟合也只是用到了不同的函数而已），这里用到了numpy库：

这样，对于这个模型的建模就已经完成了。如果要画出图来是这样的：

当然，这个图用Python3也可以画出来，需要用到matplotlib库，附上matplotlib简单教程：
ywjun的学习笔记, Python图表绘制：matplotlib绘图库入门

⑦ 如何利用 Python 实现 SVM 模型

我先直观地阐述我对SVM的理解，这其中不会涉及数学公式，然后给出Python代码。

SVM是一种二分类模型，处理的数据可以分为三类：

• 线性可分，通过硬间隔最大化，学习线性分类器

• 近似线性可分，通过软间隔最大化，学习线性分类器

• 线性不可分，通过核函数以及软间隔最大化，学习非线性分类器

线性分类器，在平面上对应直线；非线性分类器，在平面上对应曲线。

硬间隔对应于线性可分数据集，可以将所有样本正确分类，也正因为如此，受噪声样本影响很大，不推荐。

软间隔对应于通常情况下的数据集（近似线性可分或线性不可分），允许一些超平面附近的样本被错误分类，从而提升了泛化性能。

如下图：

我们可以看到，当支持向量太少，可能会得到很差的决策边界。如果支持向量太多，就相当于每次都利用整个数据集进行分类，类似KNN。

⑧ python识别怎么训练模型

Python可以用来训练模型升局，一般步骤分为：
1、收集数据：首先需要收集大量的有标记的数据，用于进行训练。
2、准备数据：对获得的数据进行清洗，筛选，分类，去除噪音等处理伍坦，使其能更好的被模型使用。
3、选择模型：根据问题的特性来选择合适的模型，比如分类问题，可以选择逻辑回归，SVM等模型。
4、训练模型：使用收集的数据对模型进行训练，训腔笑桐练的过程中会调节参数，使模型拟合数据最好。
5、评估模型：使用测试数据来评估模型的准确性，然后根据评估结果来决定是否需要调整模型。
6、应用模型：将训练好的模型用于实际应用，比如进行识别，分类，预测等。

⑨ Python可以用来建模么

可以的，目前最火的建模编程语言就是python了，单机的话使用 scikit learn， 集群的话使用 spark MLlib （提供了python 接口，所以也可以用python 写）

⑩ python定义模型

学python的人都知道，python中一切皆是对象，如class生成的对象是对象，class本身也是对象，int是对象，str是对象，dict是对象...。所以，我很好奇，python是怎样实现这些对象的？带着这份好奇，我决定去看看python的源码，毕竟源码才是满足自己好奇心最直接的方法。

在object.h文件中，定义了两种数据结构PyObject和PyVarObject，代码如下：

1 #define PyObject_HEAD 2 Py_ssize_t ob_refcnt; 3 struct _typeobject *ob_type; 4 5 #define PyObject_VAR_HEAD 6 PyObject_HEAD 7 Py_ssize_t ob_size; 8 9 typedef struct _object {10 PyObject_HEAD11 } PyObject;12 13 typedef struct {14 PyObject_VAR_HEAD15 } PyVarObject;

这两种数据结构分别对应python的两种对象：固定长度对象和可变长度对象。python中的所有对象都属于这两种对象中的一种，如int，float是固定长度对象，list，str，dict是可变长度对象。从上面两种对象数据结构定义来看，可变长度对象和固定长度对象的头都是PyObject结构体，也就是说python中所有对象的开头都包含这个结构体，并且可以用PyObject *指针来访问任何对象，这种访问对象的方法在python的源码中随处可见。PyObject结构体包含两个成员，ob_refcnt和ob_type指针。ob_refcnt用来表示对象被引用的次数，当ob_refcnt == 0时，这个对象会被立即销毁；ob_type指针指向了一个_typeobject类型的结构体，表示对象所属的类型，也就是生成该对象的类型，这其实很类似于面向对象中类与实例的关系，PyObject是某个类的实例，ob_type表示这个类。但与面向对象不同的是，ob_type本身也是个对象，我们来看下_typeobject的定义：

1 typedef struct _typeobject { 2 PyObject_VAR_HEAD 3 const char *tp_name; /*类型名 */ 4 Py_ssize_t tp_basicsize, tp_itemsize; /* 实例化对象的大小 */ 5 6 /* 标准方法 */ 7 8 destructor tp_dealloc; 9 printfunc tp_print;10 getattrfunc tp_getattr;11 setattrfunc tp_setattr;12 cmpfunc tp_compare;13 reprfunc tp_repr;14 15 /* 标准类（数值类，列表类，dict类）方法*/16 17 PyNumberMethods *tp_as_number;18 PySequenceMethods *tp_as_sequence;19 PyMappingMethods *tp_as_mapping;20 21 /* 其它标准方法*/22 23 hashfunc tp_hash;24 ternaryfunc tp_call;25 reprfunc tp_str;26 getattrofunc tp_getattro;27 setattrofunc tp_setattro;28 ...
29 } PyTypeObject;

从上面定义来看，_typeobject的开头也包含了PyObject结构体，所以它也是一个对象，既然它也是一个对象，那么按照面向对象的理解，它又是谁来生成的呢？答案是所有PyTypeObject对象都是通过PyType_Type来生成的，包括PyType_Type本身，因为PyType_Type也是PyTypeObject对象，有点绕。PyType_Type的定义是通过将PyType_Type声明为全局静态变量实现的，具体如下：

1 PyTypeObject PyType_Type = { 2 PyVarObject_HEAD_INIT(&PyType_Type, 0) 3 "type", /* tp_name */ 4 sizeof(PyHeapTypeObject), /* tp_basicsize */ 5 sizeof(PyMemberDef), /* tp_itemsize */ 6 (destructor)type_dealloc, /* tp_dealloc */ 7 0, /* tp_print */ 8 0, /* tp_getattr */ 9 0, /* tp_setattr */10 0, /* tp_compare */11 (reprfunc)type_repr, /* tp_repr */12 0, /* tp_as_number */13 0, /* tp_as_sequence */14 0, /* tp_as_mapping */15 (hashfunc)_Py_HashPointer, /* tp_hash */16 (ternaryfunc)type_call, /* tp_call */17 0, /* tp_str */18 (getattrofunc)type_getattro, /* tp_getattro */19 (setattrofunc)type_setattro, /* tp_setattro */20 0, /* tp_as_buffer */21 ...22 }

从PyType_Type定义来看，ob_type被初始化为它自己的地址，所以PyType_Type的类型就是自己。从python源码实现来看，所有PyTypeObject的ob_type都会指向PyType_Type对象，所以PyType_Type是所有类型的类型，称之为元类。python中定义了很多内建的类型对象，如PyInt_Type （int类型），PyStr_Type （str类型），PyDict_Type（dict类型） 类型对象，下面看下PyInt_Type类型的定义：

1 PyTypeObject PyInt_Type = { 2 PyVarObject_HEAD_INIT(&PyType_Type, 0) 3 "int", 4 sizeof(PyIntObject), 5 0, 6 (destructor)int_dealloc, /* tp_dealloc */ 7 (printfunc)int_print, /* tp_print */ 8 0, /* tp_getattr */ 9 0, /* tp_setattr */10 (cmpfunc)int_compare, /* tp_compare */11 (reprfunc)int_to_decimal_string, /* tp_repr */12 &int_as_number, /* tp_as_number */13 0, /* tp_as_sequence */14 0, /* tp_as_mapping */15 (hashfunc)int_hash, /* tp_hash */16 0, /* tp_call */17 ...18 };

从PyInt_Type定义来看，它主要包含了int数据类型相关的方法。PyInt_Type类型对象的初始化和PyType_Type类型类似，PyInt_Type类型的定义也是通过全局静态变量的方式实现的，除了PyInt_Type了下，所有python内建类型都是以这种方式定义的。这些类型产生的对象都会共享这些类型对象，包括这些类型定义的方法。

在python中，怎样查看对象的类型呢？有两种方法，一种是直接type：

1 >>> x = 12 >>> type(x)3 <type 'int'>

另一种是通过对象的__class__属性：

1 >>> x = 12 >>> type(x)3 <type 'int'>4 >>> x.__class__5 <type 'int'>

现在来看看int，str，dict这些类型的类型：1 <type 'int'>2 >>> type(int)3 <type 'type'>4 >>> type(str)5 <type 'type'>6 >>> type(dict)7 <type 'type'>8 >>> type(type)9 <type 'type'>从这个输出来看，int，str，dict这些类型的类型都是type，这也印证了前面说的，所有类型都是通过元类type生成的。