Auf dem volatilen Aktienmarkt von heute suchen Anleger ständig nach Möglichkeiten, ihre Rendite zu maximieren. Die Analyse der Aktienstimmung kann wertvolle Einblicke in Markttrends liefern und dabei helfen, potenzielle Gewinner und Verlierer zu identifizieren. In diesem Blogbeitrag werden wir untersuchen, wie wir die Polygon-API, Modelle für maschinelles Lernen (ML) und Stimmungsanalysen nutzen können, um die Aktien mit den größten Gewinnern und Verlierern zu identifizieren.
Schritt 1: Abrufen historischer Bestandsdaten: Der erste Schritt besteht darin, historische Bestandsdaten für unsere Analyse zu erhalten. Wir nutzen die Polygon-API, die eine große Menge an Echtzeit- und historischen Marktdaten bereitstellt. Über die API können wir die notwendigen Daten für unsere ML-Modelle abrufen.
Schritt 2: Stimmungsanalyse und Datenverarbeitung: Um die mit Aktien verbundene Stimmung zu bestimmen, benötigen wir stimmungsbezogene Daten. Obwohl die Polygon-API keine direkten Stimmungsdaten bereitstellt, können wir diese aus externen Quellen wie Nachrichten-APIs oder Social-Media-Plattformen beziehen. Durch die Durchführung einer Stimmungsanalyse dieser Textdatenquellen können wir die mit bestimmten Aktien verbundene Stimmung (positiv, negativ, impartial) einschätzen.
Schritt 3: Kombinieren von Bestandsdaten und Stimmungsdaten: Sobald wir die historischen Aktiendaten und Stimmungsdaten erhalten haben, können wir sie basierend auf übereinstimmenden Zeitstempeln oder anderen relevanten Kriterien zusammenführen. Durch die Kombination dieser Datensätze können wir einen umfassenden Datensatz erstellen, der sowohl Aktienkursinformationen als auch Ergebnisse der Stimmungsanalyse enthält.
Schritt 4: ML-Modellierung: Nachdem der kombinierte Datensatz vorhanden ist, können wir nun mit der ML-Modellierung fortfahren. Wir verwenden ML-Modelle wie Klassifizierungsalgorithmen oder Deep-Studying-Modelle, um die Stimmung der Aktien auf der Grundlage der verfügbaren Funktionen und Stimmungsdaten zu trainieren und vorherzusagen. Dieser Schritt ermöglicht es uns, die Leistungsfähigkeit von ML zu nutzen, um Aktien in verschiedene Stimmungskategorien zu klassifizieren.
Schritt 5: Visualisierung: Um ein besseres Verständnis der Ergebnisse der Stimmungsanalyse zu erhalten, visualisieren wir die Ergebnisse mithilfe von Diagrammen. Wir können verschiedene Visualisierungstechniken wie Balkendiagramme oder Kreisdiagramme verwenden, um die Stimmungsverteilung der Prime-Gewinner- und Prime-Verlierer-Aktien darzustellen. Diese Visualisierungen vermitteln ein klares Bild der mit diesen Aktien verbundenen Stimmung.
Abschluss: Die Analyse der Aktienstimmung ist ein wertvolles Instrument für Anleger, die fundierte Entscheidungen an der Börse treffen möchten. Durch die Nutzung der Polygon-API, die Kombination von Aktiendaten mit Stimmungsdaten und die Verwendung von ML-Modellen können wir die Aktien mit den größten Gewinnern und Verlierern mit der zugehörigen Stimmungsanalyse identifizieren. Mit diesen Erkenntnissen können Anleger fundiertere Entscheidungen treffen und möglicherweise Marktchancen nutzen.
Lassen Sie uns ein Beispiel für einen Python-Code sein:
import requests
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as pltapi_key = "YOUR_API_KEY"
base_url = "https://api.polygon.io/v2/aggs/ticker"
tickers = ["AAPL", "TSLA", "GOOGL", "AMZN"]
from_date = "2023-01-01"
to_date = "2023-06-01"
stock_data = {}
for ticker in tickers:
url = f"{base_url}/{ticker}/vary/1/day/{from_date}/{to_date}?apiKey={api_key}"
response = requests.get(url)
information = response.json()
stock_data[ticker] = information['results']
gainers = {}
losers = {}
for ticker, information in stock_data.objects():
df = pd.DataFrame(information)
df['timestamp'] = pd.to_datetime(df['t'], unit='ms')
df.set_index('timestamp', inplace=True)
df.sort_index(ascending=True, inplace=True)
df['change'] = df['c'].pct_change()
gainers[ticker] = df['change'].idxmax()
losers[ticker] = df['change'].idxmin()
top_gainer = max(gainers, key=gainers.get)
top_loser = min(losers, key=losers.get)
gainer_data = stock_data[top_gainer]
loser_data = stock_data[top_loser]
gainer_df = pd.DataFrame(gainer_data)
gainer_df['timestamp'] = pd.to_datetime(gainer_df['t'], unit='ms')
gainer_df.set_index('timestamp', inplace=True)
gainer_df.sort_index(ascending=True, inplace=True)
loser_df = pd.DataFrame(loser_data)
loser_df['timestamp'] = pd.to_datetime(loser_df['t'], unit='ms')
loser_df.set_index('timestamp', inplace=True)
loser_df.sort_index(ascending=True, inplace=True)
gainer_features = gainer_df[['o', 'h', 'l', 'v']]
gainer_target = gainer_df['c']
loser_features = loser_df[['o', 'h', 'l', 'v']]
loser_target = loser_df['c']
gainer_features_train, gainer_features_test, gainer_target_train, gainer_target_test = train_test_split(
gainer_features, gainer_target, test_size=0.2, random_state=42
)
loser_features_train, loser_features_test, loser_target_train, loser_target_test = train_test_split(
loser_features, loser_target, test_size=0.2, random_state=42
)
gainer_model = LinearRegression()
gainer_model.match(gainer_features_train, gainer_target_train)
gainer_score = gainer_model.rating(gainer_features_test, gainer_target_test)
loser_model = LinearRegression()
loser_model.match(loser_features_train, loser_target_train)
loser_score = loser_model.rating(loser_features_test, loser_target_test)
print("Mannequin efficiency:")
print(f"Gainer Mannequin R-squared: {gainer_score}")
print(f"Loser Mannequin R-squared: {loser_score}")
ML-Modell mit Darstellung der Ergebnisse der Stimmungsanalyse für die Prime-Gewinner- und Prime-Verlierer-Aktien. Sie können Balkendiagramme oder Kreisdiagramme verwenden, um die Stimmungsverteilung anzuzeigen, oder eine andere Visualisierungstechnik verwenden, die die Ergebnisse der Stimmungsanalyse am besten darstellt.
gainer_predictions = gainer_model.predict(gainer_features_test)
print("GAINER:", gainer_predictions)plt.determine(figsize=(12, 6))
plt.plot(gainer_target_test.index, gainer_target_test, label="Precise")
plt.plot(gainer_target_test.index, gainer_predictions, label="Predicted")
plt.xlabel("Date")
plt.ylabel("Inventory Value")
plt.title("Prime Gainer Inventory - Precise vs. Predicted")
plt.legend()
plt.present()
loser_predictions = loser_model.predict(loser_features_test)
print("LOSER:", loser_predictions)
plt.determine(figsize=(12, 6))
plt.plot(loser_target_test.index, loser_target_test, label="Precise")
plt.plot(loser_target_test.index, loser_predictions, label="Predicted")
plt.xlabel("Date")
plt.ylabel("Inventory Value")
plt.title("Prime Loser Inventory - Precise vs. Predicted")
plt.legend()
plt.present()
Dies ist nur ein einfaches Beispiel dafür, wie Sie mit der Polygon.io-API Daten zur Aktienstimmung abrufen und mithilfe eines maschinellen Lernmodells vorhersagen können, welche Aktien wahrscheinlich die größten Gewinner und Verlierer sein werden. Mit diesem Ansatz können Sie eine ausgefeiltere Handelsstrategie entwickeln, die Ihnen dabei helfen kann, fundiertere Anlageentscheidungen zu treffen.
Besuchen Sie meinen Weblog: https://medium.com/@sahajgodhani777
Besuchen Sie meine offizielle Web site: https://sahajgodhani.in/
