diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_105.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_105.yaml new file mode 100644 index 0000000000000000000000000000000000000000..d6f859eaa30878ac289d3bedfd400b1bdbe0a2d8 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_105.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-105 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-105 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-105-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_105.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_11.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_11.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c361183b24f0d1e11cadd8c9cf27848f4009161a --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_11.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-11 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-11 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-11-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_11.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_117.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_117.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ac41297fac6db01908438fd615870845a983836f --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_117.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-117 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-117 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-117-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_117.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_155.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_155.yaml new file mode 100644 index 0000000000000000000000000000000000000000..43c48800f219e53ade21e23704b2583b454c9069 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_155.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-155 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-155 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-155-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_155.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_164.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_164.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7a6c98c2f15dd01064c961319933b6c06a9ecf9c --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_164.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-164 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-164 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-164-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_164.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_172.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_172.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b3cbbe53b82729bf90dfa7fe8dd034a5fbef164f --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_172.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-172 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-172 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-172-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_172.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_179.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_179.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b941c54ffbe60fdd4ba90a922df5469e29804b82 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_179.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-179 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-179 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-179-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_179.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_218.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_218.yaml new file mode 100644 index 0000000000000000000000000000000000000000..47ea913be668d838ec4bb76eea8d0b26e06501ef --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_218.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-218 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-218 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-218-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_218.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_222.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_222.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b30cc960503b75333cc2446c613b2cfecc155a58 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_222.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-222 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-222 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-222-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_222.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_263.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_263.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9fe00994bbaf6a844e746fb1839f5d9538c144a1 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_263.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-263 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-263 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-263-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_263.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_27.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_27.yaml new file mode 100644 index 0000000000000000000000000000000000000000..d1ce3b756fa454f619bec1ef05631520a2e0808c --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_27.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-27 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-27 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-27-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_27.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_307.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_307.yaml new file mode 100644 index 0000000000000000000000000000000000000000..18c116d62bd24759a06a59c19e6abe11f4c1ac3f --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_307.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-307 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-307 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-307-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_307.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_318.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_318.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c372265810da0372fd38d20344391a07535b668c --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_318.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-318 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-318 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-318-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_318.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_32.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_32.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f302b5d3a2f20a0c2d03c3428ece77bfbb1e7e04 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_32.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-32 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-32 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-32-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_32.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_329.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_329.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8d057f76d98be6ff2f596f38aed74b1391aa593f --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_329.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-329 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-329 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-329-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_329.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_332.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_332.yaml new file mode 100644 index 0000000000000000000000000000000000000000..6e6e2b3c5773d0d8cf68858890a7029ca7dcba8a --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_332.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-332 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-332 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-332-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_332.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_348.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_348.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7232622e8f9da305a010cae4b2a627347961e730 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_348.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-348 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-348 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-348-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_348.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_360.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_360.yaml new file mode 100644 index 0000000000000000000000000000000000000000..6c31578bfdab39f1481e07f4e364a0ae1bec8b2b --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_360.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-360 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-360 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-360-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_360.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_368.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_368.yaml new file mode 100644 index 0000000000000000000000000000000000000000..681339a9051dc465eaba02fee5f4921fdba69baf --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_368.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-368 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-368 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-368-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_368.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_370.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_370.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f53535b6c02ba14404a0e03daf49dc2e914ad942 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_370.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-370 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-370 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-370-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_370.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_375.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_375.yaml new file mode 100644 index 0000000000000000000000000000000000000000..637ea3b40547610695eaa0de84a8635c4010dc5c --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_375.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-375 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-375 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-375-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_375.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_386.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_386.yaml new file mode 100644 index 0000000000000000000000000000000000000000..615284b01d6062a7ba0591dd4663a3dd4ef5ccfb --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_386.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-386 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-386 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-386-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_386.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_394.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_394.yaml new file mode 100644 index 0000000000000000000000000000000000000000..4f00559e0832c587b16e3aba46cf3199c97e4e6c --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_394.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-394 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-394 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-394-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_394.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_400.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_400.yaml new file mode 100644 index 0000000000000000000000000000000000000000..199c51f23e01c6a262ee8edbbd7c49aedd990d9e --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_400.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-400 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-400 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-400-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_400.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_414.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_414.yaml new file mode 100644 index 0000000000000000000000000000000000000000..60fb71df62609284e1f2fb2cfdf7a4f1bd1f928b --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_414.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-414 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-414 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-414-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_414.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_415.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_415.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1da2aa74d0bc9676c88d9a690e816fcab3cd3606 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_415.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-415 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-415 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-415-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_415.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_431.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_431.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e8339f30f1b6457ff7d817238d525513708a677f --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_431.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-431 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-431 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-431-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_431.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_453.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_453.yaml new file mode 100644 index 0000000000000000000000000000000000000000..fd6f62caa85accf06cb15190032f0ba70b2658a5 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_453.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-453 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-453 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-453-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_453.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_458.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_458.yaml new file mode 100644 index 0000000000000000000000000000000000000000..85f229bffa7b142fca974909d469c11f5cfe1879 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_458.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-458 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-458 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-458-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_458.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_466.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_466.yaml new file mode 100644 index 0000000000000000000000000000000000000000..75725650b01bc751bda0b2f948c9c6181df84d9b --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_466.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-466 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-466 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-466-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_466.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_482.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_482.yaml new file mode 100644 index 0000000000000000000000000000000000000000..0a5a228f8cbb4f0162907599d25b6514aff4309e --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_482.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-482 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-482 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-482-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_482.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_484.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_484.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a0f0d51506b57035220a35be548510afdbee5de6 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_484.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-484 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-484 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-484-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_484.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_488.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_488.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f35264a88699abf76d080c115aa192439bc8c41b --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_488.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-488 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-488 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-488-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_488.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_493.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_493.yaml new file mode 100644 index 0000000000000000000000000000000000000000..464af84bf8997ead250534415b79dd808fbed764 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_493.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-493 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-493 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-493-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_493.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_495.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_495.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1581c10489f412cb002465a894115bfd42a5dd74 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_495.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-495 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-495 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-495-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_495.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_50.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_50.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5a0ba64d9440d5cd0da6d356fb85dfa3674cb67f --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_50.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-50 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-50 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-50-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_50.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_500.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_500.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9a43fddd181156760bed1acbb71e0aafaae75427 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_500.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-500 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-500 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-500-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_500.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_504.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_504.yaml new file mode 100644 index 0000000000000000000000000000000000000000..40f87ae78d6e78d04c01c3628a9f59da12e807f3 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_504.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-504 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-504 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-504-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_504.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_51.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_51.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9d5dfaf3f5c2f0789b4a6e7215d02c3be48e128e --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_51.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-51 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-51 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-51-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_51.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_511.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_511.yaml new file mode 100644 index 0000000000000000000000000000000000000000..da3651a49e5c9a84d1c9bc4af4512812f53494cd --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_511.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-511 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-511 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-511-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_511.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_533.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_533.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7134e0f318792e3ca0d8588421055e28362ec365 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_533.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-533 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-533 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-533-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_533.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_538.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_538.yaml new file mode 100644 index 0000000000000000000000000000000000000000..024b0287dc03451d951432403e1db643e2ab8d58 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_538.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-538 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-538 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-538-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_538.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_566.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_566.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b0ad0a8f98d3b7e4dddaf1f2344f1fd4795c6851 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_566.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-566 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-566 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-566-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_566.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_594.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_594.yaml new file mode 100644 index 0000000000000000000000000000000000000000..de0f56944d4f2eb69e0ab6ea9a461ce6c9a542e1 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_594.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-594 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-594 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-594-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_594.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_599.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_599.yaml new file mode 100644 index 0000000000000000000000000000000000000000..625b0faa4d82302e7b623be08e6a3a0ae8552809 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_599.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-599 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-599 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-599-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_599.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_613.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_613.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b57e2c4ef03668d188ec75a24c0abc3e93a5b44f --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_613.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-613 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-613 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-613-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_613.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_615.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_615.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c1beafc5251c54f1cc42c86906b2df197d41e6a0 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_615.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-615 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-615 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-615-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_615.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_622.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_622.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b846273d49007370dbb48172fefaeeabcf5e4374 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_622.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-622 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-622 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-622-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_622.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_624.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_624.yaml new file mode 100644 index 0000000000000000000000000000000000000000..415f7a42953efaa531d54f531d2b140152140154 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_624.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-624 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-624 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-624-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_624.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_638.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_638.yaml new file mode 100644 index 0000000000000000000000000000000000000000..114afa2446d3a6b0d3680048db3e25a392de2e24 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_638.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-638 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-638 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-638-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_638.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_647.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_647.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e7d5b3d36927af2200d8b0d3135b52ae8522beff --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_647.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-647 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-647 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-647-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_647.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_648.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_648.yaml new file mode 100644 index 0000000000000000000000000000000000000000..eb2a5e424aed4611f1973005be25c6ba7061d54d --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_648.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-648 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-648 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-648-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_648.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_651.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_651.yaml new file mode 100644 index 0000000000000000000000000000000000000000..15a418a4784ea8759f3ed63cbc26e1660bcc12e5 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_651.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-651 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-651 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-651-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_651.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_673.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_673.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a5ab0a7de34aa2046e6e941f1da2620dc076eb5b --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_673.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-673 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-673 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-673-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_673.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_681.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_681.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8f7717857cce7fd9521ca1a1abd282e12be2b594 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_681.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-681 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-681 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-681-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_681.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_688.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_688.yaml new file mode 100644 index 0000000000000000000000000000000000000000..351de1a914b33decb2070a8fed2a7ddc1f7ea8bb --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_688.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-688 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-688 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-688-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_688.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_696.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_696.yaml new file mode 100644 index 0000000000000000000000000000000000000000..cc7f87a61a3dadb5940bbadffdbce7c40062581d --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_696.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-696 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-696 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-696-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_696.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_698.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_698.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c97c87e00b05ea4a904ecdcf21379a15a8b31b51 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_698.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-698 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-698 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-698-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_698.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_704.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_704.yaml new file mode 100644 index 0000000000000000000000000000000000000000..d773fbf409c376d3c8a2e317c667439f6d127155 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_704.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-704 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-704 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-704-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_704.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_708.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_708.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b04875ec05ea18686555ddecb052b0ca5a95755a --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_708.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-708 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-708 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-708-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_708.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_719.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_719.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5323fc0f40c0ccfabd83a7102be07c5ac418a2ff --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_719.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-719 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-719 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-719-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_719.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_721.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_721.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a73147944a6b0fa739e6ec7d88ff5590e1d87b5c --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_721.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-721 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-721 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-721-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_721.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_727.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_727.yaml new file mode 100644 index 0000000000000000000000000000000000000000..825f5c0791ad07ae4f30096053f85fbbb3e9c3a0 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_727.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-727 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-727 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-727-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_727.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_749.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_749.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7afb338c3b0686c88e122a6ab50efdcdd3059e19 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_749.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-749 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-749 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-749-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_749.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_752.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_752.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2bfedb4f35de51ce38ce83515ae9a537343a2527 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_752.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-752 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-752 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-752-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_752.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_755.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_755.yaml new file mode 100644 index 0000000000000000000000000000000000000000..617659d2abc326bff350752eeb7ac0738d643b2c --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_755.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-755 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-755 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-755-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_755.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_759.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_759.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c635f24607024d6012875d306fa4d46f0a2b4807 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_759.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-759 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-759 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-759-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_759.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_777.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_777.yaml new file mode 100644 index 0000000000000000000000000000000000000000..31f96ff1646f75682737c6c8ceccd2b64cc13703 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_777.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-777 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-777 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-777-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_777.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_786.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_786.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a8636dd528a960841d1b61cd03792cd01c4fdc90 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_786.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-786 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-786 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-786-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_786.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_803.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_803.yaml new file mode 100644 index 0000000000000000000000000000000000000000..edb744a93fe4e72a3b5f503c9d669329ffe70a7c --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_803.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-803 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-803 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-803-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_803.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_816.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_816.yaml new file mode 100644 index 0000000000000000000000000000000000000000..35eaec371dc628471c7a294056883fbcbeccde4c --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_816.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-816 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-816 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-816-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_816.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_82.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_82.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b9a433561396f11750b1796e751ad6c74a9e0fd5 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_82.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-82 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-82 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-82-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_82.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_820.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_820.yaml new file mode 100644 index 0000000000000000000000000000000000000000..98847afe50dd6aaccd89e0c49e3b638c6ca6f74d --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_820.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-820 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-820 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-820-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_820.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_823.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_823.yaml new file mode 100644 index 0000000000000000000000000000000000000000..14e883e8b213358d78a8fb5f6983473377910754 --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_823.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-823 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-823 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-823-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_823.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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_88.yaml b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_88.yaml new file mode 100644 index 0000000000000000000000000000000000000000..718416b375b696edcca5e9fb9f7aa4df1fbe674b --- /dev/null +++ b/hn_eng_bn/tok_en-bn-hn/tok_jobs/tokenizer_88.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-en-bn-hn-88 + namespace: peacock + labels: + app: peacock-tokenizer-en-bn-hn-88 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-en-bn-hn-88-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/hn_eng_bn/tok_en-bn-hn/tok_files/tokenizer_88.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock