Some fixes

export_model.py

@@ -0,0 +1,66 @@
+import numpy as np
+import onnx
+import torch
+import torchvision
+
+from models.spoter_embedding_model import SPOTER_EMBEDDINGS
+
+# set parameters of the model
+model_name = 'embedding_model'
+output=32
+
+# load PyTorch model from .pth file
+
+device = torch.device("cpu")
+if torch.cuda.is_available():
+    device = torch.device("cuda")
+
+CHECKPOINT_PATH = "out-checkpoints/augment_rotate_75_x8/checkpoint_embed_1105.pth"
+checkpoint = torch.load(CHECKPOINT_PATH, map_location=device)
+
+model = SPOTER_EMBEDDINGS(
+    features=checkpoint["config_args"].vector_length,
+    hidden_dim=checkpoint["config_args"].hidden_dim,
+    norm_emb=checkpoint["config_args"].normalize_embeddings,
+).to(device)
+model.load_state_dict(checkpoint["state_dict"])
+# set model to evaluation mode
+model.eval()
+
+model_export = "onnx"
+if model_export == "coreml":
+    dummy_input = torch.randn(1, 10, 54, 2)
+    traced_model = torch.jit.trace(model, dummy_input)
+    out = traced_model(dummy_input)
+    import coremltools as ct
+
+    # Convert to Core ML
+    coreml_model = ct.convert(
+        traced_model,
+        inputs=[ct.TensorType(name="input", shape=dummy_input.shape)],
+    )
+
+    # Save Core ML model
+    coreml_model.save("models/" + model_name + ".mlmodel")
+else:
+    # create dummy input tensor
+    dummy_input = torch.randn(1, 10, 54, 2)
+
+    # export model to ONNX format
+    output_file = 'models/' + model_name + '.onnx'
+    torch.onnx.export(model, dummy_input, output_file, input_names=['input'], output_names=['output'])
+
+    torch.onnx.export(model,                                # model being run
+                    dummy_input,                          # model input (or a tuple for multiple inputs)
+                    'output-models/' + model_name + '.onnx',     # where to save the model (can be a file or file-like object)
+                    export_params=True,                   # store the trained parameter weights inside the model file
+                    opset_version=9,                      # the ONNX version to export the model to
+                    do_constant_folding=True,             # whether to execute constant folding for optimization
+                    input_names = ['X'],                  # the model's input names
+                    output_names = ['Y']                  # the model's output names
+                    )
+
+
+    # load exported ONNX model for verification
+    onnx_model = onnx.load(output_file)
+    onnx.checker.check_model(onnx_model)

hyperparam_opt.py

@@ -1,7 +1,7 @@
 from clearml.automation import UniformParameterRange, UniformIntegerParameterRange, DiscreteParameterRange
 from clearml.automation import HyperParameterOptimizer
 from clearml.automation.optuna import OptimizerOptuna
-
+from optuna.pruners import HyperbandPruner, MedianPruner
 from clearml import Task
 
 task = Task.init(
@@ -17,19 +17,19 @@ optimizer = HyperParameterOptimizer(
       base_task_id="4504e0b3ec6745249d3d4c94d3d40652",  
       # setting the hyperparameters to optimize
       hyper_parameters=[
-        # epochs
+        # epochs:
-        UniformIntegerParameterRange('Args/epochs', 200, 800),
+        DiscreteParameterRange('Args/epochs', [200]),
         # learning rate
-        UniformParameterRange('Args/lr', 0.000001, 0.1),
+        UniformParameterRange('Args/lr', 0.000001, 0.01),
         # optimizer
         DiscreteParameterRange('Args/optimizer', ['ADAM', 'SGD']),
         # vector length
         UniformIntegerParameterRange('Args/vector_length', 10, 100),
           ],
       # setting the objective metric we want to maximize/minimize
-      objective_metric_title='silhouette_coefficient',
+      objective_metric_title='train_loss',
-      objective_metric_series='val',
+      objective_metric_series='loss',
-      objective_metric_sign='max',  
+      objective_metric_sign='min',  
 
       # setting optimizer  
       optimizer_class=OptimizerOptuna,
@@ -40,7 +40,34 @@ optimizer = HyperParameterOptimizer(
       compute_time_limit=480, 
       total_max_jobs=20,
       min_iteration_per_job=0,
-      max_iteration_per_job=150000,
+      max_iteration_per_job=150000, 
+      pool_period_min=0.1,
+
+      save_top_k_tasks_only=3,
+      optuna_pruner=MedianPruner(),
+
       )
 
-task.execute_remotely(queue_name='default', exit_process=True)
+def job_complete_callback(
+    job_id,                 # type: str
+    objective_value,        # type: float
+    objective_iteration,    # type: int
+    job_parameters,         # type: dict
+    top_performance_job_id  # type: str
+):
+    print('Job completed!', job_id, objective_value, objective_iteration, job_parameters)
+    if job_id == top_performance_job_id:
+        print('WOOT WOOT we broke the record! Objective reached {}'.format(objective_value))
+
+task.execute_remotely(queue_name='hypertuning', exit_process=True)
+
+optimizer.set_report_period(0.3)
+
+optimizer.start(job_complete_callback=job_complete_callback)
+
+optimizer.wait()
+
+top_exp = optimizer.get_top_experiments(top_k=3)
+print([t.id for t in top_exp])
+
+optimizer.stop()

requirements.txt

@@ -9,7 +9,7 @@ opencv-python==4.6.0.66
 plotly==5.11.0
 scikit-learn==1.0.2
 clearml==1.10.3
-torch==2.0.0+cu118
+torch==2.0.0
-torchvision==0.15.1+cu118
+torchvision==0.15.1
 tqdm==4.54.1
 optuna==3.1.1

train.py

@@ -75,12 +75,25 @@ def train(args, tracker: Tracker):
 
     # Construct the model
     if not args.classification_model:
-        slrt_model = SPOTER_EMBEDDINGS(
+        # if finetune, load the weights from the classification model
-            features=args.vector_length,
+        if args.finetune:
-            hidden_dim=args.hidden_dim,
+            checkpoint = torch.load(args.checkpoint, map_location=device)
-            norm_emb=args.normalize_embeddings,
+
-            dropout=args.dropout
+            slrt_model = SPOTER_EMBEDDINGS(
-        )
+                features=checkpoint["config_args"].vector_length,
+                hidden_dim=checkpoint["config_args"].hidden_dim,
+                norm_emb=checkpoint["config_args"].normalize_embeddings,
+                dropout=checkpoint["config_args"].dropout,
+            )
+        else:
+            slrt_model = SPOTER_EMBEDDINGS(
+                features=args.vector_length,
+                hidden_dim=args.hidden_dim,
+                norm_emb=args.normalize_embeddings,
+                dropout=args.dropout,
+            )
+            
+
         model_type = 'embed'
         if args.hard_triplet_mining == "None":
             cel_criterion = nn.TripletMarginLoss(margin=args.triplet_loss_margin, p=2)

train.sh

@@ -1,10 +1,10 @@
 #!/bin/sh
-python -m train \
+python3 -m train \
 	--save_checkpoints_every 10 \
     --experiment_name "wlasl" \
-    --epochs 300 \
+    --epochs 600 \
-	--optimizer "ADAM" \
+	--optimizer "SGD" \
-	--lr 0.0001 \
+	--lr 0.001 \
     --batch_size 16 \
 	--dataset_name "WLASL" \
 	--training_set_path "WLASL100_train.csv" \
@@ -12,7 +12,7 @@ python -m train \
 	--vector_length 32 \
 	--epoch_iters -1 \
 	--scheduler_factor 0.2 \
-	--hard_triplet_mining "None" \
+	--hard_triplet_mining "in_batch" \
 	--filter_easy_triplets \
 	--triplet_loss_margin 2 \
 	--dropout 0.2 \