ICA-LiNGAMによる因果構造推定と、目的変数へのパス抽出による可視化

# **user**:

初学者向けにVSCodeを使ってStreamlitアプリを作るガイドを書いてください。そのアプリは、次のような動作をします。

・ユーザにcsvファイルまたはエクセルファイルの入力を促します。
・エクセルファイルの場合は、どのシートを見たいかユーザに確認します。
・入力された表形式データから、ユーザは、目的変数を表す列を一つ、説明変数を表す列を複数、選択します。
・ICA_LiNGAMを適用し、因果構造を推定します。

# **assistant**:

以下は、**初学者向け**に書かれた「VSCodeを使ってStreamlitアプリを作るガイド」です。CSVやExcelファイルを読み込み、ユーザーが変数を選択したうえで、ICA-LiNGAMを用いた因果構造推定を行うアプリを作成する流れを紹介します。

---

# 📘 初心者向けガイド：VSCode + Streamlitで因果構造分析アプリを作ろう！

## 🛠 前提条件

以下のツールがインストールされている必要があります：

- Python（おすすめ：Python 3.9以降）
- VSCode（Visual Studio Code）
- pip（Pythonのパッケージ管理ツール）

## 🧱 ステップ1：仮想環境の作成と必要パッケージのインストール

まず、プロジェクト用フォルダを作り、仮想環境を作成しましょう。

```bash
mkdir streamlit_causal_app
cd streamlit_causal_app
python -m venv venv
source venv/bin/activate  # Windows の場合: venv\Scripts\activate
```

次に必要なライブラリをインストールします。

```bash
pip install streamlit pandas openpyxl lingam
```

## 🖥 ステップ2：VSCodeで新しいファイルを作成

VSCodeで `app.py` というファイルを作成し、以下のコードを貼り付けます。

---

## 💻 アプリコード `app.py`

```python
import streamlit as st
import pandas as pd
from lingam import ICALiNGAM

st.title("📊 ICA-LiNGAM による因果構造推定アプリ")

# ファイルのアップロード
uploaded_file = st.file_uploader("CSVまたはExcelファイルをアップロードしてください", type=["csv", "xlsx"])

if uploaded_file:
    file_ext = uploaded_file.name.split(".")[-1].lower()

    # ファイル読み込み
    if file_ext == "csv":
        df = pd.read_csv(uploaded_file)
    elif file_ext == "xlsx":
        xls = pd.ExcelFile(uploaded_file)
        sheet_name = st.selectbox("シートを選択してください", xls.sheet_names)
        df = pd.read_excel(xls, sheet_name=sheet_name)
    else:
        st.error("対応していないファイル形式です。")
        st.stop()

    st.subheader("データプレビュー")
    st.dataframe(df.head())

    all_columns = df.columns.tolist()
    target_col = st.selectbox("目的変数（従属変数）を選択してください", all_columns)
    feature_cols = st.multiselect("説明変数（独立変数）を選択してください", [col for col in all_columns if col != target_col])

    if st.button("因果構造を推定する"):
        if not feature_cols:
            st.error("少なくとも1つの説明変数を選んでください。")
        else:
            # データの整形
            selected_cols = feature_cols + [target_col]
            data = df[selected_cols].dropna()

            # ICA-LiNGAM モデルの適用
            model = ICALiNGAM()
            model.fit(data)

            st.success("因果構造の推定が完了しました！")

            st.subheader("因果行列（推定された重み）")
            weight_df = pd.DataFrame(model.adjacency_matrix_, columns=selected_cols, index=selected_cols)
            st.dataframe(weight_df.round(3))

            st.subheader("因果の向き")
            for (i, j) in model.get_directed_graph():
                st.write(f"👉 {selected_cols[i]} → {selected_cols[j]}")
```

---

## 🚀 ステップ3：アプリを起動する

ターミナルで以下のコマンドを実行します。

```bash
streamlit run app.py
```

ブラウザが開いて、Streamlitアプリが表示されます。

---

## 🎓 補足ポイント（初心者向けTips）

- **仮想環境**は、プロジェクトごとのライブラリを分離するためのものです。安心していろいろ試せます。
- `ICA-LiNGAM` は、データから因果関係を学習するライブラリです。列間の因果の「向き」を教えてくれます。
- `st.selectbox` や `st.multiselect` で、ユーザーから変数を選んでもらうインタラクティブなインターフェースが作れます。

---

## 📌 まとめ

このアプリは、データをアップロードして変数を選ぶだけで、複雑な因果分析を実行できます。初心者でも簡単に扱えるよう、StreamlitのUI機能とVSCodeの開発環境を活用しました。

---

必要であれば、次のような改良アイデアもご紹介できます：

- グラフで因果構造を可視化
- 分析結果をダウンロード
- 複数の因果推定アルゴリズムを比較

もしこの内容をブログ記事として仕上げたい場合や、もう少しスタイリッシュにしたい場合も気軽に言ってください！

# **user**:

ありがとうございます。次のエラーが出ましたので、解決法を提案してください。 

```
AttributeError: 'ICALiNGAM' object has no attribute 'get_directed_graph'
Traceback:
File "/Users/ikemen/streamlit-app/venv/lib/python3.10/site-packages/streamlit/runtime/scriptrunner/exec_code.py", line 121, in exec_func_with_error_handling
    result = func()
File "/Users/ikemen/streamlit-app/venv/lib/python3.10/site-packages/streamlit/runtime/scriptrunner/script_runner.py", line 639, in code_to_exec
    _mpa_v1(self._main_script_path)
File "/Users/ikemen/streamlit-app/venv/lib/python3.10/site-packages/streamlit/runtime/scriptrunner/script_runner.py", line 159, in _mpa_v1
    page.run()
File "/Users/ikemen/streamlit-app/venv/lib/python3.10/site-packages/streamlit/navigation/page.py", line 297, in run
    exec(code, module.__dict__)
File "/Users/ikemen/streamlit-app/pages/ica_lingam.py", line 50, in <module>
    for (i, j) in model.get_directed_graph():
```

# **assistant**:

ご報告ありがとうございます！

このエラーは以下の部分が原因です：

```python
for (i, j) in model.get_directed_graph():
```

`ICALiNGAM` には `get_directed_graph()` というメソッドが **存在しない** ため、`AttributeError` が出ています。

---

## ✅ 解決策

`lingam` ライブラリで因果関係のペアを取得したい場合は、以下のように **隣接行列（`adjacency_matrix_`）を使って因果の向き**を確認する必要があります。

### 🔧 修正コード（代替案）：

```python
st.subheader("因果の向き")
adj_matrix = model.adjacency_matrix_
for i in range(len(selected_cols)):
    for j in range(len(selected_cols)):
        if adj_matrix[i, j] != 0:
            st.write(f"👉 {selected_cols[i]} → {selected_cols[j]} (重み: {adj_matrix[i, j]:.3f})")
```

---

### 🧠 解説

- `adjacency_matrix_` は、要素 `[i, j]` に `i → j` の因果効果の重みを示します。
- `0` でなければ因果関係があるとみなして表示します。

---

これでエラーは解消され、推定された因果構造の「向き」が一覧で表示されるはずです！

必要であれば、因果グラフの可視化（例：`networkx` + `matplotlib`）も追加できますので、お気軽にお知らせください！

# **user**:

ありがとうございます。上記のコードをベースとして、以下のコードを参考にしながら、因果グラフの可視化の機能を追加してください。 

```python
import streamlit as st
import pandas as pd
import networkx as nx
from pyvis.network import Network
import tempfile

# タイトル
st.title("ネットワークデータ可視化アプリ")

# ファイルアップロード
uploaded_file = st.file_uploader("CSVまたはExcelファイルをアップロードしてください", type=["csv", "xlsx"])

if uploaded_file:
    # ファイル読み込み
    filename = uploaded_file.name
    if filename.endswith('.csv'):
        df = pd.read_csv(uploaded_file, index_col=0)
    elif filename.endswith('.xlsx'):
        excel = pd.ExcelFile(uploaded_file)
        sheet_name = st.selectbox("シートを選択してください", excel.sheet_names)
        df = pd.read_excel(excel, sheet_name=sheet_name, index_col=0)

    # データプレビュー
    st.write("データプレビュー：")
    st.dataframe(df.head())

    # 正方行列のチェック
    if df.shape[0] != df.shape[1]:
        st.error("正方行列ではありません。正しいデータをアップロードしてください。")
    else:
        # 閾値スライダー
        T = st.slider("閾値T（-T〜+Tの範囲の辺を削除）", 0.0, 1.0, 0.3, 0.01)

        # ネットワーク構築
        G = nx.DiGraph()
        labels = df.columns.tolist()

        for i in range(len(labels)):
            for j in range(len(labels)):
                weight = df.iat[i, j]
                if abs(weight) > T:
                    G.add_edge(labels[i], labels[j], weight=round(weight, 2))

        # PyVis ネットワーク生成
        net = Network(height='600px', width='100%', directed=True)

        # ノード追加
        for node in G.nodes:
            net.add_node(node, label=node)

        # エッジ追加（色分け・太さ調整・ラベル表示）
        for source, target, data in G.edges(data=True):
            weight = data.get('weight', 0)
            color = "blue" if weight > 0 else "red"
            thickness = 1 + abs(weight) * 2  # 太さ控えめに調整

            net.add_edge(
                source,
                target,
                value=thickness,
                label=str(weight),
                title=f"重み: {weight}",
                color=color,
                font={"size": 14, "vadjust": -10}  # ラベル浮かせて見やすく
            )

        # オプションボタン（物理エンジン設定など）
        net.show_buttons(filter_=['physics'])

        # HTMLファイルとして保存＆埋め込み
        with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as tmp_file:
            path = tmp_file.name
            net.save_graph(path)
            with open(path, 'r', encoding='utf-8') as f:
                html_content = f.read()
            st.components.v1.html(html_content, height=700, scrolling=True)

        # 保存案内
        st.markdown("**ノード位置を調整後、右クリックから画像として保存できます。**")
```

# **assistant**:

了解しました！以下は、先ほどのICA-LiNGAMベースの因果構造推定アプリに **PyVis + NetworkX を使った因果グラフの可視化機能** を統合した完全なコードです。

---

## ✅ 統合済み Streamlit アプリコード（因果推定＋可視化）

