[Python] NumPy – ベクトルの演算(加算/減算/乗算/除算)を行う方法

NumPyを使用すると、ベクトルの演算(加算、減算、乗算、除算)を簡単に行うことができます。

NumPyの配列numpy.ndarrayを使って、要素ごとの演算が可能です。

例えば、2つのベクトル a と b に対して、加算は a + b、減算は a - b、乗算は a * b、除算は a / b で行います。

これらの演算は要素ごとに適用され、ベクトルの次元が一致している必要があります。

NumPyでベクトルの加算を行う方法

ベクトルの加算とは？

ベクトルの加算は、同じ次元のベクトル同士の対応する要素を足し合わせる操作です。

例えば、2つのベクトル \(\mathbf{a} = [a_1, a_2, a_3]\) と \(\mathbf{b} = [b_1, b_2, b_3]\) がある場合、加算の結果は次のようになります。

\[\mathbf{c} = \mathbf{a} + \mathbf{b} = [a_1 + b_1, a_2 + b_2, a_3 + b_3]\]

NumPyでのベクトル加算の基本

NumPyを使用すると、ベクトルの加算を簡単に行うことができます。

以下は、NumPyを使ったベクトル加算の基本的なサンプルコードです。

import numpy as np
# ベクトルの定義
vector_a = np.array([1, 2, 3])
vector_b = np.array([4, 5, 6])
# ベクトルの加算
result = vector_a + vector_b
print(result)

[5 7 9]

このコードでは、np.arrayを使って2つのベクトルを定義し、+演算子を使って加算を行っています。

結果は新しいベクトルとして得られます。

異なる次元のベクトルを加算する場合

異なる次元のベクトルを加算する場合、NumPyはブロードキャスト機能を利用して自動的に次元を調整します。

以下の例では、1次元のベクトルと2次元のベクトルを加算しています。

import numpy as np
# 1次元ベクトルと2次元ベクトルの定義
vector_a = np.array([1, 2, 3])
vector_b = np.array([[4, 5, 6], [7, 8, 9]])
# ベクトルの加算
result = vector_a + vector_b
print(result)

[[5 7 9]
 [8 10 12]]

このように、1次元のベクトルが2次元のベクトルに対して加算され、各行に対して同じベクトルが加算される結果が得られます。

ブロードキャストを利用した加算

ブロードキャストは、異なる形状の配列同士の演算を可能にするNumPyの機能です。

例えば、スカラー値をベクトルに加算する場合、スカラーは自動的にベクトルの形状に拡張されます。

以下の例を見てみましょう。

import numpy as np
# ベクトルの定義
vector_a = np.array([1, 2, 3])
# スカラーの加算
scalar = 5
result = vector_a + scalar
print(result)

[6 7 8]

この例では、スカラー値5がベクトルの各要素に加算され、結果として新しいベクトルが得られます。

ブロードキャストを利用することで、異なる形状の配列同士の演算が簡単に行えるのがNumPyの大きな利点です。

NumPyでベクトルの減算を行う方法

ベクトルの減算とは？

ベクトルの減算は、同じ次元のベクトル同士の対応する要素を引き算する操作です。

例えば、2つのベクトル \(\mathbf{a} = [a_1, a_2, a_3]\) と \(\mathbf{b} = [b_1, b_2, b_3]\) がある場合、減算の結果は次のようになります。

\[\mathbf{c} = \mathbf{a} – \mathbf{b} = [a_1 – b_1, a_2 – b_2, a_3 – b_3]\]

NumPyでのベクトル減算の基本

NumPyを使用すると、ベクトルの減算を簡単に行うことができます。

以下は、NumPyを使ったベクトル減算の基本的なサンプルコードです。

import numpy as np
# ベクトルの定義
vector_a = np.array([7, 8, 9])
vector_b = np.array([1, 2, 3])
# ベクトルの減算
result = vector_a - vector_b
print(result)

[6 6 6]

このコードでは、np.arrayを使って2つのベクトルを定義し、-演算子を使って減算を行っています。

結果は新しいベクトルとして得られます。

異なる次元のベクトルを減算する場合

異なる次元のベクトルを減算する場合も、NumPyはブロードキャスト機能を利用して自動的に次元を調整します。

以下の例では、1次元のベクトルと2次元のベクトルを減算しています。

import numpy as np
# 1次元ベクトルと2次元ベクトルの定義
vector_a = np.array([10, 20, 30])
vector_b = np.array([[1, 2, 3], [4, 5, 6]])
# ベクトルの減算
result = vector_a - vector_b
print(result)

[[ 9 18 27]
 [ 6 15 24]]

このように、1次元のベクトルが2次元のベクトルに対して減算され、各行に対して同じベクトルが減算される結果が得られます。

ブロードキャストを利用した減算

ブロードキャストは、異なる形状の配列同士の演算を可能にするNumPyの機能です。

例えば、スカラー値をベクトルから減算する場合、スカラーは自動的にベクトルの形状に拡張されます。

以下の例を見てみましょう。

import numpy as np
# ベクトルの定義
vector_a = np.array([10, 20, 30])
# スカラーの減算
scalar = 5
result = vector_a - scalar
print(result)

[ 5 15 25]

この例では、スカラー値5がベクトルの各要素から減算され、結果として新しいベクトルが得られます。

ブロードキャストを利用することで、異なる形状の配列同士の演算が簡単に行えるのがNumPyの大きな利点です。

NumPyでベクトルの乗算を行う方法

ベクトルの乗算とは？

ベクトルの乗算には主に2つの方法があります。

1つは要素ごとの乗算(アダマール積)で、もう1つは内積や外積です。

要素ごとの乗算は、同じ次元のベクトルの対応する要素を掛け合わせる操作です。

内積は2つのベクトルのスカラー値を返し、外積は3次元空間における新しいベクトルを生成します。

NumPyでの要素ごとの乗算

NumPyを使用すると、ベクトルの要素ごとの乗算を簡単に行うことができます。

以下は、NumPyを使った要素ごとの乗算の基本的なサンプルコードです。

import numpy as np
# ベクトルの定義
vector_a = np.array([1, 2, 3])
vector_b = np.array([4, 5, 6])
# 要素ごとの乗算
result = vector_a * vector_b
print(result)

[ 4 10 18]

このコードでは、*演算子を使って2つのベクトルの要素ごとの乗算を行っています。

結果は新しいベクトルとして得られます。

スカラーとの乗算

スカラーとの乗算も非常に簡単です。

スカラー値をベクトルに掛けると、ベクトルの各要素がそのスカラー値で乗算されます。

以下の例を見てみましょう。

import numpy as np
# ベクトルの定義
vector_a = np.array([2, 4, 6])
# スカラーの定義
scalar = 3
# スカラーとの乗算
result = vector_a * scalar
print(result)

[ 6 12 18]

この例では、スカラー値3がベクトルの各要素に掛けられ、結果として新しいベクトルが得られます。

内積と外積の違い

内積と外積は、ベクトルの乗算において異なる結果を返します。

内積は2つのベクトルのスカラー値を返し、次のように計算されます。

\[\mathbf{a} \cdot \mathbf{b} = a_1b_1 + a_2b_2 + a_3b_3\]

一方、外積は3次元空間における新しいベクトルを生成し、次のように計算されます。

\[\mathbf{a} \times \mathbf{b} = \begin{vmatrix}\mathbf{i} & \mathbf{j} & \mathbf{k} \\a_1 & a_2 & a_3 \\b_1 & b_2 & b_3\end{vmatrix}\]

NumPyでの内積の計算方法

NumPyでは、内積を計算するためにnp.dot()関数または@演算子を使用します。

以下は、内積の計算方法のサンプルコードです。

import numpy as np
# ベクトルの定義
vector_a = np.array([1, 2, 3])
vector_b = np.array([4, 5, 6])
# 内積の計算
inner_product = np.dot(vector_a, vector_b)
# または inner_product = vector_a @ vector_b
print(inner_product)

32

このコードでは、np.dot()関数を使って2つのベクトルの内積を計算しています。

結果はスカラー値として得られます。

NumPyでの外積の計算方法

外積を計算するには、NumPyのnp.cross()関数を使用します。

以下は、外積の計算方法のサンプルコードです。

import numpy as np
# 3次元ベクトルの定義
vector_a = np.array([1, 2, 3])
vector_b = np.array([4, 5, 6])
# 外積の計算
cross_product = np.cross(vector_a, vector_b)
print(cross_product)

[-3  6 -3]

このコードでは、np.cross()関数を使って2つの3次元ベクトルの外積を計算しています。

結果は新しいベクトルとして得られます。

内積と外積の違いを理解することで、ベクトルの演算をより効果的に活用できます。

NumPyでベクトルの除算を行う方法

ベクトルの除算とは？

ベクトルの除算は、同じ次元のベクトル同士の対応する要素を割り算する操作です。

例えば、2つのベクトル \(\mathbf{a} = [a_1, a_2, a_3]\) と \(\mathbf{b} = [b_1, b_2, b_3]\) がある場合、除算の結果は次のようになります。

\[\mathbf{c} = \frac{\mathbf{a}}{\mathbf{b}} = \left[\frac{a_1}{b_1}, \frac{a_2}{b_2}, \frac{a_3}{b_3}\right]\]

ただし、ベクトル \(\mathbf{b}\) の要素がゼロの場合、除算は未定義となります。

NumPyでの要素ごとの除算

NumPyを使用すると、ベクトルの要素ごとの除算を簡単に行うことができます。

以下は、NumPyを使った要素ごとの除算の基本的なサンプルコードです。

import numpy as np
# ベクトルの定義
vector_a = np.array([10, 20, 30])
vector_b = np.array([2, 4, 5])
# 要素ごとの除算
result = vector_a / vector_b
print(result)

[ 5.  5.  6.]

このコードでは、/演算子を使って2つのベクトルの要素ごとの除算を行っています。

結果は新しいベクトルとして得られます。

スカラーとの除算

スカラーとの除算も非常に簡単です。

スカラー値をベクトルで割ると、ベクトルの各要素がそのスカラー値で割られます。

以下の例を見てみましょう。

import numpy as np
# ベクトルの定義
vector_a = np.array([10, 20, 30])
# スカラーの定義
scalar = 2
# スカラーとの除算
result = vector_a / scalar
print(result)

[ 5. 10. 15.]

この例では、スカラー値2がベクトルの各要素で割られ、結果として新しいベクトルが得られます。

ゼロ除算の対処法

ゼロ除算が発生すると、NumPyはinf(無限大)またはnan(非数)を返します。

これを避けるためには、除算を行う前にゼロをチェックするか、np.errstateを使用して警告を抑制することができます。

以下は、ゼロ除算を避ける方法の例です。

import numpy as np
# ベクトルの定義
vector_a = np.array([10, 20, 30])
vector_b = np.array([2, 0, 5])  # 0が含まれている
# ゼロ除算を避けるための処理
with np.errstate(divide='ignore', invalid='ignore'):
    result = np.divide(vector_a, vector_b)
    result[vector_b == 0] = 0  # ゼロで割った場合は0に設定
print(result)

[ 5.  0.  6.]

このコードでは、np.errstateを使用してゼロ除算の警告を抑制し、ゼロで割った場合の結果を手動で設定しています。

これにより、計算結果がより安全に得られます。

応用例：ベクトル演算を使った実践的な計算

ベクトルの正規化

ベクトルの正規化とは、ベクトルの長さを1にする操作です。

正規化されたベクトルは、方向を保持しつつ、単位ベクトルになります。

正規化は、ベクトルをその大きさで割ることで行います。

以下は、NumPyを使ったベクトルの正規化のサンプルコードです。

import numpy as np
# ベクトルの定義
vector = np.array([3, 4])
# ベクトルの正規化
norm = np.linalg.norm(vector)  # ベクトルの大きさ
normalized_vector = vector / norm
print(normalized_vector)

[0.6 0.8]

このコードでは、np.linalg.norm()を使ってベクトルの大きさを計算し、それを使って正規化を行っています。

ベクトルの距離計算(ユークリッド距離)

ユークリッド距離は、2つのベクトル間の直線距離を計算する方法です。

2つのベクトル \(\mathbf{a}\) と \(\mathbf{b}\) のユークリッド距離は次のように計算されます。

\[\text{距離} = \sqrt{(a_1 – b_1)^2 + (a_2 – b_2)^2 + (a_3 – b_3)^2}\]

以下は、NumPyを使ったユークリッド距離の計算方法です。

import numpy as np
# ベクトルの定義
vector_a = np.array([1, 2, 3])
vector_b = np.array([4, 5, 6])
# ユークリッド距離の計算
distance = np.linalg.norm(vector_a - vector_b)
print(distance)

5.196152422706632

このコードでは、2つのベクトルの差を計算し、その大きさを求めることでユークリッド距離を得ています。

ベクトルの角度計算(コサイン類似度)

コサイン類似度は、2つのベクトル間の角度を計算する方法で、ベクトルの方向の類似性を測る指標です。

コサイン類似度は次のように計算されます。

\[\text{コサイン類似度} = \frac{\mathbf{a} \cdot \mathbf{b}}{||\mathbf{a}|| \cdot ||\mathbf{b}||}\]

以下は、NumPyを使ったコサイン類似度の計算方法です。

import numpy as np
# ベクトルの定義
vector_a = np.array([1, 2, 3])
vector_b = np.array([4, 5, 6])
# コサイン類似度の計算
cosine_similarity = np.dot(vector_a, vector_b) / (np.linalg.norm(vector_a) * np.linalg.norm(vector_b))
print(cosine_similarity)

0.9746318461970762

このコードでは、内積とベクトルの大きさを使ってコサイン類似度を計算しています。

値が1に近いほど、ベクトルの方向が似ていることを示します。

ベクトルの射影

ベクトルの射影は、あるベクトルを別のベクトルに投影する操作です。

ベクトル \(\mathbf{a}\) をベクトル \(\mathbf{b}\) に射影する場合、次のように計算されます。

\[\text{射影} = \frac{\mathbf{a} \cdot \mathbf{b}}{||\mathbf{b}||^2} \cdot \mathbf{b}\]

以下は、NumPyを使ったベクトルの射影の計算方法です。

import numpy as np
# ベクトルの定義
vector_a = np.array([3, 4])
vector_b = np.array([1, 0])
# ベクトルの射影
projection = (np.dot(vector_a, vector_b) / np.dot(vector_b, vector_b)) * vector_b
print(projection)

[3. 0.]

このコードでは、ベクトルの射影を計算し、結果を得ています。

ベクトルの線形結合

ベクトルの線形結合は、複数のベクトルをスカラー係数で重み付けして合成する操作です。

例えば、ベクトル \(\mathbf{a}\) と \(\mathbf{b}\) の線形結合は次のように表されます。

\[c_1 \mathbf{a} + c_2 \mathbf{b}\]

以下は、NumPyを使ったベクトルの線形結合の計算方法です。

import numpy as np
# ベクトルの定義
vector_a = np.array([1, 2])
vector_b = np.array([3, 4])
# スカラー係数の定義
c1 = 2
c2 = 3
# ベクトルの線形結合
linear_combination = c1 * vector_a + c2 * vector_b
print(linear_combination)

[11 16]

このコードでは、2つのベクトルにスカラー係数を掛けて線形結合を計算しています。

ベクトル演算を活用することで、さまざまな実践的な計算が可能になります。

まとめ

この記事では、NumPyを使用したベクトルの演算方法について詳しく解説しました。

具体的には、ベクトルの加算、減算、乗算、除算の基本的な操作から、応用例としてベクトルの正規化や距離計算、コサイン類似度、射影、線形結合に至るまで、さまざまな計算手法を紹介しました。

これらの知識を活用することで、データ分析や機械学習などの分野でのベクトル演算を効果的に行うことができるでしょう。

ぜひ、実際のプロジェクトや課題にNumPyを取り入れて、ベクトル演算のスキルをさらに磨いてみてください。