Codage Blosum62 dans le code source

Question

J'essaie d'implémenter l'alignement de séquences de protéines par paires en utilisant l'algorithme «Global Alignment» de «Needleman -Wunsch».

Je ne suis pas clair sur la façon d'inclure «Blosum62 Matrix» dans mon code source pour faire la notation ou pour remplir la matrice bidimensionnelle? J'ai cherché sur google et j'ai trouvé que la plupart des gens suggéraient d'utiliser un fichier plat qui contient la matrice standard 'Blosum62 Matrix'. Cela signifie-t-il que je dois lire à partir de ce fichier plat et remplir mon codé "Blosum62 Martrix"?

L'autre approche pourrait être d'utiliser une formule mathématique et de l'inclure dans votre logique de programmation pour construire 'Blosum62 Matrix' ». Mais pas très sûr de cette option.

Toutes les idées ou des idées sont appréciés.

Merci.

Answer 1

Il serait utile de savoir quelle langue vous travaillez afin que nous puissions vous aider à les termes corrects, mais ce que j'ai fait était d'utiliser une carte de cartes (ou des dictionnaires si vous utilisez Python)

Voici un exemple de mon code Groovy, mais il est assez portable à d'autres langues:

def blosum62 = [ 
Cys:[Cys:9, Ser:-1, Thr:-1, Pro:-3, Ala:0, Gly:-3, Asn:-3, Asp:-3, Glu:-4, Gln:-3, His:-3, Arg:-3, Lys:-3, Met:-1, Ile:-1, Leu:-1, Val:-1, Phe:-2, Tyr:-2, Trp:-2], 
Ser:[Cys:-1,Ser:4, Thr:1, Pro:-1, Ala:1, Gly:0, Asn:1, Asp:0, Glu:0, Gln:0, His:-1, Arg:-1, Lys:0, Met:-1, Ile:-2, Leu:-2, Val:-2, Phe:-2, Tyr:-2, Trp:-3], 
Thr:[Cys:-1,Ser:1, Thr:4, Pro:1, Ala:-1, Gly:1, Asn:0, Asp:1, Glu:0, Gln:0, His:0, Arg:-1, Lys:0, Met:-1, Ile:-2, Leu:-2, Val:-2, Phe:-2, Tyr:-2, Trp:-3], 
Pro:[Cys:-3,Ser:-1, Thr:1, Pro:7, Ala:-1, Gly:-2, Asn:-1, Asp:-1, Glu:-1, Gln:-1, His:-2, Arg:-2, Lys:-1, Met:-2, Ile:-3, Leu:-3, Val:-2, Phe:-4, Tyr:-3, Trp:-4], 
Ala:[Cys:0, Ser:1, Thr:-1, Pro:-1, Ala:4, Gly:0, Asn:-1, Asp:-2, Glu:-1, Gln:-1, His:-2, Arg:-1, Lys:-1, Met:-1, Ile:-1, Leu:-1, Val:-2, Phe:-2, Tyr:-2, Trp:-3], 
Gly:[Cys:-3,Ser:0, Thr:1, Pro:-2, Ala:0, Gly:6, Asn:-2, Asp:-1, Glu:-2, Gln:-2, His:-2, Arg:-2, Lys:-2, Met:-3, Ile:-4, Leu:-4, Val:0, Phe:-3, Tyr:-3, Trp:-2], 
Asn:[Cys:-3,Ser:1, Thr:0, Pro:-2, Ala:-2, Gly:0, Asn:6, Asp:1, Glu:0, Gln:0, His:-1, Arg:0, Lys:0, Met:-2, Ile:-3, Leu:-3, Val:-3, Phe:-3, Tyr:-2, Trp:-4], 
Asp:[Cys:-3,Ser:0, Thr:1, Pro:-1, Ala:-2, Gly:-1, Asn:1, Asp:6, Glu:2, Gln:0, His:-1, Arg:-2, Lys:-1, Met:-3, Ile:-3, Leu:-4, Val:-3, Phe:-3, Tyr:-3, Trp:-4], 
Glu:[Cys:-4,Ser:0, Thr:0, Pro:-1, Ala:-1, Gly:-2, Asn:0, Asp:2, Glu:5, Gln:2, His:0, Arg:0, Lys:1, Met:-2, Ile:-3, Leu:-3, Val:-3, Phe:-3, Tyr:-2, Trp:-3], 
Gln:[Cys:-3,Ser:0, Thr:0, Pro:-1, Ala:-1, Gly:-2, Asn:0, Asp:0, Glu:2, Gln:5, His:0, Arg:1, Lys:1, Met:0, Ile:-3, Leu:-2, Val:-2, Phe:-3, Tyr:-1, Trp:-2], 
His:[Cys:-3,Ser:-1, Thr:0, Pro:-2, Ala:-2, Gly:-2, Asn:1, Asp:1, Glu:0, Gln:0, His:8, Arg:0, Lys:-1, Met:-2, Ile:-3, Leu:-3, Val:-2, Phe:-1, Tyr:2, Trp:-2], 
Arg:[Cys:-3,Ser:-1, Thr:-1, Pro:-2, Ala:-1, Gly:-2, Asn:0, Asp:-2, Glu:0, Gln:1, His:0, Arg:5, Lys:2, Met:-1, Ile:-3, Leu:-2, Val:-3, Phe:-3, Tyr:-2, Trp:-3], 
Lys:[Cys:-3,Ser:0, Thr:0, Pro:-1, Ala:-1, Gly:-2, Asn:0, Asp:-1, Glu:1, Gln:1, His:-1, Arg:2, Lys:5, Met:-1, Ile:-3, Leu:-2, Val:-3, Phe:-3, Tyr:-2, Trp:-3], 
Met:[Cys:-1,Ser:-1, Thr:-1, Pro:-2, Ala:-1, Gly:-3, Asn:-2, Asp:-3, Glu:-2, Gln:0, His:-2, Arg:-1, Lys:-1, Met:5, Ile:1, Leu:2, Val:-2, Phe:0, Tyr:-1, Trp:-1], 
Ile:[Cys:-1,Ser:-2, Thr:-2, Pro:-3, Ala:-1, Gly:-4, Asn:-3, Asp:-3, Glu:-3, Gln:-3, His:-3, Arg:-3, Lys:-3, Met:1, Ile:4, Leu:2, Val:1, Phe:0, Tyr:-1, Trp:-3], 
Leu:[Cys:-1,Ser:-2, Thr:-2, Pro:-3, Ala:-1, Gly:-4, Asn:-3, Asp:-4, Glu:-3, Gln:-2, His:-3, Arg:-2, Lys:-2, Met:2, Ile:2, Leu:4, Val:3, Phe:0, Tyr:-1, Trp:-2], 
Val:[Cys:-1,Ser:-2, Thr:-2, Pro:-2, Ala:0, Gly:-3, Asn:-3, Asp:-3, Glu:-2, Gln:-2, His:-3, Arg:-3, Lys:-2, Met:1, Ile:3, Leu:1, Val:4, Phe:-1, Tyr:-1, Trp:-3], 
Phe:[Cys:-2,Ser:-2, Thr:-2, Pro:-4, Ala:-2, Gly:-3, Asn:-3, Asp:-3, Glu:-3, Gln:-3, His:-1, Arg:-3, Lys:-3, Met:0, Ile:0, Leu:0, Val:-1, Phe:6, Tyr:3, Trp:1], 
Tyr:[Cys:-2,Ser:-2, Thr:-2, Pro:-3, Ala:-2, Gly:-3, Asn:-2, Asp:-3, Glu:-2, Gln:-1, His:2, Arg:-2, Lys:-2, Met:-1, Ile:-1, Leu:-1, Val:-1, Phe:3, Tyr:7, Trp:2], 
Trp:[Cys:-2,Ser:-3, Thr:-3, Pro:-4, Ala:-3, Gly:-2, Asn:-4, Asp:-4, Glu:-3, Gln:-2, His:-2, Arg:-3, Lys:-3, Met:-1, Ile:-3, Leu:-2, Val:-3, Phe:1, Tyr:2, Trp:11] 
] 

L'utilisation de ce que vous pouvez simplement appeler

def score = blosum62[Arg][Cys] 
println("Substituting Arg by Cys gives " + score) 

Answer 2

Vous pouvez toujours télécharger la matrice à partir NCBI web site:

ftp://ftp.ncbi.nih.gov/blast/matrices/BLOSUM62

D'autres matrices sont également availabl e dans le répertoire parent.

Je n'ai jamais vu la mise en œuvre de Needleman-Wunsch avec le calcul matriciel. Il est beaucoup plus facile d'inclure la matrice dans le code ou dans un fichier séparé.

Vous trouverez des détails sur le calcul des matrices BLOSUM par exemple ici: http://en.wikipedia.org/wiki/BLOSUM.

Answer 3

Vous ne pouvez pas déduire une matrice blosum d'une autre comme vous pouvez le faire pour les matrices PAM: tous les blosums sont calculés à partir d'un ensemble de données différent et ne sont pas corrélés entre eux. Par exemple, une matrice PAM250 est simplement une matrice PAM1 multipliée 250 fois par elle-même; mais ce n'est pas vrai pour BLOSUMs, et vous ne pouvez pas déduire BLOSUM80 de BLOSUM64, par exemple.

Answer 4

Oui, vous pouvez implémenter une matrice de blosum comme un élément de code câblé, vous pourriez gagner en vitesse. Mais définitivement, vous perdez de la flexibilité. Je recommande d'écrire un lecteur pour le format NCBI, par exemple en renvoyant le type de données SubstitutionMatrix. Ensuite, vous pouvez passer autour d'une telle matrice en tant qu'objet.

L'objet SubstitutionMatrix peut contenir une matrice 2D et "quelque chose" responsable du décodage des noms d'acides aminés, par ex. un tableau de hachage. Selon la langue que vous choisissez, vous pouvez également utiliser des enums pour représenter les types d'acides aminés. Dans ce cas, vous pouvez les utiliser directement pour adresser le tableau 2D.

J'espère que cela est clair, je peux écrire plus de détails si vous aimez/besoin.

Answer 5

Voici un exemple d'analyse du fichier blosum62 à partir de ce lien ftp://ftp.ncbi.nih.gov/blast/matrices/BLOSUM62 en Java.

Créer une classe Parsing:

private String[] rowData; 
private final int MARTRIX_SIZE = 24; 
private String[][] matrix = new String[MARTRIX_SIZE][MARTRIX_SIZE]; 
private HashMap<String, Integer> index = new HashMap<>(); 
private String filePath = "blosum62.txt"; 

public void blosumMartix() { 
    File fileObj = new File(filePath); 
    Scanner input; 
    boolean readLine = true; 
    int rowCounter = 0; 

    try { 
     input = new Scanner(fileObj); 
     while (input.hasNext()) { 
      String lineReader = input.nextLine().replaceAll(" ", " "); 
      if (!lineReader.substring(0, 1).equals("#")) { 
       if (readLine) { 
        readLine = false; 
        continue; 
       } 
       rowData = lineReader.split(" "); 
       for (int i = 1; i < rowData.length; i++) { 
        matrix[rowCounter][i - 1] = rowData[i]; 
       } 
       index.put(rowData[0], rowCounter); 
       rowCounter++; 
      } 
     } 

    } catch (FileNotFoundException ex) { 
     ex.printStackTrace(); 
    } 
} 

Maintenant, vous voulez calculer le coût de l'exemple A et * qui retourne -4 vous devez écrire méthode pour cela:

public int getDistance(String strS1, String strS2) { 
    try { 
     return getDistance(matrixIndex.get(strS1), matrixIndex.get(strS2)); 
    } catch (Exception ex) { 
     System.out.println("Key out of range, check your string input"); 
     System.exit(0); 
    } 
    return 0; 
} 

private int getDistance(int charS1, int charS2) { 
    if (charS1 < 0 || charS1 > matrix[0].length) { 
     System.out.println("Gap out of range"); 
     System.exit(1); 
    } 
    if (charS2 < 0 || charS2 > matrix[0].length) { 
     System.out.println("Gap out of range"); 
     System.exit(2); 
    } 

    return Integer.parseInt(matrix[charS1][charS2]); 
} 

Enfin en méthode principale

Parsing parsing = new Parsing(); 
parsing.blosumMartix(); 
String result = parsing.getDistance("A", "*"); 
System.out.print(result); 

Cela va imprimer -4.