Auf dieser Seite
Helm & Nagel
Florian Zyprian

Florian Zyprian is Chief Technology Officer at Helm & Nagel GmbH, where he leads the architecture and implementation of production artificial intelligence systems. His core responsibilities span system design, machine learning infrastructure, model training pipelines, and deployment automation across the insurance, logistics, and energy sectors. With extensive experience in building complex, scalable systems, Florian specializes in creating solutions that operate reliably in production environments for years without requiring human intervention or constant maintenance.

Traditionelle Finanzmodelle stützen sich hauptsächlich auf Marktpreise und historische Finanzdaten, um zukünftige Trends vorherzusagen und Risiken zu bewerten. Alternative Daten haben dieses Feld grundlegend verändert. Dazu zählen Nachrichtenartikel, Social-Media-Beiträge, Satellitenbilder, Audioaufnahmen und Videoinhalte. Diese Quellen liefern zusätzliche Einblicke, die fundiertere Entscheidungen ermöglichen und die Genauigkeit von Prognosemodellen verbessern.

Überblick

Dieser Artikel zeigt, wie Sie numerische Repräsentationen alternativer Daten erstellen und in bestehende Finanzmodelle integrieren. Wir konzentrieren uns auf eine vereinfachte Methode mit einem autoregressiven Ansatz kombiniert mit traditionellen Marktpreisdaten. Am Ende dieses Leitfadens verstehen Sie, wie Sie:

  1. Numerische Repräsentationen (Embeddings) alternativer Daten erstellen.
  2. Diese Embeddings in Finanzmodelle integrieren, um Risiken zu bewerten und vorherzusagen.

Alternative Daten in numerischen Modellen verwenden

Um alternative Daten in unsere Modelle zu integrieren, konvertieren wir diese vielfältigen Datentypen in numerische Repräsentationen, sogenannte Embeddings. Diese Embeddings ermöglichen es, qualitative Daten in quantitative Modelle zu überführen und mit traditionellen Finanzdaten vergleichbar zu machen.

  1. Textdaten: Durch die Verarbeitung von Texten aus Nachrichtenartikeln oder sozialen Medien erfassen wir Marktstimmung und öffentliche Meinung. Dafür verwenden wir fortschrittliche Modelle wie BERT oder GPT-3, um Sätze in numerische Vektoren umzuwandeln, die deren Bedeutung und Stimmung widerspiegeln.
  2. Audiodaten: Sprache aus Earnings Calls oder CEO-Interviews wird mit Speech-to-Text-Technologien in Text umgewandelt. Anschließend analysieren wir Stimmung und Kernthemen dieser Transkripte und überführen sie in numerische Scores.
  3. Bilddaten: Satellitenbilder von Parkplätzen großer Einzelhändler lassen sich analysieren, um den Kundenverkehr zu schätzen. Wir verwenden vortrainierte neuronale Netze wie ResNet, um relevante Merkmale aus diesen Bildern zu extrahieren und in numerische Daten umzuwandeln.

Integration in Finanzmodelle

Diese numerischen Repräsentationen werden in unseren Prognosemodellen mit traditionellen Marktdaten kombiniert. Ein autoregressives Modell könnte beispielsweise die zukünftige Volatilität vorhersagen, indem es sowohl historische Kursdaten als auch Stimmungsscores aus Nachrichtenartikeln berücksichtigt. Dieser ganzheitliche Ansatz ermöglicht genauere und robustere Risikobewertungen, was letztlich zu besseren Investitionsentscheidungen und einem effektiveren Risikomanagement führt.

Alternative Daten als numerische Repräsentation verwenden

Die Erstellung von Embeddings für Text, Audio und Bilder bedeutet, diese Datentypen in numerische Repräsentationen umzuwandeln, die von Machine-Learning-Modellen verarbeitet werden können. Verschiedene Modelle und Techniken stehen zur Verfügung, jedes mit eigenen Stärken und Anwendungsgebieten. Im Folgenden stellen wir die gängigsten Modelle und Ansätze für Text-, Audio- und Bild-Embeddings vor.

Text-Embeddings

Text-Embeddings sind numerische Repräsentationen von Text, die semantische Informationen erfassen. Bei der Implementierung von Dokumentenverarbeitungs-Systemen bilden Text-Embeddings eine grundlegende Technik. Zur Erstellung von Text-Embeddings werden häufig folgende Modelle verwendet:

Word2Vec

Word2Vec ist ein frühes und einflussreiches Modell zur Generierung von Wort-Embeddings. Es verwendet zwei Architekturen: Continuous Bag of Words (CBOW) und Skip-Gram. Word2Vec erfasst semantische Beziehungen zwischen Wörtern durch Training auf großen Textkorpora.

from gensim.models import Word2Vec

# Alternative Data Python Tutorial
sentences = [["I", "love", "machine", "learning"], ["Word2Vec", "is", "great"]]
model = Word2Vec(sentences, vector_size=100, window=5, min_count=1, workers=4)
word_vector = model.wv['machine']

GloVe (Global Vectors for Word Representation)

GloVe ist eine weitere verbreitete Methode zur Generierung von Wort-Embeddings. Sie erfasst globale statistische Informationen durch Training auf der Kookkurrenzmatrix von Wörtern in einem Korpus.

import gensim.downloader as api

## Load pre-trained GloVe model
glove_model = api.load("glove-wiki-gigaword-100")
word_vector = glove_model['machine']

BERT (Bidirectional Encoder Representations from Transformers)

BERT ist ein Transformer-basiertes Modell, das kontextbewusste Embeddings generiert. Es wird auf großen Textkorpora vortrainiert und kann für spezifische Aufgaben feinabgestimmt werden.

from transformers import BertTokenizer, BertModel
import torch

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')

## Example text
text = "Machine learning is fascinating."
inputs = tokenizer(text, return_tensors='pt')
outputs = model(**inputs)
embedding = outputs.last_hidden_state.mean(dim=1)

GPT-3

GPT-3, entwickelt von OpenAI, ist ein leistungsstarkes Sprachmodell, das qualitativ hochwertige Embeddings generieren kann. Es bewältigt ein breites Aufgabenspektrum, darunter Textklassifikation, Übersetzung und Zusammenfassung.

from transformers import GPT3Tokenizer, GPT3Model

tokenizer = GPT3Tokenizer.from_pretrained('gpt3')
model = GPT3Model.from_pretrained('gpt3')

## Example text
text = "Machine learning is fascinating."
inputs = tokenizer(text, return_tensors='pt')
outputs = model(**inputs)
embedding = outputs.last_hidden_state.mean(dim=1)

Audio-Embeddings

Audio-Embeddings erfassen Merkmale von Audiosignalen und wandeln sie in numerische Repräsentationen um. Gängige Modelle sind:

MFCC (Mel-Frequency Cepstral Coefficients)

MFCCs werden häufig in der Sprach- und Audioverarbeitung eingesetzt. Sie erfassen das kurzfristige Leistungsspektrum eines Audiosignals.

import librosa

## Load audio file
audio_path = 'path/to/audio.wav'
y, sr = librosa.load(audio_path, sr=None)

## Compute MFCC features
mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)

VGGish

VGGish ist ein faltendes neuronales Netz, das auf einem großen Audiodatensatz vortrainiert wurde. Es extrahiert Merkmale aus rohen Audiosignalen und generiert Embeddings.

import tensorflow as tf
import tensorflow_hub as hub

## Load VGGish model
vggish_model = hub.load('https://tfhub.dev/google/vggish/1')

## Load and preprocess audio file
y, sr = librosa.load(audio_path, sr=16000)
embedding = vggish_model(y)

Wav2Vec 2.0

Wav2Vec 2.0 ist ein Transformer-basiertes Modell, das von Facebook AI entwickelt wurde. Es lernt Repräsentationen direkt aus rohen Audiodaten und ist besonders effektiv für Spracherkennungsaufgaben.

from transformers import Wav2Vec2Tokenizer, Wav2Vec2Model

tokenizer = Wav2Vec2Tokenizer.from_pretrained("facebook/wav2vec2-base-960h")
model = Wav2Vec2Model.from_pretrained("facebook/wav2vec2-base-960h")

## Load and preprocess audio file
y, sr = librosa.load(audio_path, sr=16000)
inputs = tokenizer(y, return_tensors="pt", sampling_rate=sr)
outputs = model(**inputs)
embedding = outputs.last_hidden_state.mean(dim=1)

Bild-Embeddings

Bild-Embeddings konvertieren visuelle Informationen in numerische Repräsentationen. Gängige Modelle sind:

Convolutional Neural Networks (CNNs)

CNNs sind der Standardansatz zur Generierung von Bild-Embeddings. Häufig werden vortrainierte Modelle wie ResNet, VGG und Inception eingesetzt. Diese neuronalen Netzarchitekturen treiben zahlreiche KI-Anwendungen in verschiedenen Branchen an.

from torchvision import models, transforms
from PIL import Image
import torch

## Load pre-trained ResNet model
resnet = models.resnet50(pretrained=True)
resnet.eval()

## Preprocess the image
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

## Load the image
image = Image.open('path/to/image.jpg')
image = transform(image).unsqueeze(0)

## Extract features
with torch.no_grad():
    image_features = resnet(image).numpy()

ViT (Vision Transformer)

ViT ist ein Transformer-basiertes Modell für die Bildklassifikation. Es behandelt Bilder als Sequenzen von Patches und verarbeitet sie ähnlich wie Text.

from transformers import ViTFeatureExtractor, ViTModel

## Load pre-trained ViT model
feature_extractor = ViTFeatureExtractor.from_pretrained('google/vit-base-patch16-224')
model = ViTModel.from_pretrained('google/vit-base-patch16-224')

## Load and preprocess image
image = Image.open('path/to/image.jpg')
inputs = feature_extractor(images=image, return_tensors="pt")
outputs = model(**inputs)
embedding = outputs.last_hidden_state.mean(dim=1)

CLIP (Contrastive Language-Image Pre-Training)

CLIP ist ein von OpenAI entwickeltes Modell, das gemeinsame Repräsentationen von Bildern und Text lernt. Es kann Embeddings für beide Modalitäten generieren.

from transformers import CLIPProcessor, CLIPModel

## Load pre-trained CLIP model
processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")

## Load and preprocess image
image = Image.open('path/to/image.jpg')
inputs = processor(text=["a photo of a cat"], images=image, return_tensors="pt", padding=True)
outputs = model(**inputs)
image_embedding = outputs.image_embeds

Fazit

Die Wahl des Modells zur Erstellung von Embeddings hängt vom Datentyp und der spezifischen Anwendung ab. Word2Vec, GloVe, BERT und GPT-3 sind für Text-Embeddings verbreitet, während MFCC, VGGish und Wav2Vec 2.0 häufig für Audio-Embeddings eingesetzt werden. Für Bild-Embeddings sind CNNs, ViT und CLIP weit verbreitet. Jedes Modell hat seine Stärken, und die beste Wahl hängt oft von den spezifischen Anforderungen der jeweiligen Aufgabe ab.

Autoregressives Modell mit alternativen Daten

Die Erstellung eines Volatilitätsprognosemodells, das auf dem Aktienkurs autoregressiv ist und verschiedene Ereignistypen (Audio, Video, Nachrichten oder Bilder) einbezieht, umfasst mehrere Schritte:

  1. Aktienkursdaten sammeln und vorverarbeiten.
  2. Ereignisdaten sammeln und vorverarbeiten.
  3. Merkmale aus Ereignisdaten extrahieren.
  4. Aktienkurs- und Ereignismerkmale kombinieren.
  5. Das autoregressive Modell aufbauen und trainieren.

Schritt 1: Aktienkursdaten sammeln und vorverarbeiten

Wir verwenden historische Aktienkursdaten zur Volatilitätsprognose. Mit Bibliotheken wie yfinance lassen sich diese Daten abrufen.

import yfinance as yf
import pandas as pd

## Fetch historical stock price data
ticker = "AAPL"
stock_data = yf.download(ticker, start="2020-01-01", end="2023-01-01")
stock_data['Returns'] = stock_data['Adj Close'].pct_change()
stock_data = stock_data.dropna()

Schritt 2: Ereignisdaten sammeln und vorverarbeiten

Ereignisdaten können aus verschiedenen Quellen stammen. Der Einfachheit halber gehen wir davon aus, dass Transkripte für Audio- und Videoereignisse sowie Nachrichtenartikel als Textdaten vorliegen.

## Example news articles
news_data = [
    {"date": "2020-01-15", "text": "Apple releases new iPhone model."},
    {"date": "2020-02-20", "text": "Apple reports quarterly earnings."}
]

## Convert news_data to DataFrame
news_df = pd.DataFrame(news_data)
news_df['date'] = pd.to_datetime(news_df['date'])
news_df.set_index('date', inplace=True)

Schritt 3: Merkmale aus Ereignisdaten extrahieren

Wir müssen Textdaten in numerische Merkmale umwandeln. Ein Ansatz sind Text-Embeddings. Der Einfachheit halber verwenden wir ein vortrainiertes Modell aus der transformers-Bibliothek.

from transformers import pipeline

## Initialize the sentiment-analysis pipeline
sentiment_pipeline = pipeline("sentiment-analysis")

