ブログ

import os
import sys
sys.path.insert(1,"/home/pi/SUN/lib/python3.13/site-packages")
import math
import cv2
import numpy as np
import matplotlib.pyplot as plt
import random
import time
import datetime
import schedule
import pytz
from time import sleep
import paho.mqtt.client as mqtt


delay = 1
count = 0
window_name = 'frame'
epsilon = 1e-10  # ゼロ除算防止
SI_mean = 0.001
# ===== 送信制御フラグ =====
allow_send = True        # MQTT送信許可
current_lux = None       # 最新照度
LUX_THRESHOLD = 300      # 閾値
time_allow = False
start_time = 7       #朝測定開始時間
end_time = 17        #夜測定終了時間
# --- TapoカメラURL ---
camera_id = "rtsp://tarou:1234567@192.168.1.100:554/stream1?rtsp transport = tcp"
output_dir = '/home/pi/SUN/CAPTURE/'
# グラフ保存用ファイル
GRAPH_PATH = "bi_si_plot.png"

# K値と空の状態
K_values = {
    'CB': 3.0000,  # 快晴
    'BS': 7.0000,  # 晴天
    'CS': 25.0000  # 曇天
}

# 記号の対応表
MARKERS = {
    'CB': 'o',  # ◎
    'BS': 'v',  # △
    'CS': 's'   # ■
}

plt.ion()  # インタラクティブモードを有効化
    
def on_message(client, userdata, msg):
    global allow_send, current_lux

    topic = msg.topic
    payload = msg.payload.decode()

    # --- シャットダウン ---
    if topic == "sun_pat" and payload == "shutdown":
        print("Shutdown command received")
        client.loop_stop()
        os.system("sudo shutdown -h now")
        return

    # --- 照度受信 ---
    if topic == "lux":
        try:
            current_lux = float(payload)
            current_lux = 2000            #照度計が設置されている場合にはコメントアウトする。
            if current_lux < LUX_THRESHOLD:
                allow_send = False
                print(f"Lux={current_lux} → 送信停止")
            else:
                allow_send = True
                print(f"Lux={current_lux} → 照度OK")
        except ValueError:
            print("lux payload parse error:", payload)
                


def on_connect(client, userdata, flags, reason_code, properties):
    print(f"Connected mqtt broker {reason_code}")
    client.subscribe("lux")
    client.subscribe("sun_pat")

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
client.on_connect = on_connect
client.on_message = on_message
client.connect("192.168.2.242", 1884, 60)
client.loop_start()

def publish(data):
    if not allow_send:
        print("送信停止中のため publish をスキップ")
        return
    client.publish('sky_pat', payload=data, qos=0, retain=False)
    print(f"send {data} to sky_pat")

def save_image_with_sequence(image, directory, filename_prefix, start_num=1, padding=5):  
    if not os.path.exists(directory):
        os.makedirs(directory)
    num = start_num
    while True:
        # 現在の日時を取得
        now = datetime.datetime.now(pytz.timezone('Asia/Tokyo'))
        filename = str(now.year) + str(now.month) + str(now.day) + str(now.hour) + '-' + f"{str(num).zfill(padding)}.png" 
        filepath = os.path.join(directory, filename)
        if not os.path.exists(filepath):
            cv2.imwrite(filepath, image)
            print(f"保存しました: {filepath}")
            break
        num += 1

# ファイル名のプレフィックス
filename_prefix = "image"
# 連番の開始番号
start_number = 1
# 連番の桁数
padding = 5

def create_initial_plot():
    """ 初回にBI-SIグラフを作成し保存 """
    SI_range = np.linspace(-0.1, 0.4, 100)  # SI の範囲

    plt.figure(figsize=(5, 5))
    for label, K in K_values.items():
        BI_curve = np.exp(-K * SI_range)  # BI値の計算
        plt.plot(SI_range, BI_curve, label=f"{label} (K={K})")

    plt.xlabel("SI (Sky Index)")
    plt.ylabel("BI (Brightness Index)")
    plt.title("BI-SI Relationship")
    plt.ylim(0, 1)  # BI軸を 0-1 に固定
    plt.legend()
    plt.grid(True)
    
    # 画像として保存
    plt.savefig(GRAPH_PATH)
    plt.close()

# 初回のみグラフ作成
if not os.path.exists(GRAPH_PATH):
    create_initial_plot()

def update_plot(SI_new, BI_new, sky_type):
    """ BI-SIグラフに新しいデータ点をプロットし、グラフを更新 """
    SI_range = np.linspace(-0.1, 0.4, 100)  # SI の範囲を統一

    plt.clf()  # 既存のプロットをクリア
    for label, K in K_values.items():
        BI_curve = np.exp(-K * SI_range)  # BI値の計算
        plt.plot(SI_range, BI_curve, label=f"{label} (K={K})")
    dot = 'gray'
    # 新しいデータ点をプロット
    if sky_type == 'CB' or sky_type == 'BS' or sky_type == 'CS':
        dot = 'gray'
    elif SI_new < 0:
        dot = 'red'
    marker = MARKERS.get(sky_type, 'x')  # デフォルト 'x'
    plt.scatter(SI_new, BI_new, color = dot, marker=marker, s=100, label=f"{sky_type} \
({SI_new:.3f}, {BI_new:.3f})")

    # 軸ラベルとタイトル
    plt.xlabel("SI (Sky Index)")
    plt.ylabel("BI (Brightness Index)")
    plt.title("BI-SI Relationship (Updated)")
    plt.ylim(0, 1)  # BI軸を 0-1 に固定
    plt.legend()
    plt.grid(True)
    
    # グラフを保存 & 更新
    plt.savefig(GRAPH_PATH)
    plt.draw()
    plt.pause(0.1)  # 一瞬待つことで、インタラクティブモードで更新が反映される

#定期実行する関数を準備
def task():
    global time_allow
    
        # 空模様の分類
    def classify_sky(SI, BI):       
        # BI = e^(-K * SI) の関係から、各K値に対するBIを計算
        differences = {}
        for key, K in K_values.items():
            if SI < 0:
                SI = -SI
            expected_BI = math.exp(-K * SI)
            differences[key] = abs(BI - expected_BI)

        # 最も差が小さいものを選択
        closest_sky = min(differences, key=differences.get)
        return closest_sky
    
    now = datetime.datetime.now(pytz.timezone('Asia/Tokyo'))
    hour = now.hour

    if hour < start_time or hour >= end_time:
        print("hour{時夜間のため送信停止}")
        time_allow = False
        return
    else:
        time_allow = True
    
    cap = cv2.VideoCapture(camera_id)
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1920) # カメラ画像の横幅設定
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 1080) # カメラ画像の縦幅設定
    if not cap.isOpened():
        print("x RTSPストリームに接続出来ません",flush=True)
        sys.exit(1)
    #カメラからの画像取得
    ret, frame = cap.read()
    if not ret:
       print("フレーム取得失敗",flush=True)
       sys.exit(1)
    # BGRチャンネルに分割
    DNB, DNG, DNR = cv2.split(frame)
    # SIの計算
    SI = (DNB.astype(np.float32) - DNR.astype(np.float32)) / (DNB.astype(np.float32) + \
                                                              DNR.astype(np.float32) + epsilon)
    SI_mean = np.mean(SI)
    # BIの計算
    BI = (DNB.astype(np.float32) + DNG.astype(np.float32) + DNR.astype(np.float32)) / (255 * 3)
    BI_mean = np.mean(BI)
    # SIマップを可視化（0~255に正規化）
    SI_vis = cv2.normalize(SI, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)   
    # BIマップを可視化（0~255に正規化）
    BI_vis = cv2.normalize(BI, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)  

    # 現在の空模様を分類
    current_sky = classify_sky(SI_mean, BI_mean)    
    #K
    calk_K = abs(np.log(BI_mean)/SI_mean)
      
    #mqtt publish
    snd = ''
    tenki = ''
    if current_sky == 'CB':
        tenki = '快晴'
        snd = '1'
    elif current_sky == 'BS':
        tenki = '晴れ'
        snd = '2'
    elif current_sky == 'CS':
        tenki ='曇天' 
        snd = '3'
    if not (allow_send and time_allow):
        print("送信条件未達（照度 or 時刻）")
        return
    
    #結果を送信
    publish(snd)    
    preview = cv2.resize(frame,(224,224))
    #保存先のディレクトリ
    save_image_with_sequence(preview, output_dir + current_sky + '/', "image")

    # 表示用プレビュー      
    cv2.imshow("Frame", preview)
    cv2.waitKey(1)
    #cv2.imshow("SI Map", SI_vis) 
    #cv2.imshow("BI Map", BI_vis)
        
    # 結果を表示
    print(f"SIの平均値: {SI_mean:.4f}")
    print(f"BIの平均値: {BI_mean:.4f}")
    print(f"現在のK:{calk_K:.4f}")
    print(f"[{time.strftime('%H:%M:%S')}] 現在の空模様：{tenki}")

    # 例: 新しいデータをプロット
    SI_new = SI_mean # 取得したSI値
    BI_new = BI_mean       
    sky_type = current_sky # 推定された空模様
    update_plot(SI_new, BI_new, sky_type)


