El análisis de sentimiento de Twitter es el proceso de utilizar Python para comprender automáticamente las emociones u opiniones expresadas en los tweets. Analizando el texto podemos clasificar los tweets en positivos, negativos o neutrales. Esto ayuda a las empresas y a los investigadores a rastrear el estado de ánimo del público, la reputación de la marca o las reacciones a los eventos en tiempo real. Las bibliotecas de Python como TextBlob Tweepy y NLTK facilitan la recopilación de tweets, procesan el texto y realizan análisis de sentimientos de manera eficiente.

¿Cómo es útil el análisis de sentimiento de Twitter?

• El análisis de sentimiento de Twitter es importante porque ayuda a las personas y a las empresas a comprender lo que piensa el público en tiempo real.
• Cada día se publican millones de tweets compartiendo opiniones sobre marcas, productos, eventos o temas sociales. Al analizar este enorme flujo de datos, las empresas pueden medir la satisfacción del cliente, detectar tendencias tempranamente, manejar los comentarios negativos rápidamente y tomar mejores decisiones basadas en cómo se sienten realmente las personas.
• También es útil para investigadores y gobiernos monitorear el estado de ánimo del público durante crisis electorales o grandes eventos, ya que convierte los tweets sin editar en información valiosa.

Implementación paso a paso

Paso 1: instale las bibliotecas necesarias

Este bloque instala e importa las bibliotecas necesarias. se utiliza pandas para cargar y manejar datos TfidfVectorizador convertir texto en números y ciencia aprender para entrenar el modelo.

   pip   install   pandas   scikit  -  learn   import   pandas   as   pd   from   sklearn.feature_extraction.text   import   TfidfVectorizer   from   sklearn.model_selection   import   train_test_split   from   sklearn.naive_bayes   import   BernoulliNB   from   sklearn.linear_model   import   LogisticRegression   from   sklearn.svm   import   LinearSVC   from   sklearn.metrics   import   accuracy_score     classification_report   

Paso 2: cargar el conjunto de datos

• Aquí cargamos el Conjunto de datos Sentiment140 Desde un archivo CSV comprimido, puede descargarlo desde Kaggle.
• Mantenemos solo la polaridad y las columnas de texto del tweet les cambiamos el nombre para mayor claridad e imprimimos las primeras filas para verificar los datos.

   df   =   pd  .  read_csv  (  'training.1600000.processed.noemoticon.csv.zip'     encoding  =  'latin-1'     header  =  None  )   df   =   df  [[  0     5  ]]   df  .  columns   =   [  'polarity'     'text'  ]   print  (  df  .  head  ())   

Producción:

Paso 3: Mantenga sólo los sentimientos positivos y negativos

• Aquí eliminamos los tweets neutrales donde la polaridad es 2 y asignamos las etiquetas, por lo que 0 permanece negativo y 4 se convierte en 1 para positivo.
• Luego imprimimos cuántos tweets positivos y negativos quedan en los datos.

   df   =   df  [  df  .  polarity   !=   2  ]   df  [  'polarity'  ]   =   df  [  'polarity'  ]  .  map  ({  0  :   0     4  :   1  })   print  (  df  [  'polarity'  ]  .  value_counts  ())   

Producción:

Paso 4: Limpiar los Tweets

• Aquí definimos una función simple para convertir todo el texto a minúsculas para lograr coherencia y la aplica a cada tweet en el conjunto de datos.
• Luego muestra las versiones originales y limpias de los primeros tweets.

   def   clean_text  (  text  ):   return   text  .  lower  ()   df  [  'clean_text'  ]   =   df  [  'text'  ]  .  apply  (  clean_text  )   print  (  df  [[  'text'     'clean_text'  ]]  .  head  ())   

Producción:

Paso 5: Dividir la prueba del tren

• Este código divide las columnas clean_text y polarity en conjuntos de entrenamiento y prueba usando una división 80/20.
• random_state=42 garantiza la reproducibilidad.

   X_train     X_test     y_train     y_test   =   train_test_split  (   df  [  'clean_text'  ]   df  [  'polarity'  ]   test_size  =  0.2     random_state  =  42   )   print  (  'Train size:'     len  (  X_train  ))   print  (  'Test size:'     len  (  X_test  ))   

Producción:

Tamaño del tren: 1280000
Tamaño de prueba: 320000

Paso 6: realizar la vectorización

• Este código crea un vectorizador TF IDF que convierte texto en características numéricas usando unigramas y bigramas limitados a 5000 características.
• Ajusta y transforma los datos de entrenamiento y transforma los datos de prueba y luego imprime las formas de las matrices TF IDF resultantes.

   vectorizer   =   TfidfVectorizer  (  max_features  =  5000     ngram_range  =  (  1    2  ))   X_train_tfidf   =   vectorizer  .  fit_transform  (  X_train  )   X_test_tfidf   =   vectorizer  .  transform  (  X_test  )   print  (  'TF-IDF shape (train):'     X_train_tfidf  .  shape  )   print  (  'TF-IDF shape (test):'     X_test_tfidf  .  shape  )   

Producción:

Forma TF-IDF (tren): (1280000 5000)
Forma TF-IDF (prueba): (320000 5000)

Paso 7: Entrenar el modelo Bernoulli Naive Bayes

• Aquí entrenamos a un Bernoulli ingenuo Bayes clasificador en las características TF IDF a partir de los datos de entrenamiento.
• Predice opiniones sobre los datos de la prueba y luego imprime la precisión y un informe de clasificación detallado.

   bnb   =   BernoulliNB  ()   bnb  .  fit  (  X_train_tfidf     y_train  )   bnb_pred   =   bnb  .  predict  (  X_test_tfidf  )   print  (  'Bernoulli Naive Bayes Accuracy:'     accuracy_score  (  y_test     bnb_pred  ))   print  (  '  n  BernoulliNB Classification Report:  n  '     classification_report  (  y_test     bnb_pred  ))   

Producción:

Paso 9: Entrenar el modelo de máquina de vectores de soporte (SVM)

• Este código entrena a un Máquina de vectores de soporte (SVM) con un máximo de 1000 iteraciones en las funciones de TF IDF.
• Predice etiquetas de prueba y luego imprime la precisión y un informe de clasificación detallado que muestra qué tan bien se desempeñó el SVM.

   svm   =   LinearSVC  (  max_iter  =  1000  )   svm  .  fit  (  X_train_tfidf     y_train  )   svm_pred   =   svm  .  predict  (  X_test_tfidf  )   print  (  'SVM Accuracy:'     accuracy_score  (  y_test     svm_pred  ))   print  (  '  n  SVM Classification Report:  n  '     classification_report  (  y_test     svm_pred  ))   

Producción:

Paso 10: Entrenar el modelo de regresión logística

• Este código entrena a un Regresión logística modelo con hasta 100 iteraciones en las funciones TF IDF.
• Predice etiquetas de opinión para los datos de prueba e imprime el informe de clasificación detallado y de precisión para la evaluación del modelo.

   logreg   =   LogisticRegression  (  max_iter  =  100  )   logreg  .  fit  (  X_train_tfidf     y_train  )   logreg_pred   =   logreg  .  predict  (  X_test_tfidf  )   print  (  'Logistic Regression Accuracy:'     accuracy_score  (  y_test     logreg_pred  ))   print  (  '  n  Logistic Regression Classification Report:  n  '     classification_report  (  y_test     logreg_pred  ))   

Producción:

Paso 11: Haga predicciones sobre Tweets de muestra

• Este código toma tres tweets de muestra y los transforma en funciones TF IDF utilizando el mismo vectorizador.
• Luego predice su sentimiento utilizando los modelos entrenados BernoulliNB SVM y Regresión Logística e imprime los resultados para cada clasificador.
• Donde 1 representa Positivo y 0 Negativo.

   sample_tweets     =     [  'I love this!'       'I hate that!'       'It was okay not great.'  ]   sample_vec     =     vectorizer  .  transform  (  sample_tweets  )   print  (  '  n  Sample Predictions:'  )   print  (  'BernoulliNB:'       bnb  .  predict  (  sample_vec  ))   print  (  'SVM:'       svm  .  predict  (  sample_vec  ))   print  (  'Logistic Regression:'       logreg  .  predict  (  sample_vec  ))   

Producción:

Podemos ver que nuestros modelos funcionan bien y dan las mismas predicciones incluso con enfoques diferentes.

Puede descargar el código fuente desde aquí. Análisis de sentimiento de Twitter usando Python