import numpy as np

# Criação de arrays
array_1d = np.array([1, 2, 3, 4, 5])
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
array_zeros = np.zeros((3, 3))
array_ones = np.ones((2, 4))
array_range = np.arange(0, 10, 2)  # 0, 2, 4, 6, 8
array_linspace = np.linspace(0, 1, 5)  # 5 números entre 0 e 1

print("Array 1D:", array_1d)
print("Array 2D:")
print(array_2d)
print("Shape do array 2D:", array_2d.shape)
print("Tipo de dados:", array_2d.dtype)

# Operações matemáticas
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

print("Soma:", a + b)
print("Multiplicação elemento a elemento:", a * b)
print("Produto escalar:", np.dot(a, b))
print("Média:", np.mean(a))
print("Desvio padrão:", np.std(a))

# Reshaping e indexação
matriz = np.arange(12).reshape(3, 4)
print("Matriz 3x4:")
print(matriz)
print("Primeira linha:", matriz[0, :])
print("Primeira coluna:", matriz[:, 0])
print("Elemento [1,2]:", matriz[1, 2])

import pandas as pd
import numpy as np

# Criando DataFrames
dados = {
    'nome': ['Ana', 'João', 'Maria', 'Pedro', 'Paula'],
    'idade': [25, 30, 35, 28, 32],
    'salario': [5000, 6000, 7000, 5500, 6500],
    'departamento': ['TI', 'RH', 'TI', 'Vendas', 'RH']
}

df = pd.DataFrame(dados)
print("DataFrame original:")
print(df)

# Informações básicas
print("\nInformações do DataFrame:")
print(df.info())
print("\nEstatísticas descritivas:")
print(df.describe())

# Seleção e filtragem
print("\nFiltro: idade > 30")
print(df[df['idade'] > 30])

print("\nApenas colunas nome e salario:")
print(df[['nome', 'salario']])

# Agrupamento
print("\nMédia de salário por departamento:")
print(df.groupby('departamento')['salario'].mean())

# Adicionando nova coluna
df['salario_anual'] = df['salario'] * 12
print("\nDataFrame com salário anual:")
print(df)

# Tratamento de dados missing
df_com_nan = df.copy()
df_com_nan.loc[2, 'salario'] = np.nan
print("\nDataFrame com valor missing:")
print(df_com_nan)

# Removendo ou preenchendo NaN
print("\nPreenchendo NaN com a média:")
df_com_nan['salario'].fillna(df_com_nan['salario'].mean(), inplace=True)
print(df_com_nan)

import numpy as np
import matplotlib.pyplot as plt

print("=== ÁLGEBRA LINEAR PARA IA ===")

# 1. VETORES - Representam características/features
vetor_pessoa1 = np.array([25, 70, 1.75])  # idade, peso, altura
vetor_pessoa2 = np.array([30, 80, 1.80])

print("Pessoa 1 (idade, peso, altura):", vetor_pessoa1)
print("Pessoa 2:", vetor_pessoa2)

# Distância euclidiana (similaridade entre pessoas)
distancia = np.linalg.norm(vetor_pessoa1 - vetor_pessoa2)
print(f"Distância entre pessoas: {distancia:.2f}")

# 2. MATRIZES - Conjuntos de dados
# Cada linha = uma pessoa, cada coluna = uma característica
dataset = np.array([
    [25, 70, 1.75],  # Pessoa 1
    [30, 80, 1.80],  # Pessoa 2
    [35, 90, 1.85],  # Pessoa 3
    [22, 65, 1.70]   # Pessoa 4
])

print("\nDataset (4 pessoas x 3 características):")
print(dataset)
print("Shape:", dataset.shape)

# Estatísticas por característica (coluna)
print("\nMédias por característica:")
print("Idade média:", np.mean(dataset[:, 0]))
print("Peso médio:", np.mean(dataset[:, 1]))
print("Altura média:", np.mean(dataset[:, 2]))

# 3. MULTIPLICAÇÃO DE MATRIZES - Base de muitos algoritmos
# Exemplo: transformação linear (normalização)
print("\n=== TRANSFORMAÇÕES LINEARES ===")

# Matriz de transformação para normalizar dados (z-score)
media = np.mean(dataset, axis=0)
desvio = np.std(dataset, axis=0)

print("Médias:", media)
print("Desvios padrão:", desvio)

# Normalização Z-score
dataset_normalizado = (dataset - media) / desvio
print("\nDataset normalizado (z-score):")
print(dataset_normalizado)

# 4. AUTOVALORES E AUTOVETORES - PCA (Principal Component Analysis)
print("\n=== ANÁLISE DE COMPONENTES PRINCIPAIS (PCA) ===")

# Matriz de covariância
cov_matrix = np.cov(dataset_normalizado.T)
print("Matriz de covariância:")
print(cov_matrix)

# Calcular autovalores e autovetores
autovalores, autovetores = np.linalg.eig(cov_matrix)
print("\nAutovalores (importância dos componentes):", autovalores)
print("Autovetores (direções dos componentes):")
print(autovetores)

# Ordenar por importância
idx = autovalores.argsort()[::-1]
autovalores = autovalores[idx]
autovetores = autovetores[:, idx]

print("\nComponentes ordenados por importância:")
for i, val in enumerate(autovalores):
    var_explicada = val / np.sum(autovalores) * 100
    print(f"Componente {i+1}: {var_explicada:.1f}% da variância")

# 5. PRODUTO ESCALAR - Similaridade de cosseno
def similaridade_cosseno(v1, v2):
    """Calcula similaridade de cosseno entre dois vetores"""
    return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))

# Exemplo: similaridade entre preferências musicais
# 0=não gosta, 5=gosta muito
pessoa_a = np.array([5, 1, 3, 4, 2])  # rock, pop, jazz, clássica, eletrônica
pessoa_b = np.array([4, 2, 3, 5, 1])
pessoa_c = np.array([1, 5, 2, 1, 5])

sim_ab = similaridade_cosseno(pessoa_a, pessoa_b)
sim_ac = similaridade_cosseno(pessoa_a, pessoa_c)

print(f"\n=== SISTEMA DE RECOMENDAÇÃO ===")
print(f"Similaridade A-B: {sim_ab:.3f}")
print(f"Similaridade A-C: {sim_ac:.3f}")

if sim_ab > sim_ac:
    print("Pessoa A tem gostos mais similares a B")
else:
    print("Pessoa A tem gostos mais similares a C")

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import stats

print("=== ESTATÍSTICA PARA INTELIGÊNCIA ARTIFICIAL ===")

# 1. DISTRIBUIÇÕES DE PROBABILIDADE
np.random.seed(42)

# Simulando dados de altura de uma população
alturas = np.random.normal(170, 10, 1000)  # média=170cm, desvio=10cm

print("Estatísticas descritivas das alturas:")
print(f"Média: {np.mean(alturas):.2f} cm")
print(f"Mediana: {np.median(alturas):.2f} cm")
print(f"Desvio padrão: {np.std(alturas):.2f} cm")
print(f"Variância: {np.var(alturas):.2f}")

# 2. TESTE DE HIPÓTESES
print("\n=== TESTE DE HIPÓTESES ===")

# H0: A altura média da população é 170cm
# H1: A altura média é diferente de 170cm
t_stat, p_value = stats.ttest_1samp(alturas, 170)

print(f"Estatística t: {t_stat:.4f}")
print(f"P-valor: {p_value:.4f}")

alpha = 0.05
if p_value < alpha:
    print(f"Rejeitamos H0 (p < {alpha}): A média é significativamente diferente de 170cm")
else:
    print(f"Não rejeitamos H0 (p >= {alpha}): Não há evidência de diferença")

# 3. CORRELAÇÃO E REGRESSÃO
print("\n=== ANÁLISE DE CORRELAÇÃO ===")

# Simulando dados de vendas vs. temperatura
temperatura = np.random.uniform(15, 35, 100)  # Temperatura em °C
# Vendas de sorvete correlacionadas com temperatura
vendas_sorvete = 50 + 3 * temperatura + np.random.normal(0, 10, 100)

correlacao = np.corrcoef(temperatura, vendas_sorvete)[0, 1]
print(f"Correlação temperatura-vendas: {correlacao:.3f}")

# Interpretação da correlação
if abs(correlacao) > 0.7:
    print("Correlação forte")
elif abs(correlacao) > 0.3:
    print("Correlação moderada")
else:
    print("Correlação fraca")

# 4. TEOREMA DE BAYES - Fundamental para classificação
print("\n=== TEOREMA DE BAYES ===")

# Exemplo: Classificação de emails (spam vs. não-spam)
# P(Spam) = 0.3 (30% dos emails são spam)
# P(Palavra "grátis" | Spam) = 0.8
# P(Palavra "grátis" | Não-spam) = 0.1

p_spam = 0.3
p_nao_spam = 0.7
p_gratis_dado_spam = 0.8
p_gratis_dado_nao_spam = 0.1

# P(Palavra "grátis") = P(grátis|spam)*P(spam) + P(grátis|não-spam)*P(não-spam)
p_gratis = p_gratis_dado_spam * p_spam + p_gratis_dado_nao_spam * p_nao_spam

# P(Spam | Palavra "grátis") = P(grátis|spam) * P(spam) / P(grátis)
p_spam_dado_gratis = (p_gratis_dado_spam * p_spam) / p_gratis

print(f"P(Spam | palavra 'grátis'): {p_spam_dado_gratis:.3f}")
print(f"Se um email contém 'grátis', há {p_spam_dado_gratis*100:.1f}% de chance de ser spam")

# 5. INTERVALOS DE CONFIANÇA
print("\n=== INTERVALOS DE CONFIANÇA ===")

# Calculando intervalo de confiança de 95% para a média das alturas
media_amostra = np.mean(alturas)
erro_padrao = stats.sem(alturas)  # Erro padrão da média
intervalo_conf = stats.t.interval(0.95, len(alturas)-1, media_amostra, erro_padrao)

print(f"Intervalo de confiança 95% para altura média: [{intervalo_conf[0]:.2f}, {intervalo_conf[1]:.2f}] cm")
print("Interpretação: Temos 95% de confiança de que a altura média da população está neste intervalo")

# 6. BOOTSTRAP - Método de reamostragem
print("\n=== BOOTSTRAP ===")

def bootstrap_media(dados, n_amostras=1000):
    """Calcula distribuição bootstrap da média"""
    medias_bootstrap = []
    for _ in range(n_amostras):
        amostra = np.random.choice(dados, size=len(dados), replace=True)
        medias_bootstrap.append(np.mean(amostra))
    return np.array(medias_bootstrap)

medias_boot = bootstrap_media(alturas)
ic_bootstrap = np.percentile(medias_boot, [2.5, 97.5])

print(f"Intervalo de confiança 95% (Bootstrap): [{ic_bootstrap[0]:.2f}, {ic_bootstrap[1]:.2f}] cm")

# 7. DETECÇÃO DE OUTLIERS
print("\n=== DETECÇÃO DE OUTLIERS ===")

def detectar_outliers_iqr(dados):
    """Detecta outliers usando método IQR"""
    Q1 = np.percentile(dados, 25)
    Q3 = np.percentile(dados, 75)
    IQR = Q3 - Q1
    limite_inferior = Q1 - 1.5 * IQR
    limite_superior = Q3 + 1.5 * IQR
    
    outliers = dados[(dados < limite_inferior) | (dados > limite_superior)]
    return outliers, limite_inferior, limite_superior

outliers, lim_inf, lim_sup = detectar_outliers_iqr(alturas)
print(f"Limites para outliers: [{lim_inf:.2f}, {lim_sup:.2f}] cm")
print(f"Número de outliers detectados: {len(outliers)}")
print(f"Percentual de outliers: {len(outliers)/len(alturas)*100:.1f}%")

from sklearn.datasets import load_iris, make_classification
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix
import pandas as pd
import numpy as np

# Exemplo prático: Previsão de inadimplência de clientes
print("=== SISTEMA DE PREVISÃO DE INADIMPLÊNCIA ===")

# Gerando dados sintéticos de clientes
np.random.seed(42)
X, y = make_classification(n_samples=1000, n_features=10, n_classes=2, 
                          n_redundant=2, n_informative=8, random_state=42)

# Criando nomes para as features
feature_names = ['idade', 'renda', 'score_credito', 'dividas', 'tempo_emprego',
                'num_cartoes', 'limite_total', 'uso_limite', 'atrasos_anteriores', 'patrimonio']

df = pd.DataFrame(X, columns=feature_names)
df['inadimplente'] = y

print("Dataset de clientes:")
print(df.head())
print(f"\nDistribuição de classes:")
print(f"Não inadimplentes: {(y==0).sum()} ({(y==0).mean()*100:.1f}%)")
print(f"Inadimplentes: {(y==1).sum()} ({(y==1).mean()*100:.1f}%)")

# Divisão treino/teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

# Testando múltiplos algoritmos
modelos = {
    'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42),
    'SVM': SVC(random_state=42),
    'Logistic Regression': LogisticRegression(random_state=42)
}

resultados = {}
for nome, modelo in modelos.items():
    # Validação cruzada
    scores = cross_val_score(modelo, X_train, y_train, cv=5, scoring='f1')
    resultados[nome] = {
        'mean_f1': scores.mean(),
        'std_f1': scores.std()
    }
    
    # Treinar modelo
    modelo.fit(X_train, y_train)
    y_pred = modelo.predict(X_test)
    
    print(f"\n=== {nome} ===")
    print(f"F1-Score CV: {scores.mean():.3f} ± {scores.std():.3f}")
    print("Relatório de classificação:")
    print(classification_report(y_test, y_pred))

# Melhor modelo
melhor_modelo = RandomForestClassifier(n_estimators=100, random_state=42)
melhor_modelo.fit(X_train, y_train)

# Importância das features
importancias = melhor_modelo.feature_importances_
feature_importance = pd.DataFrame({
    'feature': feature_names,
    'importance': importancias
}).sort_values('importance', ascending=False)

print("\nImportância das features:")
print(feature_importance)

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

print("=== REDE NEURAL ARTIFICIAL BÁSICA ===")
print(f"TensorFlow versão: {tf.__version__}")

# Gerar dados sintéticos para classificação
X, y = make_classification(
    n_samples=10000,
    n_features=20,
    n_informative=15,
    n_redundant=5,
    n_classes=3,
    random_state=42
)

# Dividir dados
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Normalizar dados
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

print(f"Dados de treino: {X_train_scaled.shape}")
print(f"Dados de teste: {X_test_scaled.shape}")
print(f"Classes: {np.unique(y)}")

# Construir modelo de rede neural
def criar_modelo_basico(input_dim, num_classes):
    """Cria uma rede neural feedforward básica"""
    model = keras.Sequential([
        # Camada de entrada
        layers.Dense(128, activation='relu', input_shape=(input_dim,), name='camada_entrada'),
        layers.Dropout(0.3),  # Regularização
        
        # Camadas ocultas
        layers.Dense(64, activation='relu', name='camada_oculta_1'),
        layers.Dropout(0.3),
        
        layers.Dense(32, activation='relu', name='camada_oculta_2'),
        layers.Dropout(0.2),
        
        # Camada de saída
        layers.Dense(num_classes, activation='softmax', name='camada_saida')
    ])
    
    return model

# Criar modelo
modelo = criar_modelo_basico(X_train_scaled.shape[1], len(np.unique(y)))

# Compilar modelo
modelo.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Mostrar arquitetura
print("\n=== ARQUITETURA DA REDE ===")
modelo.summary()

# Treinar modelo
print("\n=== TREINAMENTO ===")

# Callbacks para melhorar treinamento
callbacks = [
    keras.callbacks.EarlyStopping(
        monitor='val_loss',
        patience=10,
        restore_best_weights=True
    ),
    keras.callbacks.ReduceLROnPlateau(
        monitor='val_loss',
        factor=0.5,
        patience=5,
        min_lr=0.00001
    )
]

# Treinar
history = modelo.fit(
    X_train_scaled, y_train,
    epochs=100,
    batch_size=32,
    validation_split=0.2,
    callbacks=callbacks,
    verbose=1
)

# Avaliar modelo
print("\n=== AVALIAÇÃO ===")
test_loss, test_accuracy = modelo.evaluate(X_test_scaled, y_test, verbose=0)
print(f"Acurácia no teste: {test_accuracy:.4f}")
print(f"Loss no teste: {test_loss:.4f}")

# Predições
y_pred = modelo.predict(X_test_scaled)
y_pred_classes = np.argmax(y_pred, axis=1)

# Relatório de classificação
from sklearn.metrics import classification_report, confusion_matrix
print("\nRelatório de classificação:")
print(classification_report(y_test, y_pred_classes))

# Função para visualizar treinamento
def plotar_historico_treinamento(history):
    """Plota curvas de loss e acurácia"""
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
    
    # Loss
    ax1.plot(history.history['loss'], label='Treino')
    ax1.plot(history.history['val_loss'], label='Validação')
    ax1.set_title('Loss durante treinamento')
    ax1.set_xlabel('Época')
    ax1.set_ylabel('Loss')
    ax1.legend()
    
    # Acurácia
    ax2.plot(history.history['accuracy'], label='Treino')
    ax2.plot(history.history['val_accuracy'], label='Validação')
    ax2.set_title('Acurácia durante treinamento')
    ax2.set_xlabel('Época')
    ax2.set_ylabel('Acurácia')
    ax2.legend()
    
    plt.tight_layout()
    plt.show()

# Exemplo de uso de transfer learning
def criar_modelo_pre_treinado():
    """Exemplo de transfer learning com modelo pré-treinado"""
    # Carregar modelo pré-treinado (exemplo conceitual)
    base_model = keras.applications.MobileNetV2(
        input_shape=(224, 224, 3),
        include_top=False,
        weights='imagenet'
    )
    
    # Congelar camadas do modelo base
    base_model.trainable = False
    
    # Adicionar camadas personalizadas
    model = keras.Sequential([
        base_model,
        layers.GlobalAveragePooling2D(),
        layers.Dense(128, activation='relu'),
        layers.Dropout(0.5),
        layers.Dense(3, activation='softmax')  # 3 classes
    ])
    
    return model

print("\n=== CONCEITOS IMPORTANTES ===")
print("1. Ativação ReLU: f(x) = max(0, x) - evita problema do gradiente")
print("2. Dropout: desliga neurônios aleatoriamente - evita overfitting")
print("3. Batch normalization: normaliza entradas de cada camada")
print("4. Adam optimizer: combina momentum e RMSprop")
print("5. Early stopping: para treinamento quando não há melhoria")

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

print("=== CNN PARA CLASSIFICAÇÃO DE IMAGENS ===")

# Carregar dataset CIFAR-10
(X_train, y_train), (X_test, y_test) = keras.datasets.cifar10.load_data()

# Nomes das classes
class_names = ['avião', 'carro', 'pássaro', 'gato', 'cervo', 
               'cachorro', 'sapo', 'cavalo', 'navio', 'caminhão']

print(f"Dados de treino: {X_train.shape}")
print(f"Dados de teste: {X_test.shape}")
print(f"Classes: {len(class_names)}")

# Pré-processamento
X_train = X_train.astype('float32') / 255.0
X_test = X_test.astype('float32') / 255.0

# Converter labels para categorical
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

