En modell för att bedöma textkvalitet
Har ägnat helgen åt att försöka lösa ett problem som antagligen är ganska vanligt när man programmerar. Frågan är hur man kan låta användare sätta betyg på något - i detta fall blogginlägg - och samtidigt låta datorn sätta betyg på hur bra användarna är på att sätta betyg?
Man kan tycka att detta borde vara Moment 22, men faktum är att sådana algoritmer ligger bakom kvalitetsuppföljning i många andra sammanhang. Ett exempel är den vetenskapliga världen, där peer-review innebär att de som har visat sig bra på att bedöma kvalitet tidigare upphöjs till domare för sina kollegor.
Även om processen fungerar riskerar den att leda till likriktning, eftersom normen blir genomsnittet av domarnas bedömningar. Man sållar fram en liten grupp som får en central roll för att avgöra vad som är kvalitet eller inte.
Började i lördags med att försöka hantera saken med matrisalgebra, men gav upp efter ett tag då det blir svårt och beräkningsintensivt att invertera matriser med väldigt många nollor. Fastnade i stället för en betydligt enklare algoritm (bifogar koden nedan).
Domarna får i det här fallet möjlighet att välja mellan godkänt och underkänt när de bedömer kvaliteten för olika blogginlägg. Rösterna registreras i en databas, där även alla användare och blogginlägg finns registrerade. Poängen för ett enskilt blogginlägg blir summan av alla domare som röstat för att godkänna inläggen multiplicerat med domarnas kvalitet. Poängen beräknas i den första funktionen blogscore nedan.
Nästa steg är att bedöma hur väl domarna har lyckats med att bedöma varje blogginlägg. För att ha en referens beräknas genomsnittspoängen för alla blogginlägg och en korrekt bedömning definieras som att domaren antingen godkänt ett inlägg som har högre poäng än genomsnittet eller att domaren har underkänt ett inlägg som har lägre poäng än genomsnittet. Jag använder det aritmetiska medelvärdet som referens här - man kanske egentligen borde använda medianen.
Som brukligt använder jag Ruby och Sinatra med databashanteraren Sequel. Det verkar som om algoritmen är stabil, jag har låtit den loopa 1000 gånger. Koden nedan är f ö bara en del av ett större projekt.
Nästa steg blir att koppla in AI. Som jag tidigare nämnt planerar jag att vektorisera alla blogginlägg med Doc2Vec hos Algorithmia för att se om inlägg som bedöms som "bra" ligger nära varandra i rummet när man mäter skalärprodukten. Genom att vektorisera texten kan man jämföra nya inlägg med befintliga bedömda inlägg. Det är ungefär samma algoritm som man använder för att upptäcka plagiat i skoluppsatser. Tanken är alltså att riktiga bedömare ska kunna lära datorn hur bra blogginlägg ser ut så att datorn själv ska kunna göra en preliminär bedömning.
Ytterst är tanken att göra det möjligt att samla text från många olika källor - via bloggars RSS-flöden - för att sätta ihop en högkvalitativ medieprodukt. Man skapar alltså en tidning, utan att behöva teckna avtal med alla tänkbara skribenter. Man kan likna det vid processen bakom en vetenskaplig tidskrift - men helt utan någon mänsklig redaktör. Algoritmer samlar ihop skribenter och via peer review upprättthålls en tillräcklig hög kvalitet i materialet. Samtidigt kan skribenterna få betalt för att bedöma andra skribenters texter genom att få företräde att publicera sina egna alster (ett slags annonser).
Det är förstås en bit kvar innan jag har hela strukturen klar. Men när jag är klar kommer jag säkert behöva hjälp med att testa programmet. Och om inte jag uppfinner det så lär någon annan göra det - tidningarna i dagens form lever på lånad tid.
# Beräkna poäng för blogginlägg (score är mellan 0 och 1)
def blogscore
poster = DB[:blogposts]
users = DB[:users]
roster = DB[:votes]
poster.each do | post |
poang = 0.0
raknare = 0
roster.each do | rost |
user = users.first(uid: rost[:uid])
if rost[:slug] == post[:slug] then
poang += user[:score] if rost[:vote]
raknare += 1
end
end
score = (raknare == 0) ? 0 : poang/raknare
poster.where(slug: post[:slug]).update(:score => score)
end
end
# Beräkna poäng för en användare (score är mellan -1 och 1)
def userscore
poster = DB[:blogposts]
users = DB[:users]
roster = DB[:votes]
snittpoang = poster.avg(:score)
puts snittpoang
users.each do | user |
# Nollställ poäng och räknare.
poang = 0.0
raknare = 0
poster.each do | post |
# Se hur användaren *user* röstat på blogginlägget *post*. Kan bli true, false eller nil.
rost = roster.where(uid: user[:uid], slug: post[:slug]).first
rost = rost[:vote] if !rost.nil?
# Variabeln flag_korrekt ska vara true om användaren röstat godkänna när poäng är över snittet.
if !rost.nil? then
flag_korrekt = false # Default false
flag_korrekt = true if (rost == true) && (post[:score] > snittpoang)
flag_korrekt = true if (rost == false) && (post[:score] < snittpoang)
poang += 1 if flag_korrekt
raknare += 1
end
end
userscore = (raknare == 0) ? 0 : 2 * poang / raknare - 1
users.where(uid: user[:uid]).update(:score => userscore)
end
end
Kommentarer