UNIVERSIDADE FEDERAL DE UBERLÂNDIA-UFU FACULDADE DE ENGENHARIA ELÉTRICA ... · organismos incluindo unicelulares e multicelulares [4]. O processo de regulação transcricional

UNIVERSIDADE FEDERAL DE UBERLÂNDIA-UFU

FACULDADE DE ENGENHARIA ELÉTRICA – CAMPUS PATOS DE MINAS

ENGENHARIA ELETRÔNICA E DE TELECOMUNICAÇÕES

IGOR KERN BRITO DE FREITAS

BIOPIPELINE:

Minerando micoRNAs em espécies do Superfilo Lophotrochozoa

PATOS DE MINAS

2015

ii


BIOPIPELINE:

Minerando micorRNAs em espécies do Superfilo Lophotrochozoa

Trabalho final de curso submetido à banca

examinadora da Universidade Federal de

Uberlândia, campus Patos de Minas, como

requisito para obtenção do Bacharelado em

Engenharia Eletrônica e de Telecomunicações.

Orientador: Prof. Dr. Laurence Rodrigues do

Amaral.

PATOS DE MINAS

2015

iii


BIOPIPELINE:

Minerando micorRNAs em espécies do Superfilo Lophotrochozoa

Trabalho final de curso submetido à banca

examinadora da Universidade Federal de

Uberlândia, campus Patos de Minas, como

requisito para obtenção do Bacharelado em

Engenharia Eletrônica e de Telecomunicações.

Patos de Minas, 11 de dezembro de 2015.

_____________________________________________________________

Prof. Dr. Laurence Rodrigues do Amaral, UFU/MG

Orientador

_____________________________________________________________

Prof. Dr. Alexandre Coutinho Mateus, UFU/MG

Membro

_____________________________________________________________

Prof.ª Dr.ª Eliana Pantaleão, UFU/MG

Membro

iv

Eu, Igor, dedico esse trabalho de conclusão de

curso àqueles de maior importância na minha

vida: minha mãe Lúcia, meu pai Adão (in

memoriam) e a minha irmã Elaine.

v

AGRADECIMENTOS

Agraço primeiramente a Deus, que sempre me deu forças e perseverança para lutar por meus

sonhos.

Obrigado mãe Lúcia de Fátima de Brito, obrigado pai Adão José de Freitas (in memoriam) e

obrigado minha irmã Elaine Amélia Kern Brito de Freitas.

Agradeço a toda minha família, aos meus tios (as), meus primos (as) e meu cunhado, que sempre

estiveram ao meu lado, me incentivando para jamais desistir de lutar por meus objetivos.

Um agradecimento especial para meu amigo e orientador Laurence Rodrigues do Amaral, por

sempre ter me auxiliado ao longo de quase todo curso.

Agradeço a todos meus amigos (as) que fiz durante esses anos de faculdade, que fizerem dessa

jornada mais agradável.

Obrigado a todos professores (as) que conseguiram transmitir seus conhecimentos, que me

tornaram um engenheiro.

Obrigado a todos técnicos e funcionários da Faculdade, que sempre estiveram dispostos a nos

ajudar, mesmo as vezes fora dos seus horários de serviço.

vi

RESUMO

Neste trabalho foi desenvolvido um programa computacional chamado Biopipeline, que tem a

função de identificar prováveis percursores de micro RNAs e microRNAs maduros no genoma

de organismos do Superfilo Lophotrochoza. Aplicando conceitos de engenharia de software

para obter um sistema confiável. Esse estudo, inovador na abordagem de miRNAs em vetores

e parasitos do Superfilo Lophotrochozoa, trará, com certeza, uma grande contribuição para o

melhor entendimento dos pequenos RNAs não codificadores distribuídos nesse grupo de

organismos tão importante.

Palavras Chave: Biopipeline, Computação, Bioinformática, Engenharia de Software,

Programação.

vii

ABSTRACT

The purpose of this project was to develop a computational program called Biopipeline, which

has the function of identify likely precursors of microRNAs and mature microRNAs in

Superfilo Lophotrochozoa organism’s genome, applying concepts of Software Engineering to

obtain a reliable system. This study, which is innovative in regard to miRNAs in vectors and

parasites of Superfilo Lophotrochozoa, will assure a substantial contribution for a better

understanding of the small non-encoders RNAs distributed within this significant group of

organisms.

Keywords: Biopipeline, Computation, Bioinformatc, Software Engineering, Programming.

viii

LISTA DE ILUSTRAÇÕES

Figura 1 - Diagrama de blocos esquematizando as funções do Biopipeline. ........................... 10

Figura 2. Esquemático das tabelas do Banco de Dados implementado.................................... 12

Figura 4 - Versão online programa Einverted. ......................................................................... 16

Figura 5 - Versão online do programa do Blastn. .................................................................... 17

Figura 6 - Resultado da execução do Einverted. ...................................................................... 18

Figura 7 - Versão online do programa RNAfold. ..................................................................... 19

Figura 8 - Estrutura do código desenvolvido............................................................................ 21

Figura 9 - Modulo Blast ........................................................................................................... 22

Figura 10 - Módulo Core. ......................................................................................................... 23

Figura 11 - Módulo Einverted. ................................................................................................. 24

Figura 12 - Resultado Einverted e seus principais pontos de interesse. ................................... 25

Figura 13 - Pacote de manuseio do genoma. ............................................................................ 25

Figura 14 - Pacote de Leitura e Escrita de dados. .................................................................... 26

Figura 15 - Pacote de controle dos arquivos provindos do miRBASE. ................................... 27

Figura 16 - Módulo de trabalho do Banco de Dados. ............................................................... 28

Figura 17 - Pacote RNAfold. .................................................................................................... 29

Figura 18 - Classes do pacote Util ............................................................................................ 30

Figura 19 - Driver JDBC utilizado no projeto Biopipeline. ..................................................... 30

ix

LISTA DE ABREVIATURAS E SIGLAS

API – Interface de Programação de Aplicativos

Biopipeline – Programa desenvolvido nessa monografia

BLASTn – Basic Local Alignment Search Tool, encontra regiões de similaridade local

entre as sequências

DNA – Ácido Desoxidoribonucléico

Einverted – O programa procura por repetições invertidas (stem loops) em uma sequência

de nucleotídeos

ESOF – Engenharia de Software

FASTA – Arquivo texto de um genoma que possui uma forma padronizada de formatação

Formatdb – Classes responsáveis por criar as entradas de dados do Blastn

GNU/Linux – Sistema operacional baseado no kernel Linux

JDBC – Java Database Connectivity

KDE – K Desktop Environment

MFE – Mínima energia livre

mirBAse – Banco de dados mundial de sequências de miRNAs

miRNA – Micro RNA

MySQL – Sistema de banco de dados da empresa Oracle

piRNA – Pequeno RNA Associado a PIWI

RAM – Memória de acesso aleatório

RNA – Ácido Ribonucléico

x

RNAfold – Programa que prediz estruturas secundárias de RNAs usando parâmetros que

se baseiam na mínima energia livre

siRNA – Pequeno RNA de Interferência

TCC – Trabalho de conclusão de curso

xi

SUMÁRIO

AGRADECIMENTOS ................................................................................................. v

RESUMO ...................................................................................................................... vi

ABSTRACT ................................................................................................................. vii

LISTA DE ILUSTRAÇÕES ..................................................................................... viii

LISTA DE ABREVIATURAS E SIGLAS ................................................................ ix

SUMÁRIO .................................................................................................................... xi

1 INTRODUÇÃO .......................................................................................................... 2

1.1 Contextualização ................................................................................................... 2

1.2 Objetivos ............................................................................................................... 3

1.3 Justificativas ......................................................................................................... 3

1.4 Estrutura da Monografia ....................................................................................... 4

2 ENGENHARIA DE SOFTWARE E BIOINFORMÁTICA .................................. 5

2.1 Engenharia de Software ........................................................................................ 5

2.2 Bioinformática ...................................................................................................... 7

3 ARQUITETURA DO BIOPIPELINE ..................................................................... 9

3.1 Princípios do desenvolvimento do software ......................................................... 9

3.2 Estrutura do software ............................................................................................ 9

3.3 Desenvolvimento do Banco de Dados ................................................................ 11

3.4 Escolha de Sistema Operacional e Linguagem de Programação ........................ 13

3.5 Leitura de Arquivos ............................................................................................ 14

3.6 Armazenamento de informações ........................................................................ 15

3.7 Utilização de Programas Externos ...................................................................... 16

4 DETALHES TÉCNICOS DO BIOPIPELINE, RESULTADOS E DISCUSSÃO

.................................................................................................................................................. 21

4.1 Detalhes técnicos do Biopipeline ........................................................................ 21

4.1.1 Pacote Blast ................................................................................................. 21

4.1.2 Pacote Core .................................................................................................. 23

4.1.3 Pacote Einverted .......................................................................................... 23

4.1.4 Pacote Genome ............................................................................................ 25

4.1.5 Pacote GUI.Pictures ..................................................................................... 26

4.1.6 Pacote IO ..................................................................................................... 26

4.1.7 Pacote Mirna ................................................................................................ 27

4.1.8 Pacote MySQL ............................................................................................. 28

4.1.9 Pacote RNAfold ........................................................................................... 28

xii

4.1.10 Pacote Util ................................................................................................. 29

4.1.11 Conexão com o bando de dados ................................................................ 30

4.2 Resultados ........................................................................................................... 30

4.3 Conclusões .......................................................................................................... 31

REFERÊNCIAS .......................................................................................................... 32

2

1 INTRODUÇÃO

1.1 Contextualização

Apesar do vasto conhecimento da biologia de diversos organismos do Superfilo

Lophotrochozoa, pouco ainda é conhecido sobre o repertório de genes de pequenos RNAs,

conhecidos como os microRNAs (miRNAs), no genoma e transcriptoma dos organismos.

Recentes estudos, em diversos organismos, desde protozoários unicelulares até multicelulares

complexos tem mostrado a importância da regulação gênica envolvendo pequenos RNAs, suas

vias de processamento e sua atuação a nível celular[1].

Estes processos são orquestrados por diversas proteínas alcançando uma fina e

específica regulação ao nível de genoma e/ou transcriptoma. Alguns dos principais pequenos

RNAs não codificadores (miRNAs), os pequenos RNAs interferentes (siRNAs) e os RNAs

associados à proteína PIWI (piRNAs). Estes pequenos RNAs se diferenciam em tamanho,

biogênese e o alvo final [2].

Entre eles, os miRNAs tem se destacado, devido as suas diversas funções na regulação

da expressão gênica. Brevemente, em sua biogênese, os miRNAs são transcritos primeiramente

em um longo RNA denominado miRNA primários ou pri-miRNAs que são processados por

enzimas específicas gerando os precursores de miRNAs (pré-miRNAs). Os pré-miRNAs

possuem características peculiares como estruturas secundárias conservadas, estabilidade em

forma de grampo (hairpin), sendo ligeiramente maiores que os miRNAs maduros (22

nucleotídeos), e possuindo em média cerca de 80 a 120 nucleotídeos [3].

Os miRNAs tem função de direcionar a repressão transcricional de miRNAs em

diferentes condições incluindo fases do ciclo de vida e desenvolvimento em diversos

organismos incluindo unicelulares e multicelulares [4]. O processo de regulação transcricional

se resume na ligação complementar entre o miRNA e o RNA mensageiro alvo em regiões

específicas levando a sua inibição e/ou degradação. Várias estratégias têm sido usadas para

identificação de miRNAs e seus precursores em vários organismos [5].

3

Estas estratégias se baseiam em abordagens computacionais e experimentais [5] [6]

[7]. As abordagens experimentais como sequenciamento, expressão e clonagem almejam a

identificação de miRNAs presentes em determinados estágios, tecidos e/ou diferentes tipos

celulares. A vantagem destas técnicas é fundamentada na obtenção de provas físicas da

presença de certas moléculas. Entretanto, a análise experimental pode excluir miRNAs pouco

ou nada expressos. Por outro lado, as técnicas computacionais podem auxiliar o processo de

descoberta de novos miRNAs.

1.2 Objetivos

A área de Engenharia de Software (ESOF) tem muito a contribuir para o

desenvolvimento da área de Bioinformática. Dessa forma, apresentaremos nesse trabalho,

alguns conceitos pertinentes à área de ESOF, à área de Bioinformática e como essas métricas

de desenvolvimento foram utilizadas. Essas métricas serviram como guias para o

desenvolvimento de um sistema computacional, denominado Biopipeline, para identificação e

caracterização de miRNAs e seus precursores utilizando sequências públicas relacionados ao

genoma e transcriptoma de organismos Lophotrochozoa.

1.3 Justificativas

As ferramentas baseadas na computação convencional têm se mostrado limitadas na

abordagem de problemas biológicos complexos. Uma das razões para essa dificuldade está na

ineficiência das ferramentas computacionais convencionais em lidar com grandes quantidades

de dados [5]. A construção de um programa confiável, que realizará essa tarefa de maneira

rápida e precisa, poderá mudar esse panorama e trazer novos resultados para o estudo desse

Superfilo.

Esse estudo, inovador na abordagem de miRNAs em vetores e parasitos do Superfilo

Lophotrochozoa, trará, com certeza, uma grande contribuição para o melhor entendimento dos

pequenos RNAs não codificadores distribuídos nesse grupo de organismos tão importante.

4

1.4 Estrutura da Monografia

Esse trabalho de conclusão de curso está dividido em quatro capítulos. O primeiro

capítulo apresentou a contextualização do tema abordado, os principais objetivos e a

justificativa da pesquisa. O capítulo 2 revisa os conceitos sobre Engenharia de Software e

Bioinformática. No terceiro capítulo será mostrado uma abordagem apresentando como o

projeto foi desenvolvido, explicando os principais pontos do mesmo. Ainda nesse capítulo será

abordado e explicado a utilização de todos componentes utilizado na elaboração do software.

O quarto capítulo exibe toda a estrutura do projeto, mostrando e explicando o princípio de

funcionamento de cada componente desenvolvido na aplicação. Além de apresentar os

resultados obtidos e uma breve discussão dos mesmos.

5

2 ENGENHARIA DE SOFTWARE E BIOINFORMÁTICA

2.1 Engenharia de Software

O software ultrapassou o hardware como a chave para o sucesso de muitos sistemas

baseados em computador. A inteireza e a oportunidade das informações oferecidas pelo

software (e bancos de dados relacionados) diferenciam uma empresa de suas concorrentes [8].

Há 20 anos, menos de 1% do público poderia descrever de forma intelegível o que

significava “software de computador”. Hoje, a maioria dos profissionais bem como a maior

parte do público, em grande medida, entendem bem o que é software [8].

Os componentes de software são criados por meio de uma série de conversões que

mapeiam as exigências do cliente para o código executável em máquina. Um modelo ou

protótipo das exigências é convertido num projeto. O projeto de software é convertido numa

forma de linguagem que especifica a estrutura de dados do software, os atributos

procedimentais e os requisitos relacionados. A forma de linguagem é processada por um

tradutor que a converte em instruções executáveis em máquina [8].

Os componentes de software são construídos usando uma linguagem de programação

que tem um vocabulário limitado, uma gramática explicitamente definida e regras de sintaxe e

semântica bem formadas. Esses atributos são essenciais para a tradução por máquina [8].

As linguagens de alto nível permitem que o desenvolvedor de software e o programa

sejam independentes da máquina. Quando é usado um tradutor mais sofisticado, o vocabulário,

a gramática, a sintaxe e a semântica de uma linguagem de alto nível podem ser muito mais

sofisticados do que as linguagens em nível de máquina [8].

O software pode ser aplicado a qualquer situação em que um conjunto previamente

especificado de passos procedimentais, isso é um algoritmo, tiver sido definido. O conteúdo de

informação e a determinância são fatores importantes na determinação da natureza de um

aplicativo [8].

Os problemas que afligem o desenvolvimento de software podem ser caracterizados a

partir de uma série de perspectivas diferentes, mas as pessoas responsáveis pelo

desenvolvimento de software concentram-se nas questões de primeiro plano: (1) As estimativas

de prazo e custo frequentemente são imprecisas; (2) A produtividade das pessoas da área de

software não tem acompanhado a demanda por seus serviços; e (3) A qualidade do software às

6

vezes é menos que adequada. Os prazos arrastam-se por meses ou anos. Pouca coisa tem sido

feita para melhorar a produtividade dos profissionais da área de software. Os índices de erros

para novos programas causam insatisfação ao cliente e falta de confiança [8].

A aflição que contaminou o desenvolvimento de software não desaparecerá da noite

para o dia. Reconhecer os problemas e suas causas e desmascarar os mitos do software são os

primeiros passos em direção às soluções. Não existe uma abordagem em particular que seja a

melhor para a solução do desenvolvimento de software. Entretanto, ao combinar métodos

abrangentes para todas as fases de desenvolvimento de software, melhores ferramentas para

automatizar estes métodos, blocos de construção mais poderosos para a implementação,

melhores técnicas para a garantia da qualidade de software e uma filosofia de coordenação

predominante, controle e administração, pode-se conseguir uma disciplina para o

desenvolvimento de software, disciplina essa, chamada Engenharia de Software [8].

O mundo moderno não poderia existir sem o software. Infraestruturas e serviços

nacionais são controlados por sistemas computacionais, e a maioria dos produtos elétricos inclui

um computador e um software que o controla. A manufatura e a distribuição industriais são

totalmente informatizadas, assim como o sistema financeiro. A área de entreterimento,

incluindo a indústria da música, jogos de computador, cinema e televisão faz uso intensivo de

software. Portanto, a Engenharia de Software (ESOF) é essencial para o funcionamento de

sociedades nacionais e internacionais [9].

Segundo Fritz [10], a ESOF pode ser vista como o estabelecimento e uso de sólidos

princípios de engenharia para que se possa obter economicamente um software que seja

confiável e que funcione eficientemente em máquinas reais. A ESOF é um rebento da

Engenharia de Sistemas e de Hardware [8]. A ESOF tem por objetivo apoiar o desenvolvimento

profissional de software. Ela inclui técnicas que apoiam a especificação, projeto e evolução de

programas, analisando questões práticas de custo, prazo e confiança, assim como as

necessidades dos clientes e produtores de software [9]. Ela abrange um conjunto de três

elementos fundamentais – métodos, ferramentas e procedimentos – que possibilita ao gerente

o controle do processo de desenvolvimento de software e oferece aos profissionais uma base

para a construção de software de alta qualidade produtivamente [8].

Os métodos de ESOF proporcionam os detalhes de “como fazer” para construir o

software. Os métodos envolvem um amplo conjunto de tarefas que incluem: planejamento e

estimativa de projeto, análise de requisitos de software e sistemas, projeto da estrutura de dados,

arquitetura de programa e algoritmo de processamento, codificação, teste e manutenção [8].

7

As ferramentas de ESOF proporcionam apoio automatizado ou semi-automatizado aos

métodos. Os procedimentos da ESOF constituem o elo de ligação que mantém juntos os

métodos e as ferramentas e possibilita o desenvolvimento racional e oportuno do software de

computador. Os procedimentos definem a sequência em que os métodos serão aplicados, os

produtos que se exige que sejam entregues, os controles que ajudam a assegurar a qualidade e

a coordenar as mudanças, e os marcos de referência que possibilitam aos gerentes de software

avaliar o progresso [8].

O processo de desenvolvimento de software contém três fases genéricas

independentemente do paradigma de ESOF escolhido. As três fases, definição,

desenvolvimento e manutenção, são encontradas em todo desenvolvimento de software,

independentemente da área de aplicação, tamanho do projeto ou complexidade [8].

Os detalhes sobre a utilização desses conceitos serão discutidos na seção 3.1 desse

trabalho. Uma das áreas onde os princípios da ESOF estão sendo utilizados largamente é a área

de Bioinformática. A Seção 2.2 descreve um pouco sobre essa nova área da ciência.

2.2 Bioinformática

Da interação das espécies e populações às funções dos tecidos e células em um

organismo individual, a Biologia é definida como o estudo dos seres vivos. Nesse estudo, os

biólogos coletam e interpretam dados. Agora, usa-se tecnologia sofisticada de laboratório, o

que permite uma coleta de dados mais rápida do que a sua interpretação. Há grandes volumes

de dados de sequências de DNA disponíveis para análise. Mas como descobrir quais partes

desse DNA controlam os vários processos químicos da vida? [11].

A utilização de técnicas e ferramentas de computação na resolução de problemas da

Biologia é chamada de Bioinformática ou Biologia Computacional. Essa área de pesquisa vem

se tornando cada vez mais importante [12]. A computação pode ser aplicada na resolução de

problemas como comparação de sequências (DNA, RNA e proteínas), montagem de

fragmentos, reconhecimento de genes, identificação e análise da expressão de genes e

determinação da estrutura de proteínas [12, 13, 14].

O emprego de métodos computacionais na Biologia iniciou-se na década de 80, quando

biólogos experimentais, em conjunto com cientistas da computação, físicos e matemáticos,

começaram a aplicar esses métodos na modelagem de sistemas biológicos [14]. Na segunda

metade de década de 90, com o surgimento dos sequenciadores automáticos de DNA, houve

8

uma explosão na quantidade de sequências a serem armazenadas, exigindo recursos

computacionais cada vez mais eficientes. Além do armazenamento ocorria, paralelamente, a

necessidade da análise desses dados, o que tornava indispensável a utilização de plataformas

computacionais eficientes para a interpretação dos resultados obtidos. Assim, a Bioinformática

surgiu para tentar dar significado a essa enorme quantidade de dados [15].

Informações sobre a função e hereditariedade de um dado organismo são armazenadas

como DNA, RNA e proteínas. Todas são cadeias lineares compostas de pequenas moléculas.

Essas macromoléculas são reunidas com base em um alfabeto fixo de produtos químicos

simples: o DNA é composto de quatro desoxirribonucleotídeos (adenina, timina, citosina e

guanina), o RNA é composto de quatro ribonucleotídeos (adenina, uracila, citosina e guanina),

e as proteínas são compostas de 20 aminoácidos. Como essas macromoléculas são cadeias

lineares de componentes definidos, podem ser representadas por sequências de símbolos. Essas

podem ser comparadas para localizar semelhanças que sugerem uma relação dessas moléculas

pela forma ou função [11].

A Bioinformática atua na representação, armazenamento e na distribuição de dados

biológicos, como por exemplo, construção de bancos de dados biológicos, criação de

ferramentas para consultar estes bancos de dados e o desenvolvimento de interfaces para

usuários utilizarem diferentes ferramentas. Todos esses aspectos estão relacionados ao

desenvolvimento da infra-estrutura da Bioinformática [11].

Além da infra-estrutura, a Bioinformática trabalha com a construção de ferramentas

analíticas, seja comparando sequências biológicas para desenvolver uma hipótese sobre a

função de um gene descoberto recentemente, quebrando estruturas protéicas tridimensionais

conhecidas em pequenas partes para encontrar padrões que possam ajudar a prever como a

proteína dobra, ou criando um modelo de como as proteínas e os metabólitos em uma célula

trabalham juntos para fazer a célula funcionar [11].

Os bioinformatas, especialistas em Bioinformática, fazem muito mais que capturar,

gerenciar e apresentar dados, buscando inspiração em uma ampla variedade de campos

quantitativos, incluindo Estatística, Física, Ciência da Computação e Engenharia [11].

No próximo capítulo, 3, serão abordados os detalhes sobre o desenvolvimento do

Biopipeline, tema deste trabalho.

9

3 ARQUITETURA DO BIOPIPELINE

3.1 Princípios do desenvolvimento do software

O modelo de desenvolvimento utilizado nesse projeto foi o modelo iterativo e

incremental, no qual o software é desenvolvido em vários passos similares, e em cada passo o

sistema é estendido com mais funcionalidades [16].

A aplicação desenvolvida tinha que ser escrita em uma linguagem de programação que

suporte trabalhar com grande volume de dados biológicos, apresentados na forma de grandes

arquivos FASTA, estabelecendo conceitos satisfatórios de Engenharia de Software como a

eficiência, a confiabilidade, a interoperabilidade, a portabilidade, a reusabilidade e a

testabilidade. O aplicativo também tinha que desenvolver métodos que facilitassem o

armazenamento, a recuperação e a análise desses dados biológicos, e também garantir o melhor

gerenciamento dos recursos disponíveis da máquina aonde será executada.

Para se entender, de uma forma abrangente e profunda, o funcionamento de cada

componente que faz parte do software, uma revisão foi elaborada e será apresentada nas seções

abaixo. Nessa etapa foram decididas a linguagem de programação, o sistema operacional

utilizado, onde a aplicação funcionaria e o banco de dados adotado para armazenamento dos

dados.

3.2 Estrutura do software

O primeiro passo para a elaboração da aplicação, chamada à partir desse ponto de

Biopipeline, foi esquematizar a estrutura de funcionamento completa do software, pois o

mesmo possui diversas funcionalidades que devem ser abordadas separadamente, afim de

manter a coesão de todo o sistema. A Figura 1 apresenta um diagrama de bloco, também

chamado de fluxograma, que resume o Biopipeline.

10

Figura 1 - Diagrama de blocos esquematizando as funções do Biopipeline.

Fonte: Elaborada pelo autor..

As sequências públicas de genoma, descrita na figura, são arquivos texto que possuem

uma forma padronizada e estruturada. Os arquivos que foram pesquisados seguem o padrão

multi-FASTA (um arquivo contém várias sequências genômicas).

Esses arquivos são lidos pela aplicação e salvos no banco de dados, e posteriormente

são aplicados em alguns programas externos a ela. Esses possuem formas próprias de

funcionamento, e cada um processará partes ou todo o arquivo do genoma. Em seguida será

gerado um novo arquivo contendo o resultado do seu processamento. Cada um desses

programas apresentam um tipo de arquivo específico contendo seu resultado.

Assim que os programas entregam os resultados, esses são novamente lidos e

processados e armazenados pelo Biopipeline. Nessa etapa alguns filtros são aplicados nos

resultados de forma a minimizar o armazenamento de dados, que não apresentam um resultado

expressivo, no quesito da área biológica, isso é, são descartados dados que não são importantes

na busca de miRNAs.

Ao final de todo o processo de filtragem e execução dos diversos programas, o programa

identificará no arquivo do genoma, partes do genoma que possuem grande probabilidade de

serem um pre-miRNA.

11

3.3 Desenvolvimento do Banco de Dados

Banco de dados é uma coleção organizada de dados, seguindo uma representação lógica

permitindo que os dados sejam acessados sem considerar sua estrutura física. Um banco de

dados relacional armazena dados em tabelas e essas tabelas são compostas de linhas e colunas

nas quais os valores são armazenados. Normalmente essas tabelas possuem um campo único,

usualmente uma coluna da tabela, chamado de chave primária (primary key), esses valores não

podem ser duplicados em outras linhas. O que garante que cada linha possa ser identificada por

sua chave primária, sem o risco de ocorrer redundâncias na identificação dos dados [17]

Dentre os bancos de dados relacionais pesquisados, MySQL – Oracle Corporation e

PostgreSQL – PostgreSQL Global Development Group, foi escolhido o MySQL, devido a sua

maior popularidade de utilização e por ter uma ferramenta de gerenciamento, MySQL

Workbench, de interface amigável o que facilitou a implantação do mesmo.

No processo de criação do banco também foi utilizado o processo iterativo e

incremental, onde novas tabelas iam sendo adicionadas ao modelo dependendo das

necessidades que iam surgindo.

A plataforma MySQL teve que primeiro ser instalado no sistema operacional base

(explicado posteriormente, na seção 3.4). Em seguida, para o funcionamento da aplicação

utilizando seus recursos, foi utilizada a ferramenta de gerenciamento chamada Workbench para

modelar o banco de dados específico do software. Levando em consideração que o resultado

final da aplicação irá apontar uma região específica do genoma, a localização exata dessa

sequência no genoma é de grande relevância.

A Figura 2 traz o modelo de dados confeccionado para o Biopipeline. Todo o sistema

de banco de dados é composto por oito tabelas de dados, cada uma com função específica dentro

do contexto do programa.

A tabela tbOrganism, juntamente com a tbSequenceOrganism, são responsáveis por

armazenarem todo o conteúdo do arquivo do genoma, sendo que uma armazena as

características de controle do genoma e a outra armazena todas sequências do mesmo,

respectivamente. A partir dessas tabelas que todas as outras são montadas.

A tabela tbResultEinverted é destinada a armazenar os resultados obtidos com a

execução do programa Einverted, recebe uma identificação da tabela de sequências do genoma

para que seus valores sejam relacionados a ela.

12

A tabela tbSource serve como identificação do arquivo de construção da árvore

filogenética. A tabela tbRatingOrganism, é uma tabela que se autorefencia, isto é, ela armazena

os dados com uma estrutura do tipo árvore.

Os dados armazenados na tabela tbSequenceMIRNA são provenientes dos miRNAs já

catalogados nos grandes bancos de genomas. Esses dados obtêm referência da tabela

tbRatingOrganism com intuito de funcionar como filtro para enviar dados compatíveis com o

que será executado no Blastn.

A tabela tbResultBlast também está relacionada com a tabela das sequências do genoma,

serve para armazenar os resultados do Blastn.

A tabela tbResultRNAfold pode receber identificação tanto da tabela de resultados do

Einverted como do Blastn. Ela armazenará os dados dos resultados do programa RNAfold.

Mais informações sobre esses programas citados acima serão encontradas na seção 3.7

desse trabalho. O processo de armazenamento desses dados feito pelo Biopipeline está

explicado na seção 4.1 desse trabalho.

Figura 2. Esquemático das tabelas do Banco de Dados implementado.

Fonte: Print screen do programa Workbench.

13

3.4 Escolha de Sistema Operacional e Linguagem de Programação

O processo de escolha do sistema operacional foi diretamente ligado com aos requisitos

de funcionamento dos programas externos utilizados no projeto. Todos esses programas

ofereciam suporte nativo para plataformas GNU/Linux. Então para a elaboração desse projeto

foi utilizada uma distribuição chamada Kubuntu, que é uma plataforma Linux de interface de

simples utilização, com ambiente de trabalho K Desktop Environment (KDE).

Outro ponto importante na escolha de uma plataforma GNU/Linux foi, por se tratar de

um sistema que utiliza poucos recursos físicos da máquina onde está instalada, aumentando

assim a eficiência da aplicação a ser desenvolvida, que poderia utilizar mais o potencial de

Hardware ali presente.

A linguagem de programação que foi escolhida para a criação da aplicação foi o Java.

Para a programação em Java, foi levantado algumas bibliográficas básicas para consultas dos

conceitos da mesma. Os livros que foram utilizados para introduzir tais conceitos foram: “Java

Como Programar” [17] e “Use a Cabeça! Java” [18]. Também foi de grande suporte, para

conceitos e implementações de módulos, a documentação do The Java Tutorials, disponível em

<http://docs.oracle.com/javase/tutorial/>.

A linguagem Java também oferece suporte para multiprocessamento, boa conectividade

com o banco de dados escolhido, além de conseguir executar e interagir com os programas

auxiliares externos. Como é uma das linguagens de programação mais difundidas no cenário

atual, é mais simples de encontrar suporte de programação. Fatos esses que foram essenciais

para a sua escolha e implementação do software.

Segurança de compilação em bytecodes, multitarefa nativa, conjunto vasto de

bibliotecas (Application programming interface - API, sigla em inglês para Interface de

Programação de Aplicativos) contribuíram para a adoção da plataforma Java. O programa

Netbeans da Oracle Corporation, ambiente de desenvolvimento integrado, fornecem

ferramentas que auxiliam todo o processo de desenvolvimento de software. Por tais motivos,

Java foi definido como a linguagem de programação do projeto.

Além desses fatores citados acima, a fácil implementação de multiprocessamento em

uma aplicação Java, foi um dos fatores determinantes na escolha de Java. Multiprocessamento

consiste em uma técnica de utilização de multithreading. Uma thread contém uma linha de

execução separada, na qual cada uma tem sua própria pilha de chamadas de método e seu

14

próprio contador de programa, permitindo a execução simultânea com outras threads ao

compartilhar recursos no nível do aplicativo como a memória [17].

3.5 Leitura de Arquivos

Parte do serviço do software elaborado nessa pesquisa era destinada a ler arquivos de

texto com características distintas, alguns com formato Fasta, outros referentes aos resultados

dos programas externos utilizados no projeto.

Figura 3 - Exemplo de arquivo do tipo FASTA.

Fonte: Print screen do arquivo hairpin.

A Figura 3 traz um fragmento de um arquivo FASTA. O formato FASTA foi criado

inicialmente por David J. Lipman e William R. Person em 1985 e é a forma mais habitual

representar sequências de nucleotídeos ou sequências de aminoácidos para serem usadas em

vários softwares, tornando o formato padrão usado na Bioinformática[19].

Ao ler o arquivo relativo ao genoma analisado, o aplicativo fará a transferência do

mesmo para a memória RAM da máquina através da aplicação Java. Depois do arquivo ser

carregado em memória, o aplicativo armazenará separadamente as sequências, do organismo

no banco de dados MySQL ou em um diretório temporário.

Como o processo de leitura desse arquivo consome grande demanda de memória RAM

e processamento foi necessária a busca de novos métodos de programação, pois os métodos

convencionais de leitura de arquivos não obtiveram resultados satisfatórios. Portanto, o esse

requisito de leitura de arquivos passou por um longo processo iterativo e incremental, até obter

níveis satisfatórios de desempenho e eficiência.

15

Na API do Java, foi encontrada uma classe (Classe StringBuilder) que trabalha com o

incremento de caracteres. Foi utilizada essa classe pois a classe nativa de caracteres (Classe

String) é imutável, ou seja, o método de leitura do arquivo é feita linha por linha, onde cada

linha é alocada em memória e a mesma não pode ser modificada. Dessa forma, para o acréscimo

de caracteres da próxima linha do arquivo deve ser feito outra reserva na memória que contenha

o tamanho da cadeia de caracteres anterior mais o tamanho dessa, ou seja, há um exagerado

desperdício de memória e processamento.

Além do arquivo do genoma, para a execução do programa Blastn é necessário ter um

conjunto de arquivos de banco de dados específicos. Esse arquivo contém sequências de

miRNAs já definidos e esses arquivos estão dentro de um arquivo do tipo FASTA. Além dessas

sequências, também foi utilizado um outro arquivo indicando a organização filogenética desses

miRNA, para que o programa buscasse somente informações pertinentes ao mesmo reino do

genoma pesquisado.

3.6 Armazenamento de informações

O processo de armazenamento dos dados do Biopipeline foi todo baseado no sistema de

banco de dados MySQL. Dessa forma, toda informação processada pelo software tem que ser

armazenada, lembrando que eles passam por um processo de filtragem antes de serem inseridos.

Todas tabelas são referenciadas levando em consideração a tabela principal que é a do genoma

que será estudado.

Por conta dos arquivos de genomas conterem grandes quantidades de dados, o processo

de armazenagem tradicional de leitura dos dados e inserção de cada sequência do genoma no

banco, se mostrou demorado e ineficiente, como citado acima. Foi necessário entender o

funcionamento do conector que faz essa comunicação entre a aplicação e o banco de dados. Foi

codificado uma função no MySQL (sintaxe load data infile) que faz a leitura de um arquivo de

texto pré-formatado em alta velocidade para armazenamento dos dados nas tabelas. Essa função

foi codificada dentro do Bipipeline para esse carregamento ser realizado de forma rápida e

automática.

Segundo a documentação oficial do MySQL, ao carregar dados em uma tabela

proveniente de um arquivo texto, a utilização do load data infile, torna a tarefa normalmente 20

vezes mais rápido do que o uso da declaração com INSERT.[20]

16

3.7 Utilização de Programas Externos

Um requisito funcional da aplicação era a necessidade da obtenção de sequências do

genoma e transcriptoma com potencial formação de estruturas de grampo ou similaridade com

estruturas de precursores de miRNAs.

Para esse requisito funcional, foi necessário encontrar programas que se baseiam em

características conservadoras das moléculas de miRNAs. Foi feito o uso do programa Einverted

[21]. O programa Einverted procura por repetições invertidas (stem loops) em uma sequência

de nucleotídeos. Essas repetições invertidas, basicamente incluem uma proporção de

mismatches e gaps (protuberâncias no stem loop). A Figura 4 traz um print screen da ferramenta

Einverted quando utilizada através do portal.

Figura 3 - Versão online programa Einverted.

Fonte: Print screen da página Emboss.[21]

17

Os arquivos de entrada do programa Einverted consistem em sequências genômicas

oriundas de banco de dados públicos encontrados e processados pelo primeiro requisito de

software. Portanto, cada instância do programa Einverted deve receber apenas uma sequência

com os seus nucleotídeos e um conjunto de parâmetros que são baseados em vários fatores

determinísticos para análise, como “gap penalty” e “minimum score threshold”.

Também foi necessário o uso do programa Blastn [22]. O Basic Local Alignment Search

Tool (BLAST) encontra regiões de similaridade local entre as sequências. O programa compara

as sequências de nucleotídeos ou a bases de dados de sequências de proteínas e calcula a

significância estatística dos resultados. BLAST pode ser utilizado para inferir relações

funcionais e evolutivas entre sequências, bem como ajudar a identificar os membros de famílias

de genes. A Figura 5 traz um print screen da ferramenta BLAST quando utilizada através do

portal.

Figura 4 - Versão online do programa do Blastn.

Fonte: Print screen da página do Blast[22].

18

Para a execução do programa Blastn é necessário ter um conjunto de arquivos de banco

de dados, que é gerado por um comando auxiliar chamado “formatdb” (ferramenta NCBI). O

comando “formatdb” é usado para formatar as sequências de proteínas ou de nucleotídeos para

a pesquisa do BLAST. Na construção dos arquivos de banco de dados, é necessário ter um

arquivo, que pode ser do tipo multi-FASTA, referenciando-o como a entrada de dados para a

execução do comando “formatdb”.

Os arquivos de entrada do programa Blastn consistem nos arquivos de banco de dados

gerados pela execução do comando auxiliar “formatdb” e nos arquivos de sequências de

miRNAs já definidos para comparação, na qual foi usada o banco de dados da miRBase [23].

O miRBase é um banco de dados pesquisável de sequências de miRNA publicados e

divulgados. Cada sequência na miRBase representa uma parcela de predição de hairpin de uma

transcrição de um miRNA, com informações sobre a localização e o sequenciamento de uma

sequência de um miRNA maduro.

As saídas dos programas Einverted e do Blastn depende tanto do conjunto de dados de

entrada como o conjunto de parâmetros enviados. As saídas desses programas são arquivos de

textos com uma formatação pré-definida e com informações de dados importantes sobre cada

sequência executada pelos programas. A Figura 6 ilustra a saída do programa Einverted, onde

tem-se os pareamentos que foram obtidos, suas pontuações, em qual posição o pareamento

ocorreu, número de gaps e porcentagem de correlação (matches).

Figura 5 - Resultado da execução do Einverted.

Fonte: Fragmento de imagem retirada da página do Einverted[21].

Portanto, o próximo requisito de software, era manejar esse conjunto de arquivos de

saídas dos programas. A manipulação desses arquivos gerados pelos programas utilizados,

gerou grandes problemas de memória nas máquinas utilizadas. Dessa forma, a máquina que

executar o Biopipeline deverá ter uma grande quantidade de memória RAM para suportar o

grande volume de dados a serem processados.

Depois dos dados gerados pela execução dos programas Einverted e do Blastn, o

Biopipeline fará uma seleção nesses resultados. Essa seleção consiste em descartar informações

19

desnecessárias, descartando uma grande quantidade de dados. Esse descarte melhora o

desempenho do Biopipeline e, além disso, tem que se assegurar que nenhum miRNA positivo,

seja eliminado. Esse descarte elimina dados genômicos que não representam uma possível

sequência de miRNA.

Outro programa externo utilizado no software foi o RNAfold [24]. O RNAfold prediz

estruturas secundárias de RNAs usando parâmetros que se baseiam na mínima energia livre

(MFE), ou seja, o programa basicamente serve para a busca de miRNAs não conservados

através da análise de sequências maduras de miRNAs nas prováveis estruturas secundárias de

seus respectivos precursores. A Figura 7 traz um print screen da ferramenta RNAfold quando

utilizada através do portal.

Figura 6 - Versão online do programa RNAfold.

Fonte: Print screen da página do RNAfold [24].

Dessa forma, o aplicativo deve manipular o programa RNAfold e deve oferecer um

conjunto de sequências pré-selecionadas oriundas da execução dos programas Einverted e

Blastn. A manipulação do programa consiste em otimizar o consumo de recursos do sistema

20

operacional para diminuir o tempo de execução do mesmo. Depois de sua execução, o aplicativo

deve manipular os arquivos de saída e fazer uma filtragem para eliminar as sequências não

desejadas através de parâmetros pré-selecionados, que resulte em um conjunto satisfatório de

sequências.

Como descrito acima, as Figuras 4, 5 e 7 trazem imagens retiradas dos portais dos

programas Einverted, Blastn e RNAfold, mostradas nessa seção para ilustrar o modo de

funcionamento dos programas na web. As versões utilizadas no projeto foram instaladas juntos

ao sistema operacional Linux Kubuntu e o seu funcionamento é através de linhas de comando,

chamadas dentro de um programa Java.

21

4 DETALHES TÉCNICOS DO BIOPIPELINE, RESULTADOS E

DISCUSSÃO

4.1 Detalhes técnicos do Biopipeline

O projeto teve início a partir dos requisitos de softwares estabelecidos anteriormente e

o projeto deve atender os requisitos funcionais. Como o modelo de processo de software

escolhido foi o iterativo e incremental, as fases de levantamento, análise, projeto,

implementação e testes passaram por constantes mudanças através do decorrer dos ciclos de

desenvolvimento.

O desenvolvimento da aplicação consistiu na criação de uma estrutura organizada de

classes orientada a objetos e divididas em pacotes, de forma que cada classe tem baixa coesão

e alto acoplamento, facilitando a reutilização de código. A divisão de pacotes está mostrada no

esquemático abaixo, definindo o nome e a função designada para cada pacote.

Figura 7 - Estrutura do código desenvolvido.

Fonte: Print screen do projeto no programa Netbeans.

4.1.1 Pacote Blast

Módulo do programa implementado unicamente para o controle das atividades

realizadas pelo programa do Blastn. A Figura 9 traz os subpacotes do pacote Blastn. No

subpacote “run” estão dispostas a classes responsáveis pelo controle do multiprocessamento do

22

programa. No subpacote “formatdb” estão as classes responsáveis por criar as entradas de dados

do programa. Subpacote “filter” ler e interpretar os resultados do programa.

Figura 8 - Modulo Blast


No primeiro estágio, ele prepara o banco de dados para a execução do Blastn, definindo

o conjunto de parâmetros do programa FormatDB e referenciando o arquivo genômico que foi

criado no primeiro módulo. Executa o comando do objeto FormatDB.

Além disso, ele prepara toda a estrutura de multiprocessamento para execução de

diversas instâncias do programa nos vários núcleos de processadores da máquina, definindo o

conjunto de parâmetros e o número de processadores ativos para a execução do programa

Blastn. Define também, o conjunto de dados de sequências miRNA selecionadas, a database de

sequências do organismo, arquivos esses que foram gerados pela execução do FormatDB.

Referencia uma localização no sistema de arquivos para os resultados (arquivos de saída) da

execução do programa Blastn.

Esse pacote também instancia todos os objetos do tipo Blastn (objetos que serão

enviados para serem executados), com o conjunto de comandos e de parâmetros. Executa os

comandos enviados dos objetos Blastn num “pool de threads” diretamente no sistema

operacional, onde cada thread ocupará um instante de tempo de um dos processadores ativos

até ser finalizada.

E por fim, ele fará a filtragem desses resultados afim de armazenar somente os que

possuírem maior probabilidade de ser um miRNA. Faz a leitura de todos os arquivos

referenciados e instancia todos os objetos de resultados com os devidos atributos. Seleciona os

objetos de resultados que satisfazem os critérios dos parâmetros já definidos. Indica os índices

nos objetos de resultados selecionados para referenciar a origem das sequências miRNA e das

23

sequências do organismo no sistema de banco de dados. Insere as mini sequências nos objetos

de resultados selecionados, ou seja, completa as sequências selecionadas com seus nucleotídeos

respectivos. Salva os objetos de resultados pré-selecionados no sistema de banco de dados.

4.1.2 Pacote Core

A Figura 10 traz todos os subpacotes presentes no pacote Core. Esse pacote indica todos

os arquivos e pastas utilizados pelo programa e implementa classes básicas diretivas. Essas

classes são utilizadas em conjunto com a execução dos programas externos, servem para criar

pastas separadas para cada resultado apresentado pelos programas, para não haver o risco de

nenhum arquivo ser sobrescrito.

Figura 9 - Módulo Core.


Também contém classes básicas que são implementadas para a criação dos objetos

destinados às tabelas do banco de dados.

