This was a new feature released by Claude.

Implementing the A3 Methodology

The app covers all eight essential A3 steps:

1. Background - Current situation context

2. Problem Statement - Specific problem definition

3. Current State Analysis - Detailed process examination

4. Target State - Ideal future vision

5. Root Cause Analysis - Underlying cause identification

6. Countermeasures - Proposed solutions

7. Implementation Plan - Execution strategy

8. Follow-up Plan - Monitoring and sustainability

Each step includes thoughtful prompts and placeholders to guide users toward comprehensive responses.

App Output

The app provides an analysis of the sections and produces an executive summary, key findings, strengths, recommendations, and risk assessment.

Impressions

Prompt Engineering is Critical - The quality of AI analysis depends heavily on structured prompts. I found that explicitly requesting JSON format and providing examples dramatically improved response consistency.

Iterative prompts - It took a few iterations after the first design to help tweak the app but the initial design was very good.

This project represents a fascinating development pattern: using AI to build AI-powered applications. Claude helped design the interface, implement the functionality, and now provides the analytical intelligence that makes the tool valuable.

Check out the A3 app on Claude here

Although it only compares open source models and not the latest foundation models, it still is useful for me to compare differences between the open source models, at least the lightweight versions.

Why I Built It

• Rapid prompt engineering

  Seeing two answers side-by-side helps me decide which wording and styling.

• Qualitative benchmarking

  Formal evaluation metrics are great, but a quick visual gut-check on tone and factuality often saves me time. I like get a ‘feel’ for each model.

How It Works under the Hood

1. Gradio front-end

   A single Textbox for the prompt and two response panes keep the UI friction-free.

2. huggingface-hub’s InferenceClient

   Instead of loading giant weights locally, the app makes chat_completion calls to

   • mistralai/Mistral-7B-Instruct-v0.2

   • meta-llama/Llama-2-7b-chat-hf

from huggingface_hub import InferenceClient

client = InferenceClient("mistralai/Mistral-7B-Instruct-v0.2", token=HF_TOKEN)
resp = client.chat_completion(
        messages=[{"role": "user", "content": prompt}],
        max_tokens=200).choices[0].message["content"]

Using the Tool

1. Paste a prompt – e.g. “Explain the second law of thermodynamics in plain English.”

2. Hit “Submit.”

Compare the Mistral answer (usually concise and instructional) with LLaMA-2’s (often more conversational).

Observations

My personal observations experimenting with the two models:

• Stylistic flavor – Mistral tends to jump straight into bullet points; LLaMA-2 sprinkles more transition words.

• Output – Mistral packs more information than LLaMA-2.

Check it out

➡️ Prompt Comparison Tool on HuggingFace

Feel free to ping me with improvements or bug reports. Happy prompting!

To bring this to life, I used LlamaIndex for document indexing and OpenAI’s language models for generating responses. I deployed the app using Gradio on Hugging Face Spaces, which provided a clean and accessible interface. The chatbot accepts questions and retrieves information from a curated set of documents I uploaded, offering a live demo of how retrieval-augmented generation (RAG) can create powerful personal or professional tools.

Check it out here

Why I Built It

In many datasets, timelines and trends are everything—yet I often bounce between separate scripts for forecasting, outlier hunting, and visualization. I wanted a single, browser-based workspace where anyone could upload a CSV or Excel file and instantly see forward-looking forecasts and anomaly flags in one place. I built this tool utilizing Streamlit.

➡️ Check out the Streamlit dashboard.

What the App Does

1. One-Click Data Ingestion

   Drop in any time-series file (or play with the built-in sample). The app automatically sniffs out the date/time and metric columns, even if you rename or reorder them.

2. Dual Forecast Engines

   • Prophet—great for strong seasonal patterns and holiday effects.

   • Auto-tuned SARIMAX—handles subtle autocorrelation structures.

     Both models train side-by-side, and their prediction intervals are plotted together for comparison.

3. Isolation Forest Anomaly Layer

   After training, an Isolation Forest scans historical residuals plus new forecasts, shading points that deviate beyond an adaptive threshold.

4. Interactive Plotly Visuals

   Hover to inspect values, toggle series on/off, zoom, or download a PNG snapshot.

5. Instant Exports

   Click once to grab a tidy CSV of both forecasts or save the current chart to PNG for slide decks.

Try It Yourself

The repo is open-sourced on GitHub and deploy-ready to Streamlit Cloud in under five minutes. Clone, push, and share a public link with stakeholders—no server wrangling required.

