Add files using upload-large-folder tool

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_106.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-106
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-106
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-106-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_106.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_131.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-131
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-131
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-131-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_131.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_154.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-154
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-154
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-154-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_154.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_156.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-156
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-156
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-156-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_156.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_167.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-167
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-167
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-167-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_167.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_177.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-177
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-177
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-177-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_177.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_180.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-180
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-180
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-180-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_180.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_186.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-186
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-186
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-186-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_186.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_187.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-187
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-187
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-187-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_187.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_193.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-193
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-193
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-193-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_193.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_197.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-197
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-197
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-197-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_197.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_198.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-198
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-198
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-198-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_198.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_215.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-215
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-215
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-215-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_215.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_233.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-233
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-233
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-233-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_233.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_279.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-279
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-279
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-279-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_279.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_285.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-285
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-285
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-285-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_285.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_290.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-290
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-290
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-290-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_290.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_293.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-293
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-293
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-293-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_293.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_295.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-295
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-295
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-295-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_295.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_299.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-299
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-299
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-299-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_299.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_309.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-309
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-309
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-309-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_309.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_323.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-323
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-323
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-323-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_323.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_337.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-337
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-337
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-337-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_337.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_341.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-341
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-341
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-341-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_341.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_343.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-343
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-343
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-343-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_343.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_344.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-344
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-344
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-344-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_344.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_353.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-353
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-353
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-353-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_353.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_377.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-377
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-377
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-377-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_377.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_381.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-381
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-381
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-381-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_381.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_384.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-384
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-384
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-384-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_384.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_404.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-404
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-404
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-404-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_404.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_418.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-418
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-418
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-418-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_418.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_425.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-425
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-425
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-425-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_425.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_447.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-447
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-447
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-447-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_447.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_454.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-454
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-454
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-454-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_454.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_455.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-455
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-455
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-455-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_455.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_464.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-464
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-464
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-464-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_464.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_496.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-496
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-496
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-496-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_496.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_5.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-5
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-5
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-5-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_5.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_527.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-527
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-527
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-527-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_527.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_529.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-529
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-529
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-529-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_529.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_531.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-531
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-531
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-531-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_531.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_536.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-536
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-536
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-536-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_536.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_548.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-548
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-548
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-548-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_548.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_55.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-55
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-55
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-55-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_55.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_557.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-557
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-557
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-557-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_557.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_563.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-563
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-563
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-563-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_563.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_572.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-572
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-572
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-572-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_572.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_580.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-580
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-580
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-580-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_580.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_581.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-581
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-581
+spec:
+  slotsPerWorker: 8
+  runPolicy:
+    backoffLimit: 1
+    cleanPodPolicy: Running
+  mpiReplicaSpecs:
+    Launcher:
+      replicas: 1
+      template:
+        spec:
+          hostIPC: true
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-tokenizer-en-bn-hn-581-launcher
+              imagePullPolicy: IfNotPresent
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock
+              command: ["/bin/bash", "-c"]
+              args:
+                - >-
+                  
+                  export SYNAPSE_VERSION="1.15.1";
+                  export WORKER_DIR="/mnt/weka/peacock/experiments/llama";
+
+                  export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh"
+                  export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_581.sh
+                  HOSTSFILE=$OMPI_MCA_orte_default_hostfile;
+                  echo "HOSTSFILE=$HOSTSFILE";
+                  MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)";
+                  NUM_NODES=$(wc -l < $HOSTSFILE);
+                  CARDS_PER_NODE=8;
+                  N_CARDS=$((NUM_NODES*CARDS_PER_NODE));
+                  echo "MPI_ROOT=$MPI_ROOT";
+                  echo "N_CARDS=$N_CARDS";
+                  echo "MASTER_ADDR=$MASTER_ADDR";
+                  sleep 20;
+
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD;
+
+                  mpirun -np $N_CARDS  -npernode 8 \
+                    --tag-output \
+                    --allow-run-as-root \
+                    --prefix $MPI_ROOT \
+                    -x WORKER_DIR=$WORKER_DIR \
+                    -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD;
+                    
+                   
+    Worker:
+      replicas: 1
+      template:
+        spec:
+          volumes:
+            - name: work-dir
+              persistentVolumeClaim:
+                claimName: peacock-fs-pvc
+          tolerations:
+            - key: "habana.ai/gaudi"
+              operator: "Exists"
+              effect: "NoSchedule"
+            - key: "k8s/namespace"
+              operator: "Equal"
+              value: "peacock"
+              effect: "NoSchedule"
+          hostIPC: true
+          containers:
+            - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest
+              name: peacock-llama-worker
+              imagePullPolicy: IfNotPresent
+              securityContext:
+                capabilities:
+                  add:
+                    - SYSLOG
+              resources:
+                limits:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+                requests:
+                  habana.ai/gaudi: 8
+                  hugepages-2Mi: 300Gi
+                  memory: 700Gi
+                  cpu: 150
+              volumeMounts:
+                - name: work-dir
+                  mountPath: /mnt/weka/peacock