Come migliorare il risultato della mia raccomandazione? Sto usando la scintilla ALS implicita

Question

In primo luogo, ho un po 'di storia d'uso dell'app utente.

Ad esempio:
user1, app1, 3 (i tempi di lancio)
utente2, app2, 2 (i tempi di lancio)
user3, App1 1 (tempi di lancio)

ho praticamente due richieste:

1. Consiglia alcune app per ogni utente.
2. Consiglia un'applicazione simile per ogni app.

Quindi uso ALS (implicito) di MLLib su spark per implementarlo. Inizialmente, uso solo i dati originali per addestrare il modello. Il risultato è terribile. Penso che possa essere causato dalla gamma di tempi di lancio. E il tempo di lancio va da 1 a migliaia. Quindi elaboro i dati originali. Penso che il punteggio possa riflettere la vera situazione e più regolarizzazione.

punteggio = lt/uMlt + lt/aMlt

clienti è risultato processo di formare modello.
lt è ora di avvio nei dati originali.
uMlt è il tempo di avvio medio dell'utente nei dati originali. uMlt (tutti i tempi di avvio di un utente)/(numero di app che questo utente ha mai lanciato)
aMlt è il tempo di avvio medio dell'app nei dati originali. aMlt (tutti i tempi di avvio di un'app)/(numero di utenti che hanno mai lanciato questa app)
Ecco alcuni esempi dei dati dopo l'elaborazione.

Valutazione (95788,20992,0.14167073369026184)
Valutazione (98696,20992,5.92363166809082)
Valutazione (160020,11264,2.261538505554199)
Valutazione (67904,11264,2.261538505554199)
Valutazione (268.430, 11264,0.13846154510974884)
Valutazione (201369,11264,1.7999999523162842)
Valutazione (180857,11264,2.2720916271209717)
Valutazione (217692,11264,1.3692307472229004)
Valutazione (186274,2867 2,2.4250855445861816)
Valutazione (120820,28672,0.4422124922275543)
Valutazione (221146,28672,1.0074234008789062)

Dopo ho fatto questo, e aggregare le applicazioni che hanno diverso nome del pacchetto, il risultato sembra meglio . Ma ancora non abbastanza buono.
Trovo che le funzionalità di utenti e prodotti siano così ridotte e la maggior parte di esse sia negativa.

Ecco 3 line lista di caratteristiche di prodotti, 10 dimensioni per ciascuna linea:

((CompactBuffer (com.youlin.xyzs.shoumeng, com.youlin.xyzs.juhe.shoumeng)), (-4.798973236574966E-7, -7.641608021913271E-7,6.040852440492017E-7,2.82689171626771E-7, -4.255948056197667E-7,1.815822798789668E-7,5.000047167413868E-7,2.0220664964654134E-7,6.386763402588258E-7, -4,289261710255232 E-7))
((CompactBuffer (com.dncfcjaobhegbjccdhandkba.huojia)), (- 4.769295992446132E-5, -1.7072002810891718E-4,2.1351299074012786E-4,1.6345139010809362E-4, -1.4456869394052774E-4,2.3657752899453044E -4, -4.508546771830879E-5,2.0895185298286378E-4,2.968782791867852E-4,1.9461760530248284E -4))
((CompactBuffer (com.tern.rest.pron)), (- 1.219763362314552E-5, -2.8371430744300596E-5,2.9869115678593516E-5,2.0747662347275764E-5, -2.0555471564875916E-5,2.632938776514493 E-5,2.934047643066151E-6,2.296348611707799E-5,3.8075613701948896E-5,1.2197584510431625E-5))

Ecco 3 line lista di caratteristiche utenti, 10 dimensioni per ciascuna linea:

(96768, (- ,0010857731103897095, -0.001926362863741815,0.0013726564357057214,6.345533765852451E-4, -9.048808133229613E-4, -4.1544197301846E-5,0.0014421759406104684, -9.77902309386991E-5,0.0010355513077229261, -,0017878251383081079)) 012.380.073.162. (97280, (- ,0022841691970825195, -0.0017134940717369318,0.001027365098707378,9.437055559828877E-4, -0.0011165080359205604,0.0017137592658400536,9.713359759189188E-4,8.947265450842679E-4,0.0014328152174130082, -5.738904583267868E-4))
(97792, (- ,0017802991205826402, -0.003464450128376484,0.002837196458131075,0.0015725698322057724, -0.0018932095263153315,9.185600210912526E-4,0.0018971719546243548,7.250450435094535E-4,0.0027060359716415405, -0,0017731878906488419))

quindi potete immaginare quanto piccolo quando ricevo prodotto scalare della funzione i vettori per calcolare il valore della matrice utente-articolo.

La mia domanda è:

