From 00a836be161709bd2e5d73476dd45ffbda8fe676 Mon Sep 17 00:00:00 2001 From: Xie Zhongle Date: Tue, 2 Dec 2025 20:41:58 +0800 Subject: [PATCH] Add the generative model for the peft example --- examples/singa_peft/examples/model/vanilla.py | 175 ++++++++++++++++++ 1 file changed, 175 insertions(+) create mode 100644 examples/singa_peft/examples/model/vanilla.py diff --git a/examples/singa_peft/examples/model/vanilla.py b/examples/singa_peft/examples/model/vanilla.py new file mode 100644 index 0000000000..49c8ec43d1 --- /dev/null +++ b/examples/singa_peft/examples/model/vanilla.py @@ -0,0 +1,175 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# + +from singa import device +from singa import opt +from singa import tensor + +import argparse +import matplotlib.pyplot as plt +import numpy as np +import os +from model import gan_mlp +from utils import load_data +from utils import print_log + + +class VANILLA(): + + def __init__(self, + dev, + rows=28, + cols=28, + channels=1, + noise_size=100, + hidden_size=128, + batch=128, + interval=1000, + learning_rate=0.001, + iterations=1000000, + dataset_filepath='mnist.pkl.gz', + file_dir='vanilla_images/'): + self.dev = dev + self.rows = rows + self.cols = cols + self.channels = channels + self.feature_size = self.rows * self.cols * self.channels + self.noise_size = noise_size + self.hidden_size = hidden_size + self.batch = batch + self.batch_size = self.batch // 2 + self.interval = interval + self.learning_rate = learning_rate + self.iterations = iterations + self.dataset_filepath = dataset_filepath + self.file_dir = file_dir + self.model = gan_mlp.create_model(noise_size=self.noise_size, + feature_size=self.feature_size, + hidden_size=self.hidden_size) + + def train(self): + train_data, _, _, _, _, _ = load_data(self.dataset_filepath) + dev = device.create_cuda_gpu_on(0) + dev.SetRandSeed(0) + np.random.seed(0) + + # sgd = opt.SGD(lr=self.learning_rate, momentum=0.9, weight_decay=1e-5) + sgd = opt.Adam(lr=self.learning_rate) + + noise = tensor.Tensor((self.batch_size, self.noise_size), dev, + tensor.float32) + real_images = tensor.Tensor((self.batch_size, self.feature_size), dev, + tensor.float32) + real_labels = tensor.Tensor((self.batch_size, 1), dev, tensor.float32) + fake_labels = tensor.Tensor((self.batch_size, 1), dev, tensor.float32) + + # attached model to graph + self.model.set_optimizer(sgd) + self.model.compile([noise], + is_train=True, + use_graph=False, + sequential=True) + + real_labels.set_value(1.0) + fake_labels.set_value(0.0) + + for iteration in range(self.iterations): + idx = np.random.randint(0, train_data.shape[0], self.batch_size) + real_images.copy_from_numpy(train_data[idx]) + + self.model.train() + + # Training the Discriminative Net + _, d_loss_real = self.model.train_one_batch_dis( + real_images, real_labels) + + noise.uniform(-1, 1) + fake_images = self.model.forward_gen(noise) + _, d_loss_fake = self.model.train_one_batch_dis( + fake_images, fake_labels) + + d_loss = tensor.to_numpy(d_loss_real)[0] + tensor.to_numpy( + d_loss_fake)[0] + + # Training the Generative Net + noise.uniform(-1, 1) + _, g_loss_tensor = self.model.train_one_batch( + noise, real_labels) + + g_loss = tensor.to_numpy(g_loss_tensor)[0] + + if iteration % self.interval == 0: + self.model.eval() + self.save_image(iteration) + print_log(' The {} iteration, G_LOSS: {}, D_LOSS: {}'.format( + iteration, g_loss, d_loss)) + + def save_image(self, iteration): + demo_row = 5 + demo_col = 5 + if not hasattr(self, "demo_noise"): + self.demo_noise = tensor.Tensor( + (demo_col * demo_row, self.noise_size), dev, tensor.float32) + self.demo_noise.uniform(-1, 1) + gen_imgs = self.model.forward_gen(self.demo_noise) + gen_imgs = tensor.to_numpy(gen_imgs) + show_imgs = np.reshape( + gen_imgs, (gen_imgs.shape[0], self.rows, self.cols, self.channels)) + fig, axs = plt.subplots(demo_row, demo_col) + cnt = 0 + for r in range(demo_row): + for c in range(demo_col): + axs[r, c].imshow(show_imgs[cnt, :, :, 0], cmap='gray') + axs[r, c].axis('off') + cnt += 1 + fig.savefig("{}{}.png".format(self.file_dir, iteration)) + plt.close() + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description='Train GAN over MNIST') + parser.add_argument('filepath', type=str, help='the dataset path') + parser.add_argument('--use_gpu', action='store_true') + args = parser.parse_args() + + if args.use_gpu: + print('Using GPU') + dev = device.create_cuda_gpu() + else: + print('Using CPU') + dev = device.get_default_device() + + if not os.path.exists('vanilla_images/'): + os.makedirs('vanilla_images/') + + rows = 28 + cols = 28 + channels = 1 + noise_size = 100 + hidden_size = 128 + batch = 128 + interval = 1000 + learning_rate = 0.0005 + iterations = 1000000 + dataset_filepath = 'mnist.pkl.gz' + file_dir = 'vanilla_images/' + vanilla = VANILLA(dev, rows, cols, channels, noise_size, hidden_size, batch, + interval, learning_rate, iterations, dataset_filepath, + file_dir) + vanilla.train()