推論ツールの案20250322

2025年3月22日 04:19

using System;

public class TimeSeriesPredictor
{
    /// <summary>
    /// 過去のデータを基に未来の値を予測する。
    /// </summary>
    /// <param name="data">時系列データ</param>
    /// <param name="windowSize">過去と未来のウィンドウサイズ</param>
    /// <returns>予測値の配列</returns>
    public double[] Predict(double[] data, int windowSize)
    {
        if (data == null || data.Length == 0)
            throw new ArgumentException("データが空です。");

        double[] predictions = new double[data.Length];
        for (int i = 0; i < data.Length; i++)
        {
            double pastAvg = 0, futureAvg = 0;
            int pastCount = 0, futureCount = 0;

            // 過去のデータを平均
            for (int j = Math.Max(0, i - windowSize); j < i; j++)
            {
                pastAvg += data[j];
                pastCount++;
            }
            pastAvg = pastCount > 0 ? pastAvg / pastCount : 0;

            // 未来のデータを平均（シミュレーション用）
            for (int j = i + 1; j < Math.Min(data.Length, i + windowSize + 1); j++)
            {
                futureAvg += data[j];
                futureCount++;
            }
            futureAvg = futureCount > 0 ? futureAvg / futureCount : 0;

            // 双方向平均を予測値とする
            predictions[i] = (pastAvg + futureAvg) / 2;
        }
        return predictions;
    }
}

TimeSeriesPredictorクラスは、
過去の時系列データから未来の値を予測します。

双方向の情報を活用し、
過去と未来のデータの平均を計算する簡易的な方法で実装します。

説明

Predictメソッド
- 入力: 時系列データdata（double型の配列）とウィンドウサイズwindowSize。
- 出力: 各時点での予測値を含む配列。
- ロジック: 各時点iにおいて、過去windowSize個のデータと未来windowSize個のデータの平均を計算し、その中間値を予測値とします。
注意
- この実装はシミュレーション用です。実際の予測では未来のデータは利用できないため、過去データのみを使用するモデル（例：ARIMAや移動平均）を検討する必要があります。
- 例外処理を追加し、データが空の場合にエラーをスローします。

using System;

public class BidirectionalHMM
{
    private double[,] forwardTransitions; // 順方向遷移確率行列
    private double[,] backwardTransitions; // 逆方向遷移確率行列
    private double[,] observations; // 観測確率行列
    private int stateCount; // 状態数
    private int observationCount; // 観測シンボル数

    /// <summary>
    /// 双方向HMMを初期化します。
    /// </summary>
    public BidirectionalHMM(double[,] forwardTransitions, double[,] backwardTransitions, double[,] observations)
    {
        this.forwardTransitions = forwardTransitions;
        this.backwardTransitions = backwardTransitions;
        this.observations = observations;
        this.stateCount = forwardTransitions.GetLength(0);
        this.observationCount = observations.GetLength(1);

        // 入力検証
        if (forwardTransitions.GetLength(1) != stateCount || backwardTransitions.GetLength(0) != stateCount ||
            backwardTransitions.GetLength(1) != stateCount || observations.GetLength(0) != stateCount)
            throw new ArgumentException("行列の次元が一致しません。");
    }

