Кодирование Blosum62 в исходном коде

Question

Я пытаюсь реализовать выравнивание парной последовательности белков с использованием алгоритма «Глобальное выравнивание» с помощью «Needleman -Wunsch».

Я не совсем понимаю, как включить 'Blosum62 Matrix' в мой исходный код, чтобы сделать подсчет или заполнить двумерную матрицу?

У меня есть googled и нашел, что большинство людей предложило использовать плоский файл, который содержит стандартную «матрицу Blosum62». Означает ли это, что мне нужно прочитать из этого плоского файла и заполнить мою кодированную «Blosum62 Martrix»?

Кроме того, другим подходом может быть использование некоторой математической формулы и включение ее в вашу логику программирования для построения «Матрицы Blosum62» . Но не очень уверен, что этот вариант.

Любые идеи или идеи приветствуются.

Спасибо.

Answer 1

Это помогло бы знать, на каком языке вы работаете, чтобы мы могли помочь вам с но я использовал карту карт (или словари, если вы используете Python).

Вот пример моего кода Groovy, но это довольно переносимым на другие языки:

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

С помощью этого вы можете просто позвонить

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

Answer 2

Вы всегда можете загрузить матрицу из NCBI сети сайт:

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

Другие матрицы также availabl e из родительского каталога.

Я никогда не видел реализацию Needleman-Wunsch с вычислением матрицы. Гораздо проще включить матрицу в код или в отдельный файл.

Подробные сведения о матрицах BLOSUM приведены здесь: http://en.wikipedia.org/wiki/BLOSUM.

Answer 3

Вы не можете вывести матрицу blosum из другого, как вы можете сделать для PAM: все blosum вычисляются из другого набора данных и не коррелируются внутри них.

Например, матрица PAM250 представляет собой просто матрицу PAM1, умноженную на 250 раз; но это не относится к BLOSUM, и вы не можете вывести BLOSUM80 из BLOSUM64, например.

Answer 4

Да, вы можете реализовать матрицу blosum в качестве проводной части кода, вы можете получить некоторую скорость с этим. Но определенно вы теряете гибкость. Я бы рекомендовал написать читатель для формата NCBI, например, вернуть тип данных SubstitutionMatrix. Затем вы можете передать такую ​​матрицу как объект.

Объект SubstitutionMatrix может содержать двумерную матрицу и «что-то», ответственное за декодирование имен аминокислот, например. хэш-массив. В зависимости от выбранного языка вы также можете использовать перечисления для обозначения типов аминокислот. В таком случае вы можете использовать их непосредственно для обращения к 2D-массиву.

Надеюсь, это ясно, я могу написать более подробную информацию, если вам нравится.

Answer 5

Вот пример разбора файла blosum62 по этой ссылке ftp://ftp.ncbi.nih.gov/blast/matrices/BLOSUM62 в Java.

Создать класс Синтаксический:

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

Теперь вы хотите, чтобы рассчитать стоимость, например, А и *, который возвращает -4 вы должны написать метод для этого:

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

Наконец в основном способе

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

Это напечатает -4.