GrantScope

import json import pandas as pd import numpy as np from pandas.io.json import json_normalize def read_json(file_path): with open(file_path, 'r') as f: json_data = json.load(f) return json_data file_path = '/work/HITUpgradesFull_fix.txt' json_data = read_json(file_path) # Normalize the json data into a dataframe df = pd.json_normalize(json_data['data']['rows']) # Create a new column 'grant_index' that stores the original 'grant_key' for each row df['grant_index'] = df['grant_key'] # Process semicolon-separated "_code" and "_tran" columns individually code_columns = [col for col in df.columns if "_code" in col] tran_columns = [col for col in df.columns if "_tran" in col] for code_col in code_columns: df[code_col] = df[code_col].str.split(';') df = df.explode(code_col) for tran_col in tran_columns: df[tran_col] = df[tran_col].str.split(';') df = df.explode(tran_col) # Identify columns by type text_columns = df.select_dtypes(include=['object']).columns.tolist() numeric_columns = df.select_dtypes(include=['float64', 'int64']).columns.tolist() date_columns = [] # Assume no date columns for this example # Define fill-in values for different types of data fill_values = { 'text': 'Unknown', 'numeric': np.nan, # Will be filled based on median or mean 'date': '01/01/2022' } # Fill missing values for col in text_columns: df[col].fillna(fill_values['text'], inplace=True) for col in numeric_columns: median_value = df[col].median() df[col].fillna(median_value, inplace=True) for col in date_columns: df[col] = pd.to_datetime(df[col]) # Ensure date column is of datetime dtype df[col].fillna(pd.to_datetime(fill_values['date']), inplace=True) # Check if any missing values remain remaining_missing_values = df.isnull().sum().sum() if remaining_missing_values > 0: print(f"Warning: {remaining_missing_values} missing values remain in the DataFrame.")

import matplotlib.pyplot as plt import seaborn as sns import plotly.express as px # Define the bins for the USD amount clusters bins = [0, 10000, 50000, 100000, 1000000, np.inf] names = ['1k-10k', '10k-50k', '50k-100k', '100k-1M', '1M+'] # Create a new column for the USD amount clusters df['amount_usd_cluster'] = pd.cut(df['amount_usd'], bins, labels=names) # Group by 'grant_index' to ensure we only count each grant once when summing 'amount_usd' grouped_df = df.groupby('grant_index').first() # Create a bar plot of the number of unique grants by USD amount cluster plt.figure(figsize=(10, 6)) grouped_df['amount_usd_cluster'].value_counts().sort_index().plot(kind='bar') plt.title('Number of Unique Grants by USD Amount Cluster') plt.ylabel('Number of Unique Grants') plt.show() # Create a bar plot of the total grant amount by USD amount cluster plt.figure(figsize=(10, 6)) grouped_df.groupby('amount_usd_cluster')['amount_usd'].sum().sort_index().plot(kind='bar') plt.title('Total Grant Amount by USD Amount Cluster') plt.ylabel('Total Grant Amount (USD)') plt.show() # Create an interactive scatter plot of the grant amount by year, colored by USD amount cluster fig = px.scatter(grouped_df, x='year_issued', y='amount_usd', color='amount_usd_cluster') fig.update_layout(title='Grant Amount by Year', xaxis_title='Year Issued', yaxis_title='Grant Amount (USD)') fig.show()

import seaborn as sns import matplotlib.pyplot as plt import numpy as np # Define a custom colormap with zero values as white ('#FFFFFF') cmap = sns.color_palette("plasma", as_cmap=True) cmap.set_bad(color='black') # For pivot_population_strategy plt.figure(figsize=(12, 8)) sns.heatmap(pivot_population_strategy, cmap=cmap, mask=pivot_population_strategy == 0, cbar_kws={'extend': 'min'}) plt.title('Total Grant Amount by Grant Population and Grant Strategy') plt.show() # For pivot_city_strategy plt.figure(figsize=(12, 8)) sns.heatmap(pivot_city_strategy, cmap=cmap, mask=pivot_city_strategy == 0, cbar_kws={'extend': 'min'}) plt.title('Total Grant Amount by Recipient City and Grant Strategy') plt.show()

# Create a pivot table of the total grant amount by grant population and grant strategy pivot_population_strategy = grouped_df.groupby(['grant_population_tran', 'grant_strategy_tran'])['amount_usd'].sum().unstack().fillna(0) # Keep only the top 20 populations and strategies by total grant amount top_populations = pivot_population_strategy.sum(axis=1).nlargest(20).index top_strategies = pivot_population_strategy.sum(axis=0).nlargest(20).index pivot_population_strategy = pivot_population_strategy.loc[top_populations, top_strategies] # Create a heatmap of the pivot table plt.figure(figsize=(12, 8)) sns.heatmap(pivot_population_strategy, cmap='plasma') plt.title('Total Grant Amount by Grant Population and Grant Strategy') plt.show() # Create a pivot table of the total grant amount by recipient city and grant strategy pivot_city_strategy = grouped_df.groupby(['recip_city', 'grant_strategy_tran'])['amount_usd'].sum().unstack().fillna(0) # Keep only the top 20 cities and strategies by total grant amount top_cities = pivot_city_strategy.sum(axis=1).nlargest(20).index top_strategies = pivot_city_strategy.sum(axis=0).nlargest(20).index pivot_city_strategy = pivot_city_strategy.loc[top_cities, top_strategies] # Create a heatmap of the pivot table plt.figure(figsize=(12, 8)) sns.heatmap(pivot_city_strategy, cmap='plasma') plt.title('Total Grant Amount by Recipient City and Grant Strategy') plt.show()

from wordcloud import WordCloud from wordcloud import WordCloud, STOPWORDS # Create a pivot table of the total grant amount by funder and grant strategy pivot_funder_strategy = grouped_df.groupby(['funder_name', 'grant_strategy_tran'])['amount_usd'].sum().unstack().fillna(0) # Keep only the top 20 funders and strategies by total grant amount top_funders = pivot_funder_strategy.sum(axis=1).nlargest(20).index top_strategies = pivot_funder_strategy.sum(axis=0).nlargest(20).index pivot_funder_strategy = pivot_funder_strategy.loc[top_funders, top_strategies] # Create a heatmap of the pivot table plt.figure(figsize=(12, 8)) sns.heatmap(pivot_funder_strategy, cmap='plasma') plt.title('Total Grant Amount by Funder and Grant Strategy') plt.show() # Create a pivot table of the total grant amount by funder and grant population pivot_funder_population = grouped_df.groupby(['funder_name', 'grant_population_tran'])['amount_usd'].sum().unstack().fillna(0) # Keep only the top 20 funders and populations by total grant amount top_funders = pivot_funder_population.sum(axis=1).nlargest(20).index top_populations = pivot_funder_population.sum(axis=0).nlargest(20).index pivot_funder_population = pivot_funder_population.loc[top_funders, top_populations] # Define the words to remove stopwords = set(STOPWORDS) stopwords.update(['public', 'Public', 'health', 'Health']) # Create a word cloud for each amount_usd bin for bin_name in names: # Select the top 20 grants in this bin by amount_usd top_grants = grouped_df[grouped_df['amount_usd_cluster'] == bin_name].nlargest(20, 'amount_usd') # Combine the grant descriptions into one text text = ' '.join(top_grants['grant_description']) # Create a word cloud wordcloud = WordCloud(stopwords=stopwords, width=800, height=400).generate(text) # Display the word cloud plt.figure(figsize=(10, 5)) plt.imshow(wordcloud, interpolation='bilinear') plt.axis('off') plt.title(f'Word Cloud of Grant Descriptions for {bin_name} Bin') plt.show()

Analysis by Grant Amount Bins

Analysis by Grant Amount Bins This section loops through each grant amount bin and performs focused analysis on grants in that bin.

For each bin, it generates:

Funder vs Strategy heatmap showing total grant amount for top funders and strategies

Funder vs Population heatmap for top funders and populations

Word cloud of grant descriptions for the top grants

Analyzing each bin separately reveals insights and trends specific to grants of those size ranges. The funder preference heatmaps show if funding priorities shift for larger or smaller grants. The word clouds highlight description differences across the bins.

By segmenting the analysis into the grant amount bins, we can compare and contrast patterns between the small and large grants. Looping through each bin automates generating the same set of visualizations for each one.

This drill-down by grant size provides a more nuanced view compared to analyzing the full data together. The amount clusters help simplify the analysis and avoid results being dominated by the large grants.

import matplotlib.pyplot as plt import seaborn as sns for bin_name in names: filtered_df = grouped_df[grouped_df['amount_usd_cluster'] == bin_name] if not filtered_df.empty: # Funder vs. Strategy pivot_funder_strategy = filtered_df.groupby(['funder_name', 'grant_strategy_tran'])['grant_key'].nunique().unstack().fillna(0) top_funders = pivot_funder_strategy.sum(axis=1).nlargest(20).index top_strategies = pivot_funder_strategy.sum(axis=0).nlargest(20).index pivot_funder_strategy = pivot_funder_strategy.loc[top_funders, top_strategies] if not pivot_funder_strategy.empty: plt.figure(figsize=(12, 8)) sns.heatmap(pivot_funder_strategy, cmap='plasma') plt.title(f'Number of Unique Grants by Funder and Grant Strategy for {bin_name} Bin') plt.show() # Funder vs. Population pivot_funder_population = filtered_df.groupby(['funder_name', 'grant_population_tran'])['grant_key'].nunique().unstack().fillna(0) top_funders = pivot_funder_population.sum(axis=1).nlargest(20).index top_populations = pivot_funder_population.sum(axis=0).nlargest(20).index pivot_funder_population = pivot_funder_population.loc[top_funders, top_populations] if not pivot_funder_population.empty: plt.figure(figsize=(12, 8)) sns.heatmap(pivot_funder_population, cmap='plasma') plt.title(f'Number of Unique Grants by Funder and Grant Population for {bin_name} Bin') plt.show() # Word Clouds top_grants = filtered_df.nlargest(20, 'amount_usd') if not top_grants.empty: text = ' '.join(top_grants['grant_description']) wordcloud = WordCloud(stopwords=stopwords, width=800, height=400).generate(text) plt.figure(figsize=(10, 5)) plt.imshow(wordcloud, interpolation='bilinear') plt.axis('off') plt.title(f'Word Cloud of Grant Descriptions for {bin_name} Bin') plt.show()

from matplotlib.colors import LinearSegmentedColormap, LogNorm # Define custom colormap cmap_list = [(0, 'white'), (0.1, 'lightblue'), (0.5, 'blue'), (0.9, 'darkblue'), (1, 'orange')] cmap = LinearSegmentedColormap.from_list('custom', cmap_list, N=256) for bin_name in names: filtered_df = grouped_df[grouped_df['amount_usd_cluster'] == bin_name] # Funder vs. Strategy pivot_funder_strategy = filtered_df.groupby(['funder_name', 'grant_strategy_tran'])['amount_usd'].sum().unstack().fillna(0) top_funders = pivot_funder_strategy.sum(axis=1).nlargest(20).index top_strategies = pivot_funder_strategy.sum(axis=0).nlargest(20).index pivot_funder_strategy = pivot_funder_strategy.loc[top_funders, top_strategies] plt.figure(figsize=(12, 8)) sns.heatmap(pivot_funder_strategy, cmap=cmap, norm=LogNorm(vmin=0.01, vmax=pivot_funder_strategy.max().max())) plt.title(f'Total Grant Amount by Funder and Grant Strategy for {bin_name} Bin') plt.show() # Funder vs. Population pivot_funder_population = filtered_df.groupby(['funder_name', 'grant_population_tran'])['amount_usd'].sum().unstack().fillna(0) top_funders = pivot_funder_population.sum(axis=1).nlargest(20).index top_populations = pivot_funder_population.sum(axis=0).nlargest(20).index pivot_funder_population = pivot_funder_population.loc[top_funders, top_populations] plt.figure(figsize=(12, 8)) sns.heatmap(pivot_funder_population, cmap=cmap, norm=LogNorm(vmin=0.01, vmax=pivot_funder_population.max().max())) plt.title(f'Total Grant Amount by Funder and Grant Population for {bin_name} Bin') plt.show()

Expanded Heatmap Analysis

This expands the heatmap analysis to explore grant amounts across multiple categories beyond just strategy and population.

It loops through each grant amount bin, and for each bin:

Iterates through a defined list of categories (strategy, population, state, city, duration, recipient name, etc)

Generates a pivot table of grant amount summed by funder and that category

Keeps the top 20 funders and top categories

Plots a log scaled heatmap of the pivot table

This provides a comprehensive view into funder preferences across different dimensions for grants of varying sizes. The multiple heatmaps enable comparing how priorities shift between categories and across the grant amount bins.

Automating the heatmap creation across categories and bins makes it easy to generate a suite of visualizations to thoroughly analyze the data from multiple angles.

The log scaling continues to improve dynamic range visualization. And filtering to the top funders and categories simplifies the charts to focus on the most relevant segments.

Together this expanded analysis provides a detailed drill-down into the grant amount data to extract insights across funders, categories, and grant sizes.

# Importing required libraries import pandas as pd import seaborn as sns import matplotlib.pyplot as plt from matplotlib.colors import LinearSegmentedColormap, LogNorm # Define the custom colormap cmap_list = [(0, 'white'), (0.1, 'lightblue'), (0.5, 'blue'), (0.9, 'darkblue'), (1, 'orange')] cmap = LinearSegmentedColormap.from_list('custom', cmap_list, N=256) # Categories to explore in heatmaps categories = ['grant_strategy_tran', 'grant_population_tran', 'recip_state', 'recip_city', 'grant_duration', 'recip_name'] # Loop through each bin for detailed analysis for bin_name in names: filtered_df = grouped_df[grouped_df['amount_usd_cluster'] == bin_name] for category in categories: # Create pivot table pivot_data = filtered_df.groupby(['funder_name', category])['amount_usd'].sum().unstack().fillna(0) # Filter to top 20 top_funders = pivot_data.sum(axis=1).nlargest(20).index top_category = pivot_data.sum(axis=0).nlargest(20).index pivot_data = pivot_data.loc[top_funders, top_category] # Create heatmap plt.figure(figsize=(12, 8)) sns.heatmap(pivot_data, cmap=cmap, norm=LogNorm(vmin=0.01, vmax=pivot_data.max().max())) plt.title(f'Total Grant Amount by Funder and {category} for {bin_name} Bin') plt.show()

import plotly.express as px import pandas as pd import numpy as np # Assuming df is your DataFrame numeric_columns = df.select_dtypes(include=['number']).columns.tolist() if 'amount_usd_cluster' in numeric_columns: numeric_columns.remove('amount_usd_cluster') # Define a function to capture the tail information def analyze_tail(df, col): q1 = df[col].quantile(0.25) q3 = df[col].quantile(0.75) iqr = q3 - q1 lower_bound = q1 - 1.5 * iqr upper_bound = q3 + 1.5 * iqr lower_tail = df[df[col] < lower_bound] upper_tail = df[df[col] > upper_bound] return lower_tail, upper_tail # Iterate over each 'amount_usd_cluster' bin for bin_name in df['amount_usd_cluster'].unique(): filtered_df = df[df['amount_usd_cluster'] == bin_name].sample(min(len(df[df['amount_usd_cluster'] == bin_name]), 500)) print(f"Analysis for bin: {bin_name}") # Univariate Analysis for col in numeric_columns: # Histogram fig = px.histogram(filtered_df, x=col, height=400, width=400) fig.show() # Boxplot fig = px.box(filtered_df, y=col, height=400, width=400) fig.show() # Analyze Tails lower_tail, upper_tail = analyze_tail(filtered_df, col) # Lower Tail Statistics print(f"Lower tail statistics for {col}") print(lower_tail.describe()) # Upper Tail Statistics print(f"Upper tail statistics for {col}") print(upper_tail.describe())

# Required Libraries import pandas as pd import numpy as np import matplotlib.pyplot as plt # Creating Bins and Adding to DataFrame bins = [0, 10000, 50000, 100000, 1000000, np.inf] labels = ['1k-10k', '10k-50k', '50k-100k', '100k-1M', '1M+'] df['amount_usd_cluster'] = pd.cut(df['amount_usd'], bins=bins, labels=labels) # Group by grant index and funder_name to get unique sums grouped_df = df.groupby(['grant_index', 'funder_name', 'amount_usd_cluster']).agg({'amount_usd': 'sum'}).reset_index() # Plotting Top 10 Funders by Grant Amount for each Bin for label in labels: filtered_df = grouped_df[grouped_df['amount_usd_cluster'] == label] funder_amount = filtered_df.groupby('funder_name')['amount_usd'].sum().sort_values(ascending=False) if not funder_amount.empty: plt.figure(figsize=(10, 6)) funder_amount.nlargest(10).plot(kind='barh', color='skyblue') plt.xlabel('Total Grant Amount (USD)') plt.title(f'Top 10 Funders by Total Grant Amount for {label}') plt.yticks(rotation=0) plt.show()

import matplotlib.pyplot as plt import seaborn as sns # List of key categorical columns to be analyzed key_categorical_columns = ['funder_type', 'recip_organization_code', 'grant_subject_code', 'grant_population_code', 'grant_strategy_code', 'year_issued'] # Drop duplicate rows based on grant_key df.drop_duplicates(subset=['grant_key'], inplace=True) # Replace NaN values in categorical columns with 'Unknown' df[key_categorical_columns] = df[key_categorical_columns].fillna('Unknown') # Examine the frequency distribution of categorical columns (top 10 categories for demonstration) plt.figure(figsize=(20, 20)) # Loop through the columns and create count plots based on unique grant_key for i, col in enumerate(key_categorical_columns, 1): plt.subplot(3, 2, i) normalized_counts = df.groupby(col)['grant_key'].nunique().sort_values(ascending=False).iloc[:10] sns.barplot(y=normalized_counts.index, x=normalized_counts.values) plt.title(f'Normalized Distribution of {col}') plt.xlabel('Unique Grant Keys') plt.ylabel(f'{col}') plt.tight_layout() plt.show()

import pandas as pd import plotly.express as px from textwrap import shorten # Numeric columns bins = [-1, 10000, 50000, 100000, 1000000, float('inf')] labels = ['0-10K', '10K-50K', '50K-100K', '100K-1M', '1M+'] df['amount_usd_bins'] = pd.cut(df['amount_usd'], bins=bins, labels=labels) # Simplified, subdued color palette simple_colors = ['#1F5673', '#2F6999', '#489CBF', '#72CAE3', '#A3E4F7'] # Numeric data visualizations for label in labels: filtered_df = df[df['amount_usd_bins'] == label] if not filtered_df.empty: fig = px.histogram(filtered_df, x='amount_usd', nbins=50, title=f"Distribution of amount_usd: {label}") fig.update_traces(marker_color=simple_colors[0]) fig.show() fig = px.histogram(df, x='amount_usd', nbins=50, log_y=True, title="Overall Distribution of amount_usd") fig.update_traces(marker_color=simple_colors[0]) fig.show() # Categorical data visualizations for col in key_categorical_columns: normalized_counts = df.groupby(col)['grant_key'].nunique().sort_values(ascending=False).iloc[:10].reset_index() normalized_counts.columns = [col, 'Unique Grant Keys'] # Truncate legend text normalized_counts['truncated_col'] = normalized_counts[col].apply(lambda x: shorten(x, width=30, placeholder="...")) fig = px.bar(normalized_counts, x='Unique Grant Keys', y=col, orientation='h', color='truncated_col', title=f"Top 10 Categories in {col}", color_discrete_sequence=simple_colors) fig.update_layout(showlegend=False) fig.show()

# Bivariate Analysis: Categorical-Numeric Relationships (Sampled Data) import plotly.express as px # Create a column with abbreviated funder_type names, taking only the first two words df['funder_type_abbrev'] = df['funder_type'].apply(lambda x: ' '.join(x.split()[:2])) # Define hover data to show full funder_type names on hover hover_data = {'funder_type': True} # Subdued color palette subdued_colors = ['#3E5A75', '#637C94', '#879EB3', '#ABBFD2', '#CEDFF1'] # Create a dictionary to map 'funder_type_abbrev' to colors color_map = {abbrev: color for abbrev, color in zip(df['funder_type_abbrev'].unique(), subdued_colors)} # Bivariate Analysis for label in labels: filtered_df = df[df['amount_usd_bins'] == label] if not filtered_df.empty: fig = px.box( filtered_df, x='funder_type_abbrev', y='amount_usd', color='funder_type_abbrev', title=f"Amount in USD by Funder Type: {label}", labels={'funder_type_abbrev': 'Funder Type', 'amount_usd': 'Amount in USD'}, hover_data=hover_data, color_discrete_map=color_map # Using the color map ) fig.update_traces(hoverinfo="all") fig.show()

# Function to create interactive box plots for each amount_usd_bin and category def create_interactive_box_plots(df, category_columns, amount_column, bins_labels): # Check if the category columns are present in the dataframe missing_columns = [col for col in category_columns if col not in df.columns] if missing_columns: print(f"Skipping missing columns: {', '.join(missing_columns)}") valid_category_columns = [col for col in category_columns if col in df.columns] hover_data = {col: True for col in valid_category_columns} # Loop through each category column for col in valid_category_columns: # Create an abbreviation column df[f"{col}_abbrev"] = df[col].apply(lambda x: ' '.join(str(x).split()[:2])) # Loop through each label to create individual box plots for label in bins_labels: filtered_df = df[df['amount_usd_bins'] == label] if not filtered_df.empty: fig = px.box( filtered_df, x=f"{col}_abbrev", y=amount_column, color=f"{col}_abbrev", title=f"Amount in USD by {col}: {label}", labels={f"{col}_abbrev": col, amount_column: 'Amount in USD'}, hover_data=hover_data ) # Update hover information fig.update_traces(hoverinfo="all") fig.show() # Define the category columns you're interested in interested_columns = ['funder_state', 'funder_city', 'recip_state', 'recip_city', 'grant_population_trans', 'grant_subject_trans'] # Define the amount column and bin labels amount_col = 'amount_usd' bins_labels = ['0-10K', '10K-50K', '50K-100K', '100K-1M', '1M+'] # Call the function create_interactive_box_plots(df, interested_columns, amount_col, bins_labels)

from wordcloud import WordCloud import matplotlib.pyplot as plt # Prepare the text data, remove specified words text_data = ' '.join(df['grant_subject_tran']) remove_words = ['health', 'care', 'public', 'Public', 'Health'] for word in remove_words: text_data = text_data.replace(word, '') # Generate a word cloud for the 'grant_subject_tran' field plt.figure(figsize=(12, 8)) wordcloud = WordCloud(background_color='white').generate(text_data) plt.imshow(wordcloud, interpolation='bilinear') plt.axis("off") plt.title('Word Cloud for Grant Subjects (Filtered)') plt.show()

# Define a subdued color palette subdued_colors = px.colors.qualitative.Safe # Columns to analyze analyze_columns = ['grant_strategy_tran', 'grant_subject_tran', 'grant_population_tran'] # Treemaps for Count of grant_keys for col in analyze_columns: for label in labels: filtered_df = df[df['amount_usd_bins'] == label] grouped_df = filtered_df.groupby(col)['grant_key'].count().reset_index().sort_values(by='grant_key', ascending=False) if not grouped_df.empty: fig = px.treemap( grouped_df, path=[col], values='grant_key', title=f"Treemap: Count of Grant Keys by {col} for {label} USD range", color_discrete_sequence=subdued_colors ) fig.update_traces(textinfo="label+value") fig.show()

# Treemaps for Sum of amount_usd for col in analyze_columns: for label in labels: filtered_df = df[df['amount_usd_bins'] == label] grouped_df = filtered_df.groupby(col)['amount_usd'].sum().reset_index().sort_values(by='amount_usd', ascending=False) if not grouped_df.empty: fig = px.treemap( grouped_df, path=[col], values='amount_usd', title=f"Treemap: Sum of Amount in USD by {col} for {label} USD range", color_discrete_sequence=subdued_colors ) fig.update_traces(textinfo="label+value") fig.show()

# Create a DataFrame to hold unique grant keys count and total amount for each state and amount bin state_bin_totals = df.groupby(['recip_state', 'amount_usd_bins'])['amount_usd'].agg(['sum', 'count']).reset_index() state_bin_totals.rename(columns={'sum': 'total_amount', 'count': 'unique_grants'}, inplace=True) # Loop through each label to create individual choropleth maps for label in labels: filtered_df = state_bin_totals[state_bin_totals['amount_usd_bins'] == label] if not filtered_df.empty: # Map for total dollars awarded by state for current bin fig1 = px.choropleth( filtered_df, scope='usa', locations='recip_state', locationmode='USA-states', color='total_amount', color_continuous_scale='Viridis', title=f'Total Dollars Awarded by State in the USA: {label}', labels={'total_amount':'Total Amount Awarded'}, hover_data=['unique_grants'] ) fig1.show() # Map for unique grant keys by state for current bin fig2 = px.choropleth( filtered_df, scope='usa', locations='recip_state', locationmode='USA-states', color='unique_grants', color_continuous_scale='Viridis', title=f'Unique Grant Keys by State in the USA: {label}', labels={'unique_grants':'Unique Grant Keys'}, hover_data=['total_amount'] ) fig2.show()

# Key columns to generate the box plots key_columns = ['grant_strategy_tran', 'grant_population_tran', 'grant_transaction_tran', 'grant_subject_tran'] # Subdued color palette subdued_colors = ['#3E5A75', '#637C94', '#879EB3', '#ABBFD2', '#CEDFF1'] # Loop through each key column for key_col in key_columns: # Loop through each label to visualize data for label in labels: filtered_df = df[df['amount_usd_bins'] == label] if not filtered_df.empty: # Generate a color map for the current key column color_map = {abbrev: color for abbrev, color in zip(filtered_df[key_col].unique(), subdued_colors)} # Box plot fig = px.box( filtered_df, x=key_col, y='amount_usd', color=key_col, title=f"Amount in USD by {key_col}: {label}", labels={key_col: key_col.replace("_", " ").title(), 'amount_usd': 'Amount in USD'}, color_discrete_map=color_map ) # Customize axis to display in USD format fig.update_layout(yaxis_tickprefix='$', yaxis_title='Amount in USD') # Show plot fig.show()

# Color palette subdued_colors = ['#3E5A75', '#637C94', '#879EB3', '#ABBFD2', '#CEDFF1'] # Create a dictionary to map 'funder_type_abbrev' to colors color_map = {abbrev: color for abbrev, color in zip(df['funder_type_abbrev'].unique(), subdued_colors)} # Hover data hover_data = {'funder_type': True} # Loop through each label to visualize data for label in labels: filtered_df = df[df['amount_usd_bins'] == label] if not filtered_df.empty: # Box plot fig = px.box( filtered_df, x='funder_type_abbrev', y='amount_usd', color='funder_type_abbrev', title=f"Amount in USD by Funder Type: {label}", labels={'funder_type_abbrev': 'Funder Type', 'amount_usd': 'Amount in USD'}, hover_data=hover_data, color_discrete_map=color_map # Using the color map ) # Customize axis to display in USD format fig.update_layout(yaxis_tickprefix='$', yaxis_title='Amount in USD') fig.update_traces(hoverinfo="all") fig.show()