Faire une chaine d'interactions avec Python

**Amniote** · 22/05/2019, 14h01

Bonjour à tous,

j'ai un fichier que voici (exemple):

P1 P2
P6 P4
P7 P5
P2 P7
P12 P52
Pf Pb
Pm Pz
ect…

Ce fichier représente des interactions entre protéines (par exemple P1 intéragit avec P2, P6 avec P4...)
Je dois faire une chaine d'interaction de 4 protéines (donc 3 interactions)
Par exemple ici, P1 interagit avec P2 qui interagit avec P7 qui interagit avec P5...

J'ai commencé par créer un dictionnaire qui pends comme clé la première protéine puis en valeur la protéine avec laquelle elle interagit, par exemple Dinteraction[P1]=P2

Je n'ai aucune idée de comment procéder par la suite… Ni comment faire mes interactions, ni comment faire pour limiter les interaction à 3.

Il me faudrait un résultat comme celui-ci (une chaine d'interaction par ligne):
P1 P2 P7 P5

Pouvez vous m'aiguiller sur la marche à suivre ?

Merci d'avance

**Bktero** · 22/05/2019, 14h05

Bonjour,

Il faut commencer par penser l'algorithme en français ou en pseudo-code. Par exemple :
- créer une liste vide
- ajouter la première protéine dans la liste
- parcourir les associations 1/1 possibles
- s'il y a correspondance, ajouter à la liste
- si la liste atteint la longueur 3, s'arrêter
- etc

Une fois que ce mode opératoire est clair, que tu arrives à le dérouler sur papier avec un crayon, il sera temps de le traduire en code

**Amniote** · 22/05/2019, 14h55

Merci pour votre réponse rapide

Pour l'instant mon code ressemble à ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
import re
import pprint
from collections import defaultdict
 
dInteraction={}
chaine=[]
with open ("nomdemonfichier.txt","r") as f1:
	for lignes in f1:
		lignes1=lignes.rstrip("\n")
		matchs=re.search("^(\S+) (\S+)", lignes1)
		if matchs:
			NameP1=matchs.group(1)
			NameP2=matchs.group(2)
			dInteraction[NameP1]=NameP2

je suis désolé j'ai beau chercher, je ne vois pas comment coder pour la suite :'(

**Bktero** · 23/05/2019, 10h01

De rien

Je parle d'algorithme en français, tu me réponds avec du code. Tu me dis que tu ne sais pas comment coder, je vais te demander : "que veux-tu coder ?".

Quelques détails sur ce que tu as déjà fait :
- Tu importes des packages que tu n'utilises pas.
- Tu fais des regexp pour extraire les numéros mais pourquoi t'embêter alors que tu pourrais stocker "P1" et "P2" au lieu de 1 et 2.
- Ta variable s'appelle lignes alors que c'est une seule ligne (donc ne mets pas de s).
- Tu peux faire : lignes = lignes.rstrip('\n').
- Tu dois même pouvoir te passer du rstrip() avec ta regexp.

Tu peux nous montrer un exemple de fichier et de résultat attendu ?

**Amniote** · 23/05/2019, 10h12

Le but de mon algorithme est de créer toutes les chaines d'interactions possibles entre les protéines de mon fichier

voici un extrait du vrai fichier sur lequel je travaille (il y a plus de 20 000 interactions comme celles-ci) :

ADSL MDH1 0 0 0 141 50 800 153 843 ---> EXP
BNYD GHFC 0 0 0 82 153 900 203 929 ---> EXP
ADSL APRT 156 0 0 485 376 900 868 995 ---> EXP
HDGV BNDY 0 0 0 82 153 900 203 929 ---> EXP
NXF2 XPO5 0 0 0 82 153 900 203 929 ---> EXP
NXF2 RAE1 0 0 0 62 507 800 627 960 ---> EXP
MDH1 HDGV 0 0 0 82 153 900 203 929 ---> EXP

Ici par exemple, ADSL interagit avec MDH1 qui interagit avec HDGV qui interagit avec BNDY qui interagit avec GHFC...
ce qui donne la chaine d'interaction : ADSL MDH1 HDGV BYDN GHFC
On peut également créer les débuts de chaines d'interactions suivantes :
HDGV BYDY GHFC...
MDH1 HDGV BNDY GHFC …

Il faut donc que je trouve toutes les combinaisons possibles sur une chaine de 10 protéines (donc 9 interactions)

J'espère que j'ai été assez clair, le problème est assez complexe

**Julien N** · 23/05/2019, 10h52

Salut,

Envoyé par Amniote

Ici par exemple, ADSL interagit avec MDH1

Dans ce cas, est-ce qu'on peut aussi considérer que MDH1 interagit avec ADSL? En gros, est-ce qu'il y a réciprocité?

J

**Amniote** · 23/05/2019, 10h53

Oui tout à fait, les interactions vont dans les deux sens

**wiztricks** · 23/05/2019, 11h12

Envoyé par Amniote

Je n'ai aucune idée de comment procéder par la suite… Ni comment faire mes interactions, ni comment faire pour limiter les interaction à 3.

Il faut commencer par décrire un "algo.".
Ici on pourrait dire:
étape 0: on a la liste contenant [ 'P1' ], on cherche dans le dico. la valeur associée à dico['P1'] (le dernier de la liste) et on l'ajoute à la liste.
étape 1 : on a la liste [ 'P1', 'P2'], on cherche dans le dico. la valeur associée au dernier de la liste et on l'ajoute.
etc...
Et on enchaine çà tant que la longueur de la liste est < 4 ou que le dernier élément ajouté n'a pas de suivant.

- W

**Julien N** · 23/05/2019, 11h37

Envoyé par wiztricks

étape 0: on a la liste contenant [ 'P1' ], on cherche dans le dico. la valeur associée à dico['P1'] (le dernier de la liste) et on l'ajoute à la liste.

Je dis peut-être une connerie, mais il me semble que c'est un chouilla plus compliqué. Il peut y avoir plusieurs protéines qui interagissent entre elles. Par exemple ADSL peut interagir avec MDH1, mais aussi avec APRT. Si on prend ADSL pour départ, on se retrouve à minima avec deux chaines possibles.

Le problème pourrait être traiter comme un graph. Chaque noeud étant une protéine. Il existe pas mal de littérature sur le sujet. Notamment pour lister tous les chemins.

[EDIT]
Pour le graph, je crois que la méthode Breadth First Search est appropriée. https://en.wikipedia.org/wiki/Breadth-first_search

Sinon, il est possible de s'inspirer de ce fait un module comme os pour lister l'ensemble des fichiers d'un dossier de façon récursif.

J

**Bktero** · 23/05/2019, 11h42

Tu donnes cette liste d'interactions :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

['ADSL', 'MDH1', 'HDGV', 'BYDN', 'GHFC']

Et pourquoi pas l'ordre inverse ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

['GHFC', 'BYDN', 'HDGV', 'MDH1', 'ADSL']

**Amniote** · 23/05/2019, 11h43

Envoyé par Julien N

Je dis peut-être une connerie, mais il me semble que c'est un chouilla plus compliqué. Il peut y avoir plusieurs protéines qui interagissent entre elles. Par exemple ADSL peut interagir avec MDH1, mais aussi avec APRT. Si on prend ADSL pour départ, on se retrouve à minima avec deux chaines possibles.

Le problème pourrait être traiter comme un graph. Chaque noeud étant un protéine. Il existe pas mal de littérature sur le sujet. Notamment pour lister tous les chemins.

J

En effet vous avez raison c'est bien le problème que j'ai rencontré au début de mes recherches.
Du coup je suis parti sur ce type de script :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from collections import defaultdict
Dprot1 = defaultdict(set)
Dprot2 = defaultdict(set)
Dinter = defaultdict(dict)
 
with open("C:/Users/lveillat/Desktop/Données stage/Données/resultats_matrice_avec_scores_sans_localisation.txt","r") as f1:
	for ligne in f1:
		lp = ligne.rstrip('\n').split(" ") 
		if lp[-1] == "EXP": #Si il y a présence d'une coexpression
			prot1 = lp[0] #prot1=la première proteine
			prot2 = lp[1] #prot2=la seconde proteine
			if prot1 not in Dprot1: #Si la prot n'est pas dans mon dico on la rajout (pas de doublons comme ça)
				Dprot1[prot1].add(prot1) 
			if prot2 not in Dprot2: #Idem pour prot 2
				Dprot2[prot2].add(prot2)
			Dinter[prot1][prot2]=1 #Si interaction entre 2 prot on marque 1
	#print (Dinter)
f1.close()
 
for i in Dprot1: #On parcours tout les elements de Dprot1
	for j in Dprot2: ##On parcours tout les elements de Dprot2
		if Dinter in (i,j): #Si on retrouve la couple prot1 prot2 dans mon dico Dinter qui contient toutes les interaction
			print ('1') #Alors on print 1
		else:
			print ('0') #sinon 0

voici ce que contient prot1 :
GHCF
SDFG
LGJ
DFHX
GDFG
SSDF
GHHS
ADSL
SDG
…

prot2:

SDF
HDFC
SDFY
SFS
TYHD
SFYD
…

mon dictionnaire Dinter

{'ARF5': {'SPTBN2': 1, 'ARFGAP1': 1, 'ANK2': 1, 'COPZ2': 1, 'KIF15': 1, 'KIF2B': 1, 'KIF25': 1, 'KDELR2': 1, 'RAB1B': 1, 'TMED10': 1, 'KIF3B': 1, 'GBF1': 1, 'CAPZB': 1, 'KIF3C': 1, 'COPA': 1, 'YKT6': 1, 'COPB1': 1, 'KIF20A': 1, 'RAB1A': 1, 'ACTR1A': 1, 'CAPZA2': 1, 'CAPZA1': 1, 'SPTBN5': 1, 'USO1': 1, 'CENPE': 1, 'KIFC1': 1, 'KIF9': 1, 'ARF1': 1, 'KIF6': 1, 'KIF18B': 1, 'KIF26A': 1, 'KIF5A': 1, 'KIF20B': 1, 'ANK1': 1, 'KIF18A': 1, 'KIF19': 1, 'KIF23': 1, 'BET1': 1, 'KDELR1': 1, 'ANK3': 1, 'SPTBN1': 1, 'KIF5B': 1, 'COPB2': 1, 'KIF11': 1, 'KIF2C': 1, 'ARCN1': 1, 'DYNLL2': 1, 'COPG2': 1, 'KIFC2': 1, 'COPG1': 1, 'KIF26B': 1, 'DYNLL1': 1, 'ARFGAP2': 1, 'KIF2A': 1, 'KIF22': 1, 'KIF12': 1, 'SEC22B': 1, 'ARFGAP3': 1, 'KDELR3': 1, 'KIF3A': 1, 'COPZ1': 1, 'COPE': 1, 'DCTN1': 1}, 'FKBP4': {'HSF1': 1, 'PPP5C': 1, 'ACTR1A': 1, 'HSPA1A': 1, 'PPID': 1, 'HSPA2': 1, 'PTGES3': 1, 'HSP90AA1': 1, 'HSP90AB1': 1, 'STIP1': 1, 'HSPA8': 1, 'EP300': 1, 'FOXA1': 1, 'HSPA1L': 1, 'ESR2': 1, 'MAPK3': 1, 'HSPA1B': 1, 'DCTN1': 1}, 'CYP26B1': {'ALDH1A1': 1}, 'NDUFAF7': {'NDUFA10': 1, 'NDUFS7': 1, 'NDUFS2': 1, 'NDUFS3': 1},

(il met un 1 a toutes les interactions possibles)

J'y suis presque !

**Julien N** · 23/05/2019, 12h17

Est-ce qu'il y a un intérêt pédagogique? Parce que si ce n'est pas le cas, ne vous emmerdez pas. Partez sur le module networkx:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import networkx as nx
 
text = """ADSL MDH1 0 0 0 141 50 800 153 843 ---> EXP
BNYD GHFC 0 0 0 82 153 900 203 929 ---> EXP
ADSL APRT 156 0 0 485 376 900 868 995 ---> EXP
HDGV BNDY 0 0 0 82 153 900 203 929 ---> EXP
NXF2 XPO5 0 0 0 82 153 900 203 929 ---> EXP
NXF2 RAE1 0 0 0 62 507 800 627 960 ---> EXP
MDH1 HDGV 0 0 0 82 153 900 203 929 ---> EXP"""
 
# Build a graph of the protein interactions
graph = nx.Graph()
for line in text.split('\n'):
    p1, p2 = line.split(' ')[:2]
    # Create nodes
    graph.add_nodes_from([p1, p2])
    # Create edge
    graph.add_edge(p1, p2)
 
print('All nodes:\n', list(graph.nodes))
 
sp = dict(nx.all_pairs_shortest_path(graph))
print('All nodes leading to BNDY:\n', sp['BNDY'])
 
print('All paths from ADSL to BNDY: \n', list(nx.all_simple_paths(graph, 'ADSL', 'BNDY', cutoff=3)))

Documentation: https://networkx.github.io/documenta...est/index.html

J

**wiztricks** · 23/05/2019, 12h40

Envoyé par Julien N

Je dis peut-être une connerie, mais il me semble que c'est un chouilla plus compliqué.

Ce que j'ai essayé d'illustrer c'est qu'il était assez simple de décrire en français un algorithme (avant de se lancer à coder)....
Et de se rendre compte rapidement, si çà avait des chances de le faire ou pas.

Et si on dit que des séquences de protéines peuvent se répéter sur des cycles plus ou moins longs, il va aussi falloir que l'algo. le traduise d'une façon ou d'une autre.

Si on ne passe pas par cette étape là, on peut coder un truc qui le fera moyen ou espérer que la bibliothèque machin ait la solution magique: si on ne sait pas ce qu'on veut et qu'on n'a pas pris le temps de décrire à quoi devrait ressembler la solution... on n'y arrivera pas - çà aussi c'est simple.

- W

Faire une chaine d'interactions avec Python

Python

Discussions similaires

Partager

Partager