IA Python
Marcelo Martins ,
SPACY – MATCHER

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])

Tabela dos padrões do MATCHER

  • ORTH, TEXT – Texto exato
  • LOWER – Forma minuscula
  • LENGTH – Tamanho do texto
  • IS_ALPHA – É caracter
  • IS_ASCII – É ascii
  • IS_DIGIT – É numerico
  • IS_LOWER – é caixa baixa
  • IS_UPPER – É caixa alta
  • IS_TITLE – É um titulo
  • IS_PUNCT – Pontuação
  • IS_SPACE – Espaco
  • IS_STOP – Stop Word
  • IS_SENT_START – Inicio de frase
  • LIKE_NUM – Parece um numero
  • LIKE_URL – Parece um endereço web
  • LIKE_EMAIL – Parece um email
  • SPACY – Tem espaço a direita
  • POS – Tamanho
  • TAG –
  • MORPH –
  • DEP –
  • LEMMA – É lematizado
  • Shape –
  • ENT_TYPE –
  • OP – Operador quantificador

IA Python
Marcelo Martins ,
SPACY – Analise do texto

Ao digitar no spacy :

 palavras = []
    for token in doc:
         token.pos_

Aparece uma série de abreviações.

Segue o significado destas aqui:

  • ADJ – adjetivo
  • ADP – Aposição
  • ADV – Adverbio
  • AUX – Verbo auxiliar
  • CONJ – Conjunção
  • CCONJ – Conjunção coordenativa
  • DET – Determinante
  • INTJ – Interjeição
  • NOUN – Substantivo
  • NUM – número
  • PART – partícula (se que)
  • PRON – pronome
  • PROPN – Nome proprio
  • PUNCT – Pontuação
  • SCONJ – Conjunção subordinada
  • SYM – Simbolo
  • VERB – verbo
  • X – outros
  • SPACE – espaço

Agora ao digitar:

 palavras = []
    for token in doc:
         token.dep_

Aparece as dependencias, que são abreviações dentro do contexto:

Segue as abreviações:

  • acl – clausula modificadora de nome
  • advcl – clausula modificadora de adverbio
  • advmod – modificadora de adverbio
  • amod – modificador de adjetivo
  • appos – modificador apposicional
  • aux – auxiliar
  • case – marcação de caixa
  • cc – conjunção coordenativa
  • ccomp – clausula complementativa
  • clf – classificador
  • compound – composição
  • conj – conjunção
  • cop – copula
  • csubj – clausula substantiva
  • dep – dependencia não especificada
  • det – determinador
  • discourse – elemento de discurso
  • dislocated – elemento deslocado
  • expl – expletive
  • fixed – expressão multi palavra fixada
  • flat – expressao multi palavra gorda
  • goeswith – indo com
  • iobj – objeto indireto
  • list – lista
  • mark – marcador
  • nmod – modificação nominal
  • nsubj – sujeito nominal
  • nummod – numeric modifier
  • obj – objeto
  • obl – nominal oblico
  • orphan – orfão
  • parataxis – parataxis
  • punct – pontuação
  • reparandum – overridden disfluency
  • root – raiz
  • vocative – vocativo
  • xcomp – open clausal complement
pacotes Programação Yocto Project
Marcelo Martins , ,
Criando um daemon no linux

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:

https://github.com/marcelomaurin/srvFalar/blob/main/srvfalar/etc/systemd/system/srvfalar.service

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:

systemctl daemon-reload

Executando o serviço

Para executar um serviço digite:

systemctrl start [serviço]
octave
Marcelo Martins ,
Octave – Sistema de transferência Malha fechada

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');

Resultado da função de malha fechada

octave
Marcelo Martins , ,
Octave – Função de transferência

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');
octave
Marcelo Martins
Octave – Primeiro contato

Comentário

o Comentário é o % seguido do texto.

Conforme o exemplo:

% Isso é um comentário

Declaração de variável

x = 14;
resultado = x + 2;
resultado2 = x ^2 ;
resultado3 = (x ^2)/ (x*2)

As variáveis podem ser declaradas livremente no octave, conforme apresentado no código acima.

Trabalhando com vetor

Trabalhar com vetor é tão simples como manipular variáveis, para isso, basta declarar os elementos entre chaves [ ]

vt = [10,20,30]

resultado4 = vt*2;

vt2 = [1,2,3]
resultado5 = vt + vt2;

resultado6 = vt .* vt2;
disp(resultado6);
printf("O Resultado: %d",resultado6);

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.

octave
Marcelo Martins
Octave – Criando gráficos do segundo grau

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

IA Python
Marcelo Martins
Biblioteca Spacy para Python

Spacy é uma biblioteca de processamento de linguagem natural, desenvolvida para auxiliar na analise e identificação do contexto de textos.

Ela pode ser utilizada, quando há necessidade de entender o que foi escrito.

A lib é mantida pelo site:

https://spacy.io/

Muito utilizada em NLP (Natural Linguage Process) Processamento de Linguagem Natural.

A biblioteca tenta analisar texto, sobre os aspectos de sua estrutura morfológica e sintática.

Identificando o sujeito da frase, os verbos e etc. Traçando também uma relação de dependência entre as diversas partes.

Todos os exemplos aqui descritos, estão em meu repositório:

Github

https://github.com/marcelomaurin/ExSpacy

Instalação do Spacy

Estarei usando o python 3, e o procedimento de instalação é relativamente simples.

Instalando a biblioteca

pip3 install spacy

No nosso repositório na pasta src/install, inclui um script ./install.sh que automatiza a instalação.

Porem considero que o usuário tenha instalado o python 3 previamente.

Para rodar o procedimento de instalação rode:

> /src/install/install.sh

Modelos

Modelos são treinados para reconhecer aspectos de diversos idiomas, tais como o portugues.

Existem diversos modelos em diversos idiomas, voce pode escolher o modelo que deseja instalar através do link:

https://spacy.io/models

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:

https://spacy.io/api/morphologizer

Pudemos ver neste artigo os primeiros fundamentos da lib spaCy, espero que tenham gostado.

en_USEnglish
pt_BRPortuguese en_USEnglish