「プログラミング」カテゴリーアーカイブ

前回の記事

「🧠 Pythonで学ぶ画像認識入門：TensorFlowとKerasで手書き数字を判定する方法(2) ～実践サンプルコード編～」

では、全結合層（Dense Layer）のみを使った
シンプルなニューラルネットワークで手書き数字を認識しました。

今回はその続編として、
より高い精度を実現するために

🌀 CNN（畳み込みニューラルネットワーク）
🌊 Dropoutによる過学習防止
⚙️ 学習率調整（Learning Rate Scheduling）

を導入した「高精度モデル版」を構築します。

🧩 動作環境（同シリーズ共通）





	項目 バージョン・設定内容




	OS Windows 11 Pro（64bit）


	Python 3.13.7（公式版インストーラ）


	pip 25.2


	仮想環境 venv（C:\python_env\env）


	TensorFlow 2.20.0


	matplotlib 3.10.6

🧱 ステップ①：CNNを使ったモデル構築

CNNは画像認識に特化したネットワーク構造で、
人間の「目」と同じように特徴（輪郭・形・濃淡）を自動的に抽出します。

import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
from tensorflow.keras.optimizers import Adam

# ---------- フォント設定（日本語対策） ----------
plt.rcParams['font.family'] = ['Meiryo', 'Yu Gothic', 'MS Gothic']
plt.rcParams['axes.unicode_minus'] = False

# ---------- データ読み込み ----------
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# ---------- CNN用にデータ形状を変換 ----------
x_train = x_train.reshape(-1, 28, 28, 1) / 255.0
x_test = x_test.reshape(-1, 28, 28, 1) / 255.0

# ---------- モデル構築 ----------
model = Sequential([
    Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)),
    MaxPooling2D((2,2)),
    Conv2D(64, (3,3), activation='relu'),
    MaxPooling2D((2,2)),
    Flatten(),
    Dropout(0.5),  # 過学習防止
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

import numpy as np

import matplotlib.pyplot as plt

from tensorflow.keras.datasets import mnist

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout

from tensorflow.keras.optimizers import Adam

# ---------- フォント設定（日本語対策） ----------

plt.rcParams['font.family'] = ['Meiryo', 'Yu Gothic', 'MS Gothic']

plt.rcParams['axes.unicode_minus'] = False

# ---------- データ読み込み ----------

(x_train, y_train), (x_test, y_test) = mnist.load_data()

# ---------- CNN用にデータ形状を変換 ----------

x_train = x_train.reshape(-1, 28, 28, 1) / 255.0

x_test = x_test.reshape(-1, 28, 28, 1) / 255.0

# ---------- モデル構築 ----------

model = Sequential([

Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)),

MaxPooling2D((2,2)),

Conv2D(64, (3,3), activation='relu'),

MaxPooling2D((2,2)),

Flatten(),

Dropout(0.5), # 過学習防止

Dense(128, activation='relu'),

Dense(10, activation='softmax')

])

⚙️ ステップ②：学習率を調整して最適化

Adam オプティマイザの learning_rate を指定することで、
勾配更新のスピードを細かく制御できます。

optimizer = Adam(learning_rate=0.001)  # 通常より少し低めで安定化
model.compile(optimizer=optimizer,
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

optimizer = Adam(learning_rate=0.001) # 通常より少し低めで安定化

model.compile(optimizer=optimizer,

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

📈 ステップ③：学習を実行

学習中の精度や損失の推移がターミナルに表示されます👇

🧾 ステップ④：テストデータで評価

CNNを導入したことで、精度は 約99％前後 に向上します🚀

🧠 ステップ⑤：予測結果の可視化

📊 ステップ⑥：精度の推移をグラフ化（オプション）

plt.plot(history.history['accuracy'], label='train_acc')
plt.plot(history.history['val_accuracy'], label='val_acc')
plt.title('学習精度の推移')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.show()

plt.plot(history.history['accuracy'], label='train_acc')

plt.plot(history.history['val_accuracy'], label='val_acc')

plt.title('学習精度の推移')

plt.xlabel('Epoch')

plt.ylabel('Accuracy')

plt.legend()

plt.show()

このグラフで、学習が過学習に陥っていないか確認できます。

💾 手順まとめ：ファイル保存〜実行まで

① ファイルを作成

任意のテキストエディタ（例：VSCode、メモ帳、サクラエディタなど）で
以下のコードをコピーして貼り付けてください。

ファイル名は：

② コード内容（完全版）

# =========================================
# Pythonで学ぶ画像認識入門
# TensorFlow + Keras (CNN高精度モデル)
# =========================================

import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
from tensorflow.keras.optimizers import Adam

# ---------- 日本語フォント設定 ----------
plt.rcParams['font.family'] = ['Meiryo', 'Yu Gothic', 'MS Gothic']
plt.rcParams['axes.unicode_minus'] = False

# ---------- データ読み込み ----------
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# ---------- CNN用にデータ形状を変換 ----------
x_train = x_train.reshape(-1, 28, 28, 1) / 255.0
x_test = x_test.reshape(-1, 28, 28, 1) / 255.0

# ---------- CNNモデル構築 ----------
model = Sequential([
    Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)),
    MaxPooling2D((2,2)),
    Conv2D(64, (3,3), activation='relu'),
    MaxPooling2D((2,2)),
    Flatten(),
    Dropout(0.5),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

# ---------- オプティマイザ（学習率調整） ----------
optimizer = Adam(learning_rate=0.001)
model.compile(optimizer=optimizer,
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# ---------- モデル学習 ----------
print("🔹 モデル学習開始中...")
history = model.fit(x_train, y_train, epochs=10, batch_size=128,
                    validation_data=(x_test, y_test))

# ---------- 評価 ----------
print("\n🔹 テストデータで評価中...")
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"✅ Test accuracy: {test_acc:.4f}")

# ---------- 予測 ----------
predictions = model.predict(x_test)
index = 0
plt.imshow(x_test[index].reshape(28,28), cmap='gray')
plt.title(f"予測結果: {np.argmax(predictions[index])}")
plt.show()

# ---------- 精度の推移グラフ ----------
plt.plot(history.history['accuracy'], label='train_acc')
plt.plot(history.history['val_accuracy'], label='val_acc')
plt.title('学習精度の推移')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.show()

# =========================================

# Pythonで学ぶ画像認識入門

# TensorFlow + Keras (CNN高精度モデル)

# =========================================

import numpy as np

import matplotlib.pyplot as plt

from tensorflow.keras.datasets import mnist

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout

from tensorflow.keras.optimizers import Adam

# ---------- 日本語フォント設定 ----------

plt.rcParams['font.family'] = ['Meiryo', 'Yu Gothic', 'MS Gothic']

plt.rcParams['axes.unicode_minus'] = False

# ---------- データ読み込み ----------

(x_train, y_train), (x_test, y_test) = mnist.load_data()

# ---------- CNN用にデータ形状を変換 ----------

x_train = x_train.reshape(-1, 28, 28, 1) / 255.0

x_test = x_test.reshape(-1, 28, 28, 1) / 255.0

# ---------- CNNモデル構築 ----------

model = Sequential([

Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)),

MaxPooling2D((2,2)),

Conv2D(64, (3,3), activation='relu'),

MaxPooling2D((2,2)),

Flatten(),

Dropout(0.5),

Dense(128, activation='relu'),

Dense(10, activation='softmax')

])

# ---------- オプティマイザ（学習率調整） ----------

optimizer = Adam(learning_rate=0.001)

