/
klischa
/
RuView
Обзор
Документация
Войти
/
klischa
/
RuView
Код
Запросы
0
Задачи
Вики
Пакеты
0
Релизы
0
Аналитика
Безопасность
v1709
references/script_6.py
261 строка
9 KB
rUv
Add WiFi DensePose implementation and results
07 июн 2025, 08:23
07 июн 2025, 08:23
f3c77b1
Код
Авторство
О чём код?
# DensePose-RCNN Architecture for WiFi-based Human Pose Estimation # Based on the DensePose paper and WiFi-DensePose implementation import numpy as np from typing import Dict, List, Tuple, Optional from collections import OrderedDict class ResNetFPN: """ Simulated ResNet-FPN backbone for feature extraction """ def __init__(self, input_channels=3, output_channels=256): self.input_channels = input_channels self.output_channels = output_channels print(f"Initialized ResNet-FPN backbone:") print(f" Input channels: {input_channels}") print(f" Output channels: {output_channels}") def extract_features(self, input_tensor): """ Simulates feature extraction through ResNet-FPN Returns a dict of feature maps at different levels (P2-P5) """ input_shape = input_tensor.shape print(f"Extracting features from input shape: {input_shape}") # Simulate FPN feature maps at different scales P2 = np.random.rand(input_shape[0], self.output_channels, input_shape[1]//4, input_shape[2]//4) P3 = np.random.rand(input_shape[0], self.output_channels, input_shape[1]//8, input_shape[2]//8) P4 = np.random.rand(input_shape[0], self.output_channels, input_shape[1]//16, input_shape[2]//16) P5 = np.random.rand(input_shape[0], self.output_channels, input_shape[1]//32, input_shape[2]//32) return { 'P2': P2, 'P3': P3, 'P4': P4, 'P5': P5 } class RegionProposalNetwork: """ Simulated Region Proposal Network (RPN) """ def __init__(self, feature_channels=256, anchor_scales=[8, 16, 32], anchor_ratios=[0.5, 1, 2]): self.feature_channels = feature_channels self.anchor_scales = anchor_scales self.anchor_ratios = anchor_ratios print(f"Initialized Region Proposal Network:") print(f" Feature channels: {feature_channels}") print(f" Anchor scales: {anchor_scales}") print(f" Anchor ratios: {anchor_ratios}") def propose_regions(self, feature_maps, num_proposals=100): """ Simulates proposing regions of interest from feature maps """ proposals = [] # Generate proposals with varying confidence for i in range(num_proposals): # Create random bounding box x = np.random.uniform(0, 1) y = np.random.uniform(0, 1) w = np.random.uniform(0.05, 0.3) h = np.random.uniform(0.1, 0.5) # Add confidence score confidence = np.random.beta(5, 2) # Biased toward higher confidence proposals.append({ 'bbox': [x, y, w, h], 'confidence': confidence }) # Sort by confidence proposals.sort(key=lambda x: x['confidence'], reverse=True) return proposals class ROIAlign: """ Simulated ROI Align operation """ def __init__(self, output_size=(7, 7)): self.output_size = output_size print(f"Initialized ROI Align with output size: {output_size}") def extract_features(self, feature_maps, proposals): """ Simulates ROI Align to extract fixed-size features for each proposal """ roi_features = [] for proposal in proposals: # Create a random feature map for each proposal features = np.random.rand(feature_maps['P2'].shape[1], self.output_size[0], self.output_size[1]) roi_features.append(features) return np.array(roi_features) class DensePoseHead: """ DensePose prediction head for estimating UV coordinates """ def __init__(self, input_channels=256, num_parts=24, output_size=(112, 112)): self.input_channels = input_channels self.num_parts = num_parts self.output_size = output_size print(f"Initialized DensePose Head:") print(f" Input channels: {input_channels}") print(f" Body parts: {num_parts}") print(f" Output size: {output_size}") def predict(self, roi_features): """ Predict body part labels and UV coordinates """ batch_size = roi_features.shape[0] # Predict part classification (24 parts + background) part_pred = np.random.rand(batch_size, self.num_parts + 1, self.output_size[0], self.output_size[1]) part_pred = np.exp(part_pred) / np.sum(np.exp(part_pred), axis=1, keepdims=True) # Apply softmax # Predict UV coordinates for each part u_pred = np.random.rand(batch_size, self.num_parts, self.output_size[0], self.output_size[1]) v_pred = np.random.rand(batch_size, self.num_parts, self.output_size[0], self.output_size[1]) return { 'part_pred': part_pred, 'u_pred': u_pred, 'v_pred': v_pred } class KeypointHead: """ Keypoint prediction head for estimating body keypoints """ def __init__(self, input_channels=256, num_keypoints=17, output_size=(56, 56)): self.input_channels = input_channels self.num_keypoints = num_keypoints self.output_size = output_size print(f"Initialized Keypoint Head:") print(f" Input channels: {input_channels}") print(f" Keypoints: {num_keypoints}") print(f" Output size: {output_size}") def predict(self, roi_features): """ Predict keypoint heatmaps """ batch_size = roi_features.shape[0] # Predict keypoint heatmaps keypoint_heatmaps = np.random.rand(batch_size, self.num_keypoints, self.output_size[0], self.output_size[1]) # Apply softmax to get probability distributions keypoint_heatmaps = np.exp(keypoint_heatmaps) / np.sum(np.exp(keypoint_heatmaps), axis=(2, 3), keepdims=True) return keypoint_heatmaps class DensePoseRCNN: """ Complete DensePose-RCNN architecture """ def __init__(self): self.backbone = ResNetFPN(input_channels=3, output_channels=256) self.rpn = RegionProposalNetwork() self.roi_align = ROIAlign(output_size=(7, 7)) self.densepose_head = DensePoseHead() self.keypoint_head = KeypointHead() print("Initialized DensePose-RCNN architecture") def forward(self, input_tensor): """ Forward pass through the DensePose-RCNN network """ # Extract features from backbone feature_maps = self.backbone.extract_features(input_tensor) # Generate region proposals proposals = self.rpn.propose_regions(feature_maps) # Keep only top proposals top_proposals = proposals[:10] # Extract ROI features roi_features = self.roi_align.extract_features(feature_maps, top_proposals) # Predict DensePose outputs densepose_outputs = self.densepose_head.predict(roi_features) # Predict keypoints keypoint_heatmaps = self.keypoint_head.predict(roi_features) # Process results into a structured format results = [] for i, proposal in enumerate(top_proposals): # Get most likely part label for each pixel part_probs = densepose_outputs['part_pred'][i] part_labels = np.argmax(part_probs, axis=0) # Extract UV coordinates for the predicted parts u_coords = densepose_outputs['u_pred'][i] v_coords = densepose_outputs['v_pred'][i] # Extract keypoint coordinates from heatmaps keypoints = [] for k in range(self.keypoint_head.num_keypoints): heatmap = keypoint_heatmaps[i, k] max_idx = np.argmax(heatmap) y, x = np.unravel_index(max_idx, heatmap.shape) confidence = np.max(heatmap) keypoints.append([x, y, confidence]) results.append({ 'bbox': proposal['bbox'], 'confidence': proposal['confidence'], 'part_labels': part_labels, 'u_coords': u_coords, 'v_coords': v_coords, 'keypoints': keypoints }) return results # Demonstrate the DensePose-RCNN architecture print("="*60) print("DENSEPOSE-RCNN ARCHITECTURE DEMONSTRATION") print("="*60) # Create model model = DensePoseRCNN() # Create a dummy input tensor input_tensor = np.random.rand(1, 3, 720, 1280) print(f"\nPassing input tensor with shape {input_tensor.shape} through model...") # Forward pass results = model.forward(input_tensor) # Display results print(f"\nDensePose-RCNN Results:") print(f" Detected {len(results)} people") for i, person in enumerate(results): bbox = person['bbox'] print(f" Person {i+1}:") print(f" Bounding box: [{bbox[0]:.3f}, {bbox[1]:.3f}, {bbox[2]:.3f}, {bbox[3]:.3f}]") print(f" Confidence: {person['confidence']:.3f}") print(f" Part labels shape: {person['part_labels'].shape}") print(f" UV coordinates shape: ({person['u_coords'].shape}, {person['v_coords'].shape})") print(f" Keypoints: {len(person['keypoints'])}") print("\nDensePose-RCNN demonstration completed!") print("This architecture forms the core of the WiFi-DensePose system") print("when combined with the CSI processing and modality translation components.")