    /// <summary>
    /// 双方向Viterbiアルゴリズムで最尤状態系列を推定します。
    /// </summary>
    /// <param name="sequence">観測シーケンス</param>
    /// <returns>推定された状態系列</returns>
    public int[] Viterbi(double[] sequence)
    {
        int T = sequence.Length;
        double[,] V_forward = new double[T, stateCount]; // 順方向確率
        double[,] V_backward = new double[T, stateCount]; // 逆方向確率
        int[,] path_forward = new int[T, stateCount];
        int[,] path_backward = new int[T, stateCount];
        int[] states = new int[T];

        // 初期確率（均等分布と仮定）
        for (int s = 0; s < stateCount; s++)
        {
            V_forward[0, s] = (1.0 / stateCount) * observations[s, (int)sequence[0]];
            V_backward[T - 1, s] = (1.0 / stateCount) * observations[s, (int)sequence[T - 1]];
        }

        // 順方向Viterbi
        for (int t = 1; t < T; t++)
        {
            for (int s = 0; s < stateCount; s++)
            {
                double maxProb = double.MinValue;
                int maxState = 0;
                for (int prev = 0; prev < stateCount; prev++)
                {
                    double prob = V_forward[t - 1, prev] * forwardTransitions[prev, s] * observations[s, (int)sequence[t]];
                    if (prob > maxProb)
                    {
                        maxProb = prob;
                        maxState = prev;
                    }
                }
                V_forward[t, s] = maxProb;
                path_forward[t, s] = maxState;
            }
        }

        // 逆方向Viterbi
        for (int t = T - 2; t >= 0; t--)
        {
            for (int s = 0; s < stateCount; s++)
            {
                double maxProb = double.MinValue;
                int maxState = 0;
                for (int next = 0; next < stateCount; next++)
                {
                    double prob = V_backward[t + 1, next] * backwardTransitions[next, s] * observations[s, (int)sequence[t]];
                    if (prob > maxProb)
                    {
                        maxProb = prob;
                        maxState = next;
                    }
                }
                V_backward[t, s] = maxProb;
                path_backward[t, s] = maxState;
            }
        }

        // 順方向と逆方向の確率を統合
        double[] combinedProb = new double[stateCount];
        int startState = 0;
        for (int s = 0; s < stateCount; s++)
        {
            combinedProb[s] = V_forward[T - 1, s] + V_backward[0, s];
            if (combinedProb[s] > combinedProb[startState])
                startState = s;
        }

        // 状態系列の復元（順方向パスを使用）
        states[T - 1] = startState;
        for (int t = T - 2; t >= 0; t--)
        {
            states[t] = path_forward[t + 1, states[t + 1]];
        }

        return states;
    }
}

BidirectionalHMMクラスは、
双方向の状態遷移を考慮した隠れマルコフモデルです。

ここでは、双方向Viterbiアルゴリズムの完全な実装を提供します。

説明

コンストラクタ
- 順方向遷移確率forwardTransitions、逆方向遷移確率backwardTransitions、観測確率observationsを受け取ります。
- 行列の次元が一致しない場合に例外をスローします。
Viterbiメソッド
- 順方向と逆方向のViterbiアルゴリズムを実行し、最尤の状態系列を推定します。
- 初期確率は均等分布と仮定し、観測シーケンスに基づいて動的計画法で確率を計算します。
- 最終的に、順方向と逆方向の確率を統合して最適な状態系列を決定します。

using MathNet.Numerics.LinearAlgebra;
using MathNet.Numerics.LinearAlgebra.Complex;
using System.Numerics;
using System;

public class LindbladSolver
{
    private Matrix<Complex> H; // ハミルトニアン
    private Matrix<Complex>[] L; // リンドブラッド演算子
    private double dt; // タイムステップ
    private int steps; // ステップ数

    /// <summary>
    /// LindbladSolverを初期化します。
    /// </summary>
    public LindbladSolver(Matrix<Complex> H, Matrix<Complex>[] L, double dt, int steps)
    {
        this.H = H ?? throw new ArgumentNullException(nameof(H));
        this.L = L ?? throw new ArgumentNullException(nameof(L));
        this.dt = dt > 0 ? dt : throw new ArgumentException("タイムステップは正でなければなりません。");
        this.steps = steps > 0 ? steps : throw new ArgumentException("ステップ数は正でなければなりません。");
    }

