Hey, I'm Daniel

# Role & Objective

Act as a Senior Data Scientist. I am evaluating a binary classification model built using Python and scikit-learn. I need you to generate [CHOOSE ONE: the Python evaluation code / a detailed analysis of the provided metric outputs] based on the configuration below.

# Context

• Project/Objective: [e.g., Predicting customer churn for a SaaS platform]
• Positive Class (1): [e.g., Churned]
• Negative Class (0): [e.g., Retained]
• Class Imbalance: [e.g., Highly imbalanced, 90% Negative / 10% Positive]
• Cost of Errors: [e.g., False Positives trigger unnecessary retention offers (costly). False Negatives are missed churn events (lost revenue).]

# Required Evaluation Metrics

Please structure your response to address the following metrics. For each, explain what the results indicate regarding the specific objective outlined above.

1. Cumulative Gains Curve: To assess how effectively we can prioritize the top percentiles of our data based on model confidence.
2. ROC Curve & AUC: To evaluate the general baseline separation of the model against a random guesser.
3. Confusion Matrix (at threshold = [e.g., 0.5]): To view the exact distribution of False Positives vs. False Negatives.
4. Classification Report: To review Precision, Recall, and F1-scores for both individual classes.
5. Precision-Recall (PR) Curve & AUC-PR: To evaluate performance specifically on the positive class, given the data balance, and ensure the model isn't generating excessive False Positives.
6. Lift Curve: To determine exactly how many times better the model is than a random guess at specific data deciles.
7. Brier Score (or Log Loss / Cross-Entropy): To measure probability calibration and verify that the output scores are mathematically reliable for automated downstream pipelines.
8. Kolmogorov-Smirnov (KS) Statistic: To measure the maximum degree of separation between the positive and negative class probability distributions.

# Input Data / Instructions

# Role & Objective

Act as a Senior Data Scientist. I am evaluating a multi-class classification model built using Python and scikit-learn. I need you to generate [CHOOSE ONE: the Python evaluation code / a detailed analysis of the provided metric outputs] based on the configuration below.

# Context

• Project/Objective: [e.g., Categorizing support tickets by severity level for automated routing]
• Classes:
  • Class 0: [e.g., Critical / Outage]
  • Class 1: [e.g., High Priority]
  • Class 2: [e.g., Medium Priority]
  • Class 3: [e.g., Low / Informational]
• Class Imbalance: [e.g., Moderate imbalance. Classes 2 and 3 make up 70% of the data; Classes 0 and 1 make up 30%.]
• Cost of Errors: [e.g., Misclassifying a 'Critical' ticket as 'Low' causes SLA breaches. Confusing 'High' with 'Medium' is suboptimal but manageable.]

# Required Evaluation Metrics

Please structure your response to address the following metrics. For each, explain what the results indicate regarding the specific objective and cost of errors outlined above.

1. Classification Report (Macro & Weighted Averages): To review Precision, Recall, and F1-scores for individual classes, and assess how the model handles minority classes via the Macro average.
2. N x N Confusion Matrix: To identify specific misclassifications and class overlap (e.g., which specific categories are being confused with each other).
3. One-vs-Rest (OvR) ROC AUC: To evaluate how well the model isolates each individual class from the rest of the dataset.
4. Cohen's Kappa: To verify that the model's overall accuracy is driven by genuine learning rather than random chance or majority-class bias.
5. Multi-Class Log Loss: To measure probability calibration and ensure the predict_proba distributions across all classes are mathematically reliable.

# Input Data / Instructions

# Role & Objective

Act as a Senior Data Scientist specializing in Time-Series Forecasting. I am trying to determine the optimal architectural approach for a forecasting problem. I need to decide whether to use a traditional parametric model (e.g., ARIMA, SARIMA, VAR) or a non-parametric deep learning model (e.g., LSTM, GRU).

Please generate [CHOOSE ONE: the Python diagnostic code / a detailed analysis of the provided diagnostic outputs] based on the configuration below.

# Context

• Project/Objective: [e.g., Forecasting weekly product demand across regional warehouses to optimize inventory allocation.]
• Data Frequency: [e.g., Monthly data]
• Data Volume: [e.g., 20 years of historical data, ~240 observations per series]
• Multivariate/Univariate: [e.g., Multivariate — predicting demand while using promotional spend and weather data as exogenous features]

# Required Evaluation Diagnostics

Please structure your response to address the following diagnostics. For each, explain what the results indicate regarding the choice between a parametric model and a neural network (LSTM).

1. Stationarity Checks (ADF & KPSS Tests): To determine if the data has a unit root or deterministic trend, and if standard differencing can make it stationary.
2. ACF & PACF Analysis: To assess the strength and clarity of linear dependencies across lags.
3. Seasonal Decomposition (STL): To evaluate the complexity of the seasonal patterns and the size/structure of the residual noise.
4. Volatility / Non-Linearity (ARCH/Ljung-Box): To detect conditional heteroskedasticity or complex non-linear patterns that standard linear models cannot capture.
5. Dimensionality & Viability Check: Based on the data volume and number of features provided in the context, explicitly state whether an LSTM is prone to overfitting here, or if the dataset is robust enough to support deep learning.

# Input Data / Instructions

# Role & Objective

Act as a Senior Data Scientist. My core objective is to answer the question: "What is the best, most natural number of groups (k) found in this dataset?" I am using unsupervised learning (K-Means clustering) to segment my data. I need you to write complete, executable Python code that scales the data, determines the optimal number of clusters by mathematically calculating the inflection point of an Elbow Curve, generates the final model, and labels the dataset.

# Context

• Project/Objective: [e.g., Discovering natural customer segments based on purchasing behavior and engagement metrics.]
• Data Characteristics: [e.g., 5 continuous numeric features: Avg Order Value, Purchase Frequency, Days Since Last Purchase, Session Duration, and Pages Viewed. No missing values.]
• Business Value: [e.g., By accurately segmenting customers, we can create tailored marketing campaigns for each group rather than using a one-size-fits-all strategy.]

# Required Workflow & Outputs

Please generate a single, cohesive Python script that performs the following steps:

1. Pre-processing: Apply StandardScaler to the features, as K-Means is a distance-based algorithm and requires normalized data.
2. Determine Optimal 'k' (Elbow Method & Silhouette):
   • Iterate through a range of clusters (e.g., k=2 to k=10).
   • Calculate the Within-Cluster Sum of Squares (WCSS/Inertia) for each 'k'.
   • Calculate the Silhouette Score for each 'k' as a secondary validation metric.
3. Calculate the Inflection Point: Do not rely on visual inspection. Programmatically calculate the exact inflection point (the "elbow") of the WCSS curve. You may use the kneed library (KneeLocator) or a distance-to-line mathematical implementation.
4. Visualization (seaborn):
   • Create a professional seaborn (sns) line plot of the Elbow Curve (WCSS vs. Number of Clusters).
   • Add a vertical dashed line or a distinct marker on the plot to explicitly highlight the calculated inflection point.
5. Final Model & Labeling:
   • Instantiate a final K-Means model using the programmatically calculated optimal 'k'.
   • Fit the model and predict the cluster labels.
   • Append these labels as a new column named Cluster_Label to the original dataframe.
6. Cluster Profiling: Group the original dataframe by Cluster_Label and calculate the mean for each feature. Print this summary table so I can interpret the real-world characteristics of each group.

# Input Data / Instructions