Add files using upload-large-folder tool

hn_eng_bn/tok_en-bn-hn/tok_jobs_6/tokenizer_500.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-500
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-500
+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-500-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_500.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_6/tokenizer_502.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-502
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-502
+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-502-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_502.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_6/tokenizer_504.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-504
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-504
+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-504-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_504.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_6/tokenizer_507.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-507
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-507
+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-507-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_507.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_6/tokenizer_509.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-509
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-509
+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-509-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_509.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_6/tokenizer_510.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-510
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-510
+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-510-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_510.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_6/tokenizer_515.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-515
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-515
+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-515-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_515.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_6/tokenizer_516.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-516
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-516
+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-516-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_516.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_6/tokenizer_517.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-517
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-517
+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-517-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_517.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_6/tokenizer_521.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-521
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-521
+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-521-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_521.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_6/tokenizer_524.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-524
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-524
+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-524-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_524.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_6/tokenizer_525.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-525
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-525
+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-525-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_525.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_6/tokenizer_526.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-526
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-526
+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-526-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_526.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_6/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_6/tokenizer_528.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-528
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-528
+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-528-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_528.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_6/tokenizer_530.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-530
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-530
+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-530-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_530.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_6/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_6/tokenizer_532.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-532
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-532
+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-532-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_532.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_6/tokenizer_533.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-533
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-533
+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-533-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_533.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_6/tokenizer_534.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-534
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-534
+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-534-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_534.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_6/tokenizer_535.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-535
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-535
+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-535-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_535.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_6/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_6/tokenizer_537.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-537
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-537
+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-537-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_537.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_6/tokenizer_538.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-538
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-538
+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-538-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_538.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_6/tokenizer_541.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-541
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-541
+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-541-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_541.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_6/tokenizer_543.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-543
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-543
+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-543-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_543.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_6/tokenizer_544.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-544
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-544
+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-544-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_544.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_6/tokenizer_546.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-546
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-546
+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-546-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_546.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_6/tokenizer_550.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-550
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-550
+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-550-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_550.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_6/tokenizer_551.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-551
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-551
+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-551-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_551.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_6/tokenizer_554.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-554
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-554
+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-554-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_554.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_6/tokenizer_555.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-555
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-555
+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-555-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_555.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_6/tokenizer_556.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-556
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-556
+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-556-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_556.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_6/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_6/tokenizer_558.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-558
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-558
+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-558-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_558.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_6/tokenizer_559.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-559
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-559
+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-559-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_559.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_6/tokenizer_560.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-560
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-560
+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-560-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_560.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_6/tokenizer_562.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-562
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-562
+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-562-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_562.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_6/tokenizer_564.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-564
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-564
+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-564-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_564.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_6/tokenizer_566.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-566
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-566
+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-566-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_566.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_6/tokenizer_568.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-568
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-568
+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-568-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_568.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_6/tokenizer_570.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-570
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-570
+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-570-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_570.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_6/tokenizer_571.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-571
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-571
+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-571-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_571.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_6/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_6/tokenizer_576.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-576
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-576
+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-576-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_576.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_6/tokenizer_577.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-577
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-577
+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-577-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_577.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_6/tokenizer_578.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-578
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-578
+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-578-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_578.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_6/tokenizer_579.yaml

@@ -0,0 +1,104 @@
+apiVersion: kubeflow.org/v2beta1
+kind: MPIJob
+metadata:
+  name: peacock-tokenizer-en-bn-hn-579
+  namespace: peacock
+  labels:
+    app: peacock-tokenizer-en-bn-hn-579
+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-579-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_579.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_6/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_6/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