4.1.3 Pacote Einverted

A Figura 11 traz todos os subpacotes presentes no pacote Einverted. Esse módulo é

similar ao item 4.1.1 desse documento. Tem sua funcionalidade voltada para controlar todo

fluxo de dados e comandos necessários para execução do Einverted. Tanto na parte de

multiprocessamento quando na parte de filtragem dos resultados do programa.

24

Figura 10 - Módulo Einverted.


O processo de execução desse módulo segue os seguintes passos:

Define o número de processadores ativos para a execução do programa

Einverted.

Referencia os arquivos FASTA no sistema de arquivos, cada um contendo uma

sequência, ou seja, referenciando o conjunto de dados de entrada;

Indica uma localização no sistema de arquivos para os resultados (arquivos de

saída) da execução do programa Einverted;

Instancia todos os objetos do tipo Einverted (objetos que serão enviados para

serem executados diretamente no sistema operacional), com o conjunto de

comandos e de parâmetros;

Executa os comandos enviados dos objetos Einverted num “pool de threads” no

sistema operacional, cada thread ocupará um instante de tempo de um dos

processadores ativos até ser finalizada;

Define o conjunto de parâmetros limites de seleção dos resultados (arquivo de

saída) da execução do programa Einverted;

Passa a referência da localização dos arquivos de resultados no sistema de

diretórios da execução do programa Einverted;

Faz a leitura de todos os arquivos referenciados e instancia todos os objetos de

resultados com os devidos atributos;

Seleciona os objetos de resultados que satisfazem os critérios dos parâmetros já

definidos;

Insere as mini sequências nos objetos de resultados selecionados, ou seja,

completa as sequências selecionadas com seus nucleotídeos respectivos;

Salva os objetos de resultados pré-selecionados no sistema de banco de dados.

25

Durante a fase de análise dos resultados, alguns dados são observados para que se possa

fazer a filtragem e posteriormente armazenar somente os que apresentarem maior relevância. A

figura abaixo ilustra um exemplo do resultado de um arquivo do Einverted, mostrando as

regiões de interesse na leitura do programa.

Figura 11 - Resultado Einverted e seus principais pontos de interesse.

Fonte: Elaborada pelo autor.

Os parâmetros de Score, Matches e total nucleotides matches são os que indicam a

relevância que essa sequência possui, os demais servem para indicar de onde veio a sequência

e a correta localização da mesma no genoma.

4.1.4 Pacote Genome

A Figura 13 traz todos os subpacotes presentes no pacote Genome. Esse módulo é

responsável pelo carregamento, interpretação e salvamento do arquivo do genoma. Esse módulo

é um dos primeiros a serem executados pelo programa.

Figura 12 - Pacote de manuseio do genoma.


As classes presentes nesse pacote fazem as seguintes operações com o arquivo

genômico:

Indica a localização do arquivo genômico multi-FASTA (denominado como

sequência plus) do sistema na aplicação;

26

Instancia o objeto organismo (entrada de dados pelo usuário) e o salva no sistema

de banco de dados;

Cria sequências reversas complementares denominadas sequências minus a

partir das sequências plus;

Instancia dados completos dos objetos de sequências plus e minus e os salva no

sistema de banco de dados;

Cria um arquivo multi-FASTA com as sequências plus e minus (necessário para

a execução do programa formatDB);

Cria vários arquivos do formato FASTA com as sequências plus e minus, cada

arquivo contendo somente uma sequência (necessário para a execução do

einverted).

4.1.5 Pacote GUI.Pictures

Esse pacote está destinado a toda parte de interface homem-máquina do programa. Essas

classes servirão para facilitar a troca dos parâmetros necessário para a execução do Biopipeline,

além de mostrar de maneira visual e simples os resultados obtidos após a toda a execução do

programa. Nenhuma classe foi realmente implementada nesse pacote, por se tratar da última

etapa do desenvolvimento do software.

4.1.6 Pacote IO

A Figura 14 traz todos os subpacotes presentes no pacote IO. Esse pacote é responsável

pela estrutura de leitura e escrita de arquivos genéricos e do tipo FASTA. Esse pacote é

considerado importantíssimo, pois é através dele que os demais Pacotes conseguem gerenciar

todo o processo de fluxo de dados com os arquivos. É utilizado mais intensamente no pacote

“Genome” pois ele faz o controle de acesso a todos esses arquivos.

Figura 13 - Pacote de Leitura e Escrita de dados.


27

Além de fazer a leitura do arquivo do genoma principal ele é responsável por criar os

arquivos que alimentam a entrada do programa Einverted, aonde cada instância do programa é

alimentada com apenas uma única sequência do genoma, localizados em um arquivo de entrada.

4.1.7 Pacote Mirna

A Figura 15 traz todos os subpacotes presentes no pacote Mirna. Esse pacote trata da

estrutura do software voltada para todo o tratamento dos arquivos quem contém miRNA

provenientes do miRBase. Gerencia tanto a parte de inserção das sequências no banco de dados,

criação da árvore filogenética de organização do miRBase, como também realiza a parte de

associar as duas partes.

Figura 14 - Pacote de controle dos arquivos provindos do miRBASE.


O processo lógico seguido dentro desse pacote segue a seguinte cronologia:

Referencia a localização dos arquivos de rating, mature e hairpin que são

encontrados no sítio da miRBase, estes arquivos são as sequências miRNAs

maduras e seus precursores;

Cria o banco de dados com as sequências miRNAs oriundas do miRBase,

instanciando um objeto source, ou seja, uma fonte de sequências confiáveis de

miRNAs;

Cria uma estrutura de dados tipo árvore n-ária genérica a partir do arquivo

rating, este arquivo contém informações de como os as sequências miRNAs são

classificadas em diferentes organismos;

28

Instancia objetos de sequências miRNA a partir da leitura dos arquivos mature

e hairpin, estes arquivos estão pré-formatados com um padrão descrito na

miRBase;

Insere todos os objetos gerados nesse módulo no banco de dados.

4.1.8 Pacote MySQL

A Figura 16 traz todos os subpacotes presentes no pacote MySQL. Esse pacote realiza

todas operações com o banco de dados do software. Contém os objetos das tabelas referentes

as tabelas encontradas no banco, classes de conexão, manuseio e atualização do banco. Também

contém as classes que implementam os arquivos de rápida inserção de dados no banco.

Figura 15 - Módulo de trabalho do Banco de Dados.


4.1.9 Pacote RNAfold

A Figura 17 traz todos os subpacotes presentes no pacote RNAfold. Esse pacote tem sua

funcionalidade voltada para controlar todo fluxo de dados e comandos necessários para

execução do RNAfold, tanto na parte de multiprocessamento quando na parte de filtragem dos

resultados do programa.

29

Figura 16 - Pacote RNAfold.


O padrão de execução das classes desse pacote segue os seguintes passos:

Define o conjunto de parâmetros e o número de processadores ativos para a

execução do programa RNAfold;

Faz um arquivo com os resultados pré-selecionados (sequências) do Einverted e

do Blastn através do sistema de banco de dados ou pelo sistema de diretório do

sistema operacional;

Indica uma localização no sistema de arquivos para os resultados (arquivos de

saída) da execução do programa RNAfold;

Instancia todos os objetos do tipo RNAfold (objetos que serão enviados para

serem executados no prompt de comando do sistema operacional), com o

conjunto de comandos e de parâmetro;

Executa os comandos enviados dos objetos RNAfold num “pool de threads” no

sistema operacional, onde cada thread ocupará um instante de tempo de um dos

processadores ativos até ser finalizada;

Define o conjunto de parâmetros limites de seleção dos resultados (arquivo de

saída) da execução do programa RNAfold;

