Diseño de Dashboard - Consideraciones y Mejores Prácticas

Los dashboards son una forma única y poderosa de presentar inteligencia basada en datos utilizando técnicas de visualización de datos que muestran datos relevantes y procesables, así como estadísticas de seguimiento e indicadores clave de rendimiento (KPI). Los paneles deben presentar estos datos en un formato rápido y fácil de escanear con la información más relevante comprensible de un vistazo.

El término nació del dashboard de instrumentos del automóvil tradicional, y han evolucionado para cumplir la misma función en el mundo digital. En su libro, Stephen Few put it best:

“Un dashboard de instrumentos es una visualización de la información más importante necesaria para lograr uno o más objetivos, consolidado y organizado en una sola pantalla para que la información se pueda supervisar de un vistazo”.

Diseño de dashboard mobile por Mason Yarnell for Mixpanel

En este artículo, esbozamos ejemplos estratégicos, analíticos, operativos e informativos, así como los principios fundamentales que se encuentran en el corazón de cada diseño de dashboard exitoso, independientemente de su tipo.

Tener el enfoque correcto para la visualización de datos es una característica clave para sentar las bases de un dashboard exitoso. La visualización de datos es la presentación de datos a través de gráficos e imágenes. Su objetivo principal es ayudar a los responsables de la toma de decisiones a identificar patrones o comprender conceptos difíciles que pueden pasar inadvertidos en las aplicaciones basadas en texto.

En su libro, Data Visualization, Noah Iliinsky and Julie Steele state:

“El propósito del diseñador en el diseño de una visualización de datos es crear un entregable que sea bien recibido y fácil de entender por el lector. Todas las elecciones de diseño y las implementaciones particulares deben cumplir este propósito”.

Características principales de los Grandes dashboards de instrumentos

Un dashboard efectivo muestra información procesable y útil de un vistazo. Simplifica la representación visual de datos complejos y ayuda a los interesados a comprender, analizar y presentar ideas clave.

Dashboard de Contractbook por el diseñador de Toptal Wojciech Dobry

Los grandes paneles son claros, intuitivos y personalizables.

• Comunican información rápidamente.
• Exhiben información clara y eficientemente.
• Muestran tendencias y cambios en los datos a lo largo del tiempo.
• Son fácilmente personalizables.
• Los widgets y componentes de datos más importantes se presentan de manera efectiva en un espacio limitado.

Una personalización inicial de datos visuales e información para los requisitos clave de los usuarios ayudará a mejorar la usabilidad y eliminar la necesidad de diferentes usuarios.

Elementos de dashboard personalizables – Contractbook por el diseñador de Toptal Wojciech Dobry

Grandes paneles proporcionan todo a un clic de distancia.

• Toda la información esencial es accesible de inmediato.
• Los datos son prioritarios.
• La información se muestra claramente en una jerarquía visual en una pantalla.
• El diseño proporciona una visión general coherente que incluye datos iniciales dispersos y claros con oportunidades adicionales para profundizar más.
• Los elementos (gráfico, tabla, formulario) se muestran en una vista minimizada con la capacidad de mostrar más detalles en una ventana modal o ir a una página con más detalles.
• El diseño mejora la usabilidad con filtros, lo que permite a los usuarios personalizar cómo se muestran los datos y filtra el contenido mediante etiquetas, categorías y KPI.

Datos detallados extraídos de un dashboard en un modal, por el diseñador de Toptal Miklos Philips

La complejidad reducida proporciona claridad

En un mundo abrumado con datos, proporcionar información clara es una de las cosas más difíciles de lograr. Es esencial presentar solo los datos más relevantes en los paneles: cuanta más información exhibamos, más difícil será para los usuarios encontrar lo que necesitan.

Cuando se enfrentan con demasiados datos para seleccionarlos, los diseñadores deben mostrar solo el subconjunto más relevante. Necesitamos priorizar y eliminar cuidadosamente las métricas engañosas y poco claras.

Las decisiones efectivas sobre el diseño del dashboard de instrumentos deben guiarse por:

• los objetivos del proyecto
• la naturaleza de los datos
• las necesidades de los usuarios

Diseño de dashboard por el diseñador de Toptal Stelian Subotin

“Al leer una visualización (o cualquier otro tipo de comunicación), su lector tiene una capacidad cerebral limitada para dedicarse al problema. Parte de esta capacidad intelectual estará dedicada a la decodificación de la visualización, cualquier capacidad intelectual que quede puede ser utilizado para entender el mensaje (si el lector aún no se ha rendido por la frustración).”

– Noah Iliinsky y Julie Steele (Visualización de datos)

El objetivo principal de un dashboard de instrumentos es hacer que la información compleja sea accesible y fácil de digerir. Por lo tanto, la interfaz que presenta los datos debe ser clara y sencilla para minimizar la carga cognitiva de los usuarios y el tiempo de búsqueda.

La arquitectura de la información debe presentar los datos esenciales primero al tiempo que permite el acceso a las medidas de soporte o secundarias. Se debe diseñar un sistema de desglose progresivo que comience con una descripción general y luego entre en más detalles: facilita la priorización de datos y crea claridad.

Diseño de dashboard mobile por Jan Losert

Determinación de los objetivos del dashboard y visualización de datos apropiados

Los diseños exitosos de dashboard de instrumentos comienzan con un conjunto bien definido de objetivos que se enfoca en el problema a resolver y la clave que se debe aprender a quitar del conjunto de datos. La configuración de estos objetivos proviene de una comprensión clara de las tareas que el usuario debe realizar.

Las buenas metas de diseño promueven una ejecución eficiente y precisa. Empleando el framework S.M.A.R.T para la fijación de objetivos pone el foco en aquellos que son específicos, medibles, procesables, realistas y basados en el tiempo.

Algunas preguntas clave para formular al determinar los objetivos:

• ¿Cuántos pasos deben tomar los usuarios para lograr un objetivo específico?
• ¿Es la interfaz lo suficientemente intuitiva para que el usuario alcance su objetivo por sí mismo?
• ¿Qué información necesita el usuario para lograr su objetivo con éxito?

Para determinar cuál puede ser el objetivo de un diseño de dashboard específico, definelo preguntando: “¿Qué problema específico resolverá este diseño para el usuario?” La respuesta proporcionará información sobre qué métricas, propiedades, valores, imágenes y datos son importantes.

Diseño de dashboard por el diseñador de Toptal Miklos Philips

El diseño centrado en objetivos se centra en soluciones a problemas reales y es la base de todo el excelente diseño del dashboard. Comienza con una comprensión clara de los objetivos comerciales, considera los objetivos del usuario y luego transmite la información clave que necesita ser comunicada.

• 
• 
• 

Contexto en el diseño del dashboard

Uno de los mayores desafíos del diseño de dashboard de instrumentos es servir a múltiples personas. Una vez que se define cada función del usuario, es fundamental comprender dónde se superponen sus necesidades y dónde divergen.

La comunicación efectiva es el principio subyacente de cada diseño exitoso de dashboard de instrumentos. Prever posibles escenarios en los que los usuarios puedan encontrarse contribuirán a una mejor comprensión de las circunstancias del usuario.

Siempre ten en cuenta el contexto de los usuarios al diseñar: identifica sus conocimientos técnicos, su familiaridad con el sistema en general, sus objetivos, etc.

Diseño de dashboard por el diseñador de Toptal Miklos Philips

Asegúrate de hacer las siguientes preguntas cuando intentes determinar el comportamiento y el contexto del usuario:

• ¿El diseño considera la dirección en que el visitante está acostumbrado a leer?
• ¿La interacción con el dashboard requiere conocimiento técnico?
• ¿Los usuarios lograrán realizar la mayoría de las acciones con solo unos pocos clics?
• ¿El diseño se alinea con el contexto del usuario creando menús detallados? ¿Utiliza una sugerente iconografía y paletas de colores?

La paleta de colores utilizada en el diseño de un dashboard también debe considerarse como un contexto. Muchos dashboards de productos SaaS de empresa a empresa están diseñados en una interfaz de usuario de temática oscura porque se utilizan durante varias horas seguidas.

Las UI de temática oscura pueden ayudar a reducir la fatiga visual y respaldar la claridad visual en la interfaz. Sin embargo, tomar este enfoque requiere una evaluación cuidadosa de la dirección del diseño: las ventajas, desventajas y riesgos potenciales, tal como se indica en un artículo anterior del blog de diseño: Dos cosas que no se deben hacer en la interfaz de usuario oscura.

Los diseños, análisis e infografías de la interfaz de usuario del panel de control funcionan bien en una interfaz de usuario oscura, pero se deben "manipular con cuidado" para garantizar un contraste suficiente. (por Alex Gilev).

Mejor diseño del dashboard con la investigación del usuario

La investigación del usuario ayuda a crear un entorno en el que a los usuarios se les presentan datos que son relevantes, claros y concisos. Esto les ayuda a pensar sobre el contenido y los datos que están buscando, en lugar de cómo usarlos y acceder a ellos.

Algunos paneles tienen que funcionar, o pueden personalizarse sin esfuerzo para los usuarios de diferentes roles mirando el mismo dashboard básico. La investigación del usuario es importante porque ayuda a determinar los objetivos del usuario, los modelos mentales, el contexto ambiental y los puntos débiles. Estos son factores que tienen una gran influencia en el diseño final del dashboard.

Diseño de dashboard por el diseñador de Toptal Stelian Subotin

El diseñador de experiencia de usuario, investigador y autor Mike Kuniavsky señala que es “el proceso de entender el impacto del diseño en una audiencia”.

Un diseñador debe definir los diferentes tipos de usuarios y comprender dónde se encuentran sus objetivos y dónde difieren. ¿Qué información es más accionable para un tipo de usuario frente a otro? Deben considerar si es necesario que haya un diseño diferente de un tipo de usuario a otro, o si existe una solución para un caso de uso más general.

Teniendo esto en cuenta, es una buena idea comenzar con wireframes rudimentarios y pasar a prototipos que puedan probarse con usuarios reales durante una fase de investigación del usuario. Una breve fase de investigación del usuario con solo cinco usuarios puede proporcionar información realmente valiosa, y ahorrará una enorme cantidad de tiempo en la línea.

Wireframe de dashboard por Aaron Sananes

Divulgación progresiva en el diseño del dashboard de instrumentos

La revelación progresiva es una técnica utilizada para mantener la atención del usuario al reducir el desorden. La creación de un sistema de divulgación progresiva ayuda a crear un entorno centrado en el usuario, lo que ayuda a priorizar la atención del usuario, evitar errores y ahorrar tiempo. También permite a los usuarios enfocarse en las características clave que les interesan y no verse forzados a revisar todas las características, incluso aquellas que no necesitan o no les interesan.

La divulgación progresiva es una mejor práctica de diseño de dashboard que también reducirá las tasas de error considerablemente; mejorará la eficiencia y ayudará a los usuarios a mejorar su comprensión de los paneles cuando un sistema se basa en la priorización de características.

Diseño de dashboard por Jan Losert

“La divulgación progresiva difiere características avanzadas o raramente utilizadas a una pantalla secundaria, haciendo que las aplicaciones sean más fáciles de aprender y menos propensas a errores”. – Jakob Nielsen

La animación es una excelente forma de satisfacer una variedad de necesidades de los usuarios a la vez que cumple múltiples funciones. Es una gran opción para usar mientras se cargan los datos y las imágenes, y es una solución avanzada de divulgación progresiva.

La animación es el proceso de crear la ilusión del movimiento; es una dinámica que crea una sensación de progreso y retroalimentación constante, lo que reduce la incertidumbre del usuario y aumenta el rendimiento percibido.

Dashboard por Virgil Pana

Ventajas de usar la divulgación progresiva en los paneles:

• Reducir la incertidumbre y la ansiedad del usuario (al mostrar signos de progreso, los usuarios tienen la seguridad de que todo está funcionando según lo previsto)
• Proporcionar a los usuarios algo para mirar (visualización parcial de datos) en lugar de hacerlos esperar
• Proporcionar a los usuarios una clara expectativa de los próximos pasos y crear una comprensión de la forma en que se presenta la información jerárquicamente

Los posibles problemas con las divulgaciones progresivas y la carga de datos incluyen:

• Usar indicadores y divulgaciones de manera inapropiada. Los tiempos de carga cortos y los pasos inútiles crearán distracción y funcionarán en contra de los principios de usabilidad.
• Un retraso en la recuperación de datos sin un indicador claro de progreso puede generar incertidumbre en el usuario y mayores tasas de rebote.
• El uso de indicadores de progreso estáticos es una solución con poco significado, y no ofrece suficiente información sobre el progreso, lo que también puede generar incertidumbre en el usuario y mayores tasas de rebote.

Diseño de dashboard por Mason Yarnell

Resumen

Los paneles son una forma poderosa de comunicar datos y otra información, especialmente con un diseño centrado en el usuario, y centrado en el objetivo que sigue las mejores prácticas de diseño del dashboard y la visualización de datos adecuada. Aunque cada dashboard de instrumentos es diferente y tiene sus propios objetivos, requisitos y limitaciones, seguir estos principios fundamentales lo ayudará a crear diseños excepcionales independientemente de los detalles:

• Lo primero y más importante es empatizar con los tipos de usuario y comprender sus objetivos.
• Transmitir una historia clara a los usuarios mediante el uso de imágenes sugerentes, etiquetas, técnicas de divulgación progresiva y animación.
• Facilite las cosas complejas mediante la aplicación de técnicas de investigación de los usuarios.
• Revelar datos e información en el momento apropiado, en un sistema de desglose.
• Utilice la visualización de datos para expresar información de una manera significativa.

Este articulo fue escrito por Stelian Subotin. Originalmente publicado en Toptal.

Cómo Crear un Bot de Análisis de Sentimientos de Correo Electrónico: Un Tutorial de NLP.

Las tecnologías de procesamiento del lenguaje natural se han vuelto bastante sofisticadas en los últimos años. Desde gigantes tecnológicos hasta aficionados, muchos se apresuran a construir interfaces ricas que puedan analizar, comprender y responder al lenguaje natural. La Alexa de Amazon, la Cortana de Microsoft, la Google Home de Google y la Siri de Apple apuntan a cambiar la forma en que interactuamos con las computadoras.

El análisis del sentimiento, un subcampo del procesamiento del lenguaje natural, consiste en técnicas que determinan el tono de un texto o discurso. Hoy en día, con el aprendizaje automático y la gran cantidad de datos recopilados de las redes sociales y los sitios de revisión, podemos entrenar modelos para identificar el sentimiento de un pasaje en lenguaje natural con una precisión razonable.

En este tutorial, aprenderá cómo puede crear un bot que pueda analizar el sentimiento de los correos electrónicos que recibe y notificarle sobre los correos electrónicos que pueden requerir su atención de inmediato.

Análisis del sentimiento en correos electrónicos

El bot se construirá usando una mezcla de Java y Python. Los dos procesos se comunicarán entre ellos usando Thrift. Si no está familiarizado con uno o ambos idiomas, puede seguir leyendo ya que los conceptos fundamentales de este artículo también se aplicarán a otros idiomas.

Para determinar si un correo electrónico necesita su atención, el bot lo analizará y determinará si hay un fuerte tono negativo. Luego enviará una alerta de texto si es necesario.

Usaremos Sendgrid para conectarnos a nuestro buzón de correo y Twilio enviará alertas de texto. ## Análisis de sentimiento: un problema engañosamente simple

Hay palabras que asociamos con emociones positivas, como el amor, la alegría y el placer. Y, hay palabras que asociamos con emociones negativas, como el odio, la tristeza y el dolor. ¿Por qué no entrenar al modelo para reconocer estas palabras y contar la frecuencia relativa y la fuerza de cada palabra positiva y negativa?

Bueno, hay un par de problemas con eso.

Primero, hay un problema de negación. Por ejemplo, una oración como “El melocotón no es malo” implica una emoción positiva usando una palabra que a menudo asociamos con ser negativo. Un modelo simple de bolsa de palabras no podrá reconocer la negación en esta oración.

