Add submission scripts

inference.py

@@ -1,30 +0,0 @@
-
-import pandas as pd
-import torch
-from preprocess_data import load_data, preprocess_data
-from model import WireframeModel
-
-def inference(model, test_data):
-    K, R, t, images, points3d, cameras, depthcm, mesh_vertices, mesh_faces, face_semantics, edge_semantics, wf_vertices, wf_edges = preprocess_data(test_data)
-    model.eval()
-    with torch.no_grad():
-        pred_vertices = model(torch.tensor(K, dtype=torch.float32)).numpy()
-        pred_edges = []  # Implement your edge detection logic here
-        for i in range(len(pred_vertices)):
-            pred_edges.append([[i, (i+1) % len(pred_vertices)]])
-    return [{"__key__": test_data['order_id'][i], "wf_vertices": pred_vertices[i], "wf_edges": pred_edges[i]} for i in range(len(pred_vertices))]
-
-# Load test data
-test_data = load_data('test_data.parquet')
-
-# Initialize and load the model
-model = WireframeModel()
-model.load_state_dict(torch.load('model.pth'))
-
-# Generate predictions
-predictions = inference(model, test_data)
-
-# Save predictions to parquet file
-pred_df = pd.DataFrame(predictions)
-pred_df.to_parquet('submission.parquet', index=False)
-    

model.py

@@ -1,26 +0,0 @@
-
-import torch
-import torch.nn as nn
-
-class WireframeModel(nn.Module):
-    def __init__(self):
-        super(WireframeModel, self).__init__()
-        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
-        self.conv2 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)
-        self.fc1 = nn.Linear(128 * 8 * 8, 1024)
-        self.fc2 = nn.Linear(1024, 512)
-        self.fc3 = nn.Linear(512, 256)
-        self.fc4 = nn.Linear(256, 3)
-        self.dropout = nn.Dropout(0.5)
-
-    def forward(self, x):
-        x = torch.relu(self.conv1(x))
-        x = torch.relu(self.conv2(x))
-        x = x.view(x.size(0), -1)
-        x = torch.relu(self.fc1(x))
-        x = self.dropout(x)
-        x = torch.relu(self.fc2(x))
-        x = torch.relu(self.fc3(x))
-        x = self.fc4(x)
-        return x
-    

preprocess_data.py

@@ -1,24 +0,0 @@
-
-import pandas as pd
-import numpy as np
-
-def load_data(file_path):
-    data = pd.read_parquet(file_path)
-    return data
-
-def preprocess_data(data):
-    K = np.stack(data['K'].values)
-    R = np.stack(data['R'].values)
-    t = np.stack(data['t'].values)
-    images = data['images']
-    points3d = data['points3d']
-    cameras = data['cameras']
-    depthcm = np.stack(data['depthcm'].values)
-    mesh_vertices = np.stack(data['mesh_vertices'].values)
-    mesh_faces = np.stack(data['mesh_faces'].values)
-    face_semantics = np.stack(data['face_semantics'].values)
-    edge_semantics = np.stack(data['edge_semantics'].values)
-    wf_vertices = np.stack(data['wf_vertices'].values)
-    wf_edges = np.stack(data['wf_edges'].values)
-    return K, R, t, images, points3d, cameras, depthcm, mesh_vertices, mesh_faces, face_semantics, edge_semantics, wf_vertices, wf_edges
-    

script.py

@@ -1,30 +1,58 @@
+### This is example of the script that will be run in the test environment.
+### Some parts of the code are compulsory and you should NOT CHANGE THEM.
+### They are between '''---compulsory---''' comments.
+### You can change the rest of the code to define and test your solution.
+### However, you should not change the signature of the provided function.
+### The script would save "submission.parquet" file in the current directory.
+### You can use any additional files and subdirectories to organize your code.
 
-import pandas as pd
-import torch
-from preprocess_data import load_data, preprocess_data
-from model import WireframeModel
+'''---compulsory---'''
+import hoho; hoho.setup() # YOU MUST CALL hoho.setup() BEFORE ANYTHING ELSE
+'''---compulsory---'''
 
-def inference(model, test_data):
-    K, R, t, images, points3d, cameras, depthcm, mesh_vertices, mesh_faces, face_semantics, edge_semantics, wf_vertices, wf_edges = preprocess_data(test_data)
-    model.eval()
-    with torch.no_grad():
-        pred_vertices = model(torch.tensor(K, dtype=torch.float32)).numpy()
-        pred_edges = []  # Implement your edge detection logic here
-        for i in range(len(pred_vertices)):
-            pred_edges.append([[i, (i+1) % len(pred_vertices)]])
-    return [{"__key__": test_data['order_id'][i], "wf_vertices": pred_vertices[i], "wf_edges": pred_edges[i]} for i in range(len(pred_vertices))]
+from pathlib import Path
+from tqdm import tqdm
+import pandas as pd
+import numpy as np
 
-# Load test data
-test_data = load_data('test_data.parquet')
 
-# Initialize and load the model
-model = WireframeModel()
-model.load_state_dict(torch.load('model.pth'))
+def empty_solution(sample):
+    '''Return a minimal valid solution, i.e. 2 vertices and 1 edge.'''
+    return np.zeros((2,3)), [(0, 1)]
 
-# Generate predictions
-predictions = inference(model, test_data)
 
-# Save predictions to parquet file
-pred_df = pd.DataFrame(predictions)
-pred_df.to_parquet('submission.parquet', index=False)
-    
+if __name__ == "__main__":
+    print ("------------ Loading dataset------------ ")
+    params = hoho.get_params()
+    
+    # by default it is usually better to use `get_dataset()` like this
+    # 
+    # dataset = hoho.get_dataset(split='all')
+    # 
+    # but in this case (because we don't do anything with the sample 
+    # anyway) we set `decode=None`. We can set the `split` argument 
+    # to 'train' or 'val' ('all' defaults back to 'train') if we are 
+    # testing ourselves locally. 
+    # 
+    # dataset = hoho.get_dataset(split='val', decode=None)
+    #
+    # On the test server *`split` must be set to 'all'* 
+    # to compute both the public and private leaderboards.
+    # 
+    dataset = hoho.get_dataset(split='all', decode=None)
+    
+    print('------------ Now you can do your solution ---------------')
+    solution = []
+    for i, sample in enumerate(tqdm(dataset)):
+        # replace this with your solution
+        pred_vertices, pred_edges = empty_solution(sample)
+        
+        solution.append({
+                        '__key__': sample['__key__'], 
+                        'wf_vertices': pred_vertices.tolist(),
+                        'wf_edges': pred_edges
+                    })
+    print('------------ Saving results ---------------')
+    sub = pd.DataFrame(solution, columns=["__key__", "wf_vertices", "wf_edges"])
+    sub.to_parquet(Path(params['output_path']) / "submission.parquet")
+    print("------------ Done ------------ ")

train.py

@@ -1,28 +0,0 @@
-
-import torch
-import torch.optim as optim
-from preprocess_data import load_data, preprocess_data
-from model import WireframeModel
-
-# Load and preprocess data
-data = load_data('data.parquet')
-K, R, t, images, points3d, cameras, depthcm, mesh_vertices, mesh_faces, face_semantics, edge_semantics, wf_vertices, wf_edges = preprocess_data(data)
-
-# Initialize model, criterion and optimizer
-model = WireframeModel()
-criterion = torch.nn.MSELoss()
-optimizer = optim.Adam(model.parameters(), lr=0.001)
-
-# Training loop
-num_epochs = 100
-for epoch in range(num_epochs):
-    optimizer.zero_grad()
-    outputs = model(torch.tensor(K, dtype=torch.float32))
-    loss = criterion(outputs, torch.tensor(wf_vertices, dtype=torch.float32))
-    loss.backward()
-    optimizer.step()
-    print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item()}')
-
-# Save the model
-torch.save(model.state_dict(), 'model.pth')
-