Method parse_benchmark_output

utils/quantize_embeddings.py:187–254

Parse benchmark output to extract t/s data (mean±std) Args: output: Benchmark command output output_suffix: Output file suffix Returns: dict: Dictionary with parsed results

(self, output, output_suffix)

            return None
    
    def parse_benchmark_output(self, output, output_suffix):
        """
        Parse benchmark output to extract t/s data (mean±std)
        
        Args:
            output: Benchmark command output
            output_suffix: Output file suffix
        
        Returns:
            dict: Dictionary with parsed results
        """
        results = {
            'embedding_type': output_suffix,
            'threads_1': None,
            'threads_2': None,
            'threads_4': None,
            'threads_8': None,
        }
        
        # Parse table data
        # Find lines containing pp128 and t/s
        lines = output.strip().split('\n')
        
        for line in lines:
            # Skip header and separator lines
            if '|' not in line or 'model' in line or '---' in line:
                continue
            
            # Try to extract data
            # Format similar to: | bitnet-25 2B I2_S - 2 bpw ternary | 1012.28 MiB |     2.74 B | CPU        |      12 |         pp128 |        405.73 ± 3.69 |
            parts = [p.strip() for p in line.split('|')]
            
            if len(parts) >= 8 and 'pp128' in parts[6]:
                threads_str = parts[5].strip()
                throughput_str = parts[7].strip()
                
                # Extract thread count
                try:
                    threads = int(threads_str)
                except:
                    continue
                
                # Extract t/s data (format: "405.73 ± 3.69" or "405.73")
                # Try to match "mean ± std" format
                match_with_std = re.search(r'([\d.]+)\s*±\s*([\d.]+)', throughput_str)
                if match_with_std:
                    mean = float(match_with_std.group(1))
                    std = float(match_with_std.group(2))
                    throughput = f"{mean:.2f}±{std:.2f}"
                else:
                    # Only mean, no std
                    match = re.search(r'([\d.]+)', throughput_str)
                    if match:
                        throughput = f"{float(match.group(1)):.2f}"
                    else:
                        continue
                
                # Store result based on thread count