From 2dabd73de6aab49f708efc8056fc4b2c5b63c7dd Mon Sep 17 00:00:00 2001 From: Alex Rush Date: Mon, 28 Oct 2019 23:21:07 -0400 Subject: [PATCH 01/26] . --- torch_struct/alignment.py | 72 +++++++++++++++++++++++++-------- torch_struct/test_algorithms.py | 12 ++++++ 2 files changed, 68 insertions(+), 16 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index 0d0b7c9f..d59fba69 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -1,9 +1,14 @@ import torch from .helpers import _Struct +from .semirings import LogSemiring import math class Alignment(_Struct): + def __init__(self, semiring=LogSemiring, local=False): + self.semiring = semiring + self.local = local + def _check_potentials(self, edge, lengths=None): batch, N_1, M_1, x = edge.shape assert x == 3 @@ -34,11 +39,11 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): log_MN = int(math.ceil(math.log(steps, 2))) bin_MN = int(math.pow(2, log_MN)) - Down, Mid, Up = 0, 1, 2 + Down, Mid, Up, New = 0, 1, 2, 3 # Create a chart N, N, back chart = self._make_chart( - log_MN + 1, (batch, bin_MN, bin_MN, bin_MN, 3), log_potentials, force_grad + log_MN + 1, (batch, bin_MN, bin_MN, bin_MN, 4), log_potentials, force_grad ) # Init @@ -62,17 +67,20 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): chart[1][:, b, point : bin_MN // 2, ind, ind, Mid] ) chart[0][ - :, b, rot_x[: end + M], rot_y[:lim], rot_y[:lim], : + :, b, rot_x[: end + M], rot_y[:lim], rot_y[:lim], :3 ] = log_potentials[:, b, : end + M] + if self.local: + chart[0][ + :, b, rot_x[: end + M], rot_y[:lim], rot_y[:lim], 3 + ] = log_potentials[:, b, : end + M, :, 1] + + for b in range(lengths.shape[0]): end = lengths[b] point = (end + M) // 2 lim = point * 2 - chart[1][:, b, :point, ind_M, ind_M, :] = torch.stack( - [ - chart[0][:, b, :lim:2, ind_M, ind_M, Down], - semiring.sum( + mid = semiring.sum( torch.stack( [ chart[0][:, b, :lim:2, ind_M, ind_M, Mid], @@ -80,11 +88,18 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): ], dim=-1, ) - ), + ) + + chart[1][:, b, :point, ind_M, ind_M, :] = torch.stack( + [ + chart[0][:, b, :lim:2, ind_M, ind_M, Down], + mid, chart[0][:, b, :lim:2, ind_M, ind_M, Up], + mid ], dim=-1, ) + x = torch.stack([ind_U, ind_D], dim=0) y = torch.stack([ind_D, ind_U], dim=0) @@ -109,13 +124,14 @@ def merge(x, size): left = ( x[:, :, 0 : size * 2 : 2] .permute(0, 1, 2, 4, 5, 3) - .view(ssize, batch, size, 1, bin_MN, 3, bin_MN) + .view(ssize, batch, size, 1, bin_MN, 4, bin_MN) ) right = ( x[:, :, 1 : size * 2 : 2] .permute(0, 1, 2, 3, 5, 4) - .view(ssize, batch, size, bin_MN, 1, 1, 3, bin_MN) + .view(ssize, batch, size, bin_MN, 1, 1, 4, bin_MN) ) + exp = (ssize, batch, size, bin_MN, bin_MN, 4, bin_MN) st = [] for op in (Up, Down, Mid): a, b, c, d = 0, bin_MN, 0, bin_MN @@ -123,7 +139,14 @@ def merge(x, size): a, b, c, d = 1, bin_MN, 0, bin_MN - 1 if op == Down: a, b, c, d = 0, bin_MN - 1, 1, bin_MN + # print(left[..., a:b].shape, + # semiring.dot(left[..., a:b], right[..., op, c:d]).shape) st.append(semiring.dot(left[..., a:b], right[..., op, c:d])) + if self.local: + plus = torch.stack([left.expand(exp), + right[..., New, :].expand(exp)], + dim=-1) + st.append(semiring.sum(semiring.sum(plus))) st = torch.stack(st, dim=-1) return semiring.sum(st) @@ -131,7 +154,10 @@ def merge(x, size): for n in range(2, log_MN + 1): size = int(size / 2) chart[n][:, :, :size] = merge(chart[n - 1], size) - v = chart[-1][:, :, 0, M, N, Mid] + if self.local: + v = semiring.sum(semiring.sum(chart[-1][:, :, 0, :, :, Mid])) + else: + v = chart[-1][:, :, 0, M, N, Mid] return v, [log_potentials], None @staticmethod @@ -145,8 +171,14 @@ def enumerate(self, edge, lengths=None): semiring = self.semiring edge, batch, N, M, lengths = self._check_potentials(edge, lengths) d = {} - d[0, 0] = [([(0, 0)], edge[:, :, 0, 0, 1])] + d[0, 0] = [([(0, 0, 1)], edge[:, :, 0, 0, 1])] # enum_lengths = torch.LongTensor(lengths.shape) + if self.local: + for i in range(N): + for j in range(M): + d.setdefault((i , j ), []) + d[i, j].append(([(i, j, 1)], edge[:, :, i, j, 1])) + for i in range(N): for j in range(M): d.setdefault((i + 1, j + 1), []) @@ -156,7 +188,7 @@ def enumerate(self, edge, lengths=None): if i + 1 < N and j + 1 < M: d[i + 1, j + 1].append( ( - chain + [(i + 1, j + 1)], + chain + [(i + 1, j + 1, 1)], semiring.mul(score, edge[:, :, i + 1, j + 1, 1]), ) ) @@ -164,16 +196,24 @@ def enumerate(self, edge, lengths=None): d[i + 1, j].append( ( - chain + [(i + 1, j)], + chain + [(i + 1, j, 2)], semiring.mul(score, edge[:, :, i + 1, j, 2]), ) ) if j + 1 < M: d[i, j + 1].append( ( - chain + [(i, j + 1)], + chain + [(i, j + 1, 0)], semiring.mul(score, edge[:, :, i, j + 1, 0]), ) ) - all_val = torch.stack([x[1] for x in d[N - 1, M - 1]], dim=-1) + if self.local: + positions = [x[0] for i in range(N) for j in range(M) for x in d[i, j]] + all_val = torch.stack([x[1] for i in range(N) for j in range(M) for x in d[i, j]], + dim=-1) + _, ind = all_val.max(dim=-1) + print(positions[ind[0, 0]]) + else: + all_val = torch.stack([x[1] for x in d[N - 1, M - 1]], dim=-1) + return semiring.unconvert(semiring.sum(all_val)), None diff --git a/torch_struct/test_algorithms.py b/torch_struct/test_algorithms.py index bf3385f5..1ef0a5cb 100644 --- a/torch_struct/test_algorithms.py +++ b/torch_struct/test_algorithms.py @@ -310,6 +310,18 @@ def test_alignment(data): assert torch.isclose(count, alpha).all() + semiring = data.draw(sampled_from([MaxSemiring])) + struct = model(semiring, local=True) + vals, (batch, N) = model._rand() + vals[..., 0] = -vals[..., 0].abs() + vals[..., 1] = vals[..., 1].abs() + vals[..., 2] = -vals[..., 2].abs() + alpha = struct.sum(vals) + count = struct.enumerate(vals)[0] + mx = struct.marginals(vals) + assert torch.isclose(count, alpha).all() + + def test_hmm(): C, V, batch, N = 5, 20, 2, 5 transition = torch.rand(C, C) From c3e853f9750c4789d25a3e7a7803757b1226641c Mon Sep 17 00:00:00 2001 From: Alex Rush Date: Mon, 28 Oct 2019 23:48:01 -0400 Subject: [PATCH 02/26] . --- docs/source/model.ipynb | 784 +++----------------------------- torch_struct/alignment.py | 10 +- torch_struct/test_algorithms.py | 2 + 3 files changed, 82 insertions(+), 714 deletions(-) diff --git a/docs/source/model.ipynb b/docs/source/model.ipynb index ed29a3e6..a2f510f1 100644 --- a/docs/source/model.ipynb +++ b/docs/source/model.ipynb @@ -22,7 +22,19 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'torch_struct'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m--------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0mTraceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mtorch_struct\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpyplot\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'torch_struct'" + ] + } + ], "source": [ "import torch_struct\n", "import torch\n", @@ -32,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -57,22 +69,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "batch, N, C = 3, 7, 2\n", "def show_chain(chain):\n", @@ -86,46 +85,20 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "show_chain(dist.marginals[0])" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "scrolled": true }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "event = dist.to_event(torch.tensor([[0, 1, 0, 1, 1, 1, 0, 1]]), 2)\n", "show_chain(event[0])" @@ -149,22 +122,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "batch, V, N, C = 10, 3, 7, 2\n", "\n", @@ -195,22 +155,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "batch, N, C, K = 3, 10, 2, 6\n", "def show_sm(chain):\n", @@ -225,44 +172,18 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "show_sm(dist.marginals[0])" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Use -1 for segments.\n", "event = dist.to_event(torch.tensor([[0, 1, -1, 1, -1, -1, 0, 1, 1, -1, -1]]), (2, 6))\n", @@ -287,22 +208,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "batch, N, M = 3, 15, 20\n", "def show_deps(tree):\n", @@ -315,22 +223,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "show_deps(dist.marginals[0])" ] @@ -353,22 +248,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "batch, N, N = 3, 10, 10\n", "def show_deps(tree):\n", @@ -381,44 +263,18 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAAGbCAYAAAD5r4b7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAP+klEQVR4nO3dX4ylh1nf8d+zO+u/2Tqu00SwdmtLITEmUAWtogRLVEqoSgoiN70ISlDhxgiVxCAkGqpUuaRqIwSqIlQT4IY0UWV8EaFAggRc9MbKxolq7LXBOGA7ccDkj+PEXu/O7tOL3UqpfYY9w+6z7znjz0eytDPn+NVP7/z5zjlz5pzq7gDA5XZo6QEAHEwCA8AIgQFghMAAMEJgABixM3HQozce6dccu3ri0JfkK6f+ydITVrrqy0sv2MPp00sv2DK19IC9HdrMbb17dukJK9XO4aUnrNRXH1l6wsucOvWNnD7z7ZWfYCOBec2xq/Oh+75/4tCX5MOP/OulJ6x07IOb+VDxemJTy7ehNvSbeJLUtdcuPWGls3//taUnrHT4Nf906QkrnX7Ddy094WU+e+Ije17mLjIARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwYq3AVNWPVtWjVfVYVX1gehQA2++igamqw0k+kuSdSe5I8pNVdcf0MAC22zq3YN6S5LHufry7Tyf5RJJ3zc4CYNutE5hjSZ78jrefuvC+/09V3VVVJ6rqxHNfP3O59gGwpS7bL/m7+57uPt7dx4/euHmvGw3AlbVOYL6U5JbvePvmC+8DgD2tE5jPJvmeqrqtqq5K8u4kn5ydBcC227nYFbp7t6p+PsmnkxxO8jvd/dD4MgC22kUDkyTd/akknxreAsAB4i/5ARghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEWs9m/J+Pf3CDfnVB985cehLsvtXr1p6wkp/9Z6lF6z22hM3LD1hpaN/+ezSE1Y69K1TS0/YOodvunHpCSv1qReXnrDSzldfWHrCy9TZ3vMyt2AAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoAROxMHvepvk3/+3yaOfGn+8j299ISVjn5xMzt/5wfvX3rCSg++5w1LT1jthVNLL9hTnzmz9ISt0i+8sPSEleqZry094eXO7O550WZ+ZwNg6wkMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGHHRwFTVLVX1p1X1cFU9VFV3X4lhAGy3dV5wbDfJL3X3A1V1NMnnquqPu/vh4W0AbLGL3oLp7qe7+4EL/34uyckkx6aHAbDd9vU7mKq6Ncmbk7zstXSr6q6qOlFVJ86c+fblWQfA1lo7MFX1qiS/n+QXuvubL728u+/p7uPdffzIkesv50YAttBagamqIzkfl491932zkwA4CNZ5FFkl+e0kJ7v71+YnAXAQrHML5s4kP5Xk7VX1hQv//dvhXQBsuYs+TLm7/3eSugJbADhA/CU/ACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAw4qLPpvyPUadezOFH/mbi0Jfk9g9t5pNC/8V//t6lJ6z0f/797UtPWOnRn7th6QkrvfG3NvfntUPffH7pCat1L71gtU3dtbu79IIV9j5Xm/sVAcBWExgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwIidiYP22XM5+9xzE4e+JIeuvXbpCSu9/uPfWnrCSl//gVcvPWGl7/0vTyw9YaWT//GWpSfs6fb/0UtPWKm+9fzSE1bqUy8uPWG1Qxt4m+Dc3p9bG7gWgINAYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8CItQNTVYer6vNV9QeTgwA4GPZzC+buJCenhgBwsKwVmKq6OcmPJfno7BwADop1b8H8epJfTnJucAsAB8hFA1NVP57k77r7cxe53l1VdaKqTpzJhr6eNQBXzDq3YO5M8hNV9ddJPpHk7VX1ey+9Unff093Hu/v4kVx9mWcCsG0uGpju/pXuvrm7b03y7iR/0t3vHV8GwFbzdzAAjNjZz5W7+8+S/NnIEgAOFLdgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEft6NuW1VVKHD48c+lL0md2lJ6x0+Jlnl56w0o27m/kK2Y/+19ctPWGl2+9+bOkJe/rmv3r90hNWOvqHTy49YaVzzz+/9ISV6urNezHH7t7zMrdgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwIidiYPWzpEcft1rJw59SXp3d+kJq714eukFK9WZs0tPWOmmT1+z9ISVvu8zX1t6wp4++8FzS09Y6dFf/YGlJ6x0+3//26UnrHZk5Fv2JanHr9rzMrdgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWDEWoGpqldX1b1V9UhVnayqt00PA2C7rfvqNb+R5I+6+99V1VVJrhvcBMABcNHAVNUNSX44yU8nSXefTrKZL8EIwMZY5y6y25I8k+R3q+rzVfXRqrr+pVeqqruq6kRVnTh97oXLPhSA7bJOYHaS/GCS3+zuNyf5dpIPvPRK3X1Pdx/v7uNXHbr2Ms8EYNusE5inkjzV3fdfePvenA8OAOzpooHp7q8kebKq3njhXe9I8vDoKgC23rqPIntfko9deATZ40l+Zm4SAAfBWoHp7i8kOT68BYADxF/yAzBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAI9Z9uv79OXcu/fzmvWxyv7B5m5IkR48uvWCl+uo3lp6w0k33n116wkoP/uyblp6wpyffv7v0hJW+65Ob+TPuI+973dITVnr9/zq19ISX6Sf2/hhu5kcXgK0nMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAETsTB+1zZ3PuuecmDn1JDr36hqUnrNQbeK6S5Nzu7tITVqpvPLv0hJUOHT269IQ93fI/b116wkpfedtm/oz7xt/6+tITVtq96dqlJ+zLZn50Adh6AgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGrBWYqvrFqnqoqv68qj5eVddMDwNgu100MFV1LMn7kxzv7jclOZzk3dPDANhu695FtpPk2qraSXJdki/PTQLgILhoYLr7S0k+nOSJJE8neba7P/PS61XVXVV1oqpOnOkXL/9SALbKOneR3ZjkXUluS/LdSa6vqve+9HrdfU93H+/u40fq6su/FICtss5dZD+S5Ivd/Ux3n0lyX5Ifmp0FwLZbJzBPJHlrVV1XVZXkHUlOzs4CYNut8zuY+5Pcm+SBJA9e+H/uGd4FwJbbWedK3f2hJB8a3gLAAeIv+QEYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBFrPZvyftU116Ruf8PEoS/Ni2eWXrBSvfampSesVKc383zl688uvWC1c2eXXrCnPlxLT1jp8AubuesPP/OJpSdsjbf8m6/ueZlbMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwIjq7st/0KpnkvzNZTrca5L8/WU61iuB87U/ztf+OF/780o4X/+iu//ZqgtGAnM5VdWJ7j6+9I5t4Xztj/O1P87X/rzSz5e7yAAYITAAjNiGwNyz9IAt43ztj/O1P87X/ryiz9fG/w4GgO20DbdgANhCAgPAiI0NTFX9aFU9WlWPVdUHlt6zyarqlqr606p6uKoeqqq7l960DarqcFV9vqr+YOktm66qXl1V91bVI1V1sqretvSmTVdVv3jh6/HPq+rjVXXN0puutI0MTFUdTvKRJO9MckeSn6yqO5ZdtdF2k/xSd9+R5K1J/oPztZa7k5xcesSW+I0kf9Tdtyf5l3He/kFVdSzJ+5Mc7+43JTmc5N3LrrryNjIwSd6S5LHufry7Tyf5RJJ3LbxpY3X30939wIV/P5fzX/zHll212arq5iQ/luSjS2/ZdFV1Q5IfTvLbSdLdp7v7G8uu2go7Sa6tqp0k1yX58sJ7rrhNDcyxJE9+x9tPxTfMtVTVrUnenOT+ZZdsvF9P8stJzi09ZAvcluSZJL974S7Fj1bV9UuP2mTd/aUkH07yRJKnkzzb3Z9ZdtWVt6mB4R+hql6V5PeT/EJ3f3PpPZuqqn48yd919+eW3rIldpL8YJLf7O43J/l2Er8X/QdU1Y05f6/LbUm+O8n1VfXeZVddeZsamC8lueU73r75wvvYQ1Udyfm4fKy771t6z4a7M8lPVNVf5/zdr2+vqt9bdtJGeyrJU939/24V35vzwWFvP5Lki939THefSXJfkh9aeNMVt6mB+WyS76mq26rqqpz/5dgnF960saqqcv7+8ZPd/WtL79l03f0r3X1zd9+a859bf9Ldr7ifLtfV3V9J8mRVvfHCu96R5OEFJ22DJ5K8taquu/D1+Y68Ah8YsbP0gFW6e7eqfj7Jp3P+0Re/090PLTxrk92Z5KeSPFhVX7jwvv/U3Z9acBMHy/uSfOzCD3yPJ/mZhfdstO6+v6ruTfJAzj/K8/N5BT5tjKeKAWDEpt5FBsCWExgARggMACMEBoARAgPACIEBYITAADDi/wLN+LuiYjOIOwAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "show_deps(dist.marginals[0])" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Convert from 1-index standard format. (Head is 0)\n", "event = dist.to_event(torch.tensor([[2, 3, 4, 1, 0, 4]]), None)\n", @@ -443,22 +299,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAAGbCAYAAAD5r4b7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAQWUlEQVR4nO3deaild33H8c83s2QWbWJcm6VJLC5NpXUZ3NJKm0jRapVSabVGWksJFPcqVmvBtlBQkFQpIqQuUIxKif5hRdxQC60ldYxSs7jGmE1NNBrjxGRmMr/+MVNIk+c6Z5z7neecO68XBGbuOXn48Nx7532fc8+9p8YYAYD1dsLcAwDYmAQGgBYCA0ALgQGghcAA0GJzx0G3bN05tm17QMehj8q++9fcEyZt/fGBuSdM2nTa3rknTLrjpyfOPWHS1h/OvWBttaTPFh21nJ+TJ9y1b+4Jk/adtHXuCfex9/Zbs/+neybfkS2B2bbtAdn1pJd2HPqo3PBby/fOSZIzP/bTuSdMOvnN1889YdLn/+eX554w6eEfvHvuCWs6Yf9yfhFzYNNyPoiy7evfm3vCpJt+75fmnnAfX//Xi9a8bTnfuwCsPIEBoIXAANBCYABoITAAtBAYAFoIDAAtBAaAFgIDQAuBAaCFwADQQmAAaCEwALQQGABaLBSYqnpGVX21qr5RVa/rHgXA6jtsYKpqU5K3J3lmknOSvKCqzukeBsBqW+QK5olJvjHGuGaMsTfJB5I8t3cWAKtukcCcluSeL214w6G3/T9VdWFV7a6q3fv27VmvfQCsqHX7Jv8Y4+Ixxq4xxq4tW3au12EBWFGLBObGJGfc4++nH3obAKxpkcB8Pskjqursqtqa5PlJPtw7C4BVt/lwdxhj7K+qlyb5eJJNSd49xriyfRkAK+2wgUmSMcZHk3y0eQsAG4if5AeghcAA0EJgAGghMAC0EBgAWggMAC0EBoAWAgNAC4EBoIXAANBCYABoITAAtBAYAFos9NuUj9TekyrffsbWjkMflUf+881zT5j0lZc8eO4Jkx7xGz+Ye8Kkc85azldM/aOPfW7uCWv620/+wdwTJm0/9SdzT5i072tnHP5OMzhh79wL7uvAlrVvcwUDQAuBAaCFwADQQmAAaCEwALQQGABaCAwALQQGgBYCA0ALgQGghcAA0EJgAGghMAC0EBgAWggMAC0EBoAWAgNAC4EBoIXAANBCYABoITAAtBAYAFoIDAAtBAaAFgIDQAuBAaCFwADQQmAAaCEwALQQGABaCAwALQQGgBYCA0ALgQGghcAA0EJgAGghMAC02Nxx0BP2J9tvqY5DH5W7zjh57gmTfvtJV8w9YdK15z1h7gmTDrzh5rknTPrHrz597glrGlvG3BMmXfmUS+aeMOmvHv7YuSdMuvTfnzz3hPsYm9a+zRUMAC0EBoAWAgNAC4EBoIXAANBCYABoITAAtBAYAFoIDAAtBAaAFgIDQAuBAaCFwADQQmAAaCEwALQ4bGCq6oyq+kxVXVVVV1bVK47FMABW2yIvOLY/yavHGJdX1f2TfKGqPjnGuKp5GwAr7LBXMGOM74wxLj/059uTXJ3ktO5hAKy2I/oeTFWdleRxSS6buO3CqtpdVbvvvmPP+qwDYGUtHJiqul+SDyZ55Rjjx/e+fYxx8Rhj1xhj16YdO9dzIwAraKHAVNWWHIzLJWOMD/VOAmAjWORZZJXkXUmuHmNc1D8JgI1gkSuYc5O8KMl5VfWlQ//9bvMuAFbcYZ+mPMb4jyR1DLYAsIH4SX4AWggMAC0EBoAWAgNAC4EBoIXAANBCYABoITAAtBAYAFoIDAAtBAaAFgIDQAuBAaDFYX+b8s+j9icn/nB0HPqo/Mqbrph7wqTnnfL5uSdM+tRFt809YdL7vvTEuSdM2v61E+eesKYdy/fpmCR5xnNfNPeESb/znv+ce8KkAycemHvCfdXaH1yuYABoITAAtBAYAFoIDAAtBAaAFgIDQAuBAaCFwADQQmAAaCEwALQQGABaCAwALQQGgBYCA0ALgQGghcAA0EJgAGghMAC0EBgAWggMAC0EBoAWAgNAC4EBoIXAANBCYABoITAAtBAYAFoIDAAtBAaAFgIDQAuBAaCFwADQQmAAaCEwALQQGABaCAwALQQGgBabOw56wt3JibeNjkMflZ/evWXuCZP+/i/+bO4Jk+46ueXD46j94li+j60kueuk5dyVJHc+sOaeMOlrF+yce8KkAxf+5twTJj36jp/MPeE+fnTLgTVvcwUDQAuBAaCFwADQQmAAaCEwALQQGABaCAwALQQGgBYCA0ALgQGghcAA0EJgAGghMAC0EBgAWggMAC0WDkxVbaqqL1bVRzoHAbAxHMkVzCuSXN01BICNZaHAVNXpSZ6V5J29cwDYKBa9gnlrktcmWfu1MQHgHg4bmKp6dpKbxxhfOMz9Lqyq3VW1e99de9ZtIACraZErmHOTPKeqrk3ygSTnVdV7732nMcbFY4xdY4xdW07cuc4zAVg1hw3MGOP1Y4zTxxhnJXl+kk+PMS5oXwbASvNzMAC02Hwkdx5jfDbJZ1uWALChuIIBoIXAANBCYABoITAAtBAYAFoIDAAtBAaAFgIDQAuBAaCFwADQQmAAaCEwALQQGABaHNFvU17Upjvvzi989baOQx+V7/7xg+aeMGnHu2+ce8KkzW946NwTJt3xsBPnnjBp5/funnvCmk788XJ+LXnme6+be8KkPe/ZOveESd//yfK9mOPe16x923J+1AGw8gQGgBYCA0ALgQGghcAA0EJgAGghMAC0EBgAWggMAC0EBoAWAgNAC4EBoIXAANBCYABoITAAtBAYAFoIDAAtBAaAFgIDQAuBAaCFwADQQmAAaCEwALQQGABaCAwALQQGgBYCA0ALgQGghcAA0EJgAGghMAC0EBgAWggMAC0EBoAWAgNAC4EBoIXAANBCYABosbnjoPd/+J6cd8l/dxz6qHzgW0+Ye8KkB7/mfnNPmHT3m26de8Kk1575qbknTLro5S+ce8Katt+8d+4Jk+565MPmnjBp/FPLP41H7aTty3dNsOnWTWvetnxrAdgQBAaAFgIDQAuBAaCFwADQQmAAaCEwALQQGABaCAwALQQGgBYCA0ALgQGghcAA0EJgAGghMAC0WCgwVXVyVV1aVV+pqqur6indwwBYbYu+qs7bknxsjPG8qtqaZEfjJgA2gMMGpqpOSvK0JH+aJGOMvUmW8+XxAFgaizxEdnaSW5K8p6q+WFXvrKqd975TVV1YVburaveeW/UH4Hi3SGA2J3l8kneMMR6XZE+S1937TmOMi8cYu8YYu3aesnWdZwKwahYJzA1JbhhjXHbo75fmYHAAYE2HDcwY47tJrq+qRx160/lJrmpdBcDKW/RZZC9LcsmhZ5Bdk+TFfZMA2AgWCswY40tJdjVvAWAD8ZP8ALQQGABaCAwALQQGgBYCA0ALgQGghcAA0EJgAGghMAC0EBgAWggMAC0EBoAWAgNAixpjrPtBdzzkjPHI571q3Y97tLbcMfeCaZvuWv/3wXrY96Jb554w6c59i77KxLF1Qi3n+zFZ3m3nnvqtuSdMunbPKXNPmHTgz7fNPeE+/uu6f8ltd363pm5zBQNAC4EBoIXAANBCYABoITAAtBAYAFoIDAAtBAaAFgIDQAuBAaCFwADQQmAAaCEwALQQGABaCAwALQQGgBYCA0ALgQGghcAA0EJgAGghMAC0EBgAWggMAC0EBoAWAgNAC4EBoIXAANBCYABoITAAtBAYAFoIDAAtBAaAFgIDQAuBAaCFwADQQmAAaCEwALTY3HHQhz301rzuL9/Xceij8o6X/+HcEyZtu+n2uSdMOuFld809YdK+h22fe8Kkn/zScu5Kku///h1zT5h0zZ+cOfeESXsfcr+5J0z65uuX75rgzr9bOyPLtxaADUFgAGghMAC0EBgAWggMAC0EBoAWAgNAC4EBoIXAANBCYABoITAAtBAYAFoIDAAtBAaAFgIDQIuFAlNVr6qqK6vqiqp6f1Vt6x4GwGo7bGCq6rQkL0+ya4zxmCSbkjy/exgAq23Rh8g2J9leVZuT7EhyU98kADaCwwZmjHFjkrckuS7Jd5LcNsb4xL3vV1UXVtXuqtp9+637138pACtlkYfIHpDkuUnOTnJqkp1VdcG97zfGuHiMsWuMsev+p6z9Gs0AHB8WeYjs6Um+Nca4ZYyxL8mHkjy1dxYAq26RwFyX5MlVtaOqKsn5Sa7unQXAqlvkezCXJbk0yeVJvnzo/7m4eRcAK26hb5aMMd6Y5I3NWwDYQPwkPwAtBAaAFgIDQAuBAaCFwADQQmAAaCEwALQQGABaCAwALQQGgBYCA0ALgQGghcAA0KLlpSdv+sEpeeMlL+w49FF51Ou/OfeESVd97uFzT5j0wMfum3vCpJ1v3jT3hEk/+LWae8Ka9n9/+9wTJl3/D8v58upn/M2euSdMOu9Xb5x7wn382/Y717zNFQwALQQGgBYCA0ALgQGghcAA0EJgAGghMAC0EBgAWggMAC0EBoAWAgNAC4EBoIXAANBCYABoITAAtBAYAFoIDAAtBAaAFgIDQAuBAaCFwADQQmAAaCEwALQQGABaCAwALQQGgBYCA0ALgQGghcAA0EJgAGghMAC0EBgAWggMAC0EBoAWAgNAC4EBoIXAANCixhjrf9CqW5J8e50O96Ak31+nYx0PnK8j43wdGefryBwP5+vMMcaDp25oCcx6qqrdY4xdc+9YFc7XkXG+jozzdWSO9/PlITIAWggMAC1WITAXzz1gxThfR8b5OjLO15E5rs/X0n8PBoDVtApXMACsIIEBoMXSBqaqnlFVX62qb1TV6+bes8yq6oyq+kxVXVVVV1bVK+betAqqalNVfbGqPjL3lmVXVSdX1aVV9ZWqurqqnjL3pmVXVa869Pl4RVW9v6q2zb3pWFvKwFTVpiRvT/LMJOckeUFVnTPvqqW2P8mrxxjnJHlykpc4Xwt5RZKr5x6xIt6W5GNjjEcn+fU4bz9TVZ2W5OVJdo0xHpNkU5Lnz7vq2FvKwCR5YpJvjDGuGWPsTfKBJM+dedPSGmN8Z4xx+aE/356Dn/ynzbtquVXV6UmeleSdc29ZdlV1UpKnJXlXkowx9o4xfjTvqpWwOcn2qtqcZEeSm2bec8wta2BOS3L9Pf5+Q/yDuZCqOivJ45JcNu+SpffWJK9NcmDuISvg7CS3JHnPoYcU31lVO+cetczGGDcmeUuS65J8J8ltY4xPzLvq2FvWwPBzqKr7JflgkleOMX48955lVVXPTnLzGOMLc29ZEZuTPD7JO8YYj0uyJ4nvi/4MVfWAHHzU5ewkpybZWVUXzLvq2FvWwNyY5Ix7/P30Q29jDVW1JQfjcskY40Nz71ly5yZ5TlVdm4MPv55XVe+dd9JSuyHJDWOM/7sqvjQHg8Panp7kW2OMW8YY+5J8KMlTZ950zC1rYD6f5BFVdXZVbc3Bb459eOZNS6uqKgcfH796jHHR3HuW3Rjj9WOM08cYZ+Xgx9anxxjH3VeXixpjfDfJ9VX1qENvOj/JVTNOWgXXJXlyVe049Pl5fo7DJ0ZsnnvAlDHG/qp6aZKP5+CzL949xrhy5lnL7NwkL0ry5ar60qG3/fUY46MzbmJjeVmSSw59wXdNkhfPvGepjTEuq6pLk1yeg8/y/GKOw18b41fFANBiWR8iA2DFCQwALQQGgBYCA0ALgQGghcAA0EJgAGjxv3t8wvogDeqAAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "batch, N, N = 3, 10, 10\n", "def show_deps(tree):\n", @@ -487,22 +330,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "batch, N, NT = 3, 20, 3\n", "def show_tree(tree):\n", @@ -518,22 +348,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "show_tree(dist.marginals[0])" ] @@ -556,7 +373,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -577,22 +394,9 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Rules\n", "show_prob_tree(rules[0])" @@ -600,32 +404,9 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Terminals\n", "plt.imshow(term[:1])" @@ -652,7 +433,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -682,22 +463,9 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "path = dist.greedy_argmax()\n", "show_ar(path[0])" @@ -705,66 +473,18 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([[-11.9900, -11.9229, -11.8859]], grad_fn=)" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "dist.log_prob(path.unsqueeze(0))" ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaIAAAC7CAYAAAAnpZqIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAIxElEQVR4nO3dX4ilh1nH8d/j7ibbpGJFc2F2F5OLWlmKTWSI1YAXiZJUxd42YC+KkBvbplKQ6p33UvSiCEsbFQwtkuailOhaNCAF3XabrrWbbSXE2mwaSWqoaRXyz8eLGWWVrXMymbPPnHk/H1iYOefw8uPdP98957ycqe4OAEz5gekBACybEAEwSogAGCVEAIwSIgBGCREAo46u46DX1fV9PDeu49AM+Ymf+o/pCcAG+8bTr+TbL7xWV7tvLSE6nhvzM3X3Og7NkLNnL0xPADbYHfc8/X3v89IcAKOECIBRQgTAKCECYJQQATBKiAAYJUQAjBIiAEYJEQCjhAiAUUIEwCghAmCUEAEwSogAGLVSiKrq3qr6elU9WVUfWfcoAJZj1xBV1ZEkH0vyriSnk9xXVafXPQyAZVjlGdEdSZ7s7qe6++Ukn0ry7vXOAmApVgnRiSRX/mi9yzu3/S9VdX9Vna+q86/kpf3aB8Aht28XK3T3me7e6u6tY7l+vw4LwCG3SoieSXLqiu9P7twGAG/YKiH6YpK3VtWtVXVdkvck+cx6ZwGwFEd3e0B3v1pV709yNsmRJA9298W1LwNgEXYNUZJ096NJHl3zFgAWyCcrADBKiAAYJUQAjBIiAEYJEQCjhAiAUUIEwCghAmCUEAEwSogAGCVEAIwSIgBGCREAo6q79/2gW+843l84e2r3Bw645+bbpicALM65/qu82C/U1e7zjAiAUUIEwCghAmCUEAEwSogAGCVEAIwSIgBGCREAo4QIgFFCBMAoIQJglBABMEqIABglRACMEiIARgkRAKN2DVFVPVhVz1XVV6/FIACWZZVnRH+c5N417wBgoXYNUXf/TZIXrsEWABZo394jqqr7q+p8VZ1//l9f26/DAnDI7VuIuvtMd29199ZNP3Jkvw4LwCHnqjkARgkRAKNWuXz7k0n+NsnbqupyVf36+mcBsBRHd3tAd993LYYAsExemgNglBABMEqIABglRACMEiIARgkRAKOECIBRQgTAKCECYJQQATBKiAAYJUQAjBIiAEbt+unbe/GPX7kh99x82zoO/Yad/daF6Qkb6aD+fgKbzzMiAEYJEQCjhAiAUUIEwCghAmCUEAEwSogAGCVEAIwSIgBGCREAo4QIgFFCBMAoIQJglBABMEqIABglRACM2jVEVXWqqh6rqieq6mJVPXAthgGwDKv8hNZXk3y4ux+vqh9M8qWq+lx3P7HmbQAswK7PiLr72e5+fOfr7ya5lOTEuocBsAyrPCP6H1V1S5Lbk5y7yn33J7k/SY7nhn2YBsASrHyxQlW9Ocmnk3you1/8v/d395nu3ururWO5fj83AnCIrRSiqjqW7Qg91N2PrHcSAEuyylVzleQTSS5190fXPwmAJVnlGdGdSd6b5K6qurDz65fWvAuAhdj1YoXu/nySugZbAFggn6wAwCghAmCUEAEwSogAGCVEAIwSIgBGCREAo4QIgFFCBMAoIQJglBABMEqIABglRACMEiIARu36YyAOm3tuvm16AgBX8IwIgFFCBMAoIQJglBABMEqIABglRACMEiIARgkRAKOECIBRQgTAKCECYJQQATBKiAAYJUQAjBIiAEbtGqKqOl5VX6iqv6+qi1X1u9diGADLsMoPxnspyV3d/b2qOpbk81X15939d2veBsAC7Bqi7u4k39v59tjOr17nKACWY6X3iKrqSFVdSPJcks9197mrPOb+qjpfVedfyUv7vROAQ2qlEHX3a919W5KTSe6oqrdf5TFnunuru7eO5fr93gnAIfW6rprr7u8keSzJveuZA8DSrHLV3E1V9Zadr9+U5BeTfG3dwwBYhlWumvuxJH9SVUeyHa4/6+7PrncWAEuxylVzX0ly+zXYAsAC+WQFAEYJEQCjhAiAUUIEwCghAmCUEAEwSogAGCVEAIwSIgBGCREAo4QIgFFCBMAoIQJglBABMKq6e/8PWvV8kn/ep8P9aJJv79OxlsR52xvnbW+ct71byrn78e6+6Wp3rCVE+6mqznf31vSOTeO87Y3ztjfO2945d16aA2CYEAEwahNCdGZ6wIZy3vbGedsb523vFn/uDvx7RAAcbpvwjAiAQ+xAh6iq7q2qr1fVk1X1kek9m6CqTlXVY1X1RFVdrKoHpjdtkqo6UlVfrqrPTm/ZFFX1lqp6uKq+VlWXqupnpzdtgqr6zZ2/o1+tqk9W1fHpTVMObIiq6kiSjyV5V5LTSe6rqtOzqzbCq0k+3N2nk7wzyW84b6/LA0kuTY/YMH+Q5C+6+yeTvCPO366q6kSSDybZ6u63JzmS5D2zq+Yc2BAluSPJk939VHe/nORTSd49vOnA6+5nu/vxna+/m+1/FE7MrtoMVXUyyS8n+fj0lk1RVT+U5OeTfCJJuvvl7v7O7KqNcTTJm6rqaJIbknxreM+YgxyiE0mevuL7y/EP6utSVbckuT3JudklG+P3k/xWkv+cHrJBbk3yfJI/2nlJ8+NVdeP0qIOuu59J8ntJvpnk2ST/1t1/ObtqzkEOEW9AVb05yaeTfKi7X5zec9BV1a8kea67vzS9ZcMcTfLTSf6wu29P8u9JvJ+7i6r64Wy/wnNrkpuT3FhVvza7as5BDtEzSU5d8f3JndvYRVUdy3aEHuruR6b3bIg7k/xqVX0j2y8D31VVfzo7aSNcTnK5u//7WffD2Q4T/79fSPJP3f18d7+S5JEkPze8acxBDtEXk7y1qm6tquuy/UbeZ4Y3HXhVVdl+vf5Sd390es+m6O7f7u6T3X1Ltv+s/XV3L/Z/qKvq7n9J8nRVvW3npruTPDE4aVN8M8k7q+qGnb+zd2fBF3kcnR7w/XT3q1X1/iRns31FyYPdfXF41ia4M8l7k/xDVV3Yue13uvvRwU0cbh9I8tDOfxifSvK+4T0HXnefq6qHkzye7Stdv5wFf8KCT1YAYNRBfmkOgAUQIgBGCREAo4QIgFFCBMAoIQJglBABMEqIABj1X+NEzSHZwl0WAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "out = dist.beam_topk(5)[:, 0]\n", "for i in range(3):\n", @@ -774,53 +494,9 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "torch.Size([5, 10, 4])\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "out = dist.sample((5,))[:, 0 ]\n", "print(out.shape)\n", @@ -831,46 +507,9 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "out = dist.sample_without_replacement((5,))[:, 0]\n", "for i in range(3):\n", @@ -897,34 +536,9 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "batch, N, C = 3, 7, 2\n", "\n", @@ -938,34 +552,9 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAACSCAYAAAAttj/ZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAK+UlEQVR4nO3df6xf9V3H8eeL/tqAMYpFqbSObjbETY1AU2cwpJGhZVuoiVsCiZMtLk3McJvGKGjCIn+h8XdctjSlDiYb027T62xEJizTmE0usxMo61brTG+HFtoOVpk0HW//uKfkcvdti73ne0/vp89H8s33fM759HzeJ03vq99zPt/PTVUhSdJCd87QBUiS1AcDTZLUBANNktQEA02S1AQDTZLUBANNktSEOQVakouSPJDka9378hP0+06Snd1rYi5jSpI0SubyPbQkvwscqqo7k9wKLK+q3xjR70hVnT+HOiVJOqm5BtpuYENVPZlkJfC5qrp8RD8DTZI0VnMNtG9W1YXddoDDx9uz+h0DdgLHgDur6q9OcL7NwGaAJa9cdNVFay447drOdM88/4qhSxir15379NAljNW+50feXW/C9y59dugSxmpRXhi6hLH6xqPnDV3CWH2Lw09X1cWjji0+1R9O8lngkhGHfmtmo6oqyYnS8TVVtT/Ja4EHkzxaVf8+u1NVbQG2AFzyhovqHR+79lTlLVh/+x9vGLqEsdp+1ZahSxir9+99+9AljM17V//D0CWM1avO+fbQJYzVHa+9cugSxuqztf0/T3TslIFWVW860bEk/51k5YxbjgdOcI793fveJJ8DrgC+K9AkSTpdc522PwHc3G3fDPz17A5JlidZ1m2vAK4Gds1xXEmSXmKugXYncF2SrwFv6tokWZdka9fnh4DJJF8GHmL6GZqBJknq1SlvOZ5MVR0EvutBV1VNAu/utv8Z+JG5jCNJ0qm4UogkqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQm9BFqSjUl2J9mT5NYRx5cl+UR3/ItJLutjXEmSjptzoCVZBHwQuB54PXBTktfP6vaLwOGq+kHgD4Hfmeu4kiTN1McntPXAnqraW1VHgfuATbP6bALu7ra3A9cmSQ9jS5IE9BNolwL7ZrSnun0j+1TVMeAZ4HtmnyjJ5iSTSSafO/x8D6VJks4WZ9SkkKraUlXrqmrducuXDV2OJGkB6SPQ9gOrZ7RXdftG9kmyGHg1cLCHsSVJAvoJtIeBtUnWJFkK3AhMzOozAdzcbb8NeLCqqoexJUkCYPFcT1BVx5LcAtwPLAK2VdXjSe4AJqtqArgL+GiSPcAhpkNPkqTezDnQAKpqB7Bj1r7bZ2z/L/D2PsaSJGmUM2pSiCRJp8tAkyQ1wUCTJDXBQJMkNcFAkyQ1wUCTJDXBQJMkNcFAkyQ1wUCTJDXBQJMkNcFAkyQ1wUCTJDXBQJMkNcFAkyQ1wUCTJDXBQJMkNcFAkyQ1wUCTJDXBQJMkNaGXQEuyMcnuJHuS3Dri+DuTPJVkZ/d6dx/jSpJ03OK5niDJIuCDwHXAFPBwkomq2jWr6yeq6pa5jidJ0ih9fEJbD+ypqr1VdRS4D9jUw3klSXrZ5vwJDbgU2DejPQX8+Ih+P5fkGuCrwK9U1b7ZHZJsBjYDLP/+ZfzAsoM9lHdmeuyN9w5dwlhdu+umoUsYq99/3V8OXcLY/N6TPzN0CWP13LElQ5cwZk8NXcBg5mtSyN8Al1XVjwIPAHeP6lRVW6pqXVWtO3/50nkqTZLUgj4CbT+wekZ7VbfvRVV1sKqe75pbgat6GFeSpBf1EWgPA2uTrEmyFLgRmJjZIcnKGc0bgCd6GFeSpBfN+RlaVR1LcgtwP7AI2FZVjye5A5isqgngvUluAI4Bh4B3znVcSZJm6mNSCFW1A9gxa9/tM7ZvA27rYyxJkkZxpRBJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhN6CbQk25IcSPLYCY4nyZ8k2ZPk35Jc2ce4kiQd19cntI8AG09y/HpgbffaDHyop3ElSQJ6CrSq+jxw6CRdNgH31LQvABcmWdnH2JIkwfw9Q7sU2DejPdXte4kkm5NMJpk8cvjoPJUmSWrBGTUppKq2VNW6qlp3/vKlQ5cjSVpA5ivQ9gOrZ7RXdfskSerFfAXaBPAL3WzHNwLPVNWT8zS2JOkssLiPkyT5OLABWJFkCvgAsASgqj4M7ADeDOwBngPe1ce4kiQd10ugVdVNpzhewHv6GEuSpFHOqEkhkiSdLgNNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUhF4CLcm2JAeSPHaC4xuSPJNkZ/e6vY9xJUk6bnFP5/kI8KfAPSfp849V9daexpMk6SV6+YRWVZ8HDvVxLkmSTkeqqp8TJZcBn6mqHx5xbAPwSWAK+Abwa1X1+Ih+m4HNXfNyYHcvxb08K4Cn53G8+eb1LWxe38LV8rXB/F/fa6rq4lEH5ivQLgBeqKojSd4M/HFVre1l4J4kmayqdUPXMS5e38Lm9S1cLV8bnFnXNy+zHKvq2ao60m3vAJYkWTEfY0uSzg7zEmhJLkmSbnt9N+7B+RhbknR26GWWY5KPAxuAFUmmgA8ASwCq6sPA24BfSnIM+DZwY/V1r7M/W4YuYMy8voXN61u4Wr42OIOur7dnaJIkDcmVQiRJTTDQJElNMNCAJBuT7E6yJ8mtQ9fTp1MtS7bQJVmd5KEku5I8nuR9Q9fUlySvSPIvSb7cXdtvD13TOCRZlORfk3xm6Fr6luTrSR7tlvybHLqeviW5MMn2JF9J8kSSnxi0nrP9GVqSRcBXgeuY/uL3w8BNVbVr0MJ6kuQa4Ahwz6jvCC50SVYCK6vqS0leBTwC/GwLf3/dzODzuu9vLgH+CXhfVX1h4NJ6leRXgXXABa0tj5fk68C6qmryi9VJ7mZ6WcOtSZYC51bVN4eqx09osB7YU1V7q+oocB+waeCaetP6smRV9WRVfanb/hbwBHDpsFX1o6Yd6ZpLuldT/wNNsgp4C7B16Fr0/5Pk1cA1wF0AVXV0yDADAw2mf/jtm9GeopEfiGebbrWaK4AvDltJf7rbcTuBA8ADVdXMtXX+CPh14IWhCxmTAv4+ySPd0n4tWQM8BfxZd8t4a5LzhizIQFMTkpzP9Hqh76+qZ4eupy9V9Z2q+jFgFbA+STO3jZO8FThQVY8MXcsY/WRVXQlcD7ynewTQisXAlcCHquoK4H+AQecgGGiwH1g9o72q26cFonu+9Eng3qr61ND1jEN3K+chYOPQtfToauCG7jnTfcBPJfnzYUvqV1Xt794PAJ9m+hFHK6aAqRl3DbYzHXCDMdCmJ4GsTbKme6h5IzAxcE16mbqJE3cBT1TVHwxdT5+SXJzkwm77lUxPXPrKsFX1p6puq6pVVXUZ0//uHqyqnx+4rN4kOa+bqER3K+6ngWZmG1fVfwH7klze7boWGHQyVl+/4HPBqqpjSW4B7gcWAdtG/WqbhWrUsmRVddewVfXqauAdwKPdsyaA3+wWwV7oVgJ3dzNxzwH+oqqam9resO8DPt0tY7sY+FhV/d2wJfXul4F7uw8De4F3DVnMWT9tX5LUBm85SpKaYKBJkppgoEmSmmCgSZKaYKBJkppgoEmSmmCgSZKa8H8zrxWRPXh26wAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "show_chain(dist.marginals[0])\n", "plt.show()\n", @@ -974,7 +563,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -988,229 +577,27 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "show_samples(dist.sample((10,)))" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAACSCAYAAAAttj/ZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAKsElEQVR4nO3df6xfd13H8eeLttvcEDbpIqVt3Ax1ShS3cVM1M0vjmHRIVhMx2RJ1EMlNDFPQGNggGZG/pn/4KxLI0lU6RYYZolfSWEc2gsYAu8PyYxsd14akt5t0tGNQEUbH2z/u6fLd9dvbse+599z76fORfHPP55xPz+d9ctL76jnn8z1NVSFJ0lr3oqELkCSpDwaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkTBVqSH0lyb5KvdD8vOk2/Z5Ic6D4zk4wpSdI4meR7aEn+BDheVbcnuQW4qKreOabfiap68QR1SpK0pEkD7SCwo6oeT7IJ+GRVXTamn4EmSVpWkwbaN6rqwm45wJOn2ov6nQQOACeB26vqH0+zv2lgGuCC8/Oan3zlOS+4ttXu0S+cP3QJy+onXv3toUtYVi2fP8+dVrNv8eTXq+ricdvOGGhJPgG8fMymdwN7RwMsyZNV9f+eoyXZXFVHkvw4cB9wTVX911LjTv3sefXZ/VuXrG0te90rLh+6hGW1/7EDQ5ewrFo+f547rWafqHserKqpcdvWn+kPV9VrT7ctydeSbBq55Xj0NPs40v08lOSTwBXAkoEmSdIPYtJp+zPATd3yTcA/Le6Q5KIk53bLG4GrgIcnHFeSpOeYNNBuB65N8hXgtV2bJFNJdnd9fgqYTfJ54H4WnqEZaJKkXp3xluNSquoYcM2Y9bPAW7rl/wB+ZpJxJEk6E98UIklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqQi+BlmRnkoNJ5pLcMmb7uUk+0m3/TJJL+hhXkqRTJg60JOuA9wHXAa8CbkzyqkXdfht4sqpeCfwZ8MeTjitJ0qg+rtC2A3NVdaiqngbuBnYt6rML2Nst3wNckyQ9jC1JEtBPoG0GDo+057t1Y/tU1UngKeBli3eUZDrJbJLZJ44900NpkqSzxaqaFFJVd1TVVFVNXfyydUOXI0laQ/oItCPA1pH2lm7d2D5J1gMvBY71MLYkSUA/gfYAsC3JpUnOAW4AZhb1mQFu6pbfCNxXVdXD2JIkAbB+0h1U1ckkNwP7gXXAnqp6KMl7gdmqmgHuBP4myRxwnIXQkySpNxMHGkBV7QP2LVp328jyd4Bf72MsSZLGWVWTQiRJeqEMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhN6CbQkO5McTDKX5JYx29+U5IkkB7rPW/oYV5KkU9ZPuoMk64D3AdcC88ADSWaq6uFFXT9SVTdPOp4kSeP0cYW2HZirqkNV9TRwN7Crh/1KkvS8TXyFBmwGDo+054GfG9Pv15JcDTwK/H5VHV7cIck0MA1wHufzuldc3kN5q9P+xw4MXcKyavncQdvnz3O3trV+/payUpNC/hm4pKpeDdwL7B3XqaruqKqpqprawLkrVJokqQV9BNoRYOtIe0u37llVdayqvts1dwOv6WFcSZKe1UegPQBsS3JpknOAG4CZ0Q5JNo00rwce6WFcSZKeNfEztKo6meRmYD+wDthTVQ8leS8wW1UzwO8luR44CRwH3jTpuJIkjepjUghVtQ/Yt2jdbSPLtwK39jGWJEnj+KYQSVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITegm0JHuSHE3ypdNsT5K/TDKX5AtJruxjXEmSTunrCu2DwM4ltl8HbOs+08D7expXkiSgp0Crqk8Bx5fosgu4qxZ8GrgwyaY+xpYkCVbuGdpm4PBIe75b9xxJppPMJpn9Ht9dodIkSS1YVZNCquqOqpqqqqkNnDt0OZKkNWSlAu0IsHWkvaVbJ0lSL1Yq0GaA3+pmO/488FRVPb5CY0uSzgLr+9hJkg8DO4CNSeaB9wAbAKrqA8A+4PXAHPBt4M19jCtJ0im9BFpV3XiG7QW8tY+xJEkaZ1VNCpEk6YUy0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU3oJdCS7ElyNMmXTrN9R5KnkhzoPrf1Ma4kSaes72k/HwT+CrhriT7/VlVv6Gk8SZKeo5crtKr6FHC8j31JkvRCpKr62VFyCfDxqvrpMdt2AB8F5oHHgD+sqofG9JsGprvmZcDBXop7fjYCX1/B8Vaax7e2eXxrV8vHBit/fD9WVReP27BSgfYS4PtVdSLJ64G/qKptvQzckySzVTU1dB3LxeNb2zy+tavlY4PVdXwrMsuxqr5ZVSe65X3AhiQbV2JsSdLZYUUCLcnLk6Rb3t6Ne2wlxpYknR16meWY5MPADmBjknngPcAGgKr6APBG4HeSnAT+F7ih+rrX2Z87hi5gmXl8a5vHt3a1fGywio6vt2dokiQNyTeFSJKaYKBJkppgoAFJdiY5mGQuyS1D19OnM72WbK1LsjXJ/UkeTvJQkrcNXVNfkpyX5LNJPt8d2x8NXdNySLIuyX8m+fjQtfQtyVeTfLF75d/s0PX0LcmFSe5J8uUkjyT5hUHrOdufoSVZBzwKXMvCF78fAG6sqocHLawnSa4GTgB3jfuO4FqXZBOwqao+l+SHgQeBX23h/HUzgy/ovr+5Afh34G1V9emBS+tVkj8ApoCXtPZ6vCRfBaaqqskvVifZy8JrDXcnOQc4v6q+MVQ9XqHBdmCuqg5V1dPA3cCugWvqTeuvJauqx6vqc93yt4BHgM3DVtWPWnCia27oPk39CzTJFuBXgN1D16IfTJKXAlcDdwJU1dNDhhkYaLDwy+/wSHueRn4hnm26t9VcAXxm2Er6092OOwAcBe6tqmaOrfPnwDuA7w9dyDIp4F+TPNi92q8llwJPAH/d3TLeneSCIQsy0NSEJC9m4X2hb6+qbw5dT1+q6pmquhzYAmxP0sxt4yRvAI5W1YND17KMfrGqrgSuA97aPQJoxXrgSuD9VXUF8D/AoHMQDDQ4AmwdaW/p1mmN6J4vfRT4UFX9w9D1LIfuVs79wM6ha+nRVcD13XOmu4FfSvK3w5bUr6o60v08CnyMhUccrZgH5kfuGtzDQsANxkBbmASyLcml3UPNG4CZgWvS89RNnLgTeKSq/nToevqU5OIkF3bLP8TCxKUvD1tVf6rq1qraUlWXsPD37r6q+o2By+pNkgu6iUp0t+J+GWhmtnFV/TdwOMll3aprgEEnY/X1H3yuWVV1MsnNwH5gHbBn3H9ts1aNey1ZVd05bFW9ugr4TeCL3bMmgHd1L8Fe6zYBe7uZuC8C/r6qmpva3rAfBT7WvcZ2PfB3VfUvw5bUu98FPtRdDBwC3jxkMWf9tH1JUhu85ShJaoKBJklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJasL/AQznFcPcAIj0AAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "show_samples(dist.topk(10))" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "torch.Size([256, 3, 7, 2, 2])\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAACSCAYAAAAttj/ZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAKt0lEQVR4nO3df6xfdX3H8efL2wKCU5gls7bNYLFzM5sDvOlmWAgZMoszdIkugWSKRnMTI85tWTbYEsz8i+2P/cqMhpTOsqm41LndmcYOAsYZo3LRogIWr41Jb2Ertoh2brLie3/cU3K5+7ZFvud+T++nz0fyzT0/Pj3v98m3va9+z/ncc1NVSJK02r1g6AYkSeqDgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqwliBluQnk9yV5Jvd1wtOMO7pJHu71+w4NSVJGiXj/Bxakj8HjlTVrUluAi6oqj8aMe5oVb1ojD4lSTqpcQNtH3BlVT2WZD3wmap65YhxBpokaUWNG2jfrarzu+UATxxfXzbuGLAXOAbcWlX/fILjzQAzAOedm9f83CvOet69aViPfPXcoVtYUT/76h8M3cKKaf290+r2fZ74TlVdOGrfKQMtyd3Ay0bs+hNg59IAS/JEVf2/+2hJNlTVwSQ/A9wDXFVV3zpZ3elfOqe+tGfTSXvT6ev1L79k6BZW1J5H9w7dwopp/b3T6nZ37bq/qqZH7Vtzqj9cVa870b4k/5lk/ZJLjodOcIyD3df9ST4DXAqcNNAkSfpxjDttfxa4oVu+AfiX5QOSXJDk7G55HXA58NCYdSVJepZxA+1W4Ook3wRe162TZDrJ9m7MzwNzSR4A7mXxHpqBJknq1SkvOZ5MVR0GrhqxfQ54Z7f8eeAXx6kjSdKp+KQQSVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITegm0JFuT7Esyn+SmEfvPTvLxbv8Xk1zUR11Jko4bO9CSTAEfAK4BXgVcn+RVy4a9A3iiql4B/CXwZ+PWlSRpqT4+oW0B5qtqf1U9BdwJbFs2Zhuws1veBVyVJD3UliQJ6CfQNgAHlqwvdNtGjqmqY8CTwEuXHyjJTJK5JHOPH366h9YkSWeK02pSSFXdVlXTVTV94Uunhm5HkrSK9BFoB4FNS9Y3dttGjkmyBngJcLiH2pIkAf0E2n3A5iQXJzkLuA6YXTZmFrihW34zcE9VVQ+1JUkCYM24B6iqY0luBPYAU8COqnowyfuBuaqaBW4H/j7JPHCExdCTJKk3YwcaQFXtBnYv23bLkuX/AX6rj1qSJI1yWk0KkSTp+TLQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTegl0JJsTbIvyXySm0bsf1uSx5Ps7V7v7KOuJEnHrRn3AEmmgA8AVwMLwH1JZqvqoWVDP15VN45bT5KkUfr4hLYFmK+q/VX1FHAnsK2H40qS9JyN/QkN2AAcWLK+APzyiHFvSnIF8Ajwe1V1YPmAJDPADMA5nMvrX35JD+1pCHse3Tt0Cyuq5b+bvndarSY1KeRfgYuq6tXAXcDOUYOq6raqmq6q6bWcPaHWJEkt6CPQDgKblqxv7LY9o6oOV9UPu9XtwGt6qCtJ0jP6CLT7gM1JLk5yFnAdMLt0QJL1S1avBR7uoa4kSc8Y+x5aVR1LciOwB5gCdlTVg0neD8xV1SzwO0muBY4BR4C3jVtXkqSl+pgUQlXtBnYv23bLkuWbgZv7qCVJ0ig+KUSS1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1IReAi3JjiSHknz9BPuT5G+SzCf5apLL+qgrSdJxfX1C+zCw9ST7rwE2d68Z4IM91ZUkCegp0Krqs8CRkwzZBtxRi74AnJ9kfR+1JUmCyd1D2wAcWLK+0G17liQzSeaSzP0vP5xQa5KkFpxWk0Kq6raqmq6q6bWcPXQ7kqRVZFKBdhDYtGR9Y7dNkqReTCrQZoG3drMdfwV4sqoem1BtSdIZYE0fB0nyMeBKYF2SBeB9wFqAqvoQsBt4AzAP/AB4ex91JUk6rpdAq6rrT7G/gHf3UUuSpFFOq0khkiQ9XwaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCb0EWpIdSQ4l+foJ9l+Z5Mkke7vXLX3UlSTpuDU9HefDwN8Cd5xkzL9X1Rt7qidJ0rP08gmtqj4LHOnjWJIkPR99fUJ7Ll6b5AHgUeAPqurB5QOSzAAz3erRu2vXvgn2tw74zgTrTdpEz29q/aQqPWPC79/85Eotmtj5DfDewUTfv3bfu4FM+vx++kQ7UlW9VEhyEfCpqvqFEfteDPyoqo4meQPw11W1uZfCPUkyV1XTQ/exUjy/1c3zW71aPjc4vc5vIrMcq+p7VXW0W94NrE2ybhK1JUlnhokEWpKXJUm3vKWre3gStSVJZ4Ze7qEl+RhwJbAuyQLwPmAtQFV9CHgz8K4kx4D/Bq6rvq519ue2oRtYYZ7f6ub5rV4tnxucRufX2z00SZKG5JNCJElNMNAkSU0w0IAkW5PsSzKf5Kah++nTqR5Lttol2ZTk3iQPJXkwyXuH7qkvSc5J8qUkD3Tn9qdD97QSkkwl+UqSTw3dS9+SfDvJ17pH/s0N3U/fkpyfZFeSbyR5OMlrB+3nTL+HlmQKeAS4GlgA7gOur6qHBm2sJ0muAI4Cd4z6GcHVLsl6YH1VfTnJTwD3A7/ZwvvXzQw+r/v5zbXA54D3VtUXBm6tV0l+H5gGXtza4/GSfBuYrqomf7A6yU4WH2u4PclZwLlV9d2h+vETGmwB5qtqf1U9BdwJbBu4p960/liyqnqsqr7cLX8feBjYMGxX/ahFR7vVtd2rqf+BJtkI/Aawfehe9ONJ8hLgCuB2gKp6asgwAwMNFr/5HViyvkAj3xDPNN3Tai4FvjhsJ/3pLsftBQ4Bd1VVM+fW+SvgD4EfDd3ICing35Lc3z3aryUXA48Df9ddMt6e5LwhGzLQ1IQkLwI+AfxuVX1v6H76UlVPV9UlwEZgS5JmLhsneSNwqKruH7qXFfSrVXUZcA3w7u4WQCvWAJcBH6yqS4H/Agadg2CgwUFg05L1jd02rRLd/aVPAB+pqn8aup+V0F3KuRfYOnQvPbocuLa7z3Qn8GtJ/mHYlvpVVQe7r4eAT7J4i6MVC8DCkqsGu1gMuMEYaIuTQDYnubi7qXkdMDtwT3qOuokTtwMPV9VfDN1Pn5JcmOT8bvmFLE5c+sawXfWnqm6uqo1VdRGL/+7uqarfHrit3iQ5r5uoRHcp7teBZmYbV9V/AAeSvLLbdBUw6GSsSf76mNNSVR1LciOwB5gCdoz61Tar1ajHklXV7cN21avLgbcAX+vuNQH8cfcQ7NVuPbCzm4n7AuAfq6q5qe0N+yngk91jbNcAH62qTw/bUu/eA3yk+zCwH3j7kM2c8dP2JUlt8JKjJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJ/wfA0wcUxG4uWgAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Enumerate \n", "x,_ = dist.enumerate_support()\n", @@ -1222,32 +609,9 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.imshow(dist.entropy.detach().unsqueeze(0))" ] @@ -1270,7 +634,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.6.8" } }, "nbformat": 4, diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index d59fba69..e682a4a7 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -131,7 +131,7 @@ def merge(x, size): .permute(0, 1, 2, 3, 5, 4) .view(ssize, batch, size, bin_MN, 1, 1, 4, bin_MN) ) - exp = (ssize, batch, size, bin_MN, bin_MN, 4, bin_MN) + exp = (ssize, batch, size, bin_MN, bin_MN, bin_MN) st = [] for op in (Up, Down, Mid): a, b, c, d = 0, bin_MN, 0, bin_MN @@ -143,10 +143,12 @@ def merge(x, size): # semiring.dot(left[..., a:b], right[..., op, c:d]).shape) st.append(semiring.dot(left[..., a:b], right[..., op, c:d])) if self.local: - plus = torch.stack([left.expand(exp), - right[..., New, :].expand(exp)], + plus = torch.stack([left[..., New, :].expand(exp), + right[..., 0, New, :].expand(exp)], dim=-1) - st.append(semiring.sum(semiring.sum(plus))) + p = semiring.sum(semiring.sum(plus)) + p2 = semiring.zero_(p.clone()) + st.append(torch.stack([p2, p2, p2, p], dim=-1)) st = torch.stack(st, dim=-1) return semiring.sum(st) diff --git a/torch_struct/test_algorithms.py b/torch_struct/test_algorithms.py index 1ef0a5cb..b324d88b 100644 --- a/torch_struct/test_algorithms.py +++ b/torch_struct/test_algorithms.py @@ -319,6 +319,8 @@ def test_alignment(data): alpha = struct.sum(vals) count = struct.enumerate(vals)[0] mx = struct.marginals(vals) + print(alpha, count) + print(mx[0].nonzero()) assert torch.isclose(count, alpha).all() From a9ef27bd7bdf402ac55cd33b141b7e9ae14a9c12 Mon Sep 17 00:00:00 2001 From: Alex Rush Date: Tue, 29 Oct 2019 08:42:41 -0400 Subject: [PATCH 03/26] . --- torch_struct/alignment.py | 60 +++++++++++++++++++-------------------- 1 file changed, 29 insertions(+), 31 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index e682a4a7..f3142d0a 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -39,11 +39,11 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): log_MN = int(math.ceil(math.log(steps, 2))) bin_MN = int(math.pow(2, log_MN)) - Down, Mid, Up, New = 0, 1, 2, 3 - + Down, Mid, Up = 0, 1, 2 + Open, Close = 0, 1 # Create a chart N, N, back chart = self._make_chart( - log_MN + 1, (batch, bin_MN, bin_MN, bin_MN, 4), log_potentials, force_grad + log_MN + 1, (batch, bin_MN, bin_MN, 2, bin_MN, 2, 3), log_potentials, force_grad ) # Init @@ -63,17 +63,17 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): point = (end + M) // 2 point = (end + M) // 2 lim = point * 2 - chart[1][:, b, point : bin_MN // 2, ind, ind, Mid] = semiring.one_( - chart[1][:, b, point : bin_MN // 2, ind, ind, Mid] + chart[1][:, b, point : bin_MN // 2, ind, :, ind, :, Mid] = semiring.one_( + chart[1][:, b, point : bin_MN // 2, ind, :, ind, :, Mid] ) chart[0][ - :, b, rot_x[: end + M], rot_y[:lim], rot_y[:lim], :3 - ] = log_potentials[:, b, : end + M] + :, b, rot_x[: end + M], rot_y[:lim], :, rot_y[:lim], :, : + ] = log_potentials[:, b, : end + M].view(ssize, end+M, 1, lim, 1, 3) - if self.local: - chart[0][ - :, b, rot_x[: end + M], rot_y[:lim], rot_y[:lim], 3 - ] = log_potentials[:, b, : end + M, :, 1] + # if self.local: + # chart[0][ + # :, b, rot_x[: end + M], rot_y[:lim], rot_y[:lim], 3 + # ] = log_potentials[:, b, : end + M, :, 1] for b in range(lengths.shape[0]): @@ -83,19 +83,18 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): mid = semiring.sum( torch.stack( [ - chart[0][:, b, :lim:2, ind_M, ind_M, Mid], - chart[0][:, b, 1:lim:2, ind_M, ind_M, Mid], + chart[0][:, b, :lim:2, ind_M, :, ind_M, :, Mid], + chart[0][:, b, 1:lim:2, ind_M, :, ind_M, :, Mid], ], dim=-1, ) ) - chart[1][:, b, :point, ind_M, ind_M, :] = torch.stack( + chart[1][:, b, :point, ind_M, :, ind_M, :, :] = torch.stack( [ - chart[0][:, b, :lim:2, ind_M, ind_M, Down], + chart[0][:, b, :lim:2, ind_M, :, ind_M, :, Down], mid, - chart[0][:, b, :lim:2, ind_M, ind_M, Up], - mid + chart[0][:, b, :lim:2, ind_M, :, ind_M, :, Up] ], dim=-1, ) @@ -106,30 +105,30 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): q = torch.stack( [ semiring.times( - chart[0][:, b, :lim:2, ind_D, ind_D, :], - chart[0][:, b, 1:lim:2, ind_U, ind_U, Down : Down + 1], + chart[0][:, b, :lim:2, ind_D, Open:Open+1, ind_D, :, :], + chart[0][:, b, 1:lim:2, ind_U, :, ind_U, Open:Open+1, Down : Down + 1], ), semiring.times( - chart[0][:, b, :lim:2, ind_U, ind_U, :], - chart[0][:, b, 1:lim:2, ind_D, ind_D, Up : Up + 1], + chart[0][:, b, :lim:2, ind_U, Open:Open+1, ind_U, :, :], + chart[0][:, b, 1:lim:2, ind_D, :, ind_D, Open:Open+1, Up : Up + 1], ), ], dim=2, ) - chart[1][:, b, :point, x, y, :] = q + chart[1][:, b, :point, x, :, y, :, :] = q # Scan def merge(x, size): left = ( x[:, :, 0 : size * 2 : 2] - .permute(0, 1, 2, 4, 5, 3) - .view(ssize, batch, size, 1, bin_MN, 4, bin_MN) + .permute(0, 1, 2, 4, 5, 6, 7, 3) + .view(ssize, batch, size, 1, 2, bin_MN, 2, 3, bin_MN) ) right = ( x[:, :, 1 : size * 2 : 2] - .permute(0, 1, 2, 3, 5, 4) - .view(ssize, batch, size, bin_MN, 1, 1, 4, bin_MN) + .permute(0, 1, 2, 3, 4, 6, 7, 5) + .view(ssize, batch, size, bin_MN, 2, 1, 1, 2, 3, bin_MN) ) exp = (ssize, batch, size, bin_MN, bin_MN, bin_MN) st = [] @@ -139,12 +138,11 @@ def merge(x, size): a, b, c, d = 1, bin_MN, 0, bin_MN - 1 if op == Down: a, b, c, d = 0, bin_MN - 1, 1, bin_MN - # print(left[..., a:b].shape, - # semiring.dot(left[..., a:b], right[..., op, c:d]).shape) - st.append(semiring.dot(left[..., a:b], right[..., op, c:d])) + st.append(semiring.dot(left[..., Open, :, a:b], right[..., Open, op, c:d])) + if self.local: - plus = torch.stack([left[..., New, :].expand(exp), - right[..., 0, New, :].expand(exp)], + plus = torch.stack([left[..., Close, Close, New, :].expand(exp), + right[..., Close, Close, New, :].expand(exp)], dim=-1) p = semiring.sum(semiring.sum(plus)) p2 = semiring.zero_(p.clone()) From 9c4876fdfdb95b776cfd723355694e470d30548f Mon Sep 17 00:00:00 2001 From: Alex Rush Date: Tue, 29 Oct 2019 08:46:48 -0400 Subject: [PATCH 04/26] . --- torch_struct/alignment.py | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index f3142d0a..c3282df7 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -141,12 +141,9 @@ def merge(x, size): st.append(semiring.dot(left[..., Open, :, a:b], right[..., Open, op, c:d])) if self.local: - plus = torch.stack([left[..., Close, Close, New, :].expand(exp), - right[..., Close, Close, New, :].expand(exp)], - dim=-1) - p = semiring.sum(semiring.sum(plus)) - p2 = semiring.zero_(p.clone()) - st.append(torch.stack([p2, p2, p2, p], dim=-1)) + st.append(left[..., :, Close, New, :].expand(exp)) + st.append(right[..., Close, :, New, :].expand(exp)]) + st = torch.stack(st, dim=-1) return semiring.sum(st) @@ -155,9 +152,9 @@ def merge(x, size): size = int(size / 2) chart[n][:, :, :size] = merge(chart[n - 1], size) if self.local: - v = semiring.sum(semiring.sum(chart[-1][:, :, 0, :, :, Mid])) + v = semiring.sum(semiring.sum(chart[-1][:, :, 0, :, Close, :, Close, Mid])) else: - v = chart[-1][:, :, 0, M, N, Mid] + v = chart[-1][:, :, 0, M, Open, N, Open, Mid] return v, [log_potentials], None @staticmethod From d4f0b7450e977314853467e58bee31233891a478 Mon Sep 17 00:00:00 2001 From: Sasha Date: Tue, 29 Oct 2019 11:37:46 -0400 Subject: [PATCH 05/26] . --- docs/source/model.ipynb | 255 +++++++++++++++++++++++++++----- torch_struct/alignment.py | 111 ++++++++------ torch_struct/distributions.py | 32 ++-- torch_struct/test_algorithms.py | 7 +- 4 files changed, 313 insertions(+), 92 deletions(-) diff --git a/docs/source/model.ipynb b/docs/source/model.ipynb index a2f510f1..e5aaa166 100644 --- a/docs/source/model.ipynb +++ b/docs/source/model.ipynb @@ -22,19 +22,7 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "ename": "ModuleNotFoundError", - "evalue": "No module named 'torch_struct'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m--------------------------------\u001b[0m", - "\u001b[0;31mModuleNotFoundError\u001b[0mTraceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mtorch_struct\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpyplot\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'torch_struct'" - ] - } - ], + "outputs": [], "source": [ "import torch_struct\n", "import torch\n", @@ -44,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -69,9 +57,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "batch, N, C = 3, 7, 2\n", "def show_chain(chain):\n", @@ -85,20 +86,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "show_chain(dist.marginals[0])" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAACSCAYAAAAttj/ZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAKuElEQVR4nO3df6xfd13H8eeL22664dhYF7m01Y1YiUTJNm6KZGZZHJMOyWoiJluiDiK5iWGKGqObJiPy1/QPf0UCWbpKp8gwQ/RCGuvIRtAYcHfYAdvouDYkvd20ox2DijI73v5xT5e7y7ft2Pfc77n30+cj+eae8z2fnvf75PZ7Xz3nfO5pqgpJkta7lw3dgCRJfTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0YK9CSvDLJfUm+0n296BTjnkuyv3vNjVNTkqRRMs7voSX5I+BYVd2R5Fbgoqr63RHjjlfVy8foU5Kk0xo30A4A11TVk0mmgU9X1WtHjDPQJEmratxA+3pVXdgtB3j65PqKcSeA/cAJ4I6q+vtT7G8WmAWYYuoN53HBS+5trfvR139r6BZW1eNfOG/oFqSR/Oytb9/k6a9V1SWjtp0x0JJ8CnjViE2/D+xZHmBJnq6q77qPlmRzVR1O8hrgfuDaqvqP09W9IK+sN+ba0/a2nu17Yv/QLayqt7z68qFbkEbys7e+farufaiqZkZt23CmP1xVbz7VtiT/lWR62SXHI6fYx+Hu68EknwauAE4baJIkfS/GnbY/B9zcLd8M/MPKAUkuSnJut7wJuAp4dMy6kiS9wLiBdgdwXZKvAG/u1kkyk2RXN+bHgPkkDwMPsHQPzUCTJPXqjJccT6eqjgLfdaOrquaBd3XL/wr8xDh1JEk6E58UIklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqQi+BlmRHkgNJFpLcOmL7uUk+2m3/XJJL+6grSdJJYwdaking/cD1wOuAm5K8bsWwXwGerqofAf4E+MNx60qStFwfZ2jbgYWqOlhVzwL3ADtXjNkJ7OmW7wWuTZIeakuSBPQTaJuBQ8vWF7v3Ro6pqhPAM8DFK3eUZDbJfJL5/+PbPbQmSTpbrKlJIVV1Z1XNVNXMRs4duh1J0jrSR6AdBrYuW9/SvTdyTJINwCuAoz3UliQJ6CfQHgS2JbksyTnAjcDcijFzwM3d8tuB+6uqeqgtSRIAG8bdQVWdSHILsA+YAnZX1SNJ3gfMV9UccBfwV0kWgGMshZ4kSb0ZO9AAqmovsHfFe7cvW/5f4Bf6qCVJ0ihralKIJEkvlYEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqQi+BlmRHkgNJFpLcOmL7O5I8lWR/93pXH3UlSTppw7g7SDIFvB+4DlgEHkwyV1WPrhj60aq6Zdx6kiSN0scZ2nZgoaoOVtWzwD3Azh72K0nSizb2GRqwGTi0bH0ReOOIcT+f5GrgceA3q+rQygFJZoFZgB/avIF98/t7aG9tesurLx+6hVW174l2v3da3/zsrW9T06feNqlJIZ8ALq2q1wP3AXtGDaqqO6tqpqpmLrl4akKtSZJa0EegHQa2Llvf0r33vKo6WlXf7lZ3AW/ooa4kSc/rI9AeBLYluSzJOcCNwNzyAUmWnyTeADzWQ11Jkp439j20qjqR5BZgHzAF7K6qR5K8D5ivqjng15PcAJwAjgHvGLeuJEnL9TEphKraC+xd8d7ty5ZvA27ro5YkSaP4pBBJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhN6CbQku5McSfKlU2xPkj9PspDkC0mu7KOuJEkn9XWG9iFgx2m2Xw9s616zwAd6qitJEtBToFXVZ4BjpxmyE7i7lnwWuDDJdB+1JUmCyd1D2wwcWra+2L33Aklmk8wnmX/q6HMTak2S1II1NSmkqu6sqpmqmrnk4qmh25EkrSOTCrTDwNZl61u69yRJ6sWkAm0O+OVutuNPAs9U1ZMTqi1JOgts6GMnST4CXANsSrIIvBfYCFBVHwT2Am8FFoBvAe/so64kSSf1EmhVddMZthfw7j5qSZI0ypqaFCJJ0ktloEmSmmCgSZKaYKBJkppgoEmSmmCgSZKaYKBJkppgoEmSmmCgSZKaYKBJkppgoEmSmmCgSZKaYKBJkppgoEmSmmCgSZKaYKBJkppgoEmSmmCgSZKaYKBJkprQS6Al2Z3kSJIvnWL7NUmeSbK/e93eR11Jkk7a0NN+PgT8BXD3acb8c1W9rad6kiS9QC9naFX1GeBYH/uSJOml6OsM7cV4U5KHgSeA366qR1YOSDILzHarx6emFw5MsL9NwNcmV25hcqWWTPT4pqYnVel5E/7+TZzH1xs/ez2b9N/NHz7VhlRVLxWSXAp8sqp+fMS2C4DvVNXxJG8F/qyqtvVSuCdJ5qtqZug+VovHt755fOtXy8cGa+v4JjLLsaq+UVXHu+W9wMYkmyZRW5J0dphIoCV5VZJ0y9u7ukcnUVuSdHbo5R5ako8A1wCbkiwC7wU2AlTVB4G3A7+a5ATwP8CN1de1zv7cOXQDq8zjW988vvWr5WODNXR8vd1DkyRpSD4pRJLUBANNktQEAw1IsiPJgSQLSW4dup8+nemxZOtdkq1JHkjyaJJHkrxn6J76kuT7kvxbkoe7Y/uDoXtaDUmmkvx7kk8O3Uvfknw1yRe7R/7ND91P35JcmOTeJF9O8liSNw3az9l+Dy3JFPA4cB2wCDwI3FRVjw7aWE+SXA0cB+4e9TuC612SaWC6qj6f5AeAh4Cfa+H7180MPr/7/c2NwL8A76mqzw7cWq+S/BYwA1zQ2uPxknwVmKmqJn8pPskelh5ruCvJOcB5VfX1ofrxDA22AwtVdbCqngXuAXYO3FNvWn8sWVU9WVWf75a/CTwGbB62q37UkuPd6sbu1dS/QJNsAX4W2DV0L/reJHkFcDVwF0BVPTtkmIGBBks//A4tW1+kkR+IZ5vuaTVXAJ8btpP+dJfj9gNHgPuqqplj6/wp8DvAd4ZuZJUU8E9JHuoe7deSy4CngL/sLhnvSnL+kA0ZaGpCkpcDHwN+o6q+MXQ/famq56rqcmALsD1JM5eNk7wNOFJVDw3dyyr6qaq6ErgeeHd3C6AVG4ArgQ9U1RXAfwODzkEw0OAwsHXZ+pbuPa0T3f2ljwEfrqq/G7qf1dBdynkA2DF0Lz26Crihu890D/DTSf562Jb6VVWHu69HgI+zdIujFYvA4rKrBveyFHCDMdCWJoFsS3JZd1PzRmBu4J70InUTJ+4CHquqPx66nz4luSTJhd3y97M0cenLw3bVn6q6raq2VNWlLH3u7q+qXxy4rd4kOb+bqER3Ke5ngGZmG1fVfwKHkry2e+taYNDJWJP872PWpKo6keQWYB8wBewe9V/brFejHktWVXcN21WvrgJ+Cfhid68J4Pe6h2Cvd9PAnm4m7suAv62q5qa2N+wHgY93j7HdAPxNVf3jsC317teAD3cnAweBdw7ZzFk/bV+S1AYvOUqSmmCgSZKaYKBJkppgoEmSmmCgSZKaYKBJkppgoEmSmvD/my0Jz0FU+nEAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "event = dist.to_event(torch.tensor([[0, 1, 0, 1, 1, 1, 0, 1]]), 2)\n", "show_chain(event[0])" @@ -122,9 +149,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "batch, V, N, C = 10, 3, 7, 2\n", "\n", @@ -155,9 +195,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "batch, N, C, K = 3, 10, 2, 6\n", "def show_sm(chain):\n", @@ -172,18 +225,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "show_sm(dist.marginals[0])" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Use -1 for segments.\n", "event = dist.to_event(torch.tensor([[0, 1, -1, 1, -1, -1, 0, 1, 1, -1, -1]]), (2, 6))\n", @@ -208,11 +287,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "batch, N, M = 3, 15, 20\n", + "batch, N, M = 3, 10, 10\n", "def show_deps(tree):\n", " plt.imshow(tree.detach())\n", "\n", @@ -223,9 +315,104 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "show_deps(dist.marginals[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "log_potentials = torch.rand(batch, N, M, 3)\n", + "\n", + "# Local values must be postive for match and negative for skip.\n", + "log_potentials[..., 0] = -log_potentials[..., 0].abs()\n", + "log_potentials[..., 1] = log_potentials[..., 1].abs()\n", + "log_potentials[..., 2] = -log_potentials[..., 2].abs()\n", + "\n", + "# Block off top rows and columns\n", + "log_potentials[..., :2, :, 1] = 0\n", + "log_potentials[..., :, :2, 1] = 0\n", + "log_potentials[..., -2:, :, 1] = 0\n", + "log_potentials[..., :, -2:, 1] = 0\n", + "\n", + "dist = torch_struct.AlignmentCRF(log_potentials, local=True)\n", + "show_deps(dist.argmax[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "log_potentials[..., 3, 7, 1] = 50\n", + "dist = torch_struct.AlignmentCRF(log_potentials, local=True)\n", + "show_deps(dist.argmax[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "show_deps(dist.marginals[0])" ] @@ -634,7 +821,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.1" } }, "nbformat": 4, diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index c3282df7..bc0658a8 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -12,8 +12,11 @@ def __init__(self, semiring=LogSemiring, local=False): def _check_potentials(self, edge, lengths=None): batch, N_1, M_1, x = edge.shape assert x == 3 + if self.local: + assert (edge[..., 0] <= 0).all(), "skips must be negative" + assert (edge[..., 1] >= 0).all(), "alignment must be positive" + assert (edge[..., 2] <= 0).all(), "skips must be negative" edge = self.semiring.convert(edge) - N = N_1 M = M_1 if lengths is None: @@ -43,7 +46,10 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): Open, Close = 0, 1 # Create a chart N, N, back chart = self._make_chart( - log_MN + 1, (batch, bin_MN, bin_MN, 2, bin_MN, 2, 3), log_potentials, force_grad + log_MN + 1, + (batch, bin_MN, bin_MN, bin_MN, 2, 2, 3), + log_potentials, + force_grad, ) # Init @@ -63,74 +69,83 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): point = (end + M) // 2 point = (end + M) // 2 lim = point * 2 - chart[1][:, b, point : bin_MN // 2, ind, :, ind, :, Mid] = semiring.one_( - chart[1][:, b, point : bin_MN // 2, ind, :, ind, :, Mid] + chart[1][:, b, point : bin_MN // 2, ind, ind, :, :, Mid] = semiring.one_( + chart[1][:, b, point : bin_MN // 2, ind, ind, :, :, Mid] + ) + + chart[0][:, b, rot_x[:lim], rot_y[:lim], rot_y[:lim], :, :, :] = ( + log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) ) - chart[0][ - :, b, rot_x[: end + M], rot_y[:lim], :, rot_y[:lim], :, : - ] = log_potentials[:, b, : end + M].view(ssize, end+M, 1, lim, 1, 3) # if self.local: # chart[0][ # :, b, rot_x[: end + M], rot_y[:lim], rot_y[:lim], 3 # ] = log_potentials[:, b, : end + M, :, 1] - - + for b in range(lengths.shape[0]): end = lengths[b] point = (end + M) // 2 lim = point * 2 mid = semiring.sum( - torch.stack( - [ - chart[0][:, b, :lim:2, ind_M, :, ind_M, :, Mid], - chart[0][:, b, 1:lim:2, ind_M, :, ind_M, :, Mid], - ], - dim=-1, - ) - ) + torch.stack( + [ + chart[0][:, b, :lim:2, ind_M, ind_M, :, :, Mid], + chart[0][:, b, 1:lim:2, ind_M, ind_M, :, :, Mid], + ], + dim=-1, + ) + ) - chart[1][:, b, :point, ind_M, :, ind_M, :, :] = torch.stack( + chart[1][:, b, :point, ind_M, ind_M, :, :, :] = torch.stack( [ - chart[0][:, b, :lim:2, ind_M, :, ind_M, :, Down], - mid, - chart[0][:, b, :lim:2, ind_M, :, ind_M, :, Up] + chart[0][:, b, :lim:2, ind_M, ind_M, :, :, Down], + mid, + chart[0][:, b, :lim:2, ind_M, ind_M, :, :, Up], ], dim=-1, ) - x = torch.stack([ind_U, ind_D], dim=0) y = torch.stack([ind_D, ind_U], dim=0) q = torch.stack( [ semiring.times( - chart[0][:, b, :lim:2, ind_D, Open:Open+1, ind_D, :, :], - chart[0][:, b, 1:lim:2, ind_U, :, ind_U, Open:Open+1, Down : Down + 1], + chart[0][:, b, :lim:2, ind_D, ind_D, Open : Open + 1, :, :], + chart[0][ + :, + b, + 1:lim:2, + ind_U, + ind_U, + :, + Open : Open + 1, + Down : Down + 1, + ], ), semiring.times( - chart[0][:, b, :lim:2, ind_U, Open:Open+1, ind_U, :, :], - chart[0][:, b, 1:lim:2, ind_D, :, ind_D, Open:Open+1, Up : Up + 1], + chart[0][:, b, :lim:2, ind_U, ind_U, Open : Open + 1, :, :], + chart[0][ + :, b, 1:lim:2, ind_D, ind_D, :, Open : Open + 1, Up : Up + 1 + ], ), ], dim=2, ) - - chart[1][:, b, :point, x, :, y, :, :] = q + chart[1][:, b, :point, x, y, :, :, :] = q # Scan def merge(x, size): left = ( x[:, :, 0 : size * 2 : 2] .permute(0, 1, 2, 4, 5, 6, 7, 3) - .view(ssize, batch, size, 1, 2, bin_MN, 2, 3, bin_MN) + .view(ssize, batch, size, 1, bin_MN, 1, 2, 2, 3, bin_MN) ) right = ( x[:, :, 1 : size * 2 : 2] - .permute(0, 1, 2, 3, 4, 6, 7, 5) - .view(ssize, batch, size, bin_MN, 2, 1, 1, 2, 3, bin_MN) + .permute(0, 1, 2, 3, 5, 6, 7, 4) + .view(ssize, batch, size, bin_MN, 1, 2, 1, 2, 1, 3, bin_MN) ) - exp = (ssize, batch, size, bin_MN, bin_MN, bin_MN) + st = [] for op in (Up, Down, Mid): a, b, c, d = 0, bin_MN, 0, bin_MN @@ -138,11 +153,16 @@ def merge(x, size): a, b, c, d = 1, bin_MN, 0, bin_MN - 1 if op == Down: a, b, c, d = 0, bin_MN - 1, 1, bin_MN - st.append(semiring.dot(left[..., Open, :, a:b], right[..., Open, op, c:d])) - + combine = semiring.dot( + left[..., Open, :, :, a:b], right[..., Open, :, op, c:d] + ) + st.append(combine) + + left = x[:, :, 0 : size * 2 : 2, :, :, Close, :, :] + right = x[:, :, 1 : size * 2 : 2, :, :, :, Close, :] if self.local: - st.append(left[..., :, Close, New, :].expand(exp)) - st.append(right[..., Close, :, New, :].expand(exp)]) + st.append(torch.stack([semiring.zero_(left.clone()), left], dim=-3)) + st.append(torch.stack([semiring.zero_(right.clone()), right], dim=-2)) st = torch.stack(st, dim=-1) return semiring.sum(st) @@ -152,16 +172,16 @@ def merge(x, size): size = int(size / 2) chart[n][:, :, :size] = merge(chart[n - 1], size) if self.local: - v = semiring.sum(semiring.sum(chart[-1][:, :, 0, :, Close, :, Close, Mid])) + v = semiring.sum(semiring.sum(chart[-1][:, :, 0, :, :, Close, Close, Mid])) else: - v = chart[-1][:, :, 0, M, Open, N, Open, Mid] + v = chart[-1][:, :, 0, M, N, Open, Open, Mid] return v, [log_potentials], None @staticmethod def _rand(min_n=2): - b = torch.randint(2, 4, (1,)) - N = torch.randint(min_n, 4, (1,)) - M = torch.randint(min_n, 4, (1,)) + b = torch.randint(2, 3, (1,)) + N = torch.randint(min_n, 6, (1,)) + M = torch.randint(min_n, 6, (1,)) return torch.rand(b, N, M, 3), (b.item(), (N).item()) def enumerate(self, edge, lengths=None): @@ -173,7 +193,7 @@ def enumerate(self, edge, lengths=None): if self.local: for i in range(N): for j in range(M): - d.setdefault((i , j ), []) + d.setdefault((i, j), []) d[i, j].append(([(i, j, 1)], edge[:, :, i, j, 1])) for i in range(N): @@ -206,11 +226,12 @@ def enumerate(self, edge, lengths=None): ) if self.local: positions = [x[0] for i in range(N) for j in range(M) for x in d[i, j]] - all_val = torch.stack([x[1] for i in range(N) for j in range(M) for x in d[i, j]], - dim=-1) + all_val = torch.stack( + [x[1] for i in range(N) for j in range(M) for x in d[i, j]], dim=-1 + ) _, ind = all_val.max(dim=-1) print(positions[ind[0, 0]]) else: all_val = torch.stack([x[1] for x in d[N - 1, M - 1]], dim=-1) - + return semiring.unconvert(semiring.sum(all_val)), None diff --git a/torch_struct/distributions.py b/torch_struct/distributions.py index 7ffa3599..0e84d473 100644 --- a/torch_struct/distributions.py +++ b/torch_struct/distributions.py @@ -35,11 +35,12 @@ class StructDistribution(Distribution): has_enumerate_support = True - def __init__(self, log_potentials, lengths=None): + def __init__(self, log_potentials, lengths=None, args={}): batch_shape = log_potentials.shape[:1] event_shape = log_potentials.shape[1:] self.log_potentials = log_potentials self.lengths = lengths + self.args = args super().__init__(batch_shape=batch_shape, event_shape=event_shape) def _new(self, *args, **kwargs): @@ -58,7 +59,7 @@ def log_prob(self, value): d = value.dim() batch_dims = range(d - len(self.event_shape)) - v = self.struct().score( + v = self._struct().score( self.log_potentials, value.type_as(self.log_potentials), batch_dims=batch_dims, @@ -73,7 +74,7 @@ def entropy(self): Returns: entropy (*batch_shape*) """ - return self.struct(EntropySemiring).sum(self.log_potentials, self.lengths) + return self._struct(EntropySemiring).sum(self.log_potentials, self.lengths) @lazy_property def argmax(self): @@ -83,7 +84,7 @@ def argmax(self): Returns: argmax (*batch_shape x event_shape*) """ - return self.struct(MaxSemiring).marginals(self.log_potentials, self.lengths) + return self._struct(MaxSemiring).marginals(self.log_potentials, self.lengths) def topk(self, k): r""" @@ -92,7 +93,7 @@ def topk(self, k): Returns: kmax (*k x batch_shape x event_shape*) """ - return self.struct(KMaxSemiring(k)).marginals( + return self._struct(KMaxSemiring(k)).marginals( self.log_potentials, self.lengths, _raw=True ) @@ -112,7 +113,7 @@ def marginals(self): Returns: marginals (*batch_shape x event_shape*) """ - return self.struct(LogSemiring).marginals(self.log_potentials, self.lengths) + return self._struct(LogSemiring).marginals(self.log_potentials, self.lengths) # @constraints.dependent_property # def support(self): @@ -125,7 +126,7 @@ def marginals(self): @lazy_property def partition(self): "Compute the partition function." - return self.struct(LogSemiring).sum(self.log_potentials, self.lengths) + return self._struct(LogSemiring).sum(self.log_potentials, self.lengths) def sample(self, sample_shape=torch.Size()): r""" @@ -142,7 +143,7 @@ def sample(self, sample_shape=torch.Size()): samples = [] for k in range(nsamples): if k % 10 == 0: - sample = self.struct(MultiSampledSemiring).marginals( + sample = self._struct(MultiSampledSemiring).marginals( self.log_potentials, lengths=self.lengths ) sample = sample.detach() @@ -165,13 +166,16 @@ def enumerate_support(self, expand=True): Returns: (enum, enum_lengths) - (*tuple cardinality x batch_shape x event_shape*) """ - _, _, edges, enum_lengths = self.struct().enumerate( + _, _, edges, enum_lengths = self._struct().enumerate( self.log_potentials, self.lengths ) # if expand: # edges = edges.unsqueeze(1).expand(edges.shape[:1] + self.batch_shape[:1] + edges.shape[1:]) return edges, enum_lengths + def _struct(self, sr=None): + return self.struct(sr if sr is not None else LogSemiring) + class LinearChainCRF(StructDistribution): r""" @@ -208,7 +212,7 @@ class LinearChainCRF(StructDistribution): class AlignmentCRF(StructDistribution): r""" - Represents basic alignment algorithm, i.e. dynamic-time warping or Needleman-Wunsch. + Represents basic alignment algorithm, i.e. dynamic-time warping, Needleman-Wunsch, and Smith-Waterman. Event shape is of the form: @@ -216,6 +220,7 @@ class AlignmentCRF(StructDistribution): log_potentials (tensor) : event_shape (*N x M x 3*), e.g. :math:`\phi(i, j, op)` Ops are 0 -> j-1, 1->i-1,j-1, and 2->i-1 + local (bool): if true computes local alignment (Smith-Waterman), else Needleman-Wunsch lengths (long tensor) : batch shape integers for length masking. @@ -227,6 +232,13 @@ class AlignmentCRF(StructDistribution): """ struct = Alignment + def __init__(self, log_potentials, local=False, lengths=None): + self.local = local + super().__init__(log_potentials, lengths) + + def _struct(self, sr=None): + return self.struct(sr if sr is not None else LogSemiring, self.local) + class HMM(StructDistribution): r""" diff --git a/torch_struct/test_algorithms.py b/torch_struct/test_algorithms.py index b324d88b..e5732ac5 100644 --- a/torch_struct/test_algorithms.py +++ b/torch_struct/test_algorithms.py @@ -309,18 +309,19 @@ def test_alignment(data): count = struct.enumerate(vals)[0] assert torch.isclose(count, alpha).all() - semiring = data.draw(sampled_from([MaxSemiring])) struct = model(semiring, local=True) vals, (batch, N) = model._rand() - vals[..., 0] = -vals[..., 0].abs() + vals[..., 0] = -2 * vals[..., 0].abs() vals[..., 1] = vals[..., 1].abs() - vals[..., 2] = -vals[..., 2].abs() + # vals[:, 1, 2,1] = 0 + vals[..., 2] = -2 * vals[..., 2].abs() alpha = struct.sum(vals) count = struct.enumerate(vals)[0] mx = struct.marginals(vals) print(alpha, count) print(mx[0].nonzero()) + # assert(False) assert torch.isclose(count, alpha).all() From 14576efd417844ef55f81f8be0ca6b0f61a57d08 Mon Sep 17 00:00:00 2001 From: Sasha Date: Tue, 29 Oct 2019 11:38:39 -0400 Subject: [PATCH 06/26] . --- docs/source/model.ipynb | 646 ++++++++++++++++++++++++++++++++++++---- 1 file changed, 592 insertions(+), 54 deletions(-) diff --git a/docs/source/model.ipynb b/docs/source/model.ipynb index e5aaa166..aba30561 100644 --- a/docs/source/model.ipynb +++ b/docs/source/model.ipynb @@ -62,7 +62,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -91,7 +91,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -200,7 +200,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -230,7 +230,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -287,12 +287,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -315,12 +315,19 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAAGbCAYAAAD5r4b7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAPEklEQVR4nO3dzavlB33H8c935uZh8oAPJK2YpCYLsY2CVQZRAy7UhVbRTRcKCnWTTdUogmg3/gMiuhAhjQpF0UV0ISJqQV20i+AkETSJpUGteZIkWGOap8nM/XYx0xKTc50zyf3md87N6wWBueec/PjwY+553985996p7g4A7LdDSw8A4GASGABGCAwAIwQGgBECA8CInYmD1iXVuXLiyM/NS29eesFqjyw9YA9PLj1gD7tLDwD+RHfXqttHApMrk/x05MjPybs29HrtpqUH7OG+pQfs4bGlB+zhxNIDYMNs6FMuANtOYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBFrBaaq3lFV/1FVd1bVp6ZHAbD9zhiYqjqc5ItJ3pnk6iTvr6qrp4cBsN3WuYJ5Q5I7u/tX3X08yTeTvHd2FgDbbp3AXJbkrqd8fPfp2/5EVV1bVceq6lge2K95AGyrfXuTv7uv7+6j3X00l+7XUQHYVusE5p4kVzzl48tP3wYAe1onMD9N8sqquqqqzk3yviTfmZ0FwLbbOdMDuvtEVX04yQ+SHE7yle6+bXwZAFvtjIFJku7+XpLvDW8B4ADxk/wAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8CItX6b8lm7+bLk0EdHDv1c/OFl/7L0hJX+9uEHl56w0u6jv196wkoP1MmlJ6z0+O7u0hP2dHzpAXvopQcwyhUMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAworp7/w9a53fyin0/7nN1yaUXLD1hpSseednSE1Z6Wd289ISVHjzx2NITVnrgyeNLT9jTPbtPLj1hpRPZ/+ef/bCZqzZXd9eq213BADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8CIMwamqq6oqh9X1e1VdVtVXfd8DANgu+2s8ZgTST7R3bdU1cVJbq6qf+3u24e3AbDFzngF0933dfctp//8cJI7klw2PQyA7bbOFcz/q6ork7wuyU0r7rs2ybXP4rAAHEBrv8lfVRcl+VaSj3X3H59+f3df391Hu/tocng/NwKwhdYKTFWdk1Nx+Xp3f3t2EgAHwTrfRVZJvpzkju7+3PwkAA6Cda5grknywSRvraqfnf7v74Z3AbDlzvhufHf/W5J6HrYAcID4SX4ARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWBEdff+H7R2Orlo34/7XJ1/+OKlJ6x0/pEjS09Y6aIjm/n1x3mPPbr0hJWO9Ob+S673PHb30hNWemR3d+kJKx3PZu7aVN298jfub+YzCABbT2AAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACN2Zg57MskjM4d+Do7vbmZP64mTS09Y6VBeuvSElc7L/yw9YaX/PvzqpSfs6S/P//3SE1Z66Iknlp6w0v0nN3PXZj5T7G0zn3EB2HoCA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEasHZiqOlxVt1bVdycHAXAwnM0VzHVJ7pgaAsDBslZgquryJO9KcsPsHAAOinWvYD6f5JNJdge3AHCAnDEwVfXuJPd3981neNy1VXWsqo7t2zoAttY6VzDXJHlPVf0myTeTvLWqvvb0B3X39d19tLuP7vNGALbQGQPT3Z/u7su7+8ok70vyo+7+wPgyALaan4MBYMTO2Ty4u3+S5CcjSwA4UFzBADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAI87qtymfnZNzh36WdvvxpSes1Cc371wlyZPHz116wkoP1wVLT1ipDj259IQ9/b7/YukJK+3W8aUnrHTk0L1LT1jpkd0TS094hv4z97mCAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACN25g7dc4d+1p5YesBKx3c38VwluycfXnrCSuedd/7SE1baOVlLT9jThYcOLz1hpeOHzll6wkp1+KKlJ6z0+BN/XHrCM5zI7p73uYIBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBFrBaaqXlxVN1bVL6vqjqp60/QwALbbuv/g2BeSfL+7/76qzk1yweAmAA6AMwamql6U5C1J/iFJuvt4kuOzswDYduu8RHZVkgeSfLWqbq2qG6rqwqc/qKqurapjVXVs31cCsHXWCcxOktcn+VJ3vy7JI0k+9fQHdff13X20u4/u80YAttA6gbk7yd3dfdPpj2/MqeAAwJ7OGJju/l2Su6rqVadveluS20dXAbD11v0uso8k+frp7yD7VZIPzU0C4CBYKzDd/bMk3lsBYG1+kh+AEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABix7q/rPyB2lx6w0m6OLz1hpZO7m3m+Hn38yNITVrr00ENLT9jT+eecu/SElV5cm/l37K66dOkJK9WJx5ae8Ax1cu/nL1cwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPAiJ2lB5Aku0sPWOlkH196wkqP9oNLT1jpvpxcesKeLtk9vPSElS64+LKlJ6z02s38lMz9u5v3d/8/Hz+x532uYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFgxFqBqaqPV9VtVfWLqvpGVZ0/PQyA7XbGwFTVZUk+muRod78myeEk75seBsB2W/clsp0kR6pqJ8kFSe6dmwTAQXDGwHT3PUk+m+S3Se5L8lB3//Dpj6uqa6vqWFUd2/+ZAGybdV4ie0mS9ya5KsnLk1xYVR94+uO6+/ruPtrdR/d/JgDbZp2XyN6e5Nfd/UB3P5nk20nePDsLgG23TmB+m+SNVXVBVVWStyW5Y3YWANtunfdgbkpyY5Jbkvz89P9z/fAuALbczjoP6u7PJPnM8BYADhA/yQ/ACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIyo7t7/g1bt/0Fhw1UdXnrCnnYOXbz0hJUuOfKipSes9Oq6aOkJK735b/5q6QnP8M+/+Pfc+8hDteo+VzAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8CI6u79P2jVA0n+a58Od0mSB/fpWC8EztfZcb7OjvN1dl4I5+sV3X3pqjtGArOfqupYdx9dese2cL7OjvN1dpyvs/NCP19eIgNghMAAMGIbAnP90gO2jPN1dpyvs+N8nZ0X9Pna+PdgANhO23AFA8AWEhgARmxsYKrqHVX1H1V1Z1V9auk9m6yqrqiqH1fV7VV1W1Vdt/SmbVBVh6vq1qr67tJbNl1VvbiqbqyqX1bVHVX1pqU3bbqq+vjpz8dfVNU3qur8pTc93zYyMFV1OMkXk7wzydVJ3l9VVy+7aqOdSPKJ7r46yRuT/KPztZbrktyx9Igt8YUk3+/uv07y2jhvf1ZVXZbko0mOdvdrkhxO8r5lVz3/NjIwSd6Q5M7u/lV3H0/yzSTvXXjTxuru+7r7ltN/fjinPvkvW3bVZquqy5O8K8kNS2/ZdFX1oiRvSfLlJOnu4939h2VXbYWdJEeqaifJBUnuXXjP825TA3NZkrue8vHd8YS5lqq6Msnrkty07JKN9/kkn0yyu/SQLXBVkgeSfPX0S4o3VNWFS4/aZN19T5LPJvltkvuSPNTdP1x21fNvUwPDs1BVFyX5VpKPdfcfl96zqarq3Unu7+6bl96yJXaSvD7Jl7r7dUkeSeJ90T+jql6SU6+6XJXk5UkurKoPLLvq+bepgbknyRVP+fjy07exh6o6J6fi8vXu/vbSezbcNUneU1W/yamXX99aVV9bdtJGuzvJ3d39f1fFN+ZUcNjb25P8ursf6O4nk3w7yZsX3vS829TA/DTJK6vqqqo6N6feHPvOwps2VlVVTr0+fkd3f27pPZuuuz/d3Zd395U59XfrR939gvvqcl3d/bskd1XVq07f9LYkty84aRv8Nskbq+qC05+fb8sL8BsjdpYesEp3n6iqDyf5QU5998VXuvu2hWdtsmuSfDDJz6vqZ6dv+6fu/t6CmzhYPpLk66e/4PtVkg8tvGejdfdNVXVjklty6rs8b80L8NfG+FUxAIzY1JfIANhyAgPACIEBYITAADBCYAAYITAAjBAYAEb8LyVxioctQuTkAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -337,12 +344,12 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -373,7 +380,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -397,12 +404,12 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAAGbCAYAAAD5r4b7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAOS0lEQVR4nO3dzavlB33H8c83c5OYpyZabYtJ2mShliCUyFTUgAvjQqvoposICnWTTdUogmj/hCKiFBGmUTcGXcQsrIhaUBftIjhJLObBQIg2zxjb5qFWnZnMt4u5LWnmjHOm3u/8zrnzekFg7jknhw8/5t73/M4595zq7gDAXjtv6QEA7E8CA8AIgQFghMAAMEJgABixM3GndaB65p5/Nxs4KUlyYENfyHfegaUXrHbe8aUXrHbk2NILTu3ohh4z9ofurlWXz/zM3UnyRyP3/Dt5xcpDsLyXv7D0gtUu/L2lF6x28a+XXrDaY08vveDUnvqvpResdmxD/+6zNzxEBsAIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEasFZiqekdVPVhVD1XVJ6dHAbD9ThuYqjqQ5PNJ3pnkuiTvq6rrpocBsN3WOYN5Y5KHuvvh7j6S5GtJ3js7C4Btt05grkzy6Iu+fmz3sv+jqm6uqsNVdTg+pQ7gnLdnH5nc3YeSHEqSurA29FPmAThb1jmDeTzJ1S/6+qrdywDglNYJzA+TvKaqrq2qC5LclOQbs7MA2HanfYisu49V1YeSfCfJgSRf6u77xpcBsNXWeg6mu7+V5FvDWwDYR/wmPwAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMKK69/7DJ6uqc2Dz2nX+y85fesJKl2YzPwD0/Es283j9wUWXLz1hpWuuOLr0hFN68Ilnlp6w0lP/fmzpCSs9/8Jmfk9uqu6uVZdvXgUA2BcEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAworp77++0au/vdB+rCzaz8xddUEtPWOmKY5u567LLL156wim99j2vWXrCSv/w93ctPWG13196wGr1b0svOFkn6e6V35Sb+ZMNgK0nMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWDEaQNTVVdX1fer6v6quq+qbjkbwwDYbjtr3OZYko93991VdVmSu6rqH7v7/uFtAGyx057BdPeT3X337p+fT/JAkiunhwGw3dY5g/lfVXVNkuuT3LniupuT3LwnqwDYemsHpqouTfL1JB/t7udeen13H0pyaPe2vWcLAdhKa72KrKrOz4m43Nbdd8xOAmA/WOdVZJXki0ke6O7PzE8CYD9Y5wzmhiQfSPK2qvrR7n9/MbwLgC132udguvufktRZ2ALAPuI3+QEYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBHVvfcfPukTLYG1PL30gNX++FWXLT1hpSfOe37pCSc5djzp7pXvuO8MBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGLGz9ADgHPaqv1t6wUrP//nfLj1hpfP+5VdLTzhJHT12yuucwQAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPAiLUDU1UHquqeqvrm5CAA9oczOYO5JckDU0MA2F/WCkxVXZXkXUlunZ0DwH6x7hnMZ5N8IsnxwS0A7COnDUxVvTvJz7v7rtPc7uaqOlxVh/dsHQBba50zmBuSvKeqfpbka0neVlVfeemNuvtQdx/s7oN7vBGALXTawHT3p7r7qu6+JslNSb7X3e8fXwbAVvN7MACM2DmTG3f3D5L8YGQJAPuKMxgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWDEGb2bMsDe+uelB6z0wnOvW3rCSudd+oulJ5zs2RdOeZUzGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBiZ+kBwLnswaUHrHT8mdcuPWGlnbp06QknOZKjp7zOGQwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjFgrMFV1RVXdXlU/qaoHqurN08MA2G7rfuDY55J8u7v/sqouSHLx4CYA9oHTBqaqLk/y1iR/lSTdfSTJkdlZAGy7dR4iuzbJ00m+XFX3VNWtVXXJS29UVTdX1eGqOrznKwHYOusEZifJG5J8obuvT/LLJJ986Y26+1B3H+zug3u8EYAttE5gHkvyWHffufv17TkRHAA4pdMGprufSvJoVb1u96Ibk9w/ugqArbfuq8g+nOS23VeQPZzkg3OTANgP1gpMd/8oiedWAFib3+QHYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGrPt2/QADHll6wEq//s0fLj1hpQsuu2zpCSd77tlTXuUMBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGLGz9ADgXPafSw9YqX/1zNITVjp+/iuXnnCS7qdOeZ0zGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYsVZgqupjVXVfVd1bVV+tqpdNDwNgu502MFV1ZZKPJDnY3a9PciDJTdPDANhu6z5EtpPkoqraSXJxkifmJgGwH5w2MN39eJJPJ3kkyZNJnu3u7770dlV1c1UdrqrDez8TgG2zzkNkL0/y3iTXJnl1kkuq6v0vvV13H+rug919cO9nArBt1nmI7O1JftrdT3f30SR3JHnL7CwAtt06gXkkyZuq6uKqqiQ3JnlgdhYA226d52DuTHJ7kruT/Hj3/zk0vAuALVfdvfd3WrX3dwrsQxcuPWClAxdev/SElc7/veNLTzjJb/7j3hw/+stadZ3f5AdghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEbsLD0AOJcdWXrASi8cvXfpCStd9IrNe5fnI8+d+jzFGQwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADBCYAAYITAAjBAYAEYIDAAjBAaAEQIDwAiBAWCEwAAwQmAAGCEwAIwQGABGCAwAIwQGgBECA8AIgQFghMAAMEJgABghMACMEBgARggMACMEBoARAgPACIEBYITAADCiunvv77Tq6ST/ukd398okv9ij+zoXOF5nxvE6M47XmTkXjtefdPerVl0xEpi9VFWHu/vg0ju2heN1ZhyvM+N4nZlz/Xh5iAyAEQIDwIhtCMyhpQdsGcfrzDheZ8bxOjPn9PHa+OdgANhO23AGA8AWEhgARmxsYKrqHVX1YFU9VFWfXHrPJquqq6vq+1V1f1XdV1W3LL1pG1TVgaq6p6q+ufSWTVdVV1TV7VX1k6p6oKrevPSmTVdVH9v9fry3qr5aVS9betPZtpGBqaoDST6f5J1Jrkvyvqq6btlVG+1Yko9393VJ3pTkrx2vtdyS5IGlR2yJzyX5dnf/aZI/i+P2W1XVlUk+kuRgd78+yYEkNy276uzbyMAkeWOSh7r74e4+kuRrSd678KaN1d1Pdvfdu39+Pie++a9cdtVmq6qrkrwrya1Lb9l0VXV5krcm+WKSdPeR7n5m2VVbYSfJRVW1k+TiJE8svOes29TAXJnk0Rd9/Vj8wFxLVV2T5Pokdy67ZON9NsknkhxfesgWuDbJ00m+vPuQ4q1VdcnSozZZdz+e5NNJHknyZJJnu/u7y646+zY1MPw/VNWlSb6e5KPd/dzSezZVVb07yc+7+66lt2yJnSRvSPKF7r4+yS+TeF70t6iql+fEoy7XJnl1kkuq6v3Lrjr7NjUwjye5+kVfX7V7GadQVefnRFxu6+47lt6z4W5I8p6q+llOPPz6tqr6yrKTNtpjSR7r7v85K749J4LDqb09yU+7++nuPprkjiRvWXjTWbepgflhktdU1bVVdUFOPDn2jYU3bayqqpx4fPyB7v7M0ns2XXd/qruv6u5rcuLv1ve6+5z71+W6uvupJI9W1et2L7oxyf0LTtoGjyR5U1VdvPv9eWPOwRdG7Cw9YJXuPlZVH0rynZx49cWXuvu+hWdtshuSfCDJj6vqR7uX/U13f2vBTewvH05y2+4/+B5O8sGF92y07r6zqm5PcndOvMrznpyDbxvjrWIAGLGpD5EBsOUEBoARAgPACIEBYITAADBCYAAYITAAjPhvXW5JlchBELgAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -435,9 +442,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "batch, N, N = 3, 10, 10\n", "def show_deps(tree):\n", @@ -450,18 +470,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "show_deps(dist.marginals[0])" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Convert from 1-index standard format. (Head is 0)\n", "event = dist.to_event(torch.tensor([[2, 3, 4, 1, 0, 4]]), None)\n", @@ -486,9 +532,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "batch, N, N = 3, 10, 10\n", "def show_deps(tree):\n", @@ -517,9 +576,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "batch, N, NT = 3, 20, 3\n", "def show_tree(tree):\n", @@ -535,9 +607,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "show_tree(dist.marginals[0])" ] @@ -560,7 +645,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -581,9 +666,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Rules\n", "show_prob_tree(rules[0])" @@ -591,9 +689,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Terminals\n", "plt.imshow(term[:1])" @@ -620,7 +741,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -650,9 +771,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "path = dist.greedy_argmax()\n", "show_ar(path[0])" @@ -660,18 +794,66 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[-12.3654, -12.3715, -12.1309]], grad_fn=)" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dist.log_prob(path.unsqueeze(0))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "out = dist.beam_topk(5)[:, 0]\n", "for i in range(3):\n", @@ -681,9 +863,53 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([5, 10, 4])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "out = dist.sample((5,))[:, 0 ]\n", "print(out.shape)\n", @@ -694,9 +920,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "out = dist.sample_without_replacement((5,))[:, 0]\n", "for i in range(3):\n", @@ -723,9 +986,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "batch, N, C = 3, 7, 2\n", "\n", @@ -739,9 +1027,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "show_chain(dist.marginals[0])\n", "plt.show()\n", @@ -750,7 +1063,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -764,27 +1077,229 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "show_samples(dist.sample((10,)))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAACSCAYAAAAttj/ZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAKrElEQVR4nO3df6xfd13H8eeL225zQ9iki5S2cTNUlChu46ZKZpbFMemQrCZgsiXqIJKbGKaoMbppMiJ/Tf/wVySQpat0CgxTRK+koW7ZCBIC7A47YBsd14akt5t2tGNQUWbH2z/u6XJ3/bYd+577Pfd++nwk39zz49Pzfp/c3Pvq95zP99xUFZIkrXUvGboBSZL6YKBJkppgoEmSmmCgSZKaYKBJkppgoEmSmjBWoCX5oST3JPla9/WiU4x7Nsn+7jU7Tk1JkkbJOJ9DS/KnwLGquj3JLcBFVfUHI8Ydr6qXjtGnJEmnNW6gHQCurqonkmwEPlVVrxkxzkCTJK2ocQPtm1V1Ybcc4KmT68vGnQD2AyeA26vqH09xvBlgBuCC8/P6H3/1OS+6t9XusS+dP3QL0kg/9rrvDN3CivJnb237Nk99o6ouHrXvjIGW5F7glSN2/RGwe2mAJXmqqv7ffbQkm6rqcJIfBe4Drqmqfz9d3emfPq++sG/LaXtby970qsuGbkEaad/j+4duYUX5s7e23Vt7Hqyq6VH71p3pH1fVG0+1L8l/Jtm45JLjkVMc43D39WCSTwGXA6cNNEmSvh/jTtufBW7qlm8C/mn5gCQXJTm3W94AXAk8MmZdSZKeZ9xAux24NsnXgDd26ySZTrKzG/MTwFySh4D7WbyHZqBJknp1xkuOp1NVR4FrRmyfA97ZLX8W+Klx6kiSdCY+KUSS1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1IReAi3J9iQHkswnuWXE/nOTfLTb//kkl/RRV5Kkk8YOtCRTwPuA64DXAjcmee2yYb8OPFVVrwb+HPiTcetKkrRUH+/QtgHzVXWwqp4B7gZ2LBuzA9jdLe8BrkmSHmpLkgT0E2ibgENL1he6bSPHVNUJ4GngFcsPlGQmyVySuSePPttDa5Kks8WqmhRSVXdU1XRVTV/8iqmh25EkrSF9BNphYMuS9c3dtpFjkqwDXg4c7aG2JElAP4H2ALA1yaVJzgFuAGaXjZkFbuqW3wbcV1XVQ21JkgBYN+4BqupEkpuBfcAUsKuqHk7yXmCuqmaBO4G/TTIPHGMx9CRJ6s3YgQZQVXuBvcu23bZk+X+AX+6jliRJo6yqSSGSJL1YBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJvQRaku1JDiSZT3LLiP1vT/Jkkv3d65191JUk6aR14x4gyRTwPuBaYAF4IMlsVT2ybOhHq+rmcetJkjRKH+/QtgHzVXWwqp4B7gZ29HBcSZJesLHfoQGbgENL1heAnxkx7q1JrgIeA36nqg4tH5BkBpgBOI/zedOrLuuhvdVp3+P7h25BGqnlnzu1bVKTQv4ZuKSqXgfcA+weNaiq7qiq6aqaXs+5E2pNktSCPgLtMLBlyfrmbttzqupoVX23W90JvL6HupIkPaePQHsA2Jrk0iTnADcAs0sHJNm4ZPV64NEe6kqS9Jyx76FV1YkkNwP7gClgV1U9nOS9wFxVzQK/leR64ARwDHj7uHUlSVqqj0khVNVeYO+ybbctWb4VuLWPWpIkjeKTQiRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTegl0JLsSnIkyVdOsT9J/irJfJIvJbmij7qSJJ3U1zu0DwLbT7P/OmBr95oB3t9TXUmSgJ4Crao+DRw7zZAdwF216HPAhUk29lFbkiSY3D20TcChJesL3bbnSTKTZC7J3P/y3Qm1JklqwaqaFFJVd1TVdFVNr+fcoduRJK0hkwq0w8CWJeubu22SJPViUoE2C/xaN9vxZ4Gnq+qJCdWWJJ0F1vVxkCQfAa4GNiRZAN4DrAeoqg8Ae4E3A/PAd4B39FFXkqSTegm0qrrxDPsLeFcftSRJGmVVTQqRJOnFMtAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElN6CXQkuxKciTJV06x/+okTyfZ371u66OuJEknrevpOB8E/hq46zRj/rWq3tJTPUmSnqeXd2hV9WngWB/HkiTpxejrHdoL8YYkDwGPA79XVQ8vH5BkBpjpVo/fW3sOTLC/DcA3JlVsauOkKj1nouc3AM+vN/OTKfN8LX//Wj43mPz5/cipdqSqeqmQ5BLgE1X1kyP2vQz4XlUdT/Jm4C+ramsvhXuSZK6qpofuY6V4fmub57d2tXxusLrObyKzHKvqW1V1vFveC6xPsmEStSVJZ4eJBFqSVyZJt7ytq3t0ErUlSWeHXu6hJfkIcDWwIckC8B5gPUBVfQB4G/AbSU4A/w3cUH1d6+zPHUM3sMI8v7XN81u7Wj43WEXn19s9NEmShuSTQiRJTTDQJElNMNCAJNuTHEgyn+SWofvp05keS7bWJdmS5P4kjyR5OMm7h+6pL0nOS/KFJA915/bHQ/e0EpJMJfm3JJ8Yupe+Jfl6ki93j/ybG7qfviW5MMmeJF9N8miSNwzaz9l+Dy3JFPAYcC2wADwA3FhVjwzaWE+SXAUcB+4a9RnBtS7JRmBjVX0xyQ8CDwK/1ML3r5sZfEH3+c31wGeAd1fV5wZurVdJfheYBl7W2uPxknwdmK6qJj9YnWQ3i4813JnkHOD8qvrmUP34Dg22AfNVdbCqngHuBnYM3FNvWn8sWVU9UVVf7Ja/DTwKbBq2q37UouPd6vru1dT/QJNsBn4R2Dl0L/r+JHk5cBVwJ0BVPTNkmIGBBou//A4tWV+gkV+IZ5vuaTWXA58ftpP+dJfj9gNHgHuqqplz6/wF8PvA94ZuZIUU8C9JHuwe7deSS4Engb/pLhnvTHLBkA0ZaGpCkpcCHwN+u6q+NXQ/famqZ6vqMmAzsC1JM5eNk7wFOFJVDw7dywr6uaq6ArgOeFd3C6AV64ArgPdX1eXAfwGDzkEw0OAwsGXJ+uZum9aI7v7Sx4APVdU/DN3PSugu5dwPbB+6lx5dCVzf3We6G/j5JH83bEv9qqrD3dcjwMdZvMXRigVgYclVgz0sBtxgDLTFSSBbk1za3dS8AZgduCe9QN3EiTuBR6vqz4bup09JLk5yYbf8AyxOXPrqsF31p6purarNVXUJiz9391XVrwzcVm+SXNBNVKK7FPcLQDOzjavqP4BDSV7TbboGGHQy1iT/fMyqVFUnktwM7AOmgF2j/rTNWjXqsWRVdeewXfXqSuBXgS9395oA/rB7CPZatxHY3c3EfQnw91XV3NT2hv0w8PHuMbbrgA9X1SeHbal3vwl8qHszcBB4x5DNnPXT9iVJbfCSoySpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCf8HMdcDHDKaoT8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "show_samples(dist.topk(10))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([256, 3, 7, 2, 2])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAACSCAYAAAAttj/ZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAKt0lEQVR4nO3df6xfdX3H8efL2wKCU5gls7bNYLFzM5sDvOlmWAgZMoszdIkugWSKRnMTI85tWTbYEsz8i+2P/cqMhpTOsqm41LndmcYOAsYZo3LRogIWr41Jb2Ertoh2brLie3/cU3K5+7ZFvud+T++nz0fyzT0/Pj3v98m3va9+z/ncc1NVSJK02r1g6AYkSeqDgSZJaoKBJklqgoEmSWqCgSZJaoKBJklqwliBluQnk9yV5Jvd1wtOMO7pJHu71+w4NSVJGiXj/Bxakj8HjlTVrUluAi6oqj8aMe5oVb1ojD4lSTqpcQNtH3BlVT2WZD3wmap65YhxBpokaUWNG2jfrarzu+UATxxfXzbuGLAXOAbcWlX/fILjzQAzAOedm9f83CvOet69aViPfPXcoVtYUT/76h8M3cKKaf290+r2fZ74TlVdOGrfKQMtyd3Ay0bs+hNg59IAS/JEVf2/+2hJNlTVwSQ/A9wDXFVV3zpZ3elfOqe+tGfTSXvT6ev1L79k6BZW1J5H9w7dwopp/b3T6nZ37bq/qqZH7Vtzqj9cVa870b4k/5lk/ZJLjodOcIyD3df9ST4DXAqcNNAkSfpxjDttfxa4oVu+AfiX5QOSXJDk7G55HXA58NCYdSVJepZxA+1W4Ook3wRe162TZDrJ9m7MzwNzSR4A7mXxHpqBJknq1SkvOZ5MVR0GrhqxfQ54Z7f8eeAXx6kjSdKp+KQQSVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITDDRJUhMMNElSEww0SVITegm0JFuT7Esyn+SmEfvPTvLxbv8Xk1zUR11Jko4bO9CSTAEfAK4BXgVcn+RVy4a9A3iiql4B/CXwZ+PWlSRpqT4+oW0B5qtqf1U9BdwJbFs2Zhuws1veBVyVJD3UliQJ6CfQNgAHlqwvdNtGjqmqY8CTwEuXHyjJTJK5JHOPH366h9YkSWeK02pSSFXdVlXTVTV94Uunhm5HkrSK9BFoB4FNS9Y3dttGjkmyBngJcLiH2pIkAf0E2n3A5iQXJzkLuA6YXTZmFrihW34zcE9VVQ+1JUkCYM24B6iqY0luBPYAU8COqnowyfuBuaqaBW4H/j7JPHCExdCTJKk3YwcaQFXtBnYv23bLkuX/AX6rj1qSJI1yWk0KkSTp+TLQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTTDQJElNMNAkSU0w0CRJTegl0JJsTbIvyXySm0bsf1uSx5Ps7V7v7KOuJEnHrRn3AEmmgA8AVwMLwH1JZqvqoWVDP15VN45bT5KkUfr4hLYFmK+q/VX1FHAnsK2H40qS9JyN/QkN2AAcWLK+APzyiHFvSnIF8Ajwe1V1YPmAJDPADMA5nMvrX35JD+1pCHse3Tt0Cyuq5b+bvndarSY1KeRfgYuq6tXAXcDOUYOq6raqmq6q6bWcPaHWJEkt6CPQDgKblqxv7LY9o6oOV9UPu9XtwGt6qCtJ0jP6CLT7gM1JLk5yFnAdMLt0QJL1S1avBR7uoa4kSc8Y+x5aVR1LciOwB5gCdlTVg0neD8xV1SzwO0muBY4BR4C3jVtXkqSl+pgUQlXtBnYv23bLkuWbgZv7qCVJ0ig+KUSS1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1AQDTZLUBANNktQEA02S1IReAi3JjiSHknz9BPuT5G+SzCf5apLL+qgrSdJxfX1C+zCw9ST7rwE2d68Z4IM91ZUkCegp0Krqs8CRkwzZBtxRi74AnJ9kfR+1JUmCyd1D2wAcWLK+0G17liQzSeaSzP0vP5xQa5KkFpxWk0Kq6raqmq6q6bWcPXQ7kqRVZFKBdhDYtGR9Y7dNkqReTCrQZoG3drMdfwV4sqoem1BtSdIZYE0fB0nyMeBKYF2SBeB9wFqAqvoQsBt4AzAP/AB4ex91JUk6rpdAq6rrT7G/gHf3UUuSpFFOq0khkiQ9XwaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCb0EWpIdSQ4l+foJ9l+Z5Mkke7vXLX3UlSTpuDU9HefDwN8Cd5xkzL9X1Rt7qidJ0rP08gmtqj4LHOnjWJIkPR99fUJ7Ll6b5AHgUeAPqurB5QOSzAAz3erRu2vXvgn2tw74zgTrTdpEz29q/aQqPWPC79/85Eotmtj5DfDewUTfv3bfu4FM+vx++kQ7UlW9VEhyEfCpqvqFEfteDPyoqo4meQPw11W1uZfCPUkyV1XTQ/exUjy/1c3zW71aPjc4vc5vIrMcq+p7VXW0W94NrE2ybhK1JUlnhokEWpKXJUm3vKWre3gStSVJZ4Ze7qEl+RhwJbAuyQLwPmAtQFV9CHgz8K4kx4D/Bq6rvq519ue2oRtYYZ7f6ub5rV4tnxucRufX2z00SZKG5JNCJElNMNAkSU0w0IAkW5PsSzKf5Kah++nTqR5Lttol2ZTk3iQPJXkwyXuH7qkvSc5J8qUkD3Tn9qdD97QSkkwl+UqSTw3dS9+SfDvJ17pH/s0N3U/fkpyfZFeSbyR5OMlrB+3nTL+HlmQKeAS4GlgA7gOur6qHBm2sJ0muAI4Cd4z6GcHVLsl6YH1VfTnJTwD3A7/ZwvvXzQw+r/v5zbXA54D3VtUXBm6tV0l+H5gGXtza4/GSfBuYrqomf7A6yU4WH2u4PclZwLlV9d2h+vETGmwB5qtqf1U9BdwJbBu4p960/liyqnqsqr7cLX8feBjYMGxX/ahFR7vVtd2rqf+BJtkI/Aawfehe9ONJ8hLgCuB2gKp6asgwAwMNFr/5HViyvkAj3xDPNN3Tai4FvjhsJ/3pLsftBQ4Bd1VVM+fW+SvgD4EfDd3ICing35Lc3z3aryUXA48Df9ddMt6e5LwhGzLQ1IQkLwI+AfxuVX1v6H76UlVPV9UlwEZgS5JmLhsneSNwqKruH7qXFfSrVXUZcA3w7u4WQCvWAJcBH6yqS4H/Agadg2CgwUFg05L1jd02rRLd/aVPAB+pqn8aup+V0F3KuRfYOnQvPbocuLa7z3Qn8GtJ/mHYlvpVVQe7r4eAT7J4i6MVC8DCkqsGu1gMuMEYaIuTQDYnubi7qXkdMDtwT3qOuokTtwMPV9VfDN1Pn5JcmOT8bvmFLE5c+sawXfWnqm6uqo1VdRGL/+7uqarfHrit3iQ5r5uoRHcp7teBZmYbV9V/AAeSvLLbdBUw6GSsSf76mNNSVR1LciOwB5gCdoz61Tar1ajHklXV7cN21avLgbcAX+vuNQH8cfcQ7NVuPbCzm4n7AuAfq6q5qe0N+yngk91jbNcAH62qTw/bUu/eA3yk+zCwH3j7kM2c8dP2JUlt8JKjJKkJBpokqQkGmiSpCQaaJKkJBpokqQkGmiSpCQaaJKkJ/wfA0wcUxG4uWgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Enumerate \n", "x,_ = dist.enumerate_support()\n", @@ -796,9 +1311,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plt.imshow(dist.entropy.detach().unsqueeze(0))" ] From 8d68ba1fe1533f29d62f274f4fc3220c29b4c63a Mon Sep 17 00:00:00 2001 From: Sasha Date: Tue, 29 Oct 2019 11:52:20 -0400 Subject: [PATCH 07/26] . --- torch_struct/alignment.py | 14 +++++++------- torch_struct/test_algorithms.py | 1 - 2 files changed, 7 insertions(+), 8 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index bc0658a8..2a813cd1 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -45,12 +45,12 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): Down, Mid, Up = 0, 1, 2 Open, Close = 0, 1 # Create a chart N, N, back - chart = self._make_chart( - log_MN + 1, - (batch, bin_MN, bin_MN, bin_MN, 2, 2, 3), + chart = [self._make_chart( + 1, + (batch, bin_MN // pow(2, i), bin_MN, bin_MN, 2, 2, 3), log_potentials, force_grad, - ) + )[0] for i in range(log_MN + 1)] # Init # This part is complicated. Rotate the scores by 45% and @@ -158,8 +158,8 @@ def merge(x, size): ) st.append(combine) - left = x[:, :, 0 : size * 2 : 2, :, :, Close, :, :] - right = x[:, :, 1 : size * 2 : 2, :, :, :, Close, :] + left = x[:, :, 0 :: 2, :, :, Close, :, :] + right = x[:, :, 1 :: 2, :, :, :, Close, :] if self.local: st.append(torch.stack([semiring.zero_(left.clone()), left], dim=-3)) st.append(torch.stack([semiring.zero_(right.clone()), right], dim=-2)) @@ -170,7 +170,7 @@ def merge(x, size): size = bin_MN // 2 for n in range(2, log_MN + 1): size = int(size / 2) - chart[n][:, :, :size] = merge(chart[n - 1], size) + chart[n][:] = merge(chart[n - 1], size) if self.local: v = semiring.sum(semiring.sum(chart[-1][:, :, 0, :, :, Close, Close, Mid])) else: diff --git a/torch_struct/test_algorithms.py b/torch_struct/test_algorithms.py index e5732ac5..eea2bce4 100644 --- a/torch_struct/test_algorithms.py +++ b/torch_struct/test_algorithms.py @@ -314,7 +314,6 @@ def test_alignment(data): vals, (batch, N) = model._rand() vals[..., 0] = -2 * vals[..., 0].abs() vals[..., 1] = vals[..., 1].abs() - # vals[:, 1, 2,1] = 0 vals[..., 2] = -2 * vals[..., 2].abs() alpha = struct.sum(vals) count = struct.enumerate(vals)[0] From 05e0c09e5eb5f41a41dd59e646abdadd1ec8b657 Mon Sep 17 00:00:00 2001 From: Sasha Date: Tue, 29 Oct 2019 15:08:27 -0400 Subject: [PATCH 08/26] . --- torch_struct/alignment.py | 100 ++++++++++++++++++-------------------- torch_struct/semirings.py | 3 ++ 2 files changed, 50 insertions(+), 53 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index 2a813cd1..f375b469 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -4,6 +4,11 @@ import math +def demote(x, index): + total = x.dim() + order = tuple(range(index)) + tuple(range(index + 1, total)) + (index, ) + return x.permute(order) + class Alignment(_Struct): def __init__(self, semiring=LogSemiring, local=False): self.semiring = semiring @@ -44,6 +49,20 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): Down, Mid, Up = 0, 1, 2 Open, Close = 0, 1 + + + # Grid + grid_x = torch.arange(N).view(N, 1).expand(N, M) + grid_y = torch.arange(M).view(1, M).expand(N, M) + rot_x = grid_x + grid_y + rot_y = grid_y - grid_x + N + + # Helpers + ind = torch.arange(bin_MN) + ind_M = ind + ind_U = torch.arange(1, bin_MN) + ind_D = torch.arange(bin_MN - 1) + # Create a chart N, N, back chart = [self._make_chart( 1, @@ -51,98 +70,73 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): log_potentials, force_grad, )[0] for i in range(log_MN + 1)] + # chartb = [self._make_chart( + # 1, + # (batch, bin_MN // pow(2, i), bin_MN, bin_MN // pow(2, log_MN - i), 2, 2, 3), + # log_potentials, + # force_grad, + # )[0] for i in range(log_MN + 1)] + # Init # This part is complicated. Rotate the scores by 45% and # then compress one. - grid_x = torch.arange(N).view(N, 1).expand(N, M) - grid_y = torch.arange(M).view(1, M).expand(N, M) - rot_x = grid_x + grid_y - rot_y = grid_y - grid_x + N - ind = torch.arange(bin_MN) - ind_M = ind - ind_U = torch.arange(1, bin_MN) - ind_D = torch.arange(bin_MN - 1) + for b in range(lengths.shape[0]): end = lengths[b] - # Add path to end. - point = (end + M) // 2 point = (end + M) // 2 lim = point * 2 - chart[1][:, b, point : bin_MN // 2, ind, ind, :, :, Mid] = semiring.one_( - chart[1][:, b, point : bin_MN // 2, ind, ind, :, :, Mid] + chart[1][:, b, point:, ind, ind, :, :, Mid] = semiring.one_( + chart[1][:, b, point:, ind, ind, :, :, Mid] ) - chart[0][:, b, rot_x[:lim], rot_y[:lim], rot_y[:lim], :, :, :] = ( log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) ) - # if self.local: - # chart[0][ - # :, b, rot_x[: end + M], rot_y[:lim], rot_y[:lim], 3 - # ] = log_potentials[:, b, : end + M, :, 1] - for b in range(lengths.shape[0]): end = lengths[b] point = (end + M) // 2 lim = point * 2 - mid = semiring.sum( - torch.stack( - [ - chart[0][:, b, :lim:2, ind_M, ind_M, :, :, Mid], - chart[0][:, b, 1:lim:2, ind_M, ind_M, :, :, Mid], - ], - dim=-1, - ) - ) + left_ = chart[0][:, b, 0:lim:2] + right = chart[0][:, b, 1:lim:2] chart[1][:, b, :point, ind_M, ind_M, :, :, :] = torch.stack( [ - chart[0][:, b, :lim:2, ind_M, ind_M, :, :, Down], - mid, - chart[0][:, b, :lim:2, ind_M, ind_M, :, :, Up], + left_[:, :, ind_M, ind_M, :, :, Down], + semiring.plus( + left_[:, :, ind_M, ind_M, :, :, Mid], + right[:, :, ind_M, ind_M, :, :, Mid]), + left_[:, :, ind_M, ind_M, :, :, Up], ], dim=-1, ) x = torch.stack([ind_U, ind_D], dim=0) y = torch.stack([ind_D, ind_U], dim=0) - q = torch.stack( + + tmp = torch.stack( [ semiring.times( - chart[0][:, b, :lim:2, ind_D, ind_D, Open : Open + 1, :, :], - chart[0][ - :, - b, - 1:lim:2, - ind_U, - ind_U, - :, - Open : Open + 1, - Down : Down + 1, - ], + left_[:, :, ind_D, ind_D, Open : Open+1 :, :], + right[:, :, ind_U, ind_U, :, Open : Open + 1, Down : Down + 1] ), semiring.times( - chart[0][:, b, :lim:2, ind_U, ind_U, Open : Open + 1, :, :], - chart[0][ - :, b, 1:lim:2, ind_D, ind_D, :, Open : Open + 1, Up : Up + 1 - ], + left_[:, :, ind_U, ind_U, Open : Open + 1, :, :], + right[:, :, ind_D, ind_D, :, Open : Open + 1, Up : Up + 1], ), ], dim=2, ) - chart[1][:, b, :point, x, y, :, :, :] = q + chart[1][:, b, :point, x, y, :, :, :] = tmp # Scan def merge(x, size): left = ( - x[:, :, 0 : size * 2 : 2] - .permute(0, 1, 2, 4, 5, 6, 7, 3) + demote(x[:, :, 0 : size * 2 : 2], 3) .view(ssize, batch, size, 1, bin_MN, 1, 2, 2, 3, bin_MN) ) right = ( - x[:, :, 1 : size * 2 : 2] - .permute(0, 1, 2, 3, 5, 6, 7, 4) + demote(x[:, :, 1 : size * 2 : 2], 4) .view(ssize, batch, size, bin_MN, 1, 2, 1, 2, 1, 3, bin_MN) ) @@ -158,10 +152,10 @@ def merge(x, size): ) st.append(combine) - left = x[:, :, 0 :: 2, :, :, Close, :, :] + left_ = x[:, :, 0 :: 2, :, :, Close, :, :] right = x[:, :, 1 :: 2, :, :, :, Close, :] if self.local: - st.append(torch.stack([semiring.zero_(left.clone()), left], dim=-3)) + st.append(torch.stack([semiring.zero_(left_.clone()), left_], dim=-3)) st.append(torch.stack([semiring.zero_(right.clone()), right], dim=-2)) st = torch.stack(st, dim=-1) diff --git a/torch_struct/semirings.py b/torch_struct/semirings.py index 551819a7..6021873c 100644 --- a/torch_struct/semirings.py +++ b/torch_struct/semirings.py @@ -55,6 +55,9 @@ def sum(xs, dim=-1): "Sum over *dim* of tensor." raise NotImplementedError() + @classmethod + def plus(cls, a, b): + return cls.sum(torch.stack([a, b], dim=-1)) class _Base(Semiring): @staticmethod From fc57f64be0b4ff52c054aa3bd49e8d7739fae24f Mon Sep 17 00:00:00 2001 From: Sasha Date: Tue, 29 Oct 2019 18:13:50 -0400 Subject: [PATCH 09/26] . --- torch_struct/alignment.py | 156 +++++++++++++++++++++++++++++++++++--- 1 file changed, 146 insertions(+), 10 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index f375b469..d9f84ee8 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -3,6 +3,14 @@ from .semirings import LogSemiring import math +def pad_conv(x, k, dim): + return sym_pad(x, k - 1, dim).unfold(dim, k, 1) + +def sym_pad(x, n, dim): + shape = list(x.shape) + shape[dim] = n // 2 + pad = torch.zeros(shape) + return torch.cat([pad, x, pad], dim=dim) def demote(x, index): total = x.dim() @@ -70,12 +78,21 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): log_potentials, force_grad, )[0] for i in range(log_MN + 1)] - # chartb = [self._make_chart( - # 1, - # (batch, bin_MN // pow(2, i), bin_MN, bin_MN // pow(2, log_MN - i), 2, 2, 3), - # log_potentials, - # force_grad, - # )[0] for i in range(log_MN + 1)] + + + charta = [self._make_chart( + 1, + (batch, bin_MN // pow(2, i), 2 * bin_MN // pow(2, log_MN - i), bin_MN, 2, 2, 3), + log_potentials, + force_grad, + )[0] for i in range(log_MN + 1)] + + chartb = [self._make_chart( + 1, + (batch, bin_MN // pow(2, i), bin_MN, 2* bin_MN // pow(2, log_MN- i), 2, 2, 3), + log_potentials, + force_grad, + )[0] for i in range(log_MN + 1)] # Init @@ -86,12 +103,26 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): end = lengths[b] point = (end + M) // 2 lim = point * 2 + chart[0][:, b, rot_x[:lim], rot_y[:lim], rot_y[:lim], :, :, :] = ( + log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) + ) + charta[0][:, b, rot_x[:lim], 0, rot_y[:lim], :, :, :] = ( + log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) + ) + chartb[0][:, b, rot_x[:lim], rot_y[:lim], 0, :, :, :] = ( + log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) + ) + chart[1][:, b, point:, ind, ind, :, :, Mid] = semiring.one_( chart[1][:, b, point:, ind, ind, :, :, Mid] ) - chart[0][:, b, rot_x[:lim], rot_y[:lim], rot_y[:lim], :, :, :] = ( - log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) + charta[1][:, b, point:, 1, ind, :, :, Mid] = semiring.one_( + charta[1][:, b, point:, 1, ind, :, :, Mid] ) + chartb[1][:, b, point:, ind, 1, :, :, Mid] = semiring.one_( + chartb[1][:, b, point:, ind, 1, :, :, Mid] + ) + for b in range(lengths.shape[0]): end = lengths[b] @@ -100,6 +131,9 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): left_ = chart[0][:, b, 0:lim:2] right = chart[0][:, b, 1:lim:2] + left2_ = charta[0][:, b, 0:lim:2] + right2 = chartb[0][:, b, 1:lim:2] + chart[1][:, b, :point, ind_M, ind_M, :, :, :] = torch.stack( [ left_[:, :, ind_M, ind_M, :, :, Down], @@ -111,9 +145,32 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): dim=-1, ) - x = torch.stack([ind_U, ind_D], dim=0) - y = torch.stack([ind_D, ind_U], dim=0) + charta[1][:, b, :point, 1, ind_M, :, :, :] = torch.stack( + [ + left2_[:, :, 0, ind_M, :, :, Down], + semiring.plus( + left2_[:, :, 0, ind_M, :, :, Mid], + right2[:, :, ind_M, 0, :, :, Mid]), + left2_[:, :, 0, ind_M, :, :, Up], + ], + dim=-1, + ) + chartb[1][:, b, :point, ind_M, 1, :, :, :] = \ + charta[1][:, b, :point, 1, ind_M, :, :, :] + x = torch.stack([ind_U, + ind_D], dim=0) + y = torch.stack([ind_D, + ind_U], dim=0) + z = y.clone() + z[0, :] = 2 + z[1, :] = 0 + + z2 = y.clone() + z2[0, :] = 0 + z2[1, :] = 2 + + # OLD tmp = torch.stack( [ semiring.times( @@ -128,8 +185,81 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): dim=2, ) chart[1][:, b, :point, x, y, :, :, :] = tmp + # OLD + + tmp = torch.stack( + [ + semiring.times( + left2_[:, :, 0, ind_D, Open : Open+1 :, :], + right2[:, :, ind_U, 0, :, Open : Open + 1, Down : Down + 1] + ), + semiring.times( + left2_[:, :, 0, ind_U, Open : Open + 1, :, :], + right2[:, :, ind_D, 0, :, Open : Open + 1, Up : Up + 1], + ), + ], + dim=2, + ) + charta[1][:, b, :point, z, y, :, :, :] = tmp + chartb[1][:, b, :point, x, z2, :, :, :] = tmp + + assert (charta[0][:, 0, :, 0, ind_M] == chart[0][:, 0, :, ind_M, ind_M]).all() + assert (chartb[0][:, 0, :, ind_M, 0] == chart[0][:, 0, :, ind_M, ind_M]).all() + + + assert (torch.isclose(charta[1][:, 0, :, 1, ind_M, :, :, Mid], + chart[1][:, 0, :, ind_M, ind_M, :, :, Mid]).all()) + + assert (torch.isclose(charta[1][:, 0, :, 1, ind_M, :, :, Down], + chart[1][:, 0, :, ind_M, ind_M, :, :, Down]).all()) + assert (charta[1][:, 0, :, 2, ind_D, :, :, Down] == chart[1][:, 0, :, ind_U, ind_D, :, :, Down]).all() + assert (charta[1][:, 0, :, 0, ind_U, :, :, Up] == chart[1][:, 0, :, ind_D, ind_U, :, :, Up]).all() + assert(charta[1][:, 0, :, 1, ind_M] == chart[1][:, 0, :, ind_M, ind_M]).all() + assert(charta[1][:, 0, :, 2, ind_D] == chart[1][:, 0, :, ind_U, ind_D]).all() + assert(charta[1][:, 0, :, 0, ind_U] == chart[1][:, 0, :, ind_D, ind_U]).all() + assert(chartb[1][:, 0, :, ind_M, 1] == chart[1][:, 0, :, ind_M, ind_M]).all() + assert(chartb[1][:, 0, :, ind_U, 0] == chart[1][:, 0, :, ind_U, ind_D]).all() + assert(chartb[1][:, 0, :, ind_D, 2] == chart[1][:, 0, :, ind_D, ind_U]).all() + + # assert(False) # Scan + def merge2(xa, xb, size, rsize): + print(rsize) + print(pad_conv(demote(xa[:, :, 0 : size * 2 : 2], 3), rsize, 3).shape) + print((ssize, batch, size, 1, bin_MN, 1, 2, 2, 3, rsize, rsize)) + left = ( + pad_conv(demote(xa[:, :, 0 : size * 2 : 2], 3), rsize+1, 3) + .view(ssize, batch, size, 1, bin_MN, 1, 2, 2, 3, rsize, rsize+1) + ) + right = ( + pad_conv(demote(xb[:, :, 1 : size * 2 : 2], 4), rsize+1, 3) + .view(ssize, batch, size, bin_MN, 1, 2, 1, 2, 1, 3, rsize, rsize+1) + ) + + st = [] + v = rsize + for op in (Up, Down, Mid): + a, b, c, d = 0, v, 0, v + if op == Up: + a, b, c, d = 1, v, 0, v -1 + if op == Down: + a, b, c, d = 0, v - 1, 1, v + combine = semiring.sum(semiring.dot( + left[..., Open, :, :, a:b, a:b], right[..., Open, :, op, c:d, c:d] + )) + st.append(combine) + + if self.local: + left_ = x[:, :, 0 :: 2, :, :, Close, :, :] + right = x[:, :, 1 :: 2, :, :, :, Close, :] + st.append(torch.stack([semiring.zero_(left_.clone()), left_], dim=-3)) + st.append(torch.stack([semiring.zero_(right.clone()), right], dim=-2)) + + st = torch.stack(st, dim=-1) + return semiring.sum(st) + + def merge(x, size): left = ( demote(x[:, :, 0 : size * 2 : 2], 3) @@ -162,9 +292,15 @@ def merge(x, size): return semiring.sum(st) size = bin_MN // 2 + rsize = 2 for n in range(2, log_MN + 1): size = int(size / 2) + rsize *= 2 chart[n][:] = merge(chart[n - 1], size) + q = merge2(charta[n - 1], chartb[n - 1], size, rsize) + # charta[n][:] = + assert (chart[n][0, 0, :, ind_M, ind_M] == q[0, 0, :, ind_M, ind_M]).all() + if self.local: v = semiring.sum(semiring.sum(chart[-1][:, :, 0, :, :, Close, Close, Mid])) else: From fd55b18860b3753ae1ce9ab38075e8601c70080a Mon Sep 17 00:00:00 2001 From: Alex Rush Date: Tue, 29 Oct 2019 23:11:02 -0400 Subject: [PATCH 10/26] . --- torch_struct/alignment.py | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index d9f84ee8..fd54f591 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -225,16 +225,16 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): # Scan def merge2(xa, xb, size, rsize): - print(rsize) - print(pad_conv(demote(xa[:, :, 0 : size * 2 : 2], 3), rsize, 3).shape) - print((ssize, batch, size, 1, bin_MN, 1, 2, 2, 3, rsize, rsize)) + # print(rsize) + # print(pad_conv(demote(xa[:, :, 0 : size * 2 : 2], 3), rsize, 3).shape) + # print((ssize, batch, size, bin_MN, 1, 2, 2, 3, rsize, rsize)) left = ( pad_conv(demote(xa[:, :, 0 : size * 2 : 2], 3), rsize+1, 3) - .view(ssize, batch, size, 1, bin_MN, 1, 2, 2, 3, rsize, rsize+1) + .view(ssize, batch, size, bin_MN, 1, 2, 2, 3, rsize, rsize+1) ) right = ( - pad_conv(demote(xb[:, :, 1 : size * 2 : 2], 4), rsize+1, 3) - .view(ssize, batch, size, bin_MN, 1, 2, 1, 2, 1, 3, rsize, rsize+1) + demote(xb[:, :, 1 : size * 2 : 2], 4) + .view(ssize, batch, size, bin_MN, 2, 1, 2, 1, 1, 3, rsize) ) st = [] @@ -245,8 +245,11 @@ def merge2(xa, xb, size, rsize): a, b, c, d = 1, v, 0, v -1 if op == Down: a, b, c, d = 0, v - 1, 1, v + print(left[..., Open, :, :, a:b, a:b].shape, + right[..., Open, :, :, op, c:d].shape) combine = semiring.sum(semiring.dot( - left[..., Open, :, :, a:b, a:b], right[..., Open, :, op, c:d, c:d] + left[..., Open, :, :, a:b, a:b], + right[..., Open, :, :, op, c:d] )) st.append(combine) @@ -277,7 +280,7 @@ def merge(x, size): a, b, c, d = 1, bin_MN, 0, bin_MN - 1 if op == Down: a, b, c, d = 0, bin_MN - 1, 1, bin_MN - combine = semiring.dot( + combine = semiring.times( left[..., Open, :, :, a:b], right[..., Open, :, op, c:d] ) st.append(combine) @@ -298,6 +301,7 @@ def merge(x, size): rsize *= 2 chart[n][:] = merge(chart[n - 1], size) q = merge2(charta[n - 1], chartb[n - 1], size, rsize) + print(q.shape) # charta[n][:] = assert (chart[n][0, 0, :, ind_M, ind_M] == q[0, 0, :, ind_M, ind_M]).all() From 15f368c489cdc9e3128c818885a211d21d62a975 Mon Sep 17 00:00:00 2001 From: Alex Rush Date: Wed, 30 Oct 2019 11:24:38 -0400 Subject: [PATCH 11/26] . --- torch_struct/alignment.py | 96 ++++++++++++++++++++++++++------- torch_struct/test_algorithms.py | 10 ++++ 2 files changed, 86 insertions(+), 20 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index fd54f591..fa9b93d4 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -3,13 +3,13 @@ from .semirings import LogSemiring import math -def pad_conv(x, k, dim): - return sym_pad(x, k - 1, dim).unfold(dim, k, 1) +def pad_conv(x, k, dim, sr): + return sym_pad(x, k - 1, dim, sr).unfold(dim, k, 1) -def sym_pad(x, n, dim): +def sym_pad(x, n, dim, sr): shape = list(x.shape) shape[dim] = n // 2 - pad = torch.zeros(shape) + pad = sr.zero_(torch.zeros(shape)) return torch.cat([pad, x, pad], dim=dim) def demote(x, index): @@ -228,13 +228,17 @@ def merge2(xa, xb, size, rsize): # print(rsize) # print(pad_conv(demote(xa[:, :, 0 : size * 2 : 2], 3), rsize, 3).shape) # print((ssize, batch, size, bin_MN, 1, 2, 2, 3, rsize, rsize)) + + nrsize = (rsize-1)*2+1 left = ( - pad_conv(demote(xa[:, :, 0 : size * 2 : 2], 3), rsize+1, 3) - .view(ssize, batch, size, bin_MN, 1, 2, 2, 3, rsize, rsize+1) + pad_conv(demote(xa[:, :, 0 : size * 2 : 2], 3), nrsize, 7, semiring) + .transpose(-1, -2) + .view(ssize, batch, size, bin_MN, 1, 2, 2, 3, nrsize, rsize) ) right = ( - demote(xb[:, :, 1 : size * 2 : 2], 4) - .view(ssize, batch, size, bin_MN, 2, 1, 2, 1, 1, 3, rsize) + pad_conv(demote(xb[:, :, 1 : size * 2 : 2], 4), nrsize, 3, semiring) + .transpose(-1, -2) + .view(ssize, batch, size, bin_MN, 2, 1, 2, 1, 3, nrsize, rsize) ) st = [] @@ -245,12 +249,12 @@ def merge2(xa, xb, size, rsize): a, b, c, d = 1, v, 0, v -1 if op == Down: a, b, c, d = 0, v - 1, 1, v - print(left[..., Open, :, :, a:b, a:b].shape, - right[..., Open, :, :, op, c:d].shape) - combine = semiring.sum(semiring.dot( - left[..., Open, :, :, a:b, a:b], - right[..., Open, :, :, op, c:d] - )) + combine = semiring.dot( + left[..., Open, :, :, :, a:b], + right[..., Open, :, :, op, :, c:d] + ) + combine = combine.view(ssize, batch, size, bin_MN, 2, 2, 3, nrsize) \ + .permute(0, 1, 2, 7, 3, 4, 5, 6) st.append(combine) if self.local: @@ -280,14 +284,15 @@ def merge(x, size): a, b, c, d = 1, bin_MN, 0, bin_MN - 1 if op == Down: a, b, c, d = 0, bin_MN - 1, 1, bin_MN - combine = semiring.times( + combine = semiring.dot( left[..., Open, :, :, a:b], right[..., Open, :, op, c:d] ) st.append(combine) - left_ = x[:, :, 0 :: 2, :, :, Close, :, :] - right = x[:, :, 1 :: 2, :, :, :, Close, :] if self.local: + left_ = x[:, :, 0 :: 2, :, :, Close, :, :] + right = x[:, :, 1 :: 2, :, :, :, Close, :] + st.append(torch.stack([semiring.zero_(left_.clone()), left_], dim=-3)) st.append(torch.stack([semiring.zero_(right.clone()), right], dim=-2)) @@ -297,18 +302,69 @@ def merge(x, size): size = bin_MN // 2 rsize = 2 for n in range(2, log_MN + 1): + print("round", n) size = int(size / 2) rsize *= 2 chart[n][:] = merge(chart[n - 1], size) - q = merge2(charta[n - 1], chartb[n - 1], size, rsize) + q = merge2(charta[n - 1], chartb[n - 1], size, charta[n - 1].shape[3]) + ex = q.shape[3] + q.view(ssize, batch, size, ex, bin_MN, 2, 2, 3) + print(q.shape, charta[n].shape) + charta[n] = q + + + f, r = torch.arange(ex), torch.arange(ex-1, -1, -1) + sp = pad_conv(q, ex, 4, semiring) + sp.view(ssize, batch, size, ex, bin_MN, 2, 2, 3, ex) + sp = sp[:, :, :, r, :, :, :, :, f].permute(1,2,3,4,0,5,6,7) \ + .view(ssize, batch, size, bin_MN, ex, 2, 2, 3) + + print(sp[0,0, :, 3, ex//2], q[0,0, :, ex//2, 3]) + assert((sp[0,0, :, 3, ex//2] == q[0,0, :, ex//2, 3]).all()) + print(sp[0,0, :, 3, ex//2 - 1], q[0,0, :, ex//2 +1, 2]) + assert((sp[0,0, :, 3, ex//2 + 1] == q[0,0, :, ex//2-1, 4]).all()) + + chartb[n] = sp + print(q.shape) # charta[n][:] = - assert (chart[n][0, 0, :, ind_M, ind_M] == q[0, 0, :, ind_M, ind_M]).all() - + print(q.shape) + print(n) + print(q[0, 0, :, 3, ind_M, Open, Open, Mid]) + print(chart[n][0, 0, :, ind_M, ind_M, Open, Open, Mid]) + assert (chart[n][0, 0, :, ind_M, ind_M, :, :, :] == + q[0, 0, :, q.shape[3] // 2, ind_M, :, :, :]).all(), "%s %s"%(n, q.shape[3]) + assert (chart[n][0, 0, :, ind_M, ind_M, :, :, :] == + sp[0, 0, :, ind_M, q.shape[3] // 2, :, :, :]).all(), "%s %s"%(n, q.shape[3]) + + print("pchart", chart[n-1][0, 0, 0, :, N, Open, Open, Mid]) + print("pconv", charta[n-1][0, 0, 0, :, N, Open, Open, Mid]) + print("pchart", chart[n-1][0, 0, 1, :, :, Open, Open, Mid]) + print("pconv", chartb[n-1][0, 0, 1, :, :, Open, Open, Mid]) + + + print("chart", chart[n][0, 0, 0, :, N, Open, Open, Mid]) + print("conv", charta[n][0, 0, 0, :, N, Open, Open, Mid]) + print("chart", chart[n][0, 0, 0, M, :, Open, Open, Mid]) + print("conv", chartb[n][0, 0, 0, M, :, Open, Open, Mid]) + + + + assert (chart[n][0, 0, :, ind_D, ind_U, :, :, :] == + q[0, 0, :, q.shape[3] // 2-1, ind_U, :, :, :]).all(), "%s %s"%(n, q.shape[3]) + + assert (chart[n][:, :, :, ind_M, ind_M, Open, Open, Mid] == + q[:, :, :, q.shape[3] // 2, ind_M, Open, Open, Mid]).all(), "%s %s"%(n, q.shape[3]) + if self.local: v = semiring.sum(semiring.sum(chart[-1][:, :, 0, :, :, Close, Close, Mid])) else: v = chart[-1][:, :, 0, M, N, Open, Open, Mid] + print("correct", chart[-1][:, :, 0, M, N, Open, Open, Mid]) + print("options",charta[-1][:, :, 0, :, N, Open, Open, Mid]) + print("options",chartb[-1][:, :, 0, M, :, Open, Open, Mid]) + v = charta[-1][:, :, 0, N - M + charta[-1].shape[3] //2, N, Open, Open, Mid] + print(v) return v, [log_potentials], None @staticmethod diff --git a/torch_struct/test_algorithms.py b/torch_struct/test_algorithms.py index eea2bce4..459acd6c 100644 --- a/torch_struct/test_algorithms.py +++ b/torch_struct/test_algorithms.py @@ -301,6 +301,16 @@ def test_params(data, seed): @given(data()) @settings(max_examples=50, deadline=None) def test_alignment(data): + model = data.draw(sampled_from([Alignment])) + semiring = data.draw(sampled_from([StdSemiring])) + struct = model(semiring) + vals, (batch, N) = model._rand() + vals.fill_(1) + + alpha = struct.sum(vals) + count = struct.enumerate(vals)[0] + assert torch.isclose(count, alpha).all() + return model = data.draw(sampled_from([Alignment])) semiring = data.draw(sampled_from([LogSemiring])) struct = model(semiring) From 38b5bad6bf48e5d057f2e73e3de53abc229d6724 Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 14:18:53 -0400 Subject: [PATCH 12/26] . --- torch_struct/alignment.py | 250 ++++++++++++++++++++------------ torch_struct/test_algorithms.py | 5 +- 2 files changed, 159 insertions(+), 96 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index fa9b93d4..db047bbd 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -3,14 +3,17 @@ from .semirings import LogSemiring import math -def pad_conv(x, k, dim, sr): - return sym_pad(x, k - 1, dim, sr).unfold(dim, k, 1) +def pad_conv(x, k, dim, sr, extra_b=0, extra_t=0): + return pad(x, (k - 1) // 2 + extra_b, (k-1)//2 + extra_t, dim, sr).unfold(dim, k, 1) -def sym_pad(x, n, dim, sr): +def pad(x, n_bot, n_top, dim, sr): shape = list(x.shape) - shape[dim] = n // 2 - pad = sr.zero_(torch.zeros(shape)) - return torch.cat([pad, x, pad], dim=dim) + shape[dim] = n_bot + padb = sr.zero_(torch.zeros(shape)) + shape[dim] = n_top + padt = sr.zero_(torch.zeros(shape)) + + return torch.cat([padb, x, padt], dim=dim) def demote(x, index): total = x.dim() @@ -82,19 +85,32 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): charta = [self._make_chart( 1, - (batch, bin_MN // pow(2, i), 2 * bin_MN // pow(2, log_MN - i), bin_MN, 2, 2, 3), + (batch, bin_MN // pow(2, i), 2 * bin_MN // pow(2, log_MN - i)-1, bin_MN, 2, 2, 3), log_potentials, force_grad, )[0] for i in range(log_MN + 1)] chartb = [self._make_chart( 1, - (batch, bin_MN // pow(2, i), bin_MN, 2* bin_MN // pow(2, log_MN- i), 2, 2, 3), + (batch, bin_MN // pow(2, i), bin_MN, 2* bin_MN // pow(2, log_MN- i) -1, 2, 2, 3), log_potentials, force_grad, )[0] for i in range(log_MN + 1)] + def reflect(x, size): + ex = x.shape[3] + f, r = torch.arange(ex), torch.arange(ex-1, -1, -1) + sp = pad_conv(x, ex, 4, semiring) + print(sp.shape) + print(bin_MN) + print((ssize, batch, size, ex, bin_MN, 2, 2, 3, ex)) + sp.view(ssize, batch, size, ex, bin_MN, 2, 2, 3, ex) + sp = sp[:, :, :, r, :, :, :, :, f].permute(1,2,3,4,0,5,6,7) \ + .view(ssize, batch, size, bin_MN, ex, 2, 2, 3) + return sp + + # Init # This part is complicated. Rotate the scores by 45% and # then compress one. @@ -103,9 +119,11 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): end = lengths[b] point = (end + M) // 2 lim = point * 2 + # OLD chart[0][:, b, rot_x[:lim], rot_y[:lim], rot_y[:lim], :, :, :] = ( log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) ) + # OLD charta[0][:, b, rot_x[:lim], 0, rot_y[:lim], :, :, :] = ( log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) ) @@ -113,16 +131,15 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) ) + # OLD chart[1][:, b, point:, ind, ind, :, :, Mid] = semiring.one_( chart[1][:, b, point:, ind, ind, :, :, Mid] ) + # OLD + charta[1][:, b, point:, 1, ind, :, :, Mid] = semiring.one_( charta[1][:, b, point:, 1, ind, :, :, Mid] ) - chartb[1][:, b, point:, ind, 1, :, :, Mid] = semiring.one_( - chartb[1][:, b, point:, ind, 1, :, :, Mid] - ) - for b in range(lengths.shape[0]): end = lengths[b] @@ -156,8 +173,6 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): dim=-1, ) - chartb[1][:, b, :point, ind_M, 1, :, :, :] = \ - charta[1][:, b, :point, 1, ind_M, :, :, :] x = torch.stack([ind_U, ind_D], dim=0) y = torch.stack([ind_D, @@ -201,7 +216,27 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): dim=2, ) charta[1][:, b, :point, z, y, :, :, :] = tmp - chartb[1][:, b, :point, x, z2, :, :, :] = tmp + + # chartb[1][:, b, point:, ind, 1, :, :, Mid] = semiring.one_( + # chartb[1][:, b, point:, ind, 1, :, :, Mid] + # ) + + # chartb[1][:, b, :point, ind_M, 1, :, :, :] = \ + # charta[1][:, b, :point, 1, ind_M, :, :, :] + + # chartb[1][:, b, :point, x, z2, :, :, :] = tmp + + # + + + # chartb[1][:, :, :, :, :3] = reflect(charta[1][:, :, :, :3], bin_MN // 2) + + + charta[1] = charta[1][:, :, :, :3] + chartb[1] = reflect(charta[1], bin_MN // 2) + + # charta[1].sum().backward() + # chartb[1].sum().backward() assert (charta[0][:, 0, :, 0, ind_M] == chart[0][:, 0, :, ind_M, ind_M]).all() assert (chartb[0][:, 0, :, ind_M, 0] == chart[0][:, 0, :, ind_M, ind_M]).all() @@ -224,45 +259,66 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): # assert(False) # Scan - def merge2(xa, xb, size, rsize): + def merge2(xa, xb, size, rsize, track): # print(rsize) # print(pad_conv(demote(xa[:, :, 0 : size * 2 : 2], 3), rsize, 3).shape) # print((ssize, batch, size, bin_MN, 1, 2, 2, 3, rsize, rsize)) - - nrsize = (rsize-1)*2+1 - left = ( - pad_conv(demote(xa[:, :, 0 : size * 2 : 2], 3), nrsize, 7, semiring) - .transpose(-1, -2) - .view(ssize, batch, size, bin_MN, 1, 2, 2, 3, nrsize, rsize) - ) - right = ( - pad_conv(demote(xb[:, :, 1 : size * 2 : 2], 4), nrsize, 3, semiring) - .transpose(-1, -2) - .view(ssize, batch, size, bin_MN, 2, 1, 2, 1, 3, nrsize, rsize) - ) + # print("RSIZE", rsize) + nrsize = (rsize-1)*2+3 + rsize += 2 + print("sizes", nrsize, rsize, track) st = [] - v = rsize + # v = rsize + 1 + # rsize = rsize + 1 for op in (Up, Down, Mid): - a, b, c, d = 0, v, 0, v + + top, bot = 1, 1 + # a, b, c, d = 0, v, 0, v + # s1, e1, s2, e2 = 0, bin_MN-1, 0, bin_MN-1 if op == Up: - a, b, c, d = 1, v, 0, v -1 + # a, b, c, d = 1, v, 0, v -1 + # s1, e1, s2, e2 = 0, bin_MN-1, 1, bin_MN + top, bot = 2, 0 if op == Down: - a, b, c, d = 0, v - 1, 1, v + # a, b, c, d = 0, v - 1, 1, v + # s1, e1, s2, e2 = 1, bin_MN, 0, bin_MN-1 + top, bot = 0, 2 + + # print(xa[:, :, 0 : size * 2 : 2, :].shape) + print(pad_conv(demote(xa[:, :, 0 : size * 2 : 2, :track], 3), nrsize, 7, semiring, bot, top) + .transpose(-1, -2).shape) + left = ( + pad_conv(demote(xa[:, :, 0 : size * 2 : 2, :track], 3), nrsize, 7, semiring, bot, top) + .transpose(-1, -2) + .view(ssize, batch, size, bin_MN, 1, 2, 2, 3, nrsize, rsize) + ) + print(pad(pad_conv(demote(xb[:, :, 1 : size * 2 : 2, :, :], 4), nrsize, 3, semiring), 1, 1, -2, semiring) + .transpose(-1, -2).shape +) + right = ( + pad(pad_conv(demote(xb[:, :, 1 : size * 2 : 2, :, :], 4), nrsize, 3, semiring), 1, 1, -2, semiring) + .transpose(-1, -2) + .view(ssize, batch, size, bin_MN, 2, 1, 2, 1, 3, nrsize, rsize) + ) + + combine = semiring.dot( - left[..., Open, :, :, :, a:b], - right[..., Open, :, :, op, :, c:d] + left[:, :, :, :, :, Open, :, :, :, :], + right[:, :, :, :, :, Open, :, :, op, :, :] ) combine = combine.view(ssize, batch, size, bin_MN, 2, 2, 3, nrsize) \ .permute(0, 1, 2, 7, 3, 4, 5, 6) st.append(combine) if self.local: - left_ = x[:, :, 0 :: 2, :, :, Close, :, :] - right = x[:, :, 1 :: 2, :, :, :, Close, :] + left_ = pad(xa[:, :, 0 :: 2, :track-1, :, Close, :, :], rsize//2, rsize//2, 3, semiring) + # print(xb.shape) + right = pad(xa[:, :, 1 :: 2, :track-1, :, :, Close, :], rsize//2, rsize//2, 3, semiring) + # print("X", rsize, xa[:, :, 1 :: 2, :track-1, :, :, Close, :].shape, right.shape) st.append(torch.stack([semiring.zero_(left_.clone()), left_], dim=-3)) st.append(torch.stack([semiring.zero_(right.clone()), right], dim=-2)) - + # print("SSS", st[0].shape, st[-2].shape, st[-1].shape) st = torch.stack(st, dim=-1) return semiring.sum(st) @@ -292,79 +348,87 @@ def merge(x, size): if self.local: left_ = x[:, :, 0 :: 2, :, :, Close, :, :] right = x[:, :, 1 :: 2, :, :, :, Close, :] - st.append(torch.stack([semiring.zero_(left_.clone()), left_], dim=-3)) st.append(torch.stack([semiring.zero_(right.clone()), right], dim=-2)) st = torch.stack(st, dim=-1) return semiring.sum(st) + size = bin_MN // 2 rsize = 2 + track = 3 for n in range(2, log_MN + 1): - print("round", n) + # print("round", n) size = int(size / 2) rsize *= 2 - chart[n][:] = merge(chart[n - 1], size) - q = merge2(charta[n - 1], chartb[n - 1], size, charta[n - 1].shape[3]) - ex = q.shape[3] - q.view(ssize, batch, size, ex, bin_MN, 2, 2, 3) - print(q.shape, charta[n].shape) + + + q = merge2(charta[n - 1], chartb[n - 1], size, charta[n - 1].shape[3], rsize) charta[n] = q + chartb[n] = reflect(q, size) + + + # track = ((track - 1 // 2) * 2 + 1) * 2 + 1 + # print(track) + # Old + chart[n][:] = merge(chart[n - 1], size) + # Old + + # ex = q.shape[3] + # q.view(ssize, batch, size, ex, bin_MN, 2, 2, 3) + # print(q.shape, charta[n].shape) + # f, r = torch.arange(ex), torch.arange(ex-1, -1, -1) + # sp = pad_conv(q, ex, 4, semiring) + # sp.view(ssize, batch, size, ex, bin_MN, 2, 2, 3, ex) + # sp = sp[:, :, :, r, :, :, :, :, f].permute(1,2,3,4,0,5,6,7) \ + # .view(ssize, batch, size, bin_MN, ex, 2, 2, 3) + # chartb[n] = sp + + + # print(sp[0,0, :, 3, ex//2], q[0,0, :, ex//2, 3]) + # assert((sp[0,0, :, 3, ex//2] == q[0,0, :, ex//2, 3]).all()) + # print(sp[0,0, :, 3, ex//2 - 1], q[0,0, :, ex//2 +1, 2]) + # assert((sp[0,0, :, 3, ex//2 + 1] == q[0,0, :, ex//2-1, 4]).all()) + # print(q.shape) + # print(q.shape) + # print(n) + # print(q[0, 0, :, 3, ind_M, Open, Open, Mid]) + # print(chart[n][0, 0, :, ind_M, ind_M, Open, Open, Mid]) + + # print("pchart", chart[n-1][0, 0, 0, :, N, Open, Open, Mid]) + # print("pconv", charta[n-1][0, 0, 0, :, N, Open, Open, Mid]) + # print("pchart", chart[n-1][0, 0, 1, :, :, Open, Open, Mid]) + # print("pconv", chartb[n-1][0, 0, 1, :, :, Open, Open, Mid]) + + + # print("chart", chart[n][0, 0, 0, :, N, Open, Open, Mid]) + # print("conv", charta[n][0, 0, 0, :, N, Open, Open, Mid]) + # print("chart", chart[n][0, 0, 0, M, :, Open, Open, Mid]) + # print("conv", chartb[n][0, 0, 0, M, :, Open, Open, Mid]) + + # assert (torch.isclose(chart[n][0, 0, :, ind_M, ind_M, :, :, :], + # q[0, 0, :, q.shape[3] // 2, ind_M, :, :, :])).all(), "%s %s"%(n, q.shape[3]) + # assert (torch.isclose(chart[n][0, 0, :, ind_M, ind_M, :, :, :], + # sp[0, 0, :, ind_M, q.shape[3] // 2, :, :, :])).all(), "%s %s"%(n, q.shape[3]) + + + # assert (torch.isclose(chart[n][0, 0, :, ind_D, ind_U, :, :, :], + # q[0, 0, :, q.shape[3] // 2-1, ind_U, :, :, :])).all(), "%s %s"%(n, q.shape[3]) + + # assert (torch.isclose(chart[n][:, :, :, ind_M, ind_M, Open, Open, Mid], + # q[:, :, :, q.shape[3] // 2, ind_M, Open, Open, Mid])).all(), "%s %s"%(n, q.shape[3]) - - f, r = torch.arange(ex), torch.arange(ex-1, -1, -1) - sp = pad_conv(q, ex, 4, semiring) - sp.view(ssize, batch, size, ex, bin_MN, 2, 2, 3, ex) - sp = sp[:, :, :, r, :, :, :, :, f].permute(1,2,3,4,0,5,6,7) \ - .view(ssize, batch, size, bin_MN, ex, 2, 2, 3) - - print(sp[0,0, :, 3, ex//2], q[0,0, :, ex//2, 3]) - assert((sp[0,0, :, 3, ex//2] == q[0,0, :, ex//2, 3]).all()) - print(sp[0,0, :, 3, ex//2 - 1], q[0,0, :, ex//2 +1, 2]) - assert((sp[0,0, :, 3, ex//2 + 1] == q[0,0, :, ex//2-1, 4]).all()) - - chartb[n] = sp - - print(q.shape) - # charta[n][:] = - print(q.shape) - print(n) - print(q[0, 0, :, 3, ind_M, Open, Open, Mid]) - print(chart[n][0, 0, :, ind_M, ind_M, Open, Open, Mid]) - assert (chart[n][0, 0, :, ind_M, ind_M, :, :, :] == - q[0, 0, :, q.shape[3] // 2, ind_M, :, :, :]).all(), "%s %s"%(n, q.shape[3]) - assert (chart[n][0, 0, :, ind_M, ind_M, :, :, :] == - sp[0, 0, :, ind_M, q.shape[3] // 2, :, :, :]).all(), "%s %s"%(n, q.shape[3]) - - print("pchart", chart[n-1][0, 0, 0, :, N, Open, Open, Mid]) - print("pconv", charta[n-1][0, 0, 0, :, N, Open, Open, Mid]) - print("pchart", chart[n-1][0, 0, 1, :, :, Open, Open, Mid]) - print("pconv", chartb[n-1][0, 0, 1, :, :, Open, Open, Mid]) - - - print("chart", chart[n][0, 0, 0, :, N, Open, Open, Mid]) - print("conv", charta[n][0, 0, 0, :, N, Open, Open, Mid]) - print("chart", chart[n][0, 0, 0, M, :, Open, Open, Mid]) - print("conv", chartb[n][0, 0, 0, M, :, Open, Open, Mid]) - - - - assert (chart[n][0, 0, :, ind_D, ind_U, :, :, :] == - q[0, 0, :, q.shape[3] // 2-1, ind_U, :, :, :]).all(), "%s %s"%(n, q.shape[3]) - - assert (chart[n][:, :, :, ind_M, ind_M, Open, Open, Mid] == - q[:, :, :, q.shape[3] // 2, ind_M, Open, Open, Mid]).all(), "%s %s"%(n, q.shape[3]) - if self.local: v = semiring.sum(semiring.sum(chart[-1][:, :, 0, :, :, Close, Close, Mid])) else: v = chart[-1][:, :, 0, M, N, Open, Open, Mid] - print("correct", chart[-1][:, :, 0, M, N, Open, Open, Mid]) - print("options",charta[-1][:, :, 0, :, N, Open, Open, Mid]) - print("options",chartb[-1][:, :, 0, M, :, Open, Open, Mid]) - v = charta[-1][:, :, 0, N - M + charta[-1].shape[3] //2, N, Open, Open, Mid] - print(v) + # print("correct", chart[-1][:, :, 0, M, N, Open, Open, Mid]) + # print("options",charta[-1][:, :, 0, :, N, Open, Open, Mid]) + # print("options",chartb[-1][:, :, 0, M, :, Open, Open, Mid]) + v = charta[-1][:, :, 0, M-N + (charta[-1].shape[3] //2), + N, Open, Open, Mid] + # print(v) return v, [log_potentials], None @staticmethod diff --git a/torch_struct/test_algorithms.py b/torch_struct/test_algorithms.py index 459acd6c..2dc7d563 100644 --- a/torch_struct/test_algorithms.py +++ b/torch_struct/test_algorithms.py @@ -306,11 +306,10 @@ def test_alignment(data): struct = model(semiring) vals, (batch, N) = model._rand() vals.fill_(1) - + alpha = struct.sum(vals) count = struct.enumerate(vals)[0] assert torch.isclose(count, alpha).all() - return model = data.draw(sampled_from([Alignment])) semiring = data.draw(sampled_from([LogSemiring])) struct = model(semiring) @@ -330,7 +329,7 @@ def test_alignment(data): mx = struct.marginals(vals) print(alpha, count) print(mx[0].nonzero()) - # assert(False) + assert torch.isclose(count, alpha).all() From 25c06c3552a003dffdcf83dfb74d76c6a7cc293c Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 14:23:26 -0400 Subject: [PATCH 13/26] . --- torch_struct/alignment.py | 250 ++++++++++++++------------------------ 1 file changed, 91 insertions(+), 159 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index db047bbd..760c8978 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -75,12 +75,12 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): ind_D = torch.arange(bin_MN - 1) # Create a chart N, N, back - chart = [self._make_chart( - 1, - (batch, bin_MN // pow(2, i), bin_MN, bin_MN, 2, 2, 3), - log_potentials, - force_grad, - )[0] for i in range(log_MN + 1)] + # chart = [self._make_chart( + # 1, + # (batch, bin_MN // pow(2, i), bin_MN, bin_MN, 2, 2, 3), + # log_potentials, + # force_grad, + # )[0] for i in range(log_MN + 1)] charta = [self._make_chart( @@ -110,7 +110,6 @@ def reflect(x, size): .view(ssize, batch, size, bin_MN, ex, 2, 2, 3) return sp - # Init # This part is complicated. Rotate the scores by 45% and # then compress one. @@ -120,9 +119,9 @@ def reflect(x, size): point = (end + M) // 2 lim = point * 2 # OLD - chart[0][:, b, rot_x[:lim], rot_y[:lim], rot_y[:lim], :, :, :] = ( - log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) - ) + # chart[0][:, b, rot_x[:lim], rot_y[:lim], rot_y[:lim], :, :, :] = ( + # log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) + # ) # OLD charta[0][:, b, rot_x[:lim], 0, rot_y[:lim], :, :, :] = ( log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) @@ -132,9 +131,9 @@ def reflect(x, size): ) # OLD - chart[1][:, b, point:, ind, ind, :, :, Mid] = semiring.one_( - chart[1][:, b, point:, ind, ind, :, :, Mid] - ) + # chart[1][:, b, point:, ind, ind, :, :, Mid] = semiring.one_( + # chart[1][:, b, point:, ind, ind, :, :, Mid] + # ) # OLD charta[1][:, b, point:, 1, ind, :, :, Mid] = semiring.one_( @@ -145,22 +144,22 @@ def reflect(x, size): end = lengths[b] point = (end + M) // 2 lim = point * 2 - left_ = chart[0][:, b, 0:lim:2] - right = chart[0][:, b, 1:lim:2] + # left_ = chart[0][:, b, 0:lim:2] + # right = chart[0][:, b, 1:lim:2] left2_ = charta[0][:, b, 0:lim:2] right2 = chartb[0][:, b, 1:lim:2] - chart[1][:, b, :point, ind_M, ind_M, :, :, :] = torch.stack( - [ - left_[:, :, ind_M, ind_M, :, :, Down], - semiring.plus( - left_[:, :, ind_M, ind_M, :, :, Mid], - right[:, :, ind_M, ind_M, :, :, Mid]), - left_[:, :, ind_M, ind_M, :, :, Up], - ], - dim=-1, - ) + # chart[1][:, b, :point, ind_M, ind_M, :, :, :] = torch.stack( + # [ + # left_[:, :, ind_M, ind_M, :, :, Down], + # semiring.plus( + # left_[:, :, ind_M, ind_M, :, :, Mid], + # right[:, :, ind_M, ind_M, :, :, Mid]), + # left_[:, :, ind_M, ind_M, :, :, Up], + # ], + # dim=-1, + # ) charta[1][:, b, :point, 1, ind_M, :, :, :] = torch.stack( [ @@ -185,21 +184,21 @@ def reflect(x, size): z2[0, :] = 0 z2[1, :] = 2 - # OLD - tmp = torch.stack( - [ - semiring.times( - left_[:, :, ind_D, ind_D, Open : Open+1 :, :], - right[:, :, ind_U, ind_U, :, Open : Open + 1, Down : Down + 1] - ), - semiring.times( - left_[:, :, ind_U, ind_U, Open : Open + 1, :, :], - right[:, :, ind_D, ind_D, :, Open : Open + 1, Up : Up + 1], - ), - ], - dim=2, - ) - chart[1][:, b, :point, x, y, :, :, :] = tmp + # # OLD + # tmp = torch.stack( + # [ + # semiring.times( + # left_[:, :, ind_D, ind_D, Open : Open+1 :, :], + # right[:, :, ind_U, ind_U, :, Open : Open + 1, Down : Down + 1] + # ), + # semiring.times( + # left_[:, :, ind_U, ind_U, Open : Open + 1, :, :], + # right[:, :, ind_D, ind_D, :, Open : Open + 1, Up : Up + 1], + # ), + # ], + # dim=2, + # ) + # chart[1][:, b, :point, x, y, :, :, :] = tmp # OLD tmp = torch.stack( @@ -238,23 +237,23 @@ def reflect(x, size): # charta[1].sum().backward() # chartb[1].sum().backward() - assert (charta[0][:, 0, :, 0, ind_M] == chart[0][:, 0, :, ind_M, ind_M]).all() - assert (chartb[0][:, 0, :, ind_M, 0] == chart[0][:, 0, :, ind_M, ind_M]).all() + # assert (charta[0][:, 0, :, 0, ind_M] == chart[0][:, 0, :, ind_M, ind_M]).all() + # assert (chartb[0][:, 0, :, ind_M, 0] == chart[0][:, 0, :, ind_M, ind_M]).all() - assert (torch.isclose(charta[1][:, 0, :, 1, ind_M, :, :, Mid], - chart[1][:, 0, :, ind_M, ind_M, :, :, Mid]).all()) + # assert (torch.isclose(charta[1][:, 0, :, 1, ind_M, :, :, Mid], + # chart[1][:, 0, :, ind_M, ind_M, :, :, Mid]).all()) - assert (torch.isclose(charta[1][:, 0, :, 1, ind_M, :, :, Down], - chart[1][:, 0, :, ind_M, ind_M, :, :, Down]).all()) - assert (charta[1][:, 0, :, 2, ind_D, :, :, Down] == chart[1][:, 0, :, ind_U, ind_D, :, :, Down]).all() - assert (charta[1][:, 0, :, 0, ind_U, :, :, Up] == chart[1][:, 0, :, ind_D, ind_U, :, :, Up]).all() - assert(charta[1][:, 0, :, 1, ind_M] == chart[1][:, 0, :, ind_M, ind_M]).all() - assert(charta[1][:, 0, :, 2, ind_D] == chart[1][:, 0, :, ind_U, ind_D]).all() - assert(charta[1][:, 0, :, 0, ind_U] == chart[1][:, 0, :, ind_D, ind_U]).all() - assert(chartb[1][:, 0, :, ind_M, 1] == chart[1][:, 0, :, ind_M, ind_M]).all() - assert(chartb[1][:, 0, :, ind_U, 0] == chart[1][:, 0, :, ind_U, ind_D]).all() - assert(chartb[1][:, 0, :, ind_D, 2] == chart[1][:, 0, :, ind_D, ind_U]).all() + # assert (torch.isclose(charta[1][:, 0, :, 1, ind_M, :, :, Down], + # chart[1][:, 0, :, ind_M, ind_M, :, :, Down]).all()) + # assert (charta[1][:, 0, :, 2, ind_D, :, :, Down] == chart[1][:, 0, :, ind_U, ind_D, :, :, Down]).all() + # assert (charta[1][:, 0, :, 0, ind_U, :, :, Up] == chart[1][:, 0, :, ind_D, ind_U, :, :, Up]).all() + # assert(charta[1][:, 0, :, 1, ind_M] == chart[1][:, 0, :, ind_M, ind_M]).all() + # assert(charta[1][:, 0, :, 2, ind_D] == chart[1][:, 0, :, ind_U, ind_D]).all() + # assert(charta[1][:, 0, :, 0, ind_U] == chart[1][:, 0, :, ind_D, ind_U]).all() + # assert(chartb[1][:, 0, :, ind_M, 1] == chart[1][:, 0, :, ind_M, ind_M]).all() + # assert(chartb[1][:, 0, :, ind_U, 0] == chart[1][:, 0, :, ind_U, ind_D]).all() + # assert(chartb[1][:, 0, :, ind_D, 2] == chart[1][:, 0, :, ind_D, ind_U]).all() # assert(False) @@ -272,30 +271,18 @@ def merge2(xa, xb, size, rsize, track): # v = rsize + 1 # rsize = rsize + 1 for op in (Up, Down, Mid): - top, bot = 1, 1 - # a, b, c, d = 0, v, 0, v - # s1, e1, s2, e2 = 0, bin_MN-1, 0, bin_MN-1 if op == Up: - # a, b, c, d = 1, v, 0, v -1 - # s1, e1, s2, e2 = 0, bin_MN-1, 1, bin_MN top, bot = 2, 0 if op == Down: - # a, b, c, d = 0, v - 1, 1, v - # s1, e1, s2, e2 = 1, bin_MN, 0, bin_MN-1 top, bot = 0, 2 - # print(xa[:, :, 0 : size * 2 : 2, :].shape) - print(pad_conv(demote(xa[:, :, 0 : size * 2 : 2, :track], 3), nrsize, 7, semiring, bot, top) - .transpose(-1, -2).shape) left = ( - pad_conv(demote(xa[:, :, 0 : size * 2 : 2, :track], 3), nrsize, 7, semiring, bot, top) + pad_conv(demote(xa[:, :, 0 : size * 2 : 2, :], 3), nrsize, 7, semiring, bot, top) .transpose(-1, -2) .view(ssize, batch, size, bin_MN, 1, 2, 2, 3, nrsize, rsize) ) - print(pad(pad_conv(demote(xb[:, :, 1 : size * 2 : 2, :, :], 4), nrsize, 3, semiring), 1, 1, -2, semiring) - .transpose(-1, -2).shape -) + right = ( pad(pad_conv(demote(xb[:, :, 1 : size * 2 : 2, :, :], 4), nrsize, 3, semiring), 1, 1, -2, semiring) .transpose(-1, -2) @@ -312,123 +299,68 @@ def merge2(xa, xb, size, rsize, track): st.append(combine) if self.local: - left_ = pad(xa[:, :, 0 :: 2, :track-1, :, Close, :, :], rsize//2, rsize//2, 3, semiring) - # print(xb.shape) - right = pad(xa[:, :, 1 :: 2, :track-1, :, :, Close, :], rsize//2, rsize//2, 3, semiring) - # print("X", rsize, xa[:, :, 1 :: 2, :track-1, :, :, Close, :].shape, right.shape) + left_ = pad(xa[:, :, 0 :: 2, :, :, Close, :, :], rsize//2, rsize//2, 3, semiring) + right = pad(xa[:, :, 1 :: 2, :, :, :, Close, :], rsize//2, rsize//2, 3, semiring) st.append(torch.stack([semiring.zero_(left_.clone()), left_], dim=-3)) st.append(torch.stack([semiring.zero_(right.clone()), right], dim=-2)) - # print("SSS", st[0].shape, st[-2].shape, st[-1].shape) st = torch.stack(st, dim=-1) return semiring.sum(st) - def merge(x, size): - left = ( - demote(x[:, :, 0 : size * 2 : 2], 3) - .view(ssize, batch, size, 1, bin_MN, 1, 2, 2, 3, bin_MN) - ) - right = ( - demote(x[:, :, 1 : size * 2 : 2], 4) - .view(ssize, batch, size, bin_MN, 1, 2, 1, 2, 1, 3, bin_MN) - ) - - st = [] - for op in (Up, Down, Mid): - a, b, c, d = 0, bin_MN, 0, bin_MN - if op == Up: - a, b, c, d = 1, bin_MN, 0, bin_MN - 1 - if op == Down: - a, b, c, d = 0, bin_MN - 1, 1, bin_MN - combine = semiring.dot( - left[..., Open, :, :, a:b], right[..., Open, :, op, c:d] - ) - st.append(combine) - - if self.local: - left_ = x[:, :, 0 :: 2, :, :, Close, :, :] - right = x[:, :, 1 :: 2, :, :, :, Close, :] - st.append(torch.stack([semiring.zero_(left_.clone()), left_], dim=-3)) - st.append(torch.stack([semiring.zero_(right.clone()), right], dim=-2)) - - st = torch.stack(st, dim=-1) - return semiring.sum(st) + # def merge(x, size): + # left = ( + # demote(x[:, :, 0 : size * 2 : 2], 3) + # .view(ssize, batch, size, 1, bin_MN, 1, 2, 2, 3, bin_MN) + # ) + # right = ( + # demote(x[:, :, 1 : size * 2 : 2], 4) + # .view(ssize, batch, size, bin_MN, 1, 2, 1, 2, 1, 3, bin_MN) + # ) + + # st = [] + # for op in (Up, Down, Mid): + # a, b, c, d = 0, bin_MN, 0, bin_MN + # if op == Up: + # a, b, c, d = 1, bin_MN, 0, bin_MN - 1 + # if op == Down: + # a, b, c, d = 0, bin_MN - 1, 1, bin_MN + # combine = semiring.dot( + # left[..., Open, :, :, a:b], right[..., Open, :, op, c:d] + # ) + # st.append(combine) + + # if self.local: + # left_ = x[:, :, 0 :: 2, :, :, Close, :, :] + # right = x[:, :, 1 :: 2, :, :, :, Close, :] + # st.append(torch.stack([semiring.zero_(left_.clone()), left_], dim=-3)) + # st.append(torch.stack([semiring.zero_(right.clone()), right], dim=-2)) + + # st = torch.stack(st, dim=-1) + # return semiring.sum(st) size = bin_MN // 2 rsize = 2 track = 3 for n in range(2, log_MN + 1): - # print("round", n) size = int(size / 2) rsize *= 2 - q = merge2(charta[n - 1], chartb[n - 1], size, charta[n - 1].shape[3], rsize) - charta[n] = q - chartb[n] = reflect(q, size) + charta[n][:] = q + chartb[n][:] = reflect(q, size) - # track = ((track - 1 // 2) * 2 + 1) * 2 + 1 - # print(track) # Old - chart[n][:] = merge(chart[n - 1], size) + # chart[n][:] = merge(chart[n - 1], size) # Old - # ex = q.shape[3] - # q.view(ssize, batch, size, ex, bin_MN, 2, 2, 3) - # print(q.shape, charta[n].shape) - # f, r = torch.arange(ex), torch.arange(ex-1, -1, -1) - # sp = pad_conv(q, ex, 4, semiring) - # sp.view(ssize, batch, size, ex, bin_MN, 2, 2, 3, ex) - # sp = sp[:, :, :, r, :, :, :, :, f].permute(1,2,3,4,0,5,6,7) \ - # .view(ssize, batch, size, bin_MN, ex, 2, 2, 3) - # chartb[n] = sp - - - # print(sp[0,0, :, 3, ex//2], q[0,0, :, ex//2, 3]) - # assert((sp[0,0, :, 3, ex//2] == q[0,0, :, ex//2, 3]).all()) - # print(sp[0,0, :, 3, ex//2 - 1], q[0,0, :, ex//2 +1, 2]) - # assert((sp[0,0, :, 3, ex//2 + 1] == q[0,0, :, ex//2-1, 4]).all()) - # print(q.shape) - # print(q.shape) - # print(n) - # print(q[0, 0, :, 3, ind_M, Open, Open, Mid]) - # print(chart[n][0, 0, :, ind_M, ind_M, Open, Open, Mid]) - - # print("pchart", chart[n-1][0, 0, 0, :, N, Open, Open, Mid]) - # print("pconv", charta[n-1][0, 0, 0, :, N, Open, Open, Mid]) - # print("pchart", chart[n-1][0, 0, 1, :, :, Open, Open, Mid]) - # print("pconv", chartb[n-1][0, 0, 1, :, :, Open, Open, Mid]) - - - # print("chart", chart[n][0, 0, 0, :, N, Open, Open, Mid]) - # print("conv", charta[n][0, 0, 0, :, N, Open, Open, Mid]) - # print("chart", chart[n][0, 0, 0, M, :, Open, Open, Mid]) - # print("conv", chartb[n][0, 0, 0, M, :, Open, Open, Mid]) - - # assert (torch.isclose(chart[n][0, 0, :, ind_M, ind_M, :, :, :], - # q[0, 0, :, q.shape[3] // 2, ind_M, :, :, :])).all(), "%s %s"%(n, q.shape[3]) - # assert (torch.isclose(chart[n][0, 0, :, ind_M, ind_M, :, :, :], - # sp[0, 0, :, ind_M, q.shape[3] // 2, :, :, :])).all(), "%s %s"%(n, q.shape[3]) - - - # assert (torch.isclose(chart[n][0, 0, :, ind_D, ind_U, :, :, :], - # q[0, 0, :, q.shape[3] // 2-1, ind_U, :, :, :])).all(), "%s %s"%(n, q.shape[3]) - - # assert (torch.isclose(chart[n][:, :, :, ind_M, ind_M, Open, Open, Mid], - # q[:, :, :, q.shape[3] // 2, ind_M, Open, Open, Mid])).all(), "%s %s"%(n, q.shape[3]) - if self.local: v = semiring.sum(semiring.sum(chart[-1][:, :, 0, :, :, Close, Close, Mid])) else: - v = chart[-1][:, :, 0, M, N, Open, Open, Mid] - # print("correct", chart[-1][:, :, 0, M, N, Open, Open, Mid]) - # print("options",charta[-1][:, :, 0, :, N, Open, Open, Mid]) - # print("options",chartb[-1][:, :, 0, M, :, Open, Open, Mid]) + # v = chart[-1][:, :, 0, M, N, Open, Open, Mid] v = charta[-1][:, :, 0, M-N + (charta[-1].shape[3] //2), N, Open, Open, Mid] - # print(v) return v, [log_potentials], None @staticmethod From 155e58148ade2fb323d3d36c7087b4aadf80d204 Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 14:27:01 -0400 Subject: [PATCH 14/26] . --- torch_struct/alignment.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index 760c8978..d8e13a29 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -9,9 +9,9 @@ def pad_conv(x, k, dim, sr, extra_b=0, extra_t=0): def pad(x, n_bot, n_top, dim, sr): shape = list(x.shape) shape[dim] = n_bot - padb = sr.zero_(torch.zeros(shape)) + padb = sr.zero_(torch.zeros(shape, dtype=x.dtype, device=x.device)) shape[dim] = n_top - padt = sr.zero_(torch.zeros(shape)) + padt = sr.zero_(torch.zeros(shape, dtype=x.dtype, device=x.device)) return torch.cat([padb, x, padt], dim=dim) @@ -356,7 +356,7 @@ def merge2(xa, xb, size, rsize, track): # Old if self.local: - v = semiring.sum(semiring.sum(chart[-1][:, :, 0, :, :, Close, Close, Mid])) + v = semiring.sum(semiring.sum(charta[-1][:, :, 0, :, :, Close, Close, Mid])) else: # v = chart[-1][:, :, 0, M, N, Open, Open, Mid] v = charta[-1][:, :, 0, M-N + (charta[-1].shape[3] //2), From 486d535e1f685e8ecb3cf0d7e4dc1e53534ed3af Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 14:28:11 -0400 Subject: [PATCH 15/26] . --- torch_struct/alignment.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index d8e13a29..7ac36868 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -102,9 +102,9 @@ def reflect(x, size): ex = x.shape[3] f, r = torch.arange(ex), torch.arange(ex-1, -1, -1) sp = pad_conv(x, ex, 4, semiring) - print(sp.shape) - print(bin_MN) - print((ssize, batch, size, ex, bin_MN, 2, 2, 3, ex)) + # print(sp.shape) + # print(bin_MN) + # print((ssize, batch, size, ex, bin_MN, 2, 2, 3, ex)) sp.view(ssize, batch, size, ex, bin_MN, 2, 2, 3, ex) sp = sp[:, :, :, r, :, :, :, :, f].permute(1,2,3,4,0,5,6,7) \ .view(ssize, batch, size, bin_MN, ex, 2, 2, 3) @@ -265,7 +265,7 @@ def merge2(xa, xb, size, rsize, track): # print("RSIZE", rsize) nrsize = (rsize-1)*2+3 rsize += 2 - print("sizes", nrsize, rsize, track) + # print("sizes", nrsize, rsize, track) st = [] # v = rsize + 1 From 1c2e44a9500ea050426122fcda64d5a4e7ef3066 Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 14:32:52 -0400 Subject: [PATCH 16/26] . --- torch_struct/alignment.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index 7ac36868..d80006a7 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -234,6 +234,8 @@ def reflect(x, size): charta[1] = charta[1][:, :, :, :3] chartb[1] = reflect(charta[1], bin_MN // 2) + print("pre") + # charta[1].sum().backward() # chartb[1].sum().backward() From 1f3e6ff77fa3ae2858a4e0404db8652b18a8a2b3 Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 14:45:01 -0400 Subject: [PATCH 17/26] . --- torch_struct/alignment.py | 35 +++++++++++++++++------------------ 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index d80006a7..9df7d93a 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -272,28 +272,28 @@ def merge2(xa, xb, size, rsize, track): st = [] # v = rsize + 1 # rsize = rsize + 1 + # print( pad_conv(demote(xa[:, :, 0 : size * 2 : 2, :], 3), nrsize, 7, semiring, 2, 2).transpose(-1, -2).shape) + left = ( + pad_conv(demote(xa[:, :, 0 : size * 2 : 2, :], 3), nrsize, 7, semiring, 2, 2) + .transpose(-1, -2) + .view(ssize, batch, size, bin_MN, 1, 2, 2, 3, nrsize, rsize+2) + ) + + right = ( + pad(pad_conv(demote(xb[:, :, 1 : size * 2 : 2, :, :], 4), nrsize, 3, semiring), 1, 1, -2, semiring) + .transpose(-1, -2) + .view(ssize, batch, size, bin_MN, 2, 1, 2, 1, 3, nrsize, rsize) + ) + for op in (Up, Down, Mid): - top, bot = 1, 1 + top, bot = rsize + 1, 1 if op == Up: - top, bot = 2, 0 + top, bot = rsize +2 , 2 if op == Down: - top, bot = 0, 2 - - left = ( - pad_conv(demote(xa[:, :, 0 : size * 2 : 2, :], 3), nrsize, 7, semiring, bot, top) - .transpose(-1, -2) - .view(ssize, batch, size, bin_MN, 1, 2, 2, 3, nrsize, rsize) - ) - - right = ( - pad(pad_conv(demote(xb[:, :, 1 : size * 2 : 2, :, :], 4), nrsize, 3, semiring), 1, 1, -2, semiring) - .transpose(-1, -2) - .view(ssize, batch, size, bin_MN, 2, 1, 2, 1, 3, nrsize, rsize) - ) - + top, bot = rsize, 0 combine = semiring.dot( - left[:, :, :, :, :, Open, :, :, :, :], + left[:, :, :, :, :, Open, :, :, :, bot:top], right[:, :, :, :, :, Open, :, :, op, :, :] ) combine = combine.view(ssize, batch, size, bin_MN, 2, 2, 3, nrsize) \ @@ -347,7 +347,6 @@ def merge2(xa, xb, size, rsize, track): for n in range(2, log_MN + 1): size = int(size / 2) rsize *= 2 - q = merge2(charta[n - 1], chartb[n - 1], size, charta[n - 1].shape[3], rsize) charta[n][:] = q chartb[n][:] = reflect(q, size) From d8ac3b69044ab3f7a6f8ef27d7d9c7a37762bde9 Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 14:50:00 -0400 Subject: [PATCH 18/26] . --- torch_struct/alignment.py | 1 + 1 file changed, 1 insertion(+) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index 9df7d93a..16228e4f 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -345,6 +345,7 @@ def merge2(xa, xb, size, rsize, track): rsize = 2 track = 3 for n in range(2, log_MN + 1): + print(n) size = int(size / 2) rsize *= 2 q = merge2(charta[n - 1], chartb[n - 1], size, charta[n - 1].shape[3], rsize) From 3d11a68c4e9d2069d9a482c0866f4c8c6452a130 Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 15:08:28 -0400 Subject: [PATCH 19/26] . --- torch_struct/alignment.py | 118 +++++--------------------------- torch_struct/test_algorithms.py | 9 +++ 2 files changed, 25 insertions(+), 102 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index 16228e4f..f1e48c9a 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -21,9 +21,10 @@ def demote(x, index): return x.permute(order) class Alignment(_Struct): - def __init__(self, semiring=LogSemiring, local=False): + def __init__(self, semiring=LogSemiring, local=False, max_gap=None): self.semiring = semiring self.local = local + self.max_gap = max_gap def _check_potentials(self, edge, lengths=None): batch, N_1, M_1, x = edge.shape @@ -54,6 +55,8 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): log_potentials, batch, N, M, lengths = self._check_potentials( log_potentials, lengths ) + assert self.max_gap is None or self.max_gap > abs(N - M) + steps = N + M log_MN = int(math.ceil(math.log(steps, 2))) bin_MN = int(math.pow(2, log_MN)) @@ -184,23 +187,6 @@ def reflect(x, size): z2[0, :] = 0 z2[1, :] = 2 - # # OLD - # tmp = torch.stack( - # [ - # semiring.times( - # left_[:, :, ind_D, ind_D, Open : Open+1 :, :], - # right[:, :, ind_U, ind_U, :, Open : Open + 1, Down : Down + 1] - # ), - # semiring.times( - # left_[:, :, ind_U, ind_U, Open : Open + 1, :, :], - # right[:, :, ind_D, ind_D, :, Open : Open + 1, Up : Up + 1], - # ), - # ], - # dim=2, - # ) - # chart[1][:, b, :point, x, y, :, :, :] = tmp - # OLD - tmp = torch.stack( [ semiring.times( @@ -216,63 +202,17 @@ def reflect(x, size): ) charta[1][:, b, :point, z, y, :, :, :] = tmp - # chartb[1][:, b, point:, ind, 1, :, :, Mid] = semiring.one_( - # chartb[1][:, b, point:, ind, 1, :, :, Mid] - # ) - - # chartb[1][:, b, :point, ind_M, 1, :, :, :] = \ - # charta[1][:, b, :point, 1, ind_M, :, :, :] - - # chartb[1][:, b, :point, x, z2, :, :, :] = tmp - - # - - - # chartb[1][:, :, :, :, :3] = reflect(charta[1][:, :, :, :3], bin_MN // 2) charta[1] = charta[1][:, :, :, :3] chartb[1] = reflect(charta[1], bin_MN // 2) - print("pre") - - # charta[1].sum().backward() - # chartb[1].sum().backward() - - # assert (charta[0][:, 0, :, 0, ind_M] == chart[0][:, 0, :, ind_M, ind_M]).all() - # assert (chartb[0][:, 0, :, ind_M, 0] == chart[0][:, 0, :, ind_M, ind_M]).all() - - - # assert (torch.isclose(charta[1][:, 0, :, 1, ind_M, :, :, Mid], - # chart[1][:, 0, :, ind_M, ind_M, :, :, Mid]).all()) - - # assert (torch.isclose(charta[1][:, 0, :, 1, ind_M, :, :, Down], - # chart[1][:, 0, :, ind_M, ind_M, :, :, Down]).all()) - # assert (charta[1][:, 0, :, 2, ind_D, :, :, Down] == chart[1][:, 0, :, ind_U, ind_D, :, :, Down]).all() - # assert (charta[1][:, 0, :, 0, ind_U, :, :, Up] == chart[1][:, 0, :, ind_D, ind_U, :, :, Up]).all() - # assert(charta[1][:, 0, :, 1, ind_M] == chart[1][:, 0, :, ind_M, ind_M]).all() - # assert(charta[1][:, 0, :, 2, ind_D] == chart[1][:, 0, :, ind_U, ind_D]).all() - # assert(charta[1][:, 0, :, 0, ind_U] == chart[1][:, 0, :, ind_D, ind_U]).all() - # assert(chartb[1][:, 0, :, ind_M, 1] == chart[1][:, 0, :, ind_M, ind_M]).all() - # assert(chartb[1][:, 0, :, ind_U, 0] == chart[1][:, 0, :, ind_U, ind_D]).all() - # assert(chartb[1][:, 0, :, ind_D, 2] == chart[1][:, 0, :, ind_D, ind_U]).all() - - # assert(False) - # Scan - def merge2(xa, xb, size, rsize, track): - # print(rsize) - # print(pad_conv(demote(xa[:, :, 0 : size * 2 : 2], 3), rsize, 3).shape) - # print((ssize, batch, size, bin_MN, 1, 2, 2, 3, rsize, rsize)) - # print("RSIZE", rsize) + def merge2(xa, xb, size, rsize): nrsize = (rsize-1)*2+3 rsize += 2 - # print("sizes", nrsize, rsize, track) - + print(nrsize, rsize) st = [] - # v = rsize + 1 - # rsize = rsize + 1 - # print( pad_conv(demote(xa[:, :, 0 : size * 2 : 2, :], 3), nrsize, 7, semiring, 2, 2).transpose(-1, -2).shape) left = ( pad_conv(demote(xa[:, :, 0 : size * 2 : 2, :], 3), nrsize, 7, semiring, 2, 2) .transpose(-1, -2) @@ -309,48 +249,22 @@ def merge2(xa, xb, size, rsize, track): return semiring.sum(st) - # def merge(x, size): - # left = ( - # demote(x[:, :, 0 : size * 2 : 2], 3) - # .view(ssize, batch, size, 1, bin_MN, 1, 2, 2, 3, bin_MN) - # ) - # right = ( - # demote(x[:, :, 1 : size * 2 : 2], 4) - # .view(ssize, batch, size, bin_MN, 1, 2, 1, 2, 1, 3, bin_MN) - # ) - - # st = [] - # for op in (Up, Down, Mid): - # a, b, c, d = 0, bin_MN, 0, bin_MN - # if op == Up: - # a, b, c, d = 1, bin_MN, 0, bin_MN - 1 - # if op == Down: - # a, b, c, d = 0, bin_MN - 1, 1, bin_MN - # combine = semiring.dot( - # left[..., Open, :, :, a:b], right[..., Open, :, op, c:d] - # ) - # st.append(combine) - - # if self.local: - # left_ = x[:, :, 0 :: 2, :, :, Close, :, :] - # right = x[:, :, 1 :: 2, :, :, :, Close, :] - # st.append(torch.stack([semiring.zero_(left_.clone()), left_], dim=-3)) - # st.append(torch.stack([semiring.zero_(right.clone()), right], dim=-2)) - - # st = torch.stack(st, dim=-1) - # return semiring.sum(st) - - size = bin_MN // 2 rsize = 2 - track = 3 for n in range(2, log_MN + 1): print(n) size = int(size / 2) rsize *= 2 - q = merge2(charta[n - 1], chartb[n - 1], size, charta[n - 1].shape[3], rsize) - charta[n][:] = q - chartb[n][:] = reflect(q, size) + q = merge2(charta[n - 1], chartb[n - 1], size, charta[n - 1].shape[3]) + charta[n] = q + gap = charta[n].shape[3] + if self.max_gap is not None and (gap - 1) // 2 > self.max_gap: + + reduced = (gap - 1) // 2 - self.max_gap + charta[n] = charta[n][:, :, :, reduced:-reduced] + chartb[n] = reflect(charta[n], size) + else: + chartb[n] = reflect(q, size) # Old diff --git a/torch_struct/test_algorithms.py b/torch_struct/test_algorithms.py index 2dc7d563..3277cbc4 100644 --- a/torch_struct/test_algorithms.py +++ b/torch_struct/test_algorithms.py @@ -305,7 +305,16 @@ def test_alignment(data): semiring = data.draw(sampled_from([StdSemiring])) struct = model(semiring) vals, (batch, N) = model._rand() + struct = model(semiring, max_gap=max(3, abs(vals.shape[1]- vals.shape[2])+1)) vals.fill_(1) + alpha = struct.sum(vals) + + model = data.draw(sampled_from([Alignment])) + semiring = data.draw(sampled_from([StdSemiring])) + struct = model(semiring) + vals, (batch, N) = model._rand() + vals.fill_(1) + alpha = struct.sum(vals) count = struct.enumerate(vals)[0] From 6cb200a845b797fdbce06587b53813a5662be85f Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 15:13:57 -0400 Subject: [PATCH 20/26] . --- torch_struct/alignment.py | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index f1e48c9a..b049a1ae 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -91,14 +91,15 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): (batch, bin_MN // pow(2, i), 2 * bin_MN // pow(2, log_MN - i)-1, bin_MN, 2, 2, 3), log_potentials, force_grad, - )[0] for i in range(log_MN + 1)] + )[0] if i <= 1 else None for i in range(log_MN + 1)] chartb = [self._make_chart( 1, (batch, bin_MN // pow(2, i), bin_MN, 2* bin_MN // pow(2, log_MN- i) -1, 2, 2, 3), log_potentials, force_grad, - )[0] for i in range(log_MN + 1)] + )[0] if i <= 1 else None + for i in range(log_MN + 1)] def reflect(x, size): @@ -259,7 +260,6 @@ def merge2(xa, xb, size, rsize): charta[n] = q gap = charta[n].shape[3] if self.max_gap is not None and (gap - 1) // 2 > self.max_gap: - reduced = (gap - 1) // 2 - self.max_gap charta[n] = charta[n][:, :, :, reduced:-reduced] chartb[n] = reflect(charta[n], size) @@ -267,10 +267,6 @@ def merge2(xa, xb, size, rsize): chartb[n] = reflect(q, size) - # Old - # chart[n][:] = merge(chart[n - 1], size) - # Old - if self.local: v = semiring.sum(semiring.sum(charta[-1][:, :, 0, :, :, Close, Close, Mid])) else: From ea51fe3abd11cb4ccbabe2d01dac3ad3e704d45e Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 15:26:23 -0400 Subject: [PATCH 21/26] . --- torch_struct/alignment.py | 28 +++++++++++++--------------- 1 file changed, 13 insertions(+), 15 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index b049a1ae..1b357742 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -10,9 +10,11 @@ def pad(x, n_bot, n_top, dim, sr): shape = list(x.shape) shape[dim] = n_bot padb = sr.zero_(torch.zeros(shape, dtype=x.dtype, device=x.device)) - shape[dim] = n_top - padt = sr.zero_(torch.zeros(shape, dtype=x.dtype, device=x.device)) - + if n_top == n_bot: + padt = padb + else: + shape[dim] = n_top + padt = sr.zero_(torch.zeros(shape, dtype=x.dtype, device=x.device)) return torch.cat([padb, x, padt], dim=dim) def demote(x, index): @@ -63,7 +65,7 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): Down, Mid, Up = 0, 1, 2 Open, Close = 0, 1 - + LOC = 2 if self.local else 1 # Grid grid_x = torch.arange(N).view(N, 1).expand(N, M) @@ -88,14 +90,14 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): charta = [self._make_chart( 1, - (batch, bin_MN // pow(2, i), 2 * bin_MN // pow(2, log_MN - i)-1, bin_MN, 2, 2, 3), + (batch, bin_MN // pow(2, i), 2 * bin_MN // pow(2, log_MN - i)-1, bin_MN, LOC, LOC, 3), log_potentials, force_grad, )[0] if i <= 1 else None for i in range(log_MN + 1)] chartb = [self._make_chart( 1, - (batch, bin_MN // pow(2, i), bin_MN, 2* bin_MN // pow(2, log_MN- i) -1, 2, 2, 3), + (batch, bin_MN // pow(2, i), bin_MN, 2* bin_MN // pow(2, log_MN- i) -1, LOC, LOC, 3), log_potentials, force_grad, )[0] if i <= 1 else None @@ -106,12 +108,9 @@ def reflect(x, size): ex = x.shape[3] f, r = torch.arange(ex), torch.arange(ex-1, -1, -1) sp = pad_conv(x, ex, 4, semiring) - # print(sp.shape) - # print(bin_MN) - # print((ssize, batch, size, ex, bin_MN, 2, 2, 3, ex)) - sp.view(ssize, batch, size, ex, bin_MN, 2, 2, 3, ex) + sp.view(ssize, batch, size, ex, bin_MN, LOC, LOC, 3, ex) sp = sp[:, :, :, r, :, :, :, :, f].permute(1,2,3,4,0,5,6,7) \ - .view(ssize, batch, size, bin_MN, ex, 2, 2, 3) + .view(ssize, batch, size, bin_MN, ex, LOC, LOC, 3) return sp # Init @@ -217,13 +216,13 @@ def merge2(xa, xb, size, rsize): left = ( pad_conv(demote(xa[:, :, 0 : size * 2 : 2, :], 3), nrsize, 7, semiring, 2, 2) .transpose(-1, -2) - .view(ssize, batch, size, bin_MN, 1, 2, 2, 3, nrsize, rsize+2) + .view(ssize, batch, size, bin_MN, 1, LOC, LOC, 3, nrsize, rsize+2) ) right = ( pad(pad_conv(demote(xb[:, :, 1 : size * 2 : 2, :, :], 4), nrsize, 3, semiring), 1, 1, -2, semiring) .transpose(-1, -2) - .view(ssize, batch, size, bin_MN, 2, 1, 2, 1, 3, nrsize, rsize) + .view(ssize, batch, size, bin_MN, LOC, 1, LOC, 1, 3, nrsize, rsize) ) for op in (Up, Down, Mid): @@ -237,7 +236,7 @@ def merge2(xa, xb, size, rsize): left[:, :, :, :, :, Open, :, :, :, bot:top], right[:, :, :, :, :, Open, :, :, op, :, :] ) - combine = combine.view(ssize, batch, size, bin_MN, 2, 2, 3, nrsize) \ + combine = combine.view(ssize, batch, size, bin_MN, LOC, LOC, 3, nrsize) \ .permute(0, 1, 2, 7, 3, 4, 5, 6) st.append(combine) @@ -266,7 +265,6 @@ def merge2(xa, xb, size, rsize): else: chartb[n] = reflect(q, size) - if self.local: v = semiring.sum(semiring.sum(charta[-1][:, :, 0, :, :, Close, Close, Mid])) else: From e3db03e73ad61865e58041e29601e650e8801634 Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 15:30:35 -0400 Subject: [PATCH 22/26] . --- torch_struct/alignment.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index 1b357742..69a5384a 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -8,13 +8,16 @@ def pad_conv(x, k, dim, sr, extra_b=0, extra_t=0): def pad(x, n_bot, n_top, dim, sr): shape = list(x.shape) + base = sr.zero_(torch.zeros([1] * len(shape), dtype=x.dtype, device=x.device)) + shape[dim] = n_bot - padb = sr.zero_(torch.zeros(shape, dtype=x.dtype, device=x.device)) + padb = base.expand(shape) if n_top == n_bot: padt = padb else: shape[dim] = n_top - padt = sr.zero_(torch.zeros(shape, dtype=x.dtype, device=x.device)) + padt = base.expand(shape) + return torch.cat([padb, x, padt], dim=dim) def demote(x, index): From e9e8c9c569f229cffb1d24c875b695666a4da0a3 Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 15:36:45 -0400 Subject: [PATCH 23/26] . --- torch_struct/alignment.py | 173 ++++++++++++++++++-------------- torch_struct/distributions.py | 7 +- torch_struct/semirings.py | 1 + torch_struct/test_algorithms.py | 3 +- 4 files changed, 103 insertions(+), 81 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index 69a5384a..a7676205 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -3,8 +3,12 @@ from .semirings import LogSemiring import math + def pad_conv(x, k, dim, sr, extra_b=0, extra_t=0): - return pad(x, (k - 1) // 2 + extra_b, (k-1)//2 + extra_t, dim, sr).unfold(dim, k, 1) + return pad(x, (k - 1) // 2 + extra_b, (k - 1) // 2 + extra_t, dim, sr).unfold( + dim, k, 1 + ) + def pad(x, n_bot, n_top, dim, sr): shape = list(x.shape) @@ -20,11 +24,13 @@ def pad(x, n_bot, n_top, dim, sr): return torch.cat([padb, x, padt], dim=dim) + def demote(x, index): total = x.dim() - order = tuple(range(index)) + tuple(range(index + 1, total)) + (index, ) + order = tuple(range(index)) + tuple(range(index + 1, total)) + (index,) return x.permute(order) + class Alignment(_Struct): def __init__(self, semiring=LogSemiring, local=False, max_gap=None): self.semiring = semiring @@ -82,38 +88,56 @@ def _dp_scan(self, log_potentials, lengths=None, force_grad=False): ind_U = torch.arange(1, bin_MN) ind_D = torch.arange(bin_MN - 1) - # Create a chart N, N, back - # chart = [self._make_chart( - # 1, - # (batch, bin_MN // pow(2, i), bin_MN, bin_MN, 2, 2, 3), - # log_potentials, - # force_grad, - # )[0] for i in range(log_MN + 1)] - - - charta = [self._make_chart( - 1, - (batch, bin_MN // pow(2, i), 2 * bin_MN // pow(2, log_MN - i)-1, bin_MN, LOC, LOC, 3), - log_potentials, - force_grad, - )[0] if i <= 1 else None for i in range(log_MN + 1)] - - chartb = [self._make_chart( - 1, - (batch, bin_MN // pow(2, i), bin_MN, 2* bin_MN // pow(2, log_MN- i) -1, LOC, LOC, 3), - log_potentials, - force_grad, - )[0] if i <= 1 else None - for i in range(log_MN + 1)] - + charta = [ + self._make_chart( + 1, + ( + batch, + bin_MN // pow(2, i), + 2 * bin_MN // pow(2, log_MN - i) - 1, + bin_MN, + LOC, + LOC, + 3, + ), + log_potentials, + force_grad, + )[0] + if i <= 1 + else None + for i in range(log_MN + 1) + ] + + chartb = [ + self._make_chart( + 1, + ( + batch, + bin_MN // pow(2, i), + bin_MN, + 2 * bin_MN // pow(2, log_MN - i) - 1, + LOC, + LOC, + 3, + ), + log_potentials, + force_grad, + )[0] + if i <= 1 + else None + for i in range(log_MN + 1) + ] def reflect(x, size): ex = x.shape[3] - f, r = torch.arange(ex), torch.arange(ex-1, -1, -1) + f, r = torch.arange(ex), torch.arange(ex - 1, -1, -1) sp = pad_conv(x, ex, 4, semiring) - sp.view(ssize, batch, size, ex, bin_MN, LOC, LOC, 3, ex) - sp = sp[:, :, :, r, :, :, :, :, f].permute(1,2,3,4,0,5,6,7) \ - .view(ssize, batch, size, bin_MN, ex, LOC, LOC, 3) + sp.view(ssize, batch, size, ex, bin_MN, LOC, LOC, 3, ex) + sp = ( + sp[:, :, :, r, :, :, :, :, f] + .permute(1, 2, 3, 4, 0, 5, 6, 7) + .view(ssize, batch, size, bin_MN, ex, LOC, LOC, 3) + ) return sp # Init @@ -124,11 +148,7 @@ def reflect(x, size): end = lengths[b] point = (end + M) // 2 lim = point * 2 - # OLD - # chart[0][:, b, rot_x[:lim], rot_y[:lim], rot_y[:lim], :, :, :] = ( - # log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) - # ) - # OLD + charta[0][:, b, rot_x[:lim], 0, rot_y[:lim], :, :, :] = ( log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) ) @@ -136,12 +156,6 @@ def reflect(x, size): log_potentials[:, b, :lim].unsqueeze(-2).unsqueeze(-2) ) - # OLD - # chart[1][:, b, point:, ind, ind, :, :, Mid] = semiring.one_( - # chart[1][:, b, point:, ind, ind, :, :, Mid] - # ) - # OLD - charta[1][:, b, point:, 1, ind, :, :, Mid] = semiring.one_( charta[1][:, b, point:, 1, ind, :, :, Mid] ) @@ -150,38 +164,23 @@ def reflect(x, size): end = lengths[b] point = (end + M) // 2 lim = point * 2 - # left_ = chart[0][:, b, 0:lim:2] - # right = chart[0][:, b, 1:lim:2] left2_ = charta[0][:, b, 0:lim:2] right2 = chartb[0][:, b, 1:lim:2] - # chart[1][:, b, :point, ind_M, ind_M, :, :, :] = torch.stack( - # [ - # left_[:, :, ind_M, ind_M, :, :, Down], - # semiring.plus( - # left_[:, :, ind_M, ind_M, :, :, Mid], - # right[:, :, ind_M, ind_M, :, :, Mid]), - # left_[:, :, ind_M, ind_M, :, :, Up], - # ], - # dim=-1, - # ) - charta[1][:, b, :point, 1, ind_M, :, :, :] = torch.stack( [ left2_[:, :, 0, ind_M, :, :, Down], semiring.plus( left2_[:, :, 0, ind_M, :, :, Mid], - right2[:, :, ind_M, 0, :, :, Mid]), + right2[:, :, ind_M, 0, :, :, Mid], + ), left2_[:, :, 0, ind_M, :, :, Up], ], dim=-1, ) - x = torch.stack([ind_U, - ind_D], dim=0) - y = torch.stack([ind_D, - ind_U], dim=0) + y = torch.stack([ind_D, ind_U], dim=0) z = y.clone() z[0, :] = 2 z[1, :] = 0 @@ -193,8 +192,8 @@ def reflect(x, size): tmp = torch.stack( [ semiring.times( - left2_[:, :, 0, ind_D, Open : Open+1 :, :], - right2[:, :, ind_U, 0, :, Open : Open + 1, Down : Down + 1] + left2_[:, :, 0, ind_D, Open : Open + 1 :, :], + right2[:, :, ind_U, 0, :, Open : Open + 1, Down : Down + 1], ), semiring.times( left2_[:, :, 0, ind_U, Open : Open + 1, :, :], @@ -205,25 +204,33 @@ def reflect(x, size): ) charta[1][:, b, :point, z, y, :, :, :] = tmp - - charta[1] = charta[1][:, :, :, :3] chartb[1] = reflect(charta[1], bin_MN // 2) # Scan def merge2(xa, xb, size, rsize): - nrsize = (rsize-1)*2+3 + nrsize = (rsize - 1) * 2 + 3 rsize += 2 print(nrsize, rsize) st = [] left = ( - pad_conv(demote(xa[:, :, 0 : size * 2 : 2, :], 3), nrsize, 7, semiring, 2, 2) + pad_conv( + demote(xa[:, :, 0 : size * 2 : 2, :], 3), nrsize, 7, semiring, 2, 2 + ) .transpose(-1, -2) - .view(ssize, batch, size, bin_MN, 1, LOC, LOC, 3, nrsize, rsize+2) + .view(ssize, batch, size, bin_MN, 1, LOC, LOC, 3, nrsize, rsize + 2) ) right = ( - pad(pad_conv(demote(xb[:, :, 1 : size * 2 : 2, :, :], 4), nrsize, 3, semiring), 1, 1, -2, semiring) + pad( + pad_conv( + demote(xb[:, :, 1 : size * 2 : 2, :, :], 4), nrsize, 3, semiring + ), + 1, + 1, + -2, + semiring, + ) .transpose(-1, -2) .view(ssize, batch, size, bin_MN, LOC, 1, LOC, 1, 3, nrsize, rsize) ) @@ -231,27 +238,39 @@ def merge2(xa, xb, size, rsize): for op in (Up, Down, Mid): top, bot = rsize + 1, 1 if op == Up: - top, bot = rsize +2 , 2 + top, bot = rsize + 2, 2 if op == Down: top, bot = rsize, 0 combine = semiring.dot( left[:, :, :, :, :, Open, :, :, :, bot:top], - right[:, :, :, :, :, Open, :, :, op, :, :] + right[:, :, :, :, :, Open, :, :, op, :, :], ) - combine = combine.view(ssize, batch, size, bin_MN, LOC, LOC, 3, nrsize) \ - .permute(0, 1, 2, 7, 3, 4, 5, 6) + combine = combine.view( + ssize, batch, size, bin_MN, LOC, LOC, 3, nrsize + ).permute(0, 1, 2, 7, 3, 4, 5, 6) st.append(combine) if self.local: - left_ = pad(xa[:, :, 0 :: 2, :, :, Close, :, :], rsize//2, rsize//2, 3, semiring) - right = pad(xa[:, :, 1 :: 2, :, :, :, Close, :], rsize//2, rsize//2, 3, semiring) + left_ = pad( + xa[:, :, 0::2, :, :, Close, :, :], + rsize // 2, + rsize // 2, + 3, + semiring, + ) + right = pad( + xa[:, :, 1::2, :, :, :, Close, :], + rsize // 2, + rsize // 2, + 3, + semiring, + ) st.append(torch.stack([semiring.zero_(left_.clone()), left_], dim=-3)) st.append(torch.stack([semiring.zero_(right.clone()), right], dim=-2)) st = torch.stack(st, dim=-1) return semiring.sum(st) - size = bin_MN // 2 rsize = 2 for n in range(2, log_MN + 1): @@ -271,9 +290,9 @@ def merge2(xa, xb, size, rsize): if self.local: v = semiring.sum(semiring.sum(charta[-1][:, :, 0, :, :, Close, Close, Mid])) else: - # v = chart[-1][:, :, 0, M, N, Open, Open, Mid] - v = charta[-1][:, :, 0, M-N + (charta[-1].shape[3] //2), - N, Open, Open, Mid] + v = charta[-1][ + :, :, 0, M - N + (charta[-1].shape[3] // 2), N, Open, Open, Mid + ] return v, [log_potentials], None @staticmethod diff --git a/torch_struct/distributions.py b/torch_struct/distributions.py index 0e84d473..16fc17d4 100644 --- a/torch_struct/distributions.py +++ b/torch_struct/distributions.py @@ -221,6 +221,7 @@ class AlignmentCRF(StructDistribution): :math:`\phi(i, j, op)` Ops are 0 -> j-1, 1->i-1,j-1, and 2->i-1 local (bool): if true computes local alignment (Smith-Waterman), else Needleman-Wunsch + max_gap (int or None): the maximum gap to allow in the dynamic program lengths (long tensor) : batch shape integers for length masking. @@ -232,12 +233,14 @@ class AlignmentCRF(StructDistribution): """ struct = Alignment - def __init__(self, log_potentials, local=False, lengths=None): + def __init__(self, log_potentials, local=False, lengths=None, max_gap=None): self.local = local super().__init__(log_potentials, lengths) def _struct(self, sr=None): - return self.struct(sr if sr is not None else LogSemiring, self.local) + return self.struct( + sr if sr is not None else LogSemiring, self.local, max_gap=self.max_gap + ) class HMM(StructDistribution): diff --git a/torch_struct/semirings.py b/torch_struct/semirings.py index 6021873c..88b14230 100644 --- a/torch_struct/semirings.py +++ b/torch_struct/semirings.py @@ -59,6 +59,7 @@ def sum(xs, dim=-1): def plus(cls, a, b): return cls.sum(torch.stack([a, b], dim=-1)) + class _Base(Semiring): @staticmethod def mul(a, b): diff --git a/torch_struct/test_algorithms.py b/torch_struct/test_algorithms.py index 3277cbc4..35aa1324 100644 --- a/torch_struct/test_algorithms.py +++ b/torch_struct/test_algorithms.py @@ -305,7 +305,7 @@ def test_alignment(data): semiring = data.draw(sampled_from([StdSemiring])) struct = model(semiring) vals, (batch, N) = model._rand() - struct = model(semiring, max_gap=max(3, abs(vals.shape[1]- vals.shape[2])+1)) + struct = model(semiring, max_gap=max(3, abs(vals.shape[1] - vals.shape[2]) + 1)) vals.fill_(1) alpha = struct.sum(vals) @@ -315,7 +315,6 @@ def test_alignment(data): vals, (batch, N) = model._rand() vals.fill_(1) - alpha = struct.sum(vals) count = struct.enumerate(vals)[0] assert torch.isclose(count, alpha).all() From 1def2aa85ce6356f972a570cc49a834a8d32b60a Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 15:38:16 -0400 Subject: [PATCH 24/26] . --- torch_struct/alignment.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/torch_struct/alignment.py b/torch_struct/alignment.py index a7676205..40c6da32 100644 --- a/torch_struct/alignment.py +++ b/torch_struct/alignment.py @@ -211,7 +211,6 @@ def reflect(x, size): def merge2(xa, xb, size, rsize): nrsize = (rsize - 1) * 2 + 3 rsize += 2 - print(nrsize, rsize) st = [] left = ( pad_conv( @@ -274,7 +273,6 @@ def merge2(xa, xb, size, rsize): size = bin_MN // 2 rsize = 2 for n in range(2, log_MN + 1): - print(n) size = int(size / 2) rsize *= 2 q = merge2(charta[n - 1], chartb[n - 1], size, charta[n - 1].shape[3]) From 595bd5df62c239a75fd54cd35d1666a9c3e00774 Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 15:40:17 -0400 Subject: [PATCH 25/26] . --- torch_struct/distributions.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/torch_struct/distributions.py b/torch_struct/distributions.py index 16fc17d4..ac09ddd9 100644 --- a/torch_struct/distributions.py +++ b/torch_struct/distributions.py @@ -225,10 +225,10 @@ class AlignmentCRF(StructDistribution): lengths (long tensor) : batch shape integers for length masking. - Implementation uses linear-scan. + Implementation uses convolution and linear-scan. Use max_gap for long sequences. - * Parallel Time: :math:`O(\log (M +N))` parallel merges. - * Forward Memory: :math:`O((M+N)^3)` + * Parallel Time: :math:`O(\log (M + N))` parallel merges. + * Forward Memory: :math:`O((M+N)^2)` """ struct = Alignment From 7c18adab9789780fb777a8e5962162be1a91404e Mon Sep 17 00:00:00 2001 From: Sasha Date: Wed, 30 Oct 2019 16:05:09 -0400 Subject: [PATCH 26/26] . --- torch_struct/semimarkov.py | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/torch_struct/semimarkov.py b/torch_struct/semimarkov.py index de9d3d0d..23dacabc 100644 --- a/torch_struct/semimarkov.py +++ b/torch_struct/semimarkov.py @@ -31,9 +31,14 @@ def _dp(self, log_potentials, lengths=None, force_grad=False): ) log_N = int(math.ceil(math.log(N - 1, 2))) bin_N = int(math.pow(2, log_N)) - chart = self._make_chart( - log_N + 1, (batch, bin_N, K - 1, K - 1, C, C), log_potentials, force_grad - ) + chart = [ + self._make_chart( + 1, (batch, bin_N, K - 1, K - 1, C, C), log_potentials, force_grad + )[0] + if i == 0 + else None + for i in range(log_N + 1) + ] # Init for b in range(lengths.shape[0]): @@ -67,7 +72,7 @@ def merge(x, size): size = bin_N for n in range(1, log_N + 1): size = int(size / 2) - chart[n][:, :, :size] = merge(chart[n - 1], size) + chart[n] = merge(chart[n - 1], size) v = semiring.sum(semiring.sum(chart[-1][:, :, 0, 0, 0, :, :])) return v, [log_potentials], None