análisis semántico latente en discrepancia Python

Question

Estoy intentando seguir el Wikipedia Article on latent semantic indexing en Python usando el siguiente código:

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.]]) 

como las matemáticas que dice que debe trabajar:

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 

Lo que hace el trabajo, con las matemáticas que se ve incorrecto: (de here)

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

¿Por qué rou te trabajo, y el primero no, cuando todo lo que puedo encontrar sobre las matemáticas de LSA muestra el primero como correcto? Siento que estoy perdiendo algo obvio ...

Answer 1

Hay varias inconsistencias en su código que provocan errores antes de que su punto de confusión. Esto hace que sea difícil comprender exactamente lo que probó y por qué está confundido (claramente no ejecutó el código mientras está pegado, o habría lanzado una excepción antes).

Dicho esto, si sigo tu intención correctamente, su primer acercamiento es casi correcta. Considere el siguiente código:

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] 

Debería ver que lowDimensionalQuery y vt[:,0] son iguales. Piense en vt como una representación de los documentos en un subespacio de baja dimensión. Primero correlacionamos nuestra consulta en ese subespacio para obtener lowDimensionalQuery, y luego lo comparamos con la columna correspondiente de vt. Su error fue tratar de comparar la consulta transformada con el vector de documento de lowRankDocumentTermMatrix, que vive en el espacio original. Dado que la consulta transformada tiene menos elementos que el documento "reconstruido", Python se quejó.