Esta función calcula los SPL desde cada nodo de la red PPI que demos de entrada al resto de nodos de la red. Después,crea un Dataframe que contiene una
columna con todos los nodos, y otra columna con la lista de SPL para cada nodo. Por último, crea un archivo llamado distances.csv con ese DataFrame.
"""
nodos=[]
d=[]
# Calculo el Shortest Path Length para cada nodo
forsource_nodeinPPI.nodes():#selecciono un nodo de la red PPI
nodos.append(source_node)#lo añado a la lista de nodos
path_lengths=[]#creo una lista con todos los path lengths para ese nodo
fortarget_nodeinPPI.nodes():#selecciono otro nodo de la red PPI
ifsource_node!=target_node:#me aseguro de que sean nodos diferentes
ifnx.has_path(PPI,source_node,target_node):
pl=nx.shortest_path_length(PPI,source=source_node,target=target_node)#calculo el SPL entre ello
path_lengths.append(pl)#añado esa distancia a la lista de todos los path lengths de ese nodo
else:
continue
d.append(path_lengths)#lista con los SPL de cada nodo
Esta función crea un diccionario a partir de la lista de genes asociados a la enfermedad con:
key: proteína asociada a cada gen del archivo gen_pro
value: gen relacionado a la proteína key en el archivo gen_pro
"""
dict1={}
fori,geninenumerate(archivo["gen"]):#bucle que opera sobre gen_pro, que relaciona genes y proteínas. Me guardo la posición del gen (i) y el id del gen (gen)
ifgeninlista_genes:#busco cada gen de gen_pro en la lista de genes correspondiente de cada enfermedad
prot=archivo["pro"][i]#si ese gen está en la lista de genes de cada enfermedad, busco la proteína asociada a la misma posición
dict1[prot]=gen#añado al diccionario de cada enfermedad la proteína como key y el gen relacionado como value
Esta función nos devuelve un diccionario en el que obtendremos los los degrees como key y, en los values, todos los nodos de la red que contengan ese degree
Datos de entrada: subred módulo de la enfermedad (G), PPI y LCC de la enfermedad (lcc). Dp puede ser False para
calcular redes preservar la distribución de degrees del módulo de la enfermedad o True en el caso contrario.
Esta función devuelve la media y la desviación estándar del LCC de 1000 redes aleatorias con el mismo número
de nodos y links que el gráfico G que demos de entrada.
Para la creación de estas redes en el caso de dp = False, se distribuyen aleatoriamente las asociaciones entre
proteínas de la enfermedad de forma en la red. Por lo tanto, las redes no tendrán la misma estructuctura que el
módulo de la enfermedad.
Para la creación de redes en el caso dp = True, se seleccionan nodo en la red PPI con el mismo degree que los
nodos del módulo de la enfermedad. De esta forma, se crran redes con la misma estructura que e módulo de la
enfermedad.
"""
#Cálculos previos:
#Obtengo el total de proteínas de la PPI
nodos_ppi=PPI.nodes()
#Obtengo el total de las proteínas en el módulo de la enfermedad
nodos_enf=G.nodes()
#Obtengo el número de proteínas del módulos de la enfermedad
numero_nodos_enf=len(nodos_enf&set(nodos_ppi))
#agrupo los nodos según su degree
grupo_nodos_degree=nodes_by_degree(PPI)
#1000 simulaciones aleatorias para calcular 1000 LCC
lista_random=[]
foriinrange(1000):
ifdp==False:#simulación para non degree preserving
#Obtengo un set aleatorio de proteínas dentro del total de nodos de la red PPI.
#Dicho set presenta un número de nodos que equivale al número de nodos del módulo de la enfermedad
nodos_random=set(random.sample(list(nodos_ppi),numero_nodos_enf))#mismo número de nodos que el módulo de la enfermedad, tomados de la lista de prots totales de la PPI aleatoriamente
ifdp==True:#simulación para degree preserving
nodos_random=set()
fornodoinnodos_enf:#para cada nodo del módulo de la enfermedad
degree=PPI.degree(nodo)#obtengo su degree en la PPI
nodos_disponibles=grupo_nodos_degree[degree]#obtengo un grupo de nodos de la PPI con igual degree al nodo iterado
control=True
while(control):#bucle para elegir los nodos sampleados solo una vez
nodo_elegido=random.choice(nodos_disponibles)#eligo un nodo entre los nodos de la PPI seleccionados en el paso anterior
control=nodo_elegidoinnodos_random#compruebo si ese nodo está entre los nodos sampleados
nodos_random.add(nodo_elegido)#añado ese nodo a la lista de nodos que usaré para crear la red aleatoria
#solo se añaden nodos que no estén anteriormente entre los nodos sampleados gracias al bucle while
r=nx.subgraph(PPI,nodos_random)#subred de la PPI con los nodos aleatorios selccionados
r=nx.Graph(r)#para remover los links paralelos
r.remove_edges_from(nx.selfloop_edges(r))#para eliminar los self-loops que conectan un nodo consigo mismo
Esta función crea una lista con los fármacos asociados a cada enfermedad según el archivo dis_dru_the
"""
drugs=[]
forx,enf2inenumerate(arch["dis"]):#para la columna "dis" del archivo dis_dru_the, que recoge los id de las enfermedades, me quedo con el id (enf2) y su posición en la columna(x)
ifenf==enf2:#si se encuentra una coincidencia entre el id de una de nuestras cuatro enfermedades y el id de una enfermedad en el archivo dis_dru_the
drug=arch["dru"][x]# selecciono la droga asociada al id de esa enfermedad (que se encuentre en su misma fila)
drugs.append(drug)#añado ese fármaco a la lista correspondiente (la que se encuentra en la misma posición en la lista drugs que el id de la enfermedad en la lista enf)
Datos de entrada: lista con los fármacos que tratan una enfermedad (lista_drugs) y archivo con las relaciones fármaco-diana (arch)
Esta función nos permite obtener un DataFrame con fármacos en la columna "Fármacos" y sus dianas en la columna "Dianas"
"""
targets_total=[]#lista en la que añadiré los targets de cada fármaco separados por comas
farmacos=[]#lista en la que añadiré los fármacos que estén en el archivo arch
fordrug1inlista_drugs:#itero sobre cada fármaco de la lista de fármacos
targets=[]#lista vacía en la que añadiré los targets de cada fármaco
fori,drug2inenumerate(arch["dru"]):#itero sobre los fármacos del archivo me quedo con el fármaco (drugs2) y fila (i) en la columna de fármacos del archivo dru_pro
ifdrug1==drug2:#si un fármaco de la enfermedad está en el archivo de fármacos-diana
targets.append(arch["pro"][i])#añado su diana a la lista de targets, que estará en la misma fila (i) en la columna de dianas
iflen(targets)>0:#comrpuebo que la lista de targets no esté vacía
farmacos.append(drug1)#añado el fármaco a la lista de fármacos para así solamente guardar los fármacos que aparecen en el archivo arch
targets_total.append(targets)#añado la lista de targets de ese fármaco a la lista de targets de todos los fármacos
data={"Fármacos":farmacos,"Dianas":targets_total}#junto los datos y los clasifico en Fármacos y Dianas
df=pd.DataFrame(data)#Creo un DataFrame con los resultados
Datos de entrada: lista con las dianas de ese fármaco (lista_targets), proteínas del módulo de la enfermedad
(prots_enf), archivo con la matriz de distrancias entre todos los nodos de la PPI (arch_dist), red PPI (PPI)
Función que devuelve el closest measure (dc) de un fármaco y una enfermedad.
"""
targets_en_ppi=set(lista_targets)&set(PPI.nodes())#lista con las dianas del fármaco que también están en la red PPI
targets_en_enf=set(targets_en_ppi)&set(prots_enf)##lista con las dianas del fármaco que también forman parte del módulo de la enfermedad
distancias_enf_target=arch_dist.loc[list(targets_en_ppi),list(prots_enf)].values#genero una matriz con los SPLs entre todas las diana del fármaco y todas las proteínas del módulo de la enfermedad según el archivo de distancias
filas_no_vacias=~np.isnan(distancias_enf_target).all(axis=1)#me quedo con las filas que no estén vacías, es decir, elimino las dianas que no tienen ningún camino a ninguna proteína de la enfermedad
ifnp.isnan(distancias_enf_target).all():#si la matriz anterior está vacía
returnnp.nan#no hay camino entre ninguna diana del fármaco fármaco y la enfermedad
eliflen(targets_en_enf)==len(targets_en_ppi):#si todas las dianas del fármaco forman parte del módulo de la enfermedad
return0#el valor dc será 0
else:
returnnp.nanmean(np.nanmin(distancias_enf_target[filas_no_vacias],axis=1))#en caso contrario, calculo la media entre los SPLs mínimos de las dianas que sí tengan algún camino al módulo de la enfermedad (la media de los valores mínimos de cada fila de mi matriz)
prots_random=set()#creo un set de proteínas aleatorias
forprotinprots_enf:#para cada proteína del módulo de la enfermedad
degree_prot=PPI.degree(prot)#calculo su degree
prots_disponibles=grupo_nodos_degree[degree_prot]#elijo las proteínas de la PPI con su mismo degree
prots_random.add(np.random.choice(prots_disponibles))#mismo número de nodos que el módulo de la enfermedad, tomados de la lista de prots totales de la PPI aleatoriamente
# Módulo diana
targets_random=set()#creo un set de proteínas dianas aleatorias
forj,druginenumerate(df["Fármacos"]):#para cada fármaco me quedo con su fila (j)
lista_targets=df["Dianas"][j]#me quedo con la lista de dianas de ese fármaco
lista_targets_PPI=set(lista_targets)&set(PPI.nodes())#me quedo con las dianas del fármaco que estén en la PPI
fortargetinlista_targets_PPI:#para cada diana de la lista de dianas
degree_target=PPI.degree(target)#calculo su degree
targets_disponibles=grupo_nodos_degree[degree_target]#elijo las proteínas de la PPI con su mismo degree
targets_random.add(np.random.choice(targets_disponibles))#mismo número de nodos que el módulo de la enfermedad, tomados de la lista de prots totales de la PPI aleatoriament
#calculo el dc de cada fármaco con el módulo aleatrio de enfermedad y de dianas
Esta función representa en un boxplot la distribución de la cercanía y a una enfermedad y
la distribución de su z-score para el grupo de fármacos que se emplean para tratar dicha
enfermedad y el grupo de fármacos que no se emplean para su tratamiento (unkwown)
Datos de entrada:
1. df_combinado: Dataframe combinado con los fármacos, su cercanía observada, su cercanía aleatoria media,
la devsiación estándar de la proximidad aleatoria, su z-score, una columna que indica la enfermedad
(la demencia, epilepsia, la bipolaridad o la esquizofrenia) y otra columna que indica si el fármaco
se usa para el tratamiento de la enfermedad en su misma fila.
2. nombre_enf: Nombre de la enfermedad
"""
# Filtro los datos para generar dos nuevos dataframes, uno con los datos de los fármacos que se emplean como tratamiento de la enfermedad, y otro con los datos para el resto de fármacos
Esta función permite obtener un DataFrame con las siguientes columnas:
1. Enfermedades (Demencia, Bipolaridad, Epilepsia o Esquizofrenia)
2. Fármacos
3. Tratamiento: columna que indica si el el fármaco de la columna 2 trata a la enfermedad
de la columna 1 ("yes" en caso afirmativo, "unkwown" en el caso contrario
4. Valor de proximidad a la Enfermedad de la columna 1
5. Proximidad aleatoria media a la Enfermedad de la columna 1
6. Desviación estándar de en las proximidades aleatorias a la Enfermedad de la columna 1
7. Z-Score de la proximidad observada (indicada en la columna 3) en comparación con
la proximidad aleatoria media (en la columna 4) y la desviación estándar de la
proximidad aleatoria (columna 5)
8. Target en módulo: indica si el fármaco en de la columna 2 presenta alguna de sus
proteínas diana en el módulo de la enfermedad en la columna 1.
Datos de entrada:
1. df_combinado: DataFrame que contiene las 7 primeras columnas del archivo que se
obtiene como resultado (enfermedades, fármacos, tratamiento, dc, dc_mean, dc_std, dc_zscore)
2. targets: DataFrame con la lista de proteínas diana de cada fármaco
3. lcc_files: diccionario con el nombre de la enfermedad (key) y la lista de proteínas que
forman parte de su módulo (values).
"""
targets_modulo=[]# lista para almacenar si el fármaco de la columna 2 en cada fila tiene una proteína diana en el módulo de la enfermedad de la columna 1 situada en su misma fila.
# Itero sobre cada fila del DataFrame df_combinado
forindex,rowindf_combinado.iterrows():
farmaco=row['Fármacos']#selecciono cada fila de la columna Fármacos
enfermedad=row['Enfermedades']#selecciono cada fila de la columna Enfermedades
# Obtengo los targets de cada fármaco según el DataFrame de targets