#スケジュール登録   
schedule.every(30).seconds.do(task)
#イベント実行
while True:  
    if cv2.waitKey(delay) & 0xFF == ord('q'):
        break
    schedule.run_pending()
    sleep(1)

import os
import glob

#クラスの名前
cls_name = "BS"   
# 現在のディレクトリ内の 'images' フォルダを指します
target_folder = "/data/sun/" + cls_name 

def rename_images_sequentially(folder_path, start_num=1, num_digits=4):
    """
    指定されたフォルダ内の画像ファイル名を連番に変更します。

    :param folder_path: 対象フォルダのパス
    :param start_num: 開始番号 (デフォルト: 1)
    :param num_digits: 連番の桁数 (デフォルト: 4, 例: 0001)
    """
    # 対応する画像ファイルの拡張子リスト
    extensions = ('*.jpg', '*.jpeg', '*.png', '*.gif', '*.bmp', '*.tiff')
    files = []
    for ext in extensions:
        # globを使用して指定拡張子のファイルを取得し、リストに追加
        files.extend(glob.glob(os.path.join(folder_path, ext)))

    # ファイル名をソートすることで、ある程度の順序（ファイル名順）を保証
    # os.listdir() の結果は順序が不定な場合があるため、sorted() が重要
    files.sort()

    print(f"対象ファイル数: {len(files)} 件")

    for index, file_path in enumerate(files, start=start_num):
        # ファイルの拡張子を取得
        _, file_extension = os.path.splitext(file_path)

        # 新しいファイル名を生成 (例: 0001.jpg)
        new_file_name = cls_name + '-' + f"{index:0{num_digits}d}{file_extension}"
        new_file_path = os.path.join(folder_path, new_file_name)

        # リネーム実行
        try:
            os.rename(file_path, new_file_path)
            print(f"'{os.path.basename(file_path)}' -> '{new_file_name}'\
            に変更しました。")
        except OSError as e:
            print(f"エラー: '{os.path.basename(file_path)}' のリネームに\
            失敗しました: {e}")

if __name__ == "__main__":
    
    # フォルダパスが存在することを確認
    if os.path.isdir(target_folder):
        rename_images_sequentially(target_folder)
    else:
        print(f"指定されたフォルダが見つかりません: {target_folder}")
        print("スクリプト内の 'target_folder' 変数を正しいパスに編集してください。")

# 必要ライブラリ・コマンドの導入
!pip install --upgrade pip
!pip install onnx
!pip install pandas
!pip install japanize_matplotlib | tail -n 1
!pip install torchviz | tail -n 1
!pip install torchinfo | tail -n 1
w = !apt install tree
print(w[-2])

# 必要ライブラリのインポート
%matplotlib inline
import time, os, signal
import numpy as np
import matplotlib.pyplot as plt
import japanize_matplotlib
import pandas as pd
from tqdm import tqdm
from IPython.display import clear_output

# PyTorch関連ライブラリのインポート
import torch
from torch import tensor
import torch.nn as nn
import torch.optim as optim
from torchinfo import summary
from torchviz import make_dot
import torchvision.transforms as transforms
from torch.utils.data import Dataset, DataLoader
import torchvision.datasets as datasets

# warning表示off
import warnings
warnings.simplefilter('ignore')
# デフォルトフォントサイズ変更
plt.rcParams['font.size'] = 14
# デフォルトグラフサイズ変更
plt.rcParams['figure.figsize'] = (6,6)
# デフォルトで方眼表示ON
plt.rcParams['axes.grid'] = True
# numpyの表示桁数設定
np.set_printoptions(suppress=True, precision=5)

# GPUチェック
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)

# 共通関数のダウンロード
!git clone https://github.com/makaishi2/pythonlibs.git
# 共通関数のロード
from pythonlibs.torch_lib1 import *
# 共通関数の存在
print(README)

# 検証データ用 : 正規化のみ実施
test_transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(0.5, 0.5)
])
# 訓練データ用: 正規化に追加で反転とRandomErasingを実施
train_transform = transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize(0.5, 0.5),
    transforms.RandomErasing(p=0.5, scale=(0.02, 0.33), ratio=(0.3, 3.3), value=0, inplace=False)
])

