Fonction de découpage de séquence pour l'étude de transcriptome [Résolu]

[faktis]

Bonjour à tous et à toutes bioinformaticiens !

Actuellement étudiant français en bio-informatique, je suis en stage en hollande pour valider mon diplôme...
J'ai un petit problème pour avancer dans mon projet et j'aurais besoin d'un coup de main des bio-informaticiens beaucoup plus expérimenté que moi.

Voici mon problème : comme vous le savez peut être tous déjâ il existe de nombreuses techniques permettant l'étude et la quantification de l'expression génique, tel que les puces à ADN....
Pour ma part je suis sur la technique récente de mRNA-seq qui porte sur l'étude des transcriptome (=: ensemble des ARNm d’une cellule, d’un tissu)
(Pour en savoir d'avantage voir article : mRNA-seq : a revolutionary tool for transcriptomics , facilement trouvable sur google ).
Donc je continue..;

Le but de mon stage sera donc de créer un programme ( en perl ) qui fera bien des choses, je ne rentrerais pas dans les details...



Cependant là ou je coince, c'est dans la réalisation d'une fonction capable de prendre n'importe quelle séquence d'ADN ou ARN et de la fragmenté en séquence de taille aléatoire , et c'est le fait que ce soit totalement aléatoire qui me dérange, je ne vois pas du tout comment faire...

Si vous avez donc des idées de rédaction de cette fonction, je suis preneur !
Merci d'avance pour l'aide que vous me fournirez !!!

A bientot.

[laura_]

J'aurais une idée, mais je ne sais pas si ca marcherait, surement quelqu'un en aura une meilleure.
Tu peux générer une liste de nombre aléatoire, grâce à la fonction rand() (en fonction du nombre de séquence que tu veux) et récupérer dans un tableau, les nucléotides correspondant à ces nombre aléatoires.

Apres je n'ai jamais utilisé la fonction rand(), et je ne sais pas comment elle génère un nombre aléatoire.

Faut-il que les fragments se chevauchent, ou doivent-ils être les uns a la suite des autres ?

[Noirham]

Salut Jordi ! Deux premiers topics, deux stagiaires aurillacois... On est doués

Pour faire de l'aléatoire, je ne vois que ce qu'a proposé laura. Je n'ai pas trouvé le code source de rand(), mais l'ayant utilisé en C, ça m'a l'air fiable.


Bon stage !

[faktis]

Salut !
Aurillacois , on voit se qui ont recourt au forum !!


Pour la fonction rand() je vais voir ce que cela peut donner, je ne connait pas trop cette fonction mais je vais essayer de trouver des renseignements dessus !

Tu peux générer une liste de nombre aléatoire, grâce à la fonction rand() (en fonction du nombre de séquence que tu veux) et récupérer dans un tableau, les nucléotides correspondant à ces nombre aléatoires.

Peut être Laura peut tu m'en dire plus...cependant je ne souhaite pas donner le nombre de morceaux de séquences que je veut récuperer car cela aussi je veux que ce soit aléatoire , en fait il s'agirait de faire ceci avec la phrase ci dessous :


blablablbalbalblablablbalblbbalbalbalbalbalbalbalbalbalbalbalbalbalbalbalbal ( on va dire que c'est pas séquence )

j'obtiendrais donc :

blablablababla
balabalalbalablabalablablablabblaba
balabalblablablablab
balbalablablabalbalablabalbalablbablbalbala et ceci complémtement aléatoire !!

Si tu as quelques pistes...je suis preneur !!

A bientot,

[laura_]

Si je résume, tu as besoin d'un nombre de brin aléatoire qui auront tous des positions aléatoires et des tailles aussi aléatoires. C'est bien ca ?

Il te suffit de générer un premier nombre aléatoire (qui sera ton nombre de brins) et de faire tourner ton programme le nombre de fois avec une valeur de position sur ta sequence et une valeur de taille, toutes deux aléatoires.

par ex :

Code :

1
2
3
4
5
6
7
8
9
 
my $seq = ******* ;
my $nb = int(rand()) ;
for (my $i=1;$i<=$nb;$i++)
{
     my $taille = int(rand()) ;
     my $position = int(rand()) ;
     my $fragment = substr($seq,$position,$taille) ;
}

j'aurais pensé à quelque chose dans ce genre la, apres je pense qu'il faut un peu plus pousser le coté aléatoire de la fonction rand pour voir si elle génère vraiment un nombre aléatoire, et comment ils le font, mais je pense que ca peut etre un début.

[faktis]

Soit, Pour le moment j'en suis la :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#!/usr/bin/perl
 
use strict;
use warnings;
 
 
open (FILE, "Seq_for_try.txt") || die "cannot open file";   #open (FILE,"$ARGV[0]") || die "cannot open $ARGV[0]";
open (OUT, ">$ARGV[0]") || die "cannot create file";	#>$ARGV[1]
my $seq=undef;
my @seq=undef;
my $sub_seq;
 
 
while (<FILE>) 
	{
		if(!/>/)
			{
			chomp ($_);
			$seq.=$_;
			@seq=($seq);
			}
 
#print OUT ("$seq\n\n\n");

Donc pour le moment je ne traite qu'une sequence qui se trouve dans mon fichier seq_for_try.txt.
mon programme prend donc une sequence au format fasta et la concatene sur une seul et meme ligne pour faciliter le decoupage..



Et c'est la que je bloque...

je voyais le truc du genre :

Code :

1
2
3
4
foreach(@seq)
	{
	$sub_seq=substr($seq, int(rand(length(@seq))), int(rand($seq)));
	}

Bien plus elaborer..

En fait je voudrais qu'il parcours la ligne de ma sequence, la coupe a un endroit aleatoire, extrait le morceaux qu'il vient de couper et continue le decoupage sur le reste de la sequence...

I am in the right direction...i think..
Merci deja pour ta piste, ca m'aide deja beaucoup...
si tu peux m'eclairer encore un peu..
Thanks,



ps : dsl pour l'orthographe je suis sur un clavier hollandais ^^

[Jasmine80]

Pour ouvrir un fichier fasta, il vaut mieux utiliser le module Bio::SEQIO pour lire ton fichier et chaque séquence lue est un BIO::SEQ

Code :

1
2
3
4
5
6
7
8
9
10
my $in  = Bio::SeqIO->new(-file => 'Seq_for_try.txt' , '-format' => 'fasta');
 
while ( my $seq = $in->next_seq() ) {
 
	# séquence
	$seq->seq;
 
	# id
	$seq->primary_id;
}

[faktis]

Pour le moment ce n'est pas ce qui me pose probleme jasmine , je m'occuperai de la recuperation de sequence apres, pour le moment je me concentre sur une sequence que jai deja mis dans un fichier...( car apres je vais devoir faire cette manipulation pour des milliers de sequences....

J'en suis toujours a essayer de creer un tableaux qui contiendra mes sequences.... puis une fonction qui prendra le 1er element du tableaux ( soit ma 1ere sequence) et qui la coupera en un nombre aleatoire de fragments et qui me reverra les fragments dans un second tableaux , et qui continuera a prendre le second element de mon premier tableaux , pour mettre les fragments dans encore un autre tableaux...
Pourb cela j'ai pense a ecrire une fonction (qui coupera aleatoirement ma chaine de characteres )dont je ferai apelle dans une boucle...

pourrais tu me guider ?? je coince et je n'ai pas les notions assez pousser pour le moment...

[Jasmine80]

Envoyé par faktis

En fait je voudrais qu'il parcours la ligne de ma sequence, la coupe a un endroit aleatoire, extrait le morceaux qu'il vient de couper et continue le decoupage sur le reste de la sequence...

Usage : $substring = $obj->subseq(10,40);
Function: Returns the subseq from start to end, where the first base
is 1 and the number is inclusive, ie 1-2 are the first two
bases of the sequence

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
#!/usr/bin/perl
 
use strict;
use warnings;
 
 
use Bio::SeqIO;
 
 
 
my $in  = Bio::SeqIO->new(-file => 'Seq_for_try.txt' , '-format' => 'fasta');
 
my @frag_list;
 
while ( my $seq = $in->next_seq() ) {
 
 
	# reste de la séquence après avoir coupé certains morceaux
	# se raccourci au fur et à mesure
	my $seq_rest = $seq->seq;
 
        $start = 0;
 
	while ($start < length($seq_rest) ){
 
 
		# on prend une taille inférieur ou égale à la longueur 
		# de la sous séquence restante	comme point de départ du nouveau fragment	
		my $start = int(rand(length($seq_rest)));
 
		# on prend une taille inférieur ou égale à la longueur 
		# de la sous séquence restante comme taille du fragment
		# donc ici, la taille due la sous-séquence moins la position de départ
		my $l_rest = length($seq_rest) - $start;
		my $length = int(rand($l_rest));
 
		# on prend un fragment commençant à $start et long de $length
		my $fragment = substr($seq_rest,$start,$length) ;
		push (@frag_list, $fragment);
 
		# la séquence restante commence après le fragment qu'on vient de coupé
		$seq_rest =~ s/\w+$fragment//;
 
	 }
 
 
} 
 map {print "$_\n"} @frag_list;

Si par exemple tu as une séquence :

TTCTTCTTGCTTATCCCAGCTGTTACGATACCCGACTCTGGCTGCCAAAATGTGGAAATTGGTAATTATAGCGTTTGCAATATTTTCTGCGGTTGTTGTTTCTGCGGCCCATACAGAGGAAGAGAAATTTTTTGCAGAAAGGCGTCCAAATTCGGAGCGGGCGCAGGAGGAGGAGGAGGGGGAAGCTCCGGCTCAGGCGGGCCTTCTTCTGCTTCGGGTTCAGATCATGGAGCAGGACCGCAAGGAAGCTGGGGATATAAGTGGGGTTATGGTTCCGCTCCCGGTTCCGGCTGGGGCTTCGGCTCCGGCTCCGGCAGATCTACTTCCGGCGACGGTAGCGCCTTCGGATTCGGCTACGGCTCCGGGTCTGGTTCCGGTTCAAGATCGGGTTCA

tu peux obtenir comme fragments :

ACGATACCCGACTCTGGCTGCCAAAATGTGGAAATTGGTAATTAT
CGTTTGCAATATTTTCTGCGGTTGTTGTTTCTGCGGCCCATACAGAGGAAGAGAAATTTTTT
GGGTTATGGTTCCGCTCCCGGTTCCGGCTGGGGCTTCGGCTCC
TCCGGCAGATCTACTTCCGGCGACGGTAGCGCCTTC

Nb : Il faut faire quelque chose de ce genre, mais il y a un problème dans le if(), j'y regarde et je te dis quoi

[Jasmine80]

Le problème avec cette méthode est que tu as des fragments de plus en plus courts car leur taille est définie par une valeur aléatoire dépendant de la longueur de la séquence restante int(rand($l_rest)) donc, avec la séquence entière de départ, ton fragment sera plus grand qu'avec la séquence restante après découpage.


Si par exemple ta séquence de départ fait 500 nucléotides Tu peux donc récupérer un fragment compris entre 0 et 500 nucléotides int(rand(500)). Admettons que tu récupères un fragment aléatoire de 150 nucléotides, allant de la position 36 à 136 de la séquence de départ. Il reste donc pour le fragment suivant à découper dans la sous-séquence restante de 137 à 500 (position de la séquence de départ). Cette sous-séquence fait donc 363 nucléotides, le fragment à récupérer peut donc faire entre 0 et 363 nucléotides int(rand(363)) et ainsi de suite.

La solution, si tu veux des fragments de tailles équivalentes est de définir une taille maximale.

[laura_]

Pour repartir de l'idée de Jasmine, tu pourrais aussi, plutot que de faire tourner ton programme qui génère des fragments de séquences SUR la séquence découpée, de la faire tourner TOUJOURS sur la séquence de départ.

Ce pourrait etre une solution non ?

[Jasmine80]

Envoyé par laura_

Pour repartir de l'idée de Jasmine, tu pourrais aussi, plutot que de faire tourner ton programme qui génère des fragments de séquences SUR la séquence découpée, de la faire tourner TOUJOURS sur la séquence de départ.

Ce pourrait etre une solution non ?

Ce serait le plus simple mais Faktis a dit plus haut :

En fait je voudrais qu'il parcours la ligne de ma sequence, la coupe a un endroit aleatoire, extrait le morceaux qu'il vient de couper et continue le decoupage sur le reste de la sequence...

[faktis]

Pour repartir de l'idée de Jasmine, tu pourrais aussi, plutot que de faire tourner ton programme qui génère des fragments de séquences SUR la séquence découpée, de la faire tourner TOUJOURS sur la séquence de départ.

Ce pourrait etre une solution non ?

alors il y aurait de nombreuse redondance dans les fragments que cela genera.. je ne pense pas que ce soit la solution...

Le problème avec cette méthode est que tu as des fragments de plus en plus courts car leur taille est définie par une valeur aléatoire dépendant de la longueur de la séquence restante int(rand($l_rest))

Tu as raison , donc il ne faudra pas que ca dépendent de la longueur de la séquence restantes mais d'une longueur fixe qui sera la longueur de ma séquences de départ.. comme ca je n'aurais pas des fragment plus court a chaque fois , mais cela me generera des fragments de taille aléatoire a chaque fois....( si tu vois ce que je veut dire)

Si par exemple tu as une séquence :
Citation:
TTCTTCTTGCTTATCCCAGCTGTTACGATACCCGACTCTGGCTGCCAAAATGTGGAAATTGGTAATTATAGCGTTTGCAATATTTTCTGCGGTTGTTGTTTCTGCGGCCCATACAGAGGAAGAGAAATTTTTTGCAGAAAGGCGTCCAAATTCGGAGCGGGCGCAGGAGGAGGAGGAGGGGGAAGCTCCGGCTCAGGCGGGCCTTCTTCTGCTTCGGGTTCAGATCATGGAGCAGGACCGCAAGGAAGCTGGGGATATAAGTGGGGTTATGGTTCCGCTCCCGGTTCCGGCTGGGGCTTCGGCTCCGGCTCCGGCAGATCTACTTCCGGCGACGGTAGCGCCTTCGGATTCGGCTACGGCTCCGGGTCTGGTTCCGGTTCAAGATCGGGTTCA
tu peux obtenir comme fragments :
Citation:
ACGATACCCGACTCTGGCTGCCAAAATGTGGAAATTGGTAATTAT
CGTTTGCAATATTTTCTGCGGTTGTTGTTTCTGCGGCCCATACAGAGGAAGAGAAATTTTTT
GGGTTATGGTTCCGCTCCCGGTTCCGGCTGGGGCTTCGGCTCC
TCCGGCAGATCTACTTCCGGCGACGGTAGCGCCTTC

Ici, tu extrait des fragment aléatoires mais tu oublis certain morceaux de la séquence initiales...

Si ma séquence est celle que tu as donné , pour te reprendre...

TTCTTCTTGCTTATCCCAGCTGTTACGATACCCGACTCTGGCTGCCAAAATGTGGAAATTGGTAATTATAGCGTTTGCAATATTTTCTGCGGTTGTTGTTTCTGCGGCCCATACAGAGGAAGAGAAATTTTTTGCAGAAAGGCGTCCAAATTCGGAGCGGGCGCAGGAGGAGGAGGAGGGGGAAGCTCCGGCTCAGGCGGGCCTTCTTCTGCTTCGGGTTCAGATCATGGAGCAGGACCGCAAGGAAGCTGGGGATATAAGTGGGGTTATGGTTCCGCTCCCGGTTCCGGCTGGGGCTTCGGCTCCGGCTCCGGCAGATCTACTTCCGGCGACGGTAGCGCCTTCGGATTCGGCTACGGCTCCGGGTCTGGTTCCGGTTCAAGATCGGGTTCA

Alors je chercherais a obtenir quelques choses comme ca :

TTCTTCTTGCTTATCCCAGCTGTTACGATACCCGACTCTGGCTG
CCAAAATGTGGAAATTGGTAATTATAGCGTTTGCAATATTTTCTGCGGTTGTTGTTTCTGCGGCCCATACAGAGGAAGAGAAATTTTTTGCAGAAAG
GCGTCCAAATTCGGAGCGGGCG
....

ou chaques fragments commenceraient la ou le précédent finis...
jusqu'à que le reste de ma séquence initiales soit trop petit ou fini...

We are in the right way !

[laura_]

Je pensais que tes fragments devaient se chevaucher, c'est pour ca que je pensais que tu voulais partir du meme fragment à chaque fois, autant pour moi !

Edit : Apres un rapide coup d'oeil à la publication dont tu parlais, j'ai vérifié et tes fragments d'ARN doivent être chevauchant, de manière à être le plus exhaustif au moment du séquencage.

[faktis]

je suis perdu... tu m'as perdu laura..

[laura_]

oublie mon commentaire, fais comme tes maitres de stage t'ont dis de faire.

Pour le reste de la methode, tu t'en sors avec les conseils de Jasmine?

[faktis]

non pas du tout....je suis un peu deboussoler la

[laura_]

qu'est ce que tu ne comprends pas ?
j'ai reecris le code que jasmine avait donné en changeant deux trois choses peut etre que tu comprendras mieux .

Sinon, quel est ton probleme ?

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
#!/usr/bin/perl
 
use strict;
use warnings;
use Bio::SeqIO;
 
my $in  = Bio::SeqIO->new(-file => 'seq.txt' , '-format' => 'fasta') ;
 
my @fragments ;
# pour chaque sequence de ton fichier
while (my $seq_objet = $in->next_seq())
{
	# on recupere la sequence
	my $seq_rest = $seq_objet->seq() ;
	# on mesure sa longueur
	my $long_total = length($seq_rest) ;
	# on genere une taille de fragment
	my $long_fragment = int(rand($long_total)) ;
	# tant que cette taille de la sequence restante est supérieure a 10 (valeur prise au hasard)
	while ($long_total>10)
	{
		# on recupere le fragment généré
		my $fragment = substr($seq_rest,0,$long_fragment) ;
		# on le place dans un tableau
		push (@fragments, $fragment) ;
		# on l'enleve de la sequence a teste
		$seq_rest =~ s/^$fragment// ;
		# on remesure sa longueur
		$long_total = length($seq_rest) ;
		# on regenere une taille de fragment
		$long_fragment = int(rand($long_total)) ;
	}
	# si la taille est inférieure ou égale a 10
	if ($long_total<=10)
	{
		# on recupere le dernier fragment et on le place dans le tableau
		my $fragment = $seq_rest ;
		push (@fragments, $fragment) ;
	}
	foreach my $k(@fragments)
	{
		print $k."\n" ;
		## ICI tu fais ce qu'il faut faire pour chaque sequence
	}
}

[thierry.chich]

Je ne suis pas bio-informaticien, mais informaticien. Néanmoins, il me semble assez net que le problème est mal défini. Dire que le découpage doit être complètement aléatoire, ça ne veut pas dire grand chose.
Comme l'a souligné Jasmine, si on coupe chaque morceau avec une fonction uniforme sur la taille du morceau, on découpe en morceaux de plus en plus petits, ce qui n'est pas vraiment aléatoire.
Ce qui faudrait, c'est savoir, c'est s'il y a une probabilité donnée de cassure de l'ADN, et si cette probabilité est uniforme. Si c'est le cas, l'algorithme est simple.

[faktis]

Salut salut !! en forme aprés ce weekend ?

Ce qui faudrait, c'est savoir, c'est s'il y a une probabilité donnée de cassure de l'ADN, et si cette probabilité est uniforme. Si c'est le cas, l'algorithme est simple.

Il n'y a pas de probabilité donnée de cassure de l'ADN sinon ce ne serait plus aléatoire !!..enfin i think.





Sinon Pour Laura Ton programme m'a l'air trés bien, je suis en train de le tester...

Edit : Maintenant j'ai un autre probleme quand je le lance , il me marque cela :

Code :

/usr/bin/perl : symbol lookup error : /geninf/prog64/lib/perl/x86_64-linux-thread-multi/auto/Cwd/Cwd.so : undefinied symbol: Perl_Tstack_sp_ptr

Je ne comprend pas cette erreur dans la compilation... manque de package ? pas de correcte mise à jour ??

Merci bien !
Enjoy