1
Python Aplicado a Problemas de Gestão de Recursos Humanos
Python Aplicado a Problemas de Gestão de Recursos Humanos
Carlos Pedro Gonçalves Instituto Superior de Ciências Sociais e Políticas (ISCSP) Universidade de Lisboa
[email protected]
Carlos Pedro Gonçalves
2
Python Aplicado a Problemas de Gestão de Recursos Humanos
Índice 1. Introdução à Linguagem Python .................................................................................. 3 1.1. Caso de Avaliação de Desempenho ................................................................... 4 2. O Python e a Gestão de Recursos Humanos .............................................................. 14 3. Exercícios de Gestão de Recursos Humanos com Python .......................................... 17 Resolução dos Exercícios ................................................................................................ 20 Exercício 1................................................................................................................... 20 Alínea a. .................................................................................................................. 20 Alínea b. .................................................................................................................. 20 Alínea c. .................................................................................................................. 21 Alínea d. .................................................................................................................. 21 Exercício 2................................................................................................................... 21 Exercício 3................................................................................................................... 23 Alínea a. .................................................................................................................. 23 Alínea b.i. ................................................................................................................ 23 Alínea b.ii. ............................................................................................................... 23 Alínea c. .................................................................................................................. 23 Exercício 4................................................................................................................... 25 Exercício 5................................................................................................................... 25 Exercício 6................................................................................................................... 26 Bibliografia...................................................................................................................... 27
Carlos Pedro Gonçalves
3
Python Aplicado a Problemas de Gestão de Recursos Humanos
1. Introdução à Linguagem Python
A linguagem de programação Python foi desenvolvida na década de 1980 pelo programador holandês Guido van Rossum, fã dos Monty Python (de onde resulta o nome da linguagem), visando:
Desenvolver uma linguagem fácil e intuitiva tão poderosa quanto as alternativas (nomeadamente o C++ e Java);
De fonte aberta, tal que qualquer um possa contribuir para o seu desenvolvimento;
Mais próximo do discurso natural;
Passível de suportar um tempo, mais curto, de desenvolvimento de programas, favorecendo a componente criativa e aplicada da programação.
A linguagem Python foi adoptada pelo MIT no curso de Engenharia Eléctrica e Ciência da Computação (http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/), no ensino da programação1 e da Inteligência Artificial. Esta linguagem tem também sido utilizada pela Google e pela NASA, assim como por um conjunto crescente de empresas, conforme ilustrado no website: https://www.python.org/about/success/#business Embora o Python suporte diferentes paradigmas de programação, a programação orientada a objectos, do ponto de vista de uma análise estatística dirigida à gestão, é a mais adequada. Um objecto corresponde a uma entidade de software, algo semelhante a um agente artificial que possui atributos e métodos necessários à realização de determinadas tarefas computacionais.
1
Embora as linguagens C++ e Java também sejam ensinadas.
Carlos Pedro Gonçalves
Dependendo do tipo de objecto, estamos perante agentes inteligentes de diferentes níveis cognitivos. Assim, em termos computacionais, existem elementos de Inteligência Artificial (IA) incorporados na programação orientada a objectos. Um objecto corresponde a uma instância de uma classe, quando definimos uma classe, definimos os atributos de instância e os procedimentos computacionais integrados nos chamados métodos de instância, um método de instância descreve uma unidade coerente de computação que define o comportamento das instâncias de uma dada classe, correspondendo a um algoritmo: sempre que o método é invocado, o algoritmo é executado pelo computador para a instância correspondente. No contexto da ciência da computação, um objecto é uma estrutura algoritmicamente complexa, pois pode correr diferentes algoritmos (diferentes métodos) e possui atributos que o caracterizam, constituindo uma entidade artificial capaz de níveis de cognição adaptativa, logo, estamos perante entidades computacionais que residem na matriz simulada pelo computador. Considerando o contexto da análise de dados aplicada à Gestão, às variáveis estatísticas correspondem atributos de instância, enquanto que aos métodos correspondem procedimentos de análise de dados e de decisões de gestão. Passamos, pois, a trabalhar um exemplo na área da Gestão de Recursos Humanos que permite ilustrar esta correspondência, assim como permite introduzir alguns conceitos da linguagem Python aplicada a problemas desta área de conhecimento.
1.1. Caso de Avaliação de Desempenho
Como exemplo, considere-se um caso de uma empresa que se encontra a avaliar a performance dos Recursos Humanos em dez unidades fabris, situadas em Portugal (6 unidades) e Espanha (4 unidades), tendo obtido a seguinte informação sobre cada uma das unidades:
Número total de trabalhadores;
Peças produzidas/hora;
Número de horas de formação;
Número de acidentes de trabalho;
Número de operários;
Antiguidade máxima dos operários.
Carlos Pedro Gonçalves
4
Python Aplicado a Problemas de Gestão de Recursos Humanos
Podemos, então, definir a classe das unidades fabris tal que cada uma das dez unidades fabris corresponde a uma instância particular. Os atributos de instância correspondem às variáveis estatísticas. Embora não seja uma condição imposta pela linguagem, adoptaremos a convenção da Oracle, tal que:
Nomes das Classes: a primeira letra de cada palavra que compõe o nome de uma classe é definida como maiúscula, sendo as restantes letras definidas como minúsculas, assim, para o problema em causa temos a classe designada por UnidadeFabril;
Nomes dos Métodos: a primeira letra é definida como minúscula, quando um método é composto por várias palavras têm de aparecer juntas, sem espaços, no nome do método, a convenção é: para a primeira palavra que compõe o nome do método as letras são minúsculas, enquanto que a primeira letra, para cada uma das restantes palavras que compõem o nome de um método, é definida
como
maiúscula
(por
exemplo,
avaliaProdutividade
ou
avaliaTrabalhadoresDaUnidade), o nome do método deverá expressar o tipo de actividade de análise que é realizada e o interesse da mesma para a gestão da empresa. A mesma convenção assumida para os métodos, seguiremos para os atributos. Em Python define-se a classe do seguinte modo: class UnidadeFabril: def __init__(self,local,numTrab,pecaHora,formacao,acidentes,operarios,antiguidade): self.local = local # Localização da Unidade (Portugal ou Espanha) self.numTrab = numTrab # Número de trabalhadores self.pecaHora = pecaHora # Número de peças produzidas por hora self.formacao = formacao # Número de horas de formação self.acidentes = acidentes # Número de acidentes de trabalho self.operarios = operarios # Número de operários self.antiguidade = antiguidade # Antiguidade máxima dos operários
A primeira linha de código define o nome da classe, as linhas seguintes definem os atributos de instância, os comentários são colocados após o cardinal. No código acima, cada instância da classe “UnidadeFabril” tem como atributos de instância os seguintes:
local: localização da unidade fabril;
numTrab: número de trabalhadores;
pecaHora: número de peças produzidas por hora;
formacao: número de horas de formação;
Carlos Pedro Gonçalves
5
Python Aplicado a Problemas de Gestão de Recursos Humanos
acidentes: número de acidentes de trabalho;
operarios: número de operários;
antiguidade: antiguidade máxima.
6
Python Aplicado a Problemas de Gestão de Recursos Humanos
Somente com a definição geral da classe podemos construir o equivalente à base de dados em código Python. Em termos tradicionais, uma base de dados tem uma estrutura semelhante a uma tabela, em que a cada linha corresponde um membro da população sob análise e a cada coluna corresponde uma variável estatística. O quadro seguinte contém um exemplo desta estrutura tradicional de base de dados, para o caso sob análise. Local Unidade 1 Unidade 2 Unidade 3 Unidade 4 Unidade 5 Unidade 6 Unidade 7 Unidade 8 Unidade 9 Unidade 10
Portugal Portugal Portugal Portugal Portugal Portugal Espanha Espanha Espanha Espanha
Nº de Trabalhadores 200 250 300 210 220 230 250 250 210 210
Peça hora 20 10 25 15 16 16 25 26 17 14
/
Formação Acidentes
2000 1200 2000 1500 1600 2000 2000 1100 1200 1200
20 10 20 30 25 15 20 14 10 20
Nº de Antiguidade Operários
150 120 250 110 110 150 160 160 150 150
20 15 30 20 20 25 15 16 17 20
Em Python, a cada unidade irá corresponder uma instância, assim, temos o seguinte processo de instanciação, conforme passamos a explicar: Unidade1 = UnidadeFabril('Portugal',200,20,2000,20,150,20) Unidade2 = UnidadeFabril('Portugal',250,10,1200,10,120,15) Unidade3 = UnidadeFabril('Portugal',300,25,2000,20,250,30) Unidade4 = UnidadeFabril('Portugal',210,15,1500,30,110,20) Unidade5 = UnidadeFabril('Portugal',220,16,1600,25,110,20) Unidade6 = UnidadeFabril('Portugal',230,16,2000,15,150,25) Unidade7 = UnidadeFabril('Espanha',250,25,2000,20,160,15) Unidade8 = UnidadeFabril('Espanha',250,26,1100,14,160,16) Unidade9 = UnidadeFabril('Espanha',210,17,1200,10,150,17) Unidade10 = UnidadeFabril('Espanha',210,15,1200,20,150,20)
O sinal “=” não corresponde a um sinal de “igual” matemático mas sim ao símbolo de atribuição, cada linha de código acima dá ao computador a instrução para criar um objecto, atribuindo-lhe, como valor, uma instância da classe UnidadeFabril com determinados valores, assim a primeira linha de código pode ser lida do seguinte modo:
Carlos Pedro Gonçalves
Atribui à “Unidade1” uma instância da classe UnidadeFabril com os seguintes valores para os atributos: o
local: Portugal;
o
numTrab: 200;
o
pecaHora: 20;
o
formacao: 2000;
o
acidentes: 20;
o
operarios: 150;
o
antiguidade: 20.
Uma interpretação análoga pode ser realizada para as restantes instâncias. Na perspectiva imediata do utilizador, existe pouca diferença prática entre a introdução dos dados numa tabela, ou a instanciação de objectos. Se o objectivo fosse somente a construção de uma base de dados, ambas as alternativas seriam efectivamente equivalentes, contudo, a partir do momento em que se criam objectos, temos entidades computacionais que registam os valores de cada unidade fabril numa memória de trabalho, existindo uma entidade computacional por cada unidade fabril. Esta natureza computacional dos objectos distingue-se da natureza da tabela. A tabela corresponde a uma estrutura de dados que são inseridos, a tabela é passiva. Os objectos têm uma estrutura de memória e a capacidade de agir sobre esses mesmos dados. O tipo de acções a serem programadas depende dos objectivos, com uma mesma estrutura de atributos é possível realizar diferentes acções. Vamos assumir, então, que a empresa pretende avaliar cada unidade fabril segundo critérios definidos a partir de objectivos relacionados com a produtividade, a formação e os acidentes. Podemos, então, definir três métodos de instância:
avaliaProdutividade
avaliaFormacao
avaliaAcidentes
avaliaUnidade
Assim, considerando cada objecto da classe UnidadeFabril como uma entidade computacional que guarda na sua memória de trabalho os valores dos atributos da unidade fabril que lhe corresponde, os métodos acima constituem procedimentos computacionais que
Carlos Pedro Gonçalves
7
Python Aplicado a Problemas de Gestão de Recursos Humanos
a entidade computacional executa a partir da sua memória de trabalho e de elementos adicionais definidos como parâmetros externos (inputs do método2). Tornando explícita a conexão com a IA, passamos a referir-nos, na descrição dos métodos, a cada objecto/entidade computacional pela noção de agente artificial definido enquanto agente de software que é capaz de avaliar o valor dos seus atributos e de, com base em critérios de gestão, classificar e produzir uma síntese cognitiva avaliativa da unidade fabril que lhe corresponde e cujas características guarda na sua memória de trabalho (valores dos atributos). O primeiro método avaliaProdutividade visa avaliar o nível de produtividade face a um valor definido pela empresa como objectivo de produtividade para a unidade fabril. Assim, considerando o número de peças produzidas por hora pela unidade fabril e o objectivo de peças definido pela empresa, o agente artificial divide os resultados obtidos pelo objectivo correspondente e, face ao resultado dessa divisão, classifica a unidade. O processamento cognitivo pode ser expresso em termos de uma árvore de decisão, conforme ilustrado abaixo.
Comunica: Divisão inferior a 1
Divide peça/hora por objectivo
'não atingiu o objectivo de produtividade'
Devolve resultado do rácio
Comunica: Divisão igual a 1
'atingiu o objectivo de produtividade'
Devolve resultado do rácio
Comunica: Divisão superior a 1
'superou o objectivo de produtividade'
Devolve resultado do rácio
A acção do agente artificial pode ser analisada seguindo a árvore. No primeiro nó da árvore (nó de raiz) o agente realiza uma divisão do resultado de produtividade pelo objectivo, quando este rácio é inferior a 1, isso significa que o resultado foi inferior ao objectivo, pelo que
2
Os inputs de um método, para problemas de gestão, geralmente correspondem a variáveis estratégicas que estão sob o controlo da empresa, podendo ser alteradas pela gestão da empresa (a definição de um objectivo quantitativo pela gestão da empresa constui um exemplo).
Carlos Pedro Gonçalves
8
Python Aplicado a Problemas de Gestão de Recursos Humanos
o agente comunica que a unidade fabril que lhe corresponde não atingiu o objectivo de produtividade. Quando o rácio é igual a 1, o resultado obtido coincide com o objectivo, logo, o agente comunica que a unidade que lhe corresponde atingiu o objectivo de produtividade. Finalmente, quando o rácio é superior a 1, o agente comunica que o objectivo de produtividade foi superado. Em qualquer das alternativas, o agente devolve o resultado do rácio, podendo esse valor ser utilizado pelo agente para efeitos de cálculo futuro, como iremos ver mais adiante. Em linguagem Python, o método é escrito do seguinte modo: def avaliaProdutividade(self,objectivo): avaliacao = self.pecaHora / objectivo if avaliacao < 1: print(self.nome, 'não atingiu o objectivo de produtividade') elif avaliacao == 1: print(self.nome, 'atingiu o objectivo de produtividade') else: print(self.nome, 'superou o objectivo de produtividade') return avaliacao
A primeira linha de código define o nome do método (def avaliaProdutividade) enquanto método de instância (self) que recebe como input o valor do objectivo de produtividade definido pela empresa (este elemento terá de ser fornecido ao agente artificial). As restantes linhas de código (após os dois pontos) correspondem ao corpo do método. No primeiro passo, o agente recupera o conteúdo da sua memória de trabalho referente ao número de peças produzidas por hora (atributo pecaHora) e divide esse conteúdo pelo objectivo a ser atingido, atribuindo-o a uma variável local designada por avaliacao. As variáveis locais permitem, em termos de IA, simular o funcionamento de memória de trabalho temporária. Após ter o conteúdo da variável avaliacao, estamos no primeiro nó da árvore. O passo seguinte, no processamento cognitivo, conduz o agente a uma dinâmica condicional:
Se o conteúdo da variável avaliacao for inferior a 1 (if avaliacao < 1:), então, imprime na consola do Python o conteúdo do atributo nome (o nome da unidade fabril) seguido da mensagem não atingiu o objectivo de produtividade (print(self.nome, 'não atingiu o objectivo de produtividade'));
Carlos Pedro Gonçalves
9
Python Aplicado a Problemas de Gestão de Recursos Humanos
Se o conteúdo da variável avaliacao for igual a 1 (elif avaliacao == 1:), então, imprime na consola do Python o conteúdo do atributo nome (o nome da unidade fabril) seguido da mensagem atingiu o objectivo de produtividade (print(self.nome, 'atingiu o objectivo de produtividade'));
Se o conteúdo da variável avaliacao for superior a 1 (else:), então, imprime na consola do Python o conteúdo do atributo nome (o nome da unidade fabril) seguido da mensagem superou o objectivo de produtividade (print(self.nome, 'superou o objectivo de produtividade')).
A estrutura condicional tem uma correspondência com os ramos da árvore de decisão. O agente necessita de avaliar em que ramo se encontra para saber que acções deverá implementar. Os ramos da condicional são expressos em código, em termos de uma estrutura de alternativas, se houvessem apenas duas alternativas teríamos a seguinte estrutura elementar geral:
Se (“if”) a condição se verifica então realiza as operações X;
De outro modo (“else”) realiza as operações Y.
A estrutura condicional SE (if) – DE OUTRO MODO (else), é tal que o agente realiza um determinado conjunto de acções se uma dada condição se verifica, de outro modo (isto é, nos restantes casos em que a condição não se verifica) realiza outro conjunto de acções. As computações realizadas pelo agente dependem da condição se verificar ou não. Para esta estrutura mais elementar teríamos uma árvore com dois ramos. No caso acima, a estrutura é mais complexa, pois existem três ramos, o primeiro está marcado com a expressão if (SE), o segundo ramo (segunda alternativa) está marcado com a expressão elif que significa else if (DE OUTRO MODO, SE). Deste modo, quando a primeira condição não se verifica, se a segunda se verifica, então, o agente realiza as acções correspondentes à segunda condição. O terceiro ramo é marcado com else, esgotando todas as alternativas, no sentido em que ou a divisão é inferior a 1, ou igual a 1 ou superior a 1, logo, esgotadas as primeiras duas alternativas o que resta (else) é o caso em que o resultado é superior a 1 (caso em que a unidade fabril supera o seu objectivo de produtividade). A última linha do método corresponde à instrução return avaliacao, esta instrução permite trabalhar o método como uma função que, para além de executar as instruções analisadas acima, devolve o valor calculado da avaliação, valor que é registado na variável local
Carlos Pedro Gonçalves
10
Python Aplicado a Problemas de Gestão de Recursos Humanos
avaliacao, o que permite incorporar o método no cálculo posterior da avaliação final da unidade fabril. O método seguinte avaliaFormacao envolve também uma comparação entre um resultado obtido e um objectivo, contudo o resultado obtido é calculado primeiro em termos de um rácio, ou seja, estamos a trabalhar um exemplo em que a empresa definiu, para cada unidade fabril, um objectivo em termos de horas de formação por operário3 (assim, as horas de formação que estão a ser consideradas na avaliação, são as horas de formação dos operários). O método seguinte inclui o cálculo do rácio horas de formação por operário e a avaliação face ao objectivo. def avaliaFormacao(self,objectivo): racio = self.formacao / self.operarios avaliacao = racio / objectivo if avaliacao < 1: print(self.nome, 'horas de formação por trabalhador inferiores ao objectivo') elif avaliacao == 1: print(self.nome, 'horas de formação por trabalhador iguais ao objectivo') else: print(self.nome, 'horas de formação por trabalhador superiores ao objectivo') return avaliacao
Deixamos, como exercício, a tarefa de analisar o método, incluindo a construção da árvore de decisão e a correspondência entre a árvore e o programa escrito em linguagem Python. O método seguinte converte mais um critério de avaliação implementado pela empresa numa estrutura algorítmica, neste caso, a empresa define um objectivo em termos de número de acidentes por operário, o que significa que é necessário calcular o rácio do número de acidentes pelo número de operários e dividir esse rácio pelo valor definido pela empresa como objectivo. def avaliaAcidentes(self,objectivo): racio = self.acidentes / self.operarios avaliacao = racio / objectivo if avaliacao < 1: print(self.nome, 'superou o objectivo de acidentes por operário') elif avaliacao == 1: print(self.nome, 'atingiu o objectivo de acidentes por operário') else: print(self.nome, 'não atingiu o objectivo de acidentes por operário') return 1 / avaliacao 3
Outros objectivos de formação podem ser trabalhados, implicando a alteração ou mesmo introdução de novos métodos para as instâncias da classe UnidadeFabril.
Carlos Pedro Gonçalves
11
Python Aplicado a Problemas de Gestão de Recursos Humanos
Embora com uma base análoga aos restantes métodos analisados até ao momento, existem algumas diferenças neste método, no que se refere à relação entre o rácio e o objectivo, pois quanto menor o rácio melhor a performance, ao contrário do que acontecia no caso do método anterior. Assim, se o valor da avaliação for inferior a 1, isso significa que o rácio de acidentes por operário é inferior ao objectivo definido pela empresa o que implica uma boa performance, logo, considera-se que a unidade fabril superou o objectivo em termos de número de acidentes por operário. Se o valor da avaliação for igual a 1, então, a unidade fabril atingiu o objectivo. Contudo, se o valor da avaliação for superior a 1, isso significa que a unidade fabril tem mais acidentes por operário do que o objectivo definido pela empresa, o que significa uma má performance em termos de acidentes, logo, considera-se, neste caso, que a empresa não atingiu o objectivo em termos de acidentes por operário. Dado que a avaliação segue no sentido inverso dos restantes elementos sob avaliação, ou seja, quanto maior o valor pior é a performance da unidade fabril, a instrução “return” devolve o valor inverso da avaliação, será esse o valor a ser utilizado na ponderação final da avaliação da unidade fabril. O último método define o processo final de avaliação da unidade fabril: def avaliaUnidade(self,objectivos,pesos): prod = self.avaliaProdutividade(objectivos[0]) form = self.avaliaFormacao(objectivos[1]) acid = self.avaliaAcidentes(objectivos[2]) avaliacao = pesos[0] * prod + pesos[1] * form + pesos[2] * acid print('Valor Final:', avaliacao,'\n')
O método avaliaUnidade recebe como inputs uma lista de objectivos e uma lista de pesos associados a cada dimensão sob avaliação. O método executa a avaliação da produtividade e guarda o valor devolvido por esta avaliação numa variável local “prod”, o mesmo é feito para a avaliação da formação (guardada na variável “form”) e dos acidentes (guardada na variável “acid”), a avaliação final resulta de uma média ponderada de cada uma das avaliações em que cada avaliação é multiplicada pelo peso respectivo, o método imprime, então, o resultado final da avaliação da unidade e muda de linha deixando um espaço (comando newline: '\n').
Carlos Pedro Gonçalves
12
Python Aplicado a Problemas de Gestão de Recursos Humanos
O método trabalha com um tipo de objecto primitivo em Python designado por lista. Uma lista é representada, na linguagem Python, como uma sequência de valores separada por vírgulas e delimitada por parêntesis rectos. Assim, por exemplo, uma lista dos nomes João, Maria e José, seria representada em Python como [João,Maria,José]. Se atribuirmos esta lista a uma variável chamada “amigos”, podemos escrever: amigos = [João,Maria,José] Para acedermos a um elemento particular da lista basta escrever “amigos[j]”, em que j é o índice correspondente ao elemento na posição j da lista, assim, por exemplo amigos[0] corresponde a João, amigos[1] a Maria e amigos[2] a José. A contagem de elementos começa em 0 (origem) e segue a sequência, tal que o terceiro elemento ocupa a posição 2, o segundo a posição 1 e o primeiro a posição 0. No caso do método avaliaUnidade, existem duas listas que são fornecidas ao agente artificial, uma lista de objectivos, em termos de valores definidos como objectivos a serem cumpridos pelas unidades fabris, e uma lista de pesos, que corresponde ao valor atribuído pela empresa a cada dimensão de avaliação. A lista de objectivos é utilizada na fase de avaliação de cada dimensão enquanto que a lista de pesos é utilizada na avaliação final da unidade fabril. Utilizando estes elementos, cada agente tem a estrutura cognitiva necessária para avaliar cada unidade, assim que tenha os valores correspondentes. Considere-se, então, que a empresa definiu os seguintes objectivos para as unidades fabris:
10 peças/hora produzidas;
20 horas de formação por operário;
No máximo 5 acidentes por cada 100 operários (rácio de 0.05).
Então, a lista de objectivos é definida em Python como objectivos = [10,20,0.05]. Assumindo que a empresa definiu os pesos seguintes para cada dimensão sob avaliação:
0.35: para a dimensão de produtividade;
0.35: para a dimensão de formação;
0.3: para dimensão de acidentes.
A lista de pesos é, então, dada por pesos = [0.35,0.35,0.3], o código final em linguagem Python é apresentado no website http://pythonfiddle.com/avaliacao-de-desempenho/. Executando o código, verifica-se que as unidades 1, 3, 7 e 8 apresentam um resultado final superior a 1, ou seja, a classificação média é positiva. Contudo, nenhuma destas quatro unidades
Carlos Pedro Gonçalves
13
Python Aplicado a Problemas de Gestão de Recursos Humanos
cumpriu os objectivos de formação e de acidentes por operário, o que ocorre também com as restantes unidades fabris. Assim, a empresa deverá rever as causas do não cumprimento destes objectivos, e, nomeadamente, no que se refere aos acidentes de trabalho, procurar implementar, em todas as unidades fabris, medidas no sentido da diminuição do número de acidentes por operário. Importa também reforçar o sistema de comunicação interno dos objectivos e sistema de avaliação de desempenho das unidades fabris.
2. O Python e a Gestão de Recursos Humanos
No exemplo fornecido na secção anterior, vimos um caso particular de implementação da linguagem Python a um problema de avaliação de desempenho. O exemplo visou ilustrar as diferenças entre uma análise de dados aplicada a uma base de dados tradicional, e uma análise estatística que incorpora um sistema de análise de gestão, logo, uma ferramenta feita à medida do problema de gestão. A programação orientada a objectos permite realizar esta transição de uma análise de dados tradicional, para uma análise de dados suportada por sistemas inteligentes artificiais que exibem respostas adaptativas em função do problema sob análise e, logo, construir soluções específicas para a Gestão de Recursos Humanos (GRH), ou para a Gestão em geral. A GRH é, deste modo, suportada por métodos de trabalho dos dados dirigidos a uma resposta feita à medida. Desde que as condições do problema se mantenham inalteradas, as mesmas classes e os mesmos métodos podem ser implementados, trata-se de um problema de generalidade algorítmica. Os algoritmos dirigidos à gestão exigem o estabelecimento de uma ponte directa entre a estatística e a gestão, no sentido de uma estruturação do problema na perspectiva da gestão e uma estruturação dos algoritmos em função do problema, de modo a que a máquina possa melhor adaptar-se às necessidades do gestor. Se outros critérios de avaliação tivessem sido definidos pela empresa, o programa a ser escrito teria sido distinto. Assim, existe a possibilidade de construir “fatos à medida” do gestor, em que o sistema artificial analisa os dados e sintetiza a informação que é mais útil ao gestor na sua actividade. O “discurso” da máquina pode inclusive ser adaptado ao discurso do gestor,
Carlos Pedro Gonçalves
14
Python Aplicado a Problemas de Gestão de Recursos Humanos
estabelecendo, o programa informático, a ponte entre o nível de discurso computacional estatístico e o nível de discurso de gestão. Por seu turno, é possível também desenvolver sistemas multiproblema, isto é, sistemas que são capazes de resolver diferentes problemas de gestão e, sem modificação de código, suportar o gestor no seu trabalho. O sistema artificial a ser desenvolvido depende do tipo de problema de gestão a ser trabalhado. No caso de GRH, é possível desenvolver quer sistemas integrados de suporte à gestão, quer aplicativos dirigidos ao trabalho do gestor. A diferença nas tecnologias actuais, e no Python em particular, reside no facto de que podemos torná-las móveis, isto é: podemos desenvolver ferramentas que podem acompanhar o gestor para qualquer lugar, utilizando os seus dispositivos móveis. O modelo de computação distribuída, em particular o aumento da capacidade e da gama de aplicações para dispositivos móveis, abre a oportunidade de desenvolvimento de ferramentas de analytics inteligentes que acompanham o gestor para qualquer lugar, apoiando-o na sua actividade. Em termos de programação, o exemplo trabalhado no presente artigo, apesar de ser elementar ao nível da programação, permite ilustrar um ponto central, a saber: cabe ao decisor humano indicar à máquina o que deve valorizar e como, cabe à máquina realizar a dimensão algorítmica do processo de tomada de decisão humana, suportando esse processo em termos de velocidade de processamento e trabalho dos dados. Assim, tudo aquilo que, na Gestão Empresarial (e das organizações em geral), pode ser convertido em algoritmo poderá ser resolvido por uma máquina, por seu turno, tudo aquilo que na gestão possa ser resolvido por uma máquina, mais eficientemente e eficazmente do que por um humano, tenderá a ser resolvido por uma máquina (devido à própria acção humana de desenhar tecnologias que substituam a componente humana nessa tarefa). Note-se que a máquina não substitui, neste caso, o gestor, mas, sim, apoia-o no processo de tomada de decisão, realizando parte da tarefa do gestor, tornando a tarefa mais fácil, logo, mais rápida. Importa relevar, contudo, que a máquina poderá nem sempre substituir com mais eficiência o ser humano numa dada actividade, principalmente se a actividade a ser realizada pela máquina for algoritmicamente complexa (conceito de complexidade algorítmica), neste caso, a capacidade humana para capturar totalidades poderá conduzir a uma solução mais eficiente dado que pode ir para além do algoritmo, não sendo confinada a segui-lo.
Carlos Pedro Gonçalves
15
Python Aplicado a Problemas de Gestão de Recursos Humanos
Se alguma vez uma máquina for capaz de intuir soluções de modo não-algorítmico, então, poderá também ultrapassar a barreira dos limites à computação, trata-se, contudo, de uma estrutura tecnológica distinta da que temos presentemente, embora, em termos de Ciência da Computação, não possamos rejeitar esta possibilidade, isto é, não podemos afirmar ser impossível construir tecnologia não-algorítmica (ou com níveis de actividade não-algorítmicos). É conhecida a capacidade da computação quântica em quebrar barreiras de complexidade que a computação clássica não é capaz de quebrar, por seu turno, a biotecnologia, incluindo a biónica, poderá vir a construir híbridos tecno-orgânicos que, caso se tornem sustentáveis, isto é, caso a componente “tecno” seja aceite/integrada e compatibilizada com o processamento orgânico, poderão possivelmente ultrapassar limites algorítmicos. Regressando ao problema anteriormente analisado, e tendo em atenção as funcionalidades que se pretende para a ferramenta, é possível construir diferentes programas que respondam eficazmente às funcionalidades requeridas, em particular, diferentes paradigmas de programação poderiam ser aplicados para a resolução do mesmo problema. Em termos de eficácia, a programação orientada a objectos apresenta duas vantagens. A primeira vantagem reside no facto de obrigar o programador a estruturar o problema de gestão, em termos de unidades computacionais e tarefas elementares incorporadas nos métodos decorrentes de escolhas estratégicas da própria empresa e que condicionam a estrutura do próprio algoritmo, de tal modo que cada método corresponde a uma estrutura algorítmica coerente de resposta ao problema da empresa. Assim, um problema pode ser dividido em partes coerentes e abordado em termos de uma dinâmica entre inputs fornecidos pelo utilizador e computações realizadas pelas instâncias de uma dada classe que trabalham esses mesmos inputs e/ou os valores dos atributos para dar uma resposta adequada ao problema, à luz dos critérios e processos definidos pela empresa, o que nos conduz à segunda vantagem, a saber: a correspondência com a IA. A segunda vantagem da programação orientada a objectos reside no facto de trabalhar com o computador enquanto ambiente tecnológico que permite simular uma matriz artificial onde residem entidades computacionais: os objectos, instâncias de uma dada classe. Os objectos, conforme vimos na secção anterior, podem ser abordados enquanto agentes inteligentes, deste modo, o programa de computador não tem uma forma de um algoritmo único mas, sim, de algoritmos incorporados num modelo de cognição do agente. O agente é capaz de trabalhar dados exteriores (fornecidos pelo utilizador) e os conteúdos da sua memória
Carlos Pedro Gonçalves
16
Python Aplicado a Problemas de Gestão de Recursos Humanos
de trabalho permanente (os registos dos valores nos atributos de instância), assim como é possível introduzir memória de trabalho temporária (as variáveis locais). Deste modo, o programa é abordado a partir de uma dinâmica cognitiva, o que suporta um trabalho mais eficaz no sentido em que uma dinâmica cognitiva humana algoritmizável pode, por paralelismo, ser programada na máquina.
3. Exercícios de Gestão de Recursos Humanos com Python 1. Uma empresa comercial decidiu atribuir prémios de produtividade aos vendedores cujas vendas se situem acima da média, esses prémios são proporcionais ao valor das vendas realizadas pelo vendedor. Com base nesta informação, responda às seguintes questões: a. Defina a classe apropriada para o caso (nome da classe e atributos). b. Defina um método de instância que expresse, em código Python, o sistema de prémios definido pela empresa. c. Construa a árvore de decisão para o método de instância da alínea anterior. d. Implemente o código para a base de dados de vendedores representada na tabela abaixo.
Código
Vendedor
V01
Ambrósio Severino Pais
Vendas (milhares de Euros) 500
V02
Ana Leopolda Leopardo
650
V03
Ana Reis Corrais
320
V04
Blimunda Refrescada Sais
450
V05
Dário Vidigais do Finigal
350
V06
Eduarda Susana Cimeira
300
V07
Helena Correia Zifulmática
360
V08
João Sumido Santeiro
470
V09
Jorge Santos Reis Tomar
420
V10
Jorge Pais dos Reis
430
2. Modifique o código da questão anterior de tal modo que os prémios sejam proporcionais às vendas até um valor máximo e construa a árvore de decisão correspondente ao código modificado. Carlos Pedro Gonçalves
17
Python Aplicado a Problemas de Gestão de Recursos Humanos
3. Uma empresa definiu um sistema de controlo de acidentes de trabalho que emite um aviso de excesso de acidentes se o número anual de acidentes ultrapassar um limite definido como número máximo aceitável pela empresa. Com base nesta informação, responda às seguintes questões: a. Defina a classe apropriada para o caso (nome da classe e atributos). b. Defina um método de instância que expresse, em código Python, o sistema de controlo definido pela empresa, para os seguintes dois casos: i. A empresa apenas pretende que o sistema forneça o alerta sem apresentar qual o número de acidentes. ii. A empresa pretende que o número de acidentes seja fornecido pelo sistema em qualquer circunstância. c. Expresse o método de instância para o código das alíneas b.i. e b.ii. em árvore de decisão, e analise as diferenças em termos de Gestão de Recursos Humanos.
4. Modifique a árvore da questão anterior para o caso em que a empresa pretende que o sinal de alerta tenha o seguinte código de cores: a. Alerta Amarelo: se o número de acidentes com nível de gravidade elevada se situar entre 25% (inclusive) e 50% (exclusive) do número total de acidentes; b. Alerta Laranja: se o número de acidentes com nível de gravidade elevada se situar entre 50% (inclusive) e 75% (exclusive) do número total de acidentes; c. Alerta Vermelho: se o número de acidentes com nível de gravidade elevada for superior ou igual a 75% do número total de acidentes.
5. Construa o código para a árvore da questão anterior.
6. A tabela seguinte contém dados de produtividade média para dez sucursais de uma empresa, no ano de 2014, construa um programa em Python que classifique as sucursais em função do objectivo de produtividade média (comum às 10 sucursais), tal que se houverem sucursais que tenham atingido ou superado o objectivo de produtividade, aquela que tiver a produtividade mais elevada recebe um prémio de produtividade e execute o código para as 10 sucursais. Considere, na resolução, um objectivo de produtividade média de 225 Euros/hora.
Carlos Pedro Gonçalves
18
Python Aplicado a Problemas de Gestão de Recursos Humanos
Sucursais
Sucursal 1
Produtividade Média (Euros/h) 230
Sucursal 2
150
Sucursal 3
260
Sucursal 4
220
Sucursal 5
120
Sucursal 6
110
Sucursal 7
225
Sucursal 8
250
Sucursal 9
270
Sucursal 10
220
Carlos Pedro Gonçalves
19
Python Aplicado a Problemas de Gestão de Recursos Humanos
Resolução dos Exercícios4 Exercício 1. Alínea a. Dado que se pretende avaliar os vendedores, o nome da classe é definido como “Vendedores”, o atributo sob avaliação é o atributo “vendas”, para além desse atributo, introduzimos também os atributos código do vendedor e nome, de onde resulta a seguinte definição de classe:
Alínea b. Conforme definido pela empresa, temos uma estrutura condicional, assim:
Se um dado vendedor tiver vendas acima da média, então este recebe um prémio que é proporcional às vendas que realizou (proporção é um elemento a ser definido pela empresa).
Temos, assim, o seguinte código em Python, com a definição da classe (alínea anterior) e do método de instância:
O método recebe como inputs a média das vendas realizadas por cada vendedor e a proporção definida pela empresa e avalia a condicional tal que: se as vendas de um vendedor forem superiores à média, então, atribui um prémio decorrente da multiplicação da proporção
4
Na resolução dos exercícios utilizamos, por uma questão de efeito comparativo, a versão 2 do
Python.
Carlos Pedro Gonçalves
20
Python Aplicado a Problemas de Gestão de Recursos Humanos
definida pela empresa pelas vendas realizadas por esse vendedor e imprime a informação de que o vendedor deverá receber o prémio.
Alínea c.
.
Vendas > Média
Calcula prémio
Comunica: codigo nome recebe prémio de euros
Alínea d. A resolução encontra-se disponível no website: https://sites.google.com/site/mqgestao/programas-em-python/caso-vendedores Esta resolução pode ser executada online no website: http://pythonfiddle.com/vendedores
Exercício 2. Temos, agora, de definir uma segunda condicional, tal que, se o prémio exceder o prémio máximo definido pela empresa (novo input do método), então, atribui-se o prémio máximo ao vendedor, caso contrário o vendedor recebe o prémio proporcional às suas vendas.
Carlos Pedro Gonçalves
21
Python Aplicado a Problemas de Gestão de Recursos Humanos
22
Python Aplicado a Problemas de Gestão de Recursos Humanos
.
Vendas > Média
Calcula prémio
Valor do prémio > Prémio Máximo
Valor do prémio ≤ Prémio Máximo
Comunica: codigo nome recebe prémio de euros
Comunica: codigo nome recebe prémio de euros
Carlos Pedro Gonçalves
Exercício 3. Alínea a. Dado que se pretende avaliar o número total anual de acidentes de trabalho, o nome da classe é definido como “Acidentes”, definida com um único atributo o número de acidentes, assim, escrevemos:
Alínea b.i. Face ao critério definido pela empresa, o seguinte código em Python, com a definição da classe (alínea anterior) e do método de instância, fornece uma solução para o problema:
Alínea b.ii. Dado que a empresa pretende que o número de acidentes seja fornecido pelo sistema em qualquer circustância o código tem de ser modificado para:
Alínea c. Para o caso da alínea b.ii. a árvore é dada por:
Carlos Pedro Gonçalves
23
Python Aplicado a Problemas de Gestão de Recursos Humanos
24
Python Aplicado a Problemas de Gestão de Recursos Humanos
.
Número de Acidentes > Limite
Comunica: Alerta: Excesso de Acidentes de Trabalho!
Para a alínea b.ii. a árvore é dada por:
Comunica: Número de acidentes de trabalho:
Número de Acidentes > Limite
Comunica: Alerta: Excesso de Acidentes de Trabalho!
No primeiro caso, a empresa não está a considerar como relevante um número de acidentes abaixo do limite. No segundo caso, a empresa considera como relevante a informação acerca do número de acidentes quer esse número exceda o limite ou não. Assim, o segundo caso reflecte uma opção estratégica por um maior controlo do número de acidentes.
Carlos Pedro Gonçalves
Python Aplicado a Problemas de Gestão de Recursos Humanos
25
Exercício 4.
Comunica: Número de acidentes de trabalho:
Número de Acidentes > Limite
Comunica: Alerta: Excesso de Acidentes de Trabalho!
Calcula percentagem de acidentes com gravidade elevada
25% ≤ Percentagem < 50%
50 ≤ Percentagem < 75%
Percentagem ≥ 75%
Comunica: "Alerta Amarelo!"
Comunica: "Alerta Laranja!
Comunica: "Alerta Vermelho!"
Exercício 5.
Carlos Pedro Gonçalves
Exercício 6. O programa, em Python é dado pelo código seguinte:
O resultado final do programa é, para estes dados, a impressão da informação na consola do Python: Sucursal 9 recebe o prémio de produtividade
Carlos Pedro Gonçalves
26
Python Aplicado a Problemas de Gestão de Recursos Humanos
Bibliografia
Borny, T. 2015, Interview: Neil Jacobstein Discusses Future of Jobs, Universal Basic Income and the Ethical Dangers of AI, http://singularityhub.com/2015/03/23/future-of-work-interview-with-neiljacobstein/.
Cassel, L. and Gauld, A. 2015, Python® Projects, Wrox.
Downey, Allen B. 2012, Think Python, O'Reilly Media. Introdução ao Python disponível no formato Wiki: http://en.wikibooks.org/wiki/Think_Python.
Goertzel, B. 2014, Ten Years to the Singularity, If We Really Really Try…and other Essays on AGI and its Implications, humanity+ Press.
Gonçalves, 2014, Singularidade Tecnológica e a Terceira Revolução Industrial, https://www.academia.edu/9763186/Singularidade_Tecnol%C3%B3gica_e_a_ Terceira_Revolu%C3%A7%C3%A3o_Industrial.
Carlos Pedro Gonçalves
27
Python Aplicado a Problemas de Gestão de Recursos Humanos
