예제 #1
0
def updateListOfUsers():
    """
        Detecta que usuarios no tienen alias y propone modificarlo en forma semiautomartica
    """
    from IPython.display import display
    from scripts.general import fechaLocal
    import os
    import pickle
    from scripts.constants import PATHALIAS

    users = listOfUsers()
    for user in users:
        if user['alias'] == str(user['id']):
            display('Usuario creado el ' + str(fechaLocal(user['id'])))
            response = input("Ingrese un alias o enter para continuar:")
            if response != "":
                user['alias'] = response
            response = input(
                "Presiones 'si' para descartar este usuario del procesamiento de datos"
            )
            if response == "si":
                user['ignore'] = True

    filename = PATHALIAS
    with open(filename, 'wb') as f:
        pickle.dump(users, f)
예제 #2
0
파일: db.py 프로젝트: IoniUTDT/IPyVisound
def updateListOfUsers(notIgnored=False):

    """
        Detecta que usuarios no tienen alias y propone modificarlo en forma semiautomartica
    """
    from scripts.general import fechaLocal
    import os
    import pickle

    users = listOfUsers()
    for user in users:
        if notIgnored:
            if not user[cts.Db_Users_Alias] in listOfUsersCleanAlias():
                continue
                display("Saltar!")
        display(
            "Usuario creado el "
            + str(fechaLocal(user[cts.Db_Sesion_User_Id]))
            + " Alias actual: "
            + user[cts.Db_Users_Alias]
        )
        response = input("Ingrese un nuevo alias o enter para continuar:")
        if response != "":
            user[cts.Db_Users_Alias] = response
        response = input("Presiones 'si' para descartar este usuario del procesamiento de datos")
        if response == "si":
            user[cts.Db_Users_Ignore] = True

    with open(cts.PATHALIAS, "wb") as f:
        pickle.dump(users, f)
예제 #3
0
파일: db.py 프로젝트: IoniUTDT/IPyVisound
def updateListOfUsers ():

    """
        Detecta que usuarios no tienen alias y propone modificarlo en forma semiautomartica
    """
    from IPython.display import display
    from scripts.general import fechaLocal
    import os
    import pickle
    from scripts.constants import PATHALIAS

    users = listOfUsers()
    for user in users:
        if user['alias']==str(user['id']):
            display ('Usuario creado el '+str(fechaLocal(user['id'])))
            response = input("Ingrese un alias o enter para continuar:")
            if response!= "":
                user['alias'] = response
            response = input("Presiones 'si' para descartar este usuario del procesamiento de datos")
            if response=="si":
                user['ignore'] = True

    filename = PATHALIAS
    with open(filename, 'wb') as f:
        pickle.dump(users, f)
예제 #4
0
파일: db.py 프로젝트: IoniUTDT/IPyVisound
def updateListOfUsers(notIgnored=False):
    """
        Detecta que usuarios no tienen alias y propone modificarlo en forma semiautomartica
    """
    from scripts.general import fechaLocal
    import os
    import pickle

    users = listOfUsers()
    for user in users:
        if notIgnored:
            if not user[cts.Db_Users_Alias] in listOfUsersCleanAlias():
                continue
                display('Saltar!')
        display('Usuario creado el ' +
                str(fechaLocal(user[cts.Db_Sesion_User_Id])) +
                ' Alias actual: ' + user[cts.Db_Users_Alias])
        response = input("Ingrese un nuevo alias o enter para continuar:")
        if response != "":
            user[cts.Db_Users_Alias] = response
        response = input(
            "Presiones 'si' para descartar este usuario del procesamiento de datos"
        )
        if response == "si":
            user[cts.Db_Users_Ignore] = True

    with open(cts.PATHALIAS, 'wb') as f:
        pickle.dump(users, f)
예제 #5
0
def joinUsers():
    """
        Esta funcion busca los usuarios nuevos en la lista de sessiones guardadas y compara con la lista de usuarios almacenada en la base de datos alias. Si encuentra que alguno no esta pregunta el alias y si ignorarlo o no y lo incluye
    """
    from IPython.display import display
    import os
    import pickle
    from scripts.constants import PATHALIAS, PATHSESSSION
    from scripts.general import fechaLocal

    filename = PATHSESSSION
    if os.path.isfile(filename):
        with open(filename, 'rb') as f:
            sessiones = pickle.load(f)
    else:
        display('ERROR! : No se encontro el archivo ' + filename +
                ' con el registro de las sessiones.')
        return

    newUsersId = set([session['contenido']['userId'] for session in sessiones])

    filename = PATHALIAS

    if os.path.isfile(filename):
        with open(filename, 'rb') as f:
            users = pickle.load(f)
    else:
        users = []

    usersId = [user['id'] for user in users]

    for newUserId in newUsersId:
        if not newUserId in usersId:
            # Creamos el usuario
            newUser = {}
            newUser['id'] = newUserId
            # Preguntamos datos del usuario
            display('Usuario creado el ' + str(fechaLocal(newUser['id'])))
            response = input("Ingrese un alias o enter para continuar:\n")
            if response != "":
                newUser['alias'] = response
            else:
                newUser['alias'] = str(newUser['id'])
            response = input(
                "Presiones 'si' para descartar este usuario del procesamiento de datos:\n"
            )
            if response == "si":
                newUser['ignore'] = True
            else:
                newUser['ignore'] = False
            users = users + [newUser]

    with open(filename, 'wb') as f:
        pickle.dump(users, f)
예제 #6
0
def sessionStats():

    data = pandasTransferencia()
    sessionInstances = data[cts.P_SessionInstance].unique()
    for sessionInstance in sessionInstances:
        infoSesion = data[data[cts.P_SessionInstance] == sessionInstance]
        display('El usuario ' + infoSesion.iloc[0][cts.P_Alias] +
                ' inicio sesion el ' + str(fechaLocal(sessionInstance)) +
                ' y juego ' +
                str(len(infoSesion[cts.P_LevelInstance].unique())) +
                ' niveles.')
        for levelInstance in data[data[cts.P_SessionInstance] ==
                                  sessionInstance][
                                      cts.P_LevelInstance].unique():
            infoLevel = data[data[cts.P_LevelInstance] ==
                             levelInstance].iloc[0]
            display(' Level ' + infoLevel[cts.P_LevelIdentificador] +
                    ' jugado a las: ' + str(fechaLocal(levelInstance)) +
                    ' Envio de datos terminado a las: ' +
                    str(fechaLocal(infoLevel[cts.P_EnvioInstance])))
예제 #7
0
파일: db.py 프로젝트: IoniUTDT/IPyVisound
def joinUsers():
    """
        Esta funcion busca los usuarios nuevos en la lista de sessiones guardadas y compara con la lista de usuarios almacenada en la base de datos alias. Si encuentra que alguno no esta pregunta el alias y si ignorarlo o no y lo incluye
    """
    import os
    import pickle
    from scripts.general import fechaLocal

    if os.path.isfile(cts.PATHSESSSION):
        with open(cts.PATHSESSSION, 'rb') as f:
            sessiones = pickle.load(f)
    else:
        display('ERROR! : No se encontro el archivo ' + cts.PATHSESSSION +
                ' con el registro de las sessiones.')
        return

    newUsersId = set([
        session[cts.Db_Envios_Contenido][cts.Db_Sesion_User][
            cts.Db_Sesion_User_Id] for session in sessiones
    ])

    if os.path.isfile(cts.PATHALIAS):
        with open(cts.PATHALIAS, 'rb') as f:
            users = pickle.load(f)
    else:
        users = []

    usersId = [user[cts.Db_Users_id] for user in users]

    for newUserId in newUsersId:
        if not newUserId in usersId:
            # Creamos el usuario
            newUser = {}
            newUser[cts.Db_Users_id] = newUserId
            # Preguntamos datos del usuario
            display('Usuario creado el ' +
                    str(fechaLocal(newUser[cts.Db_Users_id])))
            response = input("Ingrese un alias o enter para continuar:\n")
            if response != "":
                newUser[cts.Db_Users_Alias] = response
            else:
                newUser[cts.Db_Users_Alias] = str(newUser[cts.Db_Users_i])
            response = input(
                "Presiones 'si' para descartar este usuario del procesamiento de datos:\n"
            )
            if response == "si":
                newUser[cts.Db_Users_Ignore] = True
            else:
                newUser[cts.Db_Users_Ignore] = False
            users = users + [newUser]

    with open(cts.PATHALIAS, 'wb') as f:
        pickle.dump(users, f)
예제 #8
0
파일: db.py 프로젝트: IoniUTDT/IPyVisound
def joinUsers():

    """
        Esta funcion busca los usuarios nuevos en la lista de sessiones guardadas y compara con la lista de usuarios almacenada en la base de datos alias. Si encuentra que alguno no esta pregunta el alias y si ignorarlo o no y lo incluye
    """
    from IPython.display import display
    import os
    import pickle
    from scripts.constants import PATHALIAS, PATHSESSSION
    from scripts.general import fechaLocal

    filename = PATHSESSSION
    if os.path.isfile(filename):
        with open(filename, 'rb') as f:
            sessiones = pickle.load(f)
    else:
        display ('ERROR! : No se encontro el archivo ' + filename + ' con el registro de las sessiones.')
        return

    newUsersId = set([session['contenido']['userId'] for session in sessiones])

    filename = PATHALIAS

    if os.path.isfile(filename):
        with open(filename, 'rb') as f:
            users= pickle.load(f)
    else:
        users = []

    usersId = [user['id'] for user in users]

    for newUserId in newUsersId:
        if not newUserId in usersId:
            # Creamos el usuario
            newUser = {}
            newUser['id'] = newUserId
            # Preguntamos datos del usuario
            display ('Usuario creado el '+str(fechaLocal(newUser['id'])))
            response = input("Ingrese un alias o enter para continuar:\n")
            if response != "":
                newUser['alias'] = response
            else:
                newUser['alias'] = str(newUser['id'])
            response = input("Presiones 'si' para descartar este usuario del procesamiento de datos:\n")
            if response == "si":
                newUser['ignore'] = True
            else:
                newUser['ignore'] = False
            users = users + [newUser]

    with open(filename, 'wb') as f:
        pickle.dump(users, f)
예제 #9
0
파일: db.py 프로젝트: IoniUTDT/IPyVisound
def joinUsers():

    """
        Esta funcion busca los usuarios nuevos en la lista de sessiones guardadas y compara con la lista de usuarios almacenada en la base de datos alias. Si encuentra que alguno no esta pregunta el alias y si ignorarlo o no y lo incluye
    """
    import os
    import pickle
    from scripts.general import fechaLocal

    if os.path.isfile(cts.PATHSESSSION):
        with open(cts.PATHSESSSION, "rb") as f:
            sessiones = pickle.load(f)
    else:
        display("ERROR! : No se encontro el archivo " + cts.PATHSESSSION + " con el registro de las sessiones.")
        return

    newUsersId = set(
        [session[cts.Db_Envios_Contenido][cts.Db_Sesion_User][cts.Db_Sesion_User_Id] for session in sessiones]
    )

    if os.path.isfile(cts.PATHALIAS):
        with open(cts.PATHALIAS, "rb") as f:
            users = pickle.load(f)
    else:
        users = []

    usersId = [user[cts.Db_Users_id] for user in users]

    for newUserId in newUsersId:
        if not newUserId in usersId:
            # Creamos el usuario
            newUser = {}
            newUser[cts.Db_Users_id] = newUserId
            # Preguntamos datos del usuario
            display("Usuario creado el " + str(fechaLocal(newUser[cts.Db_Users_id])))
            response = input("Ingrese un alias o enter para continuar:\n")
            if response != "":
                newUser[cts.Db_Users_Alias] = response
            else:
                newUser[cts.Db_Users_Alias] = str(newUser[cts.Db_Users_i])
            response = input("Presiones 'si' para descartar este usuario del procesamiento de datos:\n")
            if response == "si":
                newUser[cts.Db_Users_Ignore] = True
            else:
                newUser[cts.Db_Users_Ignore] = False
            users = users + [newUser]

    with open(cts.PATHALIAS, "wb") as f:
        pickle.dump(users, f)
예제 #10
0
def sessionStats():

    from scripts.db import pandasUtilPiloto
    from IPython.display import display
    from scripts.general import fechaLocal

    dbPiloto = pandasUtilPiloto()
    sessionInstances = dbPiloto['sessionInstance'].unique()
    for sessionInstance in sessionInstances:
        dbPilotoBySession = dbPiloto[dbPiloto['sessionInstance'] ==
                                     sessionInstance]
        display('El usuario ' + dbPilotoBySession.iloc[0]['alias'] +
                ' inicio sesion el ' + str(fechaLocal(sessionInstance)) +
                ' y juego ' + str(len(dbPilotoBySession['levelInstance'])) +
                ' niveles.')
