Vektoren und Skalarprodukte

Ein Vektor ist eine Zahlenliste mit Regeln

Ein Vektor ist eine geordnete Liste von Zahlen fester Länge, etwa die Gewichte eines Portfolios [0.5, 0.3, 0.2] oder die Tagesrenditen dreier Werte [0.02, -0.01, 0.03]. In Python genügt eine Liste von Floats. Vektoren lassen sich stellenweise addieren, skalieren und kombinieren, weshalb ein großer Teil der quantitativen Finanzmathematik in ihrer Sprache geschrieben ist. Zwei Vektoren lassen sich nur kombinieren, wenn sie gleich lang sind; unterschiedliche Längen sind ein Fehler, von dem Sie deutlich erfahren wollen.

weights = [0.5, 0.3, 0.2]
returns = [0.02, -0.01, 0.03]

# Position by position: zip pairs the elements
products = [w * r for w, r in zip(weights, returns)]
print([round(p, 4) for p in products])   # [0.01, -0.003, 0.006]

# Scaling and adding vectors
print([2 * w for w in weights])          # [1.0, 0.6, 0.4]
print([a + b for a, b in zip(weights, returns)])  # [0.52, 0.29, 0.23]

Das Skalarprodukt

Das Skalarprodukt multipliziert zwei Vektoren stellenweise und addiert die Ergebnisse: a1*b1 + a2*b2 + ... + an*bn. Es liefert eine einzelne Zahl. Es ist die Portfoliorendite, wenn a die Gewichte und b die Renditen enthält: 0.5*0.02 + 0.3*(-0.01) + 0.2*0.03 = 0.013. Es ist auch der Wert einer Positionsliste (Mengen mal Preise) und der Baustein einer Regression. In Python: sum(x * y for x, y in zip(a, b)), nachdem Sie len(a) == len(b) geprüft haben, denn zip hört stillschweigend bei der kürzeren Liste auf.

def dot(a, b):
    if len(a) != len(b):
        raise ValueError("vectors must have the same length")
    return sum(x * y for x, y in zip(a, b))

print(dot([1, 2, 3], [4, 5, 6]))                       # 32
print(round(dot([0.5, 0.3, 0.2], [0.02, -0.01, 0.03]), 6))  # 0.013  (portfolio return)

try:
    dot([1, 2], [1, 2, 3])
except ValueError as error:
    print(error)                                       # vectors must have the same length

Länge, Richtung und Ähnlichkeit

Ein Vektor mit sich selbst skalarmultipliziert ergibt sein Längenquadrat, die Norm (Länge) ist also math.sqrt(dot(a, a)): für [3, 4] ist sie 5.0. Teilt man einen Vektor durch seine Norm, erhält man einen Einheitsvektor der Länge 1, der nur die Richtung behält (ein Nullvektor hat aber keine Richtung, lehnen Sie ihn mit ValueError ab). Die Kosinus-Ähnlichkeit dot(a, b) / (norm(a) * norm(b)) misst, wie ausgerichtet zwei Vektoren sind, von -1 (entgegengesetzt) über 0 (unabhängig, rechtwinklig) bis 1 (gleiche Richtung, egal welche Skala). Auf zentrierte Renditereihen angewandt ist sie die Korrelation, eine zentrale Größe des Portfoliorisikos.

import math

def dot(a, b):
    return sum(x * y for x, y in zip(a, b))

def norm(a):
    return math.sqrt(dot(a, a))

print(norm([3, 4]))                                    # 5.0

def normalize(a):
    length = norm(a)
    if length == 0:
        raise ValueError("a zero vector has no direction")
    return [x / length for x in a]

print(normalize([3, 4]))                               # [0.6, 0.8]

def cosine_similarity(a, b):
    return dot(a, b) / (norm(a) * norm(b))

print(round(cosine_similarity([1, 2], [2, 4]), 6))     # 1.0   (same direction)
print(cosine_similarity([1, 0], [0, 1]))               # 0.0   (perpendicular)
print(round(cosine_similarity([1, 2], [-1, -2]), 6))   # -1.0  (opposite)

import math

def dot(a, b):
    return sum(x * y for x, y in zip(a, b))

def mean(values):
    return sum(values) / len(values)

# Correlation is the cosine of the demeaned series
a = [0.01, 0.02, -0.01, 0.03]
b = [0.02, 0.04, -0.02, 0.06]       # always twice a
da = [x - mean(a) for x in a]
db = [x - mean(b) for x in b]
corr = dot(da, db) / math.sqrt(dot(da, da) * dot(db, db))
print(round(corr, 6))               # 1.0

# Value of a book: quantities dot prices
quantities = [100, -50, 20]
prices = [184.0, 410.0, 171.0]
print(dot(quantities, prices))      # 1320.0

• Skalarprodukt: stellenweise multiplizieren und addieren; vorher die Längen prüfen.
• Norm sqrt(dot(a, a)); Einheitsvektor a / norm(a) (Nullvektor ablehnen).
• Kosinus-Ähnlichkeit dot(a, b) / (norm(a) * norm(b)) von -1 bis 1; Floats mit isclose vergleichen.

Als Nächstes: Matrizen und lineare Gleichungssysteme, Zahlentabellen, die auf Vektoren wirken und viele Gleichungen auf einmal lösen.

Lab: Was bewertet wird

• Mit dot Gewichte und Renditen verknüpfen25 Pkt.
• Mit norm die Länge eines Vektors messen25 Pkt.
• Mit cosine_similarity Richtungen vergleichen25 Pkt.
• Mit normalize einen Vektor auf Länge 1 skalieren25 Pkt.