Pythonにおけるロジスティック回帰アルゴリズムの理解と実装10例

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

x = np.linspace(-10, 10, 100)
y = sigmoid(x)

plt.figure(figsize=(10, 6))
plt.plot(x, y)
plt.title('シグモイド関数')
plt.xlabel('x')
plt.ylabel('sigmoid(x)')
plt.grid(True)
plt.show()

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix
import statsmodels.api as sm

print("All libraries imported successfully!")

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
import pandas as pd

# irisデータセットの読み込み
iris = load_iris()
X = iris.data
y = iris.target

# データフレームの作成
df = pd.DataFrame(X, columns=iris.feature_names)
df['target'] = y

# データの確認
print(df.head())

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

print("訓練データのサイズ:", X_train.shape)
print("テストデータのサイズ:", X_test.shape)

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

# モデルの初期化と訓練
model = LogisticRegression(random_state=42)
model.fit(X_train, y_train)

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

# モデルの評価
accuracy = accuracy_score(y_test, y_pred)
print("モデルの精度:", accuracy)

# 詳細な評価レポート
print(classification_report(y_test, y_pred, target_names=iris.target_names))

import numpy as np

# 新しいデータの作成（仮想的なアヤメのデータ）
new_data = np.array([[5.1, 3.5, 1.4, 0.2],  # setosa
                     [6.3, 3.3, 4.7, 1.6],  # versicolor
                     [6.5, 3.0, 5.2, 2.0]]) # virginica

# 予測
predictions = model.predict(new_data)
probabilities = model.predict_proba(new_data)

# 結果の表示
for i, pred in enumerate(predictions):
    print(f"サンプル {i+1} の予測クラス: {iris.target_names[pred]}")
    print(f"クラスごとの確率: {probabilities[i]}")
    print()

# モデルの係数（特徴量の重要度）の確認
feature_importance = pd.DataFrame({'feature': iris.feature_names, 'importance': model.coef_[0]})
print("特徴量の重要度:")
print(feature_importance)

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
import statsmodels.api as sm

# irisデータセットの読み込み
iris = load_iris()
X = iris.data
y = iris.target

# 2つのクラスだけを使用（setosaとversicolor）
X = X[y != 2]
y = y[y != 2]

# 定数項の追加
X = sm.add_constant(X)

# モデルの構築
model = sm.Logit(y, X)
results = model.fit()

# 結果の表示
print(results.summary())

# p値の取得
p_values = results.pvalues
print("p値:")
print(p_values)

# オッズ比の計算
odds_ratios = np.exp(results.params)
print("\nオッズ比:")
print(odds_ratios)

# 信頼区間の計算
conf_int = results.conf_int()
conf_int_exp = np.exp(conf_int)
print("\nオッズ比の95%信頼区間:")
print(conf_int_exp)

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

# irisデータセットの読み込み
iris = load_iris()
X = iris.data
y = iris.target

# データの分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 多項ロジスティック回帰モデルの構築
multi_model = LogisticRegression(multi_class='multinomial', solver='lbfgs', random_state=42)
multi_model.fit(X_train, y_train)

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

# モデルの評価
accuracy = accuracy_score(y_test, y_pred)
print(f"モデルの精度: {accuracy:.4f}")

# 詳細な評価レポート
print("\n分類レポート:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

# 各クラスの確率予測
probabilities = multi_model.predict_proba(X_test)
print("\n最初の5サンプルの各クラスへの所属確率:")
print(pd.DataFrame(probabilities[:5], columns=iris.target_names))

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.inspection import DecisionBoundaryDisplay

# irisデータセットの読み込み（2特徴量のみを使用）
iris = load_iris()
X = iris.data[:, [0, 2]]  # がく片の長さと花弁の長さを使用
y = iris.target

# ロジスティック回帰モデルの構築
model = LogisticRegression(random_state=42)
model.fit(X, y)

# 決定境界のプロット
_, ax = plt.subplots(figsize=(10, 6))
DecisionBoundaryDisplay.from_estimator(
    model,
    X,
    cmap=plt.cm.RdYlBu,
    alpha=0.8,
    ax=ax,
    response_method="predict"
)

# データ点のプロット
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.RdYlBu, edgecolor='black')
plt.xlabel('がく片の長さ')
plt.ylabel('花弁の長さ')
plt.title('Irisデータセットの決定境界')
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_curve, auc
from sklearn.preprocessing import label_binarize
from itertools import cycle

