File size: 5,266 Bytes
41b0a37 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 |
## 2. analyze_model.py
#```python
#!/usr/bin/env python3
"""
Comprehensive analysis of the DeepSeek-V3.1-4bit model
"""
import argparse
from transformers import AutoTokenizer, AutoConfig
import json
import logging
from pathlib import Path
import os
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
def analyze_model(model_path):
"""Comprehensive model analysis"""
logger.info("=" * 60)
logger.info("🔍 DeepSeek-V3.1-4bit Comprehensive Analysis")
logger.info("=" * 60)
# Load config
try:
config = AutoConfig.from_pretrained(model_path)
logger.info("📊 Model Configuration:")
logger.info(f" Architecture: {config.architectures[0] if config.architectures else 'N/A'}")
logger.info(f" Model type: {getattr(config, 'model_type', 'N/A')}")
logger.info(f" Vocab size: {getattr(config, 'vocab_size', 'N/A'):,}")
logger.info(f" Hidden size: {getattr(config, 'hidden_size', 'N/A')}")
logger.info(f" Num hidden layers: {getattr(config, 'num_hidden_layers', 'N/A')}")
logger.info(f" Num attention heads: {getattr(config, 'num_attention_heads', 'N/A')}")
logger.info(f" Max position embeddings: {getattr(config, 'max_position_embeddings', 'N/A')}")
logger.info(f" Context length: {getattr(config, 'max_position_embeddings', 'N/A')}")
# DeepSeek specific config
if hasattr(config, 'rope_theta'):
logger.info(f" RoPE theta: {config.rope_theta}")
if hasattr(config, 'rms_norm_eps'):
logger.info(f" RMS norm eps: {config.rms_norm_eps}")
except Exception as e:
logger.error(f"❌ Failed to load config: {e}")
return
# Load tokenizer
try:
tokenizer = AutoTokenizer.from_pretrained(model_path)
logger.info("\n🔤 Tokenizer Analysis:")
logger.info(f" Vocabulary size: {tokenizer.vocab_size:,}")
logger.info(f" Special tokens: {len(tokenizer.special_tokens_map)}")
logger.info(f" Padding token: {tokenizer.pad_token}")
logger.info(f" EOS token: {tokenizer.eos_token}")
logger.info(f" BOS token: {tokenizer.bos_token}")
# Check for special tokens
special_tokens = getattr(tokenizer, 'special_tokens_map', {})
for key, value in special_tokens.items():
logger.info(f" {key}: {value}")
except Exception as e:
logger.error(f"❌ Failed to load tokenizer: {e}")
return
# Test various prompts
test_prompts = [
"The capital of France is",
"Artificial intelligence is",
"The future of machine learning will",
"Once upon a time",
"import numpy as np",
"量子コンピューティングとは", # Japanese
"El aprendizaje automático es", # Spanish
"机器学习是", # Chinese
"<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\nHello!<|im_end|>\n<|im_start|>assistant",
"def fibonacci(n):",
"The quick brown fox jumps over the lazy dog"
]
logger.info("\n🧪 Tokenization Examples:")
for prompt in test_prompts:
try:
tokens = tokenizer.encode(prompt)
decoded = tokenizer.decode(tokens[:10]) + ("..." if len(tokens) > 10 else "")
logger.info(f" '{prompt[:30]}{'...' if len(prompt) > 30 else ''}'")
logger.info(f" → {len(tokens)} tokens: {tokens[:10]}{'...' if len(tokens) > 10 else ''}")
logger.info(f" → decoded: {decoded}")
except Exception as e:
logger.warning(f" Failed to tokenize: {prompt[:30]} - {e}")
# Check model files
model_dir = Path(model_path)
model_files = list(model_dir.glob("*.safetensors")) + list(model_dir.glob("*.npz")) + list(model_dir.glob("*.gguf"))
logger.info(f"\n📦 Model Files: {len(model_files)} weight files")
for file in model_files:
size_mb = file.stat().st_size / (1024 * 1024)
logger.info(f" {file.name} ({size_mb:.1f} MB)")
# Estimate memory requirements
total_params = 236_000_000_000 # 236B parameters
param_size = 0.5 # bytes per parameter for 4-bit quantization
total_memory_gb = (total_params * param_size) / (1024 ** 3)
logger.info("\n💾 Memory Requirements (Estimated):")
logger.info(f" Model size (4-bit): ~{total_memory_gb:.1f} GB")
logger.info(f" Inference RAM: ~{total_memory_gb * 1.5:.1f} GB+ (for 128K context)")
logger.info(f" GPU VRAM: ~{total_memory_gb:.1f} GB+ (recommended)")
return config, tokenizer
def main():
parser = argparse.ArgumentParser(description="Analyze DeepSeek-V3.1-4bit model")
parser.add_argument("--model-path", type=str, default="./deepseek_v3_4bit",
help="Path to the downloaded model")
args = parser.parse_args()
if not os.path.exists(args.model_path):
logger.error(f"Model path does not exist: {args.model_path}")
return 1
analyze_model(args.model_path)
return 0
if __name__ == "__main__":
exit(main())
#``` |