ソーシャルメディア感情分析

ソーシャルメディア感情分析の例題として、Twitterのツイートデータを使用して、テキストデータから感情（ポジティブ、ネガティブ、またはニュートラル）を予測する方法を示します。

感情分析には、自然言語処理の手法と機械学習アルゴリズムを組み合わせます。

まず、必要なライブラリをインポートします。

1
2
3
4
5
6
7
8
9
10
11

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import re
import nltk
from nltk.corpus import stopwords
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

次に、Twitterの感情分析用のサンプルデータを用意します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

data = {
    'text': [
        "I love this product, it's amazing!",
        "This movie was terrible, never watching it again!",
        "Neutral tweet about some topic.",
        "The weather is beautiful today.",
        "Had a great time at the beach with friends!",
        "Feeling tired after a long day at work.",
        "Excited for the upcoming vacation!",
        "Disappointed with the customer service.",
        "Trying out a new recipe for dinner tonight.",
        "Can't wait to see my favorite band in concert!",
        "Feeling happy and grateful for all the love and support.",
        "Feeling overwhelmed with deadlines and tasks.",
        "Just finished reading a fantastic book!",
        "Feeling bored, looking for something fun to do.",
        "Feeling anxious about the job interview tomorrow.",
        "Enjoying a relaxing weekend at home.",
        "Feeling proud of my accomplishments.",
        "The traffic today is unbearable!",
        "Feeling lonely on a rainy day.",
        "Delighted to meet an old friend unexpectedly.",
        "Feeling frustrated with the slow internet connection.",
        "Had a bad experience at the restaurant tonight.",
        "Feeling motivated to achieve my goals.",
        "Feeling nostalgic looking at old photos.",
        "Feeling grateful for the little things in life.",
        "Feeling sad after saying goodbye to a dear friend.",
        "Excited for the new season of my favorite TV show!",
        "Feeling stressed about the upcoming exam.",
        "The new gadget I bought is not working properly.",
    ],
    'sentiment': [
        'positive', 'negative', 'neutral', 'positive', 'positive', 'negative', 'positive',
        'negative', 'positive', 'positive', 'positive', 'negative', 'positive', 'negative',
        'negative', 'positive', 'positive', 'negative', 'negative', 'positive', 'negative',
        'negative', 'positive', 'positive', 'positive', 'negative', 'positive', 'negative',
        'positive'
    ]
}

df = pd.DataFrame(data)

テキストデータを前処理します。

ストップワードの削除、記号や数字の削除、すべての文字を小文字に変換などの処理を行います。

1
2
3
4
5
6
7
8
9
10
11
12

nltk.download('stopwords')
stop_words = set(stopwords.words('english'))

def preprocess_text(text):
    text = re.sub('[^a-zA-Z]', ' ', text)
    text = text.lower()
    text = text.split()
    text = [word for word in text if not word in stop_words]
    text = ' '.join(text)
    return text

df['text'] = df['text'].apply(preprocess_text)

次に、テキストデータを数値ベクトル化します。

1
2
3

vectorizer = CountVectorizer()
X = vectorizer.fit_transform(df['text'])
y = df['sentiment']

データセットをトレーニングセットとテストセットに分割します。

1

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Naive Bayesアルゴリズムを使用して感情分析モデルを学習します。

1
2

clf = MultinomialNB()
clf.fit(X_train, y_train)

テストセットで予測を行い、結果を評価します。

1
2
3
4

y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")
print(classification_report(y_test, y_pred))

これで、ソーシャルメディア感情分析モデルのトレーニングと評価が完了しました。

最後に、結果をグラフ化します。

感情ごとの分類数を棒グラフで表示します。

1
2
3
4
5

sns.countplot(x='sentiment', data=df)
plt.xlabel('Sentiment')
plt.ylabel('Count')
plt.title('Sentiment Analysis Result')
plt.show()

これにより、ソーシャルメディア感情分析のモデルの予測結果を視覚化できます。

棒グラフで表示される感情のカウントを確認することができます。

[実行結果]

ソースコード解説

このコードは、感情分析（Sentiment Analysis）を行うためのプログラムです。

感情分析は、テキストデータから感情や意見を抽出するための自然言語処理の一種です。

numpyは数値計算を行うためのライブラリ、pandasはデータ解析を行うためのライブラリ、matplotlibとseabornはデータの可視化を行うためのライブラリです。

また、テキストの前処理に使用するためにreとnltkもインポートしています。

dataという辞書型の変数に、テキストと感情のペアを格納しています。

このデータは、感情分析のためのトレーニングデータとして使用されます。

その後、pandasのDataFrameオブジェクトを使用して、データを表形式で扱えるようにしています。

DataFrameは、行と列からなるデータ構造で、この場合はテキストと感情の2つの列があります。

次に、テキストの前処理を行うための関数preprocess_textを定義しています。

この関数では、テキストから不要な文字を削除し、小文字に変換し、ストップワード（一般的な単語や語句）を除外しています。

これにより、テキストデータをより扱いやすい形式に変換します。

その後、preprocess_text関数をapplyメソッドを使ってデータフレームのtext列に適用し、テキストの前処理を行っています。

次に、CountVectorizerクラスを使用してテキストデータをベクトル化しています。

CountVectorizerは、テキストデータを単語の出現回数を表すベクトルに変換するためのクラスです。

fit_transformメソッドを使用することで、テキストデータをベクトル化しています。

その後、データをトレーニングデータとテストデータに分割しています。

train_test_split関数を使用することで、データを指定した割合で分割することができます。

次に、MultinomialNBクラスを使用してナイーブベイズ分類器を作成し、トレーニングデータを用いてモデルを学習させています。

学習が完了したら、テストデータを用いて予測を行い、予測結果の正確さを評価しています。

accuracy_score関数を使用することで、予測結果の正確さを計算しています。

また、classification_report関数を使用することで、クラスごとの適合率、再現率、F1スコアなどの評価指標を表示しています。

最後に、感情のカウントを可視化するために、seabornのcountplot関数を使用して棒グラフを作成し、matplotlibを使用してグラフを表示しています。

これにより、各感情の出現回数を視覚的に確認することができます。

このコードは、テキストデータから感情を分析し、予測するための基本的な手法を示しています。

感情分析は、レビューやソーシャルメディアの投稿など、さまざまな応用分野で活用されています。

結果解説

以下にそれぞれの指標を説明します。

1. Accuracy (正解率): 0.50

正解率は、全体の予測のうち、正しく分類されたサンプルの割合を示します。
この場合、正解率は50%です。
つまり、テストセットの6つのツイートのうち、3つが正しく分類され、3つが間違って分類されました。

2. Precision (適合率):

適合率は、モデルがポジティブ（positive）と予測したサンプルのうち、実際にポジティブだったサンプルの割合を示します。
negative（ネガティブ）に関しては25%の適合率で、positive（ポジティブ）に関しては100%の適合率です。
つまり、negativeの予測は1つだけ正確であり、positiveの予測は全て正確でした。

3. Recall (再現率):

再現率は、実際にポジティブなサンプルのうち、モデルがポジティブと予測したサンプルの割合を示します。
negativeに関しては100%の再現率で、positiveに関しては40%の再現率です。
つまり、negativeの全てのサンプルを正確に予測し、positiveのうち40%のサンプルを正確に予測しました。

4. F1-score (F1スコア):

