HPV Sekvens

HPV_sekvens-1
September 27, 2023
1 Identifikation af undertypen af en HIV-sekvens (Kap. 23)

Dette kapitel er et programmeringsprojekt, hvor du vil bruge dine nye programmer-
ingsfærdigheder til at analysere en HIV DNA-sekvens.
Du er nu blevet introduceret til alle de programmeringsregler, du vil se i dette kur-
sus. Du kender nu alle de byggeklodser, der kræves for at skrive ethvert program -
bogstaveligt talt ethvert. Grunden til, at computernørder er gode til det, de laver, er
ikke, at de kender nogle uforståelige hemmeligheder. Det er fordi de øvede sig meget.
Med øvelse vil de enkle regler, du kender nu, lade dig skrive alt fra førstepersons
skydespil over jumbojet-autopiloter til scripts til simple problemer inden for bioinfor-
matik. I de sidste tre kapitler vil vi træne din evne til at løse bioinformatikproblemer
ved at sammensætte alle de ting, du har lært.
Programmeringsprojektet i dette kapitel omhandler DNA-sekvenser fra HIV-vira. Der
er to typer af hiv: hiv-1, som er langt den mest almindelige, og hiv-2, som for det
meste findes i Vestafrika. HIV-1 vira er opdelt i grupperne M, N, O og P. Den vigtigste
gruppe M (for større) er en primært ansvarlig for den globale epidemi. Gruppe M er
yderligere opdelt i undertyperne A, B, C, D, F, G, J, K og CRF’er. I dette projekt
vil vi se på sekvenser fra undertyperne A, B, C og D. Du har flere databasesekvenser
for hver af disse fire undertyper, og du har en ukendt sekvens fra en patient, som du
skal tildele til enten undertype A, B, C eller D. For at gøre dette skal du skrive et
program, der forudsiger undertypen af den ukendte sekvens. Hvor fedt er det?
På kursussiden kan du downloade de filer, du skal bruge til dette projekt:
1. unknown_type.txt indeholder en HIV-sekvens af ukendt subtype
2. subtypeA.txt indeholder en database med HIV-sekvenser af subtype A
3. subtypeB.txt indeholder en database med HIV-sekvenser af subtype B
4. subtypeC.txt indeholder en database med HIV-sekvenser af subtype C
5. subtypeD.txt indeholder en database med HIV-sekvenser af subtype D
Du skal også downloade de to projektfiler:
1. hivproject.py er en tom fil, hvor du skal skrive din kode.
2. test_hivproject.py er testprogrammet, der lader dig teste den kode, du skriver i
hivproject.py.
1
Læg filerne i en mappe dedikeret til dette projekt. På de fleste computere kan du
højreklikke på linket og vælge “Gem fil som…” eller “Download linket fil”.
Åbn nu hver fil i VScode og se, hvad der er i datafilerne. (Du må ikke ændre dem på
nogen måde, og du må ikke gemme dem efter visning. Hvis VScode spørger dig, om
du vil gemme det, før du lukker, så sig nej.) Hvor mange sekvenser er der i hver fil?
Projektet er opdelt i følgende dele:
1. Beregn ligheden mellem to sekvenser
2. Læs HIV-sekvenserne ind i dit program
3. Vurder ligheden mellem din ukendte HIV-sekvens med hver af HIV-sekvenserne
med kendt undertype.
4. Find den maksimale lighed mellem din ukendte sekvens og sekvenser fra hver
undertype.
5. Identificer HIV-undertypen af din sekvens som undertypen af den sekvens, der
din sekvens minder mest om.
Sørg for at læse hele øvelsen og forstå, hvad du skal gøre, før du begynder!
Jeg har taget den beslutning at skrive denne aflevering nummer to gennem Jubyter Notebook i VS-
code. Dette valgt skyldes, at jeg gerne vil have et mere søgbart resultat til senere brug. Imildertid
kræver dette valg, at jeg først og fremmest opsætter Conda-miljøet bioprog som vi benytter i dette
kursus. Dette metoden hvorpå jeg denne opsætning forekommer er beskrevet i Aflevering 1.
Imildertid før jeg overhovedet går igang med dette projekt, starter jeg med at placerer terminalen
i den korrekte mappe, via cd-kommandoen:
[ ]: cd Desktop/Bioinformatik/Øvelser/Projekter/HPV_sekvens
Hvorefter jeg aktiverer bioprog-miljøet via kommandoen:

[ ]: conda activate bioprog
Da jeg nu både har skiftet kernel i VS-code til bioprog og placeret mig i mappen HPV_sekvens,
hvor alle mine filer til dette projekt er gemt, manlger jeg kun at sikre at de korrekte filer er indlæst.
Derfor importerer jeg disse via import-kommandoen:
[32]: import hivproject
import test_hivproject
Så, nu er jeg endelig klar til at gå igang med selve projektet
1.1 Beregn ligheden mellem to sekvenser

Vi er nødt til at sammenligne vores ukendte HIV-sekvens med alle HIV-sekvenserne af
kendte undertyper. På den måde kan vi identificere sekvensen af en kendt undertype,
der minder mest om din ukendte sekvens. Vi vil så antage, at vores ukendte sekvens
har samme undertype som denne sekvens. For at opnå dette skal vi først skrive noget
2
kode, der sammenligner to sekvenser, så vi kan sammenligne vores HIV-sekvens med
hver af de andre HIV-sekvenser.
1.1.1 Sammenlign to sekvenser

Skriv en funktion sequence_similarity, der tager to argumenter:
1. En streng, som er en DNA-sekvens.
2. En streng af samme længde som argument et, som også er en DNA-sekvens.
Funktionen skal returnere:
1. En float, som er andelen af baser, der er ens i to DNA-sekvenser.
Eksempel på brug:
[ ]: sequence_similarity('AGTC' 'AGTT')
Skal returnere 0,75.

Start med at definere din funktion sådan her:
[ ]: def sequence_similarity(seq1, seq2):
# your code here...
Husk, at range(len(seq1)) genererer de tal, du kan bruge til at indeksere strengen

seq1. Du kan bruge disse tal som indekser til at slå positioner op i begge strenge. Du
skal bruge en for-loop i din funktion og en variabel, der holder styr på, hvor mange
ligheder du har set, mens du itererer gennem sekvenserne.
I min proces for at lave en funktion, der beregner ligheden mellem to DNA-sekvenser. Starter jeg
med at opskrive en “opskrift” på hvorledes jeg ønsker at gribe denne udfordring an:
1. Definer en funktion ved navn sequence_similarity, som tager to argumenter.
2. Omdanner disse argumenter til strenge.
3. Laver en for-løkke, om tager en indgang i det ene argument og undersøger om dette er lig
med en indgang i det andet argument.
4. Hvis indgangene er lig med hinanden, så beregnes dette ud fra antallet af tegn i den ene
streng.
Nå, nu har jeg opskrevet en “opskrift” på hvorledes jeg ønsker at gribe denne delopgave an, så lad
mig starte med at definere en funktion sequence_similarity som tager to argumenter ind:
[ ]: def sequence_similarity(seq1,seq2):
Nu da jeg har defineret en funktion, så ønsker jeg at omdanne de indtaget argumenter til lister.
Dette gøres ved hjælp af list-metoden:
seq1_list = list(seq1)
3
Jamen så er jeg klar til at lave min for-løkke. I denne for-løkke benytter jeg range(len(seq1))-
metoden til, at generere de tal, jeg skal benytte til, at indeksere strengen seq1. Efterfølgende
sammenlignes indgangene i de to DNA-sekvenser, og hvis disse er ens (returnerer til True), så
bliver scoren en større. Imidlertid definerer jeg også en score før denne forløkke som værdien 0:
score = 0
for i in range(len(seq1_list)):
if seq1_list[i] == seq2_list[i]:
score += 1
Til sidst mangler vi kun, at bestemme den brøkdel, hvormed de to sekvenser er ens. For at gøre
dette benytter jeg len-metoden som angiver den samlede længde af vores streng seq1:
score = 0
score += 1
score = score/len(seq1_list)
return score
Nu har jeg endelig defineret en funktion, så lad os teste om denne funktion returnerer resultatet vi
forventer, nemlig 0,75. Derfor starter jeg med at definere de to DNA-sekvenser og køre ovenstående
funktion:
[19]: seq1='AGTC'
seq2='AGTT'
def sequence_similarity(seq1,seq2):
score = 0
score += 1
return score
sequence_similarity(seq1, seq2)
[19]: 0.75
Som vi kan se returnerer funktionen værdien 0,75, hvilket var det forventede resultat. Det vil
altså sige at vores funktion fungerer præcis som den skal. Så derfor indsætter jeg denne funktions-
4
definition, sequence_similarity til vores hivproject.py, hvorfor jeg benytter mig af kommandoen
%%writefile -a, som indsætter funktionen i bunden af scriptet:
[3]: %%writefile -a hivproject.py
def sequence_similarity(seq1,seq2):
score = 0
score += 1
return score
Appending to hivproject.py
1.1.2 Sammenlign justerede sekvenser

