# ನಿಮ್ಮ IoT ಸಾಧನದಿಂದ ಸ್ಟಾಕ್ ಎಣಿಕೆ - ವಾಸ್ತವಿಕ IoT ಹಾರ್ಡ್‌ವೇರ್ ಮತ್ತು ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈ

ಭವಿಷ್ಯವಾಣಿ ಮತ್ತು ಅವುಗಳ ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳ ಸಂಯೋಜನೆ ಚಿತ್ರದಲ್ಲಿ ಸ್ಟಾಕ್ ಎಣಿಸಲು ಬಳಸಬಹುದು

## ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳನ್ನು ತೋರಿಸಿ

ಉಪಯುಕ್ತ ಡಿಬಗ್ಗಿಂಗ್ ಹಂತವಾಗಿ ನೀವು ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳನ್ನು ಮುದ್ರಿಸುವುದಲ್ಲದೆ, ಕ್ಯಾಪ್ಚರ್‌ ಮಾಡಿದಾಗ ಡಿಸ್ಕ್‌ಗೆ ಬರೆಯಲಾದ ಚಿತ್ರದಲ್ಲಿ ಅವುಗಳನ್ನು ರೇಖಾಚಿತ್ರದ ಮೂಲಕ ಕೂಡ ಬರೆಯಬಹುದು.

### ಕಾರ್ಯ - ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳನ್ನು ಮುದ್ರಿಸಿ

1. `stock-counter` ಯೋಜನೆ VS ಕೋಡ್‌ನಲ್ಲಿ ತೆರೆಯಲ್ಪಟ್ಟಿದ್ದಿರಲಿ ಮತ್ತು ನೀವು ವರ್ಚುವಲ್ IoT ಸಾಧನವನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ ವರ್ಚುವಲ್ ಪರಿಸರ ಸಕ್ರಿಯಗೊಂಡಿರಲಿ.

1. ಕೆಳಗಿನಂತೆ `for` ಲೂಪಿನಲ್ಲಿನ `print` ಹೇಳಿಕೆಯನ್ನು ಬದಲಾಯಿಸಿ ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳನ್ನು ಕಾನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿಸಲು:

    ```python
    print(f'{prediction.tag_name}:\t{prediction.probability * 100:.2f}%\t{prediction.bounding_box}')
    ```

1. ಕ್ಯಾಮೆರಾ ಬೇಲೆಯ ಮೇಲೆ ಯಾವುದೇ ಸ್ಟಾಕ್ ನೋಡುತ್ತಿರುವಂತೆ ಆಪ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡಿ. ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳು 0-1 ರಲ್ಲಿ ಎಡ, ಮೇಲೆ, ಅಗಲ ಮತ್ತು ಎತ್ತರ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಕಾನ್ಸೋಲ್‌ನಲ್ಲಿ ಮುದ್ರಿಸಲಾಗುವುದು.

    ```output
    pi@raspberrypi:~/stock-counter $ python3 app.py 
    tomato paste:   33.42%  {'additional_properties': {}, 'left': 0.3455171, 'top': 0.09916268, 'width': 0.14175442, 'height': 0.29405564}
    tomato paste:   34.41%  {'additional_properties': {}, 'left': 0.48283678, 'top': 0.10242918, 'width': 0.11782813, 'height': 0.27467814}
    tomato paste:   31.25%  {'additional_properties': {}, 'left': 0.4923783, 'top': 0.35007596, 'width': 0.13668466, 'height': 0.28304994}
    tomato paste:   31.05%  {'additional_properties': {}, 'left': 0.36416405, 'top': 0.37494493, 'width': 0.14024884, 'height': 0.26880276}
    ```

### ಕಾರ್ಯ - ಚಿತ್ರದಲ್ಲಿ ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳನ್ನು ಅಳೆಯಿರಿ

1. ಪಿಪ್ ಪ್ಯಾಕೇಜ್ [Pillow](https://pypi.org/project/Pillow/) ಅನ್ನು ಚಿತ್ರಗಳ ಮೇಲೆ ರೇಖಾಚಿತ್ರ ಮಾಡಲು ಬಳಸಬಹುದು. ಇದನ್ನು ಕೆಳಗಿನ ಆಜ್ಞೆಯಿಂದ ಸ್ಥಾಪಿಸಿರಿ:

    ```sh
    pip3 install pillow
    ```

    ನೀವು ವರ್ಚುವಲ್ IoT ಸಾಧನವನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ಸಕ್ರಿಯಗೊಂಡಿರುವ ವರ್ಚುವಲ್ ಪರಿಸರದೊಳಗಿನಿಂದ ಇದನ್ನು ಚಾಲನೆ ಮಾಡುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

1. ಈ ಕೆಳಗಿನ ಆಮದು ಹೇಳಿಕೆಯನ್ನು `app.py` ಫೈಲ್‌ನ ತುದಿಯಲ್ಲಿ ಸೇರಿಸಿ:

    ```python
    from PIL import Image, ImageDraw, ImageColor
    ```

    ಇದು ಚಿತ್ರ ಸಂಪಾದನೆಗಾಗಿ ಅಗತ್ಯವಿರುವ ಕೋಡ್ ಅನ್ನು ಆಮದು ಮಾಡುತ್ತದೆ.

1. ಈ ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು `app.py` ಫೈಲ್‌ನ ಕೊನೆಯಲ್ಲಿ ಸೇರಿಸಿ:

    ```python
    with Image.open('image.jpg') as im:
        draw = ImageDraw.Draw(im)
    
        for prediction in predictions:
            scale_left = prediction.bounding_box.left
            scale_top = prediction.bounding_box.top
            scale_right = prediction.bounding_box.left + prediction.bounding_box.width
            scale_bottom = prediction.bounding_box.top + prediction.bounding_box.height
            
            left = scale_left * im.width
            top = scale_top * im.height
            right = scale_right * im.width
            bottom = scale_bottom * im.height
    
            draw.rectangle([left, top, right, bottom], outline=ImageColor.getrgb('red'), width=2)
    
        im.save('image.jpg')
    ```

    ಈ ಕೋಡ್ ಹಿಂದಿನ ಸೇವ್ ಮಾಡಲಾದ ಚಿತ್ರವನ್ನು ಸಂಪಾದನೆಗೆ ತೆಗೆಯುತ್ತದೆ. ನಂತರ ಭವಿಷ್ಯವಾಣಿ ಗಳನ್ನು ಲೂಪ್ ಮೂಲಕ ತೆಗೆದುಕೊಂಡು ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳನ್ನು ಪಡೆಯುತ್ತದೆ, ಮತ್ತು ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್ ಮೌಲ್ಯಗಳಿಂದ ಕೆಳಗಡೆ ಬಲದ ಸಂಯೋಜನೆಯನ್ನು ಲೆಕ್ಕಹಾಕುತ್ತದೆ 0-1 ವ್ಯಾಪ್ತಿಯಲ್ಲಿ. ಅವುಗಳನ್ನು ಚಿತ್ರದ ಆಯಾಮದೊಡನೆ ಗುಣಿಸಿ ಚಿತ್ರ ಸಂಯೋಜನೆಗಳಿಗೆ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಎಡ ಮೌಲ್ಯ 0.5 ಆಗಿದ್ದರೆ 600 ಪಿಕ್ಸೆಲ್ಸ್ ಅಗಲದ ಚಿತ್ರದಲ್ಲಿ, ಇದನ್ನು 300 (0.5 x 600 = 300) ಗೆ ಪರಿವರ್ತಿಸುವುದಾಗಿದೆ.

    ಪ್ರತಿ ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್ ಅನ್ನು ಎರೆಗಿನ ರೇಖೆಯಿಂದ ಚಿತ್ರದಲ್ಲಿ ರೇಖಿಸುತ್ತಾರೆ. ಕೊನೆಗೆ ಸಂಪಾದಿಸಿದ ಚಿತ್ರ ಸೇವ್ ಮಾಡಿ ಮೂಲ ಚಿತ್ರವನ್ನು ಮರುಬರೆಯಲಾಗುತ್ತದೆ.

1. ಕ್ಯಾಮೆರಾ ಬೇಲೆಯ ಮೇಲೆ ಕೆಲವು ಸ್ಟಾಕ್ ನೋಡುತ್ತಿರುವಂತೆ ಆಪ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡಿ. ನೀವು VS ಕೋಡ್ ಎಕ್ಸ್‌ಪ್ಲೋರರ್‌ನಲ್ಲಿ `image.jpg` ಫೈಲ್ ಅನ್ನು ಕಾಣಬಹುದು, ಮತ್ತು ಅದನ್ನು ಆರಿಸಿ ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳನ್ನು ನೋಡಬಹುದಾಗಿದೆ.

    ![ಪ್ರತಿ ಕ್ಯಾನ್‌ ಬೆಲೆ ಚಿಹ್ನೆ ಇರುವ ಟೊಮೇಟೋ ಪೇಸ್ಟ್‌ನ 4 ಕ್ಯಾನ್ಸ್ ಹತ್ತಿರ ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳು](../../../../../translated_images/kn/rpi-stock-with-bounding-boxes.b5540e2ecb7cd49f.webp)

## ಸ್ಟಾಕ್ ಎಣಿಕೆ

ಮೇಲಿನ ಚಿತ್ರದಲ್ಲಿ ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳಿಗೆ ಸ್ವಲ್ಪ ಜೋಡಣೆ ಇದೆ. ಈ ಜೋಡಣೆ ತುಂಬು ದೊಡ್ಡದಾಗಿದ್ದರೆ, ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳು ಒಬ್ಬೇ ವಸ್ತುವನ್ನು ಸೂಚಿಸಬಹುದು. ವಸ್ತುಗಳನ್ನು ಸರಿಯಾಗಿ ಎಣಿಸಲು ನೀವು ಮಹತ್ವದ ಜೋಡಣೆಯಿರುವ ಬಾಕ್ಸ್‌ಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸಬೇಕಾಗುತ್ತದೆ.

### ಕಾರ್ಯ - ಜೋಡಣೆ ನಿರ್ಲಕ್ಷಿಸಿ ಸ್ಟಾಕ್ ಎಣಿಸಿ

1. ಪಿಪ್ ಪ್ಯಾಕೇಜ್ [Shapely](https://pypi.org/project/Shapely/) ಬಳಸಿ ವಿಚಲನ ಲೆಕ್ಕಹಾಕಬಹುದು. ನೀವು ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈ ಬಳಸುತ್ತಿದ್ದರೆ, ಮೊದಲು ಗ್ರಂಥಾಲಯ ಡಿಪೆಂಡೆನ್ಸಿ ಸ್ಥಾಪಿಸಬೇಕು:

    ```sh
    sudo apt install libgeos-dev
    ```

1. ಶ್ಯಾಪ್ಲಿ ಪಿಪ್ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ:

    ```sh
    pip3 install shapely
    ```

    ನೀವು ವರ್ಚುವಲ್ IoT ಸಾಧನವನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ಸಕ್ರಿಯಗೊಂಡಿರುವ ವರ್ಚುವಲ್ ಪರಿಸರದಿಂದ ಇದನ್ನು ಚಾಲನೆ ಮಾಡುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

1. ಈ ಕೆಳಗಿನ ಆಮದು ಹೇಳಿಕೆಯನ್ನು `app.py` ಫೈಲ್‌ನ ತುದಿಯಲ್ಲಿ ಸೇರಿಸಿ:

    ```python
    from shapely.geometry import Polygon
    ```

    ಇದು ಜೋಡಣೆ ಲೆಕ್ಕಿಸಲು ಪೊಲಿಗೋನ್ಗಳನ್ನು ರಚಿಸಲು ಅಗತ್ಯವಿರುವ ಕೋಡ್ ಅನ್ನು ಆಮದು ಮಾಡುತ್ತದೆ.

1. ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳನ್ನು ರೇಖಿಸುವ ಕೋಡ್‌ಗೂ ಮೊದಲು ಈ ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಸೇರಿಸಿ:

    ```python
    overlap_threshold = 0.20
    ```

    ಇದು ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳನ್ನು ಒಬ್ಬೇ ವಸ್ತುವಾಗಿ ಪರಿಗಣಿಸುವ ಮೊದಲು ಅನುಮತಿಸಲಾದ ಜೋಡಣೆ ಶೇಕಡಾವಾರಿಯನ್ನು ಸೂಚಿಸುತ್ತದೆ. 0.20 ಎಂದರೆ 20% ಜೋಡಣೆ.

1. ಶ್ಯಾಪ್ಲಿ ಬಳಸಿ ಜೋಡಣೆ ಲೆಕ್ಕಿಸಲು, ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳನ್ನು ಶ್ಯಾಪ್ಲಿ ಪೊಲಿಗೋನ್ಗಳಾಗಿ ಪರಿವರ್ತಿಸಬೇಕು. ಇದಕ್ಕಾಗಿ ಈ ಕೆಳಗಿನ ಕಾರ್ಯವನ್ನು ಸೇರಿಸಿ:

    ```python
    def create_polygon(prediction):
        scale_left = prediction.bounding_box.left
        scale_top = prediction.bounding_box.top
        scale_right = prediction.bounding_box.left + prediction.bounding_box.width
        scale_bottom = prediction.bounding_box.top + prediction.bounding_box.height
    
        return Polygon([(scale_left, scale_top), (scale_right, scale_top), (scale_right, scale_bottom), (scale_left, scale_bottom)])
    ```

    ಇದು ಭವಿಷ್ಯವಾಣಿ ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್ ಬಳಸಿ ಒಂದು ಪೊಲಿಗೋನ್ ಸೃಷ್ಟಿಸುತ್ತದೆ.

1. ಜೋಡಣೆಯಾಗಿರುವ ವಸ್ತುಗಳನ್ನು ತೆಗೆದುಹಾಕುವ ಲಾಜಿಕ್ ಎಂದರೆ ಎಲ್ಲಾ ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳನ್ನು ಹೋಲಿಸಿ, ಮತ್ತು ಯಾವಯಾವ ಜೋಡಿಯ ಭವಿಷ್ಯವಾಣಿಗಳ ಬಾಕ್ಸ್‌ಗಳು ಪಾರಮಿತಿ ಮೀರಿದಷ್ಟು ಜೋಡಣೆಯುಳ್ಳದಾಗಿದ್ದರೆ, ಒಂದನ್ನು ಅಳಿಸಲಾಗುತ್ತದೆ. ಎಲ್ಲಾ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಹೋಲಿಸಲು, ಮೊದಲನೆಯ ಭವಿಷ್ಯವಾಣಿ 2, 3, 4 ಇತ್ಯಾದಿ ಜೊತೆ ಹೋಲಿಸಿ, ನಂತರ 2 ಅನ್ನು 3, 4 ಇತ್ಯಾದಿ ಜೊತೆ ಹೋಲಿಸಲಾಗುತ್ತದೆ. ಈ ಕೆಳಗಿನ ಕೋಡ್ ಇದನ್ನು ಮಾಡುತ್ತದೆ:

    ```python
    to_delete = []

    for i in range(0, len(predictions)):
        polygon_1 = create_polygon(predictions[i])
    
        for j in range(i+1, len(predictions)):
            polygon_2 = create_polygon(predictions[j])
            overlap = polygon_1.intersection(polygon_2).area

            smallest_area = min(polygon_1.area, polygon_2.area)
    
            if overlap > (overlap_threshold * smallest_area):
                to_delete.append(predictions[i])
                break
    
    for d in to_delete:
        predictions.remove(d)

    print(f'Counted {len(predictions)} stock items')
    ```

    ಜೋಡಣೆ ಶ್ಯಾಪ್ಲಿ `Polygon.intersection` ವಿಧಾನದೊಂದಿಗೆ ಲೆಕ್ಕಿಸಲ್ಪಡುತ್ತದೆ ಅದು ಜೋಡಣೆ ಹೊಂದಿರುವ ಪೊಲಿಗೋನನ್ನು ನೀಡುತ್ತದೆ. ನಂತರ ಆ ಪ್ರದೇಶ ಲೆಕ್ಕಿಸಲಾಗುತ್ತದೆ. ಈ ಜೋಡಣೆ ಪಾರಮಿತಿ ಸಾಬೀತು ಅಂತಮೌಲ್ಯವಲ್ಲ, ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್ ಶೇಕಡಾವಾರಿಯಾಗಿ ಇರಬೇಕು, ಆದಕಾರಣ ಸಣ್ಣ ಬಾಕ್ಸ್ ಕಂಡು, ಆ ಜೋಡಣೆ ಪಾರಮಿತಿ ಡಗರದಲ್ಲಿ ಇರುವ ಶೇಕಡಾವಾರಿ ಅದಕ್ಕೂ ಸಂಬಂಧಿಸಿ ಲೆಕ್ಕಿಸಲಾಗುತ್ತದೆ. ಜೋಡಣೆ ಅದನ್ನು ಮೀರಿ ಇದ್ದರೆ ಭವಿಷ್ಯವಾಣಿ ಅಳಿಸಲು ಗುರುತಿಸಲಾಗುತ್ತದೆ.

    ಒಂದು ಭವಿಷ್ಯವಾಣಿ ಅಳಿಸಲ್ಪಡುವುದಾಗಿ ಗುರುತಿಸಿದರೆ ಮತ್ತೊಮ್ಮೆ ಪರಿಶೀಲಿಸುವ ಅಗತ್ಯವಿಲ್ಲದಿರುವುದರಿಂದ ಒಳದ ಲೂಪ್ ಮುಕ್ತಾಯವಾಗುತ್ತದೆ ಮುಂದಿನ ಭವಿಷ್ಯವಾಣಿಗಾಗಿ. ನೀವು ಒಂದು ಪಟ್ಟಿಯಿಂದ ವಸ್ತುಗಳನ್ನು ಅಳಿಸಲಾಗದು ಅದನ್ನು ಮರುಹೊಂದುವಾಗ, ಆದ್ದರಿಂದ ಜೋಡಣೆಯು ಹೆಚ್ಚಾಗಿ ಇರುವ ಬಾಕ್ಸ್‌ಗಳನ್ನು `to_delete` ಪಟ್ಟಿಗೆ ಸೇರಿಸಿ ಕೊನೆಯಲ್ಲಿ ಅಳಿಸಲಾಗುವುದು.

    ಕೊನೆಗೆ ಸ್ಟಾಕ್ ಎಣಿಕೆ ಕಾನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿಸಲಾಗುತ್ತದೆ. ಇದನ್ನು ಬಳಿಕ IoT ಸೇವೆಗೆ ಕಳುಹಿಸಿ ಸ್ಟಾಕ್ ಮಟ್ಟಗಳು ಕಡಿಮೆ ಇದ್ದರೆ ಎಚ್ಚರಿಕೆ ನೀಡಬಹುದು. ಎಲ್ಲಾ ಈ ಕೋಡ್ ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳನ್ನು ರೇಖಿಸುವುದಕ್ಕೂ ಮುಂಚಿತದಲ್ಲಿದೆ, ಆದ್ದರಿಂದ ರಚಿಸಲಾದ ಚಿತ್ರಗಳಲ್ಲಿ ಜೋಡಣೆ ಇಲ್ಲದ ಸ್ಟಾಕ್ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ನೋಡಬಹುದು.

    > 💁 ಇದು ಸರಳ ವಿಧಾನ ಜೋಡಣೆಗಳನ್ನು ತೆಗೆದುಹಾಕಲು, ಒಟ್ಟಿಗೆ ಇದ್ದ ಜೋಡಿ ಮೊದಲದಲ್ಲಿಯೇ ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ. ಉತ್ಪಾದನಾ ಕೋಡ್‌ಗೆ ನೀವು ಇನ್ನಷ್ಟು ಲಾಜಿಕ್ ಸೇರಿಸಬೇಕಾಗಿರಬಹುದು, ಉದಾ: ಹಲವಾರು ವಸ್ತುಗಳ ಜೋಡಣೆಗಳನ್ನು ಪರಿಗಣಿಸುವುದು ಅಥವಾ ಒಬ್ಬ ಬಾಕ್ಸ್ ಇನ್ನೊಬ್ಬರಿಂದ ಒಳಗೊಂಡಿದ್ದರೆ.

1. ಕ್ಯಾಮೆರಾ ಬೇಲೆಯ ಮೇಲೆ ಕೆಲವು ಸ್ಟಾಕ್ ನೋಡುತ್ತಿರುವಂತೆ ಆಪ್ ಚಾಲನೆ ಮಾಡಿ. ಔಟ್‌ಪುಟ್ ಪಾರಮಿತಿ ಮೀರಿದ ಜೋಡಣೆ ಇಲ್ಲದ ಬಾಕ್ಸ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ. `overlap_threshold` ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಿ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸುವುದನ್ನು ಪ್ರಯತ್ನಿಸಿ.

> 💁 ನೀವು ಈ ಕೋಡ್ ಅನ್ನು [code-count/pi](../../../../../5-retail/lessons/2-check-stock-device/code-count/pi) ಅಥವಾ [code-count/virtual-iot-device](../../../../../5-retail/lessons/2-check-stock-device/code-count/virtual-iot-device) ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಕಾಣಬಹುದು.

😀 ನಿಮ್ಮ ಸ್ಟಾಕ್ ಎಣಿಕೆ ಯೋಜನೆ ಯಶಸ್ವಿಯಾಯಿತು!

---

<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಬೆಳವಣಿಗೆ**:
ಈ ದಸ್ತಾವೇಜನ್ನು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯನ್ನು ಪ್ರಯತ್ನಿಸಿದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರುವ ಸಾಧ್ಯತೆ ಇದೆ. ಮೂಲ ದಸ್ತಾವೇಜು ಅದರ ಸ್ವದೇಶಿ ಭಾಷೆಯಲ್ಲಿ ಅಧಿಕೃತ ಮೂಲ ಎಂದು ಪರಿಗಣಿಸಬೇಕು. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಬೌದ್ಧಿಕ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪಿಗೆ ನಾವು ಹೊಣೆಗಾರರಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->