## Apply the pipeline to the news articles
news_df['sentiment'] = news_df['text'].apply(lambda x: sentiment_pipeline(x)[0]['score'])

## Combine sentiment with stock data
stock_data = stock_data.join(news_df['sentiment'], on='Date', how='left')
stock_data['sentiment'] = stock_data['sentiment'].fillna(0)

Schritt 4: Aktienkurs- und Ereignismerkmale kombinieren

Jetzt erstellen wir verzögerte Merkmale (Lagged Features) für Aktienrenditen und Stimmungsscores, um unser autoregressives Modell aufzubauen.

## Create lagged features
for lag in range(1, 6):  # Lag 1 to 5
    stock_data[f'returns_lag_{lag}'] = stock_data['Returns'].shift(lag)
    stock_data[f'sentiment_lag_{lag}'] = stock_data['sentiment'].shift(lag)

## Drop rows with NaN values created by lagging
stock_data = stock_data.dropna()

Schritt 5: Das autoregressive Modell aufbauen und trainieren

Zur Demonstration verwenden wir ein einfaches lineares Regressionsmodell. Dies kann durch ausgefeiltere Modelle wie LSTM, GRU oder andere Big-Data-Lösungen und Machine-Learning-Algorithmen ersetzt werden.

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

## Prepare the features and target variable
features = [col for col in stock_data.columns if 'lag' in col]
X = stock_data[features]
y = stock_data['Returns']

## Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

## Initialize and train the model
model = LinearRegression()
model.fit(X_train, y_train)

## Make predictions and evaluate the model
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)

print(f'Mean Squared Error: {mse}')

Verarbeitung von Audio, Video und Bildern

Zur Verarbeitung von Audio, Video und Bildern können Sie vortrainierte Modelle zur Merkmalextraktion verwenden. Für Audio verwenden Sie ein Speech-to-Text-Modell für Transkripte und folgen dann dem gleichen Prozess wie oben. Für Video extrahieren Sie Schlüsselframes und nutzen Bilderkennungsmodelle für Merkmale.

Beispiel für Audio:

## Assuming you have an audio file and you have used a speech-to-text service to get the transcript
transcript = "Apple announces the launch of a new product."

## Use the same sentiment analysis as above
audio_sentiment = sentiment_pipeline(transcript)[0]['score']

Beispiel für Bilder:

Verwenden Sie ein Bilderkennungsmodell wie ein vortrainiertes ResNet zur Merkmalextraktion.

from torchvision import models, transforms
from PIL import Image
import torch

## Load pre-trained ResNet model
resnet = models.resnet50(pretrained=True)
resnet.eval()

## Preprocess the image
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

## Load the image
image = Image.open('path_to_image.jpg')
image = transform(image).unsqueeze(0)

## Extract features
with torch.no_grad():
    image_features = resnet(image).numpy()

Integrieren Sie diese Merkmale ähnlich wie die Stimmungsscores in Ihren Datensatz.

Fazit

Mit diesen Schritten lässt sich ein autoregressives Volatilitätsprognosemodell aufbauen, das verschiedene Ereignistypen einbezieht. Dieser Ansatz kann mit ausgefeiltere Modellen und Feature-Engineering-Techniken weiterentwickelt werden, die auf die spezifischen Eigenschaften der Ereignisse und Aktiendaten zugeschnitten sind.

Risikomodellierung mit alternativen Daten

Um Risiken für Portfolios statt für den Preis eines einzelnen Assets zu modellieren, konzentrieren wir uns auf die Gesamtvolatilität des Portfolios und deren Beeinflussung durch verschiedene Ereignisse. Der Prozess umfasst ähnliche Schritte, jedoch mit Anpassungen für mehrere Assets und deren Wechselwirkungen.

Schritt 1: Aktienkursdaten für mehrere Assets sammeln und vorverarbeiten

Zunächst benötigen wir historische Kursdaten für alle Assets im Portfolio.

import yfinance as yf
import pandas as pd

tickers = ["AAPL", "MSFT", "GOOGL"]
stock_data = yf.download(tickers, start="2020-01-01", end="2023-01-01")['Adj Close']
returns = stock_data.pct_change().dropna()

Schritt 2: Portfolio-Renditen und Volatilität berechnen

Als nächstes berechnen wir Renditen und Volatilität des Portfolios. Der Einfachheit halber nehmen wir gleichmäßige Gewichtung an.

## Assume equal weighting
weights = [1/len(tickers)] * len(tickers)

## Calculate portfolio returns
portfolio_returns = returns.dot(weights)

