python中dict转化为numpy张量

可以使用numpy的array函数将dict转化为numpy张量。

例如，假设有以下字典：

my_dict = {'a': [1, 2, 3], 'b': [4, 5, 6]}

可以使用以下代码将其转换为numpy张量：

import numpy as np

my_array = np.array(list(my_dict.values()))

输出：

array([[1, 2, 3],
       [4, 5, 6]])

其中，list(my_dict.values())将字典的值作为列表返回，然后使用np.array函数将列表转换为numpy张量。

相关问题

pytorch中使用了numpy函数如何导出为onnx

### 回答1：
在 PyTorch 中使用 numpy 函数并不会影响导出 ONNX 模型的过程。可以使用 PyTorch 的 torch.onnx.export() 函数将模型导出为 ONNX 格式。使用方法如下:

import torch.onnx

# Define the model
model = ...

# Input to the model
x = ...

# Export the model
torch.onnx.export(model, x, "model.onnx")

导出模型时，可以通过指定参数 `input_names` 和 `output_names` 来命名输入和输出节点。

需要注意的是，如果模型中使用了非 ONNX 原生支持的层或操作，那么在导出模型时可能会抛出异常。

### 回答2：
在PyTorch中，可以使用torch.onnx模块将使用了numpy函数的模型导出为ONNX格式。下面是导出过程的简要步骤：

1. 首先，确保已经正确安装了PyTorch和ONNX的库。

2. 加载已经训练好的PyTorch模型并将其转换为推理模式。可以使用torch.load()函数加载模型的参数，并通过model.eval()方法将模型设置为推理模式。

3. 创建一个输入示例，它是一个PyTorch张量，具有与模型的输入形状相匹配的大小。

4. 使用torch.onnx.export()函数将PyTorch模型导出为ONNX模型。此函数需要提供导出模型的文件路径、输入示例、模型、模型的输入名称列表和动态轴的形状（如果有）。

以下是一个示例代码：

import torch
import onnx
import numpy as np

# 加载训练好的模型
model = torch.load('model.pth')
model.eval()

# 创建一个随机输入示例
input_shape = (1, 3, 224, 224)
example_input = torch.randn(*input_shape)

# 导出模型为ONNX格式
onnx_path = 'model.onnx'
input_names = ['input']
output_names = ['output']
dynamic_axes = {'input': {0: 'batch'}, 'output': {0: 'batch'}}
torch.onnx.export(model, example_input, onnx_path, input_names=input_names, output_names=output_names, dynamic_axes=dynamic_axes)

在导出过程中，PyTorch会自动将numpy函数转换为等效的ONNX操作，以确保模型的行为在PyTorch和ONNX之间保持一致。导出的ONNX模型可以用于在其他支持ONNX的深度学习框架中进行推理。

### 回答3：
在PyTorch中，可以使用`torch.onnx.export()`函数将使用了NumPy函数的模型导出为ONNX格式。

首先，确保已经安装了`onnx`和`onnxruntime`库。接下来，按照以下步骤导出模型：

1. 定义PyTorch模型，并加载训练好的权重参数。
2. 创建一个输入示例`dummy_input`，该输入示例应该是与模型输入具有相同形状的张量。
3. 使用`torch.onnx.export()`函数导出模型。将模型对象、输入示例、导出路径、输入和输出的名称作为参数传递给该函数。

下面是一个示例代码：

import torch
import torch.onnx as onnx
import numpy as np

# Step 1: 定义和加载模型
class MyModel(torch.nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        # 模型定义
        
    def forward(self, x):
        # 模型前向传播逻辑
        return x

model = MyModel()
model.load_state_dict(torch.load('model_weights.pth'))

# Step 2: 创建输入示例
dummy_input = torch.from_numpy(np.random.randn(1, input_shape)).float()

# Step 3: 导出模型
onnx_path = 'model.onnx'
torch.onnx.export(model, dummy_input, onnx_path, input_names=['input'], output_names=['output'])

print("模型已成功导出为ONNX格式。")

在上述示例中，`MyModel`类代表了你模型的定义，你需要根据具体模型进行修改。`model_weights.pth`是训练好的权重文件的路径。

最后，导出的ONNX模型将保存在`model.onnx`的路径下。你可以使用ONNX运行时进行推理和部署。

写一个python Flask销售预测系统中，有一个suanfa.py文件：先读取shuju.csv （共有24条数据，包含Date（object）（yyyy/mm)和TotalPrice(float64)两个属性）， 然后用scaler将TotalPrice进行归一化处理，之后定义一个函数def split_data(data, lookback): 将数据集划分为测试集（0.2）和训练集（0.8），data_raw = data.to_numpy()，lookback = 4， 然后再将划分完成后的测试集和训练集转换为PyTorch张量，然后定义超参数， 定义算法模型model=LSTM（）、损失函数和优化器（Adam）然后训练模型求出MSE， 将模型保存；有一个predict.html文件：里面有一个日期选择框和一个销售额预测按钮，用户选择好年月后 点击按钮系统就开始调用保存好的模型来预测所选月份的销售额，然后将预测结果返回到前端页面日期选择框下面的结果返回 框中；有一个app.py文件：定义路径。用flask和bootstrap、LayUI写出完整详细代码

suanfa.py代码：

import pandas as pd
import numpy as np
import torch
import torch.nn as nn
from sklearn.preprocessing import MinMaxScaler

# 读取数据
data = pd.read_csv('shuju.csv')
# 归一化处理
scaler = MinMaxScaler()
data['TotalPrice'] = scaler.fit_transform(data['TotalPrice'].values.reshape(-1, 1))

# 划分数据集
def split_data(data, lookback):
    data_raw = data.to_numpy()
    data = []
    for index in range(len(data_raw) - lookback):
        data.append(data_raw[index: index + lookback])
    data = np.array(data)
    test_size = int(np.round(0.2 * data.shape[0]))
    train_size = data.shape[0] - test_size
    x_train = torch.tensor(data[:train_size, :-1, :])
    y_train = torch.tensor(data[:train_size, -1, :])
    x_test = torch.tensor(data[train_size:, :-1, :])
    y_test = torch.tensor(data[train_size:, -1, :])
    return x_train, y_train, x_test, y_test

# 超参数
input_size = 1
hidden_size = 32
num_layers = 2
output_size = 1
num_epochs = 100
learning_rate = 0.01

# 定义模型
class LSTM(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super(LSTM, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)
        out, _ = self.lstm(x, (h0, c0))
        out = out[:, -1, :]
        out = self.fc(out)
        return out

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = LSTM(input_size, hidden_size, num_layers, output_size).to(device)

# 损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
x_train, y_train, x_test, y_test = split_data(data, lookback=4)
for epoch in range(num_epochs):
    inputs = x_train.to(device)
    targets = y_train.to(device)
    outputs = model(inputs)
    loss = criterion(outputs, targets)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if (epoch + 1) % 10 == 0:
        print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')

# 保存模型
torch.save(model.state_dict(), 'model.pt')

predict.html代码：

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>销售预测系统</title>
    <!-- 引入layui样式 -->
    <link rel="stylesheet" href="https://www.layuicdn.com/layui/css/layui.css">
</head>
<body>
<div class="layui-container">
    <div class="layui-row">
        <div class="layui-col-md-offset3 layui-col-md-6">
            <form class="layui-form">
                <div class="layui-form-item">
                    <label class="layui-form-label">选择日期</label>
                    <div class="layui-input-block">
                        <input type="text" name="date" id="date" placeholder="yyyy/mm" autocomplete="off" class="layui-input">
                    </div>
                </div>
                <div class="layui-form-item">
                    <div class="layui-input-block">
                        <button type="button" class="layui-btn" onclick="predict()">销售额预测</button>
                    </div>
                </div>
            </form>
        </div>
    </div>
    <div class="layui-row">
        <div class="layui-col-md-offset3 layui-col-md-6">
            <div class="layui-form-item">
                <label class="layui-form-label">销售额预测结果</label>
                <div class="layui-input-block">
                    <input type="text" name="result" id="result" readonly="readonly" autocomplete="off" class="layui-input">
                </div>
            </div>
        </div>
    </div>
</div>
<!-- 引入layui JS -->
<script src="https://www.layuicdn.com/layui/layui.js"></script>
<script>
    function predict() {
        var date = $("#date").val();
        $.ajax({
            type: "POST",
            url: "/predict",
            data: {"date": date},
            success: function (data) {
                $("#result").val(data);
            }
        });
    }
</script>
</body>
</html>

app.py代码：

from flask import Flask, render_template, request, jsonify
import pandas as pd
import numpy as np
import torch
from sklearn.preprocessing import MinMaxScaler
from suanfa import LSTM

app = Flask(__name__)

# 加载模型
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = LSTM(input_size=1, hidden_size=32, num_layers=2, output_size=1).to(device)
model.load_state_dict(torch.load('model.pt'))

# 读取数据并归一化处理
data = pd.read_csv('shuju.csv')
scaler = MinMaxScaler()
data['TotalPrice'] = scaler.fit_transform(data['TotalPrice'].values.reshape(-1, 1))

# 定义预测函数
def predict(date):
    # 获取前4个月的销售额数据
    last_4_month = []
    for i in range(4):
        year, month = date.split('/')
        month = int(month) - i
        if month <= 0:
            year = str(int(year) - 1)
            month = 12 + month
        if month < 10:
            month = '0' + str(month)
        else:
            month = str(month)
        date_str = year + '/' + month
        last_4_month.append(data[data['Date'] == date_str]['TotalPrice'].values[0])
    last_4_month.reverse()
    input_data = torch.tensor(last_4_month).view(1, 4, 1).float().to(device)
    # 模型预测
    with torch.no_grad():
        output = model(input_data)
    output = scaler.inverse_transform(output.cpu().numpy())[0][0]
    return round(output, 2)

# 定义路由
@app.route('/')
def index():
    return render_template('predict.html')

@app.route('/predict', methods=['POST'])
def predict_result():
    date = request.form.get('date')
    result = predict(date)
    return jsonify(result)

if __name__ == '__main__':
    app.run(debug=True)

在运行完以上代码后，通过访问http://localhost:5000/即可进入销售预测系统。用户选择好年月后点击预测按钮，系统就会调用保存好的模型来预测所选月份的销售额，并将预测结果显示在页面下方的结果返回框中。