658 lines
30 KiB
Python
658 lines
30 KiB
Python
import os
|
|
|
|
import joblib
|
|
import numpy as np
|
|
|
|
import config
|
|
from core.deep_learning_model import load_lstm_mlp_bundle, predict_lstm_mlp
|
|
from core.model_features import (
|
|
align_feature_frame,
|
|
apply_label_encoders,
|
|
build_prediction_dataframe,
|
|
engineer_features,
|
|
to_float_array,
|
|
)
|
|
|
|
|
|
MODEL_INFO = {
|
|
'random_forest': {'name': 'random_forest', 'name_cn': '随机森林', 'description': '稳健的树模型集成'},
|
|
'xgboost': {'name': 'xgboost', 'name_cn': '增强树模型一', 'description': '梯度提升树模型'},
|
|
'lightgbm': {'name': 'lightgbm', 'name_cn': '增强树模型二', 'description': '轻量级梯度提升树'},
|
|
'gradient_boosting': {'name': 'gradient_boosting', 'name_cn': '梯度提升树', 'description': '梯度提升决策树'},
|
|
'extra_trees': {'name': 'extra_trees', 'name_cn': '极端随机树', 'description': '高随机性的树模型'},
|
|
'stacking': {'name': 'stacking', 'name_cn': '集成模型', 'description': '多模型融合'},
|
|
'lstm_mlp': {
|
|
'name': 'lstm_mlp',
|
|
'name_cn': '时序注意力融合网络',
|
|
'description': 'Transformer 时序编码与静态特征融合的深度学习模型',
|
|
},
|
|
}
|
|
|
|
EXPLAINABLE_TREE_MODELS = (
|
|
'random_forest',
|
|
'xgboost',
|
|
'lightgbm',
|
|
'gradient_boosting',
|
|
'extra_trees',
|
|
)
|
|
|
|
|
|
class PredictService:
|
|
def __init__(self):
|
|
self.models = {}
|
|
self.classifiers = {}
|
|
self.classification_metrics = {}
|
|
self.scaler = None
|
|
self.feature_names = None
|
|
self.selected_features = None
|
|
self.label_encoders = {}
|
|
self.model_metrics = {}
|
|
self.training_metadata = {}
|
|
self.default_model = 'random_forest'
|
|
|
|
def _ensure_models_loaded(self):
|
|
if not self.models:
|
|
self.load_models()
|
|
|
|
def load_models(self):
|
|
metadata_path = os.path.join(config.MODELS_DIR, 'training_metadata.pkl')
|
|
if os.path.exists(metadata_path):
|
|
self.training_metadata = joblib.load(metadata_path)
|
|
|
|
model_files = {
|
|
'random_forest': 'random_forest_model.pkl',
|
|
'xgboost': 'xgboost_model.pkl',
|
|
'lightgbm': 'lightgbm_model.pkl',
|
|
'gradient_boosting': 'gradient_boosting_model.pkl',
|
|
'extra_trees': 'extra_trees_model.pkl',
|
|
'stacking': 'stacking_model.pkl',
|
|
'lstm_mlp': 'lstm_mlp_model.pt',
|
|
}
|
|
allowed_models = self.training_metadata.get('available_models')
|
|
if allowed_models:
|
|
model_files = {k: v for k, v in model_files.items() if k in allowed_models}
|
|
|
|
for name, filename in model_files.items():
|
|
path = os.path.join(config.MODELS_DIR, filename)
|
|
if os.path.exists(path):
|
|
try:
|
|
if name == 'lstm_mlp':
|
|
bundle = load_lstm_mlp_bundle(path)
|
|
if bundle is not None:
|
|
self.models[name] = bundle
|
|
else:
|
|
self.models[name] = joblib.load(path)
|
|
except Exception as exc:
|
|
print(f'Failed to load model {name}: {exc}')
|
|
|
|
if os.path.exists(config.SCALER_PATH):
|
|
self.scaler = joblib.load(config.SCALER_PATH)
|
|
for filename, attr in [
|
|
('feature_names.pkl', 'feature_names'),
|
|
('selected_features.pkl', 'selected_features'),
|
|
('label_encoders.pkl', 'label_encoders'),
|
|
('model_metrics.pkl', 'model_metrics'),
|
|
]:
|
|
path = os.path.join(config.MODELS_DIR, filename)
|
|
if os.path.exists(path):
|
|
try:
|
|
setattr(self, attr, joblib.load(path))
|
|
except Exception as exc:
|
|
print(f'Failed to load artifact {filename}: {exc}')
|
|
|
|
valid_metrics = {key: value for key, value in self.model_metrics.items() if key in self.models}
|
|
if valid_metrics:
|
|
self.default_model = max(valid_metrics.items(), key=lambda item: item[1]['r2'])[0]
|
|
|
|
for name in ['random_forest', 'gradient_boosting', 'lightgbm', 'xgboost']:
|
|
path = os.path.join(config.MODELS_DIR, f'risk_{name}_classifier.pkl')
|
|
if os.path.exists(path):
|
|
try:
|
|
self.classifiers[name] = joblib.load(path)
|
|
except Exception:
|
|
pass
|
|
cls_metrics_path = os.path.join(config.MODELS_DIR, 'classification_metrics.pkl')
|
|
if os.path.exists(cls_metrics_path):
|
|
try:
|
|
self.classification_metrics = joblib.load(cls_metrics_path)
|
|
except Exception:
|
|
pass
|
|
|
|
def get_available_models(self):
|
|
self._ensure_models_loaded()
|
|
models = []
|
|
for name in self.models.keys():
|
|
info = MODEL_INFO.get(name, {'name': name, 'name_cn': name, 'description': ''}).copy()
|
|
info['is_available'] = True
|
|
info['is_default'] = name == self.default_model
|
|
info['metrics'] = self.model_metrics.get(name, {'r2': 0, 'rmse': 0, 'mae': 0})
|
|
models.append(info)
|
|
models.sort(key=lambda item: item['metrics']['r2'], reverse=True)
|
|
return models
|
|
|
|
def predict_single(self, data, model_type=None, include_explanation=True):
|
|
self._ensure_models_loaded()
|
|
model_type = self._resolve_prediction_model(model_type or self.default_model)
|
|
_, engineered_df = self._build_prediction_frames(data)
|
|
engineered_row = engineered_df.iloc[0]
|
|
|
|
if model_type is None or self.scaler is None or self.feature_names is None:
|
|
result = self._get_default_prediction(data)
|
|
return self._augment_prediction_result(result, data, engineered_row) if include_explanation else result
|
|
|
|
try:
|
|
features = self._prepare_features_from_engineered(engineered_df)
|
|
except Exception:
|
|
result = self._get_default_prediction(data)
|
|
return self._augment_prediction_result(result, data, engineered_row) if include_explanation else result
|
|
|
|
try:
|
|
if model_type == 'lstm_mlp':
|
|
current_df = build_prediction_dataframe(data)
|
|
predicted_hours = predict_lstm_mlp(self.models[model_type], current_df)
|
|
else:
|
|
predicted_hours = self.models[model_type].predict([features])[0]
|
|
predicted_hours = self._inverse_transform_prediction(predicted_hours)
|
|
predicted_hours = max(0.5, float(predicted_hours))
|
|
except Exception:
|
|
result = self._get_default_prediction(data)
|
|
return self._augment_prediction_result(result, data, engineered_row) if include_explanation else result
|
|
|
|
risk_level, risk_label = self._get_risk_level(predicted_hours)
|
|
confidence = max(0.5, self.model_metrics.get(model_type, {}).get('r2', 0.82))
|
|
risk_probability = self._get_risk_probability(features, model_type)
|
|
|
|
result = {
|
|
'predicted_hours': round(predicted_hours, 2),
|
|
'risk_level': risk_level,
|
|
'risk_label': risk_label,
|
|
'risk_probability': risk_probability,
|
|
'confidence': round(confidence, 2),
|
|
'model_used': model_type,
|
|
'model_name_cn': MODEL_INFO.get(model_type, {}).get('name_cn', model_type),
|
|
}
|
|
return self._augment_prediction_result(result, data, engineered_row) if include_explanation else result
|
|
|
|
def predict_compare(self, data):
|
|
self._ensure_models_loaded()
|
|
results = []
|
|
for name in self.models.keys():
|
|
result = self.predict_single(data, name, include_explanation=False)
|
|
result['model'] = name
|
|
result['model_name_cn'] = MODEL_INFO.get(name, {}).get('name_cn', name)
|
|
result['r2'] = self.model_metrics.get(name, {}).get('r2', 0)
|
|
results.append(result)
|
|
results.sort(key=lambda item: item.get('r2', 0), reverse=True)
|
|
if results:
|
|
results[0]['recommended'] = True
|
|
return results
|
|
|
|
def _build_prediction_frames(self, data):
|
|
current_df = build_prediction_dataframe(data)
|
|
engineered_df = engineer_features(current_df.copy())
|
|
return current_df, engineered_df
|
|
|
|
def _prepare_features(self, data):
|
|
_, engineered_df = self._build_prediction_frames(data)
|
|
return self._prepare_features_from_engineered(engineered_df)
|
|
|
|
def _prepare_features_from_engineered(self, engineered_df):
|
|
X_df = apply_label_encoders(engineered_df.copy(), self.label_encoders)
|
|
X_df = align_feature_frame(X_df, self.feature_names)
|
|
features = self.scaler.transform(to_float_array(X_df))[0]
|
|
if self.selected_features:
|
|
selected_indices = [self.feature_names.index(name) for name in self.selected_features if name in self.feature_names]
|
|
if selected_indices:
|
|
features = features[selected_indices]
|
|
return features
|
|
|
|
def _resolve_prediction_model(self, requested_model):
|
|
if requested_model in self.models:
|
|
return requested_model
|
|
if self.default_model in self.models:
|
|
return self.default_model
|
|
return next(iter(self.models), None)
|
|
|
|
def _resolve_explanation_model(self, prediction_model):
|
|
if prediction_model in EXPLAINABLE_TREE_MODELS and prediction_model in self.models:
|
|
return prediction_model
|
|
for candidate in ('random_forest', 'xgboost', 'lightgbm', 'gradient_boosting', 'extra_trees'):
|
|
if candidate in self.models:
|
|
return candidate
|
|
return None
|
|
|
|
def _augment_prediction_result(self, result, data, engineered_row):
|
|
explanation_model = self._resolve_explanation_model(result.get('model_used'))
|
|
shap_local = self._get_local_explanation(data, explanation_model)
|
|
jdr_snapshot = self._build_jdr_snapshot(engineered_row)
|
|
mechanism_summary = self._build_mechanism_summary(result, data, jdr_snapshot, shap_local)
|
|
intervention_suggestions = self._build_intervention_suggestions(data, jdr_snapshot, shap_local)
|
|
|
|
payload = dict(result)
|
|
payload.update({
|
|
'jdr_snapshot': jdr_snapshot,
|
|
'mechanism_summary': mechanism_summary,
|
|
'intervention_suggestions': intervention_suggestions,
|
|
'explanation_model_used': explanation_model,
|
|
'explanation_model_name_cn': MODEL_INFO.get(explanation_model, {}).get('name_cn', '机制解释'),
|
|
'shap_local': shap_local,
|
|
})
|
|
return payload
|
|
|
|
def _get_local_explanation(self, data, model_type):
|
|
if not model_type:
|
|
return None
|
|
try:
|
|
from services.shap_service import shap_service
|
|
|
|
explanation = shap_service.get_local_explanation(data, model_type)
|
|
if explanation and not explanation.get('error'):
|
|
return explanation
|
|
except Exception:
|
|
pass
|
|
return None
|
|
|
|
def _build_jdr_snapshot(self, engineered_row):
|
|
snapshot = {
|
|
'job_demands': self._build_snapshot_item(
|
|
'job_demands',
|
|
'工作要求',
|
|
engineered_row.get('工作要求指数', 0.0),
|
|
*self._classify_job_demands(engineered_row.get('工作要求指数', 0.0)),
|
|
),
|
|
'job_resources': self._build_snapshot_item(
|
|
'job_resources',
|
|
'工作资源',
|
|
engineered_row.get('工作资源指数', 0.0),
|
|
*self._classify_resource_stock(engineered_row.get('工作资源指数', 0.0)),
|
|
),
|
|
'personal_resources': self._build_snapshot_item(
|
|
'personal_resources',
|
|
'个人资源',
|
|
engineered_row.get('个人资源指数', 0.0),
|
|
*self._classify_resource_stock(engineered_row.get('个人资源指数', 0.0)),
|
|
),
|
|
'balance': self._build_snapshot_item(
|
|
'balance',
|
|
'平衡度',
|
|
engineered_row.get('JD-R平衡度', 0.0),
|
|
*self._classify_balance(engineered_row.get('JD-R平衡度', 0.0)),
|
|
),
|
|
'burnout_risk': self._build_snapshot_item(
|
|
'burnout_risk',
|
|
'倦怠风险',
|
|
engineered_row.get('倦怠风险指数', 0.0),
|
|
*self._classify_burnout(engineered_row.get('倦怠风险指数', 0.0)),
|
|
),
|
|
'engagement': self._build_snapshot_item(
|
|
'engagement',
|
|
'工作投入',
|
|
engineered_row.get('工作投入指数', 0.0),
|
|
*self._classify_resource_stock(engineered_row.get('工作投入指数', 0.0)),
|
|
),
|
|
}
|
|
return snapshot
|
|
|
|
def _build_snapshot_item(self, key, label, score, status, tone):
|
|
return {
|
|
'key': key,
|
|
'label': label,
|
|
'score': round(self._safe_float(score), 2),
|
|
'status': status,
|
|
'tone': tone,
|
|
}
|
|
|
|
def _build_mechanism_summary(self, result, data, jdr_snapshot, shap_local):
|
|
dimension_scores = self._extract_dimension_scores(shap_local)
|
|
top_drivers = self._extract_feature_effects(shap_local, positive=True, limit=3)
|
|
protective_factors = self._extract_feature_effects(shap_local, positive=False, limit=2)
|
|
|
|
pathway_label, pathway_tone, pathway_detail = self._infer_pathway(jdr_snapshot, dimension_scores)
|
|
mechanism = self._build_mechanism_text(data, jdr_snapshot, dimension_scores, top_drivers)
|
|
buffer_text = self._build_buffer_text(jdr_snapshot, protective_factors)
|
|
scenario_hint = self._build_scenario_hint(data)
|
|
|
|
return {
|
|
'conclusion': f"本次预测为{result['risk_label']}，预计缺勤时长约 {result['predicted_hours']} 小时。",
|
|
'mechanism': mechanism,
|
|
'pathway_label': pathway_label,
|
|
'pathway_tone': pathway_tone,
|
|
'pathway_detail': pathway_detail,
|
|
'buffer_text': buffer_text,
|
|
'scenario_hint': scenario_hint,
|
|
'top_drivers': top_drivers,
|
|
'protective_factors': protective_factors,
|
|
}
|
|
|
|
def _build_mechanism_text(self, data, jdr_snapshot, dimension_scores, top_drivers):
|
|
if top_drivers:
|
|
driver_names = '、'.join(item['name_cn'] for item in top_drivers)
|
|
if dimension_scores.get('工作要求', 0.0) > 0.03:
|
|
return f'主要推高因素集中在{driver_names}，说明高工作要求正在直接抬升本次缺勤风险。'
|
|
if dimension_scores.get('事件上下文', 0.0) > 0.03:
|
|
return f'主要推高因素集中在{driver_names}，当前结果更容易受到请假事件情境的直接触发。'
|
|
if dimension_scores.get('工作资源', 0.0) > 0.03 or dimension_scores.get('个人资源', 0.0) > 0.03:
|
|
return f'主要推高因素集中在{driver_names}，说明资源缓冲不足正在放大本次缺勤时长。'
|
|
return f'主要推高因素集中在{driver_names}，它们共同推动了本次缺勤时长上升。'
|
|
|
|
fragments = []
|
|
if jdr_snapshot['job_demands']['tone'] in {'warning', 'danger'}:
|
|
fragments.append('工作要求偏高')
|
|
if jdr_snapshot['job_resources']['tone'] == 'danger':
|
|
fragments.append('工作资源不足')
|
|
if jdr_snapshot['personal_resources']['tone'] == 'danger':
|
|
fragments.append('个人资源偏弱')
|
|
if self._as_flag(data.get('medical_certificate_flag')) or self._as_flag(data.get('near_holiday_flag')):
|
|
fragments.append('事件情境触发明显')
|
|
if not fragments:
|
|
return '当前结果更多体现为常规缺勤波动，整体压力与资源结构暂时可控。'
|
|
return f"当前结果主要由{'、'.join(fragments)}共同驱动。"
|
|
|
|
def _build_buffer_text(self, jdr_snapshot, protective_factors):
|
|
if protective_factors:
|
|
names = '、'.join(item['name_cn'] for item in protective_factors)
|
|
return f'{names}对当前风险仍有一定缓冲作用，但尚不足以完全抵消主要压力来源。'
|
|
if jdr_snapshot['job_resources']['tone'] in {'success', 'info'} and jdr_snapshot['personal_resources']['tone'] in {'success', 'info'}:
|
|
return '当前资源支持和个人恢复能力对风险有一定缓冲，但事件性因素仍需持续关注。'
|
|
return ''
|
|
|
|
def _build_scenario_hint(self, data):
|
|
actions = []
|
|
if self._safe_float(data.get('monthly_overtime_hours', 0.0)) >= 25:
|
|
actions.append('将月均加班控制在 20 小时以内')
|
|
if self._safe_float(data.get('commute_minutes', 0.0)) >= 45:
|
|
actions.append('把通勤时长压缩到 30 分钟左右')
|
|
if self._as_flag(data.get('is_night_shift')):
|
|
actions.append('减少连续夜班或延长轮休恢复时间')
|
|
if not actions:
|
|
return ''
|
|
if len(actions) == 1:
|
|
return f'情境判断：若能{actions[0]}，当前风险通常会有所回落。'
|
|
return f"情境判断：若能{'，并'.join(actions[:-1])}，同时{actions[-1]}，当前风险通常会有所回落。"
|
|
|
|
def _infer_pathway(self, jdr_snapshot, dimension_scores):
|
|
demands_pressure = dimension_scores.get('工作要求', 0.0)
|
|
mediator_pressure = dimension_scores.get('中介变量', 0.0)
|
|
resource_pressure = dimension_scores.get('工作资源', 0.0) + dimension_scores.get('个人资源', 0.0)
|
|
event_pressure = dimension_scores.get('事件上下文', 0.0)
|
|
|
|
demands_high = jdr_snapshot['job_demands']['tone'] == 'danger'
|
|
burnout_high = jdr_snapshot['burnout_risk']['tone'] in {'warning', 'danger'}
|
|
resources_low = (
|
|
jdr_snapshot['job_resources']['tone'] == 'danger'
|
|
or jdr_snapshot['personal_resources']['tone'] == 'danger'
|
|
or jdr_snapshot['engagement']['tone'] == 'danger'
|
|
)
|
|
|
|
if demands_high or burnout_high or demands_pressure > 0.03 or mediator_pressure > 0.03:
|
|
if resources_low or resource_pressure > 0.03:
|
|
return (
|
|
'健康损耗与资源缓冲不足',
|
|
'danger',
|
|
'当前结果同时表现出高要求累积与资源缓冲不足，更接近“工作要求上升 → 倦怠累积 → 缺勤增加”的复合路径。',
|
|
)
|
|
return (
|
|
'健康损耗路径为主',
|
|
'warning',
|
|
'当前结果更接近“工作要求上升 → 倦怠累积 → 缺勤增加”的健康损耗路径。',
|
|
)
|
|
if resources_low or resource_pressure > 0.03:
|
|
return (
|
|
'激励支撑不足路径',
|
|
'warning',
|
|
'当前资源与个人恢复能力偏弱，工作投入对缺勤风险的缓冲作用有限。',
|
|
)
|
|
if event_pressure > 0.04:
|
|
return (
|
|
'事件触发型波动',
|
|
'info',
|
|
'当前结果更容易受到请假类型、医院证明和节假日前后等事件情境直接触发。',
|
|
)
|
|
return (
|
|
'混合影响路径',
|
|
'info',
|
|
'当前结果同时受到工作要求、资源结构与事件情境的共同影响，尚不属于单一路径主导。',
|
|
)
|
|
|
|
def _build_intervention_suggestions(self, data, jdr_snapshot, shap_local):
|
|
suggestions = []
|
|
|
|
demand_items = []
|
|
overtime_hours = self._safe_float(data.get('monthly_overtime_hours', 0.0))
|
|
commute_minutes = self._safe_float(data.get('commute_minutes', 0.0))
|
|
if overtime_hours >= 25 or jdr_snapshot['job_demands']['tone'] == 'danger':
|
|
demand_items.append('优先压降连续高负荷排班，尽量把月均加班控制在 20 小时以内。')
|
|
if commute_minutes >= 45:
|
|
demand_items.append('若条件允许，可通过弹性到岗、调班或就近安排缓和通勤压力。')
|
|
if self._as_flag(data.get('is_night_shift')):
|
|
demand_items.append('夜班岗位建议增加轮休和班后恢复时段，避免疲劳持续累积。')
|
|
if self._as_flag(data.get('near_holiday_flag')):
|
|
demand_items.append('节假日前后可提前做好替班和排班缓冲，减少事件性缺勤波动。')
|
|
if not demand_items:
|
|
demand_items.append('当前工作要求未明显失衡，重点保持排班稳定并持续监控波动。')
|
|
suggestions.append({'category': '减要求', 'items': self._limit_unique_items(demand_items)})
|
|
|
|
resource_items = []
|
|
if jdr_snapshot['job_resources']['tone'] in {'warning', 'danger'}:
|
|
resource_items.append('增加主管沟通、临时替班支持和班组协同，补足组织支持资源。')
|
|
if jdr_snapshot['balance']['tone'] in {'warning', 'danger'}:
|
|
resource_items.append('对高风险岗位提供更清晰的任务边界和优先级，降低角色冲突。')
|
|
if str(data.get('leave_reason_category', '')) == '子女照护':
|
|
resource_items.append('可结合弹性工时或家庭照护支持，缓解家庭事务对缺勤的放大作用。')
|
|
if not resource_items:
|
|
resource_items.append('当前资源面整体可用，建议继续维持支持性排班和沟通反馈机制。')
|
|
suggestions.append({'category': '增资源', 'items': self._limit_unique_items(resource_items)})
|
|
|
|
personal_items = []
|
|
if self._as_flag(data.get('chronic_disease_flag')) or self._as_flag(data.get('medical_certificate_flag')):
|
|
personal_items.append('结合健康监测、复诊安排和短期工作调整，降低身体不适带来的持续缺勤风险。')
|
|
if jdr_snapshot['burnout_risk']['tone'] in {'warning', 'danger'}:
|
|
personal_items.append('建议通过休息恢复、情绪支持和短周期工作调整，缓冲倦怠累积。')
|
|
if jdr_snapshot['personal_resources']['tone'] == 'danger':
|
|
personal_items.append('可通过辅导、复盘和岗位支持增强员工自我效能与心理韧性。')
|
|
if not personal_items:
|
|
personal_items.append('当前个体恢复能力整体可控，重点维持规律作息和健康管理即可。')
|
|
suggestions.append({'category': '补个人资源', 'items': self._limit_unique_items(personal_items)})
|
|
|
|
return suggestions
|
|
|
|
def _extract_dimension_scores(self, shap_local):
|
|
if not shap_local:
|
|
return {}
|
|
dimension_contribution = shap_local.get('dimension_contribution', {})
|
|
return {
|
|
key: self._safe_float(value)
|
|
for key, value in dimension_contribution.items()
|
|
if isinstance(value, (int, float))
|
|
}
|
|
|
|
def _extract_feature_effects(self, shap_local, positive=True, limit=3):
|
|
if not shap_local:
|
|
return []
|
|
features = shap_local.get('features', [])
|
|
filtered = []
|
|
for item in features:
|
|
shap_value = self._safe_float(item.get('shap_value', 0.0))
|
|
if positive and shap_value <= 0:
|
|
continue
|
|
if not positive and shap_value >= 0:
|
|
continue
|
|
filtered.append({
|
|
'name': item.get('name'),
|
|
'name_cn': item.get('name_cn') or item.get('name') or '未命名特征',
|
|
'dimension': self._dimension_label(item.get('dimension')),
|
|
'shap_value': round(shap_value, 4),
|
|
})
|
|
filtered.sort(key=lambda entry: entry['shap_value'], reverse=positive)
|
|
if not positive:
|
|
filtered.sort(key=lambda entry: abs(entry['shap_value']), reverse=True)
|
|
return filtered[:limit]
|
|
|
|
def _dimension_label(self, key):
|
|
if key in config.JDR_DIMENSIONS:
|
|
return config.JDR_DIMENSIONS[key]['name_cn']
|
|
if key == 'event_context':
|
|
return '事件上下文'
|
|
if key == 'other':
|
|
return '其他因素'
|
|
return key or '其他因素'
|
|
|
|
def _limit_unique_items(self, items, limit=3):
|
|
unique_items = []
|
|
for item in items:
|
|
if item not in unique_items:
|
|
unique_items.append(item)
|
|
return unique_items[:limit]
|
|
|
|
def _classify_job_demands(self, score):
|
|
score = self._safe_float(score)
|
|
if score >= 5.2:
|
|
return '偏高', 'danger'
|
|
if score >= 4.0:
|
|
return '中等', 'warning'
|
|
return '适中', 'success'
|
|
|
|
def _classify_resource_stock(self, score):
|
|
score = self._safe_float(score)
|
|
if score >= 3.8:
|
|
return '充足', 'success'
|
|
if score >= 3.0:
|
|
return '中等', 'warning'
|
|
return '偏低', 'danger'
|
|
|
|
def _classify_balance(self, score):
|
|
score = self._safe_float(score)
|
|
if score >= 0.8:
|
|
return '资源占优', 'success'
|
|
if score >= 0.0:
|
|
return '基本平衡', 'info'
|
|
if score >= -0.8:
|
|
return '轻度失衡', 'warning'
|
|
return '明显失衡', 'danger'
|
|
|
|
def _classify_burnout(self, score):
|
|
score = self._safe_float(score)
|
|
if score >= 2.8:
|
|
return '偏高', 'danger'
|
|
if score >= 2.0:
|
|
return '中等', 'warning'
|
|
return '可控', 'success'
|
|
|
|
def _inverse_transform_prediction(self, prediction):
|
|
if self.training_metadata.get('target_transform') == 'log1p':
|
|
return float(np.expm1(prediction))
|
|
return float(prediction)
|
|
|
|
def _get_risk_level(self, hours):
|
|
if hours < 4:
|
|
return 'low', '低风险'
|
|
if hours <= 8:
|
|
return 'medium', '中风险'
|
|
return 'high', '高风险'
|
|
|
|
def _get_default_prediction(self, data):
|
|
base_hours = 3.8
|
|
base_hours += min(self._safe_float(data.get('monthly_overtime_hours', 24)) / 20, 3.0)
|
|
base_hours += min(self._safe_float(data.get('commute_minutes', 40)) / 50, 2.0)
|
|
base_hours += 1.6 if self._as_flag(data.get('is_night_shift')) else 0
|
|
base_hours += 1.8 if self._as_flag(data.get('chronic_disease_flag')) else 0
|
|
base_hours += 0.9 if self._as_flag(data.get('near_holiday_flag')) else 0
|
|
base_hours += 0.8 if self._as_flag(data.get('medical_certificate_flag')) else 0
|
|
base_hours += 0.5 * int(self._safe_float(data.get('children_count', 0)))
|
|
if data.get('leave_type') in ['病假', '工伤假', '婚假', '丧假']:
|
|
base_hours += 2.5
|
|
if data.get('stress_level') == '高':
|
|
base_hours += 0.9
|
|
if data.get('performance_level') == 'A':
|
|
base_hours -= 0.5
|
|
risk_level, risk_label = self._get_risk_level(base_hours)
|
|
return {
|
|
'predicted_hours': round(max(0.5, base_hours), 2),
|
|
'risk_level': risk_level,
|
|
'risk_label': risk_label,
|
|
'risk_probability': {'low': 0.0, 'medium': 1.0, 'high': 0.0},
|
|
'confidence': 0.72,
|
|
'model_used': 'default',
|
|
'model_name_cn': '默认规则',
|
|
}
|
|
|
|
def _get_risk_probability(self, features, model_type):
|
|
classifier = self.classifiers.get(model_type)
|
|
if classifier is None:
|
|
classifier = self.classifiers.get('random_forest')
|
|
if classifier is None:
|
|
return {'low': 0.0, 'medium': 1.0, 'high': 0.0}
|
|
try:
|
|
proba = classifier.predict_proba([features])[0]
|
|
classes = list(classifier.classes_)
|
|
result = {'low': 0.0, 'medium': 0.0, 'high': 0.0}
|
|
label_map = {0: 'low', 1: 'medium', 2: 'high'}
|
|
for idx, cls in enumerate(classes):
|
|
if cls in label_map:
|
|
result[label_map[cls]] = round(float(proba[idx]), 4)
|
|
return result
|
|
except Exception:
|
|
return {'low': 0.0, 'medium': 1.0, 'high': 0.0}
|
|
|
|
def predict_risk_classification(self, data, model_type=None):
|
|
self._ensure_models_loaded()
|
|
model_type = model_type or self.default_model
|
|
classifier = self.classifiers.get(model_type)
|
|
if classifier is None:
|
|
classifier = self.classifiers.get('random_forest')
|
|
if classifier is None or self.scaler is None:
|
|
return None
|
|
|
|
features = self._prepare_features(data)
|
|
try:
|
|
pred_class = int(classifier.predict([features])[0])
|
|
proba = classifier.predict_proba([features])[0]
|
|
label_map = {0: 'low', 1: 'medium', 2: 'high'}
|
|
risk_labels_map = {'low': '低风险', 'medium': '中风险', 'high': '高风险'}
|
|
risk_level = label_map.get(pred_class, 'medium')
|
|
|
|
classes = list(classifier.classes_)
|
|
probabilities = {'low': 0.0, 'medium': 0.0, 'high': 0.0}
|
|
for idx, cls in enumerate(classes):
|
|
if cls in label_map:
|
|
probabilities[label_map[cls]] = round(float(proba[idx]), 4)
|
|
|
|
return {
|
|
'risk_level': risk_level,
|
|
'risk_label': risk_labels_map[risk_level],
|
|
'risk_probability': probabilities,
|
|
'model_used': model_type,
|
|
'classification_metrics': self.classification_metrics.get(model_type, {}),
|
|
}
|
|
except Exception:
|
|
return None
|
|
|
|
def get_model_info(self):
|
|
self._ensure_models_loaded()
|
|
return {
|
|
'models': self.get_available_models(),
|
|
'training_info': {
|
|
'train_samples': self.training_metadata.get('train_samples', 0),
|
|
'test_samples': self.training_metadata.get('test_samples', 0),
|
|
'feature_count': self.training_metadata.get('feature_count_after_selection', 0),
|
|
'training_date': self.training_metadata.get('training_date', ''),
|
|
'sequence_window_size': self.training_metadata.get('sequence_window_size', 0),
|
|
'deep_learning_available': self.training_metadata.get('deep_learning_available', False),
|
|
},
|
|
}
|
|
|
|
def _safe_float(self, value, default=0.0):
|
|
try:
|
|
return float(value)
|
|
except (TypeError, ValueError):
|
|
return default
|
|
|
|
def _as_flag(self, value):
|
|
try:
|
|
return int(value) == 1
|
|
except (TypeError, ValueError):
|
|
return False
|
|
|
|
|
|
predict_service = PredictService()
|