def criar_cnn_modelo():
    """Cria uma CNN para classificação de imagens"""
    model = keras.Sequential([
        # Primeiro bloco convolucional
        layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
        layers.BatchNormalization(),
        layers.Conv2D(32, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        layers.Dropout(0.25),
        
        # Segundo bloco convolucional
        layers.Conv2D(64, (3, 3), activation='relu'),
        layers.BatchNormalization(),
        layers.Conv2D(64, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        layers.Dropout(0.25),
        
        # Terceiro bloco convolucional
        layers.Conv2D(128, (3, 3), activation='relu'),
        layers.BatchNormalization(),
        layers.Dropout(0.25),
        
        # Camadas totalmente conectadas
        layers.Flatten(),
        layers.Dense(512, activation='relu'),
        layers.BatchNormalization(),
        layers.Dropout(0.5),
        layers.Dense(10, activation='softmax')
    ])
    
    return model

# Criar e compilar modelo
modelo_cnn = criar_cnn_modelo()

modelo_cnn.compile(
    optimizer='adam',
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

print("\n=== ARQUITETURA CNN ===")
modelo_cnn.summary()

# Data augmentation para melhorar generalização
datagen = keras.preprocessing.image.ImageDataGenerator(
    rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    horizontal_flip=True,
    zoom_range=0.2
)

print("\n=== TREINAMENTO CNN ===")

# Callbacks
callbacks_cnn = [
    keras.callbacks.EarlyStopping(
        monitor='val_accuracy',
        patience=10,
        restore_best_weights=True
    ),
    keras.callbacks.ReduceLROnPlateau(
        monitor='val_loss',
        factor=0.2,
        patience=5,
        min_lr=0.0001
    )
]

# Treinar com data augmentation
history_cnn = modelo_cnn.fit(
    datagen.flow(X_train, y_train, batch_size=32),
    steps_per_epoch=len(X_train) // 32,
    epochs=50,
    validation_data=(X_test, y_test),
    callbacks=callbacks_cnn,
    verbose=1
)

# Avaliar
test_loss, test_acc = modelo_cnn.evaluate(X_test, y_test, verbose=0)
print(f"\nAcurácia final: {test_acc:.4f}")

# Exemplo de transfer learning com modelo pré-treinado
def criar_modelo_transfer_learning():
    """Transfer learning com VGG16"""
    # Carregar VGG16 pré-treinado
    base_model = keras.applications.VGG16(
        weights='imagenet',
        include_top=False,
        input_shape=(32, 32, 3)
    )
    
    # Congelar camadas base
    base_model.trainable = False
    
    # Adicionar camadas customizadas
    model = keras.Sequential([
        # Redimensionar imagens para VGG16
        layers.Lambda(lambda x: tf.image.resize(x, (224, 224))),
        base_model,
        layers.GlobalAveragePooling2D(),
        layers.Dense(128, activation='relu'),
        layers.Dropout(0.5),
        layers.Dense(10, activation='softmax')
    ])
    
    return model

print("\n=== CONCEITOS CNN ===")
print("1. Convolução: detecta features locais usando filtros")
print("2. Pooling: reduz dimensionalidade mantendo informações importantes")
print("3. Batch Normalization: normaliza ativações, acelera treinamento")
print("4. Data Augmentation: aumenta dataset artificialmente")
print("5. Transfer Learning: usa conhecimento de modelos pré-treinados")

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np
import pandas as pd

print("=== RNN/LSTM PARA SÉRIES TEMPORAIS ===")

# Gerar dados de série temporal sintética
def gerar_serie_temporal(n_pontos=1000):
    """Gera série temporal com tendência e sazonalidade"""
    np.random.seed(42)
    t = np.arange(n_pontos)
    
    # Componentes da série
    tendencia = 0.02 * t
    sazonalidade = 10 * np.sin(2 * np.pi * t / 50)
    ruido = np.random.normal(0, 1, n_pontos)
    
    serie = 100 + tendencia + sazonalidade + ruido
    return serie

# Criar série temporal
serie_dados = gerar_serie_temporal(1000)
print(f"Série temporal gerada: {len(serie_dados)} pontos")

def criar_sequencias(dados, seq_length):
    """Converte série temporal em sequências para treinamento"""
    X, y = [], []
    
    for i in range(len(dados) - seq_length):
        X.append(dados[i:(i + seq_length)])
        y.append(dados[i + seq_length])
    
    return np.array(X), np.array(y)

# Preparar dados para RNN
seq_length = 30  # Usar 30 pontos anteriores para prever próximo
X, y = criar_sequencias(serie_dados, seq_length)

# Dividir em treino e teste
split_idx = int(0.8 * len(X))
X_train, X_test = X[:split_idx], X[split_idx:]
y_train, y_test = y[:split_idx], y[split_idx:]

# Normalizar dados
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X_train_scaled = scaler.fit_transform(X_train.reshape(-1, 1)).reshape(X_train.shape)
X_test_scaled = scaler.transform(X_test.reshape(-1, 1)).reshape(X_test.shape)
y_train_scaled = scaler.transform(y_train.reshape(-1, 1)).flatten()
y_test_scaled = scaler.transform(y_test.reshape(-1, 1)).flatten()

print(f"Dados treino: {X_train_scaled.shape}")
print(f"Dados teste: {X_test_scaled.shape}")

def criar_modelo_lstm():
    """Cria modelo LSTM para previsão de séries temporais"""
    model = keras.Sequential([
        # Primeira camada LSTM
        layers.LSTM(50, return_sequences=True, input_shape=(seq_length, 1)),
        layers.Dropout(0.2),
        
        # Segunda camada LSTM
        layers.LSTM(50, return_sequences=True),
        layers.Dropout(0.2),
        
        # Terceira camada LSTM
        layers.LSTM(50),
        layers.Dropout(0.2),
        
        # Camadas densas
        layers.Dense(25, activation='relu'),
        layers.Dense(1)
    ])
    
    return model

# Criar modelo LSTM
modelo_lstm = criar_modelo_lstm()

modelo_lstm.compile(
    optimizer='adam',
    loss='mse',
    metrics=['mae']
)

print("\n=== ARQUITETURA LSTM ===")
modelo_lstm.summary()

# Reshape dados para LSTM (samples, timesteps, features)
X_train_reshaped = X_train_scaled.reshape((X_train_scaled.shape[0], X_train_scaled.shape[1], 1))
X_test_reshaped = X_test_scaled.reshape((X_test_scaled.shape[0], X_test_scaled.shape[1], 1))

print("\n=== TREINAMENTO LSTM ===")

# Callbacks
callbacks_lstm = [
    keras.callbacks.EarlyStopping(
        monitor='val_loss',
        patience=15,
        restore_best_weights=True
    ),
    keras.callbacks.ReduceLROnPlateau(
        monitor='val_loss',
        factor=0.5,
        patience=10,
        min_lr=0.00001
    )
]

# Treinar
history_lstm = modelo_lstm.fit(
    X_train_reshaped, y_train_scaled,
    epochs=100,
    batch_size=32,
    validation_split=0.2,
    callbacks=callbacks_lstm,
    verbose=1
)

# Fazer previsões
previsoes = modelo_lstm.predict(X_test_reshaped)

# Desnormalizar previsões
previsoes_desnorm = scaler.inverse_transform(previsoes)
y_test_desnorm = scaler.inverse_transform(y_test_scaled.reshape(-1, 1))

# Calcular métricas
from sklearn.metrics import mean_absolute_error, mean_squared_error
mae = mean_absolute_error(y_test_desnorm, previsoes_desnorm)
rmse = np.sqrt(mean_squared_error(y_test_desnorm, previsoes_desnorm))

print(f"\n=== MÉTRICAS DE AVALIAÇÃO ===")
print(f"MAE: {mae:.4f}")
print(f"RMSE: {rmse:.4f}")

# Exemplo de modelo bidirecional
def criar_modelo_bidirectional():
    """Modelo LSTM bidirecional"""
    model = keras.Sequential([
        layers.Bidirectional(
            layers.LSTM(50, return_sequences=True),
            input_shape=(seq_length, 1)
        ),
        layers.Dropout(0.2),
        
        layers.Bidirectional(layers.LSTM(50)),
        layers.Dropout(0.2),
        
        layers.Dense(25, activation='relu'),
        layers.Dense(1)
    ])
    
    return model

# Exemplo de classificação de texto com RNN
def criar_modelo_classificacao_texto():
    """RNN para classificação de texto"""
    vocab_size = 10000
    max_length = 100
    
    model = keras.Sequential([
        layers.Embedding(vocab_size, 128, input_length=max_length),
        layers.LSTM(64, dropout=0.5, recurrent_dropout=0.5),
        layers.Dense(1, activation='sigmoid')
    ])
    
    return model

print("\n=== CONCEITOS RNN/LSTM ===")
print("1. RNN: processa sequências, mas sofre de vanishing gradient")
print("2. LSTM: resolve problema do gradiente com gates")
print("3. GRU: versão simplificada do LSTM")
print("4. Bidirectional: processa sequência nos dois sentidos")
print("5. Attention: foca em partes relevantes da sequência")

# Função para previsão futura
def prever_proximos_pontos(modelo, ultima_sequencia, n_pontos=10):
    """Prevê próximos n pontos da série temporal"""
    previsoes = []
    seq_atual = ultima_sequencia.copy()
    
    for _ in range(n_pontos):
        # Prever próximo ponto
        seq_reshaped = seq_atual.reshape(1, seq_length, 1)
        prox_ponto = modelo.predict(seq_reshaped, verbose=0)[0, 0]
        previsoes.append(prox_ponto)
        
        # Atualizar sequência (remover primeiro, adicionar previsão)
        seq_atual = np.append(seq_atual[1:], prox_ponto)
    
    return np.array(previsoes)

# Exemplo de uso
ultima_seq = X_test_scaled[-1]
previsoes_futuras = prever_proximos_pontos(modelo_lstm, ultima_seq, 10)
print(f"\nPrevisões para próximos 10 pontos: {previsoes_futuras[:5]}...")

print("\n=== APLICAÇÕES PRÁTICAS ===")
print("- Previsão de vendas")
print("- Análise de sentimentos em texto")
print("- Tradução automática")
print("- Reconhecimento de fala")
print("- Detecção de anomalias em séries temporais")

import pandas as pd
import numpy as np
import re
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
import nltk
from nltk.corpus import stopwords
from nltk.stem import RSLPStemmer

# Sistema de análise de sentimentos para reviews de produtos
print("=== SISTEMA DE ANÁLISE DE SENTIMENTOS ===")

# Dados simulados de reviews de e-commerce
reviews_dados = [
    ("Produto excelente, recomendo muito!", "positivo"),
    ("Chegou rápido e bem embalado", "positivo"),
    ("Qualidade péssima, não comprem", "negativo"),
    ("Não gostei, muito caro pelo que oferece", "negativo"),
    ("Produto ok, nada excepcional", "neutro"),
    ("Adorei! Superou minhas expectativas", "positivo"),
    ("Péssimo atendimento e produto ruim", "negativo"),
    ("Entrega demorou mas produto é bom", "neutro"),
    ("Melhor compra que já fiz!", "positivo"),
    ("Produto com defeito, muito frustrado", "negativo")
] * 100  # Simular mais dados

# Criar DataFrame
df_reviews = pd.DataFrame(reviews_dados, columns=['texto', 'sentimento'])
print(f"Total de reviews: {len(df_reviews)}")
print(df_reviews['sentimento'].value_counts())

# Pré-processamento de texto
def preprocessar_texto(texto):
    """Limpa e prepara texto para análise"""
    # Converter para minúsculas
    texto = texto.lower()
    
    # Remover pontuação e números
    texto = re.sub(r'[^a-záãàâéêíóôõúç\s]', '', texto)
    
    # Remover espaços extras
    texto = re.sub(r'\s+', ' ', texto).strip()
    
    return texto

# Aplicar pré-processamento
df_reviews['texto_limpo'] = df_reviews['texto'].apply(preprocessar_texto)

# Vectorização TF-IDF
vectorizer = TfidfVectorizer(
    max_features=1000,
    ngram_range=(1, 2),  # Unigrams e bigrams
    min_df=2
)

X = vectorizer.fit_transform(df_reviews['texto_limpo'])
y = df_reviews['sentimento']

# Divisão treino/teste
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Treinamento do modelo
modelo = LogisticRegression(random_state=42)
modelo.fit(X_train, y_train)

# Avaliação
y_pred = modelo.predict(X_test)
print("\n=== RESULTADOS ===")
print(classification_report(y_test, y_pred))

# Função para predizer sentimento de novo texto
def analisar_sentimento(texto):
    """Analisa sentimento de um texto"""
    texto_limpo = preprocessar_texto(texto)
    texto_vectorizado = vectorizer.transform([texto_limpo])
    sentimento = modelo.predict(texto_vectorizado)[0]
    probabilidades = modelo.predict_proba(texto_vectorizado)[0]
    
    return {
        'sentimento': sentimento,
        'confianca': max(probabilidades),
        'probabilidades': dict(zip(modelo.classes_, probabilidades))
    }

# Teste com novos textos
novos_textos = [
    "Este produto é fantástico, recomendo!",
    "Não gostei nada, qualidade horrível",
    "Produto mediano, poderia ser melhor"
]

for texto in novos_textos:
    resultado = analisar_sentimento(texto)
    print(f"\nTexto: {texto}")
    print(f"Sentimento: {resultado['sentimento']} (confiança: {resultado['confianca']:.2f})")

# Análise das palavras mais importantes
feature_names = vectorizer.get_feature_names_out()
for classe in modelo.classes_:
    idx_classe = list(modelo.classes_).index(classe)
    coef = modelo.coef_[idx_classe]
    top_indices = coef.argsort()[-10:][::-1]
    
    print(f"\nPalavras mais importantes para '{classe}':")
    for i in top_indices:
        print(f"  {feature_names[i]}: {coef[i]:.3f}")

import cv2
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

print("=== SISTEMA DE ANÁLISE DE IMAGENS ===")

# Função para criar imagem sintética para demonstração
def criar_imagem_exemplo():
    """Cria uma imagem sintética para demonstração"""
    # Criar imagem com formas geométricas
    img = np.zeros((400, 600, 3), dtype=np.uint8)
    
    # Adicionar retângulo azul
    cv2.rectangle(img, (50, 50), (200, 150), (255, 0, 0), -1)
    
    # Adicionar círculo verde
    cv2.circle(img, (400, 100), 80, (0, 255, 0), -1)
    
    # Adicionar triângulo vermelho
    triangle = np.array([[300, 200], [350, 300], [250, 300]], np.int32)
    cv2.fillPoly(img, [triangle], (0, 0, 255))
    
    # Adicionar ruído
    noise = np.random.randint(0, 50, img.shape, dtype=np.uint8)
    img = cv2.add(img, noise)
    
    return img

# 1. CARREGAMENTO E VISUALIZAÇÃO
print("1. Criando imagem de exemplo...")
img_original = criar_imagem_exemplo()

# Conversão para diferentes espaços de cor
img_gray = cv2.cvtColor(img_original, cv2.COLOR_BGR2GRAY)
img_hsv = cv2.cvtColor(img_original, cv2.COLOR_BGR2HSV)

print(f"Dimensões da imagem: {img_original.shape}")
print(f"Tipo de dados: {img_original.dtype}")

# 2. FILTROS E SUAVIZAÇÃO
print("\n2. Aplicando filtros...")

# Filtro Gaussiano (suavização)
img_blur = cv2.GaussianBlur(img_original, (15, 15), 0)

# Filtro Mediano (remove ruído sal e pimenta)
img_median = cv2.medianBlur(img_original, 5)

# Filtro Bilateral (preserva bordas)
img_bilateral = cv2.bilateralFilter(img_original, 9, 75, 75)

# 3. DETECÇÃO DE BORDAS
print("3. Detectando bordas...")

# Detecção de bordas com Canny
edges = cv2.Canny(img_gray, 50, 150)

# Gradiente Sobel
sobelx = cv2.Sobel(img_gray, cv2.CV_64F, 1, 0, ksize=3)
sobely = cv2.Sobel(img_gray, cv2.CV_64F, 0, 1, ksize=3)
sobel_combined = np.sqrt(sobelx**2 + sobely**2)

# 4. DETECÇÃO DE CONTORNOS
print("4. Detectando contornos...")

contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
img_contours = img_original.copy()
cv2.drawContours(img_contours, contours, -1, (255, 255, 255), 2)

print(f"Número de contornos encontrados: {len(contours)}")

# Análise de contornos
for i, contour in enumerate(contours):
    if cv2.contourArea(contour) > 500:  # Filtrar contornos pequenos
        # Calcular propriedades
        area = cv2.contourArea(contour)
        perimetro = cv2.arcLength(contour, True)
        
        # Aproximação poligonal
        epsilon = 0.02 * cv2.arcLength(contour, True)
        approx = cv2.approxPolyDP(contour, epsilon, True)
        
        # Determinar forma
        vertices = len(approx)
        if vertices == 3:
            forma = "Triângulo"
        elif vertices == 4:
            forma = "Retângulo"
        elif vertices > 8:
            forma = "Círculo"
        else:
            forma = f"Polígono ({vertices} lados)"
        
        print(f"Contorno {i}: {forma}, Área: {area:.0f}, Perímetro: {perimetro:.0f}")

# 5. SEGMENTAÇÃO POR COR
print("\n5. Segmentação por cor...")

def segmentar_por_cor(img, cor_min, cor_max):
    """Segmenta imagem baseada em range de cor HSV"""
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    mask = cv2.inRange(hsv, cor_min, cor_max)
    resultado = cv2.bitwise_and(img, img, mask=mask)
    return mask, resultado

# Definir ranges de cor (HSV)
# Azul
azul_min = np.array([100, 50, 50])
azul_max = np.array([130, 255, 255])
mask_azul, img_azul = segmentar_por_cor(img_original, azul_min, azul_max)

# Verde
verde_min = np.array([40, 50, 50])
verde_max = np.array([80, 255, 255])
mask_verde, img_verde = segmentar_por_cor(img_original, verde_min, verde_max)

# Vermelho (requer dois ranges devido ao wrap-around do Hue)
vermelho_min1 = np.array([0, 50, 50])
vermelho_max1 = np.array([10, 255, 255])
vermelho_min2 = np.array([170, 50, 50])
vermelho_max2 = np.array([180, 255, 255])

hsv = cv2.cvtColor(img_original, cv2.COLOR_BGR2HSV)
mask_vermelho1 = cv2.inRange(hsv, vermelho_min1, vermelho_max1)
mask_vermelho2 = cv2.inRange(hsv, vermelho_min2, vermelho_max2)
mask_vermelho = cv2.bitwise_or(mask_vermelho1, mask_vermelho2)
img_vermelho = cv2.bitwise_and(img_original, img_original, mask=mask_vermelho)

# 6. CLUSTERING DE CORES (K-MEANS)
print("6. Análise de paleta de cores...")

def extrair_cores_dominantes(img, k=5):
    """Extrai as k cores dominantes da imagem usando K-means"""
    # Reshape da imagem para lista de pixels
    pixels = img.reshape((-1, 3))
    pixels = np.float32(pixels)
    
    # Aplicar K-means
    criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 20, 1.0)
    _, labels, centers = cv2.kmeans(pixels, k, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS)
    
    # Converter de volta para uint8
    centers = np.uint8(centers)
    
    # Contar pixels por cluster
    unique_labels, counts = np.unique(labels, return_counts=True)
    
    # Ordenar por frequência
    sorted_indices = np.argsort(counts)[::-1]
    cores_dominantes = centers[sorted_indices]
    percentuais = counts[sorted_indices] / len(pixels) * 100
    
    return cores_dominantes, percentuais

cores, percentuais = extrair_cores_dominantes(img_original, k=5)
print("Cores dominantes (BGR):")
for i, (cor, perc) in enumerate(zip(cores, percentuais)):
    print(f"  Cor {i+1}: {cor} ({perc:.1f}%)")

# 7. TEMPLATE MATCHING
print("\n7. Template Matching...")

def encontrar_template(img, template, threshold=0.8):
    """Encontra template na imagem usando correlação"""
    resultado = cv2.matchTemplate(img, template, cv2.TM_CCOEFF_NORMED)
    locations = np.where(resultado >= threshold)
    
    matches = []
    for pt in zip(*locations[::-1]):
        matches.append({
            'posicao': pt,
            'confianca': resultado[pt[1], pt[0]]
        })
    
    return matches

# Criar um template simples (quadrado azul)
template = img_original[50:150, 50:200]  # Recortar o retângulo azul
matches = encontrar_template(img_gray, cv2.cvtColor(template, cv2.COLOR_BGR2GRAY), 0.8)

print(f"Template encontrado em {len(matches)} localizações")

# 8. TRANSFORMAÇÕES GEOMÉTRICAS
print("8. Aplicando transformações...")

# Rotação
altura, largura = img_original.shape[:2]
centro = (largura//2, altura//2)
matriz_rotacao = cv2.getRotationMatrix2D(centro, 45, 1.0)
img_rotacionada = cv2.warpAffine(img_original, matriz_rotacao, (largura, altura))

# Redimensionamento
img_redimensionada = cv2.resize(img_original, (300, 200))

# Corte de perspectiva
pts1 = np.float32([[50, 50], [550, 50], [50, 350], [550, 350]])
pts2 = np.float32([[0, 0], [400, 0], [0, 300], [400, 300]])
matriz_perspectiva = cv2.getPerspectiveTransform(pts1, pts2)
img_perspectiva = cv2.warpPerspective(img_original, matriz_perspectiva, (400, 300))

# Função para salvar resultados (simulação)
def salvar_resultados():
    """Simula salvamento dos resultados de análise"""
    resultados = {
        'contornos_detectados': len(contours),
        'cores_dominantes': cores.tolist(),
        'percentuais_cores': percentuais.tolist(),
        'templates_encontrados': len(matches),
        'dimensoes_originais': img_original.shape
    }
    
    print("\n=== RELATÓRIO DE ANÁLISE ===")
    print(f"Contornos detectados: {resultados['contornos_detectados']}")
    print(f"Templates encontrados: {resultados['templates_encontrados']}")
    print("Análise concluída com sucesso!")
    
    return resultados

# Executar análise completa
relatorio = salvar_resultados()

from flask import Flask, request, jsonify
import pickle
import numpy as np
from sklearn.ensemble import RandomForestClassifier

app = Flask(__name__)

# Carregar modelo treinado
with open('modelo_credito.pkl', 'rb') as f:
    modelo = pickle.load(f)

@app.route('/predict', methods=['POST'])
def predict():
    try:
        # Receber dados do request
        data = request.json
        
        # Extrair features
        features = np.array([[
            data['idade'],
            data['renda'],
            data['score_credito'],
            data['dividas'],
            data['tempo_emprego']
        ]])
        
        # Fazer predição
        predicao = modelo.predict(features)[0]
        probabilidade = modelo.predict_proba(features)[0][1]
        
        # Retornar resultado
        return jsonify({
            'inadimplente': bool(predicao),
            'probabilidade': float(probabilidade),
            'status': 'success'
        })
        
    except Exception as e:
        return jsonify({
            'error': str(e),
            'status': 'error'
        }), 400

@app.route('/health', methods=['GET'])
def health():
    return jsonify({'status': 'healthy'})

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)

FROM python:3.9-slim

WORKDIR /app

# Instalar dependências do sistema
RUN apt-get update && apt-get install -y \
    gcc \
    && rm -rf /var/lib/apt/lists/*

# Copiar requirements
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copiar código da aplicação
COPY . .

# Criar usuário não-root
RUN useradd --create-home --shell /bin/bash app
RUN chown -R app:app /app
USER app

# Expor porta
EXPOSE 5000

# Comando de início
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]

version: '3.8'

services:
  ia-api:
    build: .
    ports:
      - "5000:5000"
    environment:
      - FLASK_ENV=production
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
    
  redis:
    image: redis:6-alpine
    ports:
      - "6379:6379"
    restart: unless-stopped

import logging
import time
import psutil
from datetime import datetime
import json

# Configurar logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('ia_api.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)

class ModelMonitor:
    def __init__(self):
        self.predictions_count = 0
        self.errors_count = 0
        self.start_time = time.time()
    
    def log_prediction(self, features, prediction, probability, response_time):
        """Registra uma predição para monitoramento"""
        self.predictions_count += 1
        
        log_data = {
            'timestamp': datetime.now().isoformat(),
            'features': features.tolist(),
            'prediction': int(prediction),
            'probability': float(probability),
            'response_time_ms': response_time * 1000,
            'prediction_id': self.predictions_count
        }
        
        logger.info(f"PREDICTION: {json.dumps(log_data)}")
    
    def log_error(self, error_message, request_data=None):
        """Registra erros para análise"""
        self.errors_count += 1
        
        error_data = {
            'timestamp': datetime.now().isoformat(),
            'error_message': str(error_message),
            'request_data': request_data,
            'error_count': self.errors_count
        }
        
        logger.error(f"ERROR: {json.dumps(error_data)}")
    
    def get_health_metrics(self):
        """Retorna métricas de saúde do sistema"""
        uptime = time.time() - self.start_time
        
        return {
            'uptime_seconds': uptime,
            'total_predictions': self.predictions_count,
            'total_errors': self.errors_count,
            'error_rate': self.errors_count / max(self.predictions_count, 1),
            'cpu_percent': psutil.cpu_percent(),
            'memory_percent': psutil.virtual_memory().percent,
            'timestamp': datetime.now().isoformat()
        }

# Uso no app Flask
monitor = ModelMonitor()

@app.route('/predict', methods=['POST'])
def predict():
    start_time = time.time()
    
    try:
        data = request.json
        features = np.array([[...]])  # Processar features
        
        prediction = modelo.predict(features)[0]
        probability = modelo.predict_proba(features)[0][1]
        
        response_time = time.time() - start_time
        monitor.log_prediction(features, prediction, probability, response_time)
        
        return jsonify({
            'inadimplente': bool(prediction),
            'probabilidade': float(probability),
            'status': 'success'
        })
        
    except Exception as e:
        monitor.log_error(str(e), request.json)
        return jsonify({'error': str(e), 'status': 'error'}), 400

@app.route('/metrics', methods=['GET'])
def metrics():
    return jsonify(monitor.get_health_metrics())