Alle sekvenser, inklusive den ukendte sekvens, er fra den samme multiple alignment.
Dette sikrer, at sekvenspositioner matcher på tværs af alle sekvenser, men betyder
også, at der indsættes en masse mellemrumstegn (‘-’). For at beregne ligheder mellem
sådanne sekvenser skal du få til at fungere meget som seqeuence_similarity, der ikke
tager hensyn til sekvenspositioner, hvor begge baser er et mellemrum (‘-’) tegn. Med
andre ord skal du ikke kun tælle antallet af tegn, der er ens, du skal også tælle,
hvor mange alignment-kolonner, der er “-” for begge sekvenser. F.eks. følgende
minijustering har fem sådanne søjler og fire søjler, hvor baserne er de samme. Så i
den følgende justering er ligheden 0,8 (4/5):
[ ]: A-CT-A
A-CTTA
Skriv en funktion alignment_similarity, der tager to argumenter:

1. En streng, som er en DNA-sekvens med mellemrumstegn.
2. En streng af samme længde som argument et, som også er en DNA-sekvens med
mellemrumstegn.
1. En float, som er andelen af baser, der er ens i to DNA-sekvenser.
Fx skal følgende funktion:
[ ]: alignment_similarity('A-CT-A', 'A-CTTA')
Returnere til 0,8.

Tip: Brug en if-sætning til at teste, om de to tegn i et eller andet indeks er lig med
‘-’ i begge sekvenser. Du kan bruge et udtryk som dette:
5
[ ]: seq1[i] == '-' and seq2[i] == '-'
Når din funktion har beregnet både antallet af identiske baser og antallet af juster-
ingskolonner, der ikke begge er ‘-’, kan du få den til at returnere ligheden som forholdet
mellem de to.
For at lave en funktion der beregner antallet af identiske baser når der tages højde for -, starter jeg
igen udfordringen med at lave en “opskrift” på hvorledes jeg ønsker at gribe opgaven an:
1. Definer en funktion med navnet alignment_similarity som tager to argumenter.
2. Omdanne disse to argumenter til lister.
3. Lave en for-løkke, som undersøge om to - er ens ift. positioner. Hvis dette er ens så trækkes
der en fra længden.
4. Hvis de to - ikke er ens, så undersøges der om de to baser er ens. Hvis dette er tilfældet, så
lægges der en til scoren.
5. Til sidst beregnes scoren.
Nå, igen har jeg opskrevet en opskrift på hvorledes jeg ønsker at gribe denne delopgave an. Derfor
starter jeg med at definere en funktion med navnet alignment_similarity, som tager to indput.
Hvorefter jeg definerer længden, som længden af den ene DNA-sekvens via len-metoden samt de-
finerer scoren til at have værdien 0. Derudover benytter jeg list-metoden til at omdanne de to
argumenter til lister:
[ ]: def alignment_similarity(seq1, seq2):
length = len(seq1)
score = 0
Herefter opskriver jeg en for-løkke, som tager indgangen i fra den ene DNA-sekvens og undersøger
om denne indgang er lig med samme indgang i fra den anden DNA-sekvens. Hvis dette er tilfældet
trækkes der en fra vores længde:
length = len(seq1)
score = 0
if seq1_list[i] == '-' and seq2_list[i] == '-':
length -= 1
Hvis dette ikke er tilfældet, så undersøger jeg for om de to indgange i i i DNA-sekvenser har en
ens base. Hvis de har ens base så lægges der en til længden:
length = len(seq1)
6
score = 0
length -= 1
elif seq1_list[i] == seq2_list[i] and not seq1_list[i] == '-':
score += 1
Til sidst beregnes den endelige score. Det vil sige at brøkdelen af hvor mange baser der er ens, når
der tages højde for - bestemmes:
[20]: def alignment_similarity(seq1, seq2):
length = len(seq1)
score = 0
length -= 1
score += 1
score = score/length
return score
Yay, nu har vi endelig defineret en funktion alignment_similarity som undersøger antallet af ens
baser, når der tages højde for -. Så lad os teste om funktionen også virker. Derfor tager jeg de to
små DNA-sekvenser der er i opgaveformuleringen og definerer disse, samt undersøger om funktionen
også returnerer den korrekte værdi 0,8:
[21]: seq1='A-CT-A'
seq2='A-CTTA'
def alignment_similarity(seq1, seq2):

