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

# 1D CNN 모델 구성
model = models.Sequential([
    # 입력: (시퀀스 길이, 특징 수)
    layers.Conv1D(filters=64, kernel_size=3, activation='relu', 
                  input_shape=(100, 1)),
    layers.MaxPooling1D(pool_size=2),
    
    layers.Conv1D(filters=128, kernel_size=3, activation='relu'),
    layers.MaxPooling1D(pool_size=2),
    
    layers.Flatten(),
    layers.Dense(50, activation='relu'),
    layers.Dense(1)  # 예측값 출력
])

model.compile(optimizer='adam', loss='mse')

# 어텐션 스코어 계산
Attention(Q, K, V) = softmax(Q·K^T / √d_k) · V

# 여기서:
# Q·K^T: Query와 Key의 유사도 계산
# √d_k: 스케일링 팩터 (안정적인 학습을 위해)
# softmax: 확률 분포로 변환 (합이 1이 되도록)
# ·V: 가중치를 Value에 적용

import tensorflow as tf
from tensorflow.keras import layers

class TimeSeriesAttention(layers.Layer):
    def __init__(self, units):
        super().__init__()
        self.W_q = layers.Dense(units)
        self.W_k = layers.Dense(units)
        self.W_v = layers.Dense(units)
        self.units = units
    
    def call(self, inputs):
        # inputs shape: (batch, sequence_length, features)
        Q = self.W_q(inputs)  # Query
        K = self.W_k(inputs)  # Key
        V = self.W_v(inputs)  # Value
        
        # 어텐션 스코어 계산
        scores = tf.matmul(Q, K, transpose_b=True)
        scores = scores / tf.math.sqrt(tf.cast(self.units, tf.float32))
        
        # 소프트맥스로 가중치 변환
        attention_weights = tf.nn.softmax(scores, axis=-1)
        
        # 가중치 적용
        output = tf.matmul(attention_weights, V)
        
        return output, attention_weights

# 모델에 적용
model = tf.keras.Sequential([
    layers.Input(shape=(100, 1)),
    TimeSeriesAttention(64),
    layers.GlobalAveragePooling1D(),
    layers.Dense(50, activation='relu'),
    layers.Dense(1)
])

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

def create_hybrid_model(seq_length, n_features):
    inputs = layers.Input(shape=(seq_length, n_features))
    
    # 1단계: CNN으로 국소 특징 추출
    x = layers.Conv1D(64, 3, activation='relu', padding='same')(inputs)
    x = layers.Conv1D(64, 3, activation='relu', padding='same')(x)
    x = layers.MaxPooling1D(2)(x)
    
    x = layers.Conv1D(128, 3, activation='relu', padding='same')(x)
    x = layers.Conv1D(128, 3, activation='relu', padding='same')(x)
    
    # 2단계: 어텐션으로 중요 특징 강조
    query = layers.Dense(128)(x)
    key = layers.Dense(128)(x)
    value = layers.Dense(128)(x)
    
    attention_output = layers.Attention()([query, value, key])
    
    # 3단계: 최종 예측
    x = layers.GlobalAveragePooling1D()(attention_output)
    x = layers.Dense(64, activation='relu')(x)
    x = layers.Dropout(0.3)(x)
    outputs = layers.Dense(1)(x)
    
    model = models.Model(inputs=inputs, outputs=outputs)
    return model

# 모델 생성
model = create_hybrid_model(seq_length=200, n_features=1)
model.compile(optimizer='adam', loss='mse', metrics=['mae'])

# 멀티스케일 CNN 예시
def multi_scale_cnn(inputs):
    # 작은 필터
    conv1 = layers.Conv1D(32, 3, activation='relu', padding='same')(inputs)
    
    # 중간 필터
    conv2 = layers.Conv1D(32, 7, activation='relu', padding='same')(inputs)
    
    # 큰 필터
    conv3 = layers.Conv1D(32, 15, activation='relu', padding='same')(inputs)
    
    # 모든 스케일 결합
    merged = layers.Concatenate()([conv1, conv2, conv3])
    
    return merged

# Positional Encoding 구현
import numpy as np

def get_positional_encoding(seq_length, d_model):
    position = np.arange(seq_length)[:, np.newaxis]
    div_term = np.exp(np.arange(0, d_model, 2) * 
                      -(np.log(10000.0) / d_model))
    
    pos_encoding = np.zeros((seq_length, d_model))
    pos_encoding[:, 0::2] = np.sin(position * div_term)
    pos_encoding[:, 1::2] = np.cos(position * div_term)
    
    return pos_encoding

# 멀티헤드 어텐션 사용 예시
from tensorflow.keras.layers import MultiHeadAttention

inputs = layers.Input(shape=(seq_length, features))

# Positional Encoding 추가
pos_encoding = get_positional_encoding(seq_length, features)
x = inputs + pos_encoding

# 멀티헤드 어텐션 적용
attention_output = MultiHeadAttention(
    num_heads=8,
    key_dim=64
)(x, x)