Discussion :

[Totoprosper]

Bonjour,

Je suis un vrai débutant en matière de programmation. J’utilise les langages de programmation awk, grep, sed et python pour analyser des séquences d’ADN. Le problème auquel je fais fasse depuis un certain moment est le suivant :
J’ai 1024 fichiers en format fasta. Ils sont du genre :
…….BamTo_AAAAA.fasta
…….BamTo_CCCCC.fasta
…….BamTo_GGGGG.fasta
…….BamTo_TTTTT.fasta
…….BamTo_ACAAA.fasta
…….BamTo_AGAAA.fasta
…….BamTo_ATAAA.fasta
……………………….. Avec A,C,G,T les 4 constituants (bases) des séquences d’ADN (ici 45 = 1024 = nombre de fichiers)

Chaque fichier contient à peu près 200 à 300 séquences avec des tailles différentes pouvant aller de 50 à 240 constituants (bases).

Dans chaque fichier, il y a des séquences répétées 1x, 2x, 2x, 3x, 4x, 5x,…..Nx. Le fichier …….BamTo_AAAAA.fasta peut par exemple contenir les séquences suivantes:

----------------------------------------------G----- séquence répétée 1x

------------------------------T--------- séquence répétée 2x
------------------------------T---------

------------------------------------A--------- séquence répétée 2x (avec une erreur)
------------------------------------G---------

---------------------------------C---------------------------- séquence répétée 3x (sans erreur)
---------------------------------C----------------------------
---------------------------------C----------------------------

-----------------------------------------C--------------------------- séquence répétée 3x (avec une erreur)
-----------------------------------------A---------------------------
-----------------------------------------A---------------------------

------G-----------------------------------A-------------------------- (séquences répétée 5x avec 3 erreurs)
------G-----------------------------------A--------------------------
------C-----------------------------------G--------------------------
------T-----------------------------------A--------------------------
------G----------------------------------A---------------------------

J’aimerais maintenant créer un fichier consensus (consensus_fichier1.fasta) qui contient : toutes les séquences répétées 1x et 2x de tous les fichiers, un représentant de chaque séquence répétée au moins 3x (après correction des erreurs). Dans le fichier consensus, une même séquence peut être répétée xfois, cela ne pose aucun problème.

Egalement, je souhaiterais un deuxième fichier consensus (consensus_fichier2.fasta) similaire au premier mais qui se présente comme suit :

Sequence1_AAAAA --------------------------------T-----------------------
Seuence2_ACAAA ---------------------------------------------------G----------------
Sequence3_AACAA -------------------------------A----------------

Chaque ligne du deuxième fichier consensus contient le nom de la séquence (sequence n_NNNNN ; {NNNNN} étant le suffix du fichier d’origine d’où provient la séquence n) suivi de tabulation et la séquence elle-même.

Avec le plus grand respect, quelqu’un pourrait-il m’aider avec quelques codes de awk, sed, grep ou de python à accomplir ce travail ?

D’avance, mille mercis

[N_BaH]

je vais faire ma mauvaise tête, mais "répéter 1 fois", tel que tu le montres, ce n'est pas possible.
répéter, c'est re-dire.
Or, ----------------------------------------------G-----, est présent une seule fois, donc n'est pas répété !
par contre, ------------------------------T---------, est effectivement répété une fois : la deuxième ligne répète la première.

je suis perplexe devant le sujet : autant je peux identifier des lignes identiques, autant comment puis-je ne pas considérer qu'une ligne, qui ressemble, qui comporte (selon tes termes) une/des erreur(s), n'est pas une nouvelle séquence ?

il me faudrait quelques extraits de fichiers représentatifs, et la sortie attendue.

[Flodelarab]

Bonjour

L'ordre des lignes a-t-elle une importance ?
La phrase à droite de la séquence est-elle dans le fichier ou seulement sur le forum ?
Les tirets signifient-ils "n'importe quel caractère" ou y a-t-il vraiment des tirets dans le fichier ?
Et même questions que N_BaH.

[Totoprosper]

Bonjour,
Merci N_BAH pour votre intervention. J'aimerais tout d'abord rectifier que s'il y a dans un fichier .....BamTo_NNNNN.fasta une séquence répétée 2x avec une identité de 100%, seule une des deux séquences est présente dans le fichier consensus. S'il y a une erreur dans l'une des séquences, les deux sont prises dans le fichier consensus.

Les erreurs proviennent du séquençage et de l'amplification des séquences. S'il y a une similitude d'au moins 95%, entre deux séquences, elles peuvent être
considérées mêmes séquences, la présence d'une troisième séquence va permettre de corriger justement les erreurs.

Jai joint deux fichiers type et le résultat attendu (fichier consensus). J'ai mis des lettres et des numéros pour des raisons de clarification, mais les fichiers originaux n'en disposent pas. Merci

[Totoprosper]

Bonjour,

Merci Flodelarab. L'ordre des lignes n'a aucune importance. Le nom des séquences à droite ne se trouve pas dans les fichiers. C'était pour
clarifier ma question. Il n'y a pas non plus de tirets dans les fichiers (les tirets sont dans les nom des fichiers.). Dans les fichiers, chaque ligne est une séquence. Pas de ligne entre séquences.

Merci beaucoup

[Flodelarab]

La question laisse perplexe. A priori, on fait ceci :

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
$ ls adn_[GT]*.txt
adn_GGAAT.txt  adn_TTTCC.txt
$ sort adn_[GT]*.txt |uniq -c
      2 AACCTCAATGCTCTGCTACCCTGAATTCTCAGGTTGAGCTGGAGGTTCCCCAGCTCTGCAGCTTCATCCTGAAGACCAGCCAGTGCACCCTGAAAGAGGTGTATGGCTTCAACCCTGAGGGCAAAGCCTTGCTGAAGAAAACCAAGAACTCTGAGGAGTTTG
      3 AGGTGCCCGCCACCACGCCCGGAACTTTTTGTATTTTCAGTAGAGACGGGGTTTCACCTTGGTCTCGATCTCCTGACCTCGTGATCCACCCGCCTCAGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACTGCGCCCGGCCTCACC
      2 AGGTGCCCGCCACCACGCCCGGCCAATTTTTGTATTTTTAGTAGAAGACATGGTTTCACCATGTTGGCCAGGCTGATCTCGATCTCCTAACCTCAAGTGATCCACCCACCTCGGCCTCCCAAAGTGCTGGGTTTACAGGTGTGAGCCACTGCGCCCGGCCTCACC
      1 AGGTGCCCGCCACCACGCCCGGCTAATTTTGTATTTTTAGTAGAGACGGGGTTTCTCCATGTTGGTCAGGGTGGTCTCGAACTCCCAACCTCAGGTGATCCGCCCGCCTCCGCCTCCCAAAGTGTTGGAATTACAGATGTGAGCCACTGCGCCCGGCCTCACC
      1 AGGTGCCCGCCACCACGCCCGGCTAATTTTTCTGTATTTTTGTAGAGACAGGGTTTCACTGTGTTAGCCAGGATGGTCTCGATCTCCTGACCTCGTGATCTGCCTGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCATGAGCCACTGCGCCCGGCCTCACC
      1 AGGTGCCCGCCACCACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACAGGGTTTCATCATGTTGGCCAGGTGGGTCTCAAACTCCTGACCTCAGGTGGTCCTTCTGCCTTGGCCTCCCAAAGTGCTGGGATTATAGGCGTGAGCCACTGCGCCCGGCCTCACC
      1 AGGTGCCCGCCACCACGCCCGGCTAATTTTTTGTATTTTTAGCAGAGTCGGGGTTTCACCATGTTAGCCAGGATGGTCTCGATCTCCTGACCTCCTAATCCGCCCGCCTCAGCCTCCCAAAGTGCTGGGATTACAGGCATGAGCCACTGCGCCCGGCCTCACC
      1 AGGTGCCCGCCACCACGCCCGGCTAATTTTTTGTATTTTTAGTAGAGACGGGATTTCACCGTGTTAGCCAGGATGGTCTCGATCTCCTGACCTGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGCTAGGATTATAGGTGTGAACCACTGCGCCCGGCCTCACC
      1 AGGTGCCCGCCACCACGCCCGGCTAATTTTTTGTATTTTTAGTAGAGACGGGATTTCACCGTGTTAGCCAGGATGGTCTCGATCTCCTGACCTTGTGATCCGCCCGCCGCGGACTCCCAGAGTGCTGGGATTGCAGGCGAGAGCCACTGCGCCCGGCCTCACC
      1 AGGTGCCCGCCACCACGCCCGGCTAATTTTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTAGCCAGGATGGTCTCGATATCCTGACCTTGTGATCTGCCCGCCTTGGCCTCCCAAAGTGCTGGGATTACAGGCTTGAGCCACTGCGCCCGGCCTCACC
      1 AGGTGCCCGCCACCACGCCCGGCTAATTTTTTGTATTTTTTGTAGAGATAGGATTTCACTGTGTTAGCCAGGATGGTCTCGATCTCCTGACCTCGTTATCCACCCACCTGAACCTCCCAAAGTGCTGGGATTACAGGCTTGAGCCACTGCGCCCGGCCTCACC
      1 AGGTGCCCGCCACCACGCCCGGCTAATTTTTTTGAATTTTTAGTACAGACGGGGTTTACCGTGTTAGCCAGGATGGTCCCCTTCTCCTGACCTCGTGATCCACCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACTGCGCCCGGCCTCACC
      1 AGGTGCCCGCCACCACGCCCGGCTAATTTTTTTTGTATTTTTAGTAGAGACGGGGTTTCACCACGGTCTCGATCTCCTGACCTCGTGATCCACCCGCCTTGGCCTCTCAAAGTGCTGGGATTAAAGGTGTGAGCCACTGCGCCCGGCCTCACC
      1 AGGTGCCCGCCACCACGCCCGGCTATTTTTTGTATTTTTAGTAGAGACGGGGTTTCACCGTGTTAGCCAGGATGGTCTCGATCTCCTGACCTCCTGATTCACCCGTCTCGGCCTCCCGAGGTGCTGGATTTACAGGAGTGAGCCACTGCGCCCGCCTCACC
      1 AGGTGCCCGCCACCACGTTAGGCTAAGTTTTTGTATTTTTAGTAGAGACGGGGTTTCACCACATTAGCCAGGATGGTCTTGATCTCCTGACCTCGTGATCCACCTGCCTCGGCCTCCTAAAATGCTGGGATTACAGGCGTGAGCCACTGCGCCCGGCCTCACC
      1 CACTCCAGAGAGCCCACTACCGTCGGATCGTGCGTGTATCCTACGATCTCGTATGCCGTCTTCTGCTTGAAAAAAAAAAAAAACAAAAATAAAAAAAAAAAATAAAAAAAAAAAAAAAATAAAAAAAAAAATATATTTTTTTTTTTTAATGATACGGCGACCACCGAGATCTACACATACGAGATCCGTAATCGGGAAGCTGAAGCACTCCAG
      1 CAGAAGCCAGAAGTGAGATCCTCGCCCACTGGTCGCCTGCCAAACTGCTTCTCCAAATGGACTCATCTGCTACAGCTTATGGCTCCACAGTTTCCAAGAGGGTGGCATGGCATTATGGTATGTGTCTCTTCCCCTGTGTGAGCACTTCCAAAGTAATGCAGG
      3 CATTATGCACTGTCTTCATTGTAATGTCTTTAGATTAGAGCTGGAACTGAGGCCTACAGGAGAGATTGAGCAGTATTCTGTCAGCGCAACCTATGAGCTCCAGAGAGAGGACAGAGCCTTGGTGGATACCCTGAAGTTTGTAACTCAAGCAGAAGGTGAGTA
      1 CCAAGGATGGTCTTTGATTTCAGGAACAGTGAACCCTTGCTCTACCAATGCTTTCATACGTTTAGCCCAATCTTGGATAGAATATTGCTCTGCAAAGTCAGTAAGGTTCTTAGCAGCAAGAGTCCACCAATCAGAAATGTAGGTGACAAGTGCGCTATAAACC
      1 CCAAGGATGGTCTTTGATTTCAGGAACAGTGAACCCTTGCTCTACCAATGCTTTCATACGTTTAGCCCAATCTTGGATAGAATATTGCTCTGCAAAGTCAGTAAGGTTCTTAGCAGCAAGAGTCCACCAATCAGAAATGTAGGTGACAAGTGTGCTATAAACC
      1 CCAGGATGGTCTCCGATCTCCTGACCTCGTGATCCGCCTGCCTTGGCCTCCCGAAGTGCTGGGATTACAGGCGTGAGCCACTGCGCCCGGCCTCACC
      1 CCAGGATGGTCTCGATCTCCTGACCTCGTGATCCGCCTGCCTCGGCCTCCGAAAGTGCTGAGATCACAGGCATGAGCCACTGCGCCCGGCCTCACC
      4 CCAGGATGGTCTCGATCTCCTGACCTCGTGATCCGCCTGCCTCGGCCTCCGAAAGTGCTGAGATTACAGGCATGAGCCACTGCGCCCGGCCTCACC
      1 CCTGATGCCATTTTCTTGTCTGATTTTCTTTCTCAGATTGGCTTGGAAGGAAAAGGCTTTGAGCCAACATTGGAAGCTCTTTTTGGGAAGCAAGGATTTTTCCCAGACAGTGTCAACAAAGCTTTGTACTGGGTTAATGGTCAAGTTCCTGATGGTGTCTCT
      7 CCTGTAGAGTGGGAGGCCCTCAGGGACCCGGGTGTAGGAGAGTGCACGGGGCTGGGCGCCCTTCCACGCCCCATGCGCAGATGCCTTACTTGGACAGACCAGGCTGACATTTTCCAGCATTTCCTCTTCTGTAAGACAGGAGAAAGAAATCTGTGAGCTTCC
      1 CTCCAACTCCTGAACTCAAGTGATCGACCCACCTCGGCCTCCCAAAGTGCTGGGATTACAGGTGTGAGCCACTGCGCCCGGCCTCACC
      1 GAACAGGGCTGGGGGAAAGCTGTGGGCTCTAGGTCCCTCCTGCCTGCATCCTCCATACCTTGCAGTTGATCCTGGTGGCACTTCTTGAATCAGCAGTCCCAGGGACTCCACTGGAACTCTCAGCCTCATAGTTGTATGTGTACTTCCGGAGGTGCTTGAATC
      1 GCTAACAAGGTGAAACCCCGTCTCTACTAAAAATACAAAAAATTAGCCGGGCGCGGTGGCGGGCGCCTGTAGTCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATGGTGTGAAC
      2 GGAGGCCGAGGCGGGTGGATCACAAGGTCAGGAGATAGAGACCATCCTGGCTAACACGGTGAAACCCCATCTCTGCTAAAAATACAAAAAATTAGCCAGGCTTGGTGGTGGAAGCCTGTAGTCCCAGCTACTTGGGAGGCTGAGGCAGGAGAATGGTGTGAAC
      1 GGAGGCCGAGGCGGGTGGATCATGAGGTCAGGAGATCAAGACCATCCTGGCTAACACGGTGAAACCCCGTCTCTACTAAAAATATAAAAAATTAGCCAGGCGTCGTGGTGGGCGCCTGTAGTTCCAGCTACTCGTGAGGCTGAGGCAGGAGAATGGTGTGAAC
      1 GGAGGCCGAGGCGGGTGGATCATGAGGTCAGGAGATCAAGACCATCCTGGCTAACATGGTGCATCAGCAGCCC
      1 GGAGGCCGAGGCGGGTGGATCATGAGGTCAGGAGATCGAGACCATCCTGGCTAACAAGGTGAAACCCCGTCTCTACTAAAAATACAAAAAATTAGCCGGGCGCGGTGGCGGGCGCCTGTAGTCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATGGTGTGAAC
      1 GGAGGCCGAGGCGGGTGGATCATGAGGTCAGGAGATCGAGACCATCCTGGCTAACAAGGTGAAACCCCGTCTCTACTAAAAATACAAAAAATTAGCCGGGTGTGGTGGCGGGTGCCTGTAGTCCCAGCTATTTGGGAGGCTGAGGCGGGAGAATGGTGTGAAC
      1 GGAGGCCGAGGCGGGTGGATCATGAGGTCAGGAGATTGAGACCATCCTGGCTAACATGGTAAAACCCCATCTCTACTAAAAATACAAAAAATTTAGCCAGGCATGGTGGCGGGCGCCTGTAGTCCCAGCTACTTGGGAGGCTGAGGCAGGAGAATGGTGTGAAC
      1 GTGAGAGCAGTCAGTTTCTCCTTGGCATGTGAAACTTGTCTCTCCCAATTGAATGAATTCAGATAATCATTAGCTTGCTGTGGGAGTTTTCCCAGGGCTGCTCTGTATTTTCTTACAAATTGATCAATATTGATGTGCTTCAGGTTTCTCTGTACGTTTTCC
      1 TCAAACACAGTGGCAAGTTTACACACAGAAAAAAATACACTGGAGCTTAGTAATGGAGTGATTGTCAAGATAAACAATCAGCTTACCCTGGATAGCAACACTAAATACTTCCACAAATTGAACATCCCCAAACTGGACTTCTCTAGTCAGGCTGACCTGCGC
      2 TCCTCTCAAAATATTCTTGCAAGGTCTCAAATGACATGATGGGCTCACTGA
      1 TCTCTGGTAACTACTTTAAACAGTGACCTGAAATACAATGCTCTGGATCTCACCAACAATGGGAAACTACGGCTAGAACCCCTGAAGCTGCATGTGGCTGGTAACCTAAAAGGAGCCTACCAAAATAATGAAATAAAACACATCTATGCCATCTCTTCTGCT
      1 TGTGTTCCCTCATCTGAGAATCTGGGGCAGGCCCATTTCCATGACCCTTTTCCAGAAGAAGTCCATGCTATGTGGCCAGCTTTCAACAGTGTCTTGATCTCGTTGCGCAGGTCAGCCTGACTAGAGAAGTCCAGTTTGGGGATGTTCAATTTGTGGAAGTAT
      1 TTCTAGGTTTCCTCCAGTGGTGGGGAGGCGGACGAGGAAAAGCAGAGTAGTGGACAGGACACGTCATGTTCCTCATAGACATCTGGAACCTTCTCATGCATCGTTTCCTTCCCTTCTAGGCACTGCCCATTTCCCACCGGAAACTTCAGCCAGCGCTCGCTG

À gauche, la quantité. À droite la séquence nécessairement unique.

Il faut trier avec "sort" car "uniq" le demande.

Était-ce la question ?

[papajoker]

d'après ce que j'ai compris ... il doit être possible d'avoir un nombre X de caractères différents ("95% uniquement doit être unique")
Donc c'est plutôt une question algorithmique (python?) ! grouper les lignes avec 5% d'erreurs (en fonction de la longueur de la chaîne donc - 50 à 240)

[Totoprosper]

Merci Flodelarab.

En utilisant la commande: sort R1R2_UMI.assembled.Aln.BamTo_[AG]*.fasta | uniq -c > consensus.fasta | grep -v '^>' consensus.fasta > consensus.txt
J'ai effectivement obtenu la listes des séquences avec les occurrences (fréquences) à gauche de chaque séquence.

Maintenant comment se débarrasser dans un premier des fréquences et n'avoir que les séquences seules. Puis dans un deuxième temps, à la place des fréquences, il faudrait séquence_XXXXX avec X=A,C,G, ou T, avec XXXXX indiquant l'origine du fichier dont provient la séquence en question.

Mais les séquences apparemment ne sont pas corrigées. Dans un fichier donné, j'aimerais parcourir et comparer pour chaque groupe de séquences les positions afin de corriger les erreurs de séquençage. Je n'arrive pas faire cela..... une idée?

Merci