# ツリーのベースディレクトリ
data_dir = '/data/sun/learning_datasets'
# 訓練データディレクトリと検証データディレクトリの指定
import os
train_dir = os.path.join(data_dir, 'train')
test_dir = os.path.join(data_dir, 'test')
# join関数の結果確認
print(train_dir, test_dir)
#本プロジェクト名
project = 'sun'
# 分類先クラスのリスト作成
classes = ['BS', 'CB','CS']
def fix_class_order(dataset, classes):
    dataset.class_to_idx = {cls: i for i, cls in enumerate(classes)}
    dataset.classes = classes

    # samples を作り直す
    new_samples = []
    for path, _ in dataset.samples:
        cls_name = os.path.basename(os.path.dirname(path))
        if cls_name in dataset.class_to_idx:
            new_samples.append((path, dataset.class_to_idx[cls_name]))

    dataset.samples = new_samples
    dataset.targets = [s[1] for s in new_samples]
    
# データセット定義
# 訓練用
train_data = datasets.ImageFolder(train_dir, transform=train_transform)
fix_class_order(train_data, classes)
# 訓練データのイメージ表示用
train_data2 = datasets.ImageFolder(train_dir, transform=test_transform)
# 検証用
test_data  = datasets.ImageFolder(test_dir,  transform=test_transform)

# データ件数確認
print(f'訓練データ: {len(train_data)}件')
print(f'検証データ: {len(test_data)}件')

