Ecrire un réseau de co-auteurs dans un domaine spécifique en utilisant les informations d'arxiv
Préface
C'est un contenu avec lequel je joue en collectant des informations d'arxiv et en essayant d'obtenir des informations utiles. La procédure de ce que j'ai fait cette fois est la suivante.
- Rassemblez les titres de papier, les résumés, les auteurs, etc. soumis dans un certain délai
- Extraire des articles contenant des mots-clés spécifiques --Créer un graphique dirigé des articles extraits et des noms d'auteurs
- Extraire uniquement les auteurs avec un grand nombre de messages avec un seuil approprié
- Convertir en un graphique de co-auteur avec le nombre de papiers comme poids des côtés --Split en graphiques partiels selon qu'ils sont connectés ou non
Je me demande si je peux voir un cluster tel qu'un grand groupe de recherche dans le domaine de la recherche lié aux mots-clés appropriés. Enfin, le réseau de co-auteurs (conditionné par le nombre d'articles) tel qu'illustré dans le graphique ci-dessous est extrait.
Il s'agit d'un réseau de co-auteurs lorsque les articles quant-ph d'arxiv de 2015 à 2020 qui incluent "quantum comput" dans le titre / absolu sont sélectionnés et que seuls les auteurs avec 15 articles ou plus applicables sont sélectionnés. (Le nombre d'articles co-rédigés et la normalisation pour chaque groupe)
** (Ajout: mise à jour de la fluctuation de la notation du nom de l'auteur et correction des données) **
Collecter des informations auprès d'arxiv
Scraping normalement en Python. (Il y avait aussi une API arxiv) Appuyez directement sur la recherche avancée d'arxiv pour le récupérer. Les informations collectées chaque année sont converties en un DataFrame pandas et enregistrées sous forme de fichier csv.
Les informations à collecter
--Cite: arxiv: XXXXX. --Titre: Titre du papier --Abst: Abst --Authors: enregistre en tant que liste d'auteurs, une liste de noms d'auteurs dans le texte lié et un tuple de chaînes utilisées dans les requêtes de recherche. --Fields: informations sur le terrain. S'il s'agit d'une liste croisée, plusieurs fichiers seront enregistrés. --DOI: Get si DOI est ajouté. --OrigDateY: Première année d'affichage --OrigDateM: premier mois de publication --Date Info: enregistre les informations de date telles que les autres révisions sous forme de texte.
Après tout, il y a des informations que je n'ai pas utilisées cette fois.
** * Correction du code car il ne fonctionne pas en raison des spécifications d'arxiv si le nombre de cibles de recherche pour un an dépasse 10 000. Si vous vérifiez le nombre de cas et qu'il dépasse, effectuez une recherche mensuelle et collectez des données. ** **
from bs4 import BeautifulSoup
import requests
import re
import pandas as pd
import numpy as np
import math
def month_string_to_number(string):
m = {
'jan': 1,
'feb': 2,
'mar': 3,
'apr':4,
'may':5,
'jun':6,
'jul':7,
'aug':8,
'sep':9,
'oct':10,
'nov':11,
'dec':12
}
s = string.strip()[:3].lower()
try:
out = m[s]
return out
except:
raise ValueError('Not a month')
#Obtenez le nombre de résultats de recherche sur la page de résultats de recherche
def get_number_of_searchresult(url):
html_doc = requests.get(url).text
soup = BeautifulSoup(html_doc, "html.parser")
tags = soup.find_all("h1",{"class":"title is-clearfix"})
text = tags[0].text.strip()
if "Showing" in text and "results" in text:
stext = text.split(" ")
datanum = int(stext[3].replace(',', ''))#Obtenez le nombre de résultats de recherche
else:
datanum=math.nan
return datanum
#Obtenir des informations à partir des résultats de recherche et de np.ndarray
def collect_info_from_advancedsearch(urlhead, datanum,key):
titles=[]#Liste pour le stockage des données
absts=[]#Abst
cites=[]#citer des informations(arxiv:XXXXXX)
authors=[]# author
dates=[]#Informations sur la date
dates_orig_m =[]#Premier mois de publication
dates_orig_y =[]#Première année d'affichage
dois = []#doi
fields=[]#cross-Informations sur le terrain, y compris la liste
startnum=0
while datanum > startnum:
print(str(startnum)+"...", end="")
url = urlhead+str(startnum)#URL de recherche avancée
html_doc = requests.get(url).text
soup = BeautifulSoup(html_doc, "html.parser")
#informations sur le titre
tags1= soup.find_all("p", {"class": "title is-5 mathjax"})
titles_tmp = [tag.text.strip() for tag in tags1]
#information abst
tags2 = soup.find_all("span", {"class": "abstract-full has-text-grey-dark mathjax"})
absts_tmp = [tag.text[:-7].strip() for tag in tags2 if "Less" in tag.text]
#citer des informations
tags3 =soup.find_all("p", {"class": "list-title is-inline-block"})
cites_tmp = [tag.select("a")[0].text for tag in tags3]
#Informations sur la date
tags4 = soup.find_all("p",{"class":"is-size-7"})
text = [tag.text.strip() for tag in tags4 if "originally announced" in tag.text ]
dates_tmp = text
dates_orig_y_tmp=[txt.split(" ")[-1][:-1] for txt in text]
dates_orig_m_tmp=[month_string_to_number(txt.split(" ")[-2]) for txt in text]
#Informations DOI
tags5 = soup.find_all("div",{"class":"is-marginless"})
dois_tmp = [tag.text[tag.text.rfind("doi"):].split("\n")[1] for tag in tags5 if key in tag.text ]
#Informations sur l'auteur
tags6= soup.find_all("p", {"class": "authors"})
auths_tmp = []
for tag in tags6:
auths=tag.select("a")
authlist=[(author.text,author.get("href")[33:]) for author in auths]
auths_tmp.append(authlist)
# Cross-informations de liste
tags7= soup.find_all("div", {"class": "tags is-inline-block"}) # title#("span", {"class": "tag is-small is-link tooltip is-tooltip-top"}) # title
fields_tmp=[tag.text.strip().split("\n") for tag in tags7]
#Ajouter aux résultats
titles.extend(titles_tmp)
absts.extend(absts_tmp)
cites.extend(cites_tmp)
authors.extend(auths_tmp)
dates.extend(dates_tmp)
dates_orig_y.extend(dates_orig_y_tmp)
dates_orig_m.extend(dates_orig_m_tmp)
dois.extend(dois_tmp)
fields.extend(fields_tmp)
#Mettre à jour le numéro de départ sur la page suivante des résultats de recherche
startnum += sizenum
nt = np.array(titles)
na = np.array(absts)
nauth = np.array(authors)
ncite = np.array(cites)
nd = np.array(dates)
ndy = np.array(dates_orig_y)
ndm = np.array(dates_orig_m)
ndoi = np.array(dois)
nfields=np.array(fields)
npdataset = np.concatenate([[ncite],[nt],[na],[nauth],[nfields],[ndoi],[ndy],[ndm],[nd]],axis=0).T
print(" collected data number : ", npdataset.shape[0])
return npdataset
#Dictionnaire pour spécifier la classification de la cible de recherche de la requête de recherche
dict_class={'cs': '&classification-computer_science=y',
'econ': '&classification-economics=y',
'eess': '&classification-eess=y',
'math': '&classification-mathematics=y',
'q-bio': '&classification-q_biology=y',
'q-fin': '&classification-q_finance=y',
'stat': '&classification-statistics=y',
'all': '&classification-physics=y&classification-physics_archives=all',
'astro-ph': '&classification-physics=y&classification-physics_archives=astro-ph',
'cond-mat': '&classification-physics=y&classification-physics_archives=cond-mat',
'gr-qc': '&classification-physics=y&classification-physics_archives=gr-qc',
'hep-ex': '&classification-physics=y&classification-physics_archives=hep-ex',
'hep-lat': '&classification-physics=y&classification-physics_archives=hep-lat',
'hep-ph': '&classification-physics=y&classification-physics_archives=hep-ph',
'hep-th': '&classification-physics=y&classification-physics_archives=hep-th',
'math-ph': '&classification-physics=y&classification-physics_archives=math-ph',
'nlin': '&classification-physics=y&classification-physics_archives=nlin',
'nucl-ex': '&classification-physics=y&classification-physics_archives=nucl-ex',
'nucl-th': '&classification-physics=y&classification-physics_archives=nucl-th',
'physics': '&classification-physics=y&classification-physics_archives=physics',
'quant-ph': '&classification-physics=y&classification-physics_archives=quant-ph'}
years = [y for y in range(2015,2020)]
key = "quant-ph"#Rechercher le champ cible dict_Spécifiez la clé de classe
output_fname="df_quant-ph" #Nom du fichier de sortie
url0="https://arxiv.org/search/advanced?advanced=&terms-0-operator=AND&terms-0-term=&terms-0-field=title"
url1="&classification-include_cross_list=include"
url_daterange="&date-year=&date-filter_by=date_range"
url2="&date-date_type=submitted_date&abstracts=show&size="
urlmid = "&order=-announced_date_first&start="
sizenum = 25
startnum=0
for year in years:
m_divide = 1 #Nombre de divisions dans la période de recherche
mstart =1
mstop = 1
url_date = "&date-from_date="+str(year)+"-"+str(mstart).zfill(2)+"-01&date-to_date="+str(year+1)+"-"+str(mstop).zfill(2)+"-01"
urlhead = url0+dict_class[key]+url1+url_daterange+url_date+url2
urlmid = "&order=-announced_date_first&start="
url = urlhead+str(sizenum)+urlmid+str(startnum)
datanum=get_number_of_searchresult(url) #Obtenez le nombre de résultats de recherche
print("Number of search results ("+str(year)+") : "+str(datanum))
if datanum >=10000: #Si le nombre de cas dépasse la limite, l'acquisition de données pour un an sera divisée par mois.
m_divide = 13
for month_divide in range(2,12): #Recherchez le nombre de divisions où le nombre de cas individuels est inférieur ou égal à la limite
flag_numlimit = False
for idx in range(month_divide):
mstart = int(idx*12/month_divide+1)
mstop = (int((idx+1)*12/month_divide)+1)%12
if mstop !=1:
url_date = "&date-from_date="+str(year)+"-"+str(mstart).zfill(2)+"-01&date-to_date="+str(year)+"-"+str(mstop).zfill(2)+"-01"
else:
url_date = "&date-from_date="+str(year)+"-"+str(mstart).zfill(2)+"-01&date-to_date="+str(year+1)+"-"+str(mstop).zfill(2)+"-01"
urlhead = url0+dict_class[key]+url1+url_daterange+url_date+url2
url = urlhead+str(sizenum)+urlmid+str(startnum)
datanum=get_number_of_searchresult(url)#Obtenez le nombre de données pour chaque nombre de divisions
if datanum >= 10000:
flag_numlimit = True
if not flag_numlimit:
m_divide = month_divide
break
if m_divide > 12:
print("*** Number of search result is over the limit 10,000. Please refine your search. ***")
sizenum=200
npdataset = np.empty((0,9))
for idx in range(m_divide):
mstart = int(idx*12/m_divide+1)
mstop = (int((idx+1)*12/m_divide)+1)%12
if mstop !=1:
url_date = "&date-from_date="+str(year)+"-"+str(mstart).zfill(2)+"-01&date-to_date="+str(year)+"-"+str(mstop).zfill(2)+"-01"
else:
url_date = "&date-from_date="+str(year)+"-"+str(mstart).zfill(2)+"-01&date-to_date="+str(year+1)+"-"+str(mstop).zfill(2)+"-01"
urlhead = url0+dict_class[key]+url1+url_daterange+url_date+url2
url = urlhead+str(25)+urlmid+str(0)
datanum=get_number_of_searchresult(url)
print("Collect search results ..." + url_date + ", Number of search results : " + str(datanum))
urlhead2 = urlhead+str(sizenum)+urlmid
npdataset_tmp = collect_info_from_advancedsearch(urlhead2,datanum,key)
npdataset = np.concatenate([npdataset, npdataset_tmp], axis=0)
#Convertissez une année d'informations en Numpy et Pandas DataFrame et enregistrez-les au format CSV
dataset = pd.DataFrame(npdataset)
dataset.columns =["Cite","Title","Abst","Authors","Fields","DOI", "OrigDateY","OrigDateM","Date Info"]
dataset.to_csv(output_fname+str(year)+".csv")
Extraire des articles contenant des mots-clés spécifiques
Lisez et concaténez le csv collecté chaque année Extrayez les titres et les résumés contenant des mots-clés pour les ensembles de données concaténés. Cette fois, le mot clé est le calcul quantique.
fname_head = "df_quant-ph"
fname = fname_head + str(2020)+".csv"
dataset = pd.read_csv(fname, index_col=0)
for year in range(2010,2020):
fname = fname_head + str(year)+".csv"
print(fname)
dataset_tmp = pd.read_csv(fname, index_col=0)
dataset = pd.concat([dataset,dataset_tmp])
dataset =dataset.reset_index()
dataset_r=dataset.query('title.str.contains("quantum comput") or abst.str.contains("quantum comput")', engine='python')
Cependant, je pensais que ce formulaire ne serait pas en mesure de rechercher correctement les problèmes de cas et d'autres mots de recherche. Nous avons également ajouté le traitement Stemming en utilisant nltk. Il est basé sur ici. J'ai écrit Lemmatization pour le moment, mais je le commente maintenant.
import re
import nltk
from nltk.corpus import stopwords
from nltk.stem.porter import PorterStemmer
from nltk.stem.wordnet import WordNetLemmatizer
from nltk.corpus import stopwords
def preprocess_text(text):
text = re.sub('[^a-zA-Z]', ' ', text)#Remove punctuations
text = text.lower()
text=re.sub("</?.*?>"," <> ",text)#remove tags
text=re.sub("(\\d|\\W)+"," ",text)# remove special characters and digits
text = text.split()
stop_words = set(stopwords.words("english"))
##Stemming
#Lemmatisation
ps=PorterStemmer()
#lem = WordNetLemmatizer()
text = [ps.stem(word) for word in text if not word in stop_words]
text=" ".join(text)
return text
ndata = (dataset['Title']+" "+ dataset['Abst']).values
ndata= np.array([preprocess_text(text) for text in ndata])
dataset['Keywords'] = ndata
dataset_r=dataset.query('Keywords.str.contains("quantum comput")', engine='python')
Créer un graphique des articles extraits et des noms d'auteurs
Utilisez networkx pour dessiner un graphique orienté (les sommets sont le nom de l'auteur et le numéro d'article) avec la relation entre l'article et l'auteur comme des arêtes. Je fais quelque chose d'étrange parce que j'ai mis les informations sur l'auteur dans un format difficile à lire.
Post-scriptum: Concernant les fluctuations telles qu'une partie du nom en cours d'initialisation ou non, autre que le nom de famille? Prend des données à l'aide de la chaîne de requête initialisée. (Pour la notation, l'une des valeurs les plus fréquentes est sélectionnée. Si vous souhaitez la modifier, veuillez modifier le dictionnaire auth_dict séparément.) Cependant, il peut y avoir des noms d'auteurs qui sont sur-combinés car ils sont recherchés par la chaîne de caractères initialisée. Si vous souhaitez classer tel quel, utilisez le nom d'authentification commenté.
Pour vérifier les noms d'auteurs groupés
Par exemple, si vous exécutez le code suivant, vous obtiendrez la sortie affichée dans l'image ci-dessous.
authtext = " ".join(auths)
match = re.findall(r"(\()(.*?)\)",authtext)
for key in auth_dict.keys():
l=[m[1].split(m[1][0])[1] for m in match if key in m[1]]
c = collections.Counter(l)
print(c.most_common())
authtext = " ".join(auths)
match = re.findall(r"(\()(.*?)\)",authtext)
for key in auth_dict.keys():
l=[m[1].split(m[1][0])[1] for m in match if key in m[1]]
c = collections.Counter(l)
print(c.most_common())
import networkx as nx
import collections
auths= dataset_r['Authors'].values
datanum = auths.shape[0]
#Créer un dictionnaire de noms d'auteur
auth_dict = {}
for idx in range(datanum):
match = re.findall(r"(\()(.*?)\)",auths[idx])
for m in match:
auth = m[1].split(m[1][-1])[-2]
authname = m[1].split(m[1][0])[1]
auth_dict[auth]=authname
#Remplacez chaque élément du dictionnaire par la valeur la plus fréquente
authtext = " ".join(auths)
match = re.findall(r"(\()(.*?)\)",authtext)
for key in auth_dict.keys():
l=[m[1].split(m[1][0])[1] for m in match if key in m[1]]
c = collections.Counter(l)
auth_dict[key]=c.most_common()[0][0]
#Ajouter des informations au graphique
G=nx.DiGraph()
for idx in range(datanum):
match = re.findall(r"(\()(.*?)\)",auths[idx])
for m in match:
auth = m[1].split(m[1][-1])[-2]
#authname = m[1].split(m[1][0])[1]#Si vous souhaitez créer un graphique avec la notation telle qu'elle est, ajoutez un côté avec ce nom d'authentification
G.add_edges_from([(idx,auth_dict[auth])])
Pour chaque auteur, excluez les auteurs avec un petit nombre d'articles du graphique. (Supprimé 15 ou moins cette fois) Par conséquent, ceux dont l'ordre est 0 pour chaque article sont exclus.
thr=15
authorlist = [n for n in G.nodes() if type(n) is str]
for auth in authorlist:
deg=G.degree(auth)
if deg <=thr:
G.remove_node(auth)
for idx in range(datanum):
deg=G.degree(idx)
if deg <=0:
G.remove_node(idx)
Dessinez le graphique résultant. Dessinez l'auteur en bleu et le papier en rouge J'essaye d'augmenter la taille des sommets importants en utilisant le PageRank. Cet article est utilisé comme référence.
def draw_graph(G, label = False):
#Calcul du pagerank
pr = nx.pagerank(G)
pos = nx.spring_layout(G)
fig = plt.figure(figsize=(8.0, 6.0))
c=[(0.4,0.4,1) if type(n) is str else (1,0.4,0.4) for n in G.nodes()]
nx.draw_networkx_edges(G,pos, edge_color=(0.3,0.3,0.3))
nx.draw_networkx_nodes(G,pos, node_color=c, node_size=[5000*v for v in pr.values()])
Le résultat de sortie est le suivant. De nombreux articles sont dans un état où ils se réfèrent à un seul auteur.
Convertir en un graphique co-auteur avec le nombre de papiers comme poids des côtés
Pour le moment, j'étais intéressé par le réseau des co-auteurs, donc les informations contenues dans l'article sont pondérées.
import itertools
def convert_weightedGraph(graph):
graph_new =nx.Graph()
for node in graph.nodes:
if type(node) is str:
continue
n_new = [e[1] for e in graph.edges if e[0]==node]
for e_new in itertools.permutations(n_new, 2):
flag_dup = False
for e_check in graph_new.edges(data=True):
if e_new[0] in e_check and e_new[1] in e_check:
e_check[2]['weight']+=1
flag_dup = True
if not flag_dup:
graph_new.add_edge(e_new[0],e_new[1],weight=1)
return graph_new
wG=convert_weightedGraph(G)
Dessinez le graphe obtenu avec la fonction suivante. Si les étiquettes se chevauchent, vous pouvez les ajuster avec la taille de la figure ou l'argument k de spring_layout. (Référence)
def draw_weightedG(G):
fig = plt.figure(figsize=(8.0, 6.0))
pr = nx.pagerank(G)
pos = nx.fruchterman_reingold_layout(G,k=k0/math.sqrt(G.order()))
#pos = nx.spring_layout(G,k=15/math.sqrt(G.order()))
#Utilisez une mise en page appropriée. Ajustez la distance entre les nœuds avec la valeur de k
x_values, y_values = zip(*pos.values())
x_max = max(x_values)
x_min = min(x_values)
x_margin = (x_max - x_min) * 0.25
plt.xlim(x_min - x_margin, x_max + x_margin) #Fixez une marge pour que les caractères de l'étiquette ne soient pas coupés
node_sizes=[5000*v for v in pr.values()]
edge_colors = [e[2]['weight'] for e in G.edges(data=True)] #Coloration avec des poids latéraux
nodes = nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color='#9999ff')
edges = nx.draw_networkx_edges(G, pos, node_size=node_sizes, arrowstyle='->',
arrowsize=10, edge_color=edge_colors,
edge_cmap=plt.cm.Blues, width=2)
nx.draw_networkx_labels(G,pos)
ax = plt.gca()
ax.set_axis_off()
À partir du résultat du dessin du graphe obtenu, vous pouvez voir qu'il existe un graphe partiel non connecté.
Divisez en graphiques partiels selon qu'ils sont connectés ou non
Nous allons créer un graphe partiel connecté à partir de chaque nœud du graphe. Je n'avais pas d'outil que je pourrais utiliser en un coup d'œil, alors je l'ai écrit solidement.
def add_edges_to_wsubgraph(subg, edge_new,node,edges_all):
subg.add_edges_from([edge_new])
if node == edge_new[1]:
node_new = edge_new[0]
else:
node_new = edge_new[1]
edges_new = [e for e in edges_all if node_new in e and e not in subg.edges(data=True)]
for edge in edges_new:
if edge not in subg.edges(data=True):
add_edges_to_wsubgraph(subg,edge,node_new,edges_all)
def separate_wG_by_connectivity(G):
nodes_all =[n for n in G.nodes()]
edges_all = [e for e in G.edges(data=True)]
subgraphs = []
for node in nodes_all:
usedflag = any([node in g.nodes for g in subgraphs])
if usedflag:
continue
subg = nx.Graph()
subg.add_node(node)
edges_new = [e for e in edges_all if node in e]
for edge in edges_new:
if edge not in subg.edges(data=True):
add_edges_to_wsubgraph(subg,edge,node,edges_all)
subgraphs.append(subg)
return subgraphs
subgraphs = separate_wG_by_connectivity(wG)
Si vous dessinez chacun des graphiques partiels obtenus ici Vous obtiendrez les trois graphiques suivants. (Fabriqué manuellement en une seule image)
cnt=0
for subg in subgraphs:#Dessinez un graphique partiel et enregistrez l'image
draw_weightedG(subg)
plt.savefig("subgraph_"+str(cnt)+".png ")
plt.cla()
cnt+=1
Résumé
En commençant par l'acquisition de données d'arxiv, j'ai écrit un truc de type réseau pour co-auteur sur un mot-clé spécifique. J'ai obtenu des résultats relativement clairs, mais dans certains cas, seuls de grands clusters sont restés, en fonction des mots-clés de recherche et des paramètres de seuil. Dans un tel cas, il peut être possible d'obtenir un peu plus de détails en réduisant le nombre d'articles co-rédigés, qui sont les poids des côtés, à un seuil approprié. Après cela, je pense qu'il serait intéressant de connaître la relation de citation du journal, mais je ne pouvais pas penser à une source d'information facile, donc je serais heureux si vous pouviez me dire quelque chose.
Recommended Posts