# irisデータセットの読み込み
iris = load_iris()
X = iris.data
y = iris.target

# データの分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# ラベルのバイナリ化
y_test_bin = label_binarize(y_test, classes=[0, 1, 2])
n_classes = y_test_bin.shape[1]

# One-vs-Restアプローチでのロジスティック回帰
classifier = LogisticRegression(multi_class='ovr', random_state=42)
y_score = classifier.fit(X_train, y_train).decision_function(X_test)

# ROC曲線の計算
fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(n_classes):
    fpr[i], tpr[i], _ = roc_curve(y_test_bin[:, i], y_score[:, i])
    roc_auc[i] = auc(fpr[i], tpr[i])

# ROC曲線のプロット
plt.figure(figsize=(10, 6))
colors = cycle(['blue', 'red', 'green'])
for i, color in zip(range(n_classes), colors):
    plt.plot(fpr[i], tpr[i], color=color, lw=2,
             label=f'ROC curve of class {iris.target_names[i]} (area = {roc_auc[i]:.2f})')

plt.plot([0, 1], [0, 1], 'k--', lw=2)
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()

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_classification

# データの生成
X, y = make_classification(n_samples=1000, n_features=20, n_informative=2, 
                           n_redundant=2, n_repeated=0, n_classes=2, 
                           n_clusters_per_class=1, random_state=42)

# データの標準化
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# L1正則化（Lasso）とL2正則化（Ridge）のモデル作成
l1_model = LogisticRegression(penalty='l1', solver='liblinear', random_state=42)
l2_model = LogisticRegression(penalty='l2', solver='lbfgs', random_state=42)

# モデルの学習
l1_model.fit(X_scaled, y)
l2_model.fit(X_scaled, y)

# 係数の比較
plt.figure(figsize=(12, 6))
plt.plot(range(X.shape[1]), l1_model.coef_[0], 'b-', label='L1 正則化')
plt.plot(range(X.shape[1]), l2_model.coef_[0], 'r--', label='L2 正則化')
plt.xlabel('特徴量')
plt.ylabel('係数の値')
plt.legend()
plt.title('L1正則化とL2正則化の係数比較')
plt.show()

# ゼロでない係数の数を表示
print(f"L1正則化でのゼロでない係数の数: {np.sum(l1_model.coef_[0] != 0)}")
print(f"L2正則化でのゼロでない係数の数: {np.sum(l2_model.coef_[0] != 0)}")

from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split

# データの分割
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# グリッドサーチのパラメータ設定
param_grid = {
    'C': [0.001, 0.01, 0.1, 1, 10, 100],
    'penalty': ['l1', 'l2']
}

# グリッドサーチの実行
grid_search = GridSearchCV(LogisticRegression(solver='liblinear', random_state=42), 
                           param_grid, cv=5, scoring='accuracy')
grid_search.fit(X_train, y_train)

# 最適パラメータの表示
print("最適パラメータ:", grid_search.best_params_)
print("最高スコア:", grid_search.best_score_)

# テストデータでの性能評価
best_model = grid_search.best_estimator_
test_score = best_model.score(X_test, y_test)
print("テストデータでのスコア:", test_score)

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

# 架空のデータセットを作成
np.random.seed(42)
n_samples = 1000

data = pd.DataFrame({
    'age': np.random.randint(18, 70, n_samples),
    'tenure': np.random.randint(1, 72, n_samples),
    'monthly_charges': np.random.uniform(20, 100, n_samples),
    'total_charges': np.random.uniform(100, 5000, n_samples),
    'contract_type': np.random.choice(['Monthly', 'One year', 'Two year'], n_samples),
    'internet_service': np.random.choice(['DSL', 'Fiber optic', 'No'], n_samples),
    'churn': np.random.choice([0, 1], n_samples, p=[0.7, 0.3])  # 30%の離反率を仮定
})

# カテゴリ変数をダミー変数に変換
data_encoded = pd.get_dummies(data, columns=['contract_type', 'internet_service'], drop_first=True)

# 特徴量とターゲットを分離
X = data_encoded.drop('churn', axis=1)
y = data_encoded['churn']

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

# 特徴量の標準化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# ロジスティック回帰モデルの構築と訓練
model = LogisticRegression(random_state=42)
model.fit(X_train_scaled, y_train)

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

# モデルの評価
print("Accuracy:", accuracy_score(y_test, y_pred))
print("\nClassification Report:")
print(classification_report(y_test, y_pred))

# 混同行列の可視化
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title('Confusion Matrix')
plt.ylabel('Actual')
plt.xlabel('Predicted')
plt.show()

# 特徴量の重要度を可視化
feature_importance = pd.DataFrame({'feature': X.columns, 'importance': abs(model.coef_[0])})
feature_importance = feature_importance.sort_values('importance', ascending=False)

plt.figure(figsize=(10, 6))
sns.barplot(x='importance', y='feature', data=feature_importance)
plt.title('Feature Importance')
plt.show()

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report
import matplotlib.pyplot as plt
import seaborn as sns

# 架空のマーケティングキャンペーンデータを作成
np.random.seed(42)
n_samples = 1000

data = pd.DataFrame({
    'age': np.random.randint(18, 70, n_samples),
    'income': np.random.randint(20000, 100000, n_samples),
    'previous_purchases': np.random.randint(0, 20, n_samples),
    'email_opened': np.random.choice([0, 1], n_samples),
    'time_spent_on_website': np.random.uniform(0, 30, n_samples),
    'campaign_type': np.random.choice(['A', 'B', 'C'], n_samples),
    'purchased': np.random.choice([0, 1], n_samples, p=[0.7, 0.3])  # 30%の購入率を仮定
})

# カテゴリ変数をダミー変数に変換
data_encoded = pd.get_dummies(data, columns=['campaign_type'], drop_first=True)

# 特徴量とターゲットを分離
X = data_encoded.drop('purchased', axis=1)
y = data_encoded['purchased']

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

# 特徴量の標準化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# ロジスティック回帰モデルの構築と訓練
model = LogisticRegression(random_state=42)
model.fit(X_train_scaled, y_train)

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

# モデルの評価
print("Accuracy:", accuracy_score(y_test, y_pred))
print("\nClassification Report:")
print(classification_report(y_test, y_pred))

# 特徴量の重要度を可視化
feature_importance = pd.DataFrame({'feature': X.columns, 'importance': abs(model.coef_[0])})
feature_importance = feature_importance.sort_values('importance', ascending=False)

plt.figure(figsize=(10, 6))
sns.barplot(x='importance', y='feature', data=feature_importance)
plt.title('Feature Importance in Marketing Campaign')
plt.show()

# オッズ比の計算と可視化
odds_ratios = np.exp(model.coef_[0])
odds_ratios_df = pd.DataFrame({'feature': X.columns, 'odds_ratio': odds_ratios})
odds_ratios_df = odds_ratios_df.sort_values('odds_ratio', ascending=False)

plt.figure(figsize=(10, 6))
sns.barplot(x='odds_ratio', y='feature', data=odds_ratios_df)
plt.title('Odds Ratios of Features')
plt.axvline(x=1, color='r', linestyle='--')
plt.show()

import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer

# サンプルデータの作成
data = pd.DataFrame({
    'feature1': [1, 2, np.nan, 4, 5],
    'feature2': [10, np.nan, 30, 40, 50],
    'target': [0, 1, 1, 0, 1]
})

print("元のデータ:")
print(data)

# 平均値での欠損値の補完
imputer = SimpleImputer(strategy='mean')
data_imputed = pd.DataFrame(imputer.fit_transform(data), columns=data.columns)

print("\n欠損値を補完したデータ:")
print(data_imputed)

from sklearn.preprocessing import StandardScaler

# スケーリング前のデータ
X = np.array([[1, 10], [2, 20], [3, 30], [4, 40]])
print("スケーリング前のデータ:")
print(X)

# StandardScalerを使用してスケーリング
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

print("\nスケーリング後のデータ:")
print(X_scaled)

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# サンプルデータの生成
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)

# データの分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 正則化なしのモデル
model_no_reg = LogisticRegression(random_state=42)
model_no_reg.fit(X_train, y_train)
print("正則化なしのモデルのスコア:", model_no_reg.score(X_test, y_test))

# L1正則化（Lasso）を使用したモデル
model_l1 = LogisticRegression(penalty='l1', solver='liblinear', random_state=42)
model_l1.fit(X_train, y_train)
print("L1正則化モデルのスコア:", model_l1.score(X_test, y_test))

# L2正則化（Ridge）を使用したモデル
model_l2 = LogisticRegression(penalty='l2', random_state=42)
model_l2.fit(X_train, y_train)
print("L2正則化モデルのスコア:", model_l2.score(X_test, y_test))

from sklearn.model_selection import cross_val_score

