Grafo de hash tags (parte 3)

Tutorial de Grafos
Anterior        Índice        Siguiente

Hasta el momento podemos obtener un número de tweets deseados para un hash tag. El objetivo es obtener la relación entre hash tags. El programa de este post, analiza cada tweet y extrae los hash tags para poder construir más búsquedas. De esta forma podemos obtener más tweets de otros tópicos.

Al mismo tiempo de obtener tweets y extraer hash tags, iremos guardando la información. Usaremos la siguiente convención para guardar los datos. Por cada hash tag que consultemos crearemos un archivo, cuyo nombre es el resultado de concatenar un “timestamp” con el hash tag. El archivo contiene un hash tag por línea, estos son los hash tags encontrados en los tweets que regreso la búsqueda. Por ejemplo, después de consultar #Mexico, obtuvimos el siguiente archivo:

Nombre del archivo: 1351385380#mexico

Contenido del archivo:

#musica 
#cancun 
#guadalajara 
...
#instagram 
#instagramhub 
...
#saltillo 
#torreon 
...
#saltillo 
#argentina 
#colombia 
#bolivia 
#brasil 
...
#reforma 
#instagram
...

Como pueden ver, algunos hash tags aparecen más de una vez; esto se debe a que el mismo hash tag está en varios tweets. Decidí dejar los duplicados ya que considero que son un muy buen indicador de qué tan relacionados están los tópicos.

Esta versión del programa recibe cinco parámetros, por ejemplo:

python twitter_search.py "#Mexico" 50 5 500 ./tweets

1. El hash tag inicial, es decir, con el que iniciaremos las búsquedas.
2. El número de resultados por petición. En este ejemplo cada petición a Twitter regresará a lo más 50 tweets.
3. El número de peticiones por hash tag. En el ejemplo, para cada hash tag que busquemos realizaremos a los más 5 peticiones. Este parámetro junto con el anterior nos da el máximo número de tweets por hash tag. En este caso a lo más 250 tweets por hash tag. Puede ser menor, ya que algunos tópicos son poco populares.
4. El número de hash tags a visitar. Por ejemplo, buscaremos 500 hash tags.
5. El directorio donde queremos guardar los resultados. Después de que se termine de ejecutar el comando anterior, tendremos 500 archivos en el directorio ./tweets

La lógica del programa es la siguiente:

Mientras no hayamos visitado el número de hash tags

1. Obtener los tweets de un hash tag que aún no hayamos visitado.
2. Extraer los hash tags de los tweets.
3. Guardar los hash tags asociados al hash tag consultado.
4. Actualizar la información de los hash tags a visitar con los hash tags obtenidos en el paso 2. En este paso sólo agregamos hash tags que no hayamos visitado y que no estén ya en la lista por visitar.

El código lo pueden encontrar en la siguiente liga.

Tutorial de Grafos
Anterior        Índice        Siguiente

Grafo de hash tags (parte 2)

Tutorial de Grafos
Anterior        Índice        Siguiente

Ahora modificaremos el programa del post anterior para obtener más de 15 tweets; que es lo que regresa una petición sin parámetros. El programa recibe dos parámetros, además del hash tag inicial, también espera el número de tweets que se desean obtener. Por ejemplo:

python twitter_search.py "#Toluca" 35

Obtiene 35 tweets que contienen el hash tag #Toluca. El programa realiza peticiones hasta que obtiene los tweets deseados.

Sin embargo hay un punto a considerar, la documentación de Twitter menciona que para la API de búsqueda existe un límite en la frecuencia con la que se pueden realizar peticiones, pero no publican dicho límite. En caso de que excedamos este límite simplemente obtendremos algo como:

{"error":"..."}

Por lo que antes de iniciar una nueva petición, espero 5 segundos, si la petición resulta en un error, espero el doble. Quizá tengamos que modificar estos valores.

El siguiente es un ejemplo de la salida del programa.

El código lo pueden encontrar aquí. En el siguiente post comenzaremos a navegar entre hash tags.

Tutorial de Grafos
Anterior        Índice        Siguiente

Grafo de hash tags (parte 1)

Tutorial de Grafos
Índice        Siguiente

Realizar una búsqueda usando la API de twitter es tan sencillo como construir la siguiente URL:

http://search.twitter.com/search.json?q=%23Toluca

Esta consulta regresa tweets recientes que contienen el hash tag #Toluca. De hecho si pegan esta URL en su navegado pueden observar el formato de la respuesta. La respuesta viene en formato JSON. Los signos de llaves indican un objeto y los corchetes indican un arreglo.

{
 "completed_in":0.089,
 "max_id":259679677768151040,
 "max_id_str":"259679677768151040",
 "next_page":"?page=2&max_id=259679677768151040&q=%23Toluca",
 "page":1,
 "query":"%23Toluca",
 "refresh_url":"?since_id=259679677768151040&q=%23Toluca",
 "results":
  [
   {
    "created_at":"Sat, 20 Oct 2012 15:18:54 +0000",
    "from_user":"tlcweather",
    "from_user_id":461072765,
    "from_user_id_str":"461072765",
    "from_user_name":"Toluca Weather",
    "geo":null,
    "id":259675063110995968,
    "id_str":"259675063110995968",
    "iso_language_code":"es",
    "metadata":{"result_type":"recent"},
    "profile_image_url":"http:\/\/a0.twimg.com\/profile_...",
    "profile_image_url_https":"https:\/\/si0.twimg.com\/...",
    "source":"<a href="http:\/\/www.google.com\/">Google<\/a>",
    "text":"Toluca, MEXICO Weather :: 13C Mist ... #Toluca #Mexico",
    "to_user":null,
    "to_user_id":0,
    "to_user_id_str":"0",
    "to_user_name":null
   },
   {...}
  ],
 "results_per_page":15,
 "since_id":0,
 "since_id_str":"0"
}

Analicemos algunas variables de la respuesta JSON que utilizaremos. Como podemos ver en la variable results_per_page, cada consulta regresa sólo 15 tweets. Para obtener los siguientes 15 tweets utilizaremos la variable next_page.

La variable results es un arreglo de objetos. Cada objeto de results contiene el usuario que creó el tweet, si está dirigido a alguien, cuándo fue creado y por supuesto el texto del tweet.

El programa en python recibe el hash tag que deseamos buscar:

python twitter_search.py "#Toluca"

El programa construye y realiza la petición de búsqueda. Después de parsear el resultado, obtenemos un mapa de llaves y valores. Por ejemplo, para acceder a la variable next_page usamos algo como search_result["next_page"]. El programa despliega todos los elementos del resultado de búsqueda, todos los elementos de un tweet y finalmente sólo los textos de los 15 tweets.

En el siguiente post extenderemos este ejemplo para obtener más de 15 tweets.

Tutorial de Grafos
Índice        Siguiente

Tutorial de Grafos

Una de las estructuras de datos que más ha llamado mi atención son los grafos. Y no sólo por la parte teórica, sino por su presencia en diversas situaciones. Uno de los ejemplos más claros son las redes sociales. Este es el primer post de una serie en la que hablaremos de grafos y algunos algoritmos.

El primer paso será construir un grafo. Resulta un tanto aburrido el estudiar grafos donde los nodos son simplemente letras y las conexiones entre ellos no tienen un significado real. Algunos libros cuando hablan de encontrar rutas usan ejemplos donde los nodos son ciudades y las conexiones son caminos entre ellas. Intentaré usar algo más atractivo para esta serie.

Después de investigar un poco las APIs de Facebook y Twitter, decidí que utilizaremos el servicio de búsqueda de Twitter, ya que no requiere autenticación, así que es muy fácil de empezar a usar. Como lenguaje de programación usaremos Python y el código estará en mercurial.

En el siguiente post comenzaremos a investigar cómo construir nuestro grafo usando la API de Twitter.

Todos los post de esta serie se irán listando a continuación:

• Grafo de hash tags (parte 1)
• Grafo de hash tags (parte 2)
• Grafo de hash tags (parte 3)
• Reiniciar peticiones de tweets
• Creación del grafo
• Métricas del grafo de hash tags