wie RMSE (mittlerer quadratischer Fehler) klein, wenn ALS von Funken zu verwenden?

Question

Ich brauche einige Vorschläge, um ein gutes Modell zu bauen, um Empfehlung zu machen, indem man Collaborative Filtering des Funkens verwendet. Es gibt einen Beispielcode in official website. Ich bin auch dran vorbei:

from pyspark.mllib.recommendation import ALS, MatrixFactorizationModel, Rating 

# Load and parse the data 
data = sc.textFile("data/mllib/als/test.data") 
ratings = data.map(lambda l: l.split(','))\ 
    .map(lambda l: Rating(int(l[0]), int(l[1]), float(l[2]))) 

# Build the recommendation model using Alternating Least Squares 
rank = 10 
numIterations = 10 
model = ALS.train(ratings, rank, numIterations) 

# Evaluate the model on training data 
testdata = ratings.map(lambda p: (p[0], p[1])) 
predictions = model.predictAll(testdata).map(lambda r: ((r[0], r[1]), r[2])) 
ratesAndPreds = ratings.map(lambda r: ((r[0], r[1]), r[2])).join(predictions) 
RMSE = ratesAndPreds.map(lambda r: ((r[1][0] - r[1][1])**2).mean())**.5) 
print("Root Mean Squared Error = " + str(RMSE)) 

Ein gutes Modell braucht den RMSE so klein wie möglich.

Ist das, weil ich nicht den richtigen Parameter auf ALS.train Methode, wie Rand numIterations und so weiter?

Oder ist das, weil mein Datensatz klein ist, um RMSE groß zu machen?

Also könnte mir jemand helfen, herauszufinden, welche Ursache RMSE groß ist und wie man es beheben kann.

Zusatz:

Wie @eliasah sagte, ich brauche einige Details hinzuzufügen, um den Antwortsatz zu verengen. Lassen Sie uns diese besondere Situation betrachten:

Jetzt, wenn ich ein Empfehlungssystem aufbauen möchte, um Musik meinen Klienten zu empfehlen. Ich habe ihre Verlaufsrate für Titel, Alben, Künstler und Genres. Offensichtlich baut diese 4-Klasse eine Hierarchiestruktur auf. Tracks gehören direkt zu Alben, Alben gehören direkt Künstlern, und Künstler können verschiedenen Genres angehören. Schließlich möchte ich alle diese Informationen nutzen, um einige Tracks auszuwählen, die den Kunden empfohlen werden.

Also, was ist die beste Praxis, um ein gutes Modell für diese Situation zu bauen und sicherzustellen, dass RMSE so klein wie möglich für die Vorhersage zu machen.

Answer 1

ich es ein wenig Forschung zu tun, hier ist das Ergebnis:

Wenn rand und Iteration wachsen, nimmt die RMSE. Wenn die Größe des Datasets jedoch zunimmt, nimmt der RMSE-Wert zu. Aus dem obigen Ergebnis ändert die Rand-Größe den RMSE-Wert deutlicher.

Ich weiß, das ist nicht genug, um ein gutes Modell zu bekommen. Wünsche mehr Ideen !!!

Answer 2

Wie oben erwähnt, mit steigendem Rang und ansteigender Anzahl, sinkt RMSE bei gleichem Datensatz. Jedoch wächst , während RMSE wächst,.

Jetzt ist eine Übung zur Verringerung von RMSE und einige andere ähnliche Maßnahmen zu normalisiert die Werte in Bewertungen. Meiner Erfahrung nach funktioniert das sehr gut, wenn Sie die minimalen und maximalen Ratingwerte im Voraus kennen.

Außerdem sollten Sie auch andere Maßnahmen als RMSE in Betracht ziehen. Bei der Matrix-Faktorisierung ist es nützlich, berechnen Frobenius Norm der Ratings - Vorhersagen dann durch Frobenius Norm der Bewertungen zu teilen. Dadurch erhalten Sie den relativen Fehler Ihrer Vorhersagen in Bezug auf die ursprünglichen Bewertungen.

Hier ist der Code in Funken für diese Methode:

# Evaluate the model on training data 
testdata = ratings.map(lambda p: (p[0], p[1])) 
predictions = model.predictAll(testdata).map(lambda r: ((r[0], r[1]), r[2])) 

ratesAndPreds = ratings.map(lambda r: ((r[0], r[1]), r[2])).join(predictions) 

abs_frobenius_error = sqrt(ratesAndPreds.map(lambda r: ((r[1][0] - r[1][1])**2).sum()))) 

# frobenius error of original ratings 
frob_error_orig = sqrt(ratings.map(lambda r: r[2]**2).sum()) 

# finally, the relative error 
rel_error = abs_frobenius_error/frob_error_orig 

print("Relative Error = " + str(rel_error)) 

In diesem Fehlermaß, je näher der Fehler auf Null, desto besser werden Sie Modell.

Ich hoffe, das hilft.

Answer 3

In pyspark Verwendung dieses Root Mean Square Error für die Suche nach (rmse)

from pyspark.mllib.recommendation import ALS 
from math import sqrt 
from operator import add 


# rank is the number of latent factors in the model. 
# iterations is the number of iterations to run. 
# lambda specifies the regularization parameter in ALS 
rank = 8 
num_iterations = 8 
lmbda = 0.1 

# Train model with training data and configured rank and iterations 
model = ALS.train(training, rank, num_iterations, lmbda) 


def compute_rmse(model, data, n): 
    """ 
    Compute RMSE (Root Mean Squared Error), or square root of the average value 
     of (actual rating - predicted rating)^2 
    """ 
    predictions = model.predictAll(data.map(lambda x: (x[0], x[1]))) 
    predictions_ratings = predictions.map(lambda x: ((x[0], x[1]), x[2])) \ 
     .join(data.map(lambda x: ((x[0], x[1]), x[2]))) \ 
     .values() 
    return sqrt(predictions_ratings.map(lambda x: (x[0] - x[1]) ** 2).reduce(add)/float(n)) 

print "The model was trained with rank = %d, lambda = %.1f, and %d iterations.\n" % \ 
     (rank, lmbda, num_iterations) 
# Print RMSE of model 
validation_rmse = compute_rmse(model, validation, num_validation) 
print "Its RMSE on the validation set is %f.\n" % validation_rmse