Recognizing text in image archives using Yandex Vision OCR

1. In the management console, select the folder where you will operate.
2. Go to Object Storage.
3. Click Create bucket.
4. Specify the bucket name that meets these naming conventions.
5. In the Read objects field, select With authorization.
6. In the Storage class field, select Cold.
7. Click Create bucket.

1. In the management console, navigate to the folder dashboard, click Create resource, and select Virtual machine instance.

2. Under Boot disk image, enter CentOS 7 in the Product search field and select a public CentOS 7 image.

3. Under Location, select an availability zone where your VM will reside. If you are not sure which availability zone you need, leave the default selection.

4. Under Disks and file storages, select the disk type (SSD) and specify its size (19 GB).

5. Under Computing resources, switch to the Custom tab and specify the platform, number of vCPUs, and amount of RAM:

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

6. Under Network settings:

   • In the Subnet field, select the network and subnet to which you want to connect your VM. If the network or subnet you need does not exist yet, create it.
   • In the Public IP address field, select a static IP address from the list, or leave Auto to assign your VM a random external IP address from the Yandex Cloud pool.

7. Under Access, select SSH key and specify the VM access credentials:

   • In the Login field, enter the username. Do not use root or other reserved usernames. For operations requiring root privileges, use the sudo command.

   • In the SSH key field, select the SSH key saved in your organization user profile.

     If there are no SSH keys in your profile or you want to add a new key:

     1. Click Add key.

     2. Enter a name for the SSH key.

     3. Select one of the following:

        • Enter manually: Paste the contents of the public SSH key. You need to create an SSH key pair on your own.

        • Load from file: Upload the public part of the SSH key. You need to create an SSH key pair on your own.

        • Generate key: Automatically create an SSH key pair.

          When adding a new SSH key, an archive containing the key pair will be created and downloaded. In Linux or macOS-based operating systems, unpack the archive to the /home/<user_name>/.ssh directory. In Windows, unpack the archive to the C:\Users\<user_name>/.ssh directory. You do not need additionally enter the public key in the management console.

     4. Click Add.

     The system will add the SSH key to your organization user profile. If the organization has disabled the ability for users to add SSH keys to their profiles, the added public SSH key will only be saved in the user profile inside the newly created resource.

8. Under General information, specify the VM name. The naming requirements are as follows:

   • Length: between 3 and 63 characters.
   • It can only contain lowercase Latin letters, numbers, and hyphens.
   • It must start with a letter and cannot end with a hyphen.

9. Click Create VM.

10. 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 from the id field in the response; 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 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 values, as you will need them to configure the AWS CLI:

   • 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.
   • --output: Name of the JSON file containing your 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 as the service account, e.g., vision-profile:

   yc config profile create vision-profile
   

   Result:

   Profile 'vision-profile' created and activated
   

6. In the profile configuration, specify the service account’s authorized key:

   yc config set service-account-key key.json
   

7. Obtain an IAM token for the service account:

   yc iam create-token
   

   Save the IAM token. You will need it to send images to Vision OCR.

The script runs through the following steps:

1. Creating required directories.
2. Extracting the image archive.
3. Processing all images in sequence:
   1. Encoding the image in Base64.
   2. Creating a request body containing the image.
   3. Sending the image to Vision OCR for recognition via a POST request.
   4. Saving the response to the output.json file.
   5. Extracting the recognized text from output.json and saving it to a text file.
4. Adding the resulting text files to an archive.
5. Uploading the archive to Object Storage.
6. Deleting temporary files.

To make things clearer, the script has comments for each step.

To prepare this script:

1. Create a file named vision.sh and open it in nano:

   sudo nano vision.sh
   

2. Paste the following Bash script into vision.sh:

   #!/bin/bash
   
   # Create the required directories.
   echo "Creating directories..."
   
   # Create a directory to store the recognized text.
   mkdir my_pictures_text
   
   # Extract the image archive into the new directory.
   echo "Extract pictures in my_pictures directory..."
   tar -xf my_pictures.tar
   
   # Run text recognition on the images from the archive.
   FILES=my_pictures/*
   for f in $FILES
   # Loop through each file in the directory and perform the following steps:
   do
      # Encode the image in Base64 for submission to Vision OCR.
      CODEIMG=$(base64 -i $f | cat)
   
      # Create a `body.json` file that you will send to Vision OCR via 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 response 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 later in the request.
   IMAGE_BASE_NAME=$(basename -- "$f")
   IMAGE_NAME="${IMAGE_BASE_NAME%.*}"
   
   # Retrieve the text data from `output.json` and write it to a .txt file named after the original 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
   
   # Upload 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 temporary 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 execute permissions for 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 your recognition results.
2. Go to Object Storage.
3. Open the bucket with the recognition results.
4. Verify that the bucket contains my_pictures_text.tar.
5. Download and unpack the archive.
6. Verify that the text in the <image_name>.txt files matches the text on the corresponding images.