Add nvtext::minhash function

cpp/CMakeLists.txt

@@ -579,6 +579,7 @@ add_library(
   src/text/detokenize.cu
   src/text/edit_distance.cu
   src/text/generate_ngrams.cu
+  src/text/minhash.cu
   src/text/ngrams_tokenize.cu
   src/text/normalize.cu
   src/text/replace.cu

cpp/benchmarks/CMakeLists.txt

@@ -274,6 +274,8 @@ ConfigureBench(
   text/subword.cpp text/tokenize.cpp
 )
 
+ConfigureNVBench(TEXT_NVBENCH text/minhash.cpp)
+
 # ##################################################################################################
 # * strings benchmark -------------------------------------------------------------------
 ConfigureBench(
@@ -290,7 +292,6 @@ ConfigureBench(
   string/factory.cu
   string/filter.cpp
   string/find.cpp
-  string/like.cpp
   string/repeat_strings.cpp
   string/replace.cpp
   string/replace_re.cpp

cpp/benchmarks/text/minhash.cpp

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2023, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <benchmarks/common/generate_input.hpp>
+#include <benchmarks/fixture/rmm_pool_raii.hpp>
+
+#include <cudf/strings/strings_column_view.hpp>
+
+#include <nvtext/minhash.hpp>
+
+#include <nvbench/nvbench.cuh>
+
+#include <rmm/device_buffer.hpp>
+
+static void bench_minhash(nvbench::state& state)
+{
+  auto const num_rows   = static_cast<cudf::size_type>(state.get_int64("num_rows"));
+  auto const row_width  = static_cast<cudf::size_type>(state.get_int64("row_width"));
+  auto const hash_width = static_cast<cudf::size_type>(state.get_int64("hash_width"));
+  auto const seed_count = static_cast<cudf::size_type>(state.get_int64("seed_count"));
+
+  if (static_cast<std::size_t>(num_rows) * static_cast<std::size_t>(row_width) >=
+      static_cast<std::size_t>(std::numeric_limits<cudf::size_type>::max())) {
+    state.skip("Skip benchmarks greater than size_type limit");
+  }
+
+  data_profile const strings_profile = data_profile_builder().distribution(
+    cudf::type_id::STRING, distribution_id::NORMAL, 0, row_width);
+  auto const strings_table =
+    create_random_table({cudf::type_id::STRING}, row_count{num_rows}, strings_profile);
+  cudf::strings_column_view input(strings_table->view().column(0));
+
+  data_profile const seeds_profile = data_profile_builder().null_probability(0).distribution(
+    cudf::type_to_id<cudf::hash_value_type>(), distribution_id::NORMAL, 0, row_width);
+  auto const seeds_table = create_random_table(
+    {cudf::type_to_id<cudf::hash_value_type>()}, row_count{seed_count}, seeds_profile);
+  auto seeds = seeds_table->get_column(0);
+  seeds.set_null_mask(rmm::device_buffer{}, 0);
+
+  state.set_cuda_stream(nvbench::make_cuda_stream_view(cudf::get_default_stream().value()));
+
+  auto chars_size = input.chars_size();
+  state.add_global_memory_reads<nvbench::int8_t>(chars_size);
+  state.add_global_memory_writes<nvbench::int32_t>(num_rows);  // output are hashes
+
+  state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
+    auto result = nvtext::minhash(input, seeds.view(), hash_width);
+  });
+}
+
+NVBENCH_BENCH(bench_minhash)
+  .set_name("minhash")
+  .add_int64_axis("num_rows", {1024, 4096, 8192, 16364, 32768, 262144})
+  .add_int64_axis("row_width", {128, 512, 2048})
+  .add_int64_axis("hash_width", {5, 10, 25})
+  .add_int64_axis("seed_count", {2, 26});

cpp/include/cudf/strings/string_view.cuh

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019-2022, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2023, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -121,6 +121,13 @@ __device__ inline string_view::const_iterator::const_iterator(const string_view&
 {
 }
 
+__device__ inline string_view::const_iterator::const_iterator(const string_view& str,
+                                                              size_type pos,
+                                                              size_type offset)
+  : p{str.data()}, bytes{str.size_bytes()}, char_pos{pos}, byte_pos{offset}
+{
+}
+
 __device__ inline string_view::const_iterator& string_view::const_iterator::operator++()
 {
   if (byte_pos < bytes)
@@ -244,7 +251,7 @@ __device__ inline string_view::const_iterator string_view::begin() const
 
 __device__ inline string_view::const_iterator string_view::end() const
 {
-  return const_iterator(*this, length());
+  return const_iterator(*this, length(), size_bytes());
 }
 // @endcond
 

cpp/include/cudf/strings/string_view.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019-2022, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2023, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -104,10 +104,12 @@ class string_view {
     [[nodiscard]] __device__ inline size_type byte_offset() const;
 
    private:
+    friend class string_view;
     const char* p{};
     size_type bytes{};
     size_type char_pos{};
     size_type byte_pos{};
+    __device__ inline const_iterator(const string_view& str, size_type pos, size_type offset);
     /// @endcond
   };
 

cpp/include/doxygen_groups.h

@@ -164,6 +164,7 @@
  *   @defgroup nvtext_edit_distance Edit Distance
  *   @defgroup nvtext_tokenize Tokenizing
  *   @defgroup nvtext_replace Replacing
+ *   @defgroup nvtext_minhash MinHashing
  * @}
  * @defgroup utility_apis Utilities
  * @{

cpp/include/nvtext/minhash.hpp

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2023, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cudf/column/column.hpp>
+#include <cudf/hashing.hpp>
+#include <cudf/scalar/scalar.hpp>
+#include <cudf/strings/strings_column_view.hpp>
+#include <cudf/utilities/span.hpp>
+
+namespace nvtext {
+/**
+ * @addtogroup nvtext_minhash
+ * @{
+ * @file
+ */
+
+/**
+ * @brief Returns the minhash value for each string
+ *
+ * Hash values are computed from substrings of each string and the
+ * minimum hash value is returned for each string.
+ *
+ * Any null row entries result in corresponding null output rows.
+ *
+ * @throw std::invalid_argument if the width < 2
+ * @throw std::invalid_argument if h_id is not HASH_MURMUR3
+ *
+ * @param input Strings column to compute minhash
+ * @param seed  Seed value used for the MurmurHash3_32 algorithm
+ * @param width The character width used for apply substrings;
+ *              Any string smaller than this width will not be hashed.
+ *              Default is 4 characters.
+ * @param hash_function Hash algorithm to use;
+ *                      Only HASH_MURMUR3 is currently supported.
+ * @param mr Device memory resource used to allocate the returned column's device memory
+ * @return Minhash values for each string in input
+ */
+std::unique_ptr<cudf::column> minhash(
+  cudf::strings_column_view const& input,
+  cudf::numeric_scalar<cudf::hash_value_type> seed = cudf::numeric_scalar(cudf::DEFAULT_HASH_SEED),
+  cudf::size_type width                            = 4,
+  cudf::hash_id hash_function                      = cudf::hash_id::HASH_MURMUR3,
+  rmm::mr::device_memory_resource* mr              = rmm::mr::get_current_device_resource());
+
+/**
+ * @brief Returns the minhash values for each string per seed
+ *
+ * Hash values are computed from substrings of each string and the
+ * minimum hash value is returned for each string for each seed.
+ * Each row of the list column are seed results for the corresponding
+ * string. The order of the elements in each row match the order of
+ * the seeds provided in the `seeds` parameter.
+ *
+ * Any null row entries result in corresponding null output rows.
+ *
+ * @throw std::invalid_argument if the width < 2
+ * @throw std::invalid_argument if h_id is not HASH_MURMUR3
+ * @throw std::invalid_argument if seeds is empty
+ *
+ * @param input Strings column to compute minhash
+ * @param seeds Seed values used for the MurmurHash3_32 algorithm
+ * @param width The character width used for apply substrings;
+ *              Any string smaller than this width will not be hashed.
+ *              Default is 4 characters.
+ * @param hash_function Hash algorithm to use;
+ *                      Only HASH_MURMUR3 is currently supported.
+ * @param mr Device memory resource used to allocate the returned column's device memory
+ * @return List column of minhash values for each string per seed
+ */
+std::unique_ptr<cudf::column> minhash(
+  cudf::strings_column_view const& input,
+  cudf::device_span<cudf::hash_value_type const> seeds,
+  cudf::size_type width               = 4,
+  cudf::hash_id hash_function         = cudf::hash_id::HASH_MURMUR3,
+  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+
+/** @} */  // end of group
+}  // namespace nvtext