예제 #11
0
def sessionStats():

    data = pandasTransferencia()
    sessionInstances = data[cts.P_SessionInstance].unique()
    for sessionInstance in sessionInstances:
        infoSesion = data[data[cts.P_SessionInstance] == sessionInstance]
        display('El usuario ' + infoSesion.iloc[0][cts.P_Alias] + ' inicio sesion el ' + str(fechaLocal(sessionInstance)) + ' y juego ' + str(len(infoSesion[cts.P_LevelInstance].unique())) + ' niveles.')
        for levelInstance in data[data[cts.P_SessionInstance]==sessionInstance][cts.P_LevelInstance].unique():
            infoLevel = data[data[cts.P_LevelInstance] == levelInstance].iloc[0]
            display(' Level ' + infoLevel[cts.P_LevelIdentificador] + ' jugado a las: ' + str(fechaLocal(levelInstance)) + ' Envio de datos terminado a las: ' + str(fechaLocal(infoLevel[cts.P_EnvioInstance])))
예제 #12
0
def plotConvergenciaAngulos (levels, completos=True):
    """
        Esta función grafica el angulo en funcion del numero de trial para cada uno de los cuadrantes
    """
    import matplotlib.pyplot as plt
    from IPython.display import display
    from scripts.general import fechaLocal
    import json

    from scripts.general import chkVersion
    chkVersion()

    mostrarReferencia = True
    mostrarNivel = False
    mostrarAngulo = False

    if completos:
        levels = levels[levels['levelCompleted']]

    for usuario in levels['Alias'].unique():
        display ('Se hara la estadistica del usuario: '+usuario)
        levelsUsuario = levels[levels['Alias']==usuario]
        display ('El usuario '+usuario+' jugo '+str(len(levelsUsuario['sessionInstance'].unique()))+' veces')

        if mostrarReferencia:
            # Armamos el grafico de angulos refrenciados (esta aca porque queremos comparar entre todos los levels de todas las sesiones de un mismo usuario)

            # Armamos los colores
            # These are the "Tableau 20" colors as RGB.
            tableau20 = [(31, 119, 180), (174, 199, 232), (255, 187, 120),
                (44, 160, 44), (152, 223, 138), (214, 39, 40), (255, 152, 150),
                (148, 103, 189), (197, 176, 213), (140, 86, 75), (196, 156, 148),
                (227, 119, 194), (247, 182, 210), (127, 127, 127), (199, 199, 199),
                (188, 189, 34), (219, 219, 141), (23, 190, 207), (158, 218, 229), (255, 127, 14)]

            Color2 = ['0F3FFF','190EFE','530DFD','8D0CFD','C80BFC','FC0AF5','FB0AB9',
                'FB097D','FA0841','FA0A07','F94506','F98006','F8BB05','F8F604','BCF703',
                '80F703','43F602','06F601','00F537','00F572']

            # Scale the RGB values to the [0, 1] range, which is the format matplotlib accepts.
            for i in range(len(tableau20)):
                r, g, b = tableau20[i]
                tableau20[i] = (r / 255., g / 255., b / 255.)

            figC, (axC1, axC2, axC3, axC4) = plt.subplots(nrows=4)
            figC.set_size_inches(10, 18)
            title = 'Comparacion de la evolucion del delta angulo en funcion del trial\n' + 'Usuario: '+str(usuario)
            figC.suptitle (title, fontsize=10, fontweight='bold')
            figC.subplots_adjust(hspace=0.5)
            axC1.set_title("Cuadrante 1")
            axC1.set_xlabel('Numero de trial')
            axC1.set_ylabel('Delta angulo')
            axC1.set_color_cycle(tableau20)
            axC2.set_title("Cuadrante 2")
            axC2.set_xlabel('Numero de trial')
            axC2.set_ylabel('Delta angulo')
            axC2.set_color_cycle(tableau20)
            axC3.set_title("Cuadrante 3")
            axC3.set_xlabel('Numero de trial')
            axC3.set_ylabel('Delta angulo')
            axC3.set_color_cycle(tableau20)
            axC4.set_title("Cuadrante 4")
            axC4.set_xlabel('Numero de trial')
            axC4.set_ylabel('Delta angulo')
            axC4.set_color_cycle(tableau20)

        for session in levelsUsuario['sessionInstance'].unique():
            levelSession = levelsUsuario[levelsUsuario['sessionInstance']==session]
            display ('En la session '+ str(fechaLocal(session))+ ' el usuario '+str(usuario)+' jugo '+str(len(levelSession['levelInstance'].unique())) + ' niveles')
            for level in levelSession['levelInstance'].unique():
                levelLevel = levelSession[levelSession['levelInstance']==level]
                # display (levelLevel)
                levelInfo = levelLevel.iloc[0]
                convergencias = levelInfo['advance']['convergencias']

                for convergencia in convergencias:

                    if mostrarNivel:
                        # Armamos el grafico de nivel
                        fig1 = plt.figure(figsize=(10,3))
                        ax1 = fig1.add_subplot(111)
                        title = 'Evolucion de la dificultad en funcion del trial \n' + 'Usuario: '+str(usuario) + ' en la referencia: ' + str(convergencia['anguloDeReferencia'])
                        ax1.set_title(title, fontsize=10, fontweight='bold')
                        ax1.set_xlabel('Numero de trial')
                        ax1.set_ylabel('Nivel')

                    if mostrarAngulo:
                        # Armamos el grafico de angulo
                        fig2 = plt.figure(figsize=(10,3))
                        ax2 = fig2.add_subplot(111)
                        title = 'Evolucion del angulo en funcion del trial \n' + 'Usuario: '+str(usuario) + ' en la referencia: ' + str(convergencia['anguloDeReferencia'])
                        ax2.set_title(title, fontsize=10, fontweight='bold')
                        ax2.set_xlabel('Numero de trial')
                        ax2.set_ylabel('Angulo')




                    # Extraemos la info en forma de lista
                    aciertos=[]
                    angulosReferido=[]
                    angulos=[]
                    angulosNivel = []
                    for historial in convergencia['historial']:
                        # Extraemos la lista de aciertos o errores de la info del historial
                        if historial['acertado']:
                            aciertos=aciertos+[True]
                        else:
                            aciertos=aciertos+[False]
                        angulos = angulos + [historial['angulo']]
                        # Corregimos el tema de cuadrante para que se vea mas lindo.
                        if angulos[-1] < historial['anguloDeReferencia']:
                            angulos[-1] = angulos[-1] + 360
                        angulosReferido = angulosReferido + [historial['anguloReferido']]
                        angulosNivel = angulosNivel + [historial['nivel']]

                    if mostrarNivel:
                        # Dibujamos los niveles
                        x = range(len(angulosNivel))
                        y = angulosNivel
                        ax1.plot(x,y, label=convergencia['nombreDelCuadrante'])
                        # marcamos aciertos y errores
                        x = [i for i in range(len(aciertos)) if aciertos[i]]
                        y = [angulosNivel[i] for i in range(len(aciertos)) if aciertos[i]]
                        ax1.plot(x,y,'go')
                        x = [i for i in range(len(aciertos)) if not aciertos[i]]
                        y = [angulosNivel[i] for i in range(len(aciertos)) if not aciertos[i]]
                        ax1.plot(x,y,'ro')
                        # Marcamos el final si es convergencia o no.
                        if convergencia['convergenciaAlcanzada']:
                            ax1.plot([len(angulosNivel)-1],angulosNivel[-1],'bs', markersize=10)
                        else:
                            if len(angulosNivel) > 0: # Esto es porque hay datos malos, no deberia hacer falta en gral
                                ax1.plot([len(angulosNivel)-1],angulosNivel[-1],'rs', markersize=10)
                        ax1.legend(loc='center left', bbox_to_anchor=(1, 0.5))

                    if mostrarAngulo:
                        # Dibujamos los angulos
                        x = range(len(angulos))
                        y = angulos
                        ax2.plot(x,y, label=convergencia['nombreDelCuadrante'])
                        # marcamos aciertos y errores
                        x = [i for i in range(len(aciertos)) if aciertos[i]]
                        y = [angulos[i] for i in range(len(aciertos)) if aciertos[i]]
                        ax2.plot(x,y,'go')
                        x = [i for i in range(len(aciertos)) if not aciertos[i]]
                        y = [angulos[i] for i in range(len(aciertos)) if not aciertos[i]]
                        ax2.plot(x,y,'ro')
                        # Marcamos el final si es convergencia o no.
                        if convergencia['convergenciaAlcanzada']:
                            ax2.plot([len(angulos)-1],angulos[-1],'bs', markersize=10)
                        else:
                            if len(angulos) > 0: # Esto es porque hay datos malos, no deberia hacer falta en gral
                                ax2.plot([len(angulos)-1],angulos[-1],'rs', markersize=10)
                        ax2.legend(loc='center left', bbox_to_anchor=(1, 0.5))

                    if mostrarReferencia:
                        # Dibujamos los angulos referenciados
                        if convergencia['numeroCuadrante']==1:
                                axC=axC1
                        if convergencia['numeroCuadrante']==2:
                                axC=axC2
                        if convergencia['numeroCuadrante']==3:
                                axC=axC3
                        if convergencia['numeroCuadrante']==4:
                                axC=axC4

                        x = range(len(angulos))
                        y = angulosReferido
                        if 'ultimoMEANAngulo' in convergencia:
                            Label = "Referencia "+str(convergencia['anguloDeReferencia']) + " mean(Angulo): " + str(convergencia['ultimoMEANAngulo'])
                        else:
                            Label = "Referencia "+str(convergencia['anguloDeReferencia']) + " mean(Level): " + str(convergencia['ultimoMEAN'])
                        axC.plot(x,y,label=Label, lw=(convergencia['anguloDeReferencia']+45)/90*5)
                        # marcamos aciertos y errores
                        #x = [i for i in range(len(aciertos)) if aciertos[i]]
                        #y = [angulosRef[i] for i in range(len(aciertos)) if aciertos[i]]
                        #axC.plot(x,y,'go')
                        #x = [i for i in range(len(aciertos)) if not aciertos[i]]
                        #y = [angulosRef[i] for i in range(len(aciertos)) if not aciertos[i]]
                        #axC.plot(x,y,'ro')
                        # Marcamos el final si es convergencia o no.
                        if convergencia['convergenciaAlcanzada']:
                            axC.plot([len(angulosReferido)-1],angulosReferido[-1],'bs', markersize=10)
                        else:
                            if len(angulos) > 0: # Esto es porque hay datos malos, no deberia hacer falta en gral
                                axC.plot([len(angulos)-1],angulosReferido[-1],'rs', markersize=10)
                        axC.legend(loc='center left', bbox_to_anchor=(1, 0.5),prop={'size':10})
예제 #13
0
def plotConvergencia (db, expName, fromStadistics=False, join=False):

    import matplotlib.pyplot as plt
    import matplotlib.cm as cm
    import numpy as np
    from scripts.general import fechaLocal

    db=db[db[cts.P_LevelIdentificador]==expName]
    dbInfo = db.iloc[0]
    # Armamos el grafico
    colormap = plt.cm.nipy_spectral #I suggest to use nipy_spectral, Set1,Paired

    if join:
        if fromStadistics:
            fig = plt.figure(figsize=(20, 10))
        else:
            fig = plt.figure(figsize=(20, 20))

        ax = plt.subplot(111)
        ax.set_xlabel('Numero de trial')
        ax.set_ylabel('señal (nivel)')

        title = ''
        if len(db[cts.P_Alias].unique()) == 1:
            title = title + ' Usuario: ' + dbInfo[cts.P_Alias]

        title = title + ' Experimento: ' + expName

        ax.set_title(title, va='bottom')

        # Definimos la escala de colores
        size = len(db[cts.P_Alias])
        colors = iter(cm.Paired(np.linspace(0, 1, size)))
        levelColors = {}

    onceInstance = True
    # Hacemos un grafico para cada instancia del nivel jugado (en principio deberia haber una sola, pero podria haber mas)
    for levelInstance in db[cts.P_LevelInstance].unique():

        if not join:
            if fromStadistics:
                fig = plt.figure(figsize=(20, 10))
            else:
                fig = plt.figure(figsize=(20, 20))

            ax = plt.subplot(111)
            ax.set_xlabel('Numero de trial')
            ax.set_ylabel('señal (nivel)')

            title = ''
            if len(db[cts.P_Alias].unique()) == 1:
                title = title + ' Usuario: ' + dbInfo[cts.P_Alias]

            title = title + ' Experimento: ' + expName

            ax.set_title(title, va='bottom')

            # Definimos la escala de colores
            size = len(db[cts.P_Alias])
            colors = iter(cm.Paired(np.linspace(0, 1, size)))
            levelColors = {}


        dbLevelInstance = db[db[cts.P_LevelInstance] == levelInstance]
        #display (dbLevelInstance[cts.P_SessionInstance].unique())
        y = dbLevelInstance[cts.P_NivelEstimuloDinamica].tolist()
        x = range (len(y))

        # Construimos el label diferentes segun sea un grafico para un solo usuario o para varios
        label = ''

        if len(db[cts.P_Alias].unique()) != 1:
            label = label + ' Usuario: ' + dbLevelInstance[cts.P_Alias].unique()[0]

        label = label + ' referencia: ' + str(dbLevelInstance[cts.P_Referencia].unique()[0])
        label = label + ' \n Valor final: ' + str(y[-1])
        label = label + ' \n Sesion:' + str(dbLevelInstance[cts.P_SessionInstance].unique()[0])
        label = label + ' \n Fecha:' + str(fechaLocal(dbLevelInstance[cts.P_SessionInstance].unique()[0]))
        #display (levelInstance)

        # Agregamos las marcas
        aciertos = dbLevelInstance[cts.P_RtaCorrecta].tolist()
        tipo = dbLevelInstance[cts.P_TipoDeTrial].tolist()
        for i in x:
            if aciertos[i]:
                ax.plot(i,y[i],'go')
            else:
                ax.plot(i,y[i],'ro')

        if onceInstance:
            ax.plot([i for i in x if tipo[i]==cts.Db_Historial_Recurso_EtiquetaTipoNoEstimulo],[y[i] for i in x if tipo[i]==cts.Db_Historial_Recurso_EtiquetaTipoNoEstimulo],'8', color='black', markersize=15, fillstyle = 'none', label=cts.Db_Historial_Recurso_EtiquetaTipoNoEstimulo, mew = 3)
            ax.plot([i for i in x if tipo[i]==cts.Db_Historial_Recurso_EtiquetaTipoEstimulo],[y[i] for i in x if tipo[i]==cts.Db_Historial_Recurso_EtiquetaTipoEstimulo],'8', color='green', markersize=15, fillstyle = 'none', label=cts.Db_Historial_Recurso_EtiquetaTipoEstimulo, mew = 3)
            ax.plot([i for i in x if tipo[i]==cts.Db_Historial_Recurso_EtiquetaTipoTest],[y[i] for i in x if tipo[i]==cts.Db_Historial_Recurso_EtiquetaTipoTest],'8', color='cyan', markersize=15, fillstyle = 'none', label=cts.Db_Historial_Recurso_EtiquetaTipoTest, mew = 3)
        else:
            ax.plot([i for i in x if tipo[i]==cts.Db_Historial_Recurso_EtiquetaTipoNoEstimulo],[y[i] for i in x if tipo[i]==cts.Db_Historial_Recurso_EtiquetaTipoNoEstimulo],'8', color='black', markersize=15, fillstyle = 'none', mew = 3)
            ax.plot([i for i in x if tipo[i]==cts.Db_Historial_Recurso_EtiquetaTipoEstimulo],[y[i] for i in x if tipo[i]==cts.Db_Historial_Recurso_EtiquetaTipoEstimulo],'8', color='green', markersize=15, fillstyle = 'none', mew = 3)
            ax.plot([i for i in x if tipo[i]==cts.Db_Historial_Recurso_EtiquetaTipoTest],[y[i] for i in x if tipo[i]==cts.Db_Historial_Recurso_EtiquetaTipoTest],'8', color='cyan', markersize=15, fillstyle = 'none', mew = 3)

        # Graficamos
        if levelInstance in levelColors.keys():
            color = levelColors[levelInstance]
            # ax.plot(x,y,color=color)
            ax.plot(x,y)
        else:
            color=next(colors)
            #ax.plot(x,y,label=label,color=color)
            ax.plot(x,y,label=label)
            levelColors[levelInstance] = color

        if not join:
            fig.savefig('./Images/Calibracion'+str(levelInstance))

        ax.legend(loc='center left', bbox_to_anchor=(1, 0.5),numpoints=1)

        onceInstance = False

    if join:
        fig.savefig('./Images/Calibracion'+str(levelInstance))

    plt.show(block=False)
예제 #14
0
def sessionStats():

    from scripts.db import pandasUtilPiloto
    from IPython.display import display
    from scripts.general import fechaLocal

    dbPiloto = pandasUtilPiloto()
    sessionInstances = dbPiloto['sessionInstance'].unique()
    for sessionInstance in sessionInstances:
        dbPilotoBySession = dbPiloto[dbPiloto['sessionInstance'] == sessionInstance]
        display ('El usuario ' + dbPilotoBySession.iloc[0]['alias'] + ' inicio sesion el ' + str(fechaLocal(sessionInstance)) + ' y juego ' + str(len(dbPilotoBySession['levelInstance'])) + ' niveles.')
예제 #15
0
def buscarUmbral(touchs, ordenado=False):

    """
        Esta funcion toma el dataframe de un conjunto de touchs incluidos en muchos niveles, y devuelve un dataframe con la informacion del nivel de umbral detectado.
        El parametro ordenado indica si se ordena los datos en funcion del angulo de referencia para las mediciones de un mismo usuario.

        Estas cuentas estan en el contexto de la medicion de umbral de deteccion.
    """

    import pandas as pd
    from IPython.display import display
    from scripts.general import fechaLocal

    import numpy as np  # importando numpy
    from scipy import stats  # importando scipy.stats

    # Definimos los levelversion compatibles
    levelVersionCompatibles = [22]

    # Creamos un dataframe para guardar los datos
    resumen = pd.DataFrame(
        columns=[
            "AnguloReferencia",
            "MediaDeltaTita",
            "DesviacionDeltaTita",
            "CumpleCriterioCola",
            "Session",
            "Usuario",
            "Level",
            "LevelVersion",
            "Identificador",
        ]
    )

    # Procesamos solo los datos de niveles completos
    touchs = touchs[touchs["levelCompleted"] == True]

    # Se filtra los datos de levelVersion no compatibles con este procesamientos
    touchs = touchs[touchs["levelVersion"].isin(levelVersionCompatibles)]

    for usuario in touchs["Alias"].unique():
        touchsUsuario = touchs[touchs["Alias"] == usuario]
        for session in touchsUsuario["sessionInstance"].unique():
            touchsSession = touchsUsuario[touchsUsuario["sessionInstance"] == session]

            for level in touchsSession["levelInstance"].unique():

                resumenToAppend = pd.DataFrame(
                    columns=[
                        "AnguloReferencia",
                        "MediaDeltaTita",
                        "DesviacionDeltaTita",
                        "CumpleCriterioCola",
                        "Session",
                        "Usuario",
                        "Level",
                        "LevelVersion",
                        "Identificador",
                    ]
                )

                # Cargamos cosas en el resumen
                resumenToAppend["Session"] = [fechaLocal(session)]
                resumenToAppend["Usuario"] = [usuario]
                resumenToAppend["Level"] = [fechaLocal(level)]

                touchsLevel = touchsSession[touchsSession["levelInstance"] == level]

                # filtramos la ultima mitad de los datos
                touchsLevelEnd = touchsLevel.iloc[-int(touchsLevel.index.size / 2) :, :]

                # Miramos si tiene algun tipo de sentido (que este en el fondo de la cola). Para eso revisamos que no haya mas false que true (Xq una vez q se estabiliza tiene q haber dos true x cada false (el codigo disminuye la señal despues de dos aciertos))
                # y ademas revisamos que no haya menos de 1/4 de falses xq eso indicaria que no esta rebotando

                levelInfo = touchsLevel.iloc[0]
                contadorTouchsLevelTrue = touchsLevelEnd[touchsLevelEnd["isTrue"] == True].index.size
                contadorTouchsLevelFalse = touchsLevelEnd[touchsLevelEnd["isTrue"] == False].index.size

                if (contadorTouchsLevelTrue < contadorTouchsLevelFalse) or (
                    contadorTouchsLevelFalse * 3 < contadorTouchsLevelTrue
                ):
                    resumenToAppend["CumpleCriterioCola"] = [False]
                else:
                    resumenToAppend["CumpleCriterioCola"] = [True]

                # Extraemos la info de del delta tita del estimulo de cada trial
                columnName = "DeltaTita"
                if not columnName in touchsLevelEnd.columns:
                    temp = pd.DataFrame(columns=[columnName])
                    for (i, r) in touchsLevelEnd.iterrows():
                        e = r["jsonMetaDataEstimulo"]
                        temp.loc[i] = [e["infoConceptual"]["deltaAngulo"]]
                    touchsLevelEnd = pd.concat([touchsLevelEnd, temp], axis=1)
                else:
                    display("Warning: Se encontraron datos ya cargados para: " + columnName)

                # Extraemos la info del angulo de referencia
                columnName = "AnguloDeReferencia"
                if not columnName in touchsLevelEnd.columns:
                    temp = pd.DataFrame(columns=[columnName])
                    for (i, r) in touchsLevelEnd.iterrows():
                        e = r["jsonMetaDataEstimulo"]
                        temp.loc[i] = [e["infoConceptual"]["direccionAnguloReferencia"]]
                    touchsLevelEnd = pd.concat([touchsLevelEnd, temp], axis=1)
                else:
                    display("Warning: Se encontraron datos ya cargados para: " + columnName)

                levelInfo = touchsLevelEnd.iloc[0]
                datos = touchsLevelEnd["DeltaTita"].tolist()

                resumenToAppend["AnguloReferencia"] = [levelInfo["AnguloDeReferencia"]]
                resumenToAppend["MediaDeltaTita"] = [np.mean(datos)]
                resumenToAppend["DesviacionDeltaTita"] = [np.std(datos)]
                resumenToAppend["LevelVersion"] = [levelInfo["levelVersion"]]
                if "appVersion" in touchsLevelEnd.columns:
                    resumenToAppend["AppVersion"] = [levelInfo["appVersion"]]
                else:
                    resumenToAppend["AppVersion"] = "Sin Dato"
                if "identificador" in touchsLevelEnd.columns:
                    resumenToAppend["Identificador"] = [levelInfo["identificador"]]
                else:
                    resumenToAppend["Identificador"] = "Dato no cargado"
                resumen = pd.concat([resumen, resumenToAppend], axis=0, ignore_index=True)

    if ordenado:
        resumen = resumen.sort(["AnguloReferencia"], ascending=[True])

    return resumen