Check out the Streamlit dashboard. Also check out my other times-series projects.

Let me know what you think!

Why Prompt Assistants Matter for Process Improvement

Prompt assistants are reusable, intelligent text inputs designed to guide AI behavior in a predictable and efficient way. I think of them as customizable coworkers, that never forget your formatting preferences or details that are important.

From a process improvement perspective, these assistants offer tangible benefits:

• Standardization: They ensure that outputs—whether reports, summaries, or analysis—follow a consistent format, which is especially valuable in cross-functional teams.

• Efficiency: They significantly reduce the time spent on repetitive cognitive tasks, freeing up time for higher-value work.

• Shareability / Collaboration: These prompts can be shared with others.

• Training and Onboarding Support: New employees can use prompt assistants as learning tools, receiving structured and high-quality responses that reflect company standards.

During our training, I shared some prompts that I had created to summarize long text, re-write emails, and evaluate an A3 document (A tool for process improvements) for consistency and completeness.

Below is an assistant prompt to help me summarize text.

Driving a Culture of Continuous Improvement

Beyond the tools themselves, what excited me most was the mindset shift. Creating prompt assistants encouraged me to think critically about my daily processes. What could be automated? What tasks were repetitive and ripe for improvement?

This approach ties directly into Lean and continuous improvement principles. By identifying waste (in the form of time, inconsistency, or rework) and applying a lightweight, tech-driven solution, we were able to make small but impactful changes to how we work.

Final Thoughts

Prompt assistants are more than just clever AI tricks 😝—they're enablers of better workflows, sharper communication, and more empowered teams. I know using AI can sometimes be a controversial topics.

I'd love to hear how you're using prompt assistants to improve your processes. Drop a comment or connect with me to share your story!

Control charts have always been one of my go-to tools for monitoring process stability. They offer a clear visual representation of how a process behaves over time. In this analysis, I wanted to take things a step further by incorporating anomaly detection, specifically using Isolation Forest.

In the past I have also used the control chart as part of visualizing data while performing hypothesis testing. I have updated a previous script I have been using, updating the control chart to include anomaly detection.

check out the ipynb script

Hypothesis Testing

My Initial Control Chart: Before vs After

To start, I created a control chart to visualize two data sets—one representing the "before" phase and the other the "after" phase. The chart plots sample values over time, including key statistical indicators:

• Mean Line: Represents the average value of each phase.

• Standard Deviation Boundaries: Upper and lower bounds, marking one standard deviation from the mean.

This visualization helped me detect shifts in process performance. By comparing the "before" and "after" distributions, I could easily spot any significant changes in the mean or spread of data, indicating possible process improvements or deviations.

I do want to note that although control charts are typically used to check if a process is in control, there is information from the chart that can be beneficial to hypothesis testing. It can help visualize and highlight the different means or help assess the stability of the data.

Bringing in Anomaly Detection

To take my analysis further, I applied the Isolation Forest algorithm for anomaly detection. This method is great for identifying outliers because it isolates anomalies in fewer steps than normal data points. Here’s how I went about it:

1. Model Training: I trained the algorithm using sample scores, setting a contamination rate of 10%.

2. Anomaly Identification: The model flagged specific data points as anomalies, which I then plotted distinctly.

    #Anomaly detection
    isolation_method = IsolationForest(n_estimators=100, contamination=0.10)
    # Model fitting
    isolation_method.fit(pd.DataFrame(df['Scores']))
    df['anomaly_iso'] = isolation_method.predict(pd.DataFrame(df['Scores']))
    a = df.loc[df['anomaly_iso'] == -1, ['index', 'Scores']]  # Anomaly
   

What I Learned from the Updated Chart

After applying anomaly detection, the second control chart gave me some fresh insights:

• Highlighted Anomalies: Points identified as anomalies were marked in red, making it easy to spot unusual deviations. This also aligned with outliers above and below the standard deviation.

• Enhanced Process Understanding: These anomalies could indicate process breakdowns, measurement errors, or unexpected variations that needed further investigation.

• Better Decision-Making: Seeing anomalies in real time allowed me to take proactive measures to maintain process stability.

Adding anomaly detection to control charts has been a game-changer for me. It provides an extra layer of insight that traditional control charts alone might miss. By combining classical statistical tools with modern machine learning techniques, I feel more confident in my ability to monitor processes effectively and drive continuous improvement.

This experience reinforced my belief that data-driven decision-making is key to maintaining operational efficiency, and I’ll definitely be using this approach in future analyses.

