#!/usr/bin/env python # coding: utf-8 # ## SDG 7 objective: "Ensure access to affordable, secure, sustainable and modern energy for all." # # - ¿Cómo aumentar el uso de energías renovables, mejorar el acceso a la electricidad en áreas rurales o promover la eficiencia energética? # # Energy Consumption Trends: Analyze the data to identify trends in global energy consumption over time. This can help governments and organizations make informed decisions about energy policies, investments, and resource allocation. # # Renewable Energy Adoption: Determine the adoption rate of renewable energy sources (such as solar, wind, and hydropower) across different countries and regions. This information can be valuable for assessing progress toward sustainable energy goals. # # Carbon Emissions Analysis: Investigate the relationship between energy production methods and carbon emissions. Python data analysis can help in identifying sources of high emissions and formulating strategies for reducing carbon footprints. # ## 1.DATA CLEANING- DATA WRANGLING # In[4]: #Importing libraries import pandas as pd import numpy as np import seaborn as sns from datetime import datetime import matplotlib as mpl import matplotlib.pyplot as plt import seaborn as sns import pycountry_convert as pc import plotly.graph_objects as go import plotly.subplots as sp import plotly.graph_objs as go from sklearn.preprocessing import StandardScaler from sklearn.preprocessing import MinMaxScaler from sklearn.linear_model import LinearRegression from sklearn.ensemble import RandomForestRegressor from sklearn.model_selection import train_test_split from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error from sklearn import metrics from math import sqrt from statsmodels.stats.outliers_influence import variance_inflation_factor from statsmodels.tools.tools import add_constant from sklearn.cluster import KMeans pd.set_option('display.max_columns', None) get_ipython().run_line_magic('matplotlib', 'inline') # In[5]: #Loading,reading and storing dataset df = pd.read_csv('global_data.csv') df.head() # ### UNDERSTANDING DATA # # **Entity**: The name of the country or region for which the data is reported. # **Year**: The year for which the data is reported, ranging from 2000 to 2020. # **Access to electricity (% of population)**: The percentage of population with access to electricity. # **Access to clean fuels for cooking (% of population)**: The percentage of the population with primary reliance on clean fuels. # **Renewable-electricity-generating-capacity-per-capita**: Installed Renewable energy capacity per person # **Financial flows to developing countries (US)**: Aid and assistance from developed countries for clean energy projects. # **Renewable energy share in total final energy consumption (%)**: Percentage of renewable energy in final energy consumption. # **Electricity from fossil fuels (TWh)**: Electricity generated from fossil fuels (coal, oil, gas) in terawatt-hours. # **Electricity from nuclear (TWh)**: Electricity generated from nuclear power in terawatt-hours. # **Electricity from renewables (TWh)**: Electricity generated from renewable sources (hydro, solar, wind, etc.) in terawatt-hours. # **Low-carbon electricity (% electricity)**: Percentage of electricity from low-carbon sources (nuclear and renewables). # **Primary energy consumption per capita (kWh/person)**: Energy consumption per person in kilowatt-hours. # **Energy intensity level of primary energy (MJ/$2011 PPP GDP)**: Energy use per unit of GDP at purchasing power parity. # **Value_co2_emissions (metric tons per capita)**: Carbon dioxide emissions per person in metric tons. # **Renewables(% equivalent primary energy)**: Equivalent primary energy that is derived from renewable sources. # **GDP growth (annual %)**: Annual GDP growth rate based on constant local currency. # **GDP per capita**: Gross domestic product per person. # **Density (P/Km2)**: Population density in persons per square kilometer. # **Land Area (Km2)**: Total land area in square kilometers. # **Latitude**: Latitude of the country's centroid in decimal degrees. # **Longitude**: Longitude of the country's centroid in decimal degrees. # In[6]: #Show the DataFrame's shape df.shape # In[7]: # Standardize column names df.columns=[e.lower().replace(' ', '').replace('-', '_') for e in df.columns] df.columns # In[8]: df = df.rename(columns = {"density\\n(p/km2)":"density(P/km2)", "value_co2_emissions_kt_by_country":"CO2_emissions_value_by_country_kt", "accesstocleanfuelsforcooking":"access_to_clean_fuels_for_cooking", "financialflowstodevelopingcountries(us$)":"financial_flows_to_developing_countries(us$)", "renewableenergyshareinthetotalfinalenergyconsumption(%)":"renewable_energy_share_in_the_total_final_energy_consumption(%)", "electricityfromfossilfuels(twh)":"electricity_from_fossil_fuels(twh)", "primaryenergyconsumptionpercapita(kwh/person)":"primary_energy_consumption_per_capita(kwh/person)", "energyintensitylevelofprimaryenergy(mj/$2017pppgdp)":"energy_intensity_level_of_primary_energy(mj/$2017pppgdp)", "renewables(%equivalentprimaryenergy)": "renewables(%equivalent_primary_energy)", "accesstoelectricity(%ofpopulation)":"access_to_electricity(%_of_population)", "electricityfromnuclear(twh)":"electricity_from_nuclear(twh)", "electricityfromrenewables(twh)":"electricity_from_renewables(twh)" }) # In[9]: df.head() # In[10]: df.info() # In[11]: #df['year'] = pd.to_datetime(df['year'], format='%Y') # In[12]: # Llena los valores faltantes con ceros #df['density(P/km2)'].fillna(0, inplace=True) #df['density(P/km2)'] = df['density(P/km2)'].str.replace(',', '', regex=True) # Elimina las comas, si las hay #df['density(P/km2)'] = df['density(P/km2)'].astype(int) # In[13]: #Checking for duplicate rows in the data to remove if any df.duplicated().sum() # In[14]: ##hecking null values df.isnull().sum().sort_values(ascending=False) # In[15]: #Checking % of null values null_percentage = [(col, 100 * sum(df[col].isnull()) / len(df[col])) for col in df.columns] # Sort list of tuples by percentage of null values from largest to smallest sorted_null_percentage = sorted(null_percentage, key=lambda x: x[1], reverse=True) # Print the ordered list print("Nulls (sorted by percentage descending):") for col, percentage in sorted_null_percentage: print(f"{col} contains {percentage:.2f}%") # In[16]: # Number of zero values in the dataset (in percent) missing_values_df = df.isnull().sum() / df.shape[0] * 100.00 print(round(missing_values_df),2) # There are two feautures with a rather large number of zero values: # # - Renewables (% equivalent to primary energy) - 59.0%. # - Financial flows to developing countries (US $) - 57.0%. # Cleaning can cause significant errors in the study, as more than 57% of the data will be removed. # In[17]: df.isnull().sum().sort_values(ascending=False) # In[ ]: # In[18]: #Añadimos columna de continente al dataset para poder filtrar y hacer analisis #Creating a column 'Continent' def country_to_continent(country_name): country_alpha2 = pc.country_name_to_country_alpha2(country_name) country_continent_code = pc.country_alpha2_to_continent_code(country_alpha2) country_continent_name = pc.convert_continent_code_to_continent_name(country_continent_code) return country_continent_name df['continent'] = df['entity'].apply(country_to_continent) df.head() # In[19]: #Eliminamos lso dos continentes que vamos a dejar fuera del analisis y las columnas latitude y longitud continentes_a_eliminar = ['Oceania', 'Africa'] df = df[~df['continent'].isin(continentes_a_eliminar)] # In[20]: columnas_delete = ['latitude', 'longitude'] df = df.drop(columns=columnas_delete) df.head(5) # In[21]: df.shape # In[22]: df.isnull().sum().sort_values(ascending=False) # In[23]: #Vamos a agrupar los continentes elegidos para el analisis en distintos df para seguir tratando nulos y outliers según sus características especiales # Supongamos que ya tienes un DataFrame llamado 'df' con las columnas 'Country' y 'Continent' # Agrupar el DataFrame por la columna 'Continent' continent_groups = df.groupby('continent') # Crear diccionarios para almacenar DataFrames separados por continente continents = ['Europe', 'Asia', 'North America', 'South America',] continent_data = {} # Iterar sobre los grupos y almacenarlos en los diccionarios for continent in continents: if continent in continent_groups.groups: continent_data[continent] = continent_groups.get_group(continent) # In[24]: continent_data['Europe'].head(5) # In[25]: continent_data['Europe'].isnull().sum().sort_values(ascending=False) # In[26]: #Rellenamos columnas de nulos con 0 continent_data['Europe']['financial_flows_to_developing_countries(us$)'].fillna(0, inplace=True) continent_data['Europe']['renewables(%equivalent_primary_energy)'].fillna(0, inplace=True) continent_data['Europe']['renewable_electricity_generating_capacity_per_capita'].fillna(0, inplace=True) continent_data['Europe']['CO2_emissions_value_by_country_kt'].fillna(0, inplace=True) # In[ ]: # In[27]: continent_data['Europe'] = continent_data['Europe'].interpolate(method='pad') # In[28]: continent_data['Europe']['renewable_energy_share_in_the_total_final_energy_consumption(%)'].fillna(0, inplace=True) # In[29]: #Save numerical data of europe df_num_europe= continent_data['Europe'].select_dtypes(exclude=["object"]) df_num_europe.head(10) # In[30]: df_num_europe = df_num_europe.reset_index(drop=True) # In[31]: df_num_europe.isnull().sum().sort_values(ascending=False) # In[32]: #CHECKING OUTLIERS for col in df_num_europe.columns: # Crea un nuevo subplot para cada gráfico fig, ax = plt.subplots(figsize=(8, 6)) # Crea el gráfico de boxplot utilizando seaborn sns.boxplot(x=df[col], ax=ax) # Establece el título de cada gráfico ax.set_title('Boxplot Europe by {}'.format(col)) # Muestra cada gráfico plt.show() # In[33]: df_num_europe['access_to_electricity(%_of_population)'].describe() # columns_with_outliers_europe = [] # # Calcular el IQR para cada columna numérica y encontrar outliers # for column in df_num_europe.columns: # if df_num_europe[column].dtype == 'float64' or df_num_europe[column].dtype == 'int64': # Q1 = df_num_europe[column].quantile(0.25) # Q3 = df_num_europe[column].quantile(0.75) # IQR = Q3 - Q1 # # lower_limit = Q1 - 1.5 * IQR # upper_limit = Q3 + 1.5 * IQR # # outliers = df_num_europe[ # (df_num_europe[column] > upper_limit) | # (df_num_europe[column] < lower_limit) # ] # # if not outliers.empty: # print(f"Columna: {column}") # print(outliers) # columns_with_outliers_europe.append(column) # # # Mostrar las columnas con outliers # print("Columnas con outliers y número de outliers:") # for column, num_outliers in columns_with_outliers_europe.items(): # print(f"{column}: {num_outliers}") # In[38]: #Totol number of outliers by column column_outlier_total_eu = {} # Calcular el IQR para cada columna numérica y encontrar outliers for column in df_num_europe.columns: if df_num_europe[column].dtype == 'float64' or df_num_europe[column].dtype == 'int64': Q1 = df_num_europe[column].quantile(0.25) Q3 = df_num_europe[column].quantile(0.75) IQR = Q3 - Q1 lower_limit = Q1 - 1.5 * IQR upper_limit = Q3 + 1.5 * IQR outliers = df_num_europe[ (df_num_europe[column] > upper_limit) | (df_num_europe[column] < lower_limit) ] num_outliers = len(outliers) column_outlier_total_eu[column] = num_outliers # Mostrar el número total de outliers por columna for column, num_outliers in column_outlier_total_eu.items(): print(f"Número de outliers en {column}: {num_outliers}") # In[39]: df_num_europe.shape # In[ ]: # In[40]: #CHECKING DISTRIBUTION for c in df_num_europe.columns: plt.figure(figsize=(10,4)) sns.histplot(df_num_europe[c], kde= True) plt.title(c) plt.show() # In[ ]: # In[ ]: # In[41]: continent_data['Asia'].head() # In[42]: continent_data['Asia'].shape # In[43]: continent_data['Asia'].isnull().sum().sort_values(ascending=False) # In[44]: continent_data['Asia'] = continent_data['Asia'].interpolate(method='pad') # In[48]: continent_data['Asia'].isnull().sum().sort_values(ascending=False) # In[46]: continent_data['Asia']['gdp_per_capita'].fillna(0, inplace=True) continent_data['Asia']['gdp_growth'].fillna(0, inplace=True) continent_data['Asia']['renewables(%equivalent_primary_energy)'].fillna(0, inplace=True) # In[47]: #Save numerical data of Asia df_num_asia= continent_data['Asia'].select_dtypes(exclude=["object"]) df_num_asia.head() # In[ ]: # In[49]: df_num_asia = df_num_asia.reset_index(drop=True) # In[50]: #CHECKING OUTLIERS for col in df_num_asia.columns: # Crea un nuevo subplot para cada gráfico fig, ax = plt.subplots(figsize=(8, 6)) # Crea el gráfico de boxplot utilizando seaborn sns.boxplot(x=df[col], ax=ax) # Establece el título de cada gráfico ax.set_title('Boxplot Asia by {}'.format(col)) # Muestra cada gráfico plt.show() # In[51]: df_num_asia.describe() # columns_with_outliers_asia = [] # # # Calcular el IQR para cada columna numérica y encontrar outliers # for column in df_num_asia.columns: # if df_num_asia[column].dtype == 'float64' or df_num_asia[column].dtype == 'int64': # Q1 = df_num_asia[column].quantile(0.25) # Q3 = df_num_asia[column].quantile(0.75) # IQR = Q3 - Q1 # # lower_limit = Q1 - 1.5 * IQR # upper_limit = Q3 + 1.5 * IQR # # outliers = df_num_asia[ # (df_num_asia[column] > upper_limit) | # (df_num_asia[column] < lower_limit) # ] # # if not outliers.empty: # print(f"Columna: {column}") # print(outliers) # columns_with_outliers_asia.append(column) # # # Mostrar las columnas con outliers # print("Columnas con outliers y número de outliers:") # for column, num_outliers in columns_with_outliers_asia.items(): # print(f"{column}: {num_outliers}") # In[52]: #Totol number of outliers by column Asia column_outlier_total_asia = {} # Calcular el IQR para cada columna numérica y encontrar outliers for column in df_num_asia.columns: if df_num_asia[column].dtype == 'float64' or df_num_asia[column].dtype == 'int64': Q1 = df_num_asia[column].quantile(0.25) Q3 = df_num_asia[column].quantile(0.75) IQR = Q3 - Q1 lower_limit = Q1 - 1.5 * IQR upper_limit = Q3 + 1.5 * IQR outliers = df_num_asia[ (df_num_asia[column] > upper_limit) | (df_num_asia[column] < lower_limit) ] num_outliers = len(outliers) column_outlier_total_asia[column] = num_outliers # Mostrar el número total de outliers por columna for column, num_outliers in column_outlier_total_asia.items(): print(f"Número de outliers en {column}: {num_outliers}") # In[53]: df_num_asia.shape # In[54]: #CHECKING DISTRIBUTION for c in df_num_asia.columns: plt.figure(figsize=(10,4)) sns.histplot(df_num_asia[c], kde= True) plt.title(c) plt.show() # In[55]: continent_data['North America'].head(5) # In[56]: continent_data['North America'].shape # In[57]: continent_data['North America'].isnull().sum().sort_values(ascending=False) # In[58]: continent_data['North America'] = continent_data['North America'].interpolate(method='pad') continent_data['North America']['renewables(%equivalent_primary_energy)'].fillna(0, inplace=True) continent_data['North America']['financial_flows_to_developing_countries(us$)'].fillna(0, inplace=True) # In[59]: continent_data['North America'].isnull().sum().sort_values(ascending=False) # In[60]: #Save numerical data of Asia df_num_north_america= continent_data['North America'].select_dtypes(exclude=["object"]) df_num_north_america.head() # In[61]: df_num_north_america = df_num_north_america.reset_index(drop=True) # In[ ]: # In[62]: #CHECKING OUTLIERS for col in df_num_north_america.columns: # Crea un nuevo subplot para cada gráfico fig, ax = plt.subplots(figsize=(8, 6)) # Crea el gráfico de boxplot utilizando seaborn sns.boxplot(x=df[col], ax=ax) # Establece el título de cada gráfico ax.set_title('Boxplot North America by {}'.format(col)) # Muestra cada gráfico plt.show() # In[63]: df_num_north_america.describe() # columns_with_outliers_north_america = [] # # # Calcular el IQR para cada columna numérica y encontrar outliers # for column in df_num_north_america.columns: # if df_num_north_america[column].dtype == 'float64' or df_num_north_america[column].dtype == 'int64': # Q1 = df_num_north_america[column].quantile(0.25) # Q3 = df_num_north_america[column].quantile(0.75) # IQR = Q3 - Q1 # # lower_limit = Q1 - 1.5 * IQR # upper_limit = Q3 + 1.5 * IQR # # outliers = df_num_north_america[ # (df_num_north_america[column] > upper_limit) | # (df_num_north_america[column] < lower_limit) # ] # # if not outliers.empty: # print(f"Columna: {column}") # print(outliers) # columns_with_outliers_north_america.append(column) # # # Mostrar las columnas con outliers # print("Columnas con outliers y número de outliers:") # for column, num_outliers in columns_with_outliers_north_america.items(): # print(f"{column}: {num_outliers}") # In[64]: #Total number of outliers by column column_outlier_total_north_america = {} # Calcular el IQR para cada columna numérica y encontrar outliers for column in df_num_north_america.columns: if df_num_north_america[column].dtype == 'float64' or df_num_north_america[column].dtype == 'int64': Q1 = df_num_north_america[column].quantile(0.25) Q3 = df_num_north_america[column].quantile(0.75) IQR = Q3 - Q1 lower_limit = Q1 - 1.5 * IQR upper_limit = Q3 + 1.5 * IQR outliers = df_num_north_america[ (df_num_north_america[column] > upper_limit) | (df_num_north_america[column] < lower_limit) ] num_outliers = len(outliers) column_outlier_total_north_america[column] = num_outliers # Mostrar el número total de outliers por columna for column, num_outliers in column_outlier_total_north_america.items(): print(f"Número de outliers en {column}: {num_outliers}") # In[65]: df_num_north_america.shape # In[66]: #CHECKING DISTRIBUTION for c in df_num_north_america.columns: plt.figure(figsize=(10,4)) sns.histplot(df_num_north_america[c], kde= True) plt.title(c) plt.show() # In[ ]: # In[ ]: # In[69]: continent_data['South America'].head(5) # In[68]: continent_data['South America'].shape # In[70]: continent_data['South America'].isnull().sum().sort_values(ascending=False) # In[71]: continent_data['South America'] = continent_data['South America'].interpolate(method='pad') # In[72]: continent_data['South America'].isnull().sum().sort_values(ascending=False) # In[73]: continent_data['South America']['financial_flows_to_developing_countries(us$)'].fillna(0, inplace=True) # In[74]: #Save numerical data of Asia df_num_south_america= continent_data['South America'].select_dtypes(exclude=["object"]) df_num_south_america.head(5) # In[75]: df_num_south_america = df_num_south_america.reset_index(drop=True) # In[76]: #CHECKING OUTLIERS for col in df_num_south_america.columns: # Crea un nuevo subplot para cada gráfico fig, ax = plt.subplots(figsize=(8, 6)) # Crea el gráfico de boxplot utilizando seaborn sns.boxplot(x=df[col], ax=ax) # Establece el título de cada gráfico ax.set_title('Boxplot South America by {}'.format(col)) # Muestra cada gráfico plt.show() # In[77]: df_num_south_america.head(1) # In[78]: df_num_south_america.shape # In[79]: df_num_south_america.describe() # columns_with_outliers_south_america = [] # # # Calcular el IQR para cada columna numérica y encontrar outliers # for column in df_num_south_america.columns: # if df_num_south_america[column].dtype == 'float64' or df_num_south_america[column].dtype == 'int64': # Q1 = df_num_south_america[column].quantile(0.25) # Q3 = df_num_south_america[column].quantile(0.75) # IQR = Q3 - Q1 # # lower_limit = Q1 - 1.5 * IQR # upper_limit = Q3 + 1.5 * IQR # # outliers = df_num_south_america[ # (df_num_south_america[column] > upper_limit) | # (df_num_south_america[column] < lower_limit) # ] # # if not outliers.empty: # print(f"Columna: {column}") # print(outliers) # columns_with_outliers_south_america.append(column) # # # Mostrar las columnas con outliers # print("Columnas con outliers y número de outliers:") # for column, num_outliers in columns_with_outliers_south_america.items(): # print(f"{column}: {num_outliers}") # In[80]: #Total number of outliers by column column_outlier_total_south_america = {} # Calcular el IQR para cada columna numérica y encontrar outliers for column in df_num_south_america.columns: if df_num_south_america[column].dtype == 'float64' or df_num_south_america[column].dtype == 'int64': Q1 = df_num_south_america[column].quantile(0.25) Q3 = df_num_south_america[column].quantile(0.75) IQR = Q3 - Q1 lower_limit = Q1 - 1.5 * IQR upper_limit = Q3 + 1.5 * IQR outliers = df_num_south_america[ (df_num_south_america[column] > upper_limit) | (df_num_south_america[column] < lower_limit) ] num_outliers = len(outliers) column_outlier_total_south_america[column] = num_outliers # Mostrar el número total de outliers por columna for column, num_outliers in column_outlier_total_south_america.items(): print(f"Número de outliers en {column}: {num_outliers}") # In[ ]: # In[81]: #CHECKING DISTRIBUTION for c in df_num_south_america.columns: plt.figure(figsize=(10,4)) sns.histplot(df_num_south_america[c], kde= True) plt.title(c) plt.show() # In[ ]: # In[ ]: #Comparison of general statistics of developed and undeveloped countries # In[ ]: df_num_europe.describe() # In[ ]: df_num_north_america.describe() # In[ ]: df_num_south_america.describe() # In[ ]: df_num_asia.describe() # In[ ]: # ## SOSTENIBILIDAD PAISES DESARROLLADOS VS NO DESARROLLADOS # El Objetivo de Desarrollo Sostenible 7 (Objetivo 7 o ODS 7) trata sobre alianzas para los objetivos y es uno de los 17 Objetivos de Desarrollo Sostenible (ODS) establecidos por las Naciones Unidas en 2015. # # - El ODS 7 es: "Garantizar el acceso a una energía asequible, segura, sostenible y moderna para todos". El Objetivo tiene metas que deben alcanzarse para 2030. El progreso hacia las metas se medirá mediante indicadores. # # El principal problema que busca erradicar es la contaminación a causa de las energías fósiles y la ineficacia de los gobiernos para implementar energías limpias y renovables​ # # El acceso a fuentes de energía modernas y sostenibles es esencial no solo para hacer frente al cambio climático, sino también para el crecimiento económico de los países. # # La combinación de energía primaria de la región está dominada por los combustibles fósiles, y el carbón, el petróleo y el gas natural representan más del 80% del consumo total. Esta dependencia de los combustibles fósiles ha provocado altos niveles de emisiones de CO2, que contribuyen al cambio climático. # # En los últimos años, ha habido una creciente conciencia sobre la necesidad de reducir las emisiones de CO2 en el Sudeste Asiático. Los gobiernos de toda la región han fijado objetivos ambiciosos para el despliegue de energía renovable y hay una inversión creciente en medidas de eficiencia energética. # # Este análisis examinará las tendencias en el consumo de electricidad, el consumo de energía primaria y las emisiones de CO2 DE 4 continentes. # In[82]: # concatenamos todos los dataframes en uno, recordando que cada dataframde esta dividdo por continente y ademas tien su data numerica en su respectivo dataset dataframes = [continent_data['Europe'], continent_data['Asia'], continent_data['North America'], continent_data['South America']] # In[83]: df_all = pd.concat(dataframes, ignore_index=True) # In[84]: #Guardamos dataset limpio sin nulos archivo_csv = 'df_all.csv' df_all.to_csv(archivo_csv, index=False) # In[85]: df_all.head() # In[86]: df_all.shape # In[87]: df_all.isnull().sum().sort_values(ascending=False) # # PRIMARY ENERGY COMSUPTION ANALASYS AND ENERGY COMSUPTION TRENDS # ## CONSUMO DE ENERGIA POR CONTINENTE # In[88]: import matplotlib.pyplot as plt import seaborn as sns # Establecer el estilo de gráfico sns.set(style='whitegrid') # Crear un gráfico de líneas para cada continente plt.figure(figsize=(10, 6)) # Iterar a través de los nombres únicos de los continentes en df_all for continente in df_all['continent'].unique(): df_continente = df_all[df_all['continent'] == continente] # Crear el gráfico de líneas para el continente actual sns.lineplot(data=df_continente, x='year', y='primary_energy_consumption_per_capita(kwh/person)', label=continente) # Personalizar el diseño del gráfico plt.xlabel('Año', fontweight='bold') plt.ylabel('Consumo de energía per cápita (kWh/person)', fontweight='bold') plt.title('Consumo de energía per cápita por continente (2000 - 2020)', fontweight='bold') plt.legend(title='Continente') plt.xticks(rotation=45, ticks=df_all['year'].unique()) # Mostrar el gráfico plt.show() # In[89]: # Calcular el promedio de la columna por año y continente df_avg = df_all.groupby(['year', 'continent'])['primary_energy_consumption_per_capita(kwh/person)'].mean().reset_index() # Establecer el estilo de gráfico sns.set(style='whitegrid') # Crear un gráfico de líneas para cada continente plt.figure(figsize=(10, 6)) # Iterar a través de los nombres únicos de los continentes en df_avg for continente in df_avg['continent'].unique(): df_continente = df_avg[df_avg['continent'] == continente] # Crear el gráfico de líneas para el continente actual sns.lineplot(data=df_continente, x='year', y='primary_energy_consumption_per_capita(kwh/person)', label=continente) # Personalizar el diseño del gráfico plt.xlabel('Año', fontweight='bold') plt.ylabel('Consumo promedio de energía per cápita (kWh/person)', fontweight='bold') plt.title('Consumo promedio de energía per cápita por continente (2000 - 2020)', fontweight='bold') plt.legend(title='Continente') plt.xticks(rotation=45, ticks=df_avg['year'].unique()) # Mostrar el gráfico plt.show() # ## Electricity generated from fossil fuels # In[90]: #import matplotlib.pyplot as plt import seaborn as sns # Establecer el estilo de gráfico sns.set(style='whitegrid') # Crear un gráfico de líneas para cada continente plt.figure(figsize=(10, 6)) # Iterar a través de los nombres únicos de los continentes en df_all for continente in df_all['continent'].unique(): df_continente = df_all[df_all['continent'] == continente] # Crear el gráfico de líneas para el continente actual sns.lineplot(data=df_continente, x='year', y='electricity_from_fossil_fuels(twh)', label=continente) # Personalizar el diseño del gráfico plt.xlabel('Año', fontweight='bold') plt.ylabel('electricity_from_fossil_fuels(twh)', fontweight='bold') plt.title('electricity_from_fossil_fuels(twh) (2000 - 2020)', fontweight='bold') plt.legend(title='Continente') plt.xticks(rotation=45, ticks=df_all['year'].unique()) # Mostrar el gráfico plt.show() # ## Electricity generated from nuclear # In[91]: # Establecer el estilo de gráfico sns.set(style='whitegrid') # Crear un gráfico de líneas para cada continente plt.figure(figsize=(10, 6)) # Iterar a través de los nombres únicos de los continentes en df_all for continente in df_all['continent'].unique(): df_continente = df_all[df_all['continent'] == continente] # Crear el gráfico de líneas para el continente actual sns.lineplot(data=df_continente, x='year', y='electricity_from_nuclear(twh)', label=continente) # Personalizar el diseño del gráfico plt.xlabel('Año', fontweight='bold') plt.ylabel('electricity_from_nuclear(twh)', fontweight='bold') plt.title('electricity_from_nuclear(twh) (2000 - 2020)', fontweight='bold') plt.legend(title='Continente') plt.xticks(rotation=45, ticks=df_all['year'].unique()) # Mostrar el gráfico plt.show() # ## Electricity generated from renewables # In[92]: ## Electricity generated from renewables sns.set(style='whitegrid') # Crear un gráfico de líneas para cada continente plt.figure(figsize=(10, 6)) # Iterar a través de los nombres únicos de los continentes en df_all for continente in df_all['continent'].unique(): df_continente = df_all[df_all['continent'] == continente] # Crear el gráfico de líneas para el continente actual sns.lineplot(data=df_continente, x='year', y='electricity_from_renewables(twh)', label=continente) # Personalizar el diseño del gráfico plt.xlabel('Año', fontweight='bold') plt.ylabel('electricity_from_renewables(twh)', fontweight='bold') plt.title('electricity_from_renewables(twh) (2000 - 2020)', fontweight='bold') plt.legend(title='Continente') plt.xticks(rotation=45, ticks=df_all['year'].unique()) plt.show() # In[ ]: # ### Top 10 countries of energy primary energy consumption per capita as of 2020 # In[93]: import matplotlib.pyplot as plt # Filtrar los datos para incluir solo países de Asia en el año 2020 asia_2020 = df_all[(df_all['continent'] == 'Asia') & (df_all['year'] == 2020)] # Ordenar los países por consumo de energía per cápita en orden descendente top_10_asian_countries = asia_2020.sort_values(by='primary_energy_consumption_per_capita(kwh/person)', ascending=False).head(10) # Crear un gráfico de barras plt.figure(figsize=(7, 5)) plt.bar(top_10_asian_countries['entity'], top_10_asian_countries['primary_energy_consumption_per_capita(kwh/person)'], color='skyblue') plt.ylabel('Consumo de energía per cápita (kWh/person)', fontweight='bold') plt.xlabel('Países', fontweight='bold') plt.title('Top 10 Países Asiáticos por Consumo de Energía per Cápita (2020)', fontweight='bold') plt.xticks(rotation=45) # Rotar etiquetas del eje x para una mejor visualización # Mostrar el gráfico plt.tight_layout() plt.show() # In[94]: # Top 10 South America countries by energy consumption per capita as of 2020 sa_2020 = df_all[(df_all['continent'] == 'South America') & (df_all['year'] == 2020)] top_10_sa = sa_2020.sort_values(by='primary_energy_consumption_per_capita(kwh/person)', ascending=False).head(10) plt.figure(figsize=(7, 5)) bars = plt.bar(top_10_sa['entity'], top_10_sa['primary_energy_consumption_per_capita(kwh/person)'], color='skyblue') plt.ylabel('Consumo de energía per cápita (kWh/person)', fontweight='bold') plt.xlabel('Países', fontweight='bold') plt.title('Top 10 Países Sudamericanos por Consumo de Energía per Cápita (2020)', fontweight='bold') plt.xticks(rotation=45) # Agregar etiquetas de valores a las barras for bar in bars: yval = bar.get_height() plt.text(bar.get_x() + bar.get_width()/2, yval, f'{yval:.2f}', ha='center', va='bottom', fontsize=10, fontweight='bold') plt.tight_layout() plt.show() # In[95]: # Filtrar los datos para incluir solo países de Asia en el año 2020 asia_2020 = df_all[(df_all['continent'] == 'Asia') & (df_all['year'] == 2020)] # Ordenar los países por consumo de energía per cápita en orden descendente top_10_asian_countries = asia_2020.sort_values(by='primary_energy_consumption_per_capita(kwh/person)', ascending=False).head(10) # Crear un gráfico de barras plt.figure(figsize=(10, 6)) bars = plt.bar(top_10_asian_countries['entity'], top_10_asian_countries['primary_energy_consumption_per_capita(kwh/person)'], color='skyblue') plt.ylabel('Consumo de energía per cápita (kWh/person)', fontweight='bold') plt.xlabel('Países', fontweight='bold') plt.title('Top 10 Países Asiáticos por Consumo de Energía per Cápita (2020)', fontweight='bold') plt.xticks(rotation=45) # Rotar etiquetas del eje x para una mejor visualización # Agregar etiquetas de valores encima de las barras for bar in bars: yval = bar.get_height() plt.text(bar.get_x() + bar.get_width()/2, yval, f'{yval:.2f}', ha='center', va='bottom', fontsize=10, fontweight='bold') # Mostrar el gráfico plt.tight_layout() plt.show() # In[96]: # Top 10 Europe countries by energy consumption per capita as of 2020 eu_2020 = df_all[(df_all['continent'] == 'Europe') & (df_all['year'] == 2020)] top_10_eu = eu_2020.sort_values(by='primary_energy_consumption_per_capita(kwh/person)', ascending=False).head(10) plt.figure(figsize=(7, 5)) bars = plt.bar(top_10_eu['entity'], top_10_eu['primary_energy_consumption_per_capita(kwh/person)'], color='skyblue') plt.ylabel('Consumo de energía per cápita (kWh/person)', fontweight='bold') plt.xlabel('Países', fontweight='bold') plt.title('Top 10 Países Europeos por Consumo de Energía per Cápita (2020)', fontweight='bold') plt.xticks(rotation=45) # Agregar etiquetas de valores a las barras for bar in bars: yval = bar.get_height() plt.text(bar.get_x() + bar.get_width()/2, yval, f'{yval:.2f}', ha='center', va='bottom', fontsize=10, fontweight='bold') plt.tight_layout() plt.show() # In[ ]: # In[97]: # Top 10 North America countries by energy consumption per capita as of 2020 na_2020 = df_all[(df_all['continent'] == 'North America') & (df_all['year'] == 2020)] top_10_na = na_2020.sort_values(by='primary_energy_consumption_per_capita(kwh/person)', ascending=False).head(10) plt.figure(figsize=(7, 5)) bars = plt.bar(top_10_na['entity'], top_10_na['primary_energy_consumption_per_capita(kwh/person)'], color='skyblue') plt.ylabel('Consumo de energía per cápita (kWh/person)', fontweight='bold') plt.xlabel('Países', fontweight='bold') plt.title('Top 10 Países Norteamericanos por Consumo de Energía per Cápita (2020)', fontweight='bold') plt.xticks(rotation=45) # Agregar etiquetas de valores a las barras for bar in bars: yval = bar.get_height() plt.text(bar.get_x() + bar.get_width()/2, yval, f'{yval:.2f}', ha='center', va='bottom', fontsize=10, fontweight='bold') plt.tight_layout() plt.show() # In[ ]: # In[ ]: # ### BARRAS APILADAS COMPARATIVA FUENTES DE ELECTRICIDAD generadas por continente: FOSIL, NUCLEAR, RENOVABLE POR CONTINENTE # In[98]: # 1. Agrupar los datos por año y continente y sumar las cantidades de electricidad grouped_data = df_all.groupby(['year', 'continent'])[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum().reset_index() # 2. Crear un DataFrame con los datos agrupados para Asia data_asia = grouped_data[grouped_data['continent'] == 'Asia'] # 3. Crear un gráfico de barras apiladas fig, ax = plt.subplots() data_asia.plot(x="year", y=['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)'], kind="bar", stacked=True, ax=ax) plt.xlabel('Años') plt.ylabel('Electricidad generada en terawatt-hours') plt.title('Electricidad por fuente para Asia') plt.legend(['Renovables', 'Fósiles', 'Nuclear'], loc='upper left') plt.grid(True) # Muestra el gráfico plt.show() # In[99]: import matplotlib.pyplot as plt # 1. Agrupar los datos por año y continente y sumar las cantidades de electricidad grouped_data = df_all.groupby(['year', 'continent'])[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum().reset_index() # 2. Crear un DataFrame con los datos agrupados para Asia data_asia = grouped_data[grouped_data['continent'] == 'Asia'] # 3. Filtrar los datos para los años 2010 y 2020 data_asia_filtered = data_asia[data_asia['year'].isin([2010, 2020])] # 4. Crear un gráfico de barras apiladas fig, ax = plt.subplots() data_asia_filtered.plot(x="year", y=['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)'], kind="bar", stacked=True, ax=ax) plt.xlabel('Años') plt.ylabel('Electricidad generada en terawatt-hours') plt.title('Electricidad por fuente para Asia (2010 y 2020)') plt.legend(['Renovables', 'Fósiles', 'Nuclear'], loc='upper left') plt.grid(True) # Agregar etiquetas de valores en las barras for container in ax.containers: ax.bar_label(container, fmt='%.2f', label_type='center') # Muestra el gráfico plt.show() # In[100]: grouped_data = df_all.groupby(['year', 'continent'])[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum().reset_index() # 2. Crear un DataFrame con los datos agrupados para Asia data_asia = grouped_data[grouped_data['continent'] == 'Asia'] # 3. Filtrar los datos para los años 2010 y 2020 data_asia_filtered = data_asia[data_asia['year'].isin([2000, 2010, 2020])] # 4. Calcular los porcentajes data_asia_filtered['total_electricity'] = data_asia_filtered[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum(axis=1) data_asia_filtered['renewable_percentage'] = (data_asia_filtered['electricity_from_renewables(twh)'] / data_asia_filtered['total_electricity']) * 100 data_asia_filtered['fossil_percentage'] = (data_asia_filtered['electricity_from_fossil_fuels(twh)'] / data_asia_filtered['total_electricity']) * 100 data_asia_filtered['nuclear_percentage'] = (data_asia_filtered['electricity_from_nuclear(twh)'] / data_asia_filtered['total_electricity']) * 100 # 5. Crear un gráfico de barras apiladas fig, ax = plt.subplots() data_asia_filtered.plot(x="year", y=['renewable_percentage', 'fossil_percentage', 'nuclear_percentage'], kind="bar", stacked=True, ax=ax) plt.xlabel('Años') plt.ylabel('Porcentaje de electricidad generada') plt.title('Porcentaje de Electricidad por fuente para Asia a (2000, 2010 y 2020)') plt.legend(['Renovables', 'Fósiles', 'Nuclear'], loc='upper left') plt.grid(True) # Agregar etiquetas de valores en las barras for container in ax.containers: ax.bar_label(container, fmt='%.2f%%', label_type='center') # Muestra el gráfico plt.show() # In[101]: # 1. Agrupar los datos por año y continente y sumar las cantidades de electricidad grouped_data = df_all.groupby(['year', 'continent'])[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum().reset_index() # 2. Crear un DataFrame con los datos agrupados para Asia data_sa = grouped_data[grouped_data['continent'] == 'South America'] # 3. Crear un gráfico de barras apiladas fig, ax = plt.subplots() data_sa.plot(x="year", y=['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)'], kind="bar", stacked=True, ax=ax) plt.xlabel('Años') plt.ylabel('Electricidad geenrada (TWh)') plt.title('Electricidad generada por distintas fuentes South America') plt.legend(['Renovables', 'Fósiles', 'Nuclear'], loc='upper left') plt.grid(True) # Muestra el gráfico plt.show() # In[102]: import matplotlib.pyplot as plt # 1. Agrupar los datos por año y continente y sumar las cantidades de electricidad grouped_data = df_all.groupby(['year', 'continent'])[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum().reset_index() # 2. Crear un DataFrame con los datos agrupados para Asia data_sa = grouped_data[grouped_data['continent'] == 'South America'] # 3. Filtrar los datos para los años 2010 y 2020 data_sa_f = data_sa[data_sa['year'].isin([2000, 2010, 2020])] # 4. Crear un gráfico de barras apiladas fig, ax = plt.subplots() data_sa_f.plot(x="year", y=['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)'], kind="bar", stacked=True, ax=ax) plt.xlabel('Años') plt.ylabel('Electricidad generada en terawatt-hours') plt.title('Electricidad por fuente para South America (2000, 2010 y 2020)') plt.legend(['Renovables', 'Fósiles', 'Nuclear'], loc='upper left') plt.grid(True) # Agregar etiquetas de valores en las barras for container in ax.containers: ax.bar_label(container, fmt='%.2f', label_type='center') # Muestra el gráfico plt.show() # In[103]: # Filtrar los datos solo para los años 2000, 2010 y 2020 data_sa_filtered = data_sa[data_sa['year'].isin([2000, 2010, 2020])] # 2. Crear un DataFrame con los datos agrupados para Asia data_sa = grouped_data[grouped_data['continent'] == 'South America'] # Calcular los porcentajes data_sa_filtered['total_electricity'] = data_sa_filtered[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum(axis=1) data_sa_filtered['renewable_percentage'] = (data_sa_filtered['electricity_from_renewables(twh)'] / data_sa_filtered['total_electricity']) * 100 data_sa_filtered['fossil_percentage'] = (data_sa_filtered['electricity_from_fossil_fuels(twh)'] / data_sa_filtered['total_electricity']) * 100 data_sa_filtered['nuclear_percentage'] = (data_sa_filtered['electricity_from_nuclear(twh)'] / data_sa_filtered['total_electricity']) * 100 # Crear un gráfico de barras apiladas fig, ax = plt.subplots() data_sa_filtered.plot(x="year", y=['renewable_percentage', 'fossil_percentage', 'nuclear_percentage'], kind="bar", stacked=True, ax=ax) plt.xlabel('Años') plt.ylabel('Porcentaje de electricidad generada') plt.title('Porcentaje de Electricidad por fuente para South America en (2000, 2010 y 2020)') plt.legend(['Renovables', 'Fósiles', 'Nuclear'], loc='upper left') plt.grid(True) # Agregar etiquetas de valores en las barras for container in ax.containers: ax.bar_label(container, fmt='%.2f%%', label_type='center') # Muestra el gráfico plt.show() # In[104]: # 1. Agrupar los datos por año y continente y sumar las cantidades de electricidad grouped_data = df_all.groupby(['year', 'continent'])[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum().reset_index() # 2. Crear un DataFrame con los datos agrupados para Asia data_eu = grouped_data[grouped_data['continent'] == 'Europe'] # 3. Crear un gráfico de barras apiladas fig, ax = plt.subplots() data_eu.plot(x="year", y=['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)'], kind="bar", stacked=True, ax=ax) plt.xlabel('Años') plt.ylabel('Electricidad geenrada (TWh)') plt.title('Electricidad generada por distintas fuentes Europe') plt.legend(['Renovables', 'Fósiles', 'Nuclear'], loc='upper left') plt.grid(True) # Muestra el gráfico plt.show() # In[105]: import matplotlib.pyplot as plt # 1. Agrupar los datos por año y continente y sumar las cantidades de electricidad grouped_data = df_all.groupby(['year', 'continent'])[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum().reset_index() # 2. Crear un DataFrame con los datos agrupados para Asia data_asia = grouped_data[grouped_data['continent'] == 'Europe'] # 3. Filtrar los datos para los años 2010 y 2020 data_asia_filtered = data_asia[data_asia['year'].isin([2010, 2020])] # 4. Crear un gráfico de barras apiladas fig, ax = plt.subplots() data_asia_filtered.plot(x="year", y=['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)'], kind="bar", stacked=True, ax=ax) plt.xlabel('Años') plt.ylabel('Electricidad generada en terawatt-hours') plt.title('Electricidad por fuente para Europe (2010 y 2020)') plt.legend(['Renovables', 'Fósiles', 'Nuclear'], loc='upper left') plt.grid(True) # Agregar etiquetas de valores en las barras for container in ax.containers: ax.bar_label(container, fmt='%.2f', label_type='center') # Muestra el gráfico plt.show() # In[106]: # 1. Agrupar los datos por año y continente y sumar las cantidades de electricidad grouped_data = df_all.groupby(['year', 'continent'])[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum().reset_index() # 2. Crear un DataFrame con los datos agrupados para Asia data_asia = grouped_data[grouped_data['continent'] == 'Europe'] # 3. Filtrar los datos para los años 2010 y 2020 data_asia_filtered = data_asia[data_asia['year'].isin([2000, 2010, 2020])] # 4. Calcular los porcentajes data_asia_filtered['total_electricity'] = data_asia_filtered[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum(axis=1) data_asia_filtered['renewable_percentage'] = (data_asia_filtered['electricity_from_renewables(twh)'] / data_asia_filtered['total_electricity']) * 100 data_asia_filtered['fossil_percentage'] = (data_asia_filtered['electricity_from_fossil_fuels(twh)'] / data_asia_filtered['total_electricity']) * 100 data_asia_filtered['nuclear_percentage'] = (data_asia_filtered['electricity_from_nuclear(twh)'] / data_asia_filtered['total_electricity']) * 100 # 5. Crear un gráfico de barras apiladas fig, ax = plt.subplots() data_asia_filtered.plot(x="year", y=['renewable_percentage', 'fossil_percentage', 'nuclear_percentage'], kind="bar", stacked=True, ax=ax) plt.xlabel('Años') plt.ylabel('Porcentaje de electricidad generada') plt.title('Porcentaje de Electricidad por fuente para Europe a (2010 y 2020)') plt.legend(['Renovables', 'Fósiles', 'Nuclear'], loc='upper left') plt.grid(True) # Agregar etiquetas de valores en las barras for container in ax.containers: ax.bar_label(container, fmt='%.2f%%', label_type='center') # Muestra el gráfico plt.show() # In[107]: # 1. Agrupar los datos por año y continente y sumar las cantidades de electricidad grouped_data = df_all.groupby(['year', 'continent'])[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum().reset_index() # 2. Crear un DataFrame con los datos agrupados para Asia data_na = grouped_data[grouped_data['continent'] == 'North America'] # 3. Crear un gráfico de barras apiladas fig, ax = plt.subplots() data_na.plot(x="year", y=['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)'], kind="bar", stacked=True, ax=ax) plt.xlabel('Años') plt.ylabel('Electricidad geenrada (TWh)') plt.title('Electricidad generada por distintas fuentes North America') plt.legend(['Renovables', 'Fósiles', 'Nuclear'], loc='upper left') plt.grid(True) # Muestra el gráfico plt.show() # In[108]: import matplotlib.pyplot as plt # 1. Agrupar los datos por año y continente y sumar las cantidades de electricidad grouped_data = df_all.groupby(['year', 'continent'])[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum().reset_index() # 2. Crear un DataFrame con los datos agrupados para Asia data_na = grouped_data[grouped_data['continent'] == 'North America'] # 3. Filtrar los datos para los años 2010 y 2020 data_na_filtered = data_na[data_na['year'].isin([2010, 2020])] # 4. Crear un gráfico de barras apiladas fig, ax = plt.subplots() data_na_filtered.plot(x="year", y=['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)'], kind="bar", stacked=True, ax=ax) plt.xlabel('Años') plt.ylabel('Electricidad generada en terawatt-hours') plt.title('Electricidad por fuente para North America(2010 y 2020)') plt.legend(['Renovables', 'Fósiles', 'Nuclear'], loc='upper left') plt.grid(True) # Agregar etiquetas de valores en las barras for container in ax.containers: ax.bar_label(container, fmt='%.2f', label_type='center') # Muestra el gráfico plt.show() # In[109]: # 1. Agrupar los datos por año y continente y sumar las cantidades de electricidad grouped_data = df_all.groupby(['year', 'continent'])[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum().reset_index() # 2. Crear un DataFrame con los datos agrupados para Asia data_na = grouped_data[grouped_data['continent'] == 'North America'] # 3. Filtrar los datos para los años 2010 y 2020 data_na_filtered = data_na[data_na['year'].isin([2000, 2010, 2020])] # 4. Calcular los porcentajes data_na_filtered['total_electricity'] = data_na_filtered[['electricity_from_renewables(twh)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)']].sum(axis=1) data_na_filtered['renewable_percentage'] = (data_na_filtered['electricity_from_renewables(twh)'] / data_na_filtered['total_electricity']) * 100 data_na_filtered['fossil_percentage'] = (data_na_filtered['electricity_from_fossil_fuels(twh)'] / data_na_filtered['total_electricity']) * 100 data_na_filtered['nuclear_percentage'] = (data_na_filtered['electricity_from_nuclear(twh)'] / data_na_filtered['total_electricity']) * 100 # 5. Crear un gráfico de barras apiladas fig, ax = plt.subplots() data_na_filtered.plot(x="year", y=['renewable_percentage', 'fossil_percentage', 'nuclear_percentage'], kind="bar", stacked=True, ax=ax) plt.xlabel('Años') plt.ylabel('Porcentaje de electricidad generada') plt.title('Porcentaje de Electricidad por fuente para North America (2010 y 2020)') plt.legend(['Renovables', 'Fósiles', 'Nuclear'], loc='upper left') plt.grid(True) # Agregar etiquetas de valores en las barras for container in ax.containers: ax.bar_label(container, fmt='%.2f%%', label_type='center') # Muestra el gráfico plt.show() # In[ ]: # In[ ]: # ## Annual GDP growth rate based on constant local currency by continent # In[110]: ## Electricity generated from renewables sns.set(style='whitegrid') # Crear un gráfico de líneas para cada continente plt.figure(figsize=(10, 6)) # Iterar a través de los nombres únicos de los continentes en df_all for continente in df_all['continent'].unique(): df_continente = df_all[df_all['continent'] == continente] # Crear el gráfico de líneas para el continente actual sns.lineplot(data=df_continente, x='year', y='gdp_growth', label=continente) # Personalizar el diseño del gráfico plt.xlabel('Año', fontweight='bold') plt.ylabel('gdp_growth', fontweight='bold') plt.title('gdp_growth (2000 - 2020)', fontweight='bold') plt.legend(title='Continente') plt.xticks(rotation=45, ticks=df_all['year'].unique()) plt.show() # In[111]: df_all.head(1) # ## Gross domestic product per capita by continent # In[112]: ## Electricity generated from renewables sns.set(style='whitegrid') # Crear un gráfico de líneas para cada continente plt.figure(figsize=(10, 6)) # Iterar a través de los nombres únicos de los continentes en df_all for continente in df_all['continent'].unique(): df_continente = df_all[df_all['continent'] == continente] # Crear el gráfico de líneas para el continente actual sns.lineplot(data=df_continente, x='year', y='gdp_per_capita', label=continente) # Personalizar el diseño del gráfico plt.xlabel('Año', fontweight='bold') plt.ylabel('gdp_per_capita', fontweight='bold') plt.title('gdp_per_capita (2000 - 2020)', fontweight='bold') plt.legend(title='Continente') plt.xticks(rotation=45, ticks=df_all['year'].unique()) plt.show() # ### Primary Energy Consumption Analysis # Primary energy is energy that is extracted directly from its sources, before any transformation or conversion. The energy that is available in its raw or unprocessed form is used to power various sectors and industry # In[113]: primary_energy_all = df_all[['entity','year','primary_energy_consumption_per_capita(kwh/person)','energy_intensity_level_of_primary_energy(mj/$2017pppgdp)','renewables(%equivalent_primary_energy)','gdp_per_capita']] primary_energy_all.head() # In[ ]: # In[114]: df_all.head(2) # ### Primary Energy Consumption VS Gross Domestic Product (GDP) # In[ ]: # In[115]: import plotly.subplots as sp import plotly.graph_objs as go # Selecciona el país que deseas mostrar country = 'Chile' # Filtra el DataFrame para el país seleccionado country_data = df_all[df_all['entity'] == country] # Especifica las columnas que deseas comparar column_1 = 'primary_energy_consumption_per_capita(kwh/person)' column_2 = 'gdp_per_capita' # Crea el gráfico de líneas con dos ejes fig = sp.make_subplots(specs=[[{"secondary_y": True}]]) fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column_1], name=f'{country} - {column_1}', mode='lines+markers'), secondary_y=False) fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column_2], name=f'{country} - {column_2}', mode='lines+markers'), secondary_y=True) fig.update_layout(title=f'{column_1} & {column_2} - {country}', xaxis_title='Year', yaxis_title='Value') fig.update_yaxes(title_text=column_1, secondary_y=False) fig.update_yaxes(title_text=column_2, secondary_y=True) fig.show() # In[116]: # Selecciona el país que deseas mostrar country = 'Qatar' # Filtra el DataFrame para el país seleccionado country_data = df_all[df_all['entity'] == country] # Especifica las columnas que deseas comparar column_1 = 'primary_energy_consumption_per_capita(kwh/person)' column_2 = 'gdp_per_capita' # Crea el gráfico de líneas con dos ejes fig = sp.make_subplots(specs=[[{"secondary_y": True}]]) fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column_1], name=f'{country} - {column_1}', mode='lines+markers'), secondary_y=False) fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column_2], name=f'{country} - {column_2}', mode='lines+markers'), secondary_y=True) fig.update_layout(title=f'{column_1} & {column_2} - {country}', xaxis_title='Year', yaxis_title='Value') fig.update_yaxes(title_text=column_1, secondary_y=False) fig.update_yaxes(title_text=column_2, secondary_y=True) fig.show() # In[117]: # Selecciona el país que deseas mostrar country = 'Iceland' # Filtra el DataFrame para el país seleccionado country_data = df_all[df_all['entity'] == country] # Especifica las columnas que deseas comparar column_1 = 'primary_energy_consumption_per_capita(kwh/person)' column_2 = 'gdp_per_capita' # Crea el gráfico de líneas con dos ejes fig = sp.make_subplots(specs=[[{"secondary_y": True}]]) fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column_1], name=f'{country} - {column_1}', mode='lines+markers'), secondary_y=False) fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column_2], name=f'{country} - {column_2}', mode='lines+markers'), secondary_y=True) fig.update_layout(title=f'{column_1} & {column_2} - {country}', xaxis_title='Year', yaxis_title='Value') fig.update_yaxes(title_text=column_1, secondary_y=False) fig.update_yaxes(title_text=column_2, secondary_y=True) fig.show() # In[118]: # Selecciona el país que deseas mostrar country = 'Trinidad and Tobago' # Filtra el DataFrame para el país seleccionado country_data = df_all[df_all['entity'] == country] # Especifica las columnas que deseas comparar column_1 = 'primary_energy_consumption_per_capita(kwh/person)' column_2 = 'gdp_per_capita' # Crea el gráfico de líneas con dos ejes fig = sp.make_subplots(specs=[[{"secondary_y": True}]]) fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column_1], name=f'{country} - {column_1}', mode='lines+markers'), secondary_y=False) fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column_2], name=f'{country} - {column_2}', mode='lines+markers'), secondary_y=True) fig.update_layout(title=f'{column_1} & {column_2} - {country}', xaxis_title='Year', yaxis_title='Value') fig.update_yaxes(title_text=column_1, secondary_y=False) fig.update_yaxes(title_text=column_2, secondary_y=True) fig.show() # In[ ]: # ## Primary Energy Intensity # In[119]: # Selecciona los países que deseas mostrar countries = ['Chile', 'Iceland', 'Trinidad and Tobago', 'Qatar'] # Filtra el DataFrame para los países seleccionados selected_data = df_all[df_all['entity'].isin(countries)] # Especifica la columna que deseas comparar column = 'energy_intensity_level_of_primary_energy(mj/$2017pppgdp)' # Crea el gráfico de líneas con dos ejes fig = sp.make_subplots(specs=[[{"secondary_y": True}]]) for country in countries: country_data = selected_data[selected_data['entity'] == country] fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column], name=f'{country} - {column}', mode='lines+markers'), secondary_y=False) fig.update_layout(title=f'{column} por país', xaxis_title='Year', yaxis_title='Valor') fig.update_yaxes(title_text=column, secondary_y=False) fig.show() # Energy intensity level of primary energy. Energy intensity is defined as the energy supplied to the economy per unit value of economic output (megajoules per constant 2011 purchasing power parity GDP).TARGET 7.3 By 2030, double the global rate of improvement in energy efficiency. La variable "Energy intensity level of primary energy, MJ/constant 2011 PPP GDP" (Nivel de intensidad energética de la energía primaria, MJ/PIB constante de 2011 en paridad de poder adquisitivo) es una medida que evalúa la eficiencia energética de un país en relación con su Producto Interno Bruto (PIB) ajustado a la paridad de poder adquisitivo (PPA) en términos constantes de 2011. Esta medida se utiliza para cuantificar la cantidad de energía primaria que un país consume para producir un cierto valor de PIB. # # En términos simples, indica cuánta energía se necesita para generar una unidad de valor económico en el país. Cuanto menor sea el valor de esta variable, mayor será la eficiencia energética del país, ya que significa que está utilizando menos energía para producir su PIB. # # El hecho de que se ajuste a términos constantes de 2011 y se exprese en paridad de poder adquisitivo (PPA) significa que se han tenido en cuenta las variaciones en los precios y el valor del dinero a lo largo del tiempo y entre los países para hacer comparaciones más precisas y equitativas en términos de eficiencia energética. # # En resumen, una menor "Energy intensity level of primary energy, MJ/constant 2011 PPP GDP" indica una mayor eficiencia energética en la producción económica de un país, mientras que un valor más alto sugiere que el país consume más energía para generar su PIB. # In[124]: ## Electricity generated from renewables sns.set(style='whitegrid') # Crear un gráfico de líneas para cada continente plt.figure(figsize=(10, 6)) # Iterar a través de los nombres únicos de los continentes en df_all for continente in df_all['continent'].unique(): df_continente = df_all[df_all['continent'] == continente] # Crear el gráfico de líneas para el continente actual sns.lineplot(data=df_continente, x='year', y='energy_intensity_level_of_primary_energy(mj/$2017pppgdp)', label=continente) # Personalizar el diseño del gráfico plt.xlabel('Año', fontweight='bold') plt.ylabel('', fontweight='bold') plt.title('energy_intensity_level_of_primary_energy(mj/$2017pppgdp) (2000 - 2020)', fontweight='bold') plt.legend(title='Continente') plt.xticks(rotation=45, ticks=df_all['year'].unique()) plt.show() # In[125]: # Supongamos que tienes un DataFrame df_all con columnas 'year', 'continent', y 'primary_energy_consumption(kwh)'. import pandas as pd # Supongamos que tienes un DataFrame df_all con las columnas mencionadas. # 1. Calcular la intensidad energética primaria en megajulios por PIB df_all['primary_energy_intensity'] = df_all['energy_intensity_level_of_primary_energy(mj/$2017pppgdp)'] # 2. Calcular el Improvement Rate para cada período def calculate_improvement_rate(df, start_year, end_year): start_intensity = df[df['year'] == start_year]['primary_energy_intensity'].values[0] end_intensity = df[df['year'] == end_year]['primary_energy_intensity'].values[0] improvement_rate = ((end_intensity - start_intensity) / start_intensity) * 100 return improvement_rate # Calcular Improvement Rate para los períodos específicos improvement_2000_2010 = calculate_improvement_rate(df_all, 2000, 2010) improvement_2010_2020 = calculate_improvement_rate(df_all, 2010, 2020) print(f"Improvement Rate 2000-2010: {improvement_2000_2010:.2f}%") print(f"Improvement Rate 2010-2020: {improvement_2010_2020:.2f}%") # In[126]: df_all['primary_energy_intensity'] = df_all['energy_intensity_level_of_primary_energy(mj/$2017pppgdp)'] # 2. Calcular el Improvement Rate por continente y período def calculate_improvement_rate(df, start_year, end_year): df_filtered = df[(df['year'] >= start_year) & (df['year'] <= end_year)] grouped = df_filtered.groupby(['continent', 'year'])['primary_energy_intensity'].mean().unstack() improvement_rate = ((grouped[end_year] - grouped[start_year]) / grouped[start_year]) * 100 return improvement_rate # Calcular Improvement Rate por continente para los períodos específicos improvement_2000_2010 = calculate_improvement_rate(df_all, 2000, 2010) improvement_2010_2020 = calculate_improvement_rate(df_all, 2010, 2020) print("Improvement Rate 2000-2010:") print(improvement_2000_2010) print("Improvement Rate 2010-2016:") print(improvement_2010_2020) # In[127]: df_all.head(3) # ## C02 EMISSIONS ANALYSIS BY CONTINENT # In[128]: ## Electricity generated from renewables sns.set(style='whitegrid') # Crear un gráfico de líneas para cada continente plt.figure(figsize=(10, 6)) # Iterar a través de los nombres únicos de los continentes en df_all for continente in df_all['continent'].unique(): df_continente = df_all[df_all['continent'] == continente] # Crear el gráfico de líneas para el continente actual sns.lineplot(data=df_continente, x='year', y='CO2_emissions_value_by_country_kt', label=continente) # Personalizar el diseño del gráfico plt.xlabel('Año', fontweight='bold') plt.ylabel('', fontweight='bold') plt.title('CO2 Emissions by continent (2000 - 2020)', fontweight='bold') plt.legend(title='Continente') plt.xticks(rotation=45, ticks=df_all['year'].unique()) plt.show() # In[ ]: # In[129]: # Top 10 North America countries by C02 nac02_2020 = df_all[(df_all['continent'] == 'North America') & (df_all['year'] == 2020)] top_10_na_c02 = nac02_2020.sort_values(by='CO2_emissions_value_by_country_kt', ascending=False).head(10) plt.figure(figsize=(7, 5)) plt.bar(top_10_na_c02['entity'], top_10_na_c02['CO2_emissions_value_by_country_kt'], color='skyblue') plt.ylabel('CO2 Emissiobs value by kt', fontweight='bold') plt.xlabel('Países', fontweight='bold') plt.title('Top 10 Países Norteamericanos por C02 Emissions (2020)', fontweight='bold') plt.xticks(rotation=45) plt.tight_layout() plt.show() # In[130]: euc02_2020 = df_all[(df_all['continent'] == 'Europe') & (df_all['year'] == 2019)] top_10_eu_c02 = euc02_2020.sort_values(by='CO2_emissions_value_by_country_kt', ascending=False).head(10) plt.figure(figsize=(7, 5)) plt.bar(top_10_eu_c02['entity'], top_10_eu_c02['CO2_emissions_value_by_country_kt'], color='skyblue') plt.ylabel('CO2 Emissiobs value by kt', fontweight='bold') plt.xlabel('Países', fontweight='bold') plt.title('Top 10 Países Europeos por C02 Emissions (2020)', fontweight='bold') plt.xticks(rotation=45) plt.tight_layout() plt.show() # In[131]: sac02_2020 = df_all[(df_all['continent'] == 'South America') & (df_all['year'] == 2020)] top_10_sa_c02 = sac02_2020.sort_values(by='CO2_emissions_value_by_country_kt', ascending=False).head(10) plt.figure(figsize=(7, 5)) plt.bar(top_10_sa_c02['entity'], top_10_sa_c02['CO2_emissions_value_by_country_kt'], color='skyblue') plt.ylabel('CO2 Emissiobs value by kt', fontweight='bold') plt.xlabel('Países', fontweight='bold') plt.title('Top 10 Países Sudamericanos por C02 Emissions (2020)', fontweight='bold') plt.xticks(rotation=45) plt.tight_layout() plt.show() # In[132]: asiac02_2020 = df_all[(df_all['continent'] == 'Asia') & (df_all['year'] == 2020)] top_10_asia_c02 = asiac02_2020.sort_values(by='CO2_emissions_value_by_country_kt', ascending=False).head(10) plt.figure(figsize=(7, 5)) plt.bar(top_10_asia_c02['entity'], top_10_asia_c02['CO2_emissions_value_by_country_kt'], color='skyblue') plt.ylabel('CO2 Emissiobs value by kt', fontweight='bold') plt.xlabel('Países', fontweight='bold') plt.title('Top 10 Países Asiáticos Emissions (2020)', fontweight='bold') plt.xticks(rotation=45) plt.tight_layout() plt.show() # In[133]: # Selecciona el país que deseas mostrar country = 'United States' # Filtra el DataFrame para el país seleccionado country_data = df_all[df_all['entity'] == country] # Especifica las columnas que deseas comparar column_1 = 'CO2_emissions_value_by_country_kt' column_2 = 'gdp_growth' # Crea el gráfico de líneas con dos ejes fig = sp.make_subplots(specs=[[{"secondary_y": True}]]) fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column_1], name=f'{country} - {column_1}', mode='lines+markers'), secondary_y=False) fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column_2], name=f'{country} - {column_2}', mode='lines+markers'), secondary_y=True) fig.update_layout(title=f'{column_1} & {column_2} - {country}', xaxis_title='Year', yaxis_title='Value') fig.update_yaxes(title_text=column_1, secondary_y=False) fig.update_yaxes(title_text=column_2, secondary_y=True) fig.show() # In[134]: # Selecciona el país que deseas mostrar country = 'Brazil' # Filtra el DataFrame para el país seleccionado country_data = df_all[df_all['entity'] == country] # Especifica las columnas que deseas comparar column_1 = 'CO2_emissions_value_by_country_kt' column_2 = 'gdp_growth' # Crea el gráfico de líneas con dos ejes fig = sp.make_subplots(specs=[[{"secondary_y": True}]]) fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column_1], name=f'{country} - {column_1}', mode='lines+markers'), secondary_y=False) fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column_2], name=f'{country} - {column_2}', mode='lines+markers'), secondary_y=True) fig.update_layout(title=f'{column_1} & {column_2} - {country}', xaxis_title='Year', yaxis_title='Value') fig.update_yaxes(title_text=column_1, secondary_y=False) fig.update_yaxes(title_text=column_2, secondary_y=True) fig.show() # In[135]: # Selecciona el país que deseas mostrar country = 'China' # Filtra el DataFrame para el país seleccionado country_data = df_all[df_all['entity'] == country] # Especifica las columnas que deseas comparar column_1 = 'CO2_emissions_value_by_country_kt' column_2 = 'gdp_growth' # Crea el gráfico de líneas con dos ejes fig = sp.make_subplots(specs=[[{"secondary_y": True}]]) fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column_1], name=f'{country} - {column_1}', mode='lines+markers'), secondary_y=False) fig.add_trace(go.Scatter(x=country_data['year'], y=country_data[column_2], name=f'{country} - {column_2}', mode='lines+markers'), secondary_y=True) fig.update_layout(title=f'{column_1} & {column_2} - {country}', xaxis_title='Year', yaxis_title='Value') fig.update_yaxes(title_text=column_1, secondary_y=False) fig.update_yaxes(title_text=column_2, secondary_y=True) fig.show() # In[ ]: # In[ ]: # ### Corriente financiera # In[136]: ## Electricity generated from renewables sns.set(style='whitegrid') # Crear un gráfico de líneas para cada continente plt.figure(figsize=(10, 6)) # Iterar a través de los nombres únicos de los continentes en df_all for continente in df_all['continent'].unique(): df_continente = df_all[df_all['continent'] == continente] # Crear el gráfico de líneas para el continente actual sns.lineplot(data=df_continente, x='year', y='financial_flows_to_developing_countries(us$)', label=continente) # Personalizar el diseño del gráfico plt.xlabel('Año', fontweight='bold') plt.ylabel('us$', fontweight='bold') plt.title('financial_flows_to_developing_countries(us$) (2000 - 2020)', fontweight='bold') plt.legend(title='Continente') plt.xticks(rotation=45, ticks=df_all['year'].unique()) plt.show() # In[ ]: # In[ ]: # In[137]: df_all.head() # In[138]: df_all.isnull().sum().sort_values(ascending=False) # In[ ]: # # Feature correlatiomn analysis # In[139]: df_all_cat=df_all.select_dtypes(include=['object']) df_all_cat.head(5) # In[140]: df_all_num= df_all.select_dtypes(exclude=["object"]) df_all_num.head(5) # In[141]: df_all_num.isnull().sum().sort_values(ascending=False) # In[ ]: # In[142]: corr = df_all_num.corr() ones = np.ones_like(corr, dtype="bool") mask = np.triu(ones) mask = mask[1:, :-1] corr = corr.iloc[1:,:-1].copy() fig, ax = plt.subplots(figsize=(30,20)) sns.heatmap(corr, mask=mask, annot=True, fmt=".2f", cmap="Greens", linewidths=.6, cbar_kws={"shrink":.9}) ax.xaxis.tick_bottom() plt.title("Correlations heatmap for numerical data".upper(), fontdict={"fontsize": 18}, loc="left") # In[143]: #High correlation:.80 to 1 #Mean correlation:.60 to .80 #Low correlation: .40 to .60 # In[144]: corr = df_all_num.corr() high_corr = corr[corr > 0.80] high_corr = high_corr.unstack().dropna() high_corr = high_corr[high_corr.index.get_level_values(0) != high_corr.index.get_level_values(1)] for index, value in high_corr.items(): variable_1, variable_2 = index correlation_value = value print("Variables:", variable_1, "and", variable_2) print("Correlation:", correlation_value) print("------------------------") # electricity_from_fossil_fuels(twh) and electricity_from_renewables(twh) # electricity_from_fossil_fuels(twh) and CO2_emissions_value_by_country_kt # CO2_emissions_value_by_country_kt and electricity_from_renewables(twh) # CO2_emissions_value_by_country_kt and electricity_from_fossil_fuels(twh) # # Correlations Results # # - Correlación entre electricidad de combustibles fósiles y electricidad de energías renovables: La correlación positiva de 0.8439 entre "electricidad_from_fossil_fuels(twh)" y "electricity_from_renewables(twh)" sugiere que, en general, los países que producen más electricidad a partir de fuentes de energía fósil también tienden a producir más electricidad a partir de fuentes renovables. Esto puede ser un reflejo de la inversión en infraestructura energética en general en esos países, donde algunos pueden estar avanzando en ambas fuentes de energía. # # - Correlación entre electricidad de combustibles fósiles y emisiones de CO2: La alta correlación de 0.9898 entre "electricidad_from_fossil_fuels(twh)" y "CO2_emissions_value_by_country_kt" indica que hay una fuerte relación entre la producción de electricidad a partir de fuentes de energía fósil y las emisiones de dióxido de carbono (CO2). Esto es esperado, ya que la quema de combustibles fósiles es una de las principales fuentes de emisiones de CO2 en todo el mundo. # # - Correlación entre electricidad de energías renovables y emisiones de CO2: La correlación positiva de 0.8567 entre "electricity_from_renewables(twh)" y "CO2_emissions_value_by_country_kt" sugiere que, en general, los países que producen más electricidad a partir de fuentes renovables también tienden a tener emisiones de CO2 más bajas. Esto es consistente con la idea de que el uso de fuentes de energía renovable puede contribuir a una menor huella de carbono. # # En resumen, estas correlaciones sugieren que existe una relación significativa entre la producción de electricidad a partir de diferentes fuentes (fósiles y renovables) y las emisiones de CO2 a nivel de país. # # - Correlación negativa entre "Renewable energy share" y "Access to electricity": # # Una correlación negativa significa que a medida que aumenta el porcentaje de energía renovable en el consumo final de energía, disminuye el acceso a la electricidad en la población. # Esto podría deberse a que en algunos países o regiones, donde la energía renovable representa una parte significativa del suministro de energía, la infraestructura eléctrica puede no estar tan desarrollada como en áreas con una mayor dependencia de fuentes de energía no renovable. # También podría sugerir que en países donde el acceso a la electricidad es un desafío, se depende más de fuentes de energía no renovable tradicionales para generar electricidad. # # - Correlación nrgativa entre "Renewable energy share" y "Access to clean fuels for cooking": # # Una correlación negativa indica que a medida que aumenta el uso de energía renovable en el consumo final de energía, disminuye el acceso a combustibles limpios para cocinar. # Esto podría explicarse por el hecho de que en algunas áreas con un mayor uso de energía renovable, es posible que no se haya abordado adecuadamente el acceso a fuentes de combustible limpio para cocinar, lo que podría indicar desigualdades en el desarrollo de infraestructura energética. # También podría reflejar que en áreas con menor acceso a la electricidad, es más probable que la población dependa de combustibles tradicionales no limpios, como la biomasa o el carbón, para cocinar. # En resumen, estas correlaciones sugieren que existe una relación inversa entre el uso de energía renovable y el acceso a servicios energéticos esenciales, como la electricidad y los combustibles limpios para cocinar, en los datos que estás analizando. Sin embargo, es importante recordar que la correlación no implica causalidad y que estas relaciones pueden estar influenciadas por una serie de factores socioeconómicos y políticos específicos de cada país o región. # In[145]: df_all_num.columns # In[146]: #VIF from sklearn.linear_model import LinearRegression from sklearn.metrics import mean_squared_error, r2_score from statsmodels.stats.outliers_influence import variance_inflation_factor from statsmodels.tools.tools import add_constant features = ['year', 'access_to_electricity(%_of_population)', 'access_to_clean_fuels_for_cooking', 'renewable_electricity_generating_capacity_per_capita', 'financial_flows_to_developing_countries(us$)', 'renewable_energy_share_in_the_total_final_energy_consumption(%)', 'electricity_from_fossil_fuels(twh)', 'electricity_from_nuclear(twh)', 'electricity_from_renewables(twh)', 'low_carbonelectricity(%electricity)', 'primary_energy_consumption_per_capita(kwh/person)', 'energy_intensity_level_of_primary_energy(mj/$2017pppgdp)', 'CO2_emissions_value_by_country_kt', 'renewables(%equivalent_primary_energy)', 'gdp_growth', 'gdp_per_capita', 'landarea(km2)'] def calculate_vif(df, features): vif, tolerance, r2sq = {}, {}, {} # all the features that you want to examine for feature in features: # extract all the other features you will regress against X = [f for f in features if f != feature] X, y = df[X], df[feature] # extract r-squared from the fit r2 = LinearRegression().fit(X, y).score(X, y) # calculate tolerance r2sq[feature] = r2 tolerance[feature] = 1 - r2 # calculate VIF vif[feature] = 1/(tolerance[feature]) # return VIF DataFrame return pd.DataFrame({'VIF': vif, 'Tolerance': tolerance, 'R2': r2sq}) # In[147]: calculate_vif(df_all_num, features) # Interpreting R square k - If $R^2_k$ equals zero, variable k is not correlated with any other independent variable. Usually, multicollinearity is a potential problem when $R^2_k$ is greater than 0.75 and, a serious problem when $R^2_k$ is greater than 0.9. # # Interpretation of the variance inflation factor: If $VIF_k = 1$, variable k is not correlated with any other independent variable. Multicollinearity is a potential problem when VIFk is greater than 5 and, a serious problem when it is greater than 10. # # Interpretation of tolerance A tolerance of less than 0.20 or 0.10 indicates a multicollinearity problem. # In[148]: features = ['access_to_electricity(%_of_population)', 'renewable_electricity_generating_capacity_per_capita', 'financial_flows_to_developing_countries(us$)', 'electricity_from_nuclear(twh)', 'energy_intensity_level_of_primary_energy(mj/$2017pppgdp)', 'renewables(%equivalent_primary_energy)', 'gdp_per_capita'] def calculate_vif(df, features): vif, tolerance, r2sq = {}, {}, {} # all the features that you want to examine for feature in features: # extract all the other features you will regress against X = [f for f in features if f != feature] X, y = df[X], df[feature] # extract r-squared from the fit r2 = LinearRegression().fit(X, y).score(X, y) # calculate tolerance r2sq[feature] = r2 tolerance[feature] = 1 - r2 # calculate VIF vif[feature] = 1/(tolerance[feature]) # return VIF DataFrame return pd.DataFrame({'VIF': vif, 'Tolerance': tolerance, 'R2': r2sq}) # In[149]: calculate_vif(df_all_num, features) # In[ ]: # ## Modelling: Primary energy consumption per capita( kwh/person) Forecast # ### Modelo de regresion lineal para predecir nuestro target realizado con los cuatro continentes # In[150]: #Savin features selection df_num_l=df_all_num[['access_to_electricity(%_of_population)', 'renewable_electricity_generating_capacity_per_capita', 'financial_flows_to_developing_countries(us$)', 'electricity_from_nuclear(twh)', 'energy_intensity_level_of_primary_energy(mj/$2017pppgdp)', 'renewables(%equivalent_primary_energy)', 'gdp_per_capita', 'primary_energy_consumption_per_capita(kwh/person)']] df_num_l= df_num_l.reset_index() df_num_l = df_num_l.drop(columns=['index']) df_num_l.head() # In[151]: #X-y split y=df_num_l['primary_energy_consumption_per_capita(kwh/person)'] X=df_num_l.drop(['primary_energy_consumption_per_capita(kwh/person)'],axis=1) X.head() # In[152]: #Encodiing categorical data from sklearn.preprocessing import OneHotEncoder encoder=OneHotEncoder(drop='first').fit(df_all_cat) encoder=encoder.transform(df_all_cat).toarray() encoder # In[153]: #Normalizing numerical data from sklearn.preprocessing import StandardScaler transformer=StandardScaler().fit(X) X_norm=transformer.transform(X) X_norm # In[156]: X=np.concatenate((X_norm ,encoder),axis=1) X # In[157]: X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.3,random_state=42) # In[158]: X_train.shape # In[159]: X_test.shape # In[160]: # Crear y ajustar el modelo de regresión lineal regression_model = LinearRegression() regression_model.fit(X_train, y_train) # In[161]: # Realizar las predicciones en conjunto de entrenamiento y conjunto de prueba y_train_pred = regression_model.predict(X_train) y_test_pred = regression_model.predict(X_test) # In[162]: # Calcular las métricas r2_train = r2_score(y_train, y_train_pred) mse_train = mean_squared_error(y_train, y_train_pred) mae_train = mean_absolute_error(y_train, y_train_pred) rmse_train = sqrt(mse_train) r2_test = r2_score(y_test, y_test_pred) mse_test = mean_squared_error(y_test, y_test_pred) mae_test = mean_absolute_error(y_test, y_test_pred) rmse_test = sqrt(mse_test) # In[163]: # Imprimir las métricas print("Métricas en conjunto de entrenamiento:") print("R^2:", r2_train) print("MSE:", mse_train) print("MAE:", mae_train) print("RMSE:", rmse_train) print("------------------------------") print("Métricas en conjunto de prueba:") print("R^2:", r2_test) print("MSE:", mse_test) print("MAE:", mae_test) print("RMSE:", rmse_test) # In[164]: #problema de overfitting # ### Modelo de regresion lineal realizado con los dos continentes más desarrollados en materia de sostenibilidad, Europe - North America y realizamos otra regresion con Asia - South America # In[165]: df_dev = pd.concat([continent_data['Europe'], continent_data['North America']], axis=0) df_dev.reset_index(drop=True, inplace=True) df_dev.head(10) # In[166]: df_dev.shape # In[167]: df_dev_num= df_dev.select_dtypes(exclude=["object"]) df_dev_num.head(5) # In[168]: df_dev_num.isnull().sum().sort_values(ascending=False) # In[169]: df_dev_cat= df_dev.select_dtypes(include=["object"]) df_dev_cat.head(5) # In[170]: corr = df_dev_num.corr() high_corr = corr[corr > 0.80] high_corr = high_corr.unstack().dropna() high_corr = high_corr[high_corr.index.get_level_values(0) != high_corr.index.get_level_values(1)] for index, value in high_corr.items(): variable_1, variable_2 = index correlation_value = value print("Variables:", variable_1, "and", variable_2) print("Correlation:", correlation_value) print("------------------------") # In[171]: features = ['access_to_electricity(%_of_population)', 'renewable_electricity_generating_capacity_per_capita', 'financial_flows_to_developing_countries(us$)', 'electricity_from_nuclear(twh)', 'energy_intensity_level_of_primary_energy(mj/$2017pppgdp)', 'renewables(%equivalent_primary_energy)', 'gdp_per_capita'] def calculate_vif(df, features): vif, tolerance, r2sq = {}, {}, {} # all the features that you want to examine for feature in features: # extract all the other features you will regress against X = [f for f in features if f != feature] X, y = df[X], df[feature] # extract r-squared from the fit r2 = LinearRegression().fit(X, y).score(X, y) # calculate tolerance r2sq[feature] = r2 tolerance[feature] = 1 - r2 # calculate VIF vif[feature] = 1/(tolerance[feature]) # return VIF DataFrame return pd.DataFrame({'VIF': vif, 'Tolerance': tolerance, 'R2': r2sq}) # In[172]: calculate_vif(df_dev_num, features) # In[173]: #Savin features selection df_dev_numl=df_dev_num[['access_to_electricity(%_of_population)', 'renewable_electricity_generating_capacity_per_capita', 'financial_flows_to_developing_countries(us$)', 'electricity_from_nuclear(twh)', 'energy_intensity_level_of_primary_energy(mj/$2017pppgdp)', 'renewables(%equivalent_primary_energy)', 'gdp_per_capita', 'primary_energy_consumption_per_capita(kwh/person)']] df_dev_numl= df_dev_numl.reset_index() df_dev_numl = df_dev_numl.drop(columns=['index']) df_dev_numl.head() # In[174]: #X-y split y=df_dev_numl['primary_energy_consumption_per_capita(kwh/person)'] X_l=df_dev_numl.drop(['primary_energy_consumption_per_capita(kwh/person)'],axis=1) X_l.head() # In[175]: #Encodiing categorical data from sklearn.preprocessing import OneHotEncoder encoder=OneHotEncoder(drop='first').fit(df_dev_cat) encoder=encoder.transform(df_dev_cat).toarray() encoder # In[176]: #Normalizing numerical data from sklearn.preprocessing import StandardScaler transformer=StandardScaler().fit(X_l) X_norml=transformer.transform(X_l) X_norml # In[177]: X_norml=np.concatenate((X_norml ,encoder),axis=1) X_norml # In[178]: X_train,X_test,y_train,y_test=train_test_split(X_norml,y,test_size=0.3,random_state=42) # In[179]: X_train.shape # In[180]: X_test.shape # In[181]: # Crear y ajustar el modelo de regresión lineal regression_model = LinearRegression() regression_model.fit(X_train, y_train) # In[182]: # Realizar las predicciones en conjunto de entrenamiento y conjunto de prueba y_train_pred = regression_model.predict(X_train) y_test_pred = regression_model.predict(X_test) # In[183]: # Calcular las métricas r2_train = r2_score(y_train, y_train_pred) mse_train = mean_squared_error(y_train, y_train_pred) mae_train = mean_absolute_error(y_train, y_train_pred) rmse_train = sqrt(mse_train) r2_test = r2_score(y_test, y_test_pred) mse_test = mean_squared_error(y_test, y_test_pred) mae_test = mean_absolute_error(y_test, y_test_pred) rmse_test = sqrt(mse_test) # In[184]: # Imprimir las métricas print("Métricas en conjunto de entrenamiento:") print("R^2:", r2_train) print("MSE:", mse_train) print("MAE:", mae_train) print("RMSE:", rmse_train) print("------------------------------") print("Métricas en conjunto de prueba:") print("R^2:", r2_test) print("MSE:", mse_test) print("MAE:", mae_test) print("RMSE:", rmse_test) # In[ ]: # ### South America - Asia # In[185]: df_sub = pd.concat([continent_data['South America'], continent_data['Asia']], axis=0) df_sub.reset_index(drop=True, inplace=True) df_sub.head(10) # In[186]: df_sub.shape # In[187]: df_sub_num= df_sub.select_dtypes(exclude=["object"]) df_sub_num.head(5) # In[188]: df_sub_cat= df_sub.select_dtypes(include=["object"]) df_sub_cat.head(5) # In[189]: corr = df_sub_num.corr() high_corr = corr[corr > 0.80] high_corr = high_corr.unstack().dropna() high_corr = high_corr[high_corr.index.get_level_values(0) != high_corr.index.get_level_values(1)] for index, value in high_corr.items(): variable_1, variable_2 = index correlation_value = value print("Variables:", variable_1, "and", variable_2) print("Correlation:", correlation_value) print("------------------------") # In[190]: features = ['access_to_electricity(%_of_population)', 'renewable_electricity_generating_capacity_per_capita', 'financial_flows_to_developing_countries(us$)', 'electricity_from_nuclear(twh)', 'energy_intensity_level_of_primary_energy(mj/$2017pppgdp)', 'renewables(%equivalent_primary_energy)', 'gdp_per_capita'] def calculate_vif(df, features): vif, tolerance, r2sq = {}, {}, {} # all the features that you want to examine for feature in features: # extract all the other features you will regress against X = [f for f in features if f != feature] X, y = df[X], df[feature] # extract r-squared from the fit r2 = LinearRegression().fit(X, y).score(X, y) # calculate tolerance r2sq[feature] = r2 tolerance[feature] = 1 - r2 # calculate VIF vif[feature] = 1/(tolerance[feature]) # return VIF DataFrame return pd.DataFrame({'VIF': vif, 'Tolerance': tolerance, 'R2': r2sq}) # In[191]: calculate_vif(df_sub_num, features) # In[192]: df_sub_numl=df_sub_num[['access_to_electricity(%_of_population)', 'renewable_electricity_generating_capacity_per_capita', 'financial_flows_to_developing_countries(us$)', 'electricity_from_nuclear(twh)', 'energy_intensity_level_of_primary_energy(mj/$2017pppgdp)', 'renewables(%equivalent_primary_energy)', 'gdp_per_capita', 'primary_energy_consumption_per_capita(kwh/person)']] df_sub_numl= df_sub_numl.reset_index() df_sub_numl = df_sub_numl.drop(columns=['index']) df_sub_numl.head() # In[193]: #X-y split y=df_sub_numl['primary_energy_consumption_per_capita(kwh/person)'] X_sub_l=df_sub_numl.drop(['primary_energy_consumption_per_capita(kwh/person)'],axis=1) X_sub_l.head() # In[196]: #Encodiing categorical data from sklearn.preprocessing import OneHotEncoder encoder=OneHotEncoder(drop='first').fit(df_sub_cat) encoder_sub=encoder.transform(df_sub_cat).toarray() encoder_sub # In[197]: #Normalizing numerical data from sklearn.preprocessing import StandardScaler transformer=StandardScaler().fit(X_sub_l) X_sub_norml=transformer.transform(X_sub_l) X_sub_norml # In[200]: X_sub_norml=np.concatenate((X_sub_norml ,encoder_sub),axis=1) X_sub_norml # In[201]: X_train,X_test,y_train,y_test=train_test_split(X_sub_norml,y,test_size=0.3,random_state=42) # In[202]: X_train.shape # In[203]: X_test.shape # In[204]: # Crear y ajustar el modelo de regresión lineal regression_model = LinearRegression() regression_model.fit(X_train, y_train) # In[205]: # Realizar las predicciones en conjunto de entrenamiento y conjunto de prueba y_train_pred = regression_model.predict(X_train) y_test_pred = regression_model.predict(X_test) # In[206]: # Calcular las métricas r2_train = r2_score(y_train, y_train_pred) mse_train = mean_squared_error(y_train, y_train_pred) mae_train = mean_absolute_error(y_train, y_train_pred) rmse_train = sqrt(mse_train) # In[207]: r2_test = r2_score(y_test, y_test_pred) mse_test = mean_squared_error(y_test, y_test_pred) mae_test = mean_absolute_error(y_test, y_test_pred) rmse_test = sqrt(mse_test) # In[208]: # Imprimir las métricas print("Métricas en conjunto de entrenamiento:") print("R^2:", r2_train) print("MSE:", mse_train) print("MAE:", mae_train) print("RMSE:", rmse_train) print("------------------------------") print("Métricas en conjunto de prueba:") print("R^2:", r2_test) print("MSE:", mse_test) print("MAE:", mae_test) print("RMSE:", rmse_test) # In[ ]: # In[ ]: # # K-MEANS # In[ ]: # In[209]: df_all.head() # In[210]: columnas_delete = ['density(P/km2)'] df_all = df_all.drop(columns=columnas_delete) df_all.head(5) # In[211]: df_all.describe() # In[212]: df_all_num= df_all.select_dtypes(exclude=["object"]) df_all_num.head(5) # In[213]: df_all_cat=df_all.select_dtypes(include=['object']) df_all_cat.head(5) # In[218]: scaler = StandardScaler() df_all_num_normalized = scaler.fit_transform(df_all_num) df_all_num_normalized # In[219]: df_all_num_normalized= pd.DataFrame(df_all_num_normalized, columns= df_all_num.columns) df_all_num_normalized.head() # In[220]: df_all_cat_enc = pd.get_dummies(df_all_cat) df_all_cat_enc.head() # In[221]: df_all_num_normalized.head() # In[224]: X=np.concatenate([df_all_num_normalized, df_all_cat_enc],axis=1) X # In[225]: len(X[0]) # In[ ]: # In[226]: test= pd.concat([df_all_num_normalized, df_all_cat_enc],axis=1) test.head() # In[227]: K = range(1,11) inertia = [] for k in K: kmeans = KMeans(n_clusters = k, random_state = 42) kmeans.fit(X) inertia.append(kmeans.inertia_) inertia # In[ ]: # In[228]: plt.figure(figsize=(16,8)) plt.plot(K,inertia,'bx-') plt.xlabel('k') plt.ylabel('inertia') plt.xticks(np.arange(min(K),max(K)+1, 1.0)) plt.title('Elbow Method showing the optimal k') # In[ ]: # In[229]: kmeans = KMeans(n_clusters=4, random_state=1234, verbose=1) kmeans.fit(X) # In[230]: kmeans.inertia_ # In[231]: #Making predictions clusters = kmeans.predict(X) # In[232]: # Check the size of the clusters pd.Series(clusters).value_counts().sort_index() # In[233]: X_data= pd.DataFrame(X) X_data.head() # In[234]: X_df = pd.DataFrame(X) X_df["cluster"] = clusters X_df.head() # In[235]: X_df[X_df['cluster']==0].head() # In[ ]: # In[236]: K = range(1,11) inertia = [] for k in K: kmeans = KMeans(n_clusters = k, random_state = 42) kmeans.fit(test) inertia.append(kmeans.inertia_) inertia # In[237]: clusters_test = kmeans.predict(test) # In[238]: pd.Series(clusters_test).value_counts().sort_index() # In[239]: test2=test.copy() # In[240]: test2['clusters_test']=clusters_test # In[241]: pd.set_option('display.max_rows', None) # Mostrar todas las filas pd.set_option('display.max_columns', None) # Mostrar todas las columnas # In[242]: selected_rows = test2[test2['clusters_test'] == 9] selected_rows_reset = selected_rows.reset_index(drop=True) selected_rows_reset.head() # In[243]: test2[test2['clusters_test']==1].head() # In[ ]: # ## RAMDOM FOREST REGRESSOR # In[244]: df_all.shape # In[245]: df_all_num.head() # In[246]: df_all_cat.head(3) # In[247]: df_num_r=df_all_num[['access_to_electricity(%_of_population)', 'renewable_electricity_generating_capacity_per_capita', 'financial_flows_to_developing_countries(us$)', 'electricity_from_nuclear(twh)', 'energy_intensity_level_of_primary_energy(mj/$2017pppgdp)', 'renewables(%equivalent_primary_energy)', 'gdp_per_capita', 'primary_energy_consumption_per_capita(kwh/person)']] df_num_r= df_num_r.reset_index() df_num_r = df_num_r.drop(columns=['index']) df_num_r.head() # In[248]: df_all_cat.head() # In[249]: #X-y split y=df_num_r['primary_energy_consumption_per_capita(kwh/person)'] X=df_num_r.drop(['primary_energy_consumption_per_capita(kwh/person)'],axis=1) # In[253]: #Encodiing categorical data from sklearn.preprocessing import OneHotEncoder encoder=OneHotEncoder(drop='first').fit(df_all_cat) encoder=encoder.transform(df_all_cat).toarray() encoder # In[251]: #Normalizing numerical data from sklearn.preprocessing import StandardScaler transformer=StandardScaler().fit(X) X_norm=transformer.transform(X) X_norm # In[254]: X=np.concatenate((X_norm ,encoder),axis=1) X # In[255]: X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # Entrenar el modelo RandomForestRegressor model = RandomForestRegressor(random_state=42) # Puedes ajustar los hiperparámetros aquí model.fit(X_train, y_train) # Realizar predicciones en el conjunto de prueba y_pred = model.predict(X_test) # Calcular el error (por ejemplo, el error cuadrático medio) mse = mean_squared_error(y_test, y_pred) print(f'Error cuadrático medio: {mse}') # Calcular el error absoluto medio (MAE) mae = mean_absolute_error(y_test, y_pred) print(f'Error absoluto medio (MAE): {mae}') # Calcular el coeficiente de determinación (R-squared) r2 = r2_score(y_test, y_pred) print(f'Coeficiente de determinación (R-squared): {r2}') # In[ ]: # ## KNN Regressor # In[256]: df_all_num.head(3) # In[257]: df_all_cat.head(3) # In[258]: df_num_k=df_all_num[['access_to_electricity(%_of_population)', 'renewable_electricity_generating_capacity_per_capita', 'financial_flows_to_developing_countries(us$)', 'electricity_from_nuclear(twh)', 'energy_intensity_level_of_primary_energy(mj/$2017pppgdp)', 'renewables(%equivalent_primary_energy)', 'gdp_per_capita', 'primary_energy_consumption_per_capita(kwh/person)']] df_num_k= df_num_k.reset_index() df_num_k = df_num_k.drop(columns=['index']) df_num_k.head() # In[259]: #X-y split y=df_num_k['primary_energy_consumption_per_capita(kwh/person)'] X=df_num_k.drop(['primary_energy_consumption_per_capita(kwh/person)'],axis=1) # In[262]: #Encodiing categorical data from sklearn.preprocessing import OneHotEncoder encoder=OneHotEncoder(drop='first').fit(df_all_cat) encoder=encoder.transform(df_all_cat).toarray() encoder # In[263]: #Normalizing numerical data from sklearn.preprocessing import StandardScaler transformer=StandardScaler().fit(X) X_norm=transformer.transform(X) X_norm # In[267]: X_r=np.concatenate((X_norm ,encoder),axis=1) X_r # In[268]: from sklearn.neighbors import KNeighborsRegressor # In[269]: X_train, X_test, y_train, y_test = train_test_split(X_r, y, test_size=0.2, random_state=42) #Model development KNN_reg = KNeighborsRegressor(n_neighbors=2) # Entrenamiento de lo modelo regressor = KNN_reg.fit(X_train, y_train) #Predición de modelo y_pred_knn = regressor.predict(X_test) # In[270]: plt.figure(figsize=(15, 6)) plt.plot(list(y_test), c="g", label="Actual", linewidth=2) plt.plot(y_pred_knn, c="r", label="predicción", linewidth=2) plt.legend(loc='best') plt.show(); # Parece que el Modelo KNN se ajusto bien, los valores pronosticados siguen los valores reales # # Finalmente, evaluaré el modelo con diferentes tipos de metricas en el conjunto de prueba (línea de base contra la extrapolación) # In[ ]: # In[271]: #model evaluation print ("Mean Absolute Error:" , metrics.mean_absolute_error(y_test, y_pred_knn)) print ("Mean Squared Error:" , metrics.mean_squared_error(y_test, y_pred_knn)) print ("Root Mean Squared Error:" , np.sqrt(metrics.mean_squared_error(y_test, y_pred_knn))) print('Coefficient of determination: %.2f'% r2_score(y_test, y_pred_knn)) # In[ ]: # ### **3.8 Calculo de K-vecinos contra RMSE** # # **Elegir un valor K** # # Sigamos adelante y usemos el método del codo para elegir un buen valor $K$. # In[272]: from sklearn import neighbors rmse_val = [] #para almacenar valores rmse para diferentes k for K in range(20): K = K+1 model = neighbors.KNeighborsRegressor(n_neighbors = K) model.fit(X_train, y_train) #fit the model pred=model.predict(X_test) #hacer predicciones en el equipo de prueba error = sqrt(mean_squared_error(y_test,pred)) #calculate rmse rmse_val.append(error) #store rmse values print('Valor de RMSE para k= ' , K , 'es:', error) # In[273]: plt.figure(figsize=(15,6)) plt.plot(rmse_val ,color="blue", linestyle="dashed", marker="o", markerfacecolor="red", markersize=10) plt.title('Método del Codo, RMSE vs. K Value', size=20) plt.xlabel('K') plt.ylabel('Error Rate') # In[ ]: # In[274]: # Implementacion de GridserachCV para encontrar el mejor valor de K # In[275]: from sklearn.model_selection import GridSearchCV params={'n_neighbors': [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]} # In[276]: knn= neighbors.KNeighborsRegressor() # In[277]: model= GridSearchCV(knn, params, cv=5) model.fit(X_train, y_train) model.best_params_ # In[ ]: # In[ ]: # In[ ]: # In[ ]: # # EXTRA INSIGHTS # In[278]: # Function to plot features on world map def plot_world_map(column_name): fig = go.Figure() for year in range(2000, 2021): # Filter the data for the current year filtered_df = df_all[df_all['year'] == year] # Create a choropleth trace for the current year trace = go.Choropleth( locations=filtered_df['entity'], z=filtered_df[column_name], locationmode='country names', colorscale='Electric', # Use a different color scale for better contrast colorbar=dict(title=column_name), zmin=df[column_name].min(), zmax=df[column_name].max(), visible=False # Set the trace to invisible initially ) # Add the trace to the figure fig.add_trace(trace) # Set the first trace to visible fig.data[0].visible = True # Create animation steps steps = [] for i in range(len(fig.data)): step = dict( method='update', args=[{'visible': [False] * len(fig.data)}, # Set all traces to invisible {'title_text': f'{column_name} Map - {2000 + i}', 'frame': {'duration': 1000, 'redraw': True}}], label=str(2000 + i) # Set the label for each step ) step['args'][0]['visible'][i] = True # Set the current trace to visible steps.append(step) # Create the slider sliders = [dict( active=0, steps=steps, currentvalue={"prefix": "Year: ", "font": {"size": 14}}, # Increase font size for slider label )] # Update the layout of the figure with increased size and change the template fig.update_layout( title_text=f'{column_name}''' '%', # Set the initial title title_font_size=24, # Increase title font size title_x=0.5, # Center the title geo=dict( showframe=True, showcoastlines=True, projection_type='natural earth' ), sliders=sliders, height=500, # Set the height of the figure in pixels width=1000, # Set the width of the figure in pixels font=dict(family='Arial', size=12), # Customize font family and size for the whole figure margin=dict(t=80, l=50, r=50, b=50), # Add margin for better layout spacing template='plotly', # Change the template to 'plotly_dark' ) # Show the figure fig.show() # In[279]: column_name = 'access_to_clean_fuels_for_cooking' plot_world_map(column_name) # In[280]: column_name = 'CO2_emissions_value_by_country_kt' plot_world_map(column_name) # In[281]: column_name = 'primary_energy_consumption_per_capita(kwh/person)' plot_world_map(column_name) # In[282]: column_name = 'electricity_from_renewables(twh)' plot_world_map(column_name) #no aprece nada en Europa y Afric # In[283]: column_name = 'renewable_energy_share_in_the_total_final_energy_consumption(%)' plot_world_map(column_name) # In[284]: column_name = 'access_to_electricity(%_of_population)' plot_world_map(column_name) #no aprece nada en Europa y Afr # In[ ]: # In[ ]: # In[285]: df_all.head(1) # In[ ]: # In[ ]: # In[289]: # Filtra el DataFrame para obtener datos de los años 2010 y 2020 df_filtered = df_all[df_all['year'].isin([2010, 2020])] # Crea dos gráficos de barras apiladas plt.figure(figsize=(10, 6)) # Tamaño de la figura sns.barplot(x='continent', y='access_to_electricity(%_of_population)', hue='year', data=df_filtered, palette=['red', 'blue']) # Personaliza el gráfico plt.xlabel('Continente') plt.ylabel('Acceso a Electricidad (%)') plt.title('Comparativa de Acceso a Electricidad por Continente (2010 vs. 2020)') # Agregar etiquetas de datos a las barras for p in plt.gca().patches: plt.gca().annotate(f'{p.get_height():.2f}%', (p.get_x() + p.get_width() / 2, p.get_height()), ha='center', va='bottom') # Muestra el gráfico plt.show() # In[290]: # Filtra el DataFrame para obtener datos de los años 2010 y 2020 solo para Asia y Sudamérica continents_to_plot = ['Asia', 'South America'] df_filtered = df_all[(df_all['year'].isin([2010, 2020])) & (df_all['continent'].isin(continents_to_plot))] # Crea un gráfico de barras apiladas plt.figure(figsize=(10, 6)) # Tamaño de la figura sns.barplot(x='continent', y='access_to_electricity(%_of_population)', hue='year', data=df_filtered, palette=['red', 'blue']) # Personaliza el gráfico plt.xlabel('Continente') plt.ylabel('Acceso a Electricidad (%)') plt.title('Comparativa de Acceso a Electricidad en Asia y Sudamérica (2010 vs. 2020)') # Agregar etiquetas de datos a las barras for p in plt.gca().patches: plt.gca().annotate(f'{p.get_height():.2f}%', (p.get_x() + p.get_width() / 2, p.get_height()), ha='center', va='bottom') # Muestra el gráfico plt.show() # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: # In[ ]: