python怎么把序列在横坐标上归一化

要将序列在横坐标上归一化，可以使用NumPy库中的interp函数。该函数可以将一个序列按照一定比例插值，从而实现在横坐标上的归一化。

示例代码如下：

import numpy as np

# 假设原始序列为 x，长度为 n
x = np.arange(1, 11)
n = len(x)

# 将序列在横坐标上归一化成长度为 m 的新序列
m = 5
new_x = np.interp(np.linspace(0, n - 1, m), np.arange(n), x)

print(new_x)

在这个示例代码中，我们首先创建了一个原始序列 x，长度为 10。然后，我们通过 NumPy 的 linspace 函数生成了一个长度为 m 的等差数列，作为新序列的横坐标。接着，我们使用 interp 函数将原始序列按照比例插值到新序列上，得到了一个长度为 m 的归一化序列 new_x。最后，我们打印了 new_x 的结果。

运行上述代码，得到的输出结果为：

[ 1.    3.25  5.5   7.75 10.  ]

这个结果表示，原始序列 x 在横坐标上被归一化为了一个长度为 5 的新序列 new_x，每个位置的值分别为 1、3.25、5.5、7.75 和 10。

相关问题

写一段python代码，读取一个csv文件，该文件没有表头，第一列为时间编号,编号以1,2,3……这样自然数的形式出现，第二列为充电量数值，将该数据集的前90%划分为训练集，其余部分设置为测试集，利用L1正则化改进的lstm模型预测该时间序列，并打印rmse作为评价指标，并分别绘制训练集的真实值和预测值图片以及测试集的真实值和预测值图片，两张图片的横坐标单位为time/h，纵坐标单位为kwh

好的，以下是代码实现：

import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
from tensorflow.keras.regularizers import l1
import matplotlib.pyplot as plt

# 读取csv文件
data = pd.read_csv('data.csv', header=None)

# 取第二列作为特征值
values = data.iloc[:, 1].values.reshape(-1, 1)

# 归一化处理
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_values = scaler.fit_transform(values)

# 将数据集划分为训练集和测试集
train_size = int(len(scaled_values) * 0.9)
train_data = scaled_values[:train_size, :]
test_data = scaled_values[train_size:, :]

# 定义函数，将数据转换为时间序列和标签
def create_dataset(dataset, look_back=1):
    X, Y = [], []
    for i in range(len(dataset)-look_back):
        X.append(dataset[i:(i+look_back), 0])
        Y.append(dataset[i+look_back, 0])
    return np.array(X), np.array(Y)

# 定义时间步长
time_steps = 12

# 将数据转换为时间序列和标签
train_X, train_Y = create_dataset(train_data, time_steps)
test_X, test_Y = create_dataset(test_data, time_steps)

# 将数据转换为三维数组
train_X = np.reshape(train_X, (train_X.shape[0], train_X.shape[1], 1))
test_X = np.reshape(test_X, (test_X.shape[0], test_X.shape[1], 1))

# 定义L1正则化参数
l = 0.001

