EDGAR Filer Analysis (1994 - 2022)

          1
          {
        

          2
            "2022": [
        

          3
              {
        

          4
                "cik": "789019",
        

          5
                "companyName": "MICROSOFT CORP (Issuer)",
        

          6
                "irsNo": "911144442",
        

          7
                "fiscalYearEnd": "0630",
        

          8
                "stateOfIncorporation": "WA",
        

          9
                "sic": "7372 Services-Prepackaged Software",
        

          10
                "year": "2022"
        

          11
              },
        

          12
              {
        

          13
                "cik": "902012",
        

          14
                "companyName": "GATES WILLIAM H III (Reporting)",
        

          15
                "year": "2022"
        

          16
              }
        

          17
              // ... additional filers
        

          18
            ]
        

          19
            // ... other years
        

          20
          }
        

          1
          !pip install -q sec-api
        

          1
          import pandas as pd
        

          2
          import numpy as np
        

          3
          import matplotlib.pyplot as plt
        

          4
          import matplotlib.ticker as mtick
        

          5
          import seaborn as sns
        

          6
          import json
        

          7
          import requests
        

          8
          
        

          9
          plt.rcParams.update({'font.size': 9})
        

          1
          # load entities_1994_2011.json into entities_1994_2011 variable
        

          2
          url_a = "https://statistics.sec-api.io/tutorials/edgar-filer-analysis/entities_1994_2011.json"
        

          3
          response_a = requests.get(url_a)
        

          4
          entities_1994_2011 = response_a.json()
        

          5
          
        

          6
          url_b = "https://statistics.sec-api.io/tutorials/edgar-filer-analysis/entities_2012_2022.json"
        

          7
          response_b = requests.get(url_b)
        

          8
          entities_2012_2022 = response_b.json()
        

          9
          
        

          10
          # merge entities_1994_2011 and entities_2012_2022 into entities variable
        

          11
          entities_json = {**entities_1994_2011, **entities_2012_2022}
        

          1
          def convert_json_to_dataframe(entities_json: dict) -> pd.DataFrame:
        

          2
              entities_json_list = []
        

          3
          
        

          4
              for year in entities_json.keys():
        

          5
                  for entity in entities_json[year]:
        

          6
                      entity['cik'] = entity['cik'].lstrip('0')
        

          7
                      entity['year'] = year
        

          8
                      entities_json_list.append(entity)
        

          9
          
        

          10
              entities = pd.DataFrame(entities_json_list)
        

          11
          
        

          12
              return entities
        

          13
          
        

          14
          entities = convert_json_to_dataframe(entities_json)
        

          15
          entities.drop(labels=['act', 'fileNo', 'type', 'filmNo'], axis=1, inplace=True)
        

          16
          year = entities['year']
        

          17
          entities.drop(labels=['year'], axis=1, inplace=True)
        

          18
          entities.insert(0, 'year', year)
        

          19
          entities['year'] = entities['year'].astype(int)
        

          1
          print('All EDGAR entities from 1994 - 2022')
        

          2
          entities # 3056738 rows
        

          1
          from sec_api import MappingApi
        

          2
          
        

          3
          mappingApi = MappingApi(api_key='YOUR_API_KEY')
        

          1
          mappings_json = mappingApi.resolve('cik', '[0-9]')
        

          1
          mappings = pd.DataFrame(mappings_json).drop(columns=["id"])
        

          2
          mappings["cik"] = mappings["cik"].astype(str)
        

          3
          mappings[mappings["sector"] == ""] = np.nan
        

          4
          mappings[mappings["industry"] == ""] = np.nan
        

          1
          print(f"Number of mappings: {len(mappings)}")
        

          2
          mappings.head()
        

          1
          tmp_mappings = mappings.dropna(subset=['sector', 'industry'])
        

          2
          print(f"{len(entities)} filers before merging")
        

          3
          entities = entities.merge(tmp_mappings[['cik', 'sector', 'industry']].drop_duplicates(subset=['cik']), how='left', on='cik')
        

          4
          entities.drop_duplicates(inplace=True)
        

          5
          entities.reset_index(drop=True, inplace=True)
        

          6
          print(f"{len(entities)} filers after merging")
        

          1
          entities[entities['year']==2022].head()
        

          1
          sic_code_url = "https://statistics.sec-api.io/tutorials/edgar-filer-analysis/sic-codes-list.json"
        

          2
          sic_code_response = requests.get(sic_code_url)
        

          3
          sic_codes_json = sic_code_response.json()
        

          1
          sic_codes = pd.DataFrame(sic_codes_json)
        

          2
          sic_codes['sic_code'] = sic_codes['sic_code'].astype(str)
        

          1
          sic_codes
        

          1
          # split "sic" column in sic_stats into "sic_code" and "sic_industry" columns by splitting at first space
        

          2
          entities[['sic_code', 'sic_industry']] = entities['sic'].str.split(n=1, expand=True)
        

          3
          entities['sic_code'] = entities['sic_code'].str.lstrip('0')
        

          4
          entities['sic_code'].replace('', np.nan, inplace=True)
        

          5
          entities['sic_industry'].replace({None: np.nan}, inplace=True)
        

          1
          print(f"{len(entities)} filers before merging")
        

          2
          entities = entities.merge(sic_codes[['sic_code', 'office']], how='left', on='sic_code')
        

          3
          entities.reset_index(drop=True, inplace=True)
        

          4
          print(f"{len(entities)} filers after merging")
        

          1
          entities[entities['year']==2022].head()
        

          1
          years = entities['year'].unique().tolist()
        

          2
          num_entities = entities.groupby('year').size().tolist()
        

          3
          
        

          4
          plt.bar(years, num_entities)
        

          5
          plt.xlabel('Year'), plt.ylabel('Entities'), plt.title('EDGAR Entities per Year')
        

          6
          ax = plt.gca()
        

          7
          ax.yaxis.set_major_formatter(mtick.FuncFormatter(lambda x, p: format(int(x), ',')))
        

          8
          plt.xticks(years, rotation=90), plt.grid(axis='y'), plt.gca().set_axisbelow(True)
        

          9
          plt.show()
        

          1
          def get_new_filers_per_year(entities):
        

          2
              new_filers = None
        

          3
              processed_ciks = set()
        

          4
              years = entities['year'].unique().tolist()
        

          5
          
        

          6
              for year in years:
        

          7
                  ciks = entities[entities['year'] == year]['cik'].tolist()
        

          8
                  if year == 1994:
        

          9
                      new_filers = pd.DataFrame(entities[entities['year'] == year])
        

          10
                      processed_ciks.update(ciks)
        

          11
                      continue
        

          12
          
        

          13
                  year_entities = entities[entities['year'] == year]
        

          14
                  new_filers_for_year = year_entities[~year_entities['cik'].isin(processed_ciks)]
        

          15
                  new_filers = pd.concat([new_filers, new_filers_for_year], ignore_index=True)
        

          16
          
        

          17
                  processed_ciks.update(ciks)
        

          18
          
        

          19
              return new_filers
        

          1
          new_filers = get_new_filers_per_year(entities)
        

          1
          print('New EDGAR entities in 2020:', len(new_filers[new_filers['year'] == 2020])) # 35055
        

          1
          years = entities['year'].unique().tolist()
        

          2
          num_entities = entities.groupby('year').size().tolist()
        

          3
          num_new_filers = new_filers.groupby('year').size().tolist()
        

          4
          
        

          5
          plt.bar(years, num_entities, label='All entities')
        

          6
          plt.bar(years, num_new_filers, label='New entities')
        

          7
          plt.xlabel('Year'), plt.ylabel('Entities'), plt.title('New & Old EDGAR Entities per Year')
        

          8
          plt.legend()
        

          9
          ax = plt.gca()
        

          10
          ax.yaxis.set_major_formatter(mtick.FuncFormatter(lambda x, p: format(int(x), ',')))
        

          11
          plt.xticks(years, rotation=90), plt.grid(axis='y'), plt.gca().set_axisbelow(True)
        

          12
          plt.show()
        

          1
          years = entities['year'].unique().tolist()
        

          2
          
        

          3
          filers_df = pd.DataFrame({'total filers': num_entities, 'new filers': num_new_filers}, index=sorted(years))
        

          4
          filers_df['new filers %'] = filers_df['new filers'] / filers_df['total filers'] * 100
        

          5
          filers_df['new filers %'] = filers_df['new filers %'].map('{:,.1f}'.format)
        

          6
          filers_df['filers growth YoY'] = filers_df['total filers'].pct_change() * 100
        

          7
          filers_df['filers growth YoY'] = filers_df['filers growth YoY'].map('{:,.1f}'.format)
        

          8
          filers_df['new filers growth YoY'] = filers_df['new filers'].pct_change() * 100
        

          9
          filers_df['new filers growth YoY'] = filers_df['new filers growth YoY'].map('{:,.1f}'.format)
        

          10
          filers_df = filers_df.sort_index(ascending=False)
        

          11
          
        

          12
          filers_df.head()
        

          1
          filers_df['new filers growth YoY'] = filers_df['new filers growth YoY'].astype(float)
        

          2
          plt.figure(figsize=(5, 4)), plt.bar(filers_df.index, filers_df['new filers growth YoY'])
        

          3
          plt.title('New filers growth YoY (%)'), plt.xlabel('Year'), plt.ylabel('New filers growth YoY (%)')
        

          4
          plt.grid(axis='y'), plt.grid(axis='x')
        

          5
          plt.gca().set_axisbelow(True), plt.xticks(filers_df.index, rotation=90)
        

          6
          plt.show()
        

          1
          sector_stats = entities.groupby(['year', 'sector'], dropna=False).cik.count().reset_index(name='cik_count')
        

          2
          sector_stats[sector_stats['year'] == 2022].sort_values(by='cik_count', ascending=False).head(20)
        

          1
          sector_stats_pivot = sector_stats.pivot(index='year', columns='sector', values='cik_count')
        

          2
          sector_stats_pivot[-10:]
        

          1
          sector_stats_pivot.plot(kind='bar', stacked=True, figsize=(7, 5))
        

          2
          plt.title("EDGAR Filers per Sector per Year")
        

          3
          plt.ylabel("Filers"), plt.xlabel("Year"), plt.tight_layout()
        

          4
          ax = plt.gca()
        

          5
          ax.yaxis.set_major_formatter(mtick.FuncFormatter(lambda x, p: format(int(x), ',')))
        

          6
          handles, labels = ax.get_legend_handles_labels()
        

          7
          ax.legend(reversed(handles), reversed(labels), loc='lower left', bbox_to_anchor=(1, 0.5), fontsize=8)
        

          8
          plt.show()
        

          1
          sector_stats_pivot.drop(columns=[np.nan]).plot(kind='bar', stacked=True, figsize=(7, 5))
        

          2
          plt.title("EDGAR Filers per Sector per Year (Without NaN Category)")
        

          3
          plt.ylabel("Filers"), plt.xlabel("Year"), plt.tight_layout()
        

          4
          ax = plt.gca()
        

          5
          ax.yaxis.set_major_formatter(mtick.FuncFormatter(lambda x, p: format(int(x), ',')))
        

          6
          handles, labels = ax.get_legend_handles_labels()
        

          7
          ax.legend(reversed(handles), reversed(labels), loc='lower left', bbox_to_anchor=(1, 0.5), fontsize=8)
        

          8
          plt.show()
        

          1
          sector_stats_pivot.drop(columns=[np.nan]).plot(kind='line', figsize=(7, 5))
        

          2
          plt.title("EDGAR Filers per Sector per Year")
        

          3
          plt.ylabel("Filers"), plt.xlabel("Year"), plt.tight_layout(), plt.grid(True), plt.gca().set_axisbelow(True)
        

          4
          plt.xticks(sector_stats_pivot.index, rotation=90)
        

          5
          ax = plt.gca()
        

          6
          ax.yaxis.set_major_formatter(mtick.FuncFormatter(lambda x, p: format(int(x), ',')))
        

          7
          handles, labels = ax.get_legend_handles_labels()
        

          8
          ax.legend(reversed(handles), reversed(labels), loc='lower left', bbox_to_anchor=(1, 0.5), fontsize=8)
        

          9
          plt.show()
        

          1
          sector_stats_new_filers = new_filers.groupby(['year', 'sector'], dropna=False).cik.count().reset_index(name='cik_count')
        

          2
          sector_stats_new_filers[sector_stats_new_filers['year'] == 2022].sort_values(by='cik_count', ascending=False).head(20)
        

          1
          sector_stats_new_filers_pivot = sector_stats_new_filers.pivot(index='year', columns='sector', values='cik_count')
        

          2
          sector_stats_new_filers_pivot.fillna(0, inplace=True)
        

          3
          sector_stats_new_filers_pivot = sector_stats_new_filers_pivot.astype(int)
        

          4
          sector_stats_new_filers_pivot[-5:]
        

          1
          sector_stats_new_filers_pivot.loc[1997:, :].drop(columns=[np.nan]).plot(kind='bar', stacked=True, figsize=(7, 5))
        

          2
          plt.title("New EDGAR Filers per Sector Per Year"), plt.ylabel("New Filers"), plt.xlabel("Year"), plt.tight_layout()
        

          3
          ax = plt.gca()
        

          4
          ax.yaxis.set_major_formatter(mtick.FuncFormatter(lambda x, p: format(int(x), ',')))
        

          5
          handles, labels = ax.get_legend_handles_labels()
        

          6
          ax.legend(reversed(handles), reversed(labels), loc='lower left', bbox_to_anchor=(1, 0.5), fontsize=8)
        

          7
          plt.show()
        

          1
          industry_stats = entities.groupby(['year', 'industry'], dropna=False).cik.count().reset_index(name='cik_count')
        

          2
          industry_stats[industry_stats['year'] == 2022].sort_values(by='cik_count', ascending=False).head(10)
        

          1
          print('Number of industries:', len(industry_stats['industry'].unique()))
        

          1
          industry_stats_pivot = industry_stats.pivot(index='year', columns='industry', values='cik_count')
        

          2
          industry_stats_pivot.fillna(0, inplace=True)
        

          3
          industry_stats_pivot = industry_stats_pivot.astype(int)
        

          4
          industry_stats_pivot[-5:]
        

          1
          industry_stats_pivot.loc[1997:, :].drop(columns=[np.nan]).plot(kind='bar', stacked=True, figsize=(7, 5))
        

          2
          plt.title("EDGAR Filers per Industry Per Year")
        

          3
          plt.ylabel("New Filers"), plt.xlabel("Year"), plt.legend().set_visible(False)
        

          4
          plt.show()
        

          1
          industry_stats_new_filers = new_filers.groupby(['year', 'industry'], dropna=False).cik.count().reset_index(name='cik_count')
        

          2
          industry_stats_pivot_new_filers = industry_stats_new_filers.pivot(index='year', columns='industry', values='cik_count')
        

          3
          industry_stats_pivot_new_filers.fillna(0, inplace=True)
        

          4
          industry_stats_pivot_new_filers = industry_stats_pivot_new_filers.astype(int)
        

          5
          industry_stats_pivot_new_filers[-5:]
        

          1
          top_10_industries = {}
        

          2
          for year in range(1994, 2023):
        

          3
              top_10_industries[year] = industry_stats_new_filers[industry_stats_new_filers['year'] == year].sort_values(by='cik_count', ascending=False).head(20)
        

          4
              top_10_industries[year] = top_10_industries[year][top_10_industries[year]['cik_count'] > 15]
        

          5
          
        

          6
          top_10_industries_df = pd.concat(top_10_industries, axis=0)
        

          7
          top_10_industries_df.reset_index(inplace=True)
        

          8
          top_10_industries_df.drop(columns=['level_0', 'level_1'], inplace=True)
        

          9
          top_10_industries_df['year'] = top_10_industries_df['year'].astype(int)
        

          10
          top_10_industries_df
        

          1
          top_10_industries_df = top_10_industries_df['industry'].unique().tolist()
        

          1
          industry_stats_pivot_new_filers_top_10 = industry_stats_pivot_new_filers[top_10_industries_df]
        

          1
          industry_stats_pivot_new_filers_top_10.loc[1997:, :].drop(columns=[np.nan]).plot(kind='bar', stacked=True, figsize=(7, 5))
        

          2
          plt.title("New EDGAR Filers per Top 10 Industry Per Year"), plt.ylabel("New Filers"), plt.xlabel("Year")
        

          3
          ax = plt.gca()
        

          4
          handles, labels = ax.get_legend_handles_labels()
        

          5
          ax.legend(reversed(handles), reversed(labels), loc='center left', bbox_to_anchor=(1, 0.5), fontsize=8)
        

          6
          plt.show()
        

          1
          industry_stats_pivot_new_filers_top_10_pct_change = industry_stats_pivot_new_filers_top_10.pct_change() * 100
        

          2
          industry_stats_pivot_new_filers_top_10_pct_change = industry_stats_pivot_new_filers_top_10_pct_change.iloc[1:, :]
        

          3
          industry_stats_pivot_new_filers_top_10_pct_change = industry_stats_pivot_new_filers_top_10_pct_change.replace([np.inf, -np.inf], 0)
        

          4
          industry_stats_pivot_new_filers_top_10_pct_change = industry_stats_pivot_new_filers_top_10_pct_change.iloc[:, 1:]
        

          5
          industry_stats_pivot_new_filers_top_10_pct_change = industry_stats_pivot_new_filers_top_10_pct_change.reindex(sorted(industry_stats_pivot_new_filers_top_10_pct_change.columns), axis=1)
        

          6
          industry_stats_pivot_new_filers_top_10_pct_change[-5:]
        

          1
          sns.heatmap(industry_stats_pivot_new_filers_top_10_pct_change, cmap='Blues')
        

          2
          plt.gcf().set_size_inches(7, 7), plt.title("Change of New Filers per Industry per Year")
        

          3
          plt.ylabel("Year"), plt.xlabel(""), plt.tight_layout(), plt.grid(color='lightgrey', linestyle='dashed', linewidth=0.5)
        

          4
          ax = plt.gca()
        

          5
          ax.tick_params(axis='x', rotation=50), ax.set_xticklabels(ax.get_xticklabels(), ha='left')
        

          6
          plt.xticks(np.arange(len(industry_stats_pivot_new_filers_top_10_pct_change.columns)), industry_stats_pivot_new_filers_top_10_pct_change, rotation=90)
        

          7
          plt.yticks(np.arange(0.5, len(industry_stats_pivot_new_filers_top_10_pct_change.loc[1995:, :].index), 1), industry_stats_pivot_new_filers_top_10_pct_change.loc[1995:, :].index, rotation=0)
        

          8
          plt.show()
        

          1
          industry_stats_pivot_new_filers_top_10_corr = industry_stats_pivot_new_filers_top_10_pct_change.corr()
        

          2
          industry_stats_pivot_new_filers_top_10_corr = industry_stats_pivot_new_filers_top_10_corr[(industry_stats_pivot_new_filers_top_10_corr > 0.5) | (industry_stats_pivot_new_filers_top_10_corr < -0.5)]
        

          3
          # hide all values below the diagonal
        

          4
          mask = np.tril(np.ones_like(industry_stats_pivot_new_filers_top_10_corr, dtype=bool))
        

          5
          plt.figure(figsize=(12, 10))
        

          6
          sns.heatmap(industry_stats_pivot_new_filers_top_10_corr, annot=False, cmap='coolwarm', vmin=-1, vmax=1, mask=mask)
        

          7
          plt.title('Correlation Heatmap between Industries'), plt.tight_layout(), plt.gcf().set_size_inches(10, 7)
        

          8
          plt.ylabel(''), plt.xlabel('')
        

          9
          plt.gca().xaxis.grid(color='lightgrey', linestyle='dashed', linewidth=0.5, which='major', alpha=0.5)
        

          10
          plt.gca().yaxis.grid(color='lightgrey', linestyle='dashed', linewidth=0.5, which='major', alpha=0.5)
        

          11
          plt.gca().set_axisbelow(True)
        

          12
          ax = plt.gca()
        

          13
          ax.tick_params(axis='x', rotation=50), ax.set_xticklabels(ax.get_xticklabels(), ha='right')
        

          14
          plt.show()
        

          1
          most_correlated_industries = industry_stats_pivot_new_filers_top_10_corr.sum().sort_values(ascending=False).head(10)
        

          2
          print('Top 10 industries correlated the most with the other industries')
        

          3
          print('-'*70)
        

          4
          most_correlated_industries
        

          1
          office_stats = entities.groupby(['year', 'office'], dropna=False).cik.count().reset_index(name='cik_count')
        

          2
          office_stats
        

          1
          office_stats_pivot = office_stats.pivot(index='year', columns='office', values='cik_count')
        

          2
          office_stats_pivot.fillna(0, inplace=True)
        

          3
          office_stats_pivot = office_stats_pivot.astype(int)
        

          4
          office_stats_pivot[-5:]
        

          1
          sns.heatmap(office_stats_pivot.drop(columns=[np.nan]), cmap='Blues')
        

          2
          plt.gcf().set_size_inches(5, 7)
        

          3
          plt.title("EDGAR Filers per SEC Office per Year"), plt.ylabel("Year"), plt.xlabel("SEC Office")
        

          4
          plt.tight_layout(), plt.gca().yaxis.grid(color='lightgrey', linestyle='dashed', linewidth=0.5)
        

          5
          ax = plt.gca()
        

          6
          ax.tick_params(axis='x', rotation=50), ax.set_xticklabels(ax.get_xticklabels(), ha='right')
        

          7
          plt.show()
        

          1
          office_stats_pivot.drop(columns=[np.nan]).plot(kind='line', figsize=(7, 5))
        

          2
          plt.title("EDGAR Filers per SEC Office per Year")
        

          3
          plt.ylabel("Filers"), plt.xlabel("Year"), plt.tight_layout(), plt.grid(True), plt.gca().set_axisbelow(True)
        

          4
          plt.xticks(sector_stats_pivot.index, rotation=90)
        

          5
          ax = plt.gca()
        

          6
          ax.yaxis.set_major_formatter(mtick.FuncFormatter(lambda x, p: format(int(x), ',')))
        

          7
          handles, labels = ax.get_legend_handles_labels()
        

          8
          ax.legend(reversed(handles), reversed(labels), loc='lower left', bbox_to_anchor=(1, 0.5), fontsize=8)
        

          9
          plt.show()
        

          1
          office_stats_pivot.drop(columns=[np.nan]).plot(kind='bar', stacked=True, figsize=(5, 4))
        

          2
          plt.title("CIK Count per Office Over the Years"), plt.ylabel("CIK Count"), plt.xlabel("Year")
        

          3
          plt.tight_layout()
        

          4
          ax = plt.gca()
        

          5
          ax.yaxis.set_major_formatter(mtick.FuncFormatter(lambda x, p: format(int(x), ',')))
        

          6
          handles, labels = ax.get_legend_handles_labels()
        

          7
          ax.legend(reversed(handles), reversed(labels), loc='center left', bbox_to_anchor=(1, 0.5), fontsize=8)
        

          8
          plt.show()
        

          1
          office_stats_pivot.plot(kind='bar', stacked=True, figsize=(6, 5))
        

          2
          plt.title("CIK Count per Office Over the Years"), plt.ylabel("CIK Count"), plt.xlabel("Year")
        

          3
          plt.tight_layout()
        

          4
          ax = plt.gca()
        

          5
          ax.yaxis.set_major_formatter(mtick.FuncFormatter(lambda x, p: format(int(x), ',')))
        

          6
          handles, labels = ax.get_legend_handles_labels()
        

          7
          ax.legend(reversed(handles), reversed(labels), loc='center left', bbox_to_anchor=(1, 0.5), fontsize=8)
        

          8
          plt.show()
        

          1
          office_stats_pivot.loc[1996:2022].drop(columns=[np.nan]).plot(kind='box', figsize=(7, 5))
        

          2
          plt.title("Entities per SEC Office per Year (1996 - 2022)"), plt.ylabel("Entities"), plt.xlabel("SEC Office"), plt.tight_layout()
        

          3
          ax = plt.gca()
        

          4
          ax.tick_params(axis='x', rotation=50), ax.set_xticklabels(ax.get_xticklabels(), ha='right')
        

          5
          ax.yaxis.set_major_formatter(mtick.FuncFormatter(lambda x, p: format(int(x), ',')))
        

          6
          plt.gca().xaxis.grid(color='lightgrey', linestyle='dashed', linewidth=0.5, which='major', alpha=0.5)
        

          7
          plt.show()
        

          1
          sic_stats = entities.groupby(['year', 'sic'], dropna=False).cik.count().reset_index(name='cik_count')
        

          2
          sic_stats_pivot = sic_stats.pivot(index='year', columns='sic', values='cik_count')
        

          3
          sic_stats_pivot.fillna(0, inplace=True)
        

          4
          sic_stats_pivot = sic_stats_pivot.loc[:, sic_stats_pivot.mean() >= 50]
        

          5
          sic_stats_pivot = sic_stats_pivot.astype(int)
        

          1
          sic_stats_pivot[-5:]
        

          1
          top_20_sics_2022 = sic_stats[sic_stats['year'] == 2022].sort_values(by='cik_count', ascending=False)[:10]
        

          2
          top_20_sics_2022
        

          1
          sic_stats_wo_nan = sic_stats_pivot.drop(columns=[np.nan, '0000'])
        

          1
          sns.heatmap(sic_stats_wo_nan, cmap='Blues')
        

          2
          plt.gcf().set_size_inches(13, 5)
        

          3
          plt.title("CIK Count per SIC Over the Years"), plt.ylabel("Year"), plt.xlabel("SIC")
        

          4
          plt.gca().yaxis.grid(color='lightgrey', linestyle='dashed', linewidth=0.5)
        

          5
          ax = plt.gca()
        

          6
          ax.set_xticklabels(ax.get_xticklabels(), ha='left')
        

          7
          plt.xticks(np.arange(len(sic_stats_wo_nan.columns)), sic_stats_wo_nan, rotation=90)
        

          8
          plt.show()
        

          1
          sns.heatmap(sic_stats_wo_nan.loc[2009:2022], cmap='Blues')
        

          2
          plt.gcf().set_size_inches(13, 4)
        

          3
          plt.title("CIK Count per SIC Over the Years"), plt.ylabel("Year"), plt.xlabel("SIC")
        

          4
          plt.gca().yaxis.grid(color='lightgrey', linestyle='dashed', linewidth=0.5)
        

          5
          ax = plt.gca()
        

          6
          ax.set_xticklabels(ax.get_xticklabels(), ha='left')
        

          7
          plt.xticks(np.arange(len(sic_stats_wo_nan.columns)), sic_stats_wo_nan, rotation=90)
        

          8
          plt.show()