Current State

The students are originally grouped into 7 teams shown below.

Each student has an average score based on the categories: Reading, Writing, Math, and Science.

Team Distribution of Average Student Scores

The average of the teams ranged from 43.25 to 50.85. The difference between the teams is relatively small, but let's see if we can improve the teams.

Future State

For the future state teams, I'll be using Linear Programming to minimize the difference between the average team score. Making the teams as balanced as possible.

New team constraints:

• There will be 5 new teams

• Each student can only be assigned to 1 team

• Team size will have the specified size, team_sizes = [15, 25, 20, 20, 20]

• There will be at least 1 student with a score of 70 or more in each of the categories 'Reading', 'Writing', 'Math', and 'Science'.

The constraints were used to create a Linear Programming model with the following results.

The team averages are more balanced than the current state while following the constraints.

In the chart above you can see each students score. I also clustered the students based on the category scores, to help find students of similar skill level. The clustering did not affect the results of the linear optimization. It was more for identification of student groupings.

One benefit was that I was able to write some code that allowed for finding a similar student.

In the example below with student 99, the nearest students are student 4 and student 87.

Conclusion

I was able to build a model that could rebalance the students while following a set of constraints on the new teams.

Link to project

The network graph created below can be found here.

# Create a NetworkX DiGraph
G = nx.DiGraph()
# Iterate through the DataFrame and add edges to the graph
for index, row in df.iterrows():
    G.add_edge(row['predecessor'], row['successor'], duration=row['duration'])

# Find the critical path
critical_path = nx.dag_longest_path(G, weight='duration')
print(f'Critical Path: {critical_path}')

Critical Path: ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']

Total Duration of Critical Path: 35

Networkx makes it relatively simple to find the path. I manually colored the nodes to highlight the identified critical path.

I created a baseline by comparing the performance of 5 different classification models, measuring accuracy.

First setup, a dictionary of models.

# Put models in a dictionary
models = {"KNN": KNeighborsClassifier(),
          "Logistic Regression": LogisticRegression(), 
          "Random Forest": RandomForestClassifier(),
          "GradientBoost": GradientBoostingClassifier(),
          "GaussianNB": GaussianNB(),
          }

# Create function to fit and score models
def fit_and_score(models, X_train, X_test, y_train, y_test):
    """
    Fits and evaluates given machine learning models.
    models : a dict of different Scikit-Learn machine learning models
    X_train : training data
    X_test : testing data
    y_train : labels assosciated with training data
    y_test : labels assosciated with test data
    """
    # Random seed for reproducible results
    np.random.seed(42)
    # Make a list to keep model scores
    model_scores = {}
    # Loop through models
    for name, model in models.items():
        # Fit the model to the data
        model.fit(X_train, y_train)
        # Evaluate the model and append its score to model_scores
        model_scores[name] = model.score(X_test, y_test)
    return model_scores

{'KNN': 0.9568181818181818,
 'Logistic Regression': 0.9636363636363636,
 'Random Forest': 0.9931818181818182,
 'GradientBoost': 0.9818181818181818,
 'GaussianNB': 0.9954545454545455}

The baseline scores show the Gaussian and Random Forest models performing the best.

Next steps of the model will be selection of either Gaussian or Random Forest models and performing cross validation grid search hyper parameter tuning.

There are 20 before and 20 after samples taken of student test scores.

You can find the complete Jupyter notebook here.

Null Hypothesis (H0): Scores between the samples is the same. First 20 samples = last 20 samples
Alternative Hypothesis (H1): Scores for the samples is different.

First step in the process after importing the data is creating some visuals to help see the data.

Interactive plotly point plot

Plotly line chart

Plotly boxplot

Plotly histogram

This last chart helps makes visualizing the 2 samples over time easier, in a control chart type format.

After checking for normality and equal variance, I perform the hypothesis test using a function that check the p-value and returns an interpretation.

# Perform t-test
t_score, p_value = st.ttest_ind(a=df_new['first_twenty'],
                                b=df_new['last_twenty'],
                                alternative='two-sided') # change this if the hypothesis is greater or less than.

print(f'T-score: {t_score}')
p_value_reader(p_value, alpha=0.05)

Conclusion: Reject the Null Hypothesis, there is a difference in the means.

This model uses the Prophet library

from prophet import Prophet

After importing the AAPL price data from csv, I created a graph of the price over time.

The dataset includes column for Volume each day, which I will use as a regressor in the prophet model

