[Cleanup][B-9] Replace to_variable (#61585)

zade23 · web-flow · commit 4cd7b138f957 · 2024-02-05T09:21:47.000+08:00
diff --git a/test/collective/fleet/test_imperative_auto_mixed_precision_for_eager.py b/test/collective/fleet/test_imperative_auto_mixed_precision_for_eager.py
@@ -58,7 +58,7 @@ def amp_guard_white_op(self):
         data = np.random.uniform(-1, 1, [10, 3, 32, 32]).astype('float32')
         with base.dygraph.guard():
             conv2d = paddle.nn.Conv2D(3, 2, 3, bias_attr=False)
-            data = base.dygraph.to_variable(data)
+            data = paddle.to_tensor(data)
             with paddle.amp.amp_guard(True):
                 out_fp16 = conv2d(data)
 
@@ -75,7 +75,7 @@ def test_amp_guard_white_op(self):
     def amp_guard_black_op(self):
         data = np.random.uniform(-1, 1, [10, 3, 32, 32]).astype('float32')
         with base.dygraph.guard():
-            data = base.dygraph.to_variable(data)
+            data = paddle.to_tensor(data)
             with paddle.amp.amp_guard(True):
                 out_fp32 = paddle.mean(data)
 
@@ -140,7 +140,7 @@ def func():
                 with paddle.amp.amp_guard(
                     custom_white_list=["conv2d"], custom_black_list=["conv2d"]
                 ):
-                    inp = base.dygraph.to_variable(inp_np)
+                    inp = paddle.to_tensor(inp_np)
                     out = model(inp)
 
         self.assertRaises(ValueError, func)
@@ -152,7 +152,7 @@ def amp_guard_upsupported_fp16_op(self):
         data = np.random.uniform(-1, 1, [10, 3, 32, 32]).astype('float32')
         with base.dygraph.guard():
             conv2d = paddle.nn.Conv2D(3, 2, 3, bias_attr=False)
-            data = base.dygraph.to_variable(data)
+            data = paddle.to_tensor(data)
             with paddle.amp.amp_guard(True):
                 out_amp_fp16 = conv2d(data)
                 out_amp_fp32 = paddle.expand_as(
@@ -178,7 +178,7 @@ def func():
             data = np.random.uniform(-1, 1, [10, 3, 32, 32]).astype('float32')
             with base.dygraph.guard():
                 conv2d = paddle.nn.Conv2D(3, 2, 3, bias_attr=False)
-                data = base.dygraph.to_variable(data)
+                data = paddle.to_tensor(data)
                 with paddle.amp.amp_guard(level='O'):
                     out = conv2d(data)
 
@@ -222,7 +222,7 @@ def run_simple_conv(inp_np, use_scaler=True):
                     learning_rate=0.01, parameters=model.parameters()
                 )
                 scaler = paddle.amp.AmpScaler(init_loss_scaling=1024)
-                data = base.dygraph.to_variable(inp_np)
+                data = paddle.to_tensor(inp_np)
 
                 out = model(data)
                 loss = paddle.mean(out)
@@ -283,7 +283,7 @@ def run_simple_conv(inp_np, use_scaler=True):
                     learning_rate=0.01, parameters=model.parameters()
                 )
                 scaler = paddle.amp.GradScaler(init_loss_scaling=1024)
-                data = base.dygraph.to_variable(inp_np)
+                data = paddle.to_tensor(inp_np)
 
                 out = model(data)
                 loss = paddle.mean(out)
@@ -331,7 +331,7 @@ def nan_inf(self):
                 learning_rate=0.01, parameters=model.parameters()
             )
             scaler = paddle.amp.AmpScaler(init_loss_scaling=1024)
-            data = base.dygraph.to_variable(inp_np)
+            data = paddle.to_tensor(inp_np)
             with paddle.amp.auto_cast(dtype='float16'):
                 out = model(data)
                 loss = paddle.mean(out)
@@ -1287,8 +1287,8 @@ def train_resnet(self, enable_amp=True, level='O1'):
                     .astype('int64')
                     .reshape(-1, 1)
                 )
-                img = base.dygraph.to_variable(dy_x_data)
-                label = base.dygraph.to_variable(y_data)
+                img = paddle.to_tensor(dy_x_data)
+                label = paddle.to_tensor(y_data)
                 label.stop_gradient = True
                 with paddle.amp.amp_guard(enable=enable_amp, level=level):
                     out = resnet(img)
