Recognizing text in image archives in Yandex Vision OCR

1. Go to the management console and select the folder to perform the operations in.
2. Select Object Storage.
3. Click Create bucket.
4. Enter a name for the bucket according to the naming requirements.
5. In the Object read access field, select Restricted.
6. In the Storage class field, select Cold.
7. Click Create bucket.

1. Go to the management console and select the folder to perform the operations in.

2. Select Compute Cloud.

3. Click Create virtual machine.

4. Enter the VM name. The naming requirements are as follows:

   • The name must be from 3 to 63 characters long.
   • It may contain lowercase Latin letters, numbers, and hyphens.
   • The first character must be a letter and the last character cannot be a hyphen.

5. Select an availability zone to place your VM in.

6. Under Boot disk image, go to the Marketplace tab and select a public CentOS 7 image.

7. Under Disks, select:

   • Type: SSD
   • Size: 19 GB

8. Under Computing resources, select:

   • Platform: Intel Cascade Lake
   • Guaranteed vCPU performance: 20%
   • vCPU: 2
   • RAM: 2 GB

9. Under Network settings, select the network and the subnet to connect the VM to. If there is are no networks available, create one.

10. Under Public IP, keep Auto to assign your VM a random public IP address from the Yandex Cloud pool, or select a static address from the list if you reserved one in advance.

11. Specify the VM access details:

    • Enter the username into the Login field.

    • In the SSH key field, paste the contents of the public key file.

      You will need to create a key pair for the SSH connection yourself; see Creating an SSH key pair for details.

12. Click Create VM.

13. Wait for the VM status to change to Running and save its public IP address: you will need it for SSH connection.

1. Create a service account:

   yc iam service-account create \
     --name <service_account_name> \
     --description "<service_account_description>"
   

   Where:

   • --name: Service account name, e.g., vision-sa.
   • --description: Service account description, e.g., this is vision service account.

   Result:

   id: aje6aoc8hccu********
   folder_id: b1gv87ssvu49********
   created_at: "2022-10-12T14:04:43.198559512Z"
   name: vision-sa
   description: this is vision service account
   

   Save the service account ID (the id parameter): you will need it for further configuration.

2. Assign the editor role to the service account:

   yc resource-manager folder add-access-binding <folder_ID> \
     --role editor \
     --subject serviceAccount:<service_account_ID>
   

   Where:

   • --role: Role you want to assign.
   • --subject serviceAccount: Service account ID.

3. Create a static access key for your service account:

   yc iam access-key create \
     --service-account-id <service_account_ID> \
     --description "<key_description>"
   

   Where:

   • --service-account-id: Service account ID.
   • --description: Key description, e.g., this key is for vision.

   Result:

   access_key:
     id: ajen8d7fur27********
     service_account_id: aje6aoc8hccu********
     created_at: "2022-10-12T15:08:08.045280520Z"
     description: this key is for vision
     key_id: YC...li
   secret: YC...J5
   

   Save the following parameters (you will need them to configure the AWS CLI utility):

   • key_id: Static access key ID
   • secret: Secret key

4. Create an authorized key for the service account:

   yc iam key create \
     --service-account-id <service_account_ID> \
     --output key.json
   

   Where:

   • --service-account-id: Service account ID.
   • --output: Name of the JSON file with the authorized key.

   Result:

   id: aje3qc9pagb9********
   service_account_id: aje6aoc8hccu********
   created_at: "2022-10-13T12:53:04.810240976Z"
   key_algorithm: RSA_2048
   

5. Create a Yandex Cloud CLI profile to run on behalf of the service account, such as vision-profile:

   yc config profile create vision-profile
   

   Result:

   Profile 'vision-profile' created and activated
   

6. Specify the authorized key of the service account in the profile configuration:

   yc config set service-account-key key.json
   

7. Get a Yandex Identity and Access Management token for the service account:

   yc iam create-token
   

   Save the Identity and Access Management token, you will need it to send images to Vision OCR.

The script includes the following steps:

1. Create the relevant directories.
2. Unpack the archive with images.
3. Process all images one by one:
   1. Encode the image as Base64.
   2. Create a request body for the specific image.
   3. Send the image in a POST request to Vision OCR for recognition.
   4. Save the result to the output.json file.
   5. Extract the recognized text from output.json and save it to a text file.
4. Add the resulting text files to an archive.
5. Upload the archive with the text files to Object Storage.
6. Delete the auxiliary files.

For your convenience, the text of the script includes comments to each step.

To implement the script:

1. Create a file, e.g., vision.sh, and open it in the nano text editor:

   sudo nano vision.sh
   

2. Copy the Bash script text to vision.sh:

   #!/bin/bash
   
   # Create the relevant directories.
   echo "Creating directories..."
   
   # Create a directory for recognized text.
   mkdir my_pictures_text
   
   # Unpack the archive with images to the directory you created.
   echo "Extract pictures in my_pictures directory..."
   tar -xf my_pictures.tar
   
   # Recognize the images from the archive.
   FILES=my_pictures/*
   for f in $FILES
   # For each file in the directory, perform the following actions in a loop:
   do
      # Encode the image as Base64 for sending to Vision OCR.
      CODEIMG=$(base64 -i $f | cat)
   
      # Create a `body.json` file to send to Vision OCR in a POST request.
      cat <<EOF > body.json
   {
   "mimeType": "JPEG",
   "languageCodes": ["*"],
   "model": "page",
   "content": "$CODEIMG"
   }
   EOF
   # Send the image to Vision OCR for recognition and write the result to the `output.json` file.
   echo "Processing file $f in Vision..."
   curl --request POST \
     --header "Content-Type: application/json" \
     --header "Authorization: Bearer ${IAMTOKEN}" \
     --header "x-data-logging-enabled: true" \
     --header "x-folder-id: ${FOLDERID}" \
     --data '@body.json' \
     https://ocr.api.cloud.yandex.net/ocr/v1/recognizeText \
     --output output.json
   
   # Get the image file name to use it later.
   IMAGE_BASE_NAME=$(basename -- "$f")
   IMAGE_NAME="${IMAGE_BASE_NAME%.*}"
   
   # Get the text data from the `output.json` file and write it to a .txt file with the same name as the image file.
   cat output.json | jq -r '.result[].blocks[].lines[].text' | awk -v ORS=" " '{print}' > my_pictures_text/$IMAGE_NAME".txt"
   done
   
   # Archive the contents of the text file directory.
   echo "Packing text files to archive..."
   tar -cf my_pictures_text.tar my_pictures_text
   
   # Move the text file archive to your bucket.
   echo "Sending archive to Object Storage Bucket..."
   aws --endpoint-url=https://storage.yandexcloud.net s3 cp my_pictures_text.tar s3://$BUCKETNAME/ > /dev/null
   
   # Delete the auxiliary files.
   echo "Cleaning up..."
   rm -f body.json
   rm -f output.json
   rm -rfd my_pictures
   rm -rfd my_pictures_text
   rm -r my_pictures_text.tar
   

3. Set the permissions to run the script:

   sudo chmod 755 vision.sh
   

4. Run the script:

   ./vision.sh
   

1. In the Yandex Cloud management console, select the folder containing the bucket with the recognition results.
2. Select Object Storage.
3. Open the bucket with the recognition results.
4. Make sure the bucket contains the my_pictures_text.tar archive.
5. Download and unpack the archive.
6. Make sure the text in the <image_name>.txt files matches the text in the respective images.