예제 #16
0
def plotConvergenciaAngulos(levels, completos=True):
    """
        Esta función grafica el angulo en funcion del numero de trial para cada uno de los cuadrantes
    """
    import matplotlib.pyplot as plt
    from IPython.display import display
    from scripts.general import fechaLocal
    import json

    from scripts.general import chkVersion
    chkVersion()

    mostrarReferencia = True
    mostrarNivel = False
    mostrarAngulo = False

    if completos:
        levels = levels[levels['levelCompleted']]

    for usuario in levels['Alias'].unique():
        display('Se hara la estadistica del usuario: ' + usuario)
        levelsUsuario = levels[levels['Alias'] == usuario]
        display('El usuario ' + usuario + ' jugo ' +
                str(len(levelsUsuario['sessionInstance'].unique())) + ' veces')

        if mostrarReferencia:
            # Armamos el grafico de angulos refrenciados (esta aca porque queremos comparar entre todos los levels de todas las sesiones de un mismo usuario)

            # Armamos los colores
            # These are the "Tableau 20" colors as RGB.
            tableau20 = [(31, 119, 180), (174, 199, 232), (255, 187, 120),
                         (44, 160, 44), (152, 223, 138), (214, 39, 40),
                         (255, 152, 150), (148, 103, 189), (197, 176, 213),
                         (140, 86, 75), (196, 156, 148), (227, 119, 194),
                         (247, 182, 210), (127, 127, 127), (199, 199, 199),
                         (188, 189, 34), (219, 219, 141), (23, 190, 207),
                         (158, 218, 229), (255, 127, 14)]

            Color2 = [
                '0F3FFF', '190EFE', '530DFD', '8D0CFD', 'C80BFC', 'FC0AF5',
                'FB0AB9', 'FB097D', 'FA0841', 'FA0A07', 'F94506', 'F98006',
                'F8BB05', 'F8F604', 'BCF703', '80F703', '43F602', '06F601',
                '00F537', '00F572'
            ]

            # Scale the RGB values to the [0, 1] range, which is the format matplotlib accepts.
            for i in range(len(tableau20)):
                r, g, b = tableau20[i]
                tableau20[i] = (r / 255., g / 255., b / 255.)

            figC, (axC1, axC2, axC3, axC4) = plt.subplots(nrows=4)
            figC.set_size_inches(10, 18)
            title = 'Comparacion de la evolucion del delta angulo en funcion del trial\n' + 'Usuario: ' + str(
                usuario)
            figC.suptitle(title, fontsize=10, fontweight='bold')
            figC.subplots_adjust(hspace=0.5)
            axC1.set_title("Cuadrante 1")
            axC1.set_xlabel('Numero de trial')
            axC1.set_ylabel('Delta angulo')
            axC1.set_color_cycle(tableau20)
            axC2.set_title("Cuadrante 2")
            axC2.set_xlabel('Numero de trial')
            axC2.set_ylabel('Delta angulo')
            axC2.set_color_cycle(tableau20)
            axC3.set_title("Cuadrante 3")
            axC3.set_xlabel('Numero de trial')
            axC3.set_ylabel('Delta angulo')
            axC3.set_color_cycle(tableau20)
            axC4.set_title("Cuadrante 4")
            axC4.set_xlabel('Numero de trial')
            axC4.set_ylabel('Delta angulo')
            axC4.set_color_cycle(tableau20)

        for session in levelsUsuario['sessionInstance'].unique():
            levelSession = levelsUsuario[levelsUsuario['sessionInstance'] ==
                                         session]
            display('En la session ' + str(fechaLocal(session)) +
                    ' el usuario ' + str(usuario) + ' jugo ' +
                    str(len(levelSession['levelInstance'].unique())) +
                    ' niveles')
            for level in levelSession['levelInstance'].unique():
                levelLevel = levelSession[levelSession['levelInstance'] ==
                                          level]
                # display (levelLevel)
                levelInfo = levelLevel.iloc[0]
                convergencias = levelInfo['advance']['convergencias']

                for convergencia in convergencias:

                    if mostrarNivel:
                        # Armamos el grafico de nivel
                        fig1 = plt.figure(figsize=(10, 3))
                        ax1 = fig1.add_subplot(111)
                        title = 'Evolucion de la dificultad en funcion del trial \n' + 'Usuario: ' + str(
                            usuario) + ' en la referencia: ' + str(
                                convergencia['anguloDeReferencia'])
                        ax1.set_title(title, fontsize=10, fontweight='bold')
                        ax1.set_xlabel('Numero de trial')
                        ax1.set_ylabel('Nivel')

                    if mostrarAngulo:
                        # Armamos el grafico de angulo
                        fig2 = plt.figure(figsize=(10, 3))
                        ax2 = fig2.add_subplot(111)
                        title = 'Evolucion del angulo en funcion del trial \n' + 'Usuario: ' + str(
                            usuario) + ' en la referencia: ' + str(
                                convergencia['anguloDeReferencia'])
                        ax2.set_title(title, fontsize=10, fontweight='bold')
                        ax2.set_xlabel('Numero de trial')
                        ax2.set_ylabel('Angulo')

                    # Extraemos la info en forma de lista
                    aciertos = []
                    angulosReferido = []
                    angulos = []
                    angulosNivel = []
                    for historial in convergencia['historial']:
                        # Extraemos la lista de aciertos o errores de la info del historial
                        if historial['acertado']:
                            aciertos = aciertos + [True]
                        else:
                            aciertos = aciertos + [False]
                        angulos = angulos + [historial['angulo']]
                        # Corregimos el tema de cuadrante para que se vea mas lindo.
                        if angulos[-1] < historial['anguloDeReferencia']:
                            angulos[-1] = angulos[-1] + 360
                        angulosReferido = angulosReferido + [
                            historial['anguloReferido']
                        ]
                        angulosNivel = angulosNivel + [historial['nivel']]

                    if mostrarNivel:
                        # Dibujamos los niveles
                        x = range(len(angulosNivel))
                        y = angulosNivel
                        ax1.plot(x,
                                 y,
                                 label=convergencia['nombreDelCuadrante'])
                        # marcamos aciertos y errores
                        x = [i for i in range(len(aciertos)) if aciertos[i]]
                        y = [
                            angulosNivel[i] for i in range(len(aciertos))
                            if aciertos[i]
                        ]
                        ax1.plot(x, y, 'go')
                        x = [
                            i for i in range(len(aciertos)) if not aciertos[i]
                        ]
                        y = [
                            angulosNivel[i] for i in range(len(aciertos))
                            if not aciertos[i]
                        ]
                        ax1.plot(x, y, 'ro')
                        # Marcamos el final si es convergencia o no.
                        if convergencia['convergenciaAlcanzada']:
                            ax1.plot([len(angulosNivel) - 1],
                                     angulosNivel[-1],
                                     'bs',
                                     markersize=10)
                        else:
                            if len(
                                    angulosNivel
                            ) > 0:  # Esto es porque hay datos malos, no deberia hacer falta en gral
                                ax1.plot([len(angulosNivel) - 1],
                                         angulosNivel[-1],
                                         'rs',
                                         markersize=10)
                        ax1.legend(loc='center left', bbox_to_anchor=(1, 0.5))

                    if mostrarAngulo:
                        # Dibujamos los angulos
                        x = range(len(angulos))
                        y = angulos
                        ax2.plot(x,
                                 y,
                                 label=convergencia['nombreDelCuadrante'])
                        # marcamos aciertos y errores
                        x = [i for i in range(len(aciertos)) if aciertos[i]]
                        y = [
                            angulos[i] for i in range(len(aciertos))
                            if aciertos[i]
                        ]
                        ax2.plot(x, y, 'go')
                        x = [
                            i for i in range(len(aciertos)) if not aciertos[i]
                        ]
                        y = [
                            angulos[i] for i in range(len(aciertos))
                            if not aciertos[i]
                        ]
                        ax2.plot(x, y, 'ro')
                        # Marcamos el final si es convergencia o no.
                        if convergencia['convergenciaAlcanzada']:
                            ax2.plot([len(angulos) - 1],
                                     angulos[-1],
                                     'bs',
                                     markersize=10)
                        else:
                            if len(
                                    angulos
                            ) > 0:  # Esto es porque hay datos malos, no deberia hacer falta en gral
                                ax2.plot([len(angulos) - 1],
                                         angulos[-1],
                                         'rs',
                                         markersize=10)
                        ax2.legend(loc='center left', bbox_to_anchor=(1, 0.5))

                    if mostrarReferencia:
                        # Dibujamos los angulos referenciados
                        if convergencia['numeroCuadrante'] == 1:
                            axC = axC1
                        if convergencia['numeroCuadrante'] == 2:
                            axC = axC2
                        if convergencia['numeroCuadrante'] == 3:
                            axC = axC3
                        if convergencia['numeroCuadrante'] == 4:
                            axC = axC4

                        x = range(len(angulos))
                        y = angulosReferido
                        if 'ultimoMEANAngulo' in convergencia:
                            Label = "Referencia " + str(
                                convergencia['anguloDeReferencia']
                            ) + " mean(Angulo): " + str(
                                convergencia['ultimoMEANAngulo'])
                        else:
                            Label = "Referencia " + str(
                                convergencia['anguloDeReferencia']
                            ) + " mean(Level): " + str(
                                convergencia['ultimoMEAN'])
                        axC.plot(x,
                                 y,
                                 label=Label,
                                 lw=(convergencia['anguloDeReferencia'] + 45) /
                                 90 * 5)
                        # marcamos aciertos y errores
                        #x = [i for i in range(len(aciertos)) if aciertos[i]]
                        #y = [angulosRef[i] for i in range(len(aciertos)) if aciertos[i]]
                        #axC.plot(x,y,'go')
                        #x = [i for i in range(len(aciertos)) if not aciertos[i]]
                        #y = [angulosRef[i] for i in range(len(aciertos)) if not aciertos[i]]
                        #axC.plot(x,y,'ro')
                        # Marcamos el final si es convergencia o no.
                        if convergencia['convergenciaAlcanzada']:
                            axC.plot([len(angulosReferido) - 1],
                                     angulosReferido[-1],
                                     'bs',
                                     markersize=10)
                        else:
                            if len(
                                    angulos
                            ) > 0:  # Esto es porque hay datos malos, no deberia hacer falta en gral
                                axC.plot([len(angulos) - 1],
                                         angulosReferido[-1],
                                         'rs',
                                         markersize=10)
                        axC.legend(loc='center left',
                                   bbox_to_anchor=(1, 0.5),
                                   prop={'size': 10})
