Skip to content

Scripts

experiment_sweep

Demo script to test wandb sweep configuration and logging. This is a dry run to verify the setup works correctly.

main()

Main function that handles both sweep and standalone runs.

Source code in src/scripts/experiment_sweep.py 
 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
def main():
    """Main function that handles both sweep and standalone runs."""

    #### SETUP #####

    # Initialize wandb - this handles both sweep and standalone runs
    wandb_run = wandb.init()

    # Get configuration from wandb (sweep params override defaults)
    sweep_config = wandb.config
    run_id = wandb_run.id

    print("=" * 50)
    print("DEMO EXPERIMENT STARTING")
    print("=" * 50)
    print(f"Run ID: {run_id}")
    print(f"Run Name: {wandb_run.name}")
    print(f"Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print()

    # Print all configuration parameters
    print("Configuration:")
    for key, value in sweep_config.items():
        print(f"  {key}: {value}")
    print()

    device = torch.device(default_device_str())

    ############# FINE TUNING #############

    fine_tuning_config = FineTuningConfig(
        batch_size=sweep_config["batch_size"],
        learning_rate=sweep_config["learning_rate"],
        epochs=sweep_config["epochs"],
        margin=sweep_config["margin"],
        loss_type=sweep_config["loss_type"],
        optimizer_type=sweep_config["optimizer_type"],
        model_save_path=f"models/run_{run_id}_model.pth",
        augmentation=sweep_config["augmentation"],
        only_head=sweep_config["only_head"],
        dataset=sweep_config["dataset"],
    )

    trainer = FineTuningTrainer(config=fine_tuning_config)
    trainer.run()

    ####### BENCHMARK ########

    benchmark_config = FacePairsBenchmarkConfig()

    fine_tuned_model = get_facenet_pytorch_inception_resnet_v1(
        from_file=fine_tuning_config.model_save_path
    ).eval()

    print("Running LFW benchmark...")
    benchmark_lfw = FacePairsBenchmark.lfw(
        model=fine_tuned_model, config=benchmark_config
    )
    result_lfw = benchmark_lfw.evaluate()
    print(f"LFW Accuracy: {result_lfw}")

    print("Running ROF Sunglasses benchmark...")
    benchmark_rof_sunglasses = FacePairsBenchmark.rof_sunglasses(
        model=fine_tuned_model, config=benchmark_config
    )
    result_rof_sunglasses = benchmark_rof_sunglasses.evaluate()
    print(f"ROF Sunglasses Accuracy: {result_rof_sunglasses}")

    print("Running ROF Masked benchmark...")
    benchmark_rof_masked = FacePairsBenchmark.rof_masked(
        model=fine_tuned_model, config=benchmark_config
    )
    result_rof_masked = benchmark_rof_masked.evaluate()
    print(f"ROF Masked Accuracy: {result_rof_masked}")

    wandb.log(
        {
            "benchmark/lfw_accuracy": result_lfw.mean_accuracy,
            "benchmark/rof_sunglasses_accuracy": result_rof_sunglasses.mean_accuracy,
            "benchmark/rof_masked_accuracy": result_rof_masked.mean_accuracy,
        }
    )

    ########### Evaluation ############

    dataset_dir = sweep_config["evaluation_dataset_path"]

    detector = get_facenet_pytorch_mtcnn_detector(device=device)
    face_recognition = FaceRecognitionSystemFacenetPytorchAdapter(
        fine_tuned_model, detector, device
    )
    dataset = RococoDataset.from_directory(dataset_dir)

    validation = RococoValidation(
        face_recognition_system=face_recognition, dataset=dataset
    )

    results = validation.validate()
    log_results_to_wandb(results)

    #################

    wandb.finish()

process_video

Ekstrakcja danych z nagrania ekranu aplikacji

Skrypt do utworzenia zbioru danych (robocza nazwa Rococo2) z nagrania ekranu aplikacji obsługującej system autoryzacji osób na koncercie przez rozpoznawanie twarzy. Na ekranie wyświetlany jest obraz z kamery oraz w lewym dolnym rogu: zdjęcie rozpoznanej osoby z bazy danych lub statyczna ikona.

Osoba podchodzi do kamery, kiedy zostanie rozpoznana, w rogu przez pewien czas wyświetla się jej zdjęcie z bazy.

W niektórych momentach w aplikacji otwiera się popup, który zasłania zarówno obraz z kamery i ikonę/zdjęcie w lewym dolnym rogu.

Uruchomienie

Uruchomienie
just process_video
Usunięcie plików wygenerowanych przez skrypt
just process_video_clean

Działanie skryptu

TODO

Notatki

Wycięcie fragmentu wideo
ffmpeg -i input.mp4 -ss 00:20:00 -t 00:01:00 -c copy output.mp4
Indeksowanie klatek w filmie
  • Indeksowanie klatek przez cap.set(cv2.CAP_PROP_POS_FRAMES,myFrameNumber) może dać nieco inny rezultat niż dojście do klatki o tym indeksie przy sekwencyjnym przejściu (klatki kluczowe, kodowanie mp4)
  • Dla spójności, żeby dostać tę samą klatkę po indeksie trzeba iterować sekwencyjnie

Problemy

  • Pop-up w 20:00-21:00
Format może nie być dobry do ewaluacji modeli
  • Występują opóźnienia w rozpoznawaniu i w wyświetlaniu zdjęcia w lewym-dolnym rogu
  • Klatka z filmu będzie oznaczona id osoby rozpoznanej przez model bazowy
  • Id osoby jest dopisywane do tych klatek, dla których model dokonał autoryzacji i w lewym dolnym rogu wyświetliła się twarz
  • Powiedzmy że osoba pojawia się w klatce 1000
  • Model rozpoznaje ją w klatce 1100
  • Klatki 1000-1099 są podpisane jako puste, chociaż jest na nich osoba
  • Powiedzmy, że osoba została rozpoznana w klatce 1100
  • W lewym dolnym rogu wyświetla się jej zdjęcie, aż do klatki 1300
  • W klatce 1200 rozpoznana osoba już wyszła z kadru
  • Na środku kadru stoi ktoś inny
  • Mamy klatkę podpisaną jako osoba A, chociaż jest na niej osoba B
Objętość danych
  • Zapisywanie każdej klatki jako jpg (wycięty tylko obraz z kamery) -> 1GB na minutę nagrania
  • Pomysł - najpierw wyznaczyć mapowanie numer klatki -> id osoby (lub 0 jeśli brak) - ground truth
  • Potem na podstawie tego mapowania - podpróbkowanie
  • np. 10 równomiernie rozłożonych klatek z każdej sekwencji