0:00:00: Hoje você vai aprender a criar uma regressão linear usando Python.

0:00:04: E eu vou te mostrar duas maneiras.

0:00:06: A primeira maneira vai ser usando uma biblioteca chamada StatsModels.

0:00:11: E ela é mais interessante se você estiver querendo entender de um ponto de vista mais estatístico.

0:00:17: Como é que o seu modelo explica os dados.

0:00:19: Então você vai ter dados estatísticos, pi velho dos coeficientes e tudo mais.

0:00:24: Mais importante se você quiser fazer uma análise estatística da estimação desse modelo nos seus dados.

0:00:32: E eu também vou te mostrar uma maneira usando Scikit-Learn.

0:00:36: Que aí é mais para machine learning, para uma análise mais preditiva.

0:00:40: Então para você não se preocupar tanto com a qualidade do fit desse modelo.

0:00:45: O quão bem esse modelo fita os seus dados de treino.

0:00:48: Os dados que você está usando ali para criar o modelo.

0:00:51: Mas na qualidade das previsões em dados que ele nunca viu.

0:00:55: Vamos começar então. Vou usar o Google Collab.

0:00:57: Eu ainda não selecionei os dados.

0:01:00: Então vamos ver qual é a sample data que ele tem aqui.

0:01:03: Ele tem esse California Housing.

0:01:04: Vamos ver como é que é esses dados aqui.

0:01:07: Se a gente pode usar para esse tipo de trabalho.

0:01:12: Então eu sempre gosto de importar o Pandas e o NumPy.

0:01:15: Vamos pegar aqui data igual pd.read.csv.

0:01:19: E vamos pegar o California Housing.

0:01:22: Primeiro eu preciso selecionar aqui a pasta certa.

0:01:26: Então.-sample data.

0:01:28: Vamos ver se ele autocompleta para mim.

0:01:31: Provavelmente tem uma forma de autocompletar que eu me esqueci completamente.

0:01:34: Como é que faz aqui no nosso querido Google Collab.

0:01:37: Então vamos carregar diretamente esse arquivo.

0:01:41: Não estou muito preocupado com quais dados eu vou usar.

0:01:44: Porque a ideia aqui é mostrar como você gera o modelo.

0:01:47: Em vez de ficar te mostrando alguma coisa dos próprios dados.

0:01:52: Legal.

0:01:53: A ideia aqui é que a gente use essas primeiras colunas.

0:01:58: Latitude, longitude, idade da casa, número de quartos, etc.

0:02:02: Provavelmente isso aqui não é o número de quartos.

0:02:04: Porque se não essa casa seria 5.000 quartos.

0:02:06: Provavelmente é o número de pés quadrados que dá a área dos quartos e tudo mais.

0:02:11: E a gente não se importa muito nesse momento com essas features, com o que elas significam.

0:02:18: Mas a gente vai prever o median house value.

0:02:22: Então como é que a gente faz isso?

0:02:23: Primeiro com o stats models.

0:02:25: Então vamos colocar aqui.

0:02:26: Stats models.

0:02:27: Mais texto, jogar para cima e aqui que eu tenho que colocar.

0:02:31: Stats models.

0:02:32: Olha só que bonito.

0:02:33: Então vamos lá.

0:02:34: O stats models já deve estar instalado ali no Google Collab.

0:02:38: Então eu vou deixar o link aí também se você quiser instalar no seu computador.

0:02:42: E eu vou pegar aqui o User Guide.

0:02:46: Linear regression.

0:02:47: Se você já usou R e você está querendo mudar para a melhor linguagem que é o Python.

0:02:53: Você vai reconhecer o formato do sumário aqui.

0:02:58: Acho que no SASS também deve ser assim.

0:02:59: Eu nunca usei SASS, eu não sei.

0:03:01: Mas basicamente ele fala para a gente que a gente tem que importar desse statsmodels.api.

0:03:08: O objeto, a API do statsmodels como SM para a gente não ter que ficar escrevendo isso

0:03:12: toda hora.

0:03:13: E pelo visto ele já está instalado aqui.

0:03:16: Se não tivesse só vou dar um pip install que ele já instala.

0:03:19: Como você pode ver também ele tem vários modelos aqui lineares que você pode usar.

0:03:25: Mas aqui eu vou usar o mais básico que é o de regressão linear.

0:03:28: E aí o que ele exige da gente?

0:03:31: A gente vai fazer o OLS.

0:03:33: Ordinary List Squares.

0:03:34: A nossa regressão clássica.

0:03:39: Então vamos colocar aqui modelo, modneck ele usa mais modelo.

0:03:43: sm.ols como primeiro argumento.

0:03:47: Na verdade o endógeno é o y pelo que eu estou vendo aqui.

0:03:51: Então a variável dependente, me desculpem por esse erro.

0:03:55: Então o x vai ser o exógeno.

0:03:57: Então o exógeno tem o x aqui, o endógeno é o que geralmente você vê aqui no canal

0:04:01: falando como o y.

0:04:03: Então primeiro aqui a gente coloca o nosso y.

0:04:08: Nosso y nesse caso será data median house value.

0:04:17: E eu já vou falar de normalização também porque seria interessante normalizar isso

0:04:21: aqui porque como você pode ver como não estão nos mesmos, como a escala das variáveis

0:04:28: dos valores aqui não está no mesmo.

0:04:30: Por exemplo a idade provavelmente da casa vai chegar a 100 em alguns anos enquanto

0:04:34: o número de quartos aqui, a medida dos quartos vai passar de 5 mil, 7 mil.

0:04:39: Então ali não vai funcionar muito bem para a gente ver os coeficientes num primeiro

0:04:44: momento se a gente não normalizar.

0:04:46: Mas por enquanto eu vou só colocar aqui, só preencher os valores e o resto eu vou

0:04:51: colocar, criar uma variável com o nome da casa median.

0:04:58: Deixa eu respirar, eu vou criar uma variável com o nome da variável que a gente está

0:05:02: tentando prever.

0:05:03: Então esta variável tem esse nome, essa string que é o nome da coluna que a gente

0:05:09: está tentando prever.

0:05:11: Então data y e aqui eu vou criar data.drop y.

0:05:17: E tem que ser uma lista né, então vamos colocar entre colchetes o nosso y, axis igual 1 porque

0:05:24: ai ele vai pegar esse data frame original nosso e ele vai nos dar todas as colunas menos

0:05:33: a coluna que a gente indicou que é o nosso y.

0:05:36: Ele não rodou ali porque eu não tinha rodado a célula ainda que colocava essa variável

0:05:42: y.

0:05:43: Então você pode ver quando a gente visualiza esse data.drop ele tem todas as colunas menos

0:05:48: o median house value.

0:05:50: Legal.

0:05:52: Vamos então fazer o seguinte agora aqui.

0:05:56: Data.drop e vamos ver qual seria o resultado se a gente fizesse ele sem a normalização

0:06:00: das variáveis, sem o scaling e tudo mais.

0:06:03: Ele fala para a gente vir aqui mod.fit res igual mod.fit, então res igual modelo.fit

0:06:11: e precisa passar alguma coisa para o fit?

0:06:13: Não, legal.

0:06:14: Ele vai provavelmente armazenar o resultado aqui nessa res.

0:06:17: Então res.summary dá esse monte de informações dessa forma razoavelmente bonitinha para

0:06:26: a gente né, aqui no colab parece que ele deu uma bagunçada nos coeficientes e tudo

0:06:30: mais mas basicamente como é que a gente faz?

0:06:33: Ele dá o r squared né, o r quadrado aqui para a gente ajustado etc e tal, todas aquelas

0:06:42: métricas que a gente aprende quando estuda estatística deu p-value para a gente.

0:06:48: Tudo aqui parece que está significativo logicamente esse é um dataset já bastante conhecido e

0:06:53: certamente já foi muito filtrado.

0:06:56: Ele dá todas essas outras variáveis.

0:07:00: Então deixa eu ver qual seria o resultado disso aqui se eu normalizar os dados originais.

0:07:05: Então vamos colocar aqui normalized data.

0:07:10: E o que eu vou fazer aqui?

0:07:12: Eu vou pegar só o data drop, vou chamar de x, é bom que a gente já vai poder usar para

0:07:19: a parte do scikit-learn então vou chamar de x e eu vou usar um objeto do scikit-learn

0:07:23: então from scikit-learn pronto, from sklearn.preprocessing.import eu vou usar o standard scalar que é basicamente

0:07:35: subtrai a média de cada coluna e divide pelo desvio padrão daquela coluna.

0:07:41: É a normalização mais básica né, o scaling que a gente pode fazer mais básico, tem diferença

0:07:46: entre normalização e scaling mas geralmente confunde-se tudo quando a gente está fazendo

0:07:52: isso aqui.

0:07:53: Vamos usar standard scalar e aí aqui scalar.fit transform e você vê que eu não estou separando

0:08:03: em dados de treino e teste aqui porque como eu falei esse status models eu acho mais interessante

0:08:09: quando você quer fazer estimativa de modelos para uma análise estatística do modelo,

0:08:14: não necessariamente para você fazer uma análise preditiva onde você precisa ver

0:08:18: qual é a performance desse modelo em dados que ele nunca viu.

0:08:21: Então vamos lá scalar.fit transform x e a gente vai passar esse normalized data, colocar

0:08:28: normalized x porque fica mais consistente a nomenclatura, então normalized x, o data

0:08:36: y continua igual porque a gente não vai normalizar o y, a gente poderia normalizar o y mas nesse

0:08:43: momento eu acho que não vai ser muito interessante.

0:08:48: Então respond summary aqui e vamos ver standard scalar not defined porque eu esqueci de rodar

0:08:55: aqui essa linha do standard scalar, deixa eu ver se eu fizer o print desse summary

0:09:01: se ele fica mais bonitinho para a gente enxergar, fica bem melhor, então faça o print do summary

0:09:08: que fica bem melhor.

0:09:09: Então basicamente a ideia é você vai pegar esse objeto ols, vai passar o teu y ou a

0:09:15: tua variável endógena, vai passar o teu x ou a tua variável também conhecida como

0:09:20: exógena, as suas variáveis exógenas e você vai fazer o modelo.fit, vai chamar esse método

0:09:29: fit, ele vai te retornar um objeto com os resultados e aí você faz o print desse

0:09:34: objeto de resultado, você faz o print com o método summary e você vai ter essa bela,

0:09:42: esse belo vamos dizer assim, esse belo sumário, esse belo resumo do teu modelo.

0:09:47: Agora mudou um pouco a configuração, os p-values e tudo mais, se eu não me engano

0:09:52: no primeiro lá e deixa eu fazer o print desse primeiro aqui para ele ficar mais bonitinho

0:09:57: também para a gente conseguir comparar melhor.

0:10:00: Legal, esse aqui eu deleto fazendo o print, você vê que o p-value todos eram significativos

0:10:10: etc e tal, R squared era alto e agora ele não é o caso, aí você fala Mari mas esse

0:10:16: aqui tá x1, x2, como é que eu faço para ele ter o nome das variáveis?

0:10:20: O que a gente vai fazer?

0:10:22: Por que ele fez isso?

0:10:23: Porque quando ele transforma para normalize ele retorna para a gente esse scalar retorna

0:10:27: uma numpy array em vez de um pandas data frame, então tudo que a gente precisa fazer é simplesmente

0:10:33: transformar esse normalize x em um pandas data frame, a gente pega pd ponto data frame,

0:10:40: a gente passa normalize edX e como columns a gente passa aqui uma lista de colunas que

0:10:47: nada mais é do que a lista de colunas do x original x ponto columns, vamos ver agora

0:10:54: e cá estão as nossas maravilhosas variáveis.

0:10:58: Então beleza, aí eu sinceramente se eu te falar eu não me lembro agora qual dessas

0:11:05: análises vai ser mais válida se essa aqui eu iria mais nessa análise aqui de coeficientes

0:11:10: porque a análise estatística mais tradicional não é o meu forte, mas eu quis te mostrar

0:11:15: esse objeto porque se você estiver precisando fazer, se você entender como é que faz uma

0:11:19: análise estatística mais tradicional de pivélios e tudo mais, de coeficientes etc

0:11:25: e tal, que precisa de normalização, você pode usar esse objeto e ele vai te dar esse

0:11:32: resultado, eu vi que muita gente tem essa dúvida, como é que eu faço regressão linear

0:11:36: em python e é simples assim, esse código, esse bloco de código que você precisa basicamente

0:11:43: passar teu x teu y e fazer o teu modelinho e ter esse sumário.

0:11:47: Agora eu vou te mostrar uma coisa que eu entendo mais que é como é que você faz essa regressão

0:11:53: linear só que com viés de previsão para dados que você nunca viu, então mais na

0:11:59: forma como a gente faz em machine learning, que a gente não quer saber realmente pivélio

0:12:04: e tudo mais nos dados de treino que seriam que a gente usaria aqui, a gente quer saber

0:12:09: como é que o modelo vai funcionar em dados que a gente nunca viu.

0:12:14: Nesse caso eu vou fazer o seguinte, eu vou importar do scikit-learn da biblioteca de

0:12:21: modos lineares, eu vou importar linear regression, eu vou importar também só para a gente fazer

0:12:30: a coisa do jeito bem certinho, eu vou importar uma divisão entre treino e validação ou

0:12:38: treino e teste e aí eu não vou explicar de novo porque quem assiste todos os vídeos

0:12:43: do canal deve estar cansado de me ver explicar porque que eu trato teste e validação basicamente

0:12:49: como a mesma coisa quando eu estou fazendo análise offline, mas basicamente a gente

0:12:54: vai ter aqui os nossos dados e eu vou aproveitar o x que eu criei lá em cima, que são só

0:13:00: as variáveis que a gente quer usar como x, as features do nosso modelo, vamos para

0:13:04: a linguagem de machine learning agora, então essas são as nossas features e o nosso y

0:13:09: vai ser o data y só para a gente manter o código igual estava lá em cima que vai

0:13:16: ser o preço da casa agora tem uma vantagem muito grande na regressão linear aqui do

0:13:23: scikit-learn em termos de normalização que se eu não me engano ele faz isso automaticamente

0:13:28: internamente para a gente então o que a gente vai fazer aqui eu vou dividir entre treino

0:13:32: e teste então aqui depois de importar o treino e teste split eu vou separar entre treino

0:13:38: e validação então a primeira coisa que eu preciso aqui é colocar xtrein, xval, ytrein

0:13:46: e yval igual a treintest-split treintest-split x, y e o test-size aqui vai ser de 30% então

0:13:57: eu quero 70% dos dados para treino e 30% para validação e vamos ver se ele fez essa divisão

0:14:05: certo então xtrein.shape xval.shape ytrein.shape yval.shape e ele disse que achou alguma coisa

0:14:19: com número inconsistente claro porque o meu y aqui tem ser data y para ser consistente

0:14:26: com o que eu estava usando lá acima né o y na verdade é só uma string então beleza

0:14:32: xtrein.shape 11.900 linhas por 8 colunas correto xval.shape 5.100 linhas por 8 colunas originalmente

0:14:40: o dataset todo tem 17 mil linhas e 9 colunas que são 8 features e um target né um y ytrein

0:14:48: 11.900 linhas uma coluna né basicamente 0 dimensões aqui e 0 dimensões na segunda dimensão

0:14:55: né ele tem uma dimensão e 5.100 linhas pro yval. então tá tudo certinho dividido aqui

0:15:02: como é que a gente faz então essa regressão linear no scikit-learn a gente chama de modelo

0:15:08: a gente pega linear regression e não precisa colocar argumento nenhum sinceramente tá

0:15:14: depois eu vou te mostrar o normalize aqui para a gente ver é como é que como é que

0:15:20: funciona quando ele normaliza por si só ou não a gente pode usar o njobs aqui mas é

0:15:26: tão rápido que nem precisa njobs é para você paralelizar se você tem um computador

0:15:31: com sei lá 20 núcleos você pode colocar njobs igual a 20 que ele vai paralelizar e

0:15:36: vai ser mais rápido mas isso realmente só vale a pena se o teu dataset for muito grande

0:15:41: mesmo se não não faz muita diferença como é que a gente faz então a gente criou o modelo

0:15:46: criou o objeto e agora a gente vai treinar né a gente vai fazer o feat esse objeto vai

0:15:51: fazer estimativa dos coeficientes a gente passa pro método feat o xtrain que são os

0:15:56: nossos features ytrain que é o nosso alvo e aí a gente faz pega a nossa previsão geralmente

0:16:03: a gente está mais interessado na previsão nos dados de validação então vamos pegar

0:16:09: fazer o método predict que basicamente vai pegar o modelo treinado né os coeficientes

0:16:14: que ele achou aqui e vai fazer é a previsão para esses dados dados novos que são o do

0:16:22: da validação dados que nunca viu esses 5.100 exemplos fazendo isso nós temos aqui as nossas

0:16:28: previsões e a gente poderia fazer uma um cálculo de erro muito simples que seria pegar aqui

0:16:36: das métricas do site learn o erro médio quadrado min square error ele não quer autocompletar

0:16:45: para mim agora ele resolveu e a gente pode calcular aqui min square error entre y val

0:16:54: e p sempre o y vem primeiro né o os valores reais do erro que a gente calculava em primeiro

0:17:00: e depois a nossa previsão aqui no site learn e aí ele dá esse número gigantesco lógico

0:17:07: a gente geralmente faria o rms que é a raiz quadrada disso aqui e não tem como a gente

0:17:13: interpretar esse número no momento porque a gente não tá realmente tentando modelar

0:17:17: esses dados é mais para te mostrar mesmo como é que você faz é como é que você

0:17:22: usa esse objeto eu esqueci de fazer uma coisa aqui que o random state colocar random state

0:17:28: igual a zero ou qualquer outro valor só para ele fixar a nossa cd é para ele está sempre

0:17:36: a mesma divisão entre treino e validação então ele tava tanto resultados muito diferentes

0:17:42: aqui por isso é por isso que estava dando os resultados diferentes então agora a gente

0:17:45: pode realmente focar mais em ver como é que funciona a normalização aqui então se eu

0:17:50: colocar normalize igual a tru que ele vai tá fazendo ele vai pegar os regressores x

0:17:56: e normalizar subtraindo a média e dividindo pela l2 norm então me parece um pouquinho

0:18:05: diferente é uma normalização um pouquinho diferente que ele divide pela l2 norm né

0:18:11: então a gente não tá estandardizando vamos assim com o standard scalar então provavelmente

0:18:18: por isso que os nossos coeficientes tão diferentes também sinceramente na prática

0:18:23: do promeço no machine learning é eu não vejo tanta diferença em termos de resultado

0:18:29: com o outro claro você pode testar os dois então com normalize igual a tru ele deu 69057

0:18:35: com normalize igual a false em teste tem que ser pior mas ele deu 69057 vou rodar de novo

0:18:43: só para ter certeza do que eu tô fazendo aqui 690577158 e veja só ele não tá fazendo

0:18:53: a mínima diferença nesse caso se a gente usar os valores é scale de nessa gente usar

0:19:01: o standard scalar certamente ele vai dar um valor diferente aliás eu vou tentar fazer

0:19:05: isso aqui embaixo só porque eu tô incomodado com esses coeficientes sendo diferentes

0:19:11: entre um modelo e outro então vamos colocar aqui texto sai que learn standardizado vamos

0:19:21: abrazileirar a frase ou a palavra e aqui eu vou pegar o seguinte depois de eu separar

0:19:30: entre in test é muito importante eu vou colocar scale igual standard scalar e eu vou fazer

0:19:39: o seguinte x trem scale igual scalar ponto fit transform dessa vez eu tô usando fit

0:19:48: transform que basicamente a mesma coisa que a gente fez acima de fazer o fit e depois

0:19:52: o transform é separadamente mas ele faz tudo numa função e já retorna o resultado

0:19:58: do transform para a gente x trem e o x val scale scalar ponto transform só sem o fit

0:20:08: que a gente já fez o fit usando x trem x val então vamos lá linear regression model

0:20:15: ponto predict agora eu tenho que botar o normalize igual a falsa vamos ver também qual foi

0:20:21: o erro que ele deu eu vou copiar aqui a nossa métrica de erro 69057715 eu tô incomodado

0:20:29: que isso aqui que eu tô achando que eu tô fazendo alguma coisa errada tá a coisa errada

0:20:34: que eu fiz eu esqueci de mudar aqui o x trem e o x val para as versões scaled e ainda

0:20:44: assim ele tá dando o mesmo valor o que para mim é muito estranho mas parece estar certo

0:20:56: bom eu fiz isso aqui para gente ver os coeficientes então vamos colocar aqui os coeficientes

0:21:01: para a gente ver agora ele tá dando menos 86 mil etc e tal vamos copiar eu vou ver se

0:21:07: é igual o da li de cima e agora veja só eu consegui mais ou menos reproduzir vai não

0:21:16: vou dizer que tá super perto ainda devem ter diferenças na computação numérica atrás

0:21:22: ele tá fazendo nossa e que learn ou aqui mas você vê que tá muito mais próximo

0:21:26: é menos ponto menos 8.6504 aqui menos 8.65 vai gente arredondar aqui vai para 5 arredondar

0:21:38: aqui vai para 4 neta próximo menos 9174 aqui mesma coisa aqui é 1.448 aqui já ficou

0:21:50: um pouco mais distante mas basicamente tá muito mais perto do que com a outra normalização

0:21:56: talvez talvez por causa do intercept então vamos fazer aquele teste novamente aqui fit

0:22:03: intercept igual false vamos ver se muda a previsão e a nossa previsão claramente aqui é o nosso

0:22:11: erro mudou vamos ver os coeficientes se mudaram muito então 8.6338.3479168.6148.0.1.1

0:22:26: mais 20 ele não mudou nada nos nossos coeficientes que é bem interessante então basicamente

0:22:35: é isso se você quiser aprender a colocar um intercept só pra gente finalizar só pra

0:22:41: gente finalizar eu vou ensinar a colocar um intercept aqui nessa regressão linear sinceramente

0:22:48: a forma mais fácil da gente fazer isso é a gente vir aqui a forma mais fácil da gente

0:22:53: adicionar um intercept nessa regressão linear é a gente vir aqui pegar nosso normalize

0:22:59: x e colocar aqui intercept igual a 1 que aí ele vai adicionar essa constante para a gente

0:23:07: e a gente vê aqui ó ele dá o valor do intercept e já integra nossa análise então basicamente

0:23:15: a forma mais fácil tem como você adicionar direto no status models mas sinceramente só

0:23:21: cria uma coluna com um monte de um aqui que ele já vai adicionar e você não vai perder

0:23:26: muito tempo e olha só nosso R squared subiu bem para ponto 641 antes ele era ponto 15

0:23:36: então realmente o intercept está fazendo uma grande diferença provavelmente porque

0:23:40: os preços das casas são muito maiores do que os valores normalizados ou standardizados

0:23:45: nesse caso pra gente ser mais correto é são muito maiores e aí por isso faz essa diferença

0:23:52: mas é isso espero que você tenha conseguido aprender a rodar pelo menos o código disso

0:23:57: aqui aí você pode fazer as modificações dando uma olhada lá no status models no próprio

0:24:02: site e que você adeca melhor essas funções para o teu atuar a tarefa que você quer fazer

0:24:10: minha ideia que era só mesmo te dar um ponto de partida se você gostou deixe seu like

0:24:15: se inscreva no canal e ative o sininho para mais vídeos principalmente sobre machine

0:24:19: learning um abraço