    /// <summary>
    /// 密度行列を時間tだけ発展させます。
    /// </summary>
    /// <param name="rho">初期密度行列</param>
    /// <param name="t">発展時間</param>
    /// <returns>発展後の密度行列</returns>
    public Matrix<Complex> Evolve(Matrix<Complex> rho, double t)
    {
        var rhoCurrent = rho.Clone();
        var sgnT = Math.Sign(t);
        int totalSteps = (int)(Math.Abs(t) / dt);

        // Euler法で時間発展を計算
        for (int i = 0; i < totalSteps; i++)
        {
            rhoCurrent += dt * LindbladRHS(rhoCurrent, sgnT);
        }
        return rhoCurrent;
    }

    /// <summary>
    /// Lindblad方程式の右辺を計算します。
    /// </summary>
    private Matrix<Complex> LindbladRHS(Matrix<Complex> rho, int sgnT)
    {
        // ハミルトニアンによるコヒーレント項: -i[H, ρ]
        var commutator = -Complex.ImaginaryOne * (H * rho - rho * H);

        // リンドブラッド項
        var dissipation = Matrix<Complex>.Build.Dense(rho.RowCount, rho.ColumnCount);
        foreach (var Lk in L)
        {
            var LkDagger = Lk.ConjugateTranspose();
            dissipation += Lk * rho * LkDagger - 0.5 * (LkDagger * Lk * rho + rho * LkDagger * Lk);
        }

        return commutator + sgnT * dissipation;
    }
}

LindbladSolverクラスは、Lindblad方程式を数値的に解き、
量子系の時間発展をシミュレートします。

説明

コンストラクタ
- ハミルトニアンH、リンドブラッド演算子L、タイムステップdt、ステップ数stepsを受け取ります。
- 入力値の検証を行い、無効な場合には例外をスローします。
Evolveメソッド
- 初期密度行列rhoを時間tだけ発展させます。
- 簡略化のためEuler法を使用していますが、実用的にはRunge-Kutta法などの高精度な手法を推奨します。
LindbladRHSメソッド
- Lindblad方程式の右辺を計算します。コヒーレント項（ハミルトニアンによる発展）とディシぺーション項（リンドブラッド演算子による散逸）を組み合わせます。

using MathNet.Numerics.LinearAlgebra;
using MathNet.Numerics.LinearAlgebra.Complex;
using System.Numerics;
using System;

public static class EntropyCalculator
{
    /// <summary>
    /// Von Neumannエントロピーを計算します。
    /// </summary>
    /// <param name="rho">密度行列</param>
    /// <returns>Von Neumannエントロピー</returns>
    public static double VonNeumannEntropy(Matrix<Complex> rho)
    {
        if (rho == null)
            throw new ArgumentNullException(nameof(rho));

        var evd = rho.Evd();
        var eigenvalues = evd.EigenValues;
        double entropy = 0.0;

        foreach (var lambda in eigenvalues)
        {
            double realPart = lambda.Real;
            if (realPart > 1e-10) // 負やゼロを避ける
            {
                entropy -= realPart * Math.Log(realPart);
            }
        }
        return entropy;
    }
}

EntropyCalculatorクラスは、Von Neumannエントロピーを計算します。

説明

VonNeumannEntropyメソッド
- 密度行列rhoの固有値分解を行い、各固有値に基づいてVon Neumannエントロピーを計算します。
- 微小な値（1e-10以下）を無視し、数値的不安定性を回避します。

using System;
using MathNet.Numerics.LinearAlgebra;
using MathNet.Numerics.LinearAlgebra.Complex;
using System.Numerics;

