付録. 機械学習アプリの作り方¶

import pickle
import numpy as np
import seaborn as sns
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

# モデルの学習（iris は seaborn 版で読み込み）
df_iris = sns.load_dataset('iris')
feature_cols = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
X_train, X_test, y_train, y_test = train_test_split(
    df_iris[feature_cols].values, df_iris['species'],
    test_size=0.2, random_state=42
)
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# モデルをファイルに保存
with open('iris_model.pkl', 'wb') as f:
    pickle.dump(model, f)

# モデルの読み込み
with open('iris_model.pkl', 'rb') as f:
    loaded_model = pickle.load(f)

# 読み込んだモデルで予測
sample = np.array([[5.1, 3.5, 1.4, 0.2]])
prediction = loaded_model.predict(sample)
print(f"予測結果: {prediction[0]}")  # 予測結果: setosa

import joblib

# モデルの保存
joblib.dump(model, 'iris_model.joblib')

# モデルの読み込み
loaded_model = joblib.load('iris_model.joblib')

# train_penguin.py
import seaborn as sns
import joblib
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier

# データの準備（推論時は NumPy 配列を渡すため、.values で学習しておく）
penguins = sns.load_dataset("penguins").dropna()
X = penguins[["bill_length_mm", "bill_depth_mm",
              "flipper_length_mm", "body_mass_g"]].values
y = penguins["species"]

# パイプラインの構築と学習
pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("classifier", RandomForestClassifier(
        n_estimators=100, random_state=42
    ))
])
pipeline.fit(X, y)

# モデルの保存
joblib.dump(pipeline, "penguin_model.joblib")
print("モデルを保存しました")
print(f"クラス: {list(pipeline.classes_)}")

# predict.py
import joblib
import numpy as np

# モデルの読み込み（アプリ起動時に1回だけ実行する想定）
model = joblib.load("penguin_model.joblib")

# 特徴量からペンギンの種類と各クラスの確率を返す
def predict_penguin(bill_length, bill_depth,
                    flipper_length, body_mass):
    features = np.array([[bill_length, bill_depth,
                          flipper_length, body_mass]])
    prediction = model.predict(features)[0]
    probabilities = model.predict_proba(features)[0]
    proba_dict = {
        species: round(float(prob), 4)
        for species, prob in zip(model.classes_, probabilities)
    }
    return prediction, proba_dict

# 動作確認
species, proba = predict_penguin(39.1, 18.7, 181.0, 3750.0)
print(f"予測結果: {species}")
print(f"確率: {proba}")

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello, Flask!"

if __name__ == '__main__':
    app.run(debug=True)

from flask import Flask, request, render_template

app = Flask(__name__)

# ルート（トップページ）
@app.route('/')
def index():
    return "トップページ"

# 別のページ
@app.route('/about')
def about():
    return "About ページ"

# パラメータを受け取る
@app.route('/user/<name>')
def user(name):
    return f"Hello, {name}!"

# POST リクエストを処理
@app.route('/submit', methods=['POST'])
def submit():
    data = request.form['data']
    return f"受け取ったデータ: {data}"

if __name__ == '__main__':
    app.run(debug=True)

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html',
                           title="My App",
                           message="Hello, Flask!")

if __name__ == '__main__':
    app.run(debug=True)

from flask import Flask, request, jsonify
import requests
import numpy as np
import pickle

LLM_URL = "https://xxxxxxxx.trycloudflare.com"  # 授業でアナウンスされる URL に置き換える
EMBED_MODEL = "text-embedding-bge-m3"

app = Flask(__name__)

# 分類器の読み込み
print("分類器を読み込んでいます...")
with open('sentiment_clf.pkl', 'rb') as f:
    classifier = pickle.load(f)

print("分類器の読み込みが完了しました。")

# テキスト 1 文を LM Studio でベクトル化
def encode_one(text):
    r = requests.post(
        f"{LLM_URL}/v1/embeddings",
        json={"model": EMBED_MODEL, "input": text},
        timeout=30,
    )
    return np.array([r.json()["data"][0]["embedding"]])

@app.route('/')
def index():
    return """
    <h1>感情分析 API</h1>
    <p>使い方：POST /predict にテキストを送信してください。</p>
    <p>例：curl -X POST -H "Content-Type: application/json" -d '{"text":"この映画は面白かった"}' http://localhost:5000/predict</p>
    """

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json()

    if 'text' not in data:
        return jsonify({'error': 'テキストが指定されていません'}), 400

    text = data['text']
    if not text.strip():
        return jsonify({'error': 'テキストが空です'}), 400

    # LM Studio でベクトル化
    embedding = encode_one(text)

    # 予測
    prediction = classifier.predict(embedding)[0]
    probability = classifier.predict_proba(embedding)[0]

    result = {
        'text': text,
        'sentiment': 'positive' if prediction == 1 else 'negative',
        'confidence': float(probability[prediction]),
        'probabilities': {
            'positive': float(probability[1]),
            'negative': float(probability[0]),
        },
    }

    return jsonify(result)

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)

import requests

url = 'http://localhost:5000/predict'
data = {'text': 'この映画はつまらなかった'}

response = requests.post(url, json=data)
result = response.json()

print(result)

from flask import Flask, render_template, request
import requests
import numpy as np
import pickle

LLM_URL = "https://xxxxxxxx.trycloudflare.com"  # 授業でアナウンスされる URL に置き換える
EMBED_MODEL = "text-embedding-bge-m3"

app = Flask(__name__)

# 分類器の読み込み
with open('sentiment_clf.pkl', 'rb') as f:
    classifier = pickle.load(f)

def encode_one(text):
    r = requests.post(
        f"{LLM_URL}/v1/embeddings",
        json={"model": EMBED_MODEL, "input": text},
        timeout=30,
    )
    return np.array([r.json()["data"][0]["embedding"]])

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/analyze', methods=['POST'])
def analyze():
    text = request.form['text']

    if not text.strip():
        return render_template('index.html', error="テキストを入力してください")

    # LM Studio でベクトル化と予測
    embedding = encode_one(text)
    prediction = classifier.predict(embedding)[0]
    probability = classifier.predict_proba(embedding)[0]

    sentiment = 'Positive' if prediction == 1 else 'Negative'
    confidence = probability[prediction]

    return render_template('result.html',
                           text=text,
                           sentiment=sentiment,
                           confidence=confidence,
                           prob_positive=probability[1],
                           prob_negative=probability[0])

if __name__ == '__main__':
    app.run(debug=True)

import streamlit as st

# タイトル
st.title("Hello, Streamlit!")

# テキスト
st.write("これは Streamlit で作った Web アプリです。")

# ボタン
if st.button("クリックしてください"):
    st.write("ボタンがクリックされました！")

# スライダー
value = st.slider("値を選択してください", 0, 100, 50)
st.write(f"選択された値: {value}")

st.title("タイトル")
st.header("ヘッダー")
st.subheader("サブヘッダー")
st.write("テキスト")
st.markdown("**太字** や *斜体* も使えます")

# テキスト入力
text = st.text_input("テキストを入力してください")

# テキストエリア
long_text = st.text_area("長いテキストを入力してください")

# 数値入力
number = st.number_input("数値を入力してください", min_value=0, max_value=100)

# スライダー
value = st.slider("値を選択してください", 0, 100, 50)

# セレクトボックス
option = st.selectbox("選択してください", ["オプション1", "オプション2", "オプション3"])

# ボタン
if st.button("送信"):
    st.write("送信されました!")

import pandas as pd

# DataFrame の表示
df = pd.DataFrame({
    "列1": [1, 2, 3],
    "列2": [4, 5, 6]
})
st.dataframe(df)

# テーブルの表示
st.table(df)

import matplotlib.pyplot as plt

# Matplotlib のグラフ
fig, ax = plt.subplots()
ax.plot([1, 2, 3, 4], [1, 4, 2, 3])
st.pyplot(fig)

# 簡易グラフ
st.line_chart(df)
st.bar_chart(df)

import requests
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
import pickle

LLM_URL = "https://xxxxxxxx.trycloudflare.com"  # 授業でアナウンスされる URL に置き換える
EMBED_MODEL = "text-embedding-bge-m3"

def encode(texts):
    if isinstance(texts, str):
        texts = [texts]
    r = requests.post(
        f"{LLM_URL}/v1/embeddings",
        json={"model": EMBED_MODEL, "input": texts},
    )
    return np.array([d["embedding"] for d in r.json()["data"]])

# データの読み込み
df = pd.read_csv('movie_reviews.csv')

# LM Studio でベクトル化（少し時間がかかります）
print("ベクトル化中...")
embeddings = encode(df['text'].tolist())

# ラベルを数値に変換
df['label_num'] = (df['label'] == 'positive').astype(int)

# 訓練データとテストデータに分割
X_train, X_test, y_train, y_test = train_test_split(
    embeddings, df['label_num'],
    test_size=0.2,
    random_state=42
)

# ロジスティック回帰で学習
clf = LogisticRegression(random_state=42, max_iter=1000)
clf.fit(X_train, y_train)

# 分類器のみ保存（Embedding モデルはサーバ側にあるので保存不要）
with open('sentiment_clf.pkl', 'wb') as f:
    pickle.dump(clf, f)

print("分類器を保存しました: sentiment_clf.pkl")

import streamlit as st
import requests
import numpy as np
import pickle

LLM_URL = "https://xxxxxxxx.trycloudflare.com"  # 授業でアナウンスされる URL に置き換える
EMBED_MODEL = "text-embedding-bge-m3"

# ページの設定
st.set_page_config(page_title="感情分析アプリ", page_icon="😊")

# タイトル
st.title("😊 感情分析アプリ")
st.write("テキストを入力すると、Positive（ポジティブ）か Negative（ネガティブ）かを判定します。")

# 分類器の読み込み（キャッシュを使って 1 回だけ読み込む）
@st.cache_resource
def load_classifier():
    with open('sentiment_clf.pkl', 'rb') as f:
        return pickle.load(f)

classifier = load_classifier()

# 1 文を LM Studio でベクトル化
def encode_one(text):
    r = requests.post(
        f"{LLM_URL}/v1/embeddings",
        json={"model": EMBED_MODEL, "input": text},
    )
    return np.array([r.json()["data"][0]["embedding"]])

# テキスト入力
text_input = st.text_area(
    "テキストを入力してください",
    height=150,
    placeholder="例：この映画は本当に面白かった！"
)

# 予測ボタン
if st.button("感情を分析"):
    if text_input.strip() == "":
        st.warning("テキストを入力してください。")
    else:
        with st.spinner("LM Studio サーバで解析中..."):
            embedding = encode_one(text_input)
            prediction = classifier.predict(embedding)[0]
            probability = classifier.predict_proba(embedding)[0]

        # 結果の表示
        st.subheader("分析結果")

        if prediction == 1:
            st.success("😊 Positive（ポジティブ）")
            st.progress(probability[1])
            st.write(f"確率: {probability[1]:.2%}")
        else:
            st.error("😞 Negative（ネガティブ）")
            st.progress(probability[0])
            st.write(f"確率: {probability[0]:.2%}")

        with st.expander("詳細情報を表示"):
            st.write(f"Positive の確率: {probability[1]:.2%}")
            st.write(f"Negative の確率: {probability[0]:.2%}")

# サイドバー
st.sidebar.header("ℹ️ このアプリについて")
st.sidebar.write("""
このアプリは、機械学習を使って日本語テキストの感情を分析します。

**使用技術**
- ローカル LLM サーバ（LM Studio + bge-m3）
- Logistic Regression
- Streamlit
""")

# train_sentiment.py
import pickle
import MeCab
import pandas as pd
from urllib.request import urlretrieve
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline

# データの読み込み（第13章と同じ映画レビュー）
url = "https://ml.kano.ac/chapters/data/movie_reviews.csv"
urlretrieve(url, "movie_reviews.csv")
df = pd.read_csv("movie_reviews.csv")

# MeCabで分かち書き（アプリ側でも入力に同じ処理を行う）
tagger = MeCab.Tagger("-Owakati")
df["wakati"] = [tagger.parse(text).strip() for text in df["text"]]

# ラベルを数値に変換（positive=1, negative=0）
df["label_num"] = (df["label"] == "positive").astype(int)

# 訓練データとテストデータに分割
X_train, X_test, y_train, y_test = train_test_split(
    df["wakati"], df["label_num"], test_size=0.2, random_state=42
)

# TF-IDFベクトル化と分類器をパイプラインにまとめて学習
pipeline = Pipeline([
    ("tfidf", TfidfVectorizer()),
    ("classifier", LogisticRegression(max_iter=1000)),
])
pipeline.fit(X_train, y_train)
print(f"テスト精度: {pipeline.score(X_test, y_test):.2%}")

# パイプラインごと保存（ベクトル化と分類器がセットで保存される）
with open("sentiment_pipeline.pkl", "wb") as f:
    pickle.dump(pipeline, f)
print("保存しました: sentiment_pipeline.pkl")

import streamlit as st
import MeCab
import pickle

# ページの設定
st.set_page_config(page_title="感情分析アプリ", page_icon="😊")

# タイトル
st.title("😊 感情分析アプリ（サーバ不要版）")
st.write("テキストを入力すると、Positive（ポジティブ）か Negative（ネガティブ）かを判定します。")

# パイプラインの読み込み（キャッシュを使って 1 回だけ読み込む）
@st.cache_resource
def load_pipeline():
    with open("sentiment_pipeline.pkl", "rb") as f:
        return pickle.load(f)

pipeline = load_pipeline()
tagger = MeCab.Tagger("-Owakati")

# 学習時と同じ前処理（分かち書き）をしてから予測する
def predict_sentiment(text):
    wakati = tagger.parse(text).strip()
    prediction = pipeline.predict([wakati])[0]
    probability = pipeline.predict_proba([wakati])[0]
    return prediction, probability

# テキスト入力
text_input = st.text_area(
    "テキストを入力してください",
    height=150,
    placeholder="例：この映画は本当に面白かった！"
)

# 予測ボタン
if st.button("感情を分析"):
    if text_input.strip() == "":
        st.warning("テキストを入力してください。")
    else:
        prediction, probability = predict_sentiment(text_input)

        # 結果の表示
        st.subheader("分析結果")
        if prediction == 1:
            st.success("😊 Positive（ポジティブ）")
            st.progress(probability[1])
            st.write(f"確率: {probability[1]:.2%}")
        else:
            st.error("😞 Negative（ネガティブ）")
            st.progress(probability[0])
            st.write(f"確率: {probability[0]:.2%}")

@st.cache_resource
def load_models():
    # 時間のかかる処理（モデルの読み込みなど）
    return model

import requests

LLM_URL = "https://xxxxxxxx.trycloudflare.com"  # 授業でアナウンスされる URL に置き換える
CHAT_MODEL = "qwen/qwen3.5-9b"

response = requests.post(
    f"{LLM_URL}/v1/chat/completions",
    json={
        "model": CHAT_MODEL,
        "messages": [
            {"role": "system", "content": "あなたは親切なアシスタントです。"},
            {"role": "user", "content": "機械学習とは何ですか？簡潔に説明してください。"},
        ],
        "stream": False,
    },
)

result = response.json()
print(result["choices"][0]["message"]["content"])

import streamlit as st

st.title("チャット UI の練習")

# 会話履歴の初期化（初回だけ実行される）
if "messages" not in st.session_state:
    st.session_state.messages = []

# 入力欄（Enter で送信）
prompt = st.chat_input("メッセージを入力してください")
if prompt:
    st.session_state.messages.append({"role": "user", "content": prompt})

# 履歴をすべて吹き出しで表示
for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.write(message["content"])

import streamlit as st
import requests

LLM_URL = "https://xxxxxxxx.trycloudflare.com"  # 授業でアナウンスされる URL に置き換える
CHAT_MODEL = "qwen/qwen3.5-9b"
SYSTEM_PROMPT = "あなたは親切なアシスタントです。簡潔な日本語で回答してください。"

# ページの設定
st.set_page_config(page_title="チャットアプリ", page_icon="💬")
st.title("💬 チャットアプリ")

# 会話履歴の初期化（初回だけ実行される）
if "messages" not in st.session_state:
    st.session_state.messages = []

# これまでの会話履歴を表示
for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.write(message["content"])

# ユーザの入力を受け取る
prompt = st.chat_input("メッセージを入力してください")
if prompt:
    # ユーザの発言を履歴に追加して表示
    st.session_state.messages.append({"role": "user", "content": prompt})
    with st.chat_message("user"):
        st.write(prompt)

    # システムプロンプト + 会話履歴全体を送って応答を取得
    with st.chat_message("assistant"):
        with st.spinner("考え中..."):
            response = requests.post(
                f"{LLM_URL}/v1/chat/completions",
                json={
                    "model": CHAT_MODEL,
                    "messages": [{"role": "system", "content": SYSTEM_PROMPT}]
                    + st.session_state.messages,
                    "stream": False,
                },
            )
            answer = response.json()["choices"][0]["message"]["content"]
        st.write(answer)

    # モデルの応答も履歴に追加
    st.session_state.messages.append({"role": "assistant", "content": answer})