Cristobal Eyzaguirre

Differentiable Adaptive Computation Time for Visual Reasoning (CVPR 2020)

Sat, 25 Apr 2020 00:00:00 +0000

(if answer is ready: stop wasting computation)

On tasks where the complexity needed to answer varies it makes intuitive sense that model complexity should vary accordingly. The ability to adaptively allocate more resources to difficult tasks is one that all humans possess and is evident in the increased requirements needed for complex mathematics compared to simple everyday tasks. This post introduces DACT [0], a new algorithm for achieving adaptive computation time that, unlike existing approaches, is fully differentiable. We put it to the test on Visual Reasoning datasets and find that our models learns to actively adapt their architectures according, balancing high accuracy with as-little-as-possible computation.

LINK TO ARXIV [0]

LINK TO CODE

The Setting: Visual Question Answering


How many balls is the kid holding?		How many birds is he holding?

Visual Question Answering (VQA) [1] is a task where, for a given input image, question pair, we expect the model to return an answer. The difficulty of the task lies in the openness for both the question and image: because any image or plain-text question are valid expecting the model to output convincing answers can be seen as a more general Turing-test. These datasets pose challenging natural language questions about images whose solution requires the use of perceptual abilities, such as recognizing objects or attributes, identifying spatial relations, or implementing high-level capabilities like counting. For example, in the images above we see examples of two very similar (counting) questions for images from the Visual Genome dataset [2] that necessitate a broad understanding of the relation holding and a general purpose counting algorithm.


Examples of questions in the CLEVR dataset that show a significant variation in the number of reasoning steps that are needed to answer them correctly.

In open tasks such as this we find that instances entail diverse levels of complexity as both questions and images can be arbitrarily simple or difficult. Two examples from the CLEVR dataset [3] are shown above. Even in the very restricted subset of all possible images and questions included in this dataset (vocabulary of 28 words, generated images of the same objects) we find significant variation in complexity. Specifically, while the question of the first example involves just the identification of a specific attribute from a specific object, the second question requires the identification and comparative analysis of several attributes from several objects. We argue that dealing with this openness is paramount for more general intelligence and propose Adaptive Computation Time algorithms such as ACT [4] as possible solutions.

Existing Adaptive Approaches

1. Modular Networks


Specialized Modules		General Purpose Module

We consider modular networks those where modules are combined from a collection processing modules. Here we distinguish between two kinds:

those in which a controller selects the appropriate specialized module (eg. IEP [5] show in figure).
those where a single general purpose module is used repeatedly for a fixed number of times (eg. MAC [6] shown in figure).

Only the case of specialized modules is adaptive, but the generation of the sequences requires costly supervision or elaborate reinforcement learning training schemes.

The second case (general purpose modules) always executes the same module a fixed number of times, so no module selection training is needed. However, this approach is not adaptive as the processing pipeline is always the same. In our work, we build upon one of these networks by using DACT to adaptively select the horizon of the computational pipeline (instead of having it as a fixed hyper-parameter).

2. ACT

An algorithm for adaptive computation in neural networks already existed: ACT. I’ve already written a detailed explanation of how and why it works in a previous post, but the TLDR is that it works by forcing that the weights used to combine each step’s output into the final answer sum exactly one. To achieve this a non-differentiable piecewise function is used, namely: if the sum of the weights is more than one, then change the last weight so that the sum is exactly one. It has seen some success reducing computation in computer vision and natural language processing problems. However, we found that its theoretical shortcomings limited its usefulness for Visual Reasoning tasks (see Results), so we proposed a novel fully-differentiable algorithm.

How it works


The final answer Y is built up from the sub-answers from each module. The maximum contribution of any one of these steps is limited by all earlier ones, and any step can choose to limit contribution of subsequent ones.

DACT was formulated as a differentiable alternative to ACT. In other words, it was designed to provide a means by which a model can halt computation without adding noise to the gradients.

Our formulation can be applied to any model or ensemble that can be decomposed as a series of modules or submodels $m_n$, $n ∈ [1,…,N]$ that can be ordered by complexity. For example, recurrent networks are composed by iterative steps, CNNs by residual blocks, and ensembles by smaller models. We refer to the composition as our final model or ensemble $M$, and to its output as $Y$. This work focusses on its application to a recurrent visual reasoning architecture called MAC.

The core of the DACT algorithm is that any step can limit the total contribution of subsequent steps. To achieve this we use the sigmoidal halting values $h_n \in \left] 0, 1 \right[ $ to inductively define $p_n$ as:

\[p_n = \prod_{i=1}^{n}h_{i} = h_{n} p_{n-1}\]

We observe that $p_n$ is monotonically decreasing for increasing values of $n$. Through their halting values each $n$th step can choose to either maintain the probability ($h_n \approx 1$) or reduce it ($h_n < 1$). The value of $p_n$ can be interpreted as the probability that a subsequent step might change the value of the final answer. Consequently, we define the initial value $p_0 = 1$.

The final answer $Y$ is built incrementally using the sub-answers of each step using accumulator variables $a_n$ for $n \in [1 \dots N]$ such that $Y = a_N$:

\[a_n = \begin{cases} \overrightarrow{0} & \text{if } n=0\\ y_n p_{n-1} + a_{n-1} \left( 1 - p_{n-1} \right) & \text{otherwise} \end{cases}\]

It follows from this definition that $Y$ can always be rewritten as a weighted sum of intermediate outputs $y_n$. The relative relevance of each $y_n$ to the final output is thus constrained by $p_{n-1}$ which in turn is constrained by the $h_n$s of earlier steps.

We observe that this means that, for some step $n$ with low associated $p_n$, then $a_n \approx Y$.

Putting it all together…

During evaluation / test we want to identify the step where $a_n \approx Y$ to halt computation. How you choose to define $\approx$ in your code depends on you and the use-case. For this work we say that $a_n$ is similar enough to $Y$ once we are sure that the class with highest probability in $a_n$ is the same as in $Y$.

N = max_steps
for n in [1 ... N]:
    # run another step
    answer = run_module()

    if not answer_can_change():
        break

We say that the answer cannot change when the top class in $a_n$ will necessarily be the same as in $Y$ after all $d = N - n$ remaining steps. In particular, we are interested in checking if it’s possible that the probability associated to the runner up (second best) class $c^{ru}$ can surpass that of the top class ($c^*$).

def answer_can_change():
    d = N - n

    # get top and runner-up classes
    c_star = get_max_class(answer)
    c_ru = get_ru_class(answer)

    # check if answer cant change
    if min_p(c_star, d) >= max_p(c_ru, d):
        return False
    else:
        return True

The top answer is most likely to change if all $d$ remaining steps assign probability $0$ to $c^*$ and $1$ to $c^{ru}$. This scenario is the worst case from the perspective of the stability of the answer as it leads to the minimum value that the probability of class $c^*$ can take in $Y$; along with the maximum value for $c^{ru}$.

Then, after expanding the inductive definition of $a_n$ and replacing the worst-case probabilities we derive a lower bound for the probability of the class $c^*$ in $Y$:

\[\Pr(c^*, N) \geq \Pr(c^*, n)(1-p_n)^d\]

And an upper bound to the probability of the runner-up class $c^{ru}$:

\[\Pr(c^{ru}, N) \leq \Pr(c^{ru}, n) + p_n d\]

Therefore during inference we can safely cut computation once we identify a step $n$ such that we know for sure that the top classes in $a_n$ and $Y$ are the same. Mathematically, this means the halting condition is achieved when:

\[\Pr(c^*, n)(1-p_n)^d \geq \Pr(c^{ru}, n) + p_n d\]

(The math and some additional proofs are included in the paper.)

Finally, we add $\rho = \sum_{n=1}^{N} p_n$, a proxy of the total computation, to the loss function to encourage reduced computation:

\[\hat{L} (x, y) = L (x, y) + \tau \rho(x)\]

Results: CLEVR

1. Better accuracy in fewer steps


Scatterplot of computation (in steps) vs. precision. DACT-MACs shown in color; MACs as diamonds; ACT-MACs as crosses.		Learning curves for different regularization ( 𝜏 ponder cost) values show mean and variance of three runs.

As the scatterplot above shows, DACT enabled MACs (in color) consistently outperform vanilla MACs (shown as diamonds) when both use comparable average numbers of steps. ACT on the other hand only performs as well or bellow as comparable MACs. Additionally, the figure shows that DACT responds predictably to changes in the penalty or ponder cost $\tau$ used (represented by the color), iterating fewer times when more penalty is used. This again contrasts with ACT which proved to be insensitive to the ponder cost. For instance, ACT without ponder cost ($\tau$ = 0.0) performs 3.2 steps on average and obtains an accuracy of 95.8%.

2. Increased adaptability to changes in question difficulty


How many steps are used by adaptive MACs for each question family in the CLEVR dataset. ACT-MACs in a); DACT-MACs shown in b) and c).

The motivation behind using adaptive algorithms for this task is to use less computation for the more straightforward questions while still being able to use more computation for difficult ones. In the figure above a) shows the existing algorithm (ACT) failing to learn how to answer the most straightforward questions in less than three steps, or the hardest in more than five. The other two images show DACT using most of the available spectrum, showing that DACT enabled MACs are capable of actively allocating more computational resources to questions that need them. The second image b) shows a variant of DACT that averages approximately the same number of steps as a), while c) shows a DACT-MAC with lower ponder cost, which uses 50% more reasoning steps on average and thus achieves even better performance.

The figure shows questions clustered by family type which translates to groups that require similar step sequences to solve. The fact that DACT shows a remarkable correlation between computation and question family despite not including any type of supervision about these factors evinces the learning of meaningful patterns that correlate with question complexity. The full heatmap that shows an example for each question family can be found here.

3. Interpretability gains


Visual and linguistic attention maps for both regular MAC (left) and DACT-MAC (right).

Besides the obvious and substantial reduction in the number of steps used to answer, our model also contributes to the overall interpretability of the inference. This is achieved by adding a proxy of the number of steps taken to the loss function, effectively coercing the model into only using fewer (and therefore more likely to be semantically strong) steps. This translates into more interpretable models. For instance, the question attentions above show that the last two steps are similar for both models, but that only one of the other ten steps used by MAC was necessary.

Additionally, the values of $p_n$ and the sub answers $a_n$ provide further insights.

Bonus Results: GQA

Finally, in order to evaluate the generality of the suggested approach to real data, we evaluate the combined DACT-MAC architecture on the more diverse images and questions in the GQA dataset [7].

Method	Ponder Cost	Steps	Accuracy
MAC+Gate	NA	2	77.51
MAC+Gate	NA	3	77.52
MAC+Gate	NA	4	77.52
MAC+Gate	NA	5	77.36
MAC+Gate	NA	6	77.37
ACT	1e-2	1.99	77.17
ACT	1e-3	2.26	77.04
ACT	1e-4	2.31	77.21
ACT	0	2.15	77.20
DACT	5e-2	1.63	77.23
DACT	1e-2	2.77	77.26
DACT	5e-3	3.05	77.35
DACT	1e-3	3.69	77.31

We find that increasing computational steps doesn’t benefit the chosen architecture (MAC), and therefore adapting computation won’t increase performance. However, by adding DACT to a pre-trained 4-step MAC and then fine-tuning we find that it again outperforms the existing algorithm in terms of accuracy and responsiveness to ponder cost.


How many steps are used by DACT-MACs for each question type in the GQA dataset.

Additionally, we find that DACT-MACs adapt the 4-step algorithm reducing computation on some question types, and that the number of steps again correlate strongly with question types as can be seen in the heatmaps above. The same figures also show how the architecture adapts to changes in the ponder cost, as this penalty decreases DACT adaptively allocates more resources to more complex questions. The full heatmap that shows the question types can be found here.

Future Work Ideas (!)

A few lines for future work:

using adaptive computation to generate curriculums for curriculum learning.
using different halting conditions with DACT.
taking advantage of DACT’s differentiability to use non-linear functions of computation (eg. exponential ponder penalties).
applying DACT to other models and datasets. I’m particularly interested in using it on neural state machines [8] for real adaptive behavior on GQA.

Cite

@article{Eyzaguirre2020DifferentiableAC,
  title={Differentiable Adaptive Computation Time for Visual Reasoning},
  author={Cristobal Eyzaguirre and A. Soto},
  journal={2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
  year={2020},
  pages={12814-12822}
}

Modelación Linear Discreta

Sun, 21 Apr 2019 00:00:00 +0000

Parte dos de la guia para estudiar la materia del curso ICS1113 Optimización (curso de la Pontificia Universidad Católica de Chile). Faltan algunos.

Técnica 1: Formular restricciones usando lógica proposicional y luego traducir.

$i \rightarrow j$ lo reescribimos como $i \leq j$.
$\neg i$ lo reescribimos como $1 - i$.
un $\lor$ a la izquierda divide en dos condiciones: $i \lor j \rightarrow k$ se reescribe como $i \leq k$ y $j \leq k$.
un $\land$ a la izquierda: $i \land j \rightarrow k$ se reescribe como $i + j \leq k + 1$

Técnica 2: Para restricciones condicionadas.

$ax \leq b $ cuando $y$ se escribe: $ax \leq b + m(1-y)$. Donde m es un valor muy grande, así tenemos que cuando $y=0$ la restricción funciona como si fuera un $ax \leq b + \infty = \infty$ que siempre se cumple.

$ax \geq b $ cuando $y$ se escribe: $ax \geq b - m(1-y)$.

Ejemplo para $y \in \{0, 1\}$:

\[\begin{cases} ax_i \leq b \qquad \text{cuando } y = 1\\ ax_i \geq b \qquad \text{eoc.} \end{cases}\]

Queda:

\[ax_i \leq b + m(1-y)\] \[ax_i \geq b - m(y)\]

Técnica 3: Para funciones por partes.

si queremos modelar $y = \begin{cases} ax + b \qquad \text{cuando } x \leq k\\ cx + d \qquad \text{eoc.} \end{cases}$

Defino variables:

\[x_1 = \begin{cases} x \qquad \text{cuando } x \leq k\\ 0 \qquad \text{eoc.} \end{cases}\] \[x_2 = \begin{cases} x \qquad \text{cuando } x \geq k + 1\\ 0 \qquad \text{eoc.} \end{cases}\] \[w_1 = \begin{cases} 1 \qquad \text{cuando } x \leq k\\ 0 \qquad \text{eoc.} \end{cases}\] \[w_2 = \begin{cases} 1 \qquad \text{cuando } x \geq k + 1\\ 0 \qquad \text{eoc.} \end{cases}\]

Las restricciones son:

\[y = (ax_1 + bw_1) + (cx_2 + dw_2)\] \[x_1 \leq k w_1\] \[x_2 \geq (k + 1) w_2\] \[x = x_1 + x_2\] \[1 = w_1 + w_2\]

Problema de seleccionar: Knapsack

Llevar el producto $i$ me aporta $p_i$ dolares y me cuesta $w_i$. Tengo un total de $W$ dolares. Maxmimizar el precio de los productos que llevo.

Defino $x_i = \begin{cases} 1 \qquad \text{cuando llevo producto } i\\ 0 \qquad \text{eoc.} \end{cases}$

\[\max \sum_i x_i p_i\]

s.a.

\[\sum_i x_i w_i \leq W\]

Problema con costos fijos: Producción e inventario con costos fijos 1

El mismo problema de producción e inventario (ver publicación pasada), pero si uso maquina en $t$ tengo un costo adicional $k^t$ (o sea, si produzco algo, tengo costo fijo).

Primero, como es un problema de producción e inventario defino $x_i^t$ como la cantidad de $i$ que produzco en $t$, y $y_i^t$ como hay almacenado de $i$ en $t$.

Defino $w^t = \begin{cases} 1 \qquad \text{usé la maquina en } t\\ 0 \qquad \text{eoc.} \end{cases}$

\[\min \sum_i\sum_t x_i^tc_i^t + y_i^th_i^t + w^tt k^tt\]

s.a.

\[\sum_i x_i^t \leq 0 + mw^t\]

Obtenemos esta restricción usando la técnica 2. Vemos que sólo si se prende la maquina ($w^t = 1$) podemos producir.

\[y_i^{t-1} + x_i^t = y_i^t + d_i^t \qquad \forall i,t\] \[x_{i}^t,y_i^t \geq 0 \qquad \forall i,t\]

Problema con costos fijos y continuidad: Producción e inventario con costos fijos 2

Imaginemos ahora que en el problema anterior no hay costo fijo si la maquina estuvo prendida en $t-1$ (ej. no es necesario prenderla).

Defino $z^t = \begin{cases} 1 \qquad \text{encendí la maquina en } t\\ 0 \qquad \text{eoc.} \end{cases}$

Son las mismas restricciones que las de arriba, sólo agrego:

\[z_t \geq w^t - w^{t-1}\]

Problemas de subdivision/asignación: Coloring

2 nodos en un grafo no pueden tener el mismo color si están conectados ($C_i$ son los nodos conectados con $i$). Minimice la cantidad de colores usados.

Defino $x_{ik} = \begin{cases} 1 \qquad \text{cuando nodo } i \text{ es de color } k\\ 0 \qquad \text{eoc.} \end{cases}$

Defino $y_{k} = \begin{cases} 1 \qquad \text{cuando uso color } k \\ 0 \qquad \text{eoc.} \end{cases}$

\[\min \sum_k y_k\]

s.a.

Todos los nodos con un color: $\qquad \sum_k x_{ik} = 1 \qquad \forall i$

Si uso un color se activa $y_k$: $\qquad \sum_i x_{ik} \leq 0 + My_k \qquad \forall k$

$x_{i,k} \rightarrow \neg x_{j, k}$ para nodos conectados: $\qquad x_{ik} \leq 1- x{jk} \qquad \forall i, k, \forall j \in C_i$

Modelación Linear Continua

Sun, 21 Apr 2019 00:00:00 +0000

Esta guía la cree para mi mismo y el resto de los humanos hispano-hablantes luego de no encontrar una buena fuente para estudiar la materia del curso ICS1113 Optimización (curso de la Pontificia Universidad Católica de Chile). En ramos como este hay unas pocas “herramientas” que debemos saber usar, combinándolas para lograr modelar el problema. Consideré una cantidad extensiva de ejercicios resueltos e intenté destilar en cada uno las técnicas requeridas para resolverlo, luego, definí otro problema de optimización linear mínimo que necesite de la técnica.

Problema básico con restricciones: Movimiento de petroleo

Hay $i$ tipos de petroleo con distintos costos $c_i$ por cada litro de $i$ comprado, y con pesos diferentes $p_i$ por cada litro de $i$. Quiero maximizar mis ganancias, pero sujeto a que la suma de los pesos no puede ser mayor a mi capacidad.

Defino $x_i$ como cuántos litros de $i$ compro.

\[\max \sum_i c_i x_i\]

s.a.

\[\sum_i p_i x_i \leq capacidad\] \[x_i \geq 0 \qquad \forall i\]

Problema con condiciones: Donantes de sangre

Hay $n$ personas de las que algunas pueden recibir sangre de tipo $i$ y otras no. Diremos que las personas con sangre $i$ pueden donar a personas $j$ si $d_{ij} = 1$ y $d_{ij} = 0$ si no pueden hacerlo. El porcentaje de personas con sangre de tipo $i$ es $p_i$. El costo por un litro de sangre $i$ es $c_i$. Si tengo que comprar $n$ litros, minimice los costos pero manteniendo haya un litro para cada persona (comprar n litros).

Defino $x_{ij}$ como la cantidad de litros de $i$ que compro para $j$.

\[\min \sum_i c_i x_i\]

s.a.

\[\sum_j d_{ij} x_{ij} = n p_i \qquad \forall i\] \[x_{ij} \geq 0 \qquad \forall i, j\]

Problema con combinaciones: Combos

Una empresa tiene 3 productos con precios $y_i$ y costo $c_i$. Los productos se venden individualmente o en “paquetes” (tengo sus precios y costos). Maximice ingresos (precio - costo).

Defino $x_j$ como el número de ofertas del servicio, y considero los productos individualemente y en paquetes como servicios distintos. Luego, tengo y posibles servicios que ofrecer.

\[\max \sum_j x_j (y_j - c_j)\]

Donde $y_j$ y $c_j$ son los precios/costos individuales cuando el servicio solo contiene un producto, y los precios/costos de los paquetes cuando corresponde.

s.a.

\[x_{j} \geq 0 \qquad \forall j\]

Problema con relajación de restricción: Maquinas con sobre-tiempo

Maquina produce 5 uds. del producto 1 (que se vende a \$10) o 8 uds. del producto 2 cada hora (se vende a \$12). Maquina funciona 8 horas diarias pero puede excederse pagando un costo adicional de \$5 cada hora. Maximizar ingresos.

Definimos $x_i$ como el número de productos de tipo $i$ que producimos.

Definimos $y$ como la cantidad de horas extra trabajadas (nuestro término de relajacion).

\[\max 10x_1 + 12x_2 - 5y\]

s.a.

\[\frac{x_1}{5} + \frac{x_2}{8} \leq 8 + y\] \[x_{i}, y \geq 0 \qquad \forall i\]

Problema con inventario

Comienzo con 1000 unidades en la bodega. Conozco la demanda (será $d_j^t$ en lugar $j$ en el tiempo $t$), y debo satisfacerla. El máximo número de unidades de que puedo transportar en $t$ es $L^t$ , y el costo por unidad trasportada es $c_j^t$.

Defino $x_j^t$ como el número de unidades transportadas a $j$ en tiempo $t$.

Defino $A^t$ como la cantidad de unidades en bodega en el tiempo $t$.

\[\min \sum_j \sum_t c_j^t x_j^t\]

s.a.

\[\qquad A^0 = 1000\]

Conservación de flujo: $\qquad A^{t-1} = A^t + \sum_j x_j^t \qquad \forall t$

\[\sum_j x_j^t \leq L^t \qquad \forall t\] \[x_{j}^t \geq 0 \qquad \forall j, t\]

Problema de tareas con prerequisitos: Planificación proyecto

La tarea $i \in P$ ($P$ es conjunto de tareas) no puede hacerse antes que ninguna de las tareas en el subconjunto de $P$, $P_i$. Cada tarea $i$ demora un tiempo fijo $t_i$. Minimice el tiempo en hacer todas las tareas.

Definimos $x_i$ como el instante en que se comienza la tarea $i$. Definimos $z$ como el tiempo de término de la última tarea (el tiempo que es mayor a todos los otros tiempos $\rightarrow$ máximo).

\[\min z\]

s.a.

\[z \geq x_i + t_i \qquad \forall i\] \[x_i \geq x_j + t_j \qquad \forall i, \forall j \in P_i\] \[x_{i} \geq 0 \qquad \forall i\]

Producción e inventario con vencimiento

Produczo producto $i$ con costo unitario $c_i^t$ en tiempo $t$. Tengo bodegas en las que puedo almacenar los productos (con costo $h_i^t$), pero ojo que los productos vencen luego de $q_i$ dias… Minimizar costos de satisfacer la demanda $d_i^t$.

Primero, como es un problema de producción e inventario defino $x_i^t$ como la cantidad de $i$ que produzco en $t$, y $y_i^t$ como hay almacenado de $i$ en $t$. Defino cuanto boto del producto $i$ en $t$ como $w_i^t$.

\[\min \sum_i\sum_t x_i^t c_i^t + y_i^th_i^t\]

s.a.

\[y_i^{t-1} + x_i^t = y_i^t + d_i^t + w_i^t \qquad \forall i,t\] \[w_i^t \geq \sum_{r=1}^{t-q_i}x_i^r - \sum_{r=1}^t d_i^r - \sum_{r=1}^{t-1} w_i^t \qquad \forall i,t\]

Es decir, en $t$ debo botar al menos tantos productos $i$ como aquellos que he producido que ya han vencido (producidos hace $q_i$ dias o más), sin contar los que vendí y los que ya boté.

\[x_{i}^t,y_i^t, w_i^t \geq 0 \qquad \forall i,t\] \[y_i^0 = 0 \qquad \forall i\]

PyTorch (1.0), CUDA & cuDNN on MacOS

Tue, 02 Apr 2019 00:00:00 +0000

This guide was written primarily for my own future use and the methods described have only been tested with my own late 2013 15” Macbook Pro with Nvidia 750m graphics. Nonetheless, the guide is written in english so as to be useful for many people (although my mother tongue is spanish). The guide is based on what was published on this google group for AllenNLP, completing the information there and updating commands where useful.

Prerequisites

CUDA and cuDNN are used to speed up matrix operations and other operations that are tipically useful for machine learning algorithms. Macs have not shipped with nVidia graphics cards since 2013 and it can be difficult to find updated drivers and cuDNN libraries that are compatible with your nVidia graphics card.

Not all graphics cards are compatible with CUDA, here is a list of those compatible; you need compute capability $\geq$ 3.0 in order to follow the guide.

CUDA drivers

The first step is to update your CUDA drivers. I found this post where updated drivers can be found for MacOS versions up to 10.13.6 (most recent version when the post was written). cuDNN requires driver version 378.05 or higher. While the original guide this post is based on didn´t have access to those drivers I found those listed above and can confirm they work.

CUDA toolkit

The next step is to install CUDA toolkit form here. Select MacOS as the target OS and install the .dmg. This will install CUDA $\geq$ 10.1 on your local machine. Follow the onscreen prompts.

Compatible clang/Xcode version

The original post sugests installing Xcode 8.3.3 in order to get a compatible clang compiler. On their site nVidia says Xcode 10.1 (10B61) is compatible with MacOS 10.13.6 and CUDA 10.1. Personally I followed the instructions here to install the older version of Xcode after having problems in a later step. However the problems were unrelated to the clang version and although I didnt test Xcode 10.1, it can make sense to check here for the sugested Xcode version for the downloaded CUDA toolkit.

Older Xcode versions have to be downloaded through the Apple developer page. Searching for the version number will let you download the version you want. After downloading the version you can change the selected xcode version by running:

# first install command line tools (in case they weren't already)
xcode-select --install
# select the correct version; replace <Xcode_install_dir> with the real dir. 
sudo xcode-select -s /Applications/<Xcode_install_dir>/Contents/Developer

cuDNN

cuDNN can be found here. You will need to register as a developer (for free) in order to download. For maximum performance look for the most recent compatible version (under Dec.14); I installed cuDNN 7.0.4 for CUDA 9.0 (under Nov.13) since I was following the outdated tutorial.

The compressed file can be unziped and moved, I moved it to my home (so you will need to change some paths in the following instructions if you dont put it there).

I found I needed to export more paths than those on the original post. Run the following in your command line:

export CUDA_HOME=~/cudnn
export DYLD_LIBRARY_PATH=$CUDA_HOME/lib:$DYLD_LIBRARY_PATH
export CUDNN_LIB_DIR=$HOME/cudnn/lib
export CUDNN_INCLUDE_DIR=$HOME/cudnn/include
export LD_LIBRARY_PATH=$HOME/cudnn/lib

Pytorch Installation

On MacOS, the only way to install pytorch with CUDA support is to install from source. The pytorch repository has instructions, but they assume you use Anaconda. The following commands can be seen as a proven (be me) alternative:

# clone repository
git clone --recursive https://github.com/pytorch/pytorch
cd pytorch

# install, I use 10.13 as target because that is the version of MacOS I am running.
MACOSX_DEPLOYMENT_TARGET=10.13 CC=clang CXX=clang++ python3 setup.py install

Remove `PyTorch no longer supports this GPU because it is too old` warning

If you get this message it may be because your GPU is of CUDA compatibility 3.0 (eg. nVidia 750m). Contrary to what appears in the warning, CUDA 3.0 is supported. We can remove these warnings by going to /usr/local/lib/python3.7/site-packages/torch/cuda/__init__.py and commenting out lines 118-119. The location and line numbers can vary but the UserWarning raised indicated the file path and line. The commented lines in my distribution of pytorch (1.1.0) are as follows:

# elif capability == (3, 0) or major < 3:
  # warnings.warn(old_gpu_warn % (d, name, major, capability[1]))

Testing installation

First we test importing pytorch:

import torch
print(torch.__version__)

We check for available cuda devices and try moving a size 20 tensor to the GPU:

import torch
assert torch.cuda.is_available()
assert torch.randn(20).cuda().is_cuda

The following wont produce error messages if cuDNN is installed:

import torch
assert torch.backends.cudnn.enabled

And there you go, congratulations!

Percentage GridMap

Thu, 21 Mar 2019 00:00:00 +0000

How can we visualize the distribution of 33 categories over the whole of the USA? The webpage meetup.com hosts diferent types of events all over the world. For a class we wondered if it was posible to observe diferences in the interests between the people of diferent states. The main dificulty was that there were 33 categories to compare among 50 states, a simple barchart wouldn’t be enough as 33*50 columns is more than any one person can absorb.

The solution

We compromised. Instead of showing every minor diference among states we chose to observe tendencies. Then, a choropleth would be created to reflect these tendencies and add geographical information to the mix.

We show tendencies by dividing each state into 100 colored cells we call percentage cells. The amount of cells that are of a certain color represents the percentage of the interest of the inhabitants of the state towards the category represented by the color. By randomizing the positioning of the cels inside the state we obtain a puzle that broadly shows the main categories present in each one of the states.

We substitute the states geographical shape for one that removes surface area biases in the visualization as this only adds noise to what we want to observe. However, we maintain the general positions of the states in respect to each other so as to facilitate the detection of geographical related relations.

Finally, since the randomly positioned cells are difficult to count in order to find the exact percentage, we let the user click a state to get an easier to read visualization (a barchart) of the specific area.

Hypothesis

We hoped that the resulting visualization would enable us to detect patterns between the states by comparing their tendencies.

We found it easier to find outliers and anomalies simply by looking for states that have a diferent “average” color.
We found it was easy to find geographical tendencies. For instance, regions of the USA where there was a recognizably larger interest in Tech (shown in blue).
It’s generally easy to compare two states interest in a category by comparing the amount of cells of the desired color, and similar percentages can be distinguished after clicking each state to get the broken down percentages in the barchart.

Next steps

We didnt completely finish the project, people looking to build upon or improve should consider the following areas:

The code needs tidying up (D3.js is declaratively writen and can be dificult to read in a big project like this).
Percentages are not calculated but proxied by sampling 100 events per state and asuming the categories of these are representative of the interests per state.
There’s much need for a way to select some subset of categories to compare because as of now those most common tend to hide the rest. (++ im 99% sure no one can distinguish 33 colors).
Responsiveness: the visualization looks horrible on smaller screens.
Performance: the transitions lag on slower computers because calculations are repeated for each of many cells (100 per state).

RecSys Semana 6

Sun, 23 Sep 2018 00:00:00 +0000

Comentario: Factorization Machines

Resumen

Las máquinas de factorización son predictores generales (trabajar con cualquiera los vectores de características posibles) incluso en condiciones de datos muy sparse, todo esto teniendo complejidad lineal sobre el numero de datos y dimensiones latentes escogidas para escalar eficientemente.

Logran esto usando descomposición matricial (a un espacio de menos dimensiones) de una matriz construida específicamente para este fin como la mostrada en la siguiente imagen:

La intuición clave acá es considerar los recuadros User, Movie y Target. Cada fila representa una interacción entre un usuario y un ítem. Por ejemplo, la primera fila muestra que el usuario A (Alice) interactuó con el ítem TI (Titanic) y lo calificó con 5 puntos. La factorización de la matriz llevará columnas con interacciones similares (o cualquier patron reconocible por el modelo) a formar columnas similares en el espacio de dimensiones reducidas. Luego, el producto punto entre estas columnas similares será alto (ver mi post de la semana 2 para una explicación sobre la relación entre el producto punto de dos vectores y su distancia euclidiana). Esta relación está implícita en la ecuación del modelo mostrada a continuación donde se ve que al intentar predecir, por ejemplo, el puntaje que dará Alice al elemento Star Trek (ST) la multiplicación de $x_i = x_{Alice}$ con $x_j = x_{Star Trek}$ será la única multiplicación entre $x$ con resultado no cero, y luego la unica parte de la tercera componente de la ecuación será la similaridad entre los historiales de Alice y Star Trek.

También se pueden agregar otros elementos a la matriz (otra de las ventajas de ser predictores generales) para considerar el historial del usuario, la fecha y hora a la que consumió el elemento, etc. Incluyo una imagen con estos datos para ilustrar como se incluyen, donde aprovecho de destacar la normalización cuando hay varios elementos dentro del mismo campo (como es el caso de Other Movies Rated).

Comentarios

Tengo dos comentarios principales que hacen referencia (en ese orden) a la forma de modelar el tiempo (Time en la imagen arriba) y a la memoria necesaria para entrenar el modelo.

Primero consideremos la codificación del tiempo. EL autor convierte información rica en un contador de meses desde alguna fecha no explicada (presumiblemente la fecha que se tiene para la primera interacción). Tiene sentido que un usuario prefiera distintas películas a distintas horas o dias de la semana, meses, etc. Una mejor forma de codificar el tiempo (y compatible con el modelo en discusión) podría ser codificar el año, mes, día de la semana y momento del día. La consideración del valor que tome $w_i$ para la cada una de las columnas agregadas nos debiera mostrar la relevancia de esta variable para la predicción por lo que resulta deseable la codificación no solo para mejorar el rendimiento del modelo (pasándole información más rica) sino también aumentar su explicabilidad (y quizás hasta la confianza del usuario en el sistema si se le da acceso a esta información).

Habría sido interesante que el paper comentara sobre es si es posible paralelizar el modelo en múltiples nodos para reducir la cantidad de memoria necesaria por nodo para almacenar la matriz (que obviamente ocupa mucho mas espacio que la fomulación tradicional $R^{UxI}$). La versión original de la ecuación de modelo requiere que todos los nodos contengan la matriz $V$ (o que compartan memoria, lo que lleva a necesitar sincronizar y perder la ventaja de paralelizar), sin embargo la versión reformulada admite paralelización distribuyendo $V$ entre tantos nodos como hayan disponibles (!).

Conclusiones

Las FM son modelos potentes que aceptan gran variedad de información (que también puede ser codificada de diferentes maneras). Su flexibilidad permite codificar información de diferentes maneras y aporta algo de explicabilidad a los modelos de factorización tradicionales al incluir en $w$ una métrica de la relevancia de cada columna de $W$.

RecSys Semana 5

Sun, 16 Sep 2018 00:00:00 +0000

Comentario: Content-based recommendation systems In The adaptive web

Resumen

Los recomendadores basados en contenido recomiendan items a usuarios según la descripción del item y lo que saben del usuario. Obtener información util del contenido del item es ma fácil de minar en el caso de datos semi-estructurados (algunos campos restringidos) que para casos de datos no-estructurados (como campos de texto sin restricciones). Para generar una representación estructurada de estos datos no estructurados pueden usarse técnicas como stemming (obtener raíces de palabras) o TF-IDF para obtener un termino que indique la importancia relativa de cada termino en el texto. TF-IDF no captura el contexto de las palabras porque solo considera el numero de veces que aparece pero obtiene buenos resultados.

Los perfiles de usuario contienen la representación de los gustos de los usuarios en perfiles. Estos pueden contener un modelo de las preferencias de los usuarios o un historial de interacciones anteriores (que luego pueden ser usadas por un rule-based system). En el primer caso el modelo puede construirse con colaboración del usuario (donde cada uno declara sus preferencias), o pueden aprenderse usando clasificadores binarios (¿gusta o no gusta?).

Entre los clasificadores que sirven para determinar la preferencia de los usuarios por un cierto item estan:

Arboles de decision e inducción de reglas
Vecinos Cercanos (basado en similaridad entre elementos y otros puntuados por el usuario)
Algoritmo de Rocchio (para refinar las queries incrementalmente).
Clasificadores lineares
Naive Bayes (cualquiera de sus variantes)

Comentarios

Encontré que al paper le faltó considerar otros tipos de items para los que TF-IDF no sirve para extraer características suficientes como lo son videos o imágenes. Como sale en el texto los dos pasos principales para hacer recomendación basado en contenido es obtener representaciones del usuario y del contenido. La mayoría del contenido consumido hoy en día no es escrito por lo que se vuelve un poco irrelevante el paper para personas el 2018 (fue escrito en 2007). Aprovecho de comentar sobre aplicaciones de redes neuronales al area dado que me he informado del tema:

modelos basados en el paradigma encoder-decoder permiten obtener representaciones vectoriales del contenido independiente de la estructura de este (ej. autoencoder de imágenes).
representaciones de textos que incluyen contexto pueden ser obtenidas usando embeddings de palabras obtenidas usando GloVe, W2V, skip-thoughts entre otras. Los embeddings pueden luego ser usadas en Doc2Vec o otro modelo que use un encoder del contenido (ej. una RNN que genere resúmenes del texto debiera poder encontrar representaciones útiles de los textos).
Las técnicas de modelamiento de secuencias que son validas para texto lo son para videos (u otras secuencias), lo que permite generar representaciones de estos (se puede usar el encoder de esto).

Por ultimo quiero comentar que la razon por la que no importa para este paper que TF-IDF pierda informacion contextual es que todos los algoritmos mencionados asumen independencia entre cada dimension en el espacio de factores. Una representación que sería compatible con estos modelos sin perder tanta información contextual podría usar N-Grams para generar tokens por pares de palabras. Luego podríamos filtrar usando el IDF para eliminar las palabras (o n-gramas) que aparecen en todos los documentos.

RecSys Semana 3

Thu, 30 Aug 2018 00:00:00 +0000

Comentario: Evaluating Recommendation Systems pdf

Resumen

El escrito tiene dos partes, la primera se enfoca en como comparar sistemas recomendadores en una variedad de propiedades considerando restricciones (memoria, cpu, datos, etc). El exito de un sistema no depende unicamente de su rendimiento en metricas de accuracy sino que influyen ademas otros factores. La evaluacion y comparacion de distintos algoritmos dependera en primer lugar de la forma de validar el rendimiento de los sistemas usados de los que se discuten 3 (offline, user studies y online experiments). Se discuten primero por lo mismo.

Independiente de la forma de comparar recomendadores debe siempre comenzarse desde una hipotesis (a la que estan orientados los experimentos), se deben fijar las variables que no se quieren evaluar, la evaluacion debe medir el poder de generalizacion de los sistemas mas alla de el set de pruebas. Para los experimentos offline (usando datos recolectados previamente, barato) debemos usar datos lo mas parecidos posibles a lo que esperamos encontrar luego del deployment. Una forma de lograr esto es simulando el comportamiento de los usuarios 1) considerando solo datos previos a una fecha para predecir los usando modelos avanzados. Los user studies (evaluamos reclutando usuarios para probar sistema) permiten recolectar medidas cualitativas pero son caros y facilmente pueden contener biases debido a la eleccion de usuarios para el test o porque saben que estan siendo evaluados. Dentro de los user studies que comparan software podemos distinguir entre within (AB testing) y between (todos prueban todas las versiones). Finalmente existe la online evaluation (algunos usuarios sin saberlo estan usando version modificada) que nos permite medir directamente el rendimiento conforme los objetivos generales del sistema.

Propiedades importantes a considerar cuando se elige un recomendador:

Preferencia de los usuarios: elegir el que prefieren los usuarios considerando que algunos pueden ser mas importantes.
Exactitud en la prediccion: el mas usado pero no por ser mas exacto va a ser prferido por el usuario. Podemos usar metricas como RMSE, MAE. La prediccion apunta a encontrar items que el usuario va a consumir por lo que podemos medir exactitud comparando los items predichos por el sistema por los que sabemos que el usuario consumio y medimos usando precision (at N), recall y false positive rate. A veces el orden y cantidad de predicciones puede infuir y deben usarse metricas que lo tomen en consideracion como NDPM.
Cobertura: proporcion de items que sugiere el sistema, diversidad de ventas (medible con metricas de desigualdad), proporcion de usuarios para los que el sistema puede recomendar (segun numero y calidad de interacciones de estos) y cold start (que tan rapido empieza a ser util el sistema).
Confianza (del sistema en sus predicciones): sirven al usuario para discriminar entre las alternativas. Pueden compararse dos sistemas diferentes incluso si tienen distintas metricas de confianza comparando los resultados de c/u despues de eliminar los elementos con baja confianza.
Confianza (del usuario en el sistema): importante para que el usuario efectivamente utilice las sugerencias.
Novedad: si se sugieren elementos desconocidos (para el). Se sugiere un metodo interesante para entrenar sistemas usando offline evaluation con el fin de hacerlos mas novedosos que comentare luego. Con usuarios es trivial, basta con preguntarles (aunque cuidadose de no introducir bias).
Serendipia: que tan sorprendentes son los resultados. Notese que una pesima recomendacion seria sorprendente, por lo que debe balancearse siempre con la precision. El autor sugiere (para evaluacion ofline) evaluar esta propiedad recompensando aquellos algoritmos que sugieran elementos distintos a los consumidos (donde la distancia se calcula usando los contextos de los items, ej. distancia cosena de los tf-idf). Nuevamente usando usuarios (user studies) es trivial preguntandoles.
Diversidad: a veces al presentar una lista de elementos queremos que sean variados entre ellos (ej. al sugerir hoteles para vacaciones no queremos que todas sean del mismo lugar). Nuevamente podemos ayudarnos usando metricas de distancia para penalizar aquellos algoritmos que entreguen resultados muy similares entre si.
Utilidad(es): maximizar utilidades, sea para la empresa dueña del sistema o para el usuario.
Riesgo: en algunos casos una recomendacion puede estar asociada a un cierto riesgo (ej. acciones) y el riesgo puede ser algo positivo o negatvo dependiendo del usuario y la situacion. Se recomienda considerar la varianza al comparar dos sistemas.
Robustez: es la estabilidad del sistema a informacion falsa, o a cargas elevadas (muchos requests). Podemos simular ataques para comparar sistemas en el primer caso.
Privacidad: no revelar las preferencias del usuario.
Adaptabilidad: en situaciones donde los intereses cambian rapido (ej. noticias de ultimo momento) es importante que el sistema pueda adaptar sus sugerencias rapido. Podemos usar medidas de desigualdad (Gini, entropia) para validar los cambios en las sugerencias al variar un perfil.
Escalabilidad: que el sistema pueda trabajar con datasets grandes, crecientes. Podemos evaluar la complejidad computacional en relacion al tamaño de la BD.

Comentarios:

Mi primer y mas importante comentario es una apreciacion general sobre como el autor enfatiza las diferencias entre los distintos campos de aplicacion de sistemas recomendadores y como no se puede estandarizar una metrica porque para cada uno las necesidades (en terminos de las propiedades arriba) son distintas. Asi se plantean varios ejemplos diferentes donde podemos notar la importancia de una propiedad por encima de otras (privacidad mas importante que exactitud en algunos casos, utilidad del sistema antes de cobertura en otros, etc).

Tambien aprovecho de destacar la sub-seccion que trata sobre la significancia de los resultados usando valores p, intervalos de confianza, y como comparar resultados obtenidos paired o unpaired. Me parece relevante dado que la tendencia general es asumir que aquel sistema con mejor resultado usando una metrica es mejor, pero no se considera la probabilidad de que esa metrica favorezca a un sistema por encima de otro. Aprovecho de conectar esto al articulo de la semana 1 donde usamos el umbral inferior del intervalo de confianza para tener certeza de que la metrica usada representa efectivamente el valor real (ie, la calidad del sistema).

El paper cubre un area sorprendentemente amplia de informacion y logra estructurarla bastante bien. Por ejemplo para la mayoria de las propiedades presentadas el autor menciona formas de medirla y a veces da mas de una para considerar los distintos metodos de evaluacion. El autor logra comunicar sutiliezas de cada una de las propiedades que las hacen dificiles de evaluar y conecta estas a las características propias de datasets de diferentes fuentes (y con distintos enfoques). Ejemplo de esto es cuando sugiere una forma de construir el test set para evaluar el orden de las predicciones donde tenemos datos solo sobre si el usuario oyo una cancion entera, la adelanto, o no la oyo. Otro ejemplo que encuentro notable es la forma de construir el test set para evaluar la novedad de items presentados (penalizando por sugerir elementos que el usuario si consumio, pero en el corto plazo).