#show_images_labels関数上書き
def show_images_labels(dataloader, classes, model=None, device=None, max_images=20):
    model.eval() if model else None

    images, labels = next(iter(dataloader))
    images = images[:max_images]
    labels = labels[:max_images]

    if model:
        images_gpu = images.to(device)
        with torch.no_grad():
            outputs = model(images_gpu)
            _, preds = torch.max(outputs, 1)
        preds = preds.cpu()
    else:
        preds = None

    plt.figure(figsize=(15, 6))

    for i in range(len(images)):
        ax = plt.subplot(2, max_images // 2, i + 1)

        img = images[i].numpy().transpose(1, 2, 0)
        img = (img + 1) / 2
        plt.imshow(img)
        ax.axis("off")

        true_label = classes[labels[i]]
        ax.text(
            0.5, 1.05,
            f"GT: {true_label}",
            fontsize=9,
            color="black",
            ha="center",
            transform=ax.transAxes
        )

        if preds is not None:
            pred_label = classes[preds[i]]
            color = "black" if preds[i] == labels[i] else "red"
            ax.text(
                0.5, -0.15,
                f"Pred: {pred_label}",
                fontsize=9,
                color=color,
                ha="center",
                transform=ax.transAxes
            )

    plt.tight_layout()
    plt.show()

# データローダー定義
batch_size = 50
# 訓練用
train_loader = DataLoader(train_data, 
      batch_size=batch_size, shuffle=True)
# 検証用
test_loader = DataLoader(test_data, 
      batch_size=batch_size, shuffle=False)
# イメージ表示用
train_loader2 = DataLoader(train_data2, 
      batch_size=50, shuffle=True)
test_loader2 = DataLoader(test_data, 
      batch_size=50, shuffle=True)

# 検証用データ(50件)
torch_seed()
show_images_labels(test_loader2, classes, None, None)

# ファインチューニング版

# 学習済みモデルvgg19_bnをパラメータ付きで読み込む
from torchvision import models
net = models.vgg19_bn(pretrained = True)
# 乱数初期化
torch_seed()
# 最終ノードの出力を24に変更する
in_features = net.classifier[6].in_features
net.classifier[6] = nn.Linear(in_features, len(classes))
# AdaptiveAvgPool2d関数の取り外し
net.avgpool = nn.Identity()
# GPUの利用
net = net.to(device)
# 学習率
lr = 0.001
# 損失関数定義
criterion = nn.CrossEntropyLoss()
# 最適化関数定義
optimizer = optim.SGD(net.parameters(),lr=lr,momentum=0.9)
# historyファイルも同時に初期化する
history = np.zeros((0, 5))

print(train_data.classes)
print(train_data.class_to_idx)

# 関数定義
#train_epoch関数
def train_epoch(model, optimizer, criterion, dataloader, device):
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0

    pbar = tqdm(dataloader, desc="Train", leave=False)

    for images, labels in pbar:
        images = images.to(device)
        labels = labels.to(device)

        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item() * images.size(0)
        _, preds = torch.max(outputs, 1)
        correct += (preds == labels).sum().item()
        total += labels.size(0)

        pbar.set_postfix(loss=loss.item())

    return running_loss / total, correct / total


#eval_epoch関数
def eval_epoch(model, criterion, dataloader, device):
    model.eval()
    running_loss = 0.0
    correct = 0
    total = 0

    pbar = tqdm(dataloader, desc="Val", leave=False)

    with torch.no_grad():
        for images, labels in pbar:
            images = images.to(device)
            labels = labels.to(device)

            outputs = model(images)
            loss = criterion(outputs, labels) 

            running_loss += loss.item() * images.size(0)
            _, preds = torch.max(outputs, 1)
            correct += (preds == labels).sum().item()
            total += labels.size(0)

            pbar.set_postfix(loss=loss.item())

    epoch_loss = running_loss / total
    epoch_acc = correct / total

    return epoch_loss, epoch_acc

#学習
# 表示設定
pd.set_option('display.max_columns', None)
# ====== 共通関数 ======
def sec_to_hms(sec):
    sec = int(sec)
    h = sec // 3600
    m = (sec % 3600) // 60
    s = sec % 60
    return f"{h:02d}:{m:02d}:{s:02d}"

# ====== 保存設定 ======
SAVE_DIR = "./checkpoints"
os.makedirs(SAVE_DIR, exist_ok=True)
HISTORY_CSV = f"{SAVE_DIR}/history.csv"
BEST_MODEL = f"{SAVE_DIR}/best_model.pth"

# ====== 学習設定 ======
max_epochs = 500
patience = 10

best_val_acc = 0.0
best_epoch = 0
best_state_dict = None
no_improve_count = 0
history = []

train_start_time = time.time()
epoch_times = []

# ====== グラフ初期化（1回だけ）=====
plt.ioff()
fig, ax = plt.subplots(1, 2, figsize=(13, 4))
display(fig)
prev_val_acc = None

try:
    for epoch in range(1, max_epochs + 1):
        epoch_start = time.time()

        train_loss, train_acc = train_epoch(
            net, optimizer, criterion, train_loader, device
        )
        val_loss, val_acc = eval_epoch(
            net, criterion, test_loader, device
        )

        epoch_time = time.time() - epoch_start
        epoch_times.append(epoch_time)

        elapsed = time.time() - train_start_time
        avg_epoch = sum(epoch_times) / len(epoch_times)
        eta = avg_epoch * (max_epochs - epoch)

        history.append([
            epoch,
            train_loss, train_acc,
            val_loss, val_acc,
            sec_to_hms(epoch_time),
            sec_to_hms(elapsed)
        ])

        # ===== 表示更新 =====
        clear_output(wait=True)

        print(f"Epoch {epoch}/{max_epochs}")
        print(f"  train_acc = {train_acc:.4f}  train_loss = {train_loss:.4f}")
        print(f"  val_acc   = {val_acc:.4f}  val_loss   = {val_loss:.4f}")
        print(f"  epoch時間(平均): {sec_to_hms(avg_epoch)}")
        print(f"  経過時間       : {sec_to_hms(elapsed)}")
        print(f"  終了予想時間   : {sec_to_hms(eta)}")

        df = pd.DataFrame(
            history,
            columns=[
                "epoch",
                "train_loss", "train_acc",
                "val_loss", "val_acc",
                "epoch_time", "elapsed_time"
            ]
        )
        display(df.tail(10))

        # ===== グラフ更新 =====
        ax[0].cla()
        ax[1].cla()

        ax[0].plot(df["epoch"], df["train_loss"], label="train_loss")
        ax[0].plot(df["epoch"], df["val_loss"], label="val_loss")
        ax[0].set_title("Loss")
        ax[0].grid()

        ax[1].plot(df["epoch"], df["train_acc"], label="train_acc")
        ax[1].plot(df["epoch"], df["val_acc"], label="val_acc")
        ax[1].set_title("Accuracy")
        ax[1].grid()

        if best_epoch > 0:
            ax[0].axvline(best_epoch, color="red", linestyle="--")
            ax[1].axvline(best_epoch, color="red", linestyle="--")
            ax[1].text(
                best_epoch,
                best_val_acc,
                f"best={best_val_acc:.3f}",
                color="red"
            )

        ax[0].legend()
        ax[1].legend()
        fig.canvas.draw_idle()
        display(fig)

        # ===== val_acc 低下警告 =====
        if prev_val_acc is not None and val_acc < prev_val_acc:
            print(" 警告: val_acc が低下しています")

        prev_val_acc = val_acc

        # ===== ベスト更新 =====
        if val_acc > best_val_acc:
            best_val_acc = val_acc
            best_epoch = epoch
            best_state_dict = net.state_dict()
            torch.save(best_state_dict, BEST_MODEL)
            no_improve_count = 0
        else:
            no_improve_count += 1

        df.to_csv(HISTORY_CSV, index=False)

        if no_improve_count >= patience:
            print("\n過学習の兆候を検出")
            print(f"最良 val_acc: {best_val_acc:.4f}")
            print(f"最良 epoch : {best_epoch}")
            break

except KeyboardInterrupt:
    print("\n 学習を中断しました（Ctrl+C）")

finally:
    if best_state_dict is not None:
        net.load_state_dict(best_state_dict)
        torch.save(best_state_dict, BEST_MODEL)
    df.to_csv(HISTORY_CSV, index=False)
    print(" 学習状態を保存しました")

# 検証データへの結果表示
torch_seed()
show_images_labels(test_loader2, classes, net, device)

# PyTorch 保存
acc_percent = int(round(best_val_acc * 100))
base_name = f"{project}_{acc_percent}"
pth_name = f"{base_name}.pth"
torch.save(net.state_dict(), pth_name)
print(f"PyTorchモデル保存: {pth_name}")

# ONNX 保存
onnx_name = f"{base_name}.onnx"
dummy_input = torch.randn(1, 3, 224, 224).to(device)

torch.onnx.export(
    net,
    dummy_input,
    onnx_name,
    input_names=['input'],
    output_names=['output'],
    dynamic_axes={'input': {0: 'batch_size'},
                  'output': {0: 'batch_size'}},
    opset_version=11
)
print(f"ONNXモデル保存: {onnx_name}")

#クラス別 accuracy を計算する関数
def evaluate_per_class_accuracy(model, dataloader, classes, device):
    model.eval()
    
    num_classes = len(classes)
    correct = np.zeros(num_classes, dtype=int)
    total = np.zeros(num_classes, dtype=int)

    with torch.no_grad():
        for images, labels in dataloader:
            images = images.to(device)
            labels = labels.to(device)

            outputs = model(images)
            _, preds = torch.max(outputs, 1)

            for i in range(len(labels)):
                label = labels[i].item()
                pred = preds[i].item()
                total[label] += 1
                if pred == label:
                    correct[label] += 1

    acc = np.zeros(num_classes)
    for i in range(num_classes):
        if total[i] > 0:
            acc[i] = correct[i] / total[i] * 100
        else:
            acc[i] = np.nan  # データなし

    return acc, correct, total


#検証データで評価
per_class_acc, correct, total = evaluate_per_class_accuracy(
    net, test_loader, classes, device
)

for i, cls in enumerate(classes):
    print(f"{cls:15s} : {per_class_acc[i]:6.2f}% ({correct[i]}/{total[i]})")


#グラフ表示
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))
bars = plt.bar(range(len(classes)), per_class_acc)
plt.xticks(range(len(classes)), classes, rotation=90)
plt.ylabel("Validation Accuracy (%)")
plt.title("Class-wise Validation Accuracy")

