插值函數python

『壹』 誰有拉格朗日插值法的python代碼啊！急用啊！謝謝啦！

您好，#include<stdio.h>
#include<stdlib.h>
#include<iostream.h>
typedef struct data
{
float x;
float y;
}Data;//變數x和函數值y的結構
Data d[20];//最多二十組數據
float f(int s,int t)//牛頓插值法，用以返回插商
{
if(t==s+1)
return (d[t].y-d[s].y)/(d[t].x-d[s].x);
else
return (f(s+1,t)-f(s,t-1))/(d[t].x-d[s].x);
}
float Newton(float x,int count)
{
int n;
while(1)
{
cout<<"請輸入n值(即n次插值):";//獲得插值次數
cin>>n;
if(n<=count-1)// 插值次數不得大於count－1次
break;
else
system("cls");
}
//初始化t，y，yt。
float t=1.0;
float y=d[0].y;
float yt=0.0;
//計算y值
for(int j=1;j<=n;j++)
{
t=(x-d[j-1].x)*t;
yt=f(0,j)*t;
//cout<<f(0,j)<<endl;
y=y+yt;
}
return y;
}
float lagrange(float x,int count)
{
float y=0.0;
for(int k=0;k<count;k++)//這兒默認為count－1次插值
{
float p=1.0;//初始化p
for(int j=0;j<count;j++)
{//計算p的值
if(k==j)continue;//判斷是否為同一個數
p=p*(x-d[j].x)/(d[k].x-d[j].x);
}
y=y+p*d[k].y;//求和
}
return y;//返回y的值
}
void main()
{
float x,y;
int count;
while(1)
{
cout<<"請輸入x[i],y[i]的組數，不得超過20組:";//要求用戶輸入數據組數
cin>>count;
if(count<=20)
break;//檢查輸入的是否合法
system("cls");
}
//獲得各組數據
for(int i=0;i<count;i++)
{
cout<<"請輸入第"<<i+1<<"組x的值:";
cin>>d[i].x;
cout<<"請輸入第"<<i+1<<"組y的值:";
cin>>d[i].y;
system("cls");
}
cout<<"請輸入x的值:";//獲得變數x的值
cin>>x;
while(1)
{
int choice=3;
cout<<"請您選擇使用哪種插值法計算："<<endl;
cout<<" (0):退出"<<endl;
cout<<" (1):Lagrange"<<endl;
cout<<" (2):Newton"<<endl;
cout<<"輸入你的選擇：";
cin>>choice;//取得用戶的選擇項
if(choice==2)
{
cout<<"你選擇了牛頓插值計算方法，其結果為：";
y=Newton(x,count);break;//調用相應的處理函數
}
if(choice==1)
{
cout<<"你選擇了拉格朗日插值計算方法，其結果為：";
y=lagrange(x,count);break;//調用相應的處理函數
}
if(choice==0)
break;
system("cls");
cout<<"輸入錯誤!!!!"<<endl;
}
cout<<x<<" , "<<y<<endl;//輸出最終結果

}

『貳』 python可否用自定義函數對數據進行插值

直接定義a=True/False就行，示例代碼：
#定義布爾值類型參數a,b，值分別為True,False
a=True
b=False
print a,b
print type(a),type(b)
>>>
True False
<type 'bool'> <type 'bool'>
Python中的布爾類型：
Python的布爾類型有兩個值：True和False（注意大小寫要區分）

『叄』 python 怎麼畫與其他方法進行比較的ROC曲線

使用sklearn的一系列方法後可以很方便的繪制處ROC曲線，這里簡單實現以下。
主要是利用混淆矩陣中的知識作為繪制的數據（如果不是很懂可以先看看這里的基礎）：

tpr(Ture Positive Rate)：真陽率 圖像的縱坐標

fpr(False Positive Rate)：陽率（偽陽率） 圖像的橫坐標

mean_tpr：累計真陽率求平均值

mean_fpr：累計陽率求平均值

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm, datasets
from sklearn.metrics import roc_curve, auc
from sklearn.model_selection import StratifiedKFold

iris = datasets.load_iris()
X = iris.data
y = iris.target
X, y = X[y != 2], y[y != 2] # 去掉了label為2，label只能二分，才可以。
n_samples, n_features = X.shape
# 增加雜訊特徵
random_state = np.random.RandomState(0)
X = np.c_[X, random_state.randn(n_samples, 200 * n_features)]

cv = StratifiedKFold(n_splits=6) #導入該模型，後面將數據劃分6份
classifier = svm.SVC(kernel='linear', probability=True,random_state=random_state) # SVC模型 可以換作AdaBoost模型試試

# 畫平均ROC曲線的兩個參數
mean_tpr = 0.0 # 用來記錄畫平均ROC曲線的信息
mean_fpr = np.linspace(0, 1, 100)
cnt = 0
for i, (train, test) in enumerate(cv.split(X,y)): #利用模型劃分數據集和目標變數 為一一對應的下標
cnt +=1
probas_ = classifier.fit(X[train], y[train]).predict_proba(X[test]) # 訓練模型後預測每條樣本得到兩種結果的概率
fpr, tpr, thresholds = roc_curve(y[test], probas_[:, 1]) # 該函數得到偽正例、真正例、閾值，這里只使用前兩個

mean_tpr += np.interp(mean_fpr, fpr, tpr) # 插值函數 interp(x坐標,每次x增加距離,y坐標) 累計每次循環的總值後面求平均值
mean_tpr[0] = 0.0 # 將第一個真正例=0 以0為起點

roc_auc = auc(fpr, tpr) # 求auc面積
plt.plot(fpr, tpr, lw=1, label='ROC fold {0:.2f} (area = {1:.2f})'.format(i, roc_auc)) # 畫出當前分割數據的ROC曲線

plt.plot([0, 1], [0, 1], '--', color=(0.6, 0.6, 0.6), label='Luck') # 畫對角線

mean_tpr /= cnt # 求數組的平均值
mean_tpr[-1] = 1.0 # 坐標最後一個點為（1,1） 以1為終點
mean_auc = auc(mean_fpr, mean_tpr)

plt.plot(mean_fpr, mean_tpr, 'k--',label='Mean ROC (area = {0:.2f})'.format(mean_auc), lw=2)

plt.xlim([-0.05, 1.05]) # 設置x、y軸的上下限，設置寬一點，以免和邊緣重合，可以更好的觀察圖像的整體
plt.ylim([-0.05, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate') # 可以使用中文，但需要導入一些庫即字體
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.show()

『肆』 如何通過python實現三次樣條插值

spline函數可以實現三次樣條插值 x = 0:10; y = sin(x); xx = 0:.25:10; yy = spline(x,y,xx); plot(x,y,'o',xx,yy) 另外fnplt csapi這兩個函數也是三次樣條插值函數，具體你可以help一下！

『伍』 python怎樣對矩陣進行插值

首先需要創建數組才能對其進行其它操作。
我們可以通過給array函數傳遞Python的序列對象創建數組，如果傳遞的是多層嵌套的序列，將創建多維數組(下例中的變數c):
>>> a = np.array([1, 2, 3, 4])
>>> b = np.array((5, 6, 7, 8))
>>> c = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])
>>> b
array([5, 6, 7, 8])
>>> c
array([[1, 2, 3, 4],
[4, 5, 6, 7],
[7, 8, 9, 10]])
>>> c.dtype
dtype('int32')

數組的大小可以通過其shape屬性獲得：
>>> a.shape
(4,)
>>> c.shape

『陸』 python 線性插值

不知道有沒有，可能python數學相關的庫里會有吧

不過你寫的也不對啊，取3個值，應該是4均分。

>>>defjunfen(start,end,num):
	k=(end-start)/(num+1)
	returnset([start+item*kforiteminrange(1,num+1)])

『柒』 雙線性插值法原理 python實現

碼字不易，如果此文對你有所幫助，請幫忙點贊，感謝！

一. 雙線性插值法原理：

        ① 何為線性插值？

        插值就是在兩個數之間插入一個數，線性插值原理圖如下：

        ② 各種插值法：

        插值法的第一步都是相同的，計算目標圖（dstImage）的坐標點對應原圖（srcImage）中哪個坐標點來填充，計算公式為：

        srcX = dstX * (srcWidth/dstWidth)

        srcY = dstY * (srcHeight/dstHeight)

        (dstX,dstY)表示目標圖像的某個坐標點，(srcX,srcY)表示與之對應的原圖像的坐標點。srcWidth/dstWidth 和 srcHeight/dstHeight 分別表示寬和高的放縮比。

        那麼問題來了，通過這個公式算出來的 srcX, scrY 有可能是小數，但是原圖像坐標點是不存在小數的，都是整數，得想辦法把它轉換成整數才行。

        不同插值法的區別就體現在 srcX, scrY 是小數時，怎麼將其變成整數去取原圖像中的像素值。

        最近鄰插值（Nearest-neighborInterpolation）：看名字就很直白，四捨五入選取最接近的整數。這樣的做法會導致像素變化不連續，在目標圖像中產生鋸齒邊緣。

        雙線性插值（Bilinear Interpolation）：雙線性就是利用與坐標軸平行的兩條直線去把小數坐標分解到相鄰的四個整數坐標點。權重與距離成反比。

        雙三次插值（Bicubic Interpolation）：與雙線性插值類似，只不過用了相鄰的16個點。但是需要注意的是，前面兩種方法能保證兩個方向的坐標權重和為1，但是雙三次插值不能保證這點，所以可能出現像素值越界的情況，需要截斷。

        ③ 雙線性插值演算法原理

        假如我們想得到未知函數 f 在點 P = (x, y) 的值，假設我們已知函數 f 在 Q11 = (x1, y1)、Q12 = (x1, y2), Q21 = (x2, y1) 以及 Q22 = (x2, y2) 四個點的值。最常見的情況，f就是一個像素點的像素值。首先在 x 方向進行線性插值，然後再在 y 方向上進行線性插值，最終得到雙線性插值的結果。

    ④ 舉例說明

二. python實現灰度圖像雙線性插值演算法：

灰度圖像雙線性插值放大縮小

import numpy as np

import math

import cv2

def double_linear(input_signal, zoom_multiples):

    '''

    雙線性插值

    :param input_signal: 輸入圖像

    :param zoom_multiples: 放大倍數

    :return: 雙線性插值後的圖像

    '''

    input_signal_cp = np.(input_signal)  # 輸入圖像的副本

    input_row, input_col = input_signal_cp.shape # 輸入圖像的尺寸（行、列）

    # 輸出圖像的尺寸

    output_row = int(input_row * zoom_multiples)

    output_col = int(input_col * zoom_multiples)

    output_signal = np.zeros((output_row, output_col)) # 輸出圖片

    for i in range(output_row):

        for j in range(output_col):

            # 輸出圖片中坐標 （i，j）對應至輸入圖片中的最近的四個點點（x1，y1）（x2, y2），（x3， y3），(x4，y4)的均值

            temp_x = i / output_row * input_row

            temp_y = j / output_col * input_col

            x1 = int(temp_x)

            y1 = int(temp_y)

            x2 = x1

            y2 = y1 + 1

            x3 = x1 + 1

            y3 = y1

            x4 = x1 + 1

            y4 = y1 + 1

            u = temp_x - x1

            v = temp_y - y1

            # 防止越界

            if x4 >= input_row:

                x4 = input_row - 1

                x2 = x4

                x1 = x4 - 1

                x3 = x4 - 1

            if y4 >= input_col:

                y4 = input_col - 1

                y3 = y4

                y1 = y4 - 1

                y2 = y4 - 1

            # 插值

            output_signal[i, j] = (1-u)*(1-v)*int(input_signal_cp[x1, y1]) + (1-u)*v*int(input_signal_cp[x2, y2]) + u*(1-v)*int(input_signal_cp[x3, y3]) + u*v*int(input_signal_cp[x4, y4])

    return output_signal

