hmax

README.md

@@ -1,7 +1,7 @@
 ---
 title: Hierarchical Softmax Loss
 datasets:
--  
+- danieldux/ISCO-08
 tags:
 - evaluate
 - metric

hierarchical_softmax_loss.py

@@ -13,16 +13,19 @@
 # limitations under the License.
 """TODO: Add a description here."""
 
+from hierarchicalsoftmax import HierarchicalSoftmaxLoss
 import evaluate
 import datasets
-
+import pickle
+import torch
+import torch.nn as nn
 
 # TODO: Add BibTeX citation
 _CITATION = """\
 @InProceedings{huggingface:module,
-title = {A great new module},
-authors={huggingface, Inc.},
-year={2020}
+title = {Hierarchical Softmax Loss},
+authors={Danieldux},
+year={2023}
 }
 """
 
@@ -58,7 +61,7 @@ BAD_WORDS_URL = "http://url/to/external/resource/bad_words.txt"
 
 
 @evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
-class HierarchicalSoftmaxLoss(evaluate.Metric):
+class HierarchicalISCOSoftmaxLoss(evaluate.Metric):
     """TODO: Short description of my evaluation module."""
 
     def _info(self):
@@ -83,13 +86,100 @@ class HierarchicalSoftmaxLoss(evaluate.Metric):
 
     def _download_and_prepare(self, dl_manager):
         """Optional: download external resources useful to compute the scores"""
-        # TODO: Download external resources if needed
+        # TODO: Download ISCO hierachical metadata
         pass
 
+
+
+class HierarchicalLossNetwork:
+    """Logics to calculate the loss of the model.
+    """
+
+    def __init__(self, metafile_path, hierarchical_labels, device='cpu', total_level=2, alpha=1, beta=0.8, p_loss=3):
+        """Param init.
+        """
+        self.total_level = total_level
+        self.alpha = alpha
+        self.beta = beta
+        self.p_loss = p_loss
+        self.device = device
+        self.level_one_labels, self.level_two_labels, self.level_three_labels, self.level_four_labels = read_meta(metafile=metafile_path)
+        self.hierarchical_labels = hierarchical_labels
+        self.numeric_hierarchy = self.words_to_indices()
+
+    def read_meta(metafile):
+        """Read the meta file and return the coarse and fine labels.
+        """
+        # TODO: Replace with metadata from the dataset
+        meta_data = unpickle(metafile)
+        fine_label_names = [t.decode('utf8') for t in meta_data[b'fine_label_names']]
+        coarse_label_names = [t.decode('utf8') for t in meta_data[b'coarse_label_names']]
+        return coarse_label_names, fine_label_names
+
+    def hierarchical_softmax_loss_fn(logits: torch.Tensor, labels: torch.Tensor, root) -> torch.Tensor:
+        loss = HierarchicalSoftmaxLoss(root=root)
+        return loss(logits, labels)
+
+    def words_to_indices(self):
+        """Convert the classes from words to indices."""
+        numeric_hierarchy = {}
+        for k, v in self.hierarchical_labels.items():
+            numeric_hierarchy[self.level_one_labels.index(k)] = [self.level_two_labels.index(i) for i in v]
+
+        return numeric_hierarchy
+
+
+    def check_hierarchy(self, current_level, previous_level):
+        """
+        Check if the predicted class at level l is a child of the class predicted at level l-1 for the entire batch.
+        """
+
+        #check using the dictionary whether the current level's prediction belongs to the superclass (prediction from the prev layer)
+        bool_tensor = [not current_level[i] in self.numeric_hierarchy[previous_level[i].item()] for i in range(previous_level.size()[0])]
+
+        return torch.FloatTensor(bool_tensor).to(self.device)
+
+
+    def calculate_lloss(self, predictions, true_labels):
+        """Calculates the layer loss."""
+
+        lloss = 0
+        for l in range(self.total_level):
+
+            lloss += nn.CrossEntropyLoss()(predictions[l], true_labels[l])
+
+        return self.alpha * lloss
+
+
+    def calculate_dloss(self, predictions, true_labels):
+        """Calculate the dependence loss."""
+
+        dloss = 0
+        for l in range(1, self.total_level):
+
+            current_lvl_pred = torch.argmax(nn.Softmax(dim=1)(predictions[l]), dim=1)
+            prev_lvl_pred = torch.argmax(nn.Softmax(dim=1)(predictions[l-1]), dim=1)
+
+            D_l = self.check_hierarchy(current_lvl_pred, prev_lvl_pred)
+
+            l_prev = torch.where(prev_lvl_pred == true_labels[l-1], torch.FloatTensor([0]).to(self.device), torch.FloatTensor([1]).to(self.device))
+            l_curr = torch.where(current_lvl_pred == true_labels[l], torch.FloatTensor([0]).to(self.device), torch.FloatTensor([1]).to(self.device))
+
+            dloss += torch.sum(torch.pow(self.p_loss, D_l*l_prev)*torch.pow(self.p_loss, D_l*l_curr) - 1)
+
+        return self.beta * dloss
+
+
     def _compute(self, predictions, references):
-        """Returns the scores"""
-        # TODO: Compute the different scores of the module
-        accuracy = sum(i == j for i, j in zip(predictions, references)) / len(predictions)
+        """Returns the accuracy score of the prediction"""
+
+        num_data = references.size()[0]
+        predicted = torch.argmax(predictions, dim=1)
+
+        correct_pred = torch.sum(predicted == references)
+
+        accuracy = correct_pred*(100/num_data)
+
         return {
-            "accuracy": accuracy,
+            "accuracy": accuracy.item(),
         }

level_dict.py

@@ -0,0 +1,25 @@
+'''Dictionary for CIFAR-100 hierarchy.
+'''
+
+hierarchy = {
+    'aquatic_mammals':['beaver', 'dolphin', 'otter', 'seal', 'whale'],
+    'fish':	['aquarium_fish', 'flatfish', 'ray', 'shark', 'trout'],
+    'flowers':['orchid', 'poppy', 'rose', 'sunflower', 'tulip'],
+    'food_containers' : ['bottle', 'bowl', 'can', 'cup', 'plate'],
+    'fruit_and_vegetables':['apple', 'mushroom', 'orange', 'pear', 'sweet_pepper'],
+    'household_electrical_devices' :['clock', 'keyboard', 'lamp', 'telephone', 'television'],
+    'household_furniture':	['bed', 'chair', 'couch', 'table', 'wardrobe'],
+    'insects':	['bee', 'beetle', 'butterfly', 'caterpillar', 'cockroach'],
+    'large_carnivores':['bear', 'leopard', 'lion', 'tiger', 'wolf'],
+    'large_man-made_outdoor_things':['bridge', 'castle', 'house', 'road', 'skyscraper'],
+    'large_natural_outdoor_scenes':['cloud', 'forest', 'mountain', 'plain', 'sea'],
+    'large_omnivores_and_herbivores' :	['camel', 'cattle', 'chimpanzee', 'elephant', 'kangaroo'],
+    'medium_mammals': ['fox', 'porcupine', 'possum', 'raccoon', 'skunk'],
+    'non-insect_invertebrates':	['crab', 'lobster', 'snail', 'spider', 'worm'],
+    'people':	['baby', 'boy', 'girl', 'man', 'woman'],
+    'reptiles': ['crocodile', 'dinosaur', 'lizard', 'snake', 'turtle'],
+    'small_mammals': ['hamster', 'mouse', 'rabbit', 'shrew', 'squirrel'],
+    'trees' :	['maple_tree', 'oak_tree', 'palm_tree', 'pine_tree', 'willow_tree'],
+    'vehicles_1':['bicycle', 'bus', 'motorcycle', 'pickup_truck', 'train'],
+    'vehicles_2': ['lawn_mower', 'rocket', 'streetcar', 'tank', 'tractor']
+}

requirements.txt

@@ -1 +1,2 @@
-git+https://github.com/huggingface/evaluate@main
+git+https://github.com/huggingface/evaluate@main
+hierarchicalsoftmax