# 定义模型
model = Sequential()
model.add(LSTM(64, input_shape=(time_steps, 1), kernel_regularizer=l1(l)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')

# 训练模型
model.fit(train_X, train_Y, epochs=50, batch_size=64, verbose=2)

# 预测训练集和测试集
train_predict = model.predict(train_X)
test_predict = model.predict(test_X)

# 反归一化处理
train_predict = scaler.inverse_transform(train_predict)
train_Y = scaler.inverse_transform(train_Y.reshape(-1, 1))
test_predict = scaler.inverse_transform(test_predict)
test_Y = scaler.inverse_transform(test_Y.reshape(-1, 1))

# 计算RMSE
train_rmse = np.sqrt(np.mean(np.square(train_predict - train_Y)))
test_rmse = np.sqrt(np.mean(np.square(test_predict - test_Y)))
print('Train RMSE:', train_rmse)
print('Test RMSE:', test_rmse)

# 绘制训练集真实值和预测值的图像
train_plot = np.empty_like(scaled_values)
train_plot[:, :] = np.nan
train_plot[time_steps:len(train_predict)+time_steps, :] = train_predict
train_plot = scaler.inverse_transform(train_plot)

plt.figure(figsize=(10, 6))
plt.plot(values, label='True')
plt.plot(train_plot, label='Predicted')
plt.title('Training set')
plt.xlabel('time/h')
plt.ylabel('kwh')
plt.legend()
plt.show()

# 绘制测试集真实值和预测值的图像
test_plot = np.empty_like(scaled_values)
test_plot[:, :] = np.nan
test_plot[len(train_predict)+(time_steps*2):len(scaled_values), :] = test_predict
test_plot = scaler.inverse_transform(test_plot)

plt.figure(figsize=(10, 6))
plt.plot(values, label='True')
plt.plot(test_plot, label='Predicted')
plt.title('Testing set')
plt.xlabel('time/h')
plt.ylabel('kwh')
plt.legend()
plt.show()

需要注意的是，代码中的 `data.csv` 文件需要与代码放在同一个文件夹下，且数据集的第一列为时间编号，不需要作为特征值。另外，代码中的时间步长 `time_steps` 和 L1正则化参数 `l` 可以根据实际情况进行调整。

写一段python代码，读取一个csv文件，该文件没有表头，第一列为时间编号,编号以1,2,3……这样自然数的形式出现，第二列为充电量数值，将该数据集的前90%划分为训练集，其余部分设置为测试集，利用L1/L2正则化改进lstm模型，并用改进后的模型预测该时间序列，并打印rmse作为评价指标，并分别绘制训练集的真实值和预测值图片以及测试集的真实值和预测值图片，两张图片的横坐标单位为time/h，纵坐标单位为kwh

好的，下面是代码实现：

import pandas as pd
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, LSTM, Dropout
from keras import regularizers
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error
import matplotlib.pyplot as plt

# 读取数据
data = pd.read_csv('data.csv', header=None)
values = data.values[:, 1].astype('float32')  # 取第二列数据，即充电量数值
num_time_steps = len(values)  # 时间序列长度

# 将数据集划分为训练集和测试集
train_size = int(num_time_steps * 0.9)  # 前90%为训练集
train_data, test_data = values[:train_size], values[train_size:]

# 数据归一化
scaler = MinMaxScaler(feature_range=(0, 1))
train_data = scaler.fit_transform(train_data.reshape(-1, 1))
test_data = scaler.transform(test_data.reshape(-1, 1))

# 创建时间窗口数据
def create_dataset(data, window_size=1):
    X, y = [], []
    for i in range(len(data) - window_size):
        X.append(data[i:(i + window_size)])
        y.append(data[i + window_size])
    return np.array(X), np.array(y)

window_size = 24  # 时间窗口大小为24小时
train_X, train_y = create_dataset(train_data, window_size)
test_X, test_y = create_dataset(test_data, window_size)

# 构建LSTM模型
model = Sequential()
model.add(LSTM(32, input_shape=(window_size, 1), kernel_regularizer=regularizers.l1_l2(l1=0.01, l2=0.01)))
model.add(Dropout(0.2))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.summary()

# 训练模型
history = model.fit(train_X, train_y, epochs=100, batch_size=64, validation_split=0.1, verbose=2)

# 预测并计算RMSE
train_predict = scaler.inverse_transform(model.predict(train_X))
test_predict = scaler.inverse_transform(model.predict(test_X))
train_rmse = np.sqrt(mean_squared_error(train_y, train_predict))
test_rmse = np.sqrt(mean_squared_error(test_y, test_predict))
print('Train RMSE: %.3f' % train_rmse)
print('Test RMSE: %.3f' % test_rmse)

# 绘制训练集预测结果
plt.figure(figsize=(10, 6))
train_predict_plot = np.empty_like(values)
train_predict_plot[:window_size] = np.nan  # 前面的时间窗口数据不预测
train_predict_plot[window_size:train_size] = train_predict.reshape(-1)
plt.plot(values[:train_size], label='True Values')
plt.plot(train_predict_plot, label='Predicted Values')
plt.xlabel('Time/h')
plt.ylabel('kwh')
plt.title('Training Set')
plt.legend()
plt.show()

# 绘制测试集预测结果
plt.figure(figsize=(10, 6))
test_predict_plot = np.empty_like(values)
test_predict_plot[:train_size] = np.nan  # 测试集前面的数据不预测
test_predict_plot[train_size+window_size:] = test_predict.reshape(-1)
plt.plot(values[train_size:], label='True Values')
plt.plot(test_predict_plot, label='Predicted Values')
plt.xlabel('Time/h')
plt.ylabel('kwh')
plt.title('Test Set')
plt.legend()
plt.show()

代码中使用了L1/L2正则化来改进LSTM模型，并采用Dropout技术来防止过拟合。在训练模型后，使用预测结果和真实值计算RMSE作为评价指标，并分别绘制出训练集和测试集的真实值和预测值的图像。