F1スコアは、適合率と再現率の調和平均です。
F1スコアが高いほど、適合率と再現率の両方がバランスよく高いことを示します。
この場合、negativeに関しては0.40のF1スコアで、positiveに関しては0.57のF1スコアです。

5. Support (サポート):

Supportは各クラスのサンプル数を示します。
negativeのサポートは1で、positiveのサポートは5です。
つまり、negativeのテストデータは1つだけで、positiveのテストデータは5つあります。

総合的に見ると、この感情分析モデルは、negativeクラスの予測においては一部のサンプルを正確に予測しましたが、positiveクラスの予測には改善の余地があります。

モデルの性能を向上させるためには、データの増加や特徴抽出方法の改善、より高度な機械学習アルゴリズムの使用などが考えられます。

また、評価結果を可視化することで、モデルの性能を把握し、改善点を見つけるのに役立ちます。

サッカーの試合結果

サッカーの試合結果を予測する問題を考えてみましょう。

ここでは、チームの過去の試合データを用いて、2つのチームの対戦結果を予測する回帰問題としてアプローチします。

Scikit-learnのLinearRegressionを使用して線形回帰モデルを作成し、試合の得点差を予測します。

サンプルデータとして、2つのチームの過去の対戦データを用意し、それを使ってモデルを構築します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

# ダミーデータ: 過去の対戦データ
# (チーム1の得点, チーム2の得点, チーム1が勝利したかどうか（1:勝利, 0:引き分け・敗北）)
data = np.array([
    [1, 3, 0],
    [2, 2, 0],
    [3, 1, 1],
    [4, 0, 1],
    [0, 0, 0],
    [1, 1, 0],
    [2, 0, 1],
    [0, 3, 0],
    [1, 2, 0],
    [2, 2, 0],
])

# 訓練データとテストデータに分割
X = data[:, :2]  # チーム1とチーム2の得点
y = data[:, 2]   # 勝利フラグ

# 線形回帰モデルの作成と学習
model = LinearRegression()
model.fit(X, y)

# テストデータの予測
X_test = np.array([[3, 2], [1, 0]])
y_pred = model.predict(X_test)

print("予測結果:", y_pred)

# 予測結果のグラフ化
plt.figure(figsize=(8, 4))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='coolwarm', edgecolors='k', marker='o', s=100)
plt.scatter(X_test[:, 0], X_test[:, 1], c=y_pred, cmap='coolwarm', edgecolors='k', marker='x', s=100)
plt.xlabel('Team 1 Score')
plt.ylabel('Team 2 Score')
plt.title('Soccer Match Prediction')
plt.colorbar(label='Prediction')
plt.grid(True)
plt.show()

この例では、過去の対戦データからチーム1とチーム2の得点を使って、勝利したかどうかを予測しています。

テストデータとして、[3, 2]と[1, 0]の2試合の得点が与えられており、それぞれの試合の結果を予測しています。

結果をプロットすると、チームの得点が高いほど勝利しやすい傾向が見られることがわかります。

[実行結果]

注意: このサンプルデータはダミーデータであり、実際のデータには多くの要素が影響します。

実際の予測には多くの特徴量（例えば、選手の実力、試合場所、天候など）を考慮に入れる必要があります。

ソースコード解説

このコードは、線形回帰モデルを使用してサッカーの試合結果を予測する簡単な例を示しています。

詳細を以下に説明します：

1. import文:

必要なライブラリをインポートしています。
numpyは数値計算ライブラリ、matplotlib.pyplotはグラフ描画ライブラリ、sklearn.linear_model.LinearRegressionはScikit-learnの線形回帰モデルを意味します。

2. data:

ダミーデータを定義しています。
dataは10行3列の行列で、各行がサッカーの試合の情報を示しています。
1列目と2列目は、それぞれチーム1とチーム2の得点を表し、3列目はチーム1が勝利したかどうかを示すフラグ（1: 勝利、0: 引き分け・敗北）です。

3. Xとy:

Xは訓練データで、チーム1とチーム2の得点を格納しています。
yは目的変数で、チーム1の勝利フラグを格納しています。

4. model:

線形回帰モデルを作成します。
LinearRegression()で線形回帰オブジェクトを作成し、modelに代入します。

5. model.fit(X, y):

Xとyを使って線形回帰モデルを学習させます。
これにより、訓練データを元にモデルのパラメータ（重みと切片）が最適化されます。

6. X_testとy_pred:

テストデータであるX_testに対して、学習済みのモデルで予測を行います。
model.predict(X_test)で予測値を取得し、y_predに代入します。

7. plt.scatter:

Xとyの散布図と、テストデータX_testと予測値y_predの散布図を描画します。
各チームの得点をx軸とy軸にプロットし、c引数でyとy_predの値に応じて色を変え、勝利フラグによって点の形状を変えています。

8. plt.xlabel, plt.ylabel, plt.title:

x軸、y軸、タイトルのラベルを設定します。

9. plt.colorbar:

予測値の色に対応するカラーバーを表示します。

10. plt.grid:

グリッドを表示します。

11. plt.show():

グラフを表示します。

このコードでは、ダミーデータを使って線形回帰モデルを学習させ、チーム1とチーム2の得点から勝利フラグを予測する例を示しています。

実際のデータに応じて、特徴量や目的変数を適切に設定して、より高度な予測モデルを構築することができます。

金融不正取引検出

金融取引の不正行為を検出する問題は、クラス不均衡なデータセットを扱うことが一般的です。

ここでは、scikit-learnを使用してランダムフォレストを適用して不正行為を検出する例を示します。

まず、ダミーのデータを用意します。

不正行為は通常レアケースなので、不正行為の例が多く含まれるデータを生成します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, plot_confusion_matrix

# ダミーのデータを生成（0: 正常取引, 1: 不正取引）
np.random.seed(42)
num_samples = 1000
data = {
    '取引金額': np.random.normal(loc=100, scale=20, size=num_samples),
    '不正行為': np.random.randint(0, 2, num_samples)
}
df = pd.DataFrame(data)

# データを特徴量（X）とターゲット（y）に分割
X = df.drop(columns=['不正行為'])
y = df['不正行為']

# データをトレーニングセットとテストセットに分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

次に、ランダムフォレストモデルをトレーニングし、テストデータを用いて予測を行います。

1
2
3
4
5
6
7
8
9
10

# ランダムフォレストモデルの作成とトレーニング
rf_model = RandomForestClassifier(random_state=42)
rf_model.fit(X_train, y_train)

# テストデータを使った予測
y_pred = rf_model.predict(X_test)

# 正解率の評価
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")

最後に、混同行列をグラフ化して結果を分かりやすく表示します。

1
2
3
4
5
6
7
8

# 混同行列の作成
conf_matrix = confusion_matrix(y_test, y_pred)

# 混同行列のグラフ化
plt.figure(figsize=(6, 4))
plot_confusion_matrix(rf_model, X_test, y_test, cmap=plt.cm.Blues, display_labels=['normal', 'abnormal'])
plt.title('Confusion Matrix')
plt.show()

これにより、ランダムフォレストを用いて不正行為の検出が行われます。

混同行列は、実際のクラスと予測されたクラスの対応を視覚化するのに役立ちます。

不正行為の検出はクラス不均衡な問題なので、適切な評価指標（Precision、Recall、F1-scoreなど）の使用が重要です。

[実行結果]

ソースコード解説

処理の詳細は以下の通りです。

1. ダミーデータの生成:

• np.random.normal(loc=100, scale=20, size=num_samples)により、平均が100、標準偏差が20の正規分布に従う取引金額データが生成されます。
• np.random.randint(0, 2, num_samples)により、0と1からなる不正行為のデータ（0が正常取引、1が不正取引）が生成されます。
• dfには、取引金額と不正行為のデータが含まれたDataFrameが格納されます。

2. データの分割:

• train_test_splitを使用して、データセットをトレーニングセットとテストセットに分割します。
  ここでは、トレーニングセットが80％、テストセットが20％になるように分割しています。

3. モデルのトレーニングと予測:

• RandomForestClassifierを使用して、ランダムフォレストモデルを作成します。
  ランダムフォレストは、複数の決定木を組み合わせるアンサンブル学習の一種です。
• rf_model.fit(X_train, y_train)により、トレーニングデータを使用してモデルをトレーニングします。
• rf_model.predict(X_test)により、テストデータを使って不正行為を予測します。

4. 正解率の評価:

• accuracy_score(y_test, y_pred)により、テストデータの予測結果（y_pred）と真のラベル（y_test）を比較し、正解率を計算します。
• 正解率は、予測が全体のテストデータのうちどれだけ正確に分類されたかを示す指標です。

5. 混同行列のグラフ化:

• confusion_matrix(y_test, y_pred)により、テストデータを使って作成した予測結果と真のラベルを用いて混同行列が作成されます。
• plot_confusion_matrixを使用して混同行列をグラフ化し、実際のクラスと予測されたクラスの対応を視覚化します。

このようにして、ランダムフォレストモデルを使用して不正行為を検出し、評価指標を用いてモデルの性能を評価しています。

データの性質や使用するアルゴリズムによっては、他の評価指標（Precision、Recall、F1-scoreなど）を使うことが適切な場合もあります。

また、実際の運用ではさまざまな前処理やモデルチューニングが必要になることを考慮してください。

宗教選択予想

宗教の例題として、ある地域の人々の宗教信仰に関するデータを使って、その要因から宗教の選択を予測する多クラス分類問題を考えてみましょう。

具体的には、年齢、性別、家族の宗教、教育レベルなどを特徴量とし、宗教をカテゴリで表すターゲットを予測します。

まずは、scikit-learnのライブラリをインポートします。

1
2
3
4
5
6
7

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_multilabel_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

次に、架空の宗教データを作成します。

1
2
3
4
5
6
7
8
9

# 架空の宗教データを生成
X, y = make_multilabel_classification(n_samples=500, n_features=4, n_classes=5, n_labels=2, random_state=42)

# 特徴量のスケーリング
scaler = StandardScaler()
X = scaler.fit_transform(X)

# データをトレーニング用とテスト用に分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

次に、K近傍法（K-Nearest Neighbors）を使って多クラス分類モデルを構築し、トレーニングデータを用いて学習させます。

1
2
3
4
5

# K近傍法のモデルを初期化
knn = KNeighborsClassifier(n_neighbors=5)

# モデルをトレーニングデータで学習
knn.fit(X_train, y_train)

モデルを学習させた後は、テストデータを用いて予測を行い、性能を評価してみましょう。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# テストデータを用いて予測
y_pred = knn.predict(X_test)

# 正解率を計算
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")

# 分類レポートを表示
print("Classification Report:")
print(classification_report(y_test, y_pred))

# 混同行列を表示
print("Confusion Matrix:")
print(confusion_matrix(y_test.argmax(axis=1), y_pred.argmax(axis=1)))

最後に、結果をグラフ化してみます。

宗教が5つのカテゴリに分かれるため、t-SNE（t-distributed Stochastic Neighbor Embedding）を使って特徴量を2次元に圧縮し、散布図として表示します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

from sklearn.manifold import TSNE

# t-SNEを使って特徴量を2次元に圧縮
tsne = TSNE(n_components=2, random_state=42)
X_tsne = tsne.fit_transform(X)

# 散布図を描画
plt.figure(figsize=(8, 6))
for i in range(5):
    plt.scatter(X_tsne[y[:, i] == 1, 0], X_tsne[y[:, i] == 1, 1], label=f'Religion {i+1}')
plt.legend()
plt.xlabel('t-SNE Dimension 1')
plt.ylabel('t-SNE Dimension 2')
plt.title('t-SNE Visualization - Religious Affiliation')
plt.show()

これにより、宗教の要因から宗教の選択を予測する多クラス分類問題を解くためのK近傍法モデルを構築し、性能評価とともに宗教の選択を2次元散布図で可視化しました。

ただし、実際のデータではさまざまな要因が複雑に絡み合うため、より多くの特徴量やより複雑なモデルを検討する必要があるかもしれません。

[実行結果]

ソースコード解説

このコードは、架空の宗教データを生成し、K近傍法（K-Nearest Neighbors）を使って多クラス分類モデルを構築し、その性能を評価する一連の処理を行っています。

また、t-SNEを用いて特徴量を2次元に圧縮し、宗教の選択を可視化しています。

具体的な処理について説明します。

1. 架空の宗教データの生成

make_multilabel_classification関数を使って、架空の宗教データを生成しています。
n_samplesでサンプル数、n_featuresで特徴量の数、n_classesでクラス数、n_labelsで各サンプルにおけるラベルの数（多クラス分類の場合は1以上）を指定しています。

2. 特徴量のスケーリング

StandardScalerを使って特徴量をスケーリングしています。
スケーリングを行うことで、特徴量の範囲を揃え、モデルの学習を安定化させることができます。

3. データの分割

train_test_splitを使って、トレーニングデータとテストデータにデータを分割しています。
トレーニングデータはモデルの学習に使用し、テストデータはモデルの性能評価に使用します。
test_sizeでテストデータの割合を指定します。

4. K近傍法モデルの初期化と学習

KNeighborsClassifierを使ってK近傍法モデルを初期化し、トレーニングデータを用いてモデルを学習させています。
n_neighborsで近傍点の数を指定します。

5. テストデータを用いた予測と評価

学習したK近傍法モデルを使って、テストデータの特徴量から宗教の選択を予測します。
予測結果と正解データを用いて、正解率、分類レポート、混同行列を計算し、結果を表示します。

6. t-SNEによる可視化

TSNEを使って特徴量を2次元に圧縮します。
次元圧縮を行うことで、多次元の特徴量を2次元にプロットし、可視化します。
散布図を描画し、各クラスごとに色分けして宗教の選択を可視化しています。

このコードは、架空の宗教データを使って多クラス分類モデルを構築し、その性能評価と特徴量の可視化を行っているものです。

ただし、架空のデータであるため、実際のデータに対してはより多くの試行と評価が必要です。

結果解説

この結果は、多クラス分類モデル（K近傍法）による宗教の選択の予測の評価結果です。

1. Accuracy（正解率）: 0.30

• 正解率は、全体の予測がどれだけ正確だったかを示す指標で、0から1までの値を取ります。
  この結果では、30%の正解率が得られています。
  つまり、全体の予測のうち、30%が正しく宗教の選択を予測できているということを意味します。

2. Classification Report（分類レポート）:

• 分類レポートは、各クラスごとに、precision（適合率）、recall（再現率）、f1-score（F1スコア）、support（サポート数）の評価指標を示しています。
• precision: 正例と予測したサンプルのうち、実際に正例だった割合を示します。
  値が高いほど、偽陽性（誤って正と予測した場合）が少なくなります。
• recall: 実際の正例のうち、正しく正例と予測できた割合を示します。
  値が高いほど、偽陰性（誤って負と予測した場合）が少なくなります。
• f1-score: 適合率と再現率の調和平均であり、両者をバランスよく考慮した指標です。
  値が高いほど、適合率と再現率がバランス良く高いことを示します。
• support: 各クラスのサンプル数を示します。

3. Confusion Matrix（混同行列）:

• 混同行列は、予測結果と実際のラベルの対応を示す行列です。行が実際のラベル、列が予測結果を表します。
• 行列の (i, j) の要素は、実際のラベルが i であり、予測結果が j であったサンプル数を表します。

この結果を見ると、モデルの性能はあまり高くないことがわかります。

正解率が30%と低いため、全体的な予測があまり精度よくありません。

各クラスの適合率、再現率、f1-scoreを見ると、クラスごとにばらつきがあります。
特にクラス4の適合率、再現率、f1-scoreは低く、このクラスの予測が困難であることが示唆されます。

これらの結果を元にモデルの改善点を考えると、特徴量の選択や追加、モデルのハイパーパラメータの調整、より複雑なモデルの検討などが考えられます。

実際のデータに対しては、より多くの試行と評価が必要です。

アナフィラキシー

アナフィラキシーに関する例題として、特定の症状やアレルギーの情報を使用して、ある人がアナフィラキシーを経験するかどうかを予測する二値分類タスクを考えます。

この例題では、scikit-learnを使用してランダムフォレストモデルを構築し、その結果をグラフ化します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, roc_curve, roc_auc_score

# 乱数のシードを設定（再現性のため）
np.random.seed(42)

# サンプルデータの件数
num_samples = 100

# ランダムなサンプルデータを生成
age = np.random.randint(18, 80, num_samples)
gender = np.random.choice(['男性', '女性'], num_samples)
allergy_symptom_1 = np.random.randint(0, 2, num_samples)
allergy_symptom_2 = np.random.randint(0, 2, num_samples)
allergy_symptom_3 = np.random.randint(0, 2, num_samples)
anaphylaxis_experience = np.random.randint(0, 2, num_samples)

# データフレームに変換
data = pd.DataFrame({
    '年齢': age,
    '性別': gender,
    'アレルギー症状1': allergy_symptom_1,
    'アレルギー症状2': allergy_symptom_2,
    'アレルギー症状3': allergy_symptom_3,
    'アナフィラキシー経験': anaphylaxis_experience
})

# カテゴリカル変数をダミー変数化
data = pd.get_dummies(data, columns=['性別'])

# 特徴量とラベルに分割
X = data.drop('アナフィラキシー経験', axis=1)
y = data['アナフィラキシー経験']

# データをトレーニングセットとテストセットに分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# ランダムフォレストモデルの構築
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)

# テストデータで予測
y_pred = model.predict(X_test)

# 正解率の計算
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)

# 混同行列の作成
conf_matrix = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(conf_matrix)

# ROC曲線とAUCの計算
y_prob = model.predict_proba(X_test)[:, 1]
fpr, tpr, _ = roc_curve(y_test, y_prob)
roc_auc = roc_auc_score(y_test, y_prob)
print("AUC:", roc_auc)

# 結果のグラフ化
plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, color='b', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='gray', linestyle='--')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic (ROC)')
plt.legend(loc='lower right')
plt.show()

このコードでは、ランダムフォレストモデルを構築し、テストデータで予測結果を評価しています。

また、ROC曲線とAUCを計算してモデルの予測性能を評価し、結果をグラフ化しています。

上記のコードを実行すると、ランダムなサンプルデータに対するモデルの予測性能を確認することができます。

[実行結果]

ソースコード解説

このコードは、アナフィラキシーを経験するかどうかを予測するためのランダムフォレストモデルを構築し、その性能を評価して可視化するためのPythonコードです。

以下に各部分の説明を提供します：

1. ライブラリのインポート:

• import pandas as pd:
  pandasライブラリをインポートし、データを扱うためのデータフレームを作成するために使用します。
• import numpy as np:
  NumPyライブラリをインポートし、数値計算やランダムなサンプルデータの生成に使用します。
• import matplotlib.pyplot as plt:
  Matplotlibライブラリをインポートし、グラフを描画するために使用します。
• from sklearn.model_selection import train_test_split:
  scikit-learnのtrain_test_split関数をインポートし、データをトレーニングセットとテストセットに分割するために使用します。
• from sklearn.ensemble import RandomForestClassifier:
  scikit-learnのRandomForestClassifierクラスをインポートし、ランダムフォレストモデルを構築するために使用します。
• from sklearn.metrics import accuracy_score, confusion_matrix, roc_curve, roc_auc_score:
  scikit-learnの各種評価指標をインポートし、モデルの性能評価に使用します。

2. サンプルデータの生成:

• np.random.seed(42):
  乱数のシードを設定して、再現性を確保します。
• num_samples = 100:
  サンプルデータの件数を100件として設定します。
• age, gender, allergy_symptom_1, allergy_symptom_2, allergy_symptom_3, anaphylaxis_experience:
  乱数を使用して、年齢や性別、アレルギー症状の有無、アナフィラキシーの経験をランダムに生成します。

3. サンプルデータをデータフレームに変換:

• data = pd.DataFrame({ ... }):
  ランダムに生成したサンプルデータを辞書形式でデータフレームに変換します。
• pd.get_dummies(data, columns=['性別']):
  性別のようなカテゴリカル変数をダミー変数化して、特徴量のデータを数値データに変換します。

4. データの前処理:

• X = data.drop('アナフィラキシー経験', axis=1):
  特徴量を抽出します。
• y = data['アナフィラキシー経験']:
  ラベル（アナフィラキシー経験の有無）を抽出します。
• X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42):
  データをトレーニングセットとテストセットに分割します。

5. ランダムフォレストモデルの構築と評価:

• model = RandomForestClassifier(random_state=42):
  ランダムフォレストモデルを構築します。
• model.fit(X_train, y_train):
  モデルをトレーニングデータに適合させます。
• y_pred = model.predict(X_test):
  テストデータで予測を行います。
• accuracy = accuracy_score(y_test, y_pred):
  正解率を計算します。
• conf_matrix = confusion_matrix(y_test, y_pred):
  混同行列を作成します。
• y_prob = model.predict_proba(X_test)[:, 1]:
  テストデータに対するアナフィラキシーの経験の確率を予測します。
• fpr, tpr, _ = roc_curve(y_test, y_prob):
  ROC曲線を計算します。
• roc_auc = roc_auc_score(y_test, y_prob):
  AUCを計算します。

6. 結果のグラフ化:

• plt.plot(fpr, tpr, ... ):
  ROC曲線をグラフ化します。
• plt.xlabel('False Positive Rate'):
  X軸のラベルを設定します。
• plt.ylabel('True Positive Rate'):
  Y軸のラベルを設定します。
• plt.title('Receiver Operating Characteristic (ROC)'):
  グラフのタイトルを設定します。
• plt.legend(loc='lower right'):
  グラフに凡例を表示します。
• plt.show():
  グラフを表示します。

これにより、ランダムフォレストモデルの性能評価が実行され、ROC曲線が可視化されます。

結果解説

結果を詳しく説明します。

1. 正解率 (Accuracy): 0.35

正解率は、モデルが全体の予測において正確だった割合を示します。
この値は0から1の間で取ることができます。
今回の結果では、正解率が0.35（または35%）となっています。
つまり、テストセットに対してモデルの予測が正確だった割合は35%であることを意味します。

