Modelagem. Realiza Experimentos. Compara. Testes dos Modelos. Realiza Simulações. Resultados Experimentais. Resultados das Simulações

Transcrição

1 azevedolab.net 1

2 Modelagem de Sistemas O fluxograma abaixo destaca o uso de uma abordagem computacional para o estudo de sistemas biológicos, destacado em vermelho. Em verde temos a abordagem experimental. Ao final comparamos os resultados para validar a abordagem computacional. Sistema Biológico Modelagem Realiza Experimentos Realiza Simulações Resultados Experimentais Resultados das Simulações Compara Testes dos Modelos 2

3 Modelagem de Sistemas A comparação é necessária para a validação da abordagem computacional, sem tal etapa a modelagem fica sem base experimental para o estudo do sistema biológico a ser simulado. Sistema Biológico Modelagem Realiza Experimentos Realiza Simulações Resultados Experimentais Resultados das Simulações Compara Testes dos Modelos 3

4 Quantitative Structure Activity Relationship A abordagem moderna do desenho e desenvolvimento de fármacos é resultado de um processo iterativo. Em cada iteração (ciclo de desenvolvimento), espera-se que a atividade farmacológica da molécula seja aprimorada, de forma que haja uma evolução no processo (otimização da atividade farmacológica). O diagrama ao lado ilustra o ciclo. No processo iterativo, a molécula é desenhada e passa para síntese. Neste ponto pode ser necessário retorno à fase de desenho, caso a síntese apresente desafios, não previstos na fase de desenho.

5 Quantitative Structure Activity Relationship Chegando-se à fase de teste, a atividade é averiguada e os resultados relacionados à estrutura do fármaco em potencial. Neste processo podemos inserir uma fase de análise, onde elaboramos um modelo computacional. O modelo permite que a atividade da molécula seja relacionada com sua estrutura, ou seja, um estudo da Relação Quantitativa-Estrutura-Atividade (Quantitative Structure-Activity Relationship, QSAR). Neste estudo, descritores moleculares são relacionados à atividade da molécula, e uma análise estatística dos descritores leva a um modelo, que pode ser usado para prever atividade farmacológica. QSAR

6 Quantitative Structure Activity Relationship A abordagem de QSAR foi introduzida pelo trabalho pioneiro de Corwin Hansch na década de 1960, no seu estudo da atividade biológica de uma série de compostos relacionados estruturalmente. A atividade biológica pode ser relacionada com a estrutura molecular, a partir de equações como a descrita abaixo: 1 log C P 0 1log 2 onde C é a concentração molar de um composto necessário para produzir uma dada atividade biológica, por exemplo IC 50, log P é o coeficiente de partição entre octanol e água, é outro descritor molecular, como número de doadores de ligação de hidrogênio da molécula. Descritores moleculares descrevem propriedade gerais de uma dada molécula, que podem estar relacionadas com a atividade farmacológica. Por exemplo, um logp abaixo de 5, indica que a molécula tem baixa hidrofobicidade, aumentando as chances de disponibilidade oral. Fonte da imagem: Acesso em: 25 de novembro de Hansch, C., Ruth, A.S., Anderson, S.M., Bentley, D.L. Parabolic dependence of drug action upon lipophilic character as revealed by study of hypnotics. J. Med Chem 11 (1968) 1-11.

7 Quantitative Structure Activity Relationship Várias metodologias têm sido usadas para elaborar modelos de QSAR, sendo regressão a mais aplicada, colocada na sua forma linear, a equação de regressão tem o seguinte aspecto: y = x onde y é a variável dependente (a propriedade biológica a ser modelada), um exemplo de variável dependente usada em QSAR é log (1/IC 50 ). IC 50 é a constante inibitória para que a atividade biológica caia 50 %. O termo x é a variável independente (descritor molecular), como exemplos de variáveis independentes, usadas em QSAR, temos o log P, número de ligações rotáveis, número de doadores de ligação de H etc. O 1 é coeficiente angular da reta, ou do ponto de vista de otimização, o peso da variável x e 0 é a constante de regressão. Reta (em vermelho) obtida por regressão linear para um conjunto de pontos experimentais (pontos azuis). O gráfico foi gerado com o programa Mathematica ( atistics/) Acesso em: 25 de novembro de 2016.

8 Quantitative Structure Activity Relationship Não é objetivo do presente curso ir a fundo em métodos numéricos, mas a matemática necessária para entendermos a regressão linear é simples, por isso vamos ver as equações usadas no método. Nas equações abaixo, os termos entre < > indicam média aritmética. Na regressão linear, os coeficientes s são dados pelas seguintes equações, 1 N ( x i 1 i N x ( x i 1 i )( y x i ) 2 y ) 0 y 1 x ( x, y As linhas descritas por regressão linear passam pelo ponto médio, onde <x> e <y> são as médias das variáveis independente e dependente, respectivamente, como mostrada nas equações abaixo, N é o número de dados disponíveis (pares x,y): ) x 1 N N x i i 1 y 1 N N y i i 1

9 Quantitative Structure Activity Relationship Vamos considerar um conjunto de 20 pontos, mostrados na tabela abaixo. Usaremos estes dados para calcular a melhor reta, a partir das equações da regressão linear. O Excel já tem uma função de regressão, usaremos o exemplo abaixo para explicitar os termos. X Y Numa abordagem algorítmica para resolução do problema, temos como primeiro passo o cálculo da média, com as equações abaixo: x 1 N 1 N y x i N i 1 N i 1 Em seguida calculamos 1, com a equação a seguir: 1 N ( x i 1 Por último calculamos 0. 0 y 1 x i N ( x i 1 x i )( y x i ) 2 y ) y i

10 Quantitative Structure Activity Relationship Temos a seguinte sequencia de cálculos: 1) Médias 1 x y ( x i 1 12,902 1 N 1 N N ( x i 1 N x i i 1 N y i i 1 2) Cálculo do 1 N i x i )( y 3) Cálculo do 0 x i 1,05 13,035 ) 2 y ) 0 85,795 6,65 y x y x- <x> y-<y> (x-<x>)(y-<y>) (x-<x>)^ ,035 12,902.1,05 1 x 0,512

11 Variável dependente Quantitative Structure Activity Relationship No final temos a melhor reta (equação de regressão), indicada abaixo: X Y y = 1 x + 0 y =12,902x 0, ,5 1 1,5 2 2,5 Variável independente Na elaboração de modelos de QSAR, normalmente temos mais de uma variável independente, o que leva ao uso de regressão linear múltipla. Outro nível de abstração do modelo de QSAR, é o uso de variáveis independentes não lineares. Tais métodos de aproximação estão disponíveis em pacotes como o Mathematica ( Além disso, podemos implementar os métodos de regressão linear, a partir da linguagem de programação Python.

12 Quantitative Structure Activity Relationship Tanto nos modelos de QSAR, obtidos por regressão linear, como para aqueles obtidos por regressão linear múltipla, ou mesmo não linear, temos que acessar a qualidade do modelo de regressão, ou seja, a qualidade do ajuste da curva (ou reta) modelada, contra os pontos experimentais (y i ). Um dos parâmetros usados, é o coeficiente de correlação quadrado (R 2 ). Considere que y calc,i são valores calculados a partir da equação de regressão, usando observações experimentais x i. Assim temos os seguintes termos: soma total dos quadrados (Total Sum of Squares, TSS), soma dos quadrados explicada (Explained Sum of Squares, ESS) e soma residual dos quadrados (Residual Sum of Squares): N 2 N 2 N TSS y i y ESS y calc y RSS i 1 i 1 Que são usados para o cálculo de R 2, como segue:, i i 1 y i y calc, i 2 R 2 1 RSS TSS

13 Quantitative Structure Activity Relationship x y x-<x> y-<y> ycalc,i (y-ycalc,i)^2 (y-<y>)^2 (ycalc,i-<y))^ RSS N i ,66599 y i y calc, i TSS N i 1 2 y i y 1133,551 R 2 1 RSS TSS 1 26, ,551 0,9765

14 Variável dependente Quantitative Structure Activity Relationship O coeficiente de correlação quadrado mede a qualidade do ajuste da função teórica (equação de regressão) aos pontos experimentais. Esse índice varia de 0 a 1. O valor zero não indica correlação entre os dados. Para R 2 igual a 1, ou próximo desse, temos uma equação de regressão com boa correlação como os dados experimentais. A equação de regressão obtida, no exemplo apresentado, tem excelente correlação, R 2 = 0,9765, tal concordância pode ser vista na análise do gráfico, onde todos os pontos experimentais estão próximos à reta de regressão y = 1 x + 0 y =12,902x 0,512 R 2 = 0, ,5 1 1,5 2 2,5 Variável independente

15 Quantitative Structure Activity Relationship É óbvio que sistemas biológicos, caracterizados por uma dada atividade, raramente podem ser modelados com funções lineares simples. A introdução de variáveis independentes no modelo de QSAR leva, muitas vezes, a um modelo mais robusto, onde características químicas relevantes (descritores) são considerados. Contudo, o princípio da parcimônia deve ser adotado, ou seja, nem sempre um modelo com mais variáveis independentes é o mais adequado para modelar a atividade biológica. Colocaremos como exemplo o uso do programa Mathematica para encontrarmos modelos matemáticos para conjuntos de dados. Depois implementaremos em Python. Polinômio de grau 2 (-0,634408x 2 + 1,24534x + 0, ) usado para aproximar os cinco pontos experimentais mostrados acima. O gráfico foi gerado com o programa Mathematica ( Acesso em: 25 de novembro de 2016.

16 Quantitative Structure Activity Relationship A idéia básica atrás da aproximação de uma função é usar uma lista de funções matemáticas especificadas antecipadamente, e tentar encontrar uma combinação linear dessas funções dadas, de forma que essa combinação linear de funções fique o mais próximo possível do conjunto de dados. Vamos ilustrar as idéias principais com exemplos. Vamos considerar um conjunto formado pelos 19 pontos experimentais, indicados na tabela ao lado. Para colocar essas informações no Mathematica digitamos: x y data={{73., },{74.,35.381},{75., },{76., },{77., }, {78., },{79., }, {80., },{81., },{82., }, {83., },{84., },{85., },{86.,33.407},{87., },{88., },{89.,41.57},{90., },{91., }};

17 Quantitative Structure Activity Relationship Vamos gerar o gráfico dos pontos experimentais e conectá-los. Para isto definimos lp1 e lp2 que no Mathematica fica da seguinte forma: lp1=listplot[data,plotstyle->pointsize[0.03],displayfunction->identity]; lp2=listplot[data,plotjoined->true, DisplayFunction->Identity]; Agora preparamos o gráfico, digitando: Show[lp1,lp2, DisplayFunction->$DisplayFunction] O resultado é mostrado ao lado.

18 Vemos pelo gráfico que o ajuste é insatisfatório. Quantitative Structure Activity Relationship Vamos gerar curvas que ajustem-se ao conjunto de dados experimentais. Podemos testar vários cenários, esta é uma das vantagens de usarmos um pacote poderoso como o Mathematica, ou ainda uma linguagem de programação como o Python, que veremos adiante. Para gerarmos um ajuste por regressão linear e graficarmos os resultados, usamos os seguintes comandos: Clear[p] p=fit[data,{1,x},x] plotp=plot[p,{x,71,93},displayfunction->identity]; Show[plotp,lp1,PlotRange->{0,50},DisplayFunction->$DisplayFunction] Os resultados são mostrados no gráfico. A equação de regressão é: Y= x

19 Quantitative Structure Activity Relationship Vamos tentar uma nova curva, com um polinômio com x e x 2, para isto basta mudarmos a linha de comando Fit (indicado em vermelho), o restante é mantido. Clear[p] p=fit[data,{1,x,x^2},x] plotp=plot[p,{x,71,93},displayfunction->identity]; Show[plotp,lp1,PlotRange->{0,50},DisplayFunction->$DisplayFunction] Os resultados são mostrados no gráfico. A equação de regressão é: Y= x x 2 Vemos pelo gráfico que o ajuste é Insatisfatório. No próximo slide temos aproximações para polinômios até o grau 5.

20 Quantitative Structure Activity Relationship Nas figuras a seguir temos ajustes para diversas funções polinomiais. Aproximação com polinômio de grau 3 Aproximação com polinômio de grau 4 y = x x x 3 y = x x x x 4 A última função (com termos até a quinta potência) é a que melhor se ajusta aos pontos experimentais. y = x x x x x 5

21 Programa: qsar1.py Usaremos o programa qsar1.py, as linhas de código estão no próximo slide. O gráfico gerado está na figura ao lado. O arquivo de entrada é o data2.csv. A equação polinomial está mostrada abaixo. Veja que o resultado está próximo ao obtido com o Mathematica para o polinômio de grau 5. Type CSV file name => data2.csv Type polynomial equation degree => 5 Best fit polynomial equation: x x x x e+05 x e+0 21

22 Programa: qsar1.py Abaixo temos a função main(). Inicialmente chamamos a função read_csv() que retorna as colunas lidas como array e o grau do polinômio a ser aproximado aos pontos experimentais. Em seguida é chamada a função lsq() que determina o polinômio. Por último, é chamada a função gen_plot() que gera o gráfico. def main(): # Call read_csv() x,y,my_deg = read_csv() # Call lsq() p = lsq(x,y,my_deg) # Call gen_plot() gen_plot(x,y,p) main() 22

23 Programa: qsar1.py Abaixo temos a função read_csv(), que retorna as duas colunas lidas do arquivo csv como arrays. Além do grau do polinômio. def read_csv(): """Function to read csv""" import numpy as np # Reads input file name and polynomial equation degree my_input_file = input("type CSV file name => ") my_deg = int(input("type polynomial equation degree => ")) # Reads CSV file my_csv = np.genfromtxt (my_input_file, delimiter=",", skip_header = 1) # Gets each column from CSV file x = my_csv[:,0] y = my_csv[:,1] return x,y,my_deg 23

24 Programa: qsar1.py Abaixo temos a função lsq() que determina os coeficientes do polinômio por meio do método de regressão. def lsq(x,y,my_deg): """Function to generate regression model""" import numpy as np # Least-squares polynomial fitting z = np.polyfit(x,y, my_deg) p = np.poly1d(z) print("\nbest fit polynomial equation: ",p) return p 24

25 Programa: qsar1.py Por último a função gen_plot() gera o gráfico da função. ddef gen_plot(x,y,p): """Function to generate plot""" import matplotlib.pyplot as plt # Generates plot plt.scatter(x,y) # Generates plot plt.plot(x, p(x), '-') # Shows plot plt.show() # Saves plot on png file plt.savefig('qsar1.png') 25

26 Programa: qsar2.py Vimos que o coeficiente de correlação ao quadrado (R 2 ) é usado para atestar a qualidade de um modelo obtido por regressão. A biblioteca NumPy tem a função np.corrcoef(x,y)[0,1], para o cálculo do coeficiente de correlação (R) entre os arrays x e y. A partir deste valor, basta elevarmos ao quadrado para obtermos R 2. O código qsar2.py traz esta função. Se usarmos o programa qsar2.py, com o arquivo data1.csv, podemos conferir com os resultados anteriormente determinados. O gráfico está ao lado. Os resultados estão no quadro abaixo. O código está no próximo slide, com as linhas em vermelho indicando as modificações com relação ao qsar1.py. Type CSV file name => data1.csv Type polynomial equation degree => 1 Best fit polynomial equation: 12.9 x , R^2 =

27 Programa: qsar2.py A única modificação no programa qsar2.py é na função lsq() que agora calcula o R 2, como destacado abaixo. def lsq(x,y,my_deg): """Function to generate regression model""" import numpy as np # Least-squares polynomial fitting z = np.polyfit(x,y, my_deg) p = np.poly1d(z) rsquare = (np.corrcoef(y,p(x))[0,1] )**2 print("\nbest fit polynomial equation: ",p,", R^2 = ",rsquare) return p 27

28 SciKit-Learn Já vimos programas que faziam uso de funções pré-definidas das bibliotecas NumPy e Matplotlib. Agora continuaremos a expandir nosso arsenal de bibliotecas, com alguns programas que usam recursos da biblioteca scikit-learn. Esta biblioteca é dedicada a disponibilizar para comunidade de programadores em Python ferramentas de aprendizado de máquina. Usaremos scikit-learn para resolver um problema simples e depois aplicaremos o que aprendemos para um problema para a previsão de atividade de uma série de fármacos contra câncer. Machine Learning is the study and design of programs that improve the performance of a task by learning from experience. It is the study of programs that learn from data. HACKELING G. Mastering Machine Learning with scikitlearn. Birmingham: Packt Publishing Ltd., p. Página de entrada do site scikit-learn.org. Acesso em 25 de novembro de

29 SciKit-Learn Vamos supor que você quer usar métodos de aprendizado de máquina para prever o preço de uma pizza. Você foi recentemente 5 vezes ao Blondie s Pizza e comprou pizzas de diferentes diâmetros, como detalhado na tabela abaixo. Índice do Dado do Conjunto Treino Diâmetro da Pizza (cm) Preço (R$) 1 15,0 24, ,0 31, ,0 45, ,0 61, ,0 63,00 29

30 SciKit-Learn (pizza1.py) Abaixo temos a função main() que evoca as funções read_csv() e gen_scatter_plot1(). Veja que a primeira função a ser evocada é a read_csv(), que retorna os arrays x e y que são passados como argumentos da função gen_scatter_plot1(). def main(): # Call read_csv() function x,y = read_csv() # Call gen_scatter_plot1() gen_scatter_plot1(x,y,"diameter (cm)","r$","pizza Price vs Diameter","pizza1.png") main() 30

31 SciKit-Learn (pizza1.py) Iremos gerar um gráfico de dispersão para os dados da tabela anterior (arquivo pizza1.csv) com os recursos da biblioteca Matplotlib. O programa pizza1.py tem duas funções, uma para leitura de um arquivo no formato CSV (read_csv()) e outra para o gráfico de dispersão dos pontos. Abaixo temos a função read_csv(). Nesta função importamos a biblioteca NumPy, em seguida lemos o nome do arquivo de entrada. Depois usamos o genfromtxt() para realizarmos a leitura de um arquivo no formato CSV. As colunas são atribuídas como arrays às variáveis x e y. Estes arrays retornam ao trecho onde a função foi evocada. def read_csv(): """Function to read a CSV file and return two columns""" import numpy as np # Reads input file name my_input_file = input("type CSV file name => ") # Reads CSV file my_csv = np.genfromtxt (my_input_file, delimiter=",", skip_header = 1) # Gets each column from CSV file x = my_csv[:,0] y = my_csv[:,1] return x,y 31

32 SciKit-Learn (pizza1.py) Abaixo temos a função gen_scatter_plot1(), que gera o gráfico de dispersão. Nesta função temos os recursos do Matplotlib vistos anteriormente. def gen_scatter_plot1(x,y,x_label,y_label,title,output_file): """Function to generate scatter plot""" import matplotlib.pyplot as plt # Generates plot plt.scatter(x,y) # Title plt.title(title) # X-axis label plt.xlabel(x_label) # Y-axis label plt.ylabel(y_label) # Grid plt.grid(true) # Shows plot plt.show() # Saves plot on png file plt.savefig(output_file) 32

33 SciKit-Learn (pizza1.py) Abaixo temos a execução do código pizza1.py, onde usamos o arquivo pizza1.csv como entrada. O programa gera o gráfico pizza1.png, também mostrado abaixo. Type CSV file name => pizza1.csv 33

34 SciKit-Learn (Regressão Linear Simples) Retornamos à tabela do arquivo pizza1.csv. Vamos supor que você queira saber, baseado nas informações da tabela abaixo, o preço de uma pizza com diâmetro de 30 cm. Índice do Dado do Diâmetro da Pizza (cm) Preço (R$) Conjunto Treino 1 15,0 24, ,0 31, ,0 45, ,0 61, ,0 63,00 Veja, não temos na tabela o diâmetro de 30 cm, mas podemos usar a informação conhecida, chamada de observações passadas, no jargão de aprendizado da máquina, para prever o preço de uma pizza com 30 cm de diâmetro. Para esta previsão, usaremos o método de regressão linear simples, onde as observações passadas serão usadas para elaborarmos um modelo (equação) para a previsão do preço. 34

35 SciKit-Learn (Regressão Linear Simples) Para nos familiarizarmos com a notação dos métodos de aprendizado de máquina, vamos definir os termos necessários para a elaboração do modelo de regressão linear. Variável explanatória Variável resposta Índice do Dado do Conjunto Treino Diâmetro da Pizza (cm) Preço (R$) 1 15,0 24, ,0 31, ,0 45, ,0 61, ,0 63,00 Conjunto treino A variável diâmetro é chamada variável explanatória e o preço correspondente é a variável resposta, os valores conhecidos destas variáveis compõem o conjunto treino (training data). O método de regressão é chamado de método de aprendizado supervisionado, visto que usamos as observações passadas, para obter um modelo contínuo entre variável resposta e a variável explanatória. 35

36 SciKit-Learn (Regressão Linear Simples) Vimos a função polyfit() da biblioteca NumPy para realizar a regressão linear. Na biblioteca SciKit-learn temos o método linear_model.linearregression(). Vamos ilustrar seu uso no programa pizza2.py. Mas antes de iniciarmos o código, devemos fazer algumas considerações sobre o uso de métodos das bibliotecas do Python. Essas bibliotecas facilitam a vida do programador, pois disponibilizam métodos sofisticados, prontos para uso. Por outro lado, temos que estar atentos à estrutura dos dados que são inseridos nos métodos. No nosso exemplo do preço da pizza, se colocarmos um print() para os arrays x e y, que retornam da função read_csv(), teremos o seguinte resultado. [ ] [ ] O que funcionou bem quando foram passados para a função gen_scatter_plot1(). Por outro lado, para usarmos o método linear_model.linearregression(), temos que ter os arrays na seguinte estrutura. [[15.0], [20.0], [25.0], [35.0], [45.0]] [[24.5], [31.5], [45.5], [61.25], [63.0]] Assim, temos que converter os arrays para a estrutura acima, caso contrário teremos uma mensagem de erro ao executar o código. 36

37 SciKit-Learn (Regressão Linear Simples) (pizza2.py) O programa pizza2.py tem uma função para converter os arrays, chamada convert2scikit(). O código está mostrado abaixo. O que a função faz é basicamente receber um array x e convertê-lo num array de arrays. Para isto a função varre o array de entrada e atribui o elemento do array a uma lista (list0) que então é passada para o array de arrays (X). A função retorna o array modificado. def convert2scikit(x): """Function to convert array to scikit-learn format""" # Set up empty lists X = [] list0 = [] # Looping through x for line in x: # Converts element to list list0.append(line) # Append list to list X.append(list0) list0 = [] # Return new array return X 37

38 SciKit-Learn (Regressão Linear Simples) (pizza2.py) Para geramos o modelo, usamos a função simple_linear_regression1(). Os arrays x_in e y_in são os parâmetros da função. Explicaremos cada linha. Inicialmente importamos o método linear_model da biblioteca simple_linear_regression1. Também importamos a biblioteca NumPy, ambas indicadas em vermelho abaixo. def simple_linear_regression1(x_in,y_in): """Function to generate a linear regression model for one explanatory variable and their response variable. This function uses sklearn.linear_model.linearregression method.""" # Import library from sklearn import linear_model import numpy as np # Create and fit the model model = linear_model.linearregression() model.fit(x_in, y_in) # Get Linear Model alpha1 = float(model.coef_) const = float(model.intercept_) z = np.array([alpha1,const]) p = np.poly1d(z) A classe sklearn import linear_model é um estimador, que é usado para prever um valor, baseado em dados observados. print("\nbest fit linear regression model: ",p) return p 38

39 SciKit-Learn (Regressão Linear Simples) (pizza2.py) Para criarmos o modelo de regressão linear (model), usamos o comando model = linear_model.linearregression(), que permite que usemos o método para regressão linear, chamado.fit(), como indicado abaixo. O método.fit() ajusta uma reta com equação y = const + alpha1.x aos pontos do conjunto treino. def simple_linear_regression1(x_in,y_in): """Function to generate a linear regression model for one explanatory variable and their response variable. This function uses sklearn.linear_model.linearregression method.""" # Import library from sklearn import linear_model import numpy as np # Create and fit the model model = linear_model.linearregression() model.fit(x_in, y_in) # Get Linear Model alpha1 = float(model.coef_) const = float(model.intercept_) z = np.array([alpha1,const]) p = np.poly1d(z) print("\nbest fit linear regression model: ",p) return p 39

40 SciKit-Learn (Regressão Linear Simples) (pizza2.py) A constante da reta pode ser obtida a partir do comando const = float(model.intercept_) e o coeficiente angular pode ser determinado a partir do comando, alpha1 = float(model.coef_), como indicado abaixo. def simple_linear_regression1(x_in,y_in): """Function to generate a linear regression model for one explanatory variable and their response variable. This function uses sklearn.linear_model.linearregression method.""" # Import library from sklearn import linear_model import numpy as np # Create and fit the model model = linear_model.linearregression() model.fit(x_in, y_in) # Get Linear Model alpha1 = float(model.coef_) const = float(model.intercept_) z = np.array([alpha1,const]) p = np.poly1d(z) print("\nbest fit linear regression model: ",p) return p 40

41 SciKit-Learn (Regressão Linear Simples) (pizza2.py) A seguir montamos um array com a constante e coeficiente angular, com o comando, z = np.array([alpha1,const]). O array z é usado para gerar a equação da reta, com o comando p = np.poly1d(z). Por último, a equação da reta de regressão linear é mostrada na tela e retornamos o p para o programa principal. def simple_linear_regression1(x_in,y_in): """Function to generate a linear regression model for one explanatory variable and their response variable. This function uses sklearn.linear_model.linearregression method.""" # Import library from sklearn import linear_model import numpy as np # Create and fit the model model = linear_model.linearregression() model.fit(x_in, y_in) # Get Linear Model alpha1 = float(model.coef_) const = float(model.intercept_) z = np.array([alpha1,const]) p = np.poly1d(z) print("\nbest fit linear regression model: ",p) return p 41

42 SciKit-Learn (Regressão Linear Simples) (pizza2.py) A função gen_scatter_plot2() traz como novidade a inclusão da equação da reta p como parâmetro e uma linha de código para incluir a reta no gráfico, destacada em vermelho no código abaixo. O restante do código é o mesmo da função gen_scatter_plot1(), vista no programa pizza1.py. def gen_scatter_plot2(x,y,p,x_label,y_label,title,output_file): """Function to generate scatter plot""" import matplotlib.pyplot as plt # Generates plot plt.scatter(x,y) # Title plt.title(title) # X-axis label plt.xlabel(x_label) # Y-axis label plt.ylabel(y_label) # Grid plt.grid(true) # Generates plot plt.plot(x, p(x), '-') # Shows plot plt.show() # Saves plot on png file plt.savefig(output_file) Gera o gráfico da reta 42

43 SciKit-Learn (Regressão Linear Simples) (pizza2.py) A função main() evoca duas vezes a função convert2scikit(), em seguida evocamos a função simple_linear_regression1(). Depois mostramos o valor previsto para preço da pizza de 30 cm e, por ultimo, chamamos a função gen_scatter_plot2() para gerarmos o gráfico. def main(): # Call read_csv() function x,y = read_csv() # Call convert2scikit(x) xs = convert2scikit(x) ys = convert2scikit(y) # Call simple_linear_regression1() p = simple_linear_regression1(xs,ys) # Predict the price for 30 cm pizza pred = p(30) print("predicted price for 30 cm pizza (R$): %.2f"%pred) # Call gen_scatter_plot2() gen_scatter_plot2(x,y,p,"diameter (cm)","r$","pizza Price vs Diameter","pizza2.png main() 43

44 SciKit-Learn (Regressão Linear Simples) (pizza2.py) Vejam que ao usarmos a linha de comando pred = p(30) colocamos como argumento da equação p o valor 30. A equação p é a equação obtida por regressão linear, quando evocamos a função simple_linear_regression1(). def main(): # Call read_csv() function x,y = read_csv() # Call convert2scikit(x) xs = convert2scikit(x) ys = convert2scikit(y) # Call simple_linear_regression1() p = simple_linear_regression1(xs,ys) # Predict the price for 30 cm pizza pred = p(30) print("predicted price for 30 cm pizza (R$): %.2f"%pred) # Call gen_scatter_plot2() gen_scatter_plot2(x,y,p,"diameter (cm)","r$","pizza Price vs Diameter","pizza2.png main() 44

45 SciKit-Learn (pizza2.py) Abaixo temos a execução do código pizza2.py, onde usamos o arquivo pizza1.csv como entrada. O programa gera o gráfico pizza2.png, também mostrado abaixo. A linha azul do gráfico é a equação obtida por regressão linear. Type CSV file name => pizza1.csv Best fit linear regression model: x Predicted price for 30 cm pizza (R$):

46 SciKit-Learn (pizza2.py) De forma resumida, podemos dizer que a melhor reta é aquela que minimiza a distância dos pontos experimentais (dados do conjunto treino) para a reta. Matematicamente, a equação da reta (p) tem a seguinte forma: 0 1x1 Onde p tem o valor estimado (teórico) para o preço da pizza e x 1 recebe o valor do diâmetro da pizza( variável explanatória). Os coeficientes ( 0 e 1 ) são determinados de forma minimizar a diferença entre p e os valores experimentais do preço da pizza (y i ), ou seja, minimizam a soma do quadrado dos resíduos (Residual Sum of Squares): RSS A somatória é feita para todos os pontos do conjunto treino. p N y i p i i1 2 46

47 SciKit-Learn (Regressão Linear Simples) (pizza3.py) Muito bem, temos um modelo para previsão do preço da pizza, mas o quão confiável é nosso modelo? Vamos supor que vimos um anuncio da Blondie s pizza com a seguinte tabela de preços (pizza2.csv). Esta informação não foi usada para obtermos o modelo de regressão, tal conjunto de dados é chamado de conjunto teste (test set). Adicionamos uma coluna com os valores previstos pelo nosso modelo. O conjunto teste pode ser usado para avaliar o poder de previsão do nosso modelo. Índice do Dado do Conjunto Test Diâmetro da Pizza (cm) Preço (R$) 1 20,0 38,50 34, ,5 29,75 37, ,5 52,50 44, ,0 63,00 61, ,0 38,50 47,88 Preço Previsto pelo Modelo (R$) 47

48 Quantitative Structure Activity Relationship Para acessar a qualidade do modelo de regressão, ou seja, a qualidade do ajuste da curva (ou reta) modelada, contra os pontos experimentais (y i ), podemos calcular o coeficiente r 2. Considere que p i são valores calculados a partir da equação de regressão, usando observações experimentais x i. Assim temos os seguintes termos: soma total dos quadrados (Total Sum of Squares, TSS), soma dos quadrados explicada (Explained Sum of Squares, ESS) e soma residual dos quadrados (Residual Sum of Squares): TSS N 2 y i p ESS p i p i1 N i1 2 RSS N y i p i i1 2 O termo <p> representa o valor médio do preço da pizza estimado pela equação de regressão linear (p). O termo y i representa o valor do preço (experimental) da pizza para os diferentes diâmetros. Os termos acima são usados para o cálculo de R 2, como segue: R 2 1 RSS TSS

49 SciKit-Learn (Regressão Linear Simples) (pizza3.py) Modificaremos a função simple_linear_regression1() para que esta calcule o R 2 no programa pizza3.py. O programa pizza3.py lerá os dados dos conjuntos treino (pizza1.csv) e teste (pizza2.csv). Índice do Dado do Conjunto Test Diâmetro da Pizza (cm) Preço (R$) 1 20,0 38,50 34, ,5 29,75 37, ,5 52,50 44, ,0 63,00 61, ,0 38,50 47,88 Preço Previsto pelo Modelo (R$) 49

50 SciKit-Learn (Regressão Linear Simples) (pizza3.py) A função simple_linear_regression2() tem quatro parâmetros, além dos dois anteriores (x_in,y_in), com os dados do conjunto treino, temos dois novos arrays para os dados do conjunto teste (parâmetros x_test e y_test). def simple_linear_regression2(x_in,y_in,x_test,y_test): """Function to generate a linear regression model for one explanatory variable and their response variable. This function uses sklearn.linear_model.linearregression method.""" # Import library from sklearn import linear_model import numpy as np # Create and fit the model model = linear_model.linearregression() model.fit(x_in, y_in) # Get Linear Model alpha1 = float(model.coef_) const = float(model.intercept_) z = np.array([alpha1,const]) p = np.poly1d(z) r_square = model.score(x_test, y_test) print("\nbest fit linear regression model: ",p) print('r-squared: %.4f' % r_square) return p 50

51 SciKit-Learn (Regressão Linear Simples) (pizza3.py) A outra novidade é o método.score(), que é usado para calcular o R 2 que é atribuído à variável r_square. O resultado é mostrado na tela. def simple_linear_regression2(x_in,y_in,x_test,y_test): """Function to generate a linear regression model for one explanatory variable and their response variable. This function uses sklearn.linear_model.linearregression method.""" # Import library from sklearn import linear_model import numpy as np # Create and fit the model model = linear_model.linearregression() model.fit(x_in, y_in) # Get Linear Model alpha1 = float(model.coef_) const = float(model.intercept_) z = np.array([alpha1,const]) p = np.poly1d(z) r_square = model.score(x_test, y_test) print("\nbest fit linear regression model: ",p) print('r-squared: %.4f' % r_square) return p 51

52 SciKit-Learn (Regressão Linear Simples) (pizza3.py) No programa principal (função main()) temos que evocar duas vezes a leitura dos arquivos CSV (função read_csv()) além das respectivas conversões, como destacado em vermelho abaixo. def main(): # Call read_csv() function x1,y1 = read_csv() # Call convert2scikit() xs1 = convert2scikit(x1) ys1 = convert2scikit(y1) # Call read_csv() function again x2,y2 = read_csv() # Call convert2scikit(x) again xs2 = convert2scikit(x2) ys2 = convert2scikit(y2) # Call simple_linear_regression2() p = simple_linear_regression2(xs1,ys1,xs2,ys2) # Call gen_scatter_plot2() gen_scatter_plot2(xs1,ys1,p,"diameter (cm)","r$","pizza Price vs Diameter","pizza3.png") main() 52

53 SciKit-Learn (Regressão Linear Simples) (pizza3.py) Abaixo temos o resultado de rodar o programa pizza3.py, veja que temos dois arquivos de entrada. Type CSV file name => pizza1.csv Type CSV file name => pizza2.csv Best fit linear regression model: x R-squared:

54 SciKit-Learn (Regressão Linear Múltipla) Muito bem, evoluímos com nosso modelo para previsão do preço das pizzas. Mas se refletimos sobre a qualidade do nosso modelo, podemos imaginar que temos como melhoras. Qualquer apreciador de pizza sabe que um dos determinantes do preço da pizza é o número de coberturas. Assim podemos adicionar esta nova variável explanatória ao nosso modelo. Assim, a equação de regressão passa a ter múltiplas varáveis, um caso geral a equação tem a seguinte forma, p x x x M x M Onde M é o número de variáveis explanatórias. Quando usamos a equação acima para obtermos um modelo estamos usando o método de regressão linear múltipla. No nosso novo modelo para previsão do preço das pizzas adicionamos uma variável explanatória, assim a equação tem a seguinte forma, p 0 1x1 2x2 54

55 SciKit-Learn (Regressão Linear Múltipla) Retornamos às tabelas de preço, só que agora temos uma informação adicional, com o número de coberturas para o conjunto treino. Índice do Dado do Conjunto Treino Diâmetro da Pizza (cm) Número de Coberturas Preço (R$) 1 15,0 2 24, ,0 1 31, ,0 0 45, ,0 2 61, ,0 0 63,00 A nova coluna é a variável explanatória x 2. 55

56 SciKit-Learn (Regressão Linear Múltipla) Abaixo temos a tabela para o conjunto teste Índice do Dado do Conjunto Teste Diâmetro da Pizza (cm) Número de Coberturas Preço (R$) 1 20,0 2 38, ,5 0 29, ,5 2 52, ,0 2 63, ,0 0 38,50 A nova coluna é a variável explanatória x 2. 56

57 SciKit-Learn (Regressão Linear Simples) (pizza4.py) Para simplificar a apresentação vamos elaborar um código para gerar o modelo de regressão múltipla e prever o preço da pizza de 40 cm. O código da função main() segue abaixo. def main(): # Call read_csv_3cols() function x1,x2,y1 = read_csv_3cols() # Call convert2scikit() ytr = convert2scikit(y1) # Call make_2d_array() Xtr = make_2d_array(x1,x2) # Call read_csv_3cols() function again x1,x2,y2 = read_csv_3cols() # Call convert2scikit(x) again yte = convert2scikit(y2) # Call make_2d_array() Xte = make_2d_array(x1,x2) # Call multiple_linear_regression() p = multiple_linear_regression(xtr,ytr,xte,yte) # Prediction of the price for 40 cm pizza y = p[0] + p[1]*2.0 + p[2]*40.0 print("\npredicted price for 40 cm pizza: %6.2f"%y) main() 57

58 SciKit-Learn (Regressão Linear Simples) (pizza4.py) A principal novidade é que temos que converter as duas colunas com as variáveis explanatórias (diâmetro e número de coberturas) num array bidimensional, ou seja, uma matriz. Usaremos a função make_2d_array(). def main(): # Call read_csv_3cols() function x1,x2,y1 = read_csv_3cols() # Call convert2scikit() ytr = convert2scikit(y1) # Call make_2d_array() Xtr = make_2d_array(x1,x2) # Call read_csv_3cols() function again x1,x2,y2 = read_csv_3cols() # Call convert2scikit(x) again yte = convert2scikit(y2) # Call make_2d_array() Xte = make_2d_array(x1,x2) # Call multiple_linear_regression() p = multiple_linear_regression(xtr,ytr,xte,yte) # Prediction of the price for 40 cm pizza y = p[0] + p[1]*2.0 + p[2]*40.0 print("\npredicted price for 40 cm pizza: %6.2f"%y) main() 58

59 SciKit-Learn (Regressão Linear Simples) (pizza4.py) Inicialmente é evocada a função read_csv_3cols() que é similar à read_csv() só que agora retornamos três arrays, que são atribuídos às variáveis x1,x2, y1. def main(): # Call read_csv_3cols() function x1,x2,y1 = read_csv_3cols() # Call convert2scikit() ytr = convert2scikit(y1) # Call make_2d_array() Xtr = make_2d_array(x1,x2) # Call read_csv_3cols() function again x1,x2,y2 = read_csv_3cols() # Call convert2scikit(x) again yte = convert2scikit(y2) # Call make_2d_array() Xte = make_2d_array(x1,x2) # Call multiple_linear_regression() p = multiple_linear_regression(xtr,ytr,xte,yte) # Prediction of the price for 40 cm pizza y = p[0] + p[1]*2.0 + p[2]*40.0 print("\npredicted price for 40 cm pizza: %6.2f"%y) main() 59

60 SciKit-Learn (Regressão Linear Simples) (pizza4.py) Em seguida convertermos a variável resposta para que possa ser lida pelo scikitlearn. def main(): # Call read_csv_3cols() function x1,x2,y1 = read_csv_3cols() # Call convert2scikit() ytr = convert2scikit(y1) # Call make_2d_array() Xtr = make_2d_array(x1,x2) # Call read_csv_3cols() function again x1,x2,y2 = read_csv_3cols() # Call convert2scikit(x) again yte = convert2scikit(y2) # Call make_2d_array() Xte = make_2d_array(x1,x2) # Call multiple_linear_regression() p = multiple_linear_regression(xtr,ytr,xte,yte) # Prediction of the price for 40 cm pizza y = p[0] + p[1]*2.0 + p[2]*40.0 print("\npredicted price for 40 cm pizza: %6.2f"%y) main() 60

61 SciKit-Learn (Regressão Linear Simples) (pizza4.py) A função make_2d_array() tem como argumentos os array lidos e converte estes numa matriz, que é atribuída à variável Xtr. Até então só lemos os dados do conjunto treino (ytr e Xtr). def main(): # Call read_csv_3cols() function x1,x2,y1 = read_csv_3cols() # Call convert2scikit() ytr = convert2scikit(y1) # Call make_2d_array() Xtr = make_2d_array(x1,x2) # Call read_csv_3cols() function again x1,x2,y2 = read_csv_3cols() # Call convert2scikit(x) again yte = convert2scikit(y2) # Call make_2d_array() Xte = make_2d_array(x1,x2) # Call multiple_linear_regression() p = multiple_linear_regression(xtr,ytr,xte,yte) # Prediction of the price for 40 cm pizza y = p[0] + p[1]*2.0 + p[2]*40.0 print("\npredicted price for 40 cm pizza: %6.2f"%y) main() 61

62 SciKit-Learn (Regressão Linear Simples) (pizza4.py) As linhas seguintes fazem a leitura e conversão dos dados do conjunto treino. Em seguida é chamada a função multiple_linear_regression() que recebe as matrizes Xtr e Xte. def main(): # Call read_csv_3cols() function x1,x2,y1 = read_csv_3cols() # Call convert2scikit() ytr = convert2scikit(y1) # Call make_2d_array() Xtr = make_2d_array(x1,x2) # Call read_csv_3cols() function again x1,x2,y2 = read_csv_3cols() # Call convert2scikit(x) again yte = convert2scikit(y2) # Call make_2d_array() Xte = make_2d_array(x1,x2) # Call multiple_linear_regression() p = multiple_linear_regression(xtr,ytr,xte,yte) # Prediction of the price for 40 cm pizza y = p[0] + p[1]*2.0 + p[2]*40.0 print("\npredicted price for 40 cm pizza: %6.2f"%y) main() 62

63 SciKit-Learn (Regressão Linear Simples) (pizza4.py) Por último usamos o polinômio determinado, para obtermos uma estimativa do preço da pizza de 40 cm com duas coberturas. def main(): # Call read_csv_3cols() function x1,x2,y1 = read_csv_3cols() # Call convert2scikit() ytr = convert2scikit(y1) # Call make_2d_array() Xtr = make_2d_array(x1,x2) # Call read_csv_3cols() function again x1,x2,y2 = read_csv_3cols() # Call convert2scikit(x) again yte = convert2scikit(y2) # Call make_2d_array() Xte = make_2d_array(x1,x2) # Call multiple_linear_regression() p = multiple_linear_regression(xtr,ytr,xte,yte) # Prediction of the price for 40 cm pizza y = p[0] + p[1]*2.0 + p[2]*40.0 print("\npredicted price for 40 cm pizza: %6.2f"%y) main() 63

64 SciKit-Learn (Regressão Linear Simples) (pizza4.py) A única função nova é a make_2d_array(), mostrada abaixo. A novidade aqui é que geramos uma matriz de zeros. Em seguida temos um loop for que atribui os elementos dos vetores aos elementos da matrix. def make_2d_array(x1,x2): """Function to make 2-d array""" import numpy as np # Set up number of columns and rows number_columns = 2 number_rows = len(x1) # Set up zero matrix X= [[0]*number_columns for i in range(number_rows)] # Get matrix for i in range(number_rows): X[i][0] = x1[i] X[i][1] = x2[i] return X 64

65 SciKit-Learn (Regressão Linear Simples) (pizza3.py) Abaixo temos o resultado de rodar o programa pizza4.py, veja que temos dois arquivos de entrada. Type CSV file name => pizza3.csv Type CSV file name => pizza4.csv Best fit linear regression model: x x R-squared: Predicted price for 40 cm pizza: Veja Índice que do houve Dado do uma Diâmetro melhora da no Pizza modelo, (cm) o Número R 2 foi de de 0,66 para 0,77. Preço (R$) Conjunto Teste Coberturas 1 20,0 2 38, ,5 0 29, ,5 2 52, ,0 2 63, ,0 0 38,50 65

66 Métodos de Aprendizado de Máquina Supervisionado Vimos a aplicação do método de regressão linear para a elaboração de um modelo, a partir dos dados do conjunto treino. A biblioteca scikit-learn tem um arsenal de métodos de aprendizado de máquina supervisionado, além da regressão linear. Abaixo temos seis métodos disponíveis no scikit-learn. Esses métodos adicionais visam reduzir o número de variáveis explanatórias no modelo de regressão. A tabela verdade abaixo traz a identificação de cada termo com o respectivo peso do termo adicional somado ao RSS. RSS N P P 2 y i y calc i 11 j 22 2, j i1 j1 j1 Método α 1 α 2 Linear Regression 0 0 Ridge 0 1 Ridge CV 0 1 Lasso 1 0 Lasso CV 1 0 Elastic Net 1 1 Elastic Net CV

67 Modelagem de Sistemas (CDKs com K i ) Para discutirmos os principais métodos para melhora de funções escores com métodos de aprendizado de máquina supervisionado, iremos considerar como sistema biológico uma proteína chamada quinase dependente de ciclina (CDKs) com informação de K i (constante de inibição). Moléculas que se ligam à CDK tem o potencial de serem usadas como drogas contra o câncer. 67

68 Modelagem de Sistemas (CDKs com K i ) Abaixo temos uma tabela com informações para 30 estruturas de CDKs para as quais há informação de K i. Iremos considerar somente três variáveis explanatórias, Protein Score, Water Score e Electro Long Score. A variável log(ki) é a variável resposta. 68

69 CDKs com K i (Regressão Linear) Usaremos um programa que é parte integrante do SAnDReS (Xavier et al., 2016). O programa chamado sml15.py chama um módulo (scikit_regression_methods_v001z_works.py). Nos concentraremos no seu uso. Abaixo temos o trecho do programa principal que faz a leitura do arquivo CSV e indica o método de regressão linear. def main(): # Get the CSV file name, we the following file to be used as imput: # Verma_Hansch_EJMC_2010_Table1.csv # Verma_Hansch_EJMC_2010_Table2.csv # Verma_Hansch_EJMC_2010_Table3.csv # cdk_ki.csv # data01_19col.csv csv_file = "cdk_ki.csv" # Call get_number_of_cols() n_columns = get_number_of_cols(csv_file) # Call generate_loo_files() generate_loo_files(csv_file,n_columns) main() # Call SF() SF(csv_file,n_columns-1,"ElasticNetCV") 69

70 CDKs com K i (Regressão Linear) Na função main() inicialmente definimos o nome do arquivo CSV que tem as variáveis explanatórias e a variável resposta (log(ki)), indicada em vermelho. def main(): # Get the CSV file name, we the following file to be used as imput: # Verma_Hansch_EJMC_2010_Table1.csv # Verma_Hansch_EJMC_2010_Table2.csv # Verma_Hansch_EJMC_2010_Table3.csv # cdk_ki.csv # data01_19col.csv csv_file = "cdk_ki.csv" # Call get_number_of_cols() n_columns = get_number_of_cols(csv_file) # Call generate_loo_files() generate_loo_files(csv_file,n_columns) main() # Call SF() SF(csv_file,n_columns-1,"ElasticNetCV") 70

71 CDKs com K i (Regressão Linear) Em seguida é chamada a função get_number_of_cols() que determina o número de colunas do arquivo CSV. def main(): # Get the CSV file name, we the following file to be used as imput: # Verma_Hansch_EJMC_2010_Table1.csv # Verma_Hansch_EJMC_2010_Table2.csv # Verma_Hansch_EJMC_2010_Table3.csv # cdk_ki.csv # data01_19col.csv csv_file = "cdk_ki.csv" # Call get_number_of_cols() n_columns = get_number_of_cols(csv_file) # Call generate_loo_files() generate_loo_files(csv_file,n_columns) main() # Call SF() SF(csv_file,n_columns-1,"ElasticNetCV") 71

72 CDKs com K i (Regressão Linear) Depois é chamada a função generate_loo_files(), que gera arquivos CSV auxiliares com uma estrutura deixada fora (leave one out)(loo). Tal abordagem visa verificar a consistência interna do modelo de regressão linear gerado, onde uma linha de dado é deixada de fora para cada iteração da determinação dos pesos das variáveis explanatórias. def main(): # Get the CSV file name, we the following file to be used as imput: # Verma_Hansch_EJMC_2010_Table1.csv # Verma_Hansch_EJMC_2010_Table2.csv # Verma_Hansch_EJMC_2010_Table3.csv # cdk_ki.csv # data01_19col.csv csv_file = "cdk_ki.csv" # Call get_number_of_cols() n_columns = get_number_of_cols(csv_file) # Call generate_loo_files() generate_loo_files(csv_file,n_columns) main() # Call SF() SF(csv_file,n_columns-1,"ElasticNetCV") 72

73 CDKs com K i (Regressão Linear) A última função chamada é a SF() que determina o modelo de regressão linear. Um dos argumentos passado é o método de regressão a ser usado, no caso abaixo LinearRegression. Além deste, o programa pode testar: Lasso, LassoCV, Ridge, RidgeCV, ElasticNet e ElasticNetCV def main(): # Get the CSV file name, we the following file to be used as imput: # Verma_Hansch_EJMC_2010_Table1.csv # Verma_Hansch_EJMC_2010_Table2.csv # Verma_Hansch_EJMC_2010_Table3.csv # cdk_ki.csv # data01_19col.csv csv_file = "cdk_ki.csv" # Call get_number_of_cols() n_columns = get_number_of_cols(csv_file) # Call generate_loo_files() generate_loo_files(csv_file,n_columns) main() # Call SF() SF(csv_file,n_columns-1, LinearRegression") 73

74 CDKs com K i (Regressão Linear) Como já vimos, o método LinearRegression determina os pesos de cada variável explanatória onde x 1 é o Protein Score, x 2 o Water Score e x 3 o Electro Long Score. log( K i ) 0 1. x1 2. x2 3. x 3 def main(): # Get the CSV file name, we the following file to be used as imput: # Verma_Hansch_EJMC_2010_Table1.csv # Verma_Hansch_EJMC_2010_Table2.csv # Verma_Hansch_EJMC_2010_Table3.csv # cdk_ki.csv # data01_19col.csv csv_file = "cdk_ki.csv" # Call get_number_of_cols() n_columns = get_number_of_cols(csv_file) # Call generate_loo_files() generate_loo_files(csv_file,n_columns) main() # Call SF() SF(csv_file,n_columns-1, LinearRegression") 74