julio/carinha-control-panel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(vida): semana da casa com análise por IA e rotina contada

Browse Source 
O aprendizado passa a entender a logística da semana, não só a hora:
- presença por dia da semana × hora (7×24, média móvel por dia) e
  histórico dos últimos 42 dias;
- depois da meia-noite, com 7 dias observados, a IA escolhida (Gemini,
  IA local ou Qwen do S10, via Criacao.chamar) cruza os dias e devolve
  padrões em frases e um plano da semana (casa / fora / dormindo);
- o plano da IA só é adotado se conferir com 70% das horas medidas;
  senão fica como sugestão ("Usar este plano");
- "Conte sua rotina": texto livre vira plano na hora e vale sobre o da
  IA; o painel mostra o quanto confere com o que os sensores veem;
- o plano guia o comportamento: acorda do cochilo 15 min antes da
  chegada naquele dia da semana e, com a casa vazia, tira cochilos
  longos para guardar energia;
- lição da rotina só quando muda 3+ horas ou depois de uma semana, e
  some quando já existe plano da semana;
- painel: quadro da semana (o que eu vi / plano), a rotina entendida,
  sugestão, contar rotina, analisar agora e a IA da análise diária.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
julio
2026-10-09 10:36:32 -03:00
co-authored by Claude Opus 5.5
parent 24625453f7
commit 935bf8d586
8 changed files with 804 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files
aprendizado.py
+287 -10
View File
@@ -8,17 +8,24 @@ Sem IA e sem internet: só conta o que acontece em casa e ajusta o modo vida aos
de um cochilo para estar de pé quando a pessoa chegar.
- Sono: quando o sensor acorda o rosto e ninguém fica nem interage, foi à toa. Se isso se repete
na mesma hora, ele passa a pedir mais movimento para acordar nesse horário.
- Semana: a presença também é guardada por dia da semana × hora, com o histórico dos últimos dias.
Uma vez por dia uma IA (Gemini, IA local ou o S10) cruza esse quadro, acha os padrões ("fora de
terça a quinta, em casa na segunda e na sexta") e propõe um plano da semana. O plano só é usado
se bater com o que os sensores mediram; senão fica como sugestão. A pessoa também pode contar a
rotina com as próprias palavras, e os dados vão dizendo o quanto ela confere.
À meia-noite ele fecha o dia: o que aprendeu vira lição no diário e o que ficou para trás pesa
menos (o gosto das pessoas muda). "Esquecer" zera tudo.
"""
import json
import threading
import time
from datetime import date
from pathlib import Path
from comum import gravar_atomico, ler_json
PADRAO = dict(ligado=True)
PADRAO = dict(ligado=True, analise_ia=True, ia='gemini')
IAS = ('gemini', 'local', 's10')
JANELA = 60 # s depois de um ato em que a resposta de alguém conta para ele
PESO_RESPOSTA = {'carinho': 1.0, 'brincar': 1.0, 'conversa': 1.0, 'alimentar': 0.6, 'cutucar': 0.5}
ESQUECE = 0.85 # todo dia, o que aprendeu antes pesa um pouco menos
@@ -31,6 +38,21 @@ MIN_MINUTOS_HORA = 10 # minutos observados numa hora para ela entrar na rotin
ROTINA_CHEIA, ROTINA_VAZIA = 0.5, 0.3
AVISO_CHEGADA = 15 * 60 # s antes da hora movimentada em que ele acorda do cochilo
MAX_LICOES = 30
DIAS_SEMANA = ['segunda', 'terça', 'quarta', 'quinta', 'sexta', 'sábado', 'domingo']
CURTO = ['seg', 'ter', 'qua', 'qui', 'sex', 'sáb', 'dom']
MEMORIA_SEMANA = 0.5 # cada dia da semana aparece 1 vez por semana: aprende mais rápido
MAX_HISTORICO = 42 # dias guardados para a IA cruzar
MIN_DIAS_ANALISE = 7 # análise automática só com uma semana inteira
MIN_DIAS_MANUAL = 3
MIN_HORAS_CONFERIR = 24 # horas com dados para dizer se um plano bate
CONCORDA = 0.7 # plano da IA só vale se bater com 70% das horas medidas
TIPOS = ['casa', 'fora', 'dormindo']
SCHEMA_PLANO = dict(type='object', required=['padroes', 'dias'], properties=dict(
padroes=dict(type='array', items=dict(type='string')),
dias=dict(type='array', items=dict(type='object', required=['dia', 'periodos'], properties=dict(
dia=dict(type='integer'),
periodos=dict(type='array', items=dict(type='object', required=['ini', 'fim', 'tipo'], properties=dict(
ini=dict(type='integer'), fim=dict(type='integer'), tipo=dict(type='string', enum=TIPOS)))))))))
NOMES = {
'alegre': 'saltitar', 'musica': 'cantarolar', 'feliz': 'sorrir', 'piscadinha': 'piscadinha',
@@ -85,12 +107,21 @@ class Aprendizado:
self.dias = 0
self.licoes = []
self.rotina_avisada = []
self.rotina_avisada_dia = 0
self.hoje = self._dia_vazio(_dia(time.time()))
self.pendentes = [] # atos esperando resposta: (nome, horario)
self.acordou_em = None # acordou pelo sensor: esperando para ver se valeu
self.presenca_depois = [0, 0] # (com gente, total) nas observações depois de acordar
self.minuto = None
self.salvo_em = 0.0
self.semana = [[None] * 24 for _ in range(7)] # presença por dia da semana × hora
self.semana_n = [[0] * 24 for _ in range(7)] # quantos dias mediram cada célula
self.historico = [] # [{dia, sem, presenca[24], respostas, atos}]
self.plano = None # {origem, criado, padroes, dias[7][...]}
self.sugestao = None # plano da IA que não bateu com os dados
self.analise = dict(ocupado=False, erro='', em=None, tipo='')
self.ia = None # (provedor, prompt, schema) -> dict (o main liga)
self.pode_ia = lambda provedor: False
try:
salvo = json.loads(self.caminho.read_text(encoding='utf-8'))
self.config.update(self.validar(salvo.get('config', {})))
@@ -102,6 +133,17 @@ class Aprendizado:
self.dias = int(salvo.get('dias', 0))
self.licoes = [l for l in salvo.get('licoes', []) if isinstance(l, dict)][:MAX_LICOES]
self.rotina_avisada = list(salvo.get('rotina_avisada', []))
self.rotina_avisada_dia = int(salvo.get('rotina_avisada_dia', 0))
if len(salvo.get('semana', [])) == 7:
self.semana = [[None if v is None else float(v) for v in linha] for linha in salvo['semana']]
self.semana_n = [[int(v) for v in linha] for linha in salvo['semana_n']]
self.historico = [d for d in salvo.get('historico', []) if isinstance(d, dict)][-MAX_HISTORICO:]
if salvo.get('plano'):
self.plano = self.validar_plano(salvo['plano'], salvo['plano'].get('origem', 'ia'), salvo['plano'].get('criado'))
if salvo.get('sugestao'):
self.sugestao = self.validar_plano(salvo['sugestao'], 'ia', salvo['sugestao'].get('criado'))
if isinstance(salvo.get('analise_em'), (int, float)):
self.analise['em'] = salvo['analise_em']
if isinstance(salvo.get('hoje'), dict) and salvo['hoje'].get('dia'):
self.hoje.update(salvo['hoje'])
except (OSError, ValueError, TypeError, KeyError, AttributeError):
@@ -119,7 +161,10 @@ class Aprendizado:
for chave, valor in dados.items():
if chave not in PADRAO:
raise ValueError('Ajuste desconhecido: ' + chave)
if not isinstance(valor, bool):
if chave == 'ia':
if valor not in IAS:
raise ValueError('IA: gemini, local ou s10')
elif not isinstance(valor, bool):
raise ValueError(chave + ' precisa ser verdadeiro ou falso')
return dict(dados)
@@ -134,7 +179,9 @@ class Aprendizado:
def esquecer(self):
with self.lock:
self.itens, self.rotina, self.falsos = {}, [None] * 24, [0.0] * 24
self.dias, self.licoes, self.rotina_avisada = 0, [], []
self.semana, self.semana_n = [[None] * 24 for _ in range(7)], [[0] * 24 for _ in range(7)]
self.historico, self.plano, self.sugestao = [], None, None
self.dias, self.licoes, self.rotina_avisada, self.rotina_avisada_dia = 0, [], [], 0
self.hoje = self._dia_vazio(_dia(time.time()))
self.pendentes, self.acordou_em = [], None
self.anotar('aprendizado', 'Esqueceu tudo o que tinha aprendido e começou do zero')
@@ -145,7 +192,10 @@ class Aprendizado:
def salvar(self):
with self.lock:
dados = dict(config=self.config, itens=self.itens, rotina=self.rotina, falsos=self.falsos, dias=self.dias,
licoes=self.licoes, rotina_avisada=self.rotina_avisada, hoje=self.hoje)
licoes=self.licoes, rotina_avisada=self.rotina_avisada, rotina_avisada_dia=self.rotina_avisada_dia,
hoje=self.hoje, semana=self.semana,
semana_n=self.semana_n, historico=self.historico, plano=self.plano, sugestao=self.sugestao,
analise_em=self.analise['em'])
self.salvo_em = time.time()
try:
gravar_atomico(self.caminho, dados)
@@ -243,15 +293,32 @@ class Aprendizado:
def _extra(falsos):
return 2 if falsos >= 1.5 else 1 if falsos >= 0.5 else 0
def esperado(self, agora):
"""'casa', 'fora', 'dormindo' ou None nesta hora: pelo plano da semana, senão pelo que mediu
naquele dia da semana, senão pela média de todos os dias."""
t = time.localtime(agora)
if self.plano:
for p in self.plano['dias'][t.tm_wday]:
if p['ini'] <= t.tm_hour < p['fim']:
return p['tipo']
return None
v = self.semana[t.tm_wday][t.tm_hour] if self.semana_n[t.tm_wday][t.tm_hour] >= 2 else self.rotina[t.tm_hour]
if v is None:
return None
return 'casa' if v >= ROTINA_CHEIA else 'fora' if v < ROTINA_VAZIA else None
def chega_logo(self, agora):
"""Falta pouco para a hora em que costuma ter gente (e agora costuma estar vazio)?"""
if not self.ligado():
return False
t = time.localtime(agora)
prox, atual = self.rotina[(t.tm_hour + 1) % 24], self.rotina[t.tm_hour]
falta = 3600 - (t.tm_min * 60 + t.tm_sec)
return (prox is not None and prox >= ROTINA_CHEIA and (atual is None or atual < ROTINA_VAZIA)
and falta <= AVISO_CHEGADA)
return falta <= AVISO_CHEGADA and self.esperado(agora) != 'casa' and self.esperado(agora + falta + 1) == 'casa'
def casa_vazia(self, agora):
"""Nesta hora a casa costuma ficar vazia: dá para descansar e guardar energia para quando chegarem."""
return self.ligado() and self.esperado(agora) == 'fora'
# ------------------------------------------------------------------ fechar o dia
def virar_dia(self, agora):
@@ -266,6 +333,8 @@ class Aprendizado:
self.anotar('aprendizado', texto, agora)
self.salvar()
self.avisar()
if self.config['analise_ia'] and len(self.historico) >= MIN_DIAS_ANALISE and self.ia and self.pode_ia(self.config['ia']):
self.rodar('analise', self.analisar)
def nome(self, ident):
if ident.startswith('criado:'):
@@ -289,6 +358,17 @@ class Aprendizado:
observou = sum(hoje['observado']) >= 60
if observou:
self.dias += 1
sem = date.fromisoformat(hoje['dia']).weekday()
fracs = [round(hoje['presenca'][h] / hoje['observado'][h], 2) if hoje['observado'][h] >= MIN_MINUTOS_HORA
else None for h in range(24)]
for h, frac in enumerate(fracs):
if frac is not None:
antes = self.semana[sem][h]
self.semana[sem][h] = round(frac if antes is None else antes + (frac - antes) * MEMORIA_SEMANA, 3)
self.semana_n[sem][h] += 1
self.historico.append(dict(dia=hoje['dia'], sem=sem, presenca=fracs, atos=hoje['atos'],
respostas=sum(hoje['respostas'].values()), a_toa=sum(hoje['falsos'])))
del self.historico[:-MAX_HISTORICO]
# gosto: o que agradou e o que foi ignorado hoje
contagem = hoje['contagem']
gostou = sorted(((s, n) for n, (t, s) in contagem.items() if s >= 1), reverse=True)
@@ -301,12 +381,14 @@ class Aprendizado:
if observou and hoje['atos'] >= 5 and not sum(hoje['respostas'].values()):
licoes.append('Hoje ninguém brincou comigo. Amanhã eu tento coisas diferentes.')
# rotina: quando passa a ter um padrão (ou ele muda), conta
if self.dias >= 2:
if self.dias >= 2 and not self.plano:
cheias = [h for h in range(24) if self.rotina[h] is not None and self.rotina[h] >= ROTINA_CHEIA]
if cheias and cheias != self.rotina_avisada:
mudou = not self.rotina_avisada or len(set(cheias) ^ set(self.rotina_avisada)) >= 3 or (
cheias != self.rotina_avisada and self.dias - self.rotina_avisada_dia >= 7)
if cheias and mudou:
licoes.append('Percebi que vocês costumam estar por perto %s. Vou estar acordado nessa hora.'
% _texto_faixas(_faixas(cheias)))
self.rotina_avisada = cheias
self.rotina_avisada, self.rotina_avisada_dia = cheias, self.dias
# sono: acordou à toa várias vezes na mesma hora
piores = sorted(((n, h) for h, n in enumerate(hoje['falsos']) if n >= 2), reverse=True)
if piores:
@@ -325,6 +407,172 @@ class Aprendizado:
del self.licoes[MAX_LICOES:]
return licoes
# ------------------------------------------------------------------ semana: IA e plano
@staticmethod
def validar_plano(bruto, origem, criado=None):
"""Plano vindo da IA (ou salvo): 7 dias de períodos casa/fora/dormindo, horas de 0 a 24."""
if not isinstance(bruto, dict) or not isinstance(bruto.get('dias'), list):
raise ValueError('A IA não devolveu um plano da semana')
dias = [[] for _ in range(7)]
for i, d in enumerate(bruto['dias'][:7]):
if isinstance(d, list): # formato salvo: lista por dia
dia, periodos = i, d
elif isinstance(d, dict):
dia, periodos = d.get('dia'), d.get('periodos')
else:
continue
if isinstance(dia, bool) or not isinstance(dia, int) or not 0 <= dia <= 6 or not isinstance(periodos, list):
continue
for p in periodos[:8]:
if not isinstance(p, dict) or p.get('tipo') not in TIPOS:
continue
try:
ini, fim = max(0, min(23, int(p['ini']))), max(1, min(24, int(p['fim'])))
except (KeyError, TypeError, ValueError):
continue
if ini < fim:
dias[dia].append(dict(ini=ini, fim=fim, tipo=p['tipo']))
for periodos in dias:
periodos.sort(key=lambda p: p['ini'])
for a, b in zip(periodos, periodos[1:]): # sem sobrepor: o anterior termina antes
a['fim'] = min(a['fim'], b['ini'])
periodos[:] = [p for p in periodos if p['ini'] < p['fim']]
if not any(dias):
raise ValueError('O plano veio vazio')
padroes = [str(t).strip()[:160] for t in bruto.get('padroes') or [] if str(t).strip()][:5]
return dict(origem=origem, criado=criado or time.time(), padroes=padroes, dias=dias)
def conferir(self, plano):
"""Quanto o plano bate com o que os sensores mediram (0 a 1), ou None com poucos dados."""
if not plano:
return None
certas = total = 0
for sem in range(7):
for p in plano['dias'][sem]:
for h in range(p['ini'], p['fim']):
v = self.semana[sem][h]
if v is None or not self.semana_n[sem][h]:
continue
total += 1
certas += (v >= ROTINA_VAZIA) if p['tipo'] == 'casa' else (v < ROTINA_CHEIA)
return round(certas / total, 2) if total >= MIN_HORAS_CONFERIR else None
def tabela_semana(self):
linhas = []
for sem in range(7):
celulas = ['%dh:%s' % (h, '—' if v is None else '%d%%' % round(v * 100)) for h, v in enumerate(self.semana[sem])]
linhas.append('%s (%d dias medidos): %s' % (DIAS_SEMANA[sem], max(self.semana_n[sem]), ' '.join(celulas)))
return '\n'.join(linhas)
def resumo_dias(self):
linhas = []
for d in self.historico[-21:]:
horas = [h for h, v in enumerate(d['presenca']) if v is not None and v >= ROTINA_VAZIA]
casa = _texto_faixas(_faixas(horas)) if horas else 'ninguém por perto'
linhas.append('%s (%s): gente %s; %d carinhos/conversas' % (d['dia'], DIAS_SEMANA[d['sem']], casa, d['respostas']))
return '\n'.join(linhas)
def montar_prompt(self, pedido=None):
base = (
'Você é o Carinha, um robô de mesa que observa a casa por um sensor de presença. Analise a rotina da '
'casa e responda em português do Brasil.\n\n'
'Presença por dia da semana e hora (% do tempo com alguém perto do robô; — = sem dados):\n'
+ self.tabela_semana() + '\n\nÚltimos dias, um por linha:\n' + (self.resumo_dias() or '(nenhum ainda)') + '\n\n')
regras = (
'"dias": para cada dia da semana (dia 0 = segunda ... 6 = domingo) dê períodos que cubram de 0 a 24h sem '
'sobrepor, com tipo "casa" (tem gente acordada por perto), "fora" (casa vazia) ou "dormindo" (noite, '
'gente em casa dormindo). Horas inteiras, ini de 0 a 23, fim de 1 a 24.')
if pedido:
return base + (
'A pessoa contou a rotina dela com as próprias palavras:\n"' + pedido + '"\n\n'
'Transforme isso no plano da semana. Vale o que a pessoa disse; use os dados só para completar o que '
'ela não falou (por exemplo, o horário de dormir). ' + regras + '\n"padroes": até 4 frases curtas, em '
'primeira pessoa, resumindo a rotina que você entendeu (ex.: "Você fica fora de terça a quinta, das 8h às 18h").')
return base + (
'Cruze os dias: procure dias da semana parecidos entre si (dias úteis iguais, fim de semana diferente, um '
'dia que foge da regra), horários de chegada e de saída, e quando a casa fica vazia. Só afirme o que os '
'dados mostram; para dias sem dados, repita o padrão dos dias parecidos.\n'
'"padroes": até 5 frases curtas, em primeira pessoa, sobre o que você percebeu (ex.: "Percebi que de terça a '
'quinta a casa fica vazia das 8h às 18h, mas na segunda e na sexta tem gente o dia todo"). ' + regras)
def rodar(self, tipo, funcao, *args):
"""Uma análise por vez, em segundo plano (a IA local pode levar minutos)."""
with self.lock:
if self.analise['ocupado']:
raise ValueError('Já estou analisando, espere terminar')
self.analise.update(ocupado=True, erro='', tipo=tipo)
self.avisar()
def tarefa():
try:
funcao(*args)
except Exception as e:
with self.lock:
self.analise['erro'] = str(e)[:200]
finally:
with self.lock:
self.analise['ocupado'] = False
self.salvar()
self.avisar()
threading.Thread(target=tarefa, daemon=True).start()
def chamar_ia(self, pedido=None):
provedor = self.config['ia']
if not self.ia or not self.pode_ia(provedor):
raise ValueError('IA indisponível: confira a chave do Gemini ou a IA local nos Ajustes')
return self.ia(provedor, self.montar_prompt(pedido), SCHEMA_PLANO)
def analisar(self, agora=None):
"""A IA cruza a semana e propõe um plano. Só vale se bater com os dados; senão vira sugestão."""
agora = agora or time.time()
plano = self.validar_plano(self.chamar_ia(), 'ia')
nota = self.conferir(plano)
with self.lock:
self.analise['em'] = agora
usar = nota is not None and nota >= CONCORDA and (not self.plano or self.plano['origem'] == 'ia')
if usar:
self.plano, self.sugestao = plano, None
else:
self.sugestao = plano
if plano['padroes']:
texto = plano['padroes'][0] if usar else 'Acho que ' + plano['padroes'][0][0].lower() + plano['padroes'][0][1:]
self.anotar('aprendizado', texto, agora)
with self.lock:
self.licoes.insert(0, dict(dia=_dia(agora), texto=texto))
del self.licoes[MAX_LICOES:]
return plano
def informar(self, texto, agora=None):
"""A pessoa contou a rotina: vira o plano na hora (os dados conferem depois)."""
texto = str(texto or '').strip()
if not 5 <= len(texto) <= 600:
raise ValueError('Conte a rotina em uma ou duas frases (até 600 letras)')
plano = self.validar_plano(self.chamar_ia(texto), 'voce')
with self.lock:
self.plano, self.sugestao = plano, None
self.analise['em'] = agora or time.time()
self.anotar('aprendizado', 'Você me contou sua rotina. Vou seguir e conferir com o que eu vir.', agora)
def chamar_ia_pronta(self):
if not self.ia or not self.pode_ia(self.config['ia']):
raise ValueError('IA indisponível: confira a chave do Gemini ou a IA local nos Ajustes')
def usar_sugestao(self):
with self.lock:
if not self.sugestao:
raise ValueError('Não há sugestão para usar')
self.plano, self.sugestao = dict(self.sugestao, origem='voce'), None
self.salvar()
self.avisar()
return self.status()
def apagar_plano(self):
with self.lock:
self.plano = None
self.salvar()
self.avisar()
return self.status()
# ------------------------------------------------------------------ painel
def status(self):
with self.lock:
@@ -338,6 +586,13 @@ class Aprendizado:
return dict(config=dict(self.config), dias=self.dias, rotina=list(self.rotina),
sono=[self._extra(f) if self.ligado() else 0 for f in self.falsos],
gosto=gosto, licoes=self.licoes[:12],
semana=[[v if self.semana_n[s][h] else None for h, v in enumerate(linha)]
for s, linha in enumerate(self.semana)],
historico_dias=len(self.historico),
plano=self.plano and dict(self.plano, confere=self.conferir(self.plano)),
sugestao=self.sugestao and dict(self.sugestao, confere=self.conferir(self.sugestao)),
analise=dict(self.analise, pode=bool(self.ia) and self.pode_ia(self.config['ia']),
minimo=MIN_DIAS_MANUAL),
hoje=dict(dia=hoje['dia'], atos=hoje['atos'], respostas=dict(hoje['respostas']),
acordou=sum(hoje['acordou']), a_toa=sum(hoje['falsos'])))
@@ -355,6 +610,28 @@ class Aprendizado:
resultado = self.configurar(ler_json(h, 1024))
elif metodo == 'POST' and rota == '/aprendizado/esquecer':
resultado = self.esquecer()
elif metodo == 'POST' and rota == '/aprendizado/analisar':
ler_json(h, 64)
if len(self.historico) < MIN_DIAS_MANUAL:
raise ValueError('Preciso de pelo menos %d dias observados para analisar' % MIN_DIAS_MANUAL)
self.chamar_ia_pronta()
self.rodar('analise', self.analisar)
resultado = self.status()
elif metodo == 'POST' and rota == '/aprendizado/rotina':
texto = ler_json(h, 4096).get('texto')
if not 5 <= len(str(texto or '').strip()) <= 600:
raise ValueError('Conte a rotina em uma ou duas frases (até 600 letras)')
self.chamar_ia_pronta()
self.rodar('rotina', self.informar, texto)
resultado = self.status()
elif metodo == 'POST' and rota == '/aprendizado/plano':
acao = ler_json(h, 256).get('acao')
if acao == 'usar_sugestao':
resultado = self.usar_sugestao()
elif acao == 'apagar':
resultado = self.apagar_plano()
else:
raise ValueError('Ação: usar_sugestao ou apagar')
else:
raise ValueError('Rota inválida')
h.enviar(json.dumps(resultado, ensure_ascii=False))