2. 混同行列 (Confusion Matrix):

混同行列は、モデルの予測結果と実際の真のラベルとの一致状況を示す行列です。
この行列は4つの要素から構成されます。

• 真陽性 (True Positive, TP): 正しくアナフィラキシーを経験したと予測されたサンプル数 (5)
• 偽陽性 (False Positive, FP): アナフィラキシーを経験していないのに誤ってアナフィラキシーを経験したと予測されたサンプル数 (7)
• 真陰性 (True Negative, TN): 正しくアナフィラキシーを経験していないと予測されたサンプル数 (2)
• 偽陰性 (False Negative, FN): アナフィラキシーを経験したのに誤ってアナフィラキシーを経験していないと予測されたサンプル数 (6)

今回の混同行列の結果は以下のようになっています：

1
2

[[2 7]
 [6 5]]

3. AUC (Area Under the Curve): 0.43434343434343436

AUCは、ROC曲線（Receiver Operating Characteristic curve）の下の面積を示す値です。
ROC曲線は、真陽性率（True Positive Rate, TPR）に対する偽陽性率（False Positive Rate, FPR）の変化を表現します。

AUCは、モデルの分類性能を評価する指標で、0から1の間の値を取ります。
AUCが0.5に近いほど、モデルの分類性能がランダムに近くなります。
今回の結果では、AUCが約0.43であるため、モデルの性能はランダムに近いと評価されます。

この結果から、現在のモデルはアナフィラキシーの経験を予測するにはあまり精度が高くなく、改善の余地があると考えられます。

モデルの性能向上のためには、特徴量の選択やエンジニアリング、ハイパーパラメータの調整、より大きなデータセットの使用などが考えられます。

物流

物流の例題として、「ある企業が複数の倉庫から商品を顧客へ配送する場合の最適なルート設計」を考えてみましょう。

この問題は、倉庫と顧客の位置情報を元に、最短距離を通るルートを見つける問題として解釈できます。

ここでは、scikit-learnのKMeansクラスタリングアルゴリズムを使用して、倉庫と顧客をクラスタリングし、それぞれのクラスタの重心（倉庫の位置）とクラスタ内の各顧客との距離を求める方法を示します。

なお、本来の物流問題はより複雑であり、現実的なソリューションにはさまざまな要素（ルートの容量、交通状況、顧客の要求など）が含まれますが、ここでは単純化した例題を取り扱います。

以下はPythonコードでの例示です。

なお、numpyとmatplotlibも使用しますので、事前にインストールしてください。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

# データの作成（仮想的な倉庫と顧客の位置情報）
np.random.seed(0)
n_warehouses = 3
n_customers = 10
data = np.vstack((
    np.random.rand(n_warehouses, 2) * 10,  # 倉庫の位置情報 (x, y)
    np.random.rand(n_customers, 2) * 10   # 顧客の位置情報 (x, y)
))

# KMeansクラスタリング
n_clusters = n_warehouses
kmeans = KMeans(n_clusters=n_clusters)
kmeans.fit(data)
centers = kmeans.cluster_centers_  # 倉庫の位置

# グラフ化
plt.scatter(data[:, 0], data[:, 1], c=kmeans.labels_, cmap='rainbow')
plt.scatter(centers[:, 0], centers[:, 1], marker='X', s=200, c='black', label='Warehouses')
plt.legend()
plt.title('Warehouse Location and Customer Clustering')
plt.xlabel('X-coordinate')
plt.ylabel('Y-coordinate')
plt.grid(True)
plt.show()

このコードでは、倉庫と顧客の位置情報をランダムに生成し、KMeansアルゴリズムを使用してクラスタリングしています。

グラフでは、倉庫と顧客を異なる色でプロットし、倉庫の位置を「X」マークで示しています。

[実行結果]

ソースコード解説

このコードは、Pythonを使用して物流の例題を扱い、scikit-learnとmatplotlibを使ってデータのクラスタリングとグラフ化を行っています。

以下、各部分の詳細な説明を行います。

1. ライブラリのインポート:

1
2
3

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

• numpyは数値計算を行う際の基本的なライブラリです。
• matplotlib.pyplotはデータの可視化のためのライブラリで、グラフのプロットに使用します。
• sklearn.cluster.KMeansは、scikit-learnライブラリのKMeansクラスタリングアルゴリズムを提供します。

2. データの作成:

1
2
3
4
5
6
7

np.random.seed(0)
n_warehouses = 3
n_customers = 10
data = np.vstack((
    np.random.rand(n_warehouses, 2) * 10,  # 倉庫の位置情報 (x, y)
    np.random.rand(n_customers, 2) * 10   # 顧客の位置情報 (x, y)
))

• np.random.seed(0)は、ランダムなデータを生成する際に再現性を持たせるための乱数シードを設定しています。
• n_warehousesは倉庫の数を表し、n_customersは顧客の数を表します。
• np.random.rand(n_warehouses, 2) * 10とnp.random.rand(n_customers, 2) * 10は、それぞれ倉庫と顧客の位置情報を2次元のランダムな座標（x, y）で生成しています。
  * 10は生成される座標を0から10の範囲にスケーリングするためです。

3. KMeansクラスタリング:

1
2
3
4

n_clusters = n_warehouses
kmeans = KMeans(n_clusters=n_clusters)
kmeans.fit(data)
centers = kmeans.cluster_centers_  # 倉庫の位置

• n_clustersには倉庫の数が設定されています。
  これは、KMeansアルゴリズムがデータを指定されたクラスタ数に分割するために使用されます。
• KMeans(n_clusters=n_clusters)でKMeansクラスタリングのインスタンスを作成し、fitメソッドでデータをクラスタリングします。
• kmeans.cluster_centers_は、クラスタの重心（倉庫の位置）を表すNumPy配列として取得されます。

4. グラフ化:

1
2
3
4
5
6
7
8

plt.scatter(data[:, 0], data[:, 1], c=kmeans.labels_, cmap='rainbow')
plt.scatter(centers[:, 0], centers[:, 1], marker='X', s=200, c='black', label='Warehouses')
plt.legend()
plt.title('Warehouse Location and Customer Clustering')
plt.xlabel('X-coordinate')
plt.ylabel('Y-coordinate')
plt.grid(True)
plt.show()

• plt.scatter(data[:, 0], data[:, 1], c=kmeans.labels_, cmap='rainbow')は、倉庫と顧客の位置情報を散布図としてプロットします。
  c=kmeans.labels_により、各データポイントのクラスタラベルを表す色が自動的に割り当てられます。
• plt.scatter(centers[:, 0], centers[:, 1], marker='X', s=200, c='black', label='Warehouses')は、倉庫の位置情報を「X」マークでプロットします。
• plt.legend()で凡例を表示します。
  ここでは、「Warehouses」というラベルを使っています。
• plt.title('Warehouse Location and Customer Clustering')、plt.xlabel('X-coordinate')、plt.ylabel('Y-coordinate')は、それぞれグラフのタイトルとx軸、y軸のラベルを設定します。
• plt.grid(True)でグリッドを表示します。
• plt.show()は、作成したグラフを表示します。

これにより、倉庫と顧客の位置情報をクラスタリングして、それぞれの位置を可視化することができます。

結果解説

上記の例題では、3つの倉庫と10人の顧客の位置情報を用いてKMeansクラスタリングを行いました。
結果として得られたグラフを解釈します。

