Naive Bayes en Python: construcción del modelo

Hola, me ha parecido algo tedioso el proceso del fit siento que me pierdo entre tanto for, pero lo que hice fue comentar casi todas las lineas para saber por qué se hicieron. Si a alguien le sirve aquí dejo el código de fit

# como tal al entrenar andamos calculando las probabilidades para
  # hacer las predicciones. Dichas quedan alojadas en los diccionarios
  # creo que en el de log_classPriorProb y el de wordConditionalCounts
  # que va en un formato CLASS:{WORD: NUMBER} asi es por la prob
  # condicional de que tan probables son los dos juntos
  def fit(self, data, clases):
    n = len(data) # longitud de datos de entrenamiento
    self.unique_clases = set(clases) # identificar cuantas clases unicas hay
    # con la finalidad de una clasificación multiclase
    self.vocab = set()
    self.classCount = {} # C(c)
    self.log_classPriorProb = {} # log(P(c))
    self.wordConditionalCounts = {} # C(w|c)
    # CONTEO DE CLASES
    for c in clases:
      if c in self.classCount.keys(): # buscamos la clase si ya existe
        self.classCount[c] += 1 # si si le agregamos una
      else:
        self.classCount[c] = 1
    # CALCULO DE PROBABILIDADES P(c)
    for c in self.classCount.keys():
      # la probabilidad de la clase es la cantidad de veces que sale
      # entre la longitud del corpus
      self.log_classPriorProb[c] = math.log(self.classCount[c]/n)
      # ya que iteramos cada clase hay que aprovechar para hacer el
      # el calculo de los conteos
      self.wordConditionalCounts[c] = {}
    # CALCULO DE LOS CONTEOS C(w|c)
    for text, c in zip(data, clases): # ITERANDO TODO EL CORPUS
      # contamos las palabras del texto iterado
      counts = self.word_counts(self.tokenize(text))
      # iteramos cada palabra del texto
      for word, count in count.items(): # ITERANDO LOS CONTEOS (PALABRA, CLASE)
        # si la palabra no esta en el vocab la agregamos
        if word not in self.vocab:
          self.vocab.add(word)
        # si la palabra no esta en los conteos
        if word not in seld.wordConditionalCounts[c]:
          # primero creamos el elemento, CLASS:{WORD: NUMBER}
          self.wordConditionalCounts[c][word] = 0.0
        # en el for sumamos los conteos
        self.wordConditionalCounts[c][word] += count
        # CLASS:{WORD: NUMBER} asi es por la prob condicional de que
        # tan probables son los dos juntos

Es necesario verlo mas de una vez 😉

Un aspecto que he notado en algunas clases es verificar que un key se encuentre en un diccionario usando if w in wordCount.keys(). Lo cual no es incorrecto, pero si se procesa una cantidad de datos significativamente mayor, es posible que se note alguna diferencia en tiempo de ejecución en comparación a usar directamente la siguiente sentencia que cumple la misma función if w in wordCount. Lo menciono porque, si no me equivoco en cada iteración se obtiene una nueva lista de keys con la sentencia wordCount.keys().

Adjunto evidencia, al ejecutar el siguiente script:

import time

dict_length = 10

def loop_with_keys(d):
  new_dict = {}
  for key in d:
    if key in new_dict.keys():
      new_dict[key] = key
    else:
      new_dict[key] = key
  return new_dict

def loop_without_keys(d):
  new_dict = {}
  for key in d:
    if key in new_dict:
      new_dict[key] = key
    else:
      new_dict[key] = key
  return new_dict

dict_val = {i: i for i in range(dict_length)}

start_keys = time.time()
loop_with_keys(dict_val)
end_keys = time.time()
print('With .keys()', end_keys - start_keys)

start_no_keys = time.time()
loop_without_keys(dict_val)
end_no_keys = time.time()

print('Without .keys()', end_no_keys - start_no_keys)

Este script lo único que hace es generar un diccionario del 0 al dict_length que se indique, enviarlo a las respectivas funciones que únicamente corren el diccionario y asignan la misma clave y valor a un diccionario interno y retorna ese diccionario, importante mencionar que nunca se ejecuta le proceso dentro del if, sino el bloque de código dentro del else, pero siempre se validará el condicional, y esto es lo que se evaluaría en tiempo, de tal manera que con 10 elementos la salida es:

With .keys() 5.245208740234375e-06
Without .keys() 2.86102294921875e-06

Se nota ligeramente la diferencia, pero al cambiar la longitud del diccionario a dict_length = 10000000, obtuve los siguientes resultados:

With .keys() 2.7152957916259766
Without .keys() 1.6436471939086914

En fin, me pareció algo interesante a tomar en consideración🤔

exquisita clase.