model.compile(optimizer=optimizer,

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

# ---------- モデル学習 ----------

print("🔹 モデル学習開始中...")

history = model.fit(x_train, y_train, epochs=10, batch_size=128,

validation_data=(x_test, y_test))

# ---------- 評価 ----------

print("\n🔹 テストデータで評価中...")

test_loss, test_acc = model.evaluate(x_test, y_test)

print(f"✅ Test accuracy: {test_acc:.4f}")

# ---------- 予測 ----------

predictions = model.predict(x_test)

index = 0

plt.imshow(x_test[index].reshape(28,28), cmap='gray')

plt.title(f"予測結果: {np.argmax(predictions[index])}")

plt.show()

# ---------- 精度の推移グラフ ----------

plt.plot(history.history['accuracy'], label='train_acc')

plt.plot(history.history['val_accuracy'], label='val_acc')

plt.title('学習精度の推移')

plt.xlabel('Epoch')

plt.ylabel('Accuracy')

plt.legend()

plt.show()

③ 保存場所

わかりやすくするために、
これまでと同じフォルダ内（例：C:\python_env）に保存するのがおすすめです。

④ 実行手順

1️⃣ 仮想環境を有効化（重要）：

⑤ 実行結果

学習が進むと各 Epoch ごとの精度が表示される
終了時に

✅ Test accuracy: 0.9935

のような高精度結果が出る
その後、
- AIが予測した数字画像（例：「7」）
- 学習精度グラフ（train_acc / val_acc）
  が順に表示されます

⑥ 終了後

仮想環境を終了：

🚀 結果と考察

比較項目	前回（Dense）	今回（CNN＋Dropout）	考察
モデル構造	全結合層のみ	畳み込み+プーリング	CNNが画像の空間特徴を直接学習でき、汎化性能が向上
エポック数	5	10	学習回数は増えるが精度向上に寄与
学習時間（目安）	約5秒	約20秒	パラメータが増えるため計算時間は増加
精度（テスト）	約97.6%	約99.2%	CNN導入で+1〜2ポイント改善
過学習対策	なし	Dropout(0.5)	Dropoutにより汎化が改善し、過学習を抑制

CNNを導入することで、特徴抽出の自動化が進み、
より安定した高精度の画像認識が可能になりました。

💡 応用ポイント

🔹 BatchNormalization を追加するとさらに安定化
🔹 データ拡張（ImageDataGenerator） で汎化性能アップ
🔹 モデル保存：model.save("mnist_cnn_model.h5")

✅ まとめ

本記事では、

CNN（畳み込みニューラルネットワーク）＋Dropout＋学習率調整
を導入して、手書き数字認識AIを高精度化しました。

精度は 約99％ に到達し、実用的な画像認識モデルの基礎が完成です。

🔜 次回予告

「(4) 学習済みモデルを使って自分の手書き画像を判定する」

自分で描いた数字画像を読み込んで、
AIがそれを正しく識別できるか試してみましょう🖋️

Python, ブログ, プログラミング

🧠 Pythonで学ぶ画像認識入門：TensorFlowとKerasで手書き数字を判定する方法(2) ～実践サンプルコード編～

2025年10月5日管理者 1件のコメント

前回の記事
「🧠Pythonで学ぶ画像認識入門：TensorFlowとKerasで手書き数字を判定する方法(1) ～環境構築編～」

では、

「Python公式版＋仮想環境を使ったTensorFlow開発環境構築」
を行い、AI開発の準備が整いました。

今回はその続編として、
実際にTensorFlowとKerasを使って手書き数字を判定するAIモデルを作る実践編 を解説します。
データの読み込みからモデルの学習・評価・予測までを、
最小限のシンプルなコードで体験してみましょう。

🧩 動作環境（前回と同じ構成）





	項目 バージョン・設定内容




	OS Windows 11 Pro（64bit）


	Python 3.13.7（公式版インストーラ）


	pip 25.2


	仮想環境 venv（C:\python_env\env）


	TensorFlow 2.20.0


	matplotlib 3.10.6

🧠 ステップ①：MNISTデータセットを読み込む

TensorFlowには「手書き数字データ（MNIST）」が標準で付属しています👇

from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt

# データ読み込み（訓練用6万枚、テスト用1万枚）
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 画像を確認
plt.imshow(x_train[0], cmap='gray')
plt.title(f"Label: {y_train[0]}")
plt.show()

from tensorflow.keras.datasets import mnist

import matplotlib.pyplot as plt

# データ読み込み（訓練用6万枚、テスト用1万枚）

(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 画像を確認

plt.imshow(x_train[0], cmap='gray')

plt.title(f"Label: {y_train[0]}")

plt.show()

🧩 ステップ②：データの前処理

🧩 ステップ③：モデル構築（Keras Sequential）

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten

model = Sequential([
    Flatten(input_shape=(28, 28)),  # 28x28ピクセル → 1次元ベクトル
    Dense(128, activation='relu'),  # 隠れ層
    Dense(10, activation='softmax') # 出力層（0〜9）
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense, Flatten

model = Sequential([

Flatten(input_shape=(28, 28)), # 28x28ピクセル → 1次元ベクトル

Dense(128, activation='relu'), # 隠れ層

Dense(10, activation='softmax') # 出力層（0〜9）

])

model.compile(optimizer='adam',

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

🧩 ステップ④：学習を実行

🧩 ステップ⑤：テストデータで評価

🧩 ステップ⑥：実際に予測してみる

import numpy as np

predictions = model.predict(x_test)
index = 0

plt.imshow(x_test[index], cmap='gray')
plt.title(f"予測結果: {np.argmax(predictions[index])}")
plt.show()

import numpy as np

predictions = model.predict(x_test)

index = 0

plt.imshow(x_test[index], cmap='gray')

plt.title(f"予測結果: {np.argmax(predictions[index])}")

plt.show()

AIが画像を認識して、数字を正しく判定してくれます👀✨

ステップ①～⑥のコードについて

各ステップは、順番に実行される処理の流れを分けて説明しているだけで、
実際のプログラムとしては 連続して動く1つのコード になります。

つまり、実際に実行する場合は次のようにすべてまとめて書いて問題ありません👇

✅ 例：`mnist_sample.py` として保存する内容

# =========================================
# Pythonで学ぶ画像認識入門
# TensorFlow + Keras 実践サンプル（MNIST判定）
# 文字化け対策版
# =========================================

import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten

# ---------- 日本語フォント設定 ----------
plt.rcParams['font.family'] = ['Meiryo', 'Yu Gothic', 'MS Gothic']  # Windows向け
plt.rcParams['axes.unicode_minus'] = False  # マイナス記号の文字化け防止

# ---------- データ読み込み ----------
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# ---------- 前処理 ----------
x_train = x_train / 255.0
x_test = x_test / 255.0

# ---------- モデル構築 ----------
model = Sequential([
    Flatten(input_shape=(28, 28)),      # 画像を1次元に変換
    Dense(128, activation='relu'),      # 中間層
    Dense(10, activation='softmax')     # 出力層（0～9）
])

# ---------- モデルのコンパイル ----------
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# ---------- 学習 ----------
print("🔹 モデル学習開始中...")
model.fit(x_train, y_train, epochs=5)

# ---------- 評価 ----------
print("\n🔹 テストデータで評価中...")
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"✅ Test accuracy: {test_acc:.4f}")

# ---------- 予測 ----------
predictions = model.predict(x_test)
index = 0
predicted_label = np.argmax(predictions[index])

# ---------- 結果表示 ----------
plt.imshow(x_test[index], cmap='gray')
plt.title(f"予測結果: {predicted_label}")
plt.show()

# =========================================

# Pythonで学ぶ画像認識入門

# TensorFlow + Keras 実践サンプル（MNIST判定）

# 文字化け対策版

# =========================================

import numpy as np

import matplotlib.pyplot as plt

from tensorflow.keras.datasets import mnist

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense, Flatten

# ---------- 日本語フォント設定 ----------

plt.rcParams['font.family'] = ['Meiryo', 'Yu Gothic', 'MS Gothic'] # Windows向け

plt.rcParams['axes.unicode_minus'] = False # マイナス記号の文字化け防止

# ---------- データ読み込み ----------

(x_train, y_train), (x_test, y_test) = mnist.load_data()

# ---------- 前処理 ----------

x_train = x_train / 255.0

x_test = x_test / 255.0

# ---------- モデル構築 ----------

model = Sequential([

Flatten(input_shape=(28, 28)), # 画像を1次元に変換

Dense(128, activation='relu'), # 中間層

Dense(10, activation='softmax') # 出力層（0～9）

])

# ---------- モデルのコンパイル ----------

model.compile(optimizer='adam',

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

# ---------- 学習 ----------

print("🔹 モデル学習開始中...")

model.fit(x_train, y_train, epochs=5)

# ---------- 評価 ----------

print("\n🔹 テストデータで評価中...")

test_loss, test_acc = model.evaluate(x_test, y_test)

print(f"✅ Test accuracy: {test_acc:.4f}")

# ---------- 予測 ----------

predictions = model.predict(x_test)

index = 0

predicted_label = np.argmax(predictions[index])

# ---------- 結果表示 ----------

plt.imshow(x_test[index], cmap='gray')

plt.title(f"予測結果: {predicted_label}")

plt.show()

💾 保存と実行

C:\python_env などに上記を mnist_sample.py として保存
仮想環境を有効化：

MS DOS

cd C:\python_env env\Scripts\activate

1

cd C:\python_env env\Scripts\activate
実行：

MS DOS

python mnist_sample.py

1

python mnist_sample.py
実行例

📊 補足：精度向上のヒント

CNN（畳み込みニューラルネットワーク） を導入する
Dropout で過学習を防止
エポック数や学習率 の調整

これらを追加すると、より実践的なモデルになります。

🚀 まとめ

本記事では、
TensorFlowとKerasを用いて「手書き数字判定AI」を実装しました。

これで、

データの前処理
モデル構築
学習・評価・予測
というAIの基本的な流れを一通り理解できたはずです。

次回

「🧠 Pythonで学ぶ画像認識入門：TensorFlowとKerasで手書き数字を判定する方法(3) ～CNNによる高精度モデル編～」

は、CNNを用いた高精度モデル化（第3回） に挑戦します🔥

Python, ブログ, プログラミング

🧠 Pythonで学ぶ画像認識入門：TensorFlowとKerasで手書き数字を判定する方法(1) ～環境構築編～

2025年10月4日管理者 1件のコメント

AIや機械学習に興味がある方にとって、「画像認識」は最初の一歩として最適なテーマです。
今回は Python + TensorFlow + Keras を使って、手書き数字を自動判定するプログラムを実際に作ってみましょう。
有名な「MNIST（エムニスト）」という手書き数字データセットを使うことで、数十行のコードで高精度な認識が可能になります。

～公式版インストールから仮想環境・動作確認まで～

💻 環境例

項目	バージョン・設定内容
OS	Windows 11 Pro（64bit）
Python	3.13.7（公式版インストーラ）
pip	25.2
仮想環境	venv（C:\python_env\env）
TensorFlow	2.20.0
matplotlib	3.10.6

🧩 ステップ①：公式Pythonのインストール

1️⃣ Python公式サイトへアクセス

👉 https://www.python.org/downloads/windows/

2️⃣ 最新の「Windows installer (64-bit)」をダウンロード

①Downloads → Windows を選択し、「Latest Python 3 Release – Python 3.13.7」をクリック

②画面下にある「Windows installer (64-bit)」をクリックしてダウンロード

3️⃣ インストーラ起動後の設定

以下のチェックを必ず確認してください。

✅ Add python.exe to PATH
✅ Use admin privileges when installing py.exe
➡ 「Customize installation」を選択して進む

4️⃣ Advanced Options の設定

☑ Install Python 3.13 for all users
☑ Add Python to environment variables
☑ Precompile standard library
📁 インストール先を以下に変更：

C:\Python313

5️⃣ 「Install」をクリックして完了！

🧩 ステップ②：インストール確認

インストール完了後、コマンドプロンプトで以下を実行👇

🧩 ステップ③：仮想環境の作成と有効化

プロジェクト専用の仮想環境を作成して、ライブラリの競合を防ぎます。

🧩 ステップ④：TensorFlowとmatplotlibをインストール

仮想環境が有効な状態で以下を実行👇

🧩 ステップ⑤：動作確認

TensorFlowが正常に動作しているか確認します。

※ oneDNN に関する警告が表示されても正常です。
性能最適化のための通知なので無視してOKです。

🧩 ステップ⑥：仮想環境の管理コマンドまとめ

操作内容	コマンド
仮想環境を終了	deactivate
仮想環境を再開	cd C:\python_env && env\Scripts\activate
ライブラリ一覧確認	pip list
仮想環境の削除	rmdir /s /q C:\python_env

✅ まとめ

この手順で構築すれば、
Windows上で安定して動作する TensorFlow + Keras + matplotlib 環境が整います。
AI学習・画像認識・データ分析など、あらゆるPython開発に対応可能です💡

💬 次回予告

「🧠 Pythonで学ぶ画像認識入門：TensorFlowとKerasで手書き数字を判定する方法(2) ～実践サンプルコード編～」

では、「TensorFlowとKerasで手書き数字を判定する」実践サンプルコード

を紹介します。
実際にMNISTデータセットを使って、
AIが数字を“読む”プロセスを一緒に学んでいきましょう。

HTML, ブログ, プログラミング

JavaScriptなしで実現！HTML5 Canvasアニメーションで魅せるWeb装飾

2025年10月4日管理者コメントする

HTML5の登場以降、Webデザインの表現力は大きく進化しました。
その中でも<canvas>タグは、まるで映像作品のような動きをブラウザ上で描くための強力な機能です。

「アニメーション＝JavaScriptが必要」と思われがちですが、実はJavaScriptを使わずにCanvasを動かす方法も存在します。
今回は、HTML5の<canvas>タグだけで実現できる動くWeb装飾について紹介します。

🖋️ `<canvas>`タグの基本とは？

<canvas>タグは、HTML5で導入されたグラフィック描画用の要素です。
通常はJavaScriptを使って図形やアニメーションを描きますが、近年はCSSアニメーションやSVG、さらにはGIF・APNGを組み合わせてCanvasを動かす手法も増えています。

さらに、CSSや画像アニメーションを活用することで、JavaScriptなしでも“動きを感じさせる”デザインを作ることができます。

🌊 JavaScriptなしで実現する波紋・粒子エフェクト

近年注目されているのが、Canvasを静的画像やCSSアニメーションと組み合わせるアプローチです。

✅ 例：波紋エフェクト（CSS連携）

<div class="ripple-wrap">
  <canvas class="ripple"></canvas>
</div>

<style>
/* 表示領域 */
.ripple-wrap{
  position: relative;
  width: 100%;
  height: 320px;          /* 必要に応じて変更 */
  overflow: hidden;
  border-radius: 12px;
  background: #0b1020;    /* 下地色（任意） */
}

/* CanvasにCSSアニメーション（JSなし） */
.ripple{
  display: block;
  width: 100%;
  height: 100%;
  background: radial-gradient(circle at 50% 55%,
    rgba(255,255,255,0.40) 0%,
    rgba(255,255,255,0.30) 10%,
    rgba(255,255,255,0.10) 25%,
    rgba(255,255,255,0.00) 55%);
  animation: rippleEffect 3.6s ease-out infinite;
  transform-origin: 50% 55%;
}

@keyframes rippleEffect{
  0%   { transform: scale(0.55); opacity: 0.9; }
  60%  { opacity: 0.35; }
  100% { transform: scale(2.2); opacity: 0; }
}
</style>

</div>

<style>

/* 表示領域 */

.ripple-wrap{

position: relative;

width: 100%;

height: 320px; /* 必要に応じて変更 */

overflow: hidden;

border-radius: 12px;

background: #0b1020; /* 下地色（任意） */

}

/* CanvasにCSSアニメーション（JSなし） */

.ripple{

display: block;

width: 100%;

height: 100%;

background: radial-gradient(circle at 50% 55%,

rgba(255,255,255,0.40) 0%,

rgba(255,255,255,0.30) 10%,

rgba(255,255,255,0.10) 25%,

rgba(255,255,255,0.00) 55%);

animation: rippleEffect 3.6s ease-out infinite;

transform-origin: 50% 55%;

}

@keyframes rippleEffect{

0% { transform: scale(0.55); opacity: 0.9; }

60% { opacity: 0.35; }

100% { transform: scale(2.2); opacity: 0; }

}

</style>

これだけで、Canvas上に波紋が広がるような演出をCSSだけで表現できます。

動的スクリプトが不要なので、ローディング画面やメインビジュアルにも最適です。

サンプル

✨ パーティクル風の演出も可能

粒子（パーティクル）をイメージした演出も、背景のCanvasを複数重ねることで再現可能です。
たとえば、透明度の異なる複数のCanvasレイヤーをCSSで重ねると、光がゆらめくような表現になります。

.particles canvas {
  position: absolute;
  top: 0; left: 0;
  width: 100%; height: 100%;
  background: radial-gradient(circle, rgba(255,255,255,0.1), transparent 80%);
  animation: float 8s infinite alternate;
}
@keyframes float {
  from { transform: translateY(0); }
  to { transform: translateY(-20px); }
}

.particles canvas {

position: absolute;

top: 0; left: 0;

width: 100%; height: 100%;

background: radial-gradient(circle, rgba(255,255,255,0.1), transparent 80%);

animation: float 8s infinite alternate;

}

@keyframes float {

from { transform: translateY(0); }

to { transform: translateY(-20px); }

}

これにより、動きを感じさせる静かな装飾が可能になります。

サンプル

🧩 活用シーン

HTML5 Canvasを使った静的アニメーションは、以下のような場面で効果的です。

🌐 ローディング画面：シンプルで軽量な波紋アニメーションを表示
🖼️ メインビジュアル：粒子や光を使った背景エフェクト
🔲 ボタンホバー時：クリック誘導に動きを加える
💻 プレゼン用サイト：静かな動きでブランド感を演出

💬 まとめ

JavaScriptを使わなくても、HTML5 Canvasを上手く活用すれば軽量で美しいアニメーション表現が可能です。
CSSやCanvasレイヤーを組み合わせることで、Webサイト全体の印象を大きく向上させることができます。

「動き＝JS」ではなく、「表現＝HTML5 × CSS × Canvas」
これが、モダンWebデザインの新しいアプローチです。

Java, ブログ, プログラミング

Javaの例外テストが楽になる！JUnit5のassertThrows便利な使い方

2025年10月4日管理者コメントする

1. assertThrowsとは？

JUnit5で例外をテストする際に便利なのが assertThrows です。
従来は try-catch を使って例外を検証していましたが、コードが冗長になりがちでした。JUnit5から追加された assertThrows を使うと、例外発生をシンプルにテストできます。

import static org.junit.jupiter.api.Assertions.assertThrows;

@Test
void testException() {
    assertThrows(IllegalArgumentException.class, () -> {
        throw new IllegalArgumentException("不正な引数です");
    });
}

import static org.junit.jupiter.api.Assertions.assertThrows;

@Test

void testException() {

assertThrows(IllegalArgumentException.class, () -> {

throw new IllegalArgumentException("不正な引数です");

});

}

これだけで 「この処理で IllegalArgumentException が発生すること」 を確認できます。

2. 旧来のtry-catch方式との比較

JUnit4までの書き方は以下のようになります。

@Test
void testExceptionOld() {
    try {
        someService.doSomething(null);
        fail("例外が発生するはず");
    } catch (IllegalArgumentException e) {
        assertEquals("不正な引数です", e.getMessage());
    }
}

@Test

void testExceptionOld() {

try {

someService.doSomething(null);

fail("例外が発生するはず");

} catch (IllegalArgumentException e) {

assertEquals("不正な引数です", e.getMessage());

}

fail を入れたり、catchブロック内で assertEquals を書く必要があり、テストコードが長くなっていました。
assertThrows を使えば、これを 1行でシンプルに記述可能 です。

3. 例外メッセージの検証

assertThrows は戻り値として発生した例外オブジェクトを返すため、メッセージや詳細を検証することも可能です。@Test

void testExceptionMessage() {
    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
        someService.doSomething("invalid");
    });
    assertEquals("不正な引数です", exception.getMessage());
}

void testExceptionMessage() {

IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {

someService.doSomething("invalid");

});

assertEquals("不正な引数です", exception.getMessage());

}

これにより 例外種別だけでなく、エラーメッセージの妥当性 も簡単にチェックできます。

4. 複数の例外クラスに対応

もし異なる種類の例外が発生する可能性がある場合、複数の assertThrows を組み合わせてテストできます。

@Test
void testMultipleExceptions() {
    assertThrows(NullPointerException.class, () -> {
        someService.doSomething(null);
    });

    assertThrows(IllegalArgumentException.class, () -> {
        someService.doSomething("invalid");
    });
}

@Test

void testMultipleExceptions() {

assertThrows(NullPointerException.class, () -> {

someService.doSomething(null);

});

assertThrows(IllegalArgumentException.class, () -> {

someService.doSomething("invalid");

});

}

これにより、条件ごとに発生する例外をきちんと検証できます。

5. assertThrowsを使うメリットまとめ

コードがシンプル：try-catchやfailを省略できる
例外メッセージの検証が容易
複数パターンの例外を簡潔に記述可能
可読性が向上し、保守性もアップ

まとめ

JUnit5の assertThrows を使えば、例外発生テストがとてもスッキリ書けるようになります。
「テストコードの読みやすさ・保守性を高めたい」という方には必須のテクニックです。
これを取り入れるだけで、テストがより楽しく、効率的になるので試してみましょう！

Python, プログラミング

ゼロから学ぶ！Pythonで気軽にデータ分析入門

2025年10月3日管理者コメントする

「Pythonでデータ分析を始めたいけど、難しそう…」
そんな初心者の方でも大丈夫！この記事では、家計簿や売上のような身近なデータを題材にして、Pythonで「データを読み込む → 集計 → グラフにする」までを体験します。

まずは小さな一歩から。ゲーム感覚で数字を扱っていくうちに、自然とデータ分析の基礎が身につきます。

サンプル環境

本記事の内容は以下の環境で動作確認しています。

項目	バージョン / ツール
OS	Windows 11 Pro 24H2
Python	3.12.6
pip	24.2
エディタ	PowerShell / VS Code
ライブラリ	pandas 2.x / matplotlib 3.x / openpyxl 3.x

Pythonとは？

Python（パイソン） は、シンプルで分かりやすいプログラミング言語です。

文法がやさしい → 初めてでも読みやすい
豊富なライブラリ → 家計簿、売上管理、グラフ化などすぐ活用できる
学習者が多い → ネットに解説記事や質問回答がたくさん

今回は「pandas」「matplotlib」を使って、データを簡単に扱う方法を学びます。

1. Pythonをインストール

Windows 11なら Microsoft Store からインストールするのが簡単です。

スタート → Microsoft Store → 「Python」で検索
今回は最新版の「Python 3.13」をインストールします
※ダウンロードすると自動的にインストールされます。

2. 動作確認

PowerShellで次を実行：

3. 必要なライブラリをインストール

successfullyと上記の様に表示されればインストール正常終了してます。

4. サンプルデータ

家計簿や売上のようなシンプルなデータを用意します。

sales.csv

5. Pythonで分析！4つの出力を体験

パターン① コンソール出力（数字で確認）

ファイル名を sample.py にして、わかりやすい場所（例：C:\Users\〇〇\Documents\python\）に保存します。

import pandas as pd

df = pd.read_csv("sales.csv")
daily_sales = df.groupby("date")["sales"].sum()
print(daily_sales)

import pandas as pd

df = pd.read_csv("sales.csv")

daily_sales = df.groupby("date")["sales"].sum()

print(daily_sales)

「sample.py 」を保存したディレクトリに移動し、powershell でpython sample.pyと入力して実行すると以下の様に表示されます。

出力例：

👉 「今日は使いすぎた？」がすぐ分かります。

パターン② グラフ出力（見やすく可視化）

import pandas as pd
import matplotlib.pyplot as plt

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

# 日付ごとの合計を集計
daily_sales = df.groupby("date")["sales"].sum()

# 集計結果を表示
print(daily_sales)

# グラフで可視化
daily_sales.plot(kind="bar", title="Daily Expenses")
plt.xlabel("Date")
plt.ylabel("Sales")
plt.tight_layout()
plt.show()

import pandas as pd

import matplotlib.pyplot as plt

# データを読み込み

df = pd.read_csv("sales.csv")

# 日付ごとの合計を集計

daily_sales = df.groupby("date")["sales"].sum()

# 集計結果を表示

print(daily_sales)

# グラフで可視化

daily_sales.plot(kind="bar", title="Daily Expenses")

plt.xlabel("Date")

plt.ylabel("Sales")

plt.tight_layout()

plt.show()

出力イメージ：

👉 支出の増減がひと目で分かります。

パターン③ ファイルに保存（CSV・画像）

import pandas as pd
import matplotlib.pyplot as plt

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

# 日付ごとの合計を集計
daily_sales = df.groupby("date")["sales"].sum()

# 集計結果をCSVに保存
daily_sales.to_csv("result.csv")

# グラフを画像ファイルに保存
daily_sales.plot(kind="bar", title="Daily Expenses")
plt.xlabel("Date")
plt.ylabel("Sales")
plt.tight_layout()
plt.savefig("daily_expenses.png")  # ← PNGファイルで保存

import pandas as pd

import matplotlib.pyplot as plt

# データを読み込み

df = pd.read_csv("sales.csv")

# 日付ごとの合計を集計

daily_sales = df.groupby("date")["sales"].sum()

# 集計結果をCSVに保存

daily_sales.to_csv("result.csv")

# グラフを画像ファイルに保存

daily_sales.plot(kind="bar", title="Daily Expenses")

plt.xlabel("Date")

plt.ylabel("Sales")

plt.tight_layout()

plt.savefig("daily_expenses.png") # ← PNGファイルで保存

👉 結果をExcelや画像にして保存すれば、あとで見返したり人に見せたりできます。

パターン④ Notebookで出力

Jupyter Notebookを使えば、

ステップ1: Notebookを起動

PowerShell で以下を実行します：

pip install notebook
python -m notebook

1 2	pip install notebook python -m notebook

👉 ブラウザが開くので「File → New → Notebook → Python 3」で新しいノートブックを作ります。

ステップ2: セルごとにコードを書く

セル1: データ読み込み

import pandas as pd

df = pd.read_csv("sales.csv")
df   # ← Notebookではprint不要。最後にdfと書けば表形式で出力される

import pandas as pd

df = pd.read_csv("sales.csv")

df # ← Notebookではprint不要。最後にdfと書けば表形式で出力される

👉セルを選択し、Shift + Enterで実行すると表がセルの下にきれいに表示されます。

Notebookの特徴

print()不要 → 変数名だけで表や集計結果が表示される

グラフはセル下に直接描画

コード・結果・グラフが一つの画面でまとまって見やすい

✅ まとめると、記事で紹介したパターン④のコードはそのまま動きますが、Notebookではprintを省略して変数名だけ書けばOK という違いがあります。

👉 家計簿アプリ感覚で扱えて便利です。

まとめ

Pythonは初心者でも気軽に始められる
データ分析の出力には4パターンある
1. 数字で見る（コンソール）
2. グラフで見る（可視化）
3. ファイルに保存（CSV・PNG）
4. Notebookでまとめる
まずは「日ごとの支出」を分析してみるとイメージしやすい

Java, ブログ, プログラミング

ログ出力が一気に効率化！log4j2を使うべき場面とは

2025年10月2日管理者コメントする

Java開発におけるログ出力は、障害解析・性能改善・監査の三種の神器。長年使われてきた log4j 1.x に対し、後継の log4j2 は「高速・柔軟・安全」に大幅進化しています。本稿では、違いが直感的に分かる比較と、**失敗しない導入手順（Maven/Gradle、設定、非同期化、移行の落とし穴まで）**をまとめます。

1. log4j 1.x と log4j2 の要点比較

観点	log4j 1.x	log4j2
パフォーマンス	同期中心。大量ログでアプリに負荷	LMAX Disruptorによる非同期ロガーで高速・低レイテンシ
設定形式	properties / XML のみ	XML / JSON / YAML / properties、ホットリロード対応
非同期化	AsyncAppenderのみ	AsyncAppender＋Async Logger（全ロガー非同期も可）
GC負荷	文字列連結が発生しやすくGC負担増	遅延評価（ラムダ/プレースホルダ）で不要時は連結処理なし
拡張性	限定的	フィルタ / レイアウト / Appender が豊富（JSON出力、Failover等）
メンテナンス	EoL（保守終了）	現行バージョン維持（常に最新2.xを推奨）

結論：高負荷・可観測性重視の現場ほど log4j2 一択。

2. こんな場面で「log4j2」を選ぶ

大量ログ（秒間1000件～万件）を裁くWeb/バッチ、IoT、決済、EC
本番でログレベルを動的変更したい（再起動なしで即調査）
JSON出力で Elasticsearch / OpenSearch / Splunk / Datadog に流す
遅延評価や MDC（相関ID） で可観測性とパフォーマンスを両立したい

3. 導入手順（Maven/Gradle）――最短で“動く”まで

ここでは log4j2 を実装（Core）として使い、APIは SLF4J で書く構成を推奨します。
理由：ライブラリ間の共通言語として SLF4J がデファクト、実装差し替えも容易。

3.1 依存関係を追加

Maven（pom.xml）

<dependencies>
  <!-- SLF4J API -->
  <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
  </dependency>

  <!-- Log4j2 実装（Core）＋ API -->
  <dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
  </dependency>
  <dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
  </dependency>

  <!-- SLF4J → Log4j2 バインド（SLF4J 2.x 用） -->
  <dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j2-impl</artifactId>
  </dependency>

  <!-- （任意）Async Logger 用：Disruptor -->
  <dependency>
    <groupId>com.lmax</groupId>
    <artifactId>disruptor</artifactId>
  </dependency>
</dependencies>

</dependency>

<groupId>org.apache.logging.log4j</groupId>

</dependency>

<groupId>org.apache.logging.log4j</groupId>

</dependency>

<groupId>org.apache.logging.log4j</groupId>

</dependency>

<artifactId>disruptor</artifactId>

</dependency>

</dependencies>

Gradle（Kotlin DSL）

dependencies {
    implementation("org.slf4j:slf4j-api")
    implementation("org.apache.logging.log4j:log4j-core")
    implementation("org.apache.logging.log4j:log4j-api")
    implementation("org.apache.logging.log4j:log4j-slf4j2-impl")
    implementation("com.lmax:disruptor") // Async Logger を使うなら
}

dependencies {

implementation("org.slf4j:slf4j-api")

implementation("org.apache.logging.log4j:log4j-core")

implementation("org.apache.logging.log4j:log4j-api")

implementation("org.apache.logging.log4j:log4j-slf4j2-impl")

implementation("com.lmax:disruptor") // Async Logger を使うなら

}

重要：既存で引き込まれる logback-classic や slf4j-log4j12 は除外してください（重複実装エラー＆二重出力の原因）。

3.2 旧実装の衝突を避ける（例：Maven の除外）

<dependency>
  <groupId>some.group</groupId>
  <artifactId>some-lib</artifactId>
  <exclusions>
    <exclusion>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
    </exclusion>
    <exclusion>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
    </exclusion>
    <exclusion>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
    </exclusion>
  </exclusions>
</dependency>

<groupId>some.group</groupId>

<groupId>ch.qos.logback</groupId>

<artifactId>logback-classic</artifactId>

</exclusion>

</exclusion>

</exclusion>

</exclusions>

</dependency>

3.3 最小構成の設定ファイル（`src/main/resources/log4j2.xml`）

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN" monitorInterval="30">
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout pattern="%d{ISO8601} [%t] %-5level %logger - %msg%n"/>
    </Console>
  </Appenders>
  <Loggers>
    <Root level="INFO">
      <AppenderRef ref="Console"/>
    </Root>
  </Loggers>
</Configuration>

<?xml version="1.0" encoding="UTF-8"?>

</Console>

</Appenders>

</Root>

</Loggers>

</Configuration>

monitorInterval="30"：30秒ごとに設定ファイルの変更を検知し、再起動なしで反映。

3.4 SLF4J での利用コード

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class App {
  private static final Logger log = LoggerFactory.getLogger(App.class);

  public static void main(String[] args) {
    String userId = "alice";
    log.info("Hello, {}", userId);           // プレースホルダで連結コスト削減
    log.debug("Detail: {}", () -> heavy());  // ラムダで遅延評価（DEBUGでなければ実行されない）
  }

  private static String heavy() { /* 重い処理 */ return "ok"; }
}

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class App {

private static final Logger log = LoggerFactory.getLogger(App.class);

public static void main(String[] args) {

String userId = "alice";

log.info("Hello, {}", userId); // プレースホルダで連結コスト削減

log.debug("Detail: {}", () -> heavy()); // ラムダで遅延評価（DEBUGでなければ実行されない）

}

private static String heavy() { /* 重い処理 */ return "ok"; }

}

3.5 ローリングファイル＋JSON（実戦向け）

<Configuration status="WARN" monitorInterval="30">
  <Appenders>
    <RollingFile name="AppLog" fileName="logs/app.log"
                 filePattern="logs/app-%d{yyyy-MM-dd}-%i.log.gz">
      <JsonLayout complete="false" compact="true" eventEol="true"/>
      <Policies>
        <SizeBasedTriggeringPolicy size="50 MB"/>
        <TimeBasedTriggeringPolicy/>
      </Policies>
      <DefaultRolloverStrategy max="30"/>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="INFO">
      <AppenderRef ref="AppLog"/>
    </Root>
  </Loggers>
</Configuration>

<RollingFile name="AppLog" fileName="logs/app.log"

filePattern="logs/app-%d{yyyy-MM-dd}-%i.log.gz">

</Policies>

</RollingFile>

</Appenders>

</Root>

</Loggers>

</Configuration>

JSON出力で可観測性基盤にそのまま投入可能。
max="30"：古いファイルを30世代で自動削除。

3.6 非同期化の推奨設定（高スループット向け）

方法A：Async Appender（部分的に非同期）

方法B：Async Logger（全ロガーを非同期化）

依存に disruptor を追加（前述）
JVM 起動オプションに以下を付与

INI

-DLog4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector

1

-DLog4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector

目安：秒間数千件以上のログ、遅延許容な処理では Async Logger が強力。
低遅延の必要なクリティカル処理（トランザクション境界直前など）は同期Appenderで分離も可。

3.7 現場で必須の“相関ID”（MDC/ThreadContext）

分散トレーシングやバッチ内のジョブ相関に必須。

3.8 動的なログレベル変更（コード＆設定）

コードで変更

Java

import org.apache.logging.log4j.core.config.Configurator; import org.apache.logging.log4j.Level; Configurator.setLevel("com.example.service", Level.DEBUG);

1
2
3

import org.apache.logging.log4j.core.config.Configurator;
import org.apache.logging.log4j.Level;
Configurator.setLevel("com.example.service", Level.DEBUG);
設定のホットリロード：monitorInterval でファイルを書き換えるだけ

3.9 他フレームワークのログを一本化（任意）

JUL（java.util.logging）→ Log4j2：log4j-jul を追加し、

INI

-Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager

1

-Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager
Commons Logging（JCL）→ Log4j2：log4j-jcl を追加

4. 旧 log4j 1.x からの移行チェックリスト

jar の置換と衝突解消
- 1.x の log4j-1.2.x.jar を除去
- log4j-api, log4j-core, log4j-slf4j2-impl を追加
- 他実装（logback 等）を除外
設定ファイルを置き換え
- log4j.properties → log4j2.xml（or .json/.yaml） に構造変換
コードの修正方針（推奨順）
- SLF4J API へ書き換え（LoggerFactory.getLogger 等）
- もしくは log4j2 API へ（org.apache.logging.log4j.LogManager.getLogger）
- 当面の暫定策として log4j-1.2-api（互換レイヤ）もあるが恒久利用は非推奨
性能と出力の検証
- 期待QPSでのバックプレッシャやディスク枯渇を確認
- 非同期化の有無でレイテンシ差を測定
運用監視
- -Dlog4j2.debug=true で起動し、設定解決やエラーを起動時に確認
- ログローテーションと世代数の上限を監視に組み込み

5. 開発・運用の実用Tips

重い toString() を直接連結しない：log.debug("x={}", () -> obj.heavyToString())
Failover Appender で出力先障害に備える（ネットワークストレージ等）
パターン設計：時刻、レベル、ロガー、メッセージ、%throwable、MDC を最低限
本番では INFO 以上、詳細調査時のみ一時的に DEBUG/TRACE を開ける
最新 2.x 系を採用（セキュリティ修正が継続されるため）

6. まとめ

log4j2 は “高速＋柔軟＋安全”。大量ログ・可観測性要件に強い。
導入は依存追加 → 設定作成 → 非同期化の3ステップが核。
移行は衝突除去と設定変換が肝。SLF4J API で書くと将来の実装差し替えも容易。

HULFT, Java, ブログ, プログラミング

HULFT連携：Javaからユーティリティコマンドを呼び出す実装例

2025年10月1日管理者コメントする

HULFTには「送受信ジョブを定義して使う方法」以外に、utlsendなどのユーティリティ系コマンドを直接呼び出してファイル転送や加工を行う手段があります。
これらは事前の送受信定義が不要で、コマンド実行時に条件を指定できるため、テスト送信・スポット利用・簡易処理に非常に便利です。

本記事では、JavaでHULFTコマンドを実行する例をご紹介します。

utlsend : ファイル送信
utlrecv : ファイル受信
utlconcat : ファイル連結
utlsplit : ファイル分割

Javaから外部コマンドを実行する基本

Javaでは ProcessBuilder を使うことで、外部のHULFTコマンドを呼び出せます。
エラー出力も標準出力にまとめる設定をすれば、ログ管理が容易になります。

共通の呼び出しテンプレートは以下の通りです。

import java.io.*;

public class HulftCommandRunner {
    public static void runCommand(String... command) {
        try {
            ProcessBuilder pb = new ProcessBuilder(command);
            pb.redirectErrorStream(true);
            Process process = pb.start();

            BufferedReader reader = new BufferedReader(
                    new InputStreamReader(process.getInputStream(), "MS932")); // Windows日本語環境想定
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }

            int exitCode = process.waitFor();
            System.out.println("終了コード: " + exitCode);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;

public class HulftCommandRunner {

public static void runCommand(String... command) {

try {

ProcessBuilder pb = new ProcessBuilder(command);

pb.redirectErrorStream(true);

Process process = pb.start();

BufferedReader reader = new BufferedReader(

new InputStreamReader(process.getInputStream(), "MS932")); // Windows日本語環境想定

String line;

while ((line = reader.readLine()) != null) {

System.out.println(line);

}

int exitCode = process.waitFor();

System.out.println("終了コード: " + exitCode);

} catch (Exception e) {

e.printStackTrace();

}

以降の例では、この runCommand を利用して各ユーティリティコマンドを実行します。

1. ファイル送信（`utlsend`）

事前の送信定義が不要で、対象ファイルと宛先ノードを直接指定できます。

public class ExampleSend {
    public static void main(String[] args) {
        HulftCommandRunner.runCommand(
            "utlsend",
            "-f", "/data/test.txt",
            "-n", "NODE001"
        );
    }
}

public class ExampleSend {

public static void main(String[] args) {

HulftCommandRunner.runCommand(

"utlsend",

"-f", "/data/test.txt",

"-n", "NODE001"

);

}

-f : 送信するファイルパス
-n : 宛先ノード名（HULFTに登録済み）

2. ファイル受信（`utlrecv`）

受信ジョブを登録せず、コマンドだけでファイルを取得できます。

public class ExampleRecv {
    public static void main(String[] args) {
        HulftCommandRunner.runCommand(
            "utlrecv",
            "-f", "/data/recv.txt",
            "-n", "NODE001"
        );
    }
}

public class ExampleRecv {

public static void main(String[] args) {

HulftCommandRunner.runCommand(

"utlrecv",

"-f", "/data/recv.txt",

"-n", "NODE001"

);

}

-f : 保存先のファイル名
-n : 送信元ノード名

3. ファイル連結（`utlconcat`）

複数のファイルを1つにまとめたいときに使います。

public class ExampleConcat {
    public static void main(String[] args) {
        HulftCommandRunner.runCommand(
            "utlconcat",
            "-o", "/data/merged.txt",
            "-f", "/data/file1.txt",
            "-f", "/data/file2.txt"
        );
    }
}

public class ExampleConcat {

public static void main(String[] args) {

HulftCommandRunner.runCommand(

"utlconcat",

"-o", "/data/merged.txt",

"-f", "/data/file1.txt",

"-f", "/data/file2.txt"

);

}

-o : 出力ファイル名
-f : 結合対象のファイル（複数指定可）

4. ファイル分割（`utlsplit`）

大きなファイルを分割して処理したいときに使います。

public class ExampleSplit {
    public static void main(String[] args) {
        HulftCommandRunner.runCommand(
            "utlsplit",
            "-f", "/data/bigfile.txt",
            "-l", "1000"
        );
    }
}

public class ExampleSplit {

public static void main(String[] args) {

HulftCommandRunner.runCommand(

"utlsplit",

"-f", "/data/bigfile.txt",

"-l", "1000"

);

}

-f : 分割対象ファイル
-l : 分割する行数（例：1000行ごと）

運用上の注意点

PATHの設定
Javaから呼び出す際は、utlsend.exe などのHULFTバイナリがPATHに通っている必要があります。
通っていない場合はフルパス指定が必須です。
終了コードの確認
- 0 : 正常終了
- 0以外 : エラー（詳細はHULFTマニュアルのエラーコード参照）
ログ管理
実際の業務バッチでは process.getInputStream() の内容をファイル出力してログ管理することを推奨します。

まとめ

utlsend でファイルを即送信できる
utlrecv で即時受信が可能
utlconcat でファイルを連結
utlsplit でファイルを分解

これらをJavaから呼び出すことで、柔軟なファイル連携や加工処理が実現できます。

Three.js, ブログ, プログラミング

Three.jsで簡単3D演出！初心者でもホームページをかっこよくする方法

2025年9月27日管理者コメントする

「ホームページをかっこよく見せたい」「シンプルに3D演出を加えてみたい」──そんなときに役立つのが Three.js です。
JavaScriptだけで3Dオブジェクトを動かせる便利なライブラリで、近年のWebサイトでも多く使われています。

この記事では 最新版 Three.js (r180) を使って、実際に「回転する立方体」を表示するサンプルを紹介します。

1. Three.jsとは？

Three.js は WebGL をラップしたライブラリで、難しい低レベルコードを書かなくても以下のような処理が可能です。

3Dオブジェクトの作成（立方体・球体・モデルの読み込み）
カメラの制御
ライトの設置
マテリアルやシェーダーの設定
アニメーション処理

2. サンプルコード（最新版 Three.js r180 対応）

以下は 最小構成のサンプル です。
HTMLファイルを作成して保存してください。

<!DOCTYPE html>
<html lang="ja">
<head>
  <meta charset="UTF-8">
  <title>Three.js r180 Sample</title>
  <style>
    body { margin:0; }
    canvas { display:block; }
  </style>
</head>
<body>
  <script type="module">
    import * as THREE from "https://cdn.jsdelivr.net/npm/three@0.180.0/build/three.module.js";

    const scene = new THREE.Scene();
    const camera = new THREE.PerspectiveCamera(75, innerWidth/innerHeight, 0.1, 1000);
    camera.position.z = 5;

    const renderer = new THREE.WebGLRenderer();
    renderer.setSize(innerWidth, innerHeight);
    document.body.appendChild(renderer.domElement);

    const cube = new THREE.Mesh(
      new THREE.BoxGeometry(),
      new THREE.MeshBasicMaterial({ color: 0x00aaff })
    );
    scene.add(cube);

    function animate() {
      requestAnimationFrame(animate);
      cube.rotation.x += 0.01;
      cube.rotation.y += 0.01;
      renderer.render(scene, camera);
    }
    animate();

    addEventListener("resize", () => {
      renderer.setSize(innerWidth, innerHeight);
      camera.aspect = innerWidth / innerHeight;
      camera.updateProjectionMatrix();
    });
  </script>
</body>
</html>

<!DOCTYPE html>

<head>

<title>Three.js r180 Sample</title>

<style>

body { margin:0; }

canvas { display:block; }

</style>

</head>

<body>

import * as THREE from "https://cdn.jsdelivr.net/npm/three@0.180.0/build/three.module.js";

const scene = new THREE.Scene();

const camera = new THREE.PerspectiveCamera(75, innerWidth/innerHeight, 0.1, 1000);

camera.position.z = 5;

const renderer = new THREE.WebGLRenderer();

renderer.setSize(innerWidth, innerHeight);

document.body.appendChild(renderer.domElement);

const cube = new THREE.Mesh(

new THREE.BoxGeometry(),

new THREE.MeshBasicMaterial({ color: 0x00aaff })

);

scene.add(cube);

function animate() {

requestAnimationFrame(animate);

cube.rotation.x += 0.01;

cube.rotation.y += 0.01;

renderer.render(scene, camera);

}

animate();

addEventListener("resize", () => {

renderer.setSize(innerWidth, innerHeight);

camera.aspect = innerWidth / innerHeight;

camera.updateProjectionMatrix();

});

</script>

</body>

</html>

3. デモ（実際に動くサンプル）

このブログ記事では、外部ファイルとして用意したサンプルhtmlを iframe で埋め込んで表示してます。

デモ1：基本の回転する立方体

👇 実際に回転する立方体が表示されます。

デモ2：ライトを使った立方体

光源を加えることで、立方体に陰影がつき、立体感が増します。

const light = new THREE.DirectionalLight(0xffffff, 1);
light.position.set(5, 5, 5).normalize();
scene.add(light);

const light = new THREE.DirectionalLight(0xffffff, 1);

light.position.set(5, 5, 5).normalize();

scene.add(light);

デモ3：マテリアル変更

単色ではなく、ワイヤーフレームや透過マテリアルを適用できます。

const material = new THREE.MeshNormalMaterial({ wireframe: true });

1	const material = new THREE.MeshNormalMaterial({ wireframe: true });

デモ4：カメラ操作

OrbitControlsを使うと、マウスで回転・拡大縮小できるインタラクティブなデモが可能です。

import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
const controls = new OrbitControls(camera, renderer.domElement);

1 2	import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js'; const controls = new OrbitControls(camera, renderer.domElement);

4. ローカルで動かすには？

上記のコードをコピーして test.html などの名前で保存 → ブラウザで開いても、真っ白になる場合があります。
これは ES Modules を使う Three.js の最新版では、file:/// での読み込みがセキュリティ上ブロックされるためです。

✅ 解決方法

ローカルで動かすには 簡易Webサーバ を立ち上げる必要があります。

例:

Python がある場合
python -m http.server 8000
Node.js がある場合
npx http-server -p 8000

その後、ブラウザで
http://localhost:8000/test.html
を開くと正しく表示されます。

5. まとめ

Three.jsを使えば簡単に3D演出を加えられる
最新版 (r180) は ES Modules形式 → file:/// では動作しない
実際の環境では Webサーバ経由で実行する必要がある
WordPress記事に埋め込む場合は iframe で外部HTMLを呼び出すのが安全

これをベースに、さらにライト・カメラ操作・外部モデル読み込みを試していけば、よりリッチな演出を作れます！

Java, ブログ

JavaのGC（Garbage Collection）とは？仕組みと注意点

2025年9月26日管理者コメントする

GCとは何か

Java で開発をしていると、よく耳にする「GC（Garbage Collection）」。
これは 不要になったオブジェクトを自動で回収してメモリを解放する仕組み のことです。C言語のように手動で free() を呼ぶ必要はなく、Java VM が裏側でメモリ管理を行います。

ざっくり構造・最近のGC

世代別回収：Eden/Survivor（若世代）→ Old（老世代）
Minor GC：Edenが埋まったら短命オブジェクト中心に回収
Major/Full GC：Oldが逼迫、断片化、クラス/メタ領域逼迫などで広域回収
既定GC：G1GC（Java 9+）。低停止要求は ZGC / Shenandoah も選択肢

主なトリガ

Eden満杯（Minor） / Old高水準（Major）
巨大配列（Humongous）割当て（G1）
System.gc() 明示呼び出し
メタスペース/オフヒープ圧迫（DirectByteBuffer/JNI など）

“悪い例 → 良い例”で学ぶメモリ/GC対策

1) 無制限キャッシュ（静的Map地獄）

悪い例

// Caffeine を例に（依存追加で利用可）
Cache<String, Object> cache = Caffeine.newBuilder()
    .maximumSize(10_000)         // 上限
    .expireAfterAccess(Duration.ofMinutes(30)) // 期限
    .recordStats()
    .build();

public Object get(String key) {
  return cache.get(key, this::loadSlow);
}

// Caffeine を例に（依存追加で利用可）

Cache<String, Object> cache = Caffeine.newBuilder()

.maximumSize(10_000) // 上限

.expireAfterAccess(Duration.ofMinutes(30)) // 期限

.recordStats()

.build();

public Object get(String key) {

return cache.get(key, this::loadSlow);

}

ポイント：上限なしは必ずOldを膨らませる。キャッシュは 容量・期限・エビクションを設計。

2) リスナ/コールバック未解除

悪い例

class View {
  Closeable addListener(Listener l) {
    // 登録...
    return () -> removeListener(l); // try-with-resources で自動解除
  }
}

try (var h = view.addListener(event -> {/*...*/})) {
  // 利用中
} // スコープを出ると自動で removeListener

class View {

Closeable addListener(Listener l) {

// 登録...

return () -> removeListener(l); // try-with-resources で自動解除

}

try (var h = view.addListener(event -> {/*...*/})) {

// 利用中

} // スコープを出ると自動で removeListener

補足：WeakReference リスナはイベント強度低下や意図せぬ解放のリスク。基本は明示解除。

3) `ThreadLocal` の放置（プールスレッドに張り付く）

悪い例

良い例（finallyで確実に除去）

private static final ThreadLocal<byte[]> BUF =
    ThreadLocal.withInitial(() -> new byte[1<<20]);

void work() {
  try {
    var buf = BUF.get();
    // 処理...
  } finally {
    BUF.remove(); // プールスレッドに残さない
  }
}

private static final ThreadLocal<byte[]> BUF =

ThreadLocal.withInitial(() -> new byte[1<<20]);

void work() {

try {

var buf = BUF.get();

// 処理...

} finally {

BUF.remove(); // プールスレッドに残さない

}

ポイント：スレッドプール＝長寿命。remove() を忘れると実質グローバル保持。

4) `System.gc()` 乱用

悪い例

5) ラムダ/内部クラスが外側（巨大オブジェクト）をキャプチャ

悪い例

良い例（必要最小限のデータだけ渡す・static化）

class Holder {
  byte[] big = new byte[10_000_000];

  Runnable r() {
    int len = big.length;        // プリミティブだけ抜き出す
    return () -> System.out.println(len);
  }
}
// あるいは static ネストクラスで暗黙の外部参照を避ける

class Holder {

byte[] big = new byte[10_000_000];

Runnable r() {

int len = big.length; // プリミティブだけ抜き出す

return () -> System.out.println(len);

}

// あるいは static ネストクラスで暗黙の外部参照を避ける

ポイント：キャプチャ=保持。意図せず大物を延命していないか疑う。

6) ループ内の大量一時オブジェクト

悪い例

良い例（StringBuilder再利用・ボクシング回避）

7) finalize/Cleaner頼み（遅延・不確実）

悪い例

class Resource implements AutoCloseable {
  private final FileChannel ch = FileChannel.open(...);
  @Override public void close() throws IOException { ch.close(); }
}

try (Resource r = new Resource()) {
  // 利用
} // ここで必ず解放

class Resource implements AutoCloseable {

private final FileChannel ch = FileChannel.open(...);

@Override public void close() throws IOException { ch.close(); }

}

try (Resource r = new Resource()) {

// 利用

} // ここで必ず解放

8) クラスローダ・アプリ再デプロイ時のリーク

悪い例

良い例（クラスローダ境界を越える参照を断つ）

- static にアプリクラス/インスタンスを保持しない
- ThreadLocal を必ず remove
- Executor/Timer を停止（shutdown）してからアンデプロイ
- JDBC ドライバ/ログアダプタ等の明示的解除を守る

- static にアプリクラス/インスタンスを保持しない

- ThreadLocal を必ず remove

- Executor/Timer を停止（shutdown）してからアンデプロイ

- JDBC ドライバ/ログアダプタ等の明示的解除を守る

9) 巨大配列・Humongous割当ての長期保持（G1）

悪い例

良い例（分割・ストリーミング・寿命短縮）

ポイント：巨大ブロックは断片化と回収コスト増の温床。

10) 無制限のキュー/バッファ

悪い例

良い例（有界＋バックプレッシャ）

BlockingQueue<Event> q = new ArrayBlockingQueue<>(10_000);

boolean offered = q.offer(event, 100, TimeUnit.MILLISECONDS);
if (!offered) {
  // 混雑時の方針：間引き/遅延/古いもの破棄など
}

BlockingQueue<Event> q = new ArrayBlockingQueue<>(10_000);

boolean offered = q.offer(event, 100, TimeUnit.MILLISECONDS);

if (!offered) {

// 混雑時の方針：間引き/遅延/古いもの破棄など

}

GCログ・計測の始め方（JDK 9+）

まずはコードの割当て削減 → その後にヒープ/GC調整
監視：jcmd <pid> GC.heap_info / jstat -gc <pid> 1000
ボトルネック特定：JFR（Java Flight Recorder） で割当てホットスポットを把握
必要なら ZGC/Shenandoah も評価（レイテンシ目標に応じて）

実務チェックリスト（配布推奨）

System.gc() を禁止/抑制
キャッシュ・キューは有界＋期限
ThreadLocal は finally で remove
リスナ/コールバックは確実に解除（AutoCloseable化が効く）
ループ内の一時オブジェクトを減らす（Builder再利用/ボクシング回避）
巨大配列は分割・短命化
クラスローダ境界を跨ぐ静的参照禁止、Executor停止・ドライバ解除
try-with-resourcesでオフヒープ即時解放
GCログ/JFRで事実ベースに調整
目標停止時間（例：MaxGCPauseMillis）を定めて検証

まとめ

GCは“自動”でも“万能”ではありません。
「GCが働きやすいコード」（不要参照を残さない・波及して大物を掴ませない・ピークメモリを避ける）を心がけ、ログ/計測で改善ループを回すのが最短距離です。

🧩 動作環境（同シリーズ共通）

🧱 ステップ①：CNNを使ったモデル構築

⚙️ ステップ②：学習率を調整して最適化

📈 ステップ③：学習を実行

🧾 ステップ④：テストデータで評価

🧠 ステップ⑤：予測結果の可視化

📊 ステップ⑥：精度の推移をグラフ化（オプション）

💾 手順まとめ：ファイル保存〜実行まで

① ファイルを作成

② コード内容（完全版）

③ 保存場所

④ 実行手順

⑤ 実行結果

⑥ 終了後

🚀 結果と考察

💡 応用ポイント

✅ まとめ

🔜 次回予告

関連記事

🧩 動作環境（前回と同じ構成）

🧠 ステップ①：MNISTデータセットを読み込む

🧩 ステップ②：データの前処理

🧩 ステップ③：モデル構築（Keras Sequential）

🧩 ステップ④：学習を実行

🧩 ステップ⑤：テストデータで評価

🧩 ステップ⑥：実際に予測してみる

ステップ①～⑥のコードについて

✅ 例：mnist_sample.py として保存する内容

💾 保存と実行

📊 補足：精度向上のヒント

🚀 まとめ

関連記事

💻 環境例

🧩 ステップ①：公式Pythonのインストール

1️⃣ Python公式サイトへアクセス

2️⃣ 最新の「Windows installer (64-bit)」をダウンロード

3️⃣ インストーラ起動後の設定

4️⃣ Advanced Options の設定

5️⃣ 「Install」をクリックして完了！

🧩 ステップ②：インストール確認

🧩 ステップ③：仮想環境の作成と有効化

🧩 ステップ④：TensorFlowとmatplotlibをインストール

🧩 ステップ⑤：動作確認

🧩 ステップ⑥：仮想環境の管理コマンドまとめ

✅ まとめ

💬 次回予告

関連記事

🖋️ <canvas>タグの基本とは？

🌊 JavaScriptなしで実現する波紋・粒子エフェクト

✅ 例：波紋エフェクト（CSS連携）

サンプル

✨ パーティクル風の演出も可能

サンプル

🧩 活用シーン

💬 まとめ

関連記事

1. assertThrowsとは？

2. 旧来のtry-catch方式との比較

3. 例外メッセージの検証

4. 複数の例外クラスに対応

5. assertThrowsを使うメリットまとめ

まとめ

関連記事

サンプル環境

Pythonとは？

1. Pythonをインストール

2. 動作確認

3. 必要なライブラリをインストール

4. サンプルデータ

sales.csv

5. Pythonで分析！4つの出力を体験

パターン① コンソール出力（数字で確認）

パターン② グラフ出力（見やすく可視化）

パターン③ ファイルに保存（CSV・画像）

パターン④ Notebookで出力

ステップ1: Notebookを起動

ステップ2: セルごとにコードを書く

Notebookの特徴

まとめ

関連記事

　関連記事

✅ 例：`mnist_sample.py` として保存する内容

　関連記事

　関連記事

🖋️ `<canvas>`タグの基本とは？

　関連記事

　関連記事

　関連記事

3.3 最小構成の設定ファイル（`src/main/resources/log4j2.xml`）

　関連記事

1. ファイル送信（`utlsend`）

2. ファイル受信（`utlrecv`）

3. ファイル連結（`utlconcat`）

4. ファイル分割（`utlsplit`）

　関連記事

　関連記事

3) `ThreadLocal` の放置（プールスレッドに張り付く）

4) `System.gc()` 乱用

　関連記事