グラフでは、データポイントが2次元空間上にプロットされており、異なる色で示されています。

ここで、色の違いはKMeansによって割り当てられたクラスタを表しています。

クラスタ数は倉庫の数に設定しましたので、3つのクラスタがあります。

また、Xマークで示されたデータポイントが各クラスタの中心点を表しています。

これは倉庫の位置を示しており、3つの倉庫がそれぞれのクラスタ内で最も重要な位置を占めていることが分かります。

結果の解釈:

1. 倉庫の位置:

Xマークで示されている3つの点が、倉庫の位置を表しています。
これらの点は、クラスタリングによってデータの中心に近い位置に配置されているため、最適な倉庫の位置となります。
これらの倉庫が、顧客への商品配送の拠点として選ばれるでしょう。

2. 顧客の位置:

グラフ上のXマーク以外のデータポイントは、顧客の位置を表しています。
これらの点は、それぞれ最も近い倉庫に配送されることになります。
異なる色のクラスタに属する顧客は、異なる倉庫に配送されることが予想されます。

この結果を元に、企業は倉庫と顧客の位置を適切に設計し、各倉庫からの最適なルートを計画することができます。

ただし、実際の物流問題ではさらに多くの要素を考慮する必要があるため、より複雑なアルゴリズムや手法を用いて最適解を求めることが一般的です。

ユーザー行動予測

ユーザー行動予測の例題として、「オンラインショッピングサイトのユーザーが特定の商品を購入するかどうかを予測する」という問題を取り上げます。

これは二値分類の問題であり、ユーザーの属性や過去の行動履歴を元に、購入行動の有無を予測することが目標です。

ここでは、サンプルとしてランダムに生成したデータを使ってscikit-learnのロジスティック回帰モデルを使用して予測を行います。

まずは必要なライブラリをインポートし、データを生成しましょう。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

# データの生成
np.random.seed(42)
num_samples = 200
user_attributes = np.random.rand(num_samples, 2)
user_behavior = np.random.randint(0, 2, num_samples)

# データを学習用とテスト用に分割
X_train, X_test, y_train, y_test = train_test_split(user_attributes, user_behavior, test_size=0.2, random_state=42)

次に、ロジスティック回帰モデルを学習させ、テストデータでの予測を行います。

1
2
3
4
5

# ロジスティック回帰モデルの学習と予測
model = LogisticRegression(random_state=42)
model.fit(X_train, y_train)

y_pred = model.predict(X_test)

予測の性能を評価するために、正解率や混同行列を計算してみましょう。

1
2
3
4
5
6
7
8
9
10
11
12
13

# 正解率の計算
accuracy = accuracy_score(y_test, y_pred)
print("正解率:", accuracy)

# 混同行列の表示
conf_matrix = confusion_matrix(y_test, y_pred)
print("混同行列:")
print(conf_matrix)

# 分類レポートの表示
class_report = classification_report(y_test, y_pred)
print("分類レポート:")
print(class_report)

最後に、結果をグラフ化してみましょう。データ点を散布図で表示し、モデルが予測した境界線を描画します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# グラフ化
plt.figure(figsize=(8, 6))
plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=plt.cm.Paired, label="Training Data")
plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=plt.cm.Paired, marker='x', label="Test Data")

# 境界線の描画
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()

# メッシュグリッドの生成
xx = np.linspace(xlim[0], xlim[1], 100)
yy = np.linspace(ylim[0], ylim[1], 100)
XX, YY = np.meshgrid(xx, yy)
xy = np.vstack([XX.ravel(), YY.ravel()]).T
Z = model.decision_function(xy).reshape(XX.shape)

# 境界線を描画
ax.contour(XX, YY, Z, levels=[0], linewidths=2, colors='red')

plt.xlabel('Attribute 1')
plt.ylabel('Attribute 2')
plt.title('User Behavior Prediction')
plt.legend()
plt.show()

このコードは、ユーザー行動予測のためのロジスティック回帰モデルを使用して、属性情報を元に購入行動の有無を予測し、その結果をグラフで視覚化しています。

[実行結果]

ソースコード解説

このソースコードは、ユーザー行動予測の問題を解くために、ランダムに生成したデータを使ってロジスティック回帰モデルを学習し、その性能を評価するプログラムです。

以下に各部分の詳細を説明します。

1. データの生成:

ユーザー行動予測のためのデータをランダムに生成します。
np.random.rand関数を使って、2つの属性を持つ200個のサンプル (num_samples = 200) を生成し、それぞれのサンプルに対して0または1のランダムなラベルを割り当てます。user_attributesは2つの属性を持つ特徴量の行列であり、user_behaviorは0または1のラベルを持つベクトルです。

2. データの学習とテストへの分割:

train_test_split関数を使って、生成したデータを学習データ (X_train, y_train) とテストデータ (X_test, y_test) に分割します。
ここでは、全体の20%をテストデータとして使用しています。

3. ロジスティック回帰モデルの学習と予測:

LogisticRegressionクラスを用いて、ロジスティック回帰モデルを作成し、学習データを使ってモデルを学習します。
fitメソッドによりモデルが学習されます。
その後、テストデータを使ってモデルの予測を行い、予測結果をy_predに格納します。

4. 正解率の計算:

accuracy_score関数を使って、モデルの予測結果と真のラベル (y_test) を比較し、正解率を計算します。
正解率は全てのサンプルのうち、正しく予測できたサンプルの割合を示します。

5. 混同行列の表示:

confusion_matrix関数を使って、モデルの予測結果と真のラベルを元に混同行列を計算します。
混同行列は、予測がどれだけ正確であるかを評価する際に有用な情報を提供します。

6. 分類レポートの表示:

classification_report関数を使って、適合率 (precision)、再現率 (recall)、F1スコア (F1-score)、およびサポート (support) を含む分類レポートを表示します。
これらの指標は、各クラスごとにモデルの性能を評価するために使われます。

7. グラフ化:

matplotlibを使って、学習データとテストデータの散布図を表示します。
また、ロジスティック回帰モデルが予測した境界線を赤色で描画しています。
これにより、モデルがどのようにデータを分類しているかを視覚的に理解できます。

最終的に、このコードはランダムに生成したデータを使ってロジスティック回帰モデルを学習し、モデルの性能を評価するための各種指標を表示し、データの可視化を行っています。

これにより、ユーザー行動予測モデルの性能を把握することができます。

結果解説

以下にそれぞれの評価指標について詳しく説明します。

1. 正解率 (Accuracy):

正解率は、全てのサンプルのうち、正しく分類されたサンプルの割合を示します。
この場合の正解率は0.525 (または 52.5%) です。正解率が高いほど、モデルの予測精度が高いことを意味します。
ただし、この値だけでモデルの性能を判断するのは注意が必要で、他の指標と併せて評価することが重要です。

2. 混同行列 (Confusion Matrix):

混同行列は、モデルが予測したクラスと真のクラスのペアを示す行列です。
この混同行列は2x2の行列で、以下のように解釈されます:

• 左上のセル (True Negative): 13個のサンプルがクラス0と予測され、実際にクラス0であった。
• 右上のセル (False Positive): 11個のサンプルがクラス1と予測され、実際はクラス0であった。
• 左下のセル (False Negative): 8個のサンプルがクラス0と予測され、実際はクラス1であった。
• 右下のセル (True Positive): 8個のサンプルがクラス1と予測され、実際にクラス1であった。

3. 分類レポート (Classification Report):

