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 as per the naming conventions.
5. In the Read objects field, select With authorization.
6. In the Storage class field, select Cold.
7. Click Create bucket.

1. On the folder dashboard in the management console, click Create resource and select Virtual machine instance.

2. Select Advanced setup.

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

4. Under Location, select an availability zone where your VM will reside. If you are not sure which one to choose, leave the default.

5. Under Disks and file storages, select the SSD disk type and specify its size: 19 GB.

6. Under Computing resources, navigate 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

7. 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.
   • In the Public IP address field, keep Auto to assign the VM a random external IP address from the Yandex Cloud pool or select a static address from the list if you reserved one.

8. 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. 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 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.

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

   • It must be from 2 to 63 characters long.
   • It can only contain lowercase Latin letters, numbers, and hyphens.
   • It must start with a letter and cannot end with a hyphen.

10. Click Create VM.

11. 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 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 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.