# 手写数字识别神经网络示例（使用Keras）
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import matplotlib.pyplot as plt

# 设置随机种子保证可复现性
np.random.seed(42)
tf.random.set_seed(42)

# 1. 加载和预处理数据
print("1. 加载MNIST数据集...")
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# 数据标准化
x_train = x_train.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0

# 调整数据形状（添加通道维度）
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)

# 将标签转换为one-hot编码
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

print(f"训练集形状: {x_train.shape}")
print(f"测试集形状: {x_test.shape}")

# 2. 构建神经网络模型
print("\n2. 构建神经网络模型...")
model = keras.Sequential([
    # 输入层：28x28像素的图像
    layers.Input(shape=(28, 28, 1)),
    
    # 第一个卷积层
    layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
    layers.MaxPooling2D(pool_size=(2, 2)),
    
    # 第二个卷积层
    layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
    layers.MaxPooling2D(pool_size=(2, 2)),
    
    # 展平层
    layers.Flatten(),
    
    # 防止过拟合的Dropout层
    layers.Dropout(0.5),
    
    # 全连接输出层
    layers.Dense(10, activation="softmax")
])

# 3. 编译模型
print("\n3. 编译模型...")
model.compile(
    loss="categorical_crossentropy",
    optimizer="adam",
    metrics=["accuracy"]
)

# 显示模型架构
model.summary()

# 4. 训练模型
print("\n4. 训练模型...")
history = model.fit(
    x_train, y_train,
    batch_size=128,
    epochs=10,
    validation_split=0.1,
    verbose=1
)

# 5. 评估模型
print("\n5. 评估模型性能...")
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0)
print(f"测试集准确率: {test_acc:.4f}")
print(f"测试集损失: {test_loss:.4f}")

# 6. 可视化训练过程
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='训练准确率')
plt.plot(history.history['val_accuracy'], label='验证准确率')
plt.title('模型准确率')
plt.xlabel('Epoch')
plt.ylabel('准确率')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='训练损失')
plt.plot(history.history['val_loss'], label='验证损失')
plt.title('模型损失')
plt.xlabel('Epoch')
plt.ylabel('损失')
plt.legend()

plt.tight_layout()
plt.show()

# 7. 保存模型
model.save("mnist_cnn_model.h5")
print("模型已保存为 'mnist_cnn_model.h5'")

# 房价预测回归神经网络
import pandas as pd
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt

# 数据预处理函数
def preprocess_housing_data(data_path):
    """加载和预处理房价数据"""
    # 加载数据
    df = pd.read_csv(data_path)
    
    # 处理缺失值
    df = df.fillna(df.median())
    
    # 特征和标签分离
    X = df.drop('price', axis=1)
    y = df['price'].values
    
    # 标准化特征
    scaler_X = StandardScaler()
    X_scaled = scaler_X.fit_transform(X)
    
    # 标准化标签
    scaler_y = StandardScaler()
    y_scaled = scaler_y.fit_transform(y.reshape(-1, 1)).flatten()
    
    return X_scaled, y_scaled, scaler_X, scaler_y

# 构建回归模型
def build_regression_model(input_dim):
    """构建回归神经网络模型"""
    model = keras.Sequential([
        layers.Dense(64, activation='relu', input_shape=(input_dim,)),
        layers.Dropout(0.2),
        layers.Dense(32, activation='relu'),
        layers.Dropout(0.2),
        layers.Dense(16, activation='relu'),
        layers.Dense(1)  # 回归任务，无激活函数
    ])
    
    return model

# 主程序
def main():
    print("房价预测神经网络模型")
    
    # 1. 数据准备
    print("\n1. 准备数据...")
    # 这里假设数据文件路径
    # X, y, scaler_X, scaler_y = preprocess_housing_data('housing_data.csv')
    
    # 创建示例数据（实际使用时替换为真实数据）
    np.random.seed(42)
    n_samples = 1000
    n_features = 10
    
    X = np.random.randn(n_samples, n_features)
    y = 100 + 50 * X[:, 0] + 30 * X[:, 1] + 20 * X[:, 2] + np.random.randn(n_samples) * 10
    
    # 数据分割
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )
    
    # 2. 构建模型
    print("\n2. 构建神经网络...")
    model = build_regression_model(n_features)
    
    # 3. 编译模型
    model.compile(
        optimizer=keras.optimizers.Adam(learning_rate=0.001),
        loss='mse',
        metrics=['mae']
    )
    
    # 4. 训练模型
    print("\n3. 训练模型...")
    history = model.fit(
        X_train, y_train,
        epochs=100,
        batch_size=32,
        validation_split=0.2,
        verbose=1,
        callbacks=[
            keras.callbacks.EarlyStopping(
                patience=10,
                restore_best_weights=True
            )
        ]
    )
    
    # 5. 评估模型
    print("\n4. 评估模型...")
    test_loss, test_mae = model.evaluate(X_test, y_test, verbose=0)
    print(f"测试集MSE: {test_loss:.4f}")
    print(f"测试集MAE: {test_mae:.4f}")
    
    # 6. 预测示例
    print("\n5. 预测示例...")
    sample_prediction = model.predict(X_test[:5])
    print(f"前5个样本的真实值: {y_test[:5]}")
    print(f"前5个样本的预测值: {sample_prediction.flatten()}")
    
    return model, history

if __name__ == "__main__":
    model, history = main()