# Read image

img = cv2.imread("../paojie_g.jpg",0).astype(np.float)

out = double_linear(img,2).astype(np.uint8)

# Save result

cv2.imshow("result", out)

cv2.imwrite("out.jpg", out)

cv2.waitKey(0)

cv2.destroyAllWindows()

三. 灰度圖像雙線性插值實驗結果：

四. 彩色圖像雙線性插值python實現

def BiLinear_interpolation(img,dstH,dstW):

    scrH,scrW,_=img.shape

    img=np.pad(img,((0,1),(0,1),(0,0)),'constant')

    retimg=np.zeros((dstH,dstW,3),dtype=np.uint8)

    for i in range(dstH-1):

        for j in range(dstW-1):

            scrx=(i+1)*(scrH/dstH)

            scry=(j+1)*(scrW/dstW)

            x=math.floor(scrx)

            y=math.floor(scry)

            u=scrx-x

            v=scry-y

            retimg[i,j]=(1-u)*(1-v)*img[x,y]+u*(1-v)*img[x+1,y]+(1-u)*v*img[x,y+1]+u*v*img[x+1,y+1]

    return retimg

im_path='../paojie.jpg'

image=np.array(Image.open(im_path))

image2=BiLinear_interpolation(image,image.shape[0]*2,image.shape[1]*2)

image2=Image.fromarray(image2.astype('uint8')).convert('RGB')

image2.save('3.png')

五. 彩色圖像雙線性插值實驗結果：

六. 最近鄰插值演算法和雙三次插值演算法可參考：

        ① 最近鄰插值演算法： https://www.cnblogs.com/wojianxin/p/12515061.html

         https://blog.csdn.net/Ibelievesunshine/article/details/104936006

        ② 雙三次插值演算法： https://www.cnblogs.com/wojianxin/p/12516762.html

        https://blog.csdn.net/Ibelievesunshine/article/details/104942406

七. 參考內容：

         https://www.cnblogs.com/wojianxin/p/12515061.html

         https://blog.csdn.net/Ibelievesunshine/article/details/104939936

『捌』 python 拉格朗日插值 不能超過多少個值

拉格朗日插值Python代碼實現

1. 數學原理

對某個多項式函數有已知的k+1個點，假設任意兩個不同的都互不相同，那麼應用拉格朗日插值公式所得到的拉格朗日插值多項式為：

直接編寫程序，可以直接插值，並且得到對應的函數值。但是不能得到系數，也不能對其進行各項運算。

上述代碼中，h(x,y,a)就是插值函數，直接調用就行。參數說明如下：

• x,y分別是對應點的x值和y值。具體詳解下解釋。

• a為想要取得的函數的值。

事實上，最簡單的拉格朗日插值就是兩點式得到的一條直線。

例如：

p點(1,0)q點(0,2)

這兩個點決定了一條直線，所以當x=2的時候，y應該是-2

該代碼就是利用這兩個點插值，然後a作為x=2調用函數驗證的。

3. 引用庫

3.1 庫的安裝

主要依賴與 scipy。官方網站見：https://www.scipy.org/install.html

安裝的方法很簡單，就是使用pip install scipy 如果失敗，則將whl文件下載到本地再利用命令進行安裝。

可能如果沒有安裝numpy

3.2 庫的使用

from scipy.interplotate import lagrange

直接調用lagrange(x,y)這個函數即可，返回 一個對象。

參數x,y分別是對應各個點的x值和y值。

例如：(1,2) (3,5) (5,9)這三個點，作為函數輸入應該這么寫：

x＝[1,3,5]

y =[2, 5, 9]

a=lagrange(x,y)

直接輸出該對象，就能看到插值的函數。

