diff --git a/test/ao/sparsity/test_composability.py b/test/ao/sparsity/test_composability.py
index f531dd2927bb1b..85d78c49ea54ae 100644
--- a/test/ao/sparsity/test_composability.py
+++ b/test/ao/sparsity/test_composability.py
@@ -188,7 +188,7 @@ def test_s_prep_before_fusion(self):
         )
 
         # check that final module is the expected quantized module and that the model runs
-        self.assertTrue(isinstance(mod[5], torch.nn.intrinsic.quantized.LinearReLU))
+        self.assertTrue(isinstance(mod[5], torch.ao.nn.intrinsic.quantized.LinearReLU))
         self.assertEqual(mod(torch.randn(1, 4, 4, 4)).shape, torch.Size([1, 4, 4, 4]))
 
     # This tests whether performing fusion before sparse prepare causes and issues. The
@@ -230,7 +230,7 @@ def test_fusion_before_s_prep(self):
         tq.convert(mod, inplace=True)
 
         # check that final module is the expected quantized module and that the model runs
-        self.assertTrue(isinstance(mod[5], torch.nn.intrinsic.quantized.LinearReLU))
+        self.assertTrue(isinstance(mod[5], torch.ao.nn.intrinsic.quantized.LinearReLU))
         self.assertEqual(mod(torch.randn(1, 4, 4, 4)).shape, torch.Size([1, 4, 4, 4]))
 
         # check that module was actually sparsified
@@ -375,7 +375,7 @@ def test_q_prep_fx_before_s_prep(self):
         mod = convert_fx(mod)
 
         # check that final module is the expected quantized module and that the model runs
-        self.assertTrue(isinstance(fqn_to_module(mod, "5"), torch.nn.intrinsic.quantized.LinearReLU))
+        self.assertTrue(isinstance(fqn_to_module(mod, "5"), torch.ao.nn.intrinsic.quantized.LinearReLU))
         self.assertEqual(mod(example).shape, torch.Size([1, 4, 4, 4]))
 
         # check that module was actually sparsified
@@ -433,9 +433,9 @@ def test_q_prep_fx_s_prep_ref_conv(self):
         mod = convert_to_reference_fx(mod)
 
         # check that final module is the expected quantized module and that the model runs
-        self.assertTrue(isinstance(fqn_to_module(mod, "5"), torch.nn.intrinsic.LinearReLU))
+        self.assertTrue(isinstance(fqn_to_module(mod, "5"), torch.ao.nn.intrinsic.LinearReLU))
         self.assertEqual(mod(example).shape, torch.Size([1, 4, 4, 4]))
-        self.assertTrue(isinstance(fqn_to_module(mod, "5.0"), torch.nn.quantized._reference.Linear))
+        self.assertTrue(isinstance(fqn_to_module(mod, "5.0"), torch.ao.nn.quantized.reference.Linear))
 
         # check that module was actually sparsified
         cur_sparsity = _calculate_sparsity(fqn_to_module(mod, "5.0.weight"))
@@ -479,7 +479,7 @@ def test_s_prep_before_q_prep_fx(self):
         mod = convert_fx(mod)
 
         # check that final module is the expected quantized module and that the model runs
-        self.assertTrue(isinstance(fqn_to_module(mod, "5"), torch.nn.intrinsic.quantized.LinearReLU))
+        self.assertTrue(isinstance(fqn_to_module(mod, "5"), torch.ao.nn.intrinsic.quantized.LinearReLU))
         self.assertEqual(mod(example).shape, torch.Size([1, 4, 4, 4]))
 
         # check that module was actually sparsified
@@ -525,7 +525,7 @@ def test_s_prep_before_qat_prep_fx(self):
         mod = convert_fx(mod)
 
         # check that final module is the expected quantized module and that the model runs
-        self.assertTrue(isinstance(fqn_to_module(mod, "5"), torch.nn.intrinsic.quantized.LinearReLU))
+        self.assertTrue(isinstance(fqn_to_module(mod, "5"), torch.ao.nn.intrinsic.quantized.LinearReLU))
         self.assertEqual(mod(example).shape, torch.Size([1, 4, 4, 4]))
 
         # check that module was actually sparsified
@@ -570,9 +570,9 @@ def test_s_prep_q_prep_fx_ref(self):
         mod = convert_to_reference_fx(mod)
 
         # check that final module is the expected quantized module and that the model runs
-        self.assertTrue(isinstance(fqn_to_module(mod, "5"), torch.nn.intrinsic.LinearReLU))
+        self.assertTrue(isinstance(fqn_to_module(mod, "5"), torch.ao.nn.intrinsic.LinearReLU))
         self.assertEqual(mod(example).shape, torch.Size([1, 4, 4, 4]))
-        self.assertTrue(isinstance(fqn_to_module(mod, "5.0"), torch.nn.quantized._reference.Linear))
+        self.assertTrue(isinstance(fqn_to_module(mod, "5.0"), torch.ao.nn.quantized.reference.Linear))
 
         # check that module was actually sparsified
         cur_sparsity = _calculate_sparsity(fqn_to_module(mod, "5.0.weight"))
diff --git a/test/ao/sparsity/test_data_sparsifier.py b/test/ao/sparsity/test_data_sparsifier.py
index 5cf9a3fbb522f8..666cdf7eb46c27 100644
--- a/test/ao/sparsity/test_data_sparsifier.py
+++ b/test/ao/sparsity/test_data_sparsifier.py
@@ -533,8 +533,8 @@ def test_ptq_sparsify_first(self):
                                       select_embeddings=select_embeddings,
                                       **sparse_config)
 
-        assert type(model.emb1) == torch.nn.quantized.modules.embedding_ops.Embedding
-        assert type(model.embbag1) == torch.nn.quantized.modules.embedding_ops.EmbeddingBag
+        assert type(model.emb1) == torch.ao.nn.quantized.modules.embedding_ops.Embedding
+        assert type(model.embbag1) == torch.ao.nn.quantized.modules.embedding_ops.EmbeddingBag
         assert type(model.emb_seq[0] == nn.Embedding)
         assert type(model.emb_seq[1] == nn.EmbeddingBag)
         assert type(model.linear1) == nn.Linear
@@ -568,10 +568,10 @@ def test_ptq_quantize_first(self):
         sparse_config = {'sparsity_level': 0.8, 'sparse_block_shape': (1, 1)}
         post_training_sparse_quantize(model, DataNormSparsifier, sparsify_first=False, **sparse_config)
 
-        assert type(model.emb1) == torch.nn.quantized.modules.embedding_ops.Embedding
-        assert type(model.embbag1) == torch.nn.quantized.modules.embedding_ops.EmbeddingBag
-        assert type(model.emb_seq[0] == torch.nn.quantized.modules.embedding_ops.Embedding)
-        assert type(model.emb_seq[1] == torch.nn.quantized.modules.embedding_ops.EmbeddingBag)
+        assert type(model.emb1) == torch.ao.nn.quantized.modules.embedding_ops.Embedding
+        assert type(model.embbag1) == torch.ao.nn.quantized.modules.embedding_ops.EmbeddingBag
+        assert type(model.emb_seq[0] == torch.ao.nn.quantized.modules.embedding_ops.Embedding)
+        assert type(model.emb_seq[1] == torch.ao.nn.quantized.modules.embedding_ops.EmbeddingBag)
         assert type(model.linear1) == nn.Linear  # not quantized
         assert type(model.linear2) == nn.Linear  # not quantized
 
diff --git a/test/mobile/model_test/quantization_ops.py b/test/mobile/model_test/quantization_ops.py
index d0fdb346545e7d..00ccb97351d1a3 100644
--- a/test/mobile/model_test/quantization_ops.py
+++ b/test/mobile/model_test/quantization_ops.py
@@ -5,14 +5,14 @@
 class GeneralQuantModule(torch.nn.Module):
     def __init__(self):
         super(GeneralQuantModule, self).__init__()
-        self.embedding = torch.nn.quantized.Embedding(
+        self.embedding = torch.ao.nn.quantized.Embedding(
             num_embeddings=10, embedding_dim=12
         )
         self.embedding_input = torch.tensor([9, 6, 5, 7, 8, 8, 9, 2, 8])
-        self.func = torch.nn.quantized.QFunctional()
-        self.conv1 = torch.nn.quantized.ConvTranspose1d(16, 33, 3, stride=2)
-        self.conv2 = torch.nn.quantized.ConvTranspose2d(16, 33, 3, stride=2)
-        self.conv3 = torch.nn.quantized.ConvTranspose3d(16, 33, 3, stride=2)
+        self.func = torch.ao.nn.quantized.QFunctional()
+        self.conv1 = torch.ao.nn.quantized.ConvTranspose1d(16, 33, 3, stride=2)
+        self.conv2 = torch.ao.nn.quantized.ConvTranspose2d(16, 33, 3, stride=2)
+        self.conv3 = torch.ao.nn.quantized.ConvTranspose3d(16, 33, 3, stride=2)
 
     def forward(self):
         a = torch.quantize_per_tensor(torch.tensor([3.0]), 1.0, 0, torch.qint32)
@@ -52,7 +52,7 @@ def __init__(self):
         self.module = self.M()
 
     def getModule(self):
-        return torch.quantization.quantize_dynamic(self.module, dtype=torch.qint8)
+        return torch.ao.quantization.quantize_dynamic(self.module, dtype=torch.qint8)
 
     class M(torch.nn.Module):
         def __init__(self):
@@ -117,15 +117,15 @@ def __init__(self):
     def getModule(self):
         model_fp32 = self.M()
         model_fp32.eval()
-        model_fp32.qconfig = torch.quantization.get_default_qconfig("qnnpack")
-        model_fp32_prepared = torch.quantization.prepare(model_fp32)
-        model_int8 = torch.quantization.convert(model_fp32_prepared)
+        model_fp32.qconfig = torch.ao.quantization.get_default_qconfig("qnnpack")
+        model_fp32_prepared = torch.ao.quantization.prepare(model_fp32)
+        model_int8 = torch.ao.quantization.convert(model_fp32_prepared)
         return model_int8
 
     class M(torch.nn.Module):
         def __init__(self):
             super(StaticQuantModule.M, self).__init__()
-            self.quant = torch.quantization.QuantStub()
+            self.quant = torch.ao.quantization.QuantStub()
             self.input1d = torch.randn(4, 2, 2)
             self.input2d = torch.randn((4, 2, 4, 4))
             self.input3d = torch.randn(4, 2, 2, 4, 4)
@@ -144,7 +144,7 @@ def __init__(self):
                 nn.Conv3d(2, 2, 1), nn.BatchNorm3d(2), nn.InstanceNorm3d(1), nn.ReLU()
             )
             self.layer4 = nn.Sequential(nn.Linear(4, 3))
-            self.dequant = torch.quantization.DeQuantStub()
+            self.dequant = torch.ao.quantization.DeQuantStub()
 
         def forward(self):
             x = self.quant(self.input1d)
@@ -171,8 +171,8 @@ def __init__(self):
     def getModule(self):
         model_fp32 = self.M()
         model_fp32.eval()
-        model_fp32.qconfig = torch.quantization.get_default_qconfig("qnnpack")
-        model_fp32_fused = torch.quantization.fuse_modules(
+        model_fp32.qconfig = torch.ao.quantization.get_default_qconfig("qnnpack")
+        model_fp32_fused = torch.ao.quantization.fuse_modules(
             model_fp32,
             [
                 ["conv1d", "relu1"],
@@ -181,14 +181,14 @@ def getModule(self):
                 ["linear", "relu4"],
             ],
         )
-        model_fp32_prepared = torch.quantization.prepare(model_fp32_fused)
-        model_int8 = torch.quantization.convert(model_fp32_prepared)
+        model_fp32_prepared = torch.ao.quantization.prepare(model_fp32_fused)
+        model_int8 = torch.ao.quantization.convert(model_fp32_prepared)
         return model_int8
 
     class M(torch.nn.Module):
         def __init__(self):
             super(FusedQuantModule.M, self).__init__()
-            self.quant = torch.quantization.QuantStub()
+            self.quant = torch.ao.quantization.QuantStub()
             self.input1d = torch.randn(4, 2, 2)
             self.input2d = torch.randn((4, 2, 4, 4))
             self.input3d = torch.randn(4, 2, 2, 4, 4)
@@ -200,7 +200,7 @@ def __init__(self):
             self.relu2 = nn.ReLU()
             self.relu3 = nn.ReLU()
             self.relu4 = nn.ReLU()
-            self.dequant = torch.quantization.DeQuantStub()
+            self.dequant = torch.ao.quantization.DeQuantStub()
 
         def forward(self):
             x = self.input1d
diff --git a/test/onnx/test_models.py b/test/onnx/test_models.py
index 15904839957eef..b50e8e903c7ba0 100644
--- a/test/onnx/test_models.py
+++ b/test/onnx/test_models.py
@@ -13,7 +13,7 @@
 from model_defs.srresnet import SRResNet
 from model_defs.super_resolution import SuperResolutionNet
 from pytorch_test_common import skipIfUnsupportedMinOpsetVersion, skipScriptTest
-from torch import quantization
+from torch.ao import quantization
 from torch.autograd import Variable
 from torch.onnx import OperatorExportTypes
 from torch.testing._internal import common_utils
diff --git a/test/onnx/test_pytorch_onnx_no_runtime.py b/test/onnx/test_pytorch_onnx_no_runtime.py
index 09421808cc5790..eea86b2adc4880 100644
--- a/test/onnx/test_pytorch_onnx_no_runtime.py
+++ b/test/onnx/test_pytorch_onnx_no_runtime.py
@@ -1102,11 +1102,11 @@ def test_onnx_aten_fallback_must_not_fallback(self):
         class ONNXExportable(torch.nn.Module):
             def __init__(self):
                 super(ONNXExportable, self).__init__()
-                self.quant = torch.quantization.QuantStub()
+                self.quant = torch.ao.quantization.QuantStub()
                 self.fc1 = torch.nn.Linear(12, 8)
                 self.fc2 = torch.nn.Linear(8, 4)
                 self.fc3 = torch.nn.Linear(4, 6)
-                self.dequant = torch.quantization.DeQuantStub()
+                self.dequant = torch.ao.quantization.DeQuantStub()
 
             def forward(self, x):
                 x = self.quant(x)
diff --git a/test/onnx/test_pytorch_onnx_onnxruntime.py b/test/onnx/test_pytorch_onnx_onnxruntime.py
index a8d9a9e761e9d6..387d451a88b333 100644
--- a/test/onnx/test_pytorch_onnx_onnxruntime.py
+++ b/test/onnx/test_pytorch_onnx_onnxruntime.py
@@ -9722,7 +9722,7 @@ def forward(self, input):
     # forward on class: __torch__.torch.nn.modules.linear.Linear
     @skipScriptTest()
     def test_fake_quantize_activation(self):
-        from torch import quantization
+        from torch.ao import quantization
 
         m = torch.nn.Linear(1, 1)
         m.qconfig = quantization.QConfig(
@@ -11986,7 +11986,7 @@ def test_quantized_adaptive_avg_pool2d(self):
 
     @skipIfUnsupportedMinOpsetVersion(10)
     def test_quantized_conv2d_relu(self):
-        model = torch.nn.intrinsic.quantized.ConvReLU2d(16, 33, 3, stride=2)
+        model = torch.ao.nn.intrinsic.quantized.ConvReLU2d(16, 33, 3, stride=2)
         # Manually initialize model weight and bias to random numbers.
         # By default all zeros.
         q_weight = torch.quantize_per_tensor(
@@ -12000,7 +12000,7 @@ def test_quantized_conv2d_relu(self):
 
     @skipIfUnsupportedMinOpsetVersion(10)
     def test_quantized_conv1d_relu(self):
-        model = torch.nn.intrinsic.quantized.ConvReLU1d(16, 33, 3, stride=2)
+        model = torch.ao.nn.intrinsic.quantized.ConvReLU1d(16, 33, 3, stride=2)
         # Manually initialize model weight and bias to random numbers.
         # By default all zeros.
         q_weight = torch.quantize_per_tensor(
@@ -12024,11 +12024,11 @@ def test_quantized_conv1d_relu(self):
                 name="leaky_relu",
             ),
             common_utils.subtest(
-                torch.nn.quantized.LeakyReLU(2.0, 1),
+                torch.ao.nn.quantized.LeakyReLU(2.0, 1),
                 name="quantized_leaky_relu",
             ),
             common_utils.subtest(
-                torch.nn.quantized.Hardswish(2.0, 1),
+                torch.ao.nn.quantized.Hardswish(2.0, 1),
                 name="quantized_hardswish",
             ),
             common_utils.subtest(
@@ -12036,7 +12036,7 @@ def test_quantized_conv1d_relu(self):
                 name="sigmoid",
             ),
             common_utils.subtest(
-                torch.nn.quantized.Sigmoid(2.0, 1),
+                torch.ao.nn.quantized.Sigmoid(2.0, 1),
                 name="quantized_sigmoid",
             ),
             common_utils.subtest(
@@ -12068,7 +12068,7 @@ def test_quantized_conv1d_relu(self):
                 name="select",
             ),
             common_utils.subtest(
-                torch.nn.quantized.LayerNorm(
+                torch.ao.nn.quantized.LayerNorm(
                     [4, 2, 3],
                     torch.nn.Parameter(torch.ones([4, 2, 3])),
                     torch.nn.Parameter(torch.zeros([4, 2, 3])),
@@ -12078,7 +12078,7 @@ def test_quantized_conv1d_relu(self):
                 name="layer_norm",
             ),
             common_utils.subtest(
-                torch.nn.quantized.InstanceNorm1d(
+                torch.ao.nn.quantized.InstanceNorm1d(
                     2,
                     torch.nn.Parameter(torch.ones(4)),
                     torch.nn.Parameter(torch.zeros(4)),
@@ -12088,7 +12088,7 @@ def test_quantized_conv1d_relu(self):
                 name="instance_norm",
             ),
             common_utils.subtest(
-                torch.nn.quantized.GroupNorm(
+                torch.ao.nn.quantized.GroupNorm(
                     2,
                     4,
                     torch.nn.Parameter(torch.zeros(4)),
@@ -12134,7 +12134,7 @@ def forward(self, input):
     def test_quantized_cat_when_concatinating_the_same_tensor(self):
         class QuantizedSelfConcatenationModel(torch.nn.Module):
             def forward(self, x):
-                return torch.nn.quantized.QFunctional().cat((x, x), dim=1)
+                return torch.ao.nn.quantized.QFunctional().cat((x, x), dim=1)
 
         q_input = torch.quantize_per_tensor(torch.ones(2, 3), 0.26, 128, torch.quint8)
         self.run_test(QuantizedSelfConcatenationModel(), q_input)
@@ -12187,7 +12187,7 @@ def forward(self, x):
     def test_quantized_cat(self, x: torch.Tensor, y: torch.Tensor):
         class QuantizedConcatenationModel(torch.nn.Module):
             def forward(self, x, y):
-                return torch.nn.quantized.QFunctional().cat((x, y), dim=0)
+                return torch.ao.nn.quantized.QFunctional().cat((x, y), dim=0)
 
         self.run_test(QuantizedConcatenationModel(), (x, y))
 
@@ -12246,9 +12246,9 @@ def test_qat_linear_per_channel(self):
         class M(torch.nn.Module):
             def __init__(self):
                 super().__init__()
-                self.quant = torch.quantization.QuantStub()
+                self.quant = torch.ao.quantization.QuantStub()
                 self.linear = torch.nn.Linear(4, 3)
-                self.dequant = torch.quantization.DeQuantStub()
+                self.dequant = torch.ao.quantization.DeQuantStub()
 
             def forward(self, x):
                 x = self.quant(x)
@@ -12257,14 +12257,14 @@ def forward(self, x):
                 return x
 
         model = M()
-        model.qconfig = torch.quantization.get_default_qconfig("fbgemm")
-        model = torch.quantization.prepare_qat(model)
+        model.qconfig = torch.ao.quantization.get_default_qconfig("fbgemm")
+        model = torch.ao.quantization.prepare_qat(model)
         # Set fixed weight and bias to avoid flaky test.
         model.linear.weight = torch.nn.Parameter(
             _construct_tensor_for_quantization_test((3, 4))
         )
         model.linear.bias = torch.nn.Parameter(torch.arange(3, dtype=torch.float))
-        model = torch.quantization.convert(model)
+        model = torch.ao.quantization.convert(model)
 
         # Set fixed input to avoid flaky test.
         input = _construct_tensor_for_quantization_test((4, 4), offset=-8)
@@ -12278,8 +12278,8 @@ def test_quantized_list_of_inputs_with_cat(self):
         class TestModel(torch.nn.Module):
             def __init__(self):
                 super().__init__()
-                self.quant = torch.quantization.QuantStub()
-                self.dequant = torch.quantization.DeQuantStub()
+                self.quant = torch.ao.quantization.QuantStub()
+                self.dequant = torch.ao.quantization.DeQuantStub()
 
             def forward(self, x):
                 x = self.quant(x)
@@ -12288,9 +12288,9 @@ def forward(self, x):
                 return x
 
         model = TestModel()
-        model.qconfig = torch.quantization.get_default_qconfig("fbgemm")
-        model = torch.quantization.prepare_qat(model)
-        model = torch.quantization.convert(model)
+        model.qconfig = torch.ao.quantization.get_default_qconfig("fbgemm")
+        model = torch.ao.quantization.prepare_qat(model)
+        model = torch.ao.quantization.convert(model)
         x = torch.randn(2, 4, 6)
         self.run_test(model, x)
 
@@ -12299,9 +12299,9 @@ def test_qat_relu(self):
         class M(torch.nn.Module):
             def __init__(self):
                 super().__init__()
-                self.quant = torch.quantization.QuantStub()
+                self.quant = torch.ao.quantization.QuantStub()
                 self.relu = torch.nn.ReLU()
-                self.dequant = torch.quantization.DeQuantStub()
+                self.dequant = torch.ao.quantization.DeQuantStub()
 
             def forward(self, x):
                 x = self.quant(x)
@@ -12310,9 +12310,9 @@ def forward(self, x):
                 return x
 
         model = M()
-        model.qconfig = torch.quantization.get_default_qconfig("fbgemm")
-        model = torch.quantization.prepare_qat(model)
-        model = torch.quantization.convert(model)
+        model.qconfig = torch.ao.quantization.get_default_qconfig("fbgemm")
+        model = torch.ao.quantization.prepare_qat(model)
+        model = torch.ao.quantization.convert(model)
         input = torch.randn(8, 4)
         self.run_test(model, input)
 
@@ -12321,9 +12321,9 @@ def test_qat_conv2d(self):
         class M(torch.nn.Module):
             def __init__(self):
                 super().__init__()
-                self.quant = torch.quantization.QuantStub()
+                self.quant = torch.ao.quantization.QuantStub()
                 self.conv = torch.nn.Conv2d(2, 4, 3, stride=2)
-                self.dequant = torch.quantization.DeQuantStub()
+                self.dequant = torch.ao.quantization.DeQuantStub()
 
             def forward(self, x):
                 x = self.quant(x)
@@ -12332,14 +12332,14 @@ def forward(self, x):
                 return x
 
         model = M()
-        model.qconfig = torch.quantization.get_default_qconfig("fbgemm")
-        model = torch.quantization.prepare_qat(model)
+        model.qconfig = torch.ao.quantization.get_default_qconfig("fbgemm")
+        model = torch.ao.quantization.prepare_qat(model)
         # Set fixed weight and bias to avoid flaky test.
         model.conv.weight = torch.nn.Parameter(
             _construct_tensor_for_quantization_test((2, 4, 3, 3), max_val=2)
         )
         model.conv.bias = torch.nn.Parameter(torch.tensor([0.0, 1.0]))
-        model = torch.quantization.convert(model)
+        model = torch.ao.quantization.convert(model)
 
         # Set fixed input to avoid flaky test.
         input = _construct_tensor_for_quantization_test(
@@ -12352,10 +12352,10 @@ def test_qat_conv2d_relu(self):
         class M(torch.nn.Module):
             def __init__(self):
                 super().__init__()
-                self.quant = torch.quantization.QuantStub()
+                self.quant = torch.ao.quantization.QuantStub()
                 self.conv = torch.nn.Conv2d(2, 4, 3, stride=2)
                 self.relu = torch.nn.ReLU()
-                self.dequant = torch.quantization.DeQuantStub()
+                self.dequant = torch.ao.quantization.DeQuantStub()
 
             def forward(self, x):
                 x = self.quant(x)
@@ -12365,14 +12365,14 @@ def forward(self, x):
                 return x
 
         model = M()
-        model.qconfig = torch.quantization.get_default_qconfig("fbgemm")
-        model = torch.quantization.prepare_qat(model)
+        model.qconfig = torch.ao.quantization.get_default_qconfig("fbgemm")
+        model = torch.ao.quantization.prepare_qat(model)
         # Set fixed weight and bias to avoid flaky test.
         model.conv.weight = torch.nn.Parameter(
             _construct_tensor_for_quantization_test((2, 4, 3, 3), max_val=2)
         )
         model.conv.bias = torch.nn.Parameter(torch.tensor([0.0, 1.0]))
-        model = torch.quantization.convert(model)
+        model = torch.ao.quantization.convert(model)
 
         # Set fixed input to avoid flaky test.
         input = _construct_tensor_for_quantization_test(
@@ -12385,10 +12385,10 @@ def test_qat_conv2d_relu_fused(self):
         class M(torch.nn.Module):
             def __init__(self):
                 super().__init__()
-                self.quant = torch.quantization.QuantStub()
+                self.quant = torch.ao.quantization.QuantStub()
                 self.conv = torch.nn.Conv2d(2, 4, 3, stride=2)
                 self.relu = torch.nn.ReLU()
-                self.dequant = torch.quantization.DeQuantStub()
+                self.dequant = torch.ao.quantization.DeQuantStub()
 
             def forward(self, x):
                 x = self.quant(x)
@@ -12398,15 +12398,15 @@ def forward(self, x):
                 return x
 
         model = M()
-        model.qconfig = torch.quantization.get_default_qconfig("fbgemm")
-        model = torch.quantization.fuse_modules(model.eval(), [["conv", "relu"]])
-        model = torch.quantization.prepare_qat(model.train())
+        model.qconfig = torch.ao.quantization.get_default_qconfig("fbgemm")
+        model = torch.ao.quantization.fuse_modules(model.eval(), [["conv", "relu"]])
+        model = torch.ao.quantization.prepare_qat(model.train())
         # Set fixed weight and bias to avoid flaky test.
         model.conv.weight = torch.nn.Parameter(
             _construct_tensor_for_quantization_test((2, 4, 3, 3), max_val=2)
         )
         model.conv.bias = torch.nn.Parameter(torch.tensor([0.0, 1.0]))
-        model = torch.quantization.convert(model)
+        model = torch.ao.quantization.convert(model)
 
         # Set fixed input to avoid flaky test.
         input = _construct_tensor_for_quantization_test(
@@ -12419,9 +12419,9 @@ def test_qat_maxpool2d(self):
         class M(torch.nn.Module):
             def __init__(self):
                 super().__init__()
-                self.quant = torch.quantization.QuantStub()
+                self.quant = torch.ao.quantization.QuantStub()
                 self.pool = torch.nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
-                self.dequant = torch.quantization.DeQuantStub()
+                self.dequant = torch.ao.quantization.DeQuantStub()
 
             def forward(self, x):
                 x = self.quant(x)
@@ -12430,9 +12430,9 @@ def forward(self, x):
                 return x
 
         model = M()
-        model.qconfig = torch.quantization.get_default_qconfig("fbgemm")
-        model = torch.quantization.prepare_qat(model.train())
-        model = torch.quantization.convert(model)
+        model.qconfig = torch.ao.quantization.get_default_qconfig("fbgemm")
+        model = torch.ao.quantization.prepare_qat(model.train())
+        model = torch.ao.quantization.convert(model)
 
         # Set fixed input to avoid flaky test.
         input = _construct_tensor_for_quantization_test((4, 4, 3, 2))
@@ -12441,26 +12441,26 @@ def forward(self, x):
     @skipIfUnsupportedMinOpsetVersion(10)
     def test_qat_avg_pool2d(self):
         model = torch.nn.Sequential(
-            torch.quantization.QuantStub(),
+            torch.ao.quantization.QuantStub(),
             torch.nn.AvgPool2d(kernel_size=3, stride=2, padding=1),
-            torch.quantization.DeQuantStub(),
+            torch.ao.quantization.DeQuantStub(),
         )
-        model.qconfig = torch.quantization.get_default_qconfig("fbgemm")
-        model = torch.quantization.prepare_qat(model.train())
-        model = torch.quantization.convert(model)
+        model.qconfig = torch.ao.quantization.get_default_qconfig("fbgemm")
+        model = torch.ao.quantization.prepare_qat(model.train())
+        model = torch.ao.quantization.convert(model)
         input = _construct_tensor_for_quantization_test((4, 4, 3, 2))
         self.run_test(model, input)
 
     @skipIfUnsupportedMinOpsetVersion(11)
     def test_qat_upsample_nearest2d(self):
         model = torch.nn.Sequential(
-            torch.quantization.QuantStub(),
+            torch.ao.quantization.QuantStub(),
             torch.nn.UpsamplingNearest2d(scale_factor=1.5),
-            torch.quantization.DeQuantStub(),
+            torch.ao.quantization.DeQuantStub(),
         )
-        model.qconfig = torch.quantization.get_default_qconfig("fbgemm")
-        model = torch.quantization.prepare_qat(model.train())
-        model = torch.quantization.convert(model)
+        model.qconfig = torch.ao.quantization.get_default_qconfig("fbgemm")
+        model = torch.ao.quantization.prepare_qat(model.train())
+        model = torch.ao.quantization.convert(model)
         input = _construct_tensor_for_quantization_test((4, 3, 2, 2))
         self.run_test(model, input)
 
diff --git a/test/quantization/bc/test_backward_compatibility.py b/test/quantization/bc/test_backward_compatibility.py
index 83f2c790a6eb8b..987b0eafb8d41e 100644
--- a/test/quantization/bc/test_backward_compatibility.py
+++ b/test/quantization/bc/test_backward_compatibility.py
@@ -11,7 +11,7 @@
 import torch.nn as nn
 import torch.ao.nn.quantized as nnq
 import torch.ao.nn.quantized.dynamic as nnqd
-import torch.nn.intrinsic.quantized as nniq
+import torch.ao.nn.intrinsic.quantized as nniq
 from torch.fx import GraphModule
 
 # Testing utils
@@ -173,7 +173,7 @@ def _do_quant_transforms(
         ) -> torch.nn.Module:
             example_inputs = (input_tensor,)
             # do the quantizaton transforms and save result
-            qconfig = torch.quantization.get_default_qconfig('fbgemm')
+            qconfig = torch.ao.quantization.get_default_qconfig('fbgemm')
             mp = quantize_fx.prepare_fx(m, {'': qconfig}, example_inputs=example_inputs)
             mp(input_tensor)
             mq = quantize_fx.convert_fx(mp)
diff --git a/test/quantization/core/experimental/apot_fx_graph_mode_ptq.py b/test/quantization/core/experimental/apot_fx_graph_mode_ptq.py
index c19384294734e0..cbf3cb6756296e 100644
--- a/test/quantization/core/experimental/apot_fx_graph_mode_ptq.py
+++ b/test/quantization/core/experimental/apot_fx_graph_mode_ptq.py
@@ -1,6 +1,6 @@
 import torch
 import torch.nn as nn
-import torch.quantization
+import torch.ao.quantization
 from torchvision.models.quantization.resnet import resnet18
 from torch.ao.quantization.experimental.quantization_helper import (
     evaluate,
@@ -25,8 +25,8 @@
 Prepare models
 """
 
-# Note that this is temporary, we'll expose these functions to torch.quantization after official releasee
-from torch.quantization.quantize_fx import prepare_qat_fx
+# Note that this is temporary, we'll expose these functions to torch.ao.quantization after official releasee
+from torch.ao.quantization.quantize_fx import prepare_qat_fx
 
 def calibrate(model, data_loader):
     model.eval()
diff --git a/test/quantization/core/experimental/quantization_util.py b/test/quantization/core/experimental/quantization_util.py
index fcba45b765c924..cb5dbe18b825ac 100644
--- a/test/quantization/core/experimental/quantization_util.py
+++ b/test/quantization/core/experimental/quantization_util.py
@@ -2,7 +2,7 @@
 import torchvision
 import torchvision.transforms.transforms as transforms
 import os
-import torch.quantization
+import torch.ao.quantization
 from torchvision.models.quantization.resnet import resnet18
 from torch.autograd import Variable
 
@@ -15,7 +15,7 @@
 )
 warnings.filterwarnings(
     action='default',
-    module=r'torch.quantization'
+    module=r'torch.ao.quantization'
 )
 
 """
diff --git a/test/quantization/core/test_backend_config.py b/test/quantization/core/test_backend_config.py
index e4ee6aeff8c5ce..3cb6dcc9c4a36b 100644
--- a/test/quantization/core/test_backend_config.py
+++ b/test/quantization/core/test_backend_config.py
@@ -1,9 +1,9 @@
 # Owner(s): ["oncall: quantization"]
 
 import torch
-import torch.nn.intrinsic as nni
-import torch.nn.qat as nnqat
-import torch.nn.quantized._reference as nnqr
+import torch.ao.nn.intrinsic as nni
+import torch.ao.nn.qat as nnqat
+import torch.ao.nn.quantized.reference as nnqr
 from torch.testing._internal.common_quantization import QuantizationTestCase
 
 from torch.ao.quantization.backend_config import (
diff --git a/test/quantization/core/test_docs.py b/test/quantization/core/test_docs.py
index 27842b46ce7e07..ecfb1ab7fd03a4 100644
--- a/test/quantization/core/test_docs.py
+++ b/test/quantization/core/test_docs.py
@@ -6,7 +6,7 @@
 
 import torch
 
-# import torch.nn.quantized as nnq
+# import torch.ao.nn.quantized as nnq
 from torch.testing._internal.common_quantization import (
     QuantizationTestCase,
     SingleLayerLinearModel,
@@ -140,7 +140,7 @@ def test_quantization_doc_custom(self):
         path_from_pytorch = "docs/source/quantization.rst"
         unique_identifier = "Custom API Example::"
 
-        global_inputs = {"nnq": torch.nn.quantized}
+        global_inputs = {"nnq": torch.ao.nn.quantized}
 
         code = self._get_code(path_from_pytorch, unique_identifier)
         self._test_code(code, global_inputs)
diff --git a/test/quantization/core/test_quantized_module.py b/test/quantization/core/test_quantized_module.py
index 26048ec69a0e71..e7a1836a3e972c 100644
--- a/test/quantization/core/test_quantized_module.py
+++ b/test/quantization/core/test_quantized_module.py
@@ -2,7 +2,7 @@
 
 import torch
 import torch.nn as nn
-import torch.nn.intrinsic as nni
+import torch.ao.nn.intrinsic as nni
 import torch.ao.nn.intrinsic.quantized as nniq
 import torch.ao.nn.quantized.reference as nnqr
 import torch.ao.quantization
@@ -395,15 +395,15 @@ def _test_conv_api_impl(
             qconv_module, [example_input_q],
             check_save_load=True)
 
-        class _FusedModule_two_input_args(torch.nn.intrinsic._FusedModule):
-            # Help Module for ConvAdd2d since torch.nn.intrinsic._FusedModule only support one input arg
+        class _FusedModule_two_input_args(torch.ao.nn.intrinsic._FusedModule):
+            # Help Module for ConvAdd2d since torch.ao.nn.intrinsic._FusedModule only support one input arg
             def forward(self, x1, x2):
                 input = self[0](x1, x2)
                 return input
 
         # Test from_float
         fused_conv_module = _FusedModule_two_input_args(conv_module) \
-            if post_op in ["add", "add_relu"] else torch.nn.intrinsic._FusedModule(conv_module)
+            if post_op in ["add", "add_relu"] else torch.ao.nn.intrinsic._FusedModule(conv_module)
 
         fused_conv_module.qconfig = torch.ao.quantization.default_qconfig
         torch.ao.quantization.prepare(fused_conv_module, inplace=True)
@@ -940,7 +940,7 @@ def _test_dropout_serialization(self, get_model, data1, data2):
         ref1 = mq1(data2)
 
         m2 = get_model()
-        m2.qconfig = torch.quantization.default_qconfig
+        m2.qconfig = torch.ao.quantization.default_qconfig
         mp2 = torch.ao.quantization.prepare(m2)
         mq2 = torch.ao.quantization.convert(mp2)
 
@@ -1009,7 +1009,7 @@ def _test_batch_norm_serialization(self, get_model, data1, data2):
         ref1 = mq1(data2)
 
         m2 = get_model()
-        m2.qconfig = torch.quantization.default_qconfig
+        m2.qconfig = torch.ao.quantization.default_qconfig
         mp2 = torch.ao.quantization.prepare(m2)
         mq2 = torch.ao.quantization.convert(mp2)
 
diff --git a/test/quantization/core/test_quantized_op.py b/test/quantization/core/test_quantized_op.py
index d38b26de3dfae3..1ec22594d37978 100644
--- a/test/quantization/core/test_quantized_op.py
+++ b/test/quantization/core/test_quantized_op.py
@@ -330,7 +330,7 @@ def test_qhardsigmoid(self):
             {
                 'quantized_fn': [
                     torch.ao.nn.quantized.functional.hardsigmoid,
-                    torch.nn.quantized.functional.hardsigmoid,
+                    torch.ao.nn.quantized.functional.hardsigmoid,
                 ],
                 'reference_fn': torch.nn.functional.hardsigmoid,
                 'output_range': (0.0, 1.0),
@@ -339,7 +339,7 @@ def test_qhardsigmoid(self):
             {
                 'quantized_fn': [
                     torch.ao.nn.quantized.functional.hardsigmoid,
-                    torch.nn.quantized.functional.hardsigmoid,
+                    torch.ao.nn.quantized.functional.hardsigmoid,
                 ],
                 'reference_fn': torch.nn.functional.hardsigmoid,
                 'output_range': (0.0, 1.0),
@@ -661,7 +661,7 @@ def test_qthreshold(self, X, threshold, value):
         ops_under_test = {
             'native': torch.threshold,
             'nn.functional': torch.nn.functional.threshold,
-            'nn.quantized.functional': torch.nn.quantized.functional.threshold,
+            'nn.quantized.functional': torch.ao.nn.quantized.functional.threshold,
             'ao.nn.quantized.functional': torch.ao.nn.quantized.functional.threshold,
         }
 
@@ -734,7 +734,7 @@ def test_hardtanh(self, X, min_val, max_val):
 
             ops_under_test = {
                 'nn.quantized.functional.hardtanh':
-                    torch.nn.quantized.functional.hardtanh,
+                    torch.ao.nn.quantized.functional.hardtanh,
                 'ao.nn.quantized.functional.hardtanh':
                     torch.ao.nn.quantized.functional.hardtanh,
             }
@@ -745,7 +745,7 @@ def test_hardtanh(self, X, min_val, max_val):
 
             ops_under_test_inplace = {
                 'inplace nn.quantized.functional.hardtanh':
-                    torch.nn.quantized.functional.hardtanh,
+                    torch.ao.nn.quantized.functional.hardtanh,
                 'inplace ao.nn.quantized.functional.hardtanh':
                     torch.ao.nn.quantized.functional.hardtanh,
             }
@@ -1346,7 +1346,7 @@ def test_max_pool1d(self, X, kernel, stride, dilation, padding, ceil_mode):
         ops_under_test = {
             "torch": torch.max_pool1d,
             "nn.functional": torch.nn.functional.max_pool1d,
-            "nn.quantized.functional": torch.nn.quantized.functional.max_pool1d,
+            "nn.quantized.functional": torch.ao.nn.quantized.functional.max_pool1d,
             "ao.nn.quantized.functional": torch.ao.nn.quantized.functional.max_pool1d,
         }
 
@@ -1443,7 +1443,7 @@ def test_max_pool2d(self, X, kernel, stride, dilation, padding, ceil_mode):
         ops_under_test = {
             "torch": torch.max_pool2d,
             "nn.functional": torch.nn.functional.max_pool2d,
-            "nn.quantized.functional": torch.nn.quantized.functional.max_pool2d,
+            "nn.quantized.functional": torch.ao.nn.quantized.functional.max_pool2d,
             "ao.nn.quantized.functional": torch.ao.nn.quantized.functional.max_pool2d,
         }
 
@@ -1502,7 +1502,7 @@ def test_max_pool2d_nhwc(self, X, kernel, stride, dilation, padding, ceil_mode):
         ops_under_test = {
             "torch": torch.max_pool2d,
             "nn.functional": torch.nn.functional.max_pool2d,
-            "nn.quantized.functional": torch.nn.quantized.functional.max_pool2d,
+            "nn.quantized.functional": torch.ao.nn.quantized.functional.max_pool2d,
             "ao.nn.quantized.functional": torch.ao.nn.quantized.functional.max_pool2d,
         }
 
@@ -1552,7 +1552,7 @@ def test_avg_pool2d(self, X, kernel, stride, padding, ceil_mode, count_include_p
             ceil_mode=ceil_mode, count_include_pad=count_include_pad, divisor_override=divisor_override)
         ops_under_test = {
             "nn.functional": torch.nn.functional.avg_pool2d,
-            "nn.quantized.functional": torch.nn.quantized.functional.avg_pool2d,
+            "nn.quantized.functional": torch.ao.nn.quantized.functional.avg_pool2d,
             "ao.nn.quantized.functional": torch.ao.nn.quantized.functional.avg_pool2d,
         }
         error_message = r"Results are off for {}:\n\tExpected:\n{}\n\tGot:\n{}"
@@ -1614,7 +1614,7 @@ def test_avg_pool2d_nhwc(self, X, kernel, stride, padding, ceil_mode, count_incl
         self.assertTrue(qX.stride() != sorted(qX.stride()))
         ops_under_test = {
             "nn.functional": torch.nn.functional.avg_pool2d,
-            "nn.quantized.functional": torch.nn.quantized.functional.avg_pool2d,
+            "nn.quantized.functional": torch.ao.nn.quantized.functional.avg_pool2d,
             "ao.nn.quantized.functional": torch.ao.nn.quantized.functional.avg_pool2d,
         }
         error_message = r"Results are off for {}:\n\tExpected:\n{}\n\tGot:\n{}"
@@ -1669,7 +1669,7 @@ def test_avg_pool3d(self, X, kernel, stride, padding, ceil_mode, count_include_p
 
         ops_under_test = {
             "nn.functional": torch.nn.functional.avg_pool3d,
-            "nn.quantized.functional": torch.nn.quantized.functional.avg_pool3d,
+            "nn.quantized.functional": torch.ao.nn.quantized.functional.avg_pool3d,
             "ao.nn.quantized.functional": torch.ao.nn.quantized.functional.avg_pool3d,
         }
         error_message = r"Results are off for {}:\n\tExpected:\n{}\n\tGot:\n{}"
@@ -1732,7 +1732,7 @@ def test_avg_pool3d_nhwc(self, X, kernel, stride, padding, ceil_mode, count_incl
         self.assertTrue(qX.stride() != sorted(qX.stride()))
         ops_under_test = {
             "nn.functional": torch.nn.functional.avg_pool3d,
-            "nn.quantized.functional": torch.nn.quantized.functional.avg_pool3d,
+            "nn.quantized.functional": torch.ao.nn.quantized.functional.avg_pool3d,
             "ao.nn.quantized.functional": torch.ao.nn.quantized.functional.avg_pool3d,
         }
         error_message = r"Results are off for {}:\n\tExpected:\n{}\n\tGot:\n{}"
@@ -1802,7 +1802,7 @@ def test_adaptive_avg_pool2d_nhwc(self):
             ops_under_test = {
                 "nn.functional": torch.nn.functional.adaptive_avg_pool2d,
                 "nn.quantized.functional":
-                    torch.nn.quantized.functional.adaptive_avg_pool2d,
+                    torch.ao.nn.quantized.functional.adaptive_avg_pool2d,
                 "ao.nn.quantized.functional":
                     torch.ao.nn.quantized.functional.adaptive_avg_pool2d,
             }
@@ -1873,7 +1873,7 @@ def test_adaptive_avg_pool(self):
                     "nn.functional":
                         getattr(torch.nn.functional, 'adaptive_avg_pool{}d'.format(dim)),
                     "nn.quantized.functional":
-                        getattr(torch.nn.quantized.functional, 'adaptive_avg_pool{}d'.format(dim)),
+                        getattr(torch.ao.nn.quantized.functional, 'adaptive_avg_pool{}d'.format(dim)),
                     "ao.nn.quantized.functional":
                         getattr(torch.ao.nn.quantized.functional, 'adaptive_avg_pool{}d'.format(dim))
                 }
@@ -1952,7 +1952,7 @@ def test_adaptive_avg_pool3d_ndhwc(self):
             ops_under_test = {
                 "nn.functional": torch.nn.functional.adaptive_avg_pool3d,
                 "nn.quantized.functional":
-                    torch.nn.quantized.functional.adaptive_avg_pool3d,
+                    torch.ao.nn.quantized.functional.adaptive_avg_pool3d,
                 "ao.nn.quantized.functional":
                     torch.ao.nn.quantized.functional.adaptive_avg_pool3d,
             }
@@ -2100,7 +2100,7 @@ def test_interpolate(self, X, size, mode, scale_factor, align_corners, nhwc_layo
 
         ops_under_test = {
             "nn.functional": torch.nn.functional.interpolate,
-            "nn.quantized.functional": torch.nn.quantized.functional.interpolate,
+            "nn.quantized.functional": torch.ao.nn.quantized.functional.interpolate,
             "ao.nn.quantized.functional": torch.ao.nn.quantized.functional.interpolate,
         }
         error_message = r"Results are off for {}:\n\tExpected:\n{}\n\tGot:\n{}"
@@ -2154,7 +2154,7 @@ def test_interpolate3d(self, X, size, mode, scale_factor, align_corners, nhwc_la
 
         ops_under_test = {
             "nn.functional": torch.nn.functional.interpolate,
-            "nn.quantized.functional": torch.nn.quantized.functional.interpolate,
+            "nn.quantized.functional": torch.ao.nn.quantized.functional.interpolate,
             "ao.nn.quantized.functional": torch.ao.nn.quantized.functional.interpolate,
         }
 
@@ -2831,7 +2831,7 @@ def test_custom_module_lstm(self):
                 lstm_prepared = torch.ao.quantization.prepare(lstm)
                 self.assertTrue(hasattr(lstm_prepared[0], 'layers'))
                 self.assertEqual(num_layers, len(lstm_prepared[0].layers))
-                assert type(lstm_prepared[0]) == torch.nn.quantizable.LSTM
+                assert type(lstm_prepared[0]) == torch.ao.nn.quantizable.LSTM
 
                 # Calibrate
                 y = lstm_prepared(x)
@@ -2839,7 +2839,7 @@ def test_custom_module_lstm(self):
 
                 # Quantize
                 lstm_quantized = torch.ao.quantization.convert(lstm_prepared)
-                assert type(lstm_quantized[0]) == torch.nn.quantized.LSTM
+                assert type(lstm_quantized[0]) == torch.ao.nn.quantized.LSTM
                 qy = lstm_quantized(qx)
 
                 snr = _snr(y, qy)
diff --git a/test/quantization/core/test_utils.py b/test/quantization/core/test_utils.py
index 55d889f88eb3a4..94ae6160960472 100644
--- a/test/quantization/core/test_utils.py
+++ b/test/quantization/core/test_utils.py
@@ -3,7 +3,7 @@
 import torch
 from torch.testing._internal.common_utils import TestCase
 from torch.ao.quantization.utils import get_fqn_to_example_inputs
-from torch.nn.quantized.modules.utils import _quantize_weight
+from torch.ao.nn.quantized.modules.utils import _quantize_weight
 from torch.ao.quantization import MovingAverageMinMaxObserver, MovingAveragePerChannelMinMaxObserver
 
 
diff --git a/test/quantization/eager/test_fuse_eager.py b/test/quantization/eager/test_fuse_eager.py
index 1ebc4bfd094eb6..6343d044cfedf0 100644
--- a/test/quantization/eager/test_fuse_eager.py
+++ b/test/quantization/eager/test_fuse_eager.py
@@ -5,8 +5,8 @@
 import torch
 import torch.nn as nn
 import torch.ao.nn.quantized as nnq
-import torch.nn.intrinsic as nni
-import torch.nn.intrinsic.quantized as nniq
+import torch.ao.nn.intrinsic as nni
+import torch.ao.nn.intrinsic.quantized as nniq
 import torch.ao.nn.intrinsic.qat as nniqat
 from torch.ao.quantization import (
     quantize,
diff --git a/test/quantization/eager/test_numeric_suite_eager.py b/test/quantization/eager/test_numeric_suite_eager.py
index c8cf9c3dddf854..794630e61d2e19 100644
--- a/test/quantization/eager/test_numeric_suite_eager.py
+++ b/test/quantization/eager/test_numeric_suite_eager.py
@@ -542,9 +542,9 @@ def _test_vision_model(self, float_model):
         float_model.to('cpu')
         float_model.eval()
         float_model.fuse_model()
-        float_model.qconfig = torch.quantization.default_qconfig
+        float_model.qconfig = torch.ao.quantization.default_qconfig
         img_data = [(torch.rand(2, 3, 224, 224, dtype=torch.float), torch.randint(0, 1, (2,), dtype=torch.long)) for _ in range(2)]
-        qmodel = quantize(float_model, torch.quantization.default_eval_fn, [img_data], inplace=False)
+        qmodel = quantize(float_model, torch.ao.quantization.default_eval_fn, [img_data], inplace=False)
 
         wt_compare_dict = compare_weights(float_model.state_dict(), qmodel.state_dict())
 
diff --git a/test/quantization/eager/test_quantize_eager_ptq.py b/test/quantization/eager/test_quantize_eager_ptq.py
index ae0f6f164dce63..7a5a631080f98a 100644
--- a/test/quantization/eager/test_quantize_eager_ptq.py
+++ b/test/quantization/eager/test_quantize_eager_ptq.py
@@ -121,7 +121,7 @@ def forward(self, x):
         original_ref_m.conv.weight = torch.nn.Parameter(original_m.conv.weight.detach())
         original_ref_m.conv.bias = torch.nn.Parameter(original_m.conv.bias.detach())
 
-        original_m.qconfig = torch.quantization.default_qconfig
+        original_m.qconfig = torch.ao.quantization.default_qconfig
 
         m = prepare(original_m)
         # calibration
@@ -135,7 +135,7 @@ def forward(self, x):
 
         # quantize the reference model
         original_ref_m.eval()
-        original_ref_m.qconfig = torch.quantization.default_qconfig
+        original_ref_m.qconfig = torch.ao.quantization.default_qconfig
 
         ref_m = prepare(original_ref_m)
         ref_m(data)
@@ -1077,9 +1077,9 @@ def __init__(self, d_model, nhead, batch_first):
         qengine = torch.backends.quantized.engine
         for batch_first in [True, False]:
             model = TransformerDecoderLayer(512, 8, batch_first)
-            quantization_config = torch.quantization.get_default_qconfig(qengine)
+            quantization_config = torch.ao.quantization.get_default_qconfig(qengine)
             model.qconfig = quantization_config
-            prepared_model = torch.quantization.prepare(model, inplace=False)
+            prepared_model = torch.ao.quantization.prepare(model, inplace=False)
             self.assertTrue(prepared_model.self_attn.batch_first == model.self_attn.batch_first)
 
 @skipIfNoFBGEMM
diff --git a/test/quantization/eager/test_quantize_eager_qat.py b/test/quantization/eager/test_quantize_eager_qat.py
index 44911b6d9e11ae..b83f2e1bf97f5d 100644
--- a/test/quantization/eager/test_quantize_eager_qat.py
+++ b/test/quantization/eager/test_quantize_eager_qat.py
@@ -226,7 +226,7 @@ def from_float(cls, mod, qconfig=None):
         return qat_convbn
 
 class _ReferenceConvBn2d(_ReferenceConvBnNd, nn.Conv2d):
-    _FLOAT_MODULE = torch.nn.intrinsic.ConvBn2d
+    _FLOAT_MODULE = torch.ao.nn.intrinsic.ConvBn2d
 
     def __init__(self,
                  # ConvNd args
@@ -1053,7 +1053,7 @@ def test_linear_bn_numerics(self):
         m = nniqat.LinearBn1d.from_float(m_ref_copy[0])
 
         # without fake_quants, fused QAT module should match fp32 module
-        m.apply(torch.quantization.disable_fake_quant)
+        m.apply(torch.ao.quantization.disable_fake_quant)
         data = torch.randn(4, 4)
         r1 = m_ref(data)
         r2 = m(data)
@@ -1076,7 +1076,7 @@ def test_linear_bn_symm_numerics(self):
         m = nniqat.LinearBn1d.from_float(m_ref_copy[0])
 
         # without fake_quants, fused QAT module should match fp32 module
-        m.apply(torch.quantization.disable_fake_quant)
+        m.apply(torch.ao.quantization.disable_fake_quant)
         data = torch.randn(4, 4)
         r1 = m_ref(data)
         r2 = m(data)
diff --git a/test/quantization/fx/test_equalize_fx.py b/test/quantization/fx/test_equalize_fx.py
index e3560fd2914928..059c5bb68b9d7e 100644
--- a/test/quantization/fx/test_equalize_fx.py
+++ b/test/quantization/fx/test_equalize_fx.py
@@ -3,7 +3,7 @@
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-import torch.nn.intrinsic.quantized as nniq
+import torch.ao.nn.intrinsic.quantized as nniq
 import torch.ao.nn.quantized as nnq
 from torch.ao.quantization import default_qconfig
 from torch.ao.quantization.observer import MinMaxObserver, PerChannelMinMaxObserver
diff --git a/test/quantization/fx/test_model_report_fx.py b/test/quantization/fx/test_model_report_fx.py
index c688946eaf8b8a..6e367b0eb7fa53 100644
--- a/test/quantization/fx/test_model_report_fx.py
+++ b/test/quantization/fx/test_model_report_fx.py
@@ -20,7 +20,7 @@
     default_per_channel_weight_observer,
     default_observer
 )
-from torch.nn.intrinsic.modules.fused import ConvReLU2d, LinearReLU
+from torch.ao.nn.intrinsic.modules.fused import ConvReLU2d, LinearReLU
 from torch.testing._internal.common_quantization import (
     ConvModel,
     QuantizationTestCase,
@@ -436,12 +436,12 @@ class QATConvLinearReluModel(torch.nn.Module):
             def __init__(self):
                 super(QATConvLinearReluModel, self).__init__()
                 # QuantStub converts tensors from floating point to quantized
-                self.quant = torch.quantization.QuantStub()
+                self.quant = torch.ao.quantization.QuantStub()
                 self.conv = torch.nn.Conv2d(1, 1, 1)
                 self.bn = torch.nn.BatchNorm2d(1)
                 self.relu = torch.nn.ReLU()
                 # DeQuantStub converts tensors from quantized to floating point
-                self.dequant = torch.quantization.DeQuantStub()
+                self.dequant = torch.ao.quantization.DeQuantStub()
 
             def forward(self, x):
                 x = self.quant(x)
@@ -455,17 +455,17 @@ def forward(self, x):
             # create a model instance
             model_fp32 = QATConvLinearReluModel()
 
-            model_fp32.qconfig = torch.quantization.get_default_qat_qconfig("qnnpack")
+            model_fp32.qconfig = torch.ao.quantization.get_default_qat_qconfig("qnnpack")
 
             # model must be in eval mode for fusion
             model_fp32.eval()
-            model_fp32_fused = torch.quantization.fuse_modules(model_fp32, [["conv", "bn", "relu"]])
+            model_fp32_fused = torch.ao.quantization.fuse_modules(model_fp32, [["conv", "bn", "relu"]])
 
             # model must be set to train mode for QAT logic to work
             model_fp32_fused.train()
 
             # prepare the model for QAT, different than for post training quantization
-            model_fp32_prepared = torch.quantization.prepare_qat(model_fp32_fused)
+            model_fp32_prepared = torch.ao.quantization.prepare_qat(model_fp32_fused)
 
             # run the detector
             per_channel_detector = PerChannelDetector(torch.backends.quantized.engine)
@@ -1946,7 +1946,7 @@ def _get_prepped_for_calibration_model_helper(model, detector_set, example_input
 
     # if they passed in fusion paramter, make sure to test that
     if fused:
-        model = torch.quantization.fuse_modules(model, model.get_fusion_modules())
+        model = torch.ao.quantization.fuse_modules(model, model.get_fusion_modules())
 
     model_prep = quantize_fx.prepare_fx(model, q_config_mapping, example_input)
 
diff --git a/test/quantization/fx/test_numeric_suite_fx.py b/test/quantization/fx/test_numeric_suite_fx.py
index 41bb448ea6b6d5..0a65907998fe6e 100644
--- a/test/quantization/fx/test_numeric_suite_fx.py
+++ b/test/quantization/fx/test_numeric_suite_fx.py
@@ -13,7 +13,7 @@
     QConfigMapping,
     get_default_qconfig_mapping,
 )
-import torch.nn.quantized as nnq
+import torch.ao.nn.quantized as nnq
 toq = torch.ops.quantized
 from torch.ao.quantization.quantize_fx import (
     convert_fx,
@@ -2123,7 +2123,7 @@ def forward(self, x):
         example_input = (torch.randn(2, 2),)
 
         qconfig_mappings = \
-            QConfigMultiMapping().set_global([torch.quantization.default_qconfig])
+            QConfigMultiMapping().set_global([torch.ao.quantization.default_qconfig])
         self._test_impl(m, example_input, qconfig_mappings)
 
     @withQNNPACKBackend
@@ -2146,8 +2146,8 @@ def forward(self, x):
 
         qconfig_mappings = (
             QConfigMultiMapping().set_global([
-                torch.quantization.default_qconfig,
-                torch.quantization.default_dynamic_qconfig
+                torch.ao.quantization.default_qconfig,
+                torch.ao.quantization.default_dynamic_qconfig
             ])
         )
         self._test_impl(m, example_input, qconfig_mappings)
@@ -2172,8 +2172,8 @@ def forward(self, x):
 
         qconfig_mappings = QConfigMultiMapping() \
             .set_global([
-                torch.quantization.default_qconfig,
-                torch.quantization.default_per_channel_qconfig
+                torch.ao.quantization.default_qconfig,
+                torch.ao.quantization.default_per_channel_qconfig
             ])
         self._test_impl(m, example_input, qconfig_mappings)
 
@@ -2213,7 +2213,7 @@ def forward(self, x):
         example_input = (torch.randn(2, 2),)
 
         qconfig_mappings = QConfigMultiMapping() \
-            .set_global([torch.quantization.default_qconfig])
+            .set_global([torch.ao.quantization.default_qconfig])
         self._test_impl(m, example_input, qconfig_mappings)
 
     @withQNNPACKBackend
@@ -2248,7 +2248,7 @@ def test_logger_enabled_and_save_activations_flags(self):
         example_input = (torch.randn(1, 1),)
 
         qconfig_mappings = QConfigMultiMapping() \
-            .set_global([torch.quantization.default_qconfig])
+            .set_global([torch.ao.quantization.default_qconfig])
         backend_config = get_native_backend_config()
 
         msp = prepare_n_shadows_model(
@@ -2299,7 +2299,7 @@ def test_mobilenet_v2(self):
         example_input = (torch.randn(1, 3, 224, 224),)
 
         qconfig_mappings = QConfigMultiMapping() \
-            .set_global([torch.quantization.default_qconfig, torch.quantization.default_dynamic_qconfig])
+            .set_global([torch.ao.quantization.default_qconfig, torch.ao.quantization.default_dynamic_qconfig])
 
         self._test_impl(m, example_input, qconfig_mappings)
 
@@ -2307,7 +2307,7 @@ def test_mobilenet_v2(self):
     def test_qconfig_multi_mapping_deduplication(self):
         # check that insertion deduplicates qconfigs
         qconfig_multi_mapping = QConfigMultiMapping().set_global(
-            [torch.quantization.default_qconfig, torch.quantization.default_qconfig]
+            [torch.ao.quantization.default_qconfig, torch.ao.quantization.default_qconfig]
         )
         self.assertEqual(len(qconfig_multi_mapping.qconfig_mappings_list), 1)
 
@@ -2319,15 +2319,15 @@ def test_qconfig_multi_mapping_insert_padding(self):
             QConfigMultiMapping()
             .set_global(
                 [
-                    torch.quantization.default_qconfig,
-                    torch.quantization.default_dynamic_qconfig,
+                    torch.ao.quantization.default_qconfig,
+                    torch.ao.quantization.default_dynamic_qconfig,
                 ]
             )
-            .set_object_type(torch.nn.Linear, [torch.quantization.default_qconfig])
-            .set_module_name_regex("fc", [torch.quantization.default_qconfig])
-            .set_module_name("fc2", [torch.quantization.default_qconfig])
+            .set_object_type(torch.nn.Linear, [torch.ao.quantization.default_qconfig])
+            .set_module_name_regex("fc", [torch.ao.quantization.default_qconfig])
+            .set_module_name("fc2", [torch.ao.quantization.default_qconfig])
             .set_module_name_object_type_order(
-                "", nn.Linear, 0, [torch.quantization.default_qconfig]
+                "", nn.Linear, 0, [torch.ao.quantization.default_qconfig]
             )
         )
 
@@ -2360,16 +2360,16 @@ def test_qconfig_multi_mapping_retroactive_padding(self):
         # will result in the new QConfigMapping having None at all previously existing styles+keys
         qconfig_multi_mapping = (
             QConfigMultiMapping()
-            .set_object_type(torch.nn.Linear, [torch.quantization.default_qconfig])
-            .set_module_name_regex("fc", [torch.quantization.default_qconfig])
-            .set_module_name("fc2", [torch.quantization.default_qconfig])
+            .set_object_type(torch.nn.Linear, [torch.ao.quantization.default_qconfig])
+            .set_module_name_regex("fc", [torch.ao.quantization.default_qconfig])
+            .set_module_name("fc2", [torch.ao.quantization.default_qconfig])
             .set_module_name_object_type_order(
-                "", nn.Linear, 0, [torch.quantization.default_qconfig]
+                "", nn.Linear, 0, [torch.ao.quantization.default_qconfig]
             )
             .set_global(
                 [
-                    torch.quantization.default_qconfig,
-                    torch.quantization.default_dynamic_qconfig,
+                    torch.ao.quantization.default_qconfig,
+                    torch.ao.quantization.default_dynamic_qconfig,
                 ]
             )
         )
@@ -2409,11 +2409,11 @@ def test_qconfig_multi_mapping_end_to_end(self):
             QConfigMultiMapping()
             .set_global(
                 [
-                    torch.quantization.default_qconfig,
-                    torch.quantization.default_dynamic_qconfig,
+                    torch.ao.quantization.default_qconfig,
+                    torch.ao.quantization.default_dynamic_qconfig,
                 ]
             )
-            .set_module_name("fc2", [None, torch.quantization.default_qconfig])
+            .set_module_name("fc2", [None, torch.ao.quantization.default_qconfig])
         )
         self.assertEqual(
             qconfig_multi_mapping.qconfig_mappings_list[1].module_name_qconfigs["fc2"],
@@ -2434,10 +2434,10 @@ def test_qconfig_multi_mapping_from_list(self):
         example_input = m.get_example_inputs()
 
         qconfig_mappings_list = [
-            QConfigMapping().set_global(torch.quantization.default_qconfig),
+            QConfigMapping().set_global(torch.ao.quantization.default_qconfig),
             QConfigMapping()
-            .set_global(torch.quantization.default_dynamic_qconfig)
-            .set_module_name("fc2", torch.quantization.default_qconfig),
+            .set_global(torch.ao.quantization.default_dynamic_qconfig)
+            .set_module_name("fc2", torch.ao.quantization.default_qconfig),
         ]
 
         qconfig_multi_mapping = QConfigMultiMapping().from_list_qconfig_mapping(
@@ -2524,7 +2524,7 @@ def forward(self, x):
         example_inputs = (torch.randn(2, 2),)
 
         qconfig_mappings = QConfigMultiMapping().set_global(
-            [torch.quantization.default_qat_qconfig]
+            [torch.ao.quantization.default_qat_qconfig]
         )
 
         custom_tracer = torch.ao.quantization.quantize_fx.QuantizationTracer(
@@ -2600,7 +2600,7 @@ def forward(self, x):
                 x = F.linear(x, self.w4, self.b4)
                 return x
 
-        per_tensor_qconfig = torch.quantization.default_qconfig
+        per_tensor_qconfig = torch.ao.quantization.default_qconfig
 
         m = M().eval()
         example_input = (torch.randn(2, 2),)
diff --git a/test/quantization/fx/test_quantize_fx.py b/test/quantization/fx/test_quantize_fx.py
index 7309a76a8dd0cf..37a4790199f723 100644
--- a/test/quantization/fx/test_quantize_fx.py
+++ b/test/quantization/fx/test_quantize_fx.py
@@ -10,7 +10,7 @@
 import torch.ao.nn.quantized.dynamic as nnqd
 import torch.ao.nn.intrinsic as nni
 import torch.ao.nn.intrinsic.quantized as nniq
-import torch.nn.intrinsic.quantized.dynamic as nniqd
+import torch.ao.nn.intrinsic.quantized.dynamic as nniqd
 import torch.multiprocessing as mp
 
 # graph mode quantization based on fx
@@ -682,7 +682,7 @@ def forward(self, x):
         }
         m = prepare_fx(model, qconfig_dict, example_inputs=(torch.randn(1, 5),))
 
-        self.checkGraphModuleNodes(m, expected_node=ns.call_module(torch.nn.intrinsic.modules.fused.LinearReLU))
+        self.checkGraphModuleNodes(m, expected_node=ns.call_module(torch.ao.nn.intrinsic.modules.fused.LinearReLU))
 
     @unittest.skip("Temporarily skipping the test case, will enable after the simple"
                    "pattern format is supported")
@@ -5271,7 +5271,7 @@ def forward(self, x):
 
         mod = M()
 
-        qconfig_dict = {"": torch.quantization.get_default_qat_qconfig()}
+        qconfig_dict = {"": torch.ao.quantization.get_default_qat_qconfig()}
         prepare_custom_config_dict = {
             "non_traceable_module_class": [UnTraceableModuleClass],
             "non_traceable_module_name": ["untraceable_module_name"],
@@ -7003,7 +7003,7 @@ def forward(self, input):
         quantized_nodes = {
             # is_reference
             True: ns.call_module(torch.nn.PReLU),
-            False: ns.call_module(torch.nn.quantized.PReLU),
+            False: ns.call_module(torch.ao.nn.quantized.PReLU),
         }
 
         for num_parameter, quant_type, is_reference in options:
diff --git a/test/run_test.py b/test/run_test.py
index 778e3a0e30f9a4..2a990ed8b5192a 100755
--- a/test/run_test.py
+++ b/test/run_test.py
@@ -710,7 +710,7 @@ def run_doctests(test_module, test_directory, options):
     if enabled['qengine'] == 'auto':
         try:
             # Is there a better check if quantization is enabled?
-            import torch.nn.quantized as nnq  # NOQA
+            import torch.ao.nn.quantized as nnq  # NOQA
             torch.backends.quantized.engine = 'qnnpack'
             torch.backends.quantized.engine = 'fbgemm'
         except (ImportError, RuntimeError):
diff --git a/test/test_module_init.py b/test/test_module_init.py
index 98dcb3ee694a49..422363f748f2c2 100644
--- a/test/test_module_init.py
+++ b/test/test_module_init.py
@@ -185,9 +185,9 @@ def build_constructor_arg_db():
         torch.ao.nn.qat.EmbeddingBag: ((10, 12), {
             'qconfig': torch.ao.quantization.float_qparams_weight_only_qconfig,
         }),
-        torch.nn.quantizable.LSTM: ((5, 6), {}),
-        torch.nn.quantizable.LSTMCell: ((5, 6), {}),
-        torch.nn.quantizable.MultiheadAttention: ((10, 2), {}),
+        torch.ao.nn.quantizable.LSTM: ((5, 6), {}),
+        torch.ao.nn.quantizable.LSTMCell: ((5, 6), {}),
+        torch.ao.nn.quantizable.MultiheadAttention: ((10, 2), {}),
         torch.ao.nn.quantized.BatchNorm2d: ((2,), {}),
         torch.ao.nn.quantized.BatchNorm3d: ((2,), {}),
         torch.ao.nn.quantized.Dropout: ((), {}),
@@ -236,74 +236,74 @@ def build_constructor_arg_db():
         torch.ao.nn.quantized.FloatFunctional: ((), {}),
         torch.ao.nn.quantized.FXFloatFunctional: ((), {}),
         torch.ao.nn.quantized.QFunctional: ((), {}),
-        # Remove torch.nn.quantized after the migration completes:
-        torch.nn.qat.Conv1d: ((3, 3, 3), {
+        # Remove torch.ao.nn.quantized after the migration completes:
+        torch.ao.nn.qat.Conv1d: ((3, 3, 3), {
             'qconfig': torch.ao.quantization.default_qconfig,
         }),
-        torch.nn.qat.Conv2d: ((3, 3, 3), {
+        torch.ao.nn.qat.Conv2d: ((3, 3, 3), {
             'qconfig': torch.ao.quantization.default_qconfig,
         }),
-        torch.nn.qat.Conv3d: ((3, 3, 3), {
+        torch.ao.nn.qat.Conv3d: ((3, 3, 3), {
             'qconfig': torch.ao.quantization.default_qconfig,
         }),
-        torch.nn.qat.Linear: ((5, 2), {
+        torch.ao.nn.qat.Linear: ((5, 2), {
             'qconfig': torch.ao.quantization.default_qconfig,
         }),
-        torch.nn.qat.Embedding: ((10, 12), {
+        torch.ao.nn.qat.Embedding: ((10, 12), {
             'qconfig': torch.ao.quantization.float_qparams_weight_only_qconfig,
         }),
-        torch.nn.qat.EmbeddingBag: ((10, 12), {
+        torch.ao.nn.qat.EmbeddingBag: ((10, 12), {
             'qconfig': torch.ao.quantization.float_qparams_weight_only_qconfig,
         }),
-        torch.nn.quantized.BatchNorm2d: ((2,), {}),
-        torch.nn.quantized.BatchNorm3d: ((2,), {}),
-        torch.nn.quantized.Dropout: ((), {}),
-        torch.nn.quantized.Conv1d: ((3, 3, 3), {}),
-        torch.nn.quantized.Conv2d: ((3, 3, 3), {}),
-        torch.nn.quantized.Conv3d: ((3, 3, 3), {}),
-        torch.nn.quantized.ConvTranspose1d: ((3, 3, 3), {}),
-        torch.nn.quantized.ConvTranspose2d: ((3, 3, 3), {}),
-        torch.nn.quantized.ConvTranspose3d: ((16, 33, (3, 3, 5)), {
+        torch.ao.nn.quantized.BatchNorm2d: ((2,), {}),
+        torch.ao.nn.quantized.BatchNorm3d: ((2,), {}),
+        torch.ao.nn.quantized.Dropout: ((), {}),
+        torch.ao.nn.quantized.Conv1d: ((3, 3, 3), {}),
+        torch.ao.nn.quantized.Conv2d: ((3, 3, 3), {}),
+        torch.ao.nn.quantized.Conv3d: ((3, 3, 3), {}),
+        torch.ao.nn.quantized.ConvTranspose1d: ((3, 3, 3), {}),
+        torch.ao.nn.quantized.ConvTranspose2d: ((3, 3, 3), {}),
+        torch.ao.nn.quantized.ConvTranspose3d: ((16, 33, (3, 3, 5)), {
             'stride': (2, 1, 1),
             'padding': (4, 2, 2),
             'output_padding': (2, 2, 2),
             'dilation': (1, 1, 1),
         }),
-        torch.nn.quantized.DeQuantize: ((), {}),
-        torch.nn.quantized.ELU: ((0.01, 0), {}),
-        torch.nn.quantized.Embedding: ((10, 3), {
+        torch.ao.nn.quantized.DeQuantize: ((), {}),
+        torch.ao.nn.quantized.ELU: ((0.01, 0), {}),
+        torch.ao.nn.quantized.Embedding: ((10, 3), {
             'factory_kwargs': {},
         }),
-        torch.nn.quantized.EmbeddingBag: ((10, 3), {
+        torch.ao.nn.quantized.EmbeddingBag: ((10, 3), {
             'factory_kwargs': {},
         }),
-        torch.nn.quantized.GroupNorm: ((2, 4, torch.nn.Parameter(torch.tensor(2.)),
-                                        torch.nn.Parameter(torch.tensor(2.)), 0.1, 0), {}),
-        torch.nn.quantized.Hardswish: ((0.1, 0,), {}),
-        torch.nn.quantized.InstanceNorm1d: ((2, torch.nn.Parameter(torch.tensor(2.)),
-                                             torch.nn.Parameter(torch.tensor(2.)), 0.1, 0), {}),
-        torch.nn.quantized.InstanceNorm2d: ((2, torch.nn.Parameter(torch.tensor(2.)),
-                                             torch.nn.Parameter(torch.tensor(2.)), 0.1, 0), {}),
-        torch.nn.quantized.InstanceNorm3d: ((2, torch.nn.Parameter(torch.tensor(2.)),
-                                             torch.nn.Parameter(torch.tensor(2.)), 0.1, 0), {}),
-        torch.nn.quantized.LayerNorm: ((2, torch.nn.Parameter(torch.tensor(2.)),
-                                        torch.nn.Parameter(torch.tensor(2.)), 0.1, 0), {}),
-        torch.nn.quantized.LeakyReLU: ((0.01, 0), {}),
-        torch.nn.quantized.Linear: ((5, 2), {
+        torch.ao.nn.quantized.GroupNorm: ((2, 4, torch.nn.Parameter(torch.tensor(2.)),
+                                           torch.nn.Parameter(torch.tensor(2.)), 0.1, 0), {}),
+        torch.ao.nn.quantized.Hardswish: ((0.1, 0,), {}),
+        torch.ao.nn.quantized.InstanceNorm1d: ((2, torch.nn.Parameter(torch.tensor(2.)),
+                                                torch.nn.Parameter(torch.tensor(2.)), 0.1, 0), {}),
+        torch.ao.nn.quantized.InstanceNorm2d: ((2, torch.nn.Parameter(torch.tensor(2.)),
+                                                torch.nn.Parameter(torch.tensor(2.)), 0.1, 0), {}),
+        torch.ao.nn.quantized.InstanceNorm3d: ((2, torch.nn.Parameter(torch.tensor(2.)),
+                                                torch.nn.Parameter(torch.tensor(2.)), 0.1, 0), {}),
+        torch.ao.nn.quantized.LayerNorm: ((2, torch.nn.Parameter(torch.tensor(2.)),
+                                           torch.nn.Parameter(torch.tensor(2.)), 0.1, 0), {}),
+        torch.ao.nn.quantized.LeakyReLU: ((0.01, 0), {}),
+        torch.ao.nn.quantized.Linear: ((5, 2), {
             'factory_kwargs': {},
         }),
-        torch.nn.quantized.MaxPool2d: ((3,), {}),
-        torch.nn.quantized.PReLU: ((0.01, 0), {}),
-        torch.nn.quantized.Quantize: ((0.1, 0), {
+        torch.ao.nn.quantized.MaxPool2d: ((3,), {}),
+        torch.ao.nn.quantized.PReLU: ((0.01, 0), {}),
+        torch.ao.nn.quantized.Quantize: ((0.1, 0), {
             'dtype': torch.int16,
             'factory_kwargs': {},
         }),
-        torch.nn.quantized.ReLU6: ((), {}),
-        torch.nn.quantized.Sigmoid: ((0.1, 0), {}),
-        torch.nn.quantized.Softmax: ((), {}),
-        torch.nn.quantized.FloatFunctional: ((), {}),
-        torch.nn.quantized.FXFloatFunctional: ((), {}),
-        torch.nn.quantized.QFunctional: ((), {}),
+        torch.ao.nn.quantized.ReLU6: ((), {}),
+        torch.ao.nn.quantized.Sigmoid: ((0.1, 0), {}),
+        torch.ao.nn.quantized.Softmax: ((), {}),
+        torch.ao.nn.quantized.FloatFunctional: ((), {}),
+        torch.ao.nn.quantized.FXFloatFunctional: ((), {}),
+        torch.ao.nn.quantized.QFunctional: ((), {}),
     }
 
 
@@ -427,9 +427,9 @@ def generate_tests(test_cls, constructor_arg_db):
         torch.nn,
         torch.ao.nn.qat,
         torch.ao.nn.quantized,
-        torch.nn.qat,
-        torch.nn.quantizable,
-        torch.nn.quantized,
+        torch.ao.nn.qat,
+        torch.ao.nn.quantizable,
+        torch.ao.nn.quantized,
     ]
     # ...except these
     MODULES_TO_SKIP = {
@@ -440,10 +440,10 @@ def generate_tests(test_cls, constructor_arg_db):
         # See https://github.com/pytorch/pytorch/issues/55396
         torch.ao.nn.quantized.Embedding,
         torch.ao.nn.quantized.EmbeddingBag,
-        torch.nn.quantized.Embedding,
-        torch.nn.quantized.EmbeddingBag,
-        torch.nn.quantized.LSTM,
-        torch.nn.quantized.MultiheadAttention,
+        torch.ao.nn.quantized.Embedding,
+        torch.ao.nn.quantized.EmbeddingBag,
+        torch.ao.nn.quantized.LSTM,
+        torch.ao.nn.quantized.MultiheadAttention,
     }
     # no need to support kwargs for these modules even though
     # they have parameters / buffers because they are passed in
@@ -491,13 +491,13 @@ def generate_tests(test_cls, constructor_arg_db):
         torch.ao.nn.quantized.ConvTranspose3d,
         torch.ao.nn.quantized.Linear,
         # Remove the lines below after AO migration is complete
-        torch.nn.quantized.Conv1d,
-        torch.nn.quantized.Conv2d,
-        torch.nn.quantized.Conv3d,
-        torch.nn.quantized.ConvTranspose1d,
-        torch.nn.quantized.ConvTranspose2d,
-        torch.nn.quantized.ConvTranspose3d,
-        torch.nn.quantized.Linear,
+        torch.ao.nn.quantized.Conv1d,
+        torch.ao.nn.quantized.Conv2d,
+        torch.ao.nn.quantized.Conv3d,
+        torch.ao.nn.quantized.ConvTranspose1d,
+        torch.ao.nn.quantized.ConvTranspose2d,
+        torch.ao.nn.quantized.ConvTranspose3d,
+        torch.ao.nn.quantized.Linear,
     }
 
     for namespace in NAMESPACES:
diff --git a/torch/ao/nn/intrinsic/qat/modules/linear_relu.py b/torch/ao/nn/intrinsic/qat/modules/linear_relu.py
index 1c779658e38ef8..f10218da82c2c0 100644
--- a/torch/ao/nn/intrinsic/qat/modules/linear_relu.py
+++ b/torch/ao/nn/intrinsic/qat/modules/linear_relu.py
@@ -11,7 +11,7 @@ class LinearReLU(nnqat.Linear, nni._FusedModule):
 
     We adopt the same interface as :class:`torch.nn.Linear`.
 
-    Similar to `torch.nn.intrinsic.LinearReLU`, with FakeQuantize modules initialized to
+    Similar to `torch.ao.nn.intrinsic.LinearReLU`, with FakeQuantize modules initialized to
     default.
 
     Attributes:
@@ -45,4 +45,4 @@ def to_float(self):
         if self.bias is not None:
             linear.bias = torch.nn.Parameter(self.bias.detach())
         relu = torch.nn.ReLU()
-        return torch.nn.intrinsic.LinearReLU(linear, relu)
+        return torch.ao.nn.intrinsic.LinearReLU(linear, relu)
diff --git a/torch/ao/nn/intrinsic/quantized/modules/conv_relu.py b/torch/ao/nn/intrinsic/quantized/modules/conv_relu.py
index bd5f8800be2c4b..8374ea59895899 100644
--- a/torch/ao/nn/intrinsic/quantized/modules/conv_relu.py
+++ b/torch/ao/nn/intrinsic/quantized/modules/conv_relu.py
@@ -62,7 +62,7 @@ def from_float(cls, mod):
 
     @classmethod
     def from_reference(cls, ref_qconv, output_scale, output_zero_point):
-        assert type(ref_qconv) != torch.nn.intrinsic.ConvBnReLU1d, \
+        assert type(ref_qconv) != torch.ao.nn.intrinsic.ConvBnReLU1d, \
             "BatchNorm1d should be fused into Conv1d before converting to reference module"
         return super().from_reference(ref_qconv[0], output_scale, output_zero_point)
 
@@ -111,7 +111,7 @@ def from_float(cls, mod):
 
     @classmethod
     def from_reference(cls, ref_qconv, output_scale, output_zero_point):
-        assert type(ref_qconv) != torch.nn.intrinsic.ConvBnReLU2d, \
+        assert type(ref_qconv) != torch.ao.nn.intrinsic.ConvBnReLU2d, \
             "BatchNorm2d should be fused into Conv2d before converting to reference module"
         return super().from_reference(ref_qconv[0], output_scale, output_zero_point)
 
@@ -167,6 +167,6 @@ def from_float(cls, mod):
 
     @classmethod
     def from_reference(cls, ref_qconv, output_scale, output_zero_point):
-        assert type(ref_qconv) != torch.nn.intrinsic.ConvBnReLU3d, \
+        assert type(ref_qconv) != torch.ao.nn.intrinsic.ConvBnReLU3d, \
             "BatchNorm3d should be fused into Conv3d before converting to reference module"
         return super().from_reference(ref_qconv[0], output_scale, output_zero_point)
diff --git a/torch/ao/nn/intrinsic/quantized/modules/linear_relu.py b/torch/ao/nn/intrinsic/quantized/modules/linear_relu.py
index 1945a0447c15b2..9c3a7bcd3b4a0c 100644
--- a/torch/ao/nn/intrinsic/quantized/modules/linear_relu.py
+++ b/torch/ao/nn/intrinsic/quantized/modules/linear_relu.py
@@ -51,9 +51,9 @@ class LinearLeakyReLU(nnq.Linear):
     r"""
     For onednn backend only
     A LinearLeakyReLU module fused from Linear and LeakyReLU modules
-    We adopt the same interface as :class:`torch.nn.quantized.Linear`.
+    We adopt the same interface as :class:`torch.ao.nn.quantized.Linear`.
     Attributes:
-        Same as torch.nn.quantized.Linear
+        Same as torch.ao.nn.quantized.Linear
         + negative_slope
     Examples::
         >>> # xdoctest: +SKIP
diff --git a/torch/ao/nn/quantizable/modules/activation.py b/torch/ao/nn/quantizable/modules/activation.py
index 9290e9750d8fd4..d51b883f039f6d 100644
--- a/torch/ao/nn/quantizable/modules/activation.py
+++ b/torch/ao/nn/quantizable/modules/activation.py
@@ -51,7 +51,7 @@ class MultiheadAttention(nn.MultiheadAttention):
 
     Examples::
 
-        >>> import torch.nn.quantizable as nnqa
+        >>> import torch.ao.nn.quantizable as nnqa
         >>> multihead_attn = nnqa.MultiheadAttention(embed_dim, num_heads)
         >>> attn_output, attn_output_weights = multihead_attn(query, key, value)
 
@@ -77,8 +77,8 @@ def __init__(self, embed_dim: int, num_heads: int,
         self.out_proj = nn.Linear(self.embed_dim, self.embed_dim, bias=bias, **factory_kwargs)  # type: ignore[assignment]
 
         # Functionals
-        self.q_scaling_product = torch.nn.quantized.FloatFunctional()
-        # note: importing torch.nn.quantized at top creates a circular import
+        self.q_scaling_product = torch.ao.nn.quantized.FloatFunctional()
+        # note: importing torch.ao.nn.quantized at top creates a circular import
 
         # Quant/Dequant
         self.quant_attn_output = torch.ao.quantization.QuantStub()
diff --git a/torch/ao/nn/quantizable/modules/rnn.py b/torch/ao/nn/quantizable/modules/rnn.py
index a262fe704f37fd..bb161fd80f3864 100644
--- a/torch/ao/nn/quantizable/modules/rnn.py
+++ b/torch/ao/nn/quantizable/modules/rnn.py
@@ -22,7 +22,7 @@ class LSTMCell(torch.nn.Module):
 
     Examples::
 
-        >>> import torch.nn.quantizable as nnqa
+        >>> import torch.ao.nn.quantizable as nnqa
         >>> rnn = nnqa.LSTMCell(10, 20)
         >>> input = torch.randn(6, 10)
         >>> hx = torch.randn(3, 20)
@@ -272,7 +272,7 @@ class LSTM(torch.nn.Module):
 
     Examples::
 
-        >>> import torch.nn.quantizable as nnqa
+        >>> import torch.ao.nn.quantizable as nnqa
         >>> rnn = nnqa.LSTM(10, 20, 2)
         >>> input = torch.randn(5, 3, 10)
         >>> h0 = torch.randn(2, 3, 20)
diff --git a/torch/ao/nn/quantized/dynamic/modules/conv.py b/torch/ao/nn/quantized/dynamic/modules/conv.py
index c06a39cad7b8e2..3d1f816728f2ca 100644
--- a/torch/ao/nn/quantized/dynamic/modules/conv.py
+++ b/torch/ao/nn/quantized/dynamic/modules/conv.py
@@ -20,7 +20,7 @@ class Conv1d(nnq.Conv1d):
     r"""A dynamically quantized conv module with floating point tensors as inputs and outputs.
 
     For details on input arguments, parameters, and implementation see
-    :class:`~torch.nn.Conv1d` and :class:`~torch.nn.quantized.dynamic.Conv1d` and
+    :class:`~torch.nn.Conv1d` and :class:`~torch.ao.nn.quantized.dynamic.Conv1d` and
 
     Attributes:
         weight (Tensor):     packed tensor derived from the learnable weight
@@ -91,7 +91,7 @@ class Conv2d(nnq.Conv2d):
     r"""A dynamically quantized conv module with floating point tensors as inputs and outputs.
 
     For details on input arguments, parameters, and implementation see
-    :class:`~torch.nn.Conv2d` and :class:`~torch.nn.quantized.dynamic.Conv2d` and
+    :class:`~torch.nn.Conv2d` and :class:`~torch.ao.nn.quantized.dynamic.Conv2d` and
 
     Attributes:
         weight (Tensor):     packed tensor derived from the learnable weight
@@ -156,7 +156,7 @@ class Conv3d(nnq.Conv3d):
     r"""A dynamically quantized conv module with floating point tensors as inputs and outputs.
 
     For details on input arguments, parameters, and implementation see
-    :class:`~torch.nn.Conv3d` and :class:`~torch.nn.quantized.dynamic.Conv3d` and
+    :class:`~torch.nn.Conv3d` and :class:`~torch.ao.nn.quantized.dynamic.Conv3d` and
 
     Attributes:
         weight (Tensor):     packed tensor derived from the learnable weight
@@ -223,7 +223,7 @@ class ConvTranspose1d(nnq.ConvTranspose1d):
     For details on input arguments, parameters, and implementation see
     :class:`~torch.nn.ConvTranspose1d`.
 
-    For special notes, please, see :class:`~torch.nn.quantized.dynamic.Conv1d`
+    For special notes, please, see :class:`~torch.ao.nn.quantized.dynamic.Conv1d`
 
     Attributes:
         weight (Tensor):     packed tensor derived from the learnable weight
@@ -284,7 +284,7 @@ class ConvTranspose2d(nnq.ConvTranspose2d):
     For details on input arguments, parameters, and implementation see
     :class:`~torch.nn.ConvTranspose2d`.
 
-    For special notes, please, see :class:`~torch.nn.quantized.dynamic.Conv2d`
+    For special notes, please, see :class:`~torch.ao.nn.quantized.dynamic.Conv2d`
 
     Attributes:
         weight (Tensor):     packed tensor derived from the learnable weight
@@ -345,7 +345,7 @@ class ConvTranspose3d(nnq.ConvTranspose3d):
     For details on input arguments, parameters, and implementation see
     :class:`~torch.nn.ConvTranspose3d`.
 
-    For special notes, please, see :class:`~torch.nn.quantized.dynamic.Conv3d`
+    For special notes, please, see :class:`~torch.ao.nn.quantized.dynamic.Conv3d`
 
     Attributes:
         weight (Tensor):     packed tensor derived from the learnable weight
diff --git a/torch/ao/nn/quantized/dynamic/modules/linear.py b/torch/ao/nn/quantized/dynamic/modules/linear.py
index c82f888aee33cd..b723358c6ab5cd 100644
--- a/torch/ao/nn/quantized/dynamic/modules/linear.py
+++ b/torch/ao/nn/quantized/dynamic/modules/linear.py
@@ -87,7 +87,7 @@ def from_float(cls, mod):
                           utilities or provided by the user
         """
         float_modules = [torch.nn.Linear, torch.nn.modules.linear.NonDynamicallyQuantizableLinear,
-                         torch.nn.intrinsic.modules.fused.LinearReLU, torch.ao.nn.qat.dynamic.Linear]
+                         torch.ao.nn.intrinsic.modules.fused.LinearReLU, torch.ao.nn.qat.dynamic.Linear]
 
         assert type(mod) in float_modules, \
             'nn.quantized.dynamic.Linear.from_float only works for one of' + \
diff --git a/torch/ao/nn/quantized/functional.py b/torch/ao/nn/quantized/functional.py
index fac6326d2345b0..72218184fcfacc 100644
--- a/torch/ao/nn/quantized/functional.py
+++ b/torch/ao/nn/quantized/functional.py
@@ -552,7 +552,7 @@ def upsample(input, size=None, scale_factor=None, mode='nearest', align_corners=
 
     .. warning::
         This function is deprecated in favor of
-        :func:`torch.nn.quantized.functional.interpolate`.
+        :func:`torch.ao.nn.quantized.functional.interpolate`.
         This is equivalent with ``nn.quantized.functional.interpolate(...)``.
 
     See :func:`torch.nn.functional.interpolate` for implementation details.
@@ -604,7 +604,7 @@ def upsample_bilinear(input, size=None, scale_factor=None):
 
     .. warning::
         This function is deprecated in favor of
-        :func:`torch.nn.quantized.functional.interpolate`.
+        :func:`torch.ao.nn.quantized.functional.interpolate`.
         This is equivalent with
         ``nn.quantized.functional.interpolate(..., mode='bilinear', align_corners=True)``.
 
@@ -626,7 +626,7 @@ def upsample_nearest(input, size=None, scale_factor=None):
 
     .. warning::
         This function is deprecated in favor of
-        :func:`torch.nn.quantized.functional.interpolate`.
+        :func:`torch.ao.nn.quantized.functional.interpolate`.
         This is equivalent with ``nn.quantized.functional.interpolate(..., mode='nearest')``.
 
     .. note:: The input quantization parameters propagate to the output.
diff --git a/torch/ao/nn/quantized/modules/conv.py b/torch/ao/nn/quantized/modules/conv.py
index 24ae02fbcdeff6..e7eb90b06d8ccc 100644
--- a/torch/ao/nn/quantized/modules/conv.py
+++ b/torch/ao/nn/quantized/modules/conv.py
@@ -678,7 +678,7 @@ class ConvTranspose1d(_ConvTransposeNd):
     .. note:: Currently only the QNNPACK engine is implemented.
         Please, set the `torch.backends.quantized.engine = 'qnnpack'`
 
-    For special notes, please, see :class:`~torch.nn.quantized.Conv1d`
+    For special notes, please, see :class:`~torch.ao.nn.quantized.Conv1d`
 
     Attributes:
         weight (Tensor):     packed tensor derived from the learnable weight
@@ -691,7 +691,7 @@ class ConvTranspose1d(_ConvTransposeNd):
 
         >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE)
         >>> torch.backends.quantized.engine = 'qnnpack'
-        >>> from torch.nn import quantized as nnq
+        >>> from torch.ao.nn import quantized as nnq
         >>> # With square kernels and equal stride
         >>> m = nnq.ConvTranspose1d(16, 33, 3, stride=2)
         >>> # non-square kernels and unequal stride and with padding
@@ -768,7 +768,7 @@ class ConvTranspose2d(_ConvTransposeNd):
     For details on input arguments, parameters, and implementation see
     :class:`~torch.nn.ConvTranspose2d`.
 
-    For special notes, please, see :class:`~torch.nn.quantized.Conv2d`
+    For special notes, please, see :class:`~torch.ao.nn.quantized.Conv2d`
 
     Attributes:
         weight (Tensor):     packed tensor derived from the learnable weight
@@ -783,7 +783,7 @@ class ConvTranspose2d(_ConvTransposeNd):
         >>> # QNNPACK or FBGEMM as backend
         >>> torch.backends.quantized.engine = 'qnnpack'
         >>> # With square kernels and equal stride
-        >>> import torch.nn.quantized as nnq
+        >>> import torch.ao.nn.quantized as nnq
         >>> m = nnq.ConvTranspose2d(16, 33, 3, stride=2)
         >>> # non-square kernels and unequal stride and with padding
         >>> m = nnq.ConvTranspose2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2))
@@ -862,7 +862,7 @@ class ConvTranspose3d(_ConvTransposeNd):
     .. note:: Currently only the FBGEMM engine is implemented.
         Please, set the `torch.backends.quantized.engine = 'fbgemm'`
 
-    For special notes, please, see :class:`~torch.nn.quantized.Conv3d`
+    For special notes, please, see :class:`~torch.ao.nn.quantized.Conv3d`
 
     Attributes:
         weight (Tensor):     packed tensor derived from the learnable weight
@@ -875,7 +875,7 @@ class ConvTranspose3d(_ConvTransposeNd):
 
         >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE)
         >>> torch.backends.quantized.engine = 'fbgemm'
-        >>> from torch.nn import quantized as nnq
+        >>> from torch.ao.nn import quantized as nnq
         >>> # With cubic kernels and equal stride
         >>> m = nnq.ConvTranspose3d(16, 33, 3, stride=2)
         >>> # non-cubic kernels and unequal stride and with padding
diff --git a/torch/ao/nn/quantized/modules/rnn.py b/torch/ao/nn/quantized/modules/rnn.py
index 732b4a6a773f0c..25551c5b6d420c 100644
--- a/torch/ao/nn/quantized/modules/rnn.py
+++ b/torch/ao/nn/quantized/modules/rnn.py
@@ -14,7 +14,7 @@ class LSTM(torch.ao.nn.quantizable.LSTM):
 
     .. note::
         To access the weights and biases, you need to access them per layer.
-        See examples in :class:`~torch.nn.quantizable.LSTM`
+        See examples in :class:`~torch.ao.nn.quantizable.LSTM`
 
     Examples::
         >>> # xdoctest: +SKIP
@@ -29,7 +29,7 @@ class LSTM(torch.ao.nn.quantizable.LSTM):
         >>> tq.prepare(model, prepare_custom_module_class=custom_module_config)
         >>> tq.convert(model, convert_custom_module_class=custom_module_config)
     """
-    _FLOAT_MODULE = torch.nn.quantizable.LSTM  # type: ignore[assignment]
+    _FLOAT_MODULE = torch.ao.nn.quantizable.LSTM  # type: ignore[assignment]
 
     def _get_name(self):
         return 'QuantizedLSTM'
diff --git a/torch/ao/nn/sparse/quantized/dynamic/linear.py b/torch/ao/nn/sparse/quantized/dynamic/linear.py
index 7eac81f1814d00..87d174db8098ac 100644
--- a/torch/ao/nn/sparse/quantized/dynamic/linear.py
+++ b/torch/ao/nn/sparse/quantized/dynamic/linear.py
@@ -1,7 +1,7 @@
 from typing import Optional
 
 import torch
-import torch.nn.intrinsic as nni
+import torch.ao.nn.intrinsic as nni
 
 from torch.ao.nn.sparse.quantized import linear
 from torch.ao.nn.sparse.quantized.utils import LinearBlockSparsePattern
diff --git a/torch/ao/ns/_numeric_suite_fx.py b/torch/ao/ns/_numeric_suite_fx.py
index 49e08c8bdc1533..b7065c2a4c090e 100644
--- a/torch/ao/ns/_numeric_suite_fx.py
+++ b/torch/ao/ns/_numeric_suite_fx.py
@@ -4,11 +4,11 @@
 
     import copy
     import torch
-    import torch.quantization.quantize_fx as quantize_fx
+    import torch.ao.quantization.quantize_fx as quantize_fx
     import torch.ao.ns._numeric_suite_fx as ns
 
     m = torch.nn.Sequential(torch.nn.Conv2d(1, 1, 1)).eval()
-    mp = quantize_fx.prepare_fx(m, {'': torch.quantization.default_qconfig})
+    mp = quantize_fx.prepare_fx(m, {'': torch.ao.quantization.default_qconfig})
     # We convert a copy because we need the original prepared model
     # to be available for comparisons, and `quantize_fx.convert_fx` is inplace.
     mq = quantize_fx.convert_fx(copy.deepcopy(mp))
diff --git a/torch/ao/ns/fx/mappings.py b/torch/ao/ns/fx/mappings.py
index dd670dce7ed7b7..3000f90a22e6b7 100644
--- a/torch/ao/ns/fx/mappings.py
+++ b/torch/ao/ns/fx/mappings.py
@@ -8,7 +8,7 @@
 import torch.ao.nn.quantized as nnq
 import torch.ao.nn.quantized.dynamic as nnqd
 import torch.ao.nn.intrinsic.quantized as nniq
-import torch.nn.intrinsic.quantized.dynamic as nniqd
+import torch.ao.nn.intrinsic.quantized.dynamic as nniqd
 import torch.ao.nn.intrinsic.qat as nniqat
 import torch.ao.nn.intrinsic as nni
 import torch.ao.nn.qat as nnqat
diff --git a/torch/ao/ns/fx/utils.py b/torch/ao/ns/fx/utils.py
index db42c38abd44fa..8d6f54ef9c148f 100644
--- a/torch/ao/ns/fx/utils.py
+++ b/torch/ao/ns/fx/utils.py
@@ -3,7 +3,7 @@
 
 import torch
 import torch.nn as nn
-import torch.nn.intrinsic.quantized as nniq
+import torch.ao.nn.intrinsic.quantized as nniq
 import torch.ao.nn.quantized as nnq
 
 toq = torch.ops.quantized
diff --git a/torch/ao/ns/fx/weight_utils.py b/torch/ao/ns/fx/weight_utils.py
index e02d464a1fb7f2..aeeb1c3ee70459 100644
--- a/torch/ao/ns/fx/weight_utils.py
+++ b/torch/ao/ns/fx/weight_utils.py
@@ -5,8 +5,8 @@
 import torch.ao.nn.quantized as nnq
 import torch.ao.nn.intrinsic.qat as nniqat
 import torch.ao.nn.qat as nnqat
-import torch.nn.intrinsic as nni
-import torch.nn.intrinsic.quantized as nniq
+import torch.ao.nn.intrinsic as nni
+import torch.ao.nn.intrinsic.quantized as nniq
 toq = torch.ops.quantized
 from torch.fx import GraphModule
 from torch.fx.graph import Node
diff --git a/torch/ao/pruning/_experimental/data_sparsifier/quantization_utils.py b/torch/ao/pruning/_experimental/data_sparsifier/quantization_utils.py
index 8e79cedbb8eae5..1a2791c359b6e5 100644
--- a/torch/ao/pruning/_experimental/data_sparsifier/quantization_utils.py
+++ b/torch/ao/pruning/_experimental/data_sparsifier/quantization_utils.py
@@ -85,16 +85,16 @@ def post_training_sparse_quantize(model,
         for _, emb_module in embedding_modules:
             emb_module.qconfig = torch.ao.quantization.float_qparams_weight_only_qconfig
 
-        torch.quantization.prepare(model, inplace=True)
-        torch.quantization.convert(model, inplace=True)
+        torch.ao.quantization.prepare(model, inplace=True)
+        torch.ao.quantization.convert(model, inplace=True)
 
     else:
         # quantize
         for _, emb_module in embedding_modules:
             emb_module.qconfig = torch.ao.quantization.float_qparams_weight_only_qconfig
 
-        torch.quantization.prepare(model, inplace=True)
-        torch.quantization.convert(model, inplace=True)
+        torch.ao.quantization.prepare(model, inplace=True)
+        torch.ao.quantization.convert(model, inplace=True)
 
         # retrieve scale & zero_points
         quantize_params: Dict[str, Dict] = {'scales': {}, 'zero_points': {},
diff --git a/torch/ao/quantization/_equalize.py b/torch/ao/quantization/_equalize.py
index b15ffc65b7ad19..519d33118086e0 100644
--- a/torch/ao/quantization/_equalize.py
+++ b/torch/ao/quantization/_equalize.py
@@ -16,7 +16,7 @@
 ]
 
 _supported_types = {torch.nn.Conv2d, torch.nn.Linear}
-_supported_intrinsic_types = {torch.nn.intrinsic.ConvReLU2d, torch.nn.intrinsic.LinearReLU}
+_supported_intrinsic_types = {torch.ao.nn.intrinsic.ConvReLU2d, torch.ao.nn.intrinsic.LinearReLU}
 _all_supported_types = _supported_types.union(_supported_intrinsic_types)
 
 def set_module_weight(module, weight) -> None:
diff --git a/torch/ao/quantization/backend_config/_common_operator_config_utils.py b/torch/ao/quantization/backend_config/_common_operator_config_utils.py
index 44f2d8bafe6b00..3a1d597641a372 100644
--- a/torch/ao/quantization/backend_config/_common_operator_config_utils.py
+++ b/torch/ao/quantization/backend_config/_common_operator_config_utils.py
@@ -3,9 +3,9 @@
 import torch
 import torch.nn.functional as F
 import torch.nn as nn
-import torch.nn.intrinsic as nni
+import torch.ao.nn.intrinsic as nni
 import torch.ao.nn.intrinsic.qat as nniqat
-import torch.nn.qat as nnqat
+import torch.ao.nn.qat as nnqat
 import torch.ao.nn.quantized.reference as nnqr
 from collections import namedtuple
 from typing import Callable, Dict, List, Union
diff --git a/torch/ao/quantization/backend_config/executorch.py b/torch/ao/quantization/backend_config/executorch.py
index 965f1627ce9e0a..98a8ca6a7e4f1a 100644
--- a/torch/ao/quantization/backend_config/executorch.py
+++ b/torch/ao/quantization/backend_config/executorch.py
@@ -6,8 +6,8 @@
 import torch
 import torch.nn.functional as F
 import torch.nn as nn
-import torch.nn.qat as nnqat
-import torch.nn.quantized._reference as nnqr
+import torch.ao.nn.qat as nnqat
+import torch.ao.nn.quantized.reference as nnqr
 from .backend_config import (
     BackendConfig,
     BackendPatternConfig,
diff --git a/torch/ao/quantization/backend_config/onednn.py b/torch/ao/quantization/backend_config/onednn.py
index 6831af7a42d051..6a896608c9b5a8 100644
--- a/torch/ao/quantization/backend_config/onednn.py
+++ b/torch/ao/quantization/backend_config/onednn.py
@@ -2,7 +2,7 @@
 import torch.nn as nn
 import torch.ao.nn.intrinsic as nni
 import torch.nn.functional as F
-import torch.nn.quantized._reference as nnqr
+import torch.ao.nn.quantized.reference as nnqr
 from ._common_operator_config_utils import (
     _get_conv_configs,
     _get_linear_configs,
diff --git a/torch/ao/quantization/experimental/linear.py b/torch/ao/quantization/experimental/linear.py
index 92cf96aa5c800f..240e708bc5ecda 100644
--- a/torch/ao/quantization/experimental/linear.py
+++ b/torch/ao/quantization/experimental/linear.py
@@ -1,7 +1,7 @@
 import torch
 import numpy as np
 
-from torch.nn.quantized.modules.utils import WeightedQuantizedModule
+from torch.ao.nn.quantized.modules.utils import WeightedQuantizedModule
 from torch.ao.quantization.experimental.observer import APoTObserver
 from torch.ao.quantization.experimental.quantizer import quantize_APoT
 
diff --git a/torch/ao/quantization/fuser_method_mappings.py b/torch/ao/quantization/fuser_method_mappings.py
index 9d6455d7b0d467..03ee38d339fbfb 100644
--- a/torch/ao/quantization/fuser_method_mappings.py
+++ b/torch/ao/quantization/fuser_method_mappings.py
@@ -1,5 +1,5 @@
 import torch.nn as nn
-import torch.nn.intrinsic as nni
+import torch.ao.nn.intrinsic as nni
 
 from typing import Union, Callable, Tuple, Dict, Optional, Type
 from torch.ao.quantization.utils import Pattern, get_combined_dict, MatchAllNode
diff --git a/torch/ao/quantization/fx/_equalize.py b/torch/ao/quantization/fx/_equalize.py
index af0b79835d7d81..0328513c03433a 100644
--- a/torch/ao/quantization/fx/_equalize.py
+++ b/torch/ao/quantization/fx/_equalize.py
@@ -6,7 +6,7 @@
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-import torch.nn.intrinsic as nni
+import torch.ao.nn.intrinsic as nni
 from torch.fx import GraphModule
 from torch.fx.graph import Node
 
diff --git a/torch/ao/quantization/fx/_lower_to_native_backend.py b/torch/ao/quantization/fx/_lower_to_native_backend.py
index 51e9b7e477c423..369edb2d8bf96f 100644
--- a/torch/ao/quantization/fx/_lower_to_native_backend.py
+++ b/torch/ao/quantization/fx/_lower_to_native_backend.py
@@ -5,7 +5,7 @@
 import torch.nn.functional as F
 import torch.ao.nn.intrinsic as nni
 import torch.ao.nn.intrinsic.quantized as nniq
-import torch.nn.intrinsic.quantized.dynamic as nniqd
+import torch.ao.nn.intrinsic.quantized.dynamic as nniqd
 import torch.ao.nn.quantized as nnq
 import torch.ao.nn.quantized.dynamic as nnqd
 import torch.ao.nn.quantized.reference as nnqr
@@ -86,8 +86,8 @@ def is_default_node(node, modules):
         torch.nn.PReLU,
         torch.nn.BatchNorm2d,
         torch.nn.BatchNorm3d,
-        torch.nn.intrinsic.BNReLU2d,
-        torch.nn.intrinsic.BNReLU3d,
+        torch.ao.nn.intrinsic.BNReLU2d,
+        torch.ao.nn.intrinsic.BNReLU3d,
     ]
     return _is_node_in_list(node, modules, func_list, method_list, module_type_list)
 
diff --git a/torch/ao/quantization/fx/_model_report/detector.py b/torch/ao/quantization/fx/_model_report/detector.py
index b47f24ece078c7..dc538cdd055757 100644
--- a/torch/ao/quantization/fx/_model_report/detector.py
+++ b/torch/ao/quantization/fx/_model_report/detector.py
@@ -2,7 +2,7 @@
 
 import torch
 import torch.nn as nn
-import torch.nn.qat as nnqat
+import torch.ao.nn.qat as nnqat
 from abc import ABC, abstractmethod
 from torch.ao.quantization.fake_quantize import FakeQuantize
 from torch.ao.quantization.fx.graph_module import GraphModule
diff --git a/torch/ao/quantization/fx/convert.py b/torch/ao/quantization/fx/convert.py
index ac96c9e80b0225..64ac72ccad4245 100644
--- a/torch/ao/quantization/fx/convert.py
+++ b/torch/ao/quantization/fx/convert.py
@@ -698,7 +698,7 @@ def convert_weighted_module(
     fused_module = None
     float_module = original_module
     # extract the inidividual float_module and fused module
-    if isinstance(original_module, torch.nn.intrinsic._FusedModule):
+    if isinstance(original_module, torch.ao.nn.intrinsic._FusedModule):
         fused_module = float_module
         float_module = fused_module[0]  # type: ignore[index]
 
diff --git a/torch/ao/quantization/fx/qconfig_mapping_utils.py b/torch/ao/quantization/fx/qconfig_mapping_utils.py
index d6399be66a6c12..15d2a94b830402 100644
--- a/torch/ao/quantization/fx/qconfig_mapping_utils.py
+++ b/torch/ao/quantization/fx/qconfig_mapping_utils.py
@@ -21,7 +21,7 @@
 from torch.fx.graph import (
     Graph,
 )
-from torch.nn.intrinsic import _FusedModule
+from torch.ao.nn.intrinsic import _FusedModule
 
 from ..utils import (
     _parent_name,
diff --git a/torch/ao/quantization/fx/quantize_handler.py b/torch/ao/quantization/fx/quantize_handler.py
index be611a31554185..57e3c97411a506 100644
--- a/torch/ao/quantization/fx/quantize_handler.py
+++ b/torch/ao/quantization/fx/quantize_handler.py
@@ -148,7 +148,7 @@ def _get_pattern_to_quantize_handlers(backend_config: BackendConfig) -> Dict[Pat
                 num_tensor_args_to_observation_type)
     return pattern_to_quantize_handlers
 
-# TODO: remove this class, this is still exposed in torch.quantization
+# TODO: remove this class, this is still exposed in torch.ao.quantization
 # but we should be able to break bc
 class BinaryOpQuantizeHandler(QuantizeHandler):
     pass
@@ -194,10 +194,10 @@ class CopyNodeQuantizeHandler(QuantizeHandler):
 class GeneralTensorShapeOpQuantizeHandler(QuantizeHandler):
     pass
 
-# TODO: not used, can be removed after torch.quantization namespace is deprecated
+# TODO: not used, can be removed after torch.ao.quantization namespace is deprecated
 class CustomModuleQuantizeHandler(QuantizeHandler):
     pass
 
-# TODO: not used, can be removed after torch.quantization namespace is deprecated
+# TODO: not used, can be removed after torch.ao.quantization namespace is deprecated
 class StandaloneModuleQuantizeHandler(QuantizeHandler):
     pass
diff --git a/torch/ao/quantization/fx/tracer.py b/torch/ao/quantization/fx/tracer.py
index d372c6c06c0add..47f326caf7043f 100644
--- a/torch/ao/quantization/fx/tracer.py
+++ b/torch/ao/quantization/fx/tracer.py
@@ -1,7 +1,7 @@
 import torch
 from torch.fx._symbolic_trace import Tracer
 from torch.fx.proxy import Scope
-from torch.nn.intrinsic import _FusedModule
+from torch.ao.nn.intrinsic import _FusedModule
 from typing import List, Callable
 
 __all__ = [
diff --git a/torch/ao/quantization/quantize.py b/torch/ao/quantization/quantize.py
index d766990814b7c9..3b59b133ba9e19 100644
--- a/torch/ao/quantization/quantize.py
+++ b/torch/ao/quantization/quantize.py
@@ -5,7 +5,7 @@
 import torch
 import torch.nn as nn
 import torch.ao.nn.quantized as nnq
-from torch.nn.intrinsic import _FusedModule
+from torch.ao.nn.intrinsic import _FusedModule
 
 from torch.ao.quantization.quantization_mappings import (
     get_default_dynamic_quant_module_mappings,
diff --git a/torch/ao/quantization/quantize_fx.py b/torch/ao/quantization/quantize_fx.py
index 7fd5a9fc634300..8be3e593ba678f 100644
--- a/torch/ao/quantization/quantize_fx.py
+++ b/torch/ao/quantization/quantize_fx.py
@@ -193,7 +193,7 @@ def fuse_fx(
     backend_config: Union[BackendConfig, Dict[str, Any], None] = None,
 ) -> GraphModule:
     r""" Fuse modules like conv+bn, conv+bn+relu etc, model must be in eval mode.
-    Fusion rules are defined in torch.quantization.fx.fusion_pattern.py
+    Fusion rules are defined in torch.ao.quantization.fx.fusion_pattern.py
 
     Args:
 
diff --git a/torch/distributed/algorithms/ddp_comm_hooks/quantization_hooks.py b/torch/distributed/algorithms/ddp_comm_hooks/quantization_hooks.py
index aaa0b9455ee82c..e6afe5b831a313 100644
--- a/torch/distributed/algorithms/ddp_comm_hooks/quantization_hooks.py
+++ b/torch/distributed/algorithms/ddp_comm_hooks/quantization_hooks.py
@@ -68,7 +68,7 @@ def quantization_pertensor_hook(
 
     tensor = bucket.buffer()
 
-    myObserver = torch.quantization.MinMaxObserver().cuda(tensor.device)
+    myObserver = torch.ao.quantization.MinMaxObserver().cuda(tensor.device)
     myObserver(tensor)
 
     s, z = myObserver.calculate_qparams()
@@ -159,7 +159,7 @@ def quantization_perchannel_hook(
         .cuda(tensor.device)
     )
 
-    myPerChannelObserver = torch.quantization.PerChannelMinMaxObserver().cuda(
+    myPerChannelObserver = torch.ao.quantization.PerChannelMinMaxObserver().cuda(
         tensor.device
     )
     myPerChannelObserver(tensor_in_channels)
diff --git a/torch/quantization/fuse_modules.py b/torch/quantization/fuse_modules.py
index 896f3571aaa79c..55bd8363524bae 100644
--- a/torch/quantization/fuse_modules.py
+++ b/torch/quantization/fuse_modules.py
@@ -12,8 +12,8 @@
 from torch.ao.quantization.fuse_modules import get_fuser_method
 
 # for backward compatiblity
-from torch.quantization.fuser_method_mappings import fuse_conv_bn
-from torch.quantization.fuser_method_mappings import fuse_conv_bn_relu
+from torch.ao.quantization.fuser_method_mappings import fuse_conv_bn
+from torch.ao.quantization.fuser_method_mappings import fuse_conv_bn_relu
 
 # TODO: These functions are not used outside the `fuse_modules.py`
 #       Keeping here for now, need to remove them later.
diff --git a/torch/quantization/fx/pattern_utils.py b/torch/quantization/fx/pattern_utils.py
index 8dec26d45a19ff..d528f42a493760 100644
--- a/torch/quantization/fx/pattern_utils.py
+++ b/torch/quantization/fx/pattern_utils.py
@@ -16,11 +16,11 @@
 )
 
 # QuantizeHandler.__module__ = _NAMESPACE
-_register_fusion_pattern.__module__ = "torch.quantization.fx.pattern_utils"
-get_default_fusion_patterns.__module__ = "torch.quantization.fx.pattern_utils"
-_register_quant_pattern.__module__ = "torch.quantization.fx.pattern_utils"
-get_default_quant_patterns.__module__ = "torch.quantization.fx.pattern_utils"
-get_default_output_activation_post_process_map.__module__ = "torch.quantization.fx.pattern_utils"
+_register_fusion_pattern.__module__ = "torch.ao.quantization.fx.pattern_utils"
+get_default_fusion_patterns.__module__ = "torch.ao.quantization.fx.pattern_utils"
+_register_quant_pattern.__module__ = "torch.ao.quantization.fx.pattern_utils"
+get_default_quant_patterns.__module__ = "torch.ao.quantization.fx.pattern_utils"
+get_default_output_activation_post_process_map.__module__ = "torch.ao.quantization.fx.pattern_utils"
 
 # __all__ = [
 #     "QuantizeHandler",
diff --git a/torch/quantization/fx/quantization_patterns.py b/torch/quantization/fx/quantization_patterns.py
index 6177e9bd04b818..50bfa0bfbe8e48 100644
--- a/torch/quantization/fx/quantization_patterns.py
+++ b/torch/quantization/fx/quantization_patterns.py
@@ -23,17 +23,17 @@
     StandaloneModuleQuantizeHandler
 )
 
-QuantizeHandler.__module__ = "torch.quantization.fx.quantization_patterns"
-BinaryOpQuantizeHandler.__module__ = "torch.quantization.fx.quantization_patterns"
-CatQuantizeHandler.__module__ = "torch.quantization.fx.quantization_patterns"
-ConvReluQuantizeHandler.__module__ = "torch.quantization.fx.quantization_patterns"
-LinearReLUQuantizeHandler.__module__ = "torch.quantization.fx.quantization_patterns"
-BatchNormQuantizeHandler.__module__ = "torch.quantization.fx.quantization_patterns"
-EmbeddingQuantizeHandler.__module__ = "torch.quantization.fx.quantization_patterns"
-RNNDynamicQuantizeHandler.__module__ = "torch.quantization.fx.quantization_patterns"
-DefaultNodeQuantizeHandler.__module__ = "torch.quantization.fx.quantization_patterns"
-FixedQParamsOpQuantizeHandler.__module__ = "torch.quantization.fx.quantization_patterns"
-CopyNodeQuantizeHandler.__module__ = "torch.quantization.fx.quantization_patterns"
-CustomModuleQuantizeHandler.__module__ = "torch.quantization.fx.quantization_patterns"
-GeneralTensorShapeOpQuantizeHandler.__module__ = "torch.quantization.fx.quantization_patterns"
-StandaloneModuleQuantizeHandler.__module__ = "torch.quantization.fx.quantization_patterns"
+QuantizeHandler.__module__ = "torch.ao.quantization.fx.quantization_patterns"
+BinaryOpQuantizeHandler.__module__ = "torch.ao.quantization.fx.quantization_patterns"
+CatQuantizeHandler.__module__ = "torch.ao.quantization.fx.quantization_patterns"
+ConvReluQuantizeHandler.__module__ = "torch.ao.quantization.fx.quantization_patterns"
+LinearReLUQuantizeHandler.__module__ = "torch.ao.quantization.fx.quantization_patterns"
+BatchNormQuantizeHandler.__module__ = "torch.ao.quantization.fx.quantization_patterns"
+EmbeddingQuantizeHandler.__module__ = "torch.ao.quantization.fx.quantization_patterns"
+RNNDynamicQuantizeHandler.__module__ = "torch.ao.quantization.fx.quantization_patterns"
+DefaultNodeQuantizeHandler.__module__ = "torch.ao.quantization.fx.quantization_patterns"
+FixedQParamsOpQuantizeHandler.__module__ = "torch.ao.quantization.fx.quantization_patterns"
+CopyNodeQuantizeHandler.__module__ = "torch.ao.quantization.fx.quantization_patterns"
+CustomModuleQuantizeHandler.__module__ = "torch.ao.quantization.fx.quantization_patterns"
+GeneralTensorShapeOpQuantizeHandler.__module__ = "torch.ao.quantization.fx.quantization_patterns"
+StandaloneModuleQuantizeHandler.__module__ = "torch.ao.quantization.fx.quantization_patterns"
diff --git a/torch/testing/_internal/common_modules.py b/torch/testing/_internal/common_modules.py
index 3775f88091b724..fb61d53097c67f 100644
--- a/torch/testing/_internal/common_modules.py
+++ b/torch/testing/_internal/common_modules.py
@@ -23,8 +23,8 @@
 MODULE_NAMESPACES: List[ModuleType] = [
     torch.nn.modules,
     torch.ao.nn.qat.modules,
-    torch.nn.quantizable.modules,
-    torch.nn.quantized.modules,
+    torch.ao.nn.quantizable.modules,
+    torch.ao.nn.quantized.modules,
     torch.ao.nn.quantized.modules,
 ]
 
@@ -33,7 +33,7 @@
     torch.nn.Module,  # abstract base class
     torch.nn.Container,  # deprecated
     torch.nn.NLLLoss2d,  # deprecated
-    torch.nn.quantized.MaxPool2d,  # aliases to nn.MaxPool2d
+    torch.ao.nn.quantized.MaxPool2d,  # aliases to nn.MaxPool2d
     torch.ao.nn.quantized.MaxPool2d,  # aliases to nn.MaxPool2d
 }
 
diff --git a/torch/testing/_internal/common_quantization.py b/torch/testing/_internal/common_quantization.py
index 4893e345289928..5e4a3c526ab7f0 100644
--- a/torch/testing/_internal/common_quantization.py
+++ b/torch/testing/_internal/common_quantization.py
@@ -5,10 +5,10 @@
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-import torch.nn.intrinsic.quantized.dynamic as nniqd
+import torch.ao.nn.intrinsic.quantized.dynamic as nniqd
 import torch.ao.nn.quantized as nnq
 import torch.ao.nn.quantized.dynamic as nnqd
-from torch.nn.intrinsic import _FusedModule
+from torch.ao.nn.intrinsic import _FusedModule
 import torch.distributed as dist
 from torch.testing._internal.common_utils import TestCase, TEST_WITH_ROCM
 
@@ -18,11 +18,11 @@
     default_embedding_qat_qconfig,
     default_symmetric_qnnpack_qat_qconfig,
 )
-from torch.quantization import QuantWrapper, QuantStub, DeQuantStub, \
+from torch.ao.quantization import QuantWrapper, QuantStub, DeQuantStub, \
     default_qconfig, default_dynamic_qconfig, default_per_channel_qconfig, QConfig, default_observer, default_weight_observer, \
     propagate_qconfig_, convert, get_default_qconfig, quantize_dynamic_jit, quantize_jit, float_qparams_weight_only_qconfig, \
     get_default_qat_qconfig, PerChannelMinMaxObserver, default_dynamic_quant_observer, quantize
-from torch.quantization.quantization_mappings import (
+from torch.ao.quantization.quantization_mappings import (
     get_default_dynamic_quant_module_mappings,
     get_default_qconfig_propagation_list,
     get_default_qat_module_mappings,
@@ -453,7 +453,7 @@ def is_leaf_module(module):
            ((is_leaf_module(module) and not isinstance(module, torch.nn.Sequential)
             and type(module) in propagate_qconfig_list) or
            type(module) in float_to_observed_module_class_mapping.keys()) and \
-           not isinstance(module, torch.quantization.DeQuantStub):
+           not isinstance(module, torch.ao.quantization.DeQuantStub):
             self.assertTrue(hasattr(module, 'activation_post_process'),
                             'module: ' + str(type(module)) + ' do not have observer')
         # we don't need to check observers for child modules of the
@@ -1029,7 +1029,7 @@ def _create_quantized_model(self, model_class: Type[torch.nn.Module], **kwargs):
         # Creates quantized model for testing mobile script modules
         qengine = "qnnpack"
         with override_quantized_engine(qengine):
-            qconfig = torch.quantization.get_default_qconfig(qengine)
+            qconfig = torch.ao.quantization.get_default_qconfig(qengine)
             model = model_class(**kwargs)
             model = quantize(model, test_only_eval_fn, [self.calib_data])
 
@@ -1085,7 +1085,7 @@ def get_example_inputs(self) -> Tuple[Any, ...]:
 class AnnotatedSingleLayerLinearModel(torch.nn.Module):
     def __init__(self, qengine='fbgemm'):
         super().__init__()
-        self.qconfig = torch.quantization.get_default_qconfig(qengine)
+        self.qconfig = torch.ao.quantization.get_default_qconfig(qengine)
         self.fc1 = QuantWrapper(torch.nn.Linear(5, 5).to(dtype=torch.float))
 
     def forward(self, x):
@@ -1098,7 +1098,7 @@ def get_example_inputs(self) -> Tuple[Any, ...]:
 class SingleLayerLinearDynamicModel(torch.nn.Module):
     def __init__(self, qengine='fbgemm'):
         super().__init__()
-        self.qconfig = torch.quantization.get_default_qconfig(qengine)
+        self.qconfig = torch.ao.quantization.get_default_qconfig(qengine)
         self.fc1 = torch.nn.Linear(5, 5).to(dtype=torch.float)
 
     def forward(self, x):
@@ -1156,7 +1156,7 @@ def forward(self, x):
 class LSTMwithHiddenDynamicModel(torch.nn.Module):
     def __init__(self, qengine='fbgemm'):
         super().__init__()
-        self.qconfig = torch.quantization.get_default_qconfig(qengine)
+        self.qconfig = torch.ao.quantization.get_default_qconfig(qengine)
         self.lstm = torch.nn.LSTM(2, 2).to(dtype=torch.float)
 
     def forward(self, x, hid):
@@ -1190,7 +1190,7 @@ def get_example_inputs(self) -> Tuple[Any, ...]:
 class AnnotatedConvModel(torch.nn.Module):
     def __init__(self, qengine):
         super().__init__()
-        self.qconfig = torch.quantization.get_default_qconfig(qengine)
+        self.qconfig = torch.ao.quantization.get_default_qconfig(qengine)
         self.conv = torch.nn.Conv2d(3, 5, 3, bias=False).to(dtype=torch.float)
         self.quant = QuantStub()
         self.dequant = DeQuantStub()
@@ -1207,7 +1207,7 @@ def get_example_inputs(self) -> Tuple[Any, ...]:
 class AnnotatedConvTransposeModel(torch.nn.Module):
     def __init__(self, qengine):
         super().__init__()
-        self.qconfig = torch.quantization.get_default_qconfig(qengine)
+        self.qconfig = torch.ao.quantization.get_default_qconfig(qengine)
         self.conv = torch.nn.ConvTranspose2d(3, 5, 3, bias=False).to(dtype=torch.float)
         self.quant = QuantStub()
         self.dequant = DeQuantStub()
@@ -1273,7 +1273,7 @@ def get_example_inputs(self) -> Tuple[Any, ...]:
 class AnnotatedConvBnReLUModel(torch.nn.Module):
     def __init__(self, qengine='fbgemm'):
         super(AnnotatedConvBnReLUModel, self).__init__()
-        self.qconfig = torch.quantization.get_default_qconfig(qengine)
+        self.qconfig = torch.ao.quantization.get_default_qconfig(qengine)
         self.conv = torch.nn.Conv2d(3, 5, 3, bias=False).to(dtype=torch.float)
         self.bn = torch.nn.BatchNorm2d(5).to(dtype=torch.float)
         self.relu = nn.ReLU(inplace=True)
@@ -1291,9 +1291,9 @@ def forward(self, x):
     def fuse_model(self):
         # TODO: remove this check and define two fuse_modules function on this module
         if self.training:
-            torch.quantization.fuse_modules_qat(self, [['conv', 'bn', 'relu']], inplace=True)
+            torch.ao.quantization.fuse_modules_qat(self, [['conv', 'bn', 'relu']], inplace=True)
         else:
-            torch.quantization.fuse_modules(self, [['conv', 'bn', 'relu']], inplace=True)
+            torch.ao.quantization.fuse_modules(self, [['conv', 'bn', 'relu']], inplace=True)
 
     def get_example_inputs(self) -> Tuple[Any, ...]:
         return (torch.rand(1, 3, 5, 5),)
@@ -1345,7 +1345,7 @@ def __init__(self):
         super().__init__()
         self.fc1 = torch.nn.Linear(5, 8).to(dtype=torch.float)
         self.fc2 = QuantWrapper(torch.nn.Linear(8, 5).to(dtype=torch.float))
-        self.fc2.qconfig = torch.quantization.get_default_qconfig("fbgemm")
+        self.fc2.qconfig = torch.ao.quantization.get_default_qconfig("fbgemm")
 
     def forward(self, x):
         x = self.fc1(x)
@@ -1358,11 +1358,11 @@ def get_example_inputs(self) -> Tuple[Any, ...]:
 class ActivationsTestModel(torch.nn.Module):
     def __init__(self):
         super().__init__()
-        self.qconfig = torch.quantization.get_default_qconfig("fbgemm")
-        self.quant = torch.quantization.QuantStub()
+        self.qconfig = torch.ao.quantization.get_default_qconfig("fbgemm")
+        self.quant = torch.ao.quantization.QuantStub()
         self.hardswish = torch.nn.Hardswish().to(dtype=torch.float)
         self.elu = torch.nn.ELU().to(dtype=torch.float)
-        self.dequant = torch.quantization.DeQuantStub()
+        self.dequant = torch.ao.quantization.DeQuantStub()
 
     def forward(self, x):
         x = self.quant(x)
@@ -1564,7 +1564,7 @@ def get_example_inputs(self) -> Tuple[Any, ...]:
 class NormalizationTestModel(torch.nn.Module):
     def __init__(self):
         super().__init__()
-        self.quant = torch.quantization.QuantStub()
+        self.quant = torch.ao.quantization.QuantStub()
         self.fc1 = torch.nn.Linear(5, 8).to(dtype=torch.float)
         self.layer_norm = torch.nn.LayerNorm((8))
         self.group_norm = torch.nn.GroupNorm(2, 8)
@@ -1871,7 +1871,7 @@ class AnnotatedSkipQuantModel(torch.nn.Module):
     """
     def __init__(self, qengine):
         super().__init__()
-        self.qconfig = torch.quantization.get_default_qconfig(qengine)
+        self.qconfig = torch.ao.quantization.get_default_qconfig(qengine)
         self.sub = QuantWrapper(InnerModule())
         self.fc = torch.nn.Linear(5, 5).to(dtype=torch.float)
         # don't quantize this fc
@@ -1888,7 +1888,7 @@ class QuantStubModel(torch.nn.Module):
     """
     def __init__(self):
         super().__init__()
-        self.qconfig = torch.quantization.get_default_qconfig("qnnpack")
+        self.qconfig = torch.ao.quantization.get_default_qconfig("qnnpack")
         self.quant = QuantStub()
         self.dequant = DeQuantStub()
         self.fc = torch.nn.Linear(5, 5).to(dtype=torch.float)
@@ -1903,7 +1903,7 @@ class ManualLinearQATModel(torch.nn.Module):
     """
     def __init__(self, qengine):
         super().__init__()
-        self.qconfig = torch.quantization.get_default_qat_qconfig(qengine)
+        self.qconfig = torch.ao.quantization.get_default_qat_qconfig(qengine)
         self.quant = QuantStub()
         self.dequant = DeQuantStub()
         self.fc1 = torch.nn.Linear(5, 1).to(dtype=torch.float)
@@ -1920,7 +1920,7 @@ class ManualDropoutQATModel(torch.nn.Module):
     """
     def __init__(self, qengine):
         super().__init__()
-        self.qconfig = torch.quantization.get_default_qat_qconfig(qengine)
+        self.qconfig = torch.ao.quantization.get_default_qat_qconfig(qengine)
         self.quant = QuantStub()
         self.dequant = DeQuantStub()
         self.fc1 = torch.nn.Linear(5, 1).to(dtype=torch.float)
@@ -1952,7 +1952,7 @@ class ManualConvLinearQATModel(torch.nn.Module):
     """
     def __init__(self, qconfig=None):
         super().__init__()
-        self.qconfig = qconfig if qconfig else torch.quantization.get_default_qat_qconfig("qnnpack")
+        self.qconfig = qconfig if qconfig else torch.ao.quantization.get_default_qat_qconfig("qnnpack")
         self.quant = QuantStub()
         self.dequant = DeQuantStub()
         self.conv = torch.nn.Conv2d(3, 1, kernel_size=3).to(dtype=torch.float)