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生成的。