import torch
import torch.nn as nn
import numpy as np

class HeritageLanguageDecisionTransformer(nn.Module):
    def __init__(self, state_dim, act_dim, max_ep_len=100, n_blocks=3, embed_dim=128, n_heads=4):
        super().__init__()
        self.state_dim = state_dim
        self.act_dim = act_dim
        self.max_ep_len = max_ep_len
        self.embed_dim = embed_dim

        # Embeddings for each input type
        self.state_encoder = nn.Linear(state_dim, embed_dim)
        self.action_encoder = nn.Linear(act_dim, embed_dim)
        self.rtg_encoder = nn.Linear(1, embed_dim)  # Return-to-go

        # Alignment embedding - static vector from community interviews
        self.alignment_embedding = nn.Parameter(torch.randn(1, 1, embed_dim))

        # Transformer blocks
        self.transformer = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(
                d_model=embed_dim,
                nhead=n_heads,
                dim_feedforward=4*embed_dim,
                dropout=0.1,
                activation='gelu'
            ),
            num_layers=n_blocks
        )

        # Output heads
        self.action_predictor = nn.Linear(embed_dim, act_dim)
        self.value_head = nn.Linear(embed_dim, 1)

    def forward(self, states, actions, rtgs, timesteps, alignment_mask=None):
        batch_size, seq_len = states.shape[0], states.shape[1]

        # Encode inputs
        state_embeds = self.state_encoder(states)
        action_embeds = self.action_encoder(actions)
        rtg_embeds = self.rtg_encoder(rtgs.unsqueeze(-1))

        # Add alignment conditioning
        if alignment_mask is not None:
            alignment_embeds = self.alignment_embedding * alignment_mask.unsqueeze(-1)
        else:
            alignment_embeds = self.alignment_embedding.expand(batch_size, seq_len, -1)

        # Interleave embeddings: [RTG, state, action] pattern
        # This is key for the decision transformer to learn the return-conditioned policy
        stacked_inputs = torch.stack(
            (rtg_embeds, state_embeds, action_embeds + alignment_embeds),
            dim=2
        ).reshape(batch_size, 3*seq_len, self.embed_dim)

        # Add positional encoding
        pos_encoding = self.get_positional_encoding(3*seq_len, self.embed_dim)
        stacked_inputs = stacked_inputs + pos_encoding[:3*seq_len].to(stacked_inputs.device)

        # Transformer forward pass
        transformer_output = self.transformer(stacked_inputs)

        # Extract action predictions (every 3rd token starting from index 2)
        action_outputs = transformer_output[:, 2::3, :]
        predicted_actions = self.action_predictor(action_outputs)

        # Value prediction for planning
        values = self.value_head(transformer_output[:, 0::3, :])

        return predicted_actions, values

    def get_positional_encoding(self, length, dim):
        pe = torch.zeros(length, dim)
        position = torch.arange(0, length).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, dim, 2) * -(np.log(10000.0) / dim))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        return pe

def generate_alignment_vector(community_feedback):
    """
    Convert community feedback into a static alignment embedding.

    community_feedback: dict of {decision_scenario: [ratings]}
    Returns: alignment_vector (embed_dim,)
    """
    # Example scenarios and their average ratings
    scenarios = [
        "interrupt_elder",        # Should never do this
        "repeat_question",        # Avoid if user is tired
        "switch_dialect",         # Do if user prefers
        "save_energy",            # Prioritize when battery low
        "provide_feedback",       # Give audio confirmation
    ]

    # Average ratings from community (1=bad, 5=good)
    avg_ratings = []
    for scenario in scenarios:
        ratings = community_feedback.get(scenario, [3])
        avg_ratings.append(np.mean(ratings))

    # Normalize to [0, 1] and project to embedding space
    alignment = np.array(avg_ratings) / 5.0
    alignment_vector = np.pad(alignment, (0, 128 - len(alignment)), 'constant')
    return torch.tensor(alignment_vector, dtype=torch.float32)

# During training, we condition on this vector
alignment_vector = generate_alignment_vector(community_feedback)
model.alignment_embedding.data = alignment_vector.unsqueeze(0).unsqueeze(0)

import torch.quantization as quant

def optimize_for_edge(model, example_inputs):
    # Step 1: Quantization
    model.qconfig = quant.get_default_qconfig('fbgemm')
    quant.prepare(model, inplace=True)
    quant.convert(model, inplace=True)

    # Step 2: Pruning (remove least important heads)
    importance_scores = []
    for name, param in model.named_parameters():
        if 'weight' in name and param.dim() == 2:
            importance_scores.append(torch.norm(param, p=2))

    threshold = torch.quantile(torch.tensor(importance_scores), 0.1)
    for name, param in model.named_parameters():
        if 'weight' in name and param.dim() == 2:
            mask = torch.abs(param) > threshold
            param.data *= mask.float()

    # Step 3: Distillation to tiny model
    class TinyHeritageDT(nn.Module):
        def __init__(self, state_dim, act_dim, embed_dim=64):
            super().__init__()
            self.state_encoder = nn.Linear(state_dim, embed_dim)
            self.action_encoder = nn.Linear(act_dim, embed_dim)
            self.transformer = nn.TransformerEncoder(
                nn.TransformerEncoderLayer(
                    d_model=embed_dim, nhead=2, dim_feedforward=128
                ),
                num_layers=2
            )
            self.action_predictor = nn.Linear(embed_dim, act_dim)

        def forward(self, states, actions, rtgs, timesteps):
            state_embeds = self.state_encoder(states)
            action_embeds = self.action_encoder(actions)
            stacked = torch.stack((rtgs, state_embeds, action_embeds), dim=2)
            output = self.transformer(stacked)
            return self.action_predictor(output[:, 2::3, :])

    student = TinyHeritageDT(13, 5)  # 13 state dims, 5 action dims
    return student

# After optimization, the model runs at 50mW on a Raspberry Pi Zero
optimized_model = optimize_for_edge(model, example_inputs)
torch.save(optimized_model.state_dict(), 'heritage_dt_quantized.pth')

def dynamic_alignment_mask(state, base_alignment):
    battery = state[0]  # Battery level (0-1)
    time_of_day = state[1]  # 0-24 hours

    mask = base_alignment.clone()

    # When battery is low, prioritize energy efficiency
    if battery < 0.2:
        mask[3] *= 1.5  # save_energy becomes more important
        mask[0] *= 0.5  # interrupt_elder becomes less important (but still bad)

    # During siesta hours (12-15), reduce all interactions
    if 12 <= time_of_day <= 15:
        mask *= 0.7

    return mask / mask.sum()  # Normalize

class ContrastiveDialectEmbedding(nn.Module):
    def __init__(self, audio_dim=128, embed_dim=64):
        super().__init__()
        self.encoder = nn.Linear(audio_dim, embed_dim)
        self.projection = nn.Linear(embed_dim, embed_dim)

    def forward(self, audio_1, audio_2, label):
        # audio_1 and audio_2 are two utterances
        # label=1 if same word (possibly different dialect), 0 if different words
        emb_1 = self.projection(torch.relu(self.encoder(audio_1)))
        emb_2 = self.projection(torch.relu(self.encoder(audio_2)))

        # Contrastive loss
        similarity = torch.cosine_similarity(emb_1, emb_2)
        loss = -label * torch.log(torch.sigmoid(similarity)) - (1-label) * torch.log(1 - torch.sigmoid(similarity))
        return loss.mean()

python
class PowerAwarePlanner:
    def __init__(self, model, solar_forecast):
        self.model = model
        self.solar_forecast = solar_forecast  # Hourly solar irradiance predictions

    def plan_actions(self, current_state, horizon=24):
        # Simulate multiple action sequences and pick the one with best energy efficiency
        best_sequence = None
        best_score = -float('inf')

        for _ in range(100):  # Monte Carlo planning
            state = current_state.copy()
            actions = []
            total_energy = 0
            total_value = 0

            for h in range(horizon):
                # Predict action
                action = self.model.predict_action(state)
                actions.append(action)

                # Estimate energy cost (in mWh)
                energy_cost = self.estimate_energy(action, state)
                total_energy += energy_cost

                # Simulate state transition
                state = self.simulate_transition(state,