mindspore回归代码计算不正确

最新推荐文章于 2024-07-25 22:05:25 发布

小乐快乐

最新推荐文章于 2024-07-25 22:05:25 发布

阅读量120

点赞数 1

文章标签：回归数据挖掘人工智能

本文链接：https://blog.csdn.net/weixin_45666880/article/details/140211619

版权

问题描述

数据共3列，前两列为特征值，第3列为标签。请问代码有没有问题？计算结果一列输出基本都是一样的数值，实际是有很大区别的，pytorch实现的代码计算正确。

import os


import mindspore as ms

import mindspore.dataset as ds

import mindspore.nn as nn

import numpy as np

import pandas as pd

from mindspore import load_checkpoint, load_param_into_net

from mindspore import ops

from mindspore import Model, CheckpointConfig, ModelCheckpoint, LossMonitor

# from sklearn.metrics import mean_absolute_percentage_error

# from sklearn.preprocessing import PolynomialFeatures


ms.set_context(device_target="GPU")

ms.run_check()

# is_train = 0

is_train = 1  # not load ckpt


batchsize = 16


cnn_channel = 32

expansion = 2

L = 2



# is_train = 2 #load ckpt



def create_dataset():

    file_data = pd.read_csv("Sheet1.csv", header=None, sep=',', dtype=np.float32)

    # file_data = pd.read_csv("Sheet1.csv")

    xx = np.array(file_data)

    # xx = file_data

    print(xx.dtype, xx.shape)

    dataset = xx[:, 0:2]

    label = xx[:, 2]

    print(dataset.dtype)


    # poly_reg = PolynomialFeatures(degree=4)

    # poly_dataset = poly_reg.fit_transform(dataset)

    # poly_dataset = np.reshape(poly_dataset,(len(poly_dataset),1,5,3))

    # dataset = poly_dataset

    dataset = np.reshape(dataset, (-1, 1, 2))

    print("dataset.type and shape", dataset, dataset.shape)


    dataset = ds.NumpySlicesDataset(data=(dataset, label), column_names=["data", "label"], shuffle=False)


  


    print(dataset.get_dataset_size())

    train_dataset, test_dataset = dataset.split([0.8, 0.2])

    # dataset = dataset.batch(64, True)

    # for data, label in dataset:

    #     print("data:", data, label)

    #     print(data.shape, label.shape)

    #     break

    #

    # print(dataset.batch(64, True).get_batch_size())

    # print(dataset.get_batch_size())

    # print("train_dataset_size=",train_dataset.get_dataset_size())

    for data, label in train_dataset:

        print("train_data:", data, label)

        print(data.shape, label.shape)

        print(data.dtype, label.dtype)

        break

    for data, label in test_dataset:

        print("test_data:", data, label)

        print(data.shape, label.shape)

        break

    return train_dataset, test_dataset



# create_dataset()

train_dataset, test_dataset = create_dataset()

# output_data = test_dataset

train_dataset = train_dataset.batch(batchsize, True)

test_dataset = test_dataset.batch(batchsize, True)

# print(train_dataset.output_types)

# print(train_dataset.output_shapes)


step_size_train = train_dataset.get_dataset_size()

step_size_val = test_dataset.get_dataset_size()

print(step_size_train, step_size_val)

print(train_dataset.get_col_names())



# exit()



class cnn1net(nn.Cell):

    def __init__(self) -> None:

        super(cnn1net, self).__init__()


        self.relu = nn.ReLU()

        # self.relu = nn.PReLU()

        # self.relu = nn.Tanh()

        # 第一个卷积层，输入channel为1,输出channel为64

        self.conv1 = nn.Conv1d(1, 32, kernel_size=1, stride=1, has_bias=True, weight_init='Normal', bias_init='Normal')

        self.conv2 = nn.Conv1d(32, 64, kernel_size=1, has_bias=True, weight_init='Normal', bias_init='Normal')

        self.conv3 = nn.Conv1d(64, 128, kernel_size=1, has_bias=True, weight_init='Normal', bias_init='Normal')

        # flatten层

        self.flatten = nn.Flatten()

        # 全连接层

        self.fc1 = nn.Dense(in_channels=256, out_channels=256, has_bias=True, weight_init='Normal', bias_init='Normal')

        self.fc2 = nn.Dense(in_channels=256, out_channels=128, has_bias=True, weight_init='Normal', bias_init='Normal')

        self.fc3 = nn.Dense(in_channels=128, out_channels=128, has_bias=True, weight_init='Normal', bias_init='Normal')

        self.fc4 = nn.Dense(in_channels=64, out_channels=1, has_bias=True, weight_init='Normal', bias_init='Normal')


    def construct(self, x):

        x = self.conv1(x)

        x = self.relu(x)

        x = self.conv2(x)

        x = self.relu(x)

        x = self.conv3(x)

        x = self.relu(x)


        x = self.flatten(x)

        x = self.fc1(x)

        x = self.relu(x)

        x = self.fc2(x)

        x = self.relu(x)

        x = self.fc3(x)

        x = self.relu(x)


        output = self.fc4(x)


        return output



def _cnn1net(model_url: str, pretrained: bool, pretrained_ckpt: str):

    model = cnn1net()


    if pretrained:

        # 加载预训练模型

        param_dict = load_checkpoint(pretrained_ckpt)

        load_param_into_net(model, param_dict)


    return model



