/**
|
* 统一的配置模型管理类
|
* 用一个 model 贯穿整个配置流程，只更新 value 不改变结构
|
*/
|
import { getParameterLabel } from './parameterMapping'
|
|
export class ConfigModel {
|
constructor() {
|
this.model = null
|
this.baseConfig = null
|
}
|
|
/**
|
* 初始化配置模型（从 base_config.json 创建）
|
* @param {Object} baseConfig - 基础配置对象
|
*/
|
async initialize(baseConfig) {
|
if (!baseConfig) {
|
throw new Error('基础配置不能为空')
|
}
|
|
// 保存原始基础配置
|
this.baseConfig = JSON.parse(JSON.stringify(baseConfig))
|
|
// 创建工作模型（深拷贝）
|
this.model = JSON.parse(JSON.stringify(baseConfig))
|
|
console.log('[ConfigModel] 配置模型初始化完成')
|
return this.model
|
}
|
|
/**
|
* 根据模型类型更新配置值（只更新 value，不改变结构）
|
* @param {string} modelType - 模型类型（如 'MSDN', 'DINO' 等）
|
* @param {Object} modelConfig - 模型特定配置
|
*/
|
updateWithModelConfig(modelType, modelConfig) {
|
if (!this.model) {
|
throw new Error('配置模型未初始化')
|
}
|
|
if (!modelConfig) {
|
console.warn('[ConfigModel] 模型配置为空，跳过更新')
|
return this.model
|
}
|
|
console.log(`[ConfigModel] 应用 ${modelType} 模型配置`)
|
|
// 遍历模型配置，只更新已存在的键的值
|
this._updateValues(this.model, modelConfig)
|
|
// 特殊处理：确保模型特定的配置节点存在且更新
|
if (modelConfig[modelType] && typeof modelConfig[modelType] === 'object') {
|
if (!this.model[modelType]) {
|
// 如果基础配置中没有该模型的配置节点，创建它
|
this.model[modelType] = {}
|
}
|
// 更新模型特定配置
|
this._updateValues(this.model[modelType], modelConfig[modelType])
|
}
|
|
console.log(`[ConfigModel] ${modelType} 配置更新完成`)
|
return this.model
|
}
|
|
/**
|
* 更新单个配置值
|
* @param {string} key - 配置键（支持嵌套，如 'MSDN.backbone_weight'）
|
* @param {any} value - 新值
|
*/
|
updateValue(key, value) {
|
if (!this.model) {
|
throw new Error('配置模型未初始化')
|
}
|
|
const keys = key.split('.')
|
let target = this.model
|
|
// 导航到目标位置
|
for (let i = 0; i < keys.length - 1; i++) {
|
const k = keys[i]
|
if (!target[k]) {
|
// 如果路径不存在，创建对象
|
target[k] = {}
|
}
|
target = target[k]
|
}
|
|
// 设置值
|
const lastKey = keys[keys.length - 1]
|
target[lastKey] = value
|
|
console.log(`[ConfigModel] 更新配置: ${key} = ${value}`)
|
return this.model
|
}
|
|
/**
|
* 批量更新配置值
|
* @param {Object} updates - 要更新的键值对
|
*/
|
updateValues(updates) {
|
if (!this.model) {
|
throw new Error('配置模型未初始化')
|
}
|
|
Object.entries(updates).forEach(([key, value]) => {
|
this.updateValue(key, value)
|
})
|
|
return this.model
|
}
|
|
/**
|
* 从用户界面参数更新配置
|
* @param {Object} uiParams - UI参数对象
|
*/
|
updateFromUIParams(uiParams) {
|
if (!this.model) {
|
throw new Error('配置模型未初始化')
|
}
|
|
const {
|
trainingConfig,
|
deviceConfig,
|
neuralNetworkConfig,
|
modelParams,
|
fixedModelParams,
|
imageEnhancementConfig,
|
splitModel
|
} = uiParams
|
|
// 更新训练参数
|
if (trainingConfig) {
|
this.updateValues({
|
'epochs': trainingConfig.epochs,
|
'lr': trainingConfig.lr,
|
'batch_size': trainingConfig.batch_size || trainingConfig.batchSize,
|
'val_interval': trainingConfig.val_interval || trainingConfig.valInterval,
|
'checkpoint_interval': trainingConfig.checkpoint_interval || trainingConfig.checkpointInterval,
|
'random_seed': trainingConfig.random_seed || trainingConfig.randomSeed,
|
'optimizer_name': trainingConfig.optimizerName,
|
'loss_name': trainingConfig.lossName
|
})
|
}
|
|
// 更新设备配置
|
if (deviceConfig) {
|
this.updateValues({
|
'use_gpu': deviceConfig.use_gpu,
|
'gpu_ids': deviceConfig.gpu_ids,
|
'num_workers': deviceConfig.num_workers
|
})
|
}
|
|
// 更新神经网络配置
|
if (neuralNetworkConfig) {
|
this.updateValues({
|
'input_width': neuralNetworkConfig.input_width,
|
'input_height': neuralNetworkConfig.input_height,
|
'crop_width': neuralNetworkConfig.crop_width,
|
'crop_height': neuralNetworkConfig.crop_height
|
})
|
}
|
|
// 更新固定模型参数
|
if (fixedModelParams) {
|
this.updateValues({
|
'resume_checkpoint': fixedModelParams.resume_checkpoint,
|
'output_dir': fixedModelParams.output_dir,
|
'checkpoint_path': fixedModelParams.checkpoint_path,
|
'val_interval': fixedModelParams.val_interval,
|
'checkpoint_interval': fixedModelParams.checkpoint_interval
|
})
|
}
|
|
// 更新动态模型参数
|
if (modelParams && Array.isArray(modelParams)) {
|
modelParams.forEach(param => {
|
if (param.key && param.value !== undefined) {
|
this.updateValue(param.key, param.value)
|
}
|
})
|
}
|
|
// 更新图像增强配置
|
if (imageEnhancementConfig && Array.isArray(imageEnhancementConfig)) {
|
imageEnhancementConfig.forEach(config => {
|
if (config.key) {
|
// 启用/禁用
|
this.updateValue(config.key, config.enabled)
|
|
// 更新概率参数（ratio）
|
if (config.probability !== undefined && config.probability !== null) {
|
const ratioKey = config.key + '_ratio'
|
// UI显示的是百分比（0-100），需要转换为小数（0-1）
|
const ratioValue = parseFloat(config.probability) / 100
|
this.updateValue(ratioKey, ratioValue)
|
}
|
|
// 更新范围参数
|
if (config.range !== undefined && config.range !== null) {
|
if (config.key === 'random_flip') {
|
// 翻转类型直接保存字符串
|
this.updateValue('random_flip_type', config.range)
|
} else {
|
// 其他范围参数（UI显示的是百分比，需要转换为小数）
|
const rangeKey = config.key + '_range'
|
const rangeValue = parseFloat(config.range) / 100
|
this.updateValue(rangeKey, rangeValue)
|
}
|
}
|
}
|
})
|
}
|
|
// 更新拆分模型
|
if (splitModel) {
|
this.updateValue('split_id', splitModel)
|
}
|
|
return this.model
|
}
|
|
/**
|
* 获取当前配置模型
|
*/
|
getModel() {
|
if (!this.model) {
|
throw new Error('配置模型未初始化')
|
}
|
return JSON.parse(JSON.stringify(this.model))
|
}
|
|
/**
|
* 获取用于保存的配置（清理不必要的字段）
|
* @param {string} currentModelType - 当前模型类型，只保留此模型的特定配置
|
*/
|
getConfigForSave(currentModelType = null) {
|
if (!this.model) {
|
throw new Error('配置模型未初始化')
|
}
|
|
const config = JSON.parse(JSON.stringify(this.model))
|
|
// 过滤其他模型的配置，只保留当前模型的配置
|
if (currentModelType) {
|
const modelTypes = ['MSDN', 'SupportLabeler', 'DINO', 'Mask2Former', 'TDGN', 'MGCN']
|
|
modelTypes.forEach(modelType => {
|
if (modelType !== currentModelType && config[modelType]) {
|
delete config[modelType]
|
console.log(`[ConfigModel] 已过滤 ${modelType} 模型配置`)
|
}
|
})
|
}
|
|
return config
|
}
|
|
/**
|
* 重置到基础配置
|
*/
|
reset() {
|
if (!this.baseConfig) {
|
throw new Error('基础配置不存在')
|
}
|
|
this.model = JSON.parse(JSON.stringify(this.baseConfig))
|
console.log('[ConfigModel] 配置已重置到基础状态')
|
return this.model
|
}
|
|
/**
|
* 私有方法：递归更新值（只更新已存在的键）
|
*/
|
_updateValues(target, source) {
|
Object.keys(source).forEach(key => {
|
// 如果源值是对象且目标也有这个键且也是对象，递归更新
|
if (source[key] && typeof source[key] === 'object' &&
|
!Array.isArray(source[key]) &&
|
target[key] && typeof target[key] === 'object' &&
|
!Array.isArray(target[key])) {
|
this._updateValues(target[key], source[key])
|
} else {
|
// 直接更新值（包括数组）
|
target[key] = source[key]
|
}
|
})
|
}
|
|
/**
|
* 获取特定模型的参数（用于UI展示）
|
* @param {string} modelType - 模型类型
|
*/
|
getModelSpecificParams(modelType) {
|
if (!this.model || !modelType) {
|
return []
|
}
|
|
const modelConfig = this.model[modelType]
|
if (!modelConfig || typeof modelConfig !== 'object') {
|
return []
|
}
|
|
// 将模型特定配置转换为UI参数数组
|
return Object.entries(modelConfig).map(([key, value]) => ({
|
key: `${modelType}.${key}`,
|
label: getParameterLabel(key) || this._formatLabel(key),
|
value: value,
|
type: this._inferType(value)
|
}))
|
}
|
|
/**
|
* 格式化标签（备用方法，当 parameterMapping.js 中没有映射时使用）
|
*/
|
_formatLabel(key) {
|
return key.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase())
|
}
|
|
/**
|
* 推断值的类型
|
*/
|
_inferType(value) {
|
if (typeof value === 'boolean') return 'boolean'
|
if (typeof value === 'number') {
|
return Number.isInteger(value) ? 'integer' : 'float'
|
}
|
if (typeof value === 'string') {
|
if (value.includes('path') || value.includes('weight') || value.includes('.pth') || value.includes('.pt')) {
|
return 'path'
|
}
|
}
|
if (Array.isArray(value)) return 'array'
|
return 'string'
|
}
|
}
|
|
// 单例实例
|
export const configModel = new ConfigModel()
|
