diff --git a/dravid/tok_dravid/tok_jobs/tokenizer_0.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_0.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3e86171f40b915a75de026122c3186ea64654136 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_0.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-0 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-0 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-0-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_0.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/dravid/tok_dravid/tok_jobs/tokenizer_100.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_100.yaml new file mode 100644 index 0000000000000000000000000000000000000000..07245888de989e12b6c652f6443df58572c02b6a --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_100.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-100 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-100 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-100-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_100.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_102.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_102.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1d859731737c536aa0907e9137faa2e0b32929b9 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_102.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-102 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-102 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-102-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_102.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/dravid/tok_dravid/tok_jobs/tokenizer_103.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_103.yaml new file mode 100644 index 0000000000000000000000000000000000000000..28e0816739dcf0025f20056d0c0bd09657c0d79e --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_103.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-103 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-103 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-103-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_103.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/dravid/tok_dravid/tok_jobs/tokenizer_104.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_104.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7a5c43fbac8f73de6bdcebae87c1e542ed6fb745 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_104.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-104 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-104 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-104-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_104.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_105.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_105.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5d9aef58384e40898f17fbd0cc039b20d9a46584 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_105.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-105 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-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-dravid-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/dravid//tok_dravid/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/dravid/tok_dravid/tok_jobs/tokenizer_106.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_106.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a0ca9f9060f0755d2a367713dbd76270487b1d19 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_106.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-106 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-106 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-106-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_106.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_107.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_107.yaml new file mode 100644 index 0000000000000000000000000000000000000000..6d801ee3944cb8b44d7f0e550386c470484255bb --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_107.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-107 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-107 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-107-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_107.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_108.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_108.yaml new file mode 100644 index 0000000000000000000000000000000000000000..44af9dc5af540b64f4a99dcf94baf52091cee11a --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_108.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-108 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-108 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-108-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_108.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_109.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_109.yaml new file mode 100644 index 0000000000000000000000000000000000000000..cdceee83c1444b407bd01253ff49069d30e8e91b --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_109.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-109 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-109 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-109-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_109.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_11.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_11.yaml new file mode 100644 index 0000000000000000000000000000000000000000..50071df0d25cb241824de737fe8af14669fa318a --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_11.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-11 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-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-dravid-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/dravid//tok_dravid/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/dravid/tok_dravid/tok_jobs/tokenizer_112.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_112.yaml new file mode 100644 index 0000000000000000000000000000000000000000..fbd54e535d728c5ec430093b6bd8b9fac0b98a9c --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_112.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-112 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-112 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-112-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_112.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_114.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_114.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f75ae671c2f37013e565b9f2099d411508be04e5 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_114.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-114 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-114 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-114-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_114.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/dravid/tok_dravid/tok_jobs/tokenizer_115.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_115.yaml new file mode 100644 index 0000000000000000000000000000000000000000..84e3f8b7e9763ac7d8f1f03ca1126fadfadd10c3 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_115.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-115 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-115 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-115-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_115.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_116.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_116.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ffefe9533291dec14fe1b789c7bad9349711c156 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_116.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-116 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-116 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-116-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_116.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/dravid/tok_dravid/tok_jobs/tokenizer_117.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_117.yaml new file mode 100644 index 0000000000000000000000000000000000000000..fcb3f937fb6e4202834f21a3b0d4d740417062ed --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_117.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-117 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-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-dravid-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/dravid//tok_dravid/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/dravid/tok_dravid/tok_jobs/tokenizer_120.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_120.yaml new file mode 100644 index 0000000000000000000000000000000000000000..318acd094174d0fa50d8a23cc08e537509539684 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_120.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-120 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-120 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-120-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_120.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_121.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_121.yaml new file mode 100644 index 0000000000000000000000000000000000000000..390b65a47563b29b348377bcd43143876287b4cf --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_121.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-121 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-121 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-121-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_121.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_123.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_123.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ed3b1cce4cec6bcaaffb92f80b99cdcab0119a17 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_123.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-123 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-123 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-123-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_123.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_125.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_125.yaml new file mode 100644 index 0000000000000000000000000000000000000000..4047df7a4e182881e994410d06edda843251488f --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_125.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-125 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-125 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-125-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_125.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_126.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_126.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9a77a15f59090524e512a72585758b13de060c29 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_126.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-126 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-126 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-126-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_126.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_14.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_14.yaml new file mode 100644 index 0000000000000000000000000000000000000000..4ec283c7689298ced356089f279ee032c2fd891c --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_14.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-14 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-14 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-14-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_14.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_16.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_16.yaml new file mode 100644 index 0000000000000000000000000000000000000000..82cd8d91de0e936d93ecb574adeb0cadced0aaff --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_16.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-16 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-16 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-16-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_16.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_2.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_2.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5772671e468e036934b051b81b87b8bfa278d17b --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_2.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-2 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-2 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-2-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_2.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_21.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_21.yaml new file mode 100644 index 0000000000000000000000000000000000000000..eb4ee7eec5460ca691aac5ee554c55349f0888b1 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_21.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-21 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-21 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-21-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_21.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_22.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_22.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3d54bf28715ad6c10f9912ad86739cda992012c0 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_22.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-22 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-22 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-22-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_22.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_24.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_24.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e7e173a462db9d4cad90391c9446750b1749a761 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_24.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-24 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-24 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-24-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_24.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_26.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_26.yaml new file mode 100644 index 0000000000000000000000000000000000000000..98bc8d636052be5e5d7cc14eeb63d657150d8b73 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_26.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-26 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-26 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-26-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_26.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_27.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_27.yaml new file mode 100644 index 0000000000000000000000000000000000000000..73aa64b95ceba2f1b57d8250e1b0d4985a9057ab --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_27.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-27 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-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-dravid-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/dravid//tok_dravid/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/dravid/tok_dravid/tok_jobs/tokenizer_28.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_28.yaml new file mode 100644 index 0000000000000000000000000000000000000000..31acb687e2469bc26aed3bccf66397f9cce0083b --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_28.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-28 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-28 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-28-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_28.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/dravid/tok_dravid/tok_jobs/tokenizer_29.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_29.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8e4d40172ce23fb3fc05a4d0f0bca57013aabb4b --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_29.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-29 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-29 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-29-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_29.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_3.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_3.yaml new file mode 100644 index 0000000000000000000000000000000000000000..883dfdc16c48d720355f3146e8c6b1f2734f6834 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_3.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-3 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-3 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-3-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_3.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_30.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_30.yaml new file mode 100644 index 0000000000000000000000000000000000000000..d608064cc6c2950de5f8e5b7773f4d6ee9f3d9eb --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_30.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-30 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-30 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-30-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_30.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_32.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_32.yaml new file mode 100644 index 0000000000000000000000000000000000000000..4d7c76015ad7c33220888c88d8cac6186f86aef4 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_32.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-32 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-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-dravid-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/dravid//tok_dravid/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/dravid/tok_dravid/tok_jobs/tokenizer_34.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_34.yaml new file mode 100644 index 0000000000000000000000000000000000000000..876a834e463225c9512ff28a18369e5568e31c00 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_34.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-34 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-34 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-34-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_34.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_35.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_35.yaml new file mode 100644 index 0000000000000000000000000000000000000000..4c26bf1f040175770b6bb77b2659af2b067a7f97 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_35.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-35 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-35 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-35-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_35.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_36.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_36.yaml new file mode 100644 index 0000000000000000000000000000000000000000..51548481489c16fe0cca3ea1b416b4a6d77dd706 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_36.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-36 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-36 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-36-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_36.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_37.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_37.yaml new file mode 100644 index 0000000000000000000000000000000000000000..cb2dfae1e9fea236c4b1524e023b2cfd209234cd --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_37.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-37 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-37 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-37-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_37.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/dravid/tok_dravid/tok_jobs/tokenizer_40.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_40.yaml new file mode 100644 index 0000000000000000000000000000000000000000..fa2bf38e0dc7d393ae1b6a407eebaf36b4d209c0 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_40.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-40 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-40 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-40-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_40.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_41.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_41.yaml new file mode 100644 index 0000000000000000000000000000000000000000..41adf4b07e02e7cd2d9eed0efbf13547456249ab --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_41.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-41 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-41 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-41-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_41.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_42.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_42.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c604d9028a554183d325a432db285b12b215e9f0 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_42.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-42 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-42 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-42-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_42.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_44.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_44.yaml new file mode 100644 index 0000000000000000000000000000000000000000..d8eb5ee425b391e4c52fda716872d9eb1166e981 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_44.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-44 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-44 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-44-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_44.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_45.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_45.yaml new file mode 100644 index 0000000000000000000000000000000000000000..13ca128abd76c21af239480fc66382a439a8dcd5 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_45.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-45 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-45 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-45-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_45.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_46.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_46.yaml new file mode 100644 index 0000000000000000000000000000000000000000..6dc914a77f0c0642984125a82543b7280dda4003 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_46.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-46 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-46 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-46-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_46.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_47.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_47.yaml new file mode 100644 index 0000000000000000000000000000000000000000..22d4cd2568d982a8c829dce85972f924249afdef --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_47.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-47 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-47 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-47-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_47.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_48.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_48.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b7bf094862202e9faf60e474583207d5bd75422a --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_48.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-48 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-48 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-48-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_48.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_5.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_5.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1e8952ac8a81b1864782ac459e70ab1752307d50 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_5.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-5 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-5 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-5-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_5.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_51.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_51.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f28279c641cf72697e52573b101e9f455d7e7c2c --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_51.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-51 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-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-dravid-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/dravid//tok_dravid/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/dravid/tok_dravid/tok_jobs/tokenizer_53.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_53.yaml new file mode 100644 index 0000000000000000000000000000000000000000..183f2c7b50597e386ce4a571eab26d53c081319d --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_53.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-53 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-53 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-53-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_53.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_54.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_54.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e6134f88e0e32beba3a2373598b03faf4c0f123d --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_54.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-54 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-54 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-54-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_54.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_55.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_55.yaml new file mode 100644 index 0000000000000000000000000000000000000000..6e46b380e02c408d172108808fa048187220db32 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_55.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-55 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-55 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-55-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_55.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_56.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_56.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7a06788ba9e72d6987da0fb2298590d02db3ddae --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_56.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-56 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-56 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-56-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_56.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/dravid/tok_dravid/tok_jobs/tokenizer_57.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_57.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c6d9f1d26801cd65c6b3bed3a23249f638e9f17f --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_57.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-57 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-57 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-57-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_57.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_58.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_58.yaml new file mode 100644 index 0000000000000000000000000000000000000000..646a41a9f802cfb63bcb30102155ef55634f1e7d --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_58.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-58 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-58 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-58-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_58.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_6.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_6.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7a94f495b41f64c449c95c3d9cb6ed47db022948 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_6.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-6 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-6 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-6-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_6.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_62.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_62.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e77d2ad313c83376bdaf005af04be27979fc7006 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_62.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-62 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-62 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-62-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_62.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_66.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_66.yaml new file mode 100644 index 0000000000000000000000000000000000000000..70266ee22d9d8d72b4c50e3f2e1adcdfc62600bb --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_66.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-66 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-66 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-66-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_66.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_68.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_68.yaml new file mode 100644 index 0000000000000000000000000000000000000000..40dd110635e439787de4f203ba678d4b9b1f7651 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_68.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-68 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-68 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-68-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_68.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/dravid/tok_dravid/tok_jobs/tokenizer_71.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_71.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e1d6a5bdcc9b07e87faf4c1fd659bc57e241a72b --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_71.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-71 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-71 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-71-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_71.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_73.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_73.yaml new file mode 100644 index 0000000000000000000000000000000000000000..4bd506e4d424c6a4433e7077eb8729969f2540fc --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_73.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-73 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-73 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-73-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_73.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_74.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_74.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8ea4f7aab0a30757ecfe209f74dadafc2d2a6a5a --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_74.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-74 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-74 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-74-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_74.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_76.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_76.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7cdaf57474800cf0d9650e22c16937c0253f01ae --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_76.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-76 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-76 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-76-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_76.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_78.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_78.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1f47e12b9cc1c1af74b217da0207f35fdd0c5705 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_78.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-78 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-78 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-78-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_78.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_8.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_8.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9f8d4c5f4e68947c898549c975f53c139283d422 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_8.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-8 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-8 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-8-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_8.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_81.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_81.yaml new file mode 100644 index 0000000000000000000000000000000000000000..831dcd73c27de78325c9bc40f767d6c4f06126d7 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_81.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-81 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-81 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-81-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_81.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/dravid/tok_dravid/tok_jobs/tokenizer_83.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_83.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1465f2cd91cafe0666fed712e2da5cb4aea70375 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_83.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-83 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-83 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-83-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_83.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_84.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_84.yaml new file mode 100644 index 0000000000000000000000000000000000000000..98fbea653fe807f37922085bfeaf75f2d52310b8 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_84.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-84 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-84 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-84-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_84.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_85.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_85.yaml new file mode 100644 index 0000000000000000000000000000000000000000..6b8b138bead511d62950adb888da5b43d277279a --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_85.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-85 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-85 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-85-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_85.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_87.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_87.yaml new file mode 100644 index 0000000000000000000000000000000000000000..fd0ff0921be9d8adceed77d1f5866b4a24f8f4fd --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_87.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-87 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-87 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-87-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_87.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_88.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_88.yaml new file mode 100644 index 0000000000000000000000000000000000000000..09c2b43b112074f44929c9c3b219fab2033191fd --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_88.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-88 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-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-dravid-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/dravid//tok_dravid/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 diff --git a/dravid/tok_dravid/tok_jobs/tokenizer_91.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_91.yaml new file mode 100644 index 0000000000000000000000000000000000000000..202f2e134178ab381b84bff5129a4fac1d9098e1 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_91.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-91 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-91 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-91-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_91.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_92.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_92.yaml new file mode 100644 index 0000000000000000000000000000000000000000..93ae45d1b1c50874dc7bfa910978c7c6a90ce477 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_92.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-92 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-92 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-92-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_92.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_93.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_93.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8d7cd64d8f799e92a2d05a9ffbb1288ed2442d11 --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_93.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-93 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-93 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-93-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_93.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + 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/dravid/tok_dravid/tok_jobs/tokenizer_96.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_96.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9ce79126e7a3ffebe21daf03b55d588d1866465a --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_96.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-96 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-96 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-96-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_96.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock diff --git a/dravid/tok_dravid/tok_jobs/tokenizer_99.yaml b/dravid/tok_dravid/tok_jobs/tokenizer_99.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2a409711313a89fcc042f2d862b8e9f39125ca1a --- /dev/null +++ b/dravid/tok_dravid/tok_jobs/tokenizer_99.yaml @@ -0,0 +1,104 @@ +apiVersion: kubeflow.org/v2beta1 +kind: MPIJob +metadata: + name: peacock-tokenizer-dravid-99 + namespace: peacock + labels: + app: peacock-tokenizer-dravid-99 +spec: + slotsPerWorker: 8 + runPolicy: + backoffLimit: 1 + cleanPodPolicy: Running + mpiReplicaSpecs: + Launcher: + replicas: 1 + template: + spec: + hostIPC: true + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-tokenizer-dravid-99-launcher + imagePullPolicy: IfNotPresent + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock + command: ["/bin/bash", "-c"] + args: + - >- + + export SYNAPSE_VERSION="1.15.1"; + export WORKER_DIR="/mnt/weka/peacock/experiments/llama"; + + export MEGATRON_SETUP_CMD="$WORKER_DIR/launch/setup.sh" + export TOKENIZER_CMD=/mnt/weka/peacock/idc/datasets/dravid//tok_dravid/tok_files/tokenizer_99.sh + HOSTSFILE=$OMPI_MCA_orte_default_hostfile; + echo "HOSTSFILE=$HOSTSFILE"; + MASTER_ADDR="$(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p)"; + NUM_NODES=$(wc -l < $HOSTSFILE); + CARDS_PER_NODE=8; + N_CARDS=$((NUM_NODES*CARDS_PER_NODE)); + echo "MPI_ROOT=$MPI_ROOT"; + echo "N_CARDS=$N_CARDS"; + echo "MASTER_ADDR=$MASTER_ADDR"; + sleep 20; + + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $MEGATRON_SETUP_CMD; + + mpirun -np $N_CARDS -npernode 8 \ + --tag-output \ + --allow-run-as-root \ + --prefix $MPI_ROOT \ + -x WORKER_DIR=$WORKER_DIR \ + -x SYNAPSE_VERSION=$SYNAPSE_VERSION $TOKENIZER_CMD; + + + Worker: + replicas: 1 + template: + spec: + volumes: + - name: work-dir + persistentVolumeClaim: + claimName: peacock-fs-pvc + tolerations: + - key: "habana.ai/gaudi" + operator: "Exists" + effect: "NoSchedule" + - key: "k8s/namespace" + operator: "Equal" + value: "peacock" + effect: "NoSchedule" + hostIPC: true + containers: + - image: vault.habana.ai/gaudi-docker/1.15.1/ubuntu22.04/habanalabs/pytorch-installer-2.2.0:latest + name: peacock-llama-worker + imagePullPolicy: IfNotPresent + securityContext: + capabilities: + add: + - SYSLOG + resources: + limits: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + requests: + habana.ai/gaudi: 8 + hugepages-2Mi: 300Gi + memory: 700Gi + cpu: 150 + volumeMounts: + - name: work-dir + mountPath: /mnt/weka/peacock