【2026年版】Python機械学習完全ガイド｜scikit-learn・PyTorch・Transformersで始めるAI開発入門

Pythonで機械学習を始めるための環境構築

機械学習の世界に入るためには、まず適切な開発環境を整えることが重要です。2026年現在、最も効率的なセットアップ方法をご紹介します。

# condaで仮想環境を作成
conda create -n ml-env python=3.12
conda activate ml-env

# 主要ライブラリをインストール
pip install numpy pandas matplotlib seaborn scikit-learn
pip install torch torchvision torchaudio
pip install transformers datasets accelerate
pip install jupyter notebook ipywidgets

機械学習の基礎：scikit-learnで学ぶ

データの前処理

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

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

# 欠損値の処理
df.fillna(df.mean(), inplace=True)

# 特徴量とラベルの分離
X = df.drop("target", axis=1)
y = df["target"]

# 学習・テストデータに分割（8:2）
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 標準化
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.metrics import classification_report, confusion_matrix, roc_auc_score
import matplotlib.pyplot as plt
import seaborn as sns

# ランダムフォレストモデル
rf_model = RandomForestClassifier(
    n_estimators=100,
    max_depth=10,
    random_state=42,
    n_jobs=-1
)
rf_model.fit(X_train_scaled, y_train)

# 評価
y_pred = rf_model.predict(X_test_scaled)
print(classification_report(y_test, y_pred))
print(f"AUC-ROC: {roc_auc_score(y_test, rf_model.predict_proba(X_test_scaled)[:, 1]):.4f}")

# 特徴量重要度の可視化
feature_importance = pd.Series(
    rf_model.feature_importances_, index=X.columns
).sort_values(ascending=False)

plt.figure(figsize=(10, 6))
feature_importance.head(10).plot(kind="bar")
plt.title("Feature Importance")
plt.tight_layout()
plt.savefig("feature_importance.png")

PyTorchで深層学習モデルを構築

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

# GPU利用確認
device = torch.device("cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu")
print(f"Using device: {device}")

# ニューラルネットワークの定義
class MLPClassifier(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, dropout=0.3):
        super().__init__()
        self.network = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.BatchNorm1d(hidden_dim),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim, hidden_dim // 2),
            nn.BatchNorm1d(hidden_dim // 2),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim // 2, output_dim)
        )
    
    def forward(self, x):
        return self.network(x)

# モデルの初期化
model = MLPClassifier(input_dim=20, hidden_dim=128, output_dim=2).to(device)

# 損失関数と最適化
criterion = nn.CrossEntropyLoss()
optimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)

TransformersとHugging Faceで最新NLPを実装

from transformers import AutoTokenizer, AutoModelForSequenceClassification
from transformers import TrainingArguments, Trainer
import torch

# 日本語BERTモデルのロード
model_name = "cl-tohoku/bert-base-japanese-v3"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(
    model_name, num_labels=2
)

# テキスト分類の推論
texts = ["この映画は面白かったです", "このレストランはひどかった"]
inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt")

with torch.no_grad():
    outputs = model(**inputs)
    predictions = torch.softmax(outputs.logits, dim=-1)
    print(predictions)  # 各クラスの確率

LLMのファインチューニング（LoRA）

2026年現在、大規模言語モデル（LLM）のファインチューニングにはLoRA（Low-Rank Adaptation）が標準的手法です。

from peft import LoraConfig, get_peft_model, TaskType
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

# 4bit量子化でモデルをロード（VRAMを節約）
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

base_model = AutoModelForCausalLM.from_pretrained(
    "elyza/Llama-3-ELYZA-JP-8B",
    quantization_config=bnb_config,
    device_map="auto"
)

# LoRA設定
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM
)

model = get_peft_model(base_model, lora_config)
model.print_trainable_parameters()  # 学習可能パラメータ数を表示

まとめ：機械学習学習ロードマップ

Python機械学習の学習ロードマップとして、①scikit-learnでML基礎→②PyTorchでDL基礎→③TransformersでNLP→④LLMファインチューニングの順で学ぶことをおすすめします。実際にKaggleコンペに参加することで、実践的なスキルが身につきます。