# Precision and Recall missunderstanding

Hi, can somebody explain me what is these: T,R,K,A,M? I’m confused
In `cocoeval.py` :

`````````
T           = len(p.iouThrs)
R           = len(p.recThrs)
K           = len(p.catIds) if p.useCats else 1
A           = len(p.areaRng)
M           = len(p.maxDets)
precision   = -np.ones((T,R,K,A,M)) # -1 for the precision of absent categories
recall      = -np.ones((T,K,A,M))
scores      = -np.ones((T,R,K,A,M))
``````

Why is `recall `use just T,K,A,M without R??

In code below, what is `npig`, because in recall calculation there is tp/npig → but recall is calculated by formula: Tp/(Tp+Fn), so where are Fn?

``````npig = np.count_nonzero(gtIg==0 )
if npig == 0:
continue
tps = np.logical_and(               dtm,  np.logical_not(dtIg) )
fps = np.logical_and(np.logical_not(dtm), np.logical_not(dtIg) )

tp_sum = np.cumsum(tps, axis=1).astype(dtype=float)
fp_sum = np.cumsum(fps, axis=1).astype(dtype=float)
for t, (tp, fp) in enumerate(zip(tp_sum, fp_sum)):
tp = np.array(tp)
fp = np.array(fp)
nd = len(tp)
rc = tp / npig
pr = tp / (fp+tp+np.spacing(1))
q  = np.zeros((R,))
ss = np.zeros((R,))

if nd:
recall[t,k,a,m] = rc[-1]
else:
recall[t,k,a,m] = 0

# numpy is slow without cython optimization for accessing elements
# use python array gets significant speed improvement
pr = pr.tolist(); q = q.tolist()

for i in range(nd-1, 0, -1):
if pr[i] > pr[i-1]:
pr[i-1] = pr[i]

inds = np.searchsorted(rc, p.recThrs, side='left')
try:
for ri, pi in enumerate(inds):
q[ri] = pr[pi]
ss[ri] = dtScoresSorted[pi]
except:
pass
precision[t,:,k,a,m] = np.array(q)
scores[t,:,k,a,m] = np.array(ss)
``````

Or just can someone help me to realize how can I return and print `precision `and `recall `values?