Steuerungsfilterung

Es kann viele Steuerelemente in der Anwendung geben, die für die Aufgabe möglicherweise nicht relevant sind. UFO kann irrelevante Steuerelemente herausfiltern und sich nur auf die relevanten konzentrieren. Dieser Filterprozess kann die Komplexität der Aufgabe reduzieren.

Neben der Konfiguration der Steuerelementtypen für die Auswahl in CONTROL_LIST in config_dev.yaml unterstützt UFO auch das Filtern von Steuerelementen basierend auf semantischer Ähnlichkeit oder Schlüsselwortabgleich zwischen dem Plan des Agenten und den Informationen des Steuerelements. Wir unterstützen derzeit die folgenden Filtermethoden

Filtermethode Beschreibung
Text Filtert die Steuerelemente basierend auf dem Steuerelementtext.
Semantisch Filtert die Steuerelemente basierend auf der semantischen Ähnlichkeit.
Symbol Filtert die Steuerelemente basierend auf dem Symbolbild des Steuerelements.

Konfiguration

Sie können die Steuerelementfilterung aktivieren, indem Sie CONTROL_FILTER in der Datei config_dev.yaml festlegen. CONTROL_FILTER ist eine Liste von Filtermethoden, die Sie auf die Steuerelemente anwenden möchten, und diese können TEXT, SEMANTIC oder ICON sein.

Sie können mehrere Filtermethoden in der Liste CONTROL_FILTER konfigurieren.

Referenz

Die Implementierung der Steuerelementfilterung basiert auf der Klasse BasicControlFilter, die sich in der Datei ufo/automator/ui_control/control_filter.py befindet. Konkrete Filterklassen erben von der Klasse BasicControlFilter und implementieren die Methode control_filter, um die Steuerelemente basierend auf der spezifischen Filtermethode zu filtern.

BasicControlFilter stellt ein Modell für die Filterung von Steuerelementen dar.

__new__(model_path)

Erstellt eine neue Instanz von BasicControlFilter.

Parameter
  • model_path –

    Der Pfad zum Modell.
Rückgabe
  • –

    Die BasicControlFilter-Instanz.
Quellcode in automator/ui_control/control_filter.py 
72
73
74
75
76
77
78
79
80
81
82
def __new__(cls, model_path):
    """
    Creates a new instance of BasicControlFilter.
    :param model_path: The path to the model.
    :return: The BasicControlFilter instance.
    """
    if model_path not in cls._instances:
        instance = super(BasicControlFilter, cls).__new__(cls)
        instance.model = cls.load_model(model_path)
        cls._instances[model_path] = instance
    return cls._instances[model_path]

control_filter(control_dicts, plans, **kwargs) abstractmethod

Berechnet die Kosinus-Ähnlichkeit zwischen den Einbettungen der gegebenen Schlüsselwörter und dem Steuerelement.

Parameter
  • control_dicts –

    Das Steuerelement, das mit den Plänen verglichen werden soll.

  • plans –

    Die Pläne, die zur Berechnung der Ähnlichkeit verwendet werden sollen.
Rückgabe
  • –

    Die gefilterten Steuerungs-Elemente.
Quellcode in automator/ui_control/control_filter.py 
104
105
106
107
108
109
110
111
112
@abstractmethod
def control_filter(self, control_dicts, plans, **kwargs):
    """
    Calculates the cosine similarity between the embeddings of the given keywords and the control item.
    :param control_dicts: The control item to be compared with the plans.
    :param plans: The plans to be used for calculating the similarity.
    :return: The filtered control items.
    """
    pass

cos_sim(embedding1, embedding2) staticmethod

Berechnet die Kosinus-Ähnlichkeit zwischen zwei Einbettungen.

Parameter
  • embedding1 –

    Die erste Einbettung.

  • embedding2 –

    Die zweite Einbettung.
Rückgabe
  • float –

    Die Kosinus-Ähnlichkeit zwischen den beiden Einbettungen.
Quellcode in automator/ui_control/control_filter.py 
153
154
155
156
157
158
159
160
161
162
163
@staticmethod
def cos_sim(embedding1, embedding2) -> float:
    """
    Computes the cosine similarity between two embeddings.
    :param embedding1: The first embedding.
    :param embedding2: The second embedding.
    :return: The cosine similarity between the two embeddings.
    """
    import sentence_transformers

    return sentence_transformers.util.cos_sim(embedding1, embedding2)

get_embedding(content)

Kodiert das gegebene Objekt in eine Einbettung.

Parameter
  • content –

    Der zu kodierende Inhalt.
Rückgabe
  • –

    Die Einbettung des Objekts.
Quellcode in automator/ui_control/control_filter.py 
 95
 96
 97
 98
 99
100
101
102
def get_embedding(self, content):
    """
    Encodes the given object into an embedding.
    :param content: The content to encode.
    :return: The embedding of the object.
    """

    return self.model.encode(content)

load_model(model_path) staticmethod

Lädt das Modell vom angegebenen Modellpfad.

Parameter
  • model_path –

    Der Pfad zum Modell.
Rückgabe
  • –

    Das geladene Modell.
Quellcode in automator/ui_control/control_filter.py 
84
85
86
87
88
89
90
91
92
93
@staticmethod
def load_model(model_path):
    """
    Loads the model from the given model path.
    :param model_path: The path to the model.
    :return: The loaded model.
    """
    import sentence_transformers

    return sentence_transformers.SentenceTransformer(model_path)

plans_to_keywords(plans) staticmethod

Extrahiert Schlüsselwörter aus dem Plan. Wir berücksichtigen nur die Wörter im Plan, die alphabetische oder chinesische Zeichen sind.

Parameter
  • plans (List[str]) –

    Der zu parsende Plan.
Rückgabe
  • List[str] –

    Eine Liste von Schlüsselwörtern, die aus dem Plan extrahiert wurden.
Quellcode in automator/ui_control/control_filter.py 
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
@staticmethod
def plans_to_keywords(plans: List[str]) -> List[str]:
    """
    Gets keywords from the plan. We only consider the words in the plan that are alphabetic or Chinese characters.
    :param plans: The plan to be parsed.
    :return: A list of keywords extracted from the plan.
    """

    keywords = []
    for plan in plans:
        words = plan.replace("'", "").strip(".").split()
        words = [
            word
            for word in words
            if word.isalpha() or bool(re.fullmatch(r"[\u4e00-\u9fa5]+", word))
        ]
        keywords.extend(words)
    return keywords

remove_stopwords(keywords) staticmethod

Entfernt Stoppwörter aus der gegebenen Liste von Schlüsselwörtern. Wenn Sie Stoppwörter zum ersten Mal verwenden, müssen Sie diese mit nltk.download('stopwords') herunterladen.

Parameter
  • keywords –

    Die zu filternde Liste von Schlüsselwörtern.
Rückgabe
  • –

    Die Liste der Schlüsselwörter, aus denen die Stoppwörter entfernt wurden.
Quellcode in automator/ui_control/control_filter.py 
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
@staticmethod
def remove_stopwords(keywords):
    """
    Removes stopwords from the given list of keywords. If you are using stopwords for the first time, you need to download them using nltk.download('stopwords').
    :param keywords: The list of keywords to be filtered.
    :return: The list of keywords with the stopwords removed.
    """

    try:
        from nltk.corpus import stopwords

        stopwords_list = stopwords.words("english")
    except LookupError as e:
        import nltk

        nltk.download("stopwords")
        stopwords_list = nltk.corpus.stopwords.words("english")

    return [keyword for keyword in keywords if keyword in stopwords_list]