# 5分割クロスバリデーション
cv_scores = cross_val_score(model_l2, X, y, cv=5)
print("クロスバリデーションスコア:", cv_scores)
print("平均スコア:", cv_scores.mean())

from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression

# 再帰的特徴量除去（RFE）
rfe = RFE(estimator=LogisticRegression(), n_features_to_select=5)
rfe = rfe.fit(X, y)

# 選択された特徴量の表示
selected_features = [f"feature_{i}" for i in range(20) if rfe.support_[i]]
print("選択された特徴量:", selected_features)

# L1正則化を使用した特徴量選択
model_l1 = LogisticRegression(penalty='l1', solver='liblinear', random_state=42)
model_l1.fit(X, y)

# 係数がゼロでない特徴量の表示
non_zero_features = [f"feature_{i}" for i in range(20) if model_l1.coef_[0][i] != 0]
print("L1正則化で選択された特徴量:", non_zero_features)

import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import time

# 大規模なデータセットの生成
n_samples = 1000000
n_features = 20

X = np.random.randn(n_samples, n_features)
y = np.random.randint(0, 2, n_samples)

# Pandasを使用したデータフレームの作成
df = pd.DataFrame(X, columns=[f'feature_{i}' for i in range(n_features)])
df['target'] = y

# データの分割
X_train, X_test, y_train, y_test = train_test_split(df.drop('target', axis=1), df['target'], test_size=0.2, random_state=42)

# 通常の方法でモデルを訓練
start_time = time.time()
model = LogisticRegression(random_state=42)
model.fit(X_train, y_train)
end_time = time.time()
print(f"通常の方法での訓練時間: {end_time - start_time:.2f}秒")

# 予測と評価
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"モデルの精度: {accuracy:.4f}")

# 最適化：部分フィットを使用
start_time = time.time()
model_partial = LogisticRegression(random_state=42)
for chunk in pd.read_csv('large_dataset.csv', chunksize=100000):
    X_chunk = chunk.drop('target', axis=1)
    y_chunk = chunk['target']
    model_partial.partial_fit(X_chunk, y_chunk, classes=np.unique(y))
end_time = time.time()
print(f"部分フィットを使用した訓練時間: {end_time - start_time:.2f}秒")

# 予測と評価
y_pred_partial = model_partial.predict(X_test)
accuracy_partial = accuracy_score(y_test, y_pred_partial)
print(f"部分フィットモデルの精度: {accuracy_partial:.4f}")

# 並列処理を使用したモデルの訓練
start_time = time.time()
model_parallel = LogisticRegression(random_state=42, n_jobs=-1)
model_parallel.fit(X_train, y_train)
end_time = time.time()
print(f"並列処理を使用した訓練時間: {end_time - start_time:.2f}秒")

# 予測と評価
y_pred_parallel = model_parallel.predict(X_test)
accuracy_parallel = accuracy_score(y_test, y_pred_parallel)
print(f"並列処理モデルの精度: {accuracy_parallel:.4f}")

def data_generator(file_path, chunk_size=10000):
    for chunk in pd.read_csv(file_path, chunksize=chunk_size):
        X_chunk = chunk.drop('target', axis=1)
        y_chunk = chunk['target']
        yield X_chunk, y_chunk

# ジェネレータを使用したモデルの訓練
start_time = time.time()
model_gen = LogisticRegression(random_state=42)
for X_chunk, y_chunk in data_generator('large_dataset.csv'):
    model_gen.partial_fit(X_chunk, y_chunk, classes=np.unique(y))
end_time = time.time()
print(f"ジェネレータを使用した訓練時間: {end_time - start_time:.2f}秒")

# 予測と評価
y_pred_gen = model_gen.predict(X_test)
accuracy_gen = accuracy_score(y_test, y_pred_gen)
print(f"ジェネレータモデルの精度: {accuracy_gen:.4f}")

import category_encoders as ce

# カテゴリ変数のエンコーディング
encoder = ce.TargetEncoder()
X_encoded = encoder.fit_transform(X, y)

# エンコードされたデータでモデルを訓練
model_encoded = LogisticRegression(random_state=42)
model_encoded.fit(X_encoded, y)

# 予測と評価
X_test_encoded = encoder.transform(X_test)
y_pred_encoded = model_encoded.predict(X_test_encoded)
accuracy_encoded = accuracy_score(y_test, y_pred_encoded)
print(f"エンコードされたデータを使用したモデルの精度: {accuracy_encoded:.4f}")