initial commit

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,34 @@
+---
+title: Gradio Test
+colorFrom: red
+colorTo: purple
+sdk: gradio
+sdk_version: "3.9"
+python_version: "3.10"
+app_file: app.py
+pinned: false
+---
+
+# Demo of `deepest` parameter estimator
+This repository is a demo of the `deepest` parameter estimator introduced in []()
+
+## Usage
+Start by installing the requirements from the `requirements.txt`.
+```bash
+python -m pip install -r requirements.txt
+```
+
+The repository uses `secrets` to avoid leaking non-public information (i.e. the code, the trained model, git urls and access tokens) which can occur when users clone the repository.
+If you are in possesion of those secrets, set them as the following environement variables in your shell:
+```bash
+export MODEL_TOKEN=<Access Token for the Huggingface Model Git>
+export GIT_TOKEN=<Access Token for the `deepest` repository>
+export GIT_URL=<Url of the `deepest` repository>
+export GIT_COMMIT=<The commit shasum for the `deepest` version>
+
+```
+
+Then run the `app.py` via
+```bash
+python app.py
+```

app.py

@@ -0,0 +1,181 @@
+import os
+import sys
+import subprocess
+import numpy as np
+import logging
+import gradio as gr
+import matplotlib
+import matplotlib.pyplot as plt
+from huggingface_hub import hf_hub_download
+
+matplotlib.use("Agg")
+logger = logging.basicConfig(level=logging.ERROR)
+
+# define global variable demos
+DATA_SHAPE = (64,64)
+ETA_SHAPE = (2, 20)
+DATASET = "./data"
+N = 1000
+BS = 256
+WORKER = 2
+SNRS = {
+    "0": 1.0,
+    "10": 0.1,
+    "20": 0.01,
+    "30": 0.001,
+}
+
+# download model from huggingface hub
+MODEL_PATH = hf_hub_download("St0nedB/deepest-demo", "2022.07.03.2338.param2d.model", use_auth_token=os.environ["MODEL_TOKEN"])
+RUNNER = None
+
+# preallocated result arrays
+DATA = np.empty((len(SNRS), N, *DATA_SHAPE), dtype=np.complex128)
+TRUTH = np.empty((len(SNRS), N, *ETA_SHAPE))
+ESTIM = np.empty((len(SNRS), N, *ETA_SHAPE))
+
+def install_deepest():
+    git_token = os.environ["GIT_TOKEN"]
+    git_url = os.environ["GIT_URL"]
+    git_commit = os.environ["GIT_COMMIT"]
+    subprocess.check_call([sys.executable, "-m", "pip", "install", f"git+https://hggn:{git_token}@{git_url}@{git_commit}"])
+    return
+
+
+def make_plots(snr: float, idx: int):
+    idx -= 1
+    data, truth, estim = DATA[snr][idx], TRUTH[snr][idx], ESTIM[snr][idx]
+    
+    fig_data = make_dataplot(data)
+    fig_param = make_parameterplot(estim, truth)
+    
+    return fig_data, fig_param
+
+def make_dataplot(x: np.ndarray):
+    plt.close()
+    x = np.rot90(10*np.log10(np.abs(np.fft.fftn(x))), k=-1)
+    fig, ax = plt.subplots(1,1)
+    ax.imshow(x, extent=[0,1,0,1], cmap="viridis")
+    ax.set_xlabel("Norm. Delay")
+    ax.set_ylabel("Norm. Doppler")
+    
+    return fig
+
+def make_parameterplot(estim: np.ndarray, truth: np.ndarray = None, **kwargs):
+    plt.close()
+    fig, ax = plt.subplots(1,1)
+    ax = plot_parameters(ax, es=estim, gt=truth, **kwargs)
+    ax.set_xlim(0,1)
+    ax.set_ylim(0,1)
+    
+    return fig
+
+def load_numpy(file_obj) -> None | np.ndarray:
+    if file_obj is None:
+        # no file given
+        return None
+    
+    file = file_obj.name
+    if not(os.path.splitext(file)[1] in [".npy", ".npz"]):
+        # no numpy file
+        return None
+    
+    data = np.load(file)
+    if len(data.shape) != 3:
+        # not in proper shape
+        return None
+    
+    return data
+    
+def process_user_input(file_obj):
+    data = load_numpy(file_obj)
+    if data is None:
+        return None
+    
+    return gr.update(minimum=1, step=1, maximum=len(data), visible=True, value=1)
+
+def make_user_plot(file_obj, idx: int):
+    idx -= 1
+    data = load_numpy(file_obj)
+    
+    estim = RUNNER.fit(data[idx][None,])
+    bg_data = np.rot90(10*np.log10(np.abs(np.fft.fftn(data[idx], norm="ortho"))), k=-1)
+    fig_estim = make_parameterplot(estim=estim[0], bg=bg_data, extent=[0,1,0,1], cmap="viridis")
+    
+    return fig_estim
+    
+
+def demo():
+    with gr.Blocks() as demo:
+        gr.Markdown(
+            """
+            # deepest
+            `deepest` (short for **deep** learning parameter **est**imator) is a CNN trained to perform signal parameter estimation.
+            The corresponding paper can be found on [arxiv](arxiv.org).
+            
+            This applet lets you explore the `deepest` with data from the validationset.
+            You can also upload your own data and see how it works for your signals.
+            """
+        )
+        
+        with gr.Column():
+            snr = gr.Radio(choices=["0", "10", "20", "30"], type="index", value="0", label="SNR [dB]")
+            
+        with gr.Row():
+            data = gr.Plot(label="Data")
+            result = gr.Plot(label="Results")
+            
+        with gr.Row():
+            slider = gr.Slider(1, N, 1, label="Sample Index")
+            
+        # update callbacks
+        slider.change(make_plots, [snr, slider], [data, result])
+        snr.change(make_plots, [snr, slider], [data, result])
+        
+        with gr.Column():
+            gr.Markdown(
+                """
+                ## Try with your own data.
+                Good new everyone! If you want to try `deepest` with your own data, here is your chance. 
+                Afterall there is no need to believe a paper making vague claims about an algorithms performance.
+                But keep in mind that slight deviations from the training-data distribution might throw off `deepest`.
+                Its a Neural Network after all.  
+                You can upload a `numpy` file (both `*.npy` and `*.npz` work) with your test data.
+                Ensure the data meets the requirements, such that you get good results. 
+                ### Requirements
+                - complex-valued baseband data for the time-variant Channel transfer function $H(f,t)$ (e.g. from a channel-sounding campaing)
+                - array shape must be `batch_size x f_bins x t_bins`
+                - ideally `f_bin`=64 and `t_bin`=64, otherwise the data will be downsampled by the 2D-DFT, which might not be ideal in all scenarios.
+                
+                **Important** This demo runs on Huggingface. You are responsible for the data you upload. Do not upload any data that is confidential or unsuitable in this context.
+                """
+            )
+            
+            with gr.Row():
+                with gr.Column():
+                    user_file = gr.File(file_count="single", type="file", interactive=True)
+                    run_btn = gr.Button("Run Inference")
+                
+                user_plot = gr.Plot(label="Results")
+                
+            with gr.Column():
+                user_slider = gr.Slider(visible=False, label="Sample Index")
+                
+        run_btn.click(process_user_input, [user_file], [user_slider], show_progress=True)
+        user_slider.change(make_user_plot, [user_file, user_slider], [user_plot])
+        
+    demo.launch()
+    
+def main():
+    for dd, snr in enumerate(SNRS.values()):
+        DATA[dd], TRUTH[dd], ESTIM[dd] = RUNNER.run(snr=snr)
+        
+    demo()
+    
+    
+if __name__ == "__main__":
+    install_deepest()
+    from deepest.utils import plot_parameters
+    from helper import Runner
+    RUNNER = Runner(MODEL_PATH, DATASET, BS, WORKER)
+    main()

data/config.toml

@@ -0,0 +1,36 @@
+[[distribution]]
+minComps = 1
+maxComps = 20
+gammasLabels = [ "magnitude", "phase",]
+comment = "Moving Targets"
+[[distribution.parameter]]
+dist = "uniform"
+
+[distribution.parameter.kwargs]
+low = 0
+high = 1
+[[distribution.parameter]]
+dist = "uniform"
+
+[distribution.parameter.kwargs]
+low = 0
+high = 1
+[[distribution.gammas]]
+dist = "uniform"
+
+[distribution.gammas.kwargs]
+low = 0.001
+high = 1
+[[distribution.gammas]]
+dist = "uniform"
+
+[distribution.gammas.kwargs]
+low = 0
+high = 6.283
+
+[general]
+path = "./val"
+items = 1000
+dim = 2
+seed = 242
+minDistance = [ 0.003125, 0.003125,]

data/dataset.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:532c2127d6f70fe6844edd7c2619f42376216cedacba0cbbd8474da86cd97f87
+size 640264

helper.py

@@ -0,0 +1,59 @@
+from torch.utils.data import DataLoader
+from deepest.modules import Parameter2dNet
+from deepest.datasets import InferenceDelayDataset
+from deepest.metrics import match_components
+import numpy as np
+
+class Runner:
+    def __init__(self, model: str, dataset: str, bs: int, num_worker: int):
+        self.module = Parameter2dNet.from_file(f"{model}")
+        self.dataset_config = self.module.get_datasetconfig()
+        self.dataset = InferenceDelayDataset(path=dataset, **self.dataset_config)
+        self.bs = bs
+        self.num_worker = num_worker
+                
+    def _preallocate(self, data_shape: tuple[int, ...], eta_shape: tuple[int, ...]):
+        data = np.empty((len(self), *data_shape), dtype=np.complex128)
+        truth = np.empty((len(self), *eta_shape))
+        estim = np.empty((len(self), *eta_shape))
+        return data, truth, estim
+    
+    def _get_batchrange_for_index(self, ii: int):
+        start_idx = ii*self.bs
+        stop_idx = (ii+1)*self.bs
+        if stop_idx > len(self.dataset):
+            stop_idx = len(self.dataset)
+                
+        return range(start_idx, stop_idx)
+            
+    def run(self, snr: int) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        self.dataset.noise_var = (snr, snr)
+        dataloader = DataLoader(
+            self.dataset,
+            batch_size=self.bs,
+            num_workers=self.num_worker,
+            worker_init_fn=lambda worker_id: np.random.seed(worker_id),
+            shuffle=False,
+        )
+
+        for ii, (x, _, z) in enumerate(dataloader):
+            z = z[0][:, :2, :]
+            if ii == 0:
+                data, truth, estim = self._preallocate(x.shape[1:], z.shape[1:])
+                
+            idx_range = self._get_batchrange_for_index(ii)
+            
+            data[idx_range] = x.cpu().numpy()
+            truth[idx_range] = z.cpu().numpy()
+            estim[idx_range] = self.module.fit(x)[:, :2, :]
+        
+        estim, truth = match_components(estim, truth) 
+        
+        return data, truth, estim
+    
+    def fit(self, data: np.ndarray) -> np.ndarray:
+        x = self.module.fit(data)
+        return x[:, :2, :]
+    
+    def __len__(self):
+        return len(self.dataset)

requirements.txt

@@ -0,0 +1,14 @@
+datetime
+requests
+toml
+typical
+torch>=1.11
+torchinfo
+numpy>=1.20
+scipy
+scikit-image
+tqdm
+joblib
+matplotlib
+huggingface-hub
+gradio