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. On the folder page in 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 to create your VM in. If you do not know which availability zone you need, leave the default one.

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

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

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

   • Under Login, enter the username. Do not use root or other names reserved by the OS. To perform operations requiring superuser permissions, 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:

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

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