1. C'è un altro modo per migliorare il risultato raccomandazione?
2. Le mie funzionalità sembrano corrette o c'è qualcosa che non va?
3. È il mio modo di elaborare i tempi di avvio originali (convertire in punteggio) giusto?

Ho inserito del codice qui. E questa è assolutamente una domanda del programma. Ma forse non può essere risolto con poche righe di codice.

val model = ALS.trainImplicit(ratings, rank, iterations, lambda, alpha) 
print("recommendForAllUser") 
val userTopKRdd = recommendForAllUser(model, topN).join(userData.map(x => (x._2._1, x._1))).map { 
    case (uid, (appArray, mac)) => { 
    (mac, appArray.map { 
     case (appId, rating) => { 
     val packageName = appIdPriorityPackageNameDict.value.getOrElse(appId, Constants.PLACEHOLDER) 
     (packageName, rating) 
     } 
    }) 
    } 
} 
HbaseWriter.writeRddToHbase(userTopKRdd, "user_top100_recommendation", (x: (String, Array[(String, Double)])) => { 
    val mac = x._1 
    val products = x._2.map { 
    case (packageName, rating) => packageName + "=" + rating 
    }.mkString(",") 
    val putMap = Map("apps" -> products) 
    (new ImmutableBytesWritable(), Utils.getHbasePutByMap(mac, putMap)) 
}) 

print("recommendSimilarApp") 
println("productFeatures ******") 
model.productFeatures.take(1000).map{ 
    case (appId, features) => { 
    val packageNameList = appIdPackageNameListDict.value.get(appId) 
    val packageNameListStr = if (packageNameList.isDefined) { 
     packageNameList.mkString("(", ",", ")") 
    } else { 
     "Unknow List" 
    } 
    (packageNameListStr, features.mkString("(", ",", ")")) 
    } 
}.foreach(println) 
println("productFeatures ******") 
model.userFeatures.take(1000).map{ 
    case (userId, features) => { 
    (userId, features.mkString("(", ",", ")")) 
    } 
}.foreach(println) 
val similarAppRdd = recommendSimilarApp(model, topN).flatMap { 
    case (appId, similarAppArray) => { 
    val groupedAppList = appIdPackageNameListDict.value.get(appId) 
    if (groupedAppList.isDefined) { 
     val similarPackageList = similarAppArray.map { 
     case (destAppId, rating) => (appIdPriorityPackageNameDict.value.getOrElse(destAppId, Constants.PLACEHOLDER), rating) 
     } 
     groupedAppList.get.map(packageName => { 
     (packageName, similarPackageList) 
     }) 
    } else { 
     None 
    } 
    } 
} 
HbaseWriter.writeRddToHbase(similarAppRdd, "similar_app_top100_recommendation", (x: (String, Array[(String, Double)])) => { 
    val packageName = x._1 
    val products = x._2.map { 
    case (packageName, rating) => packageName + "=" + rating 
    }.mkString(",") 
    val putMap = Map("apps" -> products) 
    (new ImmutableBytesWritable(), Utils.getHbasePutByMap(packageName, putMap)) 
}) 

UPDATE:
ho trovato qualcosa di nuovo sui miei dati dopo la lettura della carta ("filtraggio collaborativo per il feedback dataset implicito"). I miei dati sono troppo scarsi rispetto al set di dati IPTV descritto nel documento.

carta: 300.000 (utenti) 17.000 (prodotti) 32.000.000 (dati)
miniera: 300.000 (utenti) 31.000 (prodotti) 700.000 (dati)

Quindi la matrice dall'utente elemento della il set di dati della carta è stato riempito con 0.00627 = (32.000.000/300.000/17.000). Il rapporto del mio set di dati è 0.0000033. Penso che significhi che la mia matrice utente-articolo è 2000 volte più spessa di quella del foglio.
Questo dovrebbe portare a un cattivo risultato? E un modo per migliorarlo?

Answer 1

Ci sono due cose che si dovrebbe provare:

1. standardizzare i dati in modo che abbia media zero e varianza unitaria per ogni vettore utente. Questo è un passo comune in molte attività di apprendimento automatico. Aiuta a ridurre l'effetto dei valori anomali, che causano i valori vicini allo zero che stai vedendo.
2. Rimuovi tutti gli utenti che hanno solo una singola app. L'unica cosa che imparerai da questi utenti è un valore "medio" leggermente migliore per i punteggi delle app. Non ti aiuteranno comunque ad apprendere relazioni significative, che è ciò che vuoi veramente.

Dopo aver rimosso un utente dal modello, si perde la possibilità di ottenere un suggerimento per tale utente direttamente dal modello, fornendo l'ID utente. Tuttavia, hanno comunque una sola valutazione dell'app. Pertanto, puoi eseguire una ricerca KNN sulla matrice del prodotto per trovare le app più simili a quelle degli utenti app = consigli.