バーンアウト検知器の作り方：PythonとScikit-learnでGitコミットパターンを分析する

# burnout_detector.py
import requests
import pandas as pd
import os

# --- Configuration ---
GITHUB_TOKEN = os.environ.get('GITHUB_TOKEN') # Best practice to use environment variables
REPO_OWNER = 'your-github-username'
REPO_NAME = 'your-repo-name'
# ---------------------

def fetch_all_commits(owner, repo, token):
    """Fetches all commits for a given repository."""
    commits = []
    page = 1
    per_page = 100
    headers = {'Authorization': f'token {token}'}
    
    while True:
        url = f'https://api.github.com/repos/{owner}/{repo}/commits?page={page}&per_page={per_page}'
        response = requests.get(url, headers=headers)
        
        if response.status_code != 200:
            print(f"Error: {response.status_code}")
            print(response.json())
            break
            
        data = response.json()
        if not data:
            break
            
        commits.extend(data)
        page += 1
        
    return commits

# --- Main execution ---
if __name__ == '__main__':
    if not GITHUB_TOKEN:
        raise ValueError("Please set the GITHUB_TOKEN environment variable.")
        
    print(f"Fetching commits for {REPO_OWNER}/{REPO_NAME}...")
    all_commits = fetch_all_commits(REPO_OWNER, REPO_NAME, GITHUB_TOKEN)
    print(f"Found {len(all_commits)} commits.")

    # Convert to DataFrame for easier manipulation
    df = pd.json_normalize(all_commits)
    print(df.head())

# ... (keep the previous code)

def create_features(df):
    """Engineers features from the raw commit data."""
    # Select and rename relevant columns
    df = df[['sha', 'commit.author.date', 'commit.message']].rename(columns={
        'commit.author.date': 'timestamp',
        'commit.message': 'message'
    })

    # Convert timestamp to datetime objects and set as index
    df['timestamp'] = pd.to_datetime(df['timestamp'])
    df = df.set_index('timestamp')

    # Feature 1: Hour of the day
    df['hour'] = df.index.hour

    # Feature 2: Day of the week (0=Monday, 6=Sunday)
    df['day_of_week'] = df.index.dayofweek

    # Feature 3: Commit message length
    df['message_length'] = df['message'].apply(len)
    
    # Feature 4: Commits per day
    commits_per_day = df.resample('D').size().rename('commits_on_day')
    df = df.join(commits_per_day, on=df.index.date)

    return df

# --- Main execution ---
if __name__ == '__main__':
    # ... (fetching code remains the same)
    
    df_raw = pd.json_normalize(all_commits)
    
    if df_raw.empty:
        print("No commits found.")
    else:
        df_features = create_features(df_raw.copy())
        print("\
--- Features ---")
        print(df_features.head())

# ... (keep previous code)

def label_data(df):
    """Labels data based on known periods of burnout."""
    df['is_burnout'] = 0 # Default to 'normal'
    
    # --- !!! THIS IS THE PART YOU MUST CUSTOMIZE !!! ---
    # Example: Labeling a specific date range as a 'burnout' period
    burnout_start = '2023-10-01'
    burnout_end = '2023-10-31'
    df.loc[burnout_start:burnout_end, 'is_burnout'] = 1

    # Example: Labeling another stressful period
    # burnout_start_2 = '2024-03-15'
    # burnout_end_2 = '2024-04-05'
    # df.loc[burnout_start_2:burnout_end_2, 'is_burnout'] = 1
    
    return df

# --- Main execution ---
if __name__ == '__main__':
    # ...
    else:
        df_features = create_features(df_raw.copy())
        df_labeled = label_data(df_features.copy())
        
        print("\
--- Labeled Data ---")
        # Check the distribution of your labels
        print(df_labeled['is_burnout'].value_counts())
        
        # Display some of the labeled data
        print(df_labeled[df_labeled['is_burnout'] == 1].head())

# ... (add imports at the top)
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt


# ... (add new function)
def train_model(df):
    """Trains a model to predict burnout based on commit features."""
    # Define features (X) and target (y)
    features = ['hour', 'day_of_week', 'message_length', 'commits_on_day']
    X = df[features]
    y = df['is_burnout']

    # Split data into training and testing sets
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.3, random_state=42, stratify=y
    )
    
    # Initialize and train the Random Forest Classifier
    model = RandomForestClassifier(n_estimators=100, random_state=42, class_weight='balanced')
    model.fit(X_train, y_train)
    
    # Make predictions on the test set
    y_pred = model.predict(X_test)
    
    # Evaluate the model
    print("\
--- Model Evaluation ---")
    print(f"Accuracy: {accuracy_score(y_test, y_pred):.2f}")
    print("\
Classification Report:")
    print(classification_report(y_test, y_pred))
    
    # Visualize feature importances
    feature_imp = pd.Series(model.feature_importances_, index=features).sort_values(ascending=False)
    
    plt.figure(figsize=(10, 6))
    sns.barplot(x=feature_imp, y=feature_imp.index)
    plt.xlabel('Feature Importance Score')
    plt.ylabel('Features')
    plt.title("Visualizing Important Features")
    plt.show()

    return model

# --- Main execution ---
if __name__ == '__main__':
    # ...
    else:
        df_features = create_features(df_raw.copy())
        df_labeled = label_data(df_features.copy())
        
        if df_labeled['is_burnout'].sum() > 0:
            train_model(df_labeled)
        else:
            print("\
Skipping model training: No data labeled as 'burnout'.")