Scipy-quick-guide

提供：Dev Guides
移動先:案内、検索

SciPy-はじめに

Sci Piと発音されるSciPyは科学的なpythonオープンソースで、BSDライセンスライブラリの下で配布され、数学、科学、工学計算を実行します。

SciPyライブラリは、便利で高速なN次元配列操作を提供するNumPyに依存しています。 SciPyライブラリはNumPyアレイで動作するように構築されており、数値の統合と最適化のルーチンなど、多くのユーザーフレンドリーで効率的な数値プラクティスを提供します。 一緒に、すべての一般的なオペレーティングシステムで実行され、インストールが迅速で、無料です。 NumPyとSciPyは使いやすいですが、世界有数の科学者やエンジニアが依存するほど強力です。

SciPyサブパッケージ

SciPyは、さまざまな科学計算ドメインをカバーするサブパッケージに編成されています。 これらは、次の表にまとめられています-

scipy.cluster Vector quantization/Kmeans
scipy.constants Physical and mathematical constants
scipy.fftpack Fourier transform
scipy.integrate Integration routines
scipy.interpolate Interpolation
scipy.io Data input and output
scipy.linalg Linear algebra routines
scipy.ndimage n-dimensional image package
scipy.odr Orthogonal distance regression
scipy.optimize Optimization
scipy.signal Signal processing
scipy.sparse Sparse matrices
scipy.spatial Spatial data structures and algorithms
scipy.special Any special mathematical functions
scipy.stats Statistics

データ構造

SciPyが使用する基本的なデータ構造は、NumPyモジュールが提供する多次元配列です。 NumPyは、線形代数、フーリエ変換、乱数生成のためのいくつかの関数を提供しますが、SciPyの同等の関数の一般性はありません。

SciPy-環境設定

標準のPythonディストリビューションには、SciPyモジュールがバンドルされていません。 軽量の代替手段は、人気のあるPythonパッケージインストーラーを使用してSciPyをインストールすることです。 

pip install pandas
  • Anaconda Pythonパッケージ*をインストールすると、デフォルトでPandasがインストールされます。 以下は、異なるオペレーティングシステムにインストールするためのパッケージとリンクです。

Windows

*Anaconda* （https://www.continuum.ioから）は、SciPyスタック用の無料のPythonディストリビューションです。 LinuxおよびMacでも利用可能です。
*Canopy* （https://www.enthought.com/products/canopy/）は無料で利用できます。また、Windows、Linux、およびMac用の完全なSciPyスタックを備えた商用配布も可能です。

Linux

それぞれのLinuxディストリビューションのパッケージマネージャーを使用して、SciPyスタックに1つ以上のパッケージをインストールします。

ウブンツ

次のパスを使用して、UbuntuにPythonをインストールできます。 

sudo apt-get install python-numpy python-scipy
python-matplotlibipythonipython-notebook python-pandas python-sympy python-nose

フェドラ

次のパスを使用して、FedoraにPythonをインストールできます。 

sudo yum install numpyscipy python-matplotlibipython python-pandas
sympy python-nose atlas-devel

SciPy-基本機能

デフォルトでは、すべてのNumPy関数はSciPy名前空間を介して利用できます。 SciPyをインポートするときに、NumPy関数を明示的にインポートする必要はありません。 NumPyの主なオブジェクトは、同種の多次元配列です。 これは、正の整数のタプルによってインデックスが付けられた、すべて同じタイプの要素（通常は数字）のテーブルです。 NumPyでは、ディメンションは軸と呼ばれます。 *軸*の数は*ランク*と呼ばれます。

ここで、NumPyのベクトルと行列の基本機能を修正しましょう。 SciPyはNumPyアレイの上に構築されるため、NumPyの基本を理解する必要があります。 線形代数のほとんどの部分は行列のみを扱うため。

NumPyベクトル

ベクターは複数の方法で作成できます。 それらのいくつかを以下に説明します。

Pythonの配列のようなオブジェクトをNumPyに変換する

次の例を考えてみましょう。 

import numpy as np
list = [1,2,3,4]
arr = np.array(list)
print arr

上記のプログラムの出力は次のようになります。 

[1 2 3 4]

本質的なNumPy配列の作成

NumPyには、ゼロから配列を作成するための組み込み関数があります。 これらの機能の一部を以下に説明します。

zeros（）を使用する

zeros（shape）関数は、指定された形状の0値で満たされた配列を作成します。 デフォルトのdtypeはfloat64です。 次の例を考えてみましょう。 

import numpy as np
print np.zeros((2, 3))

上記のプログラムの出力は次のようになります。 

