Yes you can use scipy.interpolate.griddata and masked array and you can choose the type of interpolation that you prefer using the argument method usually 'cubic' do an excellent job: import numpy as np
from scipy import interpolate
#Let's create some random data
array = np.random.random_integers(0,10,(10,10)).astype(float)
#values grater then 7 goes to np.nan
array[array>7] = np.nan
That looks something like this using plt.imshow(array,interpolation='nearest') : x = np.arange(0, array.shape[1])
y = np.arange(0, array.shape[0])
#mask invalid values
array = np.ma.masked_invalid(array)
xx, yy = np.meshgrid(x, y)
#get only the valid values
x1 = xx[~array.mask]
y1 = yy[~array.mask]
newarr = array[~array.mask]
GD1 = interpolate.griddata((x1, y1), newarr.ravel(),
(xx, yy),
method='cubic')
This is the final result: Look that if the nan values are in the edges and are surrounded by nan values thay can't be interpolated and are kept
nan . You can change it using the fill_value argument. How would this work if there is a 3x3 region of NaN-values, would you get sensible data for the middle point?It depends on your kind of data, you have to perform some test. You could for instance mask on purpose some good data try different kind of interpolation e.g. cubic, linear etc. etc. with the array with the masked values and calculuate the difference between the values interpolated and the original values that
you had masked before and see which method return you the minor difference. You can use something like this: reference = array[3:6,3:6].copy()
array[3:6,3:6] = np.nan
method = ['linear', 'nearest', 'cubic']
for i in method:
GD1 = interpolate.griddata((x1, y1), newarr.ravel(),
(xx, yy),
method=i)
meandifference = np.mean(np.abs(reference - GD1[3:6,3:6]))
print ' %s interpolation difference: %s' %(i,meandifference )
That gives something like this: linear interpolation difference: 4.88888888889
nearest interpolation difference: 4.11111111111
cubic interpolation difference: 5.99400137377
Of course this is for random numbers so it's normal that the result may vary a lot. So the best thing to do is to test on "on purpose masked" piece of your dataset and see what happen. Tôi đã nghĩ ra một giải pháp khá thanh lịch (IMHO), vì vậy tôi không thể cưỡng lại việc đăng nó: from bisect import bisect_left
class Interpolate(object):
def __init__(self, x_list, y_list):
if any(y - x <= 0 for x, y in zip(x_list, x_list[1:])):
raise ValueError("x_list must be in strictly ascending order!")
x_list = self.x_list = map(float, x_list)
y_list = self.y_list = map(float, y_list)
intervals = zip(x_list, x_list[1:], y_list, y_list[1:])
self.slopes = [(y2 - y1)/(x2 - x1) for x1, x2, y1, y2 in intervals]
def __getitem__(self, x):
i = bisect_left(self.x_list, x) - 1
return self.y_list[i] + self.slopes[i] * (x - self.x_list[i])
Tôi bản đồ để float để phân chia số nguyên (python <= 2.7) sẽ không kick vào và điều hủy hoại nếu x1 , x2 , y1 và y2 là tất cả các số nguyên cho một số iterval. Trong __getitem__ thực tế, tôi đang tận dụng lợi thế của việc self.x_list được sắp xếp theo thứ tự tăng dần bằng cách sử dụng bisect_left để (rất) nhanh chóng tìm ra chỉ mục của phần tử lớn
nhất nhỏ hơn x in self.x_list . Sử dụng lớp như thế này: i = Interpolate([1, 2.5, 3.4, 5.8, 6], [2, 4, 5.8, 4.3, 4])
# Get the interpolated value at x = 4:
y = i[4]
Tôi đã không giải quyết các điều kiện biên giới ở đây, vì đơn giản. Như nó là, i[x] for x < 1 sẽ hoạt động như thể dòng từ (2,5, 4) đến (1, 2) đã được kéo dài đến trừ vô cùng, trong khi i[x] cho x == 1 hoặc x > 6 sẽ tăng một IndexError . Tốt hơn là nên tăng IndexError trong mọi trường hợp, nhưng điều này được để lại như một bài tập cho người đọc. :) 18 hữu ích 2 bình luận
chia sẻ Giải pháp hợp lý là gì phần lớn phụ thuộc vào câu hỏi bạn đang cố gắng trả lời với các pixel được nội suy - báo trước: ngoại suy trên dữ liệu bị thiếu có thể dẫn đến câu trả lời rất sai lầm! Chức năng cơ sở xuyên tâm Nội suy / Làm mịn hạt nhân Về các giải pháp thực tế có sẵn trong Python, một cách để điền các pixel đó vào sẽ là sử dụng cách triển khai nội suy Hàm cơ sở hướng tâm của Scipy (xem tại đây ) nhằm mục đích làm mịn / nội suy dữ
liệu phân tán. Với ma trận của bạn M và các mảng tọa độ 1D bên dưới r và c (như vậy M.shape == (r.size, c.size) ), trong đó các mục bị thiếu của M được đặt thành nan , điều này dường như hoạt động khá tốt với hạt nhân RBF tuyến tính như sau: import numpy as np
import scipy.interpolate as interpolate
with open('measurement.txt') as fh:
M = np.vstack(map(float, r.split(' ')) for r in fh.read().splitlines())
r = np.linspace(0, 1, M.shape[0])
c = np.linspace(0, 1, M.shape[1])
rr, cc = np.meshgrid(r, c)
vals = ~np.isnan(M)
f = interpolate.Rbf(rr[vals], cc[vals], M[vals], function='linear')
interpolated = f(rr, cc)
Điều này dẫn đến nội suy sau của dữ liệu mà bạn đã liên kết ở trên, mặc dù có vẻ hợp lý, nhưng nó làm nổi bật tỷ lệ mẫu bị thiếu so với dữ liệu thực là bất lợi như thế nào: Hồi quy quy trình Gaussian / Kriging Nội suy Kriging có sẵn thông qua triển khai Hồi quy quy trình Gaussian (bản thân nó dựa trên hộp công cụ DACE Kriging cho Matlab) trong thư viện scikit-learning. Điều này có thể được gọi như sau: from sklearn.gaussian_process import GaussianProcess
gp = GaussianProcess(theta0=0.1, thetaL=.001, thetaU=1., nugget=0.01)
gp.fit(X=np.column_stack([rr[vals],cc[vals]]), y=M[vals])
rr_cc_as_cols = np.column_stack([rr.flatten(), cc.flatten()])
interpolated = gp.predict(rr_cc_as_cols).reshape(M.shape)
Điều này tạo ra một phép nội suy rất giống với ví dụ Hàm cơ sở Radial ở trên.
Trong cả hai trường hợp, có rất nhiều tham số để khám phá - sự lựa chọn của những tham số này phần lớn phụ thuộc vào các giả định mà bạn có thể đưa ra về dữ liệu. (Một ưu điểm của hạt nhân tuyến tính được sử dụng trong ví dụ RBF ở trên là nó không có tham số miễn phí) Inpainting Cuối cùng sang một bên, một giải pháp hoàn toàn có động cơ trực quan sẽ là sử dụng chức năng inpainting của OpenCV , mặc dù điều này giả định mảng 8bit (0 - 255) và không có cách giải thích
toán học đơn giản. 46 hữu ích 0 bình luận chia sẻ Tôi đã nghĩ ra một giải pháp khá thanh lịch (IMHO), vì vậy tôi không thể cưỡng lại việc đăng nó: from bisect import bisect_left
class Interpolate(object):
def __init__(self, x_list, y_list):
if any(y - x <= 0 for x, y in zip(x_list, x_list[1:])):
raise ValueError("x_list must be in strictly ascending order!")
x_list = self.x_list = map(float, x_list)
y_list = self.y_list = map(float, y_list)
intervals = zip(x_list, x_list[1:], y_list, y_list[1:])
self.slopes = [(y2 - y1)/(x2 - x1) for x1, x2, y1, y2 in intervals]
def __getitem__(self, x):
i = bisect_left(self.x_list, x) - 1
return self.y_list[i] + self.slopes[i] * (x - self.x_list[i])
Tôi bản đồ để float để phân chia số nguyên (python <= 2.7) sẽ không kick vào và điều hủy hoại nếu x1 , x2 , y1 và y2 là tất cả các số nguyên cho một số iterval. Trong __getitem__ thực tế, tôi đang tận dụng lợi thế của việc self.x_list được sắp xếp theo thứ
tự tăng dần bằng cách sử dụng bisect_left để (rất) nhanh chóng tìm ra chỉ mục của phần tử lớn nhất nhỏ hơn x in self.x_list . Sử dụng lớp như thế này: i = Interpolate([1, 2.5, 3.4, 5.8, 6], [2, 4, 5.8, 4.3, 4])
# Get the interpolated value at x = 4:
y = i[4]
Tôi đã không giải quyết các điều kiện biên giới ở đây, vì đơn giản. Như nó là, i[x] for x < 1 sẽ hoạt động như thể dòng từ (2,5, 4) đến (1, 2) đã được kéo dài đến trừ vô cùng, trong khi i[x] cho x == 1 hoặc x > 6 sẽ tăng một IndexError . Tốt hơn là nên tăng IndexError trong mọi trường hợp, nhưng điều này được để lại như
một bài tập cho người đọc. :) 18 hữu ích 2 bình luận chia sẻ Giải pháp hợp lý là gì phần lớn phụ thuộc vào câu hỏi bạn đang cố gắng trả lời với các pixel được nội suy - báo trước: ngoại suy trên dữ liệu bị thiếu có thể dẫn đến câu trả lời rất sai lầm! Chức năng cơ sở xuyên tâm Nội suy / Làm mịn hạt nhân Về các giải pháp thực tế có sẵn trong Python, một cách để điền các pixel đó vào sẽ là sử dụng cách triển khai
nội suy Hàm cơ sở hướng tâm của Scipy (xem tại đây ) nhằm mục đích làm mịn / nội suy dữ liệu phân tán. Với ma trận của bạn M và các mảng tọa độ 1D bên dưới r và c (như vậy M.shape == (r.size, c.size) ), trong đó các mục bị thiếu của M được đặt thành nan , điều này dường như hoạt động khá tốt với hạt nhân RBF tuyến tính như sau: import numpy as np
import scipy.interpolate as interpolate
with open('measurement.txt') as fh:
M = np.vstack(map(float, r.split(' ')) for r in fh.read().splitlines())
r = np.linspace(0, 1, M.shape[0])
c = np.linspace(0, 1, M.shape[1])
rr, cc = np.meshgrid(r, c)
vals = ~np.isnan(M)
f = interpolate.Rbf(rr[vals], cc[vals], M[vals], function='linear')
interpolated = f(rr, cc)
Điều này dẫn đến nội suy sau của dữ liệu mà bạn đã liên kết ở trên, mặc dù có vẻ hợp lý, nhưng nó làm nổi bật tỷ lệ mẫu bị thiếu so với dữ liệu thực
là bất lợi như thế nào: Hồi quy quy trình Gaussian / Kriging Nội suy Kriging có sẵn thông qua triển khai Hồi quy quy trình Gaussian (bản thân nó dựa trên hộp công cụ DACE Kriging cho Matlab) trong thư viện scikit-learning. Điều này có thể được gọi như sau: from sklearn.gaussian_process import GaussianProcess
gp = GaussianProcess(theta0=0.1, thetaL=.001, thetaU=1., nugget=0.01)
gp.fit(X=np.column_stack([rr[vals],cc[vals]]), y=M[vals])
rr_cc_as_cols = np.column_stack([rr.flatten(), cc.flatten()])
interpolated = gp.predict(rr_cc_as_cols).reshape(M.shape)
Điều này tạo ra một phép nội suy rất giống với ví dụ Hàm cơ sở Radial ở trên. Trong cả hai trường hợp, có rất nhiều tham số để khám phá - sự lựa chọn của những tham số này phần lớn phụ thuộc vào các
giả định mà bạn có thể đưa ra về dữ liệu. (Một ưu điểm của hạt nhân tuyến tính được sử dụng trong ví dụ RBF ở trên là nó không có tham số miễn phí) Inpainting Cuối cùng sang một bên, một giải pháp hoàn toàn có động cơ trực quan sẽ là sử dụng chức năng inpainting của OpenCV , mặc dù điều này giả định mảng 8bit (0 - 255) và không có cách giải thích toán học đơn giản. 46 hữu ích 0 bình luận chia sẻ Tôi đã nghĩ ra
một giải pháp khá thanh lịch (IMHO), vì vậy tôi không thể cưỡng lại việc đăng nó: from bisect import bisect_left
class Interpolate(object):
def __init__(self, x_list, y_list):
if any(y - x <= 0 for x, y in zip(x_list, x_list[1:])):
raise ValueError("x_list must be in strictly ascending order!")
x_list = self.x_list = map(float, x_list)
y_list = self.y_list = map(float, y_list)
intervals = zip(x_list, x_list[1:], y_list, y_list[1:])
self.slopes = [(y2 - y1)/(x2 - x1) for x1, x2, y1, y2 in intervals]
def __getitem__(self, x):
i = bisect_left(self.x_list, x) - 1
return self.y_list[i] + self.slopes[i] * (x - self.x_list[i])
Tôi bản đồ để float để phân chia số nguyên (python <= 2.7) sẽ không kick vào và điều hủy hoại nếu x1 , x2 , y1 và y2 là tất cả các số nguyên cho một số iterval. Trong __getitem__ thực tế, tôi đang tận dụng lợi thế của việc self.x_list được sắp xếp theo thứ tự tăng dần bằng cách sử dụng bisect_left để (rất) nhanh chóng tìm ra chỉ mục của phần tử lớn nhất nhỏ hơn x in
self.x_list . Sử dụng lớp như thế này: i = Interpolate([1, 2.5, 3.4, 5.8, 6], [2, 4, 5.8, 4.3, 4])
# Get the interpolated value at x = 4:
y = i[4]
Tôi đã không giải quyết các điều kiện biên giới ở đây, vì đơn giản. Như nó là, i[x] for x < 1 sẽ hoạt động như thể dòng từ (2,5, 4) đến (1, 2) đã được kéo dài đến trừ vô cùng, trong khi i[x] cho x == 1 hoặc x > 6 sẽ tăng một IndexError . Tốt hơn là nên tăng IndexError trong mọi trường hợp, nhưng điều này được để lại như một bài tập cho người đọc. :) 18 hữu ích 2 bình luận chia
sẻ Giải pháp hợp lý là gì phần lớn phụ thuộc vào câu hỏi bạn đang cố gắng trả lời với các pixel được nội suy - báo trước: ngoại suy trên dữ liệu bị thiếu có thể dẫn đến câu trả lời rất sai lầm! Chức năng cơ sở xuyên tâm Nội suy / Làm mịn hạt nhân Về các giải pháp thực tế có sẵn trong Python, một cách để điền các pixel đó vào sẽ là sử dụng cách triển khai nội suy Hàm cơ sở hướng tâm của Scipy (xem tại đây ) nhằm mục đích làm mịn / nội suy dữ liệu phân
tán. Với ma trận của bạn M và các mảng tọa độ 1D bên dưới r và c (như vậy M.shape == (r.size, c.size) ), trong đó các mục bị thiếu của M được đặt thành nan , điều này dường như hoạt động khá tốt với hạt nhân RBF tuyến tính như sau: import numpy as np
import scipy.interpolate as interpolate
with open('measurement.txt') as fh:
M = np.vstack(map(float, r.split(' ')) for r in fh.read().splitlines())
r = np.linspace(0, 1, M.shape[0])
c = np.linspace(0, 1, M.shape[1])
rr, cc = np.meshgrid(r, c)
vals = ~np.isnan(M)
f = interpolate.Rbf(rr[vals], cc[vals], M[vals], function='linear')
interpolated = f(rr, cc)
Điều này dẫn đến nội suy sau của dữ liệu mà bạn đã liên kết ở trên, mặc dù có vẻ hợp lý, nhưng nó làm nổi bật tỷ lệ mẫu bị thiếu so với dữ liệu thực là bất lợi như thế nào: Hồi quy quy trình Gaussian / Kriging Nội suy
Kriging có sẵn thông qua triển khai Hồi quy quy trình Gaussian (bản thân nó dựa trên hộp công cụ DACE Kriging cho Matlab) trong thư viện scikit-learning. Điều này có thể được gọi như sau: from sklearn.gaussian_process import GaussianProcess
gp = GaussianProcess(theta0=0.1, thetaL=.001, thetaU=1., nugget=0.01)
gp.fit(X=np.column_stack([rr[vals],cc[vals]]), y=M[vals])
rr_cc_as_cols = np.column_stack([rr.flatten(), cc.flatten()])
interpolated = gp.predict(rr_cc_as_cols).reshape(M.shape)
Điều này tạo ra một phép nội suy rất giống với ví dụ Hàm cơ sở Radial ở trên. Trong cả hai trường hợp, có rất nhiều tham số để khám phá - sự lựa chọn của những tham số này phần lớn phụ thuộc vào các giả định mà bạn có thể đưa ra về dữ liệu. (Một ưu điểm của hạt nhân tuyến tính được sử dụng trong ví
dụ RBF ở trên là nó không có tham số miễn phí) Inpainting Cuối cùng sang một bên, một giải pháp hoàn toàn có động cơ trực quan sẽ là sử dụng chức năng inpainting của OpenCV , mặc dù điều này giả định mảng 8bit (0 - 255) và không có cách giải thích toán học đơn giản. 46 hữu ích 0 bình luận chia sẻ Giải pháp hợp lý là gì phần lớn phụ thuộc vào câu hỏi bạn đang cố gắng trả lời với các pixel được nội suy - báo
trước: ngoại suy trên dữ liệu bị thiếu có thể dẫn đến câu trả lời rất sai lầm! Chức năng cơ sở xuyên tâm Nội suy / Làm mịn hạt nhân Về các giải pháp thực tế có sẵn trong Python, một cách để điền các pixel đó vào sẽ là sử dụng cách triển khai nội suy Hàm cơ sở hướng tâm của Scipy (xem tại đây ) nhằm mục đích làm mịn / nội suy dữ liệu phân tán. Với ma trận của bạn M và các mảng tọa độ 1D bên dưới r và c (như vậy M.shape == (r.size, c.size) ), trong đó các mục bị
thiếu của M được đặt thành nan , điều này dường như hoạt động khá tốt với hạt nhân RBF tuyến tính như sau: import numpy as np
import scipy.interpolate as interpolate
with open('measurement.txt') as fh:
M = np.vstack(map(float, r.split(' ')) for r in fh.read().splitlines())
r = np.linspace(0, 1, M.shape[0])
c = np.linspace(0, 1, M.shape[1])
rr, cc = np.meshgrid(r, c)
vals = ~np.isnan(M)
f = interpolate.Rbf(rr[vals], cc[vals], M[vals], function='linear')
interpolated = f(rr, cc)
Điều này dẫn đến nội suy sau của dữ liệu mà bạn đã liên kết ở trên, mặc dù có vẻ hợp lý, nhưng nó làm nổi bật tỷ lệ mẫu bị thiếu so với dữ liệu thực là bất lợi như thế nào: Hồi quy quy trình Gaussian / Kriging Nội suy Kriging có sẵn thông qua triển khai Hồi quy quy trình Gaussian (bản thân nó dựa trên hộp công cụ DACE Kriging cho Matlab) trong
thư viện scikit-learning. Điều này có thể được gọi như sau: from sklearn.gaussian_process import GaussianProcess
gp = GaussianProcess(theta0=0.1, thetaL=.001, thetaU=1., nugget=0.01)
gp.fit(X=np.column_stack([rr[vals],cc[vals]]), y=M[vals])
rr_cc_as_cols = np.column_stack([rr.flatten(), cc.flatten()])
interpolated = gp.predict(rr_cc_as_cols).reshape(M.shape)
Điều này tạo ra một phép nội suy rất giống với ví dụ Hàm cơ sở Radial ở trên. Trong cả hai trường hợp, có rất nhiều tham số để khám phá - sự lựa chọn của những tham số này phần lớn phụ thuộc vào các giả định mà bạn có thể đưa ra về dữ liệu. (Một ưu điểm của hạt nhân tuyến tính được sử dụng trong ví dụ RBF ở trên là nó không có tham số miễn phí) Inpainting Cuối cùng sang một bên, một giải pháp
hoàn toàn có động cơ trực quan sẽ là sử dụng chức năng inpainting của OpenCV , mặc dù điều này giả định mảng 8bit (0 - 255) và không có cách giải thích toán học đơn giản. 46 hữu ích 0 bình luận chia sẻ
|