Discussion :

[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 :

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

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 :

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
#!/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 :

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

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 :

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

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]

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 :

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
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.