# നിങ്ങളുടെ IoT ഡിവൈസിൽ നിന്ന് സ്റ്റോക്ക് എണ്ണുക - വെർച്വൽ IoT ഹാർഡ്‍വെയറും Raspberry Pi

ഒരു ചിത്രത്തിൽ സ്റ്റോക്ക് എണ്ണാൻ പ്രവചനങ്ങളും അവയുടെ ബൗണ്ടിംഗ് ബോക്സുകളും സംയോജിപ്പിച്ച് ഉപയോഗിക്കാം

## ബൗണ്ടിംഗ് ബോക്സുകൾ കാണിക്കുക

ഉപകാരപ്രദമായ ഒരു ഡീബഗ് ഘട്ടമായി, നിങ്ങൾ ബൗണ്ടിംഗ് ബോക്സുകൾ മാത്രമല്ല പ്രിന്റ് ചെയ്യാൻ, ചിത്രത്തിൽ എഴുതി നിലനിന്നതും വരയ്ക്കാം.

### ടാസ്‌ക് - ബൗണ്ടിംഗ് ബോക്സുകൾ പ്രിന്റ് ചെയ്യുക

1. `stock-counter` പ്രൊജക്റ്റ് VS Code-ൽ തുറന്നിരിക്കുകയാണ് എന്ന് ഉറപ്പാക്കുക, വെർച്വൽ 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')
    ```

    ഈ കോഡ് മുമ്പ് സംരക്ഷിച്ച ചിത്രമൊഴിച്ച് തുറക്കുന്നു എഡിറ്റിംഗിനായി. തുടർന്ന് predictions ലൂപ്പ് ചെയ്ത് ബൗണ്ടിംഗ് ബോക്സുകൾ സ്വീകരിച്ച്, 0-1 ശ്രେണിയിൽ നിന്നുള്ള ബൗണ്ടിംഗ് ബോക്സ് മൂല്യങ്ങൾ ഉപയോഗിച്ച് താഴെ വലതുവശത്തെ സംയോജനം കണക്കാക്കുന്നു. ഇത് ചിത്രത്തിന്റെ അനുയോജ്യമായ അളവിൽ ഗുണിച്ച് ഇമേജ് കോർഡിനേറ്റുകളായി മാറ്റുന്നു. ഉദാഹരണത്തിന്, ലെഫ്റ്റ് മൂല്യം 0.5 ആണെങ്കിൽ 600 പിക്‌സൽ വീതിയുള്ള ചിത്രത്തിൽ ഇത് 300 ആയി മാറും (0.5 x 600 = 300).

    ഓരോ ബൗണ്ടിംഗ് ബോക്സും ചുവപ്പ് ലൈനായും ചിത്രത്തിൽ വരയ്ക്കപ്പെടുന്നു. അവസാനം എഡിറ്റ് ചെയ്ത ചിത്രം സേവ് ചെയ്ത് ആദിപകൃതി ചിത്രം ഓവർറൈറ്റ് ചെയ്യുന്നു.

1. സഞ്ചാലനം നടത്തുന്നപ്പോൾ ക്യാമറ ഷെൽഫിലുള്ള സ്റ്റോക്കിലേക്കു നോക്കുന്നതായി ഉറപ്പാക്കുക. VS Code എക്സ്പ്ലോററിൽ `image.jpg` കണ്ടിട്ട് ബൗണ്ടിംഗ് ബോക്സുകൾ കാണാൻ അത് തിരഞ്ഞെടുക്കാം.

    ![ഓരോ കാൻസിനു ചുറ്റും ബൗണ്ടിംഗ് ബോക്സുകൾ ഉള്ള 4 ടാമേറ്റോ പേസ്റ്റ് കണ്ടെയ്‌നറുകള്‍](../../../../../translated_images/ml/rpi-stock-with-bounding-boxes.b5540e2ecb7cd49f.webp)

## സ്റ്റോക്ക് എണ്ണുക

മുകൾ കാണിച്ച ചിത്രത്തിൽ, ബൗണ്ടിംഗ് ബോക്സുകൾക്ക് ചെറിയ ഒവർലാപ്പ് ഉണ്ട്. ഈ ഒവർലാപ്പ് വളരെ കൂടുതലായാൽ ബൗണ്ടിംഗ് ബോക്സുകൾ ഒറ്റ ഒബ്‌ജെക്ട് സൂചിപ്പിക്കാവുന്നതാണ്. ഒബ്‌ജെക്ടുകൾ ശരിയായി എണ്ണാൻ, ഗണ്യമായ ഒവർലാപ്പുള്ള ബോക്സുകൾ അവഗണിക്കണം.

### ടാസ്‌ക് - ഒവർലാപ്പ് അവഗണിച്ച് സ്റ്റോക്ക് എണ്ണുക

1. മിഴിവുള്ള ഇന്റേഴ്‌സെക്ഷൻ കണക്കാക്കാൻ [Shapely](https://pypi.org/project/Shapely/) പിപ്പ് പാക്കേജ് ഉപയോഗിക്കാം. Raspberry Pi ഉപയോഗിച്ചുകണ്ടാൽ ആദ്യം ഒരു ലൈബ്രറി ഡിപ്പൻഡൻസി ഇൻസ്റ്റാൾ ചെയ്യേണ്ടി വരും:

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

1. Shapely പിപ്പ് പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുക:

    ```sh
    pip3 install shapely
    ```

    വെർച്വൽ IoT ഡിവൈസ് ഉപയോഗിച്ചാൽ സജീവമായ വെർച്വൽ എൻവയോൺമെന്റിൽ നിന്ന് ഇത് റൺ ചെയ്യുക.

1. `app.py` ഫയലിന്റെ മുകളിൽ താഴെ കാണുന്ന ഇൻപോർട്ട് സ്റ്റേറ്റുമെന്റ് ചേർക്കുക:

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

    ഒവർലാപ്പ് കണക്കാക്കാൻ പോളിഗോണുകൾ നിർമ്മിക്കാൻ ഈ കോഡ് ഇറക്കുമതി ചെയ്യുന്നു.

1. ബൗണ്ടിംഗ് ബോക്സ് വരയ്ക്കുന്നതിനു മുകളിൽ താഴെ കാണുന്ന കോഡ് ചേർക്കുക:

    ```python
    overlap_threshold = 0.20
    ```

    ബൗണ്ടിംഗ് ബോക്സുകൾ ഒരേ ഒബ്‌ജെക്ടായി കണക്കാക്കുന്നതിന് മുമ്പ് അനുവദിക്കുന്ന ഒവർലാപ്പ് ശതമാനം നിർവചിക്കുന്നു. 0.20 അർത്ഥം 20% ഒവർലാപ്പ് അനുവദിക്കുക.

1. Shapely ഉപയോഗിച്ച് ഒവർലാപ്പ് കണക്കാക്കാൻ, ബൗണ്ടിംഗ് ബോക്സുകൾ Shapely പോളിഗോണുകളായി പരിവർത്തനം ചെയ്യണം. ഇതിനായി താഴെ കാണുന്ന ഫങ്ഷൻ ചേർക്കുക:

    ```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. ഒവർലാപ്പ് ഉള്ള ഒബ്‌ജെക്ടുകൾ നീക്കം ചെയ്യാനുള്ള ലജിക് എല്ലാ ബൗണ്ടിംഗ് ബോക്സുകളും താരതമ്യം ചെയ്യുക. ഏതെങ്കിലും ബൗണ്ടിംഗ് ബോക്സ് ജോഡികളുടെ ഒവർലാപ്പ് ക്രമവും ദീർഘതയും ത്രേശോൾഡ് തികഞ്ഞാൽ prediction ഒന്നെണ്ണം നീക്കം ചെയ്യുക. എല്ലാ prediction-കളും താരതമ്യം ചെയ്യാൻ prediction 1-നെ 2, 3, 4 എന്നിവയുമായി, പിന്നെ prediction 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')
    ```

    ഒവർലാപ്പ് Shapely `Polygon.intersection` മെത്തഡ് ഉപയോഗിച്ച് കണക്കാക്കുന്നു, ഇത് ഒവർലാപ്പുള്ള പോളിഗൺ നൽകുന്നു. ഈ പോളിഗണിന്റെ ഏരിയ കണക്കാക്കിയ ശേഷം, ഓവർലാപ്പ് ത്രേശോൾഡിനും എത്ര ഏരിയ വരെ ഒപ്പം വെക്കാമെന്നത് കണക്കാക്കുന്നു. കുറഞ്ഞ ബൗണ്ടിംഗ് ബോക്സിന്റെ ശതമാനം ഒവർലാപ്പ് ത്രേശോൾഡിന്റെ അടിസ്ഥാനത്തിലാണ് ഇത്. ഓവർലാപ്പ് ഈ പരിധി വളരുന്ന പക്ഷം, prediction നീക്കം ചെയ്യാനുള്ളതായി അടയാളപ്പെടുത്തുന്നു.

    prediction നീക്കം ചെയ്യാനുള്ളതായി അടയാളപ്പെടുത്തിയ ശേഷം വീണ്ടും പരിശോധിക്കേണ്ടതില്ല, അതിനാൽ ഇന്റർണ്ണൽ ലൂപ്പ് പുറത്ത് പോയി അടുത്ത prediction പരിശോധിക്കും. ലിസ്റ്റ് ഇറ്ററേറ്റ് ചെയ്യുമ്പോൾ ഇനങ്ങൾ നീക്കം ചെയ്യാനാകാത്തതിനാൽ, threshold-കിടക്കുന്ന ബൗണ്ടിംഗ് ബോക്സുകൾ `to_delete` ലിസ്റ്റ്‌ക്കു ചേർക്കുകയും അവസാനം നീക്കം ചെയ്യുകയും ചെയ്യുന്നു.

    അവസാനം സ്റ്റോക്ക് എണ്ണം കൺസോളിൽ പ്രിന്റ് ചെയ്യും. ഇത് തുടർന്നും IoT സേവനത്തിലേക്ക് അയച്ച് സ്റ്റോക്ക് കുറവാണെന്ന് മുന്നറിയിപ്പ് നൽകാനും കഴിയും. ഈ മുഴുവൻ കോഡ് ബൗണ്ടിംഗ് ബോക്സുകൾ വരയ്ക്കുന്നതിനുമുൻപേ നടക്കുന്നതിനാൽ, ഒവർലാപ്പുകൾ ഇല്ലാത്ത സ്റ്റോക്ക് പ്രവചനങ്ങൾ വരച്ച് നിർമ്മിത ചിത്രങ്ങളിൽ കാണാം.

    > 💁 ഇത് ഒവർലാപ്പുകൾ നീക്കം ചെയ്യാനുള്ള വളരെ ലളിതമായ മാർഗമാണ്, ഒവർലാപ്പുള്ള ജോഡികളിൽ ആദ്യം ഒന്നിനെ നീക്കം ചെയ്യുക മാത്രമാണ്. പ്രൊഡക്ഷൻ കോഡിനായി, ഒവർലാപ്പുകൾ തമ്മിൽ കൂടുതൽ ലജികുകൾ ഉൾപ്പെടുത്തണം, ഉദാ: ഒരേ സമയം ഉള്ള പല ഒബ്‌ജെക്ടുകളുടെ ഒവർലാപ്പുകൾ പരിഗണിക്കുക അല്ലെങ്കിൽ ഒരു ബൗണ്ടിംഗ് ബോക്സ് മറ്റൊന്നിലേക്ക് അടങ്ങിയിട്ടുണ്ടോ എന്നത് പരിശോധിക്കുക.

1. ക്യാമറ ഷെൽഫിലുള്ള സ്റ്റോക്കിലേക്കു നോക്കിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കി ആപ്പ് സഞ്ചാലിപ്പിക്കുക. threshold കാൾക്കു മുകളിൽ ഒവർലാപ്പുകൾ ഇല്ലാത്ത ബൗണ്ടിംഗ് ബോക്സുകളുടെ എണ്ണം ഔട്ട്‌പുട്ട് കാണിക്കും. prediction ഒഴിവാക്കുന്നത് കാണാൻ `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 -->