PyTorch基礎：テンソル操作から始める深層学習¶

import torch
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# MPSが利用されているかを確認
# 期待値　tensor([1.], device='mps:0')
if torch.backends.mps.is_available():
    mps_device = torch.device("mps")
    x = torch.ones(1, device=mps_device)
    print (x)
else:
    print ("MPS device not found.")

# scalar 1つの数字
scalar = torch.tensor(7)
print(scalar.ndim)  # 次元数を表示
# 単一の値を含むテンソルからPythonの数値を取得するために使用します
print(scalar.item())  # Pythonの数値として取得

# Vector 方向を持つ数値（例: 風速と方向）ですが、他の多くの数値を持つこともできます
vector = torch.tensor([7, 7])
vector.ndim, vector.shape

# Matrix 数値の2次元配列
# 大文字は一般的です
MATRIX = torch.tensor([[1, 3],
                       [2, 4]])
print(MATRIX)
print(MATRIX.ndim)
print(MATRIX.shape)
print(MATRIX[0])  # 最初の行を取得

# Tensor 数値のn次元配列
# 大文字は一般的です
TENSOR = torch.tensor([[[1, 2, 3],
                        [3, 4, 5],
                        [5, 6, 7]]])
print(TENSOR)
print(TENSOR.ndim)
print(TENSOR.shape)
print(TENSOR[0][1][1])  # 特定の要素にアクセス

# 3×4のランダムテンソルを作成
random_tensor = torch.rand(3, 4)
random_tensor, random_tensor.ndim

# 画像テンソルと同様の形状でランダムテンソルを作成
random_image_size_tensor = torch.rand(size=(3, 224, 224))  # R, G, B
random_image_size_tensor.shape, random_image_size_tensor.ndim

# すべての要素が0のテンソルを作成
zeros = torch.zeros((3, 4))
zeros

# すべての要素が1のテンソルを作成
ones = torch.ones((3, 4))
ones.dtype, ones

# torch.range()は非推奨のため、torch.arange()を使用
torch.range(0, 10)  # 警告が表示される
torch.arange(0, 10)  # 推奨される方法
one_to_ten = torch.arange(start=1, end=10, step=2)
one_to_ten

# 既存テンソルと同じ形状でゼロ埋めテンソルを作成
ten_zeros = torch.zeros_like(input=one_to_ten)
ten_zeros

# Float 32 tensor
float_32_tensor = torch.tensor([3.0, 4.0, 5.0],
                                dtype=torch.float32,  # デフォルトはNone（torch.float32）
                                device="mps",  # デバイス指定（MPS使用）
                                requires_grad=False)  # 勾配計算の要否
float_32_tensor

# 32ビットから16ビット浮動小数点に変換
float_16_tensor = float_32_tensor.type(torch.float16)
float_16_tensor

# 異なるデータ型のテンソル同士の演算
float_32_tensor * float_16_tensor

# テンソルを作成
some_tensor = torch.rand(3, 4)
print(some_tensor)
print(f"Datatype of tensor: {some_tensor.dtype}")
print(some_tensor.shape)
print(some_tensor.device)

tensor = torch.tensor([1, 3, 5])
print(tensor + 10)    # 加算
print(tensor - 10)    # 減算
print(tensor * 10)    # 乗算
print(tensor / 10)    # 除算
print(torch.mul(tensor, 10))    # 関数を使った乗算
print(torch.add(tensor, 10))    # 関数を使った加算

# ベクトルの内積計算
# 1*1 + 2*2 + 3*3 = 14
tensor_a = torch.tensor([1, 2, 3])
tensor_b = torch.tensor([1, 2, 3])
torch.matmul(tensor_a, tensor_b)

# 形状を確認しながら行列を定義
tensor_A = torch.tensor([[1, 2],
                         [3, 4],
                         [5, 6]], dtype=torch.float32)

tensor_B = torch.tensor([[7, 10],
                         [8, 11], 
                         [9, 12]], dtype=torch.float32)

# torch.matmul(tensor_A, tensor_B)  # これはエラーになる

print(torch.matmul(tensor_A, tensor_B.T))

# 詳細な説明
print(f"元の形状: tensor_A = {tensor_A.shape}, tensor_B = {tensor_B.shape}\n")
print(f"新しい形状: tensor_A = {tensor_A.shape} (同じ), tensor_B.T = {tensor_B.T.shape}\n")
print(f"乗算: {tensor_A.shape} * {tensor_B.T.shape} <- 内側の次元が一致\n")
print("結果:\n")
output = torch.matmul(tensor_A, tensor_B.T)
print(output) 
print(f"\n出力の形状: {output.shape}")

