【2026年版】Python機械学習完全入門｜scikit-learn・PyTorch・TensorFlowで実践AIエンジニアへ

機械学習・ディープラーニングはエンジニアの必須スキルとなっています。この記事では、Pythonで機械学習を始めるための基礎から、scikit-learn、PyTorch、TensorFlow/Kerasを使った実装まで、ステップバイステップで解説します。

機械学習の基礎知識

機械学習の種類

• 🎓 教師あり学習：正解ラベル付きデータで学習（分類・回帰）
• 🔍 教師なし学習：ラベルなしデータのパターン発見（クラスタリング・次元削減）
• 🎮 強化学習：環境との相互作用で最適方策を学習
• 🔄 転移学習：学習済みモデルを別タスクに応用

環境構築：Python機械学習の開発環境

# 仮想環境の作成
python -m venv ml-env
source ml-env/bin/activate  # Linux/Mac
# ml-env\Scripts\activate  # Windows

# 主要ライブラリのインストール
pip install numpy pandas scikit-learn matplotlib seaborn
pip install torch torchvision torchaudio  # PyTorch
pip install tensorflow                    # TensorFlow
pip install jupyter notebook             # Jupyter Notebook

scikit-learnで機械学習入門

データの前処理

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.impute import SimpleImputer

# データの読み込み
df = pd.read_csv('data.csv')

# 欠損値の確認と補完
print(df.isnull().sum())
imputer = SimpleImputer(strategy='mean')
df[numeric_cols] = imputer.fit_transform(df[numeric_cols])

# カテゴリ変数のエンコーディング
le = LabelEncoder()
df['category'] = le.fit_transform(df['category'])

# 特徴量とターゲットの分離
X = df.drop('target', axis=1)
y = df['target']

# 訓練データとテストデータの分割
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 標準化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

分類モデルの実装と評価

from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
from sklearn.model_selection import cross_val_score

# 複数モデルの比較
models = {
    'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42),
    'Gradient Boosting': GradientBoostingClassifier(random_state=42),
    'Logistic Regression': LogisticRegression(random_state=42),
    'SVM': SVC(kernel='rbf', random_state=42)
}

results = {}
for name, model in models.items():
    # 交差検証
    cv_scores = cross_val_score(model, X_train_scaled, y_train, cv=5, scoring='accuracy')
    results[name] = {
        'cv_mean': cv_scores.mean(),
        'cv_std': cv_scores.std()
    }
    print(f"{name}: {cv_scores.mean():.4f} (+/- {cv_scores.std():.4f})")

# 最良モデルの訓練と評価
best_model = RandomForestClassifier(n_estimators=100, random_state=42)
best_model.fit(X_train_scaled, y_train)
y_pred = best_model.predict(X_test_scaled)

print("\nTest Accuracy:", accuracy_score(y_test, y_pred))
print("\nClassification Report:")
print(classification_report(y_test, y_pred))

PyTorchでディープラーニング

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# デバイスの設定（GPU/CPU自動選択）
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"Using device: {device}")

# ニューラルネットワークの定義
class MLP(nn.Module):
    def __init__(self, input_size: int, hidden_sizes: list, output_size: int):
        super(MLP, self).__init__()
        
        layers = []
        prev_size = input_size
        
        for hidden_size in hidden_sizes:
            layers.extend([
                nn.Linear(prev_size, hidden_size),
                nn.BatchNorm1d(hidden_size),
                nn.ReLU(),
                nn.Dropout(0.3)
            ])
            prev_size = hidden_size
        
        layers.append(nn.Linear(prev_size, output_size))
        self.network = nn.Sequential(*layers)
    
    def forward(self, x):
        return self.network(x)

# モデルの初期化
model = MLP(input_size=10, hidden_sizes=[64, 32], output_size=2).to(device)
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)
criterion = nn.CrossEntropyLoss()
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=5)

# 訓練ループ
def train_epoch(model, loader, optimizer, criterion):
    model.train()
    total_loss = 0
    correct = 0
    
    for X_batch, y_batch in loader:
        X_batch, y_batch = X_batch.to(device), y_batch.to(device)
        
        optimizer.zero_grad()
        outputs = model(X_batch)
        loss = criterion(outputs, y_batch)
        loss.backward()
        
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
        optimizer.step()
        
        total_loss += loss.item()
        correct += (outputs.argmax(1) == y_batch).sum().item()
    
    return total_loss / len(loader), correct / len(loader.dataset)

まとめ：機械学習エンジニアへのロードマップ

機械学習をマスターするには、理論と実践の両方が重要です。まずはscikit-learnで基本的な機械学習パイプラインを理解し、次にPyTorchでディープラーニングの実装方法を学びましょう。Kaggleなどのデータサイエンスコンテストへの参加も、実践的なスキルを磨く良い方法です。