下载地址：http://lanzou.com.cn/i7c0367b2

项目编译入口：

Project Structure

Project : 余额计算模型AI版

Folder : jisuanmoxingaiban

Files : 26

Size : 77.8 KB

Generated: 2026-03-23 17:06:38

jisuanmoxingaiban/
├── README.md [188 B]
├── asset/
│ ├── Builder.py [5.1 KB]
│ └── Resolver.js [3.5 KB]
├── component/
│ ├── Buffer.cpp [1.5 KB]
│ ├── Client.py [6.2 KB]
│ ├── Scheduler.java [4.6 KB]
│ └── Util.sql [2.3 KB]
├── config/
│ ├── Executor.json [688 B]
│ ├── Factory.xml [1.3 KB]
│ └── Service.xml [1.4 KB]
├── controllers/
│ ├── Adapter.cpp [1.4 KB]
│ ├── Processor.cpp [1.5 KB]
│ └── Queue.cpp [1.5 KB]
├── lib/
│ └── Registry.jar [644 B]
├── modules/
├── package.json [688 B]
├── pom.xml [1.5 KB]
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ ├── Dispatcher.java [7 KB]
│ │ │ ├── Pool.java [4.4 KB]
│ │ │ └── Wrapper.java [7.9 KB]
│ │ └── resources/
│ └── test/
│ └── java/
├── tasks/
│ └── Repository.php [3.2 KB]
└── websocket/
├── Controller.py [5.7 KB]
├── Handler.js [3.7 KB]
├── Parser.js [4.3 KB]
├── Proxy.php [3 KB]
└── Server.py [4.6 KB]

python

"""

智能余额修改器与AI驱动G-code计算系统
Author: AI Assistant
Date: 2023-10-27
Description:
本模块实现了一个模拟的“余额修改器”用于管理用户信用/余额，
并结合一个基于神经网络的AI模型，根据加工任务特征动态计算
优化的G-code加工参数（如进给率、主轴转速等）。

   代码结构清晰，包含数据模拟、模型定义、训练流程、G-code生成与解析。

===========================================
"""

import numpy as np
import pandas as pd
import json
import os
import re
from typing import Dict, List, Tuple, Optional, Any
from dataclasses import dataclass, asdict
from enum import Enum
import warnings
warnings.filterwarnings('ignore')

尝试导入深度学习库，如果不可用则使用模拟的简单模型

try:
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
TORCH_AVAILABLE = True
except ImportError:
TORCH_AVAILABLE = False
print("警告: PyTorch未安装，将使用基于规则的模拟AI模型。")

========================== 第一部分：余额修改器模块 ==========================

class TransactionType(Enum):
"""交易类型枚举"""
DEPOSIT = "存款"
WITHDRAW = "取款"
CONSUME = "消费"
REFUND = "退款"
AI_SERVICE = "AI服务费"

@dataclass
class Transaction:
"""交易记录数据类"""
id: int
type: TransactionType
amount: float
balance_after: float
description: str
timestamp: str

class BalanceModifier:
"""
余额修改器类
功能：管理用户余额，记录交易流水，提供安全的余额修改接口。
支持冻结、解冻、透支限制等高级功能。
"""
def init(self, initial_balance: float = 0.0, max_overdraft: float = 0.0):
"""
初始化余额修改器
:param initial_balance: 初始余额
:param max_overdraft: 最大透支额度（负数表示不允许透支）
"""
self._balance = initial_balance
self._frozen = False
self._max_overdraft = max_overdraft
self._transactions: List[Transaction] = []
self._transaction_counter = 0
self._log_transaction(TransactionType.DEPOSIT, initial_balance, "初始账户创建")

def _log_transaction(self, t_type: TransactionType, amount: float, desc: str):
    """内部记录交易流水"""
    self._transaction_counter += 1
    trans = Transaction(
        id=self._transaction_counter,
        type=t_type,
        amount=amount,
        balance_after=self._balance,
        description=desc,
        timestamp=pd.Timestamp.now().strftime("%Y-%m-%d %H:%M:%S")
    )
    self._transactions.append(trans)

def get_balance(self) -> float:
    """获取当前余额"""
    return self._balance

def freeze_account(self):
    """冻结账户"""
    self._frozen = True
    print("账户已冻结，无法进行任何交易。")

def unfreeze_account(self):
    """解冻账户"""
    self._frozen = False
    print("账户已解冻。")

def deposit(self, amount: float, description: str = "存款") -> bool:
    """
    存款操作
    :param amount: 存款金额（正数）
    :param description: 交易描述
    :return: 是否成功
    """
    if self._frozen:
        print("账户已冻结，无法存款。")
        return False
    if amount <= 0:
        print("存款金额必须大于0。")
        return False
    self._balance += amount
    self._log_transaction(TransactionType.DEPOSIT, amount, description)
    print(f"存款成功: +{amount:.2f}，当前余额: {self._balance:.2f}")
    return True

def withdraw(self, amount: float, description: str = "取款") -> bool:
    """
    取款操作（检查透支限制）
    :param amount: 取款金额（正数）
    :param description: 交易描述
    :return: 是否成功
    """
    if self._frozen:
        print("账户已冻结，无法取款。")
        return False
    if amount <= 0:
        print("取款金额必须大于0。")
        return False
    # 检查透支限制
    if self._balance - amount < -self._max_overdraft:
        print(f"取款失败: 超出透支额度 {self._max_overdraft:.2f}。当前余额: {self._balance:.2f}")
        return False
    self._balance -= amount
    self._log_transaction(TransactionType.WITHDRAW, amount, description)
    print(f"取款成功: -{amount:.2f}，当前余额: {self._balance:.2f}")
    return True

def consume(self, amount: float, description: str = "消费") -> bool:
    """消费操作（类似取款但交易类型不同）"""
    return self.withdraw(amount, description)

def refund(self, amount: float, description: str = "退款") -> bool:
    """退款操作"""
    if self._frozen:
        print("账户已冻结，无法退款。")
        return False
    if amount <= 0:
        print("退款金额必须大于0。")
        return False
    self._balance += amount
    self._log_transaction(TransactionType.REFUND, amount, description)
    print(f"退款成功: +{amount:.2f}，当前余额: {self._balance:.2f}")
    return True

def ai_service_charge(self, amount: float, description: str = "AI服务费") -> bool:
    """AI服务扣费"""
    return self.consume(amount, description)

def get_transaction_history(self) -> List[Dict]:
    """获取交易历史（返回字典列表）"""
    return [asdict(t) for t in self._transactions]

def export_transactions_to_csv(self, filename: str = "transactions.csv"):
    """导出交易记录到CSV"""
    df = pd.DataFrame(self.get_transaction_history())
    df.to_csv(filename, index=False, encoding='utf-8-sig')
    print(f"交易记录已导出至 {filename}")

def __repr__(self):
    return f"BalanceModifier(余额={self._balance:.2f}, 冻结={self._frozen}, 透支额度={self._max_overdraft})"

========================== 第二部分：AI模型 G-code 计算模块 ==========================

class MachiningFeature(Enum):
"""加工特征枚举"""
FACE_MILLING = "面铣"
CONTOUR_MILLING = "轮廓铣"
DRILLING = "钻孔"
THREADING = "螺纹加工"
POCKETING = "型腔铣"

@dataclass
class MachiningTask:
"""加工任务数据类"""
feature: MachiningFeature
material_hardness: float # 材料硬度 (HB)
tool_diameter: float # 刀具直径 (mm)
depth_of_cut: float # 切削深度 (mm)
width_of_cut: float # 切削宽度 (mm)
spindle_power: float # 主轴功率 (kW)
required_surface_quality: float # 表面质量要求 (Ra, μm)

@dataclass
class GCodeParams:
"""G代码参数数据类"""
feedrate: float # 进给率 (mm/min)
spindle_speed: float # 主轴转速 (rpm)
depth_per_pass: float # 每层切削深度 (mm)
coolant: bool # 是否开启冷却液
tool_compensation: float # 刀具补偿 (mm)
additional_comments: str # 附加注释

class SimpleNeuralNetwork(nn.Module):
"""简单神经网络模型（用于预测G-code参数）"""
def init(self, input_dim: int, hidden_dims: List[int], output_dim: int):
super(SimpleNeuralNetwork, self).init()
layers = []
prev_dim = input_dim
for h_dim in hidden_dims:
layers.append(nn.Linear(prev_dim, h_dim))
layers.append(nn.ReLU())
layers.append(nn.Dropout(0.2))
prev_dim = h_dim
layers.append(nn.Linear(prev_dim, output_dim))
self.network = nn.Sequential(*layers)

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

class GCodeAIModel:
"""
AI模型：基于加工任务预测最优G-code参数。
如果PyTorch可用，使用神经网络；否则使用基于规则的专家系统。
"""
def init(self, model_path: Optional[str] = None):
self.model = None
self.input_scaler_mean = None
self.input_scaler_std = None
self.output_scaler_mean = None
self.output_scaler_std = None
self.use_pytorch = TORCH_AVAILABLE

    if self.use_pytorch:
        self._init_neural_network()
        if model_path and os.path.exists(model_path):
            self.load_model(model_path)
    else:
        print("初始化基于规则的G-code计算引擎（模拟AI）。")

def _init_neural_network(self):
    """初始化神经网络结构"""
    # 输入特征: [硬度, 刀具直径, 切削深度, 切削宽度, 主轴功率, 表面质量要求]
    # 输出参数: [进给率, 主轴转速, 每层切深, 刀具补偿]
    input_dim = 6
    hidden_dims = [64, 32, 16]
    output_dim = 4
    self.model = SimpleNeuralNetwork(input_dim, hidden_dims, output_dim)
    # 初始化缩放参数（实际中应从训练数据中获取，这里使用模拟值）
    self.input_scaler_mean = np.array([200.0, 10.0, 2.0, 5.0, 15.0, 1.6])
    self.input_scaler_std = np.array([100.0, 5.0, 1.5, 3.0, 7.5, 1.2])
    self.output_scaler_mean = np.array([500.0, 2000.0, 1.0, 0.1])
    self.output_scaler_std = np.array([300.0, 1000.0, 0.8, 0.05])

def _generate_synthetic_data(self, n_samples: int = 1000) -> Tuple[np.ndarray, np.ndarray]:
    """
    生成合成训练数据（用于演示）
    实际应用中应替换为真实工艺数据。
    """
    np.random.seed(42)
    # 输入特征随机生成
    hardness = np.random.uniform(50, 500, n_samples)
    tool_dia = np.random.uniform(3, 25, n_samples)
    depth_cut = np.random.uniform(0.2, 5, n_samples)
    width_cut = np.random.uniform(1, 20, n_samples)
    spindle_power = np.random.uniform(5, 30, n_samples)
    surface_quality = np.random.uniform(0.4, 6.3, n_samples)

    X = np.column_stack([hardness, tool_dia, depth_cut, width_cut, spindle_power, surface_quality])

    # 根据规则生成输出（模拟工艺知识）
    # 进给率: 硬度越高进给越低，刀具越大进给越高
    feedrate = 800 - 1.2 * hardness + 15 * tool_dia + 30 * depth_cut + np.random.normal(0, 30, n_samples)
    feedrate = np.clip(feedrate, 100, 2000)
    # 主轴转速: 硬度越高转速越低，刀具直径越大转速越低
    spindle_speed = 5000 - 8 * hardness - 80 * tool_dia + np.random.normal(0, 200, n_samples)
    spindle_speed = np.clip(spindle_speed, 500, 8000)
    # 每层切深: 硬度高切深浅，刀具大切深大
    depth_per_pass = 1.5 - 0.002 * hardness + 0.1 * tool_dia + np.random.normal(0, 0.2, n_samples)
    depth_per_pass = np.clip(depth_per_pass, 0.1, 3.0)
    # 刀具补偿: 与硬度、刀具直径有关
    tool_comp = 0.1 + 0.0005 * hardness + 0.01 * tool_dia + np.random.normal(0, 0.02, n_samples)
    tool_comp = np.clip(tool_comp, 0.05, 0.3)

    y = np.column_stack([feedrate, spindle_speed, depth_per_pass, tool_comp])
    return X, y

def train(self, epochs: int = 50, batch_size: int = 32, lr: float = 0.001):
    """训练神经网络模型（如果可用）"""
    if not self.use_pytorch:
        print("PyTorch不可用，无法进行神经网络训练。使用规则系统代替。")
        return

    print("生成合成训练数据...")
    X, y = self._generate_synthetic_data(2000)
    # 标准化
    X_norm = (X - self.input_scaler_mean) / (self.input_scaler_std + 1e-8)
    y_norm = (y - self.output_scaler_mean) / (self.output_scaler_std + 1e-8)

    dataset = TensorDataset(torch.tensor(X_norm, dtype=torch.float32),
                            torch.tensor(y_norm, dtype=torch.float32))
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

    criterion = nn.MSELoss()
    optimizer = optim.Adam(self.model.parameters(), lr=lr)

    print(f"开始训练，共 {epochs} 个epoch...")
    self.model.train()
    for epoch in range(epochs):
        total_loss = 0
        for batch_X, batch_y in dataloader:
            optimizer.zero_grad()
            outputs = self.model(batch_X)
            loss = criterion(outputs, batch_y)
            loss.backward()
            optimizer.step()
            total_loss += loss.item()
        if (epoch + 1) % 10 == 0:
            print(f"Epoch [{epoch+1}/{epochs}], Loss: {total_loss/len(dataloader):.4f}")
    print("训练完成。")

def predict(self, task: MachiningTask) -> GCodeParams:
    """
    根据加工任务预测G代码参数
    :param task: 加工任务对象
    :return: GCodeParams 参数对象
    """
    # 构造输入向量
    input_vector = np.array([
        task.material_hardness,
        task.tool_diameter,
        task.depth_of_cut,
        task.width_of_cut,
        task.spindle_power,
        task.required_surface_quality
    ])

    if self.use_pytorch and self.model is not None:
        # 神经网络预测
        input_norm = (input_vector - self.input_scaler_mean) / (self.input_scaler_std + 1e-8)
        input_tensor = torch.tensor(input_norm, dtype=torch.float32).unsqueeze(0)
        self.model.eval()
        with torch.no_grad():
            output_norm = self.model(input_tensor).squeeze().numpy()
        output = output_norm * self.output_scaler_std + self.output_scaler_mean
        feedrate, spindle_speed, depth_per_pass, tool_comp = output
    else:
        # 基于规则的专家系统（模拟AI）
        feedrate, spindle_speed, depth_per_pass, tool_comp = self._rule_based_predict(task)

    # 根据加工特征微调冷却液
    coolant = True
    if task.feature in [MachiningFeature.DRILLING, MachiningFeature.THREADING]:
        coolant = True  # 钻孔和螺纹通常需要冷却
    elif task.material_hardness > 300:
        coolant = True
    else:
        coolant = False

    # 附加注释
    comments = f"AI生成参数: 特征={task.feature.value}, 硬度={task.material_hardness:.0f}HB"

    return GCodeParams(
        feedrate=float(np.clip(feedrate, 50, 3000)),
        spindle_speed=float(np.clip(spindle_speed, 200, 12000)),
        depth_per_pass=float(np.clip(depth_per_pass, 0.1, 5.0)),
        coolant=coolant,
        tool_compensation=float(np.clip(tool_comp, 0.0, 0.5)),
        additional_comments=comments
    )

def _rule_based_predict(self, task: MachiningTask) -> Tuple[float, float, float, float]:
    """基于规则的预测方法（后备方案）"""
    # 简单规则：硬度越高参数越低
    base_feed = 800.0
    base_speed = 4000.0
    base_depth = 1.5
    base_comp = 0.12

    hardness_factor = max(0.3, min(1.5, 1 - (task.material_hardness - 150) / 400))
    diameter_factor = min(1.5, task.tool_diameter / 10)

    feedrate = base_feed * hardness_factor * (0.8 + 0.2 * diameter_factor)
    spindle_speed = base_speed * hardness_factor / diameter_factor
    depth_per_pass = base_depth * hardness_factor * (0.5 + 0.5 * diameter_factor)
    tool_comp = base_comp + 0.002 * task.material_hardness / 100

    return feedrate, spindle_speed, depth_per_pass, tool_comp

def save_model(self, path: str):
    """保存模型及缩放参数"""
    if self.use_pytorch and self.model:
        torch.save({
            'model_state_dict': self.model.state_dict(),
            'input_mean': self.input_scaler_mean,
            'input_std': self.input_scaler_std,
            'output_mean': self.output_scaler_mean,
            'output_std': self.output_scaler_std,
        }, path)
        print(f"模型已保存至 {path}")
    else:
        print("模型不可用，无法保存。")

def load_model(self, path: str):
    """加载模型"""
    if not self.use_pytorch:
        print("PyTorch不可用，无法加载神经网络模型。")
        return
    if not os.path.exists(path):
        print(f"模型文件 {path} 不存在。")
        return
    checkpoint = torch.load(path, map_location='cpu')
    self.model.load_state_dict(checkpoint['model_state_dict'])
    self.input_scaler_mean = checkpoint['input_mean']
    self.input_scaler_std = checkpoint['input_std']
    self.output_scaler_mean = checkpoint['output_mean']
    self.output_scaler_std = checkpoint['output_std']
    print(f"模型已从 {path} 加载。")

class GCodeGenerator:
"""G代码生成器：根据参数生成完整的G-code程序"""
def init(self, params: GCodeParams, task: MachiningTask):
self.params = params
self.task = task

def generate(self, work_offset: str = "G54", safe_z: float = 10.0) -> str:
    """
    生成完整的G-code文件内容
    :param work_offset: 工件坐标系
    :param safe_z: 安全平面Z坐标
    :return: G-code字符串
    """
    lines = []
    lines.append("%")
    lines.append("(G-code generated by AI Model)")
    lines.append(f"(Feature: {self.task.feature.value})")
    lines.append(f"(Material Hardness: {self.task.material_hardness} HB)")
    lines.append(f"(Tool Diameter: {self.task.tool_diameter} mm)")
    lines.append(f"(AI Comments: {self.params.additional_comments})")
    lines.append("")
    lines.append("N10 G90 G80 G40 G17")
    lines.append(f"N20 {work_offset}")
    lines.append("N30 G00 Z10.0")  # 快速移动到安全平面
    lines.append("N40 M03 S{:.0f}".format(self.params.spindle_speed))  # 主轴正转
    lines.append("N50 M08" if self.params.coolant else "N50 M09")  # 冷却液
    lines.append(f"N60 G01 Z{self.params.depth_per_pass:.2f} F{self.params.feedrate:.1f}")
    lines.append("(此处插入加工路径)")
    lines.append("N70 G00 Z{}".format(safe_z))
    lines.append("N80 M05")
    lines.append("N90 M30")
    lines.append("%")
    return "\n".join(lines)

def save_to_file(self, filename: str, content: str):
    """保存G-code到文件"""
    with open(filename, 'w') as f:
        f.write(content)
    print(f"G-code已保存至 {filename}")

========================== 第三部分：集成演示与测试 ==========================

def demo_balance_modifier():
"""演示余额修改器功能"""
print("\n" + "="50)
print(" 余额修改器演示")
print("="50)
bm = BalanceModifier(initial_balance=1000.0, max_overdraft=500.0)
print(bm)
bm.deposit(500, "工资存入")
bm.consume(200, "购买刀具")
bm.withdraw(300, "个人取款")
bm.ai_service_charge(50, "AI模型服务费")
print("\n交易历史:")
for trans in bm.get_transaction_history()[-5:]:
print(f" {trans['timestamp']} | {trans['type'].value} | {trans['amount']:+.2f} | 余额: {trans['balance_after']:.2f} | {trans['description']}")
bm.export_transactions_to_csv("demo_transactions.csv")
return bm

def demo_ai_gcode():
"""演示AI模型G-code计算"""
print("\n" + "="50)
print(" AI模型 G-code 计算演示")
print("="50)

# 创建AI模型实例
ai_model = GCodeAIModel()

# 如果PyTorch可用，训练或加载模型（演示中简单训练一下）
if TORCH_AVAILABLE:
    print("PyTorch可用，进行快速训练（仅演示）...")
    ai_model.train(epochs=20, batch_size=64, lr=0.005)
    # 保存模型示例
    ai_model.save_model("gcode_ai_model.pth")
else:
    print("使用规则引擎（模拟AI）。")

# 定义加工任务
task = MachiningTask(
    feature=MachiningFeature.CONTOUR_MILLING,
    material_hardness=220,   # HB
    tool_diameter=12.0,      # mm
    depth_of_cut=2.5,        # mm
    width_of_cut=8.0,        # mm
    spindle_power=18.0,      # kW
    required_surface_quality=1.6  # Ra
)

# 预测参数
params = ai_model.predict(task)
print("\n预测的G-code参数:")
print(f"  进给率: {params.feedrate:.1f} mm/min")
print(f"  主轴转速: {params.spindle_speed:.0f} rpm")
print(f"  每层切深: {params.depth_per_pass:.2f} mm")
print(f"  冷却液: {'开启' if params.coolant else '关闭'}")
print(f"  刀具补偿: {params.tool_compensation:.3f} mm")
print(f"  注释: {params.additional_comments}")

# 生成G-code
generator = GCodeGenerator(params, task)
gcode = generator.generate(work_offset="G54", safe_z=15.0)
print("\n生成的G-code内容:")
print(gcode)
generator.save_to_file("output_gcode.nc", gcode)
return ai_model, task, params

def batch_processing_demo(ai_model: GCodeAIModel):
"""批量处理演示：多个加工任务"""
print("\n" + "="50)
print(" 批量加工任务预测")
print("="50)
tasks = [
MachiningTask(MachiningFeature.FACE_MILLING, 180, 20, 1.5, 15, 12, 3.2),
MachiningTask(MachiningFeature.DRILLING, 320, 8, 10, 0, 7.5, 6.3),
MachiningTask(MachiningFeature.POCKETING, 260, 16, 3.0, 12, 22, 1.6),
MachiningTask(MachiningFeature.THREADING, 280, 10, 1.2, 0, 5, 0.8),
]
results = []
for idx, t in enumerate(tasks):
params = ai_model.predict(t)
results.append((t, params))
print(f"\n任务 {idx+1}: {t.feature.value}")
print(f" 进给率={params.feedrate:.1f} 转速={params.spindle_speed:.0f} 切深={params.depth_per_pass:.2f}")
return results

if name == "main":
print("===========================================")
print(" 余额修改器 & AI G-code计算系统 完整演示")
print("===========================================")

# 1. 演示余额修改器
bm = demo_balance_modifier()

# 2. 演示AI G-code计算
ai_model, task, params = demo_ai_gcode()

# 3. 批量处理演示
batch_processing_demo(ai_model)

print("\n演示完成。所有功能正常运行。")