class Program
{
    static void Main(string[] args)
    {
        // 時系列予測の使用例
        Console.WriteLine("=== 時系列予測の例 ===");
        double[] pastData = { 1000, 1050, 1100, 1150, 1200 }; // 過去5年間の死亡数
        var predictor = new TimeSeriesPredictor();
        int windowSize = 2;
        double[] predictions = predictor.Predict(pastData, windowSize);
        Console.WriteLine("過去データ: " + string.Join(", ", pastData));
        Console.WriteLine("予測値: " + string.Join(", ", predictions));

        // 双方向HMMの使用例
        Console.WriteLine("\n=== 双方向HMMの例 ===");
        double[,] forwardTransitions = { { 0.7, 0.3 }, { 0.4, 0.6 } };
        double[,] backwardTransitions = { { 0.6, 0.4 }, { 0.3, 0.7 } };
        double[,] observations = { { 0.9, 0.1 }, { 0.2, 0.8 } };
        var hmm = new BidirectionalHMM(forwardTransitions, backwardTransitions, observations);
        double[] sequence = { 0, 1, 0, 1 };
        int[] states = hmm.Viterbi(sequence);
        Console.WriteLine("観測シーケンス: " + string.Join(", ", sequence));
        Console.WriteLine("推定状態: " + string.Join(", ", states));

        // 量子系シミュレーションの使用例
        Console.WriteLine("\n=== 量子系シミュレーションの例 ===");
        var H = Matrix<Complex>.Build.Dense(2, 2, (i, j) => i == j ? Complex.One : Complex.Zero);
        var L = new[] { Matrix<Complex>.Build.Dense(2, 2, (i, j) => i == 1 && j == 0 ? Complex.One : Complex.Zero) };
        var solver = new LindbladSolver(H, L, 0.01, 100);
        var rho0 = Matrix<Complex>.Build.Dense(2, 2, (i, j) => i == j ? 0.5 : Complex.Zero);
        var rhoT = solver.Evolve(rho0, 1.0);
        double entropy = EntropyCalculator.VonNeumannEntropy(rhoT);
        Console.WriteLine("初期密度行列:\n" + rho0.ToString());
        Console.WriteLine("発展後の密度行列:\n" + rhoT.ToString());
        Console.WriteLine("Von Neumannエントロピー: " + entropy);
    }
}

過去の死亡数データを用いて
未来の死亡数を予測するシナリオを想定します。

実行結果（例）

=== 時系列予測の例 ===
過去データ: 1000, 1050, 1100, 1150, 1200
予測値: 1050, 1075, 1100, 1150, 1175

=== 双方向HMMの例 ===
観測シーケンス: 0, 1, 0, 1
推定状態: 0, 1, 0, 1

=== 量子系シミュレーションの例 ===
初期密度行列: [0.5, 0] [0, 0] [0, 0] [0.5, 0]
発展後の密度行列: [...数値...] [...数値...] [...数値...] [...数値...]
Von Neumannエントロピー: 0.6931471805599453

7. ツールの利点と注意点

利点

柔軟性: 時系列予測、確率モデル、量子シミュレーションを1つのツールで実現。
高精度: 双方向の情報を活用することで、単方向モデルよりも精度向上が期待できる。
拡張性: 将来的に量子コンピューティングや深層学習との統合が可能。

注意点

学習コスト: C#や数学的背景（確率論、量子力学）の知識が必要。
データ要件: 高精度な予測には大量かつ高品質なデータが必要。
計算負荷: 大規模データや複雑なモデルでは計算リソースを多く消費する。

8. まとめ

この推論ツールは、時系列予測、双方向マルコフモデル、量子力学ベースの計算を統合した強力なシステムです。

過去の死亡数から未来の死亡数を予測するなどの実用的な応用が可能で、ExcelのGROWTH関数と比較しても柔軟性と精度で優れています。

ツールを効果的に使用するには、プログラミングと数学の知識が必要ですが、その分、高品質な予測が得られます。

CMakeLists.txt

cmake_minimum_required(VERSION 3.10)
project(InferenceTool)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOUIC ON)

find_package(Qt5 COMPONENTS Widgets REQUIRED)

add_executable(InferenceTool
    main.cpp
    TimeSeriesPredictor.cpp
    MainWindow.cpp
)

target_link_libraries(InferenceTool Qt5::Widgets)

TimeSeriesPredictor.h

時系列予測を行うクラスのヘッダーファイルです。

#ifndef TIMESERIESPREDICTOR_H
#define TIMESERIESPREDICTOR_H