# 80%未満を赤に
for i, acc in enumerate(per_class_acc):
    if not np.isnan(acc) and acc < 80:
        bars[i].set_color("red")

import os
import sys
sys.path.insert(1,"/home/pi/SUN/lib/python3.13/site-packages")
import numpy as np
import sys
import time
import random
import torch
from torchvision import transforms, models
import cv2
from PIL import Image
import datetime
import schedule
import pytz
from time import sleep
import paho.mqtt.client as mqtt

dt_now = datetime.datetime.now()
delay = 1
output_dir = '/home/pi/SUN/CAPTURE/'
frame = []
# ===== 送信制御フラグ =====
allow_send = True        # MQTT送信許可
current_lux = None       # 最新照度
LUX_THRESHOLD = 300      # 閾値
time_allow = False
start_time = 7       #朝測定開始時間
end_time = 17        #夜測定終了時間

def on_message(client, userdata, msg):
    global allow_send, current_lux

    topic = msg.topic
    payload = msg.payload.decode()

    # --- シャットダウン ---
    if topic == "sun_pat" and payload == "shutdown":
        print("Shutdown command received")
        client.loop_stop()
        os.system("sudo shutdown -h now")
        return

    # --- 照度受信 ---
    if topic == "lux":
        try:
            current_lux = float(payload)
            current_lux = 2000            #照度計が設置されている場合にはコメントアウトする。
            if current_lux < LUX_THRESHOLD:
                allow_send = False
                print(f"Lux={current_lux} → 送信停止")
            else:
                allow_send = True
                print(f"Lux={current_lux} → 照度OK")
        except ValueError:
            print("lux payload parse error:", payload)

def on_connect(client, userdata, flags, reason_code, properties):
    print(f"Connected mqtt broker {reason_code}")
    client.subscribe("lux")
    client.subscribe("sun_pat")

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
client.on_connect = on_connect
client.on_message = on_message
client.connect("192.168.2.242", 1884, 60)
client.loop_start()

