UNIVERSIDADE ANHANGUERA

LINGUAGEM DE PROGRAMAÇÃO

MAXMILLIAN DE PAES SILVA

RELATÓRIO DE AULA PRÁTICA IV:

Aplicações com Python - Machine Learning com Python

HORTOLÂNDIA/SP
2025
 1 Objetivos
1.1 ObjetivoGeral

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 ObjetivosEspecí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 impor tensorflow as tf
3 t pandas as pd
4 impor
from [Link] import load_iris
t
2
5 from sklearn.model_selection import train_test_split
6 from [Link] import StandardScaler
7 from [Link] import classification_report, accuracy_score
8

9 # Carregar o conjunto de dados Iris

10 iris = load_iris()
11 X = [Link]
12 y = [Link]

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é-processamentodos 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 = [Link](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 [Link] import load_iris
5 from sklearn.model_selection import train_test_split
6 from [Link] import StandardScaler
7 from [Link] import classification_report, accuracy_score
8

9 # Carregar o conjunto de dados Iris

10 iris = load_iris()
11 X = [Link]
12 y = [Link]

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é-processamentodos 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 = [Link](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 m o d e=
l [Link]([
3 [Link](10, activation=’relu’, input_shape=(4,)),
4 [Link](8, activation=’relu’),
5 [Link](3, activation=’softmax’) # 3 classes
6 ])
7

8 # Compilar o modelo
9 [Link](optimizer=’adam’,
10 loss=’sparse_categorical_crossentropy’,
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 [Link](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 = [Link](X_test, y_test)
3 print(f"\nAcurácia no conjunto de teste: {accuracy * 100:.2f}%")
4

5 # Relatório detalhado
6 y_pred = [Link](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 n o v o s _ d a d o s= s c a l e r . t r a n s f o r m ( n o v o s _ d a d o s )
4 predicao = [Link](novos_dados)
5 classe_predita = iris.target_names[[Link]()]
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 impor tensorflow as tf
3 t pandas as pd
4 impor
fro [Link] import load_iris
5 tm sklearn.model_selection import train_test_split
6 fro [Link] import StandardScaler
7 m [Link] import classification_report, accuracy_score
8 fro
9 m Carregar o conjunto de dados Iris
#
10 fro
iris = load_iris()
11 m = [Link]
X
12 y = [Link]
13

14 # Passo# 2: Pré-processamentodos Dados

15 X_train,
Dividir entre treino e teste
16 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 = s c a l e r . f i t _ t r a n s f o r m ( X _ t r a i n )
21 X_test = s c a l e r . t r a n s f o r m ( X _ t e s t )
22

23 # Passo 3: Construir o Modelo com TensorFlow

24 model= [Link]([
25 [Link](10, activation=’relu’, input_shape=(4,)),
26 [Link](8, activation=’relu’),
27 [Link](3, activation=’softmax’) # 3 classes
28 ])
29

30 # Compilar o modelo
31 [Link](optimizer=’adam’,
32 loss=’sparse_categorical_crossentropy’,
33 metrics=[’accuracy’])
34

35 # Passo 4: Treinar o Modelo

36 [Link](X_train, y_train, epochs=50, batch_size=5, verbose=1)
37

38 # Passo 5: Avaliar o Modelo

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

42 # Relatório detalhado
43 y_pred = m o d e l . p r e d i c t ( X _ t e s t )
44 y_pred_classes = y _ p r e d . a r g m a x ( a x i s = 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 n o v o s _ d a d o s= s c a l e r . t r a n s f o r m ( n o v o s _ d a d o s )
51 predicao = [Link](novos_dados)
52 classe_predita = iris.target_names[[Link]()]
53 print(f"\nPrevisão para nova flor: {classe_predita}")