Mi unica critica es que el autor no menciona la utilidad de ensamblar modelos con enfoques a distintas propiedades para luego combinar sus resultados. Esta muy relacionado a la materia que estamos viendo actualmente en clases (modelos hibridos) dado que considera aportes de mas de un modelo. Ensamblar, por ejemplo, un modelo que maximice la exactitud de las predicciones y devuelva una lista ordenada de resultados con otro modelo que entregue un resultado novedoso seria una excelente forma de incluir un poco de novedad a las predicciones pero sin perder precision. Justamente esto es lo que hace netflix al sugerir en categorias distintas “parecido a lo que has visto” y “tambien te podria interesar”.

Se entiende que el autor no se explaye en combinaciones de propiedades (por cantidad exponencial de combinaciones que habrian) pero me habria gustado que se mencionara que para cada aplicacion puede ser importante mas de una, y que se abordara a grandes rasgos la forma de combinar varios modelos o varias metricas en una.

RecSys Semana 2

Wed, 22 Aug 2018 00:00:00 +0000

Comentario: Collaborative Filtering for Implicit Feedback Datasets, PDF

Resumen

Los sistemas recomendadores utilizan distintos tipos de input para lograr sus objetivos de mejorar la experiencia del usuario. La forma mas conveniente para el analisis de esta informacion es el feedback explicito, por lo que la mayoria de la literatura existente esta concentrada en procesar este tipo de informacion. Sin embargo, muchas veces este no esta disponible pero podemos intentar inferir las preferencias del usuario usando el mas abundante feedback implicito (ejs, historial de compras/busquedas, patrones de busqueda, movimientos del mouse). La traduccion de algoritmos pensados para que modelos feedback explicito funcionen con datos de tipo implicito puede no ser directa por varias caracteristicas:

no hay feedback negativo
el feedback implicito es inherentemente ruidoso
no puede asumirse que el valor numerico exprese preferencia, solo confianza (es mas probable que al usuario le guste algo que ha visto muchas veces).
la evaluacion puede tener caracterisiticas que necesiten medidas especiales.

Tradicionalmente se han usado modelos de vecindad (heighborhood models) para filtrado colaborativo (generalmente mejores que los content based) pero este tipo de modelos tienen una desventaja, no permiten distinguir entre preferencia y confianza (del sistema en la preferencia). Los autores toman esto en consideracion y eligen usar modelos de factores latentes (descubren caracteristicas latentes que explican los datos) en particular, SVD. Este descompone la matriz de interacciones usario-item para obtener representaciones de los usuario e items en un espacio conjunto que pueda ser utilizado para predecir si el usuario u interactura o no con el item i (binario, no cuantas veces).

Por el ruido que probablemente contengan las observaciones obtenidas con feedback implicito (clicks accidentales, etc) convendría considerar de distinto modo aquellos items en los que tenemos mayor confianza. Esto lo logran los autores penalizando en mayor medida en la funcion de perdida por errores en la prediccion de aquellos items para los que se tiene mayor confianza c_ui. Luego, para evitar overfitting utilizan terminos regularizadores forzando a que las matrices de embedding (tanto para usuarios como items) se complejizen demasiado. Por ultimo, se propone como alternatica a SGD el uso de alternating least squares como tecnica de optimizacion, para lograr que el tiempo de entrenamiento escale linealmente con el tamaño de la libreria. Efecto secundario de esto es que pueda reescribirse el modelo como uno lineal que predice la preferencia por el item i como suma de las confianzas de acciones pasadas (i') ponderadas por la similaridad entre los items i e i'. Lo anteior nos permite explicar la preferencia por el item i considerando los elementos que son similares a este para el usuario u.

Resultados

Usaron datos recolectados de cajas de television que contenian 32 millones de pares usuario-item (cuantas veces cada usuario vio cada item). Luego escalaron logaritmicamente los valores para calcular las confianzas y midieron el rendimiento del modelo usando un set de test recolectado similarmente. Como metrica para el rendimiento usan rank que considera la diferencia entre el valor observado para un par usuario-item vs. la importancia otorgada al par por el modelo.

Se comparan 3 modelos: most-popular, neighborhood based y el propio con distintas dimensionalidades para la reprenentacion en el espacio latente. Observan:

el mejor modelo es el propuesto y este mejora con numeros mayores de factores latentes.
el mejor modelo para incluir en el top 1% items que verdaderamente son interesantes para el usuario es el nuevo (incluso eliminando secuelas).

Comentarios

Negativo:

los valores de alfa y lambda (usados como ponderadores en la formula de confianza y el termino regularizador respectivamente) deben ser determinados usando prueba y error.
la metrica elegida contradice lo afirmado antes en el mismo paper (que el valor numerico indica confianza, no preferencia) diciendo “watching a program is an indication of liking it”. Sin embargo, se entiende que requieren una metrica para comparar y el par puede servir como proxy (aunque no optimo).

Positivo:

Se valida la eleccion de incluir la confianza en la funcion de perdida probando otras funciones que no la incluyen.
Se valida la conversion de pares user-item views en p_i (booleano que indica si usuario u vio item i sin considerar cuantas veces).

Comentario: Matrix Factorization Techniques For Recommender Systems

Resumen

Se comienza haciendo un resumen de distintos metodos utilizados en sistemas recomendadores que no incluyo dado que se parece bastante al survey en mi post anterior (link). A grandes rasgos introduce el concepto y diferencia entre sistemas basados en filtrado por contenido y aquellos que lo hacen con filtrado colaborativo. Tambien nombra como principales areas en el filtrado colaborativo aquellas que comparan vecindades y la mas enfocada en extraccion de representaciones ricas en un nuevo espacio, enfocandose en esta ultima area, particularmente en metodos de factorizacion de matrices.

En mapear usuarios e items a espacios conjuntos se buscan matrices de embedding p y q (para usuarios e items respectivamente) tal que el producto interno $p_u q_i$ devuelva el rating estimado. Una forma de obtener estas matrices resulta de obtener la representacion SVD (singular value descomposition) de la matriz de interacciones usuario-item (preocupandose de imputar los valores faltantes o bien regularizar los embeddings obtenidos para considerar la sparseness de la conjunta). El entrenamiento para obtener los valores en p y q pueden obtenerse usando SGD para minimizar la funcion de perdida regularizada. De otra manera puede usarse ALS (alternating least squares) alternando entre asumir fijos los $q_i$ y los $p_u$. Esta ultima tecnica ayuda a paralelizar y evita iterar sobre todos los datos en situaciones donde la matriz a descomponer esta mas populada.

Otras extensiones al modelo son:

tomar en cuenta los bias (sea de usuarios o items) mediante un termino regularizador.
considerar ademas fuentes implicitas de datos.
considerar biases, preferencias e interacciones como funciones del tiempo para modelar variaciones temporales.
añadir metricas de certeza/confianza para reflejar la seguridad del modelo en una prediccion realizada.

Comentarios

El escrito hace un excelente trabajo en comunicar la importancia que han tenido los metodos de factorizacion de matrices para mejorar los resultados de sistemas recomendadores. Ademas, lo hace desde la perspectiva de personas que participaron en el netflix prize, aterrizando el tema. Lo que puedo criticar es no haberse explayado en las ventajas de obtener representaciones conjuntas (mismo espacio vectorial) para aumentar la explicabilidad del modelo como lo hizo Collaborative Filtering for Implicit Feedback Datasets o para obtener recomendaciones directamente usando distancias entre usuarios/items. La figura dos explicitamente muestra un usuario (Dave) y su relacion con distintas peliculas en el espacio compartido, pero no se comenta sobre sus preferencias en relacion a los vecinos mas cercanos. Un analisis poco profundo de las implicancias de embeber juntos usuarios e items habria ilustrado la relevancia de este tipo de sistemas de factores latentes de mejor manera que simplemente mostrar resultados para justificar su uso. Además, considerar las distancias entre usuarios e items nos da la intuicion de porque funciona el sistema y hasta explica la formulacion matematica usada en tanto el producto punto en $\hat r_{ui} = p_u q_i$ puede ser interpretado como el cuadrado de la distancia euclidiana entre los elementos en su espacio conjunto. Asi, creo que el autor se equivoca al no incluir estas conclusiones al presentar modelos de factores latentes ya que podria haber servido para ayudar al lector a entender lo que esta pasando y darle la intuicion de por que funciona.

Por ultimo, no puedo criticarlo por no profundizar en las matematicas tras la descomposicion matricial, pero me habria encantado que se elaborara en el calculo de los gradientes a traves de la descomposicion en valores singulares SVD.

RecSys Semana 1

Wed, 15 Aug 2018 00:00:00 +0000

Comentario: How not to sort by Average Rating, Evan Miller Blog

Problema

EL articulo de Blog trata sobre recomendacion de articulos usando opiniones de usuarios en forma de likes (o dislikes). Se escapa del clasico paradigma de sistemas recomendadores que hemos visto hasta el momento donde las valoraciones existen como rankings. El autor critica la forma de recomendar que utilizan algunas paginas y las critica, para luego sugerir una forma de recomendar que sea robusta a las faltas de las mencionadas.

Para ordenar por preferencia (y asi poder recomendar) algunas paginas calculan el puntaje del item restando a las valoraciones positivas las negativas. El problema que esto tiene es que aquellas paginas con muchas valoraciones pueden tener un gran puntaje aunque tengan casi igual proporcion de valoraciones positivas vs negativas (ie, ariticulo mediocre).

Otras paginas evitan el problema calculando el procentaje como la proporcion de valoraciones positivas respecto al total. Esta construccion conserva la informacion que nos intersa pero falla cuando un item tiene pocas valoraciones. Un ejemplo representativo de esto es un articulo con 100% de aprobacion que solo ha sido puntuado por su autor (el mitico autolike). Se entiende por lo mismo que mientras no hayan suficientes valoraciones es poco creible que la proporcion sea un buen aproximador de la calidad del item.

Solucion Propuesta

Dado que estabamos hablando de la confianza que tenemos en que proporcion estime correctamente la calidad del item resulta razonable que usemos intervalos de confianza. Mas especificamente, en que usemos la cota inferior del intervalo de confianza (el minimo valor que podria tomar la verdadera calidad medido en proporcion de likes). Asi, usando una confianza de 0.95 podemos afirmar con 95% de certeza que la puntuacion es mayor o igual a la cota inferior.

Discusion

Negativos

En primer lugar, una debilidad de usar este sistema es que esconde los elementos nuevos. Esto sucede porque mientras menor sea el total de valoraciones mas extremos son los valores de las cotas respecto a la media. En otras palabras independiente de lo bueno que sea un item, sera poco recomendado mientras no adquiera una masa critica de valoraciones. Esto establece un circulo vicioso porque es poco probable que suficientes personas voten por el articulo si este no es recomendado.
Construccion provista no es compatible con otras formas de puntuar (ej, x estrellas de 5) sin conversiones previas entre los formatos.

Positivos

Usar Wilson Score combina Most popular (usando como proxy de popularidad el numero de valoraciones) con los valores reales de los ratings para sugerir mejor en escenarios donde un item tiene pocas valoraciones.
Usar intervalos de confianza hacen que el sistema sea mas robusto a ataques que serian graves si solo se usara la proporcion como metrica. Por ejemplo, si un grupo de personas (o un individuo con bots) deciden puntuar mal el item injustamente.

Neutral

La pagina trabaja siempre con una certeza de 95% para calcular la cota inferior para el umbral de confianza. Alternativamente podemos usar distintos valores para acercar los valores a la proporcion observada (disminuyendo el valor, ej. 0.85 de reddit), o podemos aumentar nuestra certeza aumentando el valor (ej. 0.99).

Extensiones posibles

El concepto estadistico de intervalos de confianza no esta restringido a likes o deslikes. Puede aplicarse el mismo concepto para predecir la cota inferior del umbral de confianza para otras metricas como lo son x estrellas de 5 o un valor cualquiera de un dominio continuo.

Si asumimos que la distribucion de datos es normal y que los datos son aleatorios e independientes podemos calcular la cota inferior del intervalo de confianza para el promedio de las valoraciones. Este valor representara la puntuacion minima que podria tomar la verdadera calidad de un articulo y se calcula usando el promedio de valoraciones como estimador de calidad.

Comentario: Collaborative filtering recommender systems, In The adaptive web

Resumen

El paper es un survey de sistemas colaborativos que definen como el filtrado o evaluacion de items usando las opiniones de otras personas. Al entender de los autores la base para este filtrado tiene sus origenes en el boca a boca y con el advenimiento de los computadores y la web se abre la posibilidad de analizar fuentes masivas de datos. Dado que inteligencias artificiales que automaticen el proceso no existen (al momento de escribirse el paper) se utilizan jucios humanos en la forma de ratings para avanzar el estado del arte. Entendemos que los ratings pueden tomar una variedad de formas (escalar, binario, unario) y pueden ser recolectados explicitamente o implicitamente. La importancia de esta forma de filtrado en el contexto de la web (contexto que envuelve el articulo) es obvio, adaptar el contenido a las necesidades de cada usuario.

Para lograr su objetivo los diseñadores deben primero identificar las tareas que el usuario quiere automatizadas en el sistema (encontrar nuevos items para mi/mi grupo, encontrar personas con gustos parecidos, aconsejar sobre un producto especifico, etc.). En segundo lugar deben identificar las funcionalidades que se ofreceran (recomendar items, puntuar un item, busqueda constreñida) y analizar el dominio para ver si es propicio a tecnicas de este estilo segun los datos (muchos items y puntuaciones, muchos usuarios, usuarios puntuan mucho). Por ultimo se debe analidar la necesidad/validez de comparar usuarios (items son distintos en los subjetivo, usuarios tienen gustos agrupables) y la utilidad de las puntuaciones (items persisten, los gustos de los usuarios se mantienen).

Una forma alternativa para lograr el mismo objetivo (de realizar recomendaciones) es usar filtrado por contenido. Los autores comentan sobre la utilidad de estos sistemas para sugerir items no puntuados, pero destacan que son mas propensos a la sobre-especializacion (perdiendo novedad y/o serendipia). Terminan la comparacion mencionando un approach hibrido (combinacion de ambos sea automatica o manual).

Para lograr hacer recomendaciones se necesitan modelos que los autores dividen en memory-based (requieren que todos los ratings, items y users esten almacenados en memoria y por tanto no escalan bien en el mundo real) y model-based (periodicamente crean un resumen de los patrones existentes). El paper tambien explora la distinccion segun si se basan en un modelo probabilistico o no destacando en la primera categoria redes bayesianas. Para la segunda se resalta nearest neighbors en el espacio de usuarios (rating es suma ponderada y normalizada de las puntuaciones de personas similares) o en el espacio de items (rating es suma ponderada de puntuaciones que el usuario hizo a elementos similares encontrados observando puntuaciones de otros usuarios). Las tareas puede hacerse mas eficiente usando tecnicas para no considerar todos los usuarios (considerar los k vecinos mas cercanos, subsampling, clustering) para el primero, y pruning y/o reduccion de dimensionalidad para el segundo. Por ultimo (para los no-probabilisticos) se considera la mineria de reglas asociativas (association rule mining) pero se desecha por su ineficiencia en el dominio de filtrado colaborativo.

Independiente del algoritmo elegido los autores nombran problemas generalmente ignorados que los algoritmos tienen que superar como cuando hay pocos ratings (soluciones para estos casos: ignorar, ajustar calculos, incorporar un conocimiento previo), la distinccion entre prediccion y recomendacion (solo para el primer caso el sistema tiene que conocer todos los items), y hacer explicita la confianza del algoritmo en la decision que tomo.

Sobre la adquisicion de ratings se explica que aquellos obtenidos explicitamente ofrecen una descripcion mas precisa de las preferencias de los usuarios, pero son mas dificiles de recolectar (aunque estudios muestran que es mas facil de lo inicialmente esperado por beneficios sociales y practicos). Por otro lado, aquellos obtenidos implicitamente (obsercando el comportamiento del usuario) pueden ser imprecisos pero una vez que se obtienen en cantidades suficientes disminuye la incertidumbre dado que se pueden acumular (por votacion o promedio) y la incertidumbre se reduce por agregacion.

Los ratings adquiridos son usualmente usados luego para evaluar el rendimiento del sistema pero no hay una metrica aceptada por todos. La mas frecuente es accuracy que mide la capacidad de un sistema de predecir la puntuacion que un usuario dara a un item (predictive accuracy) o la utilidad de una lista recomendada para un cierto usuario (rank accuracy). Otras metricas usadas miden novelty/serendipity (capacidad para recomendar items desconocidos), coverage (cobertura, porcentaje de items potencialmente recomendables), learning rate (cuan rapido se vuelve efectivo), confidence (seguridad de prediccion), además de otros criterios como la satisfaccion de los usuarios o analisis de trafico/compras del sistema.

Por ultimo es importante reconocer la importancia del uso y almacenamiento de los datos recolectados que aseguren la privacidad del usuario para mantener la integridad de esta informacion. Tambien es importante resguardar el servicio de aquellos que intenten romperlo usando los ratings en otro modo que el esperado.

Comentarios

Si bien se nombra el temor del usuario hacia el mal uso de los datos el escrito considera todo desde la confianza del usuario y los costos/beneficios para el sistema. El uso etico de los datos por el bien del usuario se ha hecho mas relevante en el ultimo año (2018) y aprovecho de destacarlo por lo mismo.
El paper no puede seguir siendo considerado un comprehensive survey del estado del arte por su edad. Entre los temas no se tratan destaca el uso de redes neuronales que dirigen el estado del arte actualmente.
El metodos presentados no hacen uso de metadata que podria ser relevante como fecha en la que se realizo la puntuacion u otras formas menos obvias.
Creo que el enfoque del paper esta concentrado mas de lo necesario en predecir predicciones. El verdadero objetivo es servir al usuario o mantenerlo interesado/usando el servicio. Esto puede ser logrado usando RL.

Adaptive Computation Time

Sun, 12 Aug 2018 00:00:00 +0000

Top-Down explanation of Graves’ 2015 paper “Adaptive Computation Time for Recurrent Neural Networks”

1. Motivation

Graves states “evidence that increased depth leads to more performant networks is by now inarguable, and recent results show that increased sequence length can be similarly beneficial”. The underlying principle seems to imply that putting your under-achieving model inside a recurrent network and have it iterate a fixed number of times (100 if you want) to observe better results. Of course, in practice the opposite seems to hold. The resulting model will be much more computationally intensive, will overfit to data easily and you probably wont even see gains in performance.

So what we need is a way to use these increased sequence lengths when more computation is required but at the same time prevent the network from overfitting. In other words, we want to increase the sequence length when needed, but limit complexity when it isn’t. How can we achieve this? By letting the network determine how many iterations it will run and including the number of iterations (or a proxy of this) in the loss function we should achieve a network that will iterate only when it helps to obtain a more accurate answer.

As we push towards a recurrent network that determines how many times it will iterate a new problem arises. How will the network determine its number of iterations? And how to make this differentiable? Having the network determine this limit a priori “would be equivalent to determining the Kolmogorov complexity of the data (and hence solving the halting problem)” (Graves, 2015). The solution proposed by Graves is to let the network halt when it is ready instead.

Pseudo code:

is_ready = False
answer = None
while True:
  # run model to update answer and check if ready
  answer, is_ready = run_model()
  if is_ready:
    break

2. Halting

For each iteration the network outputs an answer and a SIGMOIDAL halting value. The magnitude of the contribution of any iteration to the final answer $y_t$ is equal to the sub answer (the answer given by the iteration) multiplied by its probability of being relevant to the final answer $p_n$.

\[y = \sum_{n=1}^{\infty} p_n y_n\]

In order to limit computation we want all probabilities to be zero for $n > N$ (so that running for more iterations doesn’t change the answer).

\[p_n = \begin{cases} R(n) &\text{if } n \geq N\\ h_n & \text{otherwise} \end{cases}\]

A function $N$ is used to determine the first $n’$ for which the sum of all halting probabilities is greater than one minus a small epsilon. This is so that after one iteration the sigmoidal (and therefore never quite $1$) value of $h_n$ can be enough to halt if only one iteration is needed.

\[N = min\{ n' : \sum_{n=1}^{n'} h_n \geq 1 - \epsilon \}\]

