analisi semantica latente in Python discrepanza

Question

Sto cercando di seguire il Wikipedia Article on latent semantic indexing in Python utilizzando il seguente codice:

documentTermMatrix = array([[ 0., 1., 0., 1., 1., 0., 1.], 
          [ 0., 1., 1., 0., 0., 0., 0.], 
          [ 0., 0., 0., 0., 0., 1., 1.], 
          [ 0., 0., 0., 1., 0., 0., 0.], 
          [ 0., 1., 1., 0., 0., 0., 0.], 
          [ 1., 0., 0., 1., 0., 0., 0.], 
          [ 0., 0., 0., 0., 1., 1., 0.], 
          [ 0., 0., 1., 1., 0., 0., 0.], 
          [ 1., 0., 0., 1., 0., 0., 0.]]) 
u,s,vt = linalg.svd(documentTermMatrix, full_matrices=False) 

sigma = diag(s) 
## remove extra dimensions... 
numberOfDimensions = 4 
for i in range(4, len(sigma) -1): 
    sigma[i][i] = 0 
queryVector = array([[ 0.], # same as first column in documentTermMatrix 
        [ 0.], 
        [ 0.], 
        [ 0.], 
        [ 0.], 
        [ 1.], 
        [ 0.], 
        [ 0.], 
        [ 1.]]) 

Come la matematica dice che dovrebbe funzionare:

dtMatrixToQueryAgainst = dot(u, dot(s,vt)) 
queryVector = dot(inv(s), dot(transpose(u), queryVector)) 
similarityToFirst = cosineDistance(queryVector, dtMatrixToQueryAgainst[:,0] 
# gives 'matrices are not aligned' error. should be 1 because they're the same 

cosa funziona, con la matematica che sembra non corretta: (da here)

dtMatrixToQueryAgainst = dot(s, vt) 
queryVector = dot(transpose(u), queryVector) 
similarityToFirst = cosineDistance(queryVector, dtMatrixToQueryAgainsst[:,0]) 
# gives 1, which is correct 

Perché rou lavoro, e il primo no, quando tutto quello che posso trovare sulla matematica di LSA mostra il primo come corretto? Mi sento come se mi mancasse qualcosa di ovvio ...

Answer 1

Ci sono diverse incongruenze nel codice che causano errori prima del tuo punto di confusione. Ciò rende difficile capire esattamente cosa hai provato e perché sei confuso (chiaramente non hai eseguito il codice mentre viene incollato, o prima avrebbe generato un'eccezione).

Detto questo, se seguo correttamente il tuo intento, il tuo primo approccio è quasi corretto. Si consideri il seguente codice:

documentTermMatrix = array([[ 0., 1., 0., 1., 1., 0., 1.], 
          [ 0., 1., 1., 0., 0., 0., 0.], 
          [ 0., 0., 0., 0., 0., 1., 1.], 
          [ 0., 0., 0., 1., 0., 0., 0.], 
          [ 0., 1., 1., 0., 0., 0., 0.], 
          [ 1., 0., 0., 1., 0., 0., 0.], 
          [ 0., 0., 0., 0., 1., 1., 0.], 
          [ 0., 0., 1., 1., 0., 0., 0.], 
          [ 1., 0., 0., 1., 0., 0., 0.]]) 
numDimensions = 4 
u, s, vt = linalg.svd(documentTermMatrix, full_matrices=False) 
u = u[:, :numDimensions] 
sigma = diag(s)[:numDimensions, :numDimensions] 
vt = vt[:numDimensions, :] 
lowRankDocumentTermMatrix = dot(u, dot(sigma, vt)) 
queryVector = documentTermMatrix[:, 0] 
lowDimensionalQuery = dot(inv(sigma), dot(u.T, queryVector)) 
lowDimensionalQuery 
vt[:,0] 

Dovreste vedere che lowDimensionalQuery e vt[:,0] sono uguali. Pensa a vt come una rappresentazione dei documenti in un sottospazio a bassa dimensione. Per prima cosa mappiamo la nostra query in tale sottospazio per ottenere lowDimensionalQuery, quindi la confrontiamo con la colonna corrispondente di vt. Il tuo errore è stato il tentativo di confrontare la query trasformata con il vettore di documenti da lowRankDocumentTermMatrix, che risiede nello spazio originale. Poiché la query trasformata ha meno elementi del documento "ricostruito", Python si è lamentato.