length = len(seq1)
score = 0
length -= 1
score += 1
return score
alignment_similarity(seq1, seq2)
7
[21]: 0.8
Som vi kan se returnere funktionen den korrekte værdi 0,8. Det vil sige at funktionen align-
ment_similarity virker perfekt. Så lad os igen gemme denne funktion i filen hivproject.py:
def alignment_similarity(seq1, seq2):

length = len(seq1)
score = 0
length -= 1
score += 1
return score
1.2 Læs HIV-sekvenserne ind i dit program

For at bruge din alignment_similarity-funktion til at vurdere ligheden mellem din
ukendte sekvens og sekvenserne af kendt undertype, skal du læse sekvenserne ind i dit
program. Her er en funktion, der læser sekvenserne fra en af de filer, du downloadede,
til en liste:
[ ]: def read_data(file_name):
f = open(file_name)
sequence_list = list()
for line in f:
seq = line.strip()
sequence_list.append(seq)
f.close()
return sequence_list
Du kan bruge denne funktion til at læse den ukendte sekvens ind i dit program:
[ ]: unknown_list = read_data('unknown_type.txt')
I dette tilfælde indeholder listen kun den ene ukendte HIV-sekvens i un-
known_type.txt.
Du skal også indlæse de indtastede HIV-sekvenser i dit program. Her er en funktion,
der returnerer en ordbog, hvori nøglerne er undertyper (‘A’, ‘B’, ‘C’ og ‘D’), og hver
værdi er en lister over sekvenser med den undertype:
8
[ ]: def load_typed_sequences():
return {'A': read_data('subtypeA.txt'),
'B': read_data('subtypeB.txt'),
'C': read_data('subtypeC.txt'),
'D': read_data('subtypeD.txt') }
Hvis du bruger funktionen sådan:

[ ]: typed_data = load_typed_sequences()
Så kan du få adgang til listen over sekvenser af undertype A som denne:

typed_data[‘A’].
Jamen fedt, nu har jeg to funktioner nemlig read_data og load_typed_sequences, så derfor kører
jeg funktionerne, samt definerer den listen unknown_list som værende den liste med den ukendte
DNA-sekvens. Derudover definerer jeg de forskellige DNA-sekvenser fra de andre HPV-varianter
som typed_data:
[22]: def read_data(file_name):
f = open(file_name)
for line in f:
seq = line.strip()
f.close()
def load_typed_sequences():
unknown_list = read_data('unknown_type.txt')
typed_data = load_typed_sequences()
Til sidst indsætter jeg disse to funktioner i vores arbejdsfil:

def read_data(file_name):
f = open(file_name)
for line in f:
seq = line.strip()
f.close()
9
def load_typed_sequences():
1.3 Sammenlign din HIV-sekvens med HIV-sekvenser af kendte undertype

For at skrive din HIV-sekvens skal du sammenligne din sekvens med alle databas-
esekvenserne for at se, hvilken gruppe der har den bedst matchende sekvens.
Skriv en funktion get_similarities, der tager to argumenter:
1. En streng, som er din ukendte HIV-sekvens.
2. En liste over strenge, som hver er en HIV-sekvens af kendt type.
1. En liste over flydere, som skal være lighederne mellem den ukendte sekvens givet
som det første argument og listen over sekvenser givet som det andet argument.
Eksempel på brug:
[ ]: get_similarities(unknown_list[0], typed_data['A'])
Skal returnere:
[ ]: [0.8553288474061211, 0.8721742704480066,
0.854924397221087, 0.8481709291032696,
0.8498330281159108]
Funktionen skal bruge funktionen alignment_similarity til at sammenligne din ukendte

