library.model_manager

  1# library/model_manager.py
  2"""Class for managing Keras model training, saving, and loading with metadata.
  3
  4This manager handles the complete lifecycle of Keras models including training,
  5saving, loading, and metadata management. It works with any Keras model architecture
  6including CNNs, U-Nets, ResNets, and custom architectures.
  7
  8Examples:
  9    U-Net for image segmentation (Task 5)::
 10    
 11        from library.model_manager import KerasModelManager
 12        from tensorflow.keras.callbacks import EarlyStopping
 13        
 14        # Initialize with Task 5 naming convention
 15        manager = KerasModelManager(
 16            model_name='smith_123456_unet_model_128px',
 17            student_name='John Smith',
 18            student_number='123456',
 19            patch_size=128,
 20            architecture='U-Net',
 21            task='root_segmentation'
 22        )
 23        
 24        # Set model with custom metrics
 25        manager.set_model(unet_model, custom_objects={'f1': f1})
 26        
 27        # Train with early stopping
 28        early_stop = EarlyStopping(monitor='val_loss', patience=3, 
 29                                   restore_best_weights=True)
 30        manager.train(X_train, y_train, X_val, y_val, 
 31                     epochs=50, callbacks=[early_stop])
 32        
 33        # Save everything
 34        manager.save('models')
 35        
 36        # Get best metrics
 37        metrics = manager.get_best_metrics()
 38        print(f"Best F1: {metrics['best_val_f1']:.4f}")
 39    
 40    CNN classifier for MNIST::
 41    
 42        manager = KerasModelManager(
 43            model_name='mnist_cnn',
 44            version='1.0',
 45            dataset='MNIST',
 46            input_shape=(28, 28, 1),
 47            num_classes=10,
 48            architecture='CNN'
 49        )
 50        
 51        manager.set_model(cnn_model)
 52        manager.train(X_train, y_train, X_val, y_val, epochs=20)
 53        manager.save('models')
 54    
 55    ResNet50 for plant classification::
 56    
 57        manager = KerasModelManager(
 58            model_name='resnet50_plants',
 59            version='2.1',
 60            architecture='ResNet50',
 61            dataset='PlantCLEF',
 62            pretrained='ImageNet',
 63            fine_tuned_layers=10,
 64            input_size=224
 65        )
 66        
 67        manager.set_model(resnet_model)
 68        manager.train(train_generator, steps_per_epoch=100,
 69                     validation_data=val_generator, validation_steps=20,
 70                     epochs=30)
 71        manager.save('models')
 72    
 73    LSTM for time series prediction::
 74    
 75        manager = KerasModelManager(
 76            model_name='stock_lstm',
 77            version='1.0',
 78            architecture='LSTM',
 79            sequence_length=60,
 80            features=5,
 81            prediction_horizon=1
 82        )
 83        
 84        manager.set_model(lstm_model)
 85        manager.train(X_train, y_train, X_val, y_val, epochs=50, batch_size=32)
 86        manager.save('models')
 87    
 88    Loading a saved model::
 89    
 90        # Initialize manager with same naming
 91        manager = KerasModelManager(
 92            model_name='smith_123456_unet_model_128px'
 93        )
 94        
 95        # Set custom objects before loading
 96        manager.set_model(None, custom_objects={'f1': f1})
 97        
 98        # Load model and history
 99        model, history = manager.load('models/smith_123456_unet_model_128px.h5')
100        
101        # Use loaded model
102        predictions = model.predict(X_test)
103
104Attributes:
105    model_name (str): Base name for the model files.
106    version (str): Optional version string or number.
107    metadata (dict): Additional metadata stored with the model.
108    model (keras.Model): The Keras model being managed.
109    history (keras.callbacks.History): Training history from model.fit().
110    custom_objects (dict): Custom objects needed for model loading.
111    base_name (str): Generated base filename.
112    model_path (str): Path to saved model file.
113    history_path (str): Path to saved history JSON.
114    summary_path (str): Path to saved summary text file.
115"""
116
117import json
118import numpy as np
119from pathlib import Path
120from datetime import datetime
121from tensorflow import keras
122
123
124class KerasModelManager:
125    """Manages Keras model lifecycle: training, saving, loading, and metadata."""
126    
127    def __init__(self, model_name, version=None, notes=None, **metadata):
128        """
129        Initialize the model manager.
130        
131        Args:
132            model_name: Base name for the model files. For Task 5, use format:
133                       'studentname_studentnumber_modeltype_patchsizepx'
134            version: Optional version string or number (e.g., '1.0', 'v2', 2).
135            notes: Optional initial note/hypothesis for this model.
136            **metadata: Additional metadata to store with the model. Common examples:
137                       - student_name (str): Student name for academic projects
138                       - student_number (str): Student number for academic projects
139                       - architecture (str): Model architecture (e.g., 'U-Net', 'ResNet50')
140                       - patch_size (int): Patch size for segmentation models
141                       - input_shape (tuple): Input shape for the model
142                       - num_classes (int): Number of output classes
143                       - dataset (str): Dataset name
144                       - pretrained (str): Pretrained weights source
145                       - task (str): Task description
146        
147        Examples:
148            >>> # U-Net for segmentation with notes
149            >>> manager = KerasModelManager(
150            ...     'smith_123456_unet_model_128px',
151            ...     notes="Hypothesis: 128px patches will achieve F1 > 0.90",
152            ...     patch_size=128,
153            ...     architecture='U-Net'
154            ... )
155            
156            >>> # Versioned CNN classifier
157            >>> manager = KerasModelManager(
158            ...     'mnist_cnn',
159            ...     version='1.0',
160            ...     dataset='MNIST',
161            ...     input_shape=(28, 28, 1)
162            ... )
163        """
164        self.model_name = model_name
165        self.version = version
166        self.metadata = metadata
167        self.model = None
168        self.history = None
169        self.custom_objects = {}
170        self._callbacks = None
171        self._notes = []
172        
173        # Add initial note if provided
174        if notes:
175            self._add_note(notes)
176        
177        # Generate filenames
178        version_str = f"_v{version}" if version else ""
179        self.base_name = f"{model_name}{version_str}"
180        self.model_path = f"{self.base_name}.h5"
181        self.history_path = f"{self.base_name}_history.json"
182        self.summary_path = f"{self.base_name}_summary.txt"
183    
184    def set_model(self, model, custom_objects=None):
185        """
186        Set the model to be managed.
187        
188        Args:
189            model: Compiled Keras model, or None if only loading.
190            custom_objects: Dict of custom objects needed for model loading
191                           (e.g., {'f1': f1_function, 'dice_loss': dice_loss_fn}).
192        
193        Examples:
194            >>> # With custom metric
195            >>> manager.set_model(unet_model, custom_objects={'f1': f1})
196            
197            >>> # Standard model, no custom objects
198            >>> manager.set_model(resnet_model)
199            
200            >>> # Preparing to load (no model yet)
201            >>> manager.set_model(None, custom_objects={'f1': f1})
202        """
203        self.model = model
204        if custom_objects:
205            self.custom_objects = custom_objects
206    
207    def _add_note(self, note):
208        """Internal method to add a timestamped note."""
209        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
210        self._notes.append({
211            'timestamp': timestamp,
212            'note': note
213        })
214    
215    @property
216    def notes(self):
217        """Get all notes as a formatted string."""
218        if not self._notes:
219            return ""
220        return "\n".join([f"[{n['timestamp']}] {n['note']}" for n in self._notes])
221    
222    @notes.setter
223    def notes(self, note):
224        """Append a new note with automatic timestamp."""
225        self._add_note(note)
226    
227    def set_notes(self, note, replace=False):
228        """
229        Set notes with option to replace all existing notes.
230        
231        Args:
232            note: The note text to add or set.
233            replace: If True, replaces all existing notes. If False, appends.
234        
235        Examples:
236            >>> # Append (default)
237            >>> manager.set_notes("Added dropout layers")
238            
239            >>> # Replace all notes
240            >>> manager.set_notes("Starting fresh experiment", replace=True)
241        """
242        if replace:
243            self._notes = []
244        self._add_note(note)
245    
246    def clear_notes(self):
247        """Clear all notes."""
248        self._notes = []
249    
250    def get_notes_list(self):
251        """
252        Get notes as a list of dictionaries.
253        
254        Returns:
255            List of dicts with 'timestamp' and 'note' keys.
256        """
257        return self._notes.copy()
258    
259    def train(self, X_train, y_train=None, X_val=None, y_val=None, epochs=50, 
260            batch_size=16, callbacks=None, verbose=1, **fit_kwargs):
261        """
262        Train the model and store history.
263        
264        Args:
265            X_train: Training data (numpy array, generator, or dataset).
266            y_train: Training labels (numpy array, or None if using generator).
267            X_val: Optional validation data (or None if using validation_data kwarg).
268            y_val: Optional validation labels (or None if using validation_data kwarg).
269            epochs: Maximum number of epochs.
270            batch_size: Batch size for training (ignored if using generator).
271            callbacks: List of Keras callbacks (e.g., EarlyStopping, ModelCheckpoint).
272            verbose: Verbosity level (0=silent, 1=progress bar, 2=one line per epoch).
273            **fit_kwargs: Additional arguments passed to model.fit()
274                        (e.g., steps_per_epoch, validation_steps, validation_data).
275        
276        Returns:
277            Training history object.
278        """
279        if self.model is None:
280            raise ValueError("Model not set. Call set_model() first.")
281        
282        # Store callbacks for later serialization
283        self._callbacks = callbacks
284        
285        # Handle validation_data - check if it's in fit_kwargs first
286        validation_data = fit_kwargs.pop('validation_data', None)
287        
288        # If not in fit_kwargs and we have X_val/y_val, construct it
289        if validation_data is None and X_val is not None and y_val is not None:
290            validation_data = (X_val, y_val)
291        
292        self.history = self.model.fit(
293            X_train, y_train,
294            validation_data=validation_data,
295            batch_size=batch_size,
296            epochs=epochs,
297            callbacks=callbacks,
298            verbose=verbose,
299            **fit_kwargs
300        )
301        
302        return self.history
303    
304    def save(self, output_dir='.'):
305        """
306        Save model, history, and summary to disk.
307        
308        Saves three files:
309        1. .h5 file - Complete model (architecture, weights, optimizer state)
310        2. _history.json - Training metrics for all epochs
311        3. _summary.txt - Human-readable summary
312        
313        Args:
314            output_dir: Directory to save files. Created if it doesn't exist.
315                       Default is current directory.
316        
317        Examples:
318            >>> # Save to current directory
319            >>> manager.save()
320            
321            >>> # Save to specific directory
322            >>> manager.save('trained_models')
323            
324            >>> # Save to nested path
325            >>> manager.save('models/unet/version_1')
326        """
327        if self.model is None:
328            raise ValueError("No model to save. Train or set a model first.")
329        
330        output_dir = Path(output_dir)
331        output_dir.mkdir(parents=True, exist_ok=True)
332        
333        # Save model
334        model_file = output_dir / self.model_path
335        self.model.save(str(model_file))
336        print(f"Model saved: {model_file}")
337        
338        # Save history if available
339        if self.history is not None:
340            self._save_history(output_dir)
341            self._save_summary(output_dir)
342    
343    def _serialize_custom_objects(self):
344        """
345        Serialize information about custom objects for documentation.
346        
347        Returns:
348            List of dictionaries with custom object metadata.
349        """
350        import inspect
351        import hashlib
352        
353        if not self.custom_objects:
354            return []
355        
356        serialized = []
357        
358        for name, obj in self.custom_objects.items():
359            obj_info = {
360                'name': name,
361                'type': type(obj).__name__
362            }
363            
364            # Try to get useful information about the object
365            try:
366                # Get module
367                if hasattr(obj, '__module__'):
368                    obj_info['module'] = obj.__module__
369                
370                # Get docstring
371                if hasattr(obj, '__doc__') and obj.__doc__:
372                    obj_info['docstring'] = obj.__doc__.strip()
373                
374                # For functions, get signature
375                if callable(obj):
376                    try:
377                        sig = inspect.signature(obj)
378                        obj_info['signature'] = str(sig)
379                    except (ValueError, TypeError):
380                        pass
381                    
382                    # Get source code hash (for version tracking)
383                    try:
384                        source = inspect.getsource(obj)
385                        source_hash = hashlib.md5(source.encode()).hexdigest()
386                        obj_info['source_hash'] = source_hash
387                    except (OSError, TypeError):
388                        pass
389                
390                serialized.append(obj_info)
391                
392            except Exception as e:
393                # If we can't serialize, at least save the name and type
394                obj_info['error'] = str(e)
395                serialized.append(obj_info)
396        
397        return serialized
398    
399    def _serialize_callbacks(self, callbacks):
400        """
401        Serialize callback configurations.
402        
403        Args:
404            callbacks: List of Keras callbacks or None.
405        
406        Returns:
407            List of serialized callback dictionaries.
408        """
409        import warnings
410        
411        if callbacks is None:
412            return []
413        
414        serialized = []
415        
416        for callback in callbacks:
417            callback_info = {
418                'class': callback.__class__.__name__,
419                'module': callback.__class__.__module__
420            }
421            
422            # Try to extract configuration
423            try:
424                # Get callback config if available
425                if hasattr(callback, 'get_config'):
426                    callback_info['config'] = callback.get_config()
427                else:
428                    # Manually extract common attributes
429                    config = {}
430                    
431                    # EarlyStopping attributes
432                    if hasattr(callback, 'monitor'):
433                        config['monitor'] = callback.monitor
434                    if hasattr(callback, 'patience'):
435                        config['patience'] = callback.patience
436                    if hasattr(callback, 'restore_best_weights'):
437                        config['restore_best_weights'] = callback.restore_best_weights
438                    if hasattr(callback, 'mode'):
439                        config['mode'] = callback.mode
440                    if hasattr(callback, 'min_delta'):
441                        config['min_delta'] = callback.min_delta
442                    
443                    # ReduceLROnPlateau attributes
444                    if hasattr(callback, 'factor'):
445                        config['factor'] = callback.factor
446                    if hasattr(callback, 'cooldown'):
447                        config['cooldown'] = callback.cooldown
448                    if hasattr(callback, 'min_lr'):
449                        config['min_lr'] = callback.min_lr
450                    
451                    # ModelCheckpoint attributes
452                    if hasattr(callback, 'filepath'):
453                        config['filepath'] = callback.filepath
454                    if hasattr(callback, 'save_best_only'):
455                        config['save_best_only'] = callback.save_best_only
456                    if hasattr(callback, 'save_weights_only'):
457                        config['save_weights_only'] = callback.save_weights_only
458                    
459                    # LearningRateScheduler
460                    if hasattr(callback, 'schedule'):
461                        warnings.warn(
462                            f"Callback {callback.__class__.__name__} has a 'schedule' "
463                            f"function that cannot be serialized. Saving class name only.",
464                            UserWarning
465                        )
466                        config['schedule'] = '<function>'
467                    
468                    if config:
469                        callback_info['config'] = config
470                    else:
471                        warnings.warn(
472                            f"Could not extract configuration from callback "
473                            f"{callback.__class__.__name__}. Saving class name only.",
474                            UserWarning
475                        )
476                
477                # Check if config is JSON serializable
478                json.dumps(callback_info)
479                serialized.append(callback_info)
480                
481            except (TypeError, ValueError) as e:
482                warnings.warn(
483                    f"Callback {callback.__class__.__name__} could not be fully "
484                    f"serialized: {str(e)}. Saving class name only.",
485                    UserWarning
486                )
487                serialized.append({
488                    'class': callback.__class__.__name__,
489                    'module': callback.__class__.__module__,
490                    'error': str(e)
491                })
492        
493        return serialized
494    
495    def _save_history(self, output_dir):
496        """Save training history to JSON."""
497        history_dict = {}
498        
499        for key, values in self.history.history.items():
500            # Convert to list and ensure JSON serializable
501            if isinstance(values, np.ndarray):
502                history_dict[key] = values.tolist()
503            elif isinstance(values, list):
504                history_dict[key] = [float(x) for x in values]
505            else:
506                history_dict[key] = values
507        
508        # Serialize callbacks
509        callbacks_info = self._serialize_callbacks(self._callbacks)
510        
511        # Serialize custom objects
512        custom_objects_info = self._serialize_custom_objects()
513        
514        # Add metadata
515        history_dict['metadata'] = {
516            'model_name': self.model_name,
517            'version': self.version,
518            'epochs_trained': len(self.history.history['loss']),
519            'saved_at': datetime.now().isoformat(),
520            'callbacks': callbacks_info,
521            'custom_objects': custom_objects_info,
522            'notes': self._notes,
523            **self.metadata
524        }
525        
526        history_file = output_dir / self.history_path
527        with open(history_file, 'w') as f:
528            json.dump(history_dict, f, indent=4)
529        print(f"History saved: {history_file}")
530    
531    def _save_summary(self, output_dir):
532        """Save human-readable summary."""
533        summary_file = output_dir / self.summary_path
534        
535        with open(summary_file, 'w') as f:
536            f.write(f"{self.model_name} Model Summary\n")
537            f.write("=" * 60 + "\n\n")
538            
539            # Write metadata
540            if self.version:
541                f.write(f"Version: {self.version}\n")
542            for key, value in self.metadata.items():
543                f.write(f"{key}: {value}\n")
544            
545            f.write(f"Model file: {self.model_path}\n")
546            f.write(f"Saved: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
547            
548            # Write notes
549            if self._notes:
550                f.write("Notes / Hypothesis:\n")
551                f.write("-" * 60 + "\n")
552                for note_entry in self._notes:
553                    f.write(f"[{note_entry['timestamp']}] {note_entry['note']}\n")
554                f.write("\n")
555            
556            # Write custom objects information
557            if self.custom_objects:
558                f.write("Custom Objects:\n")
559                f.write("-" * 60 + "\n")
560                custom_objs_info = self._serialize_custom_objects()
561                for obj_info in custom_objs_info:
562                    f.write(f"  {obj_info['name']} ({obj_info['type']}):\n")
563                    if 'module' in obj_info:
564                        f.write(f"    module: {obj_info['module']}\n")
565                    if 'signature' in obj_info:
566                        f.write(f"    signature: {obj_info['signature']}\n")
567                    if 'source_hash' in obj_info:
568                        f.write(f"    source_hash: {obj_info['source_hash']}\n")
569                    if 'docstring' in obj_info:
570                        # First line of docstring only
571                        first_line = obj_info['docstring'].split('\n')[0]
572                        f.write(f"    docstring: {first_line}\n")
573                    f.write("\n")
574            
575            # Write callback information
576            if self._callbacks:
577                f.write("Callbacks Used:\n")
578                f.write("-" * 60 + "\n")
579                callbacks_info = self._serialize_callbacks(self._callbacks)
580                for cb_info in callbacks_info:
581                    f.write(f"  {cb_info['class']}:\n")
582                    if 'config' in cb_info:
583                        for key, value in cb_info['config'].items():
584                            f.write(f"    {key}: {value}\n")
585                    elif 'error' in cb_info:
586                        f.write(f"    (serialization error: {cb_info['error']})\n")
587                    f.write("\n")
588            
589            if self.history:
590                history = self.history.history
591                f.write("Training Results\n")
592                f.write("-" * 60 + "\n")
593                f.write(f"Epochs trained: {len(history['loss'])}\n\n")
594                
595                # Final metrics
596                f.write("Final Metrics:\n")
597                for key in sorted(history.keys()):
598                    if not key.startswith('val_'):
599                        val_key = f'val_{key}'
600                        train_val = history[key][-1]
601                        f.write(f"  {key}: {train_val:.4f}")
602                        if val_key in history:
603                            val_val = history[val_key][-1]
604                            f.write(f" | {val_key}: {val_val:.4f}")
605                        f.write("\n")
606                
607                # Best metrics (find all val_ metrics and report best)
608                f.write("\nBest Validation Metrics:\n")
609                for key in sorted(history.keys()):
610                    if key.startswith('val_'):
611                        # Determine if higher or lower is better
612                        if 'loss' in key or 'error' in key:
613                            best_idx = np.argmin(history[key])
614                            best_val = history[key][best_idx]
615                            f.write(f"  {key}: {best_val:.4f} (epoch {best_idx + 1}, min)\n")
616                        else:
617                            best_idx = np.argmax(history[key])
618                            best_val = history[key][best_idx]
619                            f.write(f"  {key}: {best_val:.4f} (epoch {best_idx + 1}, max)\n")
620        
621        print(f"Summary saved: {summary_file}")
622    
623    def load(self, model_path=None, load_history=True):
624        """
625        Load a saved model and optionally its history.
626        
627        Args:
628            model_path: Path to model file. If None, uses default naming convention.
629            load_history: Whether to load training history JSON. Default is True.
630        
631        Returns:
632            Tuple of (loaded_model, history_dict or None).
633        
634        Examples:
635            >>> # Load with default path
636            >>> manager = KerasModelManager('smith_123456_unet_model_128px')
637            >>> manager.set_model(None, custom_objects={'f1': f1})
638            >>> model, history = manager.load()
639            
640            >>> # Load from specific path
641            >>> model, history = manager.load('models/backup/model.h5')
642            
643            >>> # Load model only, skip history
644            >>> model, _ = manager.load(load_history=False)
645        """
646        if model_path is None:
647            model_path = self.model_path
648        
649        model_path = Path(model_path)
650        
651        if not model_path.exists():
652            raise FileNotFoundError(f"Model file not found: {model_path}")
653        
654        # Load model with custom objects
655        self.model = keras.models.load_model(
656            str(model_path),
657            custom_objects=self.custom_objects
658        )
659        print(f"Model loaded: {model_path}")
660        
661        loaded_history = None
662        
663        # Load history if available
664        if load_history:
665            history_path = model_path.parent / self.history_path
666            if history_path.exists():
667                with open(history_path, 'r') as f:
668                    loaded_history = json.load(f)
669                    print(f"History loaded: {history_path}")
670                    
671                    # Print summary
672                    if 'metadata' in loaded_history:
673                        meta = loaded_history['metadata']
674                        print(f"Trained for {meta.get('epochs_trained', 'unknown')} epochs")
675                        
676                        # Print notes if available
677                        if 'notes' in meta and meta['notes']:
678                            print("\nNotes:")
679                            for note_entry in meta['notes']:
680                                print(f"  [{note_entry['timestamp']}] {note_entry['note']}")
681                        
682                        # Print custom objects if available
683                        if 'custom_objects' in meta and meta['custom_objects']:
684                            print("\nCustom objects used:")
685                            for obj_info in meta['custom_objects']:
686                                print(f"  - {obj_info['name']} ({obj_info['type']})")
687                        
688                        # Print other metadata
689                        for key, val in meta.items():
690                            if key not in ['model_name', 'version', 'epochs_trained', 'saved_at', 'callbacks', 'custom_objects', 'notes']:
691                                print(f"{key}: {val}")
692                    
693                    # Print best validation metrics
694                    for key in loaded_history.keys():
695                        if key.startswith('val_') and key != 'val_loss':
696                            best_val = max(loaded_history[key])
697                            print(f"Best {key}: {best_val:.4f}")
698        
699        return self.model, loaded_history
700    
701    def get_best_metrics(self, metric_preferences=None):
702        """
703        Get best metrics from training history.
704        
705        Args:
706            metric_preferences: Dict mapping metric names to 'min' or 'max'.
707                               If None, uses 'min' for loss/error metrics,
708                               'max' for all others.
709        
710        Returns:
711            Dictionary with best metrics, their epochs, and final values.
712            Keys include 'best_{metric}', 'best_{metric}_epoch', 'final_{metric}'.
713        
714        Examples:
715            >>> metrics = manager.get_best_metrics()
716            >>> print(f"Best F1: {metrics['best_val_f1']:.4f}")
717            >>> print(f"Achieved at epoch: {metrics['best_val_f1_epoch']}")
718            
719            >>> # Custom metric preferences
720            >>> metrics = manager.get_best_metrics(
721            ...     metric_preferences={'val_custom': 'min'}
722            ... )
723        """
724        if self.history is None:
725            raise ValueError("No training history available.")
726        
727        history = self.history.history
728        metrics = {}
729        
730        # Default preferences
731        if metric_preferences is None:
732            metric_preferences = {}
733        
734        for key in history.keys():
735            if key.startswith('val_'):
736                # Determine optimization direction
737                if key in metric_preferences:
738                    direction = metric_preferences[key]
739                elif 'loss' in key or 'error' in key:
740                    direction = 'min'
741                else:
742                    direction = 'max'
743                
744                # Find best value
745                if direction == 'min':
746                    best_idx = np.argmin(history[key])
747                else:
748                    best_idx = np.argmax(history[key])
749                
750                metrics[f'best_{key}'] = history[key][best_idx]
751                metrics[f'best_{key}_epoch'] = best_idx + 1
752                metrics[f'final_{key}'] = history[key][-1]
753        
754        return metrics
755    
756    def plot_history(self, history_dict=None, metrics=None, figsize=(14, 5)):
757        """
758        Plot training history.
759        
760        Args:
761            history_dict: History dict from load(). If None, uses self.history.
762            metrics: List of metrics to plot. If None, plots all metrics.
763            figsize: Figure size tuple.
764        
765        Examples:
766            >>> # After training
767            >>> manager.plot_history()
768            
769            >>> # After loading
770            >>> model, history = manager.load()
771            >>> manager.plot_history(history)
772            
773            >>> # Plot specific metrics
774            >>> manager.plot_history(metrics=['loss', 'f1'])
775        """
776        import matplotlib.pyplot as plt
777        
778        if history_dict is None:
779            if self.history is None:
780                raise ValueError("No history available. Train or load a model first.")
781            history_dict = self.history.history
782        
783        # Filter out metadata
784        history_dict = {k: v for k, v in history_dict.items() if k != 'metadata'}
785        
786        # Determine metrics to plot
787        if metrics is None:
788            # Plot all non-validation metrics
789            metrics = [k for k in history_dict.keys() if not k.startswith('val_')]
790        
791        n_metrics = len(metrics)
792        fig, axes = plt.subplots(1, n_metrics, figsize=figsize)
793        
794        # Handle single metric case
795        if n_metrics == 1:
796            axes = [axes]
797        
798        for ax, metric in zip(axes, metrics):
799            val_metric = f'val_{metric}'
800            
801            ax.plot(history_dict[metric], label=f'Training {metric}')
802            if val_metric in history_dict:
803                ax.plot(history_dict[val_metric], label=f'Validation {metric}')
804            
805            ax.set_xlabel('Epoch')
806            ax.set_ylabel(metric.replace('_', ' ').title())
807            ax.set_title(f'{metric.replace("_", " ").title()} over Epochs')
808            ax.legend()
809            ax.grid(True, alpha=0.3)
810        
811        plt.tight_layout()
812        plt.show()