I trained it on the whole dataset, predicting for future data 31 days in the future.

›

# building the model
m = Prophet(
            seasonality_mode=sm,
            seasonality_prior_scale=sps,
            changepoint_prior_scale=cps)
m.add_regressor('Volume')
m.fit(training)

Creating predictions is pretty simple, just passing the future data frame.

# Forecasting
forecast = m.predict(future)
forecast.head(5)

Plotting the predictions

# Forecasting
forecast = m.predict(future_df)
m.plot(forecast);

The model shows a downward trend for the next 31 days.

It also makes plotting the model components easy. So you can see the yearly, weekly trends

# Components
m.plot_components(forecast);

I will be forecasting this same dataset using some other forecasting models to compare results. And combining them together.

It is a pretty easy to use and creates interactive network diagrams.

I created a visual from the Kaggle Marvel Character Social Network dataset which shows the relationships between all the Marvel Characters. The one downside to the visuals created with PyVis is that the larger models can take some time to load on the screen. In this example I had to subset the data to just 3 characters.

But the diagrams are interactive and move based on customizable physics.

I also created a smaller diagram to show the relationship between different skills that I have learned.

You can interact with the diagram at this location here. I was able to customize the size, color, edge colors, labels.

Check out the PyVis tutorial for more.

First loaded the needed libraries and imported Kaggle dataset

# Import libraries
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
import tensorflow_hub as hub
from tensorflow.keras import layers
from sklearn.model_selection import train_test_split
from wordcloud import WordCloud

# Import data
train_df = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
test_df = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv")
train_df.head()

Shuffled and split the data

# Shuffle training dataframe
train_df_shuffled = train_df.sample(frac=1, random_state=42)
train_df_shuffled.head()

# Use train_test_split to split training data into training and validation sets
train_sentences, val_sentences, train_labels, val_labels = train_test_split(train_df_shuffled["text"].to_numpy(),
                                                                            train_df_shuffled["target"].to_numpy(),
                                                                            test_size=0.1, 
                                                                            random_state=42) 

# Create sentences and labels
whole_train_sentences = train_df_shuffled['text'].to_numpy()
whole_train_labels =  train_df_shuffled['target'].to_numpy() 

len(whole_train_sentences) , len(whole_train_labels)

Created the Keras Layer using the pretrained universal sentence encoder.

# Create a Keras layer using the USE pretrained layer from tensorflow hub
sentence_encoder_layer = hub.KerasLayer("https://tfhub.dev/google/universal-sentence-encoder/4",
                                        input_shape=[], 
                                        dtype=tf.string, 
                                        trainable=False,
                                        name="USE"
                                        )

Created a Sequential model

# Create model using the Sequential API
model = tf.keras.Sequential([
  sentence_encoder_layer, 
  layers.Dense(64 , activation ='relu'),
  layers.Dense(1, activation="sigmoid")
])

# Compile model
model.compile(loss="binary_crossentropy",
                optimizer=tf.keras.optimizers.legacy.Adam(),
                metrics=["accuracy"])

# Train a classifier on top of pretrained embeddings
model_history =model.fit(whole_train_sentences,
                              whole_train_labels,
                              epochs=5,
                              validation_data=(val_sentences, val_labels))

Make predictions

# Make predictions with the model
pred_probs = model.predict(test_df['text'].to_numpy())

Submitted my predictions in the Kaggle Competition. It just beat the AutoML Benchmark.

I also created some visuals to view the keywords in the tweet data.

I also used the TensorFlow projector tool to visualize the embeddings. It produced a neat clustering a related words.

You can find the Kaggle notebook here

Python Bar Chart

Part of the dataset is a column for the tweet keyword. I created a sorted bar chart to display top keywords. 'Fatalities' is the top keyword by count with a number words very close.

# Plot tweet keywords
plt.bar(keyword_df['keyword'].head(20), keyword_df['count'].head(20), color='green')
plt.xticks(rotation = 90)
plt.ylabel('Count')
plt.title('Top keywords')
plt.show()

Python WordCloud

In python, I created a world cloud of the keywords.

# Create word cloud visual of keywords
from wordcloud import WordCloud
word_frequencies = keyword_df['keyword'].value_counts().to_dict()

# Generate the word cloud with frequencies
wordcloud = WordCloud(width=800, height=400, background_color='white')
wordcloud.generate_from_frequencies(word_frequencies)

# Display the word cloud using matplotlib
plt.figure(figsize=(10, 5))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.show()

This created a neat visual where larger words are based on the count of keywords.

Tableau Word Cloud and TreeMap

Finally, I explored visualizing in Tableau, but since the top keywords have counts very close together, the word cloud looked more like a list of words.

I followed this video in creating the visual.

Changing the tableau chart into a TreeMap helped visualize a little better but it isn't as helpful as I would like.

You can view the Kaggle notebook where the python charts are used in a NLP classification model.

This method is also pretty straightforward.

Steps

1. Load the data into tableau. For this example I loaded an excel sheet with the mock data used in the excel example.

2. Create a line graph with a date value on the x axis.

   

3. On the left hand panel, select the 'Analytics' panel. Under 'Model', select 'Forecast' and drag it on the line chart. You will see a small pop up showing that it will add a forecast.

   

4. The chart will update and add the forecast. Here it is the light blue line with the shaded confidence interval band.

   

5. You can view and change settings by right-clicking on the line chart.

   1. You can change the forecast timeframe, model, and confidence interval.

      

   2. There is also an option to view descriptive information about the model.

      

Overall, I found this very quick to produce. Compared to the excel visual, tableau produced what looks like a smaller confidence interval band around the forecast. Excel automatically created a table with the forecasted values. While this can be created and exported by creating another sheet in tableau, it wasn't created automatically for me. Tableau is more of a visual presentation tool so this not is a surprise, but helpful to know before getting started with one method.

Time series forecasting in excel

I like exploring doing similar things using different tools, so I wanted to step through doing time series forecasting in excel. Which is surprisingly pretty simple.

Steps

1. Highlight your data in excel. (Both x and y variables). In my example I had a 'Date' and 'Value' column. I created some fake data with 'seasonality'.

2. Select Data Tab -> Forecast Section -> Click ‘Forecast Sheet'

   

3. Adjust any parameters in the window

   

4. This will output a chart and data table on a new sheet.

Time series forecasting in Tableau

🔗 Links

Kaggle notebook

Tableau dashboard

Here is an outline of the steps I took to perform the analysis:

1. Data Exploration: Here are some of the helpful graphs created while exploring the data.

   1. Histogram of Home Sales Prices

       sns.displot(df_data['SalePrice'], 
                   bins=50, 
                   aspect=2,
                   kde=True, 
                   color='darkblue')
      
       plt.title(f'Home Sales Price. Average: ${(df_data.SalePrice.mean()):,.0f}')
       plt.xlabel('Price ($)')
       plt.ylabel('# of Homes')
      
       plt.show()
      

   2. 

      Correlation heat map - This helps spot correlation between features and the target variable SalesPrice

   3. 

      Average Sales Prices over time ⬆️

   4. 

      📊 I also created a tableau dashboard to help me visualize the data. This wasn't necessary, but in the past I have used this as a way to spot correlations or relationships.

2. Data Cleaning

   1. Created variables for X (predictor) variables and y (target) variable.

   2. Train, test, split

   3. Handle missing data and transform columns

   4.  # Handle Missing Data
       numeric_cols = X.select_dtypes(include=['number']).columns
       categorical_cols = X.select_dtypes(exclude=['number']).columns
      
       numeric_imputer = SimpleImputer(strategy='mean')
       categorical_imputer = SimpleImputer(strategy='most_frequent')
      
       # Create transformers for preprocessing
       numeric_transformer = Pipeline(steps=[
           ('imputer', numeric_imputer),
           ('scaler', StandardScaler())
       ])
      
       categorical_transformer = Pipeline(steps=[
           ('imputer', categorical_imputer),
           ('encoder', OneHotEncoder(handle_unknown='ignore'))
       ])
      
       # Use ColumnTransformer to apply transformers to the appropriate columns
       from sklearn.compose import ColumnTransformer
      
       preprocessor = ColumnTransformer(
           transformers=[
               ('num', numeric_transformer, numeric_cols),
               ('cat', categorical_transformer, categorical_cols)
           ])
      

3. XGB model and Predictions

    # Create a XGBoost Regressor
    xgb = XGBRegressor(n_estimators=500, learning_rate=0.04)
   

    # Bundle preprocessing and modeling code in a pipeline
    my_pipeline = Pipeline(steps=[('preprocessor', preprocessor),
                                  ('model', xgb)
                                 ])
   
    # Preprocessing of training data, fit model 
    my_pipeline.fit(X_train, y_train)
   
    # Preprocessing of validation data, get predictions
    preds = my_pipeline.predict(X_valid)
   
    # Evaluate the model
    mae = mean_absolute_error(y_valid, preds)
    mse = mean_squared_error(y_valid, preds)
    r2 = r2_score(y_valid, preds)
    print(f"Mean Absolute Error (MAE): {mae:.2f}")
    print(f"Mean Squared Error (MSE): {mse:.2f}")
    print(f"R-squared (R2): {r2:.2f}")
   

