Rename .target to .label and class

Author: leonmavr

README.md

@@ -24,7 +24,7 @@ You can install the package as follows:
 cd <project_root>
 pip install .
 ```
-Next, you can import the package as `import ezfaces` or its main class as `from ezfaces.face_classifier import faceClassifier`.  
+Next, you can import the package as `import ezfaces` or its main class as `from ezfaces.face_classifier import FaceClassifier`.  
 
 
 The project has been tested in CI (see [workflows](https://github.com/0xLeo/EZfaces/tree/master/.github/workflows)) in Python 3.7 and 3.8 with the following dependencies installed, but newer versions will also work:
@@ -41,9 +41,9 @@ scikit-learn 0.22
 # Usage examples
 **1. Load new subject from folder**
 ```
-from ezfaces.face_classifier import faceClassifier
+from ezfaces.face_classifier import FaceClassifier
 
-fc = faceClassifier()
+fc = FaceClassifier()
 lbl_new = fc.add_img_data('tests/images_yale')
 print(fc)
 print("New subject\'s label is %d" % lbl_new)
@@ -57,11 +57,11 @@ New subject's label is 40
 
 **2. Load new subject and predict from webcam**
 ```
-from from ezfaces.face_classifier import faceClassifier
+from from ezfaces.face_classifier import FaceClassifier
 import cv2
 
 
-fc = faceClassifier()
+fc = FaceClassifier()
 lbl_new = fc.add_img_data(from_webcam=True)
 fc.train()
 # take a snapshot from webcam
@@ -78,18 +78,18 @@ cv2.destroyAllWindows()
 
 **3. Export and import dataset**
 ```
-from ezfaces.face_classifier import faceClassifier
+from ezfaces.face_classifier import FaceClassifier
 
 
-fc = faceClassifier()
+fc = FaceClassifier()
 data_file, lbl_file = fc.export('/tmp')
 
 # add some data
 lbl_new = fc.add_img_data('tests/images_yale')
 print(fc)
 
 # now let's say we made a mistake and don't like the new data
-fc = faceClassifier(data_pkl = data_file, target_pkl = lbl_file)
+fc = FaceClassifier(data_pkl = data_file, target_pkl = lbl_file)
 print(fc)
 ```
 Output:

ezfaces/__init__.py

@@ -1,2 +1,2 @@
 # __init__.py
-from .face_classifier import faceClassifier
+from .face_classifier import FaceClassifier

ezfaces/face_classifier.py

@@ -12,7 +12,7 @@
 from typing import List, Tuple
 
 
-class faceClassifier():
+class FaceClassifier():
     def __init__(self, ratio = 0.85, K = 200, data_pkl = None, target_pkl = None):
         """__init__. Class constructor.
 
@@ -34,9 +34,9 @@ def __init__(self, ratio = 0.85, K = 200, data_pkl = None, target_pkl = None):
             self.data = None        # data vectors
         if target_pkl is not None:
             with open(target_pkl, 'rb') as f:
-                self.target = pkl.load(f)
+                self.labels = pkl.load(f)
         else:
-            self.target = None      # label (ground truth) vectors
+            self.labels = None      # label (ground truth) vectors
         self.train_data = OD()      # maps sample index to data and label
         self.test_data = OD()       # maps sample index to data and label
         # how many eigenfaces to keep
@@ -48,7 +48,7 @@ def __init__(self, ratio = 0.85, K = 200, data_pkl = None, target_pkl = None):
         self.classification_report = None # obtained from benchmarking
         # mean needed for reconstruction
         self._mean = np.zeros((1, 64*64), dtype=np.float32)
-        if self.data is None and self.target is None: # no pre-loaded data
+        if self.data is None and self.labels is None: # no pre-loaded data
             self._load_olivetti_data()
         self._TRAIN_SAMPLE = 1
         self._PRED_SAMPLE = 0
@@ -67,7 +67,7 @@ def _load_olivetti_data(self):
         # data as floating vectors of length 64^2, ranging from 0 to 1
         self.data = np.array(data)
         # subject labels (sequential from to 0 to ...)
-        self.target = target
+        self.labels = target
 
 
     def _record_mean(self):
@@ -112,7 +112,7 @@ def _read_from_webcam(self, new_label, stream = 0):
                 cv2.destroyWindow("new data")
                 x = self.img2vec(im_cropped)
                 self.data = np.array([*self.data, np.array(x, dtype=np.float32)])
-                self.target = np.append(self.target, new_label)
+                self.labels = np.append(self.labels, new_label)
         cap.release()
         cv2.destroyAllWindows()
 
@@ -132,14 +132,14 @@ def add_img_data(self, dir_img: str = "", from_webcam: bool = False) -> int:
         int
             The label of the newly added subject.
         """
-        assert len(self.target) != 0, "No labels have been generated!"
+        assert len(self.labels) != 0, "No labels have been generated!"
         # find all images in given folder
         fpaths = glob.glob(os.path.join(dir_img, '*.png'))
         fpaths += glob.glob(os.path.join(dir_img, '*.jpg'))
         fpaths += glob.glob(os.path.join(dir_img, '*.bmp'))
         # create new label for new subject
-        target_new = self.target[-1] + 1
-        self.target = np.append(self.target, [target_new]*len(fpaths))
+        target_new = self.labels[-1] + 1
+        self.labels = np.append(self.labels, [target_new]*len(fpaths))
         # convert image to 64*64 data vector (ranging from 0 to 1)
         for i, f in enumerate(fpaths):
             im = cv2.imread(f)
@@ -185,11 +185,11 @@ def _divide_dataset(self, ratio = 0.85):
         # {index: (data_vector, data_label)}, index starts from 0 
         self.train_data = OD(                                       # ordered dict
                 dict(zip(train_inds,                                # keys
-            zip(self.data[train_inds,:], self.target[train_inds]))) # vals
+            zip(self.data[train_inds,:], self.labels[train_inds]))) # vals
                 )
         self.test_data = OD(                                        # ordered dict
                 dict(zip(test_inds,                                 # keys
-            zip(self.data[test_inds,:], self.target[test_inds])))   # vals
+            zip(self.data[test_inds,:], self.labels[test_inds])))   # vals
                 )
 
 
@@ -246,7 +246,6 @@ def img2vec(self, im) -> np.ndarray:
         if not len(im.shape) == 2:
             raise RuntimeError("Provide a greyscale image as input.")
         x = np.asarray(cv2.resize(im, dsize=(64,64)), np.float32).ravel()
-        import pdb; pdb.set_trace()
         x /= 255
         x = np.reshape(x, self._mean.shape)
         x -= self._mean
@@ -343,11 +342,11 @@ def export(self, dest_folder = '/tmp') -> Tuple[str, str]:
         """
         try:
             fpath_data = os.path.join(dest_folder, 'data.pkl')
-            fpath_lbl = os.path.join(dest_folder, 'target.pkl')
+            fpath_lbl = os.path.join(dest_folder, 'labels.pkl')
             with open(fpath_data, 'wb') as f:
                 pkl.dump(self.data, f)
             with open(fpath_lbl, 'wb') as f:
-                pkl.dump(self.target, f)
+                pkl.dump(self.labels, f)
             print("Wrote data and target as .pkl at:\n%s"
                     % os.path.abspath(dest_folder))
             return os.path.abspath(fpath_data), os.path.abspath(fpath_lbl)
@@ -376,7 +375,7 @@ def show_album(self, wait_time = 2.0):
             how long to wait between successive grid pages in sec
         """
         data_every_64 = self.grouper(self.data, 64)
-        lbl_every_64 = self.grouper(self.target, 64)
+        lbl_every_64 = self.grouper(self.labels, 64)
         cols, rows = 8, 8
         blank = np.zeros((64, 64), np.uint8)
 

tests/test_face_classifier.py

@@ -4,40 +4,40 @@
 this_script_path = os.path.abspath(__file__)
 this_script_folder = os.path.dirname(this_script_path)
 sys.path.insert(1, os.path.join(this_script_folder, '..', 'ezfaces'))
-from face_classifier import faceClassifier
+from face_classifier import FaceClassifier
 import numpy as np
 
 
 class TestUM(unittest.TestCase):
 
     def test_train_with_olivetti(self):
-        fc = faceClassifier()
+        fc = FaceClassifier()
         self.assertEqual(len(fc.data.shape), 2)
         # data stored as 64*64 row vectors
         self.assertEqual(fc.data.shape[1], 64*64)
         # Olivetti data contain 40 subjects
-        self.assertEqual(len(np.unique(fc.target)), 40)
+        self.assertEqual(len(np.unique(fc.labels)), 40)
         fc.train()
         # their coordinates in eigenface space as a matrix (.W)
         self.assertEqual(len(fc.W.shape), 2)
 
 
     def test_train_with_subject(self):
         img_dir = os.path.join(this_script_folder, 'images_yale')
-        fc = faceClassifier()
+        fc = FaceClassifier()
         fc.add_img_data(img_dir)
         # data stored as 64*64 row vectors
         self.assertEqual(fc.data.shape[1], 64*64)
         # 40 + 1 subjects
-        self.assertEqual(len(np.unique(fc.target)), 41)
+        self.assertEqual(len(np.unique(fc.labels)), 41)
         fc.train()
         # their coordinates in eigenface space as a matrix (.W)
         self.assertEqual(len(fc.W.shape), 2)
 
 
     def test_benchmark(self):
         img_dir = os.path.join(this_script_folder, 'images_yale')
-        fc = faceClassifier(ratio = .725)
+        fc = FaceClassifier(ratio = .725)
         fc.add_img_data(img_dir)
         fc.benchmark()
         self.assertNotEqual(fc.classification_report, None)
@@ -47,17 +47,17 @@ def test_benchmark(self):
 
     def test_export_import(self):
         img_dir = os.path.join(this_script_folder, 'images_yale')
-        fc = faceClassifier()
+        fc = FaceClassifier()
         fc.add_img_data(img_dir)
         # write as pickle files
         fc.export()
 
-        fc2 = faceClassifier(data_pkl = '/tmp/data.pkl', target_pkl = '/tmp/target.pkl')
-        self.assertEqual(len(np.unique(fc2.target)), 41)
+        fc2 = FaceClassifier(data_pkl = '/tmp/data.pkl', target_pkl = '/tmp/labels.pkl')
+        self.assertEqual(len(np.unique(fc2.labels)), 41)
 
 
     def test_show_album(self):
-        fc = faceClassifier()
+        fc = FaceClassifier()
         fc.show_album(wait_time=.1)