¿Cómo hacer un análisis del sentimiento de Twitter con Sofia2?

En este post vamos a explicar cómo hacer un análisis básico del sentimiento de Twitter.

Para eso usaremos estos 2 componentes de la Plataforma

  • El componente de escucha de Twitter
  • El módulo Notebook

Planificar una escucha en Twitter:

Para hacer esto desde el Panel de Control Sofia2 iré a la opción social media > Búsqueda programada

En mi caso tengo planificada la escucha sobre el hashtag #hadoop durante 2 días.

Los datos se estarán almacenando en una ontología nueva llamada twitter_streaming_find_hadoop

Desde herramientas > Consola BDTR y BDH puedo consultar estos datos:

Que me devuelve datos como estos:

Si hago un puedo ver el número de registros que tengo en la ontología:

Crear un Notebook para explotar la información de la ontología:

A continuación crearé un Notebook que convierta los datos de la ontología a un DataFrame de Spark y accederá a él vía Spark SQL.

1.Primero registro el JAR de Sofia2 que permite acceder al API de Sofia2 desde los Notebooks (ver post) con esta sentencia

NOTA: En el entorno CloudLab puede ser necesario contactar con soporte para registrar este JAR.

2.Tras esto crearé una conexión con la Plataforma con este código (en breve una versión Scala):

En <mi_kp> debo colocar el identificador de un KP, si no tengo ninguno puedo crearlos en la opción de menú kps/apps sofia2 > Mis KPs/APPs

En <mi_token> debo colocar el token asociado a ese KP, puedo obtenerlo desde kps/apps sofia2 > Mis Tokens

Seleccionaré el KP creado y pincharé en

Una vez creado podré verlo en Listado de Tokens (así como la última conexión):

import com.indra.sofia2.ssap.kp.config.MQTTConnectionConfig

import org.fusesource.mqtt.client.QoS

import com.indra.sofia2.ssap.kp.Kp

import com.indra.sofia2.ssap.kp.implementations.KpMQTTClient

import com.indra.sofia2.ssap.kp.SSAPMessageGenerator

import java.util.UUID

import com.indra.sofia2.ssap.ssap.SSAPMessage

import com.indra.sofia2.ssap.ssap.SSAPQueryType

import com.indra.sofia2.ssap.ssap.body.SSAPBodyReturnMessage

//conexion

val config = new MQTTConnectionConfig();

config.setHostSIB("localhost");

config.setPortSIB(1883);

config.setKeepAliveInSeconds(5);

config.setQualityOfService(QoS.AT_LEAST_ONCE);

config.setTimeOutConnectionSIB(5000);

val kpClient = new KpMQTTClient(config);

kpClient.connect();

//JOIN

val msgJoin = SSAPMessageGenerator.getInstance().generateJoinByTokenMessage("<mi_token>",

"KP_lmgracia" + ":" + UUID.randomUUID().toString());

val response = kpClient.send(msgJoin);

val sessionKey = response.getSessionKey();


3.Tras la conexión con la plataforma ya podré hacer una query sobre la ontología en la que estoy almacenando los tuits y convertirla a DataFrame, para eso:

Como veis primero estoy haciendo una query (select * from twitter_streaming_find_hadoop) sobre la ontología twitter_streaming_find_hadoop

Esto me devuelve un mensaje JSON con las instancias de la ontología, y desde ahí creo un SQLContext de Spark SQL y lo registro como una tabla temporal con el mismo nombre que la ontología.

//query

val msgQuery = SSAPMessageGenerator.getInstance().generateQueryMessage(sessionKey, "twitter_streaming_find_hadoop", "select * from twitter_streaming_find_hadoop", SSAPQueryType.valueOf("SQLLIKE"))

val response = kpClient.send(msgQuery)

val responseBody = SSAPBodyReturnMessage.fromJsonToSSAPBodyReturnMessage(response.getBody())

val events = sc.parallelize(responseBody.getData() :: Nil)

val df = sqlContext.read.json(events)

//df.printSchema()

df.registerTempTable("twitter_streaming_find_hadoop")

Puedo también sacar por pantalla el esquema del DataFrame creado con:

Que me da:

4.Ya puedo empezar a hacer las queries con Spark SQL,

desde las más sencillas:

Agrupando:

5.El paso final será hacer un análisis del sentimiento, para eso crearé una función en Spark a la que llamaré desde la sentencia Spark SQL:

Registro la función (como podéis ver es una versión muy básica):

def sentiment(s:String) : String = {

val positive = Array("like", "love", "good", "great", "happy", "cool", "the", "one", "launched", "new", "super", "fast", "the")

val negative = Array("hate", "bad", "stupid", "shit", "awful", "old", "slow", "broken", "stolen", "work", "annoy")

var st = 0;

val words = s.split(" ")

positive.foreach(p =>

words.foreach(w =>

if(p==w) st = st+1

)

)

negative.foreach(p=>

words.foreach(w=>

if(p==w) st = st-1

)

)

if(st>0)

"positive"

else if(st<0)

"negative"

else

"neutral"

}

sqlc.udf.register("sentiment", sentiment _)

6.Finalmente lanzo la query que hace el análisis del sentimiento sobre l texto del tuit:

%sql

SELECT sentiment(Tweet.tweet_text), count(1) FROM twitter_streaming_find_hadoop GROUP BY sentiment(Tweet.tweet_text)
¿Cómo hacer un análisis del sentimiento de Twitter con Sofia2?

2 comentarios en “¿Cómo hacer un análisis del sentimiento de Twitter con Sofia2?

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s