# 自定义PyTorch神经网络
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import DataLoader, TensorDataset
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# 自定义神经网络类
class CustomNeuralNetwork(nn.Module):
    """自定义神经网络架构"""
    def __init__(self, input_size, hidden_sizes, output_size, dropout_rate=0.3):
        super(CustomNeuralNetwork, self).__init__()
        
        # 创建层列表
        layers = []
        prev_size = input_size
        
        # 添加隐藏层
        for i, hidden_size in enumerate(hidden_sizes):
            layers.append(nn.Linear(prev_size, hidden_size))
            layers.append(nn.BatchNorm1d(hidden_size))
            layers.append(nn.ReLU())
            layers.append(nn.Dropout(dropout_rate))
            prev_size = hidden_size
        
        # 输出层
        layers.append(nn.Linear(prev_size, output_size))
        
        # 使用Sequential组合所有层
        self.network = nn.Sequential(*layers)
        
    def forward(self, x):
        return self.network(x)

# 训练函数
def train_model(model, train_loader, val_loader, criterion, optimizer, epochs=50):
    """训练神经网络模型"""
    train_losses = []
    val_losses = []
    train_accs = []
    val_accs = []
    
    for epoch in range(epochs):
        # 训练阶段
        model.train()
        train_loss = 0.0
        train_correct = 0
        train_total = 0
        
        for batch_idx, (data, target) in enumerate(train_loader):
            optimizer.zero_grad()
            output = model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()
            
            train_loss += loss.item()
            _, predicted = torch.max(output.data, 1)
            train_total += target.size(0)
            train_correct += (predicted == target).sum().item()
        
        # 验证阶段
        model.eval()
        val_loss = 0.0
        val_correct = 0
        val_total = 0
        
        with torch.no_grad():
            for data, target in val_loader:
                output = model(data)
                val_loss += criterion(output, target).item()
                _, predicted = torch.max(output.data, 1)
                val_total += target.size(0)
                val_correct += (predicted == target).sum().item()
        
        # 计算指标
        avg_train_loss = train_loss / len(train_loader)
        avg_val_loss = val_loss / len(val_loader)
        train_accuracy = 100 * train_correct / train_total
        val_accuracy = 100 * val_correct / val_total
        
        train_losses.append(avg_train_loss)
        val_losses.append(avg_val_loss)
        train_accs.append(train_accuracy)
        val_accs.append(val_accuracy)
        
        if (epoch + 1) % 10 == 0:
            print(f'Epoch [{epoch+1}/{epochs}]')
            print(f'Train Loss: {avg_train_loss:.4f}, Train Acc: {train_accuracy:.2f}%')
            print(f'Val Loss: {avg_val_loss:.4f}, Val Acc: {val_accuracy:.2f}%')
            print('-' * 50)
    
    return train_losses, val_losses, train_accs, val_accs

# 主程序
def main():
    print("自定义PyTorch神经网络示例")
    
    # 1. 创建示例数据
    print("\n1. 准备数据...")
    X, y = make_classification(
        n_samples=1000,
        n_features=20,
        n_informative=15,
        n_redundant=5,
        n_classes=3,
        random_state=42
    )
    
    # 数据预处理
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)
    
    # 转换为PyTorch张量
    X_tensor = torch.FloatTensor(X_scaled)
    y_tensor = torch.LongTensor(y)
    
    # 数据分割
    X_train, X_test, y_train, y_test = train_test_split(
        X_tensor, y_tensor, test_size=0.2, random_state=42
    )
    
    X_train, X_val, y_train, y_val = train_test_split(
        X_train, y_train, test_size=0.25, random_state=42
    )
    
    # 创建数据加载器
    train_dataset = TensorDataset(X_train, y_train)
    val_dataset = TensorDataset(X_val, y_val)
    test_dataset = TensorDataset(X_test, y_test)
    
    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
    val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)
    test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)
    
    # 2. 创建模型
    print("\n2. 创建自定义神经网络...")
    input_size = X.shape[1]
    hidden_sizes = [64, 32, 16]  # 自定义隐藏层大小
    output_size = len(np.unique(y))
    
    model = CustomNeuralNetwork(
        input_size=input_size,
        hidden_sizes=hidden_sizes,
        output_size=output_size,
        dropout_rate=0.3
    )
    
    print(model)
    
    # 3. 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)
    
    # 4. 训练模型
    print("\n3. 训练模型...")
    train_losses, val_losses, train_accs, val_accs = train_model(
        model, train_loader, val_loader, criterion, optimizer, epochs=100
    )
    
    # 5. 测试模型
    print("\n4. 测试模型...")
    model.eval()
    test_correct = 0
    test_total = 0
    
    with torch.no_grad():
        for data, target in test_loader:
            output = model(data)
            _, predicted = torch.max(output.data, 1)
            test_total += target.size(0)
            test_correct += (predicted == target).sum().item()
    
    test_accuracy = 100 * test_correct / test_total
    print(f"测试集准确率: {test_accuracy:.2f}%")
    
    # 6. 可视化结果
    plt.figure(figsize=(12, 4))
    
    plt.subplot(1, 2, 1)
    plt.plot(train_losses, label='训练损失')
    plt.plot(val_losses, label='验证损失')
    plt.title('训练和验证损失')
    plt.xlabel('Epoch')
    plt.ylabel('损失')
    plt.legend()
    
    plt.subplot(1, 2, 2)
    plt.plot(train_accs, label='训练准确率')
    plt.plot(val_accs, label='验证准确率')
    plt.title('训练和验证准确率')
    plt.xlabel('Epoch')
    plt.ylabel('准确率 (%)')
    plt.legend()
    
    plt.tight_layout()
    plt.show()
    
    return model

if __name__ == "__main__":
    model = main()