def publish(data):
    if not allow_send:
        print("送信停止中のため publish をスキップ")
        return
    client.publish('sky_pat', payload=data, qos=0, retain=False)
    print(f"send {data} to sky_pat")

def save_image_with_sequence(image, directory, filename_prefix, start_num=1, padding=5):
    global current_sky
    
    if not os.path.exists(directory):
        os.makedirs(directory)

    num = start_num
    while True:
        # 現在の日時を取得
        now = datetime.datetime.now(pytz.timezone('Asia/Tokyo'))
        filename = str(now.year) + str(now.month) + str(now.day) + str(now.hour) + '-' + \
                   f"{str(num).zfill(padding)}.png"

        filepath = os.path.join(directory, filename)
        if not os.path.exists(filepath):
            cv2.imwrite(filepath, image)
            print(f"保存しました: {filepath}")
            break
        num += 1
        
filename_prefix = "image"
start_number = 1
padding = 5

# --- モデル定義 ---
model = models.vgg19_bn(weights=None)
model.classifier[6] = torch.nn.Linear(model.classifier[6].in_features, 3)
model.avgpool = torch.nn.Identity()
model.load_state_dict(torch.load("sun_96.pth", map_location="cpu"))
model.eval()

# --- 前処理（学習時と同じ） ---
preprocess = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5, 0.5,0.5],std=[0.5,0.5,0.5])
])

# --- TapoカメラURL ---
RTSP_URL = "rtsp://tarou:1234567@192.168.1.100:554/stream1?rtsp transport = tcp" 

classes = ["BS", "CB", "CS"]
label_to_index = {label: idx for idx, label in enumerate(classes)}

def task():
    global time_allow

    now = datetime.datetime.now(pytz.timezone('Asia/Tokyo'))
    hour = now.hour

    if hour < start_time or hour >= end_time:
        print(f"{hour}時夜間のため送信停止")
        time_allow = False
        return
    else:
        time_allow = True

    # ==== RTSP接続 ====
    cap = cv2.VideoCapture(RTSP_URL)
    if not cap.isOpened():
        print("RTSPストリームに接続できません", flush=True)
        sys.exit(1)
    # カメラ画像取得
    ret, frame = cap.read()
    if not ret:
        print("フレーム取得失敗", flush=True)
        sys.exit(1)
    # 表示用プレビュー
    preview = cv2.resize(frame,(224,224))
    cv2.imshow("Frame", preview)
    cv2.waitKey(1)
    frame = cv2.cvtColor(frame,cv2.COLOR_BGR2RGB)    
    img_pil = Image.fromarray(frame)
    img_tensor = preprocess(img_pil).unsqueeze(0)  # NCHWに変換
     # 推論
    with torch.no_grad():
        outputs = model(img_tensor)
        predicted = torch.argmax(outputs, dim=1).item()
        current_sky = classes[predicted]
        tenki = ''
        snd = ''
        if current_sky == 'CB':
            tenki = '快晴'
            snd = '1'
        elif current_sky == 'BS':
            tenki = '晴天'
            snd = '2'
        elif current_sky == 'CS':
            tenki = '曇天'
            snd = '3'
        print(f"[{time.strftime('%H:%M:%S')}] 現在の空模様：{tenki}")
        
        if not (allow_send and time_allow):
            print("送信条件未達（照度 or 時刻）")
            return
        
        #結果を送信
        publish(snd)

        # 保存先のディレクトリ
        save_image_with_sequence(preview, output_dir + current_sky + '/', "image")

#スケジュール登録
schedule.every(180).seconds.do(task)
#イベント実行
while True:
    if cv2.waitKey(delay) & 0xFF == ord('q'):
        break
    schedule.run_pending()
    sleep(1)

import time
import os
import sys
sys.path.insert(1,"/home/pi/SUN/lib/python3.13/site-packages")
import cv2
import numpy as np
import sys
import datetime
import time
import schedule
from time import sleep
from PIL import Image
import pytz
import onnxruntime as ort
from torchvision import transforms
import paho.mqtt.client as mqtt
dt_now = datetime.datetime.now()
delay = 1
output_dir = '/home/pi/SUN/CAPTURE/'
# --- TapoカメラURL ---
RTSP_URL = "rtsp://tarou:1234567@192.168.1.100:554/stream1?rtsp transport = tcp" 

# --- モデル・クラス設定 ---
ONNX_MODEL = "sun_96.onnx"  # ONNXモデルファイル
CLASS_NAMES = ["BS", "CB", "CS"]  # 学習時のクラス順
IMG_SIZE = (224, 224)
# ===== 送信制御フラグ =====
allow_send = True        # MQTT送信許可
current_lux = None       # 最新照度
LUX_THRESHOLD = 300      # 閾値
time_allow = False
start_time = 7       #朝測定開始時間
end_time = 17        #夜測定終了時間

