解决Keras输入层维度不匹配：ValueError深度解析与实践

# 在模型定义前，确认训练数据的特征维度
print(f"训练数据X_train的特征维度: {X_train.shape[1]}")
model.add(Dense(64, activation='relu', input_dim=X_train.shape[1], kernel_regularizer=l2(0.1)))

# ... (模型编译和训练) ...

# 在预测前，确认待预测数据的特征维度
print(f"待预测数据dataframe的特征维度: {dataframe.shape[1]}")
valori = dataframe.values
prediction = model.predict(valori)[0][0]

import pandas as pd
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import Adam
from keras.regularizers import l2
import numpy as np

def carica_dataset():
    dataset = pd.read_csv("dataset.csv")
    return dataset

def carica_modello():
    dataset = carica_dataset()
    # 在训练数据上进行独热编码
    dataset_encoded = pd.get_dummies(dataset, columns=['Località'])

    # 保存训练数据的所有列名，包括独热编码后的列
    # 这将用于后续对用户输入数据进行对齐
    global training_columns
    training_columns = dataset_encoded.drop(columns=['Prezzo']).columns

    X = dataset_encoded.drop(columns=['Prezzo'])
    y = dataset_encoded['Prezzo']

    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42) # 增加random_state确保可复现性

    model = Sequential()
    # 使用X_train的实际列数作为input_dim
    model.add(Dense(64, activation='relu', input_dim=X_train.shape[1],  kernel_regularizer=l2(0.1)))
    model.add(Dropout(0.5))
    model.add(Dense(32, activation='relu',  kernel_regularizer=l2(0.1)))
    model.add(Dropout(0.5))
    model.add(Dense(16, activation='relu', kernel_regularizer=l2(0.1)))
    model.add(Dropout(0.5))
    model.add(Dense(8, activation='relu', kernel_regularizer=l2(0.1)))
    model.add(Dropout(0.5))
    model.add(Dense(1, activation='linear', kernel_regularizer=l2(0.1)))

    adam = Adam(learning_rate=0.001) # 建议指定学习率
    model.compile(loss='mean_squared_error', optimizer=adam, metrics=['mse']) # metrics='accuracy'不适用于回归问题

    print(f"模型训练前 X_train.shape: {X_train.shape}")
    model.fit(X_train, y_train, epochs=100, batch_size=64, verbose=0) # verbose=0 减少训练输出
    print(f"模型训练后 X_train.shape: {X_train.shape}")

    return model

# 全局变量用于存储训练时的列名
training_columns = None

dataset = carica_dataset()
model = carica_modello()

fields = {
    'Superficie': float,
    'Numero di stanze da letto': int,
    'Numero di bagni': int,
    'Anno di costruzione': int,
    'Località': str
}
user_data = {}

for key, value in fields.items():
    while True:
        try:
            user_input = input(f"Inserisci il valore di: {key}: ")
            user_data[key] = value(user_input)
            break
        except ValueError:
            print(f"Inserisci un valore valido per {key}")

dataframe = pd.DataFrame([user_data])

# 对用户输入数据进行独热编码
dataframe_encoded = pd.get_dummies(dataframe, columns=['Località'])

# 使用训练时的列名对用户输入数据进行对齐
# reindex会添加缺失的列并用NaN填充，或者删除多余的列
# fill_value=0 确保独热编码缺失的列填充为0
dataframe_aligned = dataframe_encoded.reindex(columns=training_columns, fill_value=0)

print(f"用户输入数据处理后 dataframe_aligned.shape: {dataframe_aligned.shape}")
print(f"用户输入数据处理后 dataframe_aligned.columns: {dataframe_aligned.columns.tolist()}")

valori = dataframe_aligned.values

prediction = model.predict(valori)[0][0]
print(f'La predizione del prezzo è: {prediction:.2f} €')

from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer

# ... (其他导入) ...

def carica_modello_with_encoder():
    dataset = carica_dataset()

    # 识别分类列和数值列
    categorical_features = ['Località']
    numerical_features = ['Superficie', 'Numero di stanze da letto', 'Numero di bagni', 'Anno di costruzione']

    # 创建一个预处理器，对分类特征进行独热编码，对数值特征不做处理
    # handle_unknown='ignore' 允许在预测时遇到训练集中未见的类别时，将其编码为全零向量，避免错误
    preprocessor = ColumnTransformer(
        transformers=[
            ('cat', OneHotEncoder(handle_unknown='ignore'), categorical_features)],
        remainder='passthrough' # 其他（数值）特征直接通过
    )

    # 在整个数据集上拟合预处理器
    global fitted_preprocessor
    fitted_preprocessor = preprocessor.fit(dataset[numerical_features + categorical_features])

    # 转换数据集
    X_processed = fitted_preprocessor.transform(dataset[numerical_features + categorical_features])
    y = dataset['Prezzo']

    # X_processed 现在是一个稀疏矩阵或Numpy数组，需要转换为DataFrame（如果需要列名）
    # 或者直接使用Numpy数组进行训练
    X_train, X_test, y_train, y_test = train_test_split(X_processed, y, random_state=42)

    model = Sequential()
    model.add(Dense(64, activation='relu', input_dim=X_train.shape[1],  kernel_regularizer=l2(0.1)))
    # ... (其他层) ...
    model.add(Dense(1, activation='linear', kernel_regularizer=l2(0.1)))

    adam = Adam(learning_rate=0.001)
    model.compile(loss='mean_squared_error', optimizer=adam, metrics=['mse'])

    print(f"模型训练前 X_train.shape: {X_train.shape}")
    model.fit(X_train, y_train, epochs=100, batch_size=64, verbose=0)
    print(f"模型训练后 X_train.shape: {X_train.shape}")

    return model

# 全局变量用于存储拟合好的预处理器
fitted_preprocessor = None

# ... (加载数据集，调用carica_modello_with_encoder) ...

# 用户输入数据处理
# ... (收集user_data) ...

dataframe = pd.DataFrame([user_data])
# 使用拟合好的预处理器转换用户输入数据
user_data_processed = fitted_preprocessor.transform(dataframe[numerical_features + categorical_features])

print(f"用户输入数据处理后 user_data_processed.shape: {user_data_processed.shape}")

prediction = model.predict(user_data_processed)[0][0]
print(f'La predizione del prezzo è: {prediction:.2f} €')