O infarto do miocárdio, ou ataque cardíaco, é a morte das células de uma região do músculo do coração por conta da formação de um coágulo que interrompe o fluxo sanguíneo de forma súbita e intensa.

Fonte: ALVES, B. / O. / O.-M. Ataque cardíaco (infarto) | Biblioteca Virtual em Saúde MS. Disponível em: https://bvsms.saude.gov.br/ataque-cardiaco-infarto/#:~:text=O%20infarto%20do%20mioc%C3%A1rdio%2C%20ou.

Prever uma possível doença cardíaca com base no histórico dos pacientes é ajudar a pessoa se cuidar antes de ter um sintoma, ou adoecer com sequelas. Analisar dados de saúde é uma ação bastante delicada, não podemos expor os pacientes de nenhuma forma, além de algumas vezes ser preciso um especialista para ajudar essa interpretação de forma mais eficaz.

Como de costume, os exemplos desse post estão no colab.

Nesse post iremos realizar o treinamento com os algoritmos: Support Vector Machine
(SVM), Random Forest (RF), Logistic Regress (LR), K-Nearest Neighbor (KNN), Decision Tree (DT). Alguns algoritmos foram executados com diferentes parâmetros para chegar em uma configuração com uma boa acurácia.

Sobre o dataset

A base de dados que vamos usar nessa abordagem esta disponível em: https://www.kaggle.com/datasets/johnsmith88/heart-disease-dataset com os seguintes dados:

Pré processamento

Removendo duplicados

Existem 1025 instâncias nesse dataset, após usar a lib profile-report foi identificado várias instâncias repetidas. Instancias repetidas pode gerar um vício no algoritmo, ja que ele não irá predizer, e sim replicar um dado visto anteriormente. Removido, usando a função do pandas drop_duplicates().

Removendo outliers

Gerando uma visualização com bloxPlot, percebemos que existem outliers, e foi usado o Intervalo Interquartil para remove-los. Essa técnica foi comentado em outro post. Consulte aqui.

Treinando os modelos

Base de testes:

É muito importante separar a base em treino e teste. Para que um dado que esteja no treino, não esteja no teste. O scikit-learn, tem uma função que realiza isso:

y = df["target"]
X = df.drop('target',axis=1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state = 0)

Decision Tree:

Esse algoritmo ja foi mencionado em outro post ( consulte aqui ). Basicamente, cada bifurcação é uma decisão, e vão sendo feitas, chamadas de nó, até chegar em uma folha, que é a decisão propriamente dita.

rf = RandomForestClassifier(n_estimators=20, random_state=12,max_depth=5)
rf.fit(X_train,y_train)
rf_predicted = rf.predict(X_test)
rf_conf_matrix = confusion_matrix(y_test, rf_predicted)
rf_acc_score = accuracy_score(y_test, rf_predicted)
print("confussion matrix")
print(rf_conf_matrix)
print("\n")
print("Accuracy of Random Forest:",rf_acc_score*100,'%\n')
print(classification_report(y_test,rf_predicted))

Accuracy of Random Forest: 84.78260869565217 %

Random Forest
Tem uma grande semelhança com o Decision Tree, a diferença é que de forma automatica, se realiza várias árvores, fazendo uma floresta. É uma ótima técnica quando se tem uma grande quantidade de dados e features.

rf = RandomForestClassifier(n_estimators=20, random_state=12,max_depth=5)
rf.fit(X_train,y_train)
rf_predicted = rf.predict(X_test)
rf_conf_matrix = confusion_matrix(y_test, rf_predicted)
rf_acc_score = accuracy_score(y_test, rf_predicted)
print("confussion matrix")
print(rf_conf_matrix)
print("\n")
print("Accuracy of Random Forest:",rf_acc_score*100,'%\n')
print(classification_report(y_test,rf_predicted))

Accuracy of Random Forest: 84.78260869565217 %

Interessante ressaltar, que ficou com o mesmo valor que a decision tree.

Decidi então realizar variações nas árvores de decisões, principalmente no critério de classificação e na profundidade máxima.

Através de medições de quanto uma instancia pertence a uma classe, o gini faz suas decisões, ja o entropy, além disso observa também a desordem dos outros dados.

k_range = range(1,11)
scores = {}

for k in k_range:
  dtFor = DecisionTreeClassifier(criterion = 'entropy',random_state=0,max_depth = k)
  dtFor.fit(X_train, y_train)
  y_pred = dtFor.predict(X_test)
  scores[k] = accuracy_score(y_test,y_pred)
plt.plot(k_range,list(scores.values()), label='entropy')
for k in k_range:
  dtFor = DecisionTreeClassifier(criterion = 'gini',random_state=0,max_depth = k)
  dtFor.fit(X_train, y_train)
  y_pred = dtFor.predict(X_test)
  scores[k] = accuracy_score(y_test,y_pred)
plt.plot(k_range,list(scores.values()), label='gini')
plt.xlabel('Profundidade da Árvore')
plt.ylabel('% de Acurácia')
plt.legend()

Conseguimos ver um gráfico, que inicia com uma ótima acurácia:

Quando exibimos a árvore visual com apenas 1 nível de profundidade, percebemos que só se observa a feature thal, que é a referente a dor no peito, algo muito previsível, provavelmente quem vai ao hospital, a chance de possuir alguma dor, é bastante alta, o ideal era observar outras features.

O segundo valor com uma boa acurácia, é o 3 profundidades, e ao plotar de forma visual, percebemos que existem outras observações.

K-NeighborsClassifier

Esse algoritmo analisa os vizinhos para tomar sua decisão e agrupar os dados. Possui algumas métricas, e podemos varias a quantidade de vizinhos analisados. No estudo foi usado euclidean e Manhattan, varias de 1 a 4 vizinhos, obtendo os seguintes níveis de acurácia.

Então, usando 3 vizinhos e métrica manhattan, obtemos 71% de acurácia.

knn = KNeighborsClassifier(n_neighbors=3, metric='manhattan')
knn.fit(X_train, y_train)
knn_predicted = knn.predict(X_test)
knn_conf_matrix = confusion_matrix(y_test, knn_predicted)
knn_acc_score_1_neighbors = accuracy_score(y_test, knn_predicted)
print("confussion matrix")
print(knn_conf_matrix)
print("\n")
print("Accuracy of K-NeighborsClassifier:",knn_acc_score_1_neighbors*100,'%\n')
print(classification_report(y_test,knn_predicted))

Accuracy of K-NeighborsClassifier: 71.73913043478261 %

Support Vector Classifier

svc =  SVC(kernel='rbf', C=2)
svc.fit(X_train, y_train)
svc_predicted = svc.predict(X_test)
svc_conf_matrix = confusion_matrix(y_test, svc_predicted)
svc_acc_score = accuracy_score(y_test, svc_predicted)
print("confussion matrix")
print(svc_conf_matrix)
print("\n")
print("Accuracy of Support Vector Classifier:",svc_acc_score*100,'%\n')
print(classification_report(y_test,svc_predicted))

Accuracy of Support Vector Classifier: 71.73913043478261 %

Logistic Regression

from sklearn.linear_model import  LogisticRegression
reg = LogisticRegression( )
reg.fit(X_train, y_train)
reg_predicted = reg.predict(X_test)
reg_conf_matrix = confusion_matrix(y_test, reg_predicted)
reg_acc_score = accuracy_score(y_test, reg_predicted)
print("confussion matrix")
print(reg_conf_matrix)
print("\n")
print("Accuracy of Support Vector Classifier:",reg_acc_score*100,'%\n')
print(classification_report(y_test,reg_predicted))

Accuracy of Support Vector Classifier: 91.30434782608695 %

Comparação dos resultados

Random Forest 84.7826091%

K-Nearest Neighbour (10) 60.8695652%

K-Nearest Neighbour (3) 71.7391303%

Decision Tree 84.7826094%

Support Vector Machine 71.7391305%

Logistic Regression 91.304348%

Pela característica do problema, o modelo de regressão logistica tem um resultado melhor.

Observações sobre o estudo:

Esse trabalho foi apresentado na disciplina de Aprendizagem de máquina e produzido artigo. Junto do meu colega Gerfesson. Obtivemos nota máxima.

Usamos também com referência diversos outros estudos, mas o principal foi esse, e fica a recomendação de leitura:

K. Rashid, M. A. Islam, R. A. Tanzin, M. L. Labib, and M. Khan, “Heart disease pre- diction using interquartile range preprocessing and hypertuned machine learning,” in 2022 4th International Conference on Inventive Research in Computing Applications (ICIRCA), IEEE, Sept. 2022.

O post Aplicando Machine Learning no dataset sobre Doenças cardíacas apareceu primeiro em Ramon Domingos Blog.

Alguns conceitos:

• Média: Soma de todos os valores, dividido pela quantidade de elementos.
• Mediana: Exatamente o valor do meio dos dados, no caso de quantidade pares, é a média dos 2 valores.
• Outlier: Ponto fora da Curva/ distribuição da maioria do dados.

Vamos analisar o seguinte cenário hipotético, temos uma base de dados referente a internações em um hospital, com os seguintes dados:

Dados:

• Dias Internados:
  • Média: 2.75 dias.
  • Mediana:1.5 dias.
• Idade:
  • Média: 26 anos.
  • Mediana:20,5 anos.

Da mesma forma que um dado isolado subiu a média para próximo de 3 dias, quando a maioria das internações duraram 1 ou 2 dias, e a media de idade para 26, quando a maioria estava próximo de 20. Uma base de dados com valores fora da curva, podem fazer seu algoritmo de aprendizagem de máquina, predizer de maneira menos assertiva, levando em considerações, essas exceções.

Uma técnica bastante utilizada é através da Identificação desses valores através de intervalos Interquartis, o boxPlot é um excelente meio de fazer essa identificação.

O boxplot

Nessa representação visual, temos os intervalos, o primeiro quartil, é representado por 25%, o terceiro quartil, por 75%. Quando é subtraído Q3 e Q1, temos o Intervalo Interquartil (IQR). Esse valor, serve de referencia para se fazer os limites de máximo e mínimo. Qualquer valor além disso, é considerado um outlier, e é uma boa prática remove-los. O limite inferior se da por Q1-1.5*IQR, e o superior Q3+1.5*IQR.

Essa etapa de pré-processamento, é muito importante para aumentar a acurácia de um algoritmo. No entanto, de nenhuma forma os dados devem ser alterados, o ideal é remove-los da base de treinamento. Nesse colab existe essa etapa de análise e remoção de outliers.

Após identificar os outliers, o próximo passo é remove-los.

for key in df.columns.values.tolist():
  Q1 = df[key].quantile(0.25)
  Q3 = df[key].quantile(0.75)
  IQR = Q3 - Q1 #IQR is interquartile range.

  filter = (df[key] >= Q1 - 1.5 * IQR) & (df[key] <= Q3 + 1.5 *IQR)
  df = df.loc[filter]

Com esse trecho de código, conseguimos passar em todas as features e remover os dados que estão fora dessa definição. É muito importante analisar os dados que serão removidos, em alguns cenários, realmente existem dados fora do padrão, que realmente são importantes. Dessa forma, a clássica resposta “DEPENDE” se aplica perfeitamente, quando o assunto é remover dados de outliers.

O post Removendo outliers de uma base de dados apareceu primeiro em Ramon Domingos Blog.

Como de costume, todo os exemplos estão no colab.

Vamos iniciar importando as nossas bibliotecas, iniciando nosso Toy Dataset Iris e transformando num dataframe do pandas.

import pandas as pd
from sklearn.datasets import load_iris
data = load_iris()
iris = pd.DataFrame(data.data)
iris.columns = data.feature_names
iris['target'] = data.target
iris.head()

Para ser mais didático, e melhorar a compreensão, vamos iniciar o nosso estudo, apenas com 2 features referente a pétalas, para conseguirmos visualizar em um plano cartesiano. Em seguida adicionamos todos os campos.

irisCopy = iris.loc[iris.target.isin([1,2]), ['petal length (cm)','petal width (cm)' , 'target']]
# separa em x e y
x = irisCopy.drop( 'target', axis=1)
y = irisCopy.target

Como temos uma dataset bem grande, conseguimos dividi-lo em duas base, treino e teste. Vamos fazer isso usando o `train_test_split`.

from sklearn.model_selection import train_test_split
x_train, x_teste, y_train, y_test = train_test_split( x, y , test_size=0.30, random_state=22)

Temos nossa base de teste e treino, agora vamos criar nosso classificador, usando nossa base de treino.

from sklearn import tree
import matplotlib.pyplot as plt

clf =  tree.DecisionTreeClassifier(random_state=22)
clf = clf.fit(x_train, y_train)
fig, ax = plt.subplots(figsize=(10,8))

tree.plot_tree(clf)
plt.show()

Obtemos essa árvore:

Agora, vamos analisar cada nó, as decisões que estao sendo analisadas, e baseado nisso, vamos traças linhas em um gráfico, para identificar como estão sendo feito cada decisão:

• x[0] < 4.75
• x[0] < 5.05
• x[1] < 1.65 ( nesse caso x[1], é o Y )
• x[1] < 1.6
• x[0] < 4.85

fig, ax = plt.subplots()
ax.scatter(
    x_train['petal length (cm)'],
    x_train['petal width (cm)'],
    c=y_train
)

ax.plot([4.75,4.75], [0,3], '--r') # primeiro nó
ax.plot([2,4.75],[1.65,1.65], '--r') # segundo nó
ax.plot([5.05,5.05], [3,0], '--r') # terceiro nó
ax.plot([4.75,5.05],[1.6,1.6], '--r') # quarto nó
ax.plot([4.75,5.05],[1.75,1.75], '--r') # quinto nó
ax.plot([4.85,4.85], [1.75,3], '--r') # sexto nó

ax.set( xlim=(3, 7), xticks=[2,3,4,5,6,7], ylim=(0.9,2.7), yticks=[1,1.5,2,2.5])
plt.show()

Conseguimos ver as seguintes linhas:

Dessa forma, podemos ver quais decisões foram tomadas pelo software. Agora, podemos evoluir, deixar de ser apenas 2 escolhas, e colocar para o algoritmo treinar todas as escolhas possíveis, ver a árvore ainda maior.

x_train, x_teste, y_train, y_test = train_test_split( iris.drop( 'target', axis=1), iris.target , test_size=0.20, random_state=10)

clf2 =  tree.DecisionTreeClassifier(random_state=22).fit(x_train, y_train)

fig, ax = plt.subplots(figsize=(10,8))

tree.plot_tree(clf2)
plt.show()

Agora, vamos avaliar nosso modelo, qual o score que ele possui:

clf2.score(x_train, y_train)
# 1

Um excelente aprendizado, nota máxima. Mas essa não é a única maneira de se avaliar um modelo. Existem outras métricas, que veremos em outro post.

O post Aplicando Árvore de decisão no dataset Íris apareceu primeiro em Ramon Domingos Blog.

Neste post vamos utilizar uma situação simples, com poucos nós. Para entendermos como ele funciona, e em quais situações ele é uma boa escolha, no próximo post utilizaremos datasets maiores, com mais decisões, além de Sim/Não.

No geral esse algoritmo busca classificar um registro ( problemas de classificação) ou estimar um valor ( problemas de regressão). Como vemos nessa imagem , cada pergunta, chamadas de nó decisão, respondemos SIM ou NÃO, a primeira pergunta, o nó inicial é o nó raiz e o último, com a resposta, é o nó folha. Em inglês, Decision node, Chance node, Endpoint Node.

Mas como sair de uma simplesmente diagramação visual e chegar num modelo?

O sckit-learn faz esse treinamento, além de exibir uma representação visual das decisões como essa:

Preparei um colab com esses exemplos que teremos nesse post.

Inicialmente, preparei um array, usando numPy, baseado nessa situação, e exibir a tabela

import pandas as pd
import numpy as np
# Criando um array de resultados
numpy_array = np.array([
[True,True,False,False,False], [False,False,False,False,False],
[True,False,True,False,True], [True,False,False,True,True], 
[True,False,False,False,False]])
# Convertendo em Pandas dataFrame
df = pd.DataFrame(numpy_array, columns=['Tenho aula?', 'É Remoto', 'Vou de Carro', 'Vou de ônibus', 'target'])
df["target"] = df["target"].astype(int)
df['target_names']= pd.Categorical.from_codes (df["target"], ['Não vou', 'Vou'])
# Exibindo
df.head()

Ficou assim:

Em seguida, usando o sckitLearn para criar uma classificador, treinar o modelo e criar a árvore de decisão, em seguida apresento aquela representação gráfica. Mostrada inicialmente.

from sklearn import tree
clf = tree.DecisionTreeClassifier( random_state=42)
clf = clf.fit(dados, df.target)
tree.plot_tree(clf)

No próximo post, vamos utilizar algum Toy dataset para esse algoritmo.

O post Conceito da Árvore de decisão – Aprendizado de máquina apareceu primeiro em Ramon Domingos Blog.

Além de ferramentas para usarmos nos estudos e aplicações de machine Learning, como os principais algoritmos para resolver problemas de cluster, classificação ou regressão, ele também possui dados de testes, os chamados Toys datasets. Que envolve diferentes contextos, como tamanho de pétalas de flores, pacote iris, ou informações sobre pacientes diabéticos. Ao todo existem 6 pacotes “toys” para explorar.

Todo o código a seguir, esta disponível em um google colab, clicando aqui

Para instalar esse pacote podemos usar o pip

pip install -U scikit-learn

Assim como todos os pacotes em python, para usa-lo precisa importar.

import sklearn

Para utilizar um dataset personalizado, utiliza a seguinte função.

from sklearn import datasets

Já para utilizar uma base Toy, como o conjunto de dados sobre flores utiliza:

from sklearn.datasets import load_iris

Assim, como a documentação mostra, esse conjunto de dados, possui altura e largura das pétalas de flores. Podemos importar de duas formas um dataset, a primeira:

Importando dataset sem X, y

# carregar os dados para uma vari'svel
dados = load_iris()
# Quero saber os valores, numéricos,  da classificação da linha 1 ,10, 100
dados.target[[1,10,100]]
array([0, 0, 2])

Se quisermos ver os valores de uma linha especifica , utilizamos a função:

dados.data[[1,10,100]]
array([[4.9, 3. , 1.4, 0.2], [5.4, 3.7, 1.5, 0.2], [6.3, 3.3, 6. , 2.5]])

Se quisermos ver os títulos de cada coluna, utilizamos o seguinte comando:

list( dados.feature_names) 
['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

Se quiser saber os target_names, isto é, os nomes das classificações, utilizo a seguinte função:

list(dados.target_names)
['setosa', 'versicolor', 'virginica']

Como temos os target_names, esse modelo fornece um treino supervisionado, ja falamos sobre isso nesse post.

A Parte DATA: São as características dos dados, as features.

A parte TARGET, é o rótulo, no caso, é o que queremos descobrir.

dados.target
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])

0,1,2 Corresponde, ao dados.target_names, respectivamente.

Importando dataset com X, y.

Na documentação, sempre existe essa notação. o X é o data, características, o Y é o target, o que queremos prever.

Lembra da fórmula:

𝑦=𝑓(𝑥)

então, qual é o Y, quando informamos x ? Isso é o que nosso algoritmo quer descobrir. Exatamente, como na fórmula.

Para utilizar essa notação , o load_iris, irá mudar.

X, y = load_iris(return_X_y=True)

nessa hora, o X == dados.data e o y == dados.target

Convertendo em PANDAS

Você pode precisar passar o seu dataset scikit-learn para um dataframe PANDAS, ele é mais amigável e popular, na análise de dados, e pode ser útil na hora de apresentar os dados. Para fazer isso, import o pandas.

import pandas as pd

Converta seu dataSet em dataFrame

iris_df = pd.DataFrame(data= dados.data, columns=dados.feature_names)

iris_df[‘target’] = dados.target

e confira

Você quer o nome? podemos add também um coluna mais amigável ainda. Com uma função do pandas:

iris_df['target_names'] = pd.Categorical.from_codes(dados.target, dados.target_names)

Podemos fazer um gráfico, para ver e entender a utilidade dessa conversão.

Para conseguir plotar gráficos aqui , precisamos de uma notação.

%matplotlib inline

iris_df.plot.scatter( 'sepal length (cm)', 'sepal width (cm)', c='target')

Conjuntos de treinamento e teste

Para separar seus dados, podemos dividir o grande conjunto em duas partes, para testarmos e validamos nossos algoritmos. O próprio scikit-learn ja faz isso para você. Conseguindo determinar quais porcentagens vão para cada conjunto. Utilizando o train_test_split, test_size, é a porcentagem das divisões, e o random_state, é uma semente para pegar aleatoriamente os elementos, caso o data_frame esteja ordenado.

from sklearn.model_selection import train_test_split 

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state=22) 

O post Hello scikit-learn apareceu primeiro em Ramon Domingos Blog.

No post que eu falei sobre a diferença entre machine Learn e Deep learning, comentei que para evoluir um modelo é necessário treiná-lo, fornecendo dados para isso, dessa forma, o aprendizado dessa máquina, é baseado no que fornecemos a ela. Quando vamos treinar um algoritmo para evolui-lo, e torná-lo mais assertivo nas tomadas de decisões, esse treinamento podemos fazer de duas formas:

Treinamento machine learning Supervisionado

No conjunto de dados de treinamento, existe uma variável chamada TARGET, que é o que queremos descobrir normalmente, preve-la no resultado final. Mas, essa característica foi colocada lá “manualmente”, por um humano. Fomos nós, seres humanos, que nomeamos esse grupo de coisas com esse nome e o modelo possui uma referência do que esta certo, e do que esta errado.

Treinamento de machine learning não supervisionado

Diferente do supervisionado, esse não possui um target nomeando cada coisa ou categoria, para se referenciar ou agrupar coisas parecidas. Essa forma, o algoritmo precisa de maneira independente agrupar os itens parecidos, não irá nomea-los, pois ele não conhece realmente o que é , mas sabe que são parecidos, levando em consideração as caraterísticas conhecidas por ele.

Vantagens e desvantagens

Como a maioria das coisas, existem vantagens e desvantagens de cada treinamento. Quando um aprendizado é supervisionado, precisamos avaliar muito bem nossa base de teste, classifica-la, muitas vezes conhecer bem o negócio que estamos desenvolvendo para evitar sinônimos, ou ate target com regionalismos, como por exemplo o nome de uma fruta, pode ter diferentes nomes no país, mexerica, bergamota ou tangerina, por exemplo.

Já no não supervisionado, precisamos gastar um tempo maior, ja que não temos um rótulo para avaliar, e mesmo sendo não supervisionado, as vezes irá precisar de uma intervenção humana para resultados mais satisfatórios.

Qual modelo de treinamento escolher?

Sem dúvidas a origem e qualidade da base de treinamento é um fator quase que determinante para a escolha inicial de um modelo de treinamento. O Problema ja é conhecido, ou estamos tentando usar aprendizagem de máquina para gerar insigths e descobrir coisas?

A escolha de um método não é imutável, ela pode ser alterado com o tempo. E com os resultados que forem obtidos. Pode se iniciar não supervisionado para agrupar e em seguida identificar os grupos.

Usufruir dos dois meios é uma boa prática, ja que durante uma aprendizagem não supervisionada pode ser identificado padrões ate então desconhecidos. Padrões que poderiam passar despercebidos caso fosse em uma supervisionada, usando target.

O post Treinamento de Machine Learning supervisionado ou não apareceu primeiro em Ramon Domingos Blog.

Pense como um sendo a evolução do outro, e estando diretamente ligado ao conceito anterior. Formando a base, sendo pilares da IA.

O que é machine learning?

Nessa abordagem é necessário dados. Com um volume de dados os algoritmos, organizam, reconhecem padrões, dessa forma, fazem com o que as máquinas aprendam, criando modelos para tomada de decisões.

Esses algoritmos, são instruções, passo-a-passo que devem ser executados com essa base de dados afim de identificar padrões. O termo parece novo, mas em 1956 as definições de inteligência ja eram conhecidas. Mas a tecnologia de hardware da época não permitia a evolução e por em prática toda a teoria estudada. O Objetivo da aprendizagem de máquina é fazer os computadores encontrar respostas para coisas que eles não foram propriamente programados.

A Kizzy do Programação Dinâmica tem um vídeo que comenta e mostra um exemplo de como identificar as frutas de forma convencional, onde precisamos usar comparadores if/else. Em seguida o mesmo exemplo usando técnicas de aprendizagem de máquina.

Pensando numa análise de crédito onde temos o escore de crédito poderíamos fazer algo como:

def analisa_credito(escore:int, salario:int):
  if escore > 900:
     return  salario * 3;
  elif escore > 600:
     return salario * 2;
  else:
    return 0
}

Mas sabemos que não existem apenas essas varáveis para analisar o crédito, e a medida que adicionamos mais propriedade referente a pessoa, como histórico de pagamentos de outros cartões, valores investido no banco ou bens, se tornaria mais difícil fazer um código para essa finalidade ser realmente eficaz. O ideal é termos uma base de dados, com diferentes características e créditos concedidos e a máquina aprender com eles. Ordenando, identificando padrões para tomar decisões.

Quando a máquina aprender com uma base de dados, o modelo gerado é capaz de tomar decisões “confiáveis” quando submetido a novos dados. Ao invés de programarmos todos os resultados esperados, deixamos o software calcular.

O que é deep Learning?

Como ja comentei, esses termos e conceitos já existem desde a década de 1950. A principal diferença era os hardwares existentes na época, e a quantidade de dados que existiam para treinar os modelos.Então a deep learning se desenvolveu por volta de 2010, no momento em que surgiram computadores mais avançados e houve o aumento da quantidade de dados.

Um artigo da Rebekah Carter publicado no dia 6 de setembro de 2022, nos traz alguns números da quantidade de dados que existem hoje como:

• As empresas geram cerca de 2,000,000,000,000,000,000 bytes de dados por dia

• Cada ser humano criou cerca de 1.7 MB de dados por segundo em 2020

É um número muito grande e incomum de vermos escritos dessa forma, com tantos zeros, referente a quantidade dados gerados por dia por uma empresa. Todo momento estamos gerado dados, nossos equipamentos pessoais, nossas redes sociais, nosso relógio. Tudo esta produzindo dados sobre nosso comportamento e são analisados, existem máquinas aprendendo com nosso comportamento nesse exato momento. Mas, com tantos dados, os algoritmos da Deep learning são considerados de alto nível, e tentam imitar a rede neural do cérebro humano.

Dessa forma, podemos pensar sobre esses algoritmos, que são diversas camadas, não lineares, que simultaneamente são capazes de identificar imagens, reconhecer a fala humana, e decodificar audio, e realizar tarefas mais avançadas sem a interferência humana.

O post Diferença entre machine learning e deep learning apareceu primeiro em Ramon Domingos Blog.