# Dynamic neural network implemented with NumPy (no external DL libs required).
# Copy & run this whole file in a Python environment or notebook.

import numpy as np
import matplotlib.pyplot as plt
import os

def one_hot(labels, num_classes):
    oh = np.zeros((labels.size, num_classes))
    oh[np.arange(labels.size), labels] = 1
    return oh

def accuracy(pred_probs, labels):
    preds = np.argmax(pred_probs, axis=1)
    return np.mean(preds == labels)

class Activations:
    @staticmethod
    def relu(x):
        return np.maximum(0, x)
    @staticmethod
    def drelu(x):
        return (x > 0).astype(float)
    @staticmethod
    def sigmoid(x):
        return 1 / (1 + np.exp(-x))
    @staticmethod
    def dsigmoid(x):
        s = Activations.sigmoid(x)
        return s * (1 - s)
    @staticmethod
    def tanh(x):
        return np.tanh(x)
    @staticmethod
    def dtanh(x):
        return 1 - np.tanh(x)**2
    @staticmethod
    def softmax(x):
        x = x - np.max(x, axis=1, keepdims=True)
        e = np.exp(x)
        return e / np.sum(e, axis=1, keepdims=True)

class Layer:
    def __init__(self, in_dim, out_dim, activation='relu'):
        self.in_dim = in_dim
        self.out_dim = out_dim
        self.activation = activation
        # init
        if activation == 'relu':
            scale = np.sqrt(2.0 / in_dim)
        elif activation in ('tanh', 'sigmoid'):
            scale = np.sqrt(1.0 / in_dim)
        else:
            scale = 0.01
        self.W = np.random.randn(in_dim, out_dim) * scale
        self.b = np.zeros((1, out_dim))
        self.x = None
        self.z = None

    def forward(self, x):
        self.x = x
        self.z = x.dot(self.W) + self.b
        if self.activation == 'relu':
            return Activations.relu(self.z)
        elif self.activation == 'sigmoid':
            return Activations.sigmoid(self.z)
        elif self.activation == 'tanh':
            return Activations.tanh(self.z)
        elif self.activation == 'linear':
            return self.z
        else:
            raise ValueError(f"Unsupported activation: {self.activation}")

    def backward(self, grad_out):
        if self.activation == 'relu':
            grad_z = grad_out * Activations.drelu(self.z)
        elif self.activation == 'sigmoid':
            grad_z = grad_out * Activations.dsigmoid(self.z)
        elif self.activation == 'tanh':
            grad_z = grad_out * Activations.dtanh(self.z)
        elif self.activation == 'linear':
            grad_z = grad_out
        else:
            raise ValueError(f"Unsupported activation: {self.activation}")
        m = self.x.shape[0]
        dW = self.x.T.dot(grad_z) / m
        db = np.sum(grad_z, axis=0, keepdims=True) / m
        dX = grad_z.dot(self.W.T)
        return dX, dW, db

class DynamicNN:
    def __init__(self, input_dim, layer_specs, num_classes):
        self.layers = []
        in_dim = input_dim
        for spec in layer_specs:
            self.layers.append(Layer(in_dim, spec['units'], spec.get('activation', 'relu')))
            in_dim = spec['units']
        self.out_layer = Layer(in_dim, num_classes, activation='linear')
        self.num_classes = num_classes

    def forward(self, x):
        out = x
        for layer in self.layers:
            out = layer.forward(out)
        logits = self.out_layer.forward(out)
        probs = Activations.softmax(logits)
        return logits, probs

    def compute_loss_and_grad(self, x, y_onehot):
        logits, probs = self.forward(x)
        m = x.shape[0]
        eps = 1e-12
        loss = -np.sum(y_onehot * np.log(probs + eps)) / m
        grad_logits = (probs - y_onehot) / m
        grad, dW, db = self.out_layer.backward(grad_logits)
        grads = [{'layer': 'out', 'dW': dW, 'db': db}]
        for layer in reversed(self.layers):
            grad, dW, db = layer.backward(grad)
            grads.append({'layer': layer, 'dW': dW, 'db': db})
        return loss, probs, grads

    def step(self, grads, lr):
        out_grad = grads[0]
        self.out_layer.W -= lr * out_grad['dW']
        self.out_layer.b -= lr * out_grad['db']
        for g, layer in zip(grads[1:], reversed(self.layers)):
            layer.W -= lr * g['dW']
            layer.b -= lr * g['db']

    def predict(self, x):
        _, probs = self.forward(x)
        return np.argmax(probs, axis=1), probs

    def save(self, path):
        params = {
            'out_W': self.out_layer.W,
            'out_b': self.out_layer.b,
            'layers': [(l.W, l.b, l.activation) for l in self.layers],
            'num_classes': self.num_classes
        }
        np.save(path, params, allow_pickle=True)

    def load(self, path):
        d = np.load(path, allow_pickle=True).item()
        self.out_layer.W = d['out_W']
        self.out_layer.b = d['out_b']
        layers_data = d['layers']
        for l, data in zip(self.layers, layers_data):
            W, b, activation = data
            l.W = W
            l.b = b
            l.activation = activation

def generate_gaussian_blobs(n_samples=1500, centers=3, dim=2, seed=42, std=1.2):
    rng = np.random.RandomState(seed)
    samples_per = n_samples // centers
    X = []
    y = []
    angles = np.linspace(0, 2*np.pi, centers, endpoint=False)
    for i, a in enumerate(angles):
        center = np.array([4*np.cos(a), 4*np.sin(a)])
        X.append(rng.randn(samples_per, dim) * std + center)
        y.append(np.full(samples_per, i))
    X = np.vstack(X)
    y = np.concatenate(y)
    perm = rng.permutation(X.shape[0])
    return X[perm], y[perm]

def train_model(config):
    input_dim = config['input_dim']
    layer_specs = config['layer_specs']
    num_classes = config['num_classes']
    epochs = config.get('epochs', 30)
    batch_size = config.get('batch_size', 64)
    lr = config.get('learning_rate', 0.01)
    seed = config.get('seed', 42)
    verbose = config.get('verbose', True)

    X, y = generate_gaussian_blobs(n_samples=config.get('n_samples', 1200), centers=num_classes, dim=input_dim, seed=seed)
    split = int(0.8 * X.shape[0])
    X_train, y_train = X[:split], y[:split]
    X_test, y_test = X[split:], y[split:]
    y_train_oh = one_hot(y_train, num_classes)
    y_test_oh = one_hot(y_test, num_classes)

    mu = X_train.mean(axis=0, keepdims=True)
    sigma = X_train.std(axis=0, keepdims=True) + 1e-8
    X_train = (X_train - mu) / sigma
    X_test = (X_test - mu) / sigma

    model = DynamicNN(input_dim, layer_specs, num_classes)
    steps_per_epoch = int(np.ceil(X_train.shape[0] / batch_size))
    history = {'loss': [], 'train_acc': [], 'test_acc': []}
    rng = np.random.RandomState(seed)
    for ep in range(1, epochs+1):
        perm = rng.permutation(X_train.shape[0])
        X_train_sh = X_train[perm]
        y_train_oh_sh = y_train_oh[perm]
        epoch_loss = 0.0
        for step in range(steps_per_epoch):
            start = step * batch_size
            end = start + batch_size
            xb = X_train_sh[start:end]
            yb = y_train_oh_sh[start:end]
            loss, probs, grads = model.compute_loss_and_grad(xb, yb)
            model.step(grads, lr)
            epoch_loss += loss * xb.shape[0]
        epoch_loss /= X_train.shape[0]
        _, train_probs = model.forward(X_train)
        train_acc = accuracy(train_probs, y_train)
        _, test_probs = model.forward(X_test)
        test_acc = accuracy(test_probs, y_test)
        history['loss'].append(epoch_loss)
        history['train_acc'].append(train_acc)
        history['test_acc'].append(test_acc)
        if verbose and (ep % max(1, epochs//6) == 0 or ep == 1 or ep == epochs):
            print(f"Epoch {ep}/{epochs} - loss: {epoch_loss:.4f} - train_acc: {train_acc:.4f} - test_acc: {test_acc:.4f}")

    save_path = "/mnt/data/dynamic_nn_demo_params.npy"
    model.save(save_path)
    if verbose:
        print(f"\nModel saved to: {save_path}")

    plt.figure(figsize=(8,4))
    plt.subplot(1,2,1)
    plt.plot(history['loss'])
    plt.title('Loss')
    plt.xlabel('Epoch')
    plt.subplot(1,2,2)
    plt.plot(history['train_acc'], label='train')
    plt.plot(history['test_acc'], label='test')
    plt.title('Accuracy')
    plt.xlabel('Epoch')
    plt.legend()
    plt.tight_layout()
    plt.show()

    preds, probs = model.predict(X_test)
    final_acc = accuracy(probs, y_test)
    print(f"Final test accuracy: {final_acc:.4f} on {X_test.shape[0]} samples")
    return model, history, save_path, (X_test, y_test, preds, probs)

# Example config — change this to experiment:
config = {
    'input_dim': 2,
    'layer_specs': [
        {'units': 64, 'activation': 'relu'},
        {'units': 32, 'activation': 'relu'},
    ],
    'num_classes': 3,
    'epochs': 30,
    'batch_size': 64,
    'learning_rate': 0.05,
    'n_samples': 1200,
    'seed': 123,
    'verbose': True
}

model, history, save_path, test_info = train_model(config)

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split

# ---------- 数据生成 ----------
def generate_gaussian_blobs(n_samples=1500, centers=3, dim=2, seed=42, std=1.2):
    rng = np.random.RandomState(seed)
    samples_per = n_samples // centers
    X = []
    y = []
    angles = np.linspace(0, 2*np.pi, centers, endpoint=False)
    for i, a in enumerate(angles):
        center = np.array([4*np.cos(a), 4*np.sin(a)])
        X.append(rng.randn(samples_per, dim) * std + center)
        y.append(np.full(samples_per, i))
    X = np.vstack(X)
    y = np.concatenate(y)
    perm = rng.permutation(X.shape[0])
    return X[perm], y[perm]

# ---------- 动态模型 ----------
class DynamicNN(nn.Module):
    def __init__(self, input_dim, layer_specs, num_classes):
        super().__init__()
        layers = []
        in_dim = input_dim
        for spec in layer_specs:
            layers.append(nn.Linear(in_dim, spec["units"]))
            if spec["activation"] == "relu":
                layers.append(nn.ReLU())
            elif spec["activation"] == "tanh":
                layers.append(nn.Tanh())
            elif spec["activation"] == "sigmoid":
                layers.append(nn.Sigmoid())
            # linear 则不加激活
            in_dim = spec["units"]
        layers.append(nn.Linear(in_dim, num_classes))
        self.net = nn.Sequential(*layers)

    def forward(self, x):
        return self.net(x)

# ---------- 训练函数 ----------
def train_model(config):
    # 数据
    X, y = generate_gaussian_blobs(
        n_samples=config.get("n_samples", 1200),
        centers=config["num_classes"],
        dim=config["input_dim"],
        seed=config.get("seed", 42),
    )
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=config.get("seed", 42))

    # 转 tensor
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    X_train = torch.tensor(X_train, dtype=torch.float32).to(device)
    y_train = torch.tensor(y_train, dtype=torch.long).to(device)
    X_test = torch.tensor(X_test, dtype=torch.float32).to(device)
    y_test = torch.tensor(y_test, dtype=torch.long).to(device)

    # 模型
    model = DynamicNN(config["input_dim"], config["layer_specs"], config["num_classes"]).to(device)
    optimizer = optim.Adam(model.parameters(), lr=config.get("learning_rate", 0.01))
    criterion = nn.CrossEntropyLoss()

    # 训练
    epochs = config.get("epochs", 30)
    batch_size = config.get("batch_size", 64)
    history = {"loss": [], "train_acc": [], "test_acc": []}

    for ep in range(1, epochs + 1):
        model.train()
        perm = torch.randperm(X_train.size(0))
        epoch_loss = 0
        correct = 0

        for i in range(0, X_train.size(0), batch_size):
            idx = perm[i : i + batch_size]
            xb, yb = X_train[idx], y_train[idx]

            optimizer.zero_grad()
            out = model(xb)
            loss = criterion(out, yb)
            loss.backward()
            optimizer.step()

            epoch_loss += loss.item() * xb.size(0)
            correct += (out.argmax(1) == yb).sum().item()

        train_acc = correct / X_train.size(0)
        epoch_loss /= X_train.size(0)

        # 测试集
        model.eval()
        with torch.no_grad():
            out_test = model(X_test)
            test_acc = (out_test.argmax(1) == y_test).float().mean().item()

        history["loss"].append(epoch_loss)
        history["train_acc"].append(train_acc)
        history["test_acc"].append(test_acc)

        if ep % max(1, epochs // 6) == 0 or ep == 1 or ep == epochs:
            print(f"Epoch {ep}/{epochs} - loss: {epoch_loss:.4f} - train_acc: {train_acc:.4f} - test_acc: {test_acc:.4f}")

    # 画图
    plt.figure(figsize=(8, 4))
    plt.subplot(1, 2, 1)
    plt.plot(history["loss"])
    plt.title("Loss")
    plt.subplot(1, 2, 2)
    plt.plot(history["train_acc"], label="train")
    plt.plot(history["test_acc"], label="test")
    plt.legend()
    plt.title("Accuracy")
    plt.show()

    return model, history, (X_test, y_test)

# ---------- 测试运行 ----------
if __name__ == "__main__":
    config = {
        "input_dim": 2,
        "layer_specs": [
            {"units": 64, "activation": "relu"},
            {"units": 32, "activation": "tanh"},
        ],
        "num_classes": 3,
        "epochs": 30,
        "batch_size": 64,
        "learning_rate": 0.01,
        "n_samples": 1200,
        "seed": 123,
    }
    model, history, test_data = train_model(config)

import pandas as pd
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# 1. 生成模拟Excel数据（DataFrame）
np.random.seed(42)
N = 300
df = pd.DataFrame({
    "feature_num1": np.random.randn(N),             # 数值特征1
    "feature_num2": np.random.rand(N) * 10,         # 数值特征2
    "feature_cat": np.random.choice(["A", "B", "C"], size=N),  # 类别特征
    "label": np.random.choice([0, 1, 2], size=N)    # 分类标签（3类）
})

print("示例数据：")
print(df.head())

# 2. 处理类别型特征（One-Hot）
df = pd.get_dummies(df, columns=["feature_cat"], drop_first=True)

# 特征和标签
X = df.drop("label", axis=1).values
y = df["label"].values

# 标准化数值特征（更利于训练）
scaler = StandardScaler()
X = scaler.fit_transform(X)

# 划分训练/测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 转为Tensor
X_train = torch.tensor(X_train, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.long)
X_test = torch.tensor(X_test, dtype=torch.float32)
y_test = torch.tensor(y_test, dtype=torch.long)

# 3. 定义动态神经网络
class DynamicNN(nn.Module):
    def __init__(self, input_dim, layer_specs, num_classes):
        super().__init__()
        layers = []
        in_dim = input_dim
        for spec in layer_specs:
            layers.append(nn.Linear(in_dim, spec["units"]))
            if spec["activation"] == "relu":
                layers.append(nn.ReLU())
            elif spec["activation"] == "tanh":
                layers.append(nn.Tanh())
            elif spec["activation"] == "sigmoid":
                layers.append(nn.Sigmoid())
            in_dim = spec["units"]
        layers.append(nn.Linear(in_dim, num_classes))
        self.net = nn.Sequential(*layers)

    def forward(self, x):
        return self.net(x)

# 配置网络
config = {
    "input_dim": X_train.shape[1],
    "layer_specs": [
        {"units": 32, "activation": "relu"},
        {"units": 16, "activation": "tanh"},
    ],
    "num_classes": len(np.unique(y)),
    "epochs": 30,
    "batch_size": 32,
    "learning_rate": 0.01
}

# 4. 模型训练
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = DynamicNN(config["input_dim"], config["layer_specs"], config["num_classes"]).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=config["learning_rate"])

X_train, y_train = X_train.to(device), y_train.to(device)
X_test, y_test = X_test.to(device), y_test.to(device)

for epoch in range(1, config["epochs"] + 1):
    model.train()
    optimizer.zero_grad()
    outputs = model(X_train)
    loss = criterion(outputs, y_train)
    loss.backward()
    optimizer.step()

    if epoch % 5 == 0 or epoch == 1 or epoch == config["epochs"]:
        _, preds_train = torch.max(outputs, 1)
        acc_train = (preds_train == y_train).float().mean().item()

        model.eval()
        with torch.no_grad():
            outputs_test = model(X_test)
            _, preds_test = torch.max(outputs_test, 1)
            acc_test = (preds_test == y_test).float().mean().item()

        print(f"Epoch {epoch}/{config['epochs']} | Loss: {loss.item():.4f} | Train Acc: {acc_train:.4f} | Test Acc: {acc_test:.4f}")

# 5. 预测结果
model.eval()
with torch.no_grad():
    probs = torch.softmax(model(X_test), dim=1)
    preds = probs.argmax(dim=1)

print("\n=== 测试集预测结果示例 ===")
for i in range(5):
    print(f"真实: {y_test[i].item()} | 预测: {preds[i].item()} | 概率分布: {probs[i].cpu().numpy()}")

layers = [64, 32, 16]

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
import pandas as pd
import numpy as np

# ===== 1. 模拟Excel数据（分类问题） =====
np.random.seed(42)
num_samples = 500
num_features = 10
num_classes = 3

# 随机生成特征
X = np.random.randn(num_samples, num_features)

# 构造一个目标列 y （0,1,2 三分类）
y = np.random.randint(0, num_classes, size=num_samples)

# 转成 DataFrame，模拟 Excel 读进来的样子
df = pd.DataFrame(X, columns=[f"feature_{i}" for i in range(num_features)])
df["label"] = y
print("📊 模拟Excel数据示例：")
print(df.head())

# ===== 2. 划分训练集和测试集 =====
X_train, X_test, y_train, y_test = train_test_split(
    df.drop("label", axis=1).values,
    df["label"].values,
    test_size=0.2,
    random_state=42
)

# 转成张量
X_train = torch.tensor(X_train, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.long)
X_test = torch.tensor(X_test, dtype=torch.float32)
y_test = torch.tensor(y_test, dtype=torch.long)

# ===== 3. 动态神经网络模型 =====
class DynamicNN(nn.Module):
    def __init__(self, input_dim, hidden_layers, num_classes):
        super(DynamicNN, self).__init__()
        layers = []
        in_dim = input_dim

        # 动态生成隐藏层
        for h in hidden_layers:
            layers.append(nn.Linear(in_dim, h))
            layers.append(nn.ReLU())
            in_dim = h

        # 输出层
        layers.append(nn.Linear(in_dim, num_classes))

        # 使用Sequential容器
        self.network = nn.Sequential(*layers)

    def forward(self, x):
        return self.network(x)

# ===== 4. 训练配置 =====
hidden_layers = [64, 32]  # 你可以改成 []
model = DynamicNN(input_dim=num_features, hidden_layers=hidden_layers, num_classes=num_classes)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

# ===== 5. 训练 =====
epochs = 50
for epoch in range(epochs):
    optimizer.zero_grad()
    outputs = model(X_train)
    loss = criterion(outputs, y_train)
    loss.backward()
    optimizer.step()
    
    if (epoch+1) % 10 == 0:
        print(f"Epoch {epoch+1}/{epochs}, Loss: {loss.item():.4f}")

# ===== 6. 测试 & 预测 =====
with torch.no_grad():
    y_pred = model(X_test).argmax(dim=1)

print("\n📈 分类结果报告：")
print(classification_report(y_test, y_pred))

# 随机取前10条预测结果
df_results = pd.DataFrame({
    "真实值": y_test.numpy()[:10],
    "预测值": y_pred.numpy()[:10]
})
print("\n🔮 前10条预测结果：")
print(df_results)

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import classification_report
import pandas as pd
import numpy as np

# ===== 1. 模拟字符型分类数据 =====
np.random.seed(42)
num_samples = 300

# 假设有 3 个类别特征（颜色, 形状, 大小）
colors = np.random.choice(["red", "blue", "green"], size=num_samples)
shapes = np.random.choice(["circle", "square", "triangle"], size=num_samples)
sizes = np.random.choice(["small", "medium", "large"], size=num_samples)

# 标签：三分类
labels = np.random.choice(["A", "B", "C"], size=num_samples)

# 转成 DataFrame（模拟 Excel）
df = pd.DataFrame({
    "color": colors,
    "shape": shapes,
    "size": sizes,
    "label": labels
})
print("📊 模拟Excel数据示例：")
print(df.head())

# ===== 2. 特征编码（字符转数字） =====
# LabelEncoder：每列独立编码
encoders = {}
for col in ["color", "shape", "size"]:
    le = LabelEncoder()
    df[col] = le.fit_transform(df[col])
    encoders[col] = le  # 保存编码器，方便之后预测新数据

# 标签编码
label_encoder = LabelEncoder()
df["label"] = label_encoder.fit_transform(df["label"])
num_classes = len(label_encoder.classes_)

# ===== 3. 划分数据 =====
X_train, X_test, y_train, y_test = train_test_split(
    df.drop("label", axis=1).values,
    df["label"].values,
    test_size=0.2,
    random_state=42
)

X_train = torch.tensor(X_train, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.long)
X_test = torch.tensor(X_test, dtype=torch.float32)
y_test = torch.tensor(y_test, dtype=torch.long)

# ===== 4. 动态神经网络模型 =====
class DynamicNN(nn.Module):
    def __init__(self, input_dim, hidden_layers, num_classes):
        super(DynamicNN, self).__init__()
        layers = []
        in_dim = input_dim

        for h in hidden_layers:
            layers.append(nn.Linear(in_dim, h))
            layers.append(nn.ReLU())
            in_dim = h

        layers.append(nn.Linear(in_dim, num_classes))
        self.network = nn.Sequential(*layers)

    def forward(self, x):
        return self.network(x)

# ===== 5. 初始化模型 =====
hidden_layers = [32, 16]   # 动态设置，或者 []
model = DynamicNN(input_dim=X_train.shape[1], hidden_layers=hidden_layers, num_classes=num_classes)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

# ===== 6. 训练 =====
epochs = 50
for epoch in range(epochs):
    optimizer.zero_grad()
    outputs = model(X_train)
    loss = criterion(outputs, y_train)
    loss.backward()
    optimizer.step()
    
    if (epoch+1) % 10 == 0:
        print(f"Epoch {epoch+1}/{epochs}, Loss: {loss.item():.4f}")

# ===== 7. 测试 & 预测 =====
with torch.no_grad():
    y_pred = model(X_test).argmax(dim=1)

print("\n📈 分类结果报告：")
print(classification_report(y_test, y_pred, target_names=label_encoder.classes_))

# 前10条预测结果
df_results = pd.DataFrame({
    "真实值": label_encoder.inverse_transform(y_test.numpy()[:10]),
    "预测值": label_encoder.inverse_transform(y_pred.numpy()[:10])
})
print("\n🔮 前10条预测结果：")
print(df_results)

df = pd.read_excel("your_data.xlsx")

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import classification_report, accuracy_score
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# ===== 动态神经网络模型 =====
class DynamicNN(nn.Module):
    def __init__(self, input_dim, hidden_layers, num_classes):
        super(DynamicNN, self).__init__()
        layers = []
        in_dim = input_dim
        for h in hidden_layers:
            layers.append(nn.Linear(in_dim, h))
            layers.append(nn.ReLU())
            in_dim = h
        layers.append(nn.Linear(in_dim, num_classes))
        self.network = nn.Sequential(*layers)

    def forward(self, x):
        return self.network(x)

# ===== 训练 & 测试函数 =====
def train_and_evaluate(df, feature_cols, label_col, hidden_layers=[32, 16], epochs=50):
    # 编码特征
    encoders = {}
    for col in feature_cols:
        if df[col].dtype == object:
            le = LabelEncoder()
            df[col] = le.fit_transform(df[col])
            encoders[col] = le

    # 标签编码
    label_encoder = LabelEncoder()
    df[label_col] = label_encoder.fit_transform(df[label_col])
    num_classes = len(label_encoder.classes_)

    # 划分数据
    X_train, X_test, y_train, y_test = train_test_split(
        df[feature_cols].values,
        df[label_col].values,
        test_size=0.2,
        random_state=42
    )
    X_train, X_test = torch.tensor(X_train, dtype=torch.float32), torch.tensor(X_test, dtype=torch.float32)
    y_train, y_test = torch.tensor(y_train, dtype=torch.long), torch.tensor(y_test, dtype=torch.long)

    # 模型
    model = DynamicNN(input_dim=len(feature_cols), hidden_layers=hidden_layers, num_classes=num_classes)
    criterion, optimizer = nn.CrossEntropyLoss(), optim.Adam(model.parameters(), lr=0.01)

    # 训练
    train_losses, train_accs = [], []
    for epoch in range(epochs):
        optimizer.zero_grad()
        outputs = model(X_train)
        loss = criterion(outputs, y_train)
        loss.backward()
        optimizer.step()

        # 计算准确率
        preds = outputs.argmax(dim=1)
        acc = accuracy_score(y_train.numpy(), preds.numpy())

        train_losses.append(loss.item())
        train_accs.append(acc)

        if (epoch+1) % 10 == 0:
            print(f"Epoch {epoch+1}/{epochs}, Loss={loss.item():.4f}, Train Acc={acc:.4f}")

    # 绘制训练曲线
    plt.figure(figsize=(10,4))
    plt.subplot(1,2,1)
    plt.plot(train_losses, label="Loss")
    plt.xlabel("Epoch"); plt.ylabel("Loss"); plt.title("Training Loss")
    plt.legend()
    plt.subplot(1,2,2)
    plt.plot(train_accs, label="Accuracy", color="orange")
    plt.xlabel("Epoch"); plt.ylabel("Accuracy"); plt.title("Training Accuracy")
    plt.legend()
    plt.show()

    # 测试
    with torch.no_grad():
        y_pred = model(X_test).argmax(dim=1)

    print("\n📈 分类报告：")
    print(classification_report(y_test, y_pred, target_names=label_encoder.classes_))

    df_results = pd.DataFrame({
        "真实值": label_encoder.inverse_transform(y_test.numpy()[:15]),
        "预测值": label_encoder.inverse_transform(y_pred.numpy()[:15])
    })
    print("\n🔮 部分预测结果：")
    print(df_results)

# ===== 场景1：三分类，字符特征 =====
np.random.seed(42)
df1 = pd.DataFrame({
    "color": np.random.choice(["red", "blue", "green"], size=300),
    "shape": np.random.choice(["circle", "square", "triangle"], size=300),
    "label": np.random.choice(["A", "B", "C"], size=300)
})
print("\n=== 场景1：三分类（字符特征） ===")
train_and_evaluate(df1, feature_cols=["color","shape"], label_col="label", hidden_layers=[32,16])

# ===== 场景2：二分类，混合特征 =====
df2 = pd.DataFrame({
    "color": np.random.choice(["red", "blue"], size=200),
    "size": np.random.choice(["small","large"], size=200),
    "num_feature": np.random.randn(200),
    "label": np.random.choice(["yes","no"], size=200)
})
print("\n=== 场景2：二分类（字符+数值特征） ===")
train_and_evaluate(df2, feature_cols=["color","size","num_feature"], label_col="label", hidden_layers=[16])

# ===== 场景3：五分类，数值特征 =====
X = np.random.randn(400, 5)
y = np.random.choice(list("ABCDE"), size=400)
df3 = pd.DataFrame(X, columns=[f"f{i}" for i in range(5)])
df3["label"] = y
print("\n=== 场景3：五分类（数值特征） ===")
train_and_evaluate(df3, feature_cols=[f"f{i}" for i in range(5)], label_col="label", hidden_layers=[64,32])

class ImprovedNN(nn.Module):
    def __init__(self, input_dim, hidden_layers, num_classes, dropout=0.3):
        super(ImprovedNN, self).__init__()
        layers = []
        in_dim = input_dim
        for h in hidden_layers:
            layers.append(nn.Linear(in_dim, h))
            layers.append(nn.BatchNorm1d(h))   # 批归一化
            layers.append(nn.ReLU())
            layers.append(nn.Dropout(dropout)) # Dropout
            in_dim = h
        layers.append(nn.Linear(in_dim, num_classes))
        self.network = nn.Sequential(*layers)

    def forward(self, x):
        return self.network(x)

model = ImprovedNN(input_dim=X_train.shape[1], hidden_layers=[128, 64, 32], num_classes=num_classes)
optimizer = optim.Adam(model.parameters(), lr=0.001)

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 数据集（MNIST）
transform = transforms.Compose([transforms.ToTensor(), lambda x: x.view(-1)])  # 展平
train_dataset = datasets.MNIST(root="./data", train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root="./data", train=False, transform=transform, download=True)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

# 动态 MLP 模型
class DynamicNN(nn.Module):
    def __init__(self, input_dim, hidden_layers, num_classes):
        super().__init__()
        layers, in_dim = [], input_dim
        for h in hidden_layers:
            layers.append(nn.Linear(in_dim, h))
            layers.append(nn.ReLU())
            in_dim = h
        layers.append(nn.Linear(in_dim, num_classes))
        self.net = nn.Sequential(*layers)

    def forward(self, x):
        return self.net(x)

model = DynamicNN(28*28, [256,128], 10)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练
for epoch in range(5):
    for X, y in train_loader:
        optimizer.zero_grad()
        out = model(X)
        loss = criterion(out, y)
        loss.backward()
        optimizer.step()
    print(f"Epoch {epoch+1}: Loss={loss.item():.4f}")

# 测试
correct, total = 0, 0
with torch.no_grad():
    for X, y in test_loader:
        pred = model(X).argmax(1)
        correct += (pred == y).sum().item()
        total += y.size(0)
print(f"Test Accuracy: {correct/total:.4f}")

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(1, 32, 3, padding=1),  # (B,1,28,28) -> (B,32,28,28)
            nn.ReLU(),
            nn.MaxPool2d(2),                 # -> (B,32,14,14)
            nn.Conv2d(32, 64, 3, padding=1), # -> (B,64,14,14)
            nn.ReLU(),
            nn.MaxPool2d(2)                  # -> (B,64,7,7)
        )
        self.fc = nn.Sequential(
            nn.Linear(64*7*7, 128),
            nn.ReLU(),
            nn.Linear(128, num_classes)
        )

    def forward(self, x):
        x = self.conv(x)
        x = x.view(x.size(0), -1)
        return self.fc(x)

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import pandas as pd
import numpy as np
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# ====================
# 1. 构造示例数据
# ====================
data = {
    "text": [
        "hello world", "hi there", "good morning", "good night",
        "machine learning", "deep learning", "neural network",
        "cat", "dog", "fish"
    ],
    "label": ["greeting", "greeting", "greeting", "greeting",
              "ai", "ai", "ai",
              "animal", "animal", "animal"]
}
df = pd.DataFrame(data)

# 标签编码
label_encoder = LabelEncoder()
df["label_encoded"] = label_encoder.fit_transform(df["label"])

# 字符字典
all_text = " ".join(df["text"].values)
vocab = sorted(set(all_text))
char2idx = {c: i + 1 for i, c in enumerate(vocab)}  # 0 留给 padding
idx2char = {i: c for c, i in char2idx.items()}

def text_to_seq(text, max_len=15):
    seq = [char2idx.get(c, 0) for c in text]
    return seq[:max_len] + [0] * (max_len - len(seq))

df["seq"] = df["text"].apply(lambda x: text_to_seq(x))

# 划分数据集
X = np.stack(df["seq"].values)
y = df["label_encoded"].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# ====================
# 2. Dataset & DataLoader
# ====================
class TextDataset(Dataset):
    def __init__(self, X, y):
        self.X = torch.tensor(X, dtype=torch.long)
        self.y = torch.tensor(y, dtype=torch.long)

    def __len__(self):
        return len(self.X)

    def __getitem__(self, idx):
        return self.X[idx], self.y[idx]

train_loader = DataLoader(TextDataset(X_train, y_train), batch_size=4, shuffle=True)
test_loader = DataLoader(TextDataset(X_test, y_test), batch_size=4)

# ====================
# 3. RNN 模型
# ====================
class RNNClassifier(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes, rnn_type="LSTM", num_layers=1, dropout=0.2):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)

        if rnn_type == "RNN":
            self.rnn = nn.RNN(embed_dim, hidden_dim, num_layers=num_layers,
                              batch_first=True, dropout=dropout if num_layers > 1 else 0)
        elif rnn_type == "GRU":
            self.rnn = nn.GRU(embed_dim, hidden_dim, num_layers=num_layers,
                              batch_first=True, dropout=dropout if num_layers > 1 else 0)
        else:  # 默认 LSTM
            self.rnn = nn.LSTM(embed_dim, hidden_dim, num_layers=num_layers,
                               batch_first=True, dropout=dropout if num_layers > 1 else 0)

        self.fc = nn.Linear(hidden_dim, num_classes)

    def forward(self, x):
        embed = self.embedding(x)  # [B, T, E]
        _, hidden = self.rnn(embed)

        if isinstance(hidden, tuple):  # LSTM
            hidden = hidden[0]

        out = self.fc(hidden[-1])  # 取最后一层 hidden
        return out

# ====================
# 4. 训练
# ====================
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

model = RNNClassifier(
    vocab_size=len(char2idx) + 1,
    embed_dim=32,
    hidden_dim=64,
    num_classes=len(label_encoder.classes_),
    rnn_type="LSTM",
    num_layers=2,
    dropout=0.3
).to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

def train_model(model, loader, epochs=20):
    for epoch in range(epochs):
        model.train()
        total_loss, correct, total = 0, 0, 0

        for X_batch, y_batch in loader:
            X_batch, y_batch = X_batch.to(device), y_batch.to(device)

            optimizer.zero_grad()
            outputs = model(X_batch)
            loss = criterion(outputs, y_batch)
            loss.backward()
            optimizer.step()

            total_loss += loss.item()
            _, predicted = torch.max(outputs, 1)
            correct += (predicted == y_batch).sum().item()
            total += y_batch.size(0)

        print(f"Epoch {epoch+1}/{epochs}, Loss: {total_loss/len(loader):.4f}, "
              f"Acc: {correct/total:.4f}")

train_model(model, train_loader, epochs=15)

# ====================
# 5. 测试与预测
# ====================
model.eval()
y_true, y_pred = [], []
with torch.no_grad():
    for X_batch, y_batch in test_loader:
        X_batch, y_batch = X_batch.to(device), y_batch.to(device)
        outputs = model(X_batch)
        _, predicted = torch.max(outputs, 1)
        y_true.extend(y_batch.cpu().numpy())
        y_pred.extend(predicted.cpu().numpy())

print("\n=== Classification Report ===")
print(classification_report(y_true, y_pred, target_names=label_encoder.classes_))

# ====================
# 6. 预测新数据
# ====================
def predict(text):
    seq = torch.tensor([text_to_seq(text)], dtype=torch.long).to(device)
    model.eval()
    with torch.no_grad():
        output = model(seq)
        pred = torch.argmax(output, dim=1).item()
    return label_encoder.inverse_transform([pred])[0]

print("\n=== 测试预测 ===")
print("Input: 'deep learning' -> Pred:", predict("deep learning"))
print("Input: 'dog' -> Pred:", predict("dog"))
print("Input: 'good evening' -> Pred:", predict("good evening"))

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.metrics import accuracy_score, classification_report

# ============================
# 1. 构造示例 DataFrame 数据
# ============================
# 假设有多个输入特征 (x1, x2, x3)，输出为分类 (y)
np.random.seed(42)
df = pd.DataFrame({
    "x1": np.random.randn(100),
    "x2": np.random.randn(100),
    "x3": np.random.randn(100),
    "y": np.random.choice(["A", "B", "C"], size=100)  # 多分类
})

# 输入输出列
input_cols = ["x1", "x2", "x3"]
output_col = "y"

# 编码输出标签
label_encoder = LabelEncoder()
df[output_col] = label_encoder.fit_transform(df[output_col])

# 归一化输入
scaler = StandardScaler()
df[input_cols] = scaler.fit_transform(df[input_cols])

# 划分训练/测试集
X_train, X_test, y_train, y_test = train_test_split(
    df[input_cols].values,
    df[output_col].values,
    test_size=0.2,
    random_state=42
)

# ============================
# 2. Dataset & DataLoader
# ============================
class DataFrameDataset(Dataset):
    def __init__(self, X, y):
        self.X = torch.tensor(X, dtype=torch.float32)
        self.y = torch.tensor(y, dtype=torch.long)

    def __len__(self):
        return len(self.X)

    def __getitem__(self, idx):
        return self.X[idx], self.y[idx]

train_loader = DataLoader(DataFrameDataset(X_train, y_train), batch_size=8, shuffle=True)
test_loader = DataLoader(DataFrameDataset(X_test, y_test), batch_size=8)

# ============================
# 3. 动态构建 DNN 模型
# ============================
class DynamicDNN(nn.Module):
    def __init__(self, input_dim, layer_list, output_dim, dropout=0.2):
        super().__init__()
        layers = []
        prev_dim = input_dim
        for hidden_dim in layer_list:
            layers.append(nn.Linear(prev_dim, hidden_dim))
            layers.append(nn.ReLU())
            layers.append(nn.Dropout(dropout))
            prev_dim = hidden_dim
        layers.append(nn.Linear(prev_dim, output_dim))
        self.network = nn.Sequential(*layers)

    def forward(self, x):
        return self.network(x)

# ============================
# 4. 训练与测试
# ============================
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
layer_list = [64, 32]  # 动态隐藏层结构
model = DynamicDNN(input_dim=len(input_cols),
                   layer_list=layer_list,
                   output_dim=len(label_encoder.classes_)).to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

def train_model(model, loader, epochs=30):
    for epoch in range(epochs):
        model.train()
        total_loss, correct, total = 0, 0, 0
        for X_batch, y_batch in loader:
            X_batch, y_batch = X_batch.to(device), y_batch.to(device)

            optimizer.zero_grad()
            outputs = model(X_batch)
            loss = criterion(outputs, y_batch)
            loss.backward()
            optimizer.step()

            total_loss += loss.item()
            _, predicted = torch.max(outputs, 1)
            correct += (predicted == y_batch).sum().item()
            total += y_batch.size(0)

        acc = correct / total
        print(f"Epoch {epoch+1}/{epochs} | Loss: {total_loss/len(loader):.4f} | Acc: {acc:.4f}")

train_model(model, train_loader, epochs=20)

# ============================
# 5. 测试与预测
# ============================
model.eval()
y_true, y_pred = [], []
with torch.no_grad():
    for X_batch, y_batch in test_loader:
        X_batch, y_batch = X_batch.to(device), y_batch.to(device)
        outputs = model(X_batch)
        _, predicted = torch.max(outputs, 1)
        y_true.extend(y_batch.cpu().numpy())
        y_pred.extend(predicted.cpu().numpy())

print("\n=== 测试集结果 ===")
print("Accuracy:", accuracy_score(y_true, y_pred))
print(classification_report(y_true, y_pred, target_names=label_encoder.classes_))

# ============================
# 6. 预测新数据（模拟 Excel 行）
# ============================
def predict(df_row):
    X_new = scaler.transform([df_row[input_cols].values])
    X_tensor = torch.tensor(X_new, dtype=torch.float32).to(device)
    with torch.no_grad():
        output = model(X_tensor)
        pred = torch.argmax(output, dim=1).item()
    return label_encoder.inverse_transform([pred])[0]

print("\n=== 新数据预测 ===")
print(df.head(3))
print("预测结果:", predict(df.iloc[0]))