diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_102.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_102.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ce966386eaf172266e5ddf537d8b3a771f608fe5 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_102.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-102 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-102 +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-102-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_102.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_103.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_103.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b02ba1aa8c7db31843dffa59cf32f0f889ffbbff --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_103.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-103 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-103 +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-103-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_103.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_111.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_111.yaml new file mode 100644 index 0000000000000000000000000000000000000000..0c53cfcc7290f6ef6c83dc4c2e27c3f591028bb0 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_111.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-111 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-111 +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-111-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_111.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_135.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_135.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1ad11850dc6fde6ca1e8a90675d4a0701f1152d0 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_135.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-135 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-135 +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-135-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_135.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_145.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_145.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9d8a1d1337290ac86e61cc30cc1217d656dd4201 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_145.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-145 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-145 +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-145-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_145.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_15.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_15.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c33fb52a730bdaa3e17b4b02a411c984f52293c3 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_15.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-15 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-15 +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-15-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_15.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_159.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_159.yaml new file mode 100644 index 0000000000000000000000000000000000000000..81c84105247be4144e010c7453a449b6d9733579 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_159.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-159 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-159 +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-159-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_159.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_201.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_201.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1f52414b98325ee09a82d108bdaa2ed2a7145b76 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_201.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-201 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-201 +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-201-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_201.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_203.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_203.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a4d9825831b0d1095c89dd5668138d40ab840fab --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_203.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-203 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-203 +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-203-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_203.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_205.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_205.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f26be4e946ec66833c12020065de1c82662e3ca6 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_205.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-205 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-205 +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-205-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_205.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_210.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_210.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2d65626cf5fdce03ca11fad6a33c254f76c02e83 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_210.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-210 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-210 +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-210-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_210.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_235.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_235.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ab355818894519e780924ede71c1f74a101d74eb --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_235.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-235 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-235 +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-235-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_235.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_253.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_253.yaml new file mode 100644 index 0000000000000000000000000000000000000000..fe95ba524338992aa8d1ad5c86a4d3eed79566f2 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_253.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-253 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-253 +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-253-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_253.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_256.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_256.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a7c65a1f5747af89ea8b1ee3a5a89dd57c27ab13 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_256.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-256 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-256 +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-256-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_256.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_260.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_260.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e6c9eb534fa2c0305e1c0858657fc6a3821aa0e0 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_260.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-260 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-260 +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-260-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_260.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_262.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_262.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5c678adf37a880fdbdcefbb3e0242e3cc0035a58 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_262.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-262 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-262 +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-262-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_262.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_265.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_265.yaml new file mode 100644 index 0000000000000000000000000000000000000000..80545fec177b9558ea9372c15f666ab5e899749f --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_265.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-265 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-265 +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-265-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_265.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_271.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_271.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a2e3a3910700b176b4648d7f9e91d3a66810d778 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_271.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-271 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-271 +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-271-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_271.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_278.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_278.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ab16251474f041d05575918d0f00528aa6e47103 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_278.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-278 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-278 +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-278-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_278.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_319.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_319.yaml new file mode 100644 index 0000000000000000000000000000000000000000..797c85185375da49768e9f9e4da945aab048f002 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_319.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-319 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-319 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-319-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_319.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_326.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_326.yaml new file mode 100644 index 0000000000000000000000000000000000000000..df1a56db02fa7406373ad871c1ec77b40188e99b --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_326.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-326 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-326 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-326-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_326.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_33.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_33.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3a547318aed27273bf4248dd5b073d1a83824cde --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_33.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-33 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-33 +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-33-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_33.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_330.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_330.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e2765a7190a2667d72ce99bb9c8f1497e8c1fa58 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_330.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-330 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-330 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-330-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_330.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_354.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_354.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e76f07632af96f1a9af6cd02a2b13f673199bf30 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_354.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-354 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-354 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-354-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_354.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_363.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_363.yaml new file mode 100644 index 0000000000000000000000000000000000000000..cb985cb6749f8189573474bddea3987706d5423f --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_363.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-363 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-363 +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-363-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_363.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_365.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_365.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5a8b20303403a5f3d7557e0dd939ef773030d4c5 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_365.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-365 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-365 +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-365-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_365.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_371.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_371.yaml new file mode 100644 index 0000000000000000000000000000000000000000..984e89184cc8546c2939c7b0ba839d5e10f75b47 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_371.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-371 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-371 +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-371-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_371.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_402.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_402.yaml new file mode 100644 index 0000000000000000000000000000000000000000..6193c7c3b1c5d49bbec4feae8ee69ecf3d4a33cb --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_402.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-402 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-402 +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-402-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_402.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_416.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_416.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9174c9afb7208a6707350dc6d73c3c962a7c24ba --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_416.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-416 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-416 +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-416-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_416.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_419.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_419.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9c56c73f050cf3fcb97f95c75cc9ab519717bcfc --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_419.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-419 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-419 +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-419-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_419.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_424.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_424.yaml new file mode 100644 index 0000000000000000000000000000000000000000..12f6e8594d66539b334a658505185abc543424aa --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_424.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-424 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-424 +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-424-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_424.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_427.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_427.yaml new file mode 100644 index 0000000000000000000000000000000000000000..693042e3ef065c1b4ee7c558dcfa1291a7f68110 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_427.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-427 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-427 +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-427-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_427.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_448.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_448.yaml new file mode 100644 index 0000000000000000000000000000000000000000..511d9217416eb963e833f3a0e85bf445050bf55a --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_448.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-448 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-448 +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-448-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_448.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_475.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_475.yaml new file mode 100644 index 0000000000000000000000000000000000000000..6f12f829a5882ce4176294d9dd2507e786a995e4 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_475.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-475 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-475 +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-475-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_475.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_479.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_479.yaml new file mode 100644 index 0000000000000000000000000000000000000000..010441659bb5e90f196eca269b17abc7a7929553 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_479.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-479 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-479 +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-479-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_479.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_483.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_483.yaml new file mode 100644 index 0000000000000000000000000000000000000000..88a4380ba28cdde41c4b5bc89acafff4d7423d70 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_483.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-483 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-483 +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-483-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_483.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_492.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_492.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9053ebc438a4b36eff51e04b3dfce4c4ce214795 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_492.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-492 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-492 +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-492-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_492.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_498.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_498.yaml new file mode 100644 index 0000000000000000000000000000000000000000..40998020bf8067aec9d862fafd7964e2bb974bb2 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_498.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-498 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-498 +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-498-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_498.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_499.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_499.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f8d2ebfa8498c9b44fdd3e473302f8b6ad89e925 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_499.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-499 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-499 +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-499-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_499.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_514.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_514.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e91763c87ad7347f8c7c42f044a62f1e4e62bfe2 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_514.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-514 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-514 +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-514-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_514.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_519.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_519.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f6271c6513daa145e33c5e4e367c3b2beb8e3360 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_519.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-519 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-519 +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-519-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_519.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_537.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_537.yaml new file mode 100644 index 0000000000000000000000000000000000000000..10e2745b6cc62ece216fead37c8f62119ff50e85 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_537.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-537 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-537 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-537-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_537.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_540.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_540.yaml new file mode 100644 index 0000000000000000000000000000000000000000..bc39d416a55c844a226f3e633467425fd870af4c --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_540.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-540 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-540 +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-540-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_540.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_553.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_553.yaml new file mode 100644 index 0000000000000000000000000000000000000000..dba4c8469271db2fb7996fd994d837c8a59796f5 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_553.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-553 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-553 +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-553-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_553.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_554.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_554.yaml new file mode 100644 index 0000000000000000000000000000000000000000..05a9f0e1002e521eb9f7ada45d6ab0b9f73de5cf --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_554.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-554 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-554 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-554-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_554.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_558.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_558.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3fa74becd2c16c4e4a5ab234e0d380bf57dc2365 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_558.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-558 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-558 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-558-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_558.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_56.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_56.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3de994b1bc887783c4ace6224c4dc9b673ce77a9 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_56.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-56 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-56 +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-56-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_56.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_560.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_560.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e69ca6179b2d859d8964dfd06bd54a645cab0b42 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_560.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-560 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-560 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-560-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_560.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_561.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_561.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2dc92b25e1ed00e397214f6b501245afb06263af --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_561.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-561 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-561 +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-561-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_561.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_573.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_573.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f7e730b28a713d2ed95efae2a62eb36295445f24 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_573.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-573 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-573 +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-573-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_573.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_607.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_607.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5dc147ff2201389028a7fcffee63a5fd204ef547 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_607.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-607 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-607 +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-607-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_607.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_628.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_628.yaml new file mode 100644 index 0000000000000000000000000000000000000000..60c22adcc70f6840f25c75d3b0f72a30fe2795c6 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_628.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-628 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-628 +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-628-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_628.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_640.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_640.yaml new file mode 100644 index 0000000000000000000000000000000000000000..28ee6db09fbc48fbac3e9aa4d2c479aa4f2aba06 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_640.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-640 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-640 +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-640-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_640.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_641.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_641.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a66fd6b929929863824b1f15b977bd041229972b --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_641.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-641 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-641 +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-641-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_641.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_665.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_665.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ac47c3eb4baa8f3beda5e037f510196d66fe2c07 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_665.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-665 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-665 +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-665-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_665.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_671.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_671.yaml new file mode 100644 index 0000000000000000000000000000000000000000..75be1164b79e4241a0578ccc12aa6beb3ebefc33 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_671.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-671 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-671 +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-671-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_671.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_68.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_68.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3bef369e077bc59d7307a8e890ceb91daf6f491b --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_68.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-68 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-68 +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-68-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_68.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_680.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_680.yaml new file mode 100644 index 0000000000000000000000000000000000000000..da95e64cabd1c8fc837aa602027fe6249afc6c6d --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_680.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-680 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-680 +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-680-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_680.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_695.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_695.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e3f17b19915ce08658dc292101d34748f10c8459 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_695.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-695 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-695 +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-695-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_695.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_726.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_726.yaml new file mode 100644 index 0000000000000000000000000000000000000000..de38cb2fd6ce4d921749ad676e9e693d99532aa1 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_726.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-726 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-726 +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-726-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_726.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_731.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_731.yaml new file mode 100644 index 0000000000000000000000000000000000000000..acb9c9f9710eeaf1f196234d4d1fbb683d6f69fb --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_731.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-731 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-731 +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-731-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_731.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_754.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_754.yaml new file mode 100644 index 0000000000000000000000000000000000000000..d6ad1702c6eac21c71f74754ee854d070a857424 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_754.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-754 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-754 +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-754-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_754.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_762.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_762.yaml new file mode 100644 index 0000000000000000000000000000000000000000..efc1c0425549ae4817a3906487f29aadee1fd4f7 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_762.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-762 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-762 +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-762-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_762.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_765.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_765.yaml new file mode 100644 index 0000000000000000000000000000000000000000..4e4454a29c3e7ba20b1dca26b8e70ea00f8ba751 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_765.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-765 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-765 +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-765-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_765.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_767.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_767.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ff4c04c27f1411895eafe72ebda08ebc3c69ce5c --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_767.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-767 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-767 +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-767-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_767.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_781.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_781.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9a82b0fac4b2ff63f0ff814af42823638acdcce2 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_781.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-781 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-781 +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-781-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_781.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_783.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_783.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b684337653cbfac6d637c6e95e20da62e892ffa0 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_783.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-783 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-783 +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-783-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_783.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_789.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_789.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5558657d7ac1d7a37f3f47f39fc1e89b91461654 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_789.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-789 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-789 +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-789-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_789.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_799.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_799.yaml new file mode 100644 index 0000000000000000000000000000000000000000..0d7383f1988deca6abbaa2ca49905fc70c521607 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_799.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-799 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-799 +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-799-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_799.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_806.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_806.yaml new file mode 100644 index 0000000000000000000000000000000000000000..830d2964797ac4ed8020018910b322e4118b81f7 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_806.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-806 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-806 +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-806-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_806.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_808.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_808.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2d7b298849a71832e0be485e8bfea5b4cafcf4c8 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_808.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-808 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-808 +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-808-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_808.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_81.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_81.yaml new file mode 100644 index 0000000000000000000000000000000000000000..750843c38711b29dacd1e244d67ad01fd25643ff --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_81.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-81 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-81 +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-81-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_81.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_829.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_829.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f16c212817a80c7e0d89d1906601c4d1f761ca19 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_829.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-829 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-829 +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-829-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_829.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_834.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_834.yaml new file mode 100644 index 0000000000000000000000000000000000000000..827eaa09d18d5f33dd6f7c4bb27a4e432c68d8b5 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_834.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-834 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-834 +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-834-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_834.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 diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_96.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_96.yaml new file mode 100644 index 0000000000000000000000000000000000000000..4d9eee7e14c5c34ac9a97a4567f58af79b263333 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_96.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-96 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-96 +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-96-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_96.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