Faire une chaine d'interactions avec Python

Version imprimable

22/05/2019, 14h01
Amniote

Faire une chaine d'interactions avec Python

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
22/05/2019, 14h05
Bktero

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 ;)

Merci pour votre réponse rapide :)

Pour l'instant mon code ressemble à ça:
Code:

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 :'(

23/05/2019, 10h01
Bktero

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 ?
23/05/2019, 10h12
Amniote

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 :)
23/05/2019, 10h52
Julien N

Salut,

Citation:

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
23/05/2019, 10h53
Amniote

Oui tout à fait, les interactions vont dans les deux sens :)
23/05/2019, 11h12
wiztricks

Citation:

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
23/05/2019, 11h37
Julien N

Citation:

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
23/05/2019, 11h42
Bktero

Tu donnes cette liste d'interactions :

Code:

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

Et pourquoi pas l'ordre inverse ?

Code:

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

Citation:

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:

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 ! :)

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:

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

23/05/2019, 12h40
wiztricks

Citation:

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