```python
import streamlit as st
import pandas as pd
from lingam import ICALiNGAM
import networkx as nx
from pyvis.network import Network
import tempfile

st.set_page_config(page_title="ICA-LiNGAM 因果推定アプリ", layout="wide")
st.title("📊 ICA-LiNGAM による因果構造推定 & 可視化アプリ")

uploaded_file = st.file_uploader("CSVまたはExcelファイルをアップロードしてください", type=["csv", "xlsx"])

if uploaded_file:
    file_ext = uploaded_file.name.split(".")[-1].lower()

    if file_ext == "csv":
        df = pd.read_csv(uploaded_file)
    elif file_ext == "xlsx":
        xls = pd.ExcelFile(uploaded_file)
        sheet_name = st.selectbox("シートを選択してください", xls.sheet_names)
        df = pd.read_excel(xls, sheet_name=sheet_name)
    else:
        st.error("対応していないファイル形式です。")
        st.stop()

    st.subheader("データプレビュー")
    st.dataframe(df.head())

    all_columns = df.columns.tolist()
    target_col = st.selectbox("目的変数（従属変数）を選択してください", all_columns)
    feature_cols = st.multiselect("説明変数（独立変数）を選択してください", [col for col in all_columns if col != target_col])

    if st.button("因果構造を推定する"):
        if not feature_cols:
            st.error("少なくとも1つの説明変数を選んでください。")
        else:
            selected_cols = feature_cols + [target_col]
            data = df[selected_cols].dropna()

            model = ICALiNGAM()
            model.fit(data)

            st.success("因果構造の推定が完了しました！")

            st.subheader("因果行列（推定された重み）")
            weight_df = pd.DataFrame(model.adjacency_matrix_, columns=selected_cols, index=selected_cols)
            st.dataframe(weight_df.round(3))

            # 因果の向きのテキスト出力
            st.subheader("因果の向き（非ゼロ成分）")
            adj_matrix = model.adjacency_matrix_
            for i in range(len(selected_cols)):
                for j in range(len(selected_cols)):
                    if adj_matrix[i, j] != 0:
                        st.write(f"👉 {selected_cols[i]} → {selected_cols[j]} (重み: {adj_matrix[i, j]:.3f})")

            # --- 可視化部分 ---
            st.subheader("因果グラフの可視化")

            # 閾値調整
            T = st.slider("閾値T（-T〜+Tの範囲の辺を削除）", 0.0, 1.0, 0.3, 0.01)

            # グラフ構築
            G = nx.DiGraph()
            for i in range(len(selected_cols)):
                for j in range(len(selected_cols)):
                    weight = adj_matrix[i, j]
                    if abs(weight) > T:
                        G.add_edge(selected_cols[i], selected_cols[j], weight=round(weight, 2))

            net = Network(height='600px', width='100%', directed=True)
            for node in G.nodes:
                net.add_node(node, label=node)

            for source, target, data in G.edges(data=True):
                weight = data.get('weight', 0)
                color = "blue" if weight > 0 else "red"
                thickness = 1 + abs(weight) * 2
                net.add_edge(
                    source,
                    target,
                    value=thickness,
                    label=str(weight),
                    title=f"重み: {weight}",
                    color=color,
                    font={"size": 14, "vadjust": -10}
                )

            net.show_buttons(filter_=['physics'])

            with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as tmp_file:
                path = tmp_file.name
                net.save_graph(path)
                with open(path, 'r', encoding='utf-8') as f:
                    html_content = f.read()
                st.components.v1.html(html_content, height=700, scrolling=True)

            st.markdown("**ノード位置を調整後、右クリックから画像として保存できます。**")
```

---

## 🎁 特徴まとめ

- CSV または Excel シートをサポート
- ICA-LiNGAM による因果構造推定
- 推定結果の表形式表示（隣接行列）
- 閾値付きのインタラクティブな因果グラフ可視化（PyVis）
- スライダーでノイズ的な弱い因果を非表示にできる

---

気になる点があればいつでも聞いてください。必要に応じて、保存機能やネットワーク画像の自動エクスポート機能の追加もできますよ！

# **user**:

ありがとうございます。UIの操作性についての質問です。「因果グラフの可視化」の「閾値T（-T〜+Tの範囲の辺を削除）」のスライダー部分を変えようとすると、「因果グラフの可視化」が消え、因果構造推定結果も消え、「因果構造を推定する」をまた最初から始めなければならなくなってしまいます。原因をステップバイステップで考えて、対策案を提示していただけませんか？

# **assistant**:

とても良い質問です！Streamlit アプリでよくある「**ユーザー操作によって状態が失われる問題**」ですね。  
これは特に、**再実行時に変数が初期化される** Streamlit の挙動によって起きます。

---

## 🧠 問題の本質

Streamlit は「**UIが更新されるたびにスクリプト全体を最初から実行する**」という仕組みです。  
そのため、スライダーを動かすと以下の流れになります：

---

### 🔍 ステップバイステップで解説

#### Step 1. 初期状態
- ファイルをアップロード
- ユーザーが説明変数・目的変数を選択
- 「因果構造を推定する」をクリック → `model.fit(data)` 実行

#### Step 2. 推定結果が変数（例：`model`, `adj_matrix`, `selected_cols`など）に保存される

#### Step 3. スライダー（閾値）を動かすと UI 更新が発生
- すると Streamlit が **スクリプト全体を再実行** する
- 再実行時に `model` などの変数は**最初から初期化されている**ので消えてしまう
- 結果、推定も可視化も消え、「ボタン押し直し」が必要になる

---

## ✅ 解決方法：`st.session_state` を使って状態を保持する

`st.session_state` を使えば、スクリプト再実行後も特定の値を**記憶させておく**ことができます。

---

### ✅ 対策コードの概要

```python
# ICA-LiNGAMの実行結果をセッション状態に保存
if st.button("因果構造を推定する"):
    model = ICALiNGAM()
    model.fit(data)
    st.session_state['model'] = model
    st.session_state['selected_cols'] = selected_cols
```

その後の部分は、`st.session_state['model']` を使って描画を行うように変更します。

---

### ✅ フルコードへの組み込み例（部分）

以下のように変更してください：

```python
# ボタンが押されたら推定を実行してセッションに保存
if st.button("因果構造を推定する"):
    if not feature_cols:
        st.error("少なくとも1つの説明変数を選んでください。")
    else:
        selected_cols = feature_cols + [target_col]
        data = df[selected_cols].dropna()

        model = ICALiNGAM()
        model.fit(data)

        # セッションに保存
        st.session_state['model'] = model
        st.session_state['selected_cols'] = selected_cols

# セッションにモデルがあるときだけ以下を実行
if 'model' in st.session_state and 'selected_cols' in st.session_state:
    model = st.session_state['model']
    selected_cols = st.session_state['selected_cols']
    adj_matrix = model.adjacency_matrix_

    st.success("因果構造の推定が完了しました！")

    st.subheader("因果行列（推定された重み）")
    weight_df = pd.DataFrame(adj_matrix, columns=selected_cols, index=selected_cols)
    st.dataframe(weight_df.round(3))

    # 因果向き表示 & 可視化はそのまま
    ...
```

---

## 🔒 注意点

- `st.session_state` に保存できるのは **Pickle 可能なオブジェクト**。Lingamのモデルは大丈夫です。
- 初回ロードやファイル変更時はセッションを初期化した方がいい場合もあります（例：ファイルアップロード時に `st.session_state.clear()` など）

---

## ✅ まとめ

| 問題 | 対策 |
|------|------|
| スライダー操作で再実行 → 推定結果が消える | `st.session_state` に推定結果を保存して状態を保持 |

---

ご希望があれば、上記を **修正済みフルコード**にしてお渡しすることも可能です！やってみましょうか？

# **user**:

はい、修正済みフルコードを書いてください。

# **assistant**:

以下に、**状態保持ができるように修正した Streamlit アプリのフルコード**を記載します。  
`st.session_state` を使って、因果構造推定結果がスライダー操作などで消えないようにしています。

---

## ✅ 修正済みフルコード（ICA-LiNGAM + グラフ可視化）

```python
import streamlit as st
import pandas as pd
import networkx as nx
from pyvis.network import Network
import tempfile
from lingam import ICALiNGAM

st.set_page_config(page_title="ICA-LiNGAM 因果構造推定", layout="wide")
st.title("ICA-LiNGAMによる因果構造推定アプリ")

# ファイルアップロード
uploaded_file = st.file_uploader("CSVまたはExcelファイルをアップロードしてください", type=["csv", "xlsx"])

if uploaded_file:
    filename = uploaded_file.name
    if filename.endswith('.csv'):
        df = pd.read_csv(uploaded_file)
    elif filename.endswith('.xlsx'):
        excel = pd.ExcelFile(uploaded_file)
        sheet_name = st.selectbox("シートを選択してください", excel.sheet_names)
        df = pd.read_excel(excel, sheet_name=sheet_name)

    st.subheader("データプレビュー")
    st.dataframe(df.head())

    st.subheader("目的変数と説明変数の選択")
    all_columns = df.columns.tolist()
    target_col = st.selectbox("目的変数（1つ）", all_columns)
    feature_cols = st.multiselect("説明変数（1つ以上）", [col for col in all_columns if col != target_col])

    if st.button("因果構造を推定する"):
        if not feature_cols:
            st.error("少なくとも1つの説明変数を選んでください。")
        else:
            selected_cols = feature_cols + [target_col]
            data = df[selected_cols].dropna()

            model = ICALiNGAM()
            model.fit(data)

            # セッションに保存
            st.session_state['model'] = model
            st.session_state['selected_cols'] = selected_cols
            st.session_state['data'] = data

# 以下の表示はセッションに保存されたモデルがある場合のみ
if 'model' in st.session_state and 'selected_cols' in st.session_state:
    model = st.session_state['model']
    selected_cols = st.session_state['selected_cols']
    data = st.session_state['data']
    adj_matrix = model.adjacency_matrix_

    st.success("因果構造の推定が完了しました！")

    st.subheader("因果行列（推定された重み）")
    weight_df = pd.DataFrame(adj_matrix, columns=selected_cols, index=selected_cols)
    st.dataframe(weight_df.round(3))

    st.subheader("因果関係の一覧（向きと重み）")
    for i in range(len(selected_cols)):
        for j in range(len(selected_cols)):
            weight = adj_matrix[i, j]
            if abs(weight) > 1e-6:
                st.write(f"{selected_cols[i]} → {selected_cols[j]}（重み: {weight:.3f}）")

    # 可視化：スライダーで閾値調整可能
    st.subheader("因果グラフの可視化")
    T = st.slider("閾値T（-T〜+Tの範囲の辺を削除）", 0.0, 1.0, 0.3, 0.01)

    G = nx.DiGraph()
    for i in range(len(selected_cols)):
        for j in range(len(selected_cols)):
            weight = adj_matrix[i, j]
            if abs(weight) > T:
                G.add_edge(selected_cols[i], selected_cols[j], weight=round(weight, 2))

    net = Network(height='600px', width='100%', directed=True)

    for node in G.nodes:
        net.add_node(node, label=node)

    for source, target, data in G.edges(data=True):
        weight = data.get('weight', 0)
        color = "blue" if weight > 0 else "red"
        thickness = 1 + abs(weight) * 2

        net.add_edge(
            source,
            target,
            value=thickness,
            label=str(weight),
            title=f"重み: {weight}",
            color=color,
            font={"size": 14, "vadjust": -10}
        )

    net.show_buttons(filter_=['physics'])

    with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as tmp_file:
        path = tmp_file.name
        net.save_graph(path)
        with open(path, 'r', encoding='utf-8') as f:
            html_content = f.read()
        st.components.v1.html(html_content, height=700, scrolling=True)

    st.markdown("**ノード位置を調整後、右クリックから画像として保存できます。**")
```

---

## 🛠 ポイントまとめ

| 技術 | 内容 |
|------|------|
| `st.session_state` | ICA-LiNGAMモデルや選択列などの状態を保持 |
| スライダー | グラフの閾値調整に使い、状態を失わずに再描画 |
| PyVis + NetworkX | 因果グラフの可視化 |
| `tempfile` + HTML埋め込み | 動的グラフを Streamlit 上に表示 |

---

「初回推定後のUI操作で結果が消えない」よう、かなり実用的な形になっています！  
必要であれば、グラフのPNG保存機能、PDF出力、説明文の追加などもできますよ。

他にも改善したい点があれば、遠慮なく教えてください！

# **user**:

ありがとうございます。目的変数だけ色を変えたいのですが、できますか？

# **assistant**:

もちろんできます！目的変数だけ色を変えるには、**PyVis の `add_node` メソッドでノードごとに色を指定**してあげればOKです。以下のように、ノード追加部分を修正すれば、目的変数だけ目立つ色（たとえばオレンジ）に変更できます。

---

## ✅ ノード追加部分の修正コード

```python
for node in G.nodes:
    if node == target_col:
        net.add_node(node, label=node, color="orange")  # 目的変数だけ色指定
    else:
        net.add_node(node, label=node, color="lightblue")
```

---

## 🔁 フルコードに組み込んだ部分（該当箇所）

以下の部分をフルコードに挿入してください：

```python
# ノード追加（目的変数は色を変える）
for node in G.nodes:
    if node == target_col:
        net.add_node(node, label=node, color="orange")  # 目的変数だけ色変更
    else:
        net.add_node(node, label=node, color="lightblue")
```

---

## 🎨 補足：他の色の候補

| 色名 | 色味 |
|------|------|
| `"red"` | 赤 |
| `"green"` | 緑 |
| `"orange"` | オレンジ |
| `"lightblue"` | 明るい青（デフォルト的に見やすい） |
| `"yellow"` | 黄色（明るくて目立つ） |
| `"pink"` | ピンク |
| `"#hexcode"` | 任意の16進カラーコードもOK（例：`"#FF69B4"`） |

---

これで、目的変数が視覚的に際立つようになります！  
もし他にも見やすさの工夫（ノードサイズ変更やツールチップ追加など）したい部分があれば、気軽にどうぞ！

# **user**:

ありがとうございます。ICA_LiNGAMにおいて、ユーザが調節できるパラメータがあればインタラクティブに調節できるようにしたいです。コードを改変して全コードを書いていただけますか？

# **assistant**:

もちろんです！`ICA-LiNGAM` モデルの主なパラメータには以下のようなものがあります（`lingam`ライブラリのバージョンにもよりますが）：

---

## 🔧 ICA-LiNGAM の主なパラメータ

| パラメータ名 | 説明 | デフォルト値 |
|--------------|------|--------------|
| `max_iter`   | 独立成分分析（ICA）の最大イテレーション回数 | 1000 |
| `random_state` | 乱数シード（再現性のため）| None |
| `prune` | 小さな重みをゼロにする枝刈り機能（True/False）| False |

---

以下のフルコードでは、これらを Streamlit の UI から調節できるように追加しています。  

---

## ✅ フルコード（ICA-LiNGAMパラメータ調節機能付き）

```python
import streamlit as st
import pandas as pd
import networkx as nx
from pyvis.network import Network
import tempfile
from lingam import ICALiNGAM

st.set_page_config(page_title="ICA-LiNGAM 因果構造推定", layout="wide")
st.title("ICA-LiNGAMによる因果構造推定アプリ")

# ファイルアップロード
uploaded_file = st.file_uploader("CSVまたはExcelファイルをアップロードしてください", type=["csv", "xlsx"])

if uploaded_file:
    filename = uploaded_file.name
    if filename.endswith('.csv'):
        df = pd.read_csv(uploaded_file)
    elif filename.endswith('.xlsx'):
        excel = pd.ExcelFile(uploaded_file)
        sheet_name = st.selectbox("シートを選択してください", excel.sheet_names)
        df = pd.read_excel(excel, sheet_name=sheet_name)

    st.subheader("データプレビュー")
    st.dataframe(df.head())

    st.subheader("目的変数と説明変数の選択")
    all_columns = df.columns.tolist()
    target_col = st.selectbox("目的変数（1つ）", all_columns)
    feature_cols = st.multiselect("説明変数（1つ以上）", [col for col in all_columns if col != target_col])

    st.subheader("ICA-LiNGAM のパラメータ調整")
    max_iter = st.number_input("最大イテレーション数（max_iter）", min_value=100, max_value=10000, value=1000, step=100)
    prune = st.checkbox("小さな重みを自動でゼロにする（prune）", value=False)
    random_state = st.number_input("ランダムシード（random_state）", value=0, step=1)

    if st.button("因果構造を推定する"):
        if not feature_cols:
            st.error("少なくとも1つの説明変数を選んでください。")
        else:
            selected_cols = feature_cols + [target_col]
            data = df[selected_cols].dropna()

            model = ICALiNGAM(max_iter=max_iter, prune=prune, random_state=random_state)
            model.fit(data)

            st.session_state['model'] = model
            st.session_state['selected_cols'] = selected_cols
            st.session_state['data'] = data
            st.session_state['target_col'] = target_col

if 'model' in st.session_state and 'selected_cols' in st.session_state:
    model = st.session_state['model']
    selected_cols = st.session_state['selected_cols']
    data = st.session_state['data']
    target_col = st.session_state['target_col']
    adj_matrix = model.adjacency_matrix_

    st.success("因果構造の推定が完了しました！")

    st.subheader("因果行列（推定された重み）")
    weight_df = pd.DataFrame(adj_matrix, columns=selected_cols, index=selected_cols)
    st.dataframe(weight_df.round(3))

    st.subheader("因果関係の一覧（向きと重み）")
    for i in range(len(selected_cols)):
        for j in range(len(selected_cols)):
            weight = adj_matrix[i, j]
            if abs(weight) > 1e-6:
                st.write(f"{selected_cols[i]} → {selected_cols[j]}（重み: {weight:.3f}）")

    st.subheader("因果グラフの可視化")
    T = st.slider("閾値T（-T〜+Tの範囲の辺を削除）", 0.0, 1.0, 0.3, 0.01)

    G = nx.DiGraph()
    for i in range(len(selected_cols)):
        for j in range(len(selected_cols)):
            weight = adj_matrix[i, j]
            if abs(weight) > T:
                G.add_edge(selected_cols[i], selected_cols[j], weight=round(weight, 2))

    net = Network(height='600px', width='100%', directed=True)

    for node in G.nodes:
        if node == target_col:
            net.add_node(node, label=node, color="orange")  # 目的変数だけ色変更
        else:
            net.add_node(node, label=node, color="lightblue")

    for source, target, data in G.edges(data=True):
        weight = data.get('weight', 0)
        color = "blue" if weight > 0 else "red"
        thickness = 1 + abs(weight) * 2

        net.add_edge(
            source,
            target,
            value=thickness,
            label=str(weight),
            title=f"重み: {weight}",
            color=color,
            font={"size": 14, "vadjust": -10}
        )

    net.show_buttons(filter_=['physics'])

    with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as tmp_file:
        path = tmp_file.name
        net.save_graph(path)
        with open(path, 'r', encoding='utf-8') as f:
            html_content = f.read()
        st.components.v1.html(html_content, height=700, scrolling=True)

    st.markdown("**ノード位置を調整後、右クリックから画像として保存できます。**")
```

---

## ✅ 追加されたUI項目

- `max_iter`: 100 〜 10000 の範囲でスライダー調整可能
- `prune`: 小さな重みをカットする枝刈り機能
- `random_state`: シードを指定して再現性確保

---

### もし他のパラメータも調整したい、あるいは ICA ではなく他の因果推論モデルにも対応させたいなどあれば、お気軽にどうぞ！

# **user**:

次のエラーが出ました。 prune の機能は付けなくて良いかもしれませんね。 

```
TypeError: ICALiNGAM.__init__() got an unexpected keyword argument 'prune'
Traceback:
File "/Users/ikemen/streamlit-app/venv/lib/python3.10/site-packages/streamlit/runtime/scriptrunner/exec_code.py", line 121, in exec_func_with_error_handling
    result = func()
File "/Users/ikemen/streamlit-app/venv/lib/python3.10/site-packages/streamlit/runtime/scriptrunner/script_runner.py", line 639, in code_to_exec
    _mpa_v1(self._main_script_path)
File "/Users/ikemen/streamlit-app/venv/lib/python3.10/site-packages/streamlit/runtime/scriptrunner/script_runner.py", line 159, in _mpa_v1
    page.run()
File "/Users/ikemen/streamlit-app/venv/lib/python3.10/site-packages/streamlit/navigation/page.py", line 297, in run
    exec(code, module.__dict__)
File "/Users/ikemen/streamlit-app/pages/ica_lingam.py", line 43, in <module>
    model = ICALiNGAM(max_iter=max_iter, prune=prune, random_state=random_state)
Ask
```

# **assistant**:

ありがとうございます！  
エラー内容を見ると、`ICALiNGAM` クラスのコンストラクタに `prune` パラメータが存在しないため、`TypeError` が発生しています。

---

## ✅ ステップバイステップでの原因分析

1. **`ICALiNGAM` クラスの定義を確認**
   - `lingam` ライブラリのバージョンによって `prune` オプションがあるかどうか異なる。
   - `prune` は `fit()` メソッドではなく、`DirectLiNGAM` クラスにしか存在しない可能性がある。

2. **今回のエラーは `__init__()` に `prune` を渡しているため発生**
   - `ICALiNGAM` クラスの `__init__()` には `prune` を受け取る引数がない。

3. **結論**: `prune` パラメータは削除する必要がある。

---

## ✅ 修正版のフルコード（`prune` 削除済み）

```python
import streamlit as st
import pandas as pd
import networkx as nx
from pyvis.network import Network
import tempfile
from lingam import ICALiNGAM

st.set_page_config(page_title="ICA-LiNGAM 因果構造推定", layout="wide")
st.title("ICA-LiNGAMによる因果構造推定アプリ")

# ファイルアップロード
uploaded_file = st.file_uploader("CSVまたはExcelファイルをアップロードしてください", type=["csv", "xlsx"])

if uploaded_file:
    filename = uploaded_file.name
    if filename.endswith('.csv'):
        df = pd.read_csv(uploaded_file)
    elif filename.endswith('.xlsx'):
        excel = pd.ExcelFile(uploaded_file)
        sheet_name = st.selectbox("シートを選択してください", excel.sheet_names)
        df = pd.read_excel(excel, sheet_name=sheet_name)

    st.subheader("データプレビュー")
    st.dataframe(df.head())

    st.subheader("目的変数と説明変数の選択")
    all_columns = df.columns.tolist()
    target_col = st.selectbox("目的変数（1つ）", all_columns)
    feature_cols = st.multiselect("説明変数（1つ以上）", [col for col in all_columns if col != target_col])

    st.subheader("ICA-LiNGAM のパラメータ調整")
    max_iter = st.number_input("最大イテレーション数（max_iter）", min_value=100, max_value=10000, value=1000, step=100)
    random_state = st.number_input("ランダムシード（random_state）", value=0, step=1)

    if st.button("因果構造を推定する"):
        if not feature_cols:
            st.error("少なくとも1つの説明変数を選んでください。")
        else:
            selected_cols = feature_cols + [target_col]
            data = df[selected_cols].dropna()

            model = ICALiNGAM(max_iter=max_iter, random_state=random_state)
            model.fit(data)

            st.session_state['model'] = model
            st.session_state['selected_cols'] = selected_cols
            st.session_state['data'] = data
            st.session_state['target_col'] = target_col

if 'model' in st.session_state and 'selected_cols' in st.session_state:
    model = st.session_state['model']
    selected_cols = st.session_state['selected_cols']
    data = st.session_state['data']
    target_col = st.session_state['target_col']
    adj_matrix = model.adjacency_matrix_

    st.success("因果構造の推定が完了しました！")

    st.subheader("因果行列（推定された重み）")
    weight_df = pd.DataFrame(adj_matrix, columns=selected_cols, index=selected_cols)
    st.dataframe(weight_df.round(3))

    st.subheader("因果関係の一覧（向きと重み）")
    for i in range(len(selected_cols)):
        for j in range(len(selected_cols)):
            weight = adj_matrix[i, j]
            if abs(weight) > 1e-6:
                st.write(f"{selected_cols[i]} → {selected_cols[j]}（重み: {weight:.3f}）")

    st.subheader("因果グラフの可視化")
    T = st.slider("閾値T（-T〜+Tの範囲の辺を削除）", 0.0, 1.0, 0.3, 0.01)

    G = nx.DiGraph()
    for i in range(len(selected_cols)):
        for j in range(len(selected_cols)):
            weight = adj_matrix[i, j]
            if abs(weight) > T:
                G.add_edge(selected_cols[i], selected_cols[j], weight=round(weight, 2))

    net = Network(height='600px', width='100%', directed=True)

    for node in G.nodes:
        if node == target_col:
            net.add_node(node, label=node, color="orange")  # 目的変数だけ色変更
        else:
            net.add_node(node, label=node, color="lightblue")

    for source, target, data in G.edges(data=True):
        weight = data.get('weight', 0)
        color = "blue" if weight > 0 else "red"
        thickness = 1 + abs(weight) * 2

        net.add_edge(
            source,
            target,
            value=thickness,
            label=str(weight),
            title=f"重み: {weight}",
            color=color,
            font={"size": 14, "vadjust": -10}
        )

    net.show_buttons(filter_=['physics'])

    with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as tmp_file:
        path = tmp_file.name
        net.save_graph(path)
        with open(path, 'r', encoding='utf-8') as f:
            html_content = f.read()
        st.components.v1.html(html_content, height=700, scrolling=True)

    st.markdown("**ノード位置を調整後、右クリックから画像として保存できます。**")
```

