mindspore NLP

import sys
import time
import pickle
import logging

from sklearn import metrics

import mindspore
import mindspore.nn as nn
from mindspore import Tensor
 
logging.basicConfig(
    format='33[92m%(asctime)s33[0m 33[94m%(levelname)s33[0m %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S',
    level=logging.INFO,
    stream=sys.stdout,
    # force=True,
)

from util.dump_data import get_train_dev_test
train_x,train_y,dev_x,dev_y,test_x,vocab_size = get_train_dev_test()
train_x,train_y,dev_x,dev_y,test_x = Tensor(train_x, mindspore.int32),Tensor(train_y, mindspore.int32),Tensor(dev_x, mindspore.int32),Tensor(dev_y, mindspore.int32),Tensor(test_x, mindspore.int32)

from util.easy_args import EasyArgs
# EAsyArgs 见 blog.csdn.net/int_main_Roland/article/details/124506877
args = EasyArgs()
args.vocab_size = vocab_size
args.sample_size = 180000
args.num_class = 10
args.pad_size = 30 # util.dump_data -> pad_cut -> sz_lm
args.embed_size = 1000
args.batch_size = 10000
args.epochs = 12
args.steps = args.epochs * (args.sample_size // args.batch_size)
args.hidden_channels = 10

class LSTM(nn.Cell):

    def __init__(self, args):
        super().__init__()
        embed_size,hidden_channels,num_class = args.embed_size,args.hidden_channels,args.num_class
        self.embed = nn.Embedding(vocab_size, embed_size)
        self.lstm = nn.LSTM(input_size=embed_size, hidden_size=hidden_channels, bidirectional=False)
        self.linear = nn.Dense(hidden_channels, num_class, has_bias=True)

    def construct(self, x):
        x = self.embed(x)
        x = x.transpose((1, 0, 2))
        z, _ = self.lstm(x)
        z = z[-1]
        y = self.linear(z)
        return y
#

criterion = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
optimizer = nn.AdamWeightDecay(net.trainable_params(), learning_rate=0.001)

from mindspore import context
context.set_context(mode=context.PYNATIVE_MODE)

net_with_criterion = nn.WithLossCell(net, criterion)
net_with_optimizer = nn.TrainOneStepCell(net_with_criterion, optimizer)

def save_curr_pred(net):
    if 'model_name' not in vars(args).keys():
        args.model_name = str(type(net)).split("'")[1].split(".")[1]
    net_with_optimizer.set_train(False)
    test_y_pred = net(test_x).asnumpy().argmax(axis=1)
    test_y_pred_list = test_y_pred.tolist()
    with open(f'./ckpt/{time.strftime("%Y_%m_%d_%H_%M_%S", time.localtime())}_{args.model_name} 191300059.txt', mode='wt') as fh:
    # with open(f'./ckpt/{args.model_name} 191300059.txt', mode='wt') as fh:
        for item in test_y_pred_list:
            fh.write(f'{str(item)}n')

def save_best_pred(net, acc):
    if 'best_acc' not in vars(args).keys():
        args.best_acc = 0.0
    if acc > args.best_acc:
        args.best_acc = acc
        save_curr_pred(net)

logging.info(f'total {args.steps:^5d}')
for step in range(args.steps):
    remainder = step % (args.sample_size // args.batch_size)
    left_bound = remainder * args.batch_size
    right_bound = (remainder + 1) * args.batch_size

    net_with_optimizer.set_train(True)
    loss = net_with_optimizer(train_x[left_bound:right_bound:1], train_y[left_bound:right_bound:1])
    logging.info(f'step {step:^5d} loss {loss.asnumpy():.5f}')

    # if (step + 1) % (args.sample_size // args.batch_size) == 0:
    if True:

        net_with_optimizer.set_train(False)
        dev_y_pred = net(dev_x).asnumpy().argmax(axis=1)
        acc = metrics.accuracy_score(dev_y.asnumpy(), dev_y_pred)
        logging.info(f'step {step:^5d} acc  {acc:.5f}')

        save_best_pred(net, acc)
#