SEI UN GRANDE , a questo ho semplicemente aggiunto il calcolo del sentiment e inidici come inflazione e PIL.
adesso il risultato è questo. dammi qualche consigliooooooooo


import yfinance as yf

import numpy as np

import matplotlib.pyplot as plt

import pandas_datareader.data as web

from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer

from newsapi import NewsApiClient




class PortfolioOptimizer:

def __init__(self, tickers, start_date, end_date, num_portfolios=10000):

"""

Inizializza l'ottimizzatore di portafoglio.



:param tickers: Lista di ticker azionari.

:param start_date: Data di inizio per i dati storici.

:param end_date: Data di fine per i dati storici.

:param num_portfolios: Numero di portafogli da simulare.

"""

self.tickers = tickers

self.start_date = start_date

self.end_date = end_date

self.num_portfolios = num_portfolios

self.data = None

self.returns = None

self.results = None

self.weights_record = []

self.inflation = None

self.gdp = None

self.sentiment_weight = None




def fetch_data(self):

"""Scarica i dati storici dei prezzi e calcola i rendimenti."""

self.data = yf.download(self.tickers, start=self.start_date, end=self.end_date)['Adj Close']

self.returns = self.data.pct_change(fill_method=None).dropna()




def fetch_economic_indicators(self):

"""Scarica i dati economici per l'inflazione e il PIL."""

self.inflation = web.DataReader('CPIAUCSL', 'fred', self.start_date, self.end_date)

self.gdp = web.DataReader('GDP', 'fred', self.start_date, self.end_date)



def fetch_sentiment(self):



"""Scarica e analizza il sentiment delle notizie di mercato."""

newsapi = NewsApiClient(api_key='YOUR_API_KEY')

all_articles = newsapi.get_everything(q='stock market', from_param=self.start_date, to=self.end_date, language='en')



analyzer = SentimentIntensityAnalyzer()

sentiments = []

for article in all_articles['articles']:

title = article['title']

sentiment = analyzer.polarity_scores(title)['compound']

sentiments.append(sentiment)

self.sentiment_weight = np.mean(sentiments)




def adjusted_returns(self):

"""Calcola i rendimenti aggiustati considerando indicatori economici e sentiment."""

# Combinare i dati di rendimenti e indicatori economici

combined_data = pd.concat([self.returns, self.inflation, self.gdp], axis=1).dropna()

# Peso per il sentiment

sentiment_weight = self.sentiment_weight if self.sentiment_weight else 0

# Peso per l'inflazione

inflation_weight = self.inflation.mean().values0 if not self.inflation.empty else 0

# Adjusted returns

return combined_data.iloc[:, :-2] * (1 + sentiment_weight + inflation_weight)



def simulate_portfolios(self):

"""Simula portafogli casuali e calcola rendimento, volatilità e Sharpe Ratio."""

num_assets = len(self.tickers)

self.results = np.zeros((3, self.num_portfolios))

adjusted_returns = self.adjusted_returns()




for i in range(self.num_portfolios):

weights = np.random.random(num_assets)

weights /= np.sum(weights)

self.weights_record.append(weights)




# Rendimento atteso annualizzato

portfolio_return = np.sum(weights * adjusted_returns.mean()) * 252

# Volatilità annualizzata

portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(adjusted_returns.cov() * 252, weights)))

# Sharpe Ratio

sharpe_ratio = portfolio_return / portfolio_volatility




self.results[0, i] = portfolio_return

self.results[1, i] = portfolio_volatility

self.results[2, i] = sharpe_ratio




def get_optimal_portfolios(self):

"""

Trova il portafoglio con il miglior Sharpe Ratio e quello con la minore volatilità.



:return: Indici e pesi ottimali.

"""

max_sharpe_idx = np.argmax(self.results2)

min_volatility_idx = np.argmin(self.results1)




return {

"max_sharpe_idx": max_sharpe_idx,

"min_volatility_idx": min_volatility_idx,

"best_weights": self.weights_recordmax sharpe idx,

"min_volatility_weights": self.weights_recordmin volatility idx,

}




def plot_results(self, optimal_portfolios):

"""Visualizza i risultati della simulazione."""

plt.figure(figsize=(10, 6))

plt.scatter(self.results[1, :], self.results[0, :], c=self.results[2, :], cmap='YlGnBu', marker='o')

plt.colorbar(label='Sharpe Ratio')

plt.scatter(

self.results[1, optimal_portfolios["max_sharpe_idx"]],

self.results[0, optimal_portfolios["max_sharpe_idx"]],

marker='*',

color='r',

s=500,

label='Miglior Sharpe Ratio',

)

plt.scatter(

self.results[1, optimal_portfolios["min_volatility_idx"]],

self.results[0, optimal_portfolios["min_volatility_idx"]],

marker='*',

color='g',

s=500,

label='Minima Volatilità',

)

plt.title('Simulazione di Portafogli')

plt.xlabel('Volatilità')

plt.ylabel('Rendimento Atteso')

plt.legend()

plt.show()




def print_optimal_portfolios(self, optimal_portfolios):

"""Stampa i dettagli dei portafogli ottimali."""

max_sharpe_idx = optimal_portfolios["max_sharpe_idx"]

min_volatility_idx = optimal_portfolios["min_volatility_idx"]




print("Portafoglio con miglior Sharpe Ratio:")

print(f"Rendimento atteso: {self.results[0, max_sharpe_idx]:.2f}")

print(f"Volatilità: {self.results[1, max_sharpe_idx]:.2f}")

print("Pesi:")

for ticker, weight in zip(self.tickers, optimal_portfolios["best_weights"]):

print(f"{ticker}: {weight:.2%}")




print("\nPortafoglio con minima volatilità:")

print(f"Rendimento atteso: {self.results[0, min_volatility_idx]:.2f}")

print(f"Volatilità: {self.results[1, min_volatility_idx]:.2f}")

print("Pesi:")

for ticker, weight in zip(self.tickers, optimal_portfolios["min_volatility_weights"]):

print(f"{ticker}: {weight:.2%}")




# Esempio di utilizzo

tickers = ['NVDA', 'KO', 'TSLA', 'ENI.MI', 'META', 'BC.MI']

optimizer = PortfolioOptimizer(tickers, start_date="2023-05-01", end_date="2023-11-01")




# Passaggi

optimizer.fetch_data()

optimizer.fetch_economic_indicators()

optimizer.fetch_sentiment()

optimizer.simulate_portfolios()

optimal_portfolios = optimizer.get_optimal_portfolios()

optimizer.plot_results(optimal_portfolios)

optimizer.print_optimal_portfolios(optimal_portfolios)

ragazzi sono un laureando magistrale e come tesi dovrei implementare un modello di gestione di un portafoglio azionari con titioli da me scelti, mediante l'utilizzo di Python
nvidia

coca cola

tesla

eni

meta pltaform

brunello cucinelli




Ora essendo io completamente ebete ed inesperto, provado a smanettare con python ho tirato giù qualche stringa di codice (grazie anche ai vari video tutorial).


import yfinance as yf

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt




# Lista di ticker azionari

tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA']




# Scarica i dati dei prezzi storici (5 anni di dati)

data = yf.download(tickers, start="2019-01-01", end="2024-01-01")['Adj Close']




# Calcolo dei rendimenti giornalieri

returns = data.pct_change().dropna()




# Numero di azioni nel portafoglio

num_assets = len(tickers)




# Numero di portafogli da simulare

num_portfolios = 10000




# Array per memorizzare risultati

results = np.zeros((3, num_portfolios))

weights_record = []




# Simulazione dei portafogli

for i in range(num_portfolios):

# Generazione di pesi casuali

weights = np.random.random(num_assets)

weights /= np.sum(weights) # Normalizzazione: la somma dei pesi è 1

weights_record.append(weights)



# Calcolo rendimento atteso e volatilità (std) del portafoglio

portfolio_return = np.sum(weights * returns.mean()) * 252 # Annualizzato

portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(returns.cov() * 252, weights))) # Annualizzato



# Sharpe Ratio (considerando un tasso privo di rischio pari a 0)

sharpe_ratio = portfolio_return / portfolio_volatility



# Memorizza rendimento, volatilità e Sharpe ratio

results[0,i] = portfolio_return

results[1,i] = portfolio_volatility

results[2,i] = sharpe_ratio




# Trovare il portafoglio con il più alto Sharpe Ratio

max_sharpe_idx = np.argmax(results2)

best_weights = weights_recordmax sharpe idx




# Trovare il portafoglio con la minore volatilità

min_volatility_idx = np.argmin(results1)




# Plotting dei risultati

plt.scatter(results[1,:], results[0,:], c=results[2,:], cmap='YlGnBu', marker='o')

plt.colorbar(label='Sharpe Ratio')

plt.scatter(results[1, max_sharpe_idx], results[0, max_sharpe_idx], marker='*', color='r', s=500, label='Miglior Sharpe Ratio')

plt.scatter(results[1, min_volatility_idx], results[0, min_volatility_idx], marker='*', color='g', s=500, label='Minima Volatilità')

plt.title('Simulazione di Portafogli')

plt.xlabel('Volatilità')

plt.ylabel('Rendimento Atteso')

plt.legend()

plt.show()




# Stampa dei risultati

print("Portafoglio con miglior Sharpe Ratio:")

print(f"Rendimento atteso: {results[0, max_sharpe_idx]:.2f}")

print(f"Volatilità: {results[1, max_sharpe_idx]:.2f}")

print(f"Pesi: {best_weights}")


questo è più o meno il risultato, qualche buon anima e innovatore del nostro mondo può aiutare un uomo in pena con qualche dritta e consiglio?
l' obiettivo oltre è valutare la performance in un arco temporale indicativo di 6 mesi da maggio ad oggi.


vi amooo