diff --git a/cyclegan/check.py b/cyclegan/check.py index 79ab4862d3c2082c36039b047be08d4a4b5dcedd..985ed9e9dd3507f541bedcdbc5ee8b0678199655 100644 --- a/cyclegan/check.py +++ b/cyclegan/check.py @@ -20,7 +20,7 @@ import sys import paddle.fluid as fluid -__all__ = ['check_gpu', 'check_version'] +__all__ = ['check_gpu'] def check_gpu(use_gpu): @@ -40,19 +40,3 @@ def check_gpu(use_gpu): sys.exit(1) except Exception as e: pass - - -def check_version(): - """ - Log error and exit when the installed version of paddlepaddle is - not satisfied. - """ - err = "PaddlePaddle version 1.6 or higher is required, " \ - "or a suitable develop version is satisfied as well. \n" \ - "Please make sure the version is good with your code." \ - - try: - fluid.require_version('1.7.0') - except Exception as e: - print(err) - sys.exit(1) diff --git a/cyclegan/cyclegan.py b/cyclegan/cyclegan.py index 5ace88ba3df87bdd1bd602900156d9ba23664b0a..f25c2bbdb9781b750f79bec988478cb10efd9ce6 100644 --- a/cyclegan/cyclegan.py +++ b/cyclegan/cyclegan.py @@ -19,12 +19,13 @@ from __future__ import print_function import numpy as np import paddle -import paddle.fluid as fluid +import paddle.nn.functional as F +from paddle.nn import Layer from layers import ConvBN, DeConvBN -class ResnetBlock(fluid.dygraph.Layer): +class ResnetBlock(Layer): def __init__(self, dim, dropout=False): super(ResnetBlock, self).__init__() self.dropout = dropout @@ -32,16 +33,16 @@ class ResnetBlock(fluid.dygraph.Layer): self.conv1 = ConvBN(dim, dim, 3, 1, act=None) def forward(self, inputs): - out_res = fluid.layers.pad2d(inputs, [1, 1, 1, 1], mode="reflect") + out_res = F.pad2d(inputs, [1, 1, 1, 1], mode="reflect") out_res = self.conv0(out_res) if self.dropout: - out_res = fluid.layers.dropout(out_res, dropout_prob=0.5) - out_res = fluid.layers.pad2d(out_res, [1, 1, 1, 1], mode="reflect") + out_res = F.dropout(out_res, p=0.5) + out_res = F.pad2d(out_res, [1, 1, 1, 1], mode="reflect") out_res = self.conv1(out_res) return out_res + inputs -class ResnetGenerator(fluid.dygraph.Layer): +class ResnetGenerator(Layer): def __init__(self, input_channel, n_blocks=9, dropout=False): super(ResnetGenerator, self).__init__() @@ -65,7 +66,7 @@ class ResnetGenerator(fluid.dygraph.Layer): 32, input_channel, 7, 1, norm=False, act=False, use_bias=True) def forward(self, inputs): - pad_input = fluid.layers.pad2d(inputs, [3, 3, 3, 3], mode="reflect") + pad_input = F.pad2d(inputs, [3, 3, 3, 3], mode="reflect") y = self.conv0(pad_input) y = self.conv1(y) y = self.conv2(y) @@ -73,13 +74,13 @@ class ResnetGenerator(fluid.dygraph.Layer): y = resnet_block(y) y = self.deconv0(y) y = self.deconv1(y) - y = fluid.layers.pad2d(y, [3, 3, 3, 3], mode="reflect") + y = F.pad2d(y, [3, 3, 3, 3], mode="reflect") y = self.conv3(y) - y = fluid.layers.tanh(y) + y = paddle.tanh(y) return y -class NLayerDiscriminator(fluid.dygraph.Layer): +class NLayerDiscriminator(Layer): def __init__(self, input_channel, d_dims=64, d_nlayers=3): super(NLayerDiscriminator, self).__init__() self.conv0 = ConvBN( @@ -186,10 +187,10 @@ class GLoss(paddle.nn.Layer): def forward(self, input_A, input_B, fake_A, fake_B, cyc_A, cyc_B, idt_A, idt_B, valid_A, valid_B): def mse(a, b): - return fluid.layers.reduce_mean(fluid.layers.square(a - b)) + return paddle.reduce_mean(paddle.square(a - b)) def mae(a, b): # L1Loss - return fluid.layers.reduce_mean(fluid.layers.abs(a - b)) + return paddle.reduce_mean(paddle.abs(a - b)) g_A_loss = mse(valid_A, 1.) g_B_loss = mse(valid_B, 1.) @@ -225,6 +226,6 @@ class DLoss(paddle.nn.Layer): super(DLoss, self).__init__() def forward(self, real, fake): - loss = fluid.layers.square(fake) + fluid.layers.square(real - 1.) - loss = fluid.layers.reduce_mean(loss / 2.0) + loss = paddle.square(fake) + paddle.square(real - 1.) + loss = paddle.reduce_mean(loss / 2.0) return loss diff --git a/cyclegan/infer.py b/cyclegan/infer.py index 935524365b8e7cd48271819720a299092e97be6c..e7d18f87e5d6e9400eebbc83ee2b39e8a51eaace 100644 --- a/cyclegan/infer.py +++ b/cyclegan/infer.py @@ -25,16 +25,15 @@ from PIL import Image from scipy.misc import imsave import paddle -import paddle.fluid as fluid from paddle.static import InputSpec as Input -from check import check_gpu, check_version +from check import check_gpu from cyclegan import Generator, GeneratorCombine def main(): place = paddle.set_device(FLAGS.device) - fluid.enable_dygraph(place) if FLAGS.dynamic else None + paddle.disable_static(place) if FLAGS.dynamic else None im_shape = [-1, 3, 256, 256] input_A = Input(im_shape, 'float32', 'input_A') @@ -110,5 +109,4 @@ if __name__ == "__main__": FLAGS = parser.parse_args() print(FLAGS) check_gpu(str.lower(FLAGS.device) == 'gpu') - check_version() main() diff --git a/cyclegan/layers.py b/cyclegan/layers.py index 8c79ef5ff541646d98c3ce26d1d9a1888dc4421c..962b4fb46d0b950a62e9989244b368eecae71620 100644 --- a/cyclegan/layers.py +++ b/cyclegan/layers.py @@ -13,53 +13,50 @@ # limitations under the License. from __future__ import division -import paddle.fluid as fluid -from paddle.fluid.dygraph.nn import Conv2D, Conv2DTranspose, BatchNorm - -# cudnn is not better when batch size is 1. -use_cudnn = False -import numpy as np - - -class ConvBN(fluid.dygraph.Layer): - """docstring for Conv2D""" - - def __init__(self, - num_channels, - num_filters, - filter_size, - stride=1, - padding=0, - stddev=0.02, - norm=True, - is_test=False, - act='leaky_relu', - relufactor=0.0, - use_bias=False): + +import paddle +import paddle.nn as nn +import paddle.nn.functional as F +from paddle.nn import Layer, Conv2d, BatchNorm2d, ConvTranspose2d + + +class ConvBN(Layer): + """docstring for Conv2d""" + + def __init__( + self, + num_channels, + num_filters, + filter_size, + stride=1, + padding=0, + stddev=0.02, + norm=True, + #is_test=False, + act='leaky_relu', + relufactor=0.0, + use_bias=False): super(ConvBN, self).__init__() - pattr = fluid.ParamAttr( - initializer=fluid.initializer.NormalInitializer( - loc=0.0, scale=stddev)) - self.conv = Conv2D( - num_channels=num_channels, - num_filters=num_filters, - filter_size=filter_size, + pattr = paddle.ParamAttr(initializer=nn.initializer.Normal( + loc=0.0, scale=stddev)) + self.conv = Conv2d( + in_channels=num_channels, + out_channels=num_filters, + kernel_size=filter_size, stride=stride, padding=padding, - use_cudnn=use_cudnn, - param_attr=pattr, + weight_attr=pattr, bias_attr=use_bias) if norm: - self.bn = BatchNorm( + self.bn = BatchNorm2d( num_filters, - param_attr=fluid.ParamAttr( - initializer=fluid.initializer.NormalInitializer(1.0, - 0.02)), - bias_attr=fluid.ParamAttr( - initializer=fluid.initializer.Constant(0.0)), - is_test=False, - trainable_statistics=True) + weight_attr=paddle.ParamAttr( + initializer=nn.initializer.Normal(1.0, 0.02)), + bias_attr=paddle.ParamAttr( + initializer=nn.initializer.Constant(0.0)), + #is_test=False, + track_running_stats=True) self.relufactor = relufactor self.norm = norm self.act = act @@ -70,52 +67,51 @@ class ConvBN(fluid.dygraph.Layer): conv = self.bn(conv) if self.act == 'leaky_relu': - conv = fluid.layers.leaky_relu(conv, alpha=self.relufactor) + conv = F.leaky_relu(conv, self.relufactor) elif self.act == 'relu': - conv = fluid.layers.relu(conv) + conv = F.relu(conv) else: conv = conv return conv -class DeConvBN(fluid.dygraph.Layer): - def __init__(self, - num_channels, - num_filters, - filter_size, - stride=1, - padding=[0, 0], - outpadding=[0, 0, 0, 0], - stddev=0.02, - act='leaky_relu', - norm=True, - is_test=False, - relufactor=0.0, - use_bias=False): +class DeConvBN(Layer): + def __init__( + self, + num_channels, + num_filters, + filter_size, + stride=1, + padding=[0, 0], + outpadding=[0, 0, 0, 0], + stddev=0.02, + act='leaky_relu', + norm=True, + #is_test=False, + relufactor=0.0, + use_bias=False): super(DeConvBN, self).__init__() - pattr = fluid.ParamAttr( - initializer=fluid.initializer.NormalInitializer( - loc=0.0, scale=stddev)) - self._deconv = Conv2DTranspose( + pattr = paddle.ParamAttr(initializer=nn.initializer.Normal( + loc=0.0, scale=stddev)) + self._deconv = ConvTranspose2d( num_channels, num_filters, - filter_size=filter_size, + kernel_size=filter_size, stride=stride, padding=padding, - param_attr=pattr, + weight_attr=pattr, bias_attr=use_bias) if norm: - self.bn = BatchNorm( + self.bn = BatchNorm2d( num_filters, - param_attr=fluid.ParamAttr( - initializer=fluid.initializer.NormalInitializer(1.0, - 0.02)), - bias_attr=fluid.ParamAttr( - initializer=fluid.initializer.Constant(0.0)), - is_test=False, - trainable_statistics=True) + weight_attr=paddle.ParamAttr( + initializer=nn.initializer.Normal(1.0, 0.02)), + bias_attr=paddle.ParamAttr( + initializer=nn.initializer.Constant(0.0)), + #is_test=False, + track_running_stats=True) self.outpadding = outpadding self.relufactor = relufactor self.use_bias = use_bias @@ -124,16 +120,16 @@ class DeConvBN(fluid.dygraph.Layer): def forward(self, inputs): conv = self._deconv(inputs) - conv = fluid.layers.pad2d( + conv = F.pad2d( conv, paddings=self.outpadding, mode='constant', pad_value=0.0) if self.norm: conv = self.bn(conv) if self.act == 'leaky_relu': - conv = fluid.layers.leaky_relu(conv, alpha=self.relufactor) + conv = F.leaky_relu(conv, self.relufactor) elif self.act == 'relu': - conv = fluid.layers.relu(conv) + conv = F.relu(conv) else: conv = conv diff --git a/cyclegan/test.py b/cyclegan/test.py index 7b0059bd43c39892d70acc1e1ab204c1cb9a62a6..1e73b20cf62d7b82501a7217d662ec57a7be6892 100644 --- a/cyclegan/test.py +++ b/cyclegan/test.py @@ -22,17 +22,16 @@ import numpy as np from scipy.misc import imsave import paddle -import paddle.fluid as fluid from paddle.static import InputSpec as Input -from check import check_gpu, check_version +from check import check_gpu from cyclegan import Generator, GeneratorCombine import data as data def main(): place = paddle.set_device(FLAGS.device) - fluid.enable_dygraph(place) if FLAGS.dynamic else None + paddle.disable_static(place) if FLAGS.dynamic else None im_shape = [-1, 3, 256, 256] input_A = Input(im_shape, 'float32', 'input_A') @@ -104,5 +103,4 @@ if __name__ == "__main__": FLAGS = parser.parse_args() print(FLAGS) check_gpu(str.lower(FLAGS.device) == 'gpu') - check_version() main() diff --git a/cyclegan/train.py b/cyclegan/train.py index 656616bf51b464661490637b89583739c12191c5..3cecd1bc2fb04bd5bbb5219a45a6b6fcb8757110 100644 --- a/cyclegan/train.py +++ b/cyclegan/train.py @@ -23,10 +23,9 @@ import contextlib import time import paddle -import paddle.fluid as fluid from paddle.static import InputSpec as Input -from check import check_gpu, check_version +from check import check_gpu from cyclegan import Generator, Discriminator, GeneratorCombine, GLoss, DLoss import data as data @@ -39,17 +38,17 @@ def opt(parameters): lr = [1., 0.8, 0.6, 0.4, 0.2, 0.1] bounds = [i * step_per_epoch for i in bounds] lr = [i * lr_base for i in lr] - optimizer = fluid.optimizer.Adam( - learning_rate=fluid.layers.piecewise_decay( + optimizer = paddle.optimizer.Adam( + learning_rate=paddle.optimizer.lr_scheduler.PiecewiseLR( boundaries=bounds, values=lr), - parameter_list=parameters, + parameters=parameters, beta1=0.5) return optimizer def main(): place = paddle.set_device(FLAGS.device) - fluid.enable_dygraph(place) if FLAGS.dynamic else None + paddle.disable_static(place) if FLAGS.dynamic else None im_shape = [None, 3, 256, 256] input_A = Input(im_shape, 'float32', 'input_A') @@ -158,5 +157,4 @@ if __name__ == "__main__": FLAGS = parser.parse_args() print(FLAGS) check_gpu(str.lower(FLAGS.device) == 'gpu') - check_version() main()