You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
170 lines
18 KiB
170 lines
18 KiB
# ನಿಮ್ಮ 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` ಫೈಲ್ ಅನ್ನು ಕಾಣಬಹುದು, ಮತ್ತು ಅದನ್ನು ಆರಿಸಿ ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್ಗಳನ್ನು ನೋಡಬಹುದಾಗಿದೆ.
|
|
|
|
|
|
|
|
## ಸ್ಟಾಕ್ ಎಣಿಕೆ
|
|
|
|
ಮೇಲಿನ ಚಿತ್ರದಲ್ಲಿ ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್ಗಳಿಗೆ ಸ್ವಲ್ಪ ಜೋಡಣೆ ಇದೆ. ಈ ಜೋಡಣೆ ತುಂಬು ದೊಡ್ಡದಾಗಿದ್ದರೆ, ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್ಗಳು ಒಬ್ಬೇ ವಸ್ತುವನ್ನು ಸೂಚಿಸಬಹುದು. ವಸ್ತುಗಳನ್ನು ಸರಿಯಾಗಿ ಎಣಿಸಲು ನೀವು ಮಹತ್ವದ ಜೋಡಣೆಯಿರುವ ಬಾಕ್ಸ್ಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸಬೇಕಾಗುತ್ತದೆ.
|
|
|
|
### ಕಾರ್ಯ - ಜೋಡಣೆ ನಿರ್ಲಕ್ಷಿಸಿ ಸ್ಟಾಕ್ ಎಣಿಸಿ
|
|
|
|
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 --> |