diff --git a/pyg_lib/csrc/classes/cpu/neighbor_sampler.cpp b/pyg_lib/csrc/classes/cpu/neighbor_sampler.cpp
index 83b1658de..c563e6a06 100644
--- a/pyg_lib/csrc/classes/cpu/neighbor_sampler.cpp
+++ b/pyg_lib/csrc/classes/cpu/neighbor_sampler.cpp
@@ -12,9 +12,9 @@ struct NeighborSampler : torch::CustomClassHolder {
  public:
   NeighborSampler(const at::Tensor& rowptr,
                   const at::Tensor& col,
-                  const std::optional<at::Tensor>& edge_weight,
-                  const std::optional<at::Tensor>& node_time,
-                  const std::optional<at::Tensor>& edge_time)
+                  const c10::optional<at::Tensor>& edge_weight,
+                  const c10::optional<at::Tensor>& node_time,
+                  const c10::optional<at::Tensor>& edge_time)
       : rowptr_(rowptr),
         col_(col),
         edge_weight_(edge_weight),
@@ -24,13 +24,13 @@ struct NeighborSampler : torch::CustomClassHolder {
   std::tuple<at::Tensor,                 // row
              at::Tensor,                 // col
              at::Tensor,                 // node_id
-             std::optional<at::Tensor>,  // edge_id,
-             std::optional<at::Tensor>,  // batch,
+             c10::optional<at::Tensor>,  // edge_id,
+             c10::optional<at::Tensor>,  // batch,
              std::vector<int64_t>,       // num_sampled_nodes,
              std::vector<int64_t>>       // num_sampled_edges,
   sample(const std::vector<int64_t>& num_neighbors,
          const at::Tensor& seed_node,
-         const std::optional<at::Tensor>& seed_time,
+         const c10::optional<at::Tensor>& seed_time,
          bool disjoint = false,
          std::string temporal_strategy = "uniform",
          bool return_edge_id = true) {
@@ -49,9 +49,9 @@ struct NeighborSampler : torch::CustomClassHolder {
  private:
   const at::Tensor& rowptr_;
   const at::Tensor& col_;
-  const std::optional<at::Tensor>& edge_weight_;
-  const std::optional<at::Tensor>& node_time_;
-  const std::optional<at::Tensor>& edge_time_;
+  const c10::optional<at::Tensor>& edge_weight_;
+  const c10::optional<at::Tensor>& node_time_;
+  const c10::optional<at::Tensor>& edge_time_;
 };
 
 struct HeteroNeighborSampler : torch::CustomClassHolder {
@@ -61,9 +61,9 @@ struct HeteroNeighborSampler : torch::CustomClassHolder {
       const std::vector<edge_type>& edge_types,
       const c10::Dict<rel_type, at::Tensor>& rowptr,
       const c10::Dict<rel_type, at::Tensor>& col,
-      const std::optional<c10::Dict<rel_type, at::Tensor>>& edge_weight,
-      const std::optional<c10::Dict<node_type, at::Tensor>>& node_time,
-      const std::optional<c10::Dict<rel_type, at::Tensor>>& edge_time)
+      const c10::optional<c10::Dict<rel_type, at::Tensor>>& edge_weight,
+      const c10::optional<c10::Dict<node_type, at::Tensor>>& node_time,
+      const c10::optional<c10::Dict<rel_type, at::Tensor>>& edge_time)
       : node_types_(node_types),
         edge_types_(edge_types),
         rowptr_(rowptr),
@@ -75,13 +75,13 @@ struct HeteroNeighborSampler : torch::CustomClassHolder {
   std::tuple<c10::Dict<rel_type, at::Tensor>,                  // row
              c10::Dict<rel_type, at::Tensor>,                  // col
              c10::Dict<node_type, at::Tensor>,                 // node_id
-             std::optional<c10::Dict<rel_type, at::Tensor>>,   // edge_id
-             std::optional<c10::Dict<node_type, at::Tensor>>,  // batch
+             c10::optional<c10::Dict<rel_type, at::Tensor>>,   // edge_id
+             c10::optional<c10::Dict<node_type, at::Tensor>>,  // batch
              c10::Dict<node_type, std::vector<int64_t>>,  // num_sampled_nodes
              c10::Dict<rel_type, std::vector<int64_t>>>   // num_sampled_edges
   sample(const c10::Dict<rel_type, std::vector<int64_t>>& num_neighbors,
          const c10::Dict<node_type, at::Tensor>& seed_node,
-         const std::optional<c10::Dict<node_type, at::Tensor>>& seed_time,
+         const c10::optional<c10::Dict<node_type, at::Tensor>>& seed_time,
          bool disjoint = false,
          std::string temporal_strategy = "uniform",
          bool return_edge_id = true) {
@@ -102,26 +102,26 @@ struct HeteroNeighborSampler : torch::CustomClassHolder {
   const std::vector<edge_type>& edge_types_;
   const c10::Dict<rel_type, at::Tensor>& rowptr_;
   const c10::Dict<rel_type, at::Tensor>& col_;
-  const std::optional<c10::Dict<rel_type, at::Tensor>>& edge_weight_;
-  const std::optional<c10::Dict<node_type, at::Tensor>>& node_time_;
-  const std::optional<c10::Dict<rel_type, at::Tensor>>& edge_time_;
+  const c10::optional<c10::Dict<rel_type, at::Tensor>>& edge_weight_;
+  const c10::optional<c10::Dict<node_type, at::Tensor>>& node_time_;
+  const c10::optional<c10::Dict<rel_type, at::Tensor>>& edge_time_;
 };
 
 }  // namespace
 
 TORCH_LIBRARY_FRAGMENT(pyg, m) {
   m.class_<NeighborSampler>("NeighborSampler")
-      .def(torch::init<at::Tensor&, at::Tensor&, std::optional<at::Tensor>,
-                       std::optional<at::Tensor>, std::optional<at::Tensor>>())
+      .def(torch::init<at::Tensor&, at::Tensor&, c10::optional<at::Tensor>,
+                       c10::optional<at::Tensor>, c10::optional<at::Tensor>>())
       .def("sample", &NeighborSampler::sample);
 
   m.class_<HeteroNeighborSampler>("HeteroNeighborSampler")
       .def(torch::init<std::vector<node_type>, std::vector<edge_type>,
                        c10::Dict<rel_type, at::Tensor>,
                        c10::Dict<rel_type, at::Tensor>,
-                       std::optional<c10::Dict<rel_type, at::Tensor>>,
-                       std::optional<c10::Dict<node_type, at::Tensor>>,
-                       std::optional<c10::Dict<rel_type, at::Tensor>>>())
+                       c10::optional<c10::Dict<rel_type, at::Tensor>>,
+                       c10::optional<c10::Dict<node_type, at::Tensor>>,
+                       c10::optional<c10::Dict<rel_type, at::Tensor>>>())
       .def("sample", &HeteroNeighborSampler::sample);
 }
 
diff --git a/pyg_lib/csrc/partition/cpu/metis_kernel.cpp b/pyg_lib/csrc/partition/cpu/metis_kernel.cpp
index 7478b4e43..56f6da886 100644
--- a/pyg_lib/csrc/partition/cpu/metis_kernel.cpp
+++ b/pyg_lib/csrc/partition/cpu/metis_kernel.cpp
@@ -13,8 +13,8 @@ namespace {
 at::Tensor metis_kernel(const at::Tensor& rowptr,
                         const at::Tensor& col,
                         int64_t num_partitions,
-                        const std::optional<at::Tensor>& node_weight,
-                        const std::optional<at::Tensor>& edge_weight,
+                        const c10::optional<at::Tensor>& node_weight,
+                        const c10::optional<at::Tensor>& edge_weight,
                         bool recursive) {
 #ifdef _WIN32
   TORCH_INTERNAL_ASSERT(false, "METIS not yet supported on Windows");
diff --git a/pyg_lib/csrc/partition/metis.cpp b/pyg_lib/csrc/partition/metis.cpp
index 6fd68d4d7..02e85c2b4 100644
--- a/pyg_lib/csrc/partition/metis.cpp
+++ b/pyg_lib/csrc/partition/metis.cpp
@@ -11,8 +11,8 @@ namespace partition {
 at::Tensor metis(const at::Tensor& rowptr,
                  const at::Tensor& col,
                  int64_t num_partitions,
-                 const std::optional<at::Tensor>& node_weight,
-                 const std::optional<at::Tensor>& edge_weight,
+                 const c10::optional<at::Tensor>& node_weight,
+                 const c10::optional<at::Tensor>& edge_weight,
                  bool recursive) {
   at::TensorArg rowptr_t{rowptr, "rowtpr", 1};
   at::TensorArg col_t{col, "col", 1};
diff --git a/pyg_lib/csrc/random/cpu/biased_sampling.cpp b/pyg_lib/csrc/random/cpu/biased_sampling.cpp
index f441aed85..386459761 100644
--- a/pyg_lib/csrc/random/cpu/biased_sampling.cpp
+++ b/pyg_lib/csrc/random/cpu/biased_sampling.cpp
@@ -5,7 +5,7 @@
 namespace pyg {
 namespace random {
 
-std::optional<at::Tensor> biased_to_cdf(const at::Tensor& rowptr,
+c10::optional<at::Tensor> biased_to_cdf(const at::Tensor& rowptr,
                                         at::Tensor& bias,
                                         bool inplace) {
   TORCH_CHECK(rowptr.is_cpu(), "'rowptr' must be a CPU tensor");
diff --git a/pyg_lib/csrc/sampler/cpu/dist_merge_outputs_kernel.cpp b/pyg_lib/csrc/sampler/cpu/dist_merge_outputs_kernel.cpp
index 3bb7cd670..f187478e0 100644
--- a/pyg_lib/csrc/sampler/cpu/dist_merge_outputs_kernel.cpp
+++ b/pyg_lib/csrc/sampler/cpu/dist_merge_outputs_kernel.cpp
@@ -15,7 +15,7 @@ namespace {
 template <bool disjoint>
 std::tuple<at::Tensor,
            at::Tensor,
-           std::optional<at::Tensor>,
+           c10::optional<at::Tensor>,
            std::vector<int64_t>>
 merge_outputs(
     const std::vector<at::Tensor>& node_ids,
@@ -25,10 +25,10 @@ merge_outputs(
     const std::vector<int64_t>& partition_orders,
     const int64_t num_partitions,
     const int64_t num_neighbors,
-    const std::optional<at::Tensor>& batch) {
+    const c10::optional<at::Tensor>& batch) {
   at::Tensor out_node_id;
   at::Tensor out_edge_id;
-  std::optional<at::Tensor> out_batch = c10::nullopt;
+  c10::optional<at::Tensor> out_batch = c10::nullopt;
 
   auto offset = num_neighbors;
 
@@ -140,7 +140,7 @@ merge_outputs(
 
 std::tuple<at::Tensor,
            at::Tensor,
-           std::optional<at::Tensor>,
+           c10::optional<at::Tensor>,
            std::vector<int64_t>>
 merge_sampler_outputs_kernel(
     const std::vector<at::Tensor>& node_ids,
@@ -150,7 +150,7 @@ merge_sampler_outputs_kernel(
     const std::vector<int64_t>& partition_orders,
     const int64_t num_partitions,
     const int64_t num_neighbors,
-    const std::optional<at::Tensor>& batch,
+    const c10::optional<at::Tensor>& batch,
     bool disjoint) {
   DISPATCH_MERGE_OUTPUTS(
       disjoint, node_ids, edge_ids, cumsum_neighbors_per_node, partition_ids,
diff --git a/pyg_lib/csrc/sampler/cpu/dist_relabel_kernel.cpp b/pyg_lib/csrc/sampler/cpu/dist_relabel_kernel.cpp
index 6a6877d9f..90831736c 100644
--- a/pyg_lib/csrc/sampler/cpu/dist_relabel_kernel.cpp
+++ b/pyg_lib/csrc/sampler/cpu/dist_relabel_kernel.cpp
@@ -33,7 +33,7 @@ std::tuple<at::Tensor, at::Tensor> relabel(
     const at::Tensor& sampled_nodes_with_duplicates,
     const std::vector<int64_t>& num_sampled_neighbors_per_node,
     const int64_t num_nodes,
-    const std::optional<at::Tensor>& batch,
+    const c10::optional<at::Tensor>& batch,
     const bool csc) {
   if (disjoint) {
     TORCH_CHECK(batch.has_value(),
@@ -103,7 +103,7 @@ relabel(
     const c10::Dict<rel_type, std::vector<std::vector<int64_t>>>&
         num_sampled_neighbors_per_node_dict,
     const c10::Dict<node_type, int64_t>& num_nodes_dict,
-    const std::optional<c10::Dict<node_type, at::Tensor>>& batch_dict,
+    const c10::optional<c10::Dict<node_type, at::Tensor>>& batch_dict,
     const bool csc) {
   c10::Dict<rel_type, at::Tensor> out_row_dict, out_col_dict;
 
@@ -281,7 +281,7 @@ std::tuple<at::Tensor, at::Tensor> relabel_neighborhood_kernel(
     const at::Tensor& sampled_nodes_with_duplicates,
     const std::vector<int64_t>& num_sampled_neighbors_per_node,
     const int64_t num_nodes,
-    const std::optional<at::Tensor>& batch,
+    const c10::optional<at::Tensor>& batch,
     bool csc,
     bool disjoint) {
   DISPATCH_RELABEL(disjoint, seed, sampled_nodes_with_duplicates,
@@ -297,7 +297,7 @@ hetero_relabel_neighborhood_kernel(
     const c10::Dict<rel_type, std::vector<std::vector<int64_t>>>&
         num_sampled_neighbors_per_node_dict,
     const c10::Dict<node_type, int64_t>& num_nodes_dict,
-    const std::optional<c10::Dict<node_type, at::Tensor>>& batch_dict,
+    const c10::optional<c10::Dict<node_type, at::Tensor>>& batch_dict,
     bool csc,
     bool disjoint) {
   c10::Dict<rel_type, at::Tensor> out_row_dict, out_col_dict;
diff --git a/pyg_lib/csrc/sampler/cpu/neighbor_kernel.cpp b/pyg_lib/csrc/sampler/cpu/neighbor_kernel.cpp
index b934a7598..72d4777a3 100644
--- a/pyg_lib/csrc/sampler/cpu/neighbor_kernel.cpp
+++ b/pyg_lib/csrc/sampler/cpu/neighbor_kernel.cpp
@@ -136,12 +136,12 @@ class NeighborSampler {
             dst_mapper, generator, out_global_dst_nodes);
   }
 
-  std::tuple<at::Tensor, at::Tensor, std::optional<at::Tensor>>
+  std::tuple<at::Tensor, at::Tensor, c10::optional<at::Tensor>>
   get_sampled_edges(bool csc = false) {
     TORCH_CHECK(save_edges, "No edges have been stored")
     const auto row = pyg::utils::from_vector(sampled_rows_);
     const auto col = pyg::utils::from_vector(sampled_cols_);
-    std::optional<at::Tensor> edge_id = c10::nullopt;
+    c10::optional<at::Tensor> edge_id = c10::nullopt;
     if (save_edge_ids) {
       edge_id = pyg::utils::from_vector(sampled_edge_ids_);
     }
@@ -330,7 +330,7 @@ template <bool replace,
 std::tuple<at::Tensor,
            at::Tensor,
            at::Tensor,
-           std::optional<at::Tensor>,
+           c10::optional<at::Tensor>,
            std::vector<int64_t>,
            std::vector<int64_t>,
            std::vector<int64_t>>
@@ -338,10 +338,10 @@ sample(const at::Tensor& rowptr,
        const at::Tensor& col,
        const at::Tensor& seed,
        const std::vector<int64_t>& num_neighbors,
-       const std::optional<at::Tensor>& node_time,
-       const std::optional<at::Tensor>& edge_time,
-       const std::optional<at::Tensor>& seed_time,
-       const std::optional<at::Tensor>& edge_weight,
+       const c10::optional<at::Tensor>& node_time,
+       const c10::optional<at::Tensor>& edge_time,
+       const c10::optional<at::Tensor>& seed_time,
+       const c10::optional<at::Tensor>& edge_weight,
        const bool csc,
        const std::string temporal_strategy) {
   TORCH_CHECK(!node_time.has_value() || disjoint,
@@ -373,7 +373,7 @@ sample(const at::Tensor& rowptr,
               "Biased edge temporal sampling not yet supported");
 
   at::Tensor out_row, out_col, out_node_id;
-  std::optional<at::Tensor> out_edge_id = c10::nullopt;
+  c10::optional<at::Tensor> out_edge_id = c10::nullopt;
   std::vector<int64_t> num_sampled_nodes_per_hop;
   std::vector<int64_t> num_sampled_edges_per_hop;
   std::vector<int64_t> cumsum_neighbors_per_node =
@@ -516,7 +516,7 @@ template <bool replace,
 std::tuple<c10::Dict<rel_type, at::Tensor>,
            c10::Dict<rel_type, at::Tensor>,
            c10::Dict<node_type, at::Tensor>,
-           std::optional<c10::Dict<rel_type, at::Tensor>>,
+           c10::optional<c10::Dict<rel_type, at::Tensor>>,
            c10::Dict<node_type, std::vector<int64_t>>,
            c10::Dict<rel_type, std::vector<int64_t>>>
 sample(const std::vector<node_type>& node_types,
@@ -525,10 +525,10 @@ sample(const std::vector<node_type>& node_types,
        const c10::Dict<rel_type, at::Tensor>& col_dict,
        const c10::Dict<node_type, at::Tensor>& seed_dict,
        const c10::Dict<rel_type, std::vector<int64_t>>& num_neighbors_dict,
-       const std::optional<c10::Dict<node_type, at::Tensor>>& node_time_dict,
-       const std::optional<c10::Dict<rel_type, at::Tensor>>& edge_time_dict,
-       const std::optional<c10::Dict<node_type, at::Tensor>>& seed_time_dict,
-       const std::optional<c10::Dict<rel_type, at::Tensor>>& edge_weight_dict,
+       const c10::optional<c10::Dict<node_type, at::Tensor>>& node_time_dict,
+       const c10::optional<c10::Dict<rel_type, at::Tensor>>& edge_time_dict,
+       const c10::optional<c10::Dict<node_type, at::Tensor>>& seed_time_dict,
+       const c10::optional<c10::Dict<rel_type, at::Tensor>>& edge_weight_dict,
        const bool csc,
        const std::string temporal_strategy) {
   TORCH_CHECK(!node_time_dict.has_value() || disjoint,
@@ -576,7 +576,7 @@ sample(const std::vector<node_type>& node_types,
 
   c10::Dict<rel_type, at::Tensor> out_row_dict, out_col_dict;
   c10::Dict<node_type, at::Tensor> out_node_id_dict;
-  std::optional<c10::Dict<node_type, at::Tensor>> out_edge_id_dict;
+  c10::optional<c10::Dict<node_type, at::Tensor>> out_edge_id_dict;
   if (return_edge_id) {
     out_edge_id_dict = c10::Dict<rel_type, at::Tensor>();
   } else {
@@ -892,17 +892,17 @@ sample(const std::vector<node_type>& node_types,
 std::tuple<at::Tensor,
            at::Tensor,
            at::Tensor,
-           std::optional<at::Tensor>,
+           c10::optional<at::Tensor>,
            std::vector<int64_t>,
            std::vector<int64_t>>
 neighbor_sample_kernel(const at::Tensor& rowptr,
                        const at::Tensor& col,
                        const at::Tensor& seed,
                        const std::vector<int64_t>& num_neighbors,
-                       const std::optional<at::Tensor>& node_time,
-                       const std::optional<at::Tensor>& edge_time,
-                       const std::optional<at::Tensor>& seed_time,
-                       const std::optional<at::Tensor>& edge_weight,
+                       const c10::optional<at::Tensor>& node_time,
+                       const c10::optional<at::Tensor>& edge_time,
+                       const c10::optional<at::Tensor>& seed_time,
+                       const c10::optional<at::Tensor>& edge_weight,
                        bool csc,
                        bool replace,
                        bool directed,
@@ -921,7 +921,7 @@ neighbor_sample_kernel(const at::Tensor& rowptr,
 std::tuple<c10::Dict<rel_type, at::Tensor>,
            c10::Dict<rel_type, at::Tensor>,
            c10::Dict<node_type, at::Tensor>,
-           std::optional<c10::Dict<rel_type, at::Tensor>>,
+           c10::optional<c10::Dict<rel_type, at::Tensor>>,
            c10::Dict<node_type, std::vector<int64_t>>,
            c10::Dict<rel_type, std::vector<int64_t>>>
 hetero_neighbor_sample_kernel(
@@ -931,10 +931,10 @@ hetero_neighbor_sample_kernel(
     const c10::Dict<rel_type, at::Tensor>& col_dict,
     const c10::Dict<node_type, at::Tensor>& seed_dict,
     const c10::Dict<rel_type, std::vector<int64_t>>& num_neighbors_dict,
-    const std::optional<c10::Dict<node_type, at::Tensor>>& node_time_dict,
-    const std::optional<c10::Dict<rel_type, at::Tensor>>& edge_time_dict,
-    const std::optional<c10::Dict<node_type, at::Tensor>>& seed_time_dict,
-    const std::optional<c10::Dict<rel_type, at::Tensor>>& edge_weight_dict,
+    const c10::optional<c10::Dict<node_type, at::Tensor>>& node_time_dict,
+    const c10::optional<c10::Dict<rel_type, at::Tensor>>& edge_time_dict,
+    const c10::optional<c10::Dict<node_type, at::Tensor>>& seed_time_dict,
+    const c10::optional<c10::Dict<rel_type, at::Tensor>>& edge_weight_dict,
     bool csc,
     bool replace,
     bool directed,
@@ -952,10 +952,10 @@ dist_neighbor_sample_kernel(const at::Tensor& rowptr,
                             const at::Tensor& col,
                             const at::Tensor& seed,
                             const int64_t num_neighbors,
-                            const std::optional<at::Tensor>& node_time,
-                            const std::optional<at::Tensor>& edge_time,
-                            const std::optional<at::Tensor>& seed_time,
-                            const std::optional<at::Tensor>& edge_weight,
+                            const c10::optional<at::Tensor>& node_time,
+                            const c10::optional<at::Tensor>& edge_time,
+                            const c10::optional<at::Tensor>& seed_time,
+                            const c10::optional<at::Tensor>& edge_weight,
                             bool csc,
                             bool replace,
                             bool directed,
diff --git a/pyg_lib/csrc/sampler/cpu/subgraph_kernel.cpp b/pyg_lib/csrc/sampler/cpu/subgraph_kernel.cpp
index 21d173cfc..7c464bb1b 100644
--- a/pyg_lib/csrc/sampler/cpu/subgraph_kernel.cpp
+++ b/pyg_lib/csrc/sampler/cpu/subgraph_kernel.cpp
@@ -10,7 +10,7 @@ namespace sampler {
 
 namespace {
 
-std::tuple<at::Tensor, at::Tensor, std::optional<at::Tensor>> subgraph_kernel(
+std::tuple<at::Tensor, at::Tensor, c10::optional<at::Tensor>> subgraph_kernel(
     const at::Tensor& rowptr,
     const at::Tensor& col,
     const at::Tensor& nodes,
@@ -21,7 +21,7 @@ std::tuple<at::Tensor, at::Tensor, std::optional<at::Tensor>> subgraph_kernel(
 
   const auto out_rowptr = rowptr.new_empty({nodes.size(0) + 1});
   at::Tensor out_col;
-  std::optional<at::Tensor> out_edge_id = c10::nullopt;
+  c10::optional<at::Tensor> out_edge_id = c10::nullopt;
 
   AT_DISPATCH_INTEGRAL_TYPES(nodes.scalar_type(), "subgraph_kernel", [&] {
     const auto rowptr_data = rowptr.data_ptr<scalar_t>();
diff --git a/pyg_lib/csrc/sampler/dist_merge_outputs.cpp b/pyg_lib/csrc/sampler/dist_merge_outputs.cpp
index 8a1fdacef..4caa06a68 100644
--- a/pyg_lib/csrc/sampler/dist_merge_outputs.cpp
+++ b/pyg_lib/csrc/sampler/dist_merge_outputs.cpp
@@ -10,7 +10,7 @@ namespace sampler {
 
 std::tuple<at::Tensor,
            at::Tensor,
-           std::optional<at::Tensor>,
+           c10::optional<at::Tensor>,
            std::vector<int64_t>>
 merge_sampler_outputs(
     const std::vector<at::Tensor>& node_ids,
@@ -20,7 +20,7 @@ merge_sampler_outputs(
     const std::vector<int64_t>& partition_orders,
     const int64_t num_partitions,
     const int64_t num_neighbors,
-    const std::optional<at::Tensor>& batch,
+    const c10::optional<at::Tensor>& batch,
     bool disjoint) {
   std::vector<at::TensorArg> node_ids_args;
   std::vector<at::TensorArg> edge_ids_args;
diff --git a/pyg_lib/csrc/sampler/dist_relabel.cpp b/pyg_lib/csrc/sampler/dist_relabel.cpp
index ebc112374..78533336e 100644
--- a/pyg_lib/csrc/sampler/dist_relabel.cpp
+++ b/pyg_lib/csrc/sampler/dist_relabel.cpp
@@ -13,7 +13,7 @@ std::tuple<at::Tensor, at::Tensor> relabel_neighborhood(
     const at::Tensor& sampled_nodes_with_duplicates,
     const std::vector<int64_t>& num_sampled_neighbors_per_node,
     const int64_t num_nodes,
-    const std::optional<at::Tensor>& batch,
+    const c10::optional<at::Tensor>& batch,
     bool csc,
     bool disjoint) {
   at::TensorArg seed_t{seed, "seed", 1};
@@ -41,7 +41,7 @@ hetero_relabel_neighborhood(
     const c10::Dict<rel_type, std::vector<std::vector<int64_t>>>&
         num_sampled_neighbors_per_node_dict,
     const c10::Dict<node_type, int64_t>& num_nodes_dict,
-    const std::optional<c10::Dict<node_type, at::Tensor>>& batch_dict,
+    const c10::optional<c10::Dict<node_type, at::Tensor>>& batch_dict,
     bool csc,
     bool disjoint) {
   std::vector<at::TensorArg> seed_dict_args;
diff --git a/pyg_lib/csrc/sampler/neighbor.cpp b/pyg_lib/csrc/sampler/neighbor.cpp
index 64b0121e1..a3304f2f8 100644
--- a/pyg_lib/csrc/sampler/neighbor.cpp
+++ b/pyg_lib/csrc/sampler/neighbor.cpp
@@ -11,17 +11,17 @@ namespace sampler {
 std::tuple<at::Tensor,
            at::Tensor,
            at::Tensor,
-           std::optional<at::Tensor>,
+           c10::optional<at::Tensor>,
            std::vector<int64_t>,
            std::vector<int64_t>>
 neighbor_sample(const at::Tensor& rowptr,
                 const at::Tensor& col,
                 const at::Tensor& seed,
                 const std::vector<int64_t>& num_neighbors,
-                const std::optional<at::Tensor>& node_time,
-                const std::optional<at::Tensor>& edge_time,
-                const std::optional<at::Tensor>& seed_time,
-                const std::optional<at::Tensor>& edge_weight,
+                const c10::optional<at::Tensor>& node_time,
+                const c10::optional<at::Tensor>& edge_time,
+                const c10::optional<at::Tensor>& seed_time,
+                const c10::optional<at::Tensor>& edge_weight,
                 bool csc,
                 bool replace,
                 bool directed,
@@ -47,7 +47,7 @@ neighbor_sample(const at::Tensor& rowptr,
 std::tuple<c10::Dict<rel_type, at::Tensor>,
            c10::Dict<rel_type, at::Tensor>,
            c10::Dict<node_type, at::Tensor>,
-           std::optional<c10::Dict<rel_type, at::Tensor>>,
+           c10::optional<c10::Dict<rel_type, at::Tensor>>,
            c10::Dict<node_type, std::vector<int64_t>>,
            c10::Dict<rel_type, std::vector<int64_t>>>
 hetero_neighbor_sample(
@@ -57,10 +57,10 @@ hetero_neighbor_sample(
     const c10::Dict<rel_type, at::Tensor>& col_dict,
     const c10::Dict<node_type, at::Tensor>& seed_dict,
     const c10::Dict<rel_type, std::vector<int64_t>>& num_neighbors_dict,
-    const std::optional<c10::Dict<node_type, at::Tensor>>& node_time_dict,
-    const std::optional<c10::Dict<rel_type, at::Tensor>>& edge_time_dict,
-    const std::optional<c10::Dict<node_type, at::Tensor>>& seed_time_dict,
-    const std::optional<c10::Dict<rel_type, at::Tensor>>& edge_weight_dict,
+    const c10::optional<c10::Dict<node_type, at::Tensor>>& node_time_dict,
+    const c10::optional<c10::Dict<rel_type, at::Tensor>>& edge_time_dict,
+    const c10::optional<c10::Dict<node_type, at::Tensor>>& seed_time_dict,
+    const c10::optional<c10::Dict<rel_type, at::Tensor>>& edge_weight_dict,
     bool csc,
     bool replace,
     bool directed,
@@ -101,10 +101,10 @@ std::tuple<at::Tensor, at::Tensor, std::vector<int64_t>> dist_neighbor_sample(
     const at::Tensor& col,
     const at::Tensor& seed,
     const int64_t num_neighbors,
-    const std::optional<at::Tensor>& node_time,
-    const std::optional<at::Tensor>& edge_time,
-    const std::optional<at::Tensor>& seed_time,
-    const std::optional<at::Tensor>& edge_weight,
+    const c10::optional<at::Tensor>& node_time,
+    const c10::optional<at::Tensor>& edge_time,
+    const c10::optional<at::Tensor>& seed_time,
+    const c10::optional<at::Tensor>& edge_weight,
     bool csc,
     bool replace,
     bool directed,
diff --git a/pyg_lib/csrc/sampler/subgraph.cpp b/pyg_lib/csrc/sampler/subgraph.cpp
index faae6b60e..d1416e106 100644
--- a/pyg_lib/csrc/sampler/subgraph.cpp
+++ b/pyg_lib/csrc/sampler/subgraph.cpp
@@ -6,7 +6,7 @@
 namespace pyg {
 namespace sampler {
 
-std::tuple<at::Tensor, at::Tensor, std::optional<at::Tensor>> subgraph(
+std::tuple<at::Tensor, at::Tensor, c10::optional<at::Tensor>> subgraph(
     const at::Tensor& rowptr,
     const at::Tensor& col,
     const at::Tensor& nodes,