Add files using upload-large-folder tool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_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/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/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/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/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/tokenizer_336.yaml

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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