---

この修正により、エラーは解消され、`max_iter` と `random_state` を調節できるシンプルで安定した構成になります。  
他にも追加したいパラメータや可視化の改善などありましたら、いつでもどうぞ！

# **user**:

ありがとうございます。ICA_LiNGAMのアルゴリズムに関する質問です。今回、目的変数と説明変数に分けてインプットしましたが、出力された因果グラフは、説明変数から目的変数に向けて伸びる矢印だけでなく、目的変数から説明変数に伸びる矢印や、説明変数から別の説明変数へ伸びる矢印などが含まれていました。なぜですか？ 目的変数と説明変数に分ける意味はあったのでしょうか？

# **assistant**:

とても本質的で良い質問です！  
ICA-LiNGAMのアルゴリズムと「目的変数・説明変数」の区別について、丁寧に説明していきますね。

---

## 🧠 ICA-LiNGAMの本質的な特徴

ICA-LiNGAM（Independent Component Analysis–Linear Non-Gaussian Acyclic Model）は、以下の前提を持った **探索的因果推論アルゴリズム** です：

1. **すべての変数を同列（対等）に扱う**
   - 説明変数と目的変数といった区別を前提とせず、「観測された全ての変数の間の因果構造」を推定します。
2. **線形・非ガウス性・非巡回性（DAG構造）を仮定**
   - 各変数は線形結合で表され、誤差項が独立かつ非ガウス分布に従うと仮定。
3. **全体の構造をデータから学習**
   - あくまで **統計的独立性** に基づき、「どの変数が他の変数に因果的影響を与えているか」を探索的に導きます。

---

## 🤔 なぜ「目的変数→説明変数」の矢印が出るの？

これはICA-LiNGAMが、**ユーザーが指定した「目的・説明変数の区別」を考慮していないから** です。

たとえば、`Y` を目的変数、`X1, X2` を説明変数として `Y ~ X1 + X2` を想定していたとしても、ICA-LiNGAMは以下のような構造を推定する可能性があります：

- `X1 → Y`（これは直感通り）
- `Y → X2`（これは想定と逆方向）
- `X1 → X2`（説明変数間の因果関係）

これらの推定はすべて、**データの共分散構造と非ガウス性から統計的に得られた最尤の因果構造**であり、ラベル（目的・説明）の情報は使われていません。

---

## 🎯 「目的変数・説明変数に分ける意味」はあったのか？

### ✅ **意味はありました**
- アプリのユーザー体験として、「**Yを目的にして、Xたちが説明変数だと想定しています**」という **文脈** をユーザー自身が明確にできる。
- 可視化時に「目的変数をオレンジ色にする」などで、文脈の補助ができる。

### ❌ **因果推定のアルゴリズム的には意味はない**
- ICA-LiNGAM自身はその区別をまったく使っていないので、「因果構造推定の計算」においては **完全に無視されます**。
- 入力変数の順序にも意味はなく、すべての変数のあらゆる組み合わせの因果関係を自動で推定します。

---

## ✅ まとめ

| 観点 | 説明 |
|------|------|
| ICA-LiNGAMの性質 | 入力されたすべての変数の因果関係を、探索的に推定する（目的・説明の区別はしない） |
| ユーザーが目的変数を指定する意義 | 可視化や文脈の補助には役立つが、推定結果には影響しない |
| 説明変数から目的変数への矢印だけでなく、逆や相互の矢印も出る理由 | 統計的に最も妥当とされる因果構造を、完全に自動で学習しているから |

---

## ✨補足：もし目的変数中心の推論がしたいなら？
もし、「Yに対して、どの変数が因果的影響を与えているか **だけ** を知りたい」場合は、以下のような方法が適しています：

- `DirectLiNGAM` で `target` を明示的に制限する
- `DoWhy` や `CausalInference` ライブラリを使って **事前に変数の役割を決めたうえで介入推定** する
- あるいは、回帰 + シャッフルテストなどの手法で、Yへの影響に特化した解析を行う

---

他にも気になることがあれば何でも聞いてくださいね！  
たとえば「特定の変数に注目して因果グラフを見たい」「目的変数への因果パスだけを強調したい」などの可視化拡張もできます。

# **user**:

ありがとうございます。ICA_LiNGAMのアルゴリズムに関して、分かりました。それでは、これまでのコードをベースに、次の改変を加えた全コードを書いてください。

・説明変数だけでなく、目的変数も、複数選択可能にする。
・因果グラフの可視化オプションとして、目的変数と、目的変数から矢印を逆向きに探索したときに到達可能な矢印・説明変数のみを表示する機能をつける。

# **assistant**:

了解しました！以下は、これまでのStreamlitアプリをベースに、以下の2点を追加した **完全なコード** です：

---

### ✅ 改変点
1. **目的変数も複数選択可能**に変更
2. **因果グラフの可視化で「目的変数とその祖先ノード」だけを表示**するオプションを追加

---

### 💻 Streamlitコード全体

```python
import streamlit as st
import pandas as pd
import networkx as nx
from pyvis.network import Network
import tempfile
from lingam import ICALiNGAM

# タイトル
st.title("ICA-LiNGAMによる因果構造推定アプリ")

# ファイルアップロード
uploaded_file = st.file_uploader("CSVまたはExcelファイルをアップロードしてください", type=["csv", "xlsx"])

if uploaded_file:
    # ファイル読み込み
    filename = uploaded_file.name
    if filename.endswith('.csv'):
        df = pd.read_csv(uploaded_file)
    elif filename.endswith('.xlsx'):
        excel = pd.ExcelFile(uploaded_file)
        sheet_name = st.selectbox("シートを選択してください", excel.sheet_names)
        df = pd.read_excel(excel, sheet_name=sheet_name)

    st.write("データプレビュー：")
    st.dataframe(df.head())

    columns = df.columns.tolist()
    target_cols = st.multiselect("目的変数を選択してください（複数可）", columns)
    input_cols = st.multiselect("説明変数を選択してください（複数可）", columns)

    if set(target_cols + input_cols).issubset(columns) and len(target_cols + input_cols) >= 2:
        use_cols = list(set(target_cols + input_cols))
        X = df[use_cols].dropna()

        with st.expander("ICA-LiNGAMのパラメータ調整"):
            max_iter = st.slider("最大繰り返し数（max_iter）", min_value=100, max_value=5000, value=1000, step=100)
            random_state = st.number_input("乱数シード（random_state）", min_value=0, value=0, step=1)

        if st.button("因果構造を推定する"):
            model = ICALiNGAM(max_iter=max_iter, random_state=random_state)
            model.fit(X)

            adjacency_matrix = model.adjacency_matrix_
            st.write("推定された因果構造（重み行列）：")
            st.dataframe(pd.DataFrame(adjacency_matrix, index=use_cols, columns=use_cols))

            st.subheader("因果グラフの可視化")

            # 可視化オプション
            view_mode = st.radio(
                "可視化モードを選択してください",
                ["全体表示", "目的変数とその祖先ノードのみ"]
            )

            T = st.slider("表示する因果強度の閾値T（|重み| > T のみ表示）", 0.0, 1.0, 0.1, 0.01)

            # グラフ構築
            G = nx.DiGraph()
            for i, source in enumerate(use_cols):
                for j, target in enumerate(use_cols):
                    weight = adjacency_matrix[j, i]
                    if abs(weight) > T:
                        G.add_edge(source, target, weight=round(weight, 2))

            # フィルタ処理：目的変数 + 祖先ノードのみ表示
            if view_mode == "目的変数とその祖先ノードのみ":
                sub_nodes = set(target_cols)
                for target in target_cols:
                    for node in nx.ancestors(G, target):
                        sub_nodes.add(node)
                G = G.subgraph(sub_nodes).copy()

            # PyVisネットワーク生成
            net = Network(height='600px', width='100%', directed=True)
            for node in G.nodes:
                color = "orange" if node in target_cols else "#97C2FC"
                net.add_node(node, label=node, color=color)

            for source, target, data in G.edges(data=True):
                weight = data.get("weight", 0)
                color = "blue" if weight > 0 else "red"
                thickness = 1 + abs(weight) * 2

                net.add_edge(
                    source,
                    target,
                    value=thickness,
                    label=str(weight),
                    title=f"重み: {weight}",
                    color=color,
                    font={"size": 14, "vadjust": -10}
                )

            net.show_buttons(filter_=["physics"])
            with tempfile.NamedTemporaryFile(delete=False, suffix=".html") as tmp_file:
                path = tmp_file.name
                net.save_graph(path)
                with open(path, "r", encoding="utf-8") as f:
                    html_content = f.read()
                st.components.v1.html(html_content, height=700, scrolling=True)

            st.markdown("**ノード位置を調整後、右クリックから画像として保存できます。**")
    else:
        st.warning("目的変数・説明変数を最低2列以上選択してください。")
```

---

### 🔍 使い方まとめ

- **目的変数と説明変数は複数選択可能**です。
- 「因果グラフの可視化」で「目的変数とその祖先ノードのみ」オプションを選ぶと、  
  → **目的変数から矢印を逆方向にたどって到達できるノードとエッジのみを表示**します。
- 閾値スライダーで弱い因果関係を除外できます。
- 色分けで目的変数が強調表示されます（オレンジ）。

---

もしさらに、「目的変数に到達する**全パス**を強調表示したい」などの拡張もできますよ！お気軽にどうぞ。

# **user**:

ありがとうございます。UIの操作性についての質問です。「因果グラフの可視化」の「閾値T（-T〜+Tの範囲の辺を削除）」のスライダー部分を変えようとすると、「因果グラフの可視化」が消え、因果構造推定結果も消え、「因果構造を推定する」をまた最初から始めなければならなくなってしまいます。原因をステップバイステップで考えて、対策案を提示していただけませんか？

# **assistant**:

とても良いご質問です。「スライダーを動かすと、因果グラフが消えて再度ボタンを押す必要がある」という問題は、**Streamlitにおける状態管理の仕組み**が原因です。以下、ステップバイステップで原因と解決策を説明します。

---

## 🔍 **問題の原因をステップバイステップで分析**

### ✅ Step 1: Streamlitの基本挙動
Streamlitは**ページ全体を毎回再実行する**構造になっています。  
つまり、**スライダーを1mmでも動かした瞬間に再実行**が走ります。

---

### ✅ Step 2: `if st.button(...)` の罠
```python
if st.button("因果構造を推定する"):
    model.fit(...)
    st.session_state["result"] = ...  ← 保存していないとここで終わり
```

- ボタンが押されたタイミングで `model.fit(...)` を実行しますが、
- スライダーなどの操作をすると **`st.button(...) == False`** になり、
- 再実行時に**再度推定が走らない** → 推定結果が消える。

---

### ✅ Step 3: 状態（ステート）を保存していない
Streamlitは**明示的に保存しないと変数を記憶しない**ため、  
推定した`model`や`adjacency_matrix`を**`st.session_state`に保存**しないと消えます。

---

## 🛠️ **対策案：`st.session_state` で状態を管理する**

以下のステップで改善できます：

---

### ✅ Step 1: 推定結果を `st.session_state` に保存

```python
if st.button("因果構造を推定する"):
    model = ICALiNGAM(...)
    model.fit(X)
    st.session_state["adjacency_matrix"] = model.adjacency_matrix_
    st.session_state["columns"] = use_cols
    st.session_state["target_cols"] = target_cols
```

---

### ✅ Step 2: 可視化部分では `session_state` の内容を使う

```python
if "adjacency_matrix" in st.session_state:
    adjacency_matrix = st.session_state["adjacency_matrix"]
    use_cols = st.session_state["columns"]
    target_cols = st.session_state["target_cols"]
    # スライダーはここで自由に使ってOK
```

---

### ✅ Step 3: 初期化オプションも加えるとより親切

```python
if st.button("リセット"):
    for key in ["adjacency_matrix", "columns", "target_cols"]:
        if key in st.session_state:
            del st.session_state[key]
```

---

## ✨ 最終的な効果

- 一度「因果構造を推定する」ボタンを押せば、
- **スライダーや可視化モードを変えても結果が保持される**。
- 推定を再実行せずにグラフだけ切り替えられる。

---

## 🔧 まとめ

| 問題 | 原因 | 解決策 |
|------|------|--------|
| スライダー変更で推定結果が消える | Streamlitは再実行時に変数を保持しない | `st.session_state` に結果を保存する |
| 毎回ボタンを押さないと結果が出ない | `st.button(...)` は1回限りのトリガー | 結果を保存して再利用する |

---

必要であれば、これを反映した **修正済みフルコード** もすぐ書きます！どうしますか？

# **user**:

はい、修正済みフルコードを書いてください。

# **assistant**:

以下は、推定結果を`st.session_state`に保存し、再実行なしでスライダー操作や可視化の変更ができるようにした修正済みの全コードです。

```python
import streamlit as st
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from lingam import ICALiNGAM
import networkx as nx
from pyvis.network import Network
import tempfile

# タイトル
st.title("因果構造推定と可視化")

# ファイルアップロード
uploaded_file = st.file_uploader("CSVまたはExcelファイルをアップロードしてください", type=["csv", "xlsx"])

# ファイル読み込み処理
if uploaded_file:
    # ファイルの種類に応じて処理
    filename = uploaded_file.name
    if filename.endswith('.csv'):
        df = pd.read_csv(uploaded_file)
    elif filename.endswith('.xlsx'):
        excel = pd.ExcelFile(uploaded_file)
        sheet_name = st.selectbox("シートを選択してください", excel.sheet_names)
        df = pd.read_excel(excel, sheet_name=sheet_name)

    # データプレビュー
    st.write("データプレビュー：")
    st.dataframe(df.head())

    # 目的変数と説明変数の選択
    target_cols = st.multiselect("目的変数を選択", df.columns)
    use_cols = st.multiselect("説明変数を選択", df.columns)

    # ユーザが選択した列を使ってデータを準備
    if target_cols and use_cols:
        X = df[use_cols + target_cols].values
        X = StandardScaler().fit_transform(X)

        # 因果構造推定を行うボタン
        if st.button("因果構造を推定する"):
            # ICA_LiNGAMを用いた因果推定
            model = ICALiNGAM()
            model.fit(X)
            st.session_state["adjacency_matrix"] = model.adjacency_matrix_
            st.session_state["columns"] = use_cols + target_cols

            # 結果の表示
            st.write("推定された因果構造：")
            st.write(model.adjacency_matrix_)

    # 因果グラフの可視化
    if "adjacency_matrix" in st.session_state:
        adjacency_matrix = st.session_state["adjacency_matrix"]
        columns = st.session_state["columns"]

        # 閾値スライダー
        T = st.slider("閾値T（-T〜+Tの範囲の辺を削除）", 0.0, 1.0, 0.3, 0.01)

        # グラフの作成
        G = nx.DiGraph()
        labels = columns

        # グラフのノードとエッジを追加
        for i in range(len(labels)):
            for j in range(len(labels)):
                weight = adjacency_matrix[i, j]
                if abs(weight) > T:
                    G.add_edge(labels[i], labels[j], weight=round(weight, 2))

        # PyVisネットワーク生成
        net = Network(height='600px', width='100%', directed=True)

        # ノード追加
        for node in G.nodes:
            net.add_node(node, label=node)

        # エッジ追加（色分け・太さ調整）
        for source, target, data in G.edges(data=True):
            weight = data.get('weight', 0)
            color = "blue" if weight > 0 else "red"
            thickness = 1 + abs(weight) * 2  # 太さ控えめに調整
            net.add_edge(
                source,
                target,
                value=thickness,
                label=str(weight),
                title=f"重み: {weight}",
                color=color,
                font={"size": 14, "vadjust": -10}  # ラベル浮かせて見やすく
            )

        # オプションボタン（物理エンジン設定など）
        net.show_buttons(filter_=['physics'])

        # HTMLファイルとして保存＆埋め込み
        with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as tmp_file:
            path = tmp_file.name
            net.save_graph(path)
            with open(path, 'r', encoding='utf-8') as f:
                html_content = f.read()
            st.components.v1.html(html_content, height=700, scrolling=True)

        # 目的変数から逆方向の因果関係を表示するオプション
        reverse_edges = st.checkbox("目的変数から逆方向に因果関係を表示する")
        if reverse_edges:
            reverse_G = nx.DiGraph()
            for i in range(len(labels)):
                for j in range(len(labels)):
                    weight = adjacency_matrix[i, j]
                    if abs(weight) > T:
                        reverse_G.add_edge(labels[j], labels[i], weight=round(weight, 2))

            # PyVisネットワークで逆方向を表示
            reverse_net = Network(height='600px', width='100%', directed=True)

            # ノード追加
            for node in reverse_G.nodes:
                reverse_net.add_node(node, label=node)

            # エッジ追加（色分け・太さ調整）
            for source, target, data in reverse_G.edges(data=True):
                weight = data.get('weight', 0)
                color = "blue" if weight > 0 else "red"
                thickness = 1 + abs(weight) * 2  # 太さ控えめに調整
                reverse_net.add_edge(
                    source,
                    target,
                    value=thickness,
                    label=str(weight),
                    title=f"重み: {weight}",
                    color=color,
                    font={"size": 14, "vadjust": -10}  # ラベル浮かせて見やすく
                )

            # 逆方向グラフ表示
            with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as tmp_file:
                path = tmp_file.name
                reverse_net.save_graph(path)
                with open(path, 'r', encoding='utf-8') as f:
                    html_content = f.read()
                st.components.v1.html(html_content, height=700, scrolling=True)

        # 保存案内
        st.markdown("**ノード位置を調整後、右クリックから画像として保存できます。**")
```

### 変更点:
1. **目的変数と説明変数を複数選択可能に**：
    - `st.multiselect`を使用して、目的変数と説明変数を複数選択できるようにしました。
2. **因果グラフの可視化オプション**：
    - スライダーの値でエッジの閾値を調整し、`st.checkbox`を使って**目的変数から逆方向に因果関係を表示**するオプションを追加しました。
3. **`st.session_state`に結果を保存**：
    - 推定した結果（因果構造）は`st.session_state`に保存し、再実行なしでスライダー操作ができるようにしました。

これで、因果構造の推定後、スライダーで閾値を調整し、選択したオプションに基づいて因果グラフの表示を更新することができます。

# **user**:

ありがとうございます。ご提案いただいたコードを少し改変して、現状、次のコードになっています。"目的変数とその祖先ノードのみ" というのを改めて、"目的変数に到達可能な全てのパス” を表示するようにコードを修正してください。

```python
import streamlit as st
import pandas as pd
import networkx as nx
from pyvis.network import Network
import tempfile
from lingam import ICALiNGAM

st.set_page_config(page_title="ICA-LiNGAM 因果構造推定", layout="wide")
st.title("ICA-LiNGAMによる因果構造推定アプリ")

# ファイルアップロード
uploaded_file = st.file_uploader(
    "CSVまたはExcelファイルをアップロードしてください", type=["csv", "xlsx"]
)

if uploaded_file:
    filename = uploaded_file.name
    if filename.endswith(".csv"):
        df = pd.read_csv(uploaded_file)
    elif filename.endswith(".xlsx"):
        excel = pd.ExcelFile(uploaded_file)
        sheet_name = st.selectbox("シートを選択してください", excel.sheet_names)
        df = pd.read_excel(excel, sheet_name=sheet_name)

    st.subheader("データプレビュー")
    st.dataframe(df.head())

    st.subheader("目的変数と説明変数の選択")
    all_columns = df.columns.tolist()
    target_cols = st.multiselect("目的変数を選択してください（複数可）", all_columns)
    feature_cols = st.multiselect(
        "説明変数（1つ以上）", [col for col in all_columns if col not in target_cols]
    )

    with st.expander("ICA-LiNGAMのパラメータ調整"):
        max_iter = st.slider(
            "最大繰り返し数（max_iter）",
            min_value=100,
            max_value=5000,
            value=1000,
            step=100,
        )
        random_state = st.number_input(
            "乱数シード（random_state）", min_value=0, value=0, step=1
        )

    if st.button("因果構造を推定する"):
        if not feature_cols:
            st.error("少なくとも1つの説明変数を選んでください。")
        else:
            selected_cols = feature_cols + target_cols
            data = df[selected_cols].dropna()

            model = ICALiNGAM(max_iter=max_iter, random_state=random_state)
            model.fit(data)

            st.session_state["model"] = model
            st.session_state["selected_cols"] = selected_cols
            st.session_state["data"] = data
            st.session_state["target_col"] = target_cols

if "model" in st.session_state and "selected_cols" in st.session_state:
    model = st.session_state["model"]
    selected_cols = st.session_state["selected_cols"]
    data = st.session_state["data"]
    target_cols = st.session_state["target_col"]
    adj_matrix = model.adjacency_matrix_

    st.success("因果構造の推定が完了しました！")

    st.subheader("因果行列（推定された重み）")
    weight_df = pd.DataFrame(adj_matrix, columns=selected_cols, index=selected_cols)
    st.dataframe(weight_df.round(3))

    st.subheader("因果関係の一覧（向きと重み）")
    for i in range(len(selected_cols)):
        for j in range(len(selected_cols)):
            weight = adj_matrix[i, j]
            if abs(weight) > 1e-6:
                st.write(
                    f"{selected_cols[i]} → {selected_cols[j]}（重み: {weight:.3f}）"
                )

    st.subheader("因果グラフの可視化")

    # 可視化オプション
    view_mode = st.radio(
        "可視化モードを選択してください", ["全体表示", "目的変数とその祖先ノードのみ"]
    )

    T = st.slider("閾値T（-T〜+Tの範囲の辺を削除）", 0.0, 1.0, 0.3, 0.01)

    G = nx.DiGraph()
    for i in range(len(selected_cols)):
        for j in range(len(selected_cols)):
            weight = adj_matrix[i, j]
            if abs(weight) > T:
                G.add_edge(selected_cols[i], selected_cols[j], weight=round(weight, 2))

    # フィルタ処理：目的変数 + 祖先ノードのみ表示
    if view_mode == "目的変数とその祖先ノードのみ":
        sub_nodes = set(target_cols)
        for target in target_cols:
            for node in nx.ancestors(G, target):
                sub_nodes.add(node)
        G = G.subgraph(sub_nodes).copy()

    net = Network(height="600px", width="100%", directed=True)

    for node in G.nodes:
        if node in target_cols:
            net.add_node(node, label=node, color="orange")  # 目的変数だけ色変更
        else:
            net.add_node(node, label=node, color="lightblue")

    for source, target, data in G.edges(data=True):
        weight = data.get("weight", 0)
        color = "blue" if weight > 0 else "red"
        thickness = 1 + abs(weight) * 2

        net.add_edge(
            source,
            target,
            value=thickness,
            label=str(weight),
            title=f"重み: {weight}",
            color=color,
            font={"size": 14, "vadjust": -10},
        )

    net.show_buttons(filter_=["physics"])

    with tempfile.NamedTemporaryFile(delete=False, suffix=".html") as tmp_file:
        path = tmp_file.name
        net.save_graph(path)
        with open(path, "r", encoding="utf-8") as f:
            html_content = f.read()
        st.components.v1.html(html_content, height=700, scrolling=True)

    st.markdown("**ノード位置を調整後、右クリックから画像として保存できます。**")
```

# **assistant**:

以下のコードは、「目的変数に到達可能な全てのパス」を表示するように修正されたものです。`view_mode`が「目的変数とその祖先ノードのみ」ではなく、`view_mode`が「目的変数に到達可能な全てのパス」を表示するように変更しました。

### 修正されたコード：

```python
import streamlit as st
import pandas as pd
import networkx as nx
from pyvis.network import Network
import tempfile
from lingam import ICALiNGAM

st.set_page_config(page_title="ICA-LiNGAM 因果構造推定", layout="wide")
st.title("ICA-LiNGAMによる因果構造推定アプリ")

# ファイルアップロード
uploaded_file = st.file_uploader(
    "CSVまたはExcelファイルをアップロードしてください", type=["csv", "xlsx"]
)

if uploaded_file:
    filename = uploaded_file.name
    if filename.endswith(".csv"):
        df = pd.read_csv(uploaded_file)
    elif filename.endswith(".xlsx"):
        excel = pd.ExcelFile(uploaded_file)
        sheet_name = st.selectbox("シートを選択してください", excel.sheet_names)
        df = pd.read_excel(excel, sheet_name=sheet_name)

    st.subheader("データプレビュー")
    st.dataframe(df.head())

    st.subheader("目的変数と説明変数の選択")
    all_columns = df.columns.tolist()
    target_cols = st.multiselect("目的変数を選択してください（複数可）", all_columns)
    feature_cols = st.multiselect(
        "説明変数（1つ以上）", [col for col in all_columns if col not in target_cols]
    )

    with st.expander("ICA-LiNGAMのパラメータ調整"):
        max_iter = st.slider(
            "最大繰り返し数（max_iter）",
            min_value=100,
            max_value=5000,
            value=1000,
            step=100,
        )
        random_state = st.number_input(
            "乱数シード（random_state）", min_value=0, value=0, step=1
        )

    if st.button("因果構造を推定する"):
        if not feature_cols:
            st.error("少なくとも1つの説明変数を選んでください。")
        else:
            selected_cols = feature_cols + target_cols
            data = df[selected_cols].dropna()

            model = ICALiNGAM(max_iter=max_iter, random_state=random_state)
            model.fit(data)

            st.session_state["model"] = model
            st.session_state["selected_cols"] = selected_cols
            st.session_state["data"] = data
            st.session_state["target_col"] = target_cols

if "model" in st.session_state and "selected_cols" in st.session_state:
    model = st.session_state["model"]
    selected_cols = st.session_state["selected_cols"]
    data = st.session_state["data"]
    target_cols = st.session_state["target_col"]
    adj_matrix = model.adjacency_matrix_

    st.success("因果構造の推定が完了しました！")

    st.subheader("因果行列（推定された重み）")
    weight_df = pd.DataFrame(adj_matrix, columns=selected_cols, index=selected_cols)
    st.dataframe(weight_df.round(3))

    st.subheader("因果関係の一覧（向きと重み）")
    for i in range(len(selected_cols)):
        for j in range(len(selected_cols)):
            weight = adj_matrix[i, j]
            if abs(weight) > 1e-6:
                st.write(
                    f"{selected_cols[i]} → {selected_cols[j]}（重み: {weight:.3f}）"
                )

    st.subheader("因果グラフの可視化")

    # 可視化オプション
    view_mode = st.radio(
        "可視化モードを選択してください", ["全体表示", "目的変数に到達可能な全てのパス"]
    )

    T = st.slider("閾値T（-T〜+Tの範囲の辺を削除）", 0.0, 1.0, 0.3, 0.01)

    G = nx.DiGraph()
    for i in range(len(selected_cols)):
        for j in range(len(selected_cols)):
            weight = adj_matrix[i, j]
            if abs(weight) > T:
                G.add_edge(selected_cols[i], selected_cols[j], weight=round(weight, 2))

    # フィルタ処理：目的変数に到達可能な全てのパスのみ表示
    if view_mode == "目的変数に到達可能な全てのパス":
        sub_nodes = set(target_cols)
        for target in target_cols:
            # 目的変数に到達可能な全てのノードを取得
            reachable_nodes = nx.descendants(G, target)  # 逆方向の全てのノードも取得
            sub_nodes.update(reachable_nodes)
        G = G.subgraph(sub_nodes).copy()

    net = Network(height="600px", width="100%", directed=True)

    for node in G.nodes:
        if node in target_cols:
            net.add_node(node, label=node, color="orange")  # 目的変数だけ色変更
        else:
            net.add_node(node, label=node, color="lightblue")

    for source, target, data in G.edges(data=True):
        weight = data.get("weight", 0)
        color = "blue" if weight > 0 else "red"
        thickness = 1 + abs(weight) * 2

        net.add_edge(
            source,
            target,
            value=thickness,
            label=str(weight),
            title=f"重み: {weight}",
            color=color,
            font={"size": 14, "vadjust": -10},
        )

    net.show_buttons(filter_=["physics"])

    with tempfile.NamedTemporaryFile(delete=False, suffix=".html") as tmp_file:
        path = tmp_file.name
        net.save_graph(path)
        with open(path, "r", encoding="utf-8") as f:
            html_content = f.read()
        st.components.v1.html(html_content, height=700, scrolling=True)

    st.markdown("**ノード位置を調整後、右クリックから画像として保存できます。**")
```

### 修正点:
1. **目的変数に到達可能な全てのパス**：
    - `view_mode`が「目的変数に到達可能な全てのパス」に設定された場合、`nx.descendants`を使って目的変数に到達可能な全てのノードを取得し、それらのノードを表示するようにしました。
    - 逆方向の因果関係も表示されるようにしています（親→子のパスだけでなく、子→親の逆向きパスも含まれる）。
    
これで、目的変数に到達可能な全てのパスが表示されるようになります。

# **user**:

ありがとうございます。「目的変数に到達可能な全てのパス」としたときに、「目的変数から説明変数に向かう矢印」は削除するようにコードを改変してください。

# **assistant**:

「目的変数に到達可能な全てのパス」としたときに、「目的変数から説明変数に向かう矢印」を削除するためには、グラフのエッジを適切にフィルタリングし、目的変数から説明変数への矢印を除外する必要があります。

以下に修正を加えたコードを示します。このコードでは、目的変数から説明変数に向かう矢印を削除し、「目的変数に到達可能な全てのパス」を表示します。

### 修正されたコード：

```python
import streamlit as st
import pandas as pd
import networkx as nx
from pyvis.network import Network
import tempfile
from lingam import ICALiNGAM

st.set_page_config(page_title="ICA-LiNGAM 因果構造推定", layout="wide")
st.title("ICA-LiNGAMによる因果構造推定アプリ")

# ファイルアップロード
uploaded_file = st.file_uploader(
    "CSVまたはExcelファイルをアップロードしてください", type=["csv", "xlsx"]
)

if uploaded_file:
    filename = uploaded_file.name
    if filename.endswith(".csv"):
        df = pd.read_csv(uploaded_file)
    elif filename.endswith(".xlsx"):
        excel = pd.ExcelFile(uploaded_file)
        sheet_name = st.selectbox("シートを選択してください", excel.sheet_names)
        df = pd.read_excel(excel, sheet_name=sheet_name)

    st.subheader("データプレビュー")
    st.dataframe(df.head())

    st.subheader("目的変数と説明変数の選択")
    all_columns = df.columns.tolist()
    target_cols = st.multiselect("目的変数を選択してください（複数可）", all_columns)
    feature_cols = st.multiselect(
        "説明変数（1つ以上）", [col for col in all_columns if col not in target_cols]
    )

    with st.expander("ICA-LiNGAMのパラメータ調整"):
        max_iter = st.slider(
            "最大繰り返し数（max_iter）",
            min_value=100,
            max_value=5000,
            value=1000,
            step=100,
        )
        random_state = st.number_input(
            "乱数シード（random_state）", min_value=0, value=0, step=1
        )

    if st.button("因果構造を推定する"):
        if not feature_cols:
            st.error("少なくとも1つの説明変数を選んでください。")
        else:
            selected_cols = feature_cols + target_cols
            data = df[selected_cols].dropna()

            model = ICALiNGAM(max_iter=max_iter, random_state=random_state)
            model.fit(data)

            st.session_state["model"] = model
            st.session_state["selected_cols"] = selected_cols
            st.session_state["data"] = data
            st.session_state["target_col"] = target_cols

if "model" in st.session_state and "selected_cols" in st.session_state:
    model = st.session_state["model"]
    selected_cols = st.session_state["selected_cols"]
    data = st.session_state["data"]
    target_cols = st.session_state["target_col"]
    adj_matrix = model.adjacency_matrix_

    st.success("因果構造の推定が完了しました！")

    st.subheader("因果行列（推定された重み）")
    weight_df = pd.DataFrame(adj_matrix, columns=selected_cols, index=selected_cols)
    st.dataframe(weight_df.round(3))

    st.subheader("因果関係の一覧（向きと重み）")
    for i in range(len(selected_cols)):
        for j in range(len(selected_cols)):
            weight = adj_matrix[i, j]
            if abs(weight) > 1e-6:
                st.write(
                    f"{selected_cols[i]} → {selected_cols[j]}（重み: {weight:.3f}）"
                )

    st.subheader("因果グラフの可視化")

    # 可視化オプション
    view_mode = st.radio(
        "可視化モードを選択してください", ["全体表示", "目的変数に到達可能な全てのパス"]
    )

    T = st.slider("閾値T（-T〜+Tの範囲の辺を削除）", 0.0, 1.0, 0.3, 0.01)

    G = nx.DiGraph()
    for i in range(len(selected_cols)):
        for j in range(len(selected_cols)):
            weight = adj_matrix[i, j]
            if abs(weight) > T:
                G.add_edge(selected_cols[i], selected_cols[j], weight=round(weight, 2))

    # フィルタ処理：目的変数に到達可能な全てのパスのみ表示、かつ目的変数から説明変数に向かう矢印は削除
    if view_mode == "目的変数に到達可能な全てのパス":
        sub_nodes = set(target_cols)
        for target in target_cols:
            # 目的変数に到達可能な全てのノードを取得
            reachable_nodes = nx.descendants(G, target)  # 逆方向の全てのノードも取得
            sub_nodes.update(reachable_nodes)
        # 目的変数から説明変数に向かう矢印を除去
        for source, target in list(G.edges):
            if target in feature_cols and source in target_cols:
                G.remove_edge(source, target)
        G = G.subgraph(sub_nodes).copy()

    net = Network(height="600px", width="100%", directed=True)

    for node in G.nodes:
        if node in target_cols:
            net.add_node(node, label=node, color="orange")  # 目的変数だけ色変更
        else:
            net.add_node(node, label=node, color="lightblue")

    for source, target, data in G.edges(data=True):
        weight = data.get("weight", 0)
        color = "blue" if weight > 0 else "red"
        thickness = 1 + abs(weight) * 2

        net.add_edge(
            source,
            target,
            value=thickness,
            label=str(weight),
            title=f"重み: {weight}",
            color=color,
            font={"size": 14, "vadjust": -10},
        )

    net.show_buttons(filter_=["physics"])

    with tempfile.NamedTemporaryFile(delete=False, suffix=".html") as tmp_file:
        path = tmp_file.name
        net.save_graph(path)
        with open(path, "r", encoding="utf-8") as f:
            html_content = f.read()
        st.components.v1.html(html_content, height=700, scrolling=True)

    st.markdown("**ノード位置を調整後、右クリックから画像として保存できます。**")
```

### 修正点:
1. **目的変数から説明変数への矢印を削除**:
    - `view_mode == "目的変数に到達可能な全てのパス"`の条件の中で、目的変数から説明変数に向かう矢印を削除する処理を追加しました。
    - `for source, target in list(G.edges):` で、`target`が説明変数かつ`source`が目的変数の場合、そのエッジを削除します。

これで、目的変数に到達可能な全てのパスを表示する際に、目的変数から説明変数に向かう矢印が表示されないようになります。

# **user**:

ありがとうございます。因果行列（推定された重み）をエクセルファイルとしてダウンロードできるボタンを追加してください。

# **assistant**:

以下のように、`因果行列（推定された重み）`の下に **Excelファイルとしてダウンロードできるボタン** を追加できます。

### ✅ 追加部分のコード（`st.dataframe(weight_df.round(3))` の直後に挿入）：

```python
    # ダウンロード用 Excel ファイル作成
    from io import BytesIO

    output = BytesIO()
    with pd.ExcelWriter(output, engine="xlsxwriter") as writer:
        weight_df.to_excel(writer, sheet_name="CausalMatrix")
    output.seek(0)

    st.download_button(
        label="因果行列をExcelファイルとしてダウンロード",
        data=output,
        file_name="causal_matrix.xlsx",
        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
    )
```

---

### 📍全体の流れの中での配置例：

```python
    st.subheader("因果行列（推定された重み）")
    weight_df = pd.DataFrame(adj_matrix, columns=selected_cols, index=selected_cols)
    st.dataframe(weight_df.round(3))

    # ▼ ここにダウンロードボタンを追加 ▼
    from io import BytesIO

    output = BytesIO()
    with pd.ExcelWriter(output, engine="xlsxwriter") as writer:
        weight_df.to_excel(writer, sheet_name="CausalMatrix")
    output.seek(0)

    st.download_button(
        label="因果行列をExcelファイルとしてダウンロード",
        data=output,
        file_name="causal_matrix.xlsx",
        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
    )
```

このボタンをクリックすると、推定された因果行列（重み付きの隣接行列）を `causal_matrix.xlsx` という名前でダウンロードできます。必要に応じてファイル名やシート名は変更可能です。

# **user**:


ありがとうございます。ご提案いただいたコードを少し改変して、現状、次のコードになっています。「目的変数に到達可能な全てのパスのみ表示」の部分が、期待した挙動を示していないので、次のような手順にあらためてください。

(1) 因果グラフを有向グラフとしてとらえたとき、目的変数に１ステップで到達可能な説明変数とその矢印を取得する。
(2) 得られた説明変数に１ステップで到達可能な説明変数とその矢印を取得する。
(3) 到達可能な説明変数がこれ以上見つからなくなるまで(2)を繰り返す。
(4) 全ての目的変数に対して(1)(2)(3)を繰り返す。
(5) 取得されなかった説明変数と、取得されなかった矢印を除外したネットワークを、「目的変数に到達可能な全てのパス」とする。

```python
import streamlit as st
from io import BytesIO
import pandas as pd
import networkx as nx
from pyvis.network import Network
import tempfile
from lingam import ICALiNGAM
import numpy as np
import xlsxwriter

st.set_page_config(page_title="ICA-LiNGAM 因果構造推定", layout="wide")
st.title("ICA-LiNGAMによる因果構造推定アプリ")

# ファイルアップロード
uploaded_file = st.file_uploader(
    "CSVまたはExcelファイルをアップロードしてください", type=["csv", "xlsx"]
)

if uploaded_file:
    filename = uploaded_file.name
    if filename.endswith(".csv"):
        df = pd.read_csv(uploaded_file)
    elif filename.endswith(".xlsx"):
        excel = pd.ExcelFile(uploaded_file)
        sheet_name = st.selectbox("シートを選択してください", excel.sheet_names)
        df = pd.read_excel(excel, sheet_name=sheet_name)

    st.subheader("データプレビュー")
    st.dataframe(df.head())

    st.subheader("目的変数と説明変数の選択")
    all_columns = df.columns.tolist()
    target_cols = st.multiselect("目的変数を選択してください（複数可）", all_columns)
    feature_cols = st.multiselect(
        "説明変数（1つ以上）", [col for col in all_columns if col not in target_cols]
    )

    with st.expander("ICA-LiNGAMのパラメータ調整"):
        max_iter = st.slider(
            "最大繰り返し数（max_iter）",
            min_value=100,
            max_value=5000,
            value=1000,
            step=100,
        )
        random_state = st.number_input(
            "乱数シード（random_state）", min_value=0, value=0, step=1
        )

    if st.button("因果構造を推定する"):
        if not feature_cols:
            st.error("少なくとも1つの説明変数を選んでください。")
        else:
            selected_cols = feature_cols + target_cols
            data = df[selected_cols].dropna()

            model = ICALiNGAM(max_iter=max_iter, random_state=random_state)
            model.fit(data)

            st.session_state["model"] = model
            st.session_state["selected_cols"] = selected_cols
            st.session_state["data"] = data
            st.session_state["target_col"] = target_cols

if "model" in st.session_state and "selected_cols" in st.session_state:
    model = st.session_state["model"]
    selected_cols = st.session_state["selected_cols"]
    data = st.session_state["data"]
    target_cols = st.session_state["target_col"]
    adj_matrix = model.adjacency_matrix_

    st.success("因果構造の推定が完了しました！")

    st.subheader("因果行列（推定された重み）")
    weight_df = pd.DataFrame(adj_matrix, columns=selected_cols, index=selected_cols)
    st.dataframe(weight_df.round(3))

    output = BytesIO()
    with pd.ExcelWriter(output, engine="xlsxwriter") as writer:
        weight_df.to_excel(writer, sheet_name="CausalMatrix")
    output.seek(0)

    st.download_button(
        label="因果行列をExcelファイルとしてダウンロード",
        data=output,
        file_name="causal_matrix.xlsx",
        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
    )

    st.subheader("因果グラフの可視化")

    # 可視化オプション
    view_mode = st.radio(
        "可視化モードを選択してください", ["全体表示", "目的変数に到達可能な全てのパス"]
    )

    T = st.slider("閾値T（-T〜+Tの範囲の辺を削除）", 0.0, 1.0, 0.3, 0.01)

    G = nx.DiGraph()
    for i in range(len(selected_cols)):
        for j in range(len(selected_cols)):
            weight = adj_matrix[i, j]
            if abs(weight) > T:
                G.add_edge(selected_cols[i], selected_cols[j], weight=round(weight, 2))

    # フィルタ処理：目的変数に到達可能な全てのパスのみ表示
    if view_mode == "目的変数に到達可能な全てのパス":
        sub_nodes = set(target_cols)
        for target in target_cols:
            # 目的変数に到達可能な全てのノードを取得
            reachable_nodes = nx.descendants(G, target)  # 逆方向の全てのノードも取得
            sub_nodes.update(reachable_nodes)
        G = G.subgraph(sub_nodes).copy()

    net = Network(height="600px", width="100%", directed=True)

    for node in G.nodes:
        if node in target_cols:
            net.add_node(node, label=node, color="orange")  # 目的変数だけ色変更
        else:
            net.add_node(node, label=node, color="lightblue")

    for source, target, data in G.edges(data=True):
        weight = data.get("weight", 0)
        color = "blue" if weight > 0 else "red"
        thickness = 1 + abs(weight) * 2

        net.add_edge(
            source,
            target,
            value=thickness,
            label=str(weight),
            title=f"重み: {weight}",
            color=color,
            font={"size": 14, "vadjust": -10},
        )

    net.show_buttons(filter_=["physics"])

    with tempfile.NamedTemporaryFile(delete=False, suffix=".html") as tmp_file:
        path = tmp_file.name
        net.save_graph(path)
        with open(path, "r", encoding="utf-8") as f:
            html_content = f.read()
        st.components.v1.html(html_content, height=700, scrolling=True)

    st.markdown("**ノード位置を調整後、右クリックから画像として保存できます。**")
```

# **assistant**:

ありがとうございます！ご提示いただいた目的：

---

### 🎯「目的変数に到達可能なすべてのパスのみ表示」の処理の正しいロジック：
あなたの説明に基づき、**「目的変数へ向かって因果的に貢献する変数すべて」**を取得するためには、**因果グラフを逆向きにたどっていく（逆伝播）必要があります。**

---

### ✅ 改善された処理ロジック（コードの修正部分）

以下のように修正すると、目的変数から「影響を与えているすべての説明変数」へと逆方向にたどり、すべての関係を取得できます。

```python
if view_mode == "目的変数に到達可能な全てのパス":
    # 重み付き有向グラフ G を一時的に逆向きにする
    reversed_G = G.reverse(copy=True)

    # 目的変数に因果的に貢献しているすべてのノードを集める
    sub_nodes = set(target_cols)
    for target in target_cols:
        contributors = nx.descendants(reversed_G, target)
        sub_nodes.update(contributors)

    # 元のグラフ G から、上記ノードだけを使ったサブグラフを抽出
    G = G.subgraph(sub_nodes).copy()
```

---

### 🧠 説明（手順ごとに）：

1. **目的変数を始点として、逆向きに探索** → `reversed_G = G.reverse()`
2. **その目的変数に影響を与えているすべてのノードを探索** → `nx.descendants(reversed_G, target)`
3. **それら全てのノードだけからなるサブグラフを元のグラフから切り出す** → `G = G.subgraph(sub_nodes)`

---

### 💡置き換える場所（元のコード）：

```python
# フィルタ処理：目的変数に到達可能な全てのパスのみ表示
if view_mode == "目的変数に到達可能な全てのパス":
    sub_nodes = set(target_cols)
    for target in target_cols:
        # 目的変数に到達可能な全てのノードを取得
        reachable_nodes = nx.descendants(G, target)  # ← これだと間違った方向
        sub_nodes.update(reachable_nodes)
    G = G.subgraph(sub_nodes).copy()
```

これを上記の修正版に置き換えてください。

---

この修正によって、「目的変数に到達可能なすべてのパス」の意味が、**因果的に貢献するすべての変数（説明変数側）とそのパス**として、正しく可視化されます。  
いつでも追加のロジック調整や保存オプションも対応できますので、お気軽にどうぞ！

# **user**:

ありがとうございます。次のコードが最終版です。今回の話をブログに書きたいのですが、タイトル案をいくつか提示していただけますか？ 

```python
import streamlit as st
from io import BytesIO
import pandas as pd
import networkx as nx
from pyvis.network import Network
import tempfile
from lingam import ICALiNGAM
import numpy as np
import xlsxwriter

st.set_page_config(page_title="ICA-LiNGAM 因果構造推定", layout="wide")
st.title("ICA-LiNGAMによる因果構造推定アプリ")

# ファイルアップロード
uploaded_file = st.file_uploader(
    "CSVまたはExcelファイルをアップロードしてください", type=["csv", "xlsx"]
)

if uploaded_file:
    filename = uploaded_file.name
    if filename.endswith(".csv"):
        df = pd.read_csv(uploaded_file)
    elif filename.endswith(".xlsx"):
        excel = pd.ExcelFile(uploaded_file)
        sheet_name = st.selectbox("シートを選択してください", excel.sheet_names)
        df = pd.read_excel(excel, sheet_name=sheet_name)

    st.subheader("データプレビュー")
    st.dataframe(df.head())

    st.subheader("目的変数と説明変数の選択")
    all_columns = df.columns.tolist()
    target_cols = st.multiselect("目的変数を選択してください（複数可）", all_columns)
    feature_cols = st.multiselect(
        "説明変数（1つ以上）", [col for col in all_columns if col not in target_cols]
    )

    with st.expander("ICA-LiNGAMのパラメータ調整"):
        max_iter = st.slider(
            "最大繰り返し数（max_iter）",
            min_value=100,
            max_value=5000,
            value=1000,
            step=100,
        )
        random_state = st.number_input(
            "乱数シード（random_state）", min_value=0, value=0, step=1
        )

    if st.button("因果構造を推定する"):
        if not feature_cols:
            st.error("少なくとも1つの説明変数を選んでください。")
        else:
            selected_cols = feature_cols + target_cols
            data = df[selected_cols].dropna()

            model = ICALiNGAM(max_iter=max_iter, random_state=random_state)
            model.fit(data)

            st.session_state["model"] = model
            st.session_state["selected_cols"] = selected_cols
            st.session_state["data"] = data
            st.session_state["target_col"] = target_cols

if "model" in st.session_state and "selected_cols" in st.session_state:
    model = st.session_state["model"]
    selected_cols = st.session_state["selected_cols"]
    data = st.session_state["data"]
    target_cols = st.session_state["target_col"]
    adj_matrix = model.adjacency_matrix_

    st.success("因果構造の推定が完了しました！")

    st.subheader("因果行列（推定された重み）")
    weight_df = pd.DataFrame(adj_matrix, columns=selected_cols, index=selected_cols)
    st.dataframe(weight_df.round(3))

    output = BytesIO()
    with pd.ExcelWriter(output, engine="xlsxwriter") as writer:
        weight_df.to_excel(writer, sheet_name="CausalMatrix")
    output.seek(0)

    st.download_button(
        label="因果行列をExcelファイルとしてダウンロード",
        data=output,
        file_name="causal_matrix.xlsx",
        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
    )

    st.subheader("因果グラフの可視化")

    # 可視化オプション
    view_mode = st.radio(
        "可視化モードを選択してください", ["全体表示", "目的変数に到達可能な全てのパス"]
    )

    T = st.slider("閾値T（-T〜+Tの範囲の辺を削除）", 0.0, 1.0, 0.3, 0.01)

    G = nx.DiGraph()
    for i in range(len(selected_cols)):
        for j in range(len(selected_cols)):
            weight = adj_matrix[i, j]
            if abs(weight) > T:
                G.add_edge(selected_cols[i], selected_cols[j], weight=round(weight, 2))

    # フィルタ処理：目的変数に到達可能な全てのパスのみ表示
    if view_mode == "目的変数に到達可能な全てのパス":
        # 重み付き有向グラフ G を一時的に逆向きにする
        reversed_G = G.reverse(copy=True)

        # 目的変数に因果的に貢献しているすべてのノードを集める
        sub_nodes = set(target_cols)
        for target in target_cols:
            try:
                contributors = nx.descendants(reversed_G, target)
                sub_nodes.update(contributors)
            except:
                pass

        # 元のグラフ G から、上記ノードだけを使ったサブグラフを抽出
        G = G.subgraph(sub_nodes).copy()

    net = Network(height="600px", width="100%", directed=True)

    for node in G.nodes:
        if node in target_cols:
            net.add_node(node, label=node, color="orange")  # 目的変数だけ色変更
        else:
            net.add_node(node, label=node, color="lightblue")

    for source, target, data in G.edges(data=True):
        weight = data.get("weight", 0)
        color = "blue" if weight > 0 else "red"
        thickness = 1 + abs(weight) * 2

        net.add_edge(
            source,
            target,
            value=thickness,
            label=str(weight),
            title=f"重み: {weight}",
            color=color,
            font={"size": 14, "vadjust": -10},
        )

    net.show_buttons(filter_=["physics"])

    with tempfile.NamedTemporaryFile(delete=False, suffix=".html") as tmp_file:
        path = tmp_file.name
        net.save_graph(path)
        with open(path, "r", encoding="utf-8") as f:
            html_content = f.read()
        st.components.v1.html(html_content, height=700, scrolling=True)

    st.markdown("**ノード位置を調整後、右クリックから画像として保存できます。**")
```

素晴らしいですね！Streamlit×ICA-LiNGAMを使った因果構造の推定＆可視化アプリをここまで仕上げた内容は、技術ブログとしてもとても価値があります。

以下、ブログのタイトル案をいくつかご提案します（キャッチーさ重視・内容説明重視の両方含めています）：

---

### ✨ キャッチー系
1. **「目的変数に辿り着く道だけを描く」因果グラフ可視化アプリを作ってみた！**
2. **ICA-LiNGAM × Streamlitで因果関係をインタラクティブに掘り下げる！**
3. **説明変数の因果パスだけ抽出してみた：可視化付きアプリの作り方**
4. **因果の「流れ」を視覚化！目的変数に向かうパスを抽出するStreamlitアプリ**
5. **目的変数の「原因だけ」可視化したくない？それ、Pythonでできます。**

---

### 🧠 技術・内容重視系
6. **ICA-LiNGAMによる因果構造推定と、目的変数へのパス抽出による可視化**
7. **Streamlitでつくる、目的変数に到達する因果パス抽出アプリ（ICA-LiNGAM利用）**
8. **Pythonで因果推論：目的変数に到達可能な因果経路だけを抽出して可視化する方法**
9. **pyvis × networkx × Streamlitで、因果関係を可視化・操作するアプリを構築する**
10. **説明変数の「因果的貢献」を可視化する：逆方向グラフからのパス抽出と応用**

---

どんな読者層をターゲットにするかによっても、タイトルの方向性が変わるので、もし「初学者向けにする」「実務者向けにする」などの方針があれば、それに合わせて調整もできますよ！どれか気になる案はありましたか？それとも他のトーンでもいくつか出してみましょうか？
    
# **user**:

「ICA-LiNGAMによる因果構造推定と、目的変数へのパス抽出による可視化」でいきますね。ありがとうございます。では最後に、今回のまとめを詳しく書いてください。

# **assistant**:

了解です！では、ブログの締めくくりとしてぴったりな「今回のまとめ」を、読者にも理解しやすく丁寧に書いてみますね。以下のような内容はいかがでしょうか？

---

## 📝 まとめ：ICA-LiNGAMによる因果構造推定と、目的変数へのパス抽出による可視化

本記事では、Pythonの`Streamlit`と`ICA-LiNGAM`を組み合わせて、**データから因果構造を推定し、それを直感的に可視化するアプリ**の作成プロセスを紹介しました。以下に、今回のアプローチの特徴とポイントをまとめます。

---

### 🔍 ICA-LiNGAMとは？
- **LiNGAM（Linear Non-Gaussian Acyclic Model）** は、線形で非ガウス分布なデータに基づく因果構造の推定手法です。
- 特に **ICA-LiNGAM** は、独立成分分析（ICA）を利用して、データの非対称性を活用し因果順序を特定します。
- 本アプリでは `lingam` ライブラリを用いて簡単に実装できました。

---

### 🧪 本アプリの主な機能
1. **CSV / Excelファイルの読み込みとデータプレビュー**
2. **目的変数と説明変数の選択（複数選択に対応）**
3. **ICA-LiNGAMによる因果構造推定**
4. **推定結果（因果行列）の表示とExcel形式でのダウンロード**
5. **因果グラフのインタラクティブな可視化（pyvisを利用）**
6. **目的変数に到達可能な因果パスのみを抽出して可視化できるフィルター機能**

---

### 🧠 目的変数へのパス抽出とは？
- 全体の因果構造から、**特定の目的変数に因果的に貢献している説明変数の経路だけを抽出する**処理を実装しました。
- ネットワーク構造を逆向きにして `networkx.descendants` を使うことで、目的変数に因果的に繋がる全ノードを動的に取得しています。
- これにより、不要なノードや関係を取り除き、「本当に注目すべき因果パス」だけを抽出・強調することが可能になりました。

---

### 📈 実務や研究での活用例
- マーケティングデータにおける購買要因の因果探索
- 医療データにおける特定疾患への影響経路の抽出
- 製造業における品質不良要因の特定と改善
- 経済・社会科学における政策要因の因果分析

---

### 💡 今後の展望
- 他の因果推定アルゴリズム（DirectLiNGAM、NOTEARSなど）への対応
- 時系列データへの拡張（VAR-LiNGAMなど）
- 推定の不確実性（信頼区間など）の可視化
- グラフのエクスポート機能強化（画像保存やレイアウト固定など）

---

### 🚀 さいごに
因果推論はデータ分析の中でも特に難しいテーマですが、今回のように視覚的・インタラクティブに扱える環境を整えることで、専門知識がなくても因果構造の「全体像」と「重要な関係」を理解する手助けになります。

「データに因果関係があるのか？」ではなく、「**どの変数がどの変数に、どの程度影響を与えているのか？**」を掘り下げたい場面で、ぜひ本アプリを試してみてください。

---

こんな感じでいかがでしょうか？さらに「コードのポイント」や「Streamlitで工夫したUIの話」も入れたい場合は追記もできます！


# **user**:

ありがとうございます。これで充分です。また今度よろしくお願いします。

# **assistant**: