Python - Machine learn - Seleção de Atributos

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import confusion_matrix, accuracy_score
from sklearn.svm import SVC
from sklearn.ensemble import ExtraTreesClassifier

credito = pd.read_csv('Credit.csv')
previsores = credito.iloc[:,0:20].values
classe = credito.iloc[:,20].values

labelencoder = LabelEncoder()
previsores[:,0] = labelencoder.fit_transform(previsores[:,0])
previsores[:,2] = labelencoder.fit_transform(previsores[:,2])
previsores[:,3] = labelencoder.fit_transform(previsores[:,3])
previsores[:,5] = labelencoder.fit_transform(previsores[:,5])
previsores[:,6] = labelencoder.fit_transform(previsores[:,6])
previsores[:,8] = labelencoder.fit_transform(previsores[:,8])
previsores[:,9] = labelencoder.fit_transform(previsores[:,9])
previsores[:,11] = labelencoder.fit_transform(previsores[:,11])
previsores[:,13] = labelencoder.fit_transform(previsores[:,13])
previsores[:,14] = labelencoder.fit_transform(previsores[:,14])
previsores[:,16] = labelencoder.fit_transform(previsores[:,16])
previsores[:,18] = labelencoder.fit_transform(previsores[:,18])
previsores[:,19] = labelencoder.fit_transform(previsores[:,19])

x_treinamento, X_teste, y_treinamento, y_teste = train_test_split(previsores,
classe,
test_size = 0.3,  random_state = 0)
svm = SVC()
svm.fit(x_treinamento, y_treinamento)
previsoes = svm.predict(X_teste)
taxa_acerto = accuracy_score(y_teste, previsoes)

forest = ExtraTreesClassifier()
forest.fit(x_treinamento, y_treinamento)
importancias = forest.feature_importances_
#selecionar os 4 atributos com importancia mais altos (escolha aleatoria)
x_treinamento2 = x_treinamento[:,[0,1,2,3]]
x_teste2 = X_teste[:,[0,1,2,3]]

svm2 = SVC()
svm2.fit(x_treinamento2, y_treinamento)
previsoes2 = svm2.predict(x_teste2)
taxa_acerto = accuracy_score(y_teste, previsoes2)

Python - Machine Learn com arvore de decisão

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import confusion_matrix, accuracy_score
from sklearn.tree import DecisionTreeClassifier
import graphviz
from sklearn.tree import export_graphviz

credito = pd.read_csv('Credit.csv')
previsores = credito.iloc[:,0:20].values
classe = credito.iloc[:,20].values

labelencoder = LabelEncoder()
previsores[:,0] = labelencoder.fit_transform(previsores[:,0])
previsores[:,2] = labelencoder.fit_transform(previsores[:,2])
previsores[:,3] = labelencoder.fit_transform(previsores[:,3])
previsores[:,5] = labelencoder.fit_transform(previsores[:,5])
previsores[:,6] = labelencoder.fit_transform(previsores[:,6])
previsores[:,8] = labelencoder.fit_transform(previsores[:,8])
previsores[:,9] = labelencoder.fit_transform(previsores[:,9])
previsores[:,11] = labelencoder.fit_transform(previsores[:,11])
previsores[:,13] = labelencoder.fit_transform(previsores[:,13])
previsores[:,14] = labelencoder.fit_transform(previsores[:,14])
previsores[:,16] = labelencoder.fit_transform(previsores[:,16])
previsores[:,18] = labelencoder.fit_transform(previsores[:,18])
previsores[:,19] = labelencoder.fit_transform(previsores[:,19])
x_treinamento, X_teste, y_treinamento, y_teste = train_test_split(previsores,
classe,
test_size = 0.3,
random_state = 0)
arvore = DecisionTreeClassifier()
arvore.fit(x_treinamento, y_treinamento)
#erro é normal

#pip install graphviz

export_graphviz(arvore, out_file = 'tree.dot')
#copiar o codigo e colar no site webgraphviz
previsoes = arvore.predict(X_teste)
confusao = confusion_matrix(y_teste, previsoes)
taxa_acerto = accuracy_score (y_teste, previsoes)
taxa_erro = 1 - taxa_acerto

Machine Learn Naive Bayes em Python

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
#GaussianNB não trabaçja com categoricos
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import confusion_matrix, accuracy_score

credito = pd.read_csv('Credit.csv')
previsores = credito.iloc[:,0:20].values #: todas linha da lionha 0 a linha 20
classe = credito.iloc[:,20].values
#Gaussina NB não trabalha com dados categoricos então converter Ecoder
labelencoder = LabelEncoder()
previsores[:,0] = labelencoder.fit_transform(previsores[:,0])#precisar fazer individualmente para cada atributo
previsores[:,2] = labelencoder.fit_transform(previsores[:,2])
previsores[:,3] = labelencoder.fit_transform(previsores[:,3])
previsores[:,5] = labelencoder.fit_transform(previsores[:,5])
previsores[:,6] = labelencoder.fit_transform(previsores[:,6])
previsores[:,8] = labelencoder.fit_transform(previsores[:,8])
previsores[:,9] = labelencoder.fit_transform(previsores[:,9])
previsores[:,11] = labelencoder.fit_transform(previsores[:,11])
previsores[:,13] = labelencoder.fit_transform(previsores[:,13])
previsores[:,14] = labelencoder.fit_transform(previsores[:,14])
previsores[:,16] = labelencoder.fit_transform(previsores[:,16])
previsores[:,18] = labelencoder.fit_transform(previsores[:,18])
previsores[:,19] = labelencoder.fit_transform(previsores[:,19])

x_treinamento, X_teste, y_treinamento, y_teste = train_test_split(previsores,
                                                                  classe,
                                                                  test_size = 0.3, #705 para treinar
                                                                  random_state = 0) #dividir da mesma maneira
naive_bayes = GaussianNB()
naive_bayes.fit(x_treinamento, y_treinamento)
#o erro é normal, inidca que já foi criado

previsoes = naive_bayes.predict(X_teste)
#matriz de confusão
confusao = confusion_matrix(y_teste, previsoes)
taxa_acerto = accuracy_score(y_teste,previsoes)
taxa_erro =1- taxa_acerto

from yellowbrick.classifier import ConfusionMatrix
v = ConfusionMatrix(GaussianNB())
v.fit(x_treinamento, y_treinamento)
v.score(X_teste, y_teste)
v.poof()

#usar outro arquivo e testar
novo_credito = pd.read_csv('NovoCredit.csv')
novo_credito = novo_credito.iloc[:,0:20].values

novo_credito[:,0] = labelencoder.fit_transform(novo_credito[:,0])
novo_credito[:,2] = labelencoder.fit_transform(novo_credito[:,2])
novo_credito[:,3] = labelencoder.fit_transform(novo_credito[:,3])
novo_credito[:,5] = labelencoder.fit_transform(novo_credito[:,5])
novo_credito[:,6] = labelencoder.fit_transform(novo_credito[:,6])
novo_credito[:,8] = labelencoder.fit_transform(novo_credito[:,8])
novo_credito[:,9] = labelencoder.fit_transform(novo_credito[:,9])
novo_credito[:,11] = labelencoder.fit_transform(novo_credito[:,11])
novo_credito[:,13] = labelencoder.fit_transform(novo_credito[:,13])
novo_credito[:,14] = labelencoder.fit_transform(novo_credito[:,14])
novo_credito[:,16] = labelencoder.fit_transform(novo_credito[:,16])
novo_credito[:,18] = labelencoder.fit_transform(novo_credito[:,18])
novo_credito[:,19] = labelencoder.fit_transform(novo_credito[:,19])

naive_bayes.predict(novo_credito)

Deep Learn com Iris em Python

#pip inatall tensorflow
#pip install keras
from sklearn import datasets
from sklearn.model_selection import train_test_split
from yellowbrick.classifier import ConfusionMatrix
from keras.models import Sequential
from keras.layers import Dense
from keras.utils import np_utils
import numpy as np


base = datasets.load_iris()
previsores = base.data
classe = base.target

classe_dummy = np_utils.to_categorical(classe)#separa em classes

x_treinamento, x_teste, y_treinamento, y_teste = train_test_split(previsores,
                                                                  classe_dummy,
                                                                  test_size = 0.3,
                                                                  random_state = 0)
#class dummy para ficar todos os dados em uma unica matrix
modelo = Sequential()#uma camada após a outra
#adicionar camadas - no ex terá 5 camadas (units)
modelo.add(Dense(units = 5, input_dim = 4)) #input entrada - quantas atributos/neoronios (4 são numero de atributos iris) o valor 5 está na aula de r
modelo.add(Dense(units = 4))
modelo.add(Dense(units = 3, activation = 'softmax')) #quando tiver mais de duas classes usar este (saida 3 que são as saidas Vesicolor, sestosa e )

modelo.summary()
#para visualizar
#from keras.util.vis_utils import plot_model   precisa de um programa pra ler
modelo.compile(optimizer = 'adam', loss = 'categorical_crossentropy',
               metrics = ['accuracy']) #adma é uma funçao / categorical_crossentroppy funcao/ accuraci / taxa de acerto
modelo.fit(x_treinamento, y_treinamento, epochs = 1000,
validation_data = (x_teste, y_teste)) #epoch numero de revelidação
previsoes = modelo.predict(x_teste)
previsoes = (previsoes > 0.5) #definir que se mais de 50% ELE É DA CLASSE
v = ConfusionMatrix()# vai dar erro, precisa convertter
y_teste_matrix = (np.argmax(t) for t in y_teste) #vai pegar o maximo argumento
y_previsao_matrix = (np.argmax(t) for t in previsoes)
confusao = ConfusionMatrix(y_teste_matrix, y_previsao_matrix)

Neste caso ele teve acerto de 98% na determinação da espécie

Exercícios de Python

 (Bike Share Chicago)

1-Crie uma função que pegue o gênero mais popular, e retorne este gênero como uma string.

import csv
import matplotlib.pyplot as plt


with open("chicago.csv", "r") as file_read:
    reader = csv.reader(file_read)
    data_list = list(reader)

cont = len(data_list)
contagem = cont - 2
males = 0
females = 0
linha = 0
colun = 6
answer=0
ntarefa_6 = data_list [linha]
while (linha <= contagem): #selecionando os itens necessários para a análise e salvando nas variáveis male e female
ntarefa_6 = data_list [linha+1]
mlist = (ntarefa_6 [colun])
flist = (ntarefa_6 [colun])
linha +=1
if mlist == 'Male':
males +=1
elif flist == 'Female':
females +=1
ntarefa_6 = []               
if males >= females:
answer = "Male"
elif males<= females:
answer = "Female"
else:
answer = "Equal"

def most_popular_gender(data_list):
    answer = ""
    return answer

print (answer)



2-Crie uma função para adicionar as colunas de uma lista em outra lista, na mesma ordem:

import pandas as pd
data_list = pd.read_csv('chicago.csv')
#data_list.index
#data_list.shape
#data_list.head()
data_list.dropna(axis=0, how='any', thresh=None, subset=None, inplace=True) #limp. valores nulos
#data_list.dropna(subset=['Gender'])                                   
cont = len(data_list)
resposta []
contagem = cont             
linha = 1
dlist = []                       #Local de armazenamento genero
clist = []                       #Local de armazenamento data de nascimento
colun = 6                        #definindo coluna de leitura
coluna= 7                        #definindo coluna de leitura
ntarefa_0 = data_list [linha]
while (linha <= contagem):
linha +=1
ntarefa_0 = []
ntarefa_0 = data_list[linha+1]
dlist = []
ddlist = (ntarefa_0 [colun])
dlist.append(ddlist)         #armazenando a informação
ntarefa_3 = []
ntarefa_3 = data_list[linha+1]
clist = []
cclist = (ntarefa_3 [coluna])
clist.append(cclist)          #armazenando a informação
resposta.append ("Genero {}: Nascimento{}".format(dlist,clist))

Criando uma função para adicionar as colunas de uma lista em outra lista, na mesma ordem em Python

Utilizei a tabela de dados Chicago_bike_share

import csv
import matplotlib.pyplot as plt

with open("chicago.csv", "r") as file_read:
    reader = csv.reader(file_read)
    data_list = list(reader)
cont = len(data_list)
linha = 1
dlist = []                       #Local de armazenamento genero
clist = []                       #Local de armazenamento data de nascimento
colun = 6                        #definindo coluna de leitura
coluna= 7                        #definindo coluna de leitura
ntarefa_0 = data_list [linha]
while (linha <= contagem):
linha +=1
ntarefa_0 = []
ntarefa_0 = data_list[linha+1]
dlist = [] #limpnado a variável
ddlist = (ntarefa_0 [colun])
dlist.append(ddlist)         #armazenando a informação
ntarefa_3 = []
ntarefa_3 = data_list[linha+1]
clist = []
cclist = (ntarefa_3 [coluna])
clist.append(cclist)          #armazenando a informação
print ("Genero {}: Nascimento{}".format(dlist,clist))  #organizando a resposta

Descobrir a diferença de horário de uma lista em Python

Do arquivo share_bikes_chicago eu extrai os valores em string de hora de inicio e hora de fim e converti em data e calculei a diferença para saber o tempo de uso:


import csv
import numpy as np
import matplotlib.pylab as plt
from datetime import datetime
import pandas as pd
from datetime import timedelta

#base = pd.read_csv('chicago.csv') # base = pb.read_csv('chicago.csv',header = None)
with open("chicago.csv", "r") as file_read:
    reader = csv.reader(file_read)
    data_list = list(reader)
    #data_list = str(reader)
 
ntarefa_1 = []
ntarefa_2 = []
ntarefa_3 = []
ntarefa_4 = []
delta = []
linha = 1
while (linha <= 1000):
    estudo = data_list[linha]
    ntarefa_4 = []
    ntarefa_4 = estudo[0]
    ntarefa_2 = datetime.strptime(ntarefa_4, '%Y-%m-%d %H:%M:%S')
    ntarefa_3 =[]
    ntarefa_3 = estudo[1]
    ntarefa_1 = datetime.strptime(ntarefa_3, '%Y-%m-%d %H:%M:%S')
    delta.append(ntarefa_1 - ntarefa_2)
    linha += 1

Resultado:

Gerar numero randômicos Python

import numpy as np
import pandas as pd

base = pd.read_csv('iris.csv')

#agora gerar numeros randomicos

amostra = np.random.choice(a = [0, 1], size = 150, replace = True,p = [0.5, 0.5])
len(amostra)
len(amostra[amostra == 1])
len(amostra[amostra ==0])

Tendencia/Sazonalidade/Aleatoriedade e Previsão em Series Temporais (Python)

import pandas as pd

import numpy as np

import matplotlib.pylab as plt

from statsmodels.tsa.seasonal import seasonal_decompose

#base = pd.read_csv('adultos.csv', sep = ';')

#base.head()

base = pd.read_csv('adultos.csv', sep = ';')

dateparse = lambda dates:pd.datetime.strptime(dates,'%Y-%m')

base = pd.read_csv('adultos.csv', sep = ';', parse_dates = ['data'], index_col = 'data', date_parser = dateparse)

#para trabalhar com serie temporal é recomendados transformar o type Data-frame em Type Series - ts, não precisa obrigatoriamente usar este nome

ts = base['SVL']

plt.plot(ts)

#decomposicao = seasonal_decompose(ts, model='additive')

decomposicao = seasonal_decompose(ts)

tendencia = decomposicao.trend

sazonal = decomposicao.seasonal

aleatorio = decomposicao.resid

plt.plot(sazonal)

plt.plot (tendencia)

plt.plot(aleatorio)

plt.subplot(4,1,1)

plt.plot(ts, label= 'original')

plt.legend(loc = 'best')

plt.subplot(4,1,2) #o ultimo é o local do bloco, se não alterar vai sobreescrever/ o do meio é o tamanho do grafico (maior fica menor)

plt.plot(tendencia, label= 'tendencia')

plt.legend(loc = 'best')

plt.subplot(4,1,3)

plt.plot(sazonal, label= 'sazonal')

plt.legend(loc = 'best')

plt.subplot(4,1,4)

plt.plot(aleatorio, label= 'Aleatório')

plt.legend(loc = 'best')

#layout

plt.tight_layout()

#Previsão

import pandas as pd

import matplotlib.pylab as plt

from statsmodels.tsa.arima_model import ARIMA

from pyramid.arima import auto_arima

base = pd.read_csv('adultos.csv', sep = ';')

dateparse = lambda dates:pd.datetime.strptime(dates,'%Y-%m')

base = pd.read_csv('adultos.csv', sep = ';', parse_dates = ['data'], index_col = 'data', date_parser = dateparse)

ts = base['SVL']

plt.plot(ts)

ts.mean() #visualizar a média

ts['1960-01-01':'1960-12-01'].mean() #média do ultimo an

media_movel = ts.rolling(window = 12).mean() #pode dar nulo porque ele precisa dos "12" dados anteriores para dar resultado

ts[0:12].mean() #posicao 0 a posicao 12

ts[1:13].mean()

plt.plot(ts)

plt.plot(media_movel, color = 'red')

#não tem biblioteca, então vamos criar

previsoes = []

for i in range(1,13):

#print(i)

superior = len(media_movel)-i

inferior = superior - 11

#print(inferior)

#print(superior)

#Print('---')

previsoes.append(media_movel[inferior:superior].mean())

#a ordem está inversa, então para virar

previsoes = previsoes[::-1] #: para não mecher nas linhas

plt.plot(previsoes)

#agora o arrima com biblioteca ARIMA P(numero dos termos auto regressivos)  Q (numero da media movel Dnumero de não sazonais

modelo = ARIMA(ts, order=(2,1,1))#ts é a serie teporal order (pqd)

modelo_treinado = modelo.fit()

modelo_treinado.summary()

previsoes = modelo_treinado.forecast(steps = 12)[0] #previsões para frente que quer fazer ex12 e [0] para retirar dados a mais

eixo = ts.plot()

modelo_treinado.plot_predict('2005-12-01', '2006-12-01')

Ta meio ruim, mas são os dados que eu usei.

Mineração de Texto com Python

      Criei minha nuvem de palavras a partir da minha dissertação de mestrado, com mais de 10.000 palavras., Tive problema em mudar a linguagem do Inglês (padrão) para o português;

# coding: latin1
import matplotlib.pyplot as plt
import nltk
from nltk.corpus import PlaintextCorpusReader
from nltk.corpus import stopwords
from matplotlib.colors import ListedColormap
from wordcloud import WordCloud
import os, nltk.test


corpus = PlaintextCorpusReader('Arquivos', ".*")
testdir = os.path.split(nltk.test.__file__)[0]
text = open(os.path.join(testdir, 'Disertacao.txt'), 'rb').read().decode('ISO 8859-1')
#coding: latin-1
#for fileid in corpus.fileids():
 #   print (type(fileid))
 #   print (fileid.encode('ascii'))
#corpus = corpus.decode('utf8')
#arquivos = corpus.fileids()
palavras = corpus.words()
len(palavras)
todo_texto= corpus.raw()
#excepitons_tutorial.py
stops = stopwords.words('english')
mapa_cores = ListedColormap(['orange', 'green', 'red', 'magenta'])
nuvem = WordCloud(background_color = 'white', colormap = mapa_cores, stopwords = stops, max_words = 100)
nuvem.generate(todo_texto)
plt.imshow(nuvem)