核心概念：让计算机通过数据自动学习和改进，而无需显式编程。
主要分支：
- 监督学习：使用带有标签的数据进行训练，用于预测和分类（如：根据历史数据预测客流）。
- 无监督学习：从无标签数据中发现内在模式和结构（如：将乘客分为不同的出行模式群体）。
- 强化学习：智能体通过与环境交互并获得奖励来学习最优策略（如：学习最节能的列车驾驶曲线）。

2. 深度学习

核心概念：机器学习的一个子集，使用包含多个处理层的深层神经网络来模拟人脑的复杂抽象概念学习。
关键技术：
- 卷积神经网络：主要用于图像和视频识别（如：识别轨道入侵、乘客跌倒）。
- 循环神经网络 及 长短期记忆网络：主要用于处理序列数据（如：基于时间序列的客流预测、设备振动信号分析）。
- 生成对抗网络：可以生成逼真的数据，用于数据增强或模拟极端场景。

3. 自然语言处理

核心概念：使计算机能够理解、解释和生成人类语言。
关键技术：
- 语音识别：将语音转换为文本（如：智能语音助手）。
- 自然语言理解：理解文本的意图和语义（如：理解乘客查询“怎么换乘到机场”）。
- 对话系统：进行多轮人机对话（如：智能客服）。
- 文本生成：自动生成文本报告（如：生成运维日志摘要）。

4. 计算机视觉

核心概念：使计算机能够从图像或视频中“看到”并提取有意义的信息。
关键技术：
- 目标检测与识别：识别图像中的特定物体（如：检测轨道上的障碍物、遗留行李）。
- 图像分割：对图像中的每个像素进行分类（如：精确分析站台人群密度）。
- 行为识别：分析视频中的人体动作（如：识别打架、跌倒等异常行为）。

5. 知识图谱与推理

核心概念：以一种结构化的方式表示现实世界中的实体、概念及其关系，形成一个巨大的语义网络。
应用：构建轨道交通领域的“知识大脑”，用于智能问答、决策推理（如：当A线停运时，自动推理出对B、C线的影响并生成应对方案）。

6. 机器人过程自动化

核心概念：使用软件“机器人”来自动化重复性、规则性的计算机操作流程。
应用：自动处理票务清算、财务对账、员工排班等后台工作。

第二部分：轨道交通中的人工智能关键技术（领域应用技术层）

这部分是将上述通用AI技术与轨道交通的专业知识、数据和业务场景深度融合后产生的具体应用技术。

1. 智能调度与运营技术

关键技术	描述	涉及的AI核心技术
动态客流预测与仿真	利用历史闸机数据、时刻表、天气、社会事件等多源数据，通过LSTM等时序模型，精准预测未来15分钟至数小时的站点级客流。	机器学习（时序模型）、大数据分析
列车智能调度	基于客流预测和实时运行状态，动态调整发车间隔、编组方案，甚至生成“快慢车”、“跨站运行”等复杂调度策略。	强化学习、优化算法、智能决策
列车节能驾驶	计算两点之间的最优速度曲线，确定最佳的加速、巡航、滑行和制动点，实现最大程度的节能。	强化学习、最优控制理论
运行图智能编制与恢复	在发生大规模延误后，快速生成新的运行图调整方案，最小化对全网的影响。	知识图谱、约束求解、遗传算法

2. 智能乘客服务技术

关键技术	描述	涉及的AI核心技术
智能语音交互系统	在车站、App内提供自然语音的问答、购票、导航服务。	自然语言处理（语音识别、NLU、对话管理）
个性化出行即服务	整合地铁、公交、共享单车等多模式交通，根据用户偏好（时间、成本、舒适度）规划端到端的最佳行程。	推荐系统、路径规划算法
生物识别无感支付	通过人脸、掌静脉等生物特征，实现“无停留”进出站和扣费。	计算机视觉（生物识别）、安全加密技术

3. 智能运维与安全技术

关键技术	描述	涉及的AI核心技术
设备预测性维护	分析列车、轨道、供电等设备的传感器数据（振动、温度、电流），提前预测故障发生概率和剩余使用寿命。	机器学习（异常检测、回归预测）、信号处理
基于计算机视觉的智能视频分析	实时分析监控视频，自动检测入侵、跌倒、拥堵、烟火等异常事件。	计算机视觉（目标检测、行为识别、图像分割）
轨道基础设施智能巡检	利用巡检机器人和图像识别技术，自动识别轨道裂纹、扣件缺失等病害。	计算机视觉、机器人技术
司机辅助驾驶与状态监测	识别轨道前方障碍物，同时监测司机的疲劳、分心状态，及时告警或干预。	计算机视觉、传感器融合

4. 智能安防与应急技术

关键技术	描述	涉及的AI核心技术
多模态安防感知	融合视频、音频、Wi-Fi嗅探、烟感等多种传感器数据，实现对安全威胁的综合感知。	多模态机器学习、传感器融合
智能应急疏散推演	在火灾等紧急情况下，基于实时人群分布，动态计算并引导最优疏散路径。	多智能体仿真、图论算法
应急处置决策支持	基于知识图谱，自动生成包含人员调度、设备控制、信息发布的应急预案。	知识图谱、推理引擎

总结

人工智能关键技术是“基础科学”，提供了通用的方法和工具。
轨道交通AI关键技术是“工程应用”，是将基础科学与轨道交通这个垂直领域深度结合的产物。

两者之间的关系是：轨道交通的智能化升级，强烈依赖于底层人工智能技术的进步；同时，轨道交通复杂、高可靠性的应用场景，也反过来推动了AI技术在实时性、可靠性和安全性方面的创新与发展。未来，两者的融合将越来越紧密，最终实现全自动、智能化、一体化的“智慧轨道”系统。

1. 智能调度与运营

动态客流预测与调度

python

复制

下载

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt

class PassengerFlowPredictor:
    """基于机器学习的客流预测系统"""
    
    def __init__(self):
        self.model = RandomForestRegressor(n_estimators=100, random_state=42)
        self.scaler = StandardScaler()
        self.is_fitted = False
        
    def prepare_features(self, historical_data, weather_data, event_data):
        """准备特征数据"""
        features = []
        
        # 时间特征
        historical_data['hour'] = historical_data['timestamp'].dt.hour
        historical_data['day_of_week'] = historical_data['timestamp'].dt.dayofweek
        historical_data['is_weekend'] = historical_data['day_of_week'].isin([5, 6]).astype(int)
        historical_data['is_peak'] = historical_data['hour'].isin([7, 8, 9, 17, 18, 19]).astype(int)
        
        # 历史客流特征
        historical_data['flow_1h_ago'] = historical_data['passenger_flow'].shift(4)  # 假设15分钟一个间隔
        historical_data['flow_same_time_yesterday'] = historical_data['passenger_flow'].shift(96)  # 24小时前
        historical_data['flow_rolling_avg_4h'] = historical_data['passenger_flow'].rolling(16).mean()
        
        # 合并外部数据
        merged_data = historical_data.merge(weather_data, on='timestamp', how='left')
        merged_data = merged_data.merge(event_data, on='timestamp', how='left')
        
        # 选择特征列
        feature_columns = [
            'hour', 'day_of_week', 'is_weekend', 'is_peak',
            'flow_1h_ago', 'flow_same_time_yesterday', 'flow_rolling_avg_4h',
            'temperature', 'rainfall', 'is_holiday', 'event_scale'
        ]
        
        return merged_data[feature_columns], merged_data['passenger_flow']
    
    def train(self, historical_data, weather_data, event_data):
        """训练预测模型"""
        X, y = self.prepare_features(historical_data, weather_data, event_data)
        
        # 处理缺失值
        X = X.fillna(method='ffill')
        y = y.fillna(method='ffill')
        
        # 标准化特征
        X_scaled = self.scaler.fit_transform(X)
        
        # 训练模型
        self.model.fit(X_scaled, y)
        self.is_fitted = True
        
        print("客流预测模型训练完成")
    
    def predict(self, current_conditions, future_hours=4):
        """预测未来客流"""
        if not self.is_fitted:
            raise ValueError("模型尚未训练，请先调用train方法")
        
        predictions = []
        current_data = current_conditions.copy()
        
        for i in range(future_hours):
            # 准备特征
            X, _ = self.prepare_features(current_data, 
                                       current_conditions['weather_data'],
                                       current_conditions['event_data'])
            X = X.fillna(method='ffill')
            X_scaled = self.scaler.transform(X.iloc[-1:])
            
            # 预测
            pred = self.model.predict(X_scaled)[0]
            predictions.append(pred)
            
            # 更新数据用于下一步预测
            # 这里简化处理，实际需要更新timestamp和移动数据
            new_row = current_data.iloc[-1:].copy()
            new_row['passenger_flow'] = pred
            # 更新时间戳等逻辑...
        
        return predictions

class IntelligentScheduler:
    """智能调度系统"""
    
    def __init__(self, flow_predictor):
        self.flow_predictor = flow_predictor
        
    def calculate_optimal_schedule(self, current_conditions):
        """计算最优调度方案"""
        # 预测未来客流
        flow_predictions = self.flow_predictor.predict(current_conditions)
        avg_predicted_flow = np.mean(flow_predictions)
        
        # 基于预测客流调整调度
        if avg_predicted_flow > 8000:  # 极高客流
            interval = 2  # 2分钟间隔
            train_count = 30
            deployment_strategy = "高峰模式：加密班次，准备备用列车"
        elif avg_predicted_flow > 5000:  # 高客流
            interval = 3  # 3分钟间隔  
            train_count = 25
            deployment_strategy = "日常高峰：标准加密班次"
        elif avg_predicted_flow > 2000:  # 中等客流
            interval = 5  # 5分钟间隔
            train_count = 20
            deployment_strategy = "平峰模式：常规班次"
        else:  # 低客流
            interval = 8  # 8分钟间隔
            train_count = 15
            deployment_strategy = "低峰模式：减少班次，节能运行"
        
        return {
            'departure_interval': interval,
            'train_count': train_count,
            'predicted_flow': avg_predicted_flow,
            'deployment_strategy': deployment_strategy,
            'energy_saving_mode': avg_predicted_flow < 3000
        }

# 使用示例
# 生成模拟数据
dates = pd.date_range('2024-01-01', '2024-01-31', freq='15T')
historical_data = pd.DataFrame({
    'timestamp': dates,
    'passenger_flow': np.random.poisson(3000, len(dates)) + 
                     np.sin(np.arange(len(dates)) * 2 * np.pi / 96) * 1000  # 日周期
})

weather_data = pd.DataFrame({
    'timestamp': dates[::96],  # 每天一个数据
    'temperature': np.random.normal(25, 5, len(dates[::96])),
    'rainfall': np.random.exponential(0.1, len(dates[::96]))
})

event_data = pd.DataFrame({
    'timestamp': [],
    'is_holiday': [],
    'event_scale': []  # 0:无事件, 1:小型, 2:中型, 3:大型
})

# 训练和预测
predictor = PassengerFlowPredictor()
predictor.train(historical_data, weather_data, event_data)

scheduler = IntelligentScheduler(predictor)
schedule = scheduler.calculate_optimal_schedule({
    'historical_data': historical_data.tail(100),
    'weather_data': weather_data.iloc[-1:],
    'event_data': event_data
})

print("智能调度方案:", schedule)

列车节能驾驶

python

复制

下载

import numpy as np
from scipy.optimize import minimize

class EnergyEfficientDriver:
    """列车节能驾驶优化"""
    
    def __init__(self, train_mass=200000, max_power=3000, max_brake=2000):
        self.mass = train_mass  # 列车质量 kg
        self.max_power = max_power  # 最大牵引功率 kW
        self.max_brake = max_brake  # 最大制动力 kN
        
    def calculate_energy_consumption(self, velocity_profile, gradient_profile, distance):
        """计算能耗"""
        dt = 1  # 时间步长 1秒
        energy = 0
        positions = np.linspace(0, distance, len(velocity_profile))
        
        for i in range(1, len(velocity_profile)):
            # 计算加速度
            acceleration = (velocity_profile[i] - velocity_profile[i-1]) / dt
            
            # 计算所需牵引力 (考虑坡度阻力、空气阻力等)
            gradient_angle = np.arctan(gradient_profile[i] / 100)  # 坡度百分比转角度
            gradient_force = self.mass * 9.8 * np.sin(gradient_angle)
            
            air_resistance = 0.5 * 0.3 * 1.2 * 10 * velocity_profile[i]**2  # 简化空气阻力
            
            traction_force = (self.mass * acceleration + 
                            gradient_force + air_resistance)
            
            # 计算功率和能耗
            if traction_force > 0:
                power = min(traction_force * velocity_profile[i] / 1000, self.max_power)
                energy += power * dt / 3600  # kWh
                
        return energy
    
    def optimize_driving_curve(self, distance, max_speed, stops, gradient_profile):
        """优化驾驶曲线"""
        n_points = 100
        x = np.linspace(0, distance, n_points)
        
        def objective(velocity_params):
            # 构建速度曲线
            velocity_profile = self._create_velocity_profile(velocity_params, x, stops, max_speed)
            energy = self.calculate_energy_consumption(velocity_profile, gradient_profile, distance)
            return energy
        
        # 初始猜测：简单的梯形速度曲线
        initial_guess = np.array([max_speed * 0.8] * 3)
        
        # 约束条件
        constraints = [
            {'type': 'ineq', 'fun': lambda v: max_speed - max(self._create_velocity_profile(v, x, stops, max_speed))},  # 不超过限速
        ]
        
        # 优化
        result = minimize(objective, initial_guess, method='SLSQP', constraints=constraints)
        
        optimal_velocity = self._create_velocity_profile(result.x, x, stops, max_speed)
        
        return {
            'optimal_velocity_profile': optimal_velocity,
            'positions': x,
            'estimated_energy': result.fun,
            'energy_saving': '约15-20%'  # 相对于简单驾驶策略
        }
    
    def _create_velocity_profile(self, params, positions, stops, max_speed):
        """根据参数创建速度曲线"""
        velocity = np.zeros_like(positions)
        
        # 简化版：加速-巡航-滑行-制动的分段曲线
        cruise_speed = params[0]
        coast_start_ratio = params[1]
        brake_start_ratio = params[2]
        
        for i, pos in enumerate(positions):
            # 检查是否在站点附近
            near_stop = any(abs(pos - stop) < 100 for stop in stops if stop > 0)
            
            if near_stop:
                # 进站制动
                velocity[i] = max(0, cruise_speed * (1 - (pos - min(stops, key=lambda s: abs(s-pos))) / 100))
            else:
                # 正常行驶
                if pos < distance * 0.3:  # 加速段
                    velocity[i] = min(cruise_speed, max_speed * (pos / (distance * 0.3)))
                elif pos < distance * coast_start_ratio:  # 巡航段
                    velocity[i] = min(cruise_speed, max_speed)
                elif pos < distance * brake_start_ratio:  # 滑行段
                    velocity[i] = cruise_speed * 0.9
                else:  # 制动准备段
                    velocity[i] = cruise_speed * 0.7
        
        return velocity

# 使用示例
driver = EnergyEfficientDriver()
distance = 5000  # 5公里
max_speed = 80  # km/h
stops = [0, 5000]  # 起点和终点
gradient = np.zeros(100)  # 平直轨道

result = driver.optimize_driving_curve(distance, max_speed, stops, gradient)
print(f"节能驾驶优化完成，预计节能: {result['energy_saving']}")

2. 智能乘客服务

智能语音助手

python

复制

下载

import speech_recognition as sr
from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
import pyttsx3

class IntelligentVoiceAssistant:
    """轨道交通智能语音助手"""
    
    def __init__(self):
        self.recognizer = sr.Recognizer()
        self.tts_engine = pyttsx3.init()
        
        # 加载预训练的意图分类模型
        self.intent_classifier = pipeline(
            "text-classification", 
            model="bert-base-uncased",  # 实际应用中会用领域特定数据微调
            return_all_scores=True
        )
        
        # 领域知识库
        self.knowledge_base = {
            'route_planning': self.handle_route_query,
            'fare_query': self.handle_fare_query,
            'facility_query': self.handle_facility_query,
            'transfer_query': self.handle_transfer_query,
            'emergency': self.handle_emergency
        }
        
        # 地铁网络数据
        self.metro_network = {
            'Line1': ['StationA', 'StationB', 'StationC', 'StationD'],
            'Line2': ['StationC', 'StationE', 'StationF', 'StationG'],
            'Line3': ['StationB', 'StationH', 'StationI', 'StationJ']
        }
    
    def listen_and_understand(self, audio_source=None):
        """语音识别和语义理解"""
        try:
            if audio_source is None:
                # 使用麦克风
                with sr.Microphone() as source:
                    print("请说话...")
                    audio = self.recognizer.listen(source, timeout=5)
            else:
                # 使用提供的音频文件
                audio = audio_source
            
            # 语音转文本
            text = self.recognizer.recognize_google(audio, language='zh-CN')
            print(f"识别结果: {text}")
            
            # 意图识别
            intent = self.classify_intent(text)
            print(f"识别意图: {intent}")
            
            # 实体提取
            entities = self.extract_entities(text)
            
            return text, intent, entities
            
        except sr.UnknownValueError:
            return None, "unknown", {}
        except sr.RequestError as e:
            return None, "error", {}
        except sr.WaitTimeoutError:
            return None, "timeout", {}
    
    def classify_intent(self, text):
        """分类用户意图"""
        # 简化版规则匹配，实际会用机器学习模型
        text_lower = text.lower()
        
        if any(word in text_lower for word in ['怎么去', '到', '路线', '怎么走']):
            return 'route_planning'
        elif any(word in text_lower for word in ['票价', '多少钱', '价格']):
            return 'fare_query'
        elif any(word in text_lower for word in ['电梯', '无障碍', '行李', '卫生间']):
            return 'facility_query'
        elif any(word in text_lower for word in ['换乘', '转车', '转线']):
            return 'transfer_query'
        elif any(word in text_lower for word in ['紧急', '救命', '帮助', '事故']):
            return 'emergency'
        else:
            return 'general_query'
    
    def extract_entities(self, text):
        """提取文本中的实体"""
        entities = {
            'start_station': None,
            'end_station': None,
            'facility_type': None,
            'special_need': None
        }
        
        # 简单的实体提取逻辑
        stations = ['StationA', 'StationB', 'StationC', 'StationD', 
                   'StationE', 'StationF', 'StationG', 'StationH', 'StationI', 'StationJ']
        
        for station in stations:
            if station.lower() in text.lower():
                if entities['start_station'] is None:
                    entities['start_station'] = station
                else:
                    entities['end_station'] = station
        
        # 提取设施类型
        if '电梯' in text or '无障碍' in text:
            entities['facility_type'] = 'elevator'
        elif '行李' in text:
            entities['special_need'] = 'luggage'
            
        return entities
    
    def generate_response(self, intent, entities, original_text):
        """生成回复"""
        if intent in self.knowledge_base:
            response = self.knowledge_base[intent](entities, original_text)
        else:
            response = "抱歉，我没有完全理解您的问题。您可以询问路线、票价、换乘或车站设施等信息。"
        
        return response
    
    def handle_route_query(self, entities, original_text):
        """处理路线查询"""
        start = entities.get('start_station')
        end = entities.get('end_station')
        
        if start and end:
            route = self.find_optimal_route(start, end)
            return f"从{start}到{end}的最优路线是：{route}。全程预计需要{len(route)-1}个站。"
        else:
            return "请告诉我您的起点和终点车站，我可以为您规划最佳路线。"
    
    def handle_facility_query(self, entities, original_text):
        """处理设施查询"""
        facility_type = entities.get('facility_type')
        special_need = entities.get('special_need')
        
        if facility_type == 'elevator' or special_need == 'luggage':
            return "我为您找到了无障碍路线：所有车站都配备了直升电梯，位于站台两端。携带大件行李的乘客请使用宽闸机。"
        else:
            return "车站内设有卫生间、无障碍设施、自助售票机等便民设施，如需具体位置请咨询站内工作人员。"
    
    def find_optimal_route(self, start, end):
        """查找最优路线（简化版）"""
        # 实际的路线规划算法会更复杂
        for line, stations in self.metro_network.items():
            if start in stations and end in stations:
                start_idx = stations.index(start)
                end_idx = stations.index(end)
                return stations[min(start_idx, end_idx):max(start_idx, end_idx)+1]
        
        # 需要换乘的情况
        return [start, 'StationC', end]  # 简化处理
    
    def speak_response(self, text):
        """语音回复"""
        self.tts_engine.say(text)
        self.tts_engine.runAndWait()

# 使用示例
assistant = IntelligentVoiceAssistant()

# 模拟用户查询
test_queries = [
    "我要从StationA到StationG怎么走？",
    "车站有电梯吗？我带了大件行李",
    "从StationB到StationF的票价是多少？"
]

for query in test_queries:
    print(f"\n用户: {query}")
    text, intent, entities = assistant.listen_and_understand(query)  # 这里简化，直接传入文本
    response = assistant.generate_response(intent, entities, query)
    print(f"助手: {response}")
    # assistant.speak_response(response)  # 实际会语音输出

3. 智能运维与安全

设备预测性维护

python

复制

下载

import numpy as np
import pandas as pd
from sklearn.ensemble import IsolationForest
from sklearn.svm import OneClassSVM
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
import warnings

class PredictiveMaintenanceSystem:
    """设备预测性维护系统"""
    
    def __init__(self):
        self.vibration_model = None
        self.temperature_model = None
        self.acoustic_model = None
        self.warning_threshold = 0.85
        
    def build_lstm_anomaly_detector(self, input_shape):
        """构建LSTM异常检测模型"""
        model = Sequential([
            LSTM(64, return_sequences=True, input_shape=input_shape),
            Dropout(0.2),
            LSTM(32, return_sequences=False),
            Dropout(0.2),
            Dense(16, activation='relu'),
            Dense(1, activation='sigmoid')  # 输出异常概率
        ])
        
        model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
        return model
    
    def train_vibration_model(self, vibration_data, labels):
        """训练振动异常检测模型"""
        # 预处理数据
        X = self.create_sequences(vibration_data, window_size=50)
        y = labels[49:]  # 对齐标签
        
        # 构建并训练模型
        self.vibration_model = self.build_lstm_anomaly_detector((50, 1))
        self.vibration_model.fit(X, y, epochs=10, batch_size=32, validation_split=0.2)
        
        print("振动异常检测模型训练完成")
    
    def create_sequences(self, data, window_size):
        """创建时间序列数据"""
        sequences = []
        for i in range(len(data) - window_size):
            sequences.append(data[i:(i + window_size)])
        return np.array(sequences)
    
    def analyze_real_time_data(self, sensor_data):
        """分析实时传感器数据"""
        warnings = []
        
        # 振动分析
        if self.vibration_model and 'vibration' in sensor_data:
            vibration_risk = self.analyze_vibration_pattern(sensor_data['vibration'])
            if vibration_risk > self.warning_threshold:
                warnings.append({
                    'component': 'wheel_bearing',
                    'risk_level': 'high' if vibration_risk > 0.9 else 'medium',
                    'risk_score': vibration_risk,
                    'predicted_failure_time': f"{int((1 - vibration_risk) * 200)}小时",
                    'recommendation': '建议尽快安排检查'
                })
        
        # 温度分析
        if 'temperature' in sensor_data:
            temp_warning = self.analyze_temperature_trend(sensor_data['temperature'])
            if temp_warning:
                warnings.append(temp_warning)
        
        # 声音分析
        if 'acoustic' in sensor_data:
            sound_warning = self.analyze_acoustic_signature(sensor_data['acoustic'])
            if sound_warning:
                warnings.append(sound_warning)
        
        return warnings
    
    def analyze_vibration_pattern(self, vibration_data):
        """分析振动模式"""
        # 提取特征
        features = {
            'rms': np.sqrt(np.mean(vibration_data**2)),  # 均方根
            'peak_to_peak': np.ptp(vibration_data),      # 峰峰值
            'kurtosis': self.calculate_kurtosis(vibration_data),  # 峰度
            'skewness': self.calculate_skewness(vibration_data)   # 偏度
        }
        
        # 简化的风险评估逻辑
        risk_score = 0
        
        # 高频振动风险
        if features['rms'] > 0.5:
            risk_score += 0.3
        
        # 冲击性振动风险
        if features['kurtosis'] > 3.5:
            risk_score += 0.4
        
        # 不对称振动风险
        if abs(features['skewness']) > 1.0:
            risk_score += 0.3
            
        return min(risk_score, 1.0)
    
    def analyze_temperature_trend(self, temperature_data):
        """分析温度趋势"""
        if len(temperature_data) < 10:
            return None
            
        # 计算温度变化率
        temp_gradient = np.gradient(temperature_data)
        recent_gradient = np.mean(temp_gradient[-5:])
        
        if recent_gradient > 0.5:  # 温度快速上升
            return {
                'component': 'motor_or_gearbox',
                'risk_level': 'medium',
                'risk_score': 0.7,
                'predicted_failure_time': '24-48小时',
                'recommendation': '监测温度变化，准备检修'
            }
        
        return None
    
    def analyze_acoustic_signature(self, audio_data):
        """分析声音特征"""
        # 简化的声音异常检测
        fft = np.fft.fft(audio_data)
        frequencies = np.fft.fftfreq(len(fft))
        
        # 检测特定频率的异常峰值（例如轴承故障特征频率）
        dominant_freq = frequencies[np.argmax(np.abs(fft))]
        
        if 1000 < abs(dominant_freq) < 5000:  # 轴承故障常见频率范围
            return {
                'component': 'bearing',
                'risk_level': 'high',
                'risk_score': 0.85,
                'predicted_failure_time': '48-72小时',
                'recommendation': '立即安排声音诊断和检修'
            }
        
        return None
    
    def calculate_kurtosis(self, data):
        """计算峰度"""
        n = len(data)
        mean = np.mean(data)
        std = np.std(data)
        return np.sum((data - mean) ** 4) / (n * std ** 4)
    
    def calculate_skewness(self, data):
        """计算偏度"""
        n = len(data)
        mean = np.mean(data)
        std = np.std(data)
        return np.sum((data - mean) ** 3) / (n * std ** 3)

# 使用示例
maintenance_system = PredictiveMaintenanceSystem()

# 模拟传感器数据
vibration_data = np.random.normal(0, 0.1, 1000)
# 模拟一个异常（突然增大的振动）
vibration_data[800:850] = np.random.normal(0.5, 0.2, 50)

temperature_data = np.random.normal(65, 5, 100)
# 模拟温度上升
temperature_data[80:] = np.linspace(65, 85, 20)

sensor_data = {
    'vibration': vibration_data,
    'temperature': temperature_data,
    'acoustic': np.random.normal(0, 0.05, 1000)
}

# 分析数据
warnings = maintenance_system.analyze_real_time_data(sensor_data)

print("预测性维护分析结果:")
for warning in warnings:
    print(f"- {warning['component']}: 风险等级{warning['risk_level']}, "
          f"预测故障时间{warning['predicted_failure_time']}, "
          f"建议: {warning['recommendation']}")

智能视频分析

python

复制

下载

import cv2
import numpy as np
from ultralytics import YOLO
import torch

class IntelligentVideoAnalytics:
    """智能视频分析系统"""
    
    def __init__(self):
        # 加载预训练的YOLO模型
        self.object_detector = YOLO('yolov8n.pt')  # 实际会用专门训练的模型
        
        # 加载姿态估计模型（用于跌倒检测）
        self.pose_estimator = YOLO('yolov8n-pose.pt')
        
        # 轨道区域掩码
        self.track_roi = None
        
    def set_track_region(self, frame, polygon_points):
        """设置轨道区域"""
        self.track_roi = np.array(polygon_points, np.int32)
        
    def analyze_frame(self, frame):
        """分析视频帧"""
        alerts = []
        
        # 目标检测
        detections = self.object_detector(frame, verbose=False)[0]
        
        # 人员入侵轨道检测
        intrusion_alerts = self.detect_track_intrusion(frame, detections)
        alerts.extend(intrusion_alerts)
        
        # 跌倒检测
        fall_alerts = self.detect_falls(frame)
        alerts.extend(fall_alerts)
        
        # 可疑物品检测
        suspicious_alerts = self.detect_suspicious_objects(detections)
        alerts.extend(suspicious_alerts)
        
        # 人群密度分析
        crowd_alert = self.analyze_crowd_density(detections)
        if crowd_alert:
            alerts.append(crowd_alert)
            
        return alerts, detections
    
    def detect_track_intrusion(self, frame, detections):
        """检测轨道入侵"""
        alerts = []
        
        if self.track_roi is None:
            return alerts
            
        # 创建轨道区域掩码
        mask = np.zeros(frame.shape[:2], dtype=np.uint8)
        cv2.fillPoly(mask, [self.track_roi], 255)
        
        for detection in detections.boxes:
            if detection.cls == 0:  # person class
                bbox = detection.xyxy[0].cpu().numpy()
                center_x = int((bbox[0] + bbox[2]) / 2)
                center_y = int((bbox[1] + bbox[3]) / 2)
                
                # 检查人员中心点是否在轨道区域内
                if mask[center_y, center_x] == 255:
                    alerts.append({
                        'type': 'track_intrusion',
                        'severity': 'critical',
                        'location': (center_x, center_y),
                        'action': 'trigger_emergency_brake_and_alert_staff',
                        'confidence': detection.conf.item()
                    })
        
        return alerts
    
    def detect_falls(self, frame):
        """检测人员跌倒"""
        alerts = []
        
        # 使用姿态估计
        pose_results = self.pose_estimator(frame, verbose=False)[0]
        
        if pose_results.keypoints is not None:
            for person_keypoints in pose_results.keypoints.xy.cpu().numpy():
                if len(person_keypoints) >= 13:  # 确保有足够的关键点
                    # 计算身体垂直度（简化版跌倒检测）
                    nose = person_keypoints[0]    # 鼻子
                    left_hip = person_keypoints[11]  # 左髋
                    right_hip = person_keypoints[12] # 右髋
                    
                    if not (np.any(np.isnan(nose)) or np.any(np.isnan(left_hip)) or np.any(np.isnan(right_hip))):
                        hip_center = (left_hip + right_hip) / 2
                        vertical_ratio = abs(nose[1] - hip_center[1]) / abs(nose[0] - hip_center[0] + 1e-5)
                        
                        # 如果垂直度很小（人接近水平），可能是跌倒
                        if vertical_ratio < 0.5:
                            bbox_center = (int(np.mean(person_keypoints[:, 0])), 
                                         int(np.mean(person_keypoints[:, 1])))
                            alerts.append({
                                'type': 'person_fall',
                                'severity': 'high',
                                'location': bbox_center,
                                'action': 'notify_station_staff_for_assistance',
                                'confidence': 0.8
                            })
        
        return alerts
    
    def detect_suspicious_objects(self, detections):
        """检测可疑物品"""
        alerts = []
        suspicious_classes = ['backpack', 'handbag', 'suitcase']
        
        for detection in detections.boxes:
            class_name = detections.names[detection.cls.item()]
            if class_name in suspicious_classes:
                # 检查是否长时间静止（实际中需要跟踪）
                bbox = detection.xyxy[0].cpu().numpy()
                center = (int((bbox[0] + bbox[2]) / 2), int((bbox[1] + bbox[3]) / 2))
                
                alerts.append({
                    'type': 'suspicious_object',
                    'severity': 'medium',
                    'object_type': class_name,
                    'location': center,
                    'action': 'mark_for_security_review',
                    'confidence': detection.conf.item()
                })
        
        return alerts
    
    def analyze_crowd_density(self, detections):
        """分析人群密度"""
        person_count = 0
        for detection in detections.boxes:
            if detection.cls == 0:  # person
                person_count += 1
        
        # 简化的密度判断（实际会考虑区域面积）
        if person_count > 50:
            return {
                'type': 'overcrowding',
                'severity': 'medium',
                'person_count': person_count,
                'action': 'initiate_crowd_control_measures',
                'confidence': min(person_count / 100, 1.0)
            }
        
        return None

# 使用示例
def test_video_analytics():
    """测试视频分析系统"""
    analytics = IntelligentVideoAnalytics()
    
    # 创建测试帧（实际中会从摄像头读取）
    test_frame = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
    
    # 设置轨道区域（示例坐标）
    track_points = [(100, 400), (540, 400), (540, 440), (100, 440)]
    analytics.set_track_region(test_frame, track_points)
    
    # 分析帧
    alerts, detections = analytics.analyze_frame(test_frame)
    
    print("视频分析结果:")
    for alert in alerts:
        print(f"- {alert['type']}: 严重程度{alert['severity']}, 位置{alert['location']}, "
              f"行动: {alert['action']}")

# test_video_analytics()

4. 智能安防与应急

智能应急疏散

python

复制

下载

import networkx as nx
import numpy as np
from collections import deque

class EmergencyEvacuationSystem:
    """智能应急疏散系统"""
    
    def __init__(self, station_layout):
        self.station_graph = self.build_station_graph(station_layout)
        self.evacuation_routes = {}
        self.current_emergency = None
        
    def build_station_graph(self, layout):
        """构建车站图结构"""
        G = nx.Graph()
        
        # 添加节点（区域）
        for area_id, area_info in layout['areas'].items():
            G.add_node(area_id, 
                      capacity=area_info['capacity'],
                      safety_score=area_info.get('safety', 1.0),
                      is_exit=area_info.get('is_exit', False))
        
        # 添加边（连接）
        for connection in layout['connections']:
            G.add_edge(connection['from'], connection['to'],
                      weight=connection['distance'],
                      width=connection.get('width', 2.0))
        
        return G
    
    def initiate_evacuation(self, emergency_type, emergency_location, crowd_distribution):
        """启动应急疏散"""
        self.current_emergency = {
            'type': emergency_type,
            'location': emergency_location,
            'timestamp': np.datetime64('now')
        }
        
        # 计算受影响区域
        affected_areas = self.identify_affected_areas(emergency_location, emergency_type)
        
        # 为每个区域生成疏散路径
        self.evacuation_routes = {}
        for area in affected_areas:
            route_info = self.calculate_optimal_evacuation_route(
                area, crowd_distribution.get(area, 0)
            )
            self.evacuation_routes[area] = route_info
        
        # 控制疏散设施
        self.control_evacuation_facilities()
        
        return self.evacuation_routes
    
    def identify_affected_areas(self, danger_zone, emergency_type):
        """识别受影响区域"""
        affected = set()
        
        if emergency_type == 'fire':
            # 火灾影响范围计算
            for node in self.station_graph.nodes:
                distance = nx.shortest_path_length(
                    self.station_graph, danger_zone, node, weight='weight'
                )
                if distance < 100:  # 100米内受影响
                    affected.add(node)
                    
                    # 烟雾可能扩散的路径
                    for neighbor in self.station_graph.neighbors(node):
                        affected.add(neighbor)
        
        elif emergency_type == 'security_threat':
            # 安全威胁影响
            affected = set(self.station_graph.nodes)  # 全站受影响
        
        return list(affected)
    
    def calculate_optimal_evacuation_route(self, start_area, crowd_count):
        """计算最优疏散路径"""
        # 找到所有出口
        exits = [node for node in self.station_graph.nodes 
                if self.station_graph.nodes[node].get('is_exit', False)]
        
        best_route = None
        best_score = -np.inf
        
        for exit_node in exits:
            try:
                # 使用A*算法，考虑安全系数
                path = nx.astar_path(
                    self.station_graph,
                    start_area,
                    exit_node,
                    heuristic=self.evacuation_heuristic,
                    weight='evacuation_cost'
                )
                
                # 计算路径评分
                score = self.calculate_route_score(path, crowd_count)
                
                if score > best_score:
                    best_score = score
                    best_route = path
                    
            except nx.NetworkXNoPath:
                continue
        
        if best_route:
            evacuation_time = self.estimate_evacuation_time(best_route, crowd_count)
            return {
                'route': best_route,
                'exit': best_route[-1],
                'estimated_time': evacuation_time,
                'safety_score': best_score,
                'capacity_utilization': crowd_count / self.get_route_capacity(best_route)
            }
        
        return None
    
    def evacuation_heuristic(self, node1, node2):
        """A*算法的启发式函数"""
        # 考虑距离和安全系数
        position1 = np.array([self.station_graph.nodes[node1].get('x', 0), 
                             self.station_graph.nodes[node1].get('y', 0)])
        position2 = np.array([self.station_graph.nodes[node2].get('x', 0), 
                             self.station_graph.nodes[node2].get('y', 0)])
        
        distance = np.linalg.norm(position1 - position2)
        safety = self.station_graph.nodes[node2].get('safety_score', 1.0)
        
        return distance / safety
    
    def calculate_route_score(self, path, crowd_count):
        """计算路径综合评分"""
        total_safety = 1.0
        total_distance = 0
        
        for i in range(len(path) - 1):
            node1, node2 = path[i], path[i+1]
            edge_data = self.station_graph[node1][node2]
            
            total_safety *= self.station_graph.nodes[node2].get('safety_score', 1.0)
            total_distance += edge_data.get('weight', 1.0)
        
        # 考虑容量约束
        capacity = self.get_route_capacity(path)
        capacity_utilization = crowd_count / capacity if capacity > 0 else np.inf
        
        # 综合评分公式
        safety_weight = 0.6
        distance_weight = 0.3
        capacity_weight = 0.1
        
        score = (safety_weight * total_safety + 
                distance_weight * (1 / total_distance) * 100 +
                capacity_weight * (1 / capacity_utilization))
        
        return score
    
    def get_route_capacity(self, path):
        """获取路径容量（基于最窄处）"""
        min_width = np.inf
        for i in range(len(path) - 1):
            node1, node2 = path[i], path[i+1]
            width = self.station_graph[node1][node2].get('width', 2.0)
            min_width = min(min_width, width)
        
        # 简化容量计算：宽度 × 单位宽度通行能力
        return min_width * 100  # 人/分钟
    
    def estimate_evacuation_time(self, path, crowd_count):
        """估计疏散时间"""
        # 基于路径长度和通行能力估算
        path_length = sum(self.station_graph[path[i]][path[i+1]]['weight'] 
                         for i in range(len(path)-1))
        
        walking_speed = 1.4  # m/s，紧急疏散速度
        walking_time = path_length / walking_speed / 60  # 分钟
        
        # 排队时间（基于容量）
        capacity = self.get_route_capacity(path)
        if capacity > 0:
            queue_time = crowd_count / capacity
        else:
            queue_time = 0
        
        return walking_time + queue_time
    
    def control_evacuation_facilities(self):
        """控制疏散设施"""
        # 打开所有应急出口
        self.control_emergency_doors('open')
        
        # 启动应急照明
        self.control_emergency_lighting('on')
        
        # 调整通风系统（火灾时）
        if self.current_emergency['type'] == 'fire':
            self.control_ventilation_system('smoke_control')
        
        # 更新电子指示牌
        self.update_evacuation_signs()
    
    def control_emergency_doors(self, action):
        """控制应急门"""
        print(f"控制应急门: {action}")
        # 实际会通过物联网接口控制物理设备
    
    def control_emergency_lighting(self, action):
        """控制应急照明"""
        print(f"控制应急照明: {action}")
    
    def control_ventilation_system(self, mode):
        """控制通风系统"""
        print(f"控制通风系统: {mode}模式")
    
    def update_evacuation_signs(self):
        """更新疏散指示牌"""
        for area, route_info in self.evacuation_routes.items():
            print(f"区域 {area} 的指示牌指向: {route_info['exit']}")

# 使用示例
# 定义测试车站布局
test_station_layout = {
    'areas': {
        'platform_a': {'capacity': 500, 'safety': 0.8, 'x': 0, 'y': 0},
        'platform_b': {'capacity': 500, 'safety': 0.8, 'x': 0, 'y': 50},
        'concourse': {'capacity': 1000, 'safety': 0.9, 'x': 30, 'y': 25},
        'exit_east': {'capacity': 200, 'safety': 1.0, 'is_exit': True, 'x': 60, 'y': 25},
        'exit_west': {'capacity': 200, 'safety': 1.0, 'is_exit': True, 'x': -30, 'y': 25},
    },
    'connections': [
        {'from': 'platform_a', 'to': 'concourse', 'distance': 30, 'width': 4.0},
        {'from': 'platform_b', 'to': 'concourse', 'distance': 30, 'width': 4.0},
        {'from': 'concourse', 'to': 'exit_east', 'distance': 30, 'width': 6.0},
        {'from': 'concourse', 'to': 'exit_west', 'distance': 30, 'width': 6.0},
    ]
}

# 创建疏散系统
evacuation_system = EmergencyEvacuationSystem(test_station_layout)

# 模拟火灾紧急情况
crowd_distribution = {
    'platform_a': 300,
    'platform_b': 250,
    'concourse': 400
}

evacuation_plan = evacuation_system.initiate_evacuation(
    emergency_type='fire',
    emergency_location='platform_a',
    crowd_distribution=crowd_distribution
)

print("应急疏散计划:")
for area, plan in evacuation_plan.items():
    if plan:
        print(f"{area} -> {plan['exit']}: 预计{plan['estimated_time']:.1f}分钟, "
              f"安全评分{plan['safety_score']:.2f}")

这些代码示例展示了AI在轨道交通中的具体技术实现，包括：