# テンソルを作成
x = torch.arange(0, 100, 10)
print(x, x.dtype)
print(torch.min(x))      # 最小値
print(x.min())           # 同上（メソッド版）
print(torch.max(x))      # 最大値
print(x.max())           # 同上（メソッド版）
# 平均値計算にはfloat型が必要
print(torch.mean(x.type(torch.float32)))
print(torch.sum(x))      # 合計
print(x.sum())           # 同上（メソッド版）

# 最大値・最小値のインデックスを取得
print(x.argmax())  # 最大値の位置
print(x.argmin())  # 最小値の位置

# テンソルを作成
x = torch.arange(1., 10.)
print(x, x.shape)

# 形状を変更
x_reshaped = x.reshape(3, 3)
print(x_reshaped, x_reshaped.shape)

# ビューを作成（データを共有）
z = x.view(3, 3)
print(z, z.shape)

# ビューを変更すると元のテンソルも変更される
z[:, 0] = 5
print(z, x)

# テンソルを積み重ねる
x_stacked = torch.stack([x, x], dim=1)
print(x)
print(x_stacked, x_stacked.shape)

# サイズ1の次元を削除
x = torch.zeros(2, 1, 2, 1, 2)
x_squeeze = torch.squeeze(x)
print(x_squeeze, x_squeeze.size())

# 次元を追加
print(f"元のテンソル: {x_squeeze}")
print(f"元の形状: {x_squeeze.shape}")

x_unsqueezed = x_squeeze.unsqueeze(dim=1)
print(x_unsqueezed, x_unsqueezed.shape)

# 次元の順序を変更（カラー画像の例）
x_original = torch.rand(size=(224, 224, 3))  # Height, Width, Channels
x_permuted = torch.permute(x_original, (2, 0, 1))  # Channels, Height, Width
print(x_permuted.shape)
print(x_original.shape)

# ビューなので同じメモリを共有
x_permuted[0, 0, 0] = 2222
print(x_original[0, 0, 0], x_permuted[0, 0, 0])

# テンソルを作成
x = torch.arange(1, 10).reshape(1, 3, 3)
print(x, x.shape)

# インデックスによるアクセス
print(x[0])          # 最初の次元
print(x[0][0])       # 最初の行
print(x[0][0][0])    # 特定の要素

# スライス記法
print(x[:, 0, :])    # すべての0番目の行
print(x[:, :, 0])    # すべての0番目の列
print(x[:, 0, 0])    # 特定の位置の要素

import numpy as np

# NumPy配列からPyTorchテンソルへ
array = np.arange(1.0, 8.0)
tensor = torch.from_numpy(array).type(torch.float32)
print(array.dtype)
print(array, tensor, tensor.dtype)

# 配列を変更（新しいオブジェクトを作成）
array = array * 10
print(array, tensor)  # tensorは変更されない

# PyTorchテンソルからNumPy配列へ
tensor = torch.ones(8)
numpy_tensor = tensor.numpy()
print(tensor, numpy_tensor, numpy_tensor.dtype)

# テンソルを変更（新しいオブジェクトを作成）
tensor = tensor * 10
print(tensor, numpy_tensor)  # numpy_tensorは変更されない

# 再現性なしの例
random_tensor_A = torch.rand(3, 4)
random_tensor_B = torch.rand(3, 4)

print(random_tensor_A)
print(random_tensor_B)
print(random_tensor_A == random_tensor_B)

# 再現性ありの例
RANDOM_SEED = 42
torch.manual_seed(RANDOM_SEED)
random_tensor_C = torch.rand(3, 4)
torch.manual_seed(RANDOM_SEED)
random_tensor_D = torch.rand(3, 4)

print(random_tensor_C)
print(random_tensor_D)
print(random_tensor_C == random_tensor_D)

# Apple Silicon Mac用のMPSデバイス設定
device = "mps" if torch.backends.mps.is_available() else "cpu"
print(device)

# CPUテンソルを作成
tensor = torch.tensor([1, 2, 3])
print(tensor, tensor.device)

# MPSデバイスに移動
tensor_on_gpu = tensor.to(device)
print(tensor_on_gpu)

# NumPyはGPUを直接サポートしないため、CPUに戻す必要がある
# tensor_on_gpu.numpy()  # これはエラーになる

# CPUに戻してからNumPy配列に変換
tensor_back_on_cpu = tensor_on_gpu.cpu().numpy()
print(tensor_back_on_cpu)