For each iteration $n$ before $n’$ the probability is equal to its halting value. Since the sum of all probabilities has to be equal to one (and we want to limit computation), for $n = N$ the probability $p_n$ will be equal to the remainder $R = 1 - \text{ the sum of all previous probabilities}$.

\[R = 1 - \sum_{n=1}^{N-1}p_n\]

This way, for any $n > N$ the probability will be zero ($R = 1 - 1$), so we can get away with not computing them and the answer wont change, so:

\[y = \sum_{n=1}^{\infty} p_n y_n\]

Finally, we add a proxy of total computation $\rho = N + R$ to the loss to encourage reduced computation and backpropagate through this.

\[\hat{L} = L(x,y) + \rho\]

3. How it works

The main mechanism through which ACT operates is a non-differentiable piece-wise function. As such, the backpropagation of gradients through it is non-trivial.

Looking at the regularization term in the loss function $\rho$ we observe that no gradient can be propagated through $N$ and therefore adding $\rho$ to the loss is functionally equivalent to adding the remainder $R$. From it’s definition we observe that again no gradient can be propagated through the constant value $1$. Taken together this means that by adding $\rho$ to the loss function to minimize $text{loss} + \text{computation}$ we are actually minimizing $text{loss}$ while maximizing $\sum_{n=1}^{N-1}p_n$. By encouraging the network to maximize the halting probabilities of earlier steps we bias the network towards lower computation. This mechanism can be easily understood by considering that the $N$th step (the last answer-changing step) will be achieved earlier if, for instance, the first step greatly increases it’s halting probability.

4. Generalizing towards recurrent neural networks

In Graves’ work the process described above is repeated for each element $t$ in a sequence using an RNN. For each of these besides outputing $y_t$ (the $y$ for element $t$ of the sequence) a hidden state $s_t$ is computed:

\[y = \sum_{n=1}^{\infty} p_n y_n\]

Where $p_t^n \text{ is } p_n \text{ in timestep } t$.

And $N(t)$ is the first $n_t$ for which the sum of all $h_t^n$ is greater than one minus small epsilon.

In blue is the process for one element of the sequence (as described in 2.). For each one of these elements $N(t)$ iterations are performed ($n = 1$ marked in red).

I haven’t talked about how to obtain any of the parameters mentioned (halting_values, sub_answers, sub_hidden_states) because it depends greatly on the implementation. A standard RNN (as shown in the image above) initializes its hidden state $s_t^1$ (when $n = 1$) to $S(s_{t-1}, x_t)$. In other words, for the first iteration of any element in the sequence the hidden state is a function $S$ applied to the COMPLETE hidden state at timestep $t - 1$ and the element of the sequence at index $t$. For any other iteration $s_t^n$ is $S(s_t^{n-1}, x_t)$.

\[s_t^n = \begin{cases} S(s_{t-1}, x_t) \text{ if } n = 1 \\ S(s_t^{n-1}, x_t) \text{ otherwise} \end{cases}\]

Then both $y_t^n$ and $h_t^n$ are calculated by feeding the hidden state $s_t^n$ through feedforward layers $W_y$ and $W_h$ (with bias values) respectively. The output for the halting value $h_t^n$ is then squashed using a Sigmoid.

Cristobal Eyzaguirre

Differentiable Adaptive Computation Time for Visual Reasoning (CVPR 2020)

The Setting: Visual Question Answering

Existing Adaptive Approaches

1. Modular Networks

2. ACT

How it works

Putting it all together…

Results: CLEVR

1. Better accuracy in fewer steps

2. Increased adaptability to changes in question difficulty

3. Interpretability gains

Bonus Results: GQA

Future Work Ideas (!)

Cite

Modelación Linear Discreta

Problema de seleccionar: Knapsack

Problema con costos fijos: Producción e inventario con costos fijos 1

Problema con costos fijos y continuidad: Producción e inventario con costos fijos 2

Problemas de subdivision/asignación: Coloring

Modelación Linear Continua

Problema básico con restricciones: Movimiento de petroleo

Problema con condiciones: Donantes de sangre

Problema con combinaciones: Combos

Problema con relajación de restricción: Maquinas con sobre-tiempo

Problema con inventario

Problema de tareas con prerequisitos: Planificación proyecto

Producción e inventario con vencimiento

PyTorch (1.0), CUDA & cuDNN on MacOS

Prerequisites

CUDA drivers

CUDA toolkit

Compatible clang/Xcode version

cuDNN

Pytorch Installation

Remove PyTorch no longer supports this GPU because it is too old warning

Testing installation

Percentage GridMap

The solution

Hypothesis

Next steps

RecSys Semana 6

Comentario: Factorization Machines

Resumen

Comentarios

Conclusiones

RecSys Semana 5

Comentario: Content-based recommendation systems In The adaptive web

Resumen

Comentarios

RecSys Semana 3

Comentario: Evaluating Recommendation Systems pdf

Resumen

Comentarios:

RecSys Semana 2

Comentario: Collaborative Filtering for Implicit Feedback Datasets, PDF

Resumen

Resultados

Comentarios

Negativo:

Positivo:

Comentario: Matrix Factorization Techniques For Recommender Systems

Resumen

Comentarios

RecSys Semana 1

Comentario: How not to sort by Average Rating, Evan Miller Blog

Problema

Solucion Propuesta

Discusion

Negativos

Positivos

Neutral

Extensiones posibles

Comentario: Collaborative filtering recommender systems, In The adaptive web

Resumen

Comentarios

Adaptive Computation Time

Top-Down explanation of Graves’ 2015 paper “Adaptive Computation Time for Recurrent Neural Networks”

1. Motivation

2. Halting

Remove `PyTorch no longer supports this GPU because it is too old` warning