# --- 前処理（学習時と同じ正規化設定にする） ---
preprocess = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])
    
def on_message(client, userdata, msg):
    global allow_send, current_lux

    topic = msg.topic
    payload = msg.payload.decode()

    # --- シャットダウン ---
    if topic == "sun_pat" and payload == "shutdown":
        print("Shutdown command received")
        client.loop_stop()
        os.system("sudo shutdown -h now")
        return

    # --- 照度受信 ---
    if topic == "lux":
        try:
            current_lux = float(payload)
            current_lux = 2000            #照度計が設置されている場合にはコメントアウトする。
            if current_lux < LUX_THRESHOLD:
                allow_send = False
                print(f"Lux={current_lux} → 送信停止")
            else:
                allow_send = True
                print(f"Lux={current_lux} → 照度OK")
        except ValueError:
            print("lux payload parse error:", payload)



def on_connect(client, userdata, flags, reason_code, properties):
    print(f"Connected mqtt broker {reason_code}")
    client.subscribe("lux")
    client.subscribe("sun_pat")
    
client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
client.on_connect = on_connect
client.on_message = on_message
client.connect("192.168.2.242", 1884, 60)
client.loop_start()

def publish(data):
    if not allow_send:
        print("送信停止中のため publish をスキップ")
        return
    client.publish('sky_pat', payload=data, qos=0, retain=False)
    print(f"send {data} to sky_pat")

def save_image_with_sequence(image, directory, filename_prefix, start_num=1, padding=5):
    global current_sky
    
    if not os.path.exists(directory):
        os.makedirs(directory)

    num = start_num
    while True:
        # 現在の日時を取得
        now = datetime.datetime.now(pytz.timezone('Asia/Tokyo'))
        filename = str(now.year) + str(now.month) + str(now.day) + str(now.hour) + '-' + \
                   f"{str(num).zfill(padding)}.png"
        filepath = os.path.join(directory, filename)
        if not os.path.exists(filepath):
            cv2.imwrite(filepath, image)
            print(f"保存しました: {filepath}")
            break
        num += 1
        
filename_prefix = "image"
start_number = 1
padding = 5

def task():
    global time_allow

    now = datetime.datetime.now(pytz.timezone('Asia/Tokyo'))
    hour = now.hour

    if hour < start_time or hour >= end_time:
        print(f"{hour}時夜間のため送信停止")
        time_allow = False
        return
    else:
        time_allow = True
        
    # ==== RTSP接続 ====
    cap = cv2.VideoCapture(RTSP_URL)
    if not cap.isOpened():
        print("RTSPストリームに接続できません", flush=True)
        sys.exit(1)
    # カメラ画像取得
    ret, frame = cap.read()
    if not ret:
        print("フレーム取得失敗", flush=True)
        sys.exit(1)
    
        # 表示用プレビュー
    preview = cv2.resize(frame,(224,224))
    cv2.imshow("Frame", preview)
    cv2.waitKey(1)
    
    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

    # 前処理
    pil_frame = Image.fromarray(frame_rgb)
    tensor_frame = preprocess(pil_frame).unsqueeze(0)  # (1,3,224,224)
    input_data = tensor_frame.numpy().astype(np.float32)  # ここで4次元に確定

    # --- ONNX 推論セッション ---
    session = ort.InferenceSession(ONNX_MODEL, providers=["CPUExecutionProvider"])

    # 推論
    ort_inputs = {session.get_inputs()[0].name: input_data}
    ort_outs = session.run(None, ort_inputs)
    predicted = np.argmax(ort_outs[0])
    current_sky = CLASS_NAMES[predicted]
    tenki = ''
    snd = ''
    if current_sky == 'CB':
        tenki = '快晴'
        snd = '1'
    elif current_sky == 'BS':
        tenki = '晴天'
        snd = '2'
    elif current_sky == 'CS':
        tenki = '曇天'
        snd = '3'
    print(f"[{time.strftime('%H:%M:%S')}] 現在の空模様：{tenki}")
    if not (allow_send and time_allow):
        print("送信条件未達（照度 or 時刻）")
        return
    #結果を送信
    publish(snd)

    # 保存先のディレクトリ
    save_image_with_sequence(preview, output_dir + current_sky + '/', "image")
    
#スケジュール登録
schedule.every(180).seconds.do(task)

#イベント実行
while True:
    if cv2.waitKey(delay) & 0xFF == ord('q'):
        break
    schedule.run_pending()
    sleep(1)