ESG Factor Modeling With Python

    	
            
import pandas as pd
import numpy as np
 
import seaborn as sns
import matplotlib.pyplot as plt
 
import refinitiv.data as rd
 
rd.open_session()

        
        Copy
    

    	
            
# Get annual pricing data with get_data function from year 2000 to 2024
fund_nav_df = rd.get_data(['SCC.BK'],
                          ['TR.PriceClose.date', 'TR.PriceClose'],
                          {'SDate': '2000-10-04', 'EDate': '2024-03-01', 'Frq': 'FY'})
fund_nav_df.set_index('Date', inplace=True)
fund_nav_df

        
        Copy
    

    	
            
# Plot graph to see the trend of pricing
price_close = fund_nav_df['Price Close']
price_close.plot()

        
        Copy
    

    	
            
# Get annual ESG score data with get_data function from year 2000 to 2024
df = rd.get_data(
    universe = ['SCC.BK'],
    fields = [
        'TR.TRESGScore.date',
        'TR.TRESGScore',
        'TR.TRESGCScore',
        'TR.TRESGCControversiesScore',
        'TR.TRESGResourceUseScore',
        'TR.TRESGEmissionsScore',
        'TR.TRESGInnovationScore',
        'TR.TRESGWorkforceScore',
        'TR.TRESGHumanRightsScore',
        'TR.TRESGCommunityScore',
        'TR.TRESGProductResponsibilityScore',
        'TR.TRESGManagementScore',
        'TR.TRESGShareholdersScore',
        'TR.TRESGCSRStrategyScore'
    ],
    parameters = {'Period':'FY0','Frq':'FY','SDate':'0','EDate':'-24'}
)
 
# Format data
factor_df = df
factor_df.sort_values(by = ['Date'], ascending = [True], inplace = True)
factor_df.dropna(inplace=True)
factor_df

        
        Copy
    

    	
            
# Calculate Log Return of Asset
 
log_returns = np.log(price_close / price_close.shift(1))
fund_nav_df["log_returns"] = log_returns
fund_nav_df

        
        Copy
    

    	
            
fund_nav_df.drop(columns=['Instrument', 'Price Close'], inplace = True)
fund_nav_df['Year'] = fund_nav_df.index.strftime('%Y')
 
factor_df['Year'] = factor_df['Date'].dt.strftime('%Y')
 
df_beta = pd.merge(fund_nav_df, factor_df , on='Year', how='left').dropna()
df_beta

        
        Copy
    

    	
            
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score
 
# Log return data are assigned to y value
y = df_beta.iloc[:, 1:2].to_numpy()
# All corresponding factors are assigned as X value
X = df_beta.drop(columns=['log_returns','Year','Instrument','Date'])
 
# coefficients linear regression
reg = LinearRegression(positive = True).fit(X, y)
liber_coeff = pd.DataFrame(reg.coef_, columns=reg.feature_names_in_)
 
# Calculate R-Squared and regression intercept (Alpha) values
R2 = r2_score( y, reg.predict(X))
liber_coeff["R2"] = R2
liber_coeff["Alpha"]=reg.intercept_
 
liber_coeff

        
        Copy
    

    	
            
sns.heatmap(liber_coeff.T, annot=True, cmap='coolwarm')
plt.show()

        
        Copy
    

    	
            
# Performing linear regression on a subset of the dataset
# Identifying variations in the relationship between variables across subsets.
 
list_factor_year = []
 
x = range(0, len(df_beta), 3)
 
for n in x:
    df_beta_ = df_beta.iloc[n:n+2].drop(columns=['Date'])
    y = df_beta_.iloc[:, 1:2].to_numpy()
    X = df_beta_.drop(columns=['log_returns','Year','Instrument'])
    
    # Coefficients linear regression
    reg = LinearRegression(positive = True).fit(X, y)
    liber_coeff = pd.DataFrame(reg.coef_, columns=reg.feature_names_in_)
    R2 = r2_score(y, reg.predict(X))
    liber_coeff['R2'] = R2
    liber_coeff['Alpha']=reg.intercept_
 
    liber_coeff['Year'] = df_beta_.Year.iloc[-1]
    list_factor_year.append(liber_coeff)
 
df_factor_time = pd.concat(list_factor_year)
df_factor_time.set_index('Year', inplace=True)
df_factor_time

        
        Copy
    

    	
            
sns.heatmap(df_factor_time.head(10), annot=True, cmap='coolwarm')
plt.show()

        
        Copy
    

    	
            
# Find the optimal weights that minimizes the Tracking error
# between a portfolio of the explanatory variables(X) and the dependent variable(y).
 
from scipy.optimize import minimize
 
def tracking_error(r_a, r_b):
    """
    Returns the Tracking Error between the two return series
    """
    return np.sqrt(((r_a - r_b)**2).sum())
 
def portfolio_tracking_error(weights, ref_r, bb_r):
    """
    returns the tracking error between the reference returns
    and a portfolio of building block returns held with given weights
    """
    return tracking_error(ref_r, (weights*bb_r).sum(axis=1))
 
# Defining the styles_analysis function
 
def style_analysis(dependent_variable, explanatory_variables):
    """
    Returns the optimal weights that minimizes the Tracking error between
    a portfolio of the explanatory variables and the dependent variable
    """
    n = explanatory_variables.shape[1]
    init_guess = np.repeat(1/n, n)
    bounds = ((0.0, 1.0),) * n # an N-tuple of 2-tuples!
    # construct the constraints
    weights_sum_to_1 = {'type': 'eq',
                        'fun': lambda weights: np.sum(weights) - 1
    }
    solution = minimize(portfolio_tracking_error, init_guess,
                       args=(dependent_variable, explanatory_variables,), method='SLSQP',
                       options={'disp': False},
                       constraints=(weights_sum_to_1,),
                       bounds=bounds)
    weights = pd.Series(solution.x, index=explanatory_variables.columns)
    return weights

        
        Copy
    

    	
            
# Assigning asset log return (y value) as dependent variable and ESG factors (X value) as explanatory variables
dependent_variable = df_beta[['log_returns']]
explanatory_variables =  df_beta.iloc[:, 4:-1]
 
# Find the optimal weights that minimizes the Tracking error
weights_b = style_analysis(dependent_variable['log_returns'], explanatory_variables)

        
        Copy
    

    	
            weights_b.sort_values(ascending=False).plot.bar()
        
        Copy
    

    	
            
pd.set_option('display.float_format', lambda x: '%.15f' % x)
weights_b

        
        Copy