Policy Viewer

1# Load the csv file without the header
2df = pd.read_csv('Truck Repairs for 2023 - Sheet1 - Dr. Victoria Gamble.csv', header=None)
3
4# Rename the columns
5df.rename(columns={0: 'Month', 3: 'Cost'}, inplace=True)
6
7# Display the first 5 rows
8print(df.head().to_markdown(index=False, numalign="left", stralign="left"))
9
10# Print the column names and their data types
11print(df.info())

1# Read the CSV file into a DataFrame with the correct header starting from row 2
2df = pd.read_csv("product_sales_-_ps pivot table.csv", encoding='latin-1', header=1)
3
4# Display the first 5 rows
5print(df.head().to_markdown(index=False, numalign="left", stralign="left"))
6
7# Print the column names and their data types
8print(df.info())

1# Get all unique values from `Z`
2unique_values = df['Z'].unique()
3
4# Check the number of unique values in `Z`
5if len(unique_values) > 50:
6    # If there are too many unique values, sample the top 50
7    top_occurring_values = df['Z'].value_counts().head(50).index.tolist()
8    print(top_occurring_values)
9else:
10    # Otherwise print all unique values in `Z`
11    print(unique_values)

1# Remove '€' and ',' from the `Total` column
2df['Total'] = df['Total'].astype(str).str.replace('€', '', regex=False).str.replace(',', '', regex=False)
3  
4# and convert it to numeric
5df['Total'] = pd.to_numeric(df['Total'])
6  
7# Aggregate on `Cost Code` and sum `Total` column and pick top value by Budget
8expensive_cost_code = df.groupby('Cost Code')['Total'].sum().reset_index(name='Budget').sort_values(by='Budget', ascending=False).iloc[0]
9  
10# Display the output
11print(expensive_cost_code)

1import numpy as np
2
3# Get all unique non-numeric values from `GMV`
4non_numeric_values = df[pd.to_numeric(df['GMV'], errors='coerce').isna()]['GMV'].unique()
5    
6if (len(non_numeric_values) > 20):
7    # Sample 20 of them if there are too many unique values
8    print(f"Non Numeric values in GMV {np.random.choice(non_numeric_values, 20, replace=False)}")
9else:
10    # Otherwise print all unique non-numeric values from `GMV`
11    print(f"Non Numeric values in GMV {non_numeric_values}")

1import numpy as np
2    
3# Get all unique non-numeric values from `net_worth` column
4non_numeric_net_worth_value = df[pd.to_numeric(df['net_worth'], errors='coerce').isna()]['net_worth'].unique()
5if (len(non_numeric_net_worth_value) > 20):
6    # Sample 20 of them if there are too many unique values
7    print(np.random.choice(non_numeric_net_worth_value, 20, replace=False))
8else:
9    # Otherwise print all unique non-numeric values from `net_worth`
10    print(non_numeric_net_worth_value)

1# Convert `Date` column to datetime
2df['Date'] = pd.to_datetime(df['Date'])
3# Extract month from `Date` and save it to new column `Month`
4df['Month'] = df['Date'].dt.month_name()

1from sklearn.model_selection import train_test_split
2from sklearn.preprocessing import OneHotEncoder, StandardScaler,LabelEncoder
3from sklearn.linear_model import LogisticRegression
4from sklearn.ensemble import RandomForestClassifier
5from xgboost import XGBClassifier
6from sklearn.metrics import accuracy_score
7
8# Separate features and target variable
9X = df.drop('Stage', axis=1)
10y = df['Stage']
11
12# Identify categorical and numerical columns
13categorical_cols = X.select_dtypes(include=['object']).columns
14numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
15
16# One-hot encode categorical columns
17encoder = OneHotEncoder(drop='first', sparse_output=False)
18X_encoded = encoder.fit_transform(X[categorical_cols])
19encoded_df = pd.DataFrame(X_encoded, columns=encoder.get_feature_names_out(categorical_cols))
20
21# Standardize numerical columns
22scaler = StandardScaler()
23X_scaled = scaler.fit_transform(X[numerical_cols])
24scaled_df = pd.DataFrame(X_scaled, columns=numerical_cols)
25
26# Combine encoded categorical columns and scaled numerical columns
27X_processed = pd.concat([encoded_df, scaled_df], axis=1)
28
29# Split the data into training and testing sets
30X_train, X_test, y_train, y_test = train_test_split(X_processed, y, test_size=0.2, random_state=42)
31
32# Create and train models
33models = {
34    'Logistic Regression': LogisticRegression(),
35    'Random Forest': RandomForestClassifier(),
36    'XGBoost': XGBClassifier(),
37}
38
39results = {}
40for name, model in models.items():
41    # Adjust labels for XGBoost
42    if name == 'XGBoost':
43        # Encode labels to start from 0 as expected by XGBoost
44        encoder = LabelEncoder()
45        y_train_encoded = encoder.fit_transform(y_train)
46        y_test_encoded = encoder.transform(y_test)
47
48        # Fit the model using encoded labels
49        model.fit(X_train, y_train_encoded)
50        y_pred = model.predict(X_test)
51        # Decode predictions to original labels for accuracy calculation
52        y_pred_original = encoder.inverse_transform(y_pred)
53        accuracy = accuracy_score(y_test, y_pred_original)
54    else:
55        # Fit the model using original labels
56        model.fit(X_train, y_train)
57        y_pred = model.predict(X_test)
58        accuracy = accuracy_score(y_test, y_pred)
59
60    results[name] = accuracy
61    print(f'{name} Accuracy: {accuracy:.4f}')
62
63# Identify the best performing model
64best_model = max(results, key=lambda name: results[name])
65print(f'Best Performing Model: {best_model}')

1# Find the maximum `Quantity_Sold`
2maximum_quantity_sold_liters = avg_quantity_sorted['Quantity_Sold'].max()
3
4# Filter the data with the maximum `Quantity_Sold`
5filtered_df = avg_quantity_sorted[avg_quantity_sorted['Quantity_Sold'] == maximum_quantity_sold_liters]
6
7# Print the data with the maximum `Quantity_Sold`
8print(filtered_df[['Fuel_Type' , 'Quantity_Sold']].to_markdown(index=False, numalign="left", stralign="left"))

1import altair as alt
2
3# Create a list `order` with elements 'Yoga', 'HIIT', 'Cardio', and 'Strength'.
4order = ['Yoga', 'HIIT', 'Cardio', 'Strength']
5# Create a bar chart using the `Workout_Type` column on the x-axis and the `Calories_Burned` column on the y-axis.
6chart = alt.Chart(median_calories_burned).mark_bar().encode(
7    # Set x-axis title as 'Workout Type' and y-axis title as 'Median Calories Burned'.
8    x=alt.X('Workout_Type', sort=order, title='Workout Type'),
9    # Use the `order` list to control the order of the bars.
10    y=alt.Y('Calories_Burned', title='Median Calories Burned'),
11    # Add tooltips for columns `Workout_Type` and `Calories_Burned`.
12    tooltip = ['Workout_Type', 'Calories_Burned']
13).properties(
14    # Set the title of the plot to 'Median Calories Burned by Workout Type'.
15    title='Median Calories Burned by Workout Type'
16).interactive() # Make the plot interactive enabling zooming and panning.
17# Save the chart to a JSON file
18chart.save('median_calories_burned_by_workout_type_bar_chart.json')

1import altair as alt
2
3# Create the base chart
4base = alt.Chart(df_plot).encode(theta=alt.Theta("count", stack=True))
5# Specify the outer radius of the arcs and encode color based on the `marital.status` 
6columnpie = base.mark_arc(outerRadius=120).encode(
7  color=alt.Color("marital.status"),
8  # Order the arcs by `count` in descending order
9  order=alt.Order("percentage", sort="descending"),
10  tooltip=["marital.status", "count", alt.Tooltip("percentage", format=".1%")]
11)
12# Add text to show the percentage on the chart
13text = base.mark_text(radius=140).encode(
14  text=alt.Text("percentage", format=".1%"),
15  order=alt.Order("percentage", sort="descending"),
16  color=alt.value("black") # Set the color of the labels to black
17)
18# Combine the pie chart and text
19chart = pie + text
20# Add title to the chart
21chart = chart.properties(title='Distribution of Marital Status')
22# Save the chart in json file
23chart.save('marital_status_pie_chart.json')

1import altair as alt
2          
3# Create a stacked bar chart
4chart = alt.Chart(df_plot).mark_bar().encode(
5  # Set the x-axis to display the companies
6  x=alt.X('Company', title='Company'),
7  # Set the y-axis to display the number of laptops sold
8  y=alt.Y('Number of Laptops', title='Number of Laptops'),
9  # Use different colors for each laptop
10  typecolor='TypeName',
11  # Add tooltips to show details when hovering over each bar
12  tooltip=['Company', 'TypeName', 'Number of Laptops']).properties(
13    # Set the chart title
14    title='Total Laptops Sold by Company and Type'
15    ).interactive() # Make the chart interactive for zooming and panning
16# Save the chart as a JSON file
17chart.save('total_laptops_sold_by_company_and_type_stacked_bar_chart.json')