Download persistent_model.py from ChadlieOak/ae: direct link, hf CLI and curl.
- Browser
- Download file 18.1 kB
-
https://huggingface.co/ChadlieOak/ae/resolve/main/persistent_model.py
- Command line
-
hf download hf://ChadlieOak/ae/persistent_model.py
-
curl -L -o persistent_model.py https://huggingface.co/ChadlieOak/ae/resolve/main/persistent_model.py
18.1 kB
| import torch | |
| import pickle | |
| import json | |
| import os | |
| from typing import Dict, List, Tuple, Optional | |
| import numpy as np | |
| from text_processor import HierarchicalTextProcessor | |
| from ae import ZRIA_Ultimate_PFAF, AdvancedTokenizer, EnhancedDataset | |
| class PersistentZRIAModel: | |
| """ | |
| A persistent wrapper around the ZRIA model that allows saving/loading | |
| and interactive prompting without retraining. | |
| """ | |
| def __init__(self, model_dir: str = "zria_model"): | |
| self.model_dir = model_dir | |
| self.model = None | |
| self.tokenizer = None | |
| self.knowledge_base = None | |
| self.device = 'cuda' if torch.cuda.is_available() else 'cpu' | |
| # Create model directory if it doesn't exist | |
| os.makedirs(model_dir, exist_ok=True) | |
| # Model file paths | |
| self.model_path = os.path.join(model_dir, "zria_model.pth") | |
| self.tokenizer_path = os.path.join(model_dir, "tokenizer.pkl") | |
| self.knowledge_path = os.path.join(model_dir, "knowledge_base.pkl") | |
| self.config_path = os.path.join(model_dir, "config.json") | |
| # Load existing model if available | |
| if self._check_model_exists(): | |
| self.load_model() | |
| def _check_model_exists(self) -> bool: | |
| """Check if a trained model exists in the model directory.""" | |
| return (os.path.exists(self.model_path) and | |
| os.path.exists(self.tokenizer_path) and | |
| os.path.exists(self.config_path)) | |
| def train_and_save(self, training_data: List[Tuple], | |
| model_config: Dict = None) -> None: | |
| """ | |
| Train the ZRIA model and save it for persistent use. | |
| Args: | |
| training_data: List of (prefix, text, label) tuples | |
| model_config: Configuration dictionary for model parameters | |
| """ | |
| print("=== Training ZRIA Model ===") | |
| # Default configuration | |
| if model_config is None: | |
| model_config = { | |
| 'dim': 128, | |
| 'max_seq_len': 64, | |
| 'action_dim': 1, | |
| 'batch_size': 16, | |
| 'epochs': 150, | |
| 'learning_rate': 3e-4, | |
| 'weight_decay': 0.01 | |
| } | |
| # Create tokenizer from training data | |
| corpus = [text for _, text, _ in training_data] | |
| self.tokenizer = AdvancedTokenizer(corpus) | |
| # Create dataset and dataloader | |
| dataset = EnhancedDataset(training_data, self.tokenizer, max_len=model_config['max_seq_len']) | |
| dataloader = torch.utils.data.DataLoader( | |
| dataset, | |
| batch_size=model_config['batch_size'], | |
| shuffle=True | |
| ) | |
| # Initialize model | |
| self.model = ZRIA_Ultimate_PFAF( | |
| dim=model_config['dim'], | |
| vocab_size=self.tokenizer.vocab_size, | |
| action_dim=model_config['action_dim'], | |
| max_seq_len=model_config['max_seq_len'] | |
| ) | |
| # Training setup | |
| optimizer = torch.optim.AdamW( | |
| self.model.parameters(), | |
| lr=model_config['learning_rate'], | |
| weight_decay=model_config['weight_decay'] | |
| ) | |
| scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts( | |
| optimizer, T_0=30, T_mult=2, eta_min=1e-6 | |
| ) | |
| # Train the model | |
| self._train_model(dataloader, optimizer, scheduler, model_config['epochs']) | |
| # Save the trained model | |
| self.save_model(model_config) | |
| print("=== Training Complete ===") | |
| def _train_model(self, dataloader, optimizer, scheduler, epochs: int): | |
| """Internal training loop.""" | |
| self.model.to(self.device) | |
| self.model.train() | |
| text_crit = torch.nn.CrossEntropyLoss() | |
| action_crit = torch.nn.MSELoss() | |
| route_crit = torch.nn.CrossEntropyLoss() | |
| for epoch in range(epochs): | |
| total_loss = 0 | |
| for batch in dataloader: | |
| ids = batch['input_ids'].to(self.device) | |
| labels = batch['label'].to(self.device) | |
| mod_idx = batch['modality_idx'].to(self.device) | |
| optimizer.zero_grad() | |
| outputs = self.model(ids, mod_idx, mode='auto') | |
| # Calculate loss | |
| text_mask = torch.tensor([m == 'text' for m in batch['mode']], device=self.device) | |
| action_mask = ~text_mask | |
| loss = 0 | |
| if text_mask.any(): | |
| loss += text_crit(outputs['text_logits'][text_mask], labels[text_mask].long()) | |
| loss += 0.1 * route_crit(outputs['route_probs'][text_mask], | |
| torch.zeros(text_mask.sum(), dtype=torch.long, device=self.device)) | |
| if action_mask.any(): | |
| loss += 0.1 * action_crit(outputs['action_output'][action_mask].squeeze(-1), | |
| labels[action_mask]) | |
| loss += 0.1 * route_crit(outputs['route_probs'][action_mask], | |
| torch.ones(action_mask.sum(), dtype=torch.long, device=self.device)) | |
| if isinstance(loss, torch.Tensor): | |
| loss.backward() | |
| torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0) | |
| optimizer.step() | |
| total_loss += loss.item() | |
| scheduler.step() | |
| if (epoch + 1) % 10 == 0 or epoch == epochs - 1: | |
| print(f"Epoch {epoch+1}/{epochs} | Avg Loss: {total_loss/len(dataloader):.4f} | LR: {scheduler.get_last_lr()[0]:.6f}") | |
| def save_model(self, config: Dict = None): | |
| """Save the trained model, tokenizer, and configuration.""" | |
| print("Saving model...") | |
| # Save model weights | |
| torch.save(self.model.state_dict(), self.model_path) | |
| # Save tokenizer | |
| with open(self.tokenizer_path, 'wb') as f: | |
| pickle.dump(self.tokenizer, f) | |
| # Save configuration | |
| if config is None: | |
| config = { | |
| 'dim': 128, | |
| 'max_seq_len': 64, | |
| 'action_dim': 1, | |
| 'vocab_size': self.tokenizer.vocab_size | |
| } | |
| with open(self.config_path, 'w') as f: | |
| json.dump(config, f, indent=2) | |
| # Save knowledge base if available | |
| if self.knowledge_base is not None: | |
| with open(self.knowledge_path, 'wb') as f: | |
| pickle.dump(self.knowledge_base, f) | |
| print(f"Model saved to {self.model_dir}") | |
| def load_model(self): | |
| """Load the trained model, tokenizer, and configuration.""" | |
| print("Loading model...") | |
| # Load configuration | |
| with open(self.config_path, 'r') as f: | |
| config = json.load(f) | |
| # Load tokenizer | |
| with open(self.tokenizer_path, 'rb') as f: | |
| self.tokenizer = pickle.load(f) | |
| # Initialize and load model | |
| self.model = ZRIA_Ultimate_PFAF( | |
| dim=config['dim'], | |
| vocab_size=config['vocab_size'], | |
| action_dim=config['action_dim'], | |
| max_seq_len=config['max_seq_len'] | |
| ) | |
| # Load model weights | |
| self.model.load_state_dict(torch.load(self.model_path, map_location=self.device)) | |
| self.model.to(self.device) | |
| self.model.eval() | |
| # Load knowledge base if available | |
| if os.path.exists(self.knowledge_path): | |
| with open(self.knowledge_path, 'rb') as f: | |
| self.knowledge_base = pickle.load(f) | |
| print("Model loaded successfully") | |
| def prompt(self, text: str, task_type: str = 'auto') -> Dict: | |
| """ | |
| Interactive prompting interface for the trained model. | |
| Args: | |
| text: Input text to process | |
| task_type: 'KNOW', 'DO', or 'auto' for automatic routing | |
| Returns: | |
| Dictionary with prediction results | |
| """ | |
| if self.model is None: | |
| raise ValueError("No model loaded. Please train or load a model first.") | |
| # Determine modality | |
| if task_type == 'KNOW': | |
| prefix = 'KNOW' | |
| modality_idx = 0 | |
| elif task_type == 'DO': | |
| prefix = 'DO' | |
| modality_idx = 1 | |
| else: # auto | |
| # Try both and let the model decide | |
| return self._auto_route(text) | |
| # Tokenize input | |
| tokens = self.tokenizer.encode(text, prefix) | |
| tokens += [self.tokenizer.pad_idx] * (64 - len(tokens)) | |
| ids = torch.tensor([tokens], dtype=torch.long).to(self.device) | |
| mod_idx = torch.tensor([modality_idx], dtype=torch.long).to(self.device) | |
| # Get prediction | |
| with torch.no_grad(): | |
| outputs = self.model(ids, mod_idx, mode='auto') | |
| # Format results | |
| if prefix == 'KNOW': | |
| pred_class = torch.argmax(outputs['text_logits'][0]).item() | |
| sentiment = ['Negative', 'Neutral', 'Positive'][pred_class] | |
| confidence = torch.softmax(outputs['text_logits'][0], dim=-1).max().item() | |
| return { | |
| 'task_type': 'KNOW', | |
| 'input': text, | |
| 'prediction': sentiment, | |
| 'confidence': confidence, | |
| 'route_probability': outputs['route_probs'][0][0].item(), | |
| 'raw_outputs': outputs | |
| } | |
| else: # DO | |
| action_value = outputs['action_output'][0].item() | |
| route_prob = outputs['route_probs'][0][1].item() | |
| return { | |
| 'task_type': 'DO', | |
| 'input': text, | |
| 'prediction': action_value, | |
| 'route_probability': route_prob, | |
| 'raw_outputs': outputs | |
| } | |
| def _auto_route(self, text: str) -> Dict: | |
| """Automatically determine task type and route accordingly.""" | |
| # Try both modalities and let the model decide | |
| know_tokens = self.tokenizer.encode(text, 'KNOW') | |
| know_tokens += [self.tokenizer.pad_idx] * (64 - len(know_tokens)) | |
| know_ids = torch.tensor([know_tokens], dtype=torch.long).to(self.device) | |
| know_mod_idx = torch.tensor([0], dtype=torch.long).to(self.device) | |
| do_tokens = self.tokenizer.encode(text, 'DO') | |
| do_tokens += [self.tokenizer.pad_idx] * (64 - len(do_tokens)) | |
| do_ids = torch.tensor([do_tokens], dtype=torch.long).to(self.device) | |
| do_mod_idx = torch.tensor([1], dtype=torch.long).to(self.device) | |
| with torch.no_grad(): | |
| know_outputs = self.model(know_ids, know_mod_idx, mode='auto') | |
| do_outputs = self.model(do_ids, do_mod_idx, mode='auto') | |
| # Compare routing probabilities | |
| know_route_prob = know_outputs['route_probs'][0][0].item() | |
| do_route_prob = do_outputs['route_probs'][0][1].item() | |
| if know_route_prob > do_route_prob: | |
| # Route to KNOW | |
| pred_class = torch.argmax(know_outputs['text_logits'][0]).item() | |
| sentiment = ['Negative', 'Neutral', 'Positive'][pred_class] | |
| confidence = torch.softmax(know_outputs['text_logits'][0], dim=-1).max().item() | |
| return { | |
| 'task_type': 'KNOW', | |
| 'input': text, | |
| 'prediction': sentiment, | |
| 'confidence': confidence, | |
| 'route_probability': know_route_prob, | |
| 'auto_routed': True, | |
| 'raw_outputs': know_outputs | |
| } | |
| else: | |
| # Route to DO | |
| action_value = do_outputs['action_output'][0].item() | |
| return { | |
| 'task_type': 'DO', | |
| 'input': text, | |
| 'prediction': action_value, | |
| 'route_probability': do_route_prob, | |
| 'auto_routed': True, | |
| 'raw_outputs': do_outputs | |
| } | |
| def batch_prompt(self, texts: List[str], task_type: str = 'auto') -> List[Dict]: | |
| """Process multiple texts in batch.""" | |
| results = [] | |
| for text in texts: | |
| result = self.prompt(text, task_type) | |
| results.append(result) | |
| return results | |
| def interactive_mode(self): | |
| """Start an interactive prompting session.""" | |
| print("\n=== ZRIA Interactive Mode ===") | |
| print("Type 'quit' to exit, 'help' for commands") | |
| print("Commands:") | |
| print(" KNOW <text> - Process as knowledge/sentiment") | |
| print(" DO <text> - Process as action/task") | |
| print(" AUTO <text> - Let model decide task type") | |
| print(" help - Show this help") | |
| print(" quit - Exit") | |
| print() | |
| while True: | |
| try: | |
| user_input = input("ZRIA> ").strip() | |
| if user_input.lower() == 'quit': | |
| break | |
| elif user_input.lower() == 'help': | |
| print("Commands:") | |
| print(" KNOW <text> - Process as knowledge/sentiment") | |
| print(" DO <text> - Process as action/task") | |
| print(" AUTO <text> - Let model decide task type") | |
| print(" help - Show this help") | |
| print(" quit - Exit") | |
| continue | |
| # Parse command | |
| if user_input.startswith('KNOW '): | |
| text = user_input[5:] | |
| result = self.prompt(text, 'KNOW') | |
| elif user_input.startswith('DO '): | |
| text = user_input[3:] | |
| result = self.prompt(text, 'DO') | |
| elif user_input.startswith('AUTO '): | |
| text = user_input[5:] | |
| result = self.prompt(text, 'auto') | |
| else: | |
| # Default to auto | |
| result = self.prompt(user_input, 'auto') | |
| # Display result | |
| self._display_result(result) | |
| except KeyboardInterrupt: | |
| print("\nExiting...") | |
| break | |
| except Exception as e: | |
| print(f"Error: {e}") | |
| def _display_result(self, result: Dict): | |
| """Display formatted result.""" | |
| print(f"\nInput: {result['input']}") | |
| print(f"Task Type: {result['task_type']}") | |
| if result['task_type'] == 'KNOW': | |
| print(f"Sentiment: {result['prediction']}") | |
| print(f"Confidence: {result['confidence']:.3f}") | |
| else: # DO | |
| print(f"Action Value: {result['prediction']:.2f}") | |
| print(f"Route Probability: {result['route_probability']:.3f}") | |
| if result.get('auto_routed'): | |
| print("(Auto-routed by model)") | |
| print() | |
| # Example usage and integration | |
| def create_and_train_model_from_text_file(text_file_path: str, model_dir: str = "zria_model"): | |
| """ | |
| Complete pipeline: process text file, train model, and save for persistent use. | |
| """ | |
| print("=== ZRIA Model Creation Pipeline ===") | |
| # Step 1: Process text file | |
| processor = HierarchicalTextProcessor() | |
| print(f"Processing text file: {text_file_path}") | |
| knowledge = processor.process_large_text_file(text_file_path) | |
| # Step 2: Create training data | |
| print("Creating training data...") | |
| training_data = processor.create_training_data(knowledge) | |
| print(f"Created {len(training_data)} training examples") | |
| # Step 3: Train and save model | |
| print("Training model...") | |
| persistent_model = PersistentZRIAModel(model_dir) | |
| persistent_model.knowledge_base = knowledge | |
| persistent_model.train_and_save(training_data) | |
| print("=== Pipeline Complete ===") | |
| return persistent_model | |
| def load_and_use_model(model_dir: str = "zria_model"): | |
| """Load a trained model and start interactive mode.""" | |
| persistent_model = PersistentZRIAModel(model_dir) | |
| if persistent_model.model is None: | |
| print("No trained model found. Please train a model first.") | |
| return None | |
| print("Model loaded successfully!") | |
| return persistent_model | |
| if __name__ == "__main__": | |
| # Example usage | |
| import sys | |
| if len(sys.argv) > 1: | |
| if sys.argv[1] == "train" and len(sys.argv) > 2: | |
| # Train from text file | |
| text_file = sys.argv[2] | |
| model_dir = sys.argv[3] if len(sys.argv) > 3 else "zria_model" | |
| model = create_and_train_model_from_text_file(text_file, model_dir) | |
| model.interactive_mode() | |
| elif sys.argv[1] == "load": | |
| # Load existing model | |
| model_dir = sys.argv[2] if len(sys.argv) > 2 else "zria_model" | |
| model = load_and_use_model(model_dir) | |
| if model: | |
| model.interactive_mode() | |
| else: | |
| print("Usage:") | |
| print(" python persistent_model.py train <text_file> [model_dir]") | |
| print(" python persistent_model.py load [model_dir]") | |
| else: | |
| print("ZRIA Persistent Model System") | |
| print("Usage:") | |
| print(" python persistent_model.py train <text_file> [model_dir]") | |
| print(" python persistent_model.py load [model_dir]") |