sekvens (unknown_list[0]) med hver af sekvenserne af en eller anden undertype. Start
sådan her:
[ ]: def get_similarities(unknown, typed_sequences):
# Your code here...
I din funktion skal du definere en liste, som du kan tilføje de ligheder, du beregner
til:
[ ]: similarities = []
Dette er listen over resultater, som din funktion skal returnere. For at beregne lighe-
den mellem din ukendte sekvens og hver af sekvenserne af kendt undertype, kan du
bruge din alignment_similarity-funktion inde i en for-loop.
10
I mit forsøg på at lave en funktion der returnerer en liste over brøkdele for hvor meget min ukendte
DNA-sekvens passer sammen med de allerede kæmpe DNA-sekvenser, starter jeg igen med at
opstille en “opskrift” for hvorledes jeg ønsker at gribe udfordringen an:
1. Definer en funktion ved navnet get_similarities, som tager to inputs, nemlig vores tidligere
defineret kendte DNA-sekvens og vores ukendte DNA-sekvens.
2. Oprette en liste ved navnet similarities.
3. Lave en for-løkke, som tager hver værdi i af de kendte sekvenser og sammenligner dem via
funktionen alignment_similarity med den ukendte DNA-sekvens.
4. Indsætter scoren i en liste.
Nå, men nu har jeg lavet en “opskrift” for hvorledes jeg ønsker at gribe opgaven an, så lad os starte
med at definere funktionen get_similarities der tager to indputs, nemlig den ukendte DNA-sekvens,
som jeg har defineret til unknown_seq og den kendte DNA-sekvens, typed_seq. Derudover opretter
jeg en liste med funktionsnavnet similarities, hvori scorerne for ligheden kan indsættes i:
[ ]: def get_similarities(unknown_seq, typed_seq):
similarities = []
Jamen hvis vi så kigger på vores “opskrift”, så er jeg nået til punktet hvor jeg skal lave en for-
løkke, som tager hver indgang i for vores kendte DNA-sekvens, typed_seq, og sammenligner dette
via funktionen alignment_similarity med den ukendte DNA-sekvens, unknown_seq. Denne score
indsættes efterfølgende i den oprettede liste, similarities, via append-metoden:
[ ]: def get_similarities(unknown_seq, typed_seq):
similarities = []
for i in range(len(typed_seq)):
score = alignment_similarity(unknown_seq, typed_seq[i])
similarities.append(score)
return similarities
Jamen nu har jeg lavet en funktion, som tager hver af vores kendte DNA-sekvenser for HPV-
varianterne og sammenligner disse med vores ukendte DNA-sekvens. Så lad os teste om denne
virker som forventet. Derfor benytter jeg opgavens eksempel således:
[26]: def get_similarities(unknown_seq, typed_seq):
similarities = []
return similarities
get_similarities(unknown_list[0], typed_data['A'])
[26]: [0.8553288474061211,
0.8721742704480066,
0.854924397221087,
0.8481709291032696,
11
0.8498330281159108]
Som vi kan se returnerer funktionen de korrekte brøkdele, hvorfor jeg konkluderer at funktionen
get_similarities virker præcis som den skal. Derfor gemmer jeg denne funktion i filen hivproject.py
via _%%writefile -a-kommandoen:
def get_similarities(unknown_seq, typed_seq):

similarities = []
return similarities
1.4 Beregn maksimal lighed med hver undertype

For at forudsige undertypen af den ukendte HIV-sekvens skal du sammenligne den
ukendte sekvens med alle sekvenserne af hver af de forskellige undertyper. Undertypen
af sekvensen med den højeste lighed med din ukendte sekvens er så vores forudsagte
undertype (eller vores bedste gæt).
Skriv en funktion get_max_similarities, der tager to argumenter:
2. En ordbog som den, der returneres af load_typed_sequences.
En ordbog, hvor nøgler er strenge, der repræsenterer hver undertype (‘A’, ‘B’, ‘C’
og ‘D’), og værdier er flydende, der repræsenterer den maksimale lighed mellem den
ukendte sekvens og sekvenserne af en undertype. Ordbogen kunne se sådan ud (det
gør den ikke, du skal selv beregne lighederne).
[ ]: {'A': 0.89, 'B': 0.95, 'C': 0.82, 'D': 0.99}
For at få det højeste tal i en liste med tal, kan du bruge max-funktionen i Python.
Det fungerer sådan her:
[13]: numbers = [3, 8, 53, 12, 7]
print(max(numbers)) # prints 53
53
For at få den højeste lighed mellem den ukendte sekvens og sekvenser i
typed_data[‘A’]:
12
[12]: subtypeA_similarities = get_similarities(unknown_list[0], typed_data['A'])
subtypeA_max = max(subtypeA_similarities)
For at opskrive en funktion, get_max_similarities der returnerer en ordbog, hvor nøgler er strenge,
der repræsenterer hver undertype (‘A’, ‘B’, ‘C’ og ‘D’), og værdier repræsenterer den maksimale
lighed mellem den ukendte sekvens og sekvenserne af en undertype, laver jeg igen en “opskrift” for
hvorledes jeg ønsker at gribe opgaven an:
1. Definer en funktion get_max_similarities, som tager to inputs, nemlig vores ukendte DNA-
sekvens, og vores kendte DNA-sekvens.
2. Definer en tom ordbog med navnet max_similarities.
3. Laver en for-løkke, som tager for hver nøgle og værdi i vores kendte DNA-sekvens.
4. For-løkken skal via funktionen get_similarities sammenligne hver kendt DNA-sekvens med
vores ukendte DNA-sekvens og indsætte dette i vores ordbog.
Lad os følge “opskriften”, hvorfor jeg starter med at definerer en funktion ved navnet
get_max_similarities som tager to indputs, nemlig vores ukendte DNA-sekvens, unknown_seq,
og vores allerede defineret ordbog med de kendte DNA-sekvenser, data. Derudover opretter en tom
liste med funktionsnavnet max_similarities:
[ ]: def get_max_similarities(unknown_seq, data):
max_similarities = {}
Efterfølgende opretter jeg en for-løkke, som først og fremmest starter med at få vores for-løkke til
at returnere nøgle-værdi parrene via items(). Derudover sammenlignes de kendte DNA-sekvenser
med vores ukendte DNA-sekvens via vores funktion get_similarities, som returnerer den maksi-
male værdi til vores nøgle-værdi par via max-metoden. Til sidst indsættes dette i vores ordbog
max_similarities:
[ ]: def get_max_similarities(unknown_seq, data):
for key, value in data.items():
max_val = max(get_similarities(unknown_seq, value))
max_similarities[key] = max_val
return max_similarities
Nå, igen har jeg defineret en funktion, så lad os teste om denne virker. Derfor tester jeg om vi får
en realistisk ordbog returneret når vi sammenligner vores data med vores ukendte DNA-sekvens:
[27]: def get_max_similarities(unknown_seq, data):
get_max_similarities(unknown_list[0], typed_data)
13
[27]: {'A': 0.8721742704480066,
'B': 0.8286861234675057,
'C': 0.8232432432432433,
'D': 0.8365436349940816}
Som vi kan se se får vi et meget realistisk output, hvorfor jeg konkludere at funktionen virker som
den skal. Derfor gemmer jeg funktionen i vores arbejdsfil hivproject.py:
def get_max_similarities(unknown_seq, data):

1.5 Identificer HIV-undertypen

Nu til den store finale! Du vil i sidste ende være i stand til at skrive kode som denne:
[ ]: unknown_list = read_data('unknown_type.txt')
typed_data = load_typed_sequences()
subtype = predict_subtype(unknown_list[0], typed_data)
print("Patient HIV is subtype {}".format(subtype))
Så alt hvad du behøver nu er funktionen predict_subtype.

