Personas, una implementación en django

Brevísima introducción a personas

Personas es un tipo de segmentación basada en reglas de negocio. Supone imaginar cómo son los usuarios que visitan tu web e intentar hacer un perfil lo más real posible de ellos: darles un nombre, un background y sobre todo definir la motivación que les lleva visitar tu web. Una ventaja de este paradigma es que te permite identificar mejor las necesidades de tus usuarios. Este artículo define mucho mejor que yo lo que es este paradigma.

Se suelen usar plantillas para definir personas, estos son un ejemplo de una de nuestras personas:

Personas en boolino

Boolino es un catálogo de libros infantiles y juveniles. A boolino le visitan diferentes tipos de usuarios, padres que buscan un libro para comprar a sus hijos, jovenes lectores que buscan información, profesionales que buscan algún tipo de referencia…

En la primera iteración de las personas definimos 8 tipos de personas. Tantas personas están bien para algunos escenarios, por ejemplo para trabajar requerimientos, sin embargo actualmente queremos identificar sólo 3 tipos de persona:

• Sandra, es el usuario casual que viene a boolino buscando un libro para sus hijos, pero que no tiene mucho conocimiento editorial. Es una madre, sabe navegar internet, ha comprado alguna vez pero no conoce librerías especializadas ni sabe identificar lo que es un buen libro.
• Raquel, es un heavy user, sí que sabe de libros o está aprendiendo con nuestros consejos. Maneja internet con soltura
• Elvira, es un usuario de perfil profesional: un profesor, editor, bibliotecario.
• Susana es el no usuario, el que hace bounce back o que apenas tenemos información.

Dependencias, CBVs, vanilla vews, braces

Todas las vistas son CVBs. Utilizo django-vanilla-views y django-braces.
Esto me facilita aplicar funcionalidades comunes a las vistas mediante mixins.
También se puede implementar vía middleware, pero es un poco más limitado.

PersonaMatrix, indicadores

El modelo PersonaMatrix identifica una usuario (mediante autenticación o uuid guardada en una cookie) y almacena sus indicadores así como los porcentajes de una persona.

PersonaMixin, reglas de negocio

Este mixin está hecho para trabajar con django-vanilla-views. Sobreescribe el método render_to_response.
Hay que asignar un nombre a la vista (persona_page_name)  y encapsula la respuesta para ejecutar las reglas de negocio y modificar los indicadores.

class PersonaMixin(object):

    persona_page_name = None
    persona_matrix = None

    def render_to_response(self, context):

        resp = super(PersonaMixin, self).render_to_response(context)
        self.process_response(self.request, resp)
        return resp

    def render_json_response(self, context_dict, status=200):
        resp = super(PersonaMixin, self).render_json_response(context_dict, status)
        self.process_response(self.request, resp)
        return resp

    def process_response(self, request, response):

        if not is_a_bot(request):

            if self.persona_matrix:
                persona_matrix = self.persona_matrix
            else:
                persona_matrix = PersonaMatrix.objects.get_matrix(request.user, request.session.get('NOUSER_SESSION_ID'))

            if persona_matrix and self.persona_page_name:

                #Reglas de negocio, segun la propiedad persona_pega_name, por ejemplo:

                if self.persona_page_name=='libro' and persona_matrix.num_libros<2:
                    persona_matrix.num_libros += 1

                if persona_matrix.has_changed:
                    persona_matrix.check_personas(commit=False)
                    persona_matrix.save(update_fields=persona_matrix.changed_fields + ['fecha_ultima'])

        return response

Y en una vista:

class LibroView(SessionKey, PersonaMixin, DetailView):
    template_name = 'libros/show.html'
    model = Libro
    lookup_field = 'slug'
    persona_page_name = 'libro'

Vista ajax para indicadores en cliente

Utilizo una vista ajax para capturar eventos de la interfaz del cliente, que mediante jquery y ajax se envío al servidor para anotar más indicadores:

class SendIndicador(AjaxResponseMixin, PersonaMixin, JSONResponseMixin, TemplateView):
    def get(self, request, *args, **kwargs):
        self.persona_page_name = self.kwargs.get('slug')
        return self.render_json_response({self.kwargs.get('slug'):True})

Cálculo de la persona
Los indicadores nos dan un porcentaje de aproximación a una persona. Nadie es 100% Raquel y 0% Elvira, somos tonalidades. Utilizo un algoritmo que utiliza pesos para priorizar la identificación de las personas.

Cada registro en bdd corresponde a una cookie, salvo que el usuario haga login, entonces podemos reutilizar su registro. Por eso, en bbdd tendremos principalmente Susanas y muchas Sandras. Raquel y Elviras generalmente entran con su usuario por lo que reutilizan su registro.

La definición de indicadores por persona:

    INDICADORES_MATRIX = {

        'susana' :[('fidelidad', 0, 1), ('origen', 0, 1),
                #...,
                ],

        #'sandra' :[...],

        'raquel' :[('fidelidad', 1, 2), ('origen', [30, 40, 50], 2),
                ('lp_blogpost', True, 1), ('lp_libro', True, 1), #...
                ],

        # 'elvira' :[...],
    }

El algoritmo de cálculo de persona:

    def check_personas(self, commit=True):

        max_persona_ind = 0.0
        nombre_max_persona = None

        for persona, indicadores in self.INDICADORES_MATRIX.items():
            len_indicadores = 0
            num_indicadores = 0
            for ind, value, peso in indicadores:
                len_indicadores += peso
                if isinstance(value, list):
                    if getattr(self, ind, None) in value:
                        num_indicadores += peso
                else:
                    if getattr(self, ind, None)==value:
                        num_indicadores += peso

            perc = 1.*num_indicadores/len_indicadores
            setattr(self, persona, perc)
            if perc>max_persona_ind:
                max_persona_ind = perc
                nombre_max_persona = persona

        self.persona = nombre_max_persona

        if commit:
            self.save()

Aplicación práctica

Con esta información estamos trabajando en lanzar diferentes mensajes. Por ejemplo, a los usuarios con perfil profesional (Elvira) le pedimos que nos ayuden a hacer reseñas.
A las Raqueles les ofrecemos tips avanzados de cómo usar la plataforma, o banners para que sean anfitrionas de MLBB
A las Sandras les queremos registrar o pedir su teléfono para que podamos llamarles y explicarles lo que es MLBB

Next steps

Con los indicadores que hemos obtenido y otros que se pueden obtener de forma más automática, podemos identificar nuevos patrones de personas y afinar mejor la identificación del usuario.

Personas vs recomendadores

Los indicadores que se utilizan son de comportamiento de la web y muy ligados al negocio, a diferencia de un recomendador tradicional que tabaja almacenando eventos sobre el catálogo de la web: visitas, compras, likes… Por eso, no existe una referencia para poder recomendar libros en base a otros usuarios.

Sin embargo, sí que se puede utilzar técnicas de cálculo de distancias entre 2 usuarios o de cálculo de clusters para agrupar usuarios identificar nuevas personas y patrones de uso.