El aprendizaje de pesos en una máquina de Boltzmann

Question

Estoy tratando de entender cómo Boltzmann máquinas de trabajo, pero no estoy muy seguro de cómo pesos son aprendidas, y no he sido capaz de encontrar una descripción clara. Es la respuesta correcta? (También, los punteros a cualquier máquina de Boltzmann explicaciones también sería genial.)

Tenemos un conjunto visible de unidades (p. ej., correspondiente a negro/blanco píxeles en una imagen) y un conjunto de unidades ocultas. Los pesos se inicializan de alguna manera (por ejemplo, el uniforme de [-0.5, 0.5]) y, a continuación, que se alternan entre las siguientes dos fases, hasta que alguna de detener la regla se alcanza:

1. Sujeta fase En esta fase, todos los valores de la visible unidades son fijos, por lo que sólo la actualización de los estados de las unidades ocultas (de acuerdo a la Boltzmann estocástico de activación de la regla). Actualizamos hasta que la red ha alcanzado el equilibrio. Una vez que alcance el equilibrio, seguimos actualizando $N$ veces más (para algunos predefinidos $N$), seguimiento de la media de $x_i x_j$ (donde $x_i, x_j$ son los estados de los nodos de $i$$j$). Después de los $N$ equilibrio actualizaciones, actualizamos $w_ij = w_ij + \frac{1}{C} Average(x_i x_j)$ donde $C$ es algo de la tasa de aprendizaje. (O, en lugar de hacer una actualización por lotes al final, hacemos la actualización después de que nos equilibrio de paso?)

2. Libre de fase En esta fase, los estados de todas las unidades están actualizados. Una vez que alcance el equilibrio, hemos igualmente de continuar actualizando N' de veces más, pero en lugar de añadir las correlaciones al final, le restamos: $w_{ij} = w_{ij} - \frac{1}{C} Average(x_i x_j)$.

Así que mis preguntas principales son:

1. Cuando estamos en la sujeta fase, ¿tenemos que restablecer el visible unidades a uno de los patrones que queremos aprender (con cierta frecuencia que representa la importancia de que el patrón), o hemos de dejar visible de unidades en el estado en que se encontraban al final de la fase libre?

2. Hacemos un lote de actualización de los pesos al final de cada fase, o la actualización de las ponderaciones en cada paso equilibrio en la fase? (O, lo que es de uno, bien?)

Answer 1

Intuitivamente, podemos pensar visible unidades como "lo que el modelo se ve" y unidades ocultos "modelo del estado de la mente". Cuando se establece todo lo visible unidades para algunos valores, que "muestran los datos para el modelo". Luego, al activar unidades ocultos, el modelo se ajusta a su estado de ánimo a lo que ve.

Lo siguiente que vamos el modelo de van gratis y fantasear. Se convertirá en salir y, literalmente, ver algunas de las cosas que la mente genera, y generar nuevos estados de la mente a partir de esas imágenes.

Lo hacemos mediante el ajuste de los pesos (y prejuicios) es la de realizar el modelo de creer más en los datos y menos en su propia fantasías. De esta manera después de algún entrenamiento va a creer en algunos de ellos (con suerte) muy buen modelo de datos, y podemos, por ejemplo, preguntar: "¿usted cree que en este par (X,Y)? ¿Qué probabilidad se encuentra? ¿Cuál es tu opinión de mr. Boltzmann De La Máquina?"

Finalmente aquí está una breve descripción de la Energía Basado en Modelos, que debería dar alguna intuición ¿dónde se fija y Libre de fases y como queremos ejecutar.

http://deeplearning.net/tutorial/rbm.html#energy-based-models-ebm

Es divertido ver que los intuitivamente claras reglas de actualización de salir formulario de derivación de la log-verosimilitud de la generación de datos por el modelo.

Con estas ideas en mente ahora es más fácil responder a tus preguntas:

1. Tenemos que restablecer el visible unidades a algunos datos que nos gustaría que el modelo de creer. Si utilizamos los valores de la final de la fase libre se acaba de seguir fantaseando, de fin de cumplir las propias creencias equivocadas.

