File size: 10,475 Bytes
59f824e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ee4a20e
59f824e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
"""Create and save a pre-trained deception detection model using synthetic data.



This script generates a realistic synthetic dataset, trains a deception classifier,

and saves it as a pre-trained model for demonstration purposes.

"""

import json
import os
import sys
from pathlib import Path

import pandas as pd

# Add src to path
sys.path.insert(0, str(Path(__file__).parent))

from src.utils.config import AppConfig, get_default_config
from src.utils.synthetic_data import SyntheticDataGenerator
from src.model.classifier import DeceptionClassifier
from src.model.calibration import SubjectCalibrator
from src.explainability.explainer import DeceptionExplainer


def create_pretrained_model(output_dir: str = "./models", 

                           n_samples: int = 1000,

                           test_size: float = 0.2,

                           random_state: int = 42):
    """Create and save a pre-trained deception detection model.

    

    Args:

        output_dir: Directory to save model and related files

        n_samples: Total number of synthetic samples to generate

        test_size: Proportion of data for testing

        random_state: Random seed for reproducibility

    """
    print("=" * 60)
    print("Creating Pre-trained Deception Detection Model")
    print("=" * 60)
    
    # Create output directory
    os.makedirs(output_dir, exist_ok=True)
    
    # Initialize components
    config = AppConfig()
    generator = SyntheticDataGenerator(config, seed=random_state)
    
    print(f"\n1. Generating synthetic dataset ({n_samples} samples)...")
    # Generate balanced dataset
    n_truthful = n_samples // 2
    n_deceptive = n_samples // 2
    
    features, labels, subject_ids = generator.generate_dataset(
        n_truthful=n_truthful,
        n_deceptive=n_deceptive
    )
    
    print(f"   Generated {len(features)} samples")
    print(f"   Truthful: {sum(labels == 0)}, Deceptive: {sum(labels == 1)}")
    print(f"   Features: {len(features.columns)}")
    print(f"   Unique subjects: {len(set(subject_ids))}")
    
    # Save dataset
    dataset_path = os.path.join(output_dir, "pretraining_dataset.csv")
    dataset_with_labels = features.copy()
    dataset_with_labels['label'] = labels
    dataset_with_labels['subject_id'] = subject_ids
    dataset_with_labels.to_csv(dataset_path, index=False)
    print(f"   Dataset saved to: {dataset_path}")
    
    print("\n2. Training deception classifier...")
    # Initialize and train classifier
    classifier = DeceptionClassifier(config.model)
    
    # Split data
    from sklearn.model_selection import train_test_split
    X_train, X_test, y_train, y_test = train_test_split(
        features, labels, 
        test_size=test_size, 
        random_state=random_state,
        stratify=labels
    )
    
    print(f"   Training samples: {len(X_train)}")
    print(f"   Test samples: {len(X_test)}")
    
    # Train
    train_result = classifier.train(X_train, y_train, list(features.columns))
    
    # Evaluate
    from sklearn.metrics import accuracy_score, f1_score, roc_auc_score
    y_pred = classifier.predict(X_test)
    y_prob = classifier.predict_proba(X_test)[:, 1]
    
    test_accuracy = accuracy_score(y_test, y_pred)
    test_f1 = f1_score(y_test, y_pred)
    test_auc = roc_auc_score(y_test, y_prob)
    
    print(f"   Training accuracy: {train_result.get('train_accuracy', 0):.3f}")
    print(f"   Test accuracy: {test_accuracy:.3f}")
    print(f"   Test F1-score: {test_f1:.3f}")
    print(f"   Test AUC-ROC: {test_auc:.3f}")
    
    print("\n3. Training subject calibrator...")
    # Train calibrator on all data
    calibrator = SubjectCalibrator(classifier, config)
    
    # Create subject profiles (in real scenario, would use baseline videos)
    subject_profiles = {}
    for subject_id in set(subject_ids):
        subject_mask = [sid == subject_id for sid in subject_ids]
        if sum(subject_mask) >= 5:  # Need enough samples per subject
            subject_features = features[subject_mask]
            calibrator.add_subject_profile(subject_id, subject_features)
            subject_profiles[subject_id] = {
                'n_samples': sum(subject_mask),
                'baseline_updated': True
            }
    
    print(f"   Created profiles for {len(subject_profiles)} subjects")
    
    print("\n4. Training explainability model...")
    # Train explainer on subset for efficiency
    explainer = DeceptionExplainer(classifier)
    
    # Use smaller subset for SHAP training (computationally expensive)
    if len(X_train) > 200:
        X_explain = X_train.iloc[:200]
    else:
        X_explain = X_train
    
    print(f"   Initializing SHAP explainer...")
    # Explainer initializes lazily
    explainer._init_shap_explainer()
    
    print("\n5. Saving model and components...")
    # Save classifier
    model_path = os.path.join(output_dir, "deception_model.pkl")
    classifier.save(model_path)
    print(f"   Classifier saved to: {model_path}")
    
    # Save calibrator
    calibrator_path = os.path.join(output_dir, "subject_calibrator.json")
    calibrator.save_profiles(calibrator_path)
    print(f"   Calibrator saved to: {calibrator_path}")
    
    # Explainer does not need saving
    explainer_path = "N/A"
    
    # Save feature names
    feature_names_path = os.path.join(output_dir, "feature_names.json")
    with open(feature_names_path, 'w') as f:
        json.dump(list(features.columns), f, indent=2)
    print(f"   Feature names saved to: {feature_names_path}")
    
    # Save model metadata
    metadata = {
        'model_name': 'DeceptionDetectionModel',
        'version': '1.0.0',
        'description': 'Pre-trained deception detection model using synthetic data',
        'training_date': pd.Timestamp.now().isoformat(),
        'training_samples': len(X_train),
        'test_samples': len(X_test),
        'n_features': len(features.columns),
        'performance_metrics': {
            'training_accuracy': float(train_result.get('train_accuracy', 0)),
            'training_f1': 0.0,  # Not returned by train()
            'test_accuracy': float(test_accuracy),
            'test_f1': float(test_f1),
            'test_auc_roc': float(test_auc)
        },
        'feature_groups': {
            'facial': generator.FACIAL_FEATURES,
            'audio': generator.AUDIO_FEATURES,
            'cross_modal': generator.CROSS_MODAL_FEATURES
        },
        'model_parameters': {
            'model_type': 'GradientBoostingClassifier',
            'random_state': random_state,
            'n_estimators': config.model.n_estimators,
            'learning_rate': config.model.learning_rate,
            'max_depth': config.model.max_depth
        }
    }
    
    metadata_path = os.path.join(output_dir, "model_metadata.json")
    with open(metadata_path, 'w') as f:
        json.dump(metadata, f, indent=2)
    print(f"   Metadata saved to: {metadata_path}")
    
    # Create a sample inference script
    inference_script = '''"""Sample inference with pre-trained deception model."""



import json

import pandas as pd

from src.model.classifier import DeceptionClassifier

from src.model.calibration import SubjectCalibrator

from src.explainability.explainer import DeceptionExplainer



# Load model and components

model = DeceptionClassifier()

model.load("./models/deception_model.pkl")

from src.utils.config import get_default_config

calibrator = SubjectCalibrator(model, get_default_config())

calibrator.load_profiles("./models/subject_calibrator.json")

explainer = DeceptionExplainer(model)



# Load feature names

with open("./models/feature_names.json", "r") as f:

    feature_names = json.load(f)



print(f"Model loaded with {len(feature_names)} features")



# Example: Create sample features (replace with real data)

import numpy as np

sample_features = pd.DataFrame({

    feature: np.random.random() for feature in feature_names

}, index=[0])



# Predict

prediction = model.predict(sample_features)

probability = model.predict_proba(sample_features)[0, 1]



print(f"Prediction: {'Deceptive' if prediction[0] == 1 else 'Truthful'}")

print(f"Probability of deception: {probability:.3f}")



# If subject ID is known, calibrate

subject_id = "S001"

if subject_id in calibrator.subject_profiles:

    calibrated_prob = calibrator.calibrate_prediction(probability, subject_id)

    print(f"Calibrated probability: {calibrated_prob:.3f}")

'''
    
    inference_path = os.path.join(output_dir, "sample_inference.py")
    with open(inference_path, 'w') as f:
        f.write(inference_script)
    print(f"   Sample inference script: {inference_path}")
    
    print("\n" + "=" * 60)
    print("✅ Pre-trained model creation complete!")
    print("=" * 60)
    print(f"\nModel files saved to: {output_dir}")
    print("\nTo use the model:")
    print(f"  1. Load classifier: DeceptionClassifier.load('{model_path}')")
    print(f"  2. Load calibrator: SubjectCalibrator.load('{calibrator_path}')")
    print(f"  3. Load explainer: DeceptionExplainer.load('{explainer_path}')")
    print(f"\nOr use the pipeline:")
    print(f"  from src.pipeline import DeceptionPipeline")
    print(f"  pipeline = DeceptionPipeline()")
    print(f"  pipeline.load_model('{model_path}')")
    
    return {
        'model_path': model_path,
        'calibrator_path': calibrator_path,
        'explainer_path': explainer_path,
        'metadata_path': metadata_path,
        'dataset_path': dataset_path
    }


if __name__ == "__main__":
    import argparse
    
    parser = argparse.ArgumentParser(description="Create pre-trained deception detection model")
    parser.add_argument("--output-dir", default="./models", help="Output directory for model files")
    parser.add_argument("--n-samples", type=int, default=1000, help="Number of synthetic samples")
    parser.add_argument("--test-size", type=float, default=0.2, help="Test set proportion")
    parser.add_argument("--seed", type=int, default=42, help="Random seed")
    
    args = parser.parse_args()
    
    create_pretrained_model(
        output_dir=args.output_dir,
        n_samples=args.n_samples,
        test_size=args.test_size,
        random_state=args.seed
    )