Cara menggunakan SCIPY.OPTIMIZE.MINIMIZE_SCALAR pada Python

Question

Penulisan untuk menguji apakah suatu titik berada dalam ruang lambung, menggunakan scipy.optimize.minimize.

Berdasarkan jawaban user1071136.

Table of Contents Show

Penulisan untuk menguji apakah suatu titik berada dalam ruang lambung, menggunakan scipy.optimize.minimize.
Apa itu SciPy?
Mengapa menggunakan SciPy
Numpy VS SciPy
SciPy - Instalasi dan Pengaturan Lingkungan
Paket Input / Output File:
Paket Fungsi Khusus
Fungsi Akar Kubik:
Fungsi eksponensial:
Permutasi & Kombinasi:
Log Sum Fungsi Eksponensial
Fungsi Bessel
Aljabar Linier dengan SciPy
Transformasi Fourier Diskrit – scipy.fftpack
Optimasi dan Fit di SciPy – scipy.optimize
Algoritma Nelder-Mead:
Pemrosesan Gambar dengan SciPy - scipy.ndimage
Integrasi dengan Scipy – Integrasi Numerik

Memang berjalan jauh lebih cepat jika Anda menghitung lambung cembung, jadi saya menambahkan beberapa baris untuk orang yang ingin melakukan itu. Saya beralih dari pemindaian graham (hanya 2D) ke algoritma qhull yang cerdik.

dokumentasi scipy.optimize.minimize:
https://docs.scipy.org/doc/scipy/reference/optimize.nonlin.html

import numpy as np
import scipy.optimize
import matplotlib.pyplot as plt
from scipy.spatial import ConvexHull


def hull_test(P, X, use_hull=True, verbose=True, hull_tolerance=1e-5, return_hull=True):
    if use_hull:
        hull = ConvexHull(X)
        X = X[hull.vertices]

    n_points = len(X)

    def F(x, X, P):
        return np.linalg.norm( np.dot( x.T, X ) - P )

    bnds = [[0, None]]*n_points # coefficients for each point must be > 0
    cons = ( {'type': 'eq', 'fun': lambda x: np.sum(x)-1} ) # Sum of coefficients must equal 1
    x0 = np.ones((n_points,1))/n_points # starting coefficients

    result = scipy.optimize.minimize(F, x0, args=(X, P), bounds=bnds, constraints=cons)

    if result.fun < hull_tolerance:
        hull_result = True
    else:
        hull_result = False

    if verbose:
        print( '# boundary points:', n_points)
        print( 'x.T * X - P:', F(result.x,X,P) )
        if hull_result: 
            print( 'Point P is in the hull space of X')
        else: 
            print( 'Point P is NOT in the hull space of X')

    if return_hull:
        return hull_result, X
    else:
        return hull_result

Tes pada beberapa sampel data:

n_dim = 3
n_points = 20
np.random.seed(0)

P = np.random.random(size=(1,n_dim))
X = np.random.random(size=(n_points,n_dim))

_, X_hull = hull_test(P, X, use_hull=True, hull_tolerance=1e-5, return_hull=True)

Keluaran:

# boundary points: 14
x.T * X - P: 2.13984259782e-06
Point P is in the hull space of X

Visualisasikan:

rows = max(1,n_dim-1)
cols = rows
plt.figure(figsize=(rows*3,cols*3))
for row in range(rows):
    for col in range(row, cols):
        col += 1
        plt.subplot(cols,rows,row*rows+col)
        plt.scatter(P[:,row],P[:,col],label='P',s=300)
        plt.scatter(X[:,row],X[:,col],label='X',alpha=0.5)
        plt.scatter(X_hull[:,row],X_hull[:,col],label='X_hull')
        plt.xlabel('x{}'.format(row))
        plt.ylabel('x{}'.format(col))
plt.tight_layout()

Dalam tutorial ini, Anda akan belajar:

Apa itu SciPy?
Mengapa menggunakan SciPy
Numpy VS SciPy
SciPy - Instalasi dan Pengaturan Lingkungan
Paket Input / Output File:
Paket Fungsi Khusus:
Aljabar Linier dengan SciPy:
Transformasi Fourier Diskrit – scipy.fftpack
Optimasi dan Fit di SciPy – scipy.optimize
Algoritma Nelder-Mead:
Pemrosesan Gambar dengan SciPy - scipy.ndimage

Apa itu SciPy?

SciPy adalah perpustakaan berbasis Python Open Source, yang digunakan dalam matematika, komputasi ilmiah, Teknik, dan komputasi teknis.

SciPy juga diucapkan sebagai Sigh Pi.

Sub-paket SciPy:

Masukan/keluaran berkas - scipy.io
Fungsi Khusus - scipy.special
Operasi Aljabar Linier - scipy.linalg
Interpolasi - scipy.interpolate
Optimasi dan cocok - scipy.optimasi
Statistik dan angka acak - scipy.stats
Integrasi numerik - scipy.integrate
Transformasi Fourier Cepat - scipy.fftpack
Pemrosesan Sinyal - scipy.signal
Manipulasi gambar – scipy.ndimage

Mengapa menggunakan SciPy

SciPy berisi berbagai sub paket yang membantu memecahkan masalah paling umum yang terkait dengan Komputasi Ilmiah.
SciPy adalah perpustakaan Ilmiah yang paling banyak digunakan setelah Perpustakaan Ilmiah GNU untuk C/C++ atau Matlab.
Mudah digunakan dan dipahami serta daya komputasi yang cepat.
Itu dapat beroperasi pada array perpustakaan NumPy.

Numpy VS SciPy

lumpuh:

Numpy ditulis dalam C dan digunakan untuk perhitungan matematis atau numerik.
Ini lebih cepat daripada Perpustakaan Python lainnya
Numpy adalah perpustakaan yang paling berguna untuk Ilmu Data untuk melakukan perhitungan dasar.
Numpy tidak berisi apa-apa selain tipe data array yang melakukan operasi paling dasar seperti pengurutan, pembentukan, pengindeksan, dll.

SciPy:

SciPy dibangun di atas NumPy
SciPy adalah versi Aljabar Linear berfitur lengkap sementara Numpy hanya berisi beberapa fitur.
Sebagian besar fitur Ilmu Data baru tersedia di Scipy daripada Numpy.

SciPy - Instalasi dan Pengaturan Lingkungan

Anda juga dapat menginstal SciPy di Windows melalui pip

Python3 -m pip install --user numpy scipy

Instal Scipy di Linux

sudo apt-get install python-scipy python-numpy

Instal SciPy di Mac

sudo port install py35-scipy py35-numpy

Sebelum mulai belajar SciPy, Anda perlu mengetahui fungsionalitas dasar serta berbagai jenis array NumPy

Cara standar untuk mengimpor modul infSciPy dan Numpy:

from scipy import special #same for other modules import numpy as np

Paket Input / Output File:

Scipy, paket I/O, memiliki berbagai fungsi untuk bekerja dengan format file yang berbeda yaitu Matlab, Arff, Wave, Matrix Market, IDL, NetCDF, TXT, CSV dan format biner.

Mari kita ambil satu contoh format file yang biasa digunakan MatLab:

apa itu koin bcd?

 import numpy as np from scipy import io as sio array = np.ones((4, 4)) sio.savemat('example.mat', {'ar': array}) data = sio.loadmat(‘example.mat', struct_as_record=True) data['ar']

Keluaran:

array([[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]])

Penjelasan Kode

Baris 1 & 2: Impor scipy perpustakaan penting dengan paket i/o dan Numpy.
Baris 3 : Buat 4 x 4, array satu dimensi
Baris 4 : Simpan array di contoh.mat mengajukan.
Baris 5: Dapatkan data dari contoh.mat mengajukan
Baris 6 : Hasil cetak.

Paket Fungsi Khusus

scipy.special paket berisi banyak fungsi fisika matematika.
Fungsi khusus SciPy termasuk Akar Kubik, Eksponensial, Log sum Eksponensial, Lambert, Permutasi dan Kombinasi, Gamma, Bessel, hipergeometrik, Kelvin, beta, silinder parabola, Eksponensial Kesalahan Relatif, dll…
Untuk satu deskripsi baris semua fungsi ini, ketik konsol Python:

help(scipy.special) Output : NAME scipy.special DESCRIPTION ======================================== Special functions (:mod:`scipy.special`) ======================================== .. module:: scipy.special Nearly all of the functions below are universal functions and follow broadcasting and automatic array-looping rules. Exceptions are noted.

Fungsi Akar Kubik:

Fungsi Akar Kubik menemukan akar pangkat tiga dari nilai.

Sintaksis:

scipy.special.cbrt(x)

Contoh:

from scipy.special import cbrt #Find cubic root of 27 & 64 using cbrt() function cb = cbrt([27, 64]) #print value of cb print(cb)

Keluaran: array([3., 4.])

Fungsi eksponensial:

Fungsi eksponensial menghitung 10**x elemen-bijaksana.

Contoh:

from scipy.special import exp10 #define exp10 function and pass value in its exp = exp10([1,10]) print(exp)

Keluaran: [1.e+01 1.e+1]

Permutasi & Kombinasi:

SciPy juga memberikan fungsionalitas untuk menghitung Permutasi dan Kombinasi.

Kombinasi - scipy.special.comb(N,k**)**

Contoh:

from scipy.special import comb #find combinations of 5, 2 values using comb(N, k) com = comb(5, 2, exact = False, repetition=True) print(com)

Keluaran: 15.0

Permutasi –

scipy.special.perm(N,k)

Contoh:

from scipy.special import perm #find permutation of 5, 2 using perm (N, k) function per = perm(5, 2, exact = True) print(per)

Keluaran: 20

Log Sum Fungsi Eksponensial

Log Sum Eksponensial menghitung log elemen input jumlah eksponensial.

Sintaks:

scipy.special.logsumexp(x)

Fungsi Bessel

Fungsi perhitungan urutan bilangan bulat ke-n

Sintaks:

scipy.special.jn()

Aljabar Linier dengan SciPy

Aljabar Linier SciPy adalah implementasi dari perpustakaan BLAS dan ATLAS LAPACK.
Performa Aljabar Linier sangat cepat dibandingkan dengan BLAS dan LAPACK.
Rutin aljabar linier menerima objek larik dua dimensi dan keluarannya juga larik dua dimensi.

Sekarang mari kita lakukan beberapa tes dengan scipy.linalg,

Menghitung penentu matriks dua dimensi,

from scipy import linalg import numpy as np #define square matrix two_d_array = np.array([ [4,5], [3,2] ]) #pass values to det() function linalg.det( two_d_array )

Keluaran: -7.0

Matriks Terbalik -

bahan formula keseimbangan darah

scipy.linalg.inv()

Matriks Terbalik dari Scipy menghitung kebalikan dari matriks persegi apa pun.

Ayo lihat,

from scipy import linalg import numpy as np # define square matrix two_d_array = np.array([ [4,5], [3,2] ]) #pass value to function inv() linalg.inv( two_d_array )

Keluaran:

array( [[-0.28571429, 0.71428571], [ 0.42857143, -0.57142857]] )

Nilai Eigen dan Vektor Eigen – scipy.linalg.eig()

Masalah yang paling umum dalam aljabar linier adalah nilai eigen dan vektor eigen yang dapat diselesaikan dengan mudah menggunakan memiliki () fungsi.
Sekarang mari kita cari nilai Eigen dari ( x ) dan vektor eigen yang sesuai dari matriks persegi dua dimensi.

Contoh,

from scipy import linalg import numpy as np #define two dimensional array arr = np.array([[5,4],[6,3]]) #pass value into function eg_val, eg_vect = linalg.eig(arr) #get eigenvalues print(eg_val) #get eigenvectors print(eg_vect)

Keluaran:

[ 9.+0.j -1.+0.j] #eigenvalues [ [ 0.70710678 -0.5547002 ] #eigenvectors [ 0.70710678 0.83205029] ]

Transformasi Fourier Diskrit – scipy.fftpack

DFT adalah teknik matematika yang digunakan untuk mengubah data spasial menjadi data frekuensi.
FFT (Fast Fourier Transformation) adalah algoritma untuk menghitung DFT
FFT diterapkan ke array multidimensi.
Frekuensi mendefinisikan jumlah sinyal atau panjang gelombang dalam periode waktu tertentu.

Contoh: Ambil gelombang dan tunjukkan menggunakan perpustakaan Matplotlib. kita ambil contoh fungsi periodik sederhana dari sin(20 × 2πt)

%matplotlib inline from matplotlib import pyplot as plt import numpy as np #Frequency in terms of Hertz fre = 5 #Sample rate fre_samp = 50 t = np.linspace(0, 2, 2 * fre_samp, endpoint = False ) a = np.sin(fre * 2 * np.pi * t) figure, axis = plt.subplots() axis.plot(t, a) axis.set_xlabel ('Time (s)') axis.set_ylabel ('Signal amplitude') plt.show()

keluaran:

Anda dapat melihat ini. Frekuensi adalah 5 Hz dan sinyalnya berulang dalam 1/5 detik – disebut sebagai periode waktu tertentu.

Sekarang mari kita gunakan gelombang sinusoidal ini dengan bantuan aplikasi DFT.

from scipy import fftpack A = fftpack.fft(a) frequency = fftpack.fftfreq(len(a)) * fre_samp figure, axis = plt.subplots() axis.stem(frequency, np.abs(A)) axis.set_xlabel('Frequency in Hz') axis.set_ylabel('Frequency Spectrum Magnitude') axis.set_xlim(-fre_samp / 2, fre_samp/ 2) axis.set_ylim(-5, 110) plt.show()

Keluaran:

Anda dapat dengan jelas melihat bahwa output adalah array satu dimensi.
Input yang mengandung nilai kompleks adalah nol kecuali dua titik.
Dalam contoh DFT kami memvisualisasikan besarnya sinyal.

Optimasi dan Fit di SciPy – scipy.optimize

Optimasi menyediakan algoritma yang berguna untuk meminimalkan pemasangan kurva, pemasangan multidimensi atau skalar dan akar.
Mari kita ambil contoh fungsi skalar, untuk menemukan fungsi skalar minimum**.**

%matplotlib inline import matplotlib.pyplot as plt from scipy import optimize import numpy as np def function(a): return a*2 + 20 * np.sin(a) plt.plot(a, function(a)) plt.show() #use BFGS algorithm for optimization optimize.fmin_bfgs(function, 0)

Keluaran:

Pengoptimalan berhasil dihentikan.

Nilai fungsi saat ini: -23.241676

Iterasi: 4

Evaluasi fungsi: 18

Evaluasi gradien: 6

array([-1.67096375])

Dalam contoh ini, optimasi dilakukan dengan bantuan algoritma penurunan gradien dari titik awal
Tetapi masalah yang mungkin terjadi adalah minima lokal, bukan minima global. Jika kita tidak menemukan tetangga minimum global, maka kita perlu menerapkan optimasi global dan menemukan fungsi minimum global yang digunakan sebagai baskom() yang menggabungkan pengoptimal lokal.

mengoptimalkan.basinhopping(fungsi, 0)

Keluaran:

fun: -23.241676238045315 lowest_optimization_result: fun: -23.241676238045315 hess_inv: array([[0.05023331]]) jac: array([4.76837158e-07]) message: 'Optimization terminated successfully.' nfev: 15 nit: 3 njev: 5 status: 0 success: True x: array([-1.67096375]) message: ['requested number of basinhopping iterations completed successfully'] minimization_failures: 0 nfev: 1530 nit: 100 njev: 510 x: array([-1.67096375])

Algoritma Nelder-Mead:

Algoritma Nelder-Mead memilih melalui parameter metode.
Ini memberikan cara minimalisasi yang paling mudah untuk fungsi berperilaku adil.
Algoritma Nelder – Mead tidak digunakan untuk evaluasi gradien karena mungkin membutuhkan waktu lebih lama untuk menemukan solusinya.

import numpy as np from scipy.optimize import minimize #define function f(x) def f(x): return .4*(1 - x[0])**2 optimize.minimize(f, [2, -1], method='Nelder-Mead')

Keluaran:

final_simplex: (array([[ 1. , -1.27109375], [ 1. , -1.27118835], [ 1. , -1.27113762]]), array([0., 0., 0.])) fun: 0.0 message: 'Optimization terminated successfully.' nfev: 147 nit: 69 status: 0 success: True x: array([ 1. , -1.27109375])

Pemrosesan Gambar dengan SciPy - scipy.ndimage

scipy.ndimage adalah submodul dari SciPy yang sebagian besar digunakan untuk melakukan operasi terkait gambar
ndima berarti gambar n dimensi.
SciPy Image Processing menyediakan transformasi Geometris (rotate, crop, flip), image filtering (sharp and de nosing), gambar tampilan, segmentasi gambar, klasifikasi dan ekstraksi fitur.
Paket MISC di SciPy berisi gambar prebuilt yang dapat digunakan untuk melakukan tugas manipulasi gambar

Contoh: Mari kita ambil contoh transformasi geometris dari gambar

from scipy import misc from matplotlib import pyplot as plt import numpy as np #get face image of panda from misc package panda = misc.face() #plot or show image of face plt.imshow( panda ) plt.show()

Keluaran:

Sekarang kita Membalikkan ke bawah gambar saat ini:

#Flip Down using scipy misc.face image flip_down = np.flipud(misc.face()) plt.imshow(flip_down) plt.show()

Keluaran:

Contoh**: Rotasi Gambar menggunakan Scipy,**

from scipy import ndimage, misc from matplotlib import pyplot as plt panda = misc.face() #rotatation function of scipy for image – image rotated 135 degree panda_rotate = ndimage.rotate(panda, 135) plt.imshow(panda_rotate) plt.show()

Keluaran:

Integrasi dengan Scipy – Integrasi Numerik

Ketika kita mengintegrasikan fungsi apa pun di mana integrasi analitik tidak memungkinkan, kita perlu beralih ke integrasi numerik
SciPy menyediakan fungsionalitas untuk mengintegrasikan fungsi dengan integrasi numerik.
scipy.integrate perpustakaan memiliki aturan integrasi tunggal, ganda, tiga, ganda, kuadrat Gaussian, Romberg, Trapesium, dan Simpson.

Contoh: Sekarang ambil contoh dari Integrasi Tunggal

Di Sini ke adalah batas atas dan B adalah batas bawah

from scipy import integrate # take f(x) function as f f = lambda x : x**2 #single integration with a = 0 & b = 1 integration = integrate.quad(f, 0 , 1) print(integration)

Keluaran:

(0.333333333333333337, 3.700743415417189e-15)

cara membeli token gmr

Di sini fungsi mengembalikan dua nilai, di mana nilai pertama adalah integrasi dan nilai kedua adalah kesalahan yang diperkirakan dalam integral.

Contoh: Sekarang ambil contoh dari integrasi ganda. Kami menemukan integrasi ganda dari persamaan berikut,

from scipy import integrate import numpy as np #import square root function from math lib from math import sqrt # set fuction f(x) f = lambda x, y : 64 *x*y # lower limit of second integral p = lambda x : 0 # upper limit of first integral q = lambda y : sqrt(1 - 2*y**2) # perform double integration integration = integrate.dblquad(f , 0 , 2/4, p, q) print(integration)

Keluaran:

(3.0, 9.657432734515774e-14)

Anda telah melihat bahwa output di atas sama dengan yang sebelumnya.

Ringkasan

SciPy (diucapkan sebagai Sigh Pi) adalah perpustakaan berbasis Python Open Source, yang digunakan dalam matematika, komputasi ilmiah, Teknik, dan komputasi teknis.
SciPy berisi berbagai sub paket yang membantu memecahkan masalah paling umum yang terkait dengan Komputasi Ilmiah.
SciPy dibangun di atas NumPy

Terima kasih telah membaca!

#python #Python SciPy #scipy #tutorial

kode python Scalar optimization