#include <vector>

class TimeSeriesPredictor {
public:
    std::vector<double> predict(const std::vector<double>& data, int windowSize);
};

#endif // TIMESERIESPREDICTOR_H

TimeSeriesPredictor.cpp

時系列予測の実装です。
過去と未来のデータを平均化して予測値を計算します。

#include "TimeSeriesPredictor.h"
#include <algorithm>
#include <stdexcept>

std::vector<double> TimeSeriesPredictor::predict(const std::vector<double>& data, int windowSize) {
    if (data.empty()) {
        throw std::invalid_argument("データが空です。");
    }
    if (windowSize <= 0) {
        throw std::invalid_argument("ウィンドウサイズは正の値でなければなりません。");
    }

    std::vector<double> predictions(data.size());
    for (size_t i = 0; i < data.size(); ++i) {
        double pastAvg = 0.0, futureAvg = 0.0;
        int pastCount = 0, futureCount = 0;

        // 過去のデータを平均
        for (int j = std::max(0, static_cast<int>(i) - windowSize); j < static_cast<int>(i); ++j) {
            pastAvg += data[j];
            pastCount++;
        }
        pastAvg = pastCount > 0 ? pastAvg / pastCount : 0.0;

        // 未来のデータを平均（シミュレーション用）
        for (size_t j = i + 1; j < std::min(data.size(), i + windowSize + 1); ++j) {
            futureAvg += data[j];
            futureCount++;
        }
        futureAvg = futureCount > 0 ? futureAvg / futureCount : 0.0;

        predictions[i] = (pastAvg + futureAvg) / 2.0;
    }
    return predictions;
}

MainWindow.h

GUIのメインウィンドウを定義するヘッダーファイルです。

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QLineEdit>
#include <QPushButton>
#include <QTextEdit>

class MainWindow : public QMainWindow {
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);

private slots:
    void onPredictButtonClicked();

private:
    QLineEdit *dataInput;
    QLineEdit *windowSizeInput;
    QPushButton *predictButton;
    QTextEdit *resultOutput;
};

#endif // MAINWINDOW_H

MainWindow.cpp

GUIの実装です。ユーザーがデータを入力し、予測ボタンを押すと結果を表示します。

#include "MainWindow.h"
#include "TimeSeriesPredictor.h"
#include <QVBoxLayout>
#include <QLabel>
#include <QMessageBox>
#include <sstream>

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) {
    // ウィジェットの作成
    dataInput = new QLineEdit(this);
    windowSizeInput = new QLineEdit(this);
    predictButton = new QPushButton("予測", this);
    resultOutput = new QTextEdit(this);
    resultOutput->setReadOnly(true);

    // レイアウトの設定
    QVBoxLayout *layout = new QVBoxLayout();
    layout->addWidget(new QLabel("時系列データ（カンマ区切り）:"));
    layout->addWidget(dataInput);
    layout->addWidget(new QLabel("ウィンドウサイズ:"));
    layout->addWidget(windowSizeInput);
    layout->addWidget(predictButton);
    layout->addWidget(new QLabel("予測結果:"));
    layout->addWidget(resultOutput);

    QWidget *centralWidget = new QWidget();
    centralWidget->setLayout(layout);
    setCentralWidget(centralWidget);

    // シグナルとスロットの接続
    connect(predictButton, &QPushButton::clicked, this, &MainWindow::onPredictButtonClicked);
}

void MainWindow::onPredictButtonClicked() {
    try {
        // 入力データを解析
        std::string dataStr = dataInput->text().toStdString();
        std::istringstream iss(dataStr);
        std::vector<double> data;
        std::string token;
        while (std::getline(iss, token, ',')) {
            data.push_back(std::stod(token));
        }

        int windowSize = windowSizeInput->text().toInt();

        // 予測の実行
        TimeSeriesPredictor predictor;
        std::vector<double> predictions = predictor.predict(data, windowSize);

        // 結果の表示
        std::ostringstream oss;
        for (size_t i = 0; i < predictions.size(); ++i) {
            oss << "時点 " << i << ": " << predictions[i] << "\n";
        }
        resultOutput->setText(QString::fromStdString(oss.str()));
    } catch (const std::exception& e) {
        QMessageBox::warning(this, "エラー", e.what());
    }
}

