UNIVERSIDADE ANHANGUERA

CIÊNCIA DE DADOS
LINGUAGEM DE PROGRAMAÇÃO

LEONARDO FELIPE AIRES DA SILVA

RELATÓRIO DE AULA PRÁTICA IV:

Aplicações com Python - Machine Learning com Python

Santa Maria/RS
2025
 1 Objetivos

1.1 Objetivo Geral

O objetivo desta atividade prática é desenvolver um modelo de Machine Learning
utilizando a linguagem Python para classificar espécies de flores Iris com base em características
como comprimento e largura das sépalas e pétalas. Para isso, será utilizada uma rede neural
simples implementada com a biblioteca TensorFlow.

1.2 Objetivos Específicos

Os objetivos específicos da atividade são:

1. Importar as bibliotecas necessárias e carregar o conjunto de dados Iris disponível no

scikit-learn.

2. Realizar o pré-processamento dos dados, incluindo a divisão entre treino e teste e a

normalização.

3. Construir uma rede neural simples utilizando TensorFlow.

4. Treinar o modelo com os dados de treinamento.

5. Avaliar a performance do modelo com os dados de teste.

6. Realizar previsões com o modelo treinado.

2 Desenvolvimento

2.1 Passo 1 - Importar Bibliotecas e Carregar Dados

O primeiro passo consiste em importar as bibliotecas necessárias para a construção e
treinamento do modelo de machine learning. São utilizadas as bibliotecas TensorFlow para
definição da rede neural, pandas para organização dos dados e scikit-learn para carregamento
do conjunto de dados Iris e outras tarefas auxiliares.
O conjunto de dados Iris contém medições de comprimento e largura das sépalas e
pétalas de três espécies de flores. Após o carregamento, os dados são separados em variáveis
independentes (X) e variável alvo (y).
1 # Passo 1: Importar bibliotecas e carregar dados
2 import tensorflow as tf
3 import pandas as pd
4 from sklearn . datasets import load_iris

2
 5 from sklearn . model_selection import train_test_split
6 from sklearn . preprocessing import StandardScaler
7 from sklearn . metrics import classification_report , accuracy_score
8

9 # Carregar o conjunto de dados Iris

10 iris = load_iris ()
11 X = iris . data
12 y = iris . target

2.2 Passo 2 - Pré-processamento dos Dados

Com os dados carregados, realiza-se o pré-processamento necessário para treinar o
modelo. Primeiramente, o conjunto é dividido em dados de treino e teste utilizando a função
train_test_split da biblioteca scikit-learn, com 80% para treino e 20% para teste.
Em seguida, os dados são normalizados utilizando StandardScaler, o que padroniza
as variáveis para que possuam média 0 e desvio padrão 1. Isso é importante para garantir melhor
desempenho e estabilidade durante o treinamento do modelo.
1 # Passo 2: Pr é - processamento dos Dados
2 # Dividir entre treino e teste
3 X_train , X_test , y_train , y_test = train_test_split (X , y , test_size
=0.2 , random_state =42)
4

5 # Normalizar os dados
6 scaler = StandardScaler ()
7 X_train = scaler . fit_transform ( X_train )
8 X_test = scaler . transform ( X_test )

3 Desenvolvimento

3.1 Passo 1 - Importar Bibliotecas e Carregar Dados

O primeiro passo consiste em importar as bibliotecas necessárias para a construção e
treinamento do modelo de machine learning. São utilizadas as bibliotecas TensorFlow para
definição da rede neural, pandas para organização dos dados e scikit-learn para carregamento
do conjunto de dados Iris e outras tarefas auxiliares.
O conjunto de dados Iris contém medições de comprimento e largura das sépalas e
pétalas de três espécies de flores. Após o carregamento, os dados são separados em variáveis
independentes (X) e variável alvo (y).
1 # Passo 1: Importar bibliotecas e carregar dados

3
 2 import tensorflow as tf
3 import pandas as pd
4 from sklearn . datasets import load_iris
5 from sklearn . model_selection import train_test_split
6 from sklearn . preprocessing import StandardScaler
7 from sklearn . metrics import classification_report , accuracy_score
8

9 # Carregar o conjunto de dados Iris

10 iris = load_iris ()
11 X = iris . data
12 y = iris . target

3.2 Passo 2 - Pré-processamento dos Dados

Com os dados carregados, realiza-se o pré-processamento necessário para treinar o
modelo. Primeiramente, o conjunto é dividido em dados de treino e teste utilizando a função
train_test_split da biblioteca scikit-learn, com 80% para treino e 20% para teste.
Em seguida, os dados são normalizados utilizando StandardScaler, o que padroniza
as variáveis para que possuam média 0 e desvio padrão 1. Isso é importante para garantir melhor
desempenho e estabilidade durante o treinamento do modelo.
1 # Passo 2: Pr é - processamento dos Dados
2 # Dividir entre treino e teste
3 X_train , X_test , y_train , y_test = train_test_split (X , y , test_size
=0.2 , random_state =42)
4

5 # Normalizar os dados
6 scaler = StandardScaler ()
7 X_train = scaler . fit_transform ( X_train )
8 X_test = scaler . transform ( X_test )

3.3 Passo 3 - Construir o Modelo

Nesta etapa, é construída uma rede neural simples utilizando a biblioteca TensorFlow. O
modelo é sequencial e contém três camadas densas (fully connected). A primeira camada possui
10 neurônios com função de ativação ReLU, a segunda possui 8 neurônios também com ativação
ReLU, e a camada de saída possui 3 neurônios com ativação softmax — um para cada classe do
conjunto de dados Iris.
Em seguida, o modelo é compilado utilizando o otimizador adam, a função de perda
sparse_categorical_crossentropy (adequada para classificação multiclasse com rótulos
inteiros), e a métrica de acurácia.

4
 1 # Passo 3: Construir o Modelo com TensorFlow
2 model = tf . keras . models . Sequential ([
3 tf . keras . layers . Dense (10 , activation = ’ relu ’ , input_shape =(4 ,) ) ,
4 tf . keras . layers . Dense (8 , activation = ’ relu ’) ,
5 tf . keras . layers . Dense (3 , activation = ’ softmax ’) # 3 classes
6 ])
7

8 # Compilar o modelo
9 model . compile ( optimizer = ’ adam ’ ,
10 loss = ’ s p a r s e _ c a t e g o r i c a l _ c r o s s e n t r o p y ’ ,
11 metrics =[ ’ accuracy ’ ])

3.4 Passo 4 - Treinar o Modelo

Com o modelo definido e compilado, o próximo passo é treiná-lo utilizando os dados de
treinamento. O processo é realizado com 50 épocas (epochs) e um tamanho de lote (batch size)
de 5. Durante o treinamento, o modelo ajusta seus pesos para minimizar a função de perda e
melhorar sua acurácia.
O parâmetro verbose=1 permite acompanhar o progresso de cada época no terminal.
1 # Passo 4: Treinar o Modelo
2 model . fit ( X_train , y_train , epochs =50 , batch_size =5 , verbose =1)

3.5 Passo 5 - Avaliar o Modelo

Após o treinamento, o modelo é avaliado com os dados de teste para verificar seu
desempenho. São calculados a perda (loss) e a acurácia no conjunto de teste.
Além disso, é gerado um relatório de classificação contendo métricas detalhadas como
precisão, revocação e F1-score para cada uma das três classes, utilizando a função classification_report
da biblioteca scikit-learn.
1 # Passo 5: Avaliar o Modelo
2 loss , accuracy = model . evaluate ( X_test , y_test )
3 print ( f " \ nAcur á cia no conjunto de teste : { accuracy * 100:.2 f }% " )
4

5 # Relat ó rio detalhado

6 y_pred = model . predict ( X_test )
7 y_pred_classes = y_pred . argmax ( axis =1)
8 print ( " \ nRelat ó rio de Classifica ç ã o : " )
9 print ( classification_report ( y_test , y_pred_classes , target_names =
iris . target_names ) )

5
 3.6 Passo 6 - Fazer Previsões
Por fim, o modelo treinado é utilizado para realizar previsões com novos dados. No
exemplo, é fornecido um vetor com quatro características correspondentes a uma flor, e o modelo
retorna a classe prevista com base no padrão aprendido.
Antes da previsão, os dados de entrada também são normalizados utilizando o mesmo
scaler empregado no treinamento.
1 # Passo 6: Fazer Previs õ es ( exemplo )
2 novos_dados = [[5.1 , 3.5 , 1.4 , 0.2]] # sepal_length , sepal_width ,
petal_length , petal_width
3 novos_dados = scaler . transform ( novos_dados )
4 predicao = model . predict ( novos_dados )
5 classe_predita = iris . target_names [ predicao . argmax () ]
6 print ( f " \ nPrevis ã o para nova flor : { classe_predita } " )

4 Resultados
A execução do modelo de machine learning foi realizada no Google Colab, onde foi
possível verificar o funcionamento correto de todas as etapas: carregamento e pré-processamento
dos dados, construção da rede neural, treinamento, avaliação do desempenho e realização de
previsões.
A imagem a seguir mostra a execução no ambiente Colab, incluindo a acurácia obtida, o
relatório de classificação e o resultado da previsão para um novo exemplo.

6
7
 Anexo - Código Completo
1 # Passo 1: Importar bibliotecas e carregar dados
2 import tensorflow as tf
3 import pandas as pd
4 from sklearn . datasets import load_iris
5 from sklearn . model_selection import train_test_split
6 from sklearn . preprocessing import StandardScaler
7 from sklearn . metrics import classification_report , accuracy_score
8

9 # Carregar o conjunto de dados Iris

10 iris = load_iris ()
11 X = iris . data
12 y = iris . target
13

14 # Passo 2: Pr é - processamento dos Dados

15 # Dividir entre treino e teste
16 X_train , X_test , y_train , y_test = train_test_split (X , y , test_size
=0.2 , random_state =42)
17

18 # Normalizar os dados
19 scaler = StandardScaler ()
20 X_train = scaler . fit_transform ( X_train )
21 X_test = scaler . transform ( X_test )
22

23 # Passo 3: Construir o Modelo com TensorFlow

24 model = tf . keras . models . Sequential ([
25 tf . keras . layers . Dense (10 , activation = ’ relu ’ , input_shape =(4 ,) ) ,
26 tf . keras . layers . Dense (8 , activation = ’ relu ’) ,
27 tf . keras . layers . Dense (3 , activation = ’ softmax ’) # 3 classes
28 ])
29

30 # Compilar o modelo
31 model . compile ( optimizer = ’ adam ’ ,
32 loss = ’ s p a r s e _ c a t e g o r i c a l _ c r o s s e n t r o p y ’ ,
33 metrics =[ ’ accuracy ’ ])
34

35 # Passo 4: Treinar o Modelo

36 model . fit ( X_train , y_train , epochs =50 , batch_size =5 , verbose =1)
37

38 # Passo 5: Avaliar o Modelo

8
39 loss , accuracy = model . evaluate ( X_test , y_test )
40 print ( f " \ nAcur á cia no conjunto de teste : { accuracy * 100:.2 f }% " )
41

42 # Relat ó rio detalhado

43 y_pred = model . predict ( X_test )
44 y_pred_classes = y_pred . argmax ( axis =1)
45 print ( " \ nRelat ó rio de Classifica ç ã o : " )
46 print ( classification_report ( y_test , y_pred_classes , target_names =
iris . target_names ) )
47

48 # Passo 6: Fazer Previs õ es ( exemplo )

49 novos_dados = [[5.1 , 3.5 , 1.4 , 0.2]] # sepal_length , sepal_width ,
petal_length , petal_width
50 novos_dados = scaler . transform ( novos_dados )
51 predicao = model . predict ( novos_dados )
52 classe_predita = iris . target_names [ predicao . argmax () ]
53 print ( f " \ nPrevis ã o para nova flor : { classe_predita } " )