diff --git a/test/legacy_test/test_histogram_op.py b/test/legacy_test/test_histogram_op.py
@@ -50,7 +50,7 @@ def test_static_graph(self):
     def test_dygraph(self):
         with base.dygraph.guard():
             inputs_np = np.array([[2, 4, 2], [2, 5, 4]]).astype(np.int64)
-            inputs = base.dygraph.to_variable(inputs_np)
+            inputs = paddle.to_tensor(inputs_np)
             actual = paddle.histogram(inputs, bins=5, min=1, max=5)
             expected = np.array([0, 3, 0, 2, 1]).astype(np.int64)
             self.assertTrue(
diff --git a/test/legacy_test/test_imperative_container_layerlist.py b/test/legacy_test/test_imperative_container_layerlist.py
@@ -40,7 +40,7 @@ def paddle_imperative_list(self):
     def layer_list(self, use_base_api):
         data_np = np.random.uniform(-1, 1, [5, 1]).astype('float32')
         with base.dygraph.guard():
-            x = base.dygraph.to_variable(data_np)
+            x = paddle.to_tensor(data_np)
             layerlist = self.paddle_imperative_list()
             size = len(layerlist)
 
diff --git a/test/legacy_test/test_imperative_container_parameterlist.py b/test/legacy_test/test_imperative_container_parameterlist.py
@@ -42,7 +42,7 @@ class TestImperativeContainerParameterList(unittest.TestCase):
     def paramter_list(self, use_base_api):
         data_np = np.random.uniform(-1, 1, [5, 2]).astype('float32')
         with base.dygraph.guard():
-            x = base.dygraph.to_variable(data_np)
+            x = paddle.to_tensor(data_np)
             num_stacked_param = 4
             model = MyLayer(num_stacked_param, use_base_api)
             self.assertEqual(len(model.params), num_stacked_param)
diff --git a/test/legacy_test/test_imperative_container_sequential.py b/test/legacy_test/test_imperative_container_sequential.py
@@ -25,7 +25,7 @@ class TestImperativeContainerSequential(unittest.TestCase):
     def test_sequential(self):
         data = np.random.uniform(-1, 1, [5, 10]).astype('float32')
         with base.dygraph.guard():
-            data = base.dygraph.to_variable(data)
+            data = paddle.to_tensor(data)
             model1 = paddle.nn.Sequential(Linear(10, 1), Linear(1, 2))
             res1 = model1(data)
             self.assertListEqual(res1.shape, [5, 2])
@@ -59,7 +59,7 @@ def test_sequential(self):
     def test_sequential_list_params(self):
         data = np.random.uniform(-1, 1, [5, 10]).astype('float32')
         with base.dygraph.guard():
-            data = base.dygraph.to_variable(data)
+            data = paddle.to_tensor(data)
             model1 = paddle.nn.Sequential(Linear(10, 1), Linear(1, 2))
             res1 = model1(data)
             self.assertListEqual(res1.shape, [5, 2])
diff --git a/test/legacy_test/test_imperative_deepcf.py b/test/legacy_test/test_imperative_deepcf.py
@@ -23,7 +23,6 @@
 import paddle
 from paddle import base
 from paddle.base import core
-from paddle.base.dygraph.base import to_variable
 from paddle.nn import Linear
 
 
@@ -316,13 +315,17 @@ def test_deefcf(self):
                     if slice + self.batch_size >= users_np.shape[0]:
                         break
                     prediction = deepcf(
-                        to_variable(users_np[slice : slice + self.batch_size]),
-                        to_variable(items_np[slice : slice + self.batch_size]),
+                        paddle.to_tensor(
+                            users_np[slice : slice + self.batch_size]
+                        ),
+                        paddle.to_tensor(
+                            items_np[slice : slice + self.batch_size]
+                        ),
                     )
                     loss = paddle.sum(
                         paddle.nn.functional.log_loss(
                             prediction,
-                            to_variable(
+                            paddle.to_tensor(
                                 labels_np[slice : slice + self.batch_size]
                             ),
                         )
@@ -348,13 +351,17 @@ def test_deefcf(self):
                     if slice + self.batch_size >= users_np.shape[0]:
                         break
                     prediction2 = deepcf2(
-                        to_variable(users_np[slice : slice + self.batch_size]),
-                        to_variable(items_np[slice : slice + self.batch_size]),
+                        paddle.to_tensor(
+                            users_np[slice : slice + self.batch_size]
+                        ),
+                        paddle.to_tensor(
+                            items_np[slice : slice + self.batch_size]
+                        ),
                     )
                     loss2 = paddle.sum(
                         paddle.nn.functional.log_loss(
                             prediction2,
-                            to_variable(
+                            paddle.to_tensor(
                                 labels_np[slice : slice + self.batch_size]
                             ),
                         )
@@ -380,13 +387,17 @@ def test_deefcf(self):
                     if slice + self.batch_size >= users_np.shape[0]:
                         break
                     prediction = deepcf(
-                        to_variable(users_np[slice : slice + self.batch_size]),
-                        to_variable(items_np[slice : slice + self.batch_size]),
+                        paddle.to_tensor(
+                            users_np[slice : slice + self.batch_size]
+                        ),
+                        paddle.to_tensor(
+                            items_np[slice : slice + self.batch_size]
+                        ),
                     )
                     loss = paddle.sum(
                         paddle.nn.functional.log_loss(
                             prediction,
-                            to_variable(
+                            paddle.to_tensor(
                                 labels_np[slice : slice + self.batch_size]
                             ),
                         )
diff --git a/test/legacy_test/test_imperative_double_grad.py b/test/legacy_test/test_imperative_double_grad.py
@@ -40,7 +40,7 @@ def __impl__(*args, **kwargs):
 
 def random_var(size, low=-1, high=1, dtype='float32'):
     x_np = np.random.uniform(low=low, high=high, size=size).astype(dtype)
-    return base.dygraph.to_variable(x_np)
+    return paddle.to_tensor(x_np)
 
 
 class TestEagerGrad(TestCase):
@@ -322,7 +322,7 @@ def test_none_one_initial_gradient(self):
         )
         np.random.shuffle(x_np)
 
-        x = base.dygraph.to_variable(x_np)
+        x = paddle.to_tensor(x_np)
         x.stop_gradient = False
 
         alpha = 0.2
@@ -538,7 +538,7 @@ def model_f(input):
         with base.dygraph.guard():
             paddle.seed(123)
             paddle.framework.random._manual_program_seed(123)
-            a = base.dygraph.to_variable(value)
+            a = paddle.to_tensor(value)
             a.stop_gradient = False
 
             out = model_f(a)
@@ -556,7 +556,7 @@ def model_f(input):
         with base.dygraph.guard():
             paddle.seed(123)
             paddle.framework.random._manual_program_seed(123)
-            a = base.dygraph.to_variable(value)
+            a = paddle.to_tensor(value)
             a.stop_gradient = False
 
             out = model_f(a)
diff --git a/test/legacy_test/test_imperative_framework.py b/test/legacy_test/test_imperative_framework.py
@@ -69,5 +69,5 @@ def test_dygraph_backward(self):
     def test_dygraph_to_string(self):
         np_inp = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)
         with base.dygraph.guard():
-            var_inp = base.dygraph.to_variable(np_inp)
+            var_inp = paddle.to_tensor(np_inp)
             print(str(var_inp))
diff --git a/test/legacy_test/test_imperative_gan.py b/test/legacy_test/test_imperative_gan.py
@@ -20,7 +20,6 @@
 import paddle
 from paddle import base
 from paddle.base import core
-from paddle.base.dygraph.base import to_variable
 from paddle.nn import Linear
 
 
@@ -155,20 +154,23 @@ def test_gan_float32(self):
                 ),
             )
 
-            d_real = discriminator(to_variable(np.ones([2, 1], np.float32)))
+            d_real = discriminator(
+                paddle.to_tensor(np.ones([2, 1], np.float32))
+            )
             d_loss_real = paddle.mean(
                 paddle.nn.functional.binary_cross_entropy_with_logits(
-                    logit=d_real, label=to_variable(np.ones([2, 1], np.float32))
+                    logit=d_real,
+                    label=paddle.to_tensor(np.ones([2, 1], np.float32)),
                 )
             )
 
             d_fake = discriminator(
-                generator(to_variable(np.ones([2, 2], np.float32)))
+                generator(paddle.to_tensor(np.ones([2, 2], np.float32)))
             )
             d_loss_fake = paddle.mean(
                 paddle.nn.functional.binary_cross_entropy_with_logits(
                     logit=d_fake,
-                    label=to_variable(np.zeros([2, 1], np.float32)),
+                    label=paddle.to_tensor(np.zeros([2, 1], np.float32)),
                 )
             )
 
@@ -179,11 +181,12 @@ def test_gan_float32(self):
             generator.clear_gradients()
 
             d_fake = discriminator(
-                generator(to_variable(np.ones([2, 2], np.float32)))
+                generator(paddle.to_tensor(np.ones([2, 2], np.float32)))
             )
             g_loss = paddle.mean(
                 paddle.nn.functional.binary_cross_entropy_with_logits(
-                    logit=d_fake, label=to_variable(np.ones([2, 1], np.float32))
+                    logit=d_fake,
+                    label=paddle.to_tensor(np.ones([2, 1], np.float32)),
                 )
             )
             g_loss.backward()
@@ -210,21 +213,23 @@ def test_gan_float32(self):
                 ),
             )
 
-            d_real2 = discriminator2(to_variable(np.ones([2, 1], np.float32)))
+            d_real2 = discriminator2(
+                paddle.to_tensor(np.ones([2, 1], np.float32))
+            )
             d_loss_real2 = paddle.mean(
                 paddle.nn.functional.binary_cross_entropy_with_logits(
                     logit=d_real2,
-                    label=to_variable(np.ones([2, 1], np.float32)),
+                    label=paddle.to_tensor(np.ones([2, 1], np.float32)),
                 )
             )
 
             d_fake2 = discriminator2(
-                generator2(to_variable(np.ones([2, 2], np.float32)))
+                generator2(paddle.to_tensor(np.ones([2, 2], np.float32)))
             )
             d_loss_fake2 = paddle.mean(
                 paddle.nn.functional.binary_cross_entropy_with_logits(
                     logit=d_fake2,
-                    label=to_variable(np.zeros([2, 1], np.float32)),
+                    label=paddle.to_tensor(np.zeros([2, 1], np.float32)),
                 )
             )
 
@@ -235,12 +240,12 @@ def test_gan_float32(self):
             generator2.clear_gradients()
 
             d_fake2 = discriminator2(
-                generator2(to_variable(np.ones([2, 2], np.float32)))
+                generator2(paddle.to_tensor(np.ones([2, 2], np.float32)))
             )
             g_loss2 = paddle.mean(
                 paddle.nn.functional.binary_cross_entropy_with_logits(
                     logit=d_fake2,
-                    label=to_variable(np.ones([2, 1], np.float32)),
+                    label=paddle.to_tensor(np.ones([2, 1], np.float32)),
                 )
             )
             g_loss2.backward()
diff --git a/test/legacy_test/test_imperative_gnn.py b/test/legacy_test/test_imperative_gnn.py
@@ -22,7 +22,6 @@
 import paddle.nn.functional as F
 from paddle import base
 from paddle.base import core
-from paddle.base.dygraph.base import to_variable
 from paddle.optimizer import Adam
 
 
@@ -123,12 +122,12 @@ def test_gnn_float32(self):
             labels = np.ones([100, 1], dtype=np.int64)
 
             model = GCN('test_gcn', 50)
-            logits = model(to_variable(features), to_variable(adj))
+            logits = model(paddle.to_tensor(features), paddle.to_tensor(adj))
             logits = paddle.reshape(logits, logits.shape[1:])
             # In other example, it's nll with log_softmax. However, paddle's
             # log_loss only supports binary classification now.
             loss = paddle.nn.functional.softmax_with_cross_entropy(
-                logits, to_variable(labels)
+                logits, paddle.to_tensor(labels)
             )
             loss = paddle.sum(loss)
             loss.backward()
@@ -149,12 +148,14 @@ def test_gnn_float32(self):
             labels2 = np.ones([100, 1], dtype=np.int64)
 
             model2 = GCN('test_gcn', 50)
-            logits2 = model2(to_variable(features2), to_variable(adj2))
+            logits2 = model2(
+                paddle.to_tensor(features2), paddle.to_tensor(adj2)
+            )
             logits2 = paddle.reshape(logits2, logits2.shape[1:])
             # In other example, it's nll with log_softmax. However, paddle's
             # log_loss only supports binary classification now.
             loss2 = paddle.nn.functional.softmax_with_cross_entropy(
-                logits2, to_variable(labels2)
+                logits2, paddle.to_tensor(labels2)
             )
             loss2 = paddle.sum(loss2)
             loss2.backward()

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,6 @@`
`20`	`20`	`import paddle`
`21`	`21`	`from paddle import base`
`22`	`22`	`from paddle.base import core`
`23`		`-from paddle.base.dygraph.base import to_variable`
`24`	`23`	`from paddle.nn import Linear`
`25`	`24`
`26`	`25`
`@@ -155,20 +154,23 @@ def test_gan_float32(self):`
`155`	`154`	`),`
`156`	`155`	`)`
`157`	`156`
`158`		`- d_real = discriminator(to_variable(np.ones([2, 1], np.float32)))`
	`157`	`+ d_real = discriminator(`
	`158`	`+ paddle.to_tensor(np.ones([2, 1], np.float32))`
	`159`	`+ )`
`159`	`160`	`d_loss_real = paddle.mean(`
`160`	`161`	`paddle.nn.functional.binary_cross_entropy_with_logits(`
`161`		`- logit=d_real, label=to_variable(np.ones([2, 1], np.float32))`
	`162`	`+ logit=d_real,`
	`163`	`+ label=paddle.to_tensor(np.ones([2, 1], np.float32)),`
`162`	`164`	`)`
`163`	`165`	`)`
`164`	`166`
`165`	`167`	`d_fake = discriminator(`
`166`		`- generator(to_variable(np.ones([2, 2], np.float32)))`
	`168`	`+ generator(paddle.to_tensor(np.ones([2, 2], np.float32)))`
`167`	`169`	`)`
`168`	`170`	`d_loss_fake = paddle.mean(`
`169`	`171`	`paddle.nn.functional.binary_cross_entropy_with_logits(`
`170`	`172`	`logit=d_fake,`
`171`		`- label=to_variable(np.zeros([2, 1], np.float32)),`
	`173`	`+ label=paddle.to_tensor(np.zeros([2, 1], np.float32)),`
`172`	`174`	`)`
`173`	`175`	`)`
`174`	`176`
`@@ -179,11 +181,12 @@ def test_gan_float32(self):`
`179`	`181`	`generator.clear_gradients()`
`180`	`182`
`181`	`183`	`d_fake = discriminator(`
`182`		`- generator(to_variable(np.ones([2, 2], np.float32)))`
	`184`	`+ generator(paddle.to_tensor(np.ones([2, 2], np.float32)))`
`183`	`185`	`)`
`184`	`186`	`g_loss = paddle.mean(`
`185`	`187`	`paddle.nn.functional.binary_cross_entropy_with_logits(`
`186`		`- logit=d_fake, label=to_variable(np.ones([2, 1], np.float32))`
	`188`	`+ logit=d_fake,`
	`189`	`+ label=paddle.to_tensor(np.ones([2, 1], np.float32)),`
`187`	`190`	`)`
`188`	`191`	`)`
`189`	`192`	`g_loss.backward()`
`@@ -210,21 +213,23 @@ def test_gan_float32(self):`
`210`	`213`	`),`
`211`	`214`	`)`
`212`	`215`
`213`		`- d_real2 = discriminator2(to_variable(np.ones([2, 1], np.float32)))`
	`216`	`+ d_real2 = discriminator2(`
	`217`	`+ paddle.to_tensor(np.ones([2, 1], np.float32))`
	`218`	`+ )`
`214`	`219`	`d_loss_real2 = paddle.mean(`
`215`	`220`	`paddle.nn.functional.binary_cross_entropy_with_logits(`
`216`	`221`	`logit=d_real2,`
`217`		`- label=to_variable(np.ones([2, 1], np.float32)),`
	`222`	`+ label=paddle.to_tensor(np.ones([2, 1], np.float32)),`
`218`	`223`	`)`
`219`	`224`	`)`
`220`	`225`
`221`	`226`	`d_fake2 = discriminator2(`
`222`		`- generator2(to_variable(np.ones([2, 2], np.float32)))`
	`227`	`+ generator2(paddle.to_tensor(np.ones([2, 2], np.float32)))`
`223`	`228`	`)`
`224`	`229`	`d_loss_fake2 = paddle.mean(`
`225`	`230`	`paddle.nn.functional.binary_cross_entropy_with_logits(`
`226`	`231`	`logit=d_fake2,`
`227`		`- label=to_variable(np.zeros([2, 1], np.float32)),`
	`232`	`+ label=paddle.to_tensor(np.zeros([2, 1], np.float32)),`
`228`	`233`	`)`
`229`	`234`	`)`
`230`	`235`
`@@ -235,12 +240,12 @@ def test_gan_float32(self):`
`235`	`240`	`generator2.clear_gradients()`
`236`	`241`
`237`	`242`	`d_fake2 = discriminator2(`
`238`		`- generator2(to_variable(np.ones([2, 2], np.float32)))`
	`243`	`+ generator2(paddle.to_tensor(np.ones([2, 2], np.float32)))`
`239`	`244`	`)`
`240`	`245`	`g_loss2 = paddle.mean(`
`241`	`246`	`paddle.nn.functional.binary_cross_entropy_with_logits(`
`242`	`247`	`logit=d_fake2,`
`243`		`- label=to_variable(np.ones([2, 1], np.float32)),`
	`248`	`+ label=paddle.to_tensor(np.ones([2, 1], np.float32)),`
`244`	`249`	`)`
`245`	`250`	`)`
`246`	`251`	`g_loss2.backward()`