4. Hyper-parameter tuning

   1. Setting up parameters to tune

param_tuning = {
    'model__learning_rate': [0.01, 0.1, 0.05],
    'model__max_depth': [3, 5, 7, 10],
    'model__min_child_weight': [1, 3, 5],
    'model__subsample': [0.5, 0.7],
    'model__colsample_bytree': [0.5, 0.7],
    'model__n_estimators': [100, 200, 500, 1000],
    'model__objective': ['reg:squarederror']
}

• Grid Search

xgb_model = XGBRegressor()
my_pipeline = Pipeline(steps=[('preprocessor', preprocessor),
                              ('model', xgb_model)
                             ])


xgb_cv = GridSearchCV(estimator=my_pipeline,
                           param_grid = param_tuning,                        
                           scoring = 'neg_mean_absolute_error', #MAE
                           #scoring = 'neg_mean_squared_error',  #MSE
                           cv = 5)

xgb_cv.fit(X_train, y_train)
print("Best Score: ", xgb_cv.best_score_)
print("Best Params: ", xgb_cv.best_params_)

Hyper-parameter tuning helped decrease the model error 🎉

Check out the Kaggle notebook

Data Exploration

The first step was loading and performing some data exploration

A pair plot is a helpful visual to spot correlations.

Here is a visual of the age of those transported

During the data exploration I used the get_dummies function on the 'HomePlanet' and 'Destination' columns. I also performed other methods to clean and transform the data.

df_data_final = pd.get_dummies(df_data_final, columns=['HomePlanet', 'Destination'], drop_first=False)

I created a tableau dashboard to help visualize the data. This wasn't necessary but helped me see and interact with the data.

Creating the model

The target variable is the 'Transported' column, the rest of the columns are the features.

# Define the y (target) variable.
y = df_data_final['Transported']

# Define the X (predictor) variables.
X = df_data_final.drop(['Transported'], axis = 1)

Results

Random Forest Model Accuracy: 0.781048758049678

XGBoost Model Accuracy: 0.7828886844526219

The XGBoost model performed slightly better on the training data.

If you are interested, the Kaggle notebook can be found here

Links:

Jupyter notebook

Tableau dashboard visualization

Here are some major steps

1. Load the dataset

2. Perform data cleaning by handling missing values, if any, and removing any redundant or unnecessary columns.

   drop_duplicates(), df.dropna()

3. Explore the basic statistics of the dataset

   df.describe()

4. Perform data visualization to gain insights into the dataset. Generate appropriate plots, such as histograms, scatter plots, or bar plots, to visualize different aspects of the data

   

5. Analyze the sales trends over time. Identify the busiest months and days of the week in terms of sales.

   I used groupby() to pivot the data for the sales trend charts.

   

6. Explore the top-selling products and countries based on the quantity sold.

   

   

7. Identify any outliers or anomalies in the dataset and discuss their potential impact on the analysis.

   

8. Conclusions:

   There are missing values for product Description and CustomerId, for now I will keep this in the data to discuss with customer before removing.

   There are some items in the transactions that might be removed. For example, items listed as AMAZON FEE, Manual, DOTCOM POSTAGE, and POSTAGE. This makes it harder to compare products sales in the data.

   There appears to be 2 transactions with very high Quantities, with the same quantity returned the same day. This appears to be returned items, recommend excluding these transactions.

2 outliers appear in UnitPrice

• First is a Manual transaction for stock code 'M' with unit price of 38,970

• Second, there are 2 negative transactions for Stockcode 'B' to 'adjust bad debt'

Until those items above are removed, we can see that:

• 📅Busiest month: November

• 📅Busiest weekday: Thursday

• 🔥Most transacted product qty: World War 2 Gliders Asstd Design (85123A)

• Most transacted stockcode (without description): 22197

• Highest unit price item: AMAZON FEE

• Highest product unit price: REGENCY CAKESTAND 3 TIER

• 🌍Majority of sales are in United Kingdom

• Avg transaction qty: 9.6

• Avg transaction unit price: 4.6

• Weekly qty has an upward trend in 2011