Categorización

Modelo de Similitud Contextual (Medin y Schaffer)

Haz Clic para ver el Código

```{python}
import numpy as np 
import pandas as pd
import ipywidgets as widgets

def similarity(x, y, m = 0.1):
    """
    Calcula la similaridad entre una categoria y un ítem de prueba
    # Parameters
    x: la categoría
    y: el ítem de prueba
    m: mismatch
    # Return
    Regresa un float que representa la similaridad del ítem con la categoría.
    """
    try:
        sim = np.empty(np.shape(x))
        for i in range(np.shape(class_a)[0]):
            for j in range(np.shape(class_a)[1]):
                if x[i, j] != y[j]:
                    sim[i, j]  = m
                else:
                    sim[i, j] = 1
        sim_by_item = np.prod(sim, axis = 1)
        sim_class = np.sum(sim_by_item)
        return sim_class

    except TypeError:
        return print(str(TypeError) + "'x' y 'y' deben ser arrays, donde 'x' es una matrix m*n y 'y' un array ndim = n")

def res_rule(sim = [0, 0]):
    """
    Calcula la probailidad de que el ítem pertenezca a cada categoría
    # Parameters
    sim: lista de la similitud de cada categoría con el item 
    # Return
    Regresa una lista con la probabilidad de cada categoría en el orden de indexación del input
    """
    proba = []
    for i in range(len(sim)):
        response = sim[i] / np.sum(sim)
        proba.append(round(response, 2))
    return proba

def contex_model(x = [0], y = [0], m = 0.1):
    """
    Calcula la similaridad entre un conjunto  arbitrario de categorías y un ítem de prieba

    # Parameters
    x: una lista con las diversas categorías.
    y: el ítem de prueba
    m: mismatch

    # Return

    Regresa un diccionario con información acerca de la similitud entre cada categoría y el ítem, y la probabilidad de que
    el ítem pertenezca a cada categoría.
    """
    sim = []
    for i in range(len(x)):
        sima = similarity(x[i], y, m)
        sim.append(sima)
    
    proba = res_rule(sim)
    out = {'probability': proba, 'similarity': sim}
    return out
```

Parámetros de Simulación.

Haz Clic para ver el Código

```{python}
# Ejemplares de la clase A
class_a  = np.array([[1, 1, 1, 1], [1, 1, 1, 0], 
                    [0, 0, 0 , 1]])
# Ejemplares de la clase B
class_b  = np.array([[0, 0, 0, 0], [0, 0, 1, 1],
                    [1, 1, 0, 0]])

# ítem de prueba
test = np.array([0, 1, 0, 1])

# Creamos DataFrames para visualizar las clases
df_clas_a = pd.DataFrame(class_a, columns= ['shape','size', 'color', 'position'])
df_clas_a.index = ['item 1', 'item 2', 'item 3']
df_clas_b = pd.DataFrame(class_b, columns= ['shape','size', 'color', 'position'])
df_clas_b.index = ['item 1', 'item 2', 'item 3']

# Vemos los DataFrame
print(df_clas_a)
print(df_clas_b)

#Se crea la lista con las clases
clases = [class_a, class_b]
m = 0.3
```

        shape  size  color  position
item 1      1     1      1         1
item 2      1     1      1         0
item 3      0     0      0         1
        shape  size  color  position
item 1      0     0      0         0
item 2      0     0      1         1
item 3      1     1      0         0

Resultado.

Haz Clic para ver el Código

```{python}
# Corremos la simulación
exp = contex_model(x = clases, y = test, m = m)
print(exp)
```

{'probability': [0.61, 0.39], 'similarity': [0.417, 0.27]}