예제 #17
0
def plotConvergencia(touchs, completo=True):

    """
        Esta funcion grafica la convergencia del delta tita en funcion del del avance del level. Sirve solo para visualizar datos.
    """

    import matplotlib.pyplot as plt
    import pandas as pd

    from IPython.display import display
    from scripts.general import fechaLocal

    # Procesamos solo los datos de niveles completos
    if completo:
        touchs = touchs[touchs["levelCompleted"] == True]

    for usuario in touchs["Alias"].unique():
        display("Se hara la estadistica del usuario: " + usuario)
        touchsUsuario = touchs[touchs["Alias"] == usuario]
        display("El usuario " + usuario + " jugo " + str(len(touchsUsuario["sessionInstance"].unique())) + " veces")
        for session in touchsUsuario["sessionInstance"].unique():
            touchsSession = touchsUsuario[touchsUsuario["sessionInstance"] == session]

            # Analizamos los datos para dificultad generica
            display(
                "En la session "
                + str(fechaLocal(session))
                + " el usuario "
                + str(usuario)
                + " jugo "
                + str(len(touchsSession["levelInstance"].unique()))
                + " niveles"
            )
            for level in touchsSession["levelInstance"].unique():

                touchsLevel = touchsSession[touchsSession["levelInstance"] == level]

                # Extraemos la info de del delta tita del estimulo de cada trial
                columnName = "DeltaTita"
                if not columnName in touchsLevel.columns:
                    temp = pd.DataFrame(columns=[columnName])
                    for (i, r) in touchsLevel.iterrows():
                        e = r["jsonMetaDataEstimulo"]
                        temp.loc[i] = [e["infoConceptual"]["deltaAngulo"]]
                    touchsLevel = pd.concat([touchsLevel, temp], axis=1)
                else:
                    display("Warning: Se encontraron datos ya cargados para: " + columnName)

                # Extraemos la info del angulo de referencia
                columnName = "AnguloDeReferencia"
                if not columnName in touchsLevel.columns:
                    temp = pd.DataFrame(columns=[columnName])
                    for (i, r) in touchsLevel.iterrows():
                        e = r["jsonMetaDataEstimulo"]
                        temp.loc[i] = [e["infoConceptual"]["direccionAnguloReferencia"]]
                    touchsLevel = pd.concat([touchsLevel, temp], axis=1)
                else:
                    display("Warning: Se encontraron datos ya cargados para: " + columnName)

                levelInfo = touchsLevel.iloc[0]
                touchsLevelTrue = touchsLevel[touchsLevel["isTrue"] == True]
                touchsLevelFalse = touchsLevel[touchsLevel["isTrue"] == False]

                # Armamos el grafico
                fig = plt.figure(figsize=(10, 3))
                ax = fig.add_subplot(111)
                title = (
                    "Evolucion de la dificultad en funcion del trial \n"
                    + "Usuario: "
                    + str(usuario)
                    + " direccion de refrencia: "
                    + str(levelInfo["AnguloDeReferencia"])
                    + " grados, "
                    + "levelVersion "
                    + str(levelInfo["levelVersion"])
                )
                ax.set_title(title, fontsize=10, fontweight="bold")
                ax.set_xlabel("Numero de trial")
                ax.set_ylabel("Delta Tita (grados)")
                x = touchsLevel.index
                y = touchsLevel["DeltaTita"].tolist()
                ax.plot(x, y)
                x = touchsLevelTrue.index
                y = touchsLevelTrue["DeltaTita"].tolist()
                ax.plot(x, y, "go")
                x = touchsLevelFalse.index
                y = touchsLevelFalse["DeltaTita"].tolist()
                ax.plot(x, y, "ro")