2. Es mejor hacer las actualizaciones después del final de la fase. Sobre todo si es sujeta de fase, es mejor dar el modelo de tiempo para "centrarse" en los datos. Las actualizaciones anteriores, se ralentizará la convergencia, como se hacen cumplir las conexiones cuando el modelo no se ha ajustado es el estado de la mente a la realidad y a la vez. Actualización el peso después de cada paso equilibrio, mientras que las fantasías deben ser menos perjudiciales, aunque yo no tengo experiencia con eso.

Si usted desea mejorar su intuición sobre la EBM, el BM, y la gestión por resultados, te aconsejo ver a algunos de Geoffrey Hinton las conferencias sobre el tema, él tiene algunas buenas analogías.

Answer 2

1. Sí, "nos reset (clamp) visible de unidades a uno de los patrones que queremos aprender (con cierta frecuencia que representa la importancia de que el patrón)."

2. Sí, "hacemos un lote de actualización de los pesos al final de cada fase." No creo que la actualización de los pesos en cada paso equilibrio en la fase de" conducirá a la convergencia rápida debido a que la red "se distrae" por instantáneo de errores - me han implementado Boltzmann máquinas de esa manera, y recuerdo que no funciona muy bien hasta que me cambiaron a una actualización por lotes.

Answer 3

Aquí se muestra el código de Python para Boltzmann Máquinas basadas en Pablo Ivanov del código de

http://redwood.berkeley.edu/wiki/VS265:_Homework_assignments

import numpy as np

def extract_patches(im,SZ,n):
    imsize,imsize=im.shape;
    X=np.zeros((n,SZ**2),dtype=np.int8);
    startsx= np.random.randint(imsize-SZ,size=n)
    startsy=np.random.randint(imsize-SZ,size=n)
    for i,stx,sty in zip(xrange(n), startsx,startsy):
        P=im[sty:sty+SZ, stx:stx+SZ];
        X[i]=2*P.flat[:]-1;
    return X.T

def sample(T,b,n,num_init_samples):
    """
    sample.m - sample states from model distribution

    function S = sample(T,b,n, num_init_samples)

    T:                weight matrix
    b:                bias
    n:                number of samples
    num_init_samples: number of initial Gibbs sweeps
    """
    N=T.shape[0]

    # initialize state vector for sampling
    s=2*(np.random.rand(N)<sigmoid(b))-1

    for k in xrange(num_init_samples):
        s=draw(s,T,b)

    # sample states
    S=np.zeros((N,n))
    S[:,0]=s
    for i in xrange(1,n):
        S[:,i]=draw(S[:,i-1],T,b)

    return S

def sigmoid(u):
    """
    sigmoid.m - sigmoid function

    function s = sigmoid(u)
    """
    return 1./(1.+np.exp(-u));

def draw(Sin,T,b):
    """
    draw.m - perform single Gibbs sweep to draw a sample from distribution

    function S = draw(Sin,T,b)

    Sin:      initial state
    T:        weight matrix
    b:        bias
    """
    N=Sin.shape[0]
    S=Sin.copy()
    rand = np.random.rand(N,1)
    for i in xrange(N):
        h=np.dot(T[i,:],S)+b[i];
        S[i]=2*(rand[i]<sigmoid(h))-1;

    return S

def run(im, T=None, b=None, display=True,N=4,num_trials=100,batch_size=100,num_init_samples=10,eta=0.1):
    SZ=np.sqrt(N);
    if T is None: T=np.zeros((N,N)); # weight matrix
    if b is None: b=np.zeros(N); # bias

    for t in xrange(num_trials):
        print t, num_trials
        # data statistics (clamped)
        X=extract_patches(im,SZ,batch_size).astype(np.float);
        R_data=np.dot(X,X.T)/batch_size;
        mu_data=X.mean(1);

        # prior statistics (unclamped)
        S=sample(T,b,batch_size,num_init_samples);
        R_prior=np.dot(S,S.T)/batch_size;
        mu_prior=S.mean(1);

        # update params
        deltaT=eta*(R_data - R_prior);
        T=T+deltaT;

        deltab=eta*(mu_data - mu_prior);
        b=b+deltab;


    return T, b

if __name__ == "__main__": 
    A = np.array([\
    [0.,1.,1.,0],
    [1.,1.,0, 0],
    [1.,1.,1.,0],
    [0, 1.,1.,1.],
    [0, 0, 1.,0]
    ])
    T,b = run(A,display=False)
    print T
    print b

Funciona mediante la creación de parches de datos, pero esto puede ser modificado de modo que el código funciona en todos los datos todo el tiempo.