array([[Using ones()

The ones(shape) function will create an array filled with 1 values. It is identical to zeros in all the other respects. Let us consider the following example.

[source,prettyprint,notranslate]

numpyをnp print np.ones（（2、3））としてインポート 

The output of the above program will be as follows.

[source,result,notranslate]

array（[[arange（）を使用

arange（）関数は、定期的に値を増やして配列を作成します。 次の例を考えてみましょう。 

import numpy as np
print np.arange(7)

上記のプログラムは、次の出力を生成します。 

array([0, 1, 2, 3, 4, 5, 6])

値のデータ型の定義

次の例を考えてみましょう。 

import numpy as np
arr = np.arange(2, 10, dtype = np.float)
print arr
print "Array Data Type :",arr.dtype

上記のプログラムは、次の出力を生成します。 

[ 2. 3. 4. 5. 6. 7. 8. 9.]
Array Data Type : float64

linspace（）を使用する

linspace（）関数は、指定された要素の数で配列を作成し、指定された開始値と終了値の間で等間隔になります。 次の例を考えてみましょう。 

import numpy as np
print np.linspace(1., 4., 6)

上記のプログラムは、次の出力を生成します。 

array([ 1. , 1.6, 2.2, 2.8, 3.4, 4. ])

マトリックス

行列は、操作を通じてその2次元の性質を保持する特殊な2次元配列です。 （行列の乗算）や*（行列のべき乗）などの特定の特別な演算子があります。 次の例を考えてみましょう。 

import numpy as np
print np.matrix('1 2; 3 4')

上記のプログラムは、次の出力を生成します。 

matrix([[Conjugate Transpose of Matrix

This feature returns the (complex) conjugate transpose of *self*. Let us consider the following example.

[source,prettyprint,notranslate]

numpyをnp mat = np.matrix（ '1 2; 3 4'）print mat.Hとしてインポート 

The above program will generate the following output.

[source,result,notranslate]

行列（[[行列の転置

この機能は、自己の転置を返します。 次の例を考えてみましょう。 

import numpy as np
mat = np.matrix('1 2; 3 4')
mat.T

上記のプログラムは、次の出力を生成します。 

matrix([[When we transpose a matrix, we make a new matrix whose rows are the columns of the original. A conjugate transposition, on the other hand, interchanges the row and the column index for each matrix element. The inverse of a matrix is a matrix that, if multiplied with the original matrix, results in an identity matrix.

SciPy-クラスター

  • K-meansクラスタリング*は、ラベルのないデータのセットでクラスターとクラスターセンターを見つける方法です。 直観的には、クラスターは、クラスターの外側のポイントまでの距離と比較してポイント間の距離が短いデータポイントのグループで構成されていると考えることができます。 Kセンターの初期セットを考えると、K平均アルゴリズムは、次の2つのステップを繰り返します-
  • 各センターについて、トレーニングポイントのサブセット（そのクラスター）は、他のどのセンターよりも近くにあります。
  • 各クラスターのデータポイントの各特徴の平均が計算され、この平均ベクトルがそのクラスターの新しい中心になります。

これらの2つのステップは、センターが移動しなくなるか、割り当てが変更されなくなるまで繰り返されます。 次に、最も近いプロトタイプのクラスターに新しいポイント x を割り当てることができます。 SciPyライブラリは、クラスターパッケージを通じてK-Meansアルゴリズムの適切な実装を提供します。 使い方を理解しましょう。

SciPyでのK-Meansの実装

SciPyでK-Meansを実装する方法を理解します。

K平均のインポート

インポートされた各関数の実装と使用方法を確認します。 

from SciPy.cluster.vq import kmeans,vq,whiten

データ生成

クラスタリングを調査するには、いくつかのデータをシミュレートする必要があります。 

from numpy import vstack,array
from numpy.random import rand

# data generation with three features
data = vstack((rand(100,3) + array([.5,.5,.5]),rand(100,3)))

次に、データを確認する必要があります。 上記のプログラムは、次の出力を生成します。 

array([[e+00, 8.17445796e-01, 1.00834051e+00],
       [ 8.45299768e-01, 1.35450732e+00, 8.66323621e-01],
       [ 1.27725864e+00, 1.00622682e+00, 8.43735610e-01],
       …………….

特徴ごとに観測グループを正規化します。 K-Meansを実行する前に、観測セットの各特徴次元をホワイトニングで再スケーリングすることが有益です。 各特徴は、すべての観測値の標準偏差で除算され、単位分散が与えられます。

データを白くする

データを白色化するには、次のコードを使用する必要があります。 

# whitening of data
data = whiten(data)

3つのクラスターでK平均を計算する

次のコードを使用して、3つのクラスターでK-Meansを計算します。 

# computing K-Means with K = 3 (2 clusters)
centroids,_ = kmeans(data,3)

上記のコードは、K個のクラスターを形成する観測ベクトルのセットに対してK平均を実行します。 K-Meansアルゴリズムは、十分な進捗が得られなくなるまで、つまり重心を調整します。 最後の反復がしきい値よりも小さいため、歪みの変化。 ここでは、以下のコードを使用してセントロイド変数を出力することにより、クラスターのセントロイドを観察できます。 

print(centroids)

上記のコードは以下の出力を生成します。 

print(centroids)[ [ 2.26034702  1.43924335  1.3697022 ]
                  [ 2.63788572  2.81446462  2.85163854]
                  [ 0.73507256  1.30801855  1.44477558] ]

以下のコードを使用して、各値をクラスターに割り当てます。 

# assign each sample to a cluster
clx,_ = vq(data,centroids)
*vq* 関数は、「M」×「N」の *obs* 配列内の各観測ベクトルを重心と比較し、観測を最も近いクラスターに割り当てます。 各観測値のクラスターと歪みを返します。 歪みも確認できます。 次のコードを使用して、各観測のクラスターを確認します。
# check clusters of observation
print clx

上記のコードは以下の出力を生成します。 

array([1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 2, 0, 2, 0, 1, 1, 1,
0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0,
0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
0, 1,  0, 0, 0, 0, 1, 0, 0, 1, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 0, 0,
2, 2, 2, 1, 0, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], dtype=int32)

上記の配列の異なる値0、1、2はクラスターを示します。

SciPy-定数

SciPy定数パッケージは、一般的な科学分野で使用される広範囲の定数を提供します。

SciPy定数パッケージ

  • scipy.constantsパッケージ*はさまざまな定数を提供します。 必要な定数をインポートし、要件に従って使用する必要があります。 これらの定数変数がどのようにインポートされ、使用されるかを見てみましょう。

まず、次の例を考慮して「pi」の値を比較しましょう。 

#Import pi constant from both the packages
from scipy.constants import pi
from math import pi

print("sciPy - pi = %.16f"%scipy.constants.pi)
print("math - pi = %.16f"%math.pi)

上記のプログラムは、次の出力を生成します。 

sciPy - pi = 3.1415926535897931
math - pi = 3.1415926535897931

利用可能な定数のリスト

次の表は、さまざまな定数を簡単に説明しています。

数学定数

Sr. No. Constant Description
1 pi pi
2 golden Golden Ratio

物理定数

次の表に、最も一般的に使用される物理定数を示します。

Sr. No. Constant & Description
1

c

真空中の光の速度

2

speed_of_light

真空中の光の速度

3

h

プランク定数

4

Planck

プランク定数h

5

G

ニュートンの重力定数

6

e

基本料金

7

R

モルガス定数

8

Avogadro

アボガドロ定数

9

k

ボルツマン定数

10

electron_mass(OR) m_e

電子質量

11

proton_mass (OR) m_p

プロトン質量

12

neutron_mass(OR)m_n

中性子質量

単位

次の表に、SIユニットのリストを示します。

Sr. No. Unit Value
1 milli 0.001
2 micro 1e-06
3 kilo 1000

これらのユニットは、ヨッタ、ゼッタ、エクサ、ペタ、テラ……キロ、ヘクター、…ナノ、ピコ、…、ゼプトまでの範囲です。

その他の重要な定数

次の表に、SciPyで使用されるその他の重要な定数を示します。

Sr. No. Unit Value
1 gram 0.001 kg
2 atomic mass Atomic mass constant
3 degree Degree in radians
4 minute One minute in seconds
5 day One day in seconds
6 inch One inch in meters
7 micron One micron in meters
8 light_year One light-year in meters
9 atm Standard atmosphere in pascals
10 acre One acre in square meters
11 liter One liter in cubic meters
12 gallon One gallon in cubic meters
13 kmh Kilometers per hour in meters per seconds
14 degree_Fahrenheit One Fahrenheit in kelvins
15 eV One electron volt in joules
16 hp One horsepower in watts
17 dyn One dyne in newtons
18 lambda2nu Convert wavelength to optical frequency

これらすべてを覚えるのは少し難しいです。 どのキーがどの機能に対応しているかを簡単に取得するには、* scipy.constants.find（）*メソッドを使用します。 次の例を考えてみましょう。 

import scipy.constants
res = scipy.constants.physical_constants["alpha particle mass"]
print res

上記のプログラムは、次の出力を生成します。 

[
   'alpha particle mass',
   'alpha particle mass energy equivalent',
   'alpha particle mass energy equivalent in MeV',
   'alpha particle mass in u',
   'electron to alpha particle mass ratio'
]

このメソッドはキーのリストを返しますが、キーワードが一致しない場合は何も返しません。

SciPy-FFTpack

  • フーリエ変換*は、周波数領域での動作を確認するために、時間領域信号で計算されます。 フーリエ変換は、信号およびノイズ処理、画像処理、音声信号処理などの分野での用途があります。 SciPyは、ユーザーが高速フーリエ変換を計算できるようにするfftpackモジュールを提供します。

以下は、fftpackモジュールを使用してフーリエ変換を計算するために使用されるサイン関数の例です。

高速フーリエ変換

高速フーリエ変換の詳細を理解しましょう。

1次元離散フーリエ変換

長さNシーケンスx [n]の長さNのFFT y [k]はfft（）によって計算され、逆変換はifft（）を使用して計算されます。 次の例を考えてみましょう 

#Importing the fft and inverse fft functions from fftpackage
from scipy.fftpack import fft

#create an array with random n numbers
x = np.array([1.0, 2.0, 1.0, -1.0, 1.5])

#Applying the fft function
y = fft(x)
print y

上記のプログラムは、次の出力を生成します。 

[ 4.50000000+0.j           2.08155948-1.65109876j   -1.83155948+1.60822041j
 -1.83155948-1.60822041j   2.08155948+1.65109876j ]

別の例を見てみましょう 

#FFT is already in the workspace, using the same workspace to for inverse transform

yinv = ifft(y)

print yinv

上記のプログラムは、次の出力を生成します。 

[ 1.0+0.j   2.0+0.j   1.0+0.j   -1.0+0.j   1.5+0.j ]
*scipy.fftpack* モジュールを使用すると、高速フーリエ変換を計算できます。 例として、（ノイズの多い）入力信号は次のように見えることがあります-
import numpy as np
time_step = 0.02
period = 5.
time_vec = np.arange(0, 20, time_step)
sig = np.sin(2 *np.pi/period* time_vec) + 0.5 *np.random.randn(time_vec.size)
print sig.size

0.02秒のタイムステップで信号を作成しています。 最後のステートメントは、シグナルsigのサイズを出力します。 出力は次のようになります- 

1000

信号周波数はわかりません。信号sigのサンプリング時間ステップのみがわかっています。 信号は実関数から送られることになっているため、フーリエ変換は対称になります。 * scipy.fftpack.fftfreq（）関数はサンプリング周波数を生成し、 scipy.fftpack.fft（）*は高速フーリエ変換を計算します。

例の助けを借りてこれを理解しましょう。 

from scipy import fftpack
sample_freq = fftpack.fftfreq(sig.size, d = time_step)
sig_fft = fftpack.fft(sig)
print sig_fft

上記のプログラムは、次の出力を生成します。 

array([
   25.45122234 +0.00000000e+00j,   6.29800973 +2.20269471e+00j,
   11.52137858 -2.00515732e+01j,   1.08111300 +1.35488579e+01j,
   …….])

離散コサイン変換

離散コサイン変換（DCT）*は、異なる周波数で振動するコサイン関数の合計に関して、データポイントの有限シーケンスを表します。 SciPyは、関数 *dct を持つDCTと、関数 idct を持つ対応するIDCTを提供します。 次の例を考えてみましょう。 

from scipy.fftpack import dct
print dct(np.array([4., 3., 5., 10., 5., 3.]))

上記のプログラムは、次の出力を生成します。 

array([ 60.,  -3.48476592,  -13.85640646,  11.3137085,  6.,  -6.31319305])

逆離散コサイン変換は、離散コサイン変換（DCT）係数からシーケンスを再構築します。 idct関数は、dct関数の逆です。 次の例でこれを理解しましょう。 

from scipy.fftpack import dct
print idct(np.array([4., 3., 5., 10., 5., 3.]))

上記のプログラムは、次の出力を生成します。 

array([ 39.15085889, -20.14213562, -6.45392043, 7.13341236,
8.14213562, -3.83035081])

SciPy-統合

関数を分析的に統合できない場合、または分析的に統合するのが非常に困難な場合は、一般に数値積分法を使用します。 SciPyには、数値積分を実行するための多数のルーチンがあります。 それらのほとんどは同じ scipy.integrate ライブラリにあります。 次の表に、一般的に使用される関数を示します。

Sr No. Function & Description
1

quad

単一の統合

2

dblquad

二重統合

3

tplquad

トリプルインテグレーション

4

nquad

n-fold複数統合

5

fixed_quad

ガウス求積法、次数n

6

quadrature

公差に対するガウス求積法

7

romberg

ロンバーグ統合

8

trapz

台形規則

9

cumtrapz

積分を累積的に計算する台形規則

10

simps

シンプソンのルール

11

romb

ロンバーグ統合

12

polyint

分析多項式積分（NumPy）

13

poly1d

polyint（NumPy）のヘルパー関数

単一積分

Quad機能は、SciPyの統合機能の主力製品です。 数値積分は quadrature と呼ばれることもあるため、その名前が付けられています。 通常、aからbまでの特定の固定範囲で関数_f（x）_の単積分を実行するためのデフォルトの選択です。

\ int _ \ {a} ^ \ {b} f（x）dx

quadの一般的な形式は* scipy.integrate.quad（f、a、b）*です。ここで、「f」は統合する関数の名前です。 一方、「a」と「b」はそれぞれ下限と上限です。 0と1の範囲で積分されたガウス関数の例を見てみましょう。

最初に関数を定義する必要があります→$ f（x）= e ^ \ {-x ^ 2} $、これはラムダ式を使用して実行でき、その関数でquadメソッドを呼び出します。 

import scipy.integrate
from numpy import exp
f= lambda x:exp(-x**2)
i = scipy.integrate.quad(f, 0, 1)
print i

上記のプログラムは、次の出力を生成します。 

(0.7468241328124271, 8.291413475940725e-15)

quad関数は2つの値を返します。最初の数値は積分値で、2番目の値は積分値の絶対誤差の推定値です。

注意-quadは最初の引数として関数を必要とするため、引数としてexpを直接渡すことはできません。 Quad関数は、正および負の無限大を制限として受け入れます。 Quad関数は、exp、sin、cosなどの単一変数の標準の定義済みNumPy関数を統合できます。

複数の積分

ダブルおよびトリプル統合のメカニズムは、関数 dblquad、tplquad および nquad にまとめられています。 これらの関数は、それぞれ4つまたは6つの引数を統合します。 すべての内部積分の限界は、関数として定義する必要があります。

二重積分

*dblquad* の一般的な形式はscipy.integrate.dblquad（func、a、b、gfun、hfun）です。 ここで、funcは統合する関数の名前、「a」と「b」はそれぞれx変数の下限と上限、gfunとhfunは下限と上限を定義する関数の名前ですy変数の。

例として、二重積分法を実行してみましょう。

\ int _ \ {0} ^ \ {1/2} dy \ int _ \ {0} ^ \ {\ sqrt \ {1-4y ^ 2}} 16xy \：dx

ラムダ式を使用して、関数f、g、およびhを定義します。 多くの場合gとhが定数であっても、下限についてはここで行ったように、関数として定義する必要があることに注意してください。 

import scipy.integrate
from numpy import exp
from math import sqrt
f = lambda x, y : 16*x*y
g = lambda x : 0
h = lambda y : sqrt(1-4*y**2)
i = scipy.integrate.dblquad(f, 0, 0.5, g, h)
print i

上記のプログラムは、次の出力を生成します。 

(0.5, 1.7092350012594845e-14)

上記のルーチンに加えて、scipy.integrateには、n倍の多重統合を実行するnquadや、さまざまな統合アルゴリズムを実装する他のルーチンなど、他の多くの統合ルーチンがあります。 ただし、quadおよびdblquadは、数値積分に対するほとんどのニーズを満たします。

SciPy-補間

この章では、SciPyで補間がどのように役立つかについて説明します。

補間とは何ですか？

補間は、直線または曲線上の2点間の値を見つけるプロセスです。 意味を思い出すために、単語の最初の部分である「inter」は「enter」を意味すると考えてください。これは、元々持っていたデータの「内部」を見るように思い出させます。 このツールである補間は、統計だけでなく、科学、ビジネス、または既存の2つのデータポイントに含まれる値を予測する必要がある場合にも役立ちます。

いくつかのデータを作成し、 scipy.interpolate パッケージを使用してこの補間を実行する方法を見てみましょう。 

import numpy as np
from scipy import interpolate
import matplotlib.pyplot as plt
x = np.linspace(0, 4, 12)
y = np.cos(x**2/3+4)
print x,y

上記のプログラムは、次の出力を生成します。 

(
   array([0.,  0.36363636,  0.72727273,  1.09090909,  1.45454545, 1.81818182,
          2.18181818,  2.54545455,  2.90909091,  3.27272727,  3.63636364,  4.]),

   array([-0.65364362,  -0.61966189,  -0.51077021,  -0.31047698,  -0.00715476,
           0.37976236,   0.76715099,   0.99239518,   0.85886263,   0.27994201,
          -0.52586509,  -0.99582185])
)

これで、2つの配列ができました。 これらの2つの配列を空間内のポイントの2つの次元と仮定して、次のプログラムを使用してプロットし、それらがどのように見えるかを見てみましょう。 

plt.plot(x, y,’o’)
plt.show()

上記のプログラムは、次の出力を生成します。

補間

1次元内挿

scipy.interpolateのinterp1dクラスは、固定データポイントに基づいて関数を作成する便利なメソッドです。これは、線形補間を使用して、指定されたデータによって定義されるドメイン内の任意の場所で評価できます。

上記のデータを使用して、補間関数を作成し、新しい補間グラフを描画しましょう。 

f1 = interp1d(x, y,kind = 'linear')

f2 = interp1d(x, y, kind = 'cubic')

interp1d関数を使用して、2つの関数f1とf2を作成しました。 これらの関数は、指定された入力xに対してyを返します。 3番目の変数の種類は、補間手法のタイプを表します。 「線形」、「最近接」、「ゼロ」、「線形」、「二次」、「立方」は、補間のいくつかの手法です。

次に、補間の明確な違いを確認するために、より長い新しい入力を作成しましょう。 古いデータと同じ機能を新しいデータで使用します。 

xnew = np.linspace(0, 4,30)

plt.plot(x, y, 'o', xnew, f(xnew), '-', xnew, f2(xnew), '--')

plt.legend(['data', 'linear', 'cubic','nearest'], loc = 'best')

plt.show()

上記のプログラムは、次の出力を生成します。

1-D補間

スプライン

データ点を通る滑らかな曲線を描くために、製図者はかつて、木材、硬質ゴム、金属、または機械的スプラインと呼ばれるプラスチックの薄い柔軟なストリップを使用していました。 メカニカルスプラインを使用するには、デザイン内の曲線に沿った適切なポイントにピンを配置し、スプラインを曲げて、これらの各ピンに接触させました。

明らかに、この構造では、スプラインはこれらのピンで曲線を補間します。 他の図面で曲線を再現するために使用できます。 ピンが配置されているポイントは、ノットと呼ばれます。 ノットの位置を調整することにより、スプラインによって定義された曲線の形状を変更できます。

単変量スプライン

1次元の平滑化スプラインは、指定されたデータポイントのセットに適合します。 scipy.interpolateのUnivariateSplineクラスは、固定データポイントクラスに基づいて関数を作成する便利なメソッドです– scipy.interpolate.UnivariateSpline（x、y、w = None、bbox = [None、None]、k = 3、s =なし、ext = 0、check_finite = False）。

パラメータ-以下は、単変量スプラインのパラメータです。

これは、k次のスプラインy = spl（x）を指定されたx、yデータに適合させます。

'w'-スプラインフィッティングの重みを指定します。 正でなければなりません。 なし（デフォルト）の場合、重みはすべて等しくなります。

「s」-平滑化条件を指定してノットの数を指定します。

'k'-平滑化スプラインの度合い。 5以下でなければなりません。 デフォルトは3次スプラインであるk = 3です。

Ext-ノットシーケンスで定義された間隔にない要素の外挿モードを制御します。

  • ext = 0または「外挿」の場合、外挿値を返します。
  • ext = 1または「ゼロ」の場合、0を返します
  • ext = 2または「raise」の場合、ValueErrorが発生します
  • ext = 3が「const」の場合、境界値を返します。

check_finite –入力配列に有限数のみが含まれていることを確認するかどうか。

次の例を考えてみましょう。 

import matplotlib.pyplot as plt
from scipy.interpolate import UnivariateSpline
x = np.linspace(-3, 3, 50)
y = np.exp(-x**2) + 0.1 * np.random.randn(50)
plt.plot(x, y, 'ro', ms = 5)
plt.show()

平滑化パラメーターにはデフォルト値を使用します。

スプライン 

spl = UnivariateSpline(x, y)
xs = np.linspace(-3, 3, 1000)
plt.plot(xs, spl(xs), 'g', lw = 3)
plt.show()

スムージングの量を手動で変更します。

スプラインスムージング 

spl.set_smoothing_factor(0.5)
plt.plot(xs, spl(xs), 'b', lw = 3)
plt.show()

スプラインスムージング

SciPy-入力および出力

Scipy.io（入力および出力）パッケージは、さまざまな形式のファイルで動作する幅広い機能を提供します。 これらの形式のいくつかは-

  • Matlab
  • IDL
  • マトリックス市場
  • Wave
  • Arff *Netcdfなど

最も一般的に使用されるファイル形式について詳しく説明しましょう-

MATLAB

以下は、.matファイルの読み込みと保存に使用される関数です。

Sr. No. Function & Description
1
  • loadmat*

MATLABファイルをロードします

2

savemat

MATLABファイルを保存します

3

whosmat

MATLABファイル内の変数をリストします

次の例を考えてみましょう。 

import scipy.io as sio
import numpy as np

#Save a mat file
vect = np.arange(10)
sio.savemat('array.mat', {'vect':vect})

#Now Load the File
mat_file_content = sio.loadmat(‘array.mat’)
Print mat_file_content

上記のプログラムは、次の出力を生成します。 

{
   'vect': array([[__version__': '1.0',
   '__header__': 'MATLAB 5.0 MAT-file Platform: posix, Created on: Sat Sep 30
   09:49:32 2017', '__globals__': []
}

メタ情報とともに配列を確認できます。 メモリにデータを読み込まずにMATLABファイルの内容を検査したい場合、以下に示すように* whosmatコマンド*を使用します。 

import scipy.io as sio
mat_file_content = sio.whosmat(‘array.mat’)
print mat_file_content

上記のプログラムは、次の出力を生成します。 

[('vect', (1, 10), 'int64')]

SciPy-リナル

SciPyは、最適化された ATLAS LAPACK および BLAS ライブラリを使用して構築されます。 非常に高速な線形代数機能を備えています。 これらの線形代数ルーチンはすべて、2次元配列に変換できるオブジェクトを必要とします。 これらのルーチンの出力も2次元配列です。

SciPy.linalg対NumPy.linalg

scipy.linalgには、numpy.linalgにあるすべての関数が含まれています。 さらに、scipy.linalgには、numpy.linalgにはない他の高度な機能もいくつかあります。 numpy.linalgよりもscipy.linalgを使用するもう1つの利点は、BLAS/LAPACKサポートで常にコンパイルされることです。一方、NumPyではこれはオプションです。 したがって、NumPyのインストール方法によっては、SciPyバージョンの方が高速になる場合があります。

一次方程式

*scipy.linalg.solve* 機能は、未知のx、y値について線形方程式a *x + b* y = Zを解きます。

例として、次の連立方程式を解くことが望ましいと仮定します。 

*x + 3y + 5z = 10*
*2x + 5y + z = 8*
*2x + 3y + 8z = 3*

x、y、zの値について上記の方程式を解くために、下に示すように逆行列を使用して解ベクトルを見つけることができます。

\ begin \ {bmatrix} x \\ y \\ z \ end \ {bmatrix} = \ begin \ {bmatrix} 1＆3＆5 \\ 2＆5＆1 \\ 2＆3＆8 \ end \ {bmatrix} ^ \ {-1} \ begin \ {bmatrix} 10 \\ 8 \\ 3 \ end \ {bmatrix} = \ frac \ {1} \ {25} \ begin \ {bmatrix} -232 \\ 129 \\ 19 \ end \ {bmatrix} = \ begin \ {bmatrix} -9.28 \\ 5.16 \\ 0.76 \ end \ {bmatrix}。

ただし、より高速で数値的に安定した linalg.solve コマンドを使用することをお勧めします。

ソルバー関数は、2つの入力「a」と「b」を取ります。「a」は係数を表し、「b」はそれぞれの右側の値を表し、ソリューション配列を返します。

次の例を考えてみましょう。 

#importing the scipy and numpy packages
from scipy import linalg
import numpy as np

#Declaring the numpy arrays
a = np.array([[b = np.array([2, 4, -1])

#Passing the values to the solve function
x = linalg.solve(a, b)

#printing the result array
print x

上記のプログラムは、次の出力を生成します。 

array([ 2., -2., 9.])

決定基を見つける

正方行列Aの行列式は、多くの場合| A |と表されます。線形代数でよく使用される量です。 SciPyでは、これは* det（）*関数を使用して計算されます。 入力として行列を受け取り、スカラー値を返します。

次の例を考えてみましょう。 

#importing the scipy and numpy packages
from scipy import linalg
import numpy as np

#Declaring the numpy array
A = np.array([[Passing the values to the det function
x = linalg.det(A)

#printing the result
print x

上記のプログラムは、次の出力を生成します。 

-2.0

固有値と固有ベクトル

固有値-固有ベクトル問題は、最も一般的に使用される線形代数演算の1つです。 次の関係を考慮することにより、正方行列（A）の固有値（λ）および対応する固有ベクトル（v）を見つけることができます-

  • Av =λv*

    *scipy.linalg.eig* は、通常または一般化された固有値問題から固有値を計算します。 この関数は、固有値と固有ベクトルを返します。

次の例を考えてみましょう。 

#importing the scipy and numpy packages
from scipy import linalg
import numpy as np

#Declaring the numpy array
A = np.array([[Passing the values to the eig function
l, v = linalg.eig(A)

#printing the result for eigen values
print l

#printing the result for eigen vectors
print v

上記のプログラムは、次の出力を生成します。 

array([-0.37228132+0.j, 5.37228132+0.j]) #--Eigen Values
array([[Eigen Vectors
       [ 0.56576746, -0.90937671]])

特異値分解

特異値分解（SVD）は、正方形ではない行列への固有値問題の拡張と考えることができます。 

*scipy.linalg.svd* は、行列 'a'を2つのユニタリ行列 'U'および 'Vh'と、a == Uのような特異値（実数、非負）の1次元配列 's'に分解します。 *S* Vh、「S」は適切な形状のゼロの行列で、主対角線は「s」です。

次の例を考えてみましょう。 

#importing the scipy and numpy packages
from scipy import linalg
import numpy as np

#Declaring the numpy array
a = np.random.randn(3, 2) + 1.j*np.random.randn(3, 2)

#Passing the values to the eig function
U, s, Vh = linalg.svd(a)

# printing the result
print U, Vh, s

上記のプログラムは、次の出力を生成します。 

(
   array([
      [ 0.54828424-0.23329795j, -0.38465728+0.01566714j,
      -0.18764355+0.67936712j],
      [-0.27123194-0.5327436j , -0.57080163-0.00266155j,
      -0.39868941-0.39729416j],
      [ 0.34443818+0.4110186j , -0.47972716+0.54390586j,
      0.25028608-0.35186815j]
   ]),

   array([ 3.25745379, 1.16150607]),

   array([
      [-0.35312444+0.j , 0.32400401+0.87768134j],
      [-0.93557636+0.j , -0.12229224-0.33127251j]
   ])
)

SciPy-Ndimage

SciPy ndimageサブモジュールは、画像処理専用です。 ここで、ndimageはn次元の画像を意味します。

画像処理で最も一般的なタスクのいくつかは次のとおりです＆miuns;

  • 入力/出力、画像の表示
  • 基本的な操作-トリミング、反転、回転など
  • 画像フィルタリング-ノイズ除去、鮮鋭化など
  • 画像のセグメンテーション-さまざまなオブジェクトに対応するピクセルのラベル付け
  • 分類
  • 特徴抽出
  • 登録

これらのいくつかがSciPyを使用してどのように達成できるかを議論しましょう。

画像ファイルを開いて書き込む

SciPyの* miscパッケージ*にはいくつかの画像が付属しています。 これらの画像を使用して、画像の操作を学習します。 次の例を考えてみましょう。 

from scipy import misc
f = misc.face()
misc.imsave('face.png', f) # uses the Image module (PIL)

import matplotlib.pyplot as plt
plt.imshow(f)
plt.show()

上記のプログラムは、次の出力を生成します。

画像ファイルを開いて書き込む

生の形式の画像は、マトリックス形式の数字で表される色の組み合わせです。 マシンは、これらの数値のみに基づいて画像を理解および操作します。 RGBは一般的な表現方法です。

上記の画像の統計情報を見てみましょう。 

from scipy import misc
face = misc.face(gray = False)
print face.mean(), face.max(), face.min()

上記のプログラムは、次の出力を生成します。 

110.16274388631184, 255, 0

これで、画像が数字で作られていることがわかったため、数字の値を変更すると元の画像が変更されます。 画像に対していくつかの幾何学的変換を実行しましょう。 基本的な幾何学的操作はクロッピングです 

from scipy import misc
face = misc.face(gray = True)
lx, ly = face.shape
# Cropping
crop_face = face[lx/4: - lx/4, ly/4: - ly/4]
import matplotlib.pyplot as plt
plt.imshow(crop_face)
plt.show()

上記のプログラムは、次の出力を生成します。

操作画像ファイルのトリミング

以下に説明するように、画像を上下逆にするなどのいくつかの基本的な操作を実行することもできます。 

# up <-> down flip
from scipy import misc
face = misc.face()
flip_ud_face = np.flipud(face)

import matplotlib.pyplot as plt
plt.imshow(flip_ud_face)
plt.show()

上記のプログラムは、次の出力を生成します。

画像回転操作

これに加えて、指定した角度で​​画像を回転させる* rotate（）関数*があります。 

# rotation
from scipy import misc,ndimage
face = misc.face()
rotate_face = ndimage.rotate(face, 45)

import matplotlib.pyplot as plt
plt.imshow(rotate_face)
plt.show()

上記のプログラムは、次の出力を生成します。

画像の回転操作

フィルター

画像処理でフィルターがどのように役立つかを説明しましょう。

画像処理におけるフィルタリングとは何ですか？

フィルタリングは、画像を修正または強化するための手法です。 たとえば、特定の機能を強調したり、他の機能を削除するために画像をフィルターできます。 フィルタリングで実装される画像処理操作には、スムージング、シャープニング、エッジエンハンスメントが含まれます。

フィルタリングは近傍演算であり、対応する入力ピクセルの近傍のピクセルの値に何らかのアルゴリズムを適用することにより、出力画像の任意のピクセルの値が決定されます。 SciPy ndimageを使用していくつかの操作を実行してみましょう。

ぼけ

ぼかしは、画像のノイズを減らすために広く使用されています。 フィルター操作を実行して、画像の変化を確認できます。 次の例を考えてみましょう。 

from scipy import misc
face = misc.face()
blurred_face = ndimage.gaussian_filter(face, sigma=3)
import matplotlib.pyplot as plt
plt.imshow(blurred_face)
plt.show()

上記のプログラムは、次の出力を生成します。

画像ぼかし操作

シグマ値は、ぼかしのレベルを5段階で示します。 シグマ値を調整することで、画質の変化を確認できます。 ぼかしの詳細については、→DIP（デジタル画像処理）チュートリアルをクリックしてください。

エッジ検出

画像処理でエッジ検出がどのように役立つかを説明しましょう。

エッジ検出とは何ですか？

エッジ検出は、画像内のオブジェクトの境界を見つけるための画像処理技術です。 明るさの不連続性を検出することで機能します。 エッジ検出は、画像処理、コンピュータービジョン、マシンビジョンなどの分野での画像セグメンテーションとデータ抽出に使用されます。

最も一般的に使用されるエッジ検出アルゴリズムは次のとおりです。

  • ソーベル
  • キャニー
  • プレウィット
  • ロバーツ
  • ファジーロジックメソッド

次の例を考えてみましょう。 

import scipy.ndimage as nd
import numpy as np

im = np.zeros((256, 256))
im[64:-64, 64:-64] = 1
im[90:-90,90:-90] = 2
im = ndimage.gaussian_filter(im, 8)

import matplotlib.pyplot as plt
plt.imshow(im)
plt.show()

上記のプログラムは、次の出力を生成します。

エッジ検出

画像は色の正方形のブロックのように見えます。 次に、これらの色付きブロックのエッジを検出します。 ここで、ndimageはこの操作を実行するための Sobel と呼ばれる関数を提供します。 一方、NumPyは、2つの結果の行列を1つに結合する Hypot 関数を提供します。

次の例を考えてみましょう。 

import scipy.ndimage as nd
import matplotlib.pyplot as plt

im = np.zeros((256, 256))
im[64:-64, 64:-64] = 1
im[90:-90,90:-90] = 2
im = ndimage.gaussian_filter(im, 8)

sx = ndimage.sobel(im, axis = 0, mode = 'constant')
sy = ndimage.sobel(im, axis = 1, mode = 'constant')
sob = np.hypot(sx, sy)

plt.imshow(sob)
plt.show()

上記のプログラムは、次の出力を生成します。

エッジ検出-2

SciPy-最適化

  • scipy.optimizeパッケージ*は、一般的に使用されるいくつかの最適化アルゴリズムを提供します。 このモジュールには、次の側面が含まれています-
  • さまざまなアルゴリズムを使用した多変量スカラー関数の制約なしおよび制約付き最小化（minimize（）） BFGS、Nelder-Meadシンプレックス、ニュートン共役勾配、COBYLAまたはSLSQP）
  • グローバル（総当たり）最適化ルーチン（anneal（）、basinhopping（）など）
  • 最小二乗最小化（leastsq（））および曲線近似（curve_fit（））アルゴリズム
  • スカラー単変量関数ミニマイザー（minimize_scalar（））およびルートファインダー（newton（））
  • さまざまなアルゴリズムを使用した多変量方程式システムソルバー（root（））（例： ハイブリッドパウエル、レーベンバーグマルカート、またはニュートンクリロフなどの大規模手法）

多変数スカラー関数の制約なしおよび制約付き最小化

  • minimize（）関数*は、 scipy.optimize の多変量スカラー関数の制約なしおよび制約付き最小化アルゴリズムへの共通インターフェースを提供します。 最小化関数を実証するために、NN変数のRosenbrock関数を最小化する問題を考えます-

f（x）= \ sum _ \ {i = 1} ^ \ {N-1} \：100（x_i-x _ \ {i-1} ^ \ {2}）

この関数の最小値は0です。これは、xi = 1のときに達成されます。

Nelder–Meadシンプレックスアルゴリズム

次の例では、minimum（）ルーチンが* Nelder-Meadシンプレックスアルゴリズム（method = 'Nelder-Mead'）*（methodパラメーターで選択）と共に使用されます。 次の例を考えてみましょう。 

import numpy as np
from scipy.optimize import minimize

def rosen(x):

x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])
res = minimize(rosen, x0, method='nelder-mead')

print(res.x)

上記のプログラムは、次の出力を生成します。 

[7.93700741e+54  -5.41692163e+53  6.28769150e+53  1.38050484e+55  -4.14751333e+54]

シンプレックスアルゴリズムは、おそらく、適切に機能する関数を最小化する最も簡単な方法です。 関数の評価のみが必要であり、単純な最小化問題に適しています。 ただし、勾配評価を使用しないため、最小値を見つけるのに時間がかかる場合があります。

最小値を見つけるために関数呼び出しのみを必要とする別の最適化アルゴリズムは、* Powellのメソッド*です。これは、minimize（）関数でmethod = 'powell’を設定することで使用できます。

最小二乗

変数に境界がある非線形最小二乗問題を解きます。 残差f（x）（n個の実変数のm次元の実関数）および損失関数rho（s）（スカラー関数）が与えられると、least_squaresはコスト関数F（x）の局所的最小値を見つけます。 次の例を考えてみましょう。

この例では、独立変数に制限のないRosenbrock関数の最小値を見つけます。 

#Rosenbrock Function
def fun_rosenbrock(x):
   return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])

from scipy.optimize import least_squares
input = np.array([2, 2])
res = least_squares(fun_rosenbrock, input)

print res

残差のベクトルのみを提供することに注意してください。 アルゴリズムは、コスト関数を残差の二乗和として構築し、Rosenbrock関数を提供します。 正確な最小値はx = [1.0,1.0]です。

上記のプログラムは、次の出力を生成します。 

active_mask: array([ 0., 0.])
      cost: 9.8669242910846867e-30
      fun: array([ 4.44089210e-15, 1.11022302e-16])
      grad: array([ -8.89288649e-14, 4.44089210e-14])
      jac: array([[message: '`gtol` termination condition is satisfied.'
      nfev: 3
      njev: 3
   optimality: 8.8928864934219529e-14
      status: 1
      success: True
         x: array([ 1., 1.])

根の発見

SciPyでルート検索がどのように役立つかを理解しましょう。

スカラー関数

単一変数の方程式がある場合、4つの異なるルート検索アルゴリズムがあり、それらを試すことができます。 これらの各アルゴリズムには、ルートが予想される間隔のエンドポイントが必要です（関数が符号を変更するため）。 一般に、 brentq が最適な選択ですが、他の方法は特定の状況や学術目的で役立つ場合があります。

固定小数点ソルバー

関数のゼロを見つけることに密接に関連する問題は、関数の不動点を見つける問題です。 関数の固定小数点は、関数の評価がポイントを返すポイントです：g（x）= x。 明らかに gg の不動点はf（x）= g（x）−xの根です。 同様に、 ff のルートは、g（x）= f（x）+ xのfixed_pointです。 ルーチンfixed_pointは、開始点が指定されている場合、* Aitkensシーケンスアクセラレーション*を使用して gg の固定点を推定する単純な反復メソッドを提供します。

方程式のセット

非線形方程式のセットのルートを見つけるには、* root（）関数*を使用します。 いくつかの方法が利用できますが、その中で hybr （デフォルト）およびlmは、それぞれMINPACKの hybrid method of Powell および Levenberg-Marquardt method を使用します。

次の例では、単一変数の超越方程式を考慮します。 

*x ^ 2 ^ + 2cos（x）= 0*

そのルートは次のように見つけることができます- 

import numpy as np
from scipy.optimize import root
def func(x):
   return x*2 + 2 * np.cos(x)
sol = root(func, 0.3)
print sol

上記のプログラムは、次の出力を生成します。 

fjac: array([[fun: array([ 2.22044605e-16])
message: 'The solution converged.'
   nfev: 10
   qtf: array([ -2.77644574e-12])
      r: array([-3.34722409])
   status: 1
   success: True
      x: array([-0.73908513])

SciPy-統計

すべての統計関数はサブパッケージ scipy.stats にあり、* info（stats）関数を使用してこれらの関数のかなり完全なリストを取得できます。 利用可能なランダム変数のリストは、statsサブパッケージの *docstring からも取得できます。 このモジュールには、多数の確率分布と成長する統計関数のライブラリが含まれています。

各単変量分布には、次の表で説明するように、独自のサブクラスがあります-

Sr. No. Class & Description
1

rv_continuous

サブクラス化を目的とした一般的な連続ランダム変数クラス

2

rv_discrete

サブクラス化を目的とした一般的な離散ランダム変数クラス

3

rv_histogram

ヒストグラムで与えられる分布を生成します

通常の連続ランダム変数

確率変数Xが任意の値を取ることができる確率分布は、連続確率変数です。 location（loc）キーワードは平均を指定します。 scale（スケール）キーワードは、標準偏差を指定します。 

*rv_continuous* クラスのインスタンスとして、 *norm* オブジェクトはそれからジェネリックメソッドのコレクションを継承し、この特定のディストリビューションに固有の詳細でそれらを完了します。

いくつかのポイントでCDFを計算するには、リストまたはNumPy配列を渡すことができます。 次の例を考えてみましょう。 

from scipy.stats import norm
import numpy as np
print norm.cdf(np.array([1,-1., 0, 1, 3, 4, -2, 6]))

上記のプログラムは、次の出力を生成します。 

array([ 0.84134475, 0.15865525, 0.5 , 0.84134475, 0.9986501 ,
0.99996833, 0.02275013, 1. ])

分布の中央値を見つけるには、CDFの逆関数であるパー​​セントポイント関数（PPF）を使用できます。 次の例を使用して理解しましょう。 

from scipy.stats import norm
print norm.ppf(0.5)

上記のプログラムは、次の出力を生成します。 

0.0

ランダム変量のシーケンスを生成するには、次の例に示すように、sizeキーワード引数を使用する必要があります。 

from scipy.stats import norm
print norm.rvs(size = 5)

上記のプログラムは、次の出力を生成します。 

array([ 0.20929928, -1.91049255, 0.41264672, -0.7135557 , -0.03833048])

上記の出力は再現できません。 同じ乱数を生成するには、シード関数を使用します。

均一な分布

一様分布は、一様関数を使用して生成できます。 次の例を考えてみましょう。 

from scipy.stats import uniform
print uniform.cdf([0, 1, 2, 3, 4, 5], loc = 1, scale = 4)

上記のプログラムは、次の出力を生成します。 

array([ 0. , 0. , 0.25, 0.5 , 0.75, 1. ])

離散分布の構築

ランダムなサンプルを生成し、観測された頻度を確率と比較しましょう。

二項分布

  • rv_discreteクラス*のインスタンスとして、* binomオブジェクト*はそれからジェネリックメソッドのコレクションを継承し、この特定のディストリビューションに固有の詳細でそれらを完了します。 次の例を考えてみましょう。
from scipy.stats import uniform
print uniform.cdf([0, 1, 2, 3, 4, 5], loc = 1, scale = 4)

上記のプログラムは、次の出力を生成します。 

array([ 0. , 0. , 0.25, 0.5 , 0.75, 1. ])

記述統計

Min、Max、Mean、Varianceなどの基本的な統計は、NumPy配列を入力として受け取り、それぞれの結果を返します。 * scipy.statsパッケージ*で利用可能ないくつかの基本的な統計関数を次の表に示します。

Sr. No. Function & Description
1

describe()

渡された配列のいくつかの記述統計を計算します

2

gmean()

指定された軸に沿って幾何平均を計算します

3

hmean()

指定された軸に沿って調和平均を計算します

4

kurtosis()

尖度を計算します

5

mode()

モーダル値を返します

6

skew()

データの歪度をテストします

7

f_oneway()

一元配置分散分析を実行します

8

iqr()

指定した軸に沿ってデータの四分位範囲を計算します

9

zscore()

サンプルの平均と標準偏差に関連して、サンプルの各値のzスコアを計算します

10

sem()

入力配列の値の平均の標準誤差（または測定の標準誤差）を計算します

これらの関数のいくつかには、 scipy.stats.mstats に同様のバージョンがあり、マスクされた配列で機能します。 以下に示す例でこれを理解しましょう。 

from scipy import stats
import numpy as np
x = np.array([1,2,3,4,5,6,7,8,9])
print x.max(),x.min(),x.mean(),x.var()

上記のプログラムは、次の出力を生成します。 

(9, 1, 5.0, 6.666666666666667)

T検定

TciがSciPyでどのように役立つかを理解しましょう。

ttest_1samp

スコアの1つのグループの平均のT検定を計算します。 これは、独立した観測値 'a’のサンプルの期待値（平均）が指定された母集団平均 popmean に等しいという帰無仮説の両側検定です。 次の例を考えてみましょう。 

from scipy import stats
rvs = stats.norm.rvs(loc = 5, scale = 10, size = (50,2))
print stats.ttest_1samp(rvs,5.0)

上記のプログラムは、次の出力を生成します。 

Ttest_1sampResult(statistic = array([-1.40184894, 2.70158009]),
pvalue = array([ 0.16726344, 0.00945234]))

2つのサンプルの比較

次の例では、同じ分布または異なる分布からの2つのサンプルがあり、これらのサンプルが同じ統計特性を持っているかどうかをテストします。 

*ttest_ind* -スコアの2つの独立したサンプルの平均のT検定を計算します。 これは、2つの独立したサンプルの平均値（期待値）が同一であるという帰無仮説の両側検定です。 このテストでは、デフォルトで母集団の分散が同一であると想定しています。

同じ母集団または異なる母集団からの2つの独立したサンプルを観察する場合、このテストを使用できます。 次の例を考えてみましょう。 

from scipy import stats
rvs1 = stats.norm.rvs(loc = 5,scale = 10,size = 500)
rvs2 = stats.norm.rvs(loc = 5,scale = 10,size = 500)
print stats.ttest_ind(rvs1,rvs2)

上記のプログラムは、次の出力を生成します。 

Ttest_indResult(statistic = -0.67406312233650278, pvalue = 0.50042727502272966)

同じ長さの新しい配列を使用して、同じことをテストできますが、平均は異なり​​ます。 loc で別の値を使用し、同じ値をテストします。

SciPy-CSGraph

CSGraphは Compressed Sparse Graph の略で、スパース行列表現に基づく高速グラフアルゴリズムに焦点を当てています。

グラフ表現

まず、スパースグラフとは何か、グラフ表現でどのように役立つかを理解しましょう。

スパースグラフとは正確には何ですか？

グラフはノードのコレクションであり、ノード間にリンクがあります。 グラフはほとんどすべてを表すことができます-ソーシャルネットワーク接続。各ノードは人であり、知り合いに接続されています。画像。各ノードはピクセルであり、隣接するピクセルに接続されています。各ノードが最近傍に接続されている高次元分布のポイント。そして、あなたが想像できる他の実質的に何でも。

グラフデータを表す非常に効率的な方法の1つは、スパース行列です。これをGと呼びましょう。 マトリックスGのサイズはN x Nで、G [i、j]はノード「i」とノード「j」間の接続の値を示します。 スパースグラフには、ほとんどゼロが含まれています。つまり、ほとんどのノードには少数の接続しかありません。 このプロパティは、関心のあるほとんどの場合に当てはまります。

スパースグラフサブモジュールの作成は、以下を含むscikit-learnで使用されるいくつかのアルゴリズムによって動機付けられました-

  • Isomap -グラフ内の最短経路を見つける必要がある多様な学習アルゴリズム。
  • 階層的クラスタリング-最小スパニングツリーに基づくクラスタリングアルゴリズム。
  • スペクトル分解-スパースグラフラプラシアンに基づく投影アルゴリズム。

具体的な例として、次の無向グラフを表現したいことを想像してください-

無向グラフ

このグラフには3つのノードがあり、ノード0と1は重み2のエッジで接続され、ノード0と2は重み1のエッジで接続されています。 次の例に示すように、無向グラフは対称行列で表されることを念頭に置いて、密集したマスクされた疎な表現を構築できます。 

G_dense = np.array([ [0, 2, 1],
                     [2, 0, 0],
                     [1, 0, 0] ])

G_masked = np.ma.masked_values(G_dense, 0)
from scipy.sparse import csr_matrix

G_sparse = csr_matrix(G_dense)
print G_sparse.data

上記のプログラムは、次の出力を生成します。 

array([2, 1, 2, 1])

対称マトリックスを使用した無向グラフ

これは、ノード0と2が重みゼロのエッジで接続されていることを除いて、前のグラフと同じです。 この場合、上記の密な表現はあいまいさをもたらします。ゼロが意味のある値である場合、どのように非エッジを表現できますか。 この場合、あいまいさを解消するには、マスク表現またはスパース表現を使用する必要があります。

次の例を考えてみましょう。 

from scipy.sparse.csgraph import csgraph_from_dense
G2_data = np.array
([
   [np.inf, 2, 0 ],
   [2, np.inf, np.inf],
   [0, np.inf, np.inf]
])
G2_sparse = csgraph_from_dense(G2_data, null_value=np.inf)
print G2_sparse.data

上記のプログラムは、次の出力を生成します。 

array([ 2., 0., 2., 0.])

スパースグラフを使用したワードラダー

ワードラダーは、ルイス・キャロルが発明したゲームで、各ステップで1文字ずつ変更することで単語がリンクされます。 たとえば- 

*APE→APT→AIT→BIT→BIG→BAG→MAG→MAN*

ここでは、「APE」から「MAN」に7つのステップで進み、そのたびに1文字ずつ変更します。 問題は、同じルールを使用してこれらの単語間の短いパスを見つけることができますか？ この問題は、当然、スパースグラフの問題として表されます。 ノードは個々の単語に対応し、最大で1文字だけ異なる単語間の接続を作成します。

単語リストの取得

最初に、もちろん、有効な単語のリストを取得する必要があります。 Macを実行していますが、Macには次のコードブロックで指定された場所に単語辞書があります。 別のアーキテクチャを使用している場合、システム辞書を見つけるために少し検索する必要がある場合があります。 

wordlist = open('/usr/share/dict/words').read().split()
print len(wordlist)

上記のプログラムは、次の出力を生成します。 

235886

次に、長さ3の単語を調べたいので、正しい長さの単語だけを選択しましょう。 また、大文字（固有名詞）で始まる単語や、アポストロフィやハイフンなどの英数字以外の文字を含む単語も削除します。 最後に、後で比較するためにすべてが小文字であることを確認します。 

word_list = [word for word in word_list if len(word) == 3]
word_list = [word for word in word_list if word[0].islower()]
word_list = [word for word in word_list if word.isalpha()]
word_list = map(str.lower, word_list)
print len(word_list)

上記のプログラムは、次の出力を生成します。 

1135

これで、1135個の有効な3文字の単語のリストができました（使用されている特定のリストによって正確な数は変わる場合があります）。 これらの単語のそれぞれがグラフのノードになり、各単語のペアに関連付けられたノードを接続するエッジを作成します。これは、1文字だけ異なります。 

import numpy as np
word_list = np.asarray(word_list)

word_list.dtype
word_list.sort()

word_bytes = np.ndarray((word_list.size, word_list.itemsize),
   dtype = 'int8',
   buffer = word_list.data)
print word_bytes.shape

上記のプログラムは、次の出力を生成します。 

(1135, 3)

各ポイント間のハミング距離を使用して、どの単語のペアが接続されているかを判断します。 ハミング距離は、異なる2つのベクトル間のエントリの割合を測定します。ハミング距離が1/N1/Nに等しい2つの単語（NNはワードラダーで接続されている文字の数）。 

from scipy.spatial.distance import pdist, squareform
from scipy.sparse import csr_matrix
hamming_dist = pdist(word_bytes, metric = 'hamming')
graph = csr_matrix(squareform(hamming_dist < 1.5/word_list.itemsize))

距離を比較するとき、これは浮動小数点値に対して不安定になる可能性があるため、等式を使用しません。 単語リストの2つのエントリが同一でない限り、不等式は望ましい結果をもたらします。 グラフが設定されたので、最短パス検索を使用して、グラフ内の2つの単語間のパスを見つけます。 

i1 = word_list.searchsorted('ape')
i2 = word_list.searchsorted('man')
print word_list[i1],word_list[i2]

上記のプログラムは、次の出力を生成します。 

ape, man

単語がリストにない場合、出力にエラーがあるため、これらが一致することを確認する必要があります。 ここで必要なのは、グラフ内のこれら2つのインデックス間の最短パスを見つけることです。 dijkstra’s アルゴリズムを使用します。これにより、1つのノードだけのパスを見つけることができるためです。 

from scipy.sparse.csgraph import dijkstra
distances, predecessors = dijkstra(graph, indices = i1, return_predecessors = True)
print distances[i2]

上記のプログラムは、次の出力を生成します。 

5.0

したがって、「ape」と「man」の間の最短経路には5つのステップしか含まれていないことがわかります。 アルゴリズムによって返された先行を使用して、このパスを再構築できます。 

path = []
i = i2

while i != i1:
   path.append(word_list[i])
   i = predecessors[i]

path.append(word_list[i1])
print path[::-1]i2]

上記のプログラムは、次の出力を生成します。 

['ape', 'ope', 'opt', 'oat', 'mat', 'man']

SciPy-空間

  • scipy.spatialパッケージ*は、* Qhullライブラリ*を利用して、ポイントセットの三角形分割、ボロノイ図、凸包を計算できます。 さらに、最近隣ポイントクエリ用の* KDTree実装*と、さまざまなメトリックでの距離計算用のユーティリティが含まれています。

ドローネ三角形分割

Delaunay三角形分割とは何か、それらがSciPyでどのように使用されるかを理解しましょう。

ドローネ三角形分割とは何ですか？

数学および計算幾何学では、平面内の離散点の特定のセット P に対するドロネー三角形分割は、 P の点がDT（Pの三角形の外接円の内側にない三角形分割* DT（P）*です。 ）。

SciPyを通じて同じことを計算できます。 次の例を考えてみましょう。 

from scipy.spatial import Delaunay
points = np.array([[tri = Delaunay(points)
import matplotlib.pyplot as plt
plt.triplot(points[:,0], points[:,1], tri.simplices.copy())
plt.plot(points[:,0], points[:,1], 'o')
plt.show()

上記のプログラムは、次の出力を生成します。

Delaunay Triangulations

コプラナーポイント

コプラナーポイントとは何か、そしてそれらがSciPyでどのように使用されるかを理解しましょう。

コプラナーポイントとは何ですか？

共面点は、同じ平面にある3つ以上の点です。 平面は平らな表面であり、すべての方向に無限に広がることを思い出してください。 通常、数学の教科書では四面図として表示されます。

SciPyを使用してこれを見つける方法を見てみましょう。 次の例を考えてみましょう。 

from scipy.spatial import Delaunay
points = np.array([[tri = Delaunay(points)
print tri.coplanar

上記のプログラムは、次の出力を生成します。 

array([[dtype = int32)

つまり、ポイント4は三角形0と頂点3の近くにありますが、三角形分割には含まれていません。

凸包

凸包とは何か、SciPyでどのように使用されるかを理解しましょう。

凸包とは何ですか？

数学では、ユークリッド平面またはユークリッド空間（またはより一般的には実数上のアフィン空間）にある点Xの集合の*凸包*または*凸包*は、最小の*凸集合*です。 Xを含む

詳細を理解するために、次の例を考えてみましょう。 

from scipy.spatial import ConvexHull
points = np.random.rand(10, 2) # 30 random points in 2-D
hull = ConvexHull(points)
import matplotlib.pyplot as plt
plt.plot(points[:,0], points[:,1], 'o')
for simplex in hull.simplices:
plt.plot(points[simplex,0], points[simplex,1], 'k-')
plt.show()

上記のプログラムは、次の出力を生成します。

凸包

SciPy-ODR

ODRは、回帰研究で使用される Orthogonal Distance Regression の略です。 基本的な線形回帰は、グラフに最適な線を描くことにより、2つの変数 y と x の関係を推定するためによく使用されます。

これに使用される数学的な方法は*最小二乗*と呼ばれ、各ポイントの二乗誤差の合計を最小化することを目的としています。 ここで重要な質問は、各ポイントの誤差（残差とも呼ばれます）をどのように計算するのですか？

標準の線形回帰では、目的はX値からY値を予測することです。したがって、賢明なことは、Y値の誤差を計算することです（次の画像の灰色の線として表示）。 ただし、XとYの両方のエラーを考慮する方が賢明な場合があります（次の画像の赤い点線で示すように）。

例-Xの測定値が不確実であることがわかっている場合、または1つの変数のエラーに焦点を合わせたくない場合。

直交距離線形回帰

直交距離回帰（ODR）は、これを行うことができる方法です（このコンテキストでは直交とは、垂直を意味します。したがって、「垂直」ではなく、ラインに垂直な誤差を計算します）。

一変量回帰のscipy.odr実装

次の例は、単変量回帰のscipy.odr実装を示しています。 

import numpy as np
import matplotlib.pyplot as plt
from scipy.odr import *
import random

# Initiate some data, giving some randomness using random.random().
x = np.array([0, 1, 2, 3, 4, 5])
y = np.array([i**2 + random.random() for i in x])

# Define a function (quadratic in our case) to fit the data with.
def linear_func(p, x):
   m, c = p
   return m*x + c

# Create a model for fitting.
linear_model = Model(linear_func)

# Create a RealData object using our initiated data from above.
data = RealData(x, y)

# Set up ODR with the model and data.
odr = ODR(data, linear_model, beta0=[0., 1.])

# Run the regression.
out = odr.run()

# Use the in-built pprint method to give us results.
out.pprint()

上記のプログラムは、次の出力を生成します。 

Beta: [ 5.51846098 -4.25744878]
Beta Std Error: [ 0.7786442 2.33126407]

Beta Covariance: [
   [ 1.93150969 -4.82877433]
   [ -4.82877433 17.31417201
]]

Residual Variance: 0.313892697582
Inverse Condition #: 0.146618499389
Reason(s) for Halting:
   Sum of squares convergence

SciPy-特別パッケージ

特別なパッケージで利用可能な機能は、ブロードキャストおよび自動配列ループに続く汎用機能です。

最も頻繁に使用される特殊機能のいくつかを見てみましょう-

  • 立方根関数
  • 指数関数
  • 相対誤差指数関数
  • ログサム指数関数
  • ランバート関数
  • 順列と組み合わせ関数
  • ガンマ関数

これらの各機能について簡単に説明します。

立方根関数

この立方根関数の構文は– scipy.special.cbrt（x）です。 これにより、 x の要素単位のキューブルートが取得されます。

次の例を考えてみましょう。 

from scipy.special import cbrt
res = cbrt([10, 9, 0.1254, 234])
print res

上記のプログラムは、次の出力を生成します。 

[ 2.15443469 2.08008382 0.50053277 6.16224015]

指数関数

指数関数の構文は– scipy.special.exp10（x）です。 これは、賢明な10 ** x要素を計算します。

次の例を考えてみましょう。 

from scipy.special import exp10
res = exp10([2, 9])
print res

上記のプログラムは、次の出力を生成します。 

[1.00000000e+02  1.00000000e+09]

相対誤差指数関数

この関数の構文は– scipy.special.exprel（x）です。 相対誤差指数（exp（x）-1）/xを生成します。 

*x* がゼロに近い場合、exp（x）は1に近いため、exp（x）-1の数値計算では致命的な精度の損失が発生する可能性があります。 次に、exprel（x）を実装して、 *x* がゼロに近いときに発生する精度の損失を回避します。

次の例を考えてみましょう。 

from scipy.special import exprel
res = exprel([-0.25, -0.1, 0, 0.1, 0.25])
print res

上記のプログラムは、次の出力を生成します。 

[0.88479687 0.95162582 1.   1.05170918 1.13610167]

ログサム指数関数

この関数の構文は– scipy.special.logsumexp（x）です。 入力要素の指数の合計のログを計算するのに役立ちます。

次の例を考えてみましょう。 

from scipy.special import logsumexp
import numpy as np
a = np.arange(10)
res = logsumexp(a)
print res

上記のプログラムは、次の出力を生成します。 

9.45862974443

ランバート関数

この関数の構文は– scipy.special.lambertw（x）です。 Lambert W関数とも呼ばれます。 ランベルトのW関数W（z）は、w * exp（w）の逆関数として定義されます。 つまり、W（z）の値は、複素数zに対してz = W（z） *exp（W（z））のようになります。

Lambert W関数は、無限に多くの分岐を持つ多値関数です。 各ブランチは、方程式z = w exp（w）の個別のソリューションを提供します。 ここでは、分岐は整数kによってインデックス付けされます。

次の例を考えてみましょう。 ここで、ランベルトのW関数はw exp（w）の逆関数です。 

from scipy.special import lambertw
w = lambertw(1)
print w
print w* np.exp(w)

上記のプログラムは、次の出力を生成します。 

(0.56714329041+0j)
(1+0j)

順列と組み合わせ

それらを明確に理解するために、順列と組み合わせを個別に議論しましょう。 

*Combinations* -組み合わせ機能の構文は– scipy.special.comb（N、k）です。 私たちは次の例を考えてみましょう-
from scipy.special import comb
res = comb(10, 3, exact = False,repetition=True)
print res

上記のプログラムは、次の出力を生成します。 

220.0

注-配列引数は、exact = Falseの場合にのみ受け入れられます。 k> N、N <0、またはk <0の場合、0が返されます。

順列-組み合わせ関数の構文は– scipy.special.perm（N、k）です。 一度にk個のN個の順列、つまりNのk個の順列 これは「部分置換」とも呼ばれます。

次の例を考えてみましょう。 

from scipy.special import perm
res = perm(10, 3, exact = True)
print res

上記のプログラムは、次の出力を生成します。 

720

ガンマ関数

自然数「n」に対して、z * gamma（z）= gamma（z + 1）およびgamma（n + 1）= n！であるため、ガンマ関数はしばしば一般化階乗と呼ばれます。

組み合わせ関数の構文は– scipy.special.gamma（x）です。 一度にk個のN個の順列、つまりNのk個の順列 これは「部分置換」とも呼ばれます。

組み合わせ関数の構文は– scipy.special.gamma（x）です。 一度にk個のN個の順列、つまりNのk個の順列 これは「部分置換」とも呼ばれます。 

from scipy.special import gamma
res = gamma([0, 0.5, 1, 5])
print res

上記のプログラムは、次の出力を生成します。 

[inf  1.77245385  1.  24.]
「https://www.finddevguides.com/index.php?title=Scipy-quick-guide&oldid=79344」から取得
Powered by MediaWiki