From 0904426d2f223079a04d318d632d6ab1695fbd80 Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Wed, 28 Feb 2018 18:25:50 -0800
Subject: [PATCH 01/17] Initial commit for unique op

---
 aten/src/ATen/native/Unique.cpp            | 0
 aten/src/ATen/native/native_functions.yaml | 3 +++
 test/test_torch.py                         | 3 +++
 3 files changed, 6 insertions(+)
 create mode 100644 aten/src/ATen/native/Unique.cpp

diff --git a/aten/src/ATen/native/Unique.cpp b/aten/src/ATen/native/Unique.cpp
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/aten/src/ATen/native/native_functions.yaml b/aten/src/ATen/native/native_functions.yaml
index f7dc2d1203418..fc2737c45355e 100644
--- a/aten/src/ATen/native/native_functions.yaml
+++ b/aten/src/ATen/native/native_functions.yaml
@@ -363,6 +363,9 @@
 - func: type_as(Tensor self, Tensor other) -> Tensor
   variants: method
 
+- func: unique(Tensor self, bool return_inverse=false) -> (Tensor, Tensor)
+  variants: method
+
 - func: _unsafe_view(Tensor self, IntList size) -> Tensor
   variants: function
 
diff --git a/test/test_torch.py b/test/test_torch.py
index 1632f424fa984..2444e559f3340 100644
--- a/test/test_torch.py
+++ b/test/test_torch.py
@@ -5422,6 +5422,9 @@ def test_set_flush_denormal(self):
         self.assertEqual(double_tensor[2], 0.0, prec=0.0)  # tiny_double to zero
         torch.set_flush_denormal(False)
 
+    def test_unique(self):
+        pass
+    
 # Functions to test negative dimension wrapping
 METHOD = 1
 INPLACE_METHOD = 2

From a8d5ffa6ec8095437d802b597dc3e73cb8ef5aa1 Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Thu, 1 Mar 2018 10:52:36 -0800
Subject: [PATCH 02/17] Working unique with test

---
 aten/src/ATen/native/Unique.cpp            | 43 ++++++++++++++++++++++
 aten/src/ATen/native/native_functions.yaml |  2 +-
 test/test_torch.py                         | 43 +++++++++++++++++++++-
 3 files changed, 85 insertions(+), 3 deletions(-)

diff --git a/aten/src/ATen/native/Unique.cpp b/aten/src/ATen/native/Unique.cpp
index e69de29bb2d1d..c61589ba54220 100644
--- a/aten/src/ATen/native/Unique.cpp
+++ b/aten/src/ATen/native/Unique.cpp
@@ -0,0 +1,43 @@
+#include <unordered_map>
+#include <unordered_set>
+
+#include "ATen/ATen.h"
+
+namespace at {
+namespace native{
+
+std::tuple<Tensor, Tensor> unique_1d(
+    const Tensor& self, const bool sorted, const bool return_inverse) {
+  std::unordered_set<int64_t> set(
+      self.data<int64_t>(), self.data<int64_t>() + self.numel());
+  Tensor output = self.type().tensor({static_cast<long long>(set.size())});
+  
+  if (!sorted) {
+    std::copy(set.begin(), set.end(), output.data<int64_t>());
+  } else {
+    std::vector<int64_t> vec(set.begin(), set.end());
+    std::sort(vec.begin(), vec.end());
+    std::copy(vec.begin(), vec.end(), output.data<int64_t>());
+  }
+
+  Tensor inverse_indices;
+  if (!return_inverse) {
+    inverse_indices = self.type().toScalarType(kLong).tensor({0});
+    
+  } else {
+    inverse_indices = self.type().toScalarType(kLong).tensor({self.numel()});    
+    std::unordered_map<int64_t, int64_t> inverse_map;
+    inverse_map.reserve(output.numel());
+    for (int i = 0; i < output.numel(); ++i) {
+      inverse_map[output.data<int64_t>()[i]] = i;
+    }
+    for (int i = 0; i < self.numel(); ++i) {
+      inverse_indices.data<int64_t>()[i] = inverse_map[self.data<int64_t>()[i]];
+    }
+  }
+  
+  return std::make_tuple(output, inverse_indices);
+}
+
+}  // namespace native
+}  // namespace at
diff --git a/aten/src/ATen/native/native_functions.yaml b/aten/src/ATen/native/native_functions.yaml
index fc2737c45355e..5e3ee40fbbd80 100644
--- a/aten/src/ATen/native/native_functions.yaml
+++ b/aten/src/ATen/native/native_functions.yaml
@@ -363,7 +363,7 @@
 - func: type_as(Tensor self, Tensor other) -> Tensor
   variants: method
 
-- func: unique(Tensor self, bool return_inverse=false) -> (Tensor, Tensor)
+- func: unique_1d(IndexTensor self, bool sorted=false, bool return_inverse=false) -> (Tensor, Tensor)
   variants: method
 
 - func: _unsafe_view(Tensor self, IntList size) -> Tensor
diff --git a/test/test_torch.py b/test/test_torch.py
index 2444e559f3340..0eae3322e285d 100644
--- a/test/test_torch.py
+++ b/test/test_torch.py
@@ -5423,8 +5423,47 @@ def test_set_flush_denormal(self):
         torch.set_flush_denormal(False)
 
     def test_unique(self):
-        pass
-    
+        x = torch.LongTensor([1, 2, 3, 2, 8, 5, 2, 3])
+        expected_unique = torch.LongTensor([1, 2, 3, 5, 8])
+        expected_inverse = torch.LongTensor([0, 1, 2, 1, 4, 3, 1, 2])
+        empty_inverse = torch.LongTensor([])
+
+        if TEST_NUMPY:
+            x_unique, x_inverse = x.unique_1d()
+            self.assertEqual(
+                expected_unique.numpy().tolist(),
+                sorted(x_unique.numpy().tolist())
+            ) 
+            self.assertEqual(empty_inverse, x_inverse)
+
+            x_unique, x_inverse = x.unique_1d(return_inverse=True)
+            self.assertEqual(
+                expected_unique.numpy().tolist(),
+                sorted(x_unique.numpy().tolist())
+            )
+            self.assertEqual(expected_inverse.numel(), x_inverse.numel())
+            
+        x_unique, x_inverse = x.unique_1d(sorted=True)
+        self.assertEqual(expected_unique, x_unique)
+        self.assertEqual(empty_inverse, x_inverse)
+
+        x_unique, x_inverse = x.unique_1d(sorted=True, return_inverse=True)
+        self.assertEqual(expected_unique, x_unique)
+        self.assertEqual(expected_inverse, x_inverse)
+
+        # Tests 1-D unique on a higher rank tensor.
+        y = x.view(2, 2, 2)
+        y_unique, y_inverse = y.unique_1d(sorted=True, return_inverse=True)
+        self.assertEqual(expected_unique, y_unique)
+        self.assertEqual(expected_inverse, y_inverse)
+        
+        # Tests invalid use cases.
+        self.assertRaises(
+            RuntimeError, lambda: torch.IntTensor([1, 2, 3]).unique_1d())
+        self.assertRaises(
+            RuntimeError, lambda: torch.FloatTensor([1., 2.5, 3.5]).unique_1d())
+        
+
 # Functions to test negative dimension wrapping
 METHOD = 1
 INPLACE_METHOD = 2

From 55a8b5ae03310c13e7a3a74e33218eaf290c86bc Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Thu, 1 Mar 2018 12:19:31 -0800
Subject: [PATCH 03/17] Make inverse indices shape conform to input

---
 aten/src/ATen/native/Unique.cpp            |  6 ++++--
 aten/src/ATen/native/native_functions.yaml |  2 +-
 test/test_torch.py                         | 18 +++++++++---------
 3 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/aten/src/ATen/native/Unique.cpp b/aten/src/ATen/native/Unique.cpp
index c61589ba54220..d3c41a209613e 100644
--- a/aten/src/ATen/native/Unique.cpp
+++ b/aten/src/ATen/native/Unique.cpp
@@ -1,3 +1,5 @@
+// Returns unique elements of input tensor.
+
 #include <unordered_map>
 #include <unordered_set>
 
@@ -6,7 +8,7 @@
 namespace at {
 namespace native{
 
-std::tuple<Tensor, Tensor> unique_1d(
+std::tuple<Tensor, Tensor> unique(
     const Tensor& self, const bool sorted, const bool return_inverse) {
   std::unordered_set<int64_t> set(
       self.data<int64_t>(), self.data<int64_t>() + self.numel());
@@ -25,7 +27,7 @@ std::tuple<Tensor, Tensor> unique_1d(
     inverse_indices = self.type().toScalarType(kLong).tensor({0});
     
   } else {
-    inverse_indices = self.type().toScalarType(kLong).tensor({self.numel()});    
+    inverse_indices = self.type().toScalarType(kLong).tensor(self.sizes());    
     std::unordered_map<int64_t, int64_t> inverse_map;
     inverse_map.reserve(output.numel());
     for (int i = 0; i < output.numel(); ++i) {
diff --git a/aten/src/ATen/native/native_functions.yaml b/aten/src/ATen/native/native_functions.yaml
index 5e3ee40fbbd80..8854c1581b41d 100644
--- a/aten/src/ATen/native/native_functions.yaml
+++ b/aten/src/ATen/native/native_functions.yaml
@@ -363,7 +363,7 @@
 - func: type_as(Tensor self, Tensor other) -> Tensor
   variants: method
 
-- func: unique_1d(IndexTensor self, bool sorted=false, bool return_inverse=false) -> (Tensor, Tensor)
+- func: unique(IndexTensor self, bool sorted=false, bool return_inverse=false) -> (Tensor, Tensor)
   variants: method
 
 - func: _unsafe_view(Tensor self, IntList size) -> Tensor
diff --git a/test/test_torch.py b/test/test_torch.py
index 0eae3322e285d..58f4f4c8eb621 100644
--- a/test/test_torch.py
+++ b/test/test_torch.py
@@ -5429,39 +5429,39 @@ def test_unique(self):
         empty_inverse = torch.LongTensor([])
 
         if TEST_NUMPY:
-            x_unique, x_inverse = x.unique_1d()
+            x_unique, x_inverse = x.unique()
             self.assertEqual(
                 expected_unique.numpy().tolist(),
                 sorted(x_unique.numpy().tolist())
             ) 
             self.assertEqual(empty_inverse, x_inverse)
 
-            x_unique, x_inverse = x.unique_1d(return_inverse=True)
+            x_unique, x_inverse = x.unique(return_inverse=True)
             self.assertEqual(
                 expected_unique.numpy().tolist(),
                 sorted(x_unique.numpy().tolist())
             )
             self.assertEqual(expected_inverse.numel(), x_inverse.numel())
             
-        x_unique, x_inverse = x.unique_1d(sorted=True)
+        x_unique, x_inverse = x.unique(sorted=True)
         self.assertEqual(expected_unique, x_unique)
         self.assertEqual(empty_inverse, x_inverse)
 
-        x_unique, x_inverse = x.unique_1d(sorted=True, return_inverse=True)
+        x_unique, x_inverse = x.unique(sorted=True, return_inverse=True)
         self.assertEqual(expected_unique, x_unique)
         self.assertEqual(expected_inverse, x_inverse)
 
-        # Tests 1-D unique on a higher rank tensor.
+        # Tests per-element unique on a higher rank tensor.
         y = x.view(2, 2, 2)
-        y_unique, y_inverse = y.unique_1d(sorted=True, return_inverse=True)
+        y_unique, y_inverse = y.unique(sorted=True, return_inverse=True)
         self.assertEqual(expected_unique, y_unique)
-        self.assertEqual(expected_inverse, y_inverse)
+        self.assertEqual(expected_inverse.view(y.size()), y_inverse)
         
         # Tests invalid use cases.
         self.assertRaises(
-            RuntimeError, lambda: torch.IntTensor([1, 2, 3]).unique_1d())
+            RuntimeError, lambda: torch.IntTensor([1, 2, 3]).unique())
         self.assertRaises(
-            RuntimeError, lambda: torch.FloatTensor([1., 2.5, 3.5]).unique_1d())
+            RuntimeError, lambda: torch.FloatTensor([1., 2.5, 3.5]).unique())
         
 
 # Functions to test negative dimension wrapping

From a197a7baef2f3e4ebe0859229f9b3979e17335f9 Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Thu, 1 Mar 2018 12:26:29 -0800
Subject: [PATCH 04/17] flake8 whitespace removal

---
 test/test_torch.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/test_torch.py b/test/test_torch.py
index 58f4f4c8eb621..3c4f668a7e767 100644
--- a/test/test_torch.py
+++ b/test/test_torch.py
@@ -5433,7 +5433,7 @@ def test_unique(self):
             self.assertEqual(
                 expected_unique.numpy().tolist(),
                 sorted(x_unique.numpy().tolist())
-            ) 
+            )
             self.assertEqual(empty_inverse, x_inverse)
 
             x_unique, x_inverse = x.unique(return_inverse=True)
@@ -5442,7 +5442,7 @@ def test_unique(self):
                 sorted(x_unique.numpy().tolist())
             )
             self.assertEqual(expected_inverse.numel(), x_inverse.numel())
-            
+
         x_unique, x_inverse = x.unique(sorted=True)
         self.assertEqual(expected_unique, x_unique)
         self.assertEqual(empty_inverse, x_inverse)
@@ -5456,13 +5456,13 @@ def test_unique(self):
         y_unique, y_inverse = y.unique(sorted=True, return_inverse=True)
         self.assertEqual(expected_unique, y_unique)
         self.assertEqual(expected_inverse.view(y.size()), y_inverse)
-        
+
         # Tests invalid use cases.
         self.assertRaises(
             RuntimeError, lambda: torch.IntTensor([1, 2, 3]).unique())
         self.assertRaises(
             RuntimeError, lambda: torch.FloatTensor([1., 2.5, 3.5]).unique())
-        
+
 
 # Functions to test negative dimension wrapping
 METHOD = 1

From 3c263099ee606ad1e2bb740589603f44ee762d90 Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Thu, 1 Mar 2018 13:13:11 -0800
Subject: [PATCH 05/17] address review comment nits

---
 aten/src/ATen/native/Unique.cpp | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/aten/src/ATen/native/Unique.cpp b/aten/src/ATen/native/Unique.cpp
index d3c41a209613e..7fe2ef5f2513f 100644
--- a/aten/src/ATen/native/Unique.cpp
+++ b/aten/src/ATen/native/Unique.cpp
@@ -1,10 +1,10 @@
 // Returns unique elements of input tensor.
 
+#include "ATen/ATen.h"
+
 #include <unordered_map>
 #include <unordered_set>
 
-#include "ATen/ATen.h"
-
 namespace at {
 namespace native{
 
@@ -14,19 +14,16 @@ std::tuple<Tensor, Tensor> unique(
       self.data<int64_t>(), self.data<int64_t>() + self.numel());
   Tensor output = self.type().tensor({static_cast<long long>(set.size())});
   
-  if (!sorted) {
-    std::copy(set.begin(), set.end(), output.data<int64_t>());
-  } else {
+  if (sorted) {
     std::vector<int64_t> vec(set.begin(), set.end());
     std::sort(vec.begin(), vec.end());
     std::copy(vec.begin(), vec.end(), output.data<int64_t>());
+  } else {
+    std::copy(set.begin(), set.end(), output.data<int64_t>());
   }
 
   Tensor inverse_indices;
-  if (!return_inverse) {
-    inverse_indices = self.type().toScalarType(kLong).tensor({0});
-    
-  } else {
+  if (return_inverse) {
     inverse_indices = self.type().toScalarType(kLong).tensor(self.sizes());    
     std::unordered_map<int64_t, int64_t> inverse_map;
     inverse_map.reserve(output.numel());
@@ -36,6 +33,8 @@ std::tuple<Tensor, Tensor> unique(
     for (int i = 0; i < self.numel(); ++i) {
       inverse_indices.data<int64_t>()[i] = inverse_map[self.data<int64_t>()[i]];
     }
+  } else {
+    inverse_indices = self.type().toScalarType(kLong).tensor({0});
   }
   
   return std::make_tuple(output, inverse_indices);

From b48b427606a8d930a60497e84cc1589b7ac52e0c Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Thu, 1 Mar 2018 18:08:50 -0800
Subject: [PATCH 06/17] Expose fn and add docs. Explicitly declare no gradients

---
 aten/src/ATen/native/native_functions.yaml |  5 +-
 test/test_torch.py                         | 13 ++---
 tools/autograd/derivatives.yaml            |  3 ++
 torch/_tensor_docs.py                      |  7 +++
 torch/_torch_docs.py                       | 56 ++++++++++++++++++++++
 5 files changed, 75 insertions(+), 9 deletions(-)

diff --git a/aten/src/ATen/native/native_functions.yaml b/aten/src/ATen/native/native_functions.yaml
index 8854c1581b41d..711dbba396ba2 100644
--- a/aten/src/ATen/native/native_functions.yaml
+++ b/aten/src/ATen/native/native_functions.yaml
@@ -363,9 +363,8 @@
 - func: type_as(Tensor self, Tensor other) -> Tensor
   variants: method
 
-- func: unique(IndexTensor self, bool sorted=false, bool return_inverse=false) -> (Tensor, Tensor)
-  variants: method
-
+- func: unique(Tensor self, bool sorted=false, bool return_inverse=false) -> (Tensor, Tensor)
+  
 - func: _unsafe_view(Tensor self, IntList size) -> Tensor
   variants: function
 
diff --git a/test/test_torch.py b/test/test_torch.py
index 3c4f668a7e767..3fbe4a1ae6b17 100644
--- a/test/test_torch.py
+++ b/test/test_torch.py
@@ -5429,7 +5429,7 @@ def test_unique(self):
         empty_inverse = torch.LongTensor([])
 
         if TEST_NUMPY:
-            x_unique, x_inverse = x.unique()
+            x_unique, x_inverse = torch.unique(x)
             self.assertEqual(
                 expected_unique.numpy().tolist(),
                 sorted(x_unique.numpy().tolist())
@@ -5447,7 +5447,8 @@ def test_unique(self):
         self.assertEqual(expected_unique, x_unique)
         self.assertEqual(empty_inverse, x_inverse)
 
-        x_unique, x_inverse = x.unique(sorted=True, return_inverse=True)
+        x_unique, x_inverse = torch.autograd.Variable.unique(
+            x, sorted=True, return_inverse=True)
         self.assertEqual(expected_unique, x_unique)
         self.assertEqual(expected_inverse, x_inverse)
 
@@ -5458,10 +5459,10 @@ def test_unique(self):
         self.assertEqual(expected_inverse.view(y.size()), y_inverse)
 
         # Tests invalid use cases.
-        self.assertRaises(
-            RuntimeError, lambda: torch.IntTensor([1, 2, 3]).unique())
-        self.assertRaises(
-            RuntimeError, lambda: torch.FloatTensor([1., 2.5, 3.5]).unique())
+        #self.assertRaises(
+        #    RuntimeError, lambda: torch.IntTensor([1, 2, 3]).unique())
+        #self.assertRaises(
+        #    RuntimeError, lambda: torch.FloatTensor([1., 2.5, 3.5]).unique())
 
 
 # Functions to test negative dimension wrapping
diff --git a/tools/autograd/derivatives.yaml b/tools/autograd/derivatives.yaml
index b53c067198e62..e4391c328714e 100644
--- a/tools/autograd/derivatives.yaml
+++ b/tools/autograd/derivatives.yaml
@@ -637,6 +637,9 @@
 - name: uniform_(Tensor self, double from, double to, Generator generator)
   self: zeros_like(grad)
 
+- name: unique(Tensor self, bool sorted, bool return_inverse)
+  self: not_implemented("unique")
+
 - name: _unsafe_view(Tensor self, IntList size)
   self: grad.contiguous().view(self.sizes())
 
diff --git a/torch/_tensor_docs.py b/torch/_tensor_docs.py
index aa635170510fe..c3fc92f15f458 100644
--- a/torch/_tensor_docs.py
+++ b/torch/_tensor_docs.py
@@ -1795,6 +1795,13 @@ def callable(a, b) -> number
     P(x) = \dfrac{1}{to - from}
 """)
 
+add_docstr_all('unique',
+               r"""
+unique(sorted=False, return_inverse=False)
+
+See :func:`torch.unique`
+""")
+
 add_docstr_all('unsqueeze',
                r"""
 unsqueeze(dim)
diff --git a/torch/_torch_docs.py b/torch/_torch_docs.py
index 2518a29286f42..a09e22bbb8dab 100644
--- a/torch/_torch_docs.py
+++ b/torch/_torch_docs.py
@@ -4926,6 +4926,62 @@
 
 """)
 
+add_docstr(torch.unique,
+           r"""
+unique(input, sorted=False, return_inverse=False) -> (Tensor, Tensor)
+
+Returns the unique scalar elements of the input tensor as list.
+
+Args:
+    input (Tensor): the input tensor
+    sorted (bool): Whether to sort the unique elements in ascending order
+        before returning as output.
+    return_inverse (bool): Whether to also return the indices for where
+        elements in the original input ended up in the returned unique list. 
+
+Returns:
+    (Tensor, Tensor): A tuple containing
+
+        - **output** (*Tensor*): the list of unique scalar elements
+        - **inverse_indices** (*Tensor*): the indices (same shape as input)
+            for where elements in the original input map to in the output
+            if ``return_inverse`` is ``True``; otherwise, an empty tensor.
+
+Example::
+
+    >>>> output, inverse_indices = torch.unique(
+             torch.LongTensor([1, 3, 2, 3]), sorted=True, return_inverse=True)
+    >>>> output
+    
+     1
+     2
+     3
+    [torch.LongTensor of size (3,)]
+    
+    >>>> inverse_indices
+
+     0
+     2
+     1
+     2
+    [torch.LongTensor of size (4,)]
+
+    >>>> output, inverse_indices = torch.unique(
+             torch.LongTensor([[1, 3], [2, 3]]), sorted=True, return_inverse=True)
+    >>>> output
+
+     1
+     2
+     3
+    [torch.LongTensor of size (3,)]
+
+    >>>> inverse_indices
+
+     0  2
+     1  2
+    [torch.LongTensor of size (2,2)]
+""")
+
 add_docstr(torch.unsqueeze,
            r"""
 unsqueeze(input, dim, out=None)

From 00244e8fc4c1f93a519a5bce6c779d79bc1d7754 Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Thu, 1 Mar 2018 18:59:02 -0800
Subject: [PATCH 07/17] Trial generic dispatch implementation

---
 aten/src/ATen/native/Unique.cpp | 59 ++++++++++++++++++++++-----------
 1 file changed, 40 insertions(+), 19 deletions(-)

diff --git a/aten/src/ATen/native/Unique.cpp b/aten/src/ATen/native/Unique.cpp
index 7fe2ef5f2513f..d944ada90c99a 100644
--- a/aten/src/ATen/native/Unique.cpp
+++ b/aten/src/ATen/native/Unique.cpp
@@ -1,6 +1,9 @@
 // Returns unique elements of input tensor.
 
 #include "ATen/ATen.h"
+#include "ATen/Dispatch.h"
+#include "ATen/ExpandUtils.h"
+#include "ATen/NativeFunctions.h"
 
 #include <unordered_map>
 #include <unordered_set>
@@ -8,35 +11,53 @@
 namespace at {
 namespace native{
 
-std::tuple<Tensor, Tensor> unique(
-    const Tensor& self, const bool sorted, const bool return_inverse) {
-  std::unordered_set<int64_t> set(
-      self.data<int64_t>(), self.data<int64_t>() + self.numel());
-  Tensor output = self.type().tensor({static_cast<long long>(set.size())});
-  
+namespace {
+template <typename scalar_t>
+std::tuple<Tensor, Tensor> unique_template(
+    const Tensor& self,
+    const bool sorted,
+    const bool return_inverse,
+    Tensor* output,
+    Tensor* inverse_indices) {
+  std::unordered_set<scalar_t> set(
+      self.data<scalar_t>(), self.data<scalar_t>() + self.numel());
+  output->resize_({static_cast<long long>(set.size())});
+
   if (sorted) {
-    std::vector<int64_t> vec(set.begin(), set.end());
+    std::vector<scalar_t> vec(set.begin(), set.end());
     std::sort(vec.begin(), vec.end());
-    std::copy(vec.begin(), vec.end(), output.data<int64_t>());
+    std::copy(vec.begin(), vec.end(), output->data<scalar_t>());
   } else {
-    std::copy(set.begin(), set.end(), output.data<int64_t>());
+    std::copy(set.begin(), set.end(), output->data<scalar_t>());
   }
 
-  Tensor inverse_indices;
   if (return_inverse) {
-    inverse_indices = self.type().toScalarType(kLong).tensor(self.sizes());    
-    std::unordered_map<int64_t, int64_t> inverse_map;
-    inverse_map.reserve(output.numel());
-    for (int i = 0; i < output.numel(); ++i) {
-      inverse_map[output.data<int64_t>()[i]] = i;
+    inverse_indices->resize_(self.sizes());
+    std::unordered_map<scalar_t, int64_t> inverse_map;
+    inverse_map.reserve(output->numel());
+    for (int i = 0; i < output->numel(); ++i) {
+      inverse_map[output->data<scalar_t>()[i]] = i;
     }
     for (int i = 0; i < self.numel(); ++i) {
-      inverse_indices.data<int64_t>()[i] = inverse_map[self.data<int64_t>()[i]];
+      inverse_indices->data<int64_t>()[i] =
+          inverse_map[self.data<scalar_t>()[i]];
     }
-  } else {
-    inverse_indices = self.type().toScalarType(kLong).tensor({0});
   }
-  
+}
+} // namespace
+
+std::tuple<Tensor, Tensor>
+unique(const Tensor& self, const bool sorted, const bool return_inverse) {
+  // output will be resized in unique_template once we know how big it is.
+  // inverse_indices may also be resized depending on return_inverse.
+  Tensor output = self.type().tensor({0});
+  Tensor inverse_indices = self.type().toScalarType(kLong).tensor({0});
+
+  AT_DISPATCH_ALL_TYPES(self.type(), "unique", [&] {
+    unique_template<scalar_t>(
+        self, sorted, return_inverse, &output, &inverse_indices);
+  });
+
   return std::make_tuple(output, inverse_indices);
 }
 

From bd49d0ad3c00e4cc70c2f4da8f06782f4f546f7a Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Thu, 1 Mar 2018 19:54:18 -0800
Subject: [PATCH 08/17] Add tests for generics

---
 aten/src/ATen/native/Unique.cpp |  8 +++++---
 test/test_torch.py              | 26 +++++++++++++++++++++-----
 2 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/aten/src/ATen/native/Unique.cpp b/aten/src/ATen/native/Unique.cpp
index d944ada90c99a..5e824e2420424 100644
--- a/aten/src/ATen/native/Unique.cpp
+++ b/aten/src/ATen/native/Unique.cpp
@@ -2,18 +2,20 @@
 
 #include "ATen/ATen.h"
 #include "ATen/Dispatch.h"
-#include "ATen/ExpandUtils.h"
-#include "ATen/NativeFunctions.h"
 
 #include <unordered_map>
 #include <unordered_set>
 
+#include <iostream>
+using std::cout;
+using std::endl;
+
 namespace at {
 namespace native{
 
 namespace {
 template <typename scalar_t>
-std::tuple<Tensor, Tensor> unique_template(
+void unique_template(
     const Tensor& self,
     const bool sorted,
     const bool return_inverse,
diff --git a/test/test_torch.py b/test/test_torch.py
index 3fbe4a1ae6b17..97033c7c5e8eb 100644
--- a/test/test_torch.py
+++ b/test/test_torch.py
@@ -5458,11 +5458,27 @@ def test_unique(self):
         self.assertEqual(expected_unique, y_unique)
         self.assertEqual(expected_inverse.view(y.size()), y_inverse)
 
-        # Tests invalid use cases.
-        #self.assertRaises(
-        #    RuntimeError, lambda: torch.IntTensor([1, 2, 3]).unique())
-        #self.assertRaises(
-        #    RuntimeError, lambda: torch.FloatTensor([1., 2.5, 3.5]).unique())
+        # Tests unique on other types.
+        int_unique, int_inverse = torch.unique(
+            torch.IntTensor([2, 1, 2]), sorted=True, return_inverse=True)
+        self.assertEqual(torch.IntTensor([1, 2]), int_unique)
+        self.assertEqual(torch.LongTensor([1, 0, 1]), int_inverse)
+
+        double_unique, double_inverse = torch.unique(
+            torch.DoubleTensor([2., 1.5, 2.1, 2.]),
+            sorted=True,
+            return_inverse=True,
+        )
+        self.assertEqual(torch.DoubleTensor([1.5, 2., 2.1]), double_unique)
+        self.assertEqual(torch.LongTensor([1, 0, 2, 1]), double_inverse)
+
+        byte_unique, byte_inverse = torch.unique(
+            torch.ByteTensor([133, 7, 7, 7, 42, 128]),
+            sorted=True,
+            return_inverse=True,
+        )
+        self.assertEqual(torch.ByteTensor([7, 42, 128, 133]), byte_unique)
+        self.assertEqual(torch.LongTensor([3, 0, 0, 0, 1, 2]), byte_inverse)
 
 
 # Functions to test negative dimension wrapping

From a3dc7b23e8efad32c99507eb24fc35c6c0ccdec4 Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Thu, 1 Mar 2018 20:42:31 -0800
Subject: [PATCH 09/17] flake8 whitespace

---
 torch/_torch_docs.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/torch/_torch_docs.py b/torch/_torch_docs.py
index a09e22bbb8dab..3b799cafd6a3a 100644
--- a/torch/_torch_docs.py
+++ b/torch/_torch_docs.py
@@ -4937,7 +4937,7 @@
     sorted (bool): Whether to sort the unique elements in ascending order
         before returning as output.
     return_inverse (bool): Whether to also return the indices for where
-        elements in the original input ended up in the returned unique list. 
+        elements in the original input ended up in the returned unique list.
 
 Returns:
     (Tensor, Tensor): A tuple containing
@@ -4952,12 +4952,12 @@
     >>>> output, inverse_indices = torch.unique(
              torch.LongTensor([1, 3, 2, 3]), sorted=True, return_inverse=True)
     >>>> output
-    
+
      1
      2
      3
     [torch.LongTensor of size (3,)]
-    
+
     >>>> inverse_indices
 
      0

From a016ea268bed7294ced66f93f4b94b9bfc7f1e8b Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Fri, 2 Mar 2018 13:25:37 -0800
Subject: [PATCH 10/17] Add basic CUDA error throwing and templateize set

---
 aten/src/ATen/native/Unique.cpp            | 40 ++++++++++------------
 aten/src/ATen/native/cuda/Unique.cu        | 17 +++++++++
 aten/src/ATen/native/native_functions.yaml |  5 ++-
 test/test_torch.py                         | 14 ++++++--
 4 files changed, 52 insertions(+), 24 deletions(-)
 create mode 100644 aten/src/ATen/native/cuda/Unique.cu

diff --git a/aten/src/ATen/native/Unique.cpp b/aten/src/ATen/native/Unique.cpp
index 5e824e2420424..354588bc6a61d 100644
--- a/aten/src/ATen/native/Unique.cpp
+++ b/aten/src/ATen/native/Unique.cpp
@@ -3,35 +3,26 @@
 #include "ATen/ATen.h"
 #include "ATen/Dispatch.h"
 
+#include <set>
+#include <tuple>
 #include <unordered_map>
 #include <unordered_set>
 
-#include <iostream>
-using std::cout;
-using std::endl;
-
 namespace at {
 namespace native{
 
 namespace {
-template <typename scalar_t>
-void unique_template(
+
+template <template <class...> class set_type, typename scalar_t>
+void _unique_cpu_template(
     const Tensor& self,
-    const bool sorted,
     const bool return_inverse,
     Tensor* output,
     Tensor* inverse_indices) {
-  std::unordered_set<scalar_t> set(
+  set_type<scalar_t> set(
       self.data<scalar_t>(), self.data<scalar_t>() + self.numel());
   output->resize_({static_cast<long long>(set.size())});
-
-  if (sorted) {
-    std::vector<scalar_t> vec(set.begin(), set.end());
-    std::sort(vec.begin(), vec.end());
-    std::copy(vec.begin(), vec.end(), output->data<scalar_t>());
-  } else {
-    std::copy(set.begin(), set.end(), output->data<scalar_t>());
-  }
+  std::copy(set.begin(), set.end(), output->data<scalar_t>());
 
   if (return_inverse) {
     inverse_indices->resize_(self.sizes());
@@ -49,16 +40,23 @@ void unique_template(
 } // namespace
 
 std::tuple<Tensor, Tensor>
-unique(const Tensor& self, const bool sorted, const bool return_inverse) {
+unique_cpu(const Tensor& self, const bool sorted, const bool return_inverse) {
   // output will be resized in unique_template once we know how big it is.
   // inverse_indices may also be resized depending on return_inverse.
   Tensor output = self.type().tensor({0});
   Tensor inverse_indices = self.type().toScalarType(kLong).tensor({0});
 
-  AT_DISPATCH_ALL_TYPES(self.type(), "unique", [&] {
-    unique_template<scalar_t>(
-        self, sorted, return_inverse, &output, &inverse_indices);
-  });
+  if (sorted) {
+    AT_DISPATCH_ALL_TYPES(self.type(), "unique", [&] {
+      _unique_cpu_template<std::set, scalar_t>(
+          self, return_inverse, &output, &inverse_indices);
+    });
+  } else {
+    AT_DISPATCH_ALL_TYPES(self.type(), "unique", [&] {
+      _unique_cpu_template<std::unordered_set, scalar_t>(
+          self, return_inverse, &output, &inverse_indices);
+    });
+  }
 
   return std::make_tuple(output, inverse_indices);
 }
diff --git a/aten/src/ATen/native/cuda/Unique.cu b/aten/src/ATen/native/cuda/Unique.cu
new file mode 100644
index 0000000000000..225b5ad6dfa51
--- /dev/null
+++ b/aten/src/ATen/native/cuda/Unique.cu
@@ -0,0 +1,17 @@
+#include "ATen/ATen.h"
+
+#include <tuple>
+
+namespace at {
+namespace native{
+
+std::tuple<Tensor, Tensor>
+unique_cuda(const Tensor& self, const bool sorted, const bool return_inverse) {
+  throw std::runtime_error(
+      "unique is currently CPU-only, and lacks CUDA support. "
+      "Pull requests welcome!");
+  return std::make_tuple(self.type().tensor({0}), self.type().tensor({0}));
+}
+
+}  // namespace native
+}  // namespace at
diff --git a/aten/src/ATen/native/native_functions.yaml b/aten/src/ATen/native/native_functions.yaml
index 711dbba396ba2..3ee149d49193c 100644
--- a/aten/src/ATen/native/native_functions.yaml
+++ b/aten/src/ATen/native/native_functions.yaml
@@ -364,7 +364,10 @@
   variants: method
 
 - func: unique(Tensor self, bool sorted=false, bool return_inverse=false) -> (Tensor, Tensor)
-  
+  dispatch:
+    CPU: unique_cpu
+    CUDA: unique_cuda
+
 - func: _unsafe_view(Tensor self, IntList size) -> Tensor
   variants: function
 
diff --git a/test/test_torch.py b/test/test_torch.py
index 97033c7c5e8eb..07568ac7f3181 100644
--- a/test/test_torch.py
+++ b/test/test_torch.py
@@ -5422,7 +5422,7 @@ def test_set_flush_denormal(self):
         self.assertEqual(double_tensor[2], 0.0, prec=0.0)  # tiny_double to zero
         torch.set_flush_denormal(False)
 
-    def test_unique(self):
+    def test_unique_cpu(self):
         x = torch.LongTensor([1, 2, 3, 2, 8, 5, 2, 3])
         expected_unique = torch.LongTensor([1, 2, 3, 5, 8])
         expected_inverse = torch.LongTensor([0, 1, 2, 1, 4, 3, 1, 2])
@@ -5447,7 +5447,7 @@ def test_unique(self):
         self.assertEqual(expected_unique, x_unique)
         self.assertEqual(empty_inverse, x_inverse)
 
-        x_unique, x_inverse = torch.autograd.Variable.unique(
+        x_unique, x_inverse = torch.unique(
             x, sorted=True, return_inverse=True)
         self.assertEqual(expected_unique, x_unique)
         self.assertEqual(expected_inverse, x_inverse)
@@ -5480,6 +5480,16 @@ def test_unique(self):
         self.assertEqual(torch.ByteTensor([7, 42, 128, 133]), byte_unique)
         self.assertEqual(torch.LongTensor([3, 0, 0, 0, 1, 2]), byte_inverse)
 
+    @unittest.skipIf(not torch.cuda.is_available(), 'no CUDA')
+    def test_unique_cuda(self):
+        # unique currently does not support CUDA.
+        self.assertRaises(
+            RuntimeError, lambda: torch.cuda.LongTensor([0, 1]).unique())
+        self.assertRaises(
+            RuntimeError,
+            lambda: torch.unique(torch.cuda.FloatTensor([0., 1.])),
+        )
+
 
 # Functions to test negative dimension wrapping
 METHOD = 1

From 294ed5d861e498e06456fd4b31f06843222213aa Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Fri, 2 Mar 2018 15:06:23 -0800
Subject: [PATCH 11/17] Explicit contiguous and AT_DISPATCH_ALL_TYPES return

---
 aten/src/ATen/native/Unique.cpp     | 47 ++++++++++++-----------------
 aten/src/ATen/native/cuda/Unique.cu |  3 +-
 2 files changed, 21 insertions(+), 29 deletions(-)

diff --git a/aten/src/ATen/native/Unique.cpp b/aten/src/ATen/native/Unique.cpp
index 354588bc6a61d..17924c88daa51 100644
--- a/aten/src/ATen/native/Unique.cpp
+++ b/aten/src/ATen/native/Unique.cpp
@@ -14,51 +14,44 @@ namespace native{
 namespace {
 
 template <template <class...> class set_type, typename scalar_t>
-void _unique_cpu_template(
+std::tuple<Tensor, Tensor> _unique_cpu_template(
     const Tensor& self,
-    const bool return_inverse,
-    Tensor* output,
-    Tensor* inverse_indices) {
+    const bool return_inverse) {
+  const Tensor& input = self.contiguous();
   set_type<scalar_t> set(
-      self.data<scalar_t>(), self.data<scalar_t>() + self.numel());
-  output->resize_({static_cast<long long>(set.size())});
-  std::copy(set.begin(), set.end(), output->data<scalar_t>());
+      input.data<scalar_t>(), input.data<scalar_t>() + input.numel());
+  Tensor output = input.type().tensor({static_cast<long long>(set.size())});
+  std::copy(set.begin(), set.end(), output.data<scalar_t>());
 
+  Tensor inverse_indices = self.type().toScalarType(kLong).tensor({0});
   if (return_inverse) {
-    inverse_indices->resize_(self.sizes());
+    inverse_indices.resize_(input.sizes());
     std::unordered_map<scalar_t, int64_t> inverse_map;
-    inverse_map.reserve(output->numel());
-    for (int i = 0; i < output->numel(); ++i) {
-      inverse_map[output->data<scalar_t>()[i]] = i;
+    inverse_map.reserve(output.numel());
+    for (int i = 0; i < output.numel(); ++i) {
+      inverse_map[output.data<scalar_t>()[i]] = i;
     }
-    for (int i = 0; i < self.numel(); ++i) {
-      inverse_indices->data<int64_t>()[i] =
-          inverse_map[self.data<scalar_t>()[i]];
+    for (int i = 0; i < input.numel(); ++i) {
+      inverse_indices.data<int64_t>()[i] =
+          inverse_map[input.data<scalar_t>()[i]];
     }
   }
+  return std::make_tuple(output, inverse_indices);
 }
 } // namespace
 
 std::tuple<Tensor, Tensor>
 unique_cpu(const Tensor& self, const bool sorted, const bool return_inverse) {
-  // output will be resized in unique_template once we know how big it is.
-  // inverse_indices may also be resized depending on return_inverse.
-  Tensor output = self.type().tensor({0});
-  Tensor inverse_indices = self.type().toScalarType(kLong).tensor({0});
-
   if (sorted) {
-    AT_DISPATCH_ALL_TYPES(self.type(), "unique", [&] {
-      _unique_cpu_template<std::set, scalar_t>(
-          self, return_inverse, &output, &inverse_indices);
+    return AT_DISPATCH_ALL_TYPES(self.type(), "unique", [&] {
+      return _unique_cpu_template<std::set, scalar_t>(self, return_inverse);
     });
   } else {
-    AT_DISPATCH_ALL_TYPES(self.type(), "unique", [&] {
-      _unique_cpu_template<std::unordered_set, scalar_t>(
-          self, return_inverse, &output, &inverse_indices);
+    return AT_DISPATCH_ALL_TYPES(self.type(), "unique", [&] {
+      return _unique_cpu_template<std::unordered_set, scalar_t>(
+          self, return_inverse);
     });
   }
-
-  return std::make_tuple(output, inverse_indices);
 }
 
 }  // namespace native
diff --git a/aten/src/ATen/native/cuda/Unique.cu b/aten/src/ATen/native/cuda/Unique.cu
index 225b5ad6dfa51..af7d522235c2a 100644
--- a/aten/src/ATen/native/cuda/Unique.cu
+++ b/aten/src/ATen/native/cuda/Unique.cu
@@ -1,7 +1,7 @@
 #include "ATen/ATen.h"
 
 #include <tuple>
-
+A
 namespace at {
 namespace native{
 
@@ -10,7 +10,6 @@ unique_cuda(const Tensor& self, const bool sorted, const bool return_inverse) {
   throw std::runtime_error(
       "unique is currently CPU-only, and lacks CUDA support. "
       "Pull requests welcome!");
-  return std::make_tuple(self.type().tensor({0}), self.type().tensor({0}));
 }
 
 }  // namespace native

From 65345796391bc32ce5ff9b335dad6f9536179947 Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Fri, 2 Mar 2018 17:08:29 -0800
Subject: [PATCH 12/17] Remove extraneous numpy conversion

---
 test/test_torch.py | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/test/test_torch.py b/test/test_torch.py
index 07568ac7f3181..56ac6a952efb9 100644
--- a/test/test_torch.py
+++ b/test/test_torch.py
@@ -5428,20 +5428,15 @@ def test_unique_cpu(self):
         expected_inverse = torch.LongTensor([0, 1, 2, 1, 4, 3, 1, 2])
         empty_inverse = torch.LongTensor([])
 
-        if TEST_NUMPY:
-            x_unique, x_inverse = torch.unique(x)
-            self.assertEqual(
-                expected_unique.numpy().tolist(),
-                sorted(x_unique.numpy().tolist())
-            )
-            self.assertEqual(empty_inverse, x_inverse)
-
-            x_unique, x_inverse = x.unique(return_inverse=True)
-            self.assertEqual(
-                expected_unique.numpy().tolist(),
-                sorted(x_unique.numpy().tolist())
-            )
-            self.assertEqual(expected_inverse.numel(), x_inverse.numel())
+        x_unique, x_inverse = torch.unique(x)
+        self.assertEqual(
+            expected_unique.tolist(), sorted(x_unique.tolist()))
+        self.assertEqual(empty_inverse, x_inverse)
+
+        x_unique, x_inverse = x.unique(return_inverse=True)
+        self.assertEqual(
+            expected_unique.tolist(), sorted(x_unique.tolist()))
+        self.assertEqual(expected_inverse.numel(), x_inverse.numel())
 
         x_unique, x_inverse = x.unique(sorted=True)
         self.assertEqual(expected_unique, x_unique)

From 69c61f40f21d6d5bd847d2c1471f2acfd148e3a2 Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Mon, 5 Mar 2018 11:02:51 -0800
Subject: [PATCH 13/17] Refactor out .data calls

---
 aten/src/ATen/native/Unique.cpp | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/aten/src/ATen/native/Unique.cpp b/aten/src/ATen/native/Unique.cpp
index 17924c88daa51..a847803f69a82 100644
--- a/aten/src/ATen/native/Unique.cpp
+++ b/aten/src/ATen/native/Unique.cpp
@@ -18,22 +18,23 @@ std::tuple<Tensor, Tensor> _unique_cpu_template(
     const Tensor& self,
     const bool return_inverse) {
   const Tensor& input = self.contiguous();
-  set_type<scalar_t> set(
-      input.data<scalar_t>(), input.data<scalar_t>() + input.numel());
-  Tensor output = input.type().tensor({static_cast<long long>(set.size())});
-  std::copy(set.begin(), set.end(), output.data<scalar_t>());
+  const scalar_t* input_data = input.data<scalar_t>();
+  set_type<scalar_t> set(input_data, input_data + input.numel());
+  Tensor output = input.type().tensor({static_cast<int64_t>(set.size())});
+  scalar_t* output_data = output.data<scalar_t>();
+  std::copy(set.begin(), set.end(), output_data);
 
   Tensor inverse_indices = self.type().toScalarType(kLong).tensor({0});
   if (return_inverse) {
     inverse_indices.resize_(input.sizes());
+    int64_t* inverse_indices_data = inverse_indices.data<int64_t>();
     std::unordered_map<scalar_t, int64_t> inverse_map;
     inverse_map.reserve(output.numel());
     for (int i = 0; i < output.numel(); ++i) {
-      inverse_map[output.data<scalar_t>()[i]] = i;
+      inverse_map[output_data[i]] = i;
     }
     for (int i = 0; i < input.numel(); ++i) {
-      inverse_indices.data<int64_t>()[i] =
-          inverse_map[input.data<scalar_t>()[i]];
+      inverse_indices_data[i] = inverse_map[input_data[i]];
     }
   }
   return std::make_tuple(output, inverse_indices);

From 7ae734ba9859c8123de52a8fd1af54a5fe00b0d5 Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Tue, 6 Mar 2018 15:08:10 -0800
Subject: [PATCH 14/17] Refactored to variable return length API with wrapper
 fn as opposed to returning a 0-length tensor, per off-line reviewer comments

---
 aten/src/ATen/native/Unique.cpp            |  2 +-
 aten/src/ATen/native/cuda/Unique.cu        |  2 +-
 aten/src/ATen/native/native_functions.yaml |  6 +-
 test/test_torch.py                         |  9 +--
 tools/autograd/derivatives.yaml            |  4 +-
 torch/_tensor_docs.py                      |  7 ---
 torch/_torch_docs.py                       | 56 -----------------
 torch/autograd/variable.py                 | 12 ++++
 torch/functional.py                        | 72 +++++++++++++++++++++-
 9 files changed, 93 insertions(+), 77 deletions(-)

diff --git a/aten/src/ATen/native/Unique.cpp b/aten/src/ATen/native/Unique.cpp
index a847803f69a82..31555fb4a7a7b 100644
--- a/aten/src/ATen/native/Unique.cpp
+++ b/aten/src/ATen/native/Unique.cpp
@@ -42,7 +42,7 @@ std::tuple<Tensor, Tensor> _unique_cpu_template(
 } // namespace
 
 std::tuple<Tensor, Tensor>
-unique_cpu(const Tensor& self, const bool sorted, const bool return_inverse) {
+_unique_cpu(const Tensor& self, const bool sorted, const bool return_inverse) {
   if (sorted) {
     return AT_DISPATCH_ALL_TYPES(self.type(), "unique", [&] {
       return _unique_cpu_template<std::set, scalar_t>(self, return_inverse);
diff --git a/aten/src/ATen/native/cuda/Unique.cu b/aten/src/ATen/native/cuda/Unique.cu
index af7d522235c2a..82d2821d30441 100644
--- a/aten/src/ATen/native/cuda/Unique.cu
+++ b/aten/src/ATen/native/cuda/Unique.cu
@@ -6,7 +6,7 @@ namespace at {
 namespace native{
 
 std::tuple<Tensor, Tensor>
-unique_cuda(const Tensor& self, const bool sorted, const bool return_inverse) {
+_unique_cuda(const Tensor& self, const bool sorted, const bool return_inverse) {
   throw std::runtime_error(
       "unique is currently CPU-only, and lacks CUDA support. "
       "Pull requests welcome!");
diff --git a/aten/src/ATen/native/native_functions.yaml b/aten/src/ATen/native/native_functions.yaml
index 3ee149d49193c..8ac198eebda52 100644
--- a/aten/src/ATen/native/native_functions.yaml
+++ b/aten/src/ATen/native/native_functions.yaml
@@ -363,10 +363,10 @@
 - func: type_as(Tensor self, Tensor other) -> Tensor
   variants: method
 
-- func: unique(Tensor self, bool sorted=false, bool return_inverse=false) -> (Tensor, Tensor)
+- func: _unique(Tensor self, bool sorted=false, bool return_inverse=false) -> (Tensor, Tensor)
   dispatch:
-    CPU: unique_cpu
-    CUDA: unique_cuda
+    CPU: _unique_cpu
+    CUDA: _unique_cuda
 
 - func: _unsafe_view(Tensor self, IntList size) -> Tensor
   variants: function
diff --git a/test/test_torch.py b/test/test_torch.py
index 56ac6a952efb9..66d51e3d48ed1 100644
--- a/test/test_torch.py
+++ b/test/test_torch.py
@@ -5426,23 +5426,20 @@ def test_unique_cpu(self):
         x = torch.LongTensor([1, 2, 3, 2, 8, 5, 2, 3])
         expected_unique = torch.LongTensor([1, 2, 3, 5, 8])
         expected_inverse = torch.LongTensor([0, 1, 2, 1, 4, 3, 1, 2])
-        empty_inverse = torch.LongTensor([])
 
-        x_unique, x_inverse = torch.unique(x)
+        x_unique = torch.unique(x)
         self.assertEqual(
             expected_unique.tolist(), sorted(x_unique.tolist()))
-        self.assertEqual(empty_inverse, x_inverse)
 
         x_unique, x_inverse = x.unique(return_inverse=True)
         self.assertEqual(
             expected_unique.tolist(), sorted(x_unique.tolist()))
         self.assertEqual(expected_inverse.numel(), x_inverse.numel())
 
-        x_unique, x_inverse = x.unique(sorted=True)
+        x_unique = x.unique(sorted=True)
         self.assertEqual(expected_unique, x_unique)
-        self.assertEqual(empty_inverse, x_inverse)
 
-        x_unique, x_inverse = torch.unique(
+        x_unique, x_inverse = torch._unique(
             x, sorted=True, return_inverse=True)
         self.assertEqual(expected_unique, x_unique)
         self.assertEqual(expected_inverse, x_inverse)
diff --git a/tools/autograd/derivatives.yaml b/tools/autograd/derivatives.yaml
index e4391c328714e..8cda01a6a98c3 100644
--- a/tools/autograd/derivatives.yaml
+++ b/tools/autograd/derivatives.yaml
@@ -637,8 +637,8 @@
 - name: uniform_(Tensor self, double from, double to, Generator generator)
   self: zeros_like(grad)
 
-- name: unique(Tensor self, bool sorted, bool return_inverse)
-  self: not_implemented("unique")
+- name: _unique(Tensor self, bool sorted, bool return_inverse)
+  self: not_implemented("_unique")
 
 - name: _unsafe_view(Tensor self, IntList size)
   self: grad.contiguous().view(self.sizes())
diff --git a/torch/_tensor_docs.py b/torch/_tensor_docs.py
index c3fc92f15f458..aa635170510fe 100644
--- a/torch/_tensor_docs.py
+++ b/torch/_tensor_docs.py
@@ -1795,13 +1795,6 @@ def callable(a, b) -> number
     P(x) = \dfrac{1}{to - from}
 """)
 
-add_docstr_all('unique',
-               r"""
-unique(sorted=False, return_inverse=False)
-
-See :func:`torch.unique`
-""")
-
 add_docstr_all('unsqueeze',
                r"""
 unsqueeze(dim)
diff --git a/torch/_torch_docs.py b/torch/_torch_docs.py
index 3b799cafd6a3a..2518a29286f42 100644
--- a/torch/_torch_docs.py
+++ b/torch/_torch_docs.py
@@ -4926,62 +4926,6 @@
 
 """)
 
-add_docstr(torch.unique,
-           r"""
-unique(input, sorted=False, return_inverse=False) -> (Tensor, Tensor)
-
-Returns the unique scalar elements of the input tensor as list.
-
-Args:
-    input (Tensor): the input tensor
-    sorted (bool): Whether to sort the unique elements in ascending order
-        before returning as output.
-    return_inverse (bool): Whether to also return the indices for where
-        elements in the original input ended up in the returned unique list.
-
-Returns:
-    (Tensor, Tensor): A tuple containing
-
-        - **output** (*Tensor*): the list of unique scalar elements
-        - **inverse_indices** (*Tensor*): the indices (same shape as input)
-            for where elements in the original input map to in the output
-            if ``return_inverse`` is ``True``; otherwise, an empty tensor.
-
-Example::
-
-    >>>> output, inverse_indices = torch.unique(
-             torch.LongTensor([1, 3, 2, 3]), sorted=True, return_inverse=True)
-    >>>> output
-
-     1
-     2
-     3
-    [torch.LongTensor of size (3,)]
-
-    >>>> inverse_indices
-
-     0
-     2
-     1
-     2
-    [torch.LongTensor of size (4,)]
-
-    >>>> output, inverse_indices = torch.unique(
-             torch.LongTensor([[1, 3], [2, 3]]), sorted=True, return_inverse=True)
-    >>>> output
-
-     1
-     2
-     3
-    [torch.LongTensor of size (3,)]
-
-    >>>> inverse_indices
-
-     0  2
-     1  2
-    [torch.LongTensor of size (2,2)]
-""")
-
 add_docstr(torch.unsqueeze,
            r"""
 unsqueeze(input, dim, out=None)
diff --git a/torch/autograd/variable.py b/torch/autograd/variable.py
index 7d9f2068f5ece..c09c33874f898 100644
--- a/torch/autograd/variable.py
+++ b/torch/autograd/variable.py
@@ -310,6 +310,18 @@ def masked_fill(self, mask, value):
     def expand_as(self, tensor):
         return self.expand(tensor.size())
 
+    def unique(self, sorted=False, return_inverse=False):
+        r"""Returns the unique scalar elements of the tensor as a 1-D tensor.
+
+        See :func:`torch.unique`
+        """
+        output, inverse_indices = self._unique(
+            sorted=sorted, return_inverse=return_inverse)
+        if return_inverse:
+            return output, inverse_indices
+        else:
+            return output
+
     def __rsub__(self, other):
         return -self + other
 
diff --git a/torch/functional.py b/torch/functional.py
index f9b0d6dd370c1..2a01e72afe63b 100644
--- a/torch/functional.py
+++ b/torch/functional.py
@@ -5,7 +5,7 @@
 
 __all__ = [
     'split', 'chunk', 'empty_like', 'stack', 'unbind', 'btriunpack', 'matmul', 'det', 'stft',
-    'hann_window', 'hamming_window', 'bartlett_window', 'where', 'isnan'
+    'hann_window', 'hamming_window', 'bartlett_window', 'where', 'isnan', 'unique'
 ]
 
 
@@ -536,3 +536,73 @@ def isnan(tensor):
     if not torch.is_tensor(tensor):
         raise ValueError("The argument is not a tensor")
     return tensor != tensor
+
+
+def unique(input, sorted=False, return_inverse=False):
+    r"""Returns the unique scalar elements of the input tensor as a 1-D tensor.
+
+    Arguments:
+        input (Tensor): the input tensor
+        sorted (bool): Whether to sort the unique elements in ascending order
+            before returning as output.
+        return_inverse (bool): Whether to also return the indices for where
+            elements in the original input ended up in the returned unique list.
+
+    Returns:
+        Tensor: the output list of unique scalar elements.
+        Tensor (optional): if :attr:`return_inverse` is True, there will be a
+            2nd returned tensor (same shape as input) representing the indices
+            for where elements in the original input map to in the output;
+            otherwise, this function will only return a single tensor.
+
+    Example::
+
+        >>>> output = torch.unique(torch.LongTensor([1, 3, 2, 3]))
+        >>>> output
+
+         2
+         3
+         1
+        [torch.LongTensor of size (3,)]
+
+        >>>> output, inverse_indices = torch.unique(
+                 torch.LongTensor([1, 3, 2, 3]), sorted=True, return_inverse=True)
+        >>>> output
+
+         1
+         2
+         3
+        [torch.LongTensor of size (3,)]
+
+        >>>> inverse_indices
+
+         0
+         2
+         1
+         2
+        [torch.LongTensor of size (4,)]
+
+        >>>> output, inverse_indices = torch.unique(
+                 torch.LongTensor([[1, 3], [2, 3]]), sorted=True, return_inverse=True)
+        >>>> output
+
+         1
+         2
+         3
+        [torch.LongTensor of size (3,)]
+
+        >>>> inverse_indices
+
+         0  2
+         1  2
+        [torch.LongTensor of size (2,2)]
+    """
+    output, inverse_indices = torch._C._VariableBase._unique(
+        input,
+        sorted=sorted,
+        return_inverse=return_inverse,
+    )
+    if return_inverse:
+        return output, inverse_indices
+    else:
+        return output

From b07dcc37b73e5ce380bf3f3b764183258a342880 Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Tue, 6 Mar 2018 15:09:32 -0800
Subject: [PATCH 15/17] Remove A

---
 aten/src/ATen/native/cuda/Unique.cu | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/aten/src/ATen/native/cuda/Unique.cu b/aten/src/ATen/native/cuda/Unique.cu
index 82d2821d30441..d6996d20e67a9 100644
--- a/aten/src/ATen/native/cuda/Unique.cu
+++ b/aten/src/ATen/native/cuda/Unique.cu
@@ -1,7 +1,7 @@
 #include "ATen/ATen.h"
 
 #include <tuple>
-A
+
 namespace at {
 namespace native{
 

From 6c1b125880ccb5f652e079ec27c437f183c25a09 Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Tue, 6 Mar 2018 15:16:01 -0800
Subject: [PATCH 16/17] Don't use hidden torch._unique() in test

---
 test/test_torch.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_torch.py b/test/test_torch.py
index 66d51e3d48ed1..11236b8361159 100644
--- a/test/test_torch.py
+++ b/test/test_torch.py
@@ -5439,7 +5439,7 @@ def test_unique_cpu(self):
         x_unique = x.unique(sorted=True)
         self.assertEqual(expected_unique, x_unique)
 
-        x_unique, x_inverse = torch._unique(
+        x_unique, x_inverse = torch.unique(
             x, sorted=True, return_inverse=True)
         self.assertEqual(expected_unique, x_unique)
         self.assertEqual(expected_inverse, x_inverse)

From eeebf16c94770df8b05401d4934f767ec9ea9044 Mon Sep 17 00:00:00 2001
From: Wei Ho <weiho@fb.com>
Date: Tue, 6 Mar 2018 15:45:42 -0800
Subject: [PATCH 17/17] Fix documentations

---
 docs/source/tensors.rst |  1 +
 docs/source/torch.rst   |  1 +
 torch/functional.py     | 30 +++++++++++++++++++++++-------
 3 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/docs/source/tensors.rst b/docs/source/tensors.rst
index 521b5e872b02c..a0db66675ae5b 100644
--- a/docs/source/tensors.rst
+++ b/docs/source/tensors.rst
@@ -311,6 +311,7 @@ view of a storage and defines numeric operations on it.
    .. automethod:: type_as
    .. automethod:: unfold
    .. automethod:: uniform_
+   .. automethod:: unique
    .. automethod:: unsqueeze
    .. automethod:: unsqueeze_
    .. automethod:: var
diff --git a/docs/source/torch.rst b/docs/source/torch.rst
index 16b39f7c232ee..4139c9e1f3bc6 100644
--- a/docs/source/torch.rst
+++ b/docs/source/torch.rst
@@ -143,6 +143,7 @@ Reduction Ops
 .. autofunction:: prod
 .. autofunction:: std
 .. autofunction:: sum
+.. autofunction:: unique
 .. autofunction:: var
 
 
diff --git a/torch/functional.py b/torch/functional.py
index 2a01e72afe63b..484f2d6e1b150 100644
--- a/torch/functional.py
+++ b/torch/functional.py
@@ -4,8 +4,21 @@
 import math
 
 __all__ = [
-    'split', 'chunk', 'empty_like', 'stack', 'unbind', 'btriunpack', 'matmul', 'det', 'stft',
-    'hann_window', 'hamming_window', 'bartlett_window', 'where', 'isnan', 'unique'
+    'bartlett_window',
+    'btriunpack',
+    'chunk',
+    'det',
+    'empty_like',
+    'hamming_window',
+    'hann_window',
+    'isnan',
+    'matmul',
+    'split',
+    'stack',
+    'stft',
+    'unbind',
+    'unique',
+    'where',
 ]
 
 
@@ -549,11 +562,14 @@ def unique(input, sorted=False, return_inverse=False):
             elements in the original input ended up in the returned unique list.
 
     Returns:
-        Tensor: the output list of unique scalar elements.
-        Tensor (optional): if :attr:`return_inverse` is True, there will be a
-            2nd returned tensor (same shape as input) representing the indices
-            for where elements in the original input map to in the output;
-            otherwise, this function will only return a single tensor.
+        (Tensor, Tensor (optional)): A tensor or a tuple of tensors containing
+
+            - **output** (*Tensor*): the output list of unique scalar elements.
+            - **inverse_indices** (*Tensor*): (optional) if
+              :attr:`return_inverse` is True, there will be a
+              2nd returned tensor (same shape as input) representing the indices
+              for where elements in the original input map to in the output;
+              otherwise, this function will only return a single tensor.
 
     Example::