From 013682fa3c25da6b51750707fce2c401b258a956 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Sun, 24 Aug 2025 16:02:31 +0000 Subject: [PATCH 01/29] plugged actions in --- .github/workflows/shared.yaml | 222 ++++++++++++++++++++++++++++++++++ .github/workflows/train.yaml | 28 +++++ 2 files changed, 250 insertions(+) create mode 100644 .github/workflows/shared.yaml create mode 100644 .github/workflows/train.yaml diff --git a/.github/workflows/shared.yaml b/.github/workflows/shared.yaml new file mode 100644 index 0000000..8aeb1c4 --- /dev/null +++ b/.github/workflows/shared.yaml @@ -0,0 +1,222 @@ +# .github/workflows/shared.yml +on: + workflow_call: + inputs: + name: + required: true + type: string + target: + required: true + type: string + additional_profile: + type: string + required: false + default: "" + + generated_model_path: + type: string + required: true + + secrets: + SECRETS_YAML: + required: true + +jobs: + train-and-validate: + runs-on: aiinfn-lamarrsim-gpu + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Restore file timestamps + run: | + git log -1 --format="%at" -- pidgan/workflow/envs/lhcb.def + + - name: Retrieve secrets + run: | + mkdir -p /tmp/artifacts + cat < /tmp/artifacts/secrets.yaml + ${{ secrets.SECRETS_YAML }} + EOF + + - name: Snakemake workflow + uses: landerlini/apptainer-gha-runner/workflow@main + with: + workdir: pidgan + target: ${{ inputs.target }} + report: report-${{ inputs.name }} + snakefile: workflow/Snakefile + config: | + secrets_file: /tmp/artifacts/secrets.yaml + storage_folder: ${{ inputs.name }} + profile: | + rerun-incomplete: True + keep-going: True + + software-deployment-method: apptainer + local-storage-prefix: /tmp + apptainer-args: -B /home -B /cvmfs -B /tmp --nv --writable-tmpfs --no-mount /usr + keep-storage-local-copies: true + + jobs: 1 + cores: 8 + + default-resources: + mem_mb: 2000 + millicpu: 1000 + + resources: + mem_mb: 64000 + millicpu: 32000 + gpu: 1 + + ${{ inputs.additional_profile }} + + + - name: Upload raw model + uses: actions/upload-artifact@v4 + with: + name: pid_compiled_model.c + path: ${{ inputs.generated_model_path }} + + + compress-transpiled-c: + runs-on: ubuntu-latest + container: harbor.cloud.infn.it/unpacked/aiinfn-gha-runner:latest + needs: train-and-validate + steps: + - name: Install missing libraries + run: | + sudo apt-get update + sudo apt-get install -y xz-utils + + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Download artifact + uses: actions/download-artifact@v4 + with: + name: compiled_model.c + path: ./artifact + + - name: Compress file + run: | + xz -9e -T0 -c -k "$(find ./artifact -type f -name '*.c' | head -n 1)" > compiled_model.c.xz + + - name: Upload compressed model + uses: actions/upload-artifact@v4 + with: + name: compiled_model.c.xz + path: ./compiled_model.c.xz + + + compile: + needs: train-and-validate + strategy: + matrix: + include: + - runner: ubuntu-latest + arch: x86_64_v2 + compiler: centos7-gcc9-opt + container: /cvmfs/lhcb.cern.ch/containers/os-base/centos7-devel/prod/amd64 + + - runner: ubuntu-latest + arch: x86_64_v2 + compiler: el9-gcc13-opt + container: /cvmfs/lhcb.cern.ch/containers/os-base/alma9-devel/prod/amd64/ + + - runner: ubuntu-latest + arch: x86_64_v2 + compiler: el9-gcc13-dbg + container: /cvmfs/lhcb.cern.ch/containers/os-base/alma9-devel/prod/amd64/ + + - runner: ubuntu-24.04-arm + arch: armv8.1_a + compiler: el9-gcc13-opt + container: /cvmfs/lhcb.cern.ch/containers/os-base/alma9-devel/prod/arm64v8/ + + + + runs-on: ${{ matrix.runner }} + + steps: + - name: Mount CVMFS + uses: cvmfs-contrib/github-action-cvmfs@v4 + + - name: Build apptainer + run: | + git clone https://github.com/apptainer/apptainer.git + cd apptainer + git checkout v1.4.1 + ./mconfig --with-suid + make -C builddir + sudo make -C builddir install + + + - name: Download transpiled model (uncompressed) + uses: actions/download-artifact@v4 + with: + name: compiled_model.c + path: ./artifact + + - name: Compile for ${{ matrix.arch }}-${{ matrix.compiler }} + run: | + cat < compile_cmd.sh + source /cvmfs/lhcb.cern.ch/lib/LbEnv -c ${{ matrix.arch }}-${{ matrix.compiler }} + + mkdir -p build + gcc artifact/compiled_model.c \ + -O3 \ + -lm \ + --shared \ + -fPIC \ + -std=c99 \ + -o build/trk-${{ matrix.arch }}-${{ matrix.compiler }}.so + EOF + apptainer exec -B/home -B/cvmfs -B/tmp \ + ${{ matrix.container }} \ + /bin/bash compile_cmd.sh + + - name: Upload trk-${{ matrix.arch }}-${{ matrix.compiler }} + uses: actions/upload-artifact@v4 + with: + path: build/trk-${{ matrix.arch }}-${{ matrix.compiler }}.so + name: ${{ matrix.arch }}-${{ matrix.compiler }} + + release: + runs-on: ubuntu-latest + needs: compile + permissions: + contents: write + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Download artifact + uses: actions/download-artifact@v4 + with: + path: ./artifact + + - name: Install GitHub CLI + run: sudo apt-get update && sudo apt-get install -y gh + + - name: Fetch latest merged PR description + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + echo "RELEASE_TIMESTAMP=$(date +'%Y-%m-%dT%Hh%Mm%S')" >> $GITHUB_ENV + gh pr list --head ${{ github.head_ref }} --limit 1 --json number,body \ + --jq '.[0].body' > pr_description.md + + - name: Create GitHub Release + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + uses: ncipollo/release-action@v1 + with: + tag: ${{ inputs.name }}-${{ env.RELEASE_TIMESTAMP }} + name: "Tracking models `${{ inputs.name }}-${{ env.RELEASE_TIMESTAMP }}`" + bodyFile: pr_description.md + artifacts: artifact/*/*.so,artifact/*/*.html,artifact/*/*.xz + artifactContentType: raw + + diff --git a/.github/workflows/train.yaml b/.github/workflows/train.yaml new file mode 100644 index 0000000..98068cf --- /dev/null +++ b/.github/workflows/train.yaml @@ -0,0 +1,28 @@ +name: Train models + +on: + pull_request: + branches: + - main + +concurrency: + group: pull_request-${{ github.head_ref }} + cancel-in-progress: true + + +jobs: + trk-2016MagUp-Sim10b: + uses: LamarrSim/release-models/.github/workflows/release.yaml@main + permissions: + contents: write + pull-requests: write + with: + name: pp-2016-MU-Sim10b-${{ github.head_ref }} + snakemake_dir: pidgan + target: deploy validate_all + additional_config: "" + additional_profile: "" + generated_model_path: /tmp/compiled_pid_model.c + secrets: + SECRETS_YAML: ${{ secrets.STORAGE_SECRETS }} + From 3ac539c9243558c8cd15ec3a84cf7e7ee03cadee Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Sun, 24 Aug 2025 16:14:03 +0000 Subject: [PATCH 02/29] try modifying snakemake rule order --- .github/workflows/train.yaml | 2 +- pidgan/workflow/Snakefile | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/.github/workflows/train.yaml b/.github/workflows/train.yaml index 98068cf..153ca46 100644 --- a/.github/workflows/train.yaml +++ b/.github/workflows/train.yaml @@ -19,7 +19,7 @@ jobs: with: name: pp-2016-MU-Sim10b-${{ github.head_ref }} snakemake_dir: pidgan - target: deploy validate_all + target: validate_all additional_config: "" additional_profile: "" generated_model_path: /tmp/compiled_pid_model.c diff --git a/pidgan/workflow/Snakefile b/pidgan/workflow/Snakefile index 0359e44..661f583 100644 --- a/pidgan/workflow/Snakefile +++ b/pidgan/workflow/Snakefile @@ -9,6 +9,10 @@ PARTICLES = ['muon', 'pion', 'kaon', 'proton'] ITEMS = ['model.keras', 'tX.pkl', 'tY.pkl'] +rule validate_all: + input: smkstore(expand("validate-{particle}.html", particle=PARTICLES), 's3reports') + + rule build_container: input: definition_file="workflow/envs/pidgan.def" @@ -278,7 +282,5 @@ rule validate: {input.notebook} --output {log} """ -rule validate_all: - input: smkstore(expand("validate-{particle}.html", particle=PARTICLES), 's3reports') From 9bb8caa64dcb571b004c236db0a9981d7bf34962 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Sun, 24 Aug 2025 16:18:43 +0000 Subject: [PATCH 03/29] try to avoid building container calling explicitely for caching --- .github/workflows/train.yaml | 2 +- pidgan/workflow/Snakefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/train.yaml b/.github/workflows/train.yaml index 153ca46..6c5d037 100644 --- a/.github/workflows/train.yaml +++ b/.github/workflows/train.yaml @@ -19,7 +19,7 @@ jobs: with: name: pp-2016-MU-Sim10b-${{ github.head_ref }} snakemake_dir: pidgan - target: validate_all + target: cache_container validate_all additional_config: "" additional_profile: "" generated_model_path: /tmp/compiled_pid_model.c diff --git a/pidgan/workflow/Snakefile b/pidgan/workflow/Snakefile index 661f583..c261ee9 100644 --- a/pidgan/workflow/Snakefile +++ b/pidgan/workflow/Snakefile @@ -13,7 +13,7 @@ rule validate_all: input: smkstore(expand("validate-{particle}.html", particle=PARTICLES), 's3reports') -rule build_container: +rule build_apptainer_image: input: definition_file="workflow/envs/pidgan.def" From 139d84687a314f2facd89aa68a689f9e7852aa43 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Sun, 24 Aug 2025 16:21:34 +0000 Subject: [PATCH 04/29] try to avoid building container calling explicitely for caching --- pidgan/workflow/Snakefile | 50 +++++++++++++++++++-------------------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/pidgan/workflow/Snakefile b/pidgan/workflow/Snakefile index c261ee9..ad49bb6 100644 --- a/pidgan/workflow/Snakefile +++ b/pidgan/workflow/Snakefile @@ -13,31 +13,31 @@ rule validate_all: input: smkstore(expand("validate-{particle}.html", particle=PARTICLES), 's3reports') -rule build_apptainer_image: - input: - definition_file="workflow/envs/pidgan.def" - - output: - sif=smkstore("lhcb-pidsim.sif", 's3images') - - params: - unpacked=config['apptainer_image'], - wait4cvfms=f"{config['cvmfs_repo']}/{config['apptainer_image']}", - push=0, # Set to 1 to push to harbor - - shell: - """ - apptainer build {output.sif} {input.definition_file} - - if [ {params.push} -eq 1 ]; then - apptainer push {output.sif} oras://{params.unpacked} - - echo "Waiting for cvmfs repo: {params.wait4cvfms}" - while true; - do - ls {params.wait4cvfms} &> /dev/null || ( sleep 5 && echo "Still waiting..." ) ; - done - fi +# rule build_apptainer_image: +# input: +# definition_file="workflow/envs/pidgan.def" +# +# output: +# sif=smkstore("lhcb-pidsim.sif", 's3images') +# +# params: +# unpacked=config['apptainer_image'], +# wait4cvfms=f"{config['cvmfs_repo']}/{config['apptainer_image']}", +# push=0, # Set to 1 to push to harbor +# +# shell: +# """ +# apptainer build {output.sif} {input.definition_file} +# +# if [ {params.push} -eq 1 ]; then +# apptainer push {output.sif} oras://{params.unpacked} +# +# echo "Waiting for cvmfs repo: {params.wait4cvfms}" +# while true; +# do +# ls {params.wait4cvfms} &> /dev/null || ( sleep 5 && echo "Still waiting..." ) ; +# done +# fi """ From 715e441c464c34ee9f3ee690599ed11e43184488 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Sun, 24 Aug 2025 16:22:48 +0000 Subject: [PATCH 05/29] try to avoid building container calling explicitely for caching --- pidgan/workflow/Snakefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pidgan/workflow/Snakefile b/pidgan/workflow/Snakefile index ad49bb6..7a730d7 100644 --- a/pidgan/workflow/Snakefile +++ b/pidgan/workflow/Snakefile @@ -38,7 +38,7 @@ rule validate_all: # ls {params.wait4cvfms} &> /dev/null || ( sleep 5 && echo "Still waiting..." ) ; # done # fi - """ +# """ rule cache_container: From 1e2a24ad46bfc2425b10d66a3c8806919f57daf9 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Sun, 24 Aug 2025 16:26:41 +0000 Subject: [PATCH 06/29] try to avoid building container calling explicitely for caching --- pidgan/workflow/Snakefile | 54 +++++++++++++++++++-------------------- 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/pidgan/workflow/Snakefile b/pidgan/workflow/Snakefile index 7a730d7..ea89a9e 100644 --- a/pidgan/workflow/Snakefile +++ b/pidgan/workflow/Snakefile @@ -13,36 +13,36 @@ rule validate_all: input: smkstore(expand("validate-{particle}.html", particle=PARTICLES), 's3reports') -# rule build_apptainer_image: -# input: -# definition_file="workflow/envs/pidgan.def" -# -# output: -# sif=smkstore("lhcb-pidsim.sif", 's3images') -# -# params: -# unpacked=config['apptainer_image'], -# wait4cvfms=f"{config['cvmfs_repo']}/{config['apptainer_image']}", -# push=0, # Set to 1 to push to harbor -# -# shell: -# """ -# apptainer build {output.sif} {input.definition_file} -# -# if [ {params.push} -eq 1 ]; then -# apptainer push {output.sif} oras://{params.unpacked} -# -# echo "Waiting for cvmfs repo: {params.wait4cvfms}" -# while true; -# do -# ls {params.wait4cvfms} &> /dev/null || ( sleep 5 && echo "Still waiting..." ) ; -# done -# fi -# """ +rule build_apptainer_image: + input: + definition_file=ancient("workflow/envs/pidgan.def") + + output: + sif=smkstore("lhcb-pidsim.sif", 's3images') + + params: + unpacked=config['apptainer_image'], + wait4cvfms=f"{config['cvmfs_repo']}/{config['apptainer_image']}", + push=0, # Set to 1 to push to harbor + + shell: + """ + apptainer build {output.sif} {input.definition_file} + + if [ {params.push} -eq 1 ]; then + apptainer push {output.sif} oras://{params.unpacked} + + echo "Waiting for cvmfs repo: {params.wait4cvfms}" + while true; + do + ls {params.wait4cvfms} &> /dev/null || ( sleep 5 && echo "Still waiting..." ) ; + done + fi + """ rule cache_container: - input: ancient(smkstore("lhcb-pidsim.sif", 's3images')) + input: smkstore("lhcb-pidsim.sif", 's3images') output: config['apptainer_cached_image'] shell: "cp {input} {output}" From 0084635bc409b9655100c804305bc8c128bcf0c7 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Sun, 24 Aug 2025 16:55:09 +0000 Subject: [PATCH 07/29] move additional config in the root workflow configuration and clean dismissed shared.yaml --- .github/workflows/shared.yaml | 222 ---------------------------------- .github/workflows/train.yaml | 4 +- pidgan/config/config.yaml | 5 +- 3 files changed, 5 insertions(+), 226 deletions(-) diff --git a/.github/workflows/shared.yaml b/.github/workflows/shared.yaml index 8aeb1c4..e69de29 100644 --- a/.github/workflows/shared.yaml +++ b/.github/workflows/shared.yaml @@ -1,222 +0,0 @@ -# .github/workflows/shared.yml -on: - workflow_call: - inputs: - name: - required: true - type: string - target: - required: true - type: string - additional_profile: - type: string - required: false - default: "" - - generated_model_path: - type: string - required: true - - secrets: - SECRETS_YAML: - required: true - -jobs: - train-and-validate: - runs-on: aiinfn-lamarrsim-gpu - steps: - - name: Checkout repository - uses: actions/checkout@v4 - - - name: Restore file timestamps - run: | - git log -1 --format="%at" -- pidgan/workflow/envs/lhcb.def - - - name: Retrieve secrets - run: | - mkdir -p /tmp/artifacts - cat < /tmp/artifacts/secrets.yaml - ${{ secrets.SECRETS_YAML }} - EOF - - - name: Snakemake workflow - uses: landerlini/apptainer-gha-runner/workflow@main - with: - workdir: pidgan - target: ${{ inputs.target }} - report: report-${{ inputs.name }} - snakefile: workflow/Snakefile - config: | - secrets_file: /tmp/artifacts/secrets.yaml - storage_folder: ${{ inputs.name }} - profile: | - rerun-incomplete: True - keep-going: True - - software-deployment-method: apptainer - local-storage-prefix: /tmp - apptainer-args: -B /home -B /cvmfs -B /tmp --nv --writable-tmpfs --no-mount /usr - keep-storage-local-copies: true - - jobs: 1 - cores: 8 - - default-resources: - mem_mb: 2000 - millicpu: 1000 - - resources: - mem_mb: 64000 - millicpu: 32000 - gpu: 1 - - ${{ inputs.additional_profile }} - - - - name: Upload raw model - uses: actions/upload-artifact@v4 - with: - name: pid_compiled_model.c - path: ${{ inputs.generated_model_path }} - - - compress-transpiled-c: - runs-on: ubuntu-latest - container: harbor.cloud.infn.it/unpacked/aiinfn-gha-runner:latest - needs: train-and-validate - steps: - - name: Install missing libraries - run: | - sudo apt-get update - sudo apt-get install -y xz-utils - - - name: Checkout repository - uses: actions/checkout@v4 - - - name: Download artifact - uses: actions/download-artifact@v4 - with: - name: compiled_model.c - path: ./artifact - - - name: Compress file - run: | - xz -9e -T0 -c -k "$(find ./artifact -type f -name '*.c' | head -n 1)" > compiled_model.c.xz - - - name: Upload compressed model - uses: actions/upload-artifact@v4 - with: - name: compiled_model.c.xz - path: ./compiled_model.c.xz - - - compile: - needs: train-and-validate - strategy: - matrix: - include: - - runner: ubuntu-latest - arch: x86_64_v2 - compiler: centos7-gcc9-opt - container: /cvmfs/lhcb.cern.ch/containers/os-base/centos7-devel/prod/amd64 - - - runner: ubuntu-latest - arch: x86_64_v2 - compiler: el9-gcc13-opt - container: /cvmfs/lhcb.cern.ch/containers/os-base/alma9-devel/prod/amd64/ - - - runner: ubuntu-latest - arch: x86_64_v2 - compiler: el9-gcc13-dbg - container: /cvmfs/lhcb.cern.ch/containers/os-base/alma9-devel/prod/amd64/ - - - runner: ubuntu-24.04-arm - arch: armv8.1_a - compiler: el9-gcc13-opt - container: /cvmfs/lhcb.cern.ch/containers/os-base/alma9-devel/prod/arm64v8/ - - - - runs-on: ${{ matrix.runner }} - - steps: - - name: Mount CVMFS - uses: cvmfs-contrib/github-action-cvmfs@v4 - - - name: Build apptainer - run: | - git clone https://github.com/apptainer/apptainer.git - cd apptainer - git checkout v1.4.1 - ./mconfig --with-suid - make -C builddir - sudo make -C builddir install - - - - name: Download transpiled model (uncompressed) - uses: actions/download-artifact@v4 - with: - name: compiled_model.c - path: ./artifact - - - name: Compile for ${{ matrix.arch }}-${{ matrix.compiler }} - run: | - cat < compile_cmd.sh - source /cvmfs/lhcb.cern.ch/lib/LbEnv -c ${{ matrix.arch }}-${{ matrix.compiler }} - - mkdir -p build - gcc artifact/compiled_model.c \ - -O3 \ - -lm \ - --shared \ - -fPIC \ - -std=c99 \ - -o build/trk-${{ matrix.arch }}-${{ matrix.compiler }}.so - EOF - apptainer exec -B/home -B/cvmfs -B/tmp \ - ${{ matrix.container }} \ - /bin/bash compile_cmd.sh - - - name: Upload trk-${{ matrix.arch }}-${{ matrix.compiler }} - uses: actions/upload-artifact@v4 - with: - path: build/trk-${{ matrix.arch }}-${{ matrix.compiler }}.so - name: ${{ matrix.arch }}-${{ matrix.compiler }} - - release: - runs-on: ubuntu-latest - needs: compile - permissions: - contents: write - steps: - - name: Checkout repository - uses: actions/checkout@v4 - - - name: Download artifact - uses: actions/download-artifact@v4 - with: - path: ./artifact - - - name: Install GitHub CLI - run: sudo apt-get update && sudo apt-get install -y gh - - - name: Fetch latest merged PR description - env: - GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} - run: | - echo "RELEASE_TIMESTAMP=$(date +'%Y-%m-%dT%Hh%Mm%S')" >> $GITHUB_ENV - gh pr list --head ${{ github.head_ref }} --limit 1 --json number,body \ - --jq '.[0].body' > pr_description.md - - - name: Create GitHub Release - env: - GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} - uses: ncipollo/release-action@v1 - with: - tag: ${{ inputs.name }}-${{ env.RELEASE_TIMESTAMP }} - name: "Tracking models `${{ inputs.name }}-${{ env.RELEASE_TIMESTAMP }}`" - bodyFile: pr_description.md - artifacts: artifact/*/*.so,artifact/*/*.html,artifact/*/*.xz - artifactContentType: raw - - diff --git a/.github/workflows/train.yaml b/.github/workflows/train.yaml index 6c5d037..3a509c9 100644 --- a/.github/workflows/train.yaml +++ b/.github/workflows/train.yaml @@ -20,7 +20,9 @@ jobs: name: pp-2016-MU-Sim10b-${{ github.head_ref }} snakemake_dir: pidgan target: cache_container validate_all - additional_config: "" + additional_config: | + storage_folder: ${{ inputs.name }} + additional_profile: "" generated_model_path: /tmp/compiled_pid_model.c secrets: diff --git a/pidgan/config/config.yaml b/pidgan/config/config.yaml index 8d9d906..69d762a 100644 --- a/pidgan/config/config.yaml +++ b/pidgan/config/config.yaml @@ -6,8 +6,8 @@ apptainer_cached_image: /tmp/lb-pidsim-train.sif sample: 2016MU storage_folder: tests temp_dir: /tmp -training_time_limit_seconds: 60 #0 -entries_for_validation: 10000 #00 +training_time_limit_seconds: 600 +entries_for_validation: 1000000 nbconvert_args: - --allow-errors @@ -19,7 +19,6 @@ training_data: - training-data/2016MU-sim10b/LamarrTraining-j109.10.root - training-data/2016MU-sim10b/LamarrTraining-j109.100.root - training-data/2016MU-sim10b/LamarrTraining-j109.101.root -other: - training-data/2016MU-sim10b/LamarrTraining-j109.102.root - training-data/2016MU-sim10b/LamarrTraining-j109.103.root From 199a4398e5708788cc0fa11d44871a1e115828c1 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Sun, 24 Aug 2025 16:56:32 +0000 Subject: [PATCH 08/29] removed file shared.yaml tout-court --- .github/workflows/shared.yaml | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 .github/workflows/shared.yaml diff --git a/.github/workflows/shared.yaml b/.github/workflows/shared.yaml deleted file mode 100644 index e69de29..0000000 From 0dd1ce2497047d52616b2b713509b5670ef44a06 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Sun, 24 Aug 2025 17:04:04 +0000 Subject: [PATCH 09/29] fixed folder name (cannot be taken from job name) --- .github/workflows/train.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/train.yaml b/.github/workflows/train.yaml index 3a509c9..4e2eada 100644 --- a/.github/workflows/train.yaml +++ b/.github/workflows/train.yaml @@ -11,7 +11,7 @@ concurrency: jobs: - trk-2016MagUp-Sim10b: + pid-2016MagUp-Sim10b: uses: LamarrSim/release-models/.github/workflows/release.yaml@main permissions: contents: write @@ -21,7 +21,7 @@ jobs: snakemake_dir: pidgan target: cache_container validate_all additional_config: | - storage_folder: ${{ inputs.name }} + storage_folder: pid-2016MagUp-Sim10b additional_profile: "" generated_model_path: /tmp/compiled_pid_model.c From c351519c40ccc3378e00be9894ae4159c572d22a Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Mon, 25 Aug 2025 05:49:13 +0000 Subject: [PATCH 10/29] compiled model must be named compiled_model.c otherwise gcc fails --- .github/workflows/train.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/train.yaml b/.github/workflows/train.yaml index 4e2eada..e2d6e03 100644 --- a/.github/workflows/train.yaml +++ b/.github/workflows/train.yaml @@ -24,7 +24,7 @@ jobs: storage_folder: pid-2016MagUp-Sim10b additional_profile: "" - generated_model_path: /tmp/compiled_pid_model.c + generated_model_path: /tmp/compiled_model.c secrets: SECRETS_YAML: ${{ secrets.STORAGE_SECRETS }} From 8e0cc5c3607482ca5365fa9c96dbc4308e73d834 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Mon, 25 Aug 2025 06:28:08 +0000 Subject: [PATCH 11/29] cleaned-up (commenting for now) parts moved to scikinC --- pidgan/workflow/notebooks/Deploy.ipynb | 134 ++++-------------- pidgan/workflow/notebooks/deploy_utils.py | 24 ++-- .../workflow/notebooks/preprocessing_utils.py | 5 +- 3 files changed, 42 insertions(+), 121 deletions(-) diff --git a/pidgan/workflow/notebooks/Deploy.ipynb b/pidgan/workflow/notebooks/Deploy.ipynb index 9f5f8ca..5c87f26 100644 --- a/pidgan/workflow/notebooks/Deploy.ipynb +++ b/pidgan/workflow/notebooks/Deploy.ipynb @@ -10,12 +10,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "2025-08-24 15:11:23.691898: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:479] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2025-08-24 15:11:23.895605: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:10575] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2025-08-24 15:11:23.897772: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1442] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "2025-08-24 15:11:24.288717: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "2025-08-25 06:17:44.244658: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:479] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2025-08-25 06:17:44.458658: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:10575] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2025-08-25 06:17:44.461189: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1442] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2025-08-25 06:17:44.867893: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", - "2025-08-24 15:11:25.945021: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + "2025-08-25 06:17:46.699782: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" ] } ], @@ -535,16 +535,16 @@ "name": "stderr", "output_type": "stream", "text": [ - "2025-08-24 15:11:30.204452: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2025-08-24 15:11:30.675436: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2025-08-24 15:11:30.677146: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2025-08-24 15:11:30.683408: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2025-08-24 15:11:30.684807: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2025-08-24 15:11:30.686230: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2025-08-24 15:11:30.818757: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2025-08-24 15:11:30.820277: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2025-08-24 15:11:30.821709: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2025-08-24 15:11:30.824567: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1928] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 8098 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe MIG 1g.10gb, pci bus id: 0000:00:05.0, compute capability: 8.0\n", + "2025-08-25 06:17:51.120927: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2025-08-25 06:17:51.695901: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2025-08-25 06:17:51.697462: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2025-08-25 06:17:51.704496: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2025-08-25 06:17:51.705928: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2025-08-25 06:17:51.707326: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2025-08-25 06:17:51.833231: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2025-08-25 06:17:51.834709: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2025-08-25 06:17:51.836092: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2025-08-25 06:17:51.838776: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1928] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 8098 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe MIG 1g.10gb, pci bus id: 0000:00:05.0, compute capability: 8.0\n", "/usr/local/lib/python3.12/site-packages/keras/src/layers/core/dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n", " super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n" ] @@ -565,11 +565,11 @@ "Received: inputs=('Tensor(shape=(1, 4))',)\n", " warnings.warn(msg)\n", "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", - "I0000 00:00:1756048292.764403 280664 service.cc:145] XLA service 0x7f1544003c50 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n", - "I0000 00:00:1756048292.764458 280664 service.cc:153] StreamExecutor device (0): NVIDIA A100 80GB PCIe MIG 1g.10gb, Compute Capability 8.0\n", - "2025-08-24 15:11:32.784847: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:268] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n", - "2025-08-24 15:11:32.871452: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:465] Loaded cuDNN version 8907\n", - "I0000 00:00:1756048292.970247 280664 device_compiler.h:188] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n" + "I0000 00:00:1756102673.861655 330562 service.cc:145] XLA service 0x7f55d8003500 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n", + "I0000 00:00:1756102673.861734 330562 service.cc:153] StreamExecutor device (0): NVIDIA A100 80GB PCIe MIG 1g.10gb, Compute Capability 8.0\n", + "2025-08-25 06:17:53.885603: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:268] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n", + "2025-08-25 06:17:53.987500: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:465] Loaded cuDNN version 8907\n", + "I0000 00:00:1756102674.102647 330562 device_compiler.h:188] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n" ] }, { @@ -652,11 +652,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "WARNING:tensorflow:5 out of the last 5 calls to .one_step_on_data_distributed at 0x7f16c87bf880> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n", + "WARNING:tensorflow:5 out of the last 5 calls to .one_step_on_data_distributed at 0x7f5761b6b880> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n", "Processing RICH_PION...\n", "Loading model from '/tmp/s3models/lamarr-train/models/Rich/pion'. Preprocessing: 👌.Postprocessing: 👌.\n", "Check on the number of weights: ✅! Original model: 157956. Collapsed model: 157956. \n", - "WARNING:tensorflow:6 out of the last 6 calls to .one_step_on_data_distributed at 0x7f16c83ab9c0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" + "WARNING:tensorflow:6 out of the last 6 calls to .one_step_on_data_distributed at 0x7f57617579c0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" ] }, { @@ -788,8 +788,6 @@ "output_type": "stream", "text": [ "Processing GLOBALPID_IM_MUON...\n", - "Injecting func_inC in FunctionTransformer\n", - "Injecting inverse_func_inC in FunctionTransformer\n", "Loading model from '/tmp/s3models/lamarr-train/models/GlobalPID-im/muon'. Preprocessing: 👌.Postprocessing: 👌.\n", "Check on the number of weights: ✅! Original model: 76809. Collapsed model: 76809. \n" ] @@ -809,8 +807,6 @@ "output_type": "stream", "text": [ "Processing GLOBALPID_IM_PION...\n", - "Injecting func_inC in FunctionTransformer\n", - "Injecting inverse_func_inC in FunctionTransformer\n", "Loading model from '/tmp/s3models/lamarr-train/models/GlobalPID-im/pion'. Preprocessing: 👌.Postprocessing: 👌.\n", "Check on the number of weights: ✅! Original model: 76809. Collapsed model: 76809. \n" ] @@ -830,8 +826,6 @@ "output_type": "stream", "text": [ "Processing GLOBALPID_IM_KAON...\n", - "Injecting func_inC in FunctionTransformer\n", - "Injecting inverse_func_inC in FunctionTransformer\n", "Loading model from '/tmp/s3models/lamarr-train/models/GlobalPID-im/kaon'. Preprocessing: 👌.Postprocessing: 👌.\n", "Check on the number of weights: ✅! Original model: 76809. Collapsed model: 76809. \n" ] @@ -851,8 +845,6 @@ "output_type": "stream", "text": [ "Processing GLOBALPID_IM_PROTON...\n", - "Injecting func_inC in FunctionTransformer\n", - "Injecting inverse_func_inC in FunctionTransformer\n", "Loading model from '/tmp/s3models/lamarr-train/models/GlobalPID-im/proton'. Preprocessing: 👌.Postprocessing: 👌.\n", "Check on the number of weights: ✅! Original model: 76809. Collapsed model: 76809. \n" ] @@ -872,8 +864,6 @@ "output_type": "stream", "text": [ "Processing GLOBALPID_NM_MUON...\n", - "Injecting func_inC in FunctionTransformer\n", - "Injecting inverse_func_inC in FunctionTransformer\n", "Loading model from '/tmp/s3models/lamarr-train/models/GlobalPID-nm/muon'. Preprocessing: 👌.Postprocessing: 👌.\n", "Check on the number of weights: ✅! Original model: 76424. Collapsed model: 76424. \n" ] @@ -893,8 +883,6 @@ "output_type": "stream", "text": [ "Processing GLOBALPID_NM_PION...\n", - "Injecting func_inC in FunctionTransformer\n", - "Injecting inverse_func_inC in FunctionTransformer\n", "Loading model from '/tmp/s3models/lamarr-train/models/GlobalPID-nm/pion'. Preprocessing: 👌.Postprocessing: 👌.\n", "Check on the number of weights: ✅! Original model: 76424. Collapsed model: 76424. \n" ] @@ -914,8 +902,6 @@ "output_type": "stream", "text": [ "Processing GLOBALPID_NM_KAON...\n", - "Injecting func_inC in FunctionTransformer\n", - "Injecting inverse_func_inC in FunctionTransformer\n", "Loading model from '/tmp/s3models/lamarr-train/models/GlobalPID-nm/kaon'. Preprocessing: 👌.Postprocessing: 👌.\n", "Check on the number of weights: ✅! Original model: 76424. Collapsed model: 76424. \n" ] @@ -935,8 +921,6 @@ "output_type": "stream", "text": [ "Processing GLOBALPID_NM_PROTON...\n", - "Injecting func_inC in FunctionTransformer\n", - "Injecting inverse_func_inC in FunctionTransformer\n", "Loading model from '/tmp/s3models/lamarr-train/models/GlobalPID-nm/proton'. Preprocessing: 👌.Postprocessing: 👌.\n", "Check on the number of weights: ✅! Original model: 76424. Collapsed model: 76424. \n" ] @@ -1055,7 +1039,7 @@ "Compilation command:\n", " gcc \\\n", " /tmp/exported/generated.c \\\n", - " -o/tmp/exported/generated1756048304.0314913.so \\\n", + " -o/tmp/exported/generated1756102685.532006.so \\\n", " -lm \\\n", " --shared \\\n", " -fPIC \\\n", @@ -1122,7 +1106,7 @@ "\n", "## Stats\n", " * Generated C file size: `71.1 MiB`\n", - " * MD5: `05692bf6757737adfb3ea1ef51a26f00`\n", + " * MD5: `90047af4f4d4bf02bf7ec8bb62931686`\n", "\n", "\n", "## Compiler command\n", @@ -1130,7 +1114,7 @@ "``` bash \n", "gcc \\\n", " /tmp/exported/generated.c \\\n", - " -o/tmp/exported/generated1756048304.0314913.so \\\n", + " -o/tmp/exported/generated1756102685.532006.so \\\n", " -lm \\\n", " --shared \\\n", " -fPIC \\\n", @@ -1145,73 +1129,9 @@ "\n", "---\n", "``` c \n", - "/tmp/exported/generated.c:1:9: note: ‘#pragma message: Using Lamarr PID models as exported on 2025-08-24 15:11:40.225288’\n", - " 1 | #pragma message \"Using Lamarr PID models as exported on 2025-08-24 15:11:40.225288\"\n", + "/tmp/exported/generated.c:1:9: note: ‘#pragma message: Using Lamarr PID models as exported on 2025-08-25 06:18:01.608275’\n", + " 1 | #pragma message \"Using Lamarr PID models as exported on 2025-08-25 06:18:01.608275\"\n", " | ^~~~~~~\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDmu_muon_tY_probs’:\n", - "/tmp/exported/generated.c:6924:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - " 6924 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDmu_muon_tY_probs_inverse’:\n", - "/tmp/exported/generated.c:6936:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - " 6936 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDmu_pion_tY_probs’:\n", - "/tmp/exported/generated.c:7485:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - " 7485 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDmu_pion_tY_probs_inverse’:\n", - "/tmp/exported/generated.c:7497:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - " 7497 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDmu_kaon_tY_probs’:\n", - "/tmp/exported/generated.c:8046:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - " 8046 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDmu_kaon_tY_probs_inverse’:\n", - "/tmp/exported/generated.c:8058:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - " 8058 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDmu_proton_tY_probs’:\n", - "/tmp/exported/generated.c:8607:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - " 8607 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDmu_proton_tY_probs_inverse’:\n", - "/tmp/exported/generated.c:8619:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - " 8619 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDh_muon_tY_probs’:\n", - "/tmp/exported/generated.c:9116:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - " 9116 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDh_muon_tY_probs_inverse’:\n", - "/tmp/exported/generated.c:9128:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - " 9128 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDh_pion_tY_probs’:\n", - "/tmp/exported/generated.c:9621:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - " 9621 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDh_pion_tY_probs_inverse’:\n", - "/tmp/exported/generated.c:9633:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - " 9633 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDh_kaon_tY_probs’:\n", - "/tmp/exported/generated.c:10126:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - "10126 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDh_kaon_tY_probs_inverse’:\n", - "/tmp/exported/generated.c:10138:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - "10138 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDh_proton_tY_probs’:\n", - "/tmp/exported/generated.c:10631:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - "10631 | int c;\n", - " | ^\n", - "/tmp/exported/generated.c: In function ‘colcnv_GlobalPIDh_proton_tY_probs_inverse’:\n", - "/tmp/exported/generated.c:10643:11: warning: unused variable ‘c’ [-Wunused-variable]\n", - "10643 | int c;\n", - " | ^\n", " \n", "```\n", "---\n", diff --git a/pidgan/workflow/notebooks/deploy_utils.py b/pidgan/workflow/notebooks/deploy_utils.py index 6130686..287e323 100644 --- a/pidgan/workflow/notebooks/deploy_utils.py +++ b/pidgan/workflow/notebooks/deploy_utils.py @@ -17,17 +17,17 @@ class hacks: - @staticmethod - def _restore_c_impl(transformer): - if isinstance(transformer, ColumnTransformer): - return [hacks._restore_c_impl(t) for _, t, _ in transformer.transformers_] + # @staticmethod + # def _restore_c_impl(transformer): + # if isinstance(transformer, ColumnTransformer): + # return [hacks._restore_c_impl(t) for _, t, _ in transformer.transformers_] - if isinstance(transformer, FunctionTransformer) and hasattr(transformer.func, 'inC'): - print (f"Injecting func_inC in {transformer.__class__.__name__}") - transformer.func_inC = transformer.func.inC - if isinstance(transformer, FunctionTransformer) and hasattr(transformer.inverse_func, 'inC'): - print (f"Injecting inverse_func_inC in {transformer.__class__.__name__}") - transformer.inverse_func_inC = transformer.inverse_func.inC + # if isinstance(transformer, FunctionTransformer) and hasattr(transformer.func, 'inC'): + # print (f"Injecting func_inC in {transformer.__class__.__name__}") + # transformer.func_inC = transformer.func.inC + # if isinstance(transformer, FunctionTransformer) and hasattr(transformer.inverse_func, 'inC'): + # print (f"Injecting inverse_func_inC in {transformer.__class__.__name__}") + # transformer.inverse_func_inC = transformer.inverse_func.inC @staticmethod @@ -122,10 +122,10 @@ def from_saved_model_pb(filename): tX = tY = None if os.path.exists(os.path.join(model_dir, "tX.pkl")): tX = pickle.load(open(os.path.join(model_dir, "tX.pkl"), 'rb')) - hacks._restore_c_impl(tX) + # hacks._restore_c_impl(tX) if os.path.exists(os.path.join(model_dir, "tY.pkl")): tY = pickle.load(open(os.path.join(model_dir, "tY.pkl"), 'rb')) - hacks._restore_c_impl(tY) + # hacks._restore_c_impl(tY) diff --git a/pidgan/workflow/notebooks/preprocessing_utils.py b/pidgan/workflow/notebooks/preprocessing_utils.py index d5753f8..00ebc89 100644 --- a/pidgan/workflow/notebooks/preprocessing_utils.py +++ b/pidgan/workflow/notebooks/preprocessing_utils.py @@ -6,6 +6,7 @@ from feather_io import FeatherWriter, FeatherReader from sklearn.preprocessing import FunctionTransformer import numpy as np +from scikinC.decorators import inline_c def store_as_pickle(obj, path_in_env: str, default_path: str): """ @@ -144,11 +145,11 @@ def decorator(f): return f return decorator -@c_impl("log(1e-7 + ({x}/(1e-7 + (1 - {x}))))") +@inline_c("log(1e-7 + ({x}/(1e-7 + (1 - {x}))))") def ProbNNTransformer_fwd(X): return np.log(1e-7 + X/(1e-7 + (1 - X))) -@c_impl("1 / (1 + exp(-{x}))") +@inline_c("1 / (1 + exp(-{x}))") def ProbNNTransformer_bwd(Y): return 1 / (1 + np.exp(-Y)) From 242a886fa1469ce87c8de9554d34e712cc005628 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Mon, 25 Aug 2025 06:28:26 +0000 Subject: [PATCH 12/29] fixed SHARED_OBJECT env variable name --- pidgan/workflow/Snakefile | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/pidgan/workflow/Snakefile b/pidgan/workflow/Snakefile index ea89a9e..b2d362b 100644 --- a/pidgan/workflow/Snakefile +++ b/pidgan/workflow/Snakefile @@ -63,7 +63,7 @@ rule preprocessing: report=report( smkstore("{model}-{particle}-preprocessing.html", 's3reports'), category="Preprocessing", - labels=dict(model="{model}", particle="{particle}") + labels=dict(model="{model}", particle="{particle}", type='html') ) log: smkstore("{model}-{particle}-preprocessing.html", 's3reports') @@ -124,7 +124,7 @@ rule train: history_csv=report( smkstore("history/generator-{model}-{particle}.csv", 's3reports'), category="Training", - labels=dict(model="{model}", particle="{particle}") + labels=dict(model="{model}", particle="{particle}", type='csv') ), output_validation_set=smkstore("ready2validate/{model}-{particle}.npz", 's3reports'), @@ -133,7 +133,7 @@ rule train: report=report( smkstore("{model}-{particle}-train.html", 's3reports'), category="Preprocessing", - labels=dict(model="{model}", particle="{particle}") + labels=dict(model="{model}", particle="{particle}", type='html') ) log: smkstore("{model}-{particle}-train.html", 's3reports') @@ -197,12 +197,12 @@ rule deploy: output: hook=touch("/tmp/deploy.touch"), - generated_c_file="/tmp/compiled_pid_model.c", + generated_c_file="/tmp/compiled_model.c", generated_library=smkstore("pid_compiled_model/generated.so", 's3models'), report=report( smkstore("deploy.html", 's3reports'), category="Deploy", - labels=dict(model="ALL", particle="ALL") + labels=dict(model="ALL", particle="ALL", type='html') ) params: @@ -247,8 +247,8 @@ rule validate: report=report( smkstore("validate-{particle}.html", 's3reports'), - category="Preprocessing", - labels=dict(model="ALL", particle="{particle}") + category="Validation", + labels=dict(model="ALL", particle="{particle}", type="html") ) log: smkstore("validate-{particle}.html", 's3reports') @@ -271,7 +271,7 @@ rule validate: """ INPUT_FILES='{params.data_files}' \ PARTICLE='{wildcards.particle}' \ - GENERATED_LIBRARY='{input.generated_library}' \ + SHARED_OBJECT='{input.generated_library}' \ MAX_ENTRIES='{params.max_entries}' \ SAMPLE='{params.sample}' \ jupyter nbconvert --to html --execute \ From f024e21a1641c1b73c6ce1ef2d79c384b42562aa Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Mon, 25 Aug 2025 06:28:50 +0000 Subject: [PATCH 13/29] shortened training for gha testing purpose --- pidgan/config/config.yaml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pidgan/config/config.yaml b/pidgan/config/config.yaml index 69d762a..8d9d906 100644 --- a/pidgan/config/config.yaml +++ b/pidgan/config/config.yaml @@ -6,8 +6,8 @@ apptainer_cached_image: /tmp/lb-pidsim-train.sif sample: 2016MU storage_folder: tests temp_dir: /tmp -training_time_limit_seconds: 600 -entries_for_validation: 1000000 +training_time_limit_seconds: 60 #0 +entries_for_validation: 10000 #00 nbconvert_args: - --allow-errors @@ -19,6 +19,7 @@ training_data: - training-data/2016MU-sim10b/LamarrTraining-j109.10.root - training-data/2016MU-sim10b/LamarrTraining-j109.100.root - training-data/2016MU-sim10b/LamarrTraining-j109.101.root +other: - training-data/2016MU-sim10b/LamarrTraining-j109.102.root - training-data/2016MU-sim10b/LamarrTraining-j109.103.root From fdd53b50a65c52d98401bb27f696c0c6c557a722 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Mon, 25 Aug 2025 11:01:27 +0000 Subject: [PATCH 14/29] attempt parallel processing of training --- .github/workflows/train.yaml | 4 +++- pidgan/workflow/Snakefile | 8 ++++---- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/.github/workflows/train.yaml b/.github/workflows/train.yaml index e2d6e03..9eebb21 100644 --- a/.github/workflows/train.yaml +++ b/.github/workflows/train.yaml @@ -23,7 +23,9 @@ jobs: additional_config: | storage_folder: pid-2016MagUp-Sim10b - additional_profile: "" + additional_profile: | + jobs: 2 + generated_model_path: /tmp/compiled_model.c secrets: SECRETS_YAML: ${{ secrets.STORAGE_SECRETS }} diff --git a/pidgan/workflow/Snakefile b/pidgan/workflow/Snakefile index b2d362b..3417bb1 100644 --- a/pidgan/workflow/Snakefile +++ b/pidgan/workflow/Snakefile @@ -142,8 +142,8 @@ rule train: resources: - cpu=8, - mem_mb=32000, + cpu=4, + mem_mb=15000, gpu=1 params: @@ -263,8 +263,8 @@ rule validate: max_entries=config['entries_for_validation'], resources: - cpu=8, - mem_mb=32000, + cpu=4, + mem_mb=15000, gpu=0 shell: From 7ed055ac7b40042ffe5883619bbbedb3cbbb95fd Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Mon, 25 Aug 2025 11:19:50 +0000 Subject: [PATCH 15/29] fixed report for training, fixed validation --- pidgan/workflow/Snakefile | 2 +- pidgan/workflow/notebooks/validate.ipynb | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/pidgan/workflow/Snakefile b/pidgan/workflow/Snakefile index 3417bb1..470a692 100644 --- a/pidgan/workflow/Snakefile +++ b/pidgan/workflow/Snakefile @@ -132,7 +132,7 @@ rule train: report=report( smkstore("{model}-{particle}-train.html", 's3reports'), - category="Preprocessing", + category="Training", labels=dict(model="{model}", particle="{particle}", type='html') ) diff --git a/pidgan/workflow/notebooks/validate.ipynb b/pidgan/workflow/notebooks/validate.ipynb index ed6c06c..0d5809d 100644 --- a/pidgan/workflow/notebooks/validate.ipynb +++ b/pidgan/workflow/notebooks/validate.ipynb @@ -47,7 +47,9 @@ "PARTICLE = os.environ.get(\"PARTICLE\", \"muon\")\n", "LOCAL = os.environ.get(\"LOCAL\", \"yes\").lower() in ['y', 'yes', 'true', '1']\n", "SAMPLE = os.environ.get(\"SAMPLE\", \"2016MU\")\n", - "SHARED_OBJECT = os.environ.get(\"SHARED_OBJECT\", sorted(glob(\"/tmp/exported/generated*.so\"))[-1])\n", + "SHARED_OBJECT = os.environ.get(\"SHARED_OBJECT\")\n", + "if SHARED_OBJECT is None and len(glob(\"/tmp/exported/generated*.so\")) > 1:\n", + " SHARED_OBJECT = sorted(glob(\"/tmp/exported/generated*.so\"))[-1])\n", "MAX_ENTRIES = int(os.environ.get(\"MAX_ENTRIES\", \"10000\"))\n", "\n", "Markdown(f\"\"\"\n", From 52cd87b57b0f9c713aefab555fdfe997c6aedd1c Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Mon, 25 Aug 2025 11:22:03 +0000 Subject: [PATCH 16/29] rolled-back to single-job pipeline for comparison --- .github/workflows/train.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/train.yaml b/.github/workflows/train.yaml index 9eebb21..33cc6b2 100644 --- a/.github/workflows/train.yaml +++ b/.github/workflows/train.yaml @@ -24,7 +24,7 @@ jobs: storage_folder: pid-2016MagUp-Sim10b additional_profile: | - jobs: 2 + jobs: 1 generated_model_path: /tmp/compiled_model.c secrets: From 2fb8e67434f0e0773a3c3acc47a9c75ce4090a4f Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Mon, 25 Aug 2025 13:11:40 +0000 Subject: [PATCH 17/29] try to go parallel --- .github/workflows/train.yaml | 2 +- pidgan/workflow/notebooks/validate.ipynb | 9 +++++---- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/.github/workflows/train.yaml b/.github/workflows/train.yaml index 33cc6b2..9eebb21 100644 --- a/.github/workflows/train.yaml +++ b/.github/workflows/train.yaml @@ -24,7 +24,7 @@ jobs: storage_folder: pid-2016MagUp-Sim10b additional_profile: | - jobs: 1 + jobs: 2 generated_model_path: /tmp/compiled_model.c secrets: diff --git a/pidgan/workflow/notebooks/validate.ipynb b/pidgan/workflow/notebooks/validate.ipynb index 0d5809d..740f90d 100644 --- a/pidgan/workflow/notebooks/validate.ipynb +++ b/pidgan/workflow/notebooks/validate.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "id": "3a7d3458-49f0-4863-a031-a214dfc1f32e", "metadata": {}, "outputs": [ @@ -21,14 +21,14 @@ " * PARTICLE: `muon`\n", " * LOCAL: `True`\n", " * SAMPLE: `2016MU`\n", - " * SHARED_OBJECT: `/tmp/exported/generated1756048304.0314913.so`\n", + " * SHARED_OBJECT: `/tmp/exported/generated1756102685.532006.so`\n", " * MAX_ENTRIES: `10000`\n" ], "text/plain": [ "" ] }, - "execution_count": 1, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -49,7 +49,8 @@ "SAMPLE = os.environ.get(\"SAMPLE\", \"2016MU\")\n", "SHARED_OBJECT = os.environ.get(\"SHARED_OBJECT\")\n", "if SHARED_OBJECT is None and len(glob(\"/tmp/exported/generated*.so\")) > 1:\n", - " SHARED_OBJECT = sorted(glob(\"/tmp/exported/generated*.so\"))[-1])\n", + " SHARED_OBJECT = sorted(glob(\"/tmp/exported/generated*.so\"))[-1]\n", + " \n", "MAX_ENTRIES = int(os.environ.get(\"MAX_ENTRIES\", \"10000\"))\n", "\n", "Markdown(f\"\"\"\n", From 586bd05dd0c009c3d0cedd23ed700a1520e5cae6 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Mon, 25 Aug 2025 16:13:04 +0000 Subject: [PATCH 18/29] training two jobs in parallel takes twice the time --- .github/workflows/train.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/train.yaml b/.github/workflows/train.yaml index 9eebb21..33cc6b2 100644 --- a/.github/workflows/train.yaml +++ b/.github/workflows/train.yaml @@ -24,7 +24,7 @@ jobs: storage_folder: pid-2016MagUp-Sim10b additional_profile: | - jobs: 2 + jobs: 1 generated_model_path: /tmp/compiled_model.c secrets: From d1bfb7494dbe42370f5909cbacf48f8e3dfdd578 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Mon, 25 Aug 2025 16:14:08 +0000 Subject: [PATCH 19/29] test zip report --- .github/workflows/train.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/train.yaml b/.github/workflows/train.yaml index 33cc6b2..371ca1c 100644 --- a/.github/workflows/train.yaml +++ b/.github/workflows/train.yaml @@ -19,7 +19,7 @@ jobs: with: name: pp-2016-MU-Sim10b-${{ github.head_ref }} snakemake_dir: pidgan - target: cache_container validate_all + target: /tmp/train-GlobalPID-im-kaon.touch #cache_container validate_all additional_config: | storage_folder: pid-2016MagUp-Sim10b From a8fd8f43187e091500646b31a69180be772391bb Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Mon, 25 Aug 2025 16:29:33 +0000 Subject: [PATCH 20/29] test at full steam --- .github/workflows/train.yaml | 2 +- pidgan/config/config.yaml | 5 ++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/.github/workflows/train.yaml b/.github/workflows/train.yaml index 371ca1c..33cc6b2 100644 --- a/.github/workflows/train.yaml +++ b/.github/workflows/train.yaml @@ -19,7 +19,7 @@ jobs: with: name: pp-2016-MU-Sim10b-${{ github.head_ref }} snakemake_dir: pidgan - target: /tmp/train-GlobalPID-im-kaon.touch #cache_container validate_all + target: cache_container validate_all additional_config: | storage_folder: pid-2016MagUp-Sim10b diff --git a/pidgan/config/config.yaml b/pidgan/config/config.yaml index 8d9d906..356356f 100644 --- a/pidgan/config/config.yaml +++ b/pidgan/config/config.yaml @@ -6,8 +6,8 @@ apptainer_cached_image: /tmp/lb-pidsim-train.sif sample: 2016MU storage_folder: tests temp_dir: /tmp -training_time_limit_seconds: 60 #0 -entries_for_validation: 10000 #00 +training_time_limit_seconds: 1000 +entries_for_validation: 1000000 nbconvert_args: - --allow-errors @@ -19,7 +19,6 @@ training_data: - training-data/2016MU-sim10b/LamarrTraining-j109.10.root - training-data/2016MU-sim10b/LamarrTraining-j109.100.root - training-data/2016MU-sim10b/LamarrTraining-j109.101.root -other: - training-data/2016MU-sim10b/LamarrTraining-j109.102.root - training-data/2016MU-sim10b/LamarrTraining-j109.103.root From 9bce8d2f1f689263d9295a83c3f62a1a5ea10e19 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Mon, 25 Aug 2025 16:48:02 +0000 Subject: [PATCH 21/29] a super-short run just creating the reports in zip format rather than html --- pidgan/config/config.yaml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pidgan/config/config.yaml b/pidgan/config/config.yaml index 356356f..39a0baa 100644 --- a/pidgan/config/config.yaml +++ b/pidgan/config/config.yaml @@ -6,8 +6,8 @@ apptainer_cached_image: /tmp/lb-pidsim-train.sif sample: 2016MU storage_folder: tests temp_dir: /tmp -training_time_limit_seconds: 1000 -entries_for_validation: 1000000 +training_time_limit_seconds: 10 #00 +entries_for_validation: 10000 #00 nbconvert_args: - --allow-errors @@ -19,6 +19,7 @@ training_data: - training-data/2016MU-sim10b/LamarrTraining-j109.10.root - training-data/2016MU-sim10b/LamarrTraining-j109.100.root - training-data/2016MU-sim10b/LamarrTraining-j109.101.root +other: - training-data/2016MU-sim10b/LamarrTraining-j109.102.root - training-data/2016MU-sim10b/LamarrTraining-j109.103.root From 8acbd22563eb7286033df69b32510730539879a5 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Mon, 25 Aug 2025 17:55:16 +0000 Subject: [PATCH 22/29] full prod --- pidgan/config/config.yaml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/pidgan/config/config.yaml b/pidgan/config/config.yaml index 39a0baa..356356f 100644 --- a/pidgan/config/config.yaml +++ b/pidgan/config/config.yaml @@ -6,8 +6,8 @@ apptainer_cached_image: /tmp/lb-pidsim-train.sif sample: 2016MU storage_folder: tests temp_dir: /tmp -training_time_limit_seconds: 10 #00 -entries_for_validation: 10000 #00 +training_time_limit_seconds: 1000 +entries_for_validation: 1000000 nbconvert_args: - --allow-errors @@ -19,7 +19,6 @@ training_data: - training-data/2016MU-sim10b/LamarrTraining-j109.10.root - training-data/2016MU-sim10b/LamarrTraining-j109.100.root - training-data/2016MU-sim10b/LamarrTraining-j109.101.root -other: - training-data/2016MU-sim10b/LamarrTraining-j109.102.root - training-data/2016MU-sim10b/LamarrTraining-j109.103.root From 274422f6b0830b10f144d446f92d8b213aba9e03 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Tue, 26 Aug 2025 06:08:34 +0000 Subject: [PATCH 23/29] quick test on releasing --- .github/workflows/train.yaml | 2 +- pidgan/config/config.yaml | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/.github/workflows/train.yaml b/.github/workflows/train.yaml index 33cc6b2..c0ba2c7 100644 --- a/.github/workflows/train.yaml +++ b/.github/workflows/train.yaml @@ -19,7 +19,7 @@ jobs: with: name: pp-2016-MU-Sim10b-${{ github.head_ref }} snakemake_dir: pidgan - target: cache_container validate_all + target: deploy # cache_container validate_all additional_config: | storage_folder: pid-2016MagUp-Sim10b diff --git a/pidgan/config/config.yaml b/pidgan/config/config.yaml index 356356f..374bff8 100644 --- a/pidgan/config/config.yaml +++ b/pidgan/config/config.yaml @@ -6,8 +6,8 @@ apptainer_cached_image: /tmp/lb-pidsim-train.sif sample: 2016MU storage_folder: tests temp_dir: /tmp -training_time_limit_seconds: 1000 -entries_for_validation: 1000000 +training_time_limit_seconds: 10 #00 +entries_for_validation: 10000 #00 nbconvert_args: - --allow-errors @@ -17,6 +17,7 @@ training_data: - training-data/2016MU-sim10b/LamarrTraining-j109.0.root - training-data/2016MU-sim10b/LamarrTraining-j109.1.root - training-data/2016MU-sim10b/LamarrTraining-j109.10.root +other: - training-data/2016MU-sim10b/LamarrTraining-j109.100.root - training-data/2016MU-sim10b/LamarrTraining-j109.101.root From 17ab5b66ffff31d62291c7bc75e72c16c3b6d78f Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Tue, 26 Aug 2025 06:58:08 +0000 Subject: [PATCH 24/29] full prod --- pidgan/config/config.yaml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/pidgan/config/config.yaml b/pidgan/config/config.yaml index 374bff8..356356f 100644 --- a/pidgan/config/config.yaml +++ b/pidgan/config/config.yaml @@ -6,8 +6,8 @@ apptainer_cached_image: /tmp/lb-pidsim-train.sif sample: 2016MU storage_folder: tests temp_dir: /tmp -training_time_limit_seconds: 10 #00 -entries_for_validation: 10000 #00 +training_time_limit_seconds: 1000 +entries_for_validation: 1000000 nbconvert_args: - --allow-errors @@ -17,7 +17,6 @@ training_data: - training-data/2016MU-sim10b/LamarrTraining-j109.0.root - training-data/2016MU-sim10b/LamarrTraining-j109.1.root - training-data/2016MU-sim10b/LamarrTraining-j109.10.root -other: - training-data/2016MU-sim10b/LamarrTraining-j109.100.root - training-data/2016MU-sim10b/LamarrTraining-j109.101.root From 061c63dc4cfdae82ffea8c35fa7d57697419a92e Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Tue, 26 Aug 2025 12:41:14 +0000 Subject: [PATCH 25/29] added custom model prefix (was trk) and re-added validation --- .github/workflows/train.yaml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/train.yaml b/.github/workflows/train.yaml index c0ba2c7..a43e5a1 100644 --- a/.github/workflows/train.yaml +++ b/.github/workflows/train.yaml @@ -19,7 +19,8 @@ jobs: with: name: pp-2016-MU-Sim10b-${{ github.head_ref }} snakemake_dir: pidgan - target: deploy # cache_container validate_all + target: cache_container validate_all + model_prefix: pid additional_config: | storage_folder: pid-2016MagUp-Sim10b From 280dcbe328ca7153f847ccafd6c3a98dc25a3761 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Tue, 26 Aug 2025 20:28:00 +0000 Subject: [PATCH 26/29] reduced training time --- pidgan/config/config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pidgan/config/config.yaml b/pidgan/config/config.yaml index 356356f..69d762a 100644 --- a/pidgan/config/config.yaml +++ b/pidgan/config/config.yaml @@ -6,7 +6,7 @@ apptainer_cached_image: /tmp/lb-pidsim-train.sif sample: 2016MU storage_folder: tests temp_dir: /tmp -training_time_limit_seconds: 1000 +training_time_limit_seconds: 600 entries_for_validation: 1000000 nbconvert_args: From 42184073a303ab6cc78c2403a95e32106f06c78b Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Wed, 27 Aug 2025 06:55:51 +0000 Subject: [PATCH 27/29] restored quantile transformer for rich preprocessing --- .../notebooks/Rich-preprocessing.ipynb | 289 +++--------------- 1 file changed, 43 insertions(+), 246 deletions(-) diff --git a/pidgan/workflow/notebooks/Rich-preprocessing.ipynb b/pidgan/workflow/notebooks/Rich-preprocessing.ipynb index ec981df..ff50513 100644 --- a/pidgan/workflow/notebooks/Rich-preprocessing.ipynb +++ b/pidgan/workflow/notebooks/Rich-preprocessing.ipynb @@ -16,6 +16,7 @@ "data": { "text/markdown": [ "\n", + " * PARTICLE: `muon`\n", " * LOCAL: `True`\n", " * SAMPLE: `2016MU`\n" ], @@ -84,7 +85,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Found 3 data files\n" + "Found 1 data files\n" ] } ], @@ -113,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -139,9 +140,29 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "IsADirectoryError", + "evalue": "[Errno 21] Is a directory: '/home/private/lamarr/lb-pidsim-train/pidgan/workflow/notebooks'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mIsADirectoryError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mfunctools\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m partial\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m opened_files = [\u001b[43muproot\u001b[49m\u001b[43m.\u001b[49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m f \u001b[38;5;129;01min\u001b[39;00m file_list]\n\u001b[32m 5\u001b[39m sim = (\n\u001b[32m 6\u001b[39m ddf.from_map(\n\u001b[32m 7\u001b[39m \u001b[38;5;28;01mlambda\u001b[39;00m f: pd.DataFrame(f[\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mPidTupler/pid_\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mPARTICLE\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m].arrays(library=\u001b[33m'\u001b[39m\u001b[33mnp\u001b[39m\u001b[33m'\u001b[39m)),\n\u001b[32m 8\u001b[39m opened_files,\n\u001b[32m 9\u001b[39m ).query(cuts)\n\u001b[32m 10\u001b[39m )\n", + "\u001b[36mFile \u001b[39m\u001b[32m/usr/local/lib/python3.12/site-packages/uproot/reading.py:142\u001b[39m, in \u001b[36mopen\u001b[39m\u001b[34m(path, object_cache, array_cache, custom_classes, decompression_executor, interpretation_executor, **options)\u001b[39m\n\u001b[32m 133\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(file_path, \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\n\u001b[32m 134\u001b[39m \u001b[38;5;28mhasattr\u001b[39m(file_path, \u001b[33m\"\u001b[39m\u001b[33mread\u001b[39m\u001b[33m\"\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(file_path, \u001b[33m\"\u001b[39m\u001b[33mseek\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 135\u001b[39m ):\n\u001b[32m 136\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m 137\u001b[39m \u001b[33m\"\u001b[39m\u001b[33m'\u001b[39m\u001b[33mpath\u001b[39m\u001b[33m'\u001b[39m\u001b[33m must be a string, pathlib.Path, an object with \u001b[39m\u001b[33m'\u001b[39m\u001b[33mread\u001b[39m\u001b[33m'\u001b[39m\u001b[33m and \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 138\u001b[39m \u001b[33m\"\u001b[39m\u001b[33m'\u001b[39m\u001b[33mseek\u001b[39m\u001b[33m'\u001b[39m\u001b[33m methods, or a length-1 dict of \u001b[39m\u001b[33m{\u001b[39m\u001b[33mfile_path: object_path}, \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 139\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mnot \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mpath\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[33m\"\u001b[39m\n\u001b[32m 140\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m142\u001b[39m file = \u001b[43mReadOnlyFile\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 143\u001b[39m \u001b[43m \u001b[49m\u001b[43mfile_path\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 144\u001b[39m \u001b[43m \u001b[49m\u001b[43mobject_cache\u001b[49m\u001b[43m=\u001b[49m\u001b[43mobject_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 145\u001b[39m \u001b[43m \u001b[49m\u001b[43marray_cache\u001b[49m\u001b[43m=\u001b[49m\u001b[43marray_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 146\u001b[39m \u001b[43m \u001b[49m\u001b[43mcustom_classes\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcustom_classes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 147\u001b[39m \u001b[43m \u001b[49m\u001b[43mdecompression_executor\u001b[49m\u001b[43m=\u001b[49m\u001b[43mdecompression_executor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 148\u001b[39m \u001b[43m \u001b[49m\u001b[43minterpretation_executor\u001b[49m\u001b[43m=\u001b[49m\u001b[43minterpretation_executor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 149\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43moptions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 150\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 152\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m object_path \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 153\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m file.root_directory\n", + "\u001b[36mFile \u001b[39m\u001b[32m/usr/local/lib/python3.12/site-packages/uproot/reading.py:573\u001b[39m, in \u001b[36mReadOnlyFile.__init__\u001b[39m\u001b[34m(self, file_path, object_cache, array_cache, custom_classes, decompression_executor, interpretation_executor, **options)\u001b[39m\n\u001b[32m 565\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._options[\u001b[33m\"\u001b[39m\u001b[33mbegin_chunk_size\u001b[39m\u001b[33m\"\u001b[39m] < _file_header_fields_big.size:\n\u001b[32m 566\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m 567\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mbegin_chunk_size=\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[33m is not enough to read the TFile header (\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[33m)\u001b[39m\u001b[33m\"\u001b[39m.format(\n\u001b[32m 568\u001b[39m \u001b[38;5;28mself\u001b[39m._options[\u001b[33m\"\u001b[39m\u001b[33mbegin_chunk_size\u001b[39m\u001b[33m\"\u001b[39m],\n\u001b[32m 569\u001b[39m _file_header_fields_big.size,\n\u001b[32m 570\u001b[39m )\n\u001b[32m 571\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m573\u001b[39m \u001b[38;5;28mself\u001b[39m._begin_chunk = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_source\u001b[49m\u001b[43m.\u001b[49m\u001b[43mchunk\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 574\u001b[39m \u001b[43m \u001b[49m\u001b[32;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_options\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mbegin_chunk_size\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[32m 575\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m.detach_memmap()\n\u001b[32m 577\u001b[39m \u001b[38;5;28mself\u001b[39m.hook_before_interpret()\n\u001b[32m 579\u001b[39m (\n\u001b[32m 580\u001b[39m magic,\n\u001b[32m 581\u001b[39m \u001b[38;5;28mself\u001b[39m._fVersion,\n\u001b[32m (...)\u001b[39m\u001b[32m 595\u001b[39m \u001b[38;5;28mself\u001b[39m._begin_chunk, _file_header_fields_small, {}\n\u001b[32m 596\u001b[39m )\n", + "\u001b[36mFile \u001b[39m\u001b[32m/usr/local/lib/python3.12/site-packages/uproot/source/fsspec.py:95\u001b[39m, in \u001b[36mFSSpecSource.chunk\u001b[39m\u001b[34m(self, start, stop)\u001b[39m\n\u001b[32m 93\u001b[39m \u001b[38;5;28mself\u001b[39m._num_requested_chunks += \u001b[32m1\u001b[39m\n\u001b[32m 94\u001b[39m \u001b[38;5;28mself\u001b[39m._num_requested_bytes += stop - start\n\u001b[32m---> \u001b[39m\u001b[32m95\u001b[39m data = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_fs\u001b[49m\u001b[43m.\u001b[49m\u001b[43mcat_file\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_file_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstart\u001b[49m\u001b[43m=\u001b[49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mend\u001b[49m\u001b[43m=\u001b[49m\u001b[43mstop\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 96\u001b[39m future = uproot.source.futures.TrivialFuture(data)\n\u001b[32m 97\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m uproot.source.chunk.Chunk(\u001b[38;5;28mself\u001b[39m, start, stop, future)\n", + "\u001b[36mFile \u001b[39m\u001b[32m/usr/local/lib/python3.12/site-packages/fsspec/spec.py:797\u001b[39m, in \u001b[36mAbstractFileSystem.cat_file\u001b[39m\u001b[34m(self, path, start, end, **kwargs)\u001b[39m\n\u001b[32m 785\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"Get the content of a file\u001b[39;00m\n\u001b[32m 786\u001b[39m \n\u001b[32m 787\u001b[39m \u001b[33;03mParameters\u001b[39;00m\n\u001b[32m (...)\u001b[39m\u001b[32m 794\u001b[39m \u001b[33;03mkwargs: passed to ``open()``.\u001b[39;00m\n\u001b[32m 795\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 796\u001b[39m \u001b[38;5;66;03m# explicitly set buffering off?\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m797\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpath\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mrb\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[32m 798\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m start \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 799\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m start >= \u001b[32m0\u001b[39m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m/usr/local/lib/python3.12/site-packages/fsspec/spec.py:1338\u001b[39m, in \u001b[36mAbstractFileSystem.open\u001b[39m\u001b[34m(self, path, mode, block_size, cache_options, compression, **kwargs)\u001b[39m\n\u001b[32m 1336\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 1337\u001b[39m ac = kwargs.pop(\u001b[33m\"\u001b[39m\u001b[33mautocommit\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m._intrans)\n\u001b[32m-> \u001b[39m\u001b[32m1338\u001b[39m f = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_open\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1339\u001b[39m \u001b[43m \u001b[49m\u001b[43mpath\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1340\u001b[39m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m=\u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1341\u001b[39m \u001b[43m \u001b[49m\u001b[43mblock_size\u001b[49m\u001b[43m=\u001b[49m\u001b[43mblock_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1342\u001b[39m \u001b[43m \u001b[49m\u001b[43mautocommit\u001b[49m\u001b[43m=\u001b[49m\u001b[43mac\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1343\u001b[39m \u001b[43m \u001b[49m\u001b[43mcache_options\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcache_options\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1344\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1345\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1346\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m compression \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 1347\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mfsspec\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mcompression\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m compr\n", + "\u001b[36mFile \u001b[39m\u001b[32m/usr/local/lib/python3.12/site-packages/fsspec/implementations/local.py:206\u001b[39m, in \u001b[36mLocalFileSystem._open\u001b[39m\u001b[34m(self, path, mode, block_size, **kwargs)\u001b[39m\n\u001b[32m 204\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.auto_mkdir \u001b[38;5;129;01mand\u001b[39;00m \u001b[33m\"\u001b[39m\u001b[33mw\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m mode:\n\u001b[32m 205\u001b[39m \u001b[38;5;28mself\u001b[39m.makedirs(\u001b[38;5;28mself\u001b[39m._parent(path), exist_ok=\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m--> \u001b[39m\u001b[32m206\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mLocalFileOpener\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpath\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfs\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/usr/local/lib/python3.12/site-packages/fsspec/implementations/local.py:383\u001b[39m, in \u001b[36mLocalFileOpener.__init__\u001b[39m\u001b[34m(self, path, mode, autocommit, fs, compression, **kwargs)\u001b[39m\n\u001b[32m 381\u001b[39m \u001b[38;5;28mself\u001b[39m.compression = get_compression(path, compression)\n\u001b[32m 382\u001b[39m \u001b[38;5;28mself\u001b[39m.blocksize = io.DEFAULT_BUFFER_SIZE\n\u001b[32m--> \u001b[39m\u001b[32m383\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_open\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/usr/local/lib/python3.12/site-packages/fsspec/implementations/local.py:388\u001b[39m, in \u001b[36mLocalFileOpener._open\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 386\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.f \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m.f.closed:\n\u001b[32m 387\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.autocommit \u001b[38;5;129;01mor\u001b[39;00m \u001b[33m\"\u001b[39m\u001b[33mw\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m.mode:\n\u001b[32m--> \u001b[39m\u001b[32m388\u001b[39m \u001b[38;5;28mself\u001b[39m.f = \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mpath\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mmode\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 389\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.compression:\n\u001b[32m 390\u001b[39m compress = compr[\u001b[38;5;28mself\u001b[39m.compression]\n", + "\u001b[31mIsADirectoryError\u001b[39m: [Errno 21] Is a directory: '/home/private/lamarr/lb-pidsim-train/pidgan/workflow/notebooks'" + ] + } + ], "source": [ "from functools import partial\n", "\n", @@ -164,46 +185,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
  • mc_key
    \n", - "
  • evtNumber
    \n", - "
  • runNumber
    \n", - "
  • nTracks_Brunel
    \n", - "
  • probe_Brunel_P
    \n", - "
  • probe_Brunel_ETA
    \n", - "
  • probe_Brunel_trackcharge
    \n", - "
  • probe_Brunel_RichDLLe
    \n", - "
  • probe_Brunel_RichDLLmu
    \n", - "
  • probe_Brunel_RichDLLk
    \n", - "
  • probe_Brunel_RichDLLp
    \n", - "
  • probe_Brunel_MuonMuLL
    \n", - "
  • probe_Brunel_MuonBgLL
    \n", - "
  • probe_Brunel_isMuon
    \n", - "
  • probe_Brunel_MuonUnbiased
    \n", - "
  • probe_Brunel_PIDe
    \n", - "
  • probe_Brunel_PIDK
    \n", - "
  • probe_Brunel_PIDp
    \n", - "
  • probe_Brunel_PIDmu
    \n", - "
  • probe_Brunel_MC15TuneV1_ProbNNe
    \n", - "
  • probe_Brunel_MC15TuneV1_ProbNNpi
    \n", - "
  • probe_Brunel_MC15TuneV1_ProbNNk
    \n", - "
  • probe_Brunel_MC15TuneV1_ProbNNp
    \n", - "
  • probe_Brunel_MC15TuneV1_ProbNNmu
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from IPython.display import HTML\n", "\n", @@ -219,7 +203,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -237,7 +221,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -250,51 +234,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "

Input features (real)

  • p_GeV
    \n", - "
  • eta
    \n", - "
  • nTracks_f
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "

Input features (boolean)

  • charge
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "

Output features (real)

  • RichDLLe
    \n", - "
  • RichDLLmu
    \n", - "
  • RichDLLk
    \n", - "
  • RichDLLp
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from IPython.display import HTML\n", "\n", @@ -308,20 +250,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of muons: 350447\n", - "Number of pions: 500000\n", - "Number of kaons: 500000\n", - "Number of protons: 500000\n" - ] - } - ], + "outputs": [], "source": [ "dfs = dict()\n", "npartitions=min(len(file_list), 10)\n", @@ -339,20 +270,9 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", @@ -381,20 +301,9 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure(figsize=(24, 10), dpi=100)\n", "\n", @@ -450,7 +359,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -471,127 +380,15 @@ ").fit(dfs[conditions].values)\n", "\n", "prep_step_y = dict()\n", - "prep_step_y = StandardScaler().fit(dfs[target].values)" + "# prep_step_y = StandardScaler().fit(dfs[target].values)\n", + "prep_step_y = QuantileTransformer(output_distribution='normal').fit(dfs[target].values)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2025-08-13 08:28:22.856338: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", - "E0000 00:00:1755073703.025354 10944 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "E0000 00:00:1755073703.068171 10944 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "W0000 00:00:1755073703.529422 10944 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1755073703.529482 10944 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1755073703.529484 10944 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1755073703.529487 10944 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "2025-08-13 08:28:23.576357: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", - "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" - ] - }, - { - "data": { - "text/html": [ - "Preprocessing step stored in: 
/tmp/lb-pidsim-train/models/Rich_muon_models/tX_2016MU.pkl
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Preprocessing step stored in: 
/tmp/lb-pidsim-train/models/Rich_muon_models/tY_2016MU.pkl
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Preprocessing step stored in: 
/tmp/lb-pidsim-train/models/Rich_pion_models/tX_2016MU.pkl
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Preprocessing step stored in: 
/tmp/lb-pidsim-train/models/Rich_pion_models/tY_2016MU.pkl
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Preprocessing step stored in: 
/tmp/lb-pidsim-train/models/Rich_kaon_models/tX_2016MU.pkl
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Preprocessing step stored in: 
/tmp/lb-pidsim-train/models/Rich_kaon_models/tY_2016MU.pkl
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Preprocessing step stored in: 
/tmp/lb-pidsim-train/models/Rich_proton_models/tX_2016MU.pkl
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Preprocessing step stored in: 
/tmp/lb-pidsim-train/models/Rich_proton_models/tY_2016MU.pkl
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from preprocessing_utils import store_as_pickle\n", "\n", @@ -627,7 +424,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ From fd863d5bddde25b8516655c3ecd159438c91c01d Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Wed, 27 Aug 2025 06:58:06 +0000 Subject: [PATCH 28/29] shrinked ProbNN preprocessing --- pidgan/workflow/notebooks/preprocessing_utils.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pidgan/workflow/notebooks/preprocessing_utils.py b/pidgan/workflow/notebooks/preprocessing_utils.py index 00ebc89..d0162c5 100644 --- a/pidgan/workflow/notebooks/preprocessing_utils.py +++ b/pidgan/workflow/notebooks/preprocessing_utils.py @@ -145,13 +145,13 @@ def decorator(f): return f return decorator -@inline_c("log(1e-7 + ({x}/(1e-7 + (1 - {x}))))") +@inline_c("0.3*log(1e-7 + ({x}/(1e-7 + (1 - {x}))))") def ProbNNTransformer_fwd(X): - return np.log(1e-7 + X/(1e-7 + (1 - X))) + return 0.3*np.log(1e-7 + X/(1e-7 + (1 - X))) -@inline_c("1 / (1 + exp(-{x}))") +@inline_c("1 / (1 + exp(-{x/0.3}))") def ProbNNTransformer_bwd(Y): - return 1 / (1 + np.exp(-Y)) + return 1 / (1 + np.exp(-Y/0.3)) def makeProbNNTransformer(): ret = FunctionTransformer( From 72a4f636e5fa9d810af69a16c8016729621c4f32 Mon Sep 17 00:00:00 2001 From: Lucio Anderlini Date: Wed, 27 Aug 2025 13:40:36 +0000 Subject: [PATCH 29/29] fix a stupid typo breaking ProbNN preprocessing deployment --- pidgan/workflow/notebooks/preprocessing_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pidgan/workflow/notebooks/preprocessing_utils.py b/pidgan/workflow/notebooks/preprocessing_utils.py index d0162c5..78d96c7 100644 --- a/pidgan/workflow/notebooks/preprocessing_utils.py +++ b/pidgan/workflow/notebooks/preprocessing_utils.py @@ -149,7 +149,7 @@ def decorator(f): def ProbNNTransformer_fwd(X): return 0.3*np.log(1e-7 + X/(1e-7 + (1 - X))) -@inline_c("1 / (1 + exp(-{x/0.3}))") +@inline_c("1 / (1 + exp(-{x}/0.3))") def ProbNNTransformer_bwd(Y): return 1 / (1 + np.exp(-Y/0.3))