Sådan bruges tidsordre i maskinindlæringsanbefalinger til uddannelse

Anbefalinger om maskinlæring forbinder brugere med indhold, de ønsker eller har brug for. For eksempel anbefaler Amazon nedenfor bøger til Ringenes Lord.

Tidsbestilling betyder ikke meget i produktanbefalinger, der tilbydes af Amazon eller Netflix. Du kan først læse enten Ringenes Herre eller Tronenes spil før den anden.

For uddannelsesmæssigt indhold er ordren vigtigere. Knewton har en eksplicit forudsætning (viden) graf, der siger, at du lærer koncept X før koncept Y. For eksempel udøver du først enscifrede tilføjelser 3 + 4 før du går til mere komplekse tilføjelser som 13 + 4.

I dette blogindlæg forklarer jeg, hvordan man udvider anbefalingsalgoritmer til enkel samarbejdsfiltrering (CF) til at bruge tidsbestilling. Fokus er inden for uddannelsesdomæne, hvor indholdets tidsrækkefølge også fortæller om:

  • de gennemsnitlige læringsstier taget af elever, eller
  • måske endda den forudsatte graf over koncepter.

Indholdet af dette blogindlæg kommer fra datavidenskabeligt arbejde, der udføres til adaptiv læringsplatform Bingel fra VANIN. Mange tak for VANIN for at lade til at dele nogle eksempler i dette blogindlæg!

Enkle samarbejdsfiltreringsalgoritmer

Lad os først introducere enkle, men alligevel kraftige samarbejdsfiltreringsalgoritmer (CF) af typen:

  • brugere, der har set X, købte også Y.
  • brugere, der købte X, købte også Y.

Implicit kosinus-lighed mellem elementer og ting er en algoritme til formalisering af disse. Vi definerer kosinus-lighed, så vi senere kan sammenligne med en algoritme, der har tidsorden inkluderet. I det er dine data implicit "Jeg kan godt lide" data såsom par (bruger, indhold). Derefter beregner du for alle indholdspar (X, Y):

tælling (X, Y):
antal brugere, der købte både X og Y.
tæller (X):
antal brugere, der bough X
lighed (X, Y):
count (X, Y) / sqrt (count (X) * count (Y)).

For X anbefaler du Y, der har stor værdi for lighed (X, Y). Jeg udelader nogle tekniske detaljer, som hvordan man håndterer godt indhold med lidt data.

Inkl. Tidsbestilling i samarbejdsfiltrering

De enkle CF-algoritmer inspirerer tidsbestilte relationer til uddannelsesindhold:

følger (X => Y):
sandsynlighed for, at øvelse Y følger øvelse X.
går foran (X => Y):
sandsynlighed for, at øvelse X går foran træningsblok Y.
forudsætning (X af Y):
afbalanceret tilgang til ovenstående to, så begge Y skal gøres, efter at X og X er gjort før Y. Lad os sige
forudsætning (X af Y) = sqrt (følger (X => Y) * forud for (X => Y)).

Ovenfor forhold er lidt uklar, så vi vil senere formalisere dem. Før det skal vi se på et eksempel fra et virkeligt datasæt!

Eksempel: Bingel-læringssti til "Læs ur" -øvelse

Bingel er en adaptiv lærings- og øvelsesplatform til grundskoleuddannelse, der bruges af over 600.000 elever i Belgien, Finland og Sverige. I de sidste 5 år er der foretaget mere end 1 milliard øvelser på Bingel.

I 2017 foretog vi en undersøgelse af tidsbestilling af øvelser med Bingel-data. Undersøgelsen udledte den tidsbestilte relation fra datapar (elev lavet øvelse, lærer fik hjemmearbejde). Bemærk, hvordan øvelsen til højre (til fremtiden for venstre side) skal gives af læreren som hjemmearbejde, men til venstre kan eleven udføre enhver øvelse.

Nedenstående billeder har top-5 øvelser til forskellige tidsbestillingsrelationer til matematikøvelse "Læs ur" i kapitel 2 i 3. klassebog i grundskolen.

I dette enkelt eksempel havde den øverste liste over den forudsatte relation mere relevante øvelser end den foregående relation.

Formalisering af tidsbestilt samarbejdsfiltrering

Du kan gøre formalisering på mange måder, og det følgende er bare en af ​​dem, men det er den, der fungerede for os.

Inputdataene er et stort sæt poster

(bruger, øvelse, tidsstempel),

som vi omdanner til bestilte motionspar

(bruger, X, Y, t),

hvor X er en øvelse, der er udført før træning Y af brugeren, og tiden imellem i dage er t. Vi gør (bruger, X, Y) unik ved at filtrere til første gang, en øvelse udføres af en bruger.

Lad os se på et eksempel. Under billedet har to elever, Alice og Bob, og de øvelser, de lavede over tre dage.

Indgangsposterne er:

(bruger, øvelse, dag)
(Alice, X, mandag)
(Alice, Y, tirsdag)
(Alice, Z, onsdag)
(Bob, Z, mandag)
(Bob, X, tirsdag)
(Bob, Y, onsdag)

Og øvelsesparene er:

(træne før, træne efter, tid imellem)
(X, Y, 1d)
(X, Z, 2d)
(Y, Z, 1d)
(Z, X, 1d)
(Z, Y, 2d)
(X, Y, 1d)

Vi beregner derefter mellemværdier:

tælling (X => Y):
antal gange træningsparet (X, Y) forekommer.
count_before (X):
antal gange X forekommer i venstre side af træningsparet (X, _).
count_after (Y):
antal gange Y forekommer i højre side af træningsparet (_, Y).

Og med mellemværdierne får vi de ønskede relationer:

følger (X => Y):
count (X => Y) / count_before (X)
går foran (X => Y):
count (X => Y) / count_after (Y)
forudsætning (X af Y):
sqrt (følger (A => B) * går foran (A => B))

I vores eksempel:

følger (X => Y) = 2/3
følger (X => Z) = 1/3

Inkl. Tidsafstand mellem øvelser

Ovenfor havde vi superenkelt før / efter forhold, som ikke tog højde for, om der var en dag eller 100 dage mellem øvelserne. Du får dog bedre resultater, hvis du håndterer tidsafstand bedre.

En nem måde er at knytte en tidsvægt til et træningspar (X, Y, t). For eksempel time_weight (t) = exp (-t / 20). Derefter skal du ændre tælling (X => Y) til at være summen af ​​tidsvægtene for træningspar (X, Y) i stedet for at tælle sådanne par. Gør det samme for alle tællefunktioner.

Der er andre måder at vægte træningspar på, og hvilken slags vægtning der fungerer afhænger af dine data. Den her givne måde fungerede for data indsamlet i løbet af et skoleår.

Kun for matematiske junkies: er den sædvanlige kosinus-lighed forbundet med forudsætningsforholdet?

Formlen for den forudsætningsrelation ovenfor ligner meget reglen mellem kosinus-lighed mellem element og element. Lad os se nærmere på.

lighed (X, Y):
= antal (X, Y) / sqrt (count (X) * count (Y))
= kosinus (vec (X), vec (Y)),

hvor vec (X) er en 0/1 vektor, hvor koordinat vec (X) _i er 1, hvis bruger jeg købte vare X. På den anden side:

forudsætning (X af Y)
= sqrt (følger (X => Y) * går foran (X => Y))
= count (X => Y) / sqrt (count_before (X) * count_after (Y))
= cosinus (vec_before (X), vec_after (Y)).

Her er vec_before (X) _i 1, hvis X forekommer i venstre side af elementparret, og vec_after (X) _i er 1, hvis X forekommer i højre side af paret i.

Så både lighed (X, Y) og forudsætning (X af Y) er kosinus af to 0 / 1- vektorer. I førstnævnte svarer koordinaterne til brugere, men i sidstnævnte svarer koordinaterne til par par. Vi kan bygge bro over definitionerne yderligere: for lighed (X, Y) gør hvert par øvelser udført af den samme bruger to nye “virtuelle” brugere (X, Y) og (Y, X). Derefter er lighed (X, Y) den samme som forudsætning (X for Y), som har en mere intuitiv definition gennem sandsynligheder. Fedt nok?

Relateret arbejde

Jeg er glad for at høre om lignende arbejde udført andetsteds. Vi har samlet noget relateret arbejde til dette dokument.