Introdução à Inteligência Artificial com Python e Suas Bibliotecas

Quando o assunto é Inteligência Artificial, muita gente desiste antes de começar por causa da linguagem técnica, tutoriais confusos e exemplos distantes da realidade. Este artigo é para quem quer aprender de forma prática, clara e sem rodeios como usar Python com bibliotecas de IA – mesmo que esteja começando agora.

Tópicos abordados neste artigo:

🤖 Introdução
💡 O que é Inteligência Artificial?
🐍 Por que Python é a linguagem ideal para IA?
🧰 Principais bibliotecas de IA em Python
💡 Exemplo prático na veia: classificação de dígitos escritos à mão com IA
🔚 Conclusão
📚 Referências

1. 🤖 Introdução

A Inteligência Artificial está crescendo a cada dia no mundo todo de forma muito rápida, desde análise de dados até desenvolvimento de aplicativos inteligentes.

Como a IA está avançando mundialmente, destacamos uma linguagem de programação que se destacou por ser mais usada junto com a IA: o Python. A pergunta que mais se faz é: Por quê o Python? A resposta é que essa linguagem é bem simples de ser aplicado.

Mais pra frente será explicado melhor como o Python se destacou e também como a IA se juntou com algumas bibliotecas que será destacado. Mas o que são essas bibliotecas? São pacotes de códigos prontos que podem ser exportados para ser utilizado em diferentes projetos, assim evitando que o desenvolvedor desenvolva do zero o seu projeto.

2. 💡 O que é Inteligência Artificial?

A IA está evoluindo, mas o que é a Inteligência Artificial? Como se define? Antes de seguir para o próximo tópico, a definição de Inteligência Artificial é importante para entender e seguir para o próximo tópico. A Inteligência Artificial (IA) é definido como um conjunto de tecnologias que permitem executar várias funções como analisar dados, traduzir idiomas escritos.

Como ela funciona? Como no parágrafo anterior, o princípio básico são os dados. Com esses dados, a IA acaba aprendendo e melhorando por meio dessa exposição de dados. Mais pra frente será explicado por meio de exemplos de bibliotecas.

Porém dependendo do aprendizado envolve algoritmos, um conjunto de regras que orientam a análise e a tomada de decisões da IA. Em Machine Learning, um subconjunto conhecido da IA, algoritmos são treinados em dados rotulados ou não rotulados para fazer previsões ou categorizar informações. Já o Deep Learning utiliza de redes neurais artificiais com várias camadas para poder processar orientações, imitando a estrutura de um cérebro humano.

3. 🐍 Por que Python é a linguagem ideal para IA?

Por que o Python? A resposta é que essa linguagem de programação de alto nível, interpretada, imperativa, orientada a objetos e funcional, se destacando por sua simplicidade e legibilidade, tornando uma excelente opção para iniciantes e profissionais experientes.

Alguns destaques abaixo:

Simplicidade e Facilidade de Uso: Python é conhecida por sua sintaxe simples e direta, que facilita o aprendizado e a escrita de código. Isso permite que os desenvolvedores foquem mais na lógica do problema a ser resolvido do que na sintaxe da linguagem.
Integração com APIs: Python é a principal linguagem para integração com APIs de IA, como a API da OpenAI. Isso facilita a criação de aplicações que utilizam modelos avançados de linguagem, como o ChatGPT, para realizar tarefas como geração de texto, tradução, e até mesmo transcrição de áudios.

No próximo tópico, será mostrado algumas bibliotecas e na prática deles.

4. 🧰 Principais bibliotecas de IA em Python

No Python, existem diversas bibliotecas voltados para IA e Machine Learning. Essas ferramentas facilitam o desenvolvimento de modelos de IA de forma rápida e eficiente. Além disso, a maior parte da documentação dessas bibliotecas é em Python, o que torna o processo de aprendizado ainda mais acessível. Abaixo algumas bibliotecas:

Pandas

Uma biblioteca utilizada para manipulação de dados estruturados fornecendo estruturas de dados flexíveis, transformação e análise de dados.

import pandas as pd

dataset = pd.read_csv('https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv')

print(dataset.head())

NumPy

Uma biblioteca utilizada para operações matemáticas e vetoriais.

import numpy as np


a = np.array([1, 2, 3, 4])          
b = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]) 


print(a)
print('_' * 10)
print(b)

Scikit-learn

Uma biblioteca de código aberto usada para criar modelos preditivos.

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression


# Definindo os dados diretamente (sem pandas)
# Exemplo: área de casas (X) e seus respectivos preços (y)
X = [[50], [60], [70], [80], [90], [100], [110], [120]]  # lista de listas para manter o formato 2D
y = [150, 180, 210, 240, 270, 300, 330, 360]             # lista 1D


# Dividir os dados em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Criar e treinar o modelo
modelo = LinearRegression()
modelo.fit(X_train, y_train)


# Fazer previsões
previsoes = modelo.predict(X_test)


# Exibir resultados
print("Valores reais:", y_test)
print("Previsões:", previsoes)

Pytorch

Uma biblioteca de Machine Learning de código aberto, utilizada para treinamentos.

import torch
import torch.nn as nn
import torch.optim as optim


# Dados de entrada (ex: área de casas) e saída (ex: preço)
# X precisa estar no formato [ [x1], [x2], ..., [xn] ]
X = torch.tensor([[50.0], [60.0], [70.0], [80.0], [90.0], [100.0], [110.0], [120.0]])
y = torch.tensor([[150.0], [180.0], [210.0], [240.0], [270.0], [300.0], [330.0], [360.0]])


# Definir o modelo
model = nn.Linear(in_features=1, out_features=1)


# Função de perda (erro quadrático médio)
criterio = nn.MSELoss()


# Otimizador (gradiente descendente)
otimizador = optim.SGD(model.parameters(), lr=0.0001)


# Treinamento
for epoca in range(1000):
  # Forward
  predicao = model(X)
  perda = criterio(predicao, y)


  # Backward
  otimizador.zero_grad()
  perda.backward()
  otimizador.step()


  # Mostrar progresso a cada 100 épocas
  if epoca % 100 == 0:
      print(f'Época {epoca}, Perda: {perda.item():.2f}')


# Fazer uma previsão com novo valor
entrada_nova = torch.tensor([[105.0]])
saida_prevista = model(entrada_nova).item()
print(f'\nPreço previsto para área 105: {saida_prevista:.2f}')

TensorFlow / Keras

O TensorFlow é uma biblioteca de código aberto para modelos de Deep Learning. Já o Keras atua como uma interface para o TensorFlow.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers


# Criar tensores para entrada (X) e saída (y)
X = tf.constant([[50], [60], [70], [80], [90], [100], [110], [120]], dtype=tf.float32)
y = tf.constant([150, 180, 210, 240, 270, 300, 330, 360], dtype=tf.float32)


# Modelo simples de regressão linear
model = keras.Sequential([
  layers.Dense(units=1, input_shape=[1])
])


# Compilar o modelo
model.compile(optimizer='sgd', loss='mean_squared_error')


# Treinar o modelo (funciona com tensores)
model.fit(X, y, epochs=500, verbose=0)


# Fazer previsão
nova_area = tf.constant([[105]], dtype=tf.float32)
previsao = model.predict(nova_area)


print(f"Preço previsto para área 105: {previsao[0][0]:.2f}")

OpenCv

Uma biblioteca utilizada para visão computacional e processamento de imagens.

import cv2
from google.colab.patches import cv2_imshow  # <- Importa a função compatível com Colab


# Carregar a imagem
imagem = cv2.imread('Machine-Learning.png') #nome do arquivo quando salva no computador


# Verificar se a imagem foi carregada com sucesso
if imagem is None:
  print("Erro ao carregar a imagem.")
else:
  # Exibir a imagem no Colab
  cv2_imshow(imagem)


  # (cv2.waitKey e cv2.destroyAllWindows não são necessários no Colab)


  # Salvar uma cópia da imagem
  cv2.imwrite('imagem_copia.jpg', imagem)

Esses foram alguns exemplos de bibliotecas que podem ser usados, mas ainda tem vários.

5.💡 Exemplo prático na veia: classificação de dígitos escritos à mão com IA

🧠 Objetivo

Criar um modelo de IA que reconhece números de 0 a 9 com base em imagens pequenas (8x8 pixels) de dígitos escritos à mão.

Importar os dados:

from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt


# Carregando o conjunto de dados Digits
digits = load_digits()
X = digits.data     # imagens em formato de vetor (64 pixels)
y = digits.target   # rótulos (números de 0 a 9)

Dividir o treino e o teste:

# Dividindo os dados em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

Criar e treinar o modelo (utilizado o modelo Random Forest):

# Criando e treinando o modelo (Random Forest)
modelo = RandomForestClassifier()
modelo.fit(X_train, y_train)

Fazer e avaliar o modelo:

# Fazendo previsões
y_pred = modelo.predict(X_test)


# Avaliando o modelo
precisao = accuracy_score(y_test, y_pred)
print(f"Acurácia do modelo: {precisao:.2f}")

Mostrar a imagem:

# Mostrando algumas imagens com previsões
for i in range(5):
  plt.imshow(X_test[i].reshape(8, 8), cmap='gray')
  plt.title(f"Previsto: {y_pred[i]}, Real: {y_test[i]}")
  plt.axis('off')
  plt.show()

Neste exemplo prático, o modelo deveria atingir uma acurácia acima de 95%, dependendo do modelo e configuração. E este foi o resultado com imagens.

6.🔚 Conclusão

A Inteligência Artificial vem transformando o mundo em ritmo acelerado, impactando desde áreas acadêmicas até setores industriais e comerciais. Neste artigo, vimos que, por trás dessa revolução tecnológica, há uma linguagem que se destaca por sua simplicidade, flexibilidade e poder: o Python.

Com sua sintaxe acessível e vasta coleção de bibliotecas voltadas para ciência de dados, machine learning e deep learning, o Python se consolidou como a principal linguagem para o desenvolvimento de soluções baseadas em IA. Ferramentas como Pandas, NumPy, Scikit-learn, PyTorch, TensorFlow e OpenCV demonstram como é possível manipular dados, treinar modelos inteligentes e até processar imagens de forma eficiente e acessível.

Além da teoria, aplicamos esse conhecimento em um exemplo prático de classificação de dígitos escritos à mão, que mostrou como é simples treinar e testar um modelo de IA com poucas linhas de código. Isso comprova que a Inteligência Artificial, antes vista como algo distante e complexo, está cada vez mais acessível a estudantes, pesquisadores e desenvolvedores de todos os níveis.

O próximo passo? Continuar explorando, praticando e aplicando a IA em problemas do mundo real. O Python e suas bibliotecas estão aí para apoiar essa jornada.

7.📚 Referências

GOOGLE CLOUD. O que é inteligência artificial (IA)? Disponível em: https://cloud.google.com/learn/what-is-artificial-intelligence?hl=pt-BR.

SIMOV ACADEMY. Inteligência Artificial com Python: por que usar Python para trabalhar com IA? Disponível em: https://hub.asimov.academy/tutorial/inteligencia-artificial-com-python-por-que-usar-python-para-trabalhar-com-ia/.

GHIRARDELLO, Giovanna. Lista com as principais bibliotecas Python [atualizado 2024]. Disponível em: https://blog.botcity.dev/pt-br/2024/01/15/bibliotecas-python/.