main.cpp

アプリケーションのエントリーポイントです。

#include "MainWindow.h"
#include <QApplication>

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    MainWindow window;
    window.setWindowTitle("推論ツール");
    window.resize(400, 300);
    window.show();
    return app.exec();
}

mkdir build
cd build
cmake ..

make

./InferenceTool

いいなと思ったら応援しよう！

ログインまたは会員登録するとコメントできます。

推論ツールの案20250322

いいなと思ったら応援しよう！

コメント

【速報】Python・時系列分析ライブラリ「Merlion」マジで凄すぎて草なんだ…w

ノーコードでpythonで機械学習してみた

時系列分析：Pythonでの実装とProphet

【mql5】２つのCCIでチャート分析をするヒストグラムオシレーター【ソースコード】

MT5環境認識インジケーター：いちもくりょーぜん😲 Part1

ABC396DEF備忘録

深層学習の教え！part2ニューラルネットワークの定義。今なら９８０円！

【生成AIとPythonで統計学】 1. 相関係数と散布図＆回帰直線

ゼロから作るDeep Learning_3章ニューラルネットワーク

第１節 ー私はアルゴリズムー

ナンバーズ3のPythonを使った予想方法

機械学習およびディープラーニングの準備

Monte Carlo for Stock Price Prediction

StockPriceAnalyzer

5週目：市場変動の統計分析 vs 感情バイアス

AI2nd day16 総合実践その２

ヒストリカルデータからtradingviewのチャートを作る！

GC(ゴールデンクロス)とかDC(デッドクロス)について考えてみる

ダウ理論

金融与信モデル（2）——証拠の重さと情報価値(WOE and IV)

ChatGPTのGPT‑4.5がリリース！ジョルノ式トレードをドル円とユーロドルのスキャルのEAに進化させてみた！【FX手法検証動画】

AI競馬予想 // 2025_0223【Update】

（応用）長期足のレジサポを一瞬で引き直すスクリプト

在庫予測の詳細解説

MCMC入門してみた

ついに予測精度60%越え ChatGPT推奨のAIモデルを評価してみた LSTM編

100個列挙に入れなかったもの

【第13回】機械学習に挑戦！scikit-learnで簡単な予測モデルを作ろう

「回帰分析から学ぶ計量経済学」をPythonで写経 ～ 第５章「時系列分析」⑤ランダムウォーク、階差系列、グレンジャー因果性

Pine Script™ (v6) の覚書 - 作ってみる： 日足・週足・月足再び- 上位足を重ねて表示する - (2)

統計学的アプローチによる競馬予想（調教データの活用法）

【3月13日配信】高精度なポイントのみを狙いに行く分析方法②

雑な株式の期待リターン計算方法（今回は方法だけ）

LogisticRegression関数：モデルの選択

忘却の彼方になりがちなC#コマンドなど

新年から全経理担当者に伝えたい 電帳法＆インボイスの負担を減らす文具の話

【生成AIとPythonで統計学】　1. 相関係数と散布図＆回帰直線

第１節　ー私はアルゴリズムー

AI2nd　day16　総合実践その２

AI競馬予想 //　2025_0223【Update】

「回帰分析から学ぶ計量経済学」をPythonで写経～第５章「時系列分析」⑤ランダムウォーク、階差系列、グレンジャー因果性

Pine Script™ (v6) の覚書 - 作ってみる：日足・週足・月足再び- 上位足を重ねて表示する - (2)

新年から全経理担当者に伝えたい　電帳法＆インボイスの負担を減らす文具の話