Documentation for Dataset

def define_hierarchies(self, clsses: list[str]):
    """
    define_hierarchies is a method to define the hierarchies for the classes to predict

    Args:
        clsses (list[str]): list of classes to predict

    Raises:
        ValueError: if the class is not in the accepted classes
    """
    # TODO: use all possible hierarchies instead of just the ones for which we have a sample annotated with
    self.labels_groupings = {}
    self.class_topred = {}
    for clss in clsses:
        if clss not in [
            "cell_type_ontology_term_id",
            "tissue_ontology_term_id",
            "disease_ontology_term_id",
            "development_stage_ontology_term_id",
            "simplified_dev_stage",
            "age_group",
            "assay_ontology_term_id",
            "self_reported_ethnicity_ontology_term_id",
        ]:
            raise ValueError(
                "class {} not in accepted classes, for now only supported from bionty sources".format(
                    clss
                )
            )
        elif clss == "cell_type_ontology_term_id":
            parentdf = (
                bt.CellType.filter()
                .df(include=["parents__ontology_id"])
                .set_index("ontology_id")
            )
        elif clss == "tissue_ontology_term_id":
            parentdf = (
                bt.Tissue.filter()
                .df(include=["parents__ontology_id"])
                .set_index("ontology_id")
            )
        elif clss == "disease_ontology_term_id":
            parentdf = (
                bt.Disease.filter()
                .df(include=["parents__ontology_id"])
                .set_index("ontology_id")
            )
        elif clss in [
            "development_stage_ontology_term_id",
            "simplified_dev_stage",
            "age_group",
        ]:
            parentdf = (
                bt.DevelopmentalStage.filter()
                .df(include=["parents__ontology_id"])
                .set_index("ontology_id")
            )
        elif clss == "assay_ontology_term_id":
            parentdf = (
                bt.ExperimentalFactor.filter()
                .df(include=["parents__ontology_id"])
                .set_index("ontology_id")
            )
        elif clss == "self_reported_ethnicity_ontology_term_id":
            parentdf = (
                bt.Ethnicity.filter()
                .df(include=["parents__ontology_id"])
                .set_index("ontology_id")
            )

        else:
            raise ValueError(
                "class {} not in accepted classes, for now only supported from bionty sources".format(
                    clss
                )
            )
        cats = set(self.mapped_dataset.get_merged_categories(clss))
        addition = set(LABELS_TOADD.get(clss, {}).values())
        cats |= addition
        groupings, _, leaf_labels = get_ancestry_mapping(cats, parentdf)
        for i, j in groupings.items():
            if len(j) == 0:
                groupings.pop(i)
        self.labels_groupings[clss] = groupings
        if clss in self.clss_to_predict:
            # if we have added new clss, we need to update the encoder with them too.
            mlength = len(self.mapped_dataset.encoders[clss])

            mlength -= (
                1
                if self.mapped_dataset.unknown_label
                in self.mapped_dataset.encoders[clss].keys()
                else 0
            )

            for i, v in enumerate(
                addition - set(self.mapped_dataset.encoders[clss].keys())
            ):
                self.mapped_dataset.encoders[clss].update({v: mlength + i})
            # we need to change the ordering so that the things that can't be predicted appear afterward

            self.class_topred[clss] = leaf_labels
            c = 0
            update = {}
            mlength = len(leaf_labels)
            mlength -= (
                1
                if self.mapped_dataset.unknown_label
                in self.mapped_dataset.encoders[clss].keys()
                else 0
            )
            for k, v in self.mapped_dataset.encoders[clss].items():
                if k in self.labels_groupings[clss].keys():
                    update.update({k: mlength + c})
                    c += 1
                elif k == self.mapped_dataset.unknown_label:
                    update.update({k: v})
                    self.class_topred[clss] -= set([k])
                else:
                    update.update({k: v - c})
            self.mapped_dataset.encoders[clss] = update

def get_label_weights(
    self,
    obs_keys: str | list[str],
    scaler: int = 10,
    return_categories=False,
    bypass_label=["neuron"],
):
    """Get all weights for the given label keys."""
    if isinstance(obs_keys, str):
        obs_keys = [obs_keys]
    labels_list = []
    for label_key in obs_keys:
        labels_to_str = (
            self.mapped_dataset.get_merged_labels(label_key).astype(str).astype("O")
        )
        labels_list.append(labels_to_str)
    if len(labels_list) > 1:
        labels = ["___".join(labels_obs) for labels_obs in zip(*labels_list)]
    else:
        labels = labels_list[0]

    counter = Counter(labels)  # type: ignore
    if return_categories:
        rn = {n: i for i, n in enumerate(counter.keys())}
        labels = np.array([rn[label] for label in labels])
        counter = np.array(list(counter.values()))
        weights = scaler / (counter + scaler)
        return weights, labels
    else:
        counts = np.array([counter[label] for label in labels])
        if scaler is None:
            weights = 1.0 / counts
        else:
            weights = scaler / (counts + scaler)
        return weights

def get_unseen_mapped_dataset_elements(self, idx: int):
    """
    get_unseen_mapped_dataset_elements is a wrapper around mappedDataset.get_unseen_mapped_dataset_elements

    Args:
        idx (int): index of the element to get

    Returns:
        list[str]: list of unseen genes
    """
    return [str(i)[2:-1] for i in self.mapped_dataset.uns(idx, "unseen_genes")]