O matcher é um módulo do SPACY destinado a encontrar padrões.
Um exemplo de código:
from spacy.matcher import Matcher
mat = Matcher(nlp.vocab)
padrao =[{"ORTH":"("},"SHAPE":"dd"},{"ORTH":")"},{"ORTH":"-","OP":"?"},{"IS_DIGIT":True})
doc= nlp("Meu telefone é (16) 981434112")
matches= matcher(doc)
for match_id, start, end in mat:
print(doc[start:end])
Daemon são programas que rodam em back ground e que são inicializados e controlados pelo sistema operacional.
Os daemon são geralmente serviços que devem ser gerenciados de forma automatica.
Iremos apresentar aqui um bom exemplo de como criar um daemon.
Para criar um daemon, primeiramente seu binário precisa ser incluído em um local que permita o acesso para qualquer usuário, por este motivo a inclusão na pasta /home/[usuário] não é uma boa pratica. Em geral incluímos em uma pasta como /usr/bin.
Os arquivos de configuração , quando houver, poderão ser incluídos na pasta /etc/[nome daemon].
A criação
A criação do daemon é bem simples.
Crie em /etc/systemd/system/ o arquivo [servido].service, tal como o exemplo do meu git:
Edite o arquivo [servico].service conforme apresentado abaixo:
[Unit]
Description=[Descreva o que faz o servico]
After=network.target
[Service]
ExecStart=/usr/bin/[servico_binario]
Restart=always
User=root
Group=root
[Install]
WantedBy=multi-user.target
Salve o serviço e como sudo dê o seguinte comando:
No vídeo anterior, apresentamos uma pequena apresentação de um sistema de malha aberta.
Agora iremos apresentar um exemplo de malha fechada.
Conforme o wiki:
“Também chamado de controle retroativo (realimentação ou feedback) necessita de informações da saída do controlador através de elementos sensores ou transdutores, compara o sinal da saída com o set-point(referência) e corrige a saída caso a mesma esteja desviando-se dos parâmetros programados.”
O vídeo de treinamento deste material pode ser visto aqui.
Primeiramente, temos que carregar a função control, através do comando:
pkg load control
Em seguida criamos o num01 e den01, da planta.
Em seguida criamos o num02 e den02 da função de controle.
Por fim atribuimos a função de feedback, através da união de ambas as funções:
sys01= feedback(tf01,tf02);
Lembrando que a função feedback , aceita mais um parâmetro, que é o sinal de realimentação.
“Se sign for omitido ou definido como +1, indica que o sinal de realimentação é positivo (realimentação negativa). Se sign for definido como -1, indica realimentação positiva.”
%Apresentação do sistema de malha fechada
pkg load control
%Sistema de transferencia da planta.
num01 = [1];
den01 = [1,2,10];
%tf01 - Sistema da Planta
%tf01=tf([1],[1,2,10])
tf01=tf(num01,den01);
num02=[2];
den02=[1];
% Função de controle
tf02=tf(num02,den02);
% Construir o sistema de malha fechada
sys01= feedback(tf01,tf02);
disp(sys01);
step(sys01);
xlabel('tempo');
ylabel('saida v');
title('Sistema malha fechada');
Pelo wiki: “Função de transferência é a representação matemática da relação entre a entrada e a saída de um sistema físico.”
Desta forma podemos simular equipamentos físicos através de funções matemáticas, simulando seus resultados.
De forma geral existem 2 tipo de simulação.
Sistema Malha Abertos – São sistemas que apresentam apenas uma entrada – > Com sua respectiva saída.
Já um sistema de malha fechada, possui feedback, sendo definido pela wiki como:
“Também chamado de controle retroativo (realimentação ou feedback) necessita de informações da saída do controlador através de elementos sensores ou transdutores, compara o sinal da saída com o set-point(referência) e corrige a saída caso a mesma esteja desviando-se dos parâmetros programados.”
Entendendo como funciona o sistema de malha aberta no OCTAVE:
Para entender o sistema de malha aberta , com uso da função de transferência, montei este vídeo para voces.
Podemos inicialmente verificar, que faz-se necessário o uso da lib control, pois o octave precisa desta lib para utilizar o sistema de transferencia.
Para isso usamos o comando:
pkg load control
Em seguida precisamos criar a função de transferência atribuindo o numerador num01 e denominador den01. Em criando a função de transferência, que será utilizada para injetar os valores de entrada.
Logo atribuimos a função tf(num,den) criando a variavel S01, que armazena a função de transferencia.
Agora por fim, atuaremos passando os valores de entrada, através do t, e plotando no gráfico, conforme a função step.
O resultado final fica conforme apresentado a seguir:
% Carrega o pacote da função de transferencia.
pkg load control
% 1
% -------------
% S^2 +2S + 10
% num01
% den01
%num01= [0,0,1];
num01 = [1];
den01= [1,2,10];
% Cria a funçao de transferencia
S01= tf(num01,den01);
disp(S01);
%Atribui um vetor de tempo
t= 0:0.1:10;
%Resposta ao degrau da função de transferencia
step(S01,t);
xlabel('Tempo');
ylabel('Saida (v)');
title('Resposta da Função de transferencia');
Podemos ver, no exemplo acima, que temos a variável vt, que tem 3 elementos, 10,20 e 30, armazenados.
Desta forma sempre que falarmos em vt, estaremos trabalhando com os valores [10,20,30]. Até que este seja modificado.
Ao declarar resultado4, fazemos a operação matemática de multiplicação por 2, ficando [20,40,60 como resultado na variável resultado4.
Comparando valores
Agora iremos usar o valor armazenado na variável para tomar uma decisão. Para isso usamos o comando if, conforme nosso exemplo.
x = 14;
printf("\n\n");
if (x == 12)
printf("O valor bateu\n");
else
printf("O valor nao bateu\n");
end;
printf("\n\n");
if (x < 12)
printf("O valor é menor que 12\n");
else
printf("O valor é maior ou igual a 12\n");
end;
Neste exemplo testamos o valor de x, verificando se este atende a condição onde == é valor igual ao definido, < (menor que o definido).
Atendendo o primeiro print será mostrado. Caso contrário, ele mostrará o print atribuído após o else.
O Else pode ser omitido, não tendo então exceção. Apenas condição de atendimento ao teste if.
Iremo hoje, usar o octave para definir e criar gráficos do segundo grau.
Para isso iremos utilizar o exemplo abaixo:
% Gerar gráfico de Função do Segundo Grau
% X^2 + 2X + 10
% 2X^2 +2X^1 + 10X^0
x = -10:0.1:10;
y = 2*x.^2 - 5*x - 100;
plot(x, y);
xlabel('x');
ylabel('f(x)');
title('Gráfico da função f(x) = x^2 + 2x + 10');
grid on;
Em gráficos do segundo grau, temos os valores de Y em função do X, sendo assim primeiramente atribuimos o x. O X recebe uma faixa de valores, ou seja, valores que serão apresentados ao Y, começando do -10 até o valor 10, pulando de 0.1 em 0.1.
Para isso usamos a seguinte sintaxe:
x = valor_inicial: pulo : valor_final
Onde:
valor_inicial é o primeiro valor a ser atribuido a X, no nosso caso -10;
pulo é o valor que será acrescido de contagem a contagem até chegar ao valor final, exemplo: -10.0, -9.99, -9.98, 9.98…,9.98, 9.99, 10.00 , no nosso caso o pulo será 0.1.
valor _final é o valor que se quer chegar para terminar a contagem, no nosso caso 10
Os modelos em português não destoam do português Brasil, pois as regras ortográficas são as mesmas em qualquer pais com a língua.
Ao rodar nosso install o padrão do modelo com melhor acurácia, já será instalado automáticamente.
Primeiro Exemplo
Agora iremos colocar a mão na massa!
Neste primeiro modelo, apresentamos um texto e analisamos o mesmo de forma sintática.
Esterei apresentando o Ex01 do nosso git:
import spacy
nlp = spacy.load("pt_core_news_lg")
import pt_core_news_lg
nlp = pt_core_news_lg.load()
doc = nlp("O Marcelo pegou COVID-19 em setembro de 2019, porem não teve problemas com isso")
for token in doc:
print("Token:"+token.text)
print("Pos:"+token.pos_)
Nele importamos a lib spacy, e em seguida carregamos a rede treinada pt_core_news_lg. Após isso identificamos o texto alvo através da variável doc.
E em seguida mostramos alguns resultados tokenizados.
O POS faz a analise do que significa o token.
Maior informação sobre a morfologia aplicada ao spacy pode ser vista no link abaixo:
