NumPyってなんだ？〜「for文で回すな」と言われる本当の理由〜

# Pythonリストは何でも入る
mixed = [42, "hello", 3.14, True, [1, 2, 3]]

import numpy as np

# ndarrayは全要素が同じ型
arr = np.array([42, 3.14, 2.71, 1.41])
print(arr.dtype)  # float64 — 全要素がfloat64に統一されている

arr = np.array([[1, 2, 3],
                [4, 5, 6]])

print(f"dtype:   {arr.dtype}")    # int64
print(f"shape:   {arr.shape}")    # (2, 3)
print(f"strides: {arr.strides}")  # (24, 8) — 行方向に24バイト、列方向に8バイト
print(f"ndim:    {arr.ndim}")     # 2
print(f"size:    {arr.size}")     # 6（全要素数）
print(f"nbytes:  {arr.nbytes}")   # 48（6要素 × 8バイト）

import numpy as np

# 100万要素の配列
a = np.random.rand(1_000_000)
b = np.random.rand(1_000_000)

# ❌ Pythonのfor文で回す（手作業テーブル方式）
result_loop = np.empty(1_000_000)
for i in range(1_000_000):
    result_loop[i] = a[i] + b[i]

# ✅ NumPyのベクトル化演算（ベルトコンベア方式）
result_vec = a + b

import numpy as np
import time

size = 1_000_000
a = np.random.rand(size)
b = np.random.rand(size)

# --- Pythonリスト + for文 ---
a_list = a.tolist()
b_list = b.tolist()

start = time.perf_counter()
result_list = [a_list[i] + b_list[i] for i in range(size)]
elapsed_list = time.perf_counter() - start

# --- NumPy ベクトル化 ---
start = time.perf_counter()
result_np = a + b
elapsed_np = time.perf_counter() - start

print(f"Pythonリスト: {elapsed_list:.4f} 秒")
print(f"NumPy:        {elapsed_np:.6f} 秒")
print(f"速度差:       {elapsed_list / elapsed_np:.0f}倍")

import numpy as np

a = np.array([[1, 2, 3],
              [4, 5, 6]])   # shape: (2, 3)
b = np.array([10, 20, 30])  # shape: (3,)

# 形状が違うのに足せる！
c = a + b
print(c)
# [[11 22 33]
#  [14 25 36]]

# shape (3,) → shape (1, 3) に自動拡張
a = np.ones((2, 3))        # (2, 3)
b = np.array([1, 2, 3])    # (3,) → (1, 3) と解釈される

# (2, 3) と (1, 3) → 次元0: 2 vs 1 → 1を2に拡張 → OK
# (2, 3) と (2, 1) → 次元1: 3 vs 1 → 1を3に拡張 → OK
# (2, 3) と (2, 4) → 次元1: 3 vs 4 → 不一致で1でもない → NG！

a = np.ones((3, 1))    # shape: (3, 1)
b = np.ones((1, 4))    # shape: (1, 4)
c = a + b              # shape: (3, 4) — 両方が引き伸ばされる
print(c.shape)         # (3, 4)

# 例1: 各行からその行の平均を引く（行ごとの正規化）
data = np.array([[10, 20, 30],
                 [40, 50, 60]])

row_mean = data.mean(axis=1, keepdims=True)  # shape: (2, 1)
normalized = data - row_mean                  # (2, 3) - (2, 1) → ブロードキャスト

print(row_mean)
# [[20.]
#  [50.]]
print(normalized)
# [[-10.   0.  10.]
#  [-10.   0.  10.]]

# 例2: 距離行列の計算（全点間の距離を一発で計算）
points = np.random.rand(100, 2)  # 100個の2D座標

# ブロードキャスティングで全組み合わせの差を計算
diff = points[:, np.newaxis, :] - points[np.newaxis, :, :]  # (100, 100, 2)
distances = np.sqrt((diff ** 2).sum(axis=2))                 # (100, 100)
# for文なら二重ループが必要 → ベクトル化で1行

import numpy as np

original = np.array([1, 2, 3, 4, 5])

# --- view（監視カメラ）---
view = original[1:4]       # スライスはviewを返す
view[0] = 999              # viewを変更すると...
print(original)            # [  1 999   3   4   5] ← 元データも変わる！(;ﾟдﾟ)ﾎﾟｶｰﾝ

# --- copy（写真撮影）---
original = np.array([1, 2, 3, 4, 5])
copied = original[1:4].copy()  # 明示的にcopy
copied[0] = 999                # copyを変更しても...
print(original)                # [1 2 3 4 5] ← 元データは無傷

# viewかcopyかを確認する方法
a = np.array([1, 2, 3, 4, 5])

s = a[1:4]
print(s.base is a)         # True → viewである（baseが元配列を指す）

f = a[[1, 2, 3]]
print(f.base is a)         # False → copyである

a = np.arange(12)
print(a)          # [ 0  1  2  3  4  5  6  7  8  9 10 11]
print(a.strides)  # (8,) — 次の要素まで8バイト

b = a.reshape(3, 4)
print(b)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
print(b.strides)  # (32, 8) — 次の行まで32バイト、次の列まで8バイト

# メモリ上のデータは同一！
print(b.base is a)  # True — viewである

arr = np.array([[1, 2, 3],
                [4, 5, 6]])

c_arr = np.array([[1, 2, 3], [4, 5, 6]], order='C')  # C-contiguous
f_arr = np.array([[1, 2, 3], [4, 5, 6]], order='F')  # F-contiguous

print(f"C-contiguous strides: {c_arr.strides}")  # (24, 8) — 行方向に連続
print(f"F-contiguous strides: {f_arr.strides}")  # (8, 16) — 列方向に連続

import numpy as np
import time

size = 5000
arr = np.random.rand(size, size)  # C-contiguous（既定）

# 行方向の合計（メモリ連続方向 → 速い）
start = time.perf_counter()
for _ in range(100):
    _ = arr.sum(axis=1)
elapsed_row = time.perf_counter() - start

# 列方向の合計（メモリ非連続方向 → 遅い）
start = time.perf_counter()
for _ in range(100):
    _ = arr.sum(axis=0)
elapsed_col = time.perf_counter() - start

print(f"行方向合計: {elapsed_row:.4f}秒")
print(f"列方向合計: {elapsed_col:.4f}秒")
print(f"速度差:     {elapsed_col / elapsed_row:.2f}倍")

import numpy as np
import torch

# NumPy → PyTorch（ゼロコピー。メモリ共有）
np_arr = np.array([1.0, 2.0, 3.0])
tensor = torch.from_numpy(np_arr)      # メモリを共有するview

np_arr[0] = 999
print(tensor)  # tensor([999.,   2.,   3.]) ← 連動する！

# PyTorch → NumPy
tensor2 = torch.tensor([4.0, 5.0, 6.0])
np_arr2 = tensor2.numpy()  # CPU上のテンソルのみ可能

# GPU上のテンソルはcpu()で戻してからnumpy()
# gpu_tensor = tensor2.to("cuda")
# np_from_gpu = gpu_tensor.cpu().numpy()

# CuPy — NumPyのコードをほぼそのままGPUで動かせる
# pip install cupy-cuda12x
import cupy as cp

a_gpu = cp.random.rand(1_000_000)
b_gpu = cp.random.rand(1_000_000)
c_gpu = a_gpu + b_gpu  # GPU上でベクトル化演算！

# NumPy配列に戻す
c_cpu = cp.asnumpy(c_gpu)

#!/usr/bin/env python3
"""
NumPy環境診断スクリプト v1.0
- NumPyのバージョン/ビルド情報
- BLAS/LAPACKバックエンドの確認
- 基本的なベンチマーク
- メモリ使用量の見積もり
"""

import sys
import time

def diagnose_numpy():
    try:
        import numpy as np
    except ImportError:
        print("❌ NumPyがインストールされていません")
        print("   pip install numpy でインストールしてください")
        return

    print("=" * 60)
    print("  NumPy 環境診断レポート")
    print("=" * 60)

    # 1. 基本情報
    print("\n[1] NumPy基本情報")
    print(f"  バージョン:    {np.__version__}")
    print(f"  インストール先: {np.__file__}")
    print(f"  Python:        {sys.version.split()[0]}")

    # 2. ビルド構成
    print("\n[2] ビルド構成（BLAS/LAPACK）")
    try:
        config = np.show_config(mode="dicts")
        if isinstance(config, dict):
            blas = config.get("Build Dependencies", {}).get("blas", {})
            lapack = config.get("Build Dependencies", {}).get("lapack", {})
            print(f"  BLAS:   {blas.get('name', '不明')} {blas.get('version', '')}")
            print(f"  LAPACK: {lapack.get('name', '不明')} {lapack.get('version', '')}")
        else:
            print("  （詳細はnp.show_config()で確認）")
    except Exception:
        print("  （ビルド情報の取得に失敗）")
        np.show_config()

    # 3. dtypeサイズ確認
    print("\n[3] dtype別メモリサイズ")
    dtypes = [np.float16, np.float32, np.float64,
              np.int8, np.int16, np.int32, np.int64]
    for dt in dtypes:
        print(f"  {dt.__name__:10s}: {np.dtype(dt).itemsize} bytes")

    # 4. 簡易ベンチマーク
    print("\n[4] 簡易ベンチマーク（100万要素）")
    size = 1_000_000
    a = np.random.rand(size)
    b = np.random.rand(size)

    # 加算
    start = time.perf_counter()
    for _ in range(100):
        _ = a + b
    elapsed = time.perf_counter() - start
    print(f"  加算(float64) × 100回:   {elapsed:.4f}秒")

    # 行列積
    m = np.random.rand(500, 500)
    start = time.perf_counter()
    for _ in range(10):
        _ = m @ m
    elapsed = time.perf_counter() - start
    print(f"  行列積(500×500) × 10回:  {elapsed:.4f}秒")

    # ソート
    arr = np.random.rand(size)
    start = time.perf_counter()
    _ = np.sort(arr)
    elapsed = time.perf_counter() - start
    print(f"  ソート(100万要素):        {elapsed:.4f}秒")

    # 5. メモリ見積もり
    print("\n[5] 配列サイズ別メモリ使用量（float64）")
    shapes = [(1000,), (1000, 1000), (10000, 1000), (1000, 1000, 10)]
    for shape in shapes:
        nbytes = np.prod(shape) * 8  # float64 = 8bytes
        if nbytes < 1024**2:
            mem = f"{nbytes / 1024:.1f} KB"
        elif nbytes < 1024**3:
            mem = f"{nbytes / 1024**2:.1f} MB"
        else:
            mem = f"{nbytes / 1024**3:.2f} GB"
        print(f"  shape {str(shape):20s} → {mem}")

    print("\n" + "=" * 60)
    print("  診断完了")
    print("=" * 60)


if __name__ == "__main__":
    diagnose_numpy()

import numpy as np
from PIL import Image

# 画像を読み込んでNumPy配列に変換
img = np.array(Image.open("photo.jpg"))
print(f"shape: {img.shape}")    # 例: (1080, 1920, 3) — フルHD RGB
print(f"dtype: {img.dtype}")    # uint8 (0-255)

# グレースケール変換（ベクトル化演算で一発）
gray = np.dot(img[..., :3], [0.2989, 0.5870, 0.1140]).astype(np.uint8)

# 明るさ調整（ブロードキャスティング）
brighter = np.clip(img.astype(np.int16) + 50, 0, 255).astype(np.uint8)

# 結果を保存
Image.fromarray(gray).save("gray.jpg")
Image.fromarray(brighter).save("brighter.jpg")

import numpy as np

def estimate_pi(n_samples: int = 1_000_000) -> float:
    """モンテカルロ法で円周率を推定する"""
    # 0〜1の一様乱数を生成（ベクトル化）
    x = np.random.rand(n_samples)
    y = np.random.rand(n_samples)

    # 原点からの距離が1以下の点を数える（ベクトル化）
    inside = (x**2 + y**2) <= 1.0

    # 円の面積 / 正方形の面積 = π/4
    pi_estimate = 4.0 * np.sum(inside) / n_samples
    return pi_estimate

# 実行
pi = estimate_pi(10_000_000)
print(f"推定値: {pi:.6f}")
print(f"誤差:   {abs(pi - np.pi):.6f}")

import numpy as np

# サンプルデータ（100サンプル × 5特徴量）
data = np.random.randn(100, 5) * [1, 10, 100, 1000, 10000] + [0, 50, 500, 5000, 50000]

# Min-Maxスケーリング（ブロードキャスティング活用）
data_min = data.min(axis=0)                    # shape: (5,)
data_max = data.max(axis=0)                    # shape: (5,)
scaled = (data - data_min) / (data_max - data_min)  # (100, 5)にブロードキャスト

print(f"スケーリング前: min={data.min(axis=0)[:3]}, max={data.max(axis=0)[:3]}")
print(f"スケーリング後: min={scaled.min(axis=0)[:3]}, max={scaled.max(axis=0)[:3]}")

# 標準化（Z-score正規化）
mean = data.mean(axis=0)
std = data.std(axis=0)
standardized = (data - mean) / std

print(f"標準化後: mean≈{standardized.mean(axis=0).round(6)[:3]}")
print(f"標準化後: std≈{standardized.std(axis=0).round(4)[:3]}")

# 外れ値検出（3σルール）
outliers = np.abs(standardized) > 3
print(f"外れ値の数: {outliers.sum()} / {data.size}個中")