Site de documentação da Maurinsoft
Site de documentação da Maurinsoft
Na versão 1.22 do fila, incluímos muitas evoluções.
Alem do visual melhorado, tambem incluimos versões desktop para o painel de senhas, bem como funcionalidades melhoradas no guichê e no fila.
Por ultimo, incluímos a versão Linux do Guichê que contará com atualizações para windows e Linux.
O instalador do guich}
Este projeto propõe o desenvolvimento de um chatbot inteligente voltado para dúvidas sobre processos e procedimentos, utilizando exclusivamente um banco de dados relacional (MySQL) como fonte principal de consulta, sem uso de bancos vetoriais como ChromaDB. O sistema será capaz de pesquisar documentos, apresentar respostas, registrar feedback dos usuários e, em caso de respostas insuficientes, recorrer à API do ChatGPT como fallback.
/docs_novos/ para documentos a indexar, /docs_indexados/ para documentos já processados.pdfminer.six e python-docx.sqlCopiarEditarCREATE TABLE documentos (
id INT AUTO_INCREMENT PRIMARY KEY,
nome_arquivo VARCHAR(255),
texto LONGTEXT,
data_upload DATETIME,
usuario VARCHAR(100)
);
CREATE TABLE interacoes (
id INT AUTO_INCREMENT PRIMARY KEY,
id_documento INT,
pergunta TEXT,
resposta TEXT,
foi_fallback BOOLEAN,
data DATETIME,
FOREIGN KEY (id_documento) REFERENCES documentos(id)
);
CREATE TABLE feedback (
id INT AUTO_INCREMENT PRIMARY KEY,
id_interacao INT,
avaliacao ENUM('boa','ruim'),
comentario TEXT,
data DATETIME,
FOREIGN KEY (id_interacao) REFERENCES interacoes(id)
);
| Framework/Biblioteca | Função |
|---|---|
| Python 3.9+ | Linguagem principal |
| MySQL | Banco relacional, principal repositório |
| mysql-connector-python | Conexão Python-MySQL |
| pdfminer.six | Ler PDF |
| python-docx | Ler Word |
| OpenAI (API) | ChatGPT (fallback) |
| Unstructured | Ler múltiplos formatos (opcional) |
| Streamlit/Flask (opcional) | Interface web |
O projeto propõe uma solução prática, fácil de gerenciar e com requisitos tecnológicos acessíveis, usando o MySQL como núcleo do sistema. Garante automatização da base de conhecimento, integração com IA de ponta (ChatGPT), avaliação do usuário e flexibilidade para futuras expansões.
Lucas tem 16 anos, é curioso e adora desmontar coisas. Um dia, enquanto mexia numa caixa de sucata do avô, encontrou uma pequena lâmpada de LED vermelha e uma bateria de 9V.
— “Será que consigo acender isso?”, pensou, empolgado.
Ele conectou o LED direto na bateria. Por um instante, ele brilhou forte… e depois queimou!
— “Mas por que isso aconteceu? Não era só ligar e pronto?”
Frustrado, Lucas correu até sua irmã Ana, que estava estudando para a prova de física. Ela olhou para ele e sorriu:
— Ana: “Lucas, você acabou de aprender na prática o que eu estudei hoje: Lei de Ohm e eletricidade básica.”
Ana pegou um papel e começou a desenhar:
— Ana: “Lembra que a gente aprendeu que a eletricidade é o movimento dos elétrons?
Na escola, estudamos tensão (voltagem), que é como a pressão da água num cano, e corrente, que é como o fluxo dessa água. E tem também a resistência, que é como se fosse um aperto no cano que controla o fluxo.”
Lucas, curioso, respondeu:
— Lucas: “Ah, então quando liguei o LED direto na bateria, era como jogar um jato de água sem controle?”
— Ana: “Exatamente! O LED não aguenta toda essa ‘pressão’. É por isso que ele queimou.”
Ana escreveu a fórmula da Lei de Ohm no caderno: V=R⋅IV = R \cdot IV=R⋅I
— Ana: “Olha só: se reorganizarmos, podemos calcular a resistência necessária:” R=Vfonte−VLEDILEDR = \frac{V_\text{fonte} – V_\text{LED}}{I_\text{LED}}R=ILEDVfonte−VLED
Lucas ficou intrigado.
— Lucas: “Então preciso de um resistor para proteger o LED?”
— Ana: “Sim! Isso é exatamente o que aprendemos em física: controlar a corrente usando resistência.”
Ela explicou que cada cor de LED tem uma queda de tensão típica. Pegou uma tabela na internet:
| Cor do LED | Tensão típica (V) |
|---|---|
| 🔴 Vermelho | 2,0 V |
| 🟢 Verde | 2,2 V |
| 🔵 Azul | 3,0 V |
| ⚪ Branco | 3,2 V |
Lucas, empolgado, disse:
— Lucas: “Mas calcular isso toda hora é chato. Vou programar isso!”
Ele abriu o notebook e escreveu em Python:
def calcular_resistencia(v_fonte, v_led, i_led_mA):
"""
Calcula a resistência ideal para um LED usando a Lei de Ohm.
v_fonte: tensão da fonte (Volts)
v_led: tensão típica do LED (Volts)
i_led_mA: corrente do LED (miliamperes)
"""
i_led = i_led_mA / 1000 # converte mA para A
return (v_fonte - v_led) / i_led
print("=== Sistema Computacional: Cálculo de Resistor para LED ===")
v_fonte = float(input("Digite a tensão da fonte (V): "))
v_led = float(input("Digite a tensão do LED (V): "))
i_led_mA = float(input("Digite a corrente do LED (mA): "))
resistor = calcular_resistencia(v_fonte, v_led, i_led_mA)
print(f"\n🔧 Resistor recomendado: {resistor:.2f} Ω")
print("Use o valor comercial mais próximo.")
Ele digitou os valores:
O computador respondeu:
Resistor recomendado: 350.00 Ω
Lucas ficou maravilhado:
— Lucas: “Então com um resistor de 350Ω, meu LED vai funcionar sem queimar?”
— Ana: “Sim! E olha como você aplicou física e programação juntas. Isso é exatamente o que estamos aprendendo no segundo grau: usar conceitos teóricos para resolver problemas práticos.”
No dia seguinte, Lucas levou o circuito para a escola. Na aula de física, a professora pediu que os alunos montassem o mesmo experimento em protoboards.
Eles testaram resistores diferentes:
A turma riu quando viram o LED queimando sem resistor, e todos compreenderam de forma prática o motivo da existência dos resistores.
Ao final da aula, a professora disse:
“O que Lucas fez foi criar um sistema computacional para resolver um problema real de eletrônica. Ele aplicou conceitos de física (Lei de Ohm), eletrônica (uso de resistores) e programação (Python) de forma integrada.”
Lucas sorriu. Agora, sempre que via um LED acender — seja na TV, no celular ou até no semáforo — ele lembrava que havia ciência e cálculo por trás daquele simples pontinho de luz.
Inspirado na história de Lucas, você fará o mesmo em sala de aula:
O multímetro é uma ferramenta essencial para medir e testar circuitos elétricos. Ele será usado no projeto para:
📌 Aplicação no projeto: Antes de ligar o LED, os alunos vão usar o multímetro para conferir a voltagem da fonte e o valor do resistor escolhido. Isso evita erros e garante segurança.
A protoboard será o espaço para montar e testar o circuito do LED sem necessidade de solda.
📌 Aplicação no projeto: Os alunos irão montar o circuito calculado (Fonte → Resistor → LED) na protoboard e testar os diferentes valores de resistência.
Os resistores têm faixas coloridas que indicam seu valor em Ohms. Essa tabela será usada para identificar e confirmar os resistores corretos para o projeto.
| Cor | Número |
|---|---|
| Preto | 0 |
| Marrom | 1 |
| Vermelho | 2 |
| Laranja | 3 |
| Amarelo | 4 |
| Verde | 5 |
| Azul | 6 |
| Violeta | 7 |
| Cinza | 8 |
| Branco | 9 |
📌 Aplicação no projeto: Após calcular o valor com Python, os alunos vão:
1️⃣ Calcular no Python o valor do resistor.
2️⃣ Identificar o resistor pela tabela de cores.
3️⃣ Medir no multímetro para confirmar o valor.
4️⃣ Montar o circuito na protoboard com a fonte, resistor e LED.
5️⃣ Ligar e observar: testar brilho e segurança do LED.
6️⃣ Experimentar resistores de valores diferentes e anotar os resultados.
Objetivo: Relembrar conceitos fundamentais e contextualizar o experimento.
Objetivo: Familiarizar os alunos com os instrumentos e componentes.
Objetivo: Aplicar programação para automatizar o cálculo do resistor.
Objetivo: Relacionar cálculo teórico com identificação prática.
Objetivo: Aplicar física e programação para criar o circuito.
Objetivo: Observar efeitos práticos de diferentes resistências.
Objetivo: Consolidar os conceitos.
class LancadorDeDados:
def init(self, nro_lancamentos):
self.nro_lancamentos = nro_lancamentos
self.nro_ocorrencias = 6 # dado com 6 faces
def calculaPercentual(self):
"""Calcula o percentual usando a fórmula: (1/nro_ocorrencias)^nro_lancamentos."""
return (1 / self.nro_ocorrencias) ** self.nro_lancamentos * 100
def mostrar_percentual(self):
"""Mostra o resultado do cálculo."""
percentual = self.calculaPercentual()
print(f"Lançamentos: {self.nro_lancamentos} → Percentual: {percentual:.4f}%")
==========================
Programa principal no Colab
==========================
for n in range(1, 6): # Calcula de 1 até 5 lançamentos consecutivos
dado = LancadorDeDados(nro_lancamentos=n)
dado.mostrar_percentual()
Este programa calcula a probabilidade percentual de ocorrer uma sequência específica de resultados ao lançar um dado de 6 faces diversas vezes de forma consecutiva.
Ele utiliza a fórmula de probabilidade para eventos independentes:
Percentual = (1 / nro_faces) ^ nro_lancamentos × 100
Cada lançamento de um dado justo de 6 faces possui probabilidade igual de 1/6 para cada face.
Como os lançamentos são eventos independentes, a chance de obter o mesmo resultado consecutivamente é dada pela multiplicação das probabilidades.
Para transformar isso em percentual, multiplicamos o resultado por 100.
1 lançamento:
P = (1 / 6) × 100 ≈ 16,67%2 lançamentos consecutivos iguais:
P = (1 / 6)² × 100 ≈ 2,78%3 lançamentos consecutivos iguais:
P = (1 / 6)³ × 100 ≈ 0,46%LancadorDeDados.O programa mostra o percentual de chance para cada quantidade de lançamentos consecutivos:
Neste programa testaremos se o resultado apresentado, condiz com a prática.
A idéia é lançar o dado muitas vezes e acompanhar as estatísticas de seu lançamento.
class LancadorDeDados:
def init(self):
self.resultados = [] # Lista para armazenar os lançamentos
def registrar_lancamento(self, valor):
"""Registra o valor digitado pelo usuário."""
if 1 <= valor <= 6:
self.resultados.append(valor)
else:
print("⚠️ Valor inválido! Digite apenas números de 1 a 6.")
def calculaPercentual(self, ocorrencias, total):
"""Calcula o percentual de ocorrência."""
return (ocorrencias / total) * 100 if total > 0 else 0
def mostrar_estatistica(self):
"""Exibe a estatística atualizada após cada lançamento."""
total = len(self.resultados)
print(f"\n📊 Estatística após {total} lançamentos:")
for face in range(1, 7):
ocorrencias = self.resultados.count(face)
percentual = self.calculaPercentual(ocorrencias, total)
print(f"Face {face}: {ocorrencias} ocorrências ({percentual:.2f}%)")
def mostrar_relatorio_final(self):
"""Exibe o relatório final consolidado."""
print("\n✅ Relatório Final:")
self.mostrar_estatistica()
==========================
Programa principal no Colab
==========================
dado = LancadorDeDados()
print("🎲 Digite os valores obtidos no lançamento do dado (1 a 6).")
print("Digite 0 para encerrar.\n")
while True:
valor = int(input("Digite o valor do dado (1 a 6) ou 0 para sair: "))
if valor == 0:
break
dado.registrar_lancamento(valor)
dado.mostrar_estatistica()dado.mostrar_relatorio_final()
Este programa permite registrar manualmente os resultados de lançamentos de um dado e calcular a estatística de frequência e percentual de cada face (1 a 6) em tempo real.
O programa segue um loop contínuo onde o usuário digita o valor obtido em cada lançamento, e ao digitar 0 o sistema encerra e apresenta o relatório final consolidado.
A estatística apresentada pelo programa é baseada na frequência relativa de cada face, calculada como:
Percentual da Face = (Número de ocorrências da face / Total de lançamentos) × 100
Isso permite observar a distribuição das faces e como ela evolui à medida que mais lançamentos são registrados.
LancadorDeDados.__init__(self)self.resultados para armazenar os lançamentos.registrar_lancamento(self, valor)calculaPercentual(self, ocorrencias, total)mostrar_estatistica(self)mostrar_relatorio_final(self)Utilizar o programa de estatística de lançamentos de dado para registrar resultados reais e comparar com os valores teóricos de probabilidade, entendendo como a frequência relativa se aproxima da probabilidade real à medida que aumentamos o número de lançamentos.
Os alunos devem perceber que:
Isso demonstra, na prática, a Lei dos Grandes Números, um princípio fundamental da estatística e probabilidade.
🔎 Exemplo sem conexão (Unigrama):
Limite: Não entende contexto. Pode gerar sugestões sem sentido.
🔎 Exemplo:
Agora o modelo entende contexto básico.
🔧 Como funciona:
🖥 Exemplo prático:
Usado em preditores antigos como T9 de celulares.
https://youtu.be/sANCpLOZPIo?si=UkJ0P7unx1tepvH2
🔎 Exemplos: Word2Vec, RNN, LSTM
✨ Aplicações:
💡 Frase de impacto final:
“A estatística deu os primeiros passos, mas as IAs atuais nos fizeram correr maratonas na linguagem!”
O Teatro das Competências tem como meta:
Professor pode falar:
“Hoje vamos trabalhar situações comuns do ambiente profissional por meio de encenações rápidas. Vocês vão receber roteiros baseados em desafios reais, como conflitos entre colegas, atendimento a clientes insatisfeitos, brainstorming de ideias e entrevistas simuladas.
O objetivo não é apenas ‘atuar’, mas mostrar como resolver problemas usando empatia, comunicação clara e colaboração. No fim, vamos discutir juntos o que funcionou bem e o que poderia ser melhorado.”
Cada grupo recebe um roteiro impresso com: situação, contexto, papéis e objetivos.
Cada participante deve receber uma ficha individual, contendo:
Após todas as apresentações:
Uma clínica médica está implementando um sistema de prontuário eletrônico. Durante o desenvolvimento, um novo requisito surge: permitir que os pacientes consultem seus exames online.
Tarefas:
Plano de Gerenciamento de Mudanças:
Fluxo UML (atividade simplificada):
[Solicitação de Mudança] → [Análise de Impacto] → [Aprovação do Comitê] →
[Planejamento no Backlog] → [Implementação e Testes] → [Deploy e Feedback]
Métodos Ágeis:
Crie uma classe Pessoa com atributos comuns (nome, idade e CPF), e duas subclasses: Aluno e Professor, que herdam atributos e adicionam informações específicas.
class Pessoa:
def __init__(self, nome, idade, cpf):
self._nome = nome
self._idade = idade
self._cpf = cpf
def get_nome(self):
return self._nome
def set_nome(self, nome):
self._nome = nome
def get_idade(self):
return self._idade
def set_idade(self, idade):
self._idade = idade
def get_cpf(self):
return self._cpf
def set_cpf(self, cpf):
self._cpf = cpf
class Aluno(Pessoa):
def __init__(self, nome, idade, cpf, serie):
super().__init__(nome, idade, cpf)
self.serie = serie
def exibir_informacoes(self):
return f"Aluno: {self.get_nome()}, Idade: {self.get_idade()}, Série: {self.serie}"
class Professor(Pessoa):
def __init__(self, nome, idade, cpf, disciplina):
super().__init__(nome, idade, cpf)
self.disciplina = disciplina
def exibir_informacoes(self):
return f"Professor: {self.get_nome()}, Idade: {self.get_idade()}, Disciplina: {self.disciplina}"
# Teste
aluno1 = Aluno("Carlos", 15, "123.456.789-00", "9º Ano")
prof1 = Professor("Ana", 35, "987.654.321-00", "Matemática")
print(aluno1.exibir_informacoes())
print(prof1.exibir_informacoes())
Saída esperada:
yamlCopiarEditarAluno: Carlos, Idade: 15, Série: 9º Ano
Professor: Ana, Idade: 35, Disciplina: Matemática
Implemente classes de transporte (Moto, Caminhao, Drone) que calculam o tempo de entrega de forma distinta, utilizando polimorfismo.
from abc import ABC, abstractmethod
class Transporte(ABC):
@abstractmethod
def calcular_tempo(self, distancia):
pass
class Moto(Transporte):
def calcular_tempo(self, distancia):
velocidade = 60 # km/h
return distancia / velocidade
class Caminhao(Transporte):
def calcular_tempo(self, distancia):
velocidade = 40 # km/h
return distancia / velocidade
class Drone(Transporte):
def calcular_tempo(self, distancia):
velocidade = 80 # km/h
return distancia / velocidade
# Teste com polimorfismo
transportes = [Moto(), Caminhao(), Drone()]
distancia = 120 # km
for t in transportes:
print(f"{t.__class__.__name__}: Tempo estimado = {t.calcular_tempo(distancia):.2f} horas")
Saída esperada:
Moto: Tempo estimado = 2.00 horas
Caminhao: Tempo estimado = 3.00 horas
Drone: Tempo estimado = 1.50 horas
Carro e Estoque, aplicação de getters e setters, e métodos como adicionar_carro.depositar, sacar, consultar_saldo).
O desenvolvimento de modelos de inteligência artificial depende diretamente da qualidade e da diversidade dos dados utilizados para treinamento. Entretanto, a construção dessas bases costuma ser um grande desafio, exigindo ferramentas específicas para coleta, análise e organização de dados multimodais (texto, áudio, vídeo, imagens, documentos e produtos comerciais).
Pensando nessa necessidade, foi criado o projeto Ferramentas de Treinamento para Redes Neurais, um pacote integrado que oferece automação e gestão de dados para pesquisa, treinamento e experimentação em IA.
O projeto visa fornecer um ecossistema unificado para coleta e preparação de dados de treinamento, eliminando processos manuais e descentralizados.
Ele integra diferentes módulos que atuam em conjunto:
A IA moderna exige grandes volumes de dados rotulados e variados para treinar modelos capazes de generalizar bem em situações reais.
Muitas vezes, os dados disponíveis estão dispersos em fontes distintas, sem padronização ou acessibilidade prática. Isso gera problemas como:
Além disso, empresas e pesquisadores que não possuem infraestrutura especializada têm dificuldade para replicar pipelines consistentes de treinamento de modelos.
Este projeto surge como uma solução modular e acessível, reunindo automação e banco de dados estruturado em MySQL, simplificando a criação de datasets ricos para experimentos de IA.
O código-fonte completo está disponível no GitHub:
➡️ https://github.com/marcelomaurin/TreinamentosIA
Criação e teste em diversos modelos de IA online e offline.
Melhora dos processos de classificação de documentos, palavras chaves de busca, referencias , síntese.
Uso de IAs para gerar melhora na qualidade dos dados.
O projeto Ferramentas de Treinamento para Redes Neurais democratiza a preparação de datasets e a experimentação em IA, permitindo que desenvolvedores, pesquisadores e equipes técnicas acelerem seu ciclo de desenvolvimento de modelos.
Com uma estrutura modular, aberta e escalável, ele resolve um dos principais gargalos da área: a obtenção e organização de dados para treinar inteligências artificiais robustas e eficazes.
Portuguese 
English