## Calculate rolling volatility (e.g., 30-day rolling standard deviation)
portfolio_volatility = portfolio_returns.rolling(window=30).std()

Schritt 3: Ereignisdaten sammeln und vorverarbeiten

Ereignisdaten, wie Nachrichtenartikel, bleiben wie im vorherigen Ansatz. Wir sammeln und verarbeiten sie auf die gleiche Weise.

## Example news articles
news_data = [
    {"date": "2020-01-15", "text": "Tech sector sees major breakthroughs."},
    {"date": "2020-02-20", "text": "Federal Reserve announces rate cut."}
]

## Convert news_data to DataFrame
news_df = pd.DataFrame(news_data)
news_df['date'] = pd.to_datetime(news_df['date'])
news_df.set_index('date', inplace=True)

Schritt 4: Merkmale aus Ereignisdaten extrahieren

Wie zuvor müssen wir Textdaten in numerische Merkmale umwandeln.

from transformers import pipeline

## Initialize the sentiment-analysis pipeline
sentiment_pipeline = pipeline("sentiment-analysis")

## Apply the pipeline to the news articles
news_df['sentiment'] = news_df['text'].apply(lambda x: sentiment_pipeline(x)[0]['score'])

## Combine sentiment with stock data
portfolio_data = portfolio_volatility.to_frame(name='volatility')
portfolio_data = portfolio_data.join(news_df['sentiment'], on='Date', how='left')
portfolio_data['sentiment'] = portfolio_data['sentiment'].fillna(0)

Schritt 5: Verzögerte Merkmale erstellen

Erstellen Sie verzögerte Merkmale für Portfoliovolatilität und Stimmungsscores, um das autoregressive Modell aufzubauen.

## Create lagged features
for lag in range(1, 6):  # Lag 1 to 5
    portfolio_data[f'volatility_lag_{lag}'] = portfolio_data['volatility'].shift(lag)
    portfolio_data[f'sentiment_lag_{lag}'] = portfolio_data['sentiment'].shift(lag)

## Drop rows with NaN values created by lagging
portfolio_data = portfolio_data.dropna()

Schritt 6: Das autoregressive Modell aufbauen und trainieren

Wir können ein Regressionsmodell verwenden, um zukünftige Volatilität auf Basis verzögerter Merkmale vorherzusagen.

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

## Prepare the features and target variable
features = [col for col in portfolio_data.columns if 'lag' in col]
X = portfolio_data[features]
y = portfolio_data['volatility']

## Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

## Initialize and train the model
model = LinearRegression()
model.fit(X_train, y_train)

## Make predictions and evaluate the model
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)

print(f'Mean Squared Error: {mse}')

Verarbeitung von Audio, Video und Bildern

Für Audio, Video und Bilder extrahieren Sie Merkmale ähnlich wie im vorherigen Ansatz. Für Audio kann Speech-to-Text Audio in Text umwandeln, gefolgt von einer Stimmungsanalyse. Für Bilder kann ein vortrainiertes CNN Merkmale extrahieren.

Beispiel für Audio:

## Assuming you have an audio file and you have used a speech-to-text service to get the transcript
transcript = "Federal Reserve announces rate cut."

## Use the same sentiment analysis as above
audio_sentiment = sentiment_pipeline(transcript)[0]['score']

Beispiel für Bilder:

Verwenden Sie ein Bilderkennungsmodell wie ein vortrainiertes ResNet zur Merkmalextraktion.

from torchvision import models, transforms
from PIL import Image
import torch

## Load pre-trained ResNet model
resnet = models.resnet50(pretrained=True)
resnet.eval()

## Preprocess the image
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

## Load the image
image = Image.open('path_to_image.jpg')
image = transform(image).unsqueeze(0)

## Extract features
with torch.no_grad():
    image_features = resnet(image).numpy()

Ereignismerkmale in Portfoliodaten integrieren

Diese Merkmale können Sie ähnlich wie die Stimmungsscores zu Ihren Portfoliodaten hinzufügen. Dazu integrieren Sie die extrahierten Merkmale in den Dataframe und erstellen bei Bedarf verzögerte Versionen.

Fazit

Durch die Erweiterung des Modells auf mehrere Assets und die Berechnung der Portfoliovolatilität lässt sich ein umfassendes Risikomodell für Portfolios aufbauen. Dieses Modell kann mit ausgefeilteren Techniken und einem besseren Verständnis der Auswirkungen von Ereignissen auf den Markt weiterentwickelt werden.

Verwandte Artikel

Weitere Ressourcen