# num_classes>1时，该程序为分类，num_classes=1时，该程序为预测。

def cnn1net8(pretrained: bool = False):

    """cnn1net8模型"""

    cnn1net8_ckpt = "./BestCheckpoint/cnn1net-best-rmse.ckpt"

    return _cnn1net("./", pretrained, cnn1net8_ckpt)



# 定义cnn1net8网络

# network = cnn1net8(pretrained=False)

network = cnn1net()

num_epochs = 50

# 设置学习率


# 定义优化器和损失函数

opt = nn.Adam(params=network.trainable_params(), learning_rate=0.0001)

loss_fn = nn.RMSELoss()


# config_ = CheckpointConfig(save_checkpoint_steps=step_size_train)

# ckpt_callback = ModelCheckpoint('PPP', directory="./checkpoint", config=config_)

# loss_callback = LossMonitor(step_size_train)

#

# trainer = Model(network, loss_fn=loss_fn, optimizer=opt, metrics={'accuracy'})

#

# trainer.fit(5, train_dataset, test_dataset, callbacks=[ckpt_callback, loss_callback])

# acc = trainer.eval(test_dataset)

# print('acc', acc)



def forward_fn(inputs, targets):

    output = network(inputs)

    loss = loss_fn(output, targets)

    return loss, output



grad_fn = ms.value_and_grad(forward_fn, None, opt.parameters, has_aux=True)



def train_step(inputs, targets):

    (loss, output), grads = grad_fn(inputs, targets)

    # print("output:", output)

    # print('targets', targets)

    # print('grad:', grads)

    opt(grads)

    return loss

#

#

# # 创建迭代器

data_loader_train = train_dataset.create_tuple_iterator()

data_loader_val = test_dataset.create_tuple_iterator()



#

# 最佳模型存储路径

best_acc = 1.0

best_ckpt_dir = "./BestCheckpoint"

best_ckpt_path = "./BestCheckpoint/cnn1net8-best-rmse.ckpt"


if not os.path.exists(best_ckpt_dir):

    os.mkdir(best_ckpt_dir)



def train(data_loader, epoch):

    """模型训练"""

    losses = []

    labels_mean = []

    network.set_train()


    # summary_collector = ms.SummaryCollector("./summary_dir")


    for i, (data_s, labels) in enumerate(data_loader):

        loss = train_step(data_s, labels)


        # if i % 10 == 0 or i == step_size_train - 1:

        #     print('Epoch: [%3d/%3d], Steps: [%3d/%3d], Train Loss: [%8.6f], Label mean: [%8.6f], percent:[%8.6f]' %

        #           (epoch + 1, num_epochs, i + 1, step_size_train, loss, ops.mean(labels), loss / ops.mean(labels)))

        # print(datas.shape)

        losses.append(loss)

        labels_mean.append(ops.mean(labels))


    return sum(losses) / sum(labels_mean)

    # return sum(losses) / len(losses) /sum(labels_mean)


#

def evaluate(data_loader):

    """模型验证"""

    losses = []

    labels = []

    outputs = []

    data_s = []

    network.set_train(False)

    for data, label in data_loader:

        output = network(data)

        loss = loss_fn(output, label)

        losses.append(loss)

        labels.append(label)

        outputs.append(output)

        data_s.append(data)


    data = np.array(data_s, np.float32)

    data = np.reshape(data, (-1, 1, 2))

    data = np.reshape(data, (-1, 2))

    # print(data.shape)

    # print(data)

    # print(labels[1].shape, labels.__sizeof__())

    # print(outputs[1].shape)

    output = np.array(outputs, np.float32)

    # print(output.shape)

    output = output.reshape(step_size_val * batchsize, )

    # print(output.shape)

    # print(output)

    label = np.array(labels, np.float32)

    # print(label.shape)

    label = label.reshape(step_size_val * batchsize, )

    # print(label.shape)

    # print(label)

    data_csv = np.append(data, label.reshape(-1, 1), axis=1)

    data_csv = np.append(data_csv, output.reshape(-1, 1), axis=1)

    print("datacsv.shape", data_csv.shape)


    df = pd.DataFrame(data_csv)

    df.to_csv('output_label.csv', index=False)

    return sum(np.abs(output - label)) / sum(label)

    # return sum(losses)/len(losses)

    # return mean_absolute_percentage_error(label, output)



evaluate(data_loader_val)


# 开始循环训练

print("Start Training Loop ...")


for epoch in range(num_epochs):

    curr_loss = train(data_loader_train, epoch)

    curr_acc = evaluate(data_loader_val)


    print("-" * 50)

    print("Epoch: [%3d/%3d], Average Train Loss percent: [%8.6f], Accuracy percent: [%8.6f]" % (

        epoch + 1, num_epochs, curr_loss, curr_acc))

    print("-" * 50)

    # 保存当前预测准确率最高的模型

    if curr_acc < best_acc:

        best_acc = curr_acc

        ms.save_checkpoint(network, best_ckpt_path)


print("-" * 80)

print("End of validation the best Accuracy is: best_acc: [%8.6f]" % (best_acc))

(data, label.reshape(-1, 1), axis=1)

    data_csv = np.append(data_csv, output.reshape(-1, 1), axis=1)

    print("datacsv.shape", data_csv.shape)


    df = pd.DataFrame(data_csv)

    df.to_csv('output_label.csv', index=False)