利用該對象，能得到很多特性。具體參見：https://docs.scipy.org/doc/numpy-1.12.0/reference/generated/numpy.poly1d.html

• a.order得到階

• a[]得到系數

• a()得到對應函數值

• 此外可以對其進行加減乘除運算

3.3 代碼實現

1234567
fromscipy.interpolateimportlagrangex=[1,2,3,4,7]y=[5,7,10,3,9]a=lagrange(x,y)print(a)print(a(1),a(2),a(3))print(a[0],a[2],a[3])

結果是：

<class 'numpy.lib.polynomial.poly1d'> 4
4 3 2
0.5472 x - 7.306 x + 30.65 x - 47.03 x + 28.13
5.0 7.0 10.0
28.1333333333 30.6527777778 -7.30555555556

解釋：

<class 'numpy.lib.polynomial.poly1d'> 4

這一行是輸出a的類型，以及最高次冪。

4 3 2
0.5472 x - 7.306 x + 30.65 x - 47.03 x + 28.13

第二行和第三行就是插值的結果，顯示出的函數。

第二行的數字是對應下午的x的冪，如果對應不齊，則是排版問題。

5.0 7.0 10.0

第四行是代入的x值，得到的結果。

也就是說，用小括弧f(x)的這種形式，可以直接得到計算結果。

28.1333333333 30.6527777778 -7.30555555556

『玖』 想用python來求解牛頓插值問題，編了一段程序，其中有些錯誤看不出來，懇請大佬指出錯誤，代碼如下

importmatplotlib.pyplotasplt
frompylabimportmpl
importmath
"""
牛頓插值法
插值的函數表為
xi-28.9,-12.2,4.4,21.1,37.8
f(xi)2.2,3.9,6.6,10.3,15.4
"""
x=[-28.9,-12.2,4.4,21.1,37.8]
y=[2.2,3.9,6.6,10.3,15.4]

"""計算4次差商的值"""
defFour_time_difference_quotient(x,y):
i=0#i記錄計算差商的次數
quotient=[0,0,0,0,0,]
whilei<4:
j=4
whilej>i:
ifi==0:
quotient[j]=((y[j]-y[j-1])/(x[j]-x[j-1]))
else:
quotient[j]=(quotient[j]-quotient[j-1])/(x[j]-x[j-1-i])
j-=1
i+=1
returnquotient;

deffunction(data):
returnx[0]+parameters[1]*(data-0.4)+parameters[2]*(data-0.4)*(data-0.55)+
parameters[3]*(data-0.4)*(data-0.55)*(data-0.65)
+parameters[4]*(data-0.4)*(data-0.55)*(data-0.80)

"""計算插值多項式的值和相應的誤差"""
defcalculate_data(x,parameters):
returnData=[];
fordatainx:
returnData.append(function(data))
returnreturnData

"""畫函數的圖像
newData為曲線擬合後的曲線
"""

defdraw(newData):
plt.scatter(x,y,label="離散數據",color="red")
plt.plot(x,newData,label="牛頓插值擬合曲線",color="black")
plt.scatter(0.596,function(0.596),label="預測函數點",color="blue")
plt.title("牛頓插值法")
mpl.rcParams['font.sans-serif']=['SimHei']
mpl.rcParams['axes.unicode_minus']=False
plt.legend(loc="upperleft")
plt.show()

parameters=Four_time_difference_quotient(x,y)
yuanzu=calculate_data(x,parameters)
draw(yuanzu)

『拾』 python線性插值解析

在缺失值填補上如果用前後的均值填補中間的均值， 比如，0，空，1， 我們希望中間填充0.5；或者0，空，空，1，我們希望中間填充0.33，0.67這樣。

可以用pandas的函數進行填充，因為這個就是線性插值法

df..interpolate()

dd=pd.DataFrame(data=[0,np.nan,np.nan,1])

dd.interpolate()

補充知識：線性插值公式簡單推導

以上這篇python線性插值解析就是我分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持。