Skriv en funktion predict_subtype, der tager to argumenter:
2. En ordbog som den, der returneres af load_typed_sequences.
1. En streng med længde 1 (enten ‘A’, ‘B’, ‘C’ eller ‘D’), der repræsenterer den
forudsagte undertype af din ukendte HIV-sekvens.
Funktionen skal bruge get_max_similarities til at beregne ordbogen over maks.
ligheder og derefter udtrække nøglen med den højeste værdi (lighed) fra den ord-
bog. Så funktionen skal returnere ‘A’, hvis den ukendte sekvens minder mest om en
sekvens af undertype A, ‘B’, hvis den ukendte sekvens minder mest om en sekvens af
undertype B og så videre.
Jubi, nu er jeg endelig nået til den store finale. Så lad mig for sidste gang i dette projekt oprette
en “opskrift” for hvorledes jeg griber denne afsluttende udfordring an:
1. Definer en funktion ved navnet predict_subtype, som tager vores ukendte DNA-sekvens og
sammenligner disse med vores kendte DNA-sekvens.
14
2. Derefter benytter jeg funktionen get_max_similarities til at bestemme brøkdelen hvorledes
vores ukendte DNA-sekvens er ens med de kendte DNA-sekvenser.
3. Den nøgle som har den største værdi af sammenligning returneres.
Så ja, lad os igen starter med at definerer funktionen. Denne gang defineres den predict_subtype,
som tager to argumenter, nemlig vores ukendte DNA-sekvens og vores kendte DNA-sekvenser. I
denne funktion benytter jeg den tidligere defineret funktion get_max_similarities, til at undersøge
den maksimale brøkdel hvormed vores ukendte DNA-sekvens er ens med de kendte DNA-sekvenser:
[ ]: def predict_subtype(unknown_seq, typed_data):
max_similarities = get_max_similarities(unknown_seq, typed_data)
Derefter får jeg via max-metoden vores funktion til at returnere den nøgle som indeholder den
største lighed mellem vores ukendte DNA-sekvens og vores kendte DNA-sekvenser A,B, C og D:
[ ]: def predict_subtype(unknown_seq, typed_data):
the_one = (max(max_similarities, key = max_similarities.get))
return the_one
Nu bliver det spænende. Så lad os se om funktionen virker som forventet. Jeg forventer nemlig at
vores funktion forudsiger at undertypen A har den største lighed med den ukendte DNA-sekvens:
[29]: def predict_subtype(unknown_seq, typed_data):
return the_one
subtype = predict_subtype(unknown_list[0], typed_data)

print("Patient HIV is subtype {}".format(subtype))
Patient HIV is subtype A

Som det kan ses returnerer funktionen den forventede nøgle, nemlig A. Derfor kan det vurderes,
at vores patient må have undertypen A af HPV-infektion. Her til sidst ønsker jeg at gemme denne
funktion i vores arbejdsfil via %%writefile -a-kommandoen:
def predict_subtype(unknown_seq, typed_data):

return the_one
Her til aller sidst vil jeg dog teste om funktionerne skrevet i translationproject.py er tilstrækkelige
holdbare. Derfor kører jeg filen test_hivproject.py via !python-kommandoen:
[33]: !python test_hivproject.py
15
Ran 25 tests in 0.079s
OK
Som det kan ses i ovenstående output, er alle mine funktioner holdbare, hvorfor der printes OK.
16

HPV Sekvens

Uploaded by

Copyright:

Available Formats

You might also like

HPV Sekvens

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

HPV Sekvens

Uploaded by

Copyright:

Available Formats

HPV_sekvens-1

September 27, 2023

1 Identifikation af undertypen af en HIV-sekvens (Kap. 23)

Hvorefter jeg aktiverer bioprog-miljøet via kommandoen:

Så, nu er jeg endelig klar til at gå igang med selve projektet

1.1 Beregn ligheden mellem to sekvenser

1.1.1 Sammenlign to sekvenser

Skal returnere 0,75.

Husk, at range(len(seq1)) genererer de tal, du kan bruge til at indeksere strengen

1.1.2 Sammenlign justerede sekvenser

Skriv en funktion alignment_similarity, der tager to argumenter:

Returnere til 0,8.

def alignment_similarity(seq1, seq2):

def alignment_similarity(seq1, seq2):

1.2 Læs HIV-sekvenserne ind i dit program

Hvis du bruger funktionen sådan:

Så kan du få adgang til listen over sekvenser af undertype A som denne:

Til sidst indsætter jeg disse to funktioner i vores arbejdsfil:

1.3 Sammenlign din HIV-sekvens med HIV-sekvenser af kendte undertype

Funktionen skal bruge funktionen alignment_similarity til at sammenligne din ukendte

def get_similarities(unknown_seq, typed_seq):

1.4 Beregn maksimal lighed med hver undertype

[ ]: {'A': 0.89, 'B': 0.95, 'C': 0.82, 'D': 0.99}

def get_max_similarities(unknown_seq, data):

1.5 Identificer HIV-undertypen

Så alt hvad du behøver nu er funktionen predict_subtype.

subtype = predict_subtype(unknown_list[0], typed_data)

Patient HIV is subtype A

def predict_subtype(unknown_seq, typed_data):

You might also like