Además, los sentimientos mixtos demuestran ser otro problema con el análisis ingenuo de sentimientos. Por ejemplo, una oración como “El melocotón no es malo, pero la manzana es realmente terrible” contiene sentimientos mixtos de intensidades mixtas que interactúan entre sí. Un enfoque simple no podrá resolver los sentimientos combinados, la intensidad diferente o las interacciones entre los sentimientos.

Análisis de sentimiento mediante la red recursiva del tensor neuronal

La biblioteca Stanford Natural Language Processing para el análisis del sentimiento resuelve estos problemas usando una Red de tensor neuronal recursivo (RNTN).

El algoritmo RNTN primero divide una oración en palabras individuales. Luego construye una red neuronal donde los nodos son las palabras individuales. Finalmente, se agrega una capa de tensor para que el modelo pueda ajustar adecuadamente las interacciones entre las palabras y frases.

Puede encontrar una demostración visual del algoritmo en su sitio web oficial.

El grupo Stanford NLP entrenó a la Red Recursiva del Tensor Neural usando evaluaciones de películas IMDB etiquetadas manualmente y descubrió que su modelo es capaz de predecir el sentimiento con muy buena precisión.

Bot que recibe correos electrónicos

Lo primero que debes hacer es configurar la integración del correo electrónico para que los datos puedan transferirse a tu bot.

Hay muchas maneras de lograr esto, pero por simplicidad, configuremos un servidor web simple y use el enganche de análisis de entrada de Sendgrid para canalizar correos electrónicos al servidor. Podemos reenviar correos electrónicos a la dirección de análisis entrante de Sendgrid. Sendgrid enviará una solicitud POST a nuestro servidor web, y luego podremos procesar los datos a través de nuestro servidor.

Para construir el servidor, usaremos Flask, un marco web simple para Python.

Además de construir el servidor web, querremos conectar el servicio web a un dominio. Para abreviar, omitiremos escribir sobre esto en el artículo. Sin embargo, puedes leer más sobre esto aquí.

Crear un servidor web en Flask es increíblemente simple.

Simplemente crea un app.py y agrégalo al archivo:

from flask import Flask, request
import datetime
 
app = Flask(__name__)
 
@app.route('/analyze', methods=['POST'])
def analyze():
    with open('logfile.txt', 'a') as fp_log:
        fp_log.write('endpoint hit %s \n' % datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
    return "Got it"
 
app.run(host='0.0.0.0')

Si implementamos esta aplicación detrás de un nombre de dominio y pulsamos el punto final “/analizar”, debería ver algo como esto:

>>> requests.post ('http://sentiments.shanglunwang.com:5000/analyze') .text
'Lo tengo'

A continuación, queremos enviar correos electrónicos a este punto final.

Puede encontrar más documentación aquí pero básicamente desea configurar Sendgrid para que sea su procesador de correo electrónico y que Sendgrid reenvíe los correos electrónicos a nuestro Servidor web.

Aquí está mi configuración en Sendgrid. Esto reenviará correos electrónicos a @sentibot.shanglunwang.com como solicitudes POST a “http://sentiments.shanglunwang.com/analyze”:

Puedes usar cualquier otro servicio que admita el envío de correos entrantes a través de webhooks.

Después de configurar todo, intenta enviar un correo electrónico a tu dirección SendGrid. Deberías ver algo como esto en los registros:

endpoint hit 2017-05-25 14:35:46

¡Eso es genial! Ahora tienes un bot que puede recibir correos electrónicos. Eso es la mitad de lo que estamos tratando de hacer.

Ahora, deseas darle a este bot la capacidad de analizar sentimientos en correos electrónicos.

Email Sentiment Analysis con Stanford NLP

Dado que la biblioteca Stanford NLP está escrita en Java, querremos construir el motor de análisis en Java.

Comencemos descargando la biblioteca y los modelos de PNL de Stanford en Maven. Crea un nuevo proyecto Java, agrega lo siguiente a sus dependencias Maven e importe:

<dependency>
   <groupId>edu.stanford.nlp</groupId>
   <artifactId>stanford-corenlp</artifactId>
   <version>3.6.0</version>
</dependency>

Se puede acceder al motor de análisis de sentimiento de Stanford NLP especificando el anotador de sentimiento en el código de inicialización de la tubería. La anotación se puede recuperar como una estructura de árbol.

Para los fines de este tutorial, solo queremos saber el sentimiento general de una oración, por lo que no será necesario analizar el árbol. Solo tenemos que mirar el nodo base.

Esto hace que el código principal sea relativamente simple:

package seanwang;
import edu.stanford.nlp.pipeline.*;
import edu.stanford.nlp.util.CoreMap;
import edu.stanford.nlp.ling.CoreAnnotations;
import edu.stanford.nlp.sentiment.SentimentCoreAnnotations;
 
 
import java.util.*;
 
public class App
{
    public static void main( String[] args )
    {
        Properties pipelineProps = new Properties();
        Properties tokenizerProps = new Properties();
        pipelineProps.setProperty("annotators", "parse, sentiment");
        pipelineProps.setProperty("parse.binaryTrees", "true");
        pipelineProps.setProperty("enforceRequirements", "false");
        tokenizerProps.setProperty("annotators", "tokenize ssplit");
        StanfordCoreNLP tokenizer = new StanfordCoreNLP(tokenizerProps);
        StanfordCoreNLP pipeline = new StanfordCoreNLP(pipelineProps);
        String line = "Los amigos hermosos increíblemente agradecidos están cumpliendo un logro increíblemente alegre. ¡Qué idea verdaderamente terrible!";
        Annotation annotation = tokenizer.process(line);
        pipeline.annotate(annotation);
        // normal output
        for (CoreMap sentence : annotation.get(CoreAnnotations.SentencesAnnotation.class)) {
            String output = sentence.get(SentimentCoreAnnotations.SentimentClass.class);
            System.out.println(output);
        }
    }
}

Prueba algunas oraciones y deberías ver las anotaciones apropiadas. Ejecutando los resultados del código de ejemplo:

Muy positivo
Negativo

Integrando el Bot y el Motor de Análisis

Así que tenemos un programa analizador de sentimientos escrito en Java y un bot de correo electrónico escrito en Python. ¿Cómo hacemos que hablen entre ellos?

Hay muchas soluciones posibles para este problema, pero aquí utilizaremos Thrift. Activaremos el Analizador de Sentimientos como un servidor Thrift y el bot de correo electrónico como un cliente Thrift.

Thrift es un generador de código y un protocolo utilizado para habilitar dos aplicaciones, a menudo escritas en diferentes idiomas, para poder comunicarse entre sí utilizando un protocolo definido. Los equipos de Polyglot usan Thrift para construir redes de microservicios para aprovechar lo mejor de cada idioma que usan.

Para usar Thrift, necesitaremos dos cosas: un archivo .thrift para definir los puntos finales del servicio y un código generado para hacer uso del protocolo definido en el archivo.proto. Para el servicio analizador, el sentiment.thrift se ve así:

namespace java sentiment
namespace py sentiment
 
service SentimentAnalysisService
{
        string sentimentAnalyze(1:string sentence),
}

Podemos generar código de cliente y servidor utilizando este archivo .thrift. Corre:

thrift-0.10.0.exe --gen py sentiment.thrift
thrift-0.10.0.exe --gen java sentiment.thrift

Nota: genere el código en una máquina con Windows. Deberá utilizar la ruta adecuada al ejecutable Thrift en su entorno.

Ahora, hagamos los cambios apropiados en el motor de análisis para crear un servidor. Su programa Java debería verse así:

SentimentHandler.java

package seanwang;
 
public class SentimentHandler implements SentimentAnalysisService.Iface {
    SentimentAnalyzer analyzer;
    SentimentHandler() {
        analyzer = new SentimentAnalyzer();
    }
 
    public String sentimentAnalyze(String sentence) {
        System.out.println("got: " + sentence);
        return analyzer.analyze(sentence);
    }
 
}

Este manejador es donde recibimos la solicitud de análisis sobre el protocolo Thrift.

SentimentAnalyzer.java

package seanwang;
 
// ...
 
public class SentimentAnalyzer {
    StanfordCoreNLP tokenizer;
    StanfordCoreNLP pipeline;
 
    public SentimentAnalyzer() {
        Properties pipelineProps = new Properties();
        Properties tokenizerProps = new Properties();
        pipelineProps.setProperty("annotators", "parse, sentiment");
        pipelineProps.setProperty("parse.binaryTrees", "true");
        pipelineProps.setProperty("enforceRequirements", "false");
        tokenizerProps.setProperty("annotators", "tokenize ssplit");
        tokenizer = new StanfordCoreNLP(tokenizerProps);
        pipeline = new StanfordCoreNLP(pipelineProps);
    }
 
    public String analyze(String line) {
        Annotation annotation = tokenizer.process(line);
        pipeline.annotate(annotation);
        String output = "";
        for (CoreMap sentence : annotation.get(CoreAnnotations.SentencesAnnotation.class)) {
            output += sentence.get(SentimentCoreAnnotations.SentimentClass.class);
            output += "\n";
        }
        return output;
    }
}

El analizador utiliza la biblioteca de PNL de Stanford para determinar el sentimiento del texto y produce una cadena que contiene las anotaciones de sentimiento para cada oración en el texto.

SentimentServer.java

package seanwang;
 
// ...
 
public class SentimentServer {
    public static SentimentHandler handler;
 
    public static SentimentAnalysisService.Processor processor;
 
    public static void main(String [] args) {
        try {
            handler = new SentimentHandler();
            processor = new SentimentAnalysisService.Processor(handler);
 
            Runnable simple = new Runnable() {
                public void run() {
                    simple(processor);
                }
            };
 
            new Thread(simple).start();
        } catch (Exception x) {
            x.printStackTrace();
        }
    }
 
    public static void simple(SentimentAnalysisService.Processor processor) {
        try {
            TServerTransport serverTransport = new TServerSocket(9090);
            TServer server = new TSimpleServer(new Args(serverTransport).processor(processor));
 
            System.out.println("Starting the simple server...");
            server.serve();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Ten en cuenta que no incluí el archivo SentimentAnalysisService.java aquí porque es un archivo generado. Deberás poner el código generado en un lugar donde el resto de tu código puedas acceder a él.

Ahora que tenemos el servidor activo, escribamos un cliente de Python para usar el servidor.

client.py

from sentiment import SentimentAnalysisService
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
 
class SentimentClient:
    def __init__(self, server='localhost', socket=9090):
        transport = TSocket.TSocket(server, socket)
        transport = TTransport.TBufferedTransport(transport)
        protocol = TBinaryProtocol.TBinaryProtocol(transport)
        self.transport = transport
        self.client = SentimentAnalysisService.Client(protocol)
        self.transport.open()
 
    def __del__(self):
        self.transport.close()
 
    def analyze(self, sentence):
        return self.client.sentimentAnalyze(sentence)
 
if __name__ == '__main__':
    client = SentimentClient()
    print(client.analyze('An amazingly wonderful sentence'))

Ejecuta esto y deberías ver:

Muy positivo

¡Estupendo! Ahora que tenemos el servidor ejecutándose y hablando con el cliente, integrámoslo con el robot de correo electrónico instanciando un cliente y conectándolo al correo electrónico.

import client
 
# ...
 
@app.route('/analyze', methods=['POST'])
def analyze():
    sentiment_client = client.SentimentClient()
    with open('logfile.txt', 'a') as fp_log:
        fp_log.write(str(request.form.get('text')))
        fp_log.write(request.form.get('text'))
        fp_log.write(sentiment_client.analyze(request.form.get('text')))
    return "Got it"

Ahora despliega tu servicio Java en la misma máquina donde estás ejecutando el servidor web, inicia el servicio y reinicia la aplicación. Envía un correo electrónico al bot con una oración de prueba y deberías ver algo como esto en el archivo de registro:

Increíblemente maravillosamente positiva y hermosa frase.
Muy positivo

Analizando el correo electrónico

¡Todo bien! ¡Ahora tenemos un bot de correo electrónico que puede realizar análisis de opinión! Podemos enviar un correo electrónico y recibir una etiqueta de opinión para cada oración que enviamos. Ahora, exploremos cómo podemos hacer que la inteligencia sea procesable.

Para mantener las cosas simples, centrémonos en los correos electrónicos donde hay una alta concentración de oraciones negativas y muy negativas. Usemos un sistema de puntuación simple y digamos que si un correo electrónico contiene más del 75% de oraciones de sentimiento negativo, lo marcaremos como un posible correo electrónico de alarma que puede requerir una respuesta inmediata. Implementemos la lógica de puntuación en la ruta de análisis:

@app.route('/analyze', methods=['POST'])
def analyze():
    text = str(request.form.get('text'))
    sentiment_client = client.SentimentClient()
    text.replace('\n', '')  # remove all new lines
    sentences = text.rstrip('.').split('.')  # remove the last period before splitting
    negative_sentences = [
        sentence for sentence in sentences
        if sentiment_client.analyze(sentence).rstrip() in ['Negative', 'Very negative']  # remove newline char
    ]
    urgent = len(negative_sentences) / len(sentences) > 0.75
    with open('logfile.txt', 'a') as fp_log:
        fp_log.write("Received: %s" % (request.form.get('text')))
        fp_log.write("urgent = %s" % (str(urgent)))
 
    return "Got it"

El código anterior hace algunas suposiciones, pero funcionará con fines de demostración. Envía un par de correos electrónicos a tu bot y deberías ver el análisis del correo electrónico en los registros:

Recibido: Aquí hay una prueba para el sistema. Se supone que es una solicitud no urgente.
¡Es muy bueno! En su mayor parte esto es positivo o neutral. Grandes cosas
están sucediendo!
urgente = Falso
 
Recibido: esta es una solicitud urgente. Todo es realmente horrible Esto es un desastre.
La gente odia este correo insípido.
urgente = True

• 

Envío de una alerta

¡Ya casi hemos terminado!

Hemos creado un bot de correo electrónico que puede recibir correos electrónicos, realizar análisis de sentimientos y determinar si un correo electrónico requiere atención inmediata. Ahora, solo tenemos que enviar una alerta de texto cuando un correo electrónico es particularmente negativo.

Utilizaremos Twilio para enviar una alerta de texto. Su API de Python, que está documentada aquí, es bastante sencilla. Modifiquemos la ruta de análisis para enviar una solicitud cuando reciba una solicitud urgente.

def send_message(body):
    twilio_client.messages.create(
        to=on_call,
        from_=os.getenv('TWILIO_PHONE_NUMBER'),
        body=body
    )
 
app = Flask(__name__)
 
 
@app.route('/analyze', methods=['POST'])
def analyze():
    text = str(request.form.get('text'))
    sentiment_client = client.SentimentClient()
    text.replace('\n', '')  # remove all new lines
    sentences = text.rstrip('.').split('.')  # remove the last period before splitting
    negative_sentences = [
        sentence for sentence in sentences
        if sentiment_client.analyze(sentence).rstrip() in ['Negative', 'Very negative']  # remove newline char
    ]
    urgent = len(negative_sentences) / len(sentences) > 0.75
    if urgent:
        send_message('Highly negative email received. Please take action')
    with open('logfile.txt', 'a') as fp_log:
        fp_log.write("Received: " % request.form.get('text'))
        fp_log.write("urgent = %s" % (str(urgent)))
        fp_log.write("\n")
 
    return "Got it"

Deberás configurar las variables de entorno en sus credenciales de cuenta de Twilio y establecer el número de llamada en un teléfono que pueda verificar. Una vez que hayas hecho eso, envía un correo electrónico al punto final del análisis y verás un mensaje de texto enviado al número de teléfono en cuestión.

¡Y terminamos!

Procesamiento de lenguaje natural simplificado con Stanford NLP

En este artículo, aprendiste a construir un bot de análisis de sentimiento de correo electrónico utilizando la biblioteca Stanford NLP. La biblioteca ayuda a abstraer todos los detalles esenciales del procesamiento del lenguaje natural y te permite usarlo como un bloque de construcción para sus aplicaciones NLP.

Espero que esta publicación haya demostrado una de las muchas aplicaciones potenciales increíbles del análisis de sentimientos, y que esto te inspire a crear tu propia aplicación PNL.

Este articulo fue escrito por Shanglun Wang. Originalmente publicado en Toptal.