from sklearn.

naive_bayes import MultinomialNB

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics import accuracy_score

# Dados de treinamento
train_data = ["O céu está azul", "Eu adoro cachorros", "O Brasil é um país grande"]
train_labels = ["clima", "animais", "país"]

# Dados de teste
test_data = ["O sol está quente", "Gatos são animais legais", "A França é um país bonito"]
test_labels = ["clima", "animais", "país"]

# Vetorização dos dados

vectorizer = CountVectorizer()
train_vectors = vectorizer.fit_transform(train_data)
test_vectors = vectorizer.transform(test_data)

# Treinamento do modelo
clf = MultinomialNB()
clf.fit(train_vectors, train_labels)

# Predição dos dados de teste

pred_labels = clf.predict(test_vectors)

# Avaliação do modelo
accuracy = accuracy_score(test_labels, pred_labels)
print("Acurácia do modelo: ", accuracy)
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Dados de treinamento e teste

X_train = ['Isso é um texto de treinamento', 'Este é outro texto de treinamento', 'Mais um
texto de treinamento']
y_train = [0, 1, 1]
X_test = ['Este é um texto de teste', 'Outro texto de teste']
y_test = [0, 1]

# Vetorização dos dados de texto

vectorizer = CountVectorizer()
X_train_vec = vectorizer.fit_transform(X_train)
X_test_vec = vectorizer.transform(X_test)

# Treinamento do modelo Naive Bayes

clf = MultinomialNB()
clf.fit(X_train_vec, y_train)
# Classificação dos dados de teste e cálculo da acurácia
y_pred = clf.predict(X_test_vec)
accuracy = accuracy_score(y_test, y_pred)
print('Acurácia:', accuracy)

import cv2

# Carregamento da imagem
img = cv2.imread('imagem.jpg')

# Conversão para escala de cinza

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Detecção de rostos usando Cascade Classifier

face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
faces = face_cascade.detectMultiScale(gray, 1.3, 5)

# Desenho de retângulos ao redor dos rostos detectados

for (x, y, w, h) in faces:
cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2)

# Exibição da imagem com os retângulos

cv2.imshow('Imagem', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

from sklearn.cluster import KMeans

from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt

# Dados de exemplo
X, y = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)

# Clusterização usando k-means

kmeans = KMeans(n_clusters=4)
kmeans.fit(X)

# Plot dos dados com as regiões de clusterização

plt.scatter(X[:, 0], X[:, 1], c=kmeans.labels_, cmap='viridis')
plt.show()

from tensorflow.keras.preprocessing.text import Tokenizer

from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.layers import Embedding, LSTM, Dense
from tensorflow.keras.models import Sequential

#Pré-processamento dos dados:

import pandas as pd
import nltk
nltk.download('stopwords')
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer

data = pd.read_csv('dataset.csv')

stopwords = set(stopwords.words('english'))
lemmatizer = WordNetLemmatizer()

def preprocess_text(text):
words = word_tokenize(text)
words = [w.lower() for w in words if w.isalpha() and w.lower() not in stopwords]
words = [lemmatizer.lemmatize(w) for w in words]
return ' '.join(words)

data['preprocessed_text'] = data['text'].apply(preprocess_text)

#Criação do modelo de classificação Naive Bayes:

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score, classification_report
from sklearn.model_selection import train_test_split

vectorizer = CountVectorizer()
X = vectorizer.fit_transform(data['preprocessed_text'])
y = data['label']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

clf = MultinomialNB()
clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

print(classification_report(y_test, y_pred))
print('Accuracy: {:.2f}%'.format(accuracy_score(y_test, y_pred)*100))

#Criação do modelo de classificação SVM:

from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report

X = vectorizer.fit_transform(data['preprocessed_text'])
y = data['label']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

clf = SVC(kernel='linear')
clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

print(classification_report(y_test, y_pred))
print('Accuracy: {:.2f}%'.format(accuracy_score(y_test, y_pred)*100))

#Criação do modelo de agrupamento k-means:

from sklearn.cluster import KMeans
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

X = vectorizer.fit_transform(data['preprocessed_text'])

pca = PCA(n_components=2).fit(X.toarray())
X_pca = pca.transform(X.toarray())

kmeans = KMeans(n_clusters=3, random_state=0).fit(X_pca)

colors = ['r', 'g', 'b']

for i in range(len(X_pca)):
plt.scatter(X_pca[i, 0], X_pca[i, 1], c=colors[kmeans.labels_[i]])

plt.show()

#Criação do modelo de agrupamento hierárquico:

from sklearn.cluster import AgglomerativeClustering

X = vectorizer.fit_transform(data['preprocessed_text'])

agg_clustering = AgglomerativeClustering(n_clusters=3)
agg_clustering.fit(X.toarray())

cluster_labels = agg_clustering.labels_

from sklearn.naive_bayes import MultinomialNB

from sklearn.svm import SVC
from sklearn.cluster import KMeans
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score
from transformers import pipeline

# Definindo os modelos
nb_model = MultinomialNB()
svm_model = SVC(kernel='linear', C=1.0)
kmeans_model = KMeans(n_clusters=2)
lstm_model = MLPClassifier(hidden_layer_sizes=(100,), activation='relu', solver='adam',
max_iter=1000)

nlp_pipeline = pipeline("text-classification", model="nlptown/bert-base-multilingual-uncased-

sentiment")

# Função que executa todos os modelos

def predict(text):
# Executando o modelo Naive Bayes
nb_model.fit(X_train, y_train)
nb_pred = nb_model.predict(X_test)
nb_acc = accuracy_score(y_test, nb_pred)

if nb_acc < 0.8666666:

# Executando o modelo SVM
svm_model.fit(X_train, y_train)
svm_pred = svm_model.predict(X_test)
svm_acc = accuracy_score(y_test, svm_pred)

if svm_acc < 0.8666666:

# Executando o modelo de clusterização KMeans
kmeans_model.fit(X_train)
kmeans_pred = kmeans_model.predict(X_test)
kmeans_acc = accuracy_score(y_test, kmeans_pred)

if kmeans_acc < 0.8666666:

# Executando o modelo LSTM
lstm_model.fit(X_train, y_train)
lstm_pred = lstm_model.predict(X_test)
lstm_acc = accuracy_score(y_test, lstm_pred)

if lstm_acc < 0.8666666:

# Executando o modelo de processamento de linguagem natural
nlp_pred = nlp_pipeline(text)[0]
return nlp_pred['label']
else:
return lstm_pred
else:
return kmeans_pred
else:
return svm_pred
else:
return nb_pred