|
- # ms
- import os,time
- import numpy as np
- import urllib.request
- from urllib.parse import urlparse
- import gzip
- import argparse
- import mindspore as ms
- import mindspore.dataset as ds
- import mindspore.nn as nn
- from mindspore import context
- from mindspore.train.serialization import load_checkpoint, load_param_into_net
- from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor
- from mindspore.train import Model
- from mindspore.common.initializer import TruncatedNormal
- import mindspore.dataset.vision.c_transforms as CV # import mindspore.dataset.transforms.vision.c_transforms as CV
- import mindspore.dataset.vision.c_transforms as C
- from mindspore.nn.metrics import Loss
- from mindspore.common import dtype as mstype
- from mindspore.nn.loss import SoftmaxCrossEntropyWithLogits, MSELoss
- from mindspore import Tensor
- from mindspore import dtype as mstype
-
- def fc_with_initialize(input_channels, out_channels):
- """Fc layer weight initial."""
- weight = weight_variable()
- bias = weight_variable()
- return nn.Dense(input_channels, out_channels, weight, bias)
- def weight_variable():
- """Weight initial."""
- return TruncatedNormal(0.02)
-
- a = np.random.rand(512,4096*4).astype(np.float32)
- a = Tensor(a)
- fc = fc_with_initialize(4096*4, 4096*4)
- b = fc(a)
- b[:10, :10]
-
- n_input = 463
- n_hidden = 20000
- n_output = 463
- device_target = 'Ascend'
- batch_size = 512
-
- np.random.seed(2021)
-
- class DatasetGenerator:
- def __init__(self, data):
- self.data = data
- self.label = data
-
- def __getitem__(self, index):
- return self.data[index], self.label[index]
-
- def __len__(self):
- return len(self.data)
-
- def To_ms_dataset(np_data):
- dataset_obj = DatasetGenerator(np_data)
- ms_dataset = ds.GeneratorDataset(dataset_obj, ["data", "label"]).shuffle(buffer_size=10000).batch(batch_size, drop_remainder=True)
- return ms_dataset
-
- ds_train = np.random.rand(512*10, n_input).astype(np.float32)
- ds_eval = np.random.rand(512*10, n_input).astype(np.float32)
- ds_train = To_ms_dataset(ds_train)
- ds_eval = To_ms_dataset(ds_eval)
-
- def conv(in_channels, out_channels, kernel_size, stride=1, padding=0):
- """Conv layer weight initial."""
- weight = weight_variable()
- return nn.Conv2d(in_channels, out_channels,
- kernel_size=kernel_size, stride=stride, padding=padding,
- weight_init=weight, has_bias=False, pad_mode="valid")
-
-
- def fc_with_initialize(input_channels, out_channels):
- """Fc layer weight initial."""
- weight = weight_variable()
- bias = weight_variable()
- return nn.Dense(input_channels, out_channels, weight, bias)
-
-
- def weight_variable():
- """Weight initial."""
- return TruncatedNormal(0.02)
-
-
- class MLPNet(nn.Cell):
- # define the operator required
- def __init__(self):
- super().__init__()
- self.fc1 = fc_with_initialize(n_input, n_hidden)
- self.fc2 = fc_with_initialize(n_hidden, n_output)
- self.relu = nn.ReLU()
-
- # use the preceding operators to construct networks
- def construct(self, x):
- x = self.fc1(x)
- x = self.relu(x)
- x = self.fc2(x)
- return x
-
-
- def train_net(model, epoch_size, ds_train, ckpoint_cb, sink_mode):
- """Define the training method."""
- print("============== Starting Training ==============")
- model.train(epoch_size, ds_train, callbacks=[ckpoint_cb, LossMonitor()], dataset_sink_mode=sink_mode)
-
-
- def test_net(network, model, ds_eval):
- """Define the evaluation method."""
- print("============== Starting Testing ==============")
- # load the saved model for evaluation
- param_dict = load_checkpoint("checkpoint_mlpnet-1_10.ckpt")
- # load parameter to the network
- load_param_into_net(network, param_dict)
- loss = model.eval(ds_eval, dataset_sink_mode=False)
- print("============== Loss:{} ==============".format(loss))
-
-
- if __name__ == "__main__":
- context.set_context(mode=context.GRAPH_MODE, device_target='Ascend')
- dataset_sink_mode = False#not device_target == "CPU"
- # learning rate setting
- lr = 0.01
- momentum = 0.9
- epoch_size = 2
- # define the loss function
- net_loss = MSELoss(reduction='mean')
- # create the network
- network = MLPNet()
- # define the optimizer
- net_opt = nn.Momentum(network.trainable_params(), lr, momentum)
- config_ck = CheckpointConfig(save_checkpoint_steps=10000, keep_checkpoint_max=10)
- # save the network model and parameters for subsequence fine-tuning
- ckpoint_cb = ModelCheckpoint(prefix="checkpoint_mlpnet", config=config_ck)
- # group layers into an object with training and evaluation features
- model = Model(network, net_loss, net_opt, metrics={"Loss": Loss()})
- start = time.time()
- train_net(model, epoch_size, ds_train, ckpoint_cb, dataset_sink_mode)
- end = time.time()
- print('train time used:', end-start)
- test_net(network, model, ds_eval)
|