Add files using upload-large-folder tool

hn_eng_bn/tok_en-bn-hn/tok_jobs_4/tokenizer_300.yaml

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

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

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

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

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

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

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

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

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

hn_eng_bn/tok_en-bn-hn/tok_jobs_4/tokenizer_310.yaml

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

hn_eng_bn/tok_en-bn-hn/tok_jobs_4/tokenizer_342.yaml

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

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

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

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

hn_eng_bn/tok_en-bn-hn/tok_jobs_4/tokenizer_346.yaml

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

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

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

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

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

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

hn_eng_bn/tok_en-bn-hn/tok_jobs_4/tokenizer_354.yaml

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

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

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

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

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