Während wir die Daten von der API aufnehmen, wenden wir einige Kriterien an. Erstens nehmen wir nur Dokumente auf, deren Jahr zwischen 2016 und 2022 liegt. Wir möchten eine relativ aktuelle Sprache, da sich Begriffe und Taxonomien bestimmter Themen über lange Zeiträume ändern können.

Wir werden auch Schlüsselbegriffe hinzufügen und mehrere Suchvorgänge durchführen. Während wir normalerweise wahrscheinlich zufällige Themenbereiche aufnehmen würden, werden wir Schlüsselbegriffe verwenden, um unsere Suche einzugrenzen. Auf diese Weise erhalten wir eine Vorstellung davon, wie viele übergeordnete Themen wir haben, und können dies mit der Ausgabe des Modells vergleichen. Im Folgenden erstellen wir eine Funktion, mit der wir Schlüsselbegriffe hinzufügen und Suchvorgänge über die API durchführen können.

import pandas as pd
import requests

def import_data(pages, start_year, end_year, search_terms):
"""
This operate is used to make use of the OpenAlex API, conduct a search on works, a return a dataframe with related works.
Inputs: 
- pages: int, variety of pages to loop by
- search_terms: str, key phrases to seek for (should be formatted in response to OpenAlex requirements)
- start_year and end_year: int, years to set as a variety for filtering works
"""
#create an empty dataframe
search_results = pd.DataFrame()
for web page in vary(1, pages):
#use paramters to conduct request and format to a dataframe
response = requests.get(f'https://api.openalex.org/works?web page={web page}&per-page=200&filter=publication_year:{start_year}-{end_year},kind:article&search={search_terms}')
information = pd.DataFrame(response.json()('outcomes'))
#append to empty dataframe
search_results = pd.concat((search_results, information))
#subset to related options
search_results = search_results(("id", "title", "display_name", "publication_year", "publication_date",
"kind", "countries_distinct_count","institutions_distinct_count",
"has_fulltext", "cited_by_count", "key phrases", "referenced_works_count", "abstract_inverted_index"))
return(search_results)

Wir führen 5 verschiedene Suchvorgänge durch, die jeweils einen anderen Technologiebereich abdecken. Diese Technologiebereiche sind von den „Crucial Expertise Areas“ des US-Verteidigungsministeriums inspiriert. Weitere Informationen finden Sie hier:

Hier ist ein Beispiel für eine Suche mit der erforderlichen OpenAlex-Syntax:

#seek for Trusted AI and Autonomy
ai_search = import_data(35, 2016, 2024, "'synthetic intelligence' OR 'deep be taught' OR 'neural web' OR 'autonomous' OR drone")

Nachdem wir unsere Suchvorgänge zusammengestellt und doppelte Dokumente gelöscht haben, müssen wir die Daten bereinigen, um sie für unser Themenmodell vorzubereiten. Es gibt zwei Hauptprobleme mit unserer aktuellen Ausgabe.

1. Die Abstracts werden (aus rechtlichen Gründen) als invertierter Index zurückgegeben. Wir können diese jedoch verwenden, um den Originaltext zurückzugeben.
2. Sobald wir den Originaltext erhalten, ist er roh und unbearbeitet, was zu Störungen führt und unserem Modell schadet. Wir führen eine traditionelle NLP-Vorverarbeitung durch, um ihn für das Modell vorzubereiten.

Unten finden Sie eine Funktion zum Zurückgeben des Originaltexts aus einem invertierten Index.

def undo_inverted_index(inverted_index):
"""
The aim of the operate is to 'undo' and inverted index. It inputs an inverted index and
returns the unique string.
"""
#create empty lists to retailer uninverted index
word_index = ()
words_unindexed = ()
#loop by index and return key-value pairs
for ok,v in inverted_index.objects(): 
for index in v: word_index.append((ok,index))
#kind by the index
word_index = sorted(word_index, key = lambda x : x(1))
#be part of solely the values and flatten
for pair in word_index:
words_unindexed.append(pair(0))
words_unindexed = ' '.be part of(words_unindexed)
return(words_unindexed)

Da wir nun den Rohtext haben, können wir unsere traditionellen Vorverarbeitungsschritte durchführen, wie z. B. Standardisierung, Entfernen von Stoppwörtern, Lemmatisierung usw. Unten finden Sie Funktionen, die einer Liste oder einer Reihe von Dokumenten zugeordnet werden können.

def preprocess(textual content):
"""
This operate takes in a string, coverts it to lowercase, cleans
it (take away particular character and numbers), and tokenizes it.
"""
#convert to lowercase
textual content = textual content.decrease()
#take away particular character and digits
textual content = re.sub(r'd+', '', textual content)
textual content = re.sub(r'(^ws)', '', textual content)
#tokenize
tokens = nltk.word_tokenize(textual content)
return(tokens)

def remove_stopwords(tokens):
"""
This operate takes in an inventory of tokens (from the 'preprocess' operate) and 
removes an inventory of stopwords. Customized stopwords will be added to the 'custom_stopwords' checklist.
"""
#set default and customized stopwords
stop_words = nltk.corpus.stopwords.phrases('english')
custom_stopwords = ()
stop_words.lengthen(custom_stopwords)
#filter out stopwords
filtered_tokens = (phrase for phrase in tokens if phrase not in stop_words)
return(filtered_tokens)

def lemmatize(tokens):
"""
This operate conducts lemmatization on an inventory of tokens (from the 'remove_stopwords' operate).
This shortens every phrase all the way down to its root kind to enhance modeling outcomes.
"""
#initalize lemmatizer and lemmatize
lemmatizer = nltk.WordNetLemmatizer()
lemmatized_tokens = (lemmatizer.lemmatize(token) for token in tokens)
return(lemmatized_tokens)

def clean_text(textual content):
"""
This operate makes use of the beforehand outlined capabilities to take a string and
run it by your complete information preprocessing course of.
"""
#clear, tokenize, and lemmatize a string
tokens = preprocess(textual content)
filtered_tokens = remove_stopwords(tokens)
lemmatized_tokens = lemmatize(filtered_tokens)
clean_text = ' '.be part of(lemmatized_tokens)
return(clean_text)

Da wir nun über eine vorverarbeitete Reihe von Dokumenten verfügen, können wir unser erstes Themenmodell erstellen!