分類レポートは、クラスごとの適合率 (precision)、再現率 (recall)、F1スコア (F1-score)、およびサポート (support) を示す表です。

• 適合率 (Precision):
  正しく分類された陽性サンプル (True Positive) の割合を示します。
  クラス0の適合率は0.62であり、クラス1の適合率は0.42です。
  適合率が高いほど、陽性と予測されたサンプルが実際に陽性である確率が高いことを意味します。

• 再現率 (Recall):
  実際に陽性のサンプルのうち、正しく分類された割合を示します。
  クラス0の再現率は0.54であり、クラス1の再現率は0.50です。
  再現率が高いほど、実際に陽性であるサンプルを見逃さずに予測できることを意味します。

• F1スコア (F1-score):
  適合率と再現率の調和平均です。
  F1スコアは、適合率と再現率のバランスを取る指標として使われます。
  クラス0のF1スコアは0.58であり、クラス1のF1スコアは0.46です。

• サポート (Support):
  各クラスに属するサンプルの数を示します。
  クラス0には24個のサンプルがあり、クラス1には16個のサンプルがあります。

総合的に見ると、このユーザー行動予測モデルは、精度やF1スコアなどの評価指標が比較的低いため、改善の余地があると言えます。

モデルの性能を向上させるためには、より適切な特徴量の選択やモデルの調整、データの前処理などが必要かもしれません。

貿易関係ネットワーク分析

貿易関係ネットワーク分析の例題として、いくつかの国とそれらの国々間の貿易量を示す仮想的なデータを用いて、scikit-learnでネットワーク分析を行います。

ここでは、ネットワークの可視化にはNetworkXとMatplotlibを使用します。

まずは以下のスクリプトを使ってデータを生成してみましょう：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

Copy code
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt

# 仮想的な貿易量のデータを作成
countries = ['USA', 'China', 'Japan', 'Germany', 'UK']
trade_data = np.array([[0, 100, 50, 80, 20],
                       [100, 0, 70, 40, 10],
                       [50, 70, 0, 60, 30],
                       [80, 40, 60, 0, 50],
                       [20, 10, 30, 50, 0]])

# ネットワークの可視化用のグラフを作成
G = nx.from_numpy_matrix(trade_data, create_using=nx.Graph())

# ノードに国名を割り当てる
node_labels = {i: countries[i] for i in range(len(countries))}

# グラフを描画
plt.figure(figsize=(8, 6))
pos = nx.spring_layout(G, seed=42)  # ノードの位置を決定
nx.draw(G, pos, with_labels=True, labels=node_labels, node_size=1000, node_color='skyblue', font_size=10)
edge_labels = {(i, j): trade_data[i][j] for i in range(len(countries)) for j in range(len(countries)) if trade_data[i][j] > 0}
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8)

plt.title('Trade Relationship Network')
plt.show()

このスクリプトでは、仮想的な貿易量のデータを作成し、それをネットワークXのグラフに変換しています。

ノードは各国を表し、エッジはそれらの国々間の貿易量を示しています。

ノードの色が青く、ノード間のエッジには貿易量が表示されます。

実行すると、可視化された貿易関係のネットワークが表示されますす。

ネットワークの構造を確認し、各国の貿易関係を分析することができます。

[実行結果]

なお、この例ではデータを手動で作成していますが、実際の貿易データを用いて同様のネットワーク分析を行うことも可能です。

顧客離反予測（チャーン予測）

顧客離反予測（チャーン予測）の例題として、以下のようなシナリオを考えます：

あるテレコム会社があり、顧客の情報と過去の利用データが得られています。

これを使って、顧客が離反するかどうかを予測し、リテンション戦略を立てたいとします。

scikit-learnを使ってロジスティック回帰モデルを構築し、結果をグラフ化してみましょう。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, roc_auc_score, roc_curve

# ダミーデータを生成するための関数（仮想的なデータです）
def generate_dummy_data(n_samples=1000):
    np.random.seed(42)
    age = np.random.normal(40, 10, n_samples)
    usage_months = np.random.randint(1, 25, n_samples)
    monthly_expense = np.random.normal(100, 50, n_samples)
    churn = np.random.randint(0, 2, n_samples)

    data = pd.DataFrame({'Age': age, 'UsageMonths': usage_months, 'MonthlyExpense': monthly_expense, 'Churn': churn})
    return data

# ダミーデータを生成
data = generate_dummy_data()

# 特徴量とターゲットに分割
X = data.drop('Churn', axis=1)
y = data['Churn']

# 訓練データとテストデータに分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# ロジスティック回帰モデルを構築
model = LogisticRegression()
model.fit(X_train, y_train)

# テストデータを用いて予測
y_pred = model.predict(X_test)
y_prob = model.predict_proba(X_test)[:, 1]  # 予測確率を取得

# ROC曲線をプロットして結果を可視化
fpr, tpr, thresholds = roc_curve(y_test, y_prob)
roc_auc = roc_auc_score(y_test, y_prob)

plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, color='blue', lw=2, label='ROC curve (AUC = {:.2f})'.format(roc_auc))
plt.plot([0, 1], [0, 1], color='gray', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic (ROC) Curve')
plt.legend(loc='lower right')
plt.show()

上記のコードでは、ダミーデータを作成してロジスティック回帰モデルを構築し、ROC曲線をプロットしています。

ROC曲線はモデルの性能を評価する際によく用いられる指標で、AUC (Area Under the Curve) の値が高いほど優れた予測モデルと言えます。

[実行結果]

ソースコード解説

上記のコードは、ロジスティック回帰モデルを使用して顧客離反予測（チャーン予測）を行い、その結果をROC曲線を用いて可視化しています。

以下にコードの詳細を説明します：

1. ダミーデータを生成する関数 generate_dummy_data:

   • この関数は仮想的なデータを生成するためのもので、乱数を使って顧客の年齢 (Age)、利用期間 (UsageMonths)、月間支出 (MonthlyExpense)、および離反したかどうかを表すターゲット変数 (Churn) を作成します。

2. ダミーデータの生成:

   • generate_dummy_data() 関数を呼び出して、ダミーデータを生成します。このデータは data という名前のPandas DataFrameに保存されます。

3. 特徴量とターゲットの分割:

   • X = data.drop('Churn', axis=1) で特徴量 (Age, UsageMonths, MonthlyExpense) を取得します。
   • y = data['Churn'] でターゲット変数 Churn（離反したかどうかを表すラベル）を取得します。

4. 訓練データとテストデータの分割:

   • train_test_split() を使ってデータを訓練データとテストデータに分割します。テストデータは全体の20%に設定されており、random_state=42 で乱数シードを固定して再現性を保証しています。

5. ロジスティック回帰モデルの構築と学習:

   • LogisticRegression() を使用してロジスティック回帰モデルを初期化し、fit() メソッドで訓練データに適合させます。

6. テストデータを用いた予測:

   • predict() メソッドを使用して、テストデータの特徴量を用いて離反の予測を行います。
   • predict_proba() メソッドを使用して、各テストサンプルがクラス1（離反）に属する確率を取得します。

7. ROC曲線のプロットと結果の可視化:

   • roc_curve() 関数を用いて、予測確率と真のターゲット値を用いてROC曲線のデータを取得します。
   • roc_auc_score() 関数を用いて、ROC曲線の下の面積 (AUC) を計算します。
   • plt.figure() でグラフのサイズを設定し、plt.plot() を用いてROC曲線を描画します。
   • plt.plot([0, 1], [0, 1], color='gray', lw=2, linestyle='--') は対角線を描画し、ランダムな予測の場合の参考として用います。
   • ラベル、軸の範囲、タイトルなどのグラフの詳細設定を行います。
   • 最後に plt.show() でグラフを表示します。

結果として、ROC曲線が表示されます。

この曲線は、モデルの性能評価に使用され、AUCスコアが曲線下の面積を示します。

AUCが高いほど、モデルの性能が良いとされます。

結果解説

表示されるグラフは「Receiver Operating Characteristic (ROC) Curve（受信者動作特性曲線）」です。

ROC曲線は、二値分類モデル（ここではロジスティック回帰モデル）の性能評価に用いられるグラフで、以下の要素で構成されています：

• X軸（横軸）: False Positive Rate (FPR)

  • FPRは、実際には陰性（クラス0）であるもののうち、モデルが陽性（クラス1）と誤って予測したサンプルの割合を示します。計算式は FPR = FP / (FP + TN) であり、FPは偽陽性の数、TNは真陰性の数です。

• Y軸（縦軸）: True Positive Rate (TPR) または Recall

  • TPRは、実際には陽性（クラス1）であるもののうち、モデルが陽性と正しく予測したサンプルの割合を示します。計算式は TPR = TP / (TP + FN) であり、TPは真陽性の数、FNは偽陰性の数です。

ROC曲線の解釈：

• 曲線の左下に近いほど、FPRが低く、真陰性率が高くなりますが、偽陽性率が高くなる傾向があります。
• 曲線の右上に近いほど、FPRが高く、真陽性率が高くなりますが、偽陰性率が低くなる傾向があります。

AUC (Area Under the Curve)：

• ROC曲線の下の面積をAUCと呼びます。AUCは0から1の間の値を取り、モデルの性能を評価する指標です。

AUCが1に近いほど、モデルの性能が優れていると言えます。

このグラフを見ることで、モデルの性能がどれくらい優れているかが把握できます。

AUCが高いほど、モデルの予測精度が高いと言えます。ROC曲線が左上に近いほど、優れた分類モデルと言えます。

リハビリテーション支援

リハビリテーション支援の例として、患者のリハビリテーション進捗データを使用して、適切な運動プランを提案する問題を考えます。

データには、患者の週ごとのリハビリテーションの目標と実績のデータが含まれています。

scikit-learnを使用して、患者の週ごとのリハビリテーション進捗を予測し、運動プランを提案するモデルを構築します。

まず、仮想的なデータを生成して、問題を定義します：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

# 仮想的なリハビリテーション進捗データの生成
np.random.seed(0)
weeks = np.arange(1, 11)
target_progress = np.random.randint(10, 50, size=len(weeks))
actual_progress = target_progress + np.random.randint(-5, 5, size=len(weeks))

# データフレームに格納
rehab_data = pd.DataFrame({'Week': weeks, 'Target Progress': target_progress, 'Actual Progress': actual_progress})

# データの表示
print(rehab_data)

データを生成したら、線形回帰を使用してリハビリテーション進捗を予測し、結果をグラフ化します：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 線形回帰モデルの構築
X = rehab_data['Week'].values.reshape(-1, 1)
y = rehab_data['Actual Progress'].values
model = LinearRegression()
model.fit(X, y)

# 予測した進捗データの生成
predicted_progress = model.predict(X)

# グラフ化
plt.scatter(weeks, actual_progress, label='Actual Progress', color='b')
plt.plot(weeks, predicted_progress, label='Predicted Progress', color='r')
plt.xlabel('Week')
plt.ylabel('Rehabilitation Progress')
plt.title('Rehabilitation Progress Prediction')
plt.legend()
plt.show()

このコードでは、線形回帰を用いて週ごとのリハビリテーション進捗を予測しています。

散布図で実績の進捗を青で、予測した進捗を赤で表示します。グラフを通じて、リハビリテーションの進捗を予測することができます。

実際のデータを使用する場合は、適切なデータセットを用意してください。

[実行結果]

ソースコード解説

このソースコードは、リハビリテーション支援の例として、患者のリハビリテーション進捗データを使用して、週ごとの実績の進捗を予測し、結果をグラフ化するものです。

以下、各部分の詳細な説明です：

1. import文：必要なライブラリをインポートしています。

• numpy（np）: 数値計算のためのライブラリ。
• pandas（pd）: データフレーム操作のためのライブラリ。
• matplotlib.pyplot（plt）: グラフ描画のためのライブラリ。
• LinearRegression（線形回帰モデル）: scikit-learnの線形回帰モデルを使用するためのクラス。

2. データ生成：

• np.random.seed(0): 乱数のシードを設定して再現性を持たせます。
• weeks = np.arange(1, 11): 1から10までの週の数値を生成し、weeksに代入します。
• target_progress = np.random.randint(10, 50, size=len(weeks)): 10から49までのランダムな整数をweeksの数だけ生成し、target_progressに代入します。
• actual_progress = target_progress + np.random.randint(-5, 5, size=len(weeks)): target_progressに対して、-5から5までのランダムな整数を足して、actual_progressに代入します。

3. データフレームの作成：

• pd.DataFrame: weeks、target_progress、actual_progressを列とするデータフレームrehab_dataを作成します。

4. データ表示：

• print(rehab_data): rehab_dataを表示します。生成されたリハビリテーション進捗データが表示されます。

5. 線形回帰モデルの構築：

• X = rehab_data['Week'].values.reshape(-1, 1): rehab_dataの’Week’列を入力データXとして取得し、1次元の配列から2次元の行列に変形します。
• y = rehab_data['Actual Progress'].values: rehab_dataの’Actual Progress’列をターゲットデータyとして取得します。
• model = LinearRegression(): 線形回帰モデルのインスタンスを作成します。
• model.fit(X, y): モデルをデータに適合させます（トレーニング）。

6. 予測した進捗データの生成：

• predicted_progress = model.predict(X): モデルを使用して、Xを入力として実績の進捗を予測し、predicted_progressに代入します。

7. グラフ化：

• plt.scatter(weeks, actual_progress, label='Actual Progress', color='b'): 実際の進捗を青い散布図としてプロットします。
• plt.plot(weeks, predicted_progress, label='Predicted Progress', color='r'): 予測した進捗を赤い線でプロットします。
• plt.xlabel('Week'): x軸のラベルを設定します。
• plt.ylabel('Rehabilitation Progress'): y軸のラベルを設定します。
• plt.title('Rehabilitation Progress Prediction'): グラフのタイトルを設定します。
• plt.legend(): 凡例を表示します。
• plt.show(): グラフを表示します。

最終的に、実際の進捗を青い散布図で表し、線形回帰モデルによって予測された進捗を赤い線で表すグラフが描画されます。

結果解説

線形回帰モデルを使用して実績の進捗を予測し、その結果をグラフ化しました。

実際の進捗（青の散布図）と、線形回帰モデルによる予測された進捗（赤の線）が表示されます。

結果として、赤い線が青い点に近いことから、線形回帰モデルが実績の進捗をうまく予測していることが分かります。

この例では、10週間のリハビリテーション進捗データを用いて、線形回帰モデルにより次の週の進捗を予測しています。

実際のデータを使用する場合は、より多くのデータポイントを持つデータセットを使用することで、より精度の高い予測が期待できます。

また、他の機械学習アルゴリズムを試すことも検討すると良いでしょう。