Recognizing text in image archives in Yandex Vision OCR

1. Go to the management console and select the folder where you will perform the operations.
2. Select Object Storage.
3. Click Create bucket.
4. Enter a name for the bucket consistent with 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. On the folder dashboard of the management console, click Create resource and select Virtual machine instance.

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

3. Under Location, select an availability zone where your VM will reside. If you do not know which availability zone you need, leave the default one.

4. Under Disks and file storages, select theSSD disk and specify its size: 19 GB.

5. Under Computing resources, navigate to the Custom tab and specify the required platform, number of vCPUs, and the 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 connect your VM to. If the required network or subnet is not there, create it.
   • Under Public IP address, leave Auto to assign a random external IP address to your VM from the Yandex Cloud pool. Alternatively, select a static address from the list if you reserved one.

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

   • Under Login, enter a username. Do not use root or any other reserved names. To perform 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 saved SSH keys in your profile, or you want to add a new key:

     • Click Add key.
     • Enter a name for the SSH key.
     • Upload or paste the contents of the public key file. You need to create a key pair for the SSH connection to a VM yourself.
     • Click Add.

     The SSH key will be added to your organization user profile.

     If users cannot add SSH keys to their profiles in the organization, the added public SSH key will only be saved to the user profile of the VM being created.

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

   • It must be from 2 to 63 characters long.
   • It may 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 until the VM status switches to Running and save the VM’s public IP address required 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 property. This ID is required 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 these properties, 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 authorized key JSON file.

   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 under the service account, such as vision-profile:

   yc config profile create vision-profile
   

   Result:

   Profile 'vision-profile' created and activated
   

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

   yc config set service-account-key key.json
   

7. Get a 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 includes these steps:

1. Create the appropriate directories.
2. Unpack the image archive.
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. Pack the text files you got into an archive.
5. Upload the text files archive to Object Storage.
6. Delete the auxiliary files.

For your convenience, the script text 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 appropriate directories.
   echo "Creating directories..."
   
   # Create a directory for recognized text.
   mkdir my_pictures_text
   
   # Unpack the image archive 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 these actions in a loop:
   do
      # Encode the image as Base64 for sending it 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 that in the respective images.