|
|
<!--
|
|
|
CO_OP_TRANSLATOR_METADATA:
|
|
|
{
|
|
|
"original_hash": "1b560955ff39a2bcf2a049fce474a951",
|
|
|
"translation_date": "2025-09-05T19:19:55+00:00",
|
|
|
"source_file": "2-Working-With-Data/08-data-preparation/README.md",
|
|
|
"language_code": "hr"
|
|
|
}
|
|
|
-->
|
|
|
# Rad s podacima: Priprema podataka
|
|
|
|
|
|
| ](../../sketchnotes/08-DataPreparation.png)|
|
|
|
|:---:|
|
|
|
|Priprema podataka - _Sketchnote by [@nitya](https://twitter.com/nitya)_ |
|
|
|
|
|
|
## [Pre-Lecture Quiz](https://ff-quizzes.netlify.app/en/ds/quiz/14)
|
|
|
|
|
|
Ovisno o izvoru, sirovi podaci mogu sadržavati neke nedosljednosti koje će uzrokovati poteškoće u analizi i modeliranju. Drugim riječima, ti podaci mogu biti kategorizirani kao "nečisti" i potrebno ih je očistiti. Ova lekcija fokusira se na tehnike čišćenja i transformacije podataka kako bi se riješili problemi s nedostajućim, netočnim ili nepotpunim podacima. Teme obrađene u ovoj lekciji koriste Python i biblioteku Pandas te će biti [prikazane u bilježnici](../../../../2-Working-With-Data/08-data-preparation/notebook.ipynb) unutar ovog direktorija.
|
|
|
|
|
|
## Važnost čišćenja podataka
|
|
|
|
|
|
- **Jednostavnost korištenja i ponovne upotrebe**: Kada su podaci pravilno organizirani i normalizirani, lakše ih je pretraživati, koristiti i dijeliti s drugima.
|
|
|
|
|
|
- **Dosljednost**: Znanost o podacima često zahtijeva rad s više skupova podataka, gdje se skupovi podataka iz različitih izvora moraju spojiti. Osiguravanje da svaki pojedini skup podataka ima zajedničku standardizaciju osigurava da podaci ostanu korisni kada se svi spoje u jedan skup podataka.
|
|
|
|
|
|
- **Točnost modela**: Očišćeni podaci poboljšavaju točnost modela koji se na njih oslanjaju.
|
|
|
|
|
|
## Uobičajeni ciljevi i strategije čišćenja
|
|
|
|
|
|
- **Istraživanje skupa podataka**: Istraživanje podataka, koje je obrađeno u [kasnijoj lekciji](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/4-Data-Science-Lifecycle/15-analyzing), može vam pomoći otkriti podatke koje treba očistiti. Vizualno promatranje vrijednosti unutar skupa podataka može postaviti očekivanja o tome kako ostatak izgleda ili pružiti ideju o problemima koji se mogu riješiti. Istraživanje može uključivati osnovne upite, vizualizacije i uzorkovanje.
|
|
|
|
|
|
- **Formatiranje**: Ovisno o izvoru, podaci mogu imati nedosljednosti u načinu na koji su predstavljeni. To može uzrokovati probleme u pretraživanju i prikazivanju vrijednosti, gdje se vidi unutar skupa podataka, ali nije pravilno prikazano u vizualizacijama ili rezultatima upita. Uobičajeni problemi s formatiranjem uključuju rješavanje razmaka, datuma i tipova podataka. Rješavanje problema s formatiranjem obično je odgovornost korisnika podataka. Na primjer, standardi o tome kako se datumi i brojevi prikazuju mogu se razlikovati od zemlje do zemlje.
|
|
|
|
|
|
- **Duplikati**: Podaci koji se pojavljuju više puta mogu proizvesti netočne rezultate i obično ih treba ukloniti. Ovo je česta pojava kada se spajaju dva ili više skupova podataka. Međutim, postoje slučajevi kada duplikati u spojenim skupovima podataka sadrže dijelove koji mogu pružiti dodatne informacije i možda ih treba sačuvati.
|
|
|
|
|
|
- **Nedostajući podaci**: Nedostajući podaci mogu uzrokovati netočnosti, kao i slabe ili pristrane rezultate. Ponekad se to može riješiti "ponovnim učitavanjem" podataka, popunjavanjem nedostajućih vrijednosti pomoću izračuna i koda poput Pythona ili jednostavno uklanjanjem vrijednosti i pripadajućih podataka. Postoji mnogo razloga zašto podaci mogu nedostajati, a radnje koje se poduzimaju za rješavanje tih nedostajućih vrijednosti mogu ovisiti o tome kako i zašto su nestali.
|
|
|
|
|
|
## Istraživanje informacija o DataFrameu
|
|
|
> **Cilj učenja:** Na kraju ovog pododjeljka trebali biste biti ugodni u pronalaženju općih informacija o podacima pohranjenim u pandas DataFrameovima.
|
|
|
|
|
|
Kada učitate svoje podatke u pandas, oni će najvjerojatnije biti u DataFrameu (pogledajte prethodnu [lekciju](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/2-Working-With-Data/07-python#dataframe) za detaljan pregled). Međutim, ako skup podataka u vašem DataFrameu ima 60.000 redaka i 400 stupaca, kako uopće početi dobivati osjećaj za ono s čime radite? Srećom, [pandas](https://pandas.pydata.org/) pruža neke praktične alate za brzo pregledavanje općih informacija o DataFrameu, uz prve i posljednje retke.
|
|
|
|
|
|
Kako bismo istražili ovu funkcionalnost, uvest ćemo Python biblioteku scikit-learn i koristiti poznati skup podataka: **Iris dataset**.
|
|
|
|
|
|
```python
|
|
|
import pandas as pd
|
|
|
from sklearn.datasets import load_iris
|
|
|
|
|
|
iris = load_iris()
|
|
|
iris_df = pd.DataFrame(data=iris['data'], columns=iris['feature_names'])
|
|
|
```
|
|
|
| |dužina čaške (cm)|širina čaške (cm)|dužina latice (cm)|širina latice (cm)|
|
|
|
|----------------------------------------|-----------------|----------------|-----------------|----------------|
|
|
|
|0 |5.1 |3.5 |1.4 |0.2 |
|
|
|
|1 |4.9 |3.0 |1.4 |0.2 |
|
|
|
|2 |4.7 |3.2 |1.3 |0.2 |
|
|
|
|3 |4.6 |3.1 |1.5 |0.2 |
|
|
|
|4 |5.0 |3.6 |1.4 |0.2 |
|
|
|
|
|
|
- **DataFrame.info**: Za početak, metoda `info()` koristi se za ispis sažetka sadržaja prisutnog u `DataFrameu`. Pogledajmo ovaj skup podataka kako bismo vidjeli što imamo:
|
|
|
```python
|
|
|
iris_df.info()
|
|
|
```
|
|
|
```
|
|
|
RangeIndex: 150 entries, 0 to 149
|
|
|
Data columns (total 4 columns):
|
|
|
# Column Non-Null Count Dtype
|
|
|
--- ------ -------------- -----
|
|
|
0 sepal length (cm) 150 non-null float64
|
|
|
1 sepal width (cm) 150 non-null float64
|
|
|
2 petal length (cm) 150 non-null float64
|
|
|
3 petal width (cm) 150 non-null float64
|
|
|
dtypes: float64(4)
|
|
|
memory usage: 4.8 KB
|
|
|
```
|
|
|
Iz ovoga znamo da skup podataka *Iris* ima 150 unosa u četiri stupca bez praznih unosa. Svi podaci pohranjeni su kao 64-bitni brojevi s pomičnim zarezom.
|
|
|
|
|
|
- **DataFrame.head()**: Zatim, kako bismo provjerili stvarni sadržaj `DataFramea`, koristimo metodu `head()`. Pogledajmo kako izgledaju prvi redovi našeg `iris_df`:
|
|
|
```python
|
|
|
iris_df.head()
|
|
|
```
|
|
|
```
|
|
|
sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)
|
|
|
0 5.1 3.5 1.4 0.2
|
|
|
1 4.9 3.0 1.4 0.2
|
|
|
2 4.7 3.2 1.3 0.2
|
|
|
3 4.6 3.1 1.5 0.2
|
|
|
4 5.0 3.6 1.4 0.2
|
|
|
```
|
|
|
- **DataFrame.tail()**: Suprotno tome, kako bismo provjerili posljednje redove `DataFramea`, koristimo metodu `tail()`:
|
|
|
```python
|
|
|
iris_df.tail()
|
|
|
```
|
|
|
```
|
|
|
sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)
|
|
|
145 6.7 3.0 5.2 2.3
|
|
|
146 6.3 2.5 5.0 1.9
|
|
|
147 6.5 3.0 5.2 2.0
|
|
|
148 6.2 3.4 5.4 2.3
|
|
|
149 5.9 3.0 5.1 1.8
|
|
|
```
|
|
|
> **Zaključak:** Čak i samo promatranjem metapodataka o informacijama u DataFrameu ili prvih i posljednjih vrijednosti u njemu, možete odmah dobiti ideju o veličini, obliku i sadržaju podataka s kojima radite.
|
|
|
|
|
|
## Rješavanje nedostajućih podataka
|
|
|
> **Cilj učenja:** Na kraju ovog pododjeljka trebali biste znati kako zamijeniti ili ukloniti prazne vrijednosti iz DataFrameova.
|
|
|
|
|
|
Većinu vremena skupovi podataka koje želite koristiti (ili morate koristiti) imaju nedostajuće vrijednosti. Način na koji se nedostajući podaci obrađuju nosi suptilne kompromise koji mogu utjecati na vašu konačnu analizu i stvarne rezultate.
|
|
|
|
|
|
Pandas obrađuje nedostajuće vrijednosti na dva načina. Prvi ste već vidjeli u prethodnim odjeljcima: `NaN`, ili Not a Number. Ovo je zapravo posebna vrijednost koja je dio IEEE specifikacije za brojeve s pomičnim zarezom i koristi se samo za označavanje nedostajućih vrijednosti s pomičnim zarezom.
|
|
|
|
|
|
Za nedostajuće vrijednosti osim brojeva s pomičnim zarezom, pandas koristi Python objekt `None`. Iako se može činiti zbunjujućim da ćete naići na dvije različite vrste vrijednosti koje u osnovi govore isto, postoje dobri programerski razlozi za ovaj dizajnerski izbor i, u praksi, ovaj pristup omogućuje pandasu da pruži dobar kompromis za veliku većinu slučajeva. Bez obzira na to, i `None` i `NaN` imaju ograničenja koja morate imati na umu u vezi s načinom na koji se mogu koristiti.
|
|
|
|
|
|
Pogledajte više o `NaN` i `None` u [bilježnici](https://github.com/microsoft/Data-Science-For-Beginners/blob/main/4-Data-Science-Lifecycle/15-analyzing/notebook.ipynb)!
|
|
|
|
|
|
- **Otkrivanje praznih vrijednosti**: U `pandas`, metode `isnull()` i `notnull()` su vaše primarne metode za otkrivanje praznih podataka. Obje vraćaju Booleove maske nad vašim podacima. Koristit ćemo `numpy` za `NaN` vrijednosti:
|
|
|
```python
|
|
|
import numpy as np
|
|
|
|
|
|
example1 = pd.Series([0, np.nan, '', None])
|
|
|
example1.isnull()
|
|
|
```
|
|
|
```
|
|
|
0 False
|
|
|
1 True
|
|
|
2 False
|
|
|
3 True
|
|
|
dtype: bool
|
|
|
```
|
|
|
Pogledajte pažljivo izlaz. Iznenađuje li vas nešto? Iako je `0` aritmetički nula, ipak je savršen cijeli broj i pandas ga tako tretira. `''` je malo suptilniji. Iako smo ga koristili u odjeljku 1 za predstavljanje prazne vrijednosti niza, ipak je objekt niza i nije predstavljanje prazne vrijednosti prema pandas.
|
|
|
|
|
|
Sada, okrenimo ovo i koristimo ove metode na način koji je sličniji onome kako ćete ih koristiti u praksi. Možete koristiti Booleove maske izravno kao indeks ``Series`` ili ``DataFrame``, što može biti korisno kada pokušavate raditi s izoliranim nedostajućim (ili prisutnim) vrijednostima.
|
|
|
|
|
|
> **Zaključak**: Obje metode `isnull()` i `notnull()` daju slične rezultate kada ih koristite u `DataFrameovima`: prikazuju rezultate i indeks tih rezultata, što će vam uvelike pomoći dok se borite s vašim podacima.
|
|
|
|
|
|
- **Uklanjanje praznih vrijednosti**: Osim identificiranja nedostajućih vrijednosti, pandas pruža praktičan način za uklanjanje praznih vrijednosti iz `Series` i `DataFrameova`. (Posebno kod velikih skupova podataka, često je preporučljivije jednostavno ukloniti nedostajuće [NA] vrijednosti iz vaše analize nego se baviti njima na druge načine.) Kako bismo to vidjeli u praksi, vratimo se na `example1`:
|
|
|
```python
|
|
|
example1 = example1.dropna()
|
|
|
example1
|
|
|
```
|
|
|
```
|
|
|
0 0
|
|
|
2
|
|
|
dtype: object
|
|
|
```
|
|
|
Primijetite da bi ovo trebalo izgledati kao vaš izlaz iz `example3[example3.notnull()]`. Razlika ovdje je u tome što, umjesto da samo indeksira na maskirane vrijednosti, `dropna` je uklonio te nedostajuće vrijednosti iz `Series` `example1`.
|
|
|
|
|
|
Budući da `DataFrameovi` imaju dvije dimenzije, oni omogućuju više opcija za uklanjanje podataka.
|
|
|
|
|
|
```python
|
|
|
example2 = pd.DataFrame([[1, np.nan, 7],
|
|
|
[2, 5, 8],
|
|
|
[np.nan, 6, 9]])
|
|
|
example2
|
|
|
```
|
|
|
| | 0 | 1 | 2 |
|
|
|
|------|---|---|---|
|
|
|
|0 |1.0|NaN|7 |
|
|
|
|1 |2.0|5.0|8 |
|
|
|
|2 |NaN|6.0|9 |
|
|
|
|
|
|
(Jeste li primijetili da je pandas promijenio dva stupca u brojeve s pomičnim zarezom kako bi prilagodio `NaN`?)
|
|
|
|
|
|
Ne možete ukloniti jednu vrijednost iz `DataFramea`, pa morate ukloniti cijele retke ili stupce. Ovisno o tome što radite, možda ćete htjeti učiniti jedno ili drugo, pa pandas daje opcije za oba. Budući da u znanosti o podacima stupci općenito predstavljaju varijable, a redovi predstavljaju opažanja, vjerojatnije je da ćete ukloniti retke podataka; zadana postavka za `dropna()` je uklanjanje svih redaka koji sadrže bilo koje prazne vrijednosti:
|
|
|
|
|
|
```python
|
|
|
example2.dropna()
|
|
|
```
|
|
|
```
|
|
|
0 1 2
|
|
|
1 2.0 5.0 8
|
|
|
```
|
|
|
Ako je potrebno, možete ukloniti NA vrijednosti iz stupaca. Koristite `axis=1` za to:
|
|
|
```python
|
|
|
example2.dropna(axis='columns')
|
|
|
```
|
|
|
```
|
|
|
2
|
|
|
0 7
|
|
|
1 8
|
|
|
2 9
|
|
|
```
|
|
|
Primijetite da ovo može ukloniti puno podataka koje možda želite zadržati, posebno u manjim skupovima podataka. Što ako želite ukloniti samo retke ili stupce koji sadrže nekoliko ili čak sve prazne vrijednosti? Te postavke možete odrediti u `dropna` pomoću parametara `how` i `thresh`.
|
|
|
|
|
|
Prema zadanim postavkama, `how='any'` (ako želite provjeriti sami ili vidjeti koje druge parametre metoda ima, pokrenite `example4.dropna?` u ćeliji koda). Alternativno, možete odrediti `how='all'` kako biste uklonili samo retke ili stupce koji sadrže sve prazne vrijednosti. Proširimo naš primjer `DataFrame` kako bismo to vidjeli u praksi.
|
|
|
|
|
|
```python
|
|
|
example2[3] = np.nan
|
|
|
example2
|
|
|
```
|
|
|
| |0 |1 |2 |3 |
|
|
|
|------|---|---|---|---|
|
|
|
|0 |1.0|NaN|7 |NaN|
|
|
|
|1 |2.0|5.0|8 |NaN|
|
|
|
|2 |NaN|6.0|9 |NaN|
|
|
|
|
|
|
Parametar `thresh` daje vam precizniju kontrolu: postavljate broj *ne-praznih* vrijednosti koje redak ili stupac mora imati kako bi bio zadržan:
|
|
|
```python
|
|
|
example2.dropna(axis='rows', thresh=3)
|
|
|
```
|
|
|
```
|
|
|
0 1 2 3
|
|
|
1 2.0 5.0 8 NaN
|
|
|
```
|
|
|
Ovdje su prvi i posljednji redak uklonjeni jer sadrže samo dvije ne-prazne vrijednosti.
|
|
|
|
|
|
- **Popunjavanje praznih vrijednosti**: Ovisno o vašem skupu podataka, ponekad može imati više smisla popuniti prazne vrijednosti valjanima nego ih ukloniti. Mogli biste koristiti `isnull` za to na licu mjesta, ali to može biti zamorno, posebno ako imate puno vrijednosti za popuniti. Budući da je ovo tako čest zadatak u znanosti o podacima, pandas pruža `fillna`, koji vraća kopiju `Series` ili `DataFramea` s nedostajućim vrijednostima zamijenjenim onima koje odaberete. Stvorimo još jedan primjer `Series` kako bismo vidjeli kako ovo funkcionira u praksi.
|
|
|
```python
|
|
|
example3 = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'))
|
|
|
example3
|
|
|
```
|
|
|
```
|
|
|
a 1.0
|
|
|
b NaN
|
|
|
c 2.0
|
|
|
d NaN
|
|
|
e 3.0
|
|
|
dtype: float64
|
|
|
```
|
|
|
Možete popuniti sve prazne unose jednom vrijednošću, poput `0`:
|
|
|
```python
|
|
|
example3.fillna(0)
|
|
|
```
|
|
|
```
|
|
|
a 1.0
|
|
|
b 0.0
|
|
|
c 2.0
|
|
|
d 0.0
|
|
|
e 3.0
|
|
|
dtype: float64
|
|
|
```
|
|
|
Možete **popuniti unaprijed** prazne vrijednosti, koristeći posljednju valjanu vrijednost za popunjavanje prazne:
|
|
|
```python
|
|
|
example3.fillna(method='ffill')
|
|
|
```
|
|
|
```
|
|
|
a 1.0
|
|
|
b 1.0
|
|
|
c 2.0
|
|
|
d 2.0
|
|
|
e 3.0
|
|
|
dtype: float64
|
|
|
```
|
|
|
Također možete **popuniti unatrag** kako biste propagirali sljedeću valjanu vrijednost unatrag za popunjavanje prazne:
|
|
|
```python
|
|
|
example3.fillna(method='bfill')
|
|
|
```
|
|
|
```
|
|
|
a 1.0
|
|
|
b 2.0
|
|
|
c 2.0
|
|
|
d 3.0
|
|
|
e 3.0
|
|
|
dtype: float64
|
|
|
```
|
|
|
Kao što možete pretpostaviti, ovo funkcionira isto s `DataFrameovima`, ali također možete odrediti `axis` duž kojeg želite popuniti prazne vrijednosti. Koristeći ponovno prethodno korišteni `example2`:
|
|
|
```python
|
|
|
example2.fillna(method='ffill', axis=1)
|
|
|
```
|
|
|
```
|
|
|
0 1 2 3
|
|
|
0 1.0 1.0 7.0 7.0
|
|
|
1 2.0 5.0 8.0 8.0
|
|
|
2 NaN 6.0 9.0 9.0
|
|
|
```
|
|
|
Primijetite da kada prethodna vrijednost nije dostupna za popunjavanje unaprijed, prazna vrijednost ostaje.
|
|
|
> **Zaključak:** Postoji više načina za rješavanje nedostajućih vrijednosti u vašim skupovima podataka. Konkretna strategija koju koristite (uklanjanje, zamjena ili način na koji ih zamjenjujete) trebala bi biti određena specifičnostima tih podataka. Razvijat ćete bolji osjećaj za rješavanje nedostajućih vrijednosti što više radite s i analizirate skupove podataka.
|
|
|
## Uklanjanje dupliciranih podataka
|
|
|
|
|
|
> **Cilj učenja:** Na kraju ovog pododjeljka, trebali biste biti sposobni prepoznati i ukloniti duplicirane vrijednosti iz DataFrameova.
|
|
|
|
|
|
Osim nedostajućih podataka, često ćete naići na duplicirane podatke u stvarnim skupovima podataka. Srećom, `pandas` pruža jednostavan način za otkrivanje i uklanjanje dupliciranih unosa.
|
|
|
|
|
|
- **Prepoznavanje duplikata: `duplicated`**: Lako možete uočiti duplicirane vrijednosti koristeći metodu `duplicated` u pandas, koja vraća Booleovu masku koja pokazuje je li unos u `DataFrameu` duplikat ranijeg unosa. Napravimo još jedan primjer `DataFramea` kako bismo to vidjeli u praksi.
|
|
|
```python
|
|
|
example4 = pd.DataFrame({'letters': ['A','B'] * 2 + ['B'],
|
|
|
'numbers': [1, 2, 1, 3, 3]})
|
|
|
example4
|
|
|
```
|
|
|
| |letters|numbers|
|
|
|
|------|-------|-------|
|
|
|
|0 |A |1 |
|
|
|
|1 |B |2 |
|
|
|
|2 |A |1 |
|
|
|
|3 |B |3 |
|
|
|
|4 |B |3 |
|
|
|
|
|
|
```python
|
|
|
example4.duplicated()
|
|
|
```
|
|
|
```
|
|
|
0 False
|
|
|
1 False
|
|
|
2 True
|
|
|
3 False
|
|
|
4 True
|
|
|
dtype: bool
|
|
|
```
|
|
|
- **Uklanjanje duplikata: `drop_duplicates`:** jednostavno vraća kopiju podataka za koje su sve vrijednosti označene kao `duplicated` `False`:
|
|
|
```python
|
|
|
example4.drop_duplicates()
|
|
|
```
|
|
|
```
|
|
|
letters numbers
|
|
|
0 A 1
|
|
|
1 B 2
|
|
|
3 B 3
|
|
|
```
|
|
|
Obje metode, `duplicated` i `drop_duplicates`, prema zadanim postavkama uzimaju u obzir sve stupce, ali možete odrediti da pregledaju samo podskup stupaca u vašem `DataFrameu`:
|
|
|
```python
|
|
|
example4.drop_duplicates(['letters'])
|
|
|
```
|
|
|
```
|
|
|
letters numbers
|
|
|
0 A 1
|
|
|
1 B 2
|
|
|
```
|
|
|
|
|
|
> **Zaključak:** Uklanjanje dupliciranih podataka ključni je dio gotovo svakog projekta u području znanosti o podacima. Duplicirani podaci mogu promijeniti rezultate vaših analiza i dovesti do netočnih zaključaka!
|
|
|
|
|
|
|
|
|
## 🚀 Izazov
|
|
|
|
|
|
Svi materijali koji su obrađeni dostupni su kao [Jupyter Notebook](https://github.com/microsoft/Data-Science-For-Beginners/blob/main/2-Working-With-Data/08-data-preparation/notebook.ipynb). Osim toga, nakon svakog odjeljka nalaze se vježbe – isprobajte ih!
|
|
|
|
|
|
## [Kviz nakon predavanja](https://ff-quizzes.netlify.app/en/ds/quiz/15)
|
|
|
|
|
|
|
|
|
|
|
|
## Pregled i samostalno učenje
|
|
|
|
|
|
Postoji mnogo načina za otkrivanje i pristup pripremi vaših podataka za analizu i modeliranje, a čišćenje podataka važan je korak koji zahtijeva praktično iskustvo. Isprobajte ove izazove na Kaggleu kako biste istražili tehnike koje nisu obuhvaćene ovom lekcijom.
|
|
|
|
|
|
- [Izazov čišćenja podataka: Parsiranje datuma](https://www.kaggle.com/rtatman/data-cleaning-challenge-parsing-dates/)
|
|
|
|
|
|
- [Izazov čišćenja podataka: Skaliranje i normalizacija podataka](https://www.kaggle.com/rtatman/data-cleaning-challenge-scale-and-normalize-data)
|
|
|
|
|
|
|
|
|
## Zadatak
|
|
|
|
|
|
[Procjena podataka iz obrasca](assignment.md)
|
|
|
|
|
|
---
|
|
|
|
|
|
**Odricanje od odgovornosti**:
|
|
|
Ovaj dokument je preveden pomoću AI usluge za prevođenje [Co-op Translator](https://github.com/Azure/co-op-translator). Iako nastojimo osigurati točnost, imajte na umu da automatski prijevodi mogu sadržavati pogreške ili netočnosti. Izvorni dokument na izvornom jeziku treba smatrati autoritativnim izvorom. Za ključne informacije preporučuje se profesionalni prijevod od strane čovjeka. Ne preuzimamo odgovornost za bilo kakva nesporazuma ili pogrešna tumačenja koja proizlaze iz korištenja ovog prijevoda. |