Referencia a localização dos arquivos de resultados no sistema de diretórios da

execução do programa RNAfold;

Salva os resultados significativos no banco de dados.

4.1.10 Pacote Util

A Figura 18 traz todos os subpacotes presentes no pacote Util. Esse pacote possui classes

que ajudam no processo de execução do programa, como o auxílio no gerenciamento de threads

em processos do sistema, informação do tempo de execução de processos e liberação de

endereços da memória RAM que não serão mais utilizados.

30

Figura 17 - Classes do pacote Util


4.1.11 Conexão com o bando de dados

Para comunicação com o banco de dados, foi utilizada o driver JDBC™ (Java Database

Connectivity), versão 5.1.25, como pode ser visto através da Figura 19.

Figura 18 - Driver JDBC utilizado no projeto Biopipeline.


4.2 Resultados

Após o programa ser executado, durante 6 horas, foram obtidas cerca de 800 sequências

de prováveis miRNAs. O resultado, do ponto de vista biológico, pode parecer grande demais

para ser analisado em bancada. Contudo, o processo de filtragem pode ser reajustado de forma

a eliminar sequências de menor expressão biológica, diminuindo assim o número de resultados.

O modelo e a implementação do banco de dados funcionaram para todas as instâncias

estabelecidas no programa. A parte mais complexa foi a estruturação da tabela da árvore

filogenética. Ela faz referência a si própria (possui recursividade), retornando apenas os

miRNAs, também cadastrados no banco, do mesmo Filo pertencente ao genoma, como

esperado. O processo de armazenamento dos dados foi feito de maneira rápida, sem que

houvesse comprometimento dos dados, além dos processos de consulta retornarem os valores

esperados.

Alguns problemas como o travamento do computador por uso excessivo dos threds que

ocuparam todo a capacidade de processamento da máquina e falta de memória RAM para a

aplicação ocorreram durante essa etapa. Contudo alguns ajustes foram realizados, tais como

estabelecimento do número máximo de processadores utilizados por cada módulo do software,

31

e o aumento da configuração da quantidade de memória que a aplicação poderia utilizar

resolveram esses contratempos.

Após totalmente configurado de acordo com a máquina que estava sendo rodado o

Biopipeline, funcionou ocupando todos núcleos de processamento do computador, manejando

o consumo de memória, e realizando todas suas tarefas de maneira otimizada e sem

travamentos. O que demostra que do ponto de vista computacional o projeto obteve êxito

completo em sua execução.

4.3 Conclusões

O programa Biopipeline desenvolvido nesse estudo se mostrou uma ferramenta eficiente

no auxílio dos profissionais de biologia na procura de novos miRNAs. A proposta visa facilitar

a localização de miRNAs pouco ou nada expressos no genoma, que em processos puramente

experimentais acabam sendo desprezados.

O Biopipeline não é uma ferramenta tão complexa que necessite de um computador com

muitos recursos computacionais para ser executa. Sendo assim, ela pode ser implementada

facilmente em diversas Universidades ou laboratórios genéticos, que trabalhem com miRNAs,

sem a necessidade de compra de computadores caros para sua execução desse software.

Os resultados podem sofrer variações de acordo com as características dos filtros aqui

implementados, variando de acordo com a necessidade de cada utilizador do Biopipeline.

A aplicação dos conceitos de engenharia de software nesse projeto, fez com que o

software final funcionasse de maneira robusta e eficiente. O que prova que esse tipo de ciência

pode ser aplicadas nas diversas áreas de conhecimento, de maneira a melhorar seu desempenho.

32

REFERÊNCIAS

[1] D. Moazed. Small rnas in transcriptional gene silencing and genome de- fence.

Nature, 457(7228):413–420, 2009.

[2] V. N. Kim, J. Han, and et al. Biogenesis of small rnas in animals. Rev Mol Cell Biol,

10(2):126–139, 2009.

[3] J. Winter, S. Jung, and et al. Many roads to maturity: microrna biogenesis

pathways and their regulation. Nat Cell Biol, 11(3):228–234, 2009.

[4] D. Murphy, B. Dancis, and et al. The evolution of core proteins involved in microrna

biogenesis. BMC Evol Biol, 8:92, 2008.

[5] S. M. Hammond. microrna detection comes of age. Nat Methods, 3(1):12–13, 2006.

[6] X. Yu, Q. Zhou, and et al. A discovery of novel micrornas in the silkworm (bombyx

mori) genome. Genomics, 94(6):438–444, 2009.

[7] Y. Huang, Q. Zou, and et al. The discovery approaches and detection methods of

micrornas. Mol Biol Rep, 38(6):4125–4135, 2011.

[8] PRESSMAN, R. S., Engenharia de Software. São Paulo: Pearson Makron Books, 1995.

[9] SOMMERVILLE, I. Engenharia de Software. São Paulo: Pearson Prentice Hall, 2011.

[10] Naur, P. e Randell B (editores). Software Engineering: A Report on a Conference

Sponsored by the NATO Science Commitee, 1969.

[11] GIBAS, C. Desenvolvendo bioinformática: ferramentas de software para

aplicações em biologia. Rio de Janeiro: Campus, 2001.

[12] P. Baldi and S. Brunak. Bioinformatics: the Machine Learning approach. MIT

Press, 2 edition, 2001.

33

[13] J. C. Setúbal and J. Meidanis. Introduction to Computacional Molecular Biology.

PWS Publishing Company, Boston, 1997

[14] M. C. P. de Souto, A. C. Lorena, A. C. B. Delbem, and A. C. P. L. F. de Carvalho.

Técnicas de aprendizado de máquina para problemas de biologia molecular.

Porto Alegre, 2003. Sociedade Brasileira de Computação, Sociedade Brasileira de

Computação.

[15] L. R. Amaral. Bioinformática, surge uma nova ciência. Especialização, Universidade

Federal de Lavras, Lavras, 2005.

[16] Bezzera, E. Princípios de Análise e Projeto de Sistemas com UML. 1. Ed. Rio de

Janeiro: Elsevier, 2002.

[17] Deitel, P. J. Java: como programar. 8. Ed. São Paulo: Pearson Prentice hall, 2010.

[18] SIERRA, K.; BATES, B. Use a Cabeça! Java. Rio de Janeiro: Alta Books, 2007.

[19] Lipman, DJ. Rapid and sensitive protein similarity searches. Science 227 (4693):

1435–41. Pearson, WR (1985).

[20] MySQL, Speed of INSERT Statements. Disponível em:

<http://dev.mysql.com/doc/refman/5.7/en/insert-speed.html>. Acesso em: 30 de outubro de

2015.

[21] EMBOSS - The European Molecular Biology Open Software Suite. Einverted.

Disponível em: <http://emboss.bioinformatics.nl/cgi-bin/emboss/einverted>. Acesso em: 28

de outubro de 2015.

[22] NCBI - National Center for Biotechnology Information. Blastn. Disponível em:

<http://blast.ncbi.nlm.nih.gov/Blast.cgi?PROGRAM=blastn>. Acesso em: 28 de outubro de

2015.

[23] MiRBase. miRBase: the microRNA database. Disponível em:

<http://www.mirbase.org/>. Acesso em 02 de novembro de 2015.

[24] Vienna RNA Package - RNA Secondary Structure Prediction and Comparison.

Disponível em: <http://rna.tbi.univie.ac.at/cgi-bin/RNAfold.cgi>. Acesso em: 06 de outubro

de 2015.

Documents

UNIVERSIDADE FEDERAL DE UBERLÂNDIA-UFU FACULDADE DE ENGENHARIA ELÉTRICA ... · organismos incluindo unicelulares e multicelulares [4]. O processo de regulação transcricional