Agile Data Science - Guia rápido

A ciência de dados ágil é uma abordagem de uso da ciência de dados com metodologia ágil para o desenvolvimento de aplicativos da web. Ele se concentra na saída do processo de ciência de dados adequado para efetuar mudanças em uma organização. A ciência de dados inclui a construção de aplicativos que descrevem o processo de pesquisa com análise, visualização interativa e agora também o aprendizado de máquina aplicado.

O principal objetivo da ciência de dados ágil é -

documentar e orientar a análise de dados explicativos para descobrir e seguir o caminho crítico para um produto atraente.

A ciência de dados ágil é organizada com o seguinte conjunto de princípios -

Iteração Contínua

Este processo envolve iteração contínua com tabelas de criação, gráficos, relatórios e previsões. A construção de modelos preditivos exigirá muitas iterações de engenharia de recursos com extração e produção de insight.

Produto intermediário

Esta é a lista de trilhas das saídas geradas. Diz-se até que experimentos fracassados ​​também produzem resultados. O rastreamento da saída de cada iteração ajudará a criar uma saída melhor na próxima iteração.

Experiências de protótipo

Os experimentos de protótipo envolvem a atribuição de tarefas e a geração de resultados de acordo com os experimentos. Em uma determinada tarefa, devemos iterar para obter um insight e essas iterações podem ser melhor explicadas como experimentos.

Integração de dados

O ciclo de vida de desenvolvimento de software inclui diferentes fases com dados essenciais para -

  • customers

  • desenvolvedores e

  • o negócio

A integração de dados abre caminho para melhores perspectivas e resultados.

Valor de dados da pirâmide

O valor da pirâmide acima descreve as camadas necessárias para o desenvolvimento da “ciência de dados ágil”. Ele começa com uma coleção de registros com base nos requisitos e registros individuais de encanamento. Os gráficos são criados após a limpeza e agregação de dados. Os dados agregados podem ser usados ​​para visualização de dados. Os relatórios são gerados com estrutura adequada, metadados e tags de dados. A segunda camada da pirâmide do topo inclui análise de previsão. A camada de previsão é onde mais valor é criado, mas ajuda na criação de boas previsões com foco na engenharia de recursos.

A camada superior envolve ações nas quais o valor dos dados é direcionado de forma eficaz. A melhor ilustração dessa implementação é “Inteligência Artificial”.

Neste capítulo, vamos nos concentrar nos conceitos do ciclo de vida de desenvolvimento de software denominado “ágil”. A metodologia de desenvolvimento de software Agile ajuda na construção de um software por meio de sessões incrementais em iterações curtas de 1 a 4 semanas para que o desenvolvimento esteja alinhado com os requisitos de negócios em constante mudança.

Existem 12 princípios que descrevem a metodologia Agile em detalhes -

Satisfação dos clientes

A maior prioridade é dada aos clientes com foco nos requisitos por meio da entrega antecipada e contínua de software valioso.

Recebendo novas mudanças

As alterações são aceitáveis ​​durante o desenvolvimento do software. Os processos ágeis são projetados para funcionar de forma a corresponder à vantagem competitiva do cliente.

Entrega

A entrega de um software funcional é fornecida aos clientes dentro de um período de uma a quatro semanas.

Colaboração

Analistas de negócios, analistas de qualidade e desenvolvedores devem trabalhar juntos durante todo o ciclo de vida do projeto.

Motivação

Os projetos devem ser elaborados com um clã de indivíduos motivados. Ele fornece um ambiente para apoiar os membros individuais da equipe.

Conversa pessoal

A conversa face a face é o método mais eficiente e eficaz de enviar informações para e dentro de uma equipe de desenvolvimento.

Medindo o progresso

Medir o progresso é a chave que ajuda a definir o andamento do projeto e do desenvolvimento de software.

Manter um ritmo constante

O processo ágil se concentra no desenvolvimento sustentável. A empresa, os desenvolvedores e os usuários devem ser capazes de manter um ritmo constante com o projeto.

Monitoramento

É obrigatório manter atenção regular à excelência técnica e ao bom design para aprimorar a funcionalidade ágil.

Simplicidade

O processo ágil mantém tudo simples e usa termos simples para medir o trabalho que não é concluído.

Termos auto-organizados

Uma equipe ágil deve ser auto-organizada e independente com a melhor arquitetura; requisitos e designs surgem de equipes auto-organizadas.

Reveja o trabalho

É importante revisar o trabalho em intervalos regulares para que a equipe possa refletir sobre como o trabalho está progredindo. A revisão do módulo em tempo hábil melhorará o desempenho.

Stand-up diário

Levantar-se diariamente refere-se à reunião diária de status entre os membros da equipe. Ele fornece atualizações relacionadas ao desenvolvimento de software. Também se refere a abordar os obstáculos do desenvolvimento do projeto.

O stand-up diário é uma prática obrigatória, não importa como uma equipe ágil seja estabelecida, independentemente da localização do escritório.

A lista de recursos de um stand-up diário é a seguinte -

  • A duração dos encontros diários em pé deve ser de aproximadamente 15 minutos. Não deve se estender por um período maior.

  • O stand-up deve incluir discussões sobre a atualização do status.

  • Os participantes dessa reunião geralmente se levantam com a intenção de acabar se encontrando rapidamente.

História do usuário

Uma história é geralmente um requisito, que é formulado em poucas frases em linguagem simples e deve ser concluída em uma iteração. Uma história de usuário deve incluir as seguintes características -

  • Todo o código relacionado deve ter check-ins relacionados.

  • Os casos de teste de unidade para a iteração especificada.

  • Todos os casos de teste de aceitação devem ser definidos.

  • Aceitação do product owner enquanto define a história.

O que é Scrum?

Scrum pode ser considerado um subconjunto da metodologia ágil. É um processo leve e inclui os seguintes recursos -

  • É uma estrutura de processo, que inclui um conjunto de práticas que precisam ser seguidas em uma ordem consistente. A melhor ilustração do Scrum é seguir iterações ou sprints.

  • É um processo “leve”, o que significa que o processo é mantido tão pequeno quanto possível, para maximizar a saída produtiva na duração especificada.

O processo Scrum é conhecido por seu processo de diferenciação em comparação com outras metodologias de abordagem ágil tradicional. Está dividido nas seguintes três categorias -

  • Roles

  • Artifacts

  • Caixas de Tempo

As funções definem os membros da equipe e suas funções incluídas ao longo do processo. O Time Scrum consiste nas seguintes três funções -

  • Scrum Master

  • Proprietário do produto

  • Team

Os artefatos Scrum fornecem informações importantes das quais cada membro deve estar ciente. As informações incluem detalhes do produto, atividades planejadas e atividades concluídas. Os artefatos definidos no framework Scrum são os seguintes -

  • Backlog do produto

  • Sprint backlog

  • Gráfico de queima

  • Increment

As caixas de tempo são as histórias de usuário planejadas para cada iteração. Essas histórias de usuário ajudam a descrever os recursos do produto que fazem parte dos artefatos Scrum. O backlog do produto é uma lista de histórias de usuários. Essas histórias de usuários são priorizadas e encaminhadas às reuniões de usuários para decidir qual delas deve ser retomada.

Por que Scrum Master?

Scrum Master interage com todos os membros da equipe. Vamos agora ver a interação do Scrum Master com outras equipes e recursos.

Proprietário do produto

O Scrum Master interage com o proprietário do produto das seguintes maneiras -

  • Encontrar técnicas para obter uma carteira de produtos eficaz de histórias de usuários e gerenciá-las.

  • Ajudar a equipe a entender as necessidades de itens de backlog de produtos claros e concisos.

  • Planejamento de produto com ambiente específico.

  • Garantir que o product owner saiba como aumentar o valor do produto.

  • Facilitar eventos Scrum como e quando necessário.

Time Scrum

O Scrum Master interage com a equipe de várias maneiras -

  • Treinar a organização na adoção do Scrum.

  • Planejando implementações de Scrum para a organização específica.

  • Ajudar os funcionários e partes interessadas a compreender os requisitos e as fases de desenvolvimento do produto.

  • Trabalhar com Scrum Masters de outras equipes para aumentar a eficácia da aplicação de Scrum da equipe especificada.

Organização

O Scrum Master interage com a organização de várias maneiras. Alguns são mencionados abaixo -

  • A equipe de coaching e scrum interage com a auto-organização e inclui um recurso de funcionalidade cruzada.

  • Treinar a organização e as equipes em áreas onde o Scrum ainda não foi totalmente adotado ou não foi aceito.

Benefícios do Scrum

Scrum ajuda os clientes, membros da equipe e stakeholders a colaborar. Inclui abordagem com prazo definido e feedback contínuo do proprietário do produto, garantindo que o produto esteja em condições de funcionamento. Scrum oferece benefícios para diferentes funções do projeto.

Cliente

Os sprints ou iterações são considerados para uma duração mais curta e as histórias de usuário são projetadas de acordo com a prioridade e são consideradas no planejamento do sprint. Ele garante que a cada entrega de sprint, os requisitos do cliente sejam atendidos. Caso contrário, os requisitos são anotados e planejados e levados para o sprint.

Organização

A organização com a ajuda de Scrum e Scrum masters pode focar nos esforços necessários para o desenvolvimento de user stories, reduzindo assim a sobrecarga de trabalho e evitando retrabalho, se houver. Isso também ajuda a manter o aumento da eficiência da equipe de desenvolvimento e satisfação do cliente. Essa abordagem também ajuda a aumentar o potencial do mercado.

Gerentes de Produto

A principal responsabilidade dos gerentes de produto é garantir que a qualidade do produto seja mantida. Com a ajuda do Scrum Masters, torna-se fácil facilitar o trabalho, reunir respostas rápidas e absorver alterações, se houver. Os gerentes de produto também verificam se o produto projetado está alinhado de acordo com os requisitos do cliente em cada sprint.

Equipe de desenvolvimento

Com a natureza limitada pelo tempo e mantendo os sprints por um período menor de tempo, a equipe de desenvolvimento fica entusiasmada para ver se o trabalho é refletido e entregue corretamente. O produto de trabalho incrementa cada nível após cada iteração, ou melhor, podemos chamá-los de “sprint”. As histórias de usuário projetadas para cada sprint tornam-se a prioridade do cliente, agregando mais valor à iteração.

Conclusão

Scrum é uma estrutura eficiente dentro da qual você pode desenvolver software em trabalho em equipe. É totalmente projetado com base em princípios ágeis. ScrumMaster está lá para ajudar e cooperar com a equipe Scrum de todas as maneiras possíveis. Ele atua como um personal trainer que o ajuda a cumprir o plano projetado e realizar todas as atividades de acordo com o plano. A autoridade do ScrumMaster nunca deve se estender além do processo. Ele / ela deve ser potencialmente capaz de gerenciar todas as situações.

Neste capítulo, entenderemos o processo de ciência de dados e as terminologias necessárias para entender o processo.

“Ciência de dados é a combinação de interface de dados, desenvolvimento de algoritmos e tecnologia para resolver problemas analíticos complexos”.

Ciência de dados é um campo interdisciplinar que engloba métodos, processos e sistemas científicos com categorias incluídas como aprendizado de máquina, conhecimento matemático e estatístico com pesquisa tradicional. Também inclui uma combinação de habilidades de hacking com experiência substantiva. A ciência de dados extrai princípios da matemática, estatística, ciência da informação e ciência da computação, mineração de dados e análise preditiva.

As diferentes funções que fazem parte da equipe de ciência de dados são mencionadas abaixo -

clientes

Os clientes são as pessoas que usam o produto. Seu interesse determina o sucesso do projeto e seu feedback é muito valioso na ciência de dados.

Desenvolvimento de negócios

Essa equipe de ciência de dados registra os primeiros clientes, seja em primeira mão ou por meio da criação de páginas de destino e promoções. A equipe de desenvolvimento de negócios entrega o valor do produto.

Gerentes de Produto

Os gerentes de produto consideram importante criar o melhor produto, o que é valioso no mercado.

Designers de interação

Eles se concentram em interações de design em torno de modelos de dados para que os usuários encontrem o valor apropriado.

Cientistas de dados

Os cientistas de dados exploram e transformam os dados de novas maneiras para criar e publicar novos recursos. Esses cientistas também combinam dados de diversas fontes para criar um novo valor. Eles desempenham um papel importante na criação de visualizações com pesquisadores, engenheiros e desenvolvedores da web.

Pesquisadores

Como o nome especifica, os pesquisadores estão envolvidos em atividades de pesquisa. Eles resolvem problemas complicados, que os cientistas de dados não podem fazer. Esses problemas envolvem foco intenso e tempo de aprendizado de máquina e módulo de estatísticas.

Adaptando-se à Mudança

Todos os membros da equipe de ciência de dados devem se adaptar às novas mudanças e trabalhar com base nos requisitos. Diversas mudanças devem ser feitas para a adoção de metodologia ágil com ciência de dados, que são citadas a seguir -

  • Escolhendo generalistas em vez de especialistas.

  • Preferência de equipes pequenas sobre equipes grandes.

  • Usando ferramentas e plataformas de alto nível.

  • Compartilhamento contínuo e iterativo do trabalho intermediário.

Note

Na equipe de ciência de dados Agile, uma pequena equipe de generalistas usa ferramentas de alto nível que são escalonáveis ​​e refinam os dados por meio de iterações em estados de valor cada vez mais elevados.

Considere os seguintes exemplos relacionados ao trabalho dos membros da equipe de ciência de dados -

  • Designers entregam CSS.

  • Os desenvolvedores da Web criam aplicativos inteiros, entendem a experiência do usuário e o design da interface.

  • Os cientistas de dados devem trabalhar tanto na pesquisa quanto na construção de serviços da web, incluindo aplicativos da web.

  • Os pesquisadores trabalham na base de código, que mostra resultados explicando resultados intermediários.

  • Os gerentes de produto procuram identificar e compreender as falhas em todas as áreas relacionadas.

Neste capítulo, aprenderemos sobre as diferentes ferramentas Agile e sua instalação. A pilha de desenvolvimento da metodologia ágil inclui o seguinte conjunto de componentes -

Eventos

Um evento é uma ocorrência que acontece ou é registrada junto com seus recursos e carimbos de data / hora.

Um evento pode vir de várias formas, como servidores, sensores, transações financeiras ou ações, que nossos usuários realizam em nosso aplicativo. Neste tutorial completo, usaremos arquivos JSON que irão facilitar a troca de dados entre diferentes ferramentas e linguagens.

Colecionadores

Coletores são agregadores de eventos. Eles coletam eventos de maneira sistemática para armazenar e agregar dados volumosos, enfileirando-os para a ação de funcionários em tempo real.

Documento distribuído

Esses documentos incluem vários nós (nós múltiplos) que armazena o documento em um formato específico. Vamos nos concentrar no MongoDB neste tutorial.

Servidor de aplicação web

O servidor de aplicativos da Web habilita dados como JSON por meio do cliente por meio de visualização, com sobrecarga mínima. Significa que o servidor de aplicação web ajuda a testar e implantar os projetos criados com metodologia ágil.

Navegador Moderno

Ele permite que um navegador ou aplicativo moderno apresente dados como uma ferramenta interativa para nossos usuários.

Configuração Ambiental Local

Para gerenciar conjuntos de dados, nos concentraremos na estrutura Anaconda de python que inclui ferramentas para gerenciar excel, csv e muitos mais arquivos. O painel do framework Anaconda, uma vez instalado, é mostrado abaixo. Também é chamado de “Anaconda Navigator” -

O navegador inclui o “framework Jupyter” que é um sistema de notebook que ajuda a gerenciar conjuntos de dados. Depois de iniciar o framework, ele será hospedado no navegador conforme mencionado abaixo -

Neste capítulo, vamos nos concentrar na diferença entre dados estruturados, semiestruturados e não estruturados.

Dados estruturados

Os dados estruturados referem-se aos dados armazenados no formato SQL em tabela com linhas e colunas. Inclui uma chave relacional, que é mapeada em campos predefinidos. Os dados estruturados são usados ​​em uma escala maior.

Os dados estruturados representam apenas 5 a 10 por cento de todos os dados de informática.

Dados semiestruturados

Os dados semiestruturados incluem dados que não residem no banco de dados relacional. Eles incluem algumas propriedades organizacionais que facilitam a análise. Inclui o mesmo processo para armazená-los no banco de dados relacional. Os exemplos de banco de dados semiestruturado são arquivos CSV, documentos XML e JSON. Os bancos de dados NoSQL são considerados semiestruturados.

Dados não estruturados

Os dados não estruturados representam 80 por cento dos dados. Geralmente inclui conteúdo de texto e multimídia. Os melhores exemplos de dados não estruturados incluem arquivos de áudio, apresentações e páginas da web. Os exemplos de dados não estruturados gerados por máquina são imagens de satélite, dados científicos, fotografias e vídeo, dados de radar e sonar.

A estrutura da pirâmide acima se concentra especificamente na quantidade de dados e na proporção na qual eles estão espalhados.

Os dados quase estruturados aparecem como um tipo entre dados não estruturados e semiestruturados. Neste tutorial, vamos nos concentrar em dados semiestruturados, o que é benéfico para metodologia ágil e pesquisa de ciência de dados.

Os dados semiestruturados não possuem um modelo de dados formal, mas apresentam um padrão e uma estrutura autodescritos aparentes que são desenvolvidos por sua análise.

O foco completo deste tutorial é seguir metodologia ágil com menor número de etapas e com implementação de ferramentas mais úteis. Para entender isso, é importante saber a diferença entre os bancos de dados SQL e NoSQL.

A maioria dos usuários está ciente do banco de dados SQL e tem um bom conhecimento em MySQL, Oracle ou outros bancos de dados SQL. Nos últimos anos, o banco de dados NoSQL está sendo amplamente adotado para resolver vários problemas de negócios e requisitos de projeto.

A tabela a seguir mostra a diferença entre os bancos de dados SQL e NoSQL -

SQL NoSQL
Os bancos de dados SQL são chamados principalmente de sistema de gerenciamento de banco de dados relacional (RDBMS). O banco de dados NoSQL também é chamado de banco de dados orientado a documentos. É não relacional e distribuído.
Os bancos de dados baseados em SQL incluem estrutura de tabela com linhas e colunas. Coleção de tabelas e outras estruturas de esquema denominadas banco de dados. O banco de dados NoSQL inclui documentos como estrutura principal e a inclusão de documentos é chamada de coleção.
Os bancos de dados SQL incluem esquema predefinido. Os bancos de dados NoSQL têm dados dinâmicos e incluem dados não estruturados.
Os bancos de dados SQL são escalonáveis ​​verticalmente. Os bancos de dados NoSQL são escalonáveis ​​horizontalmente.
Os bancos de dados SQL são adequados para ambientes de consulta complexos. NoSQL não tem interfaces padrão para desenvolvimento de consultas complexas.
Os bancos de dados SQL não são viáveis ​​para armazenamento hierárquico de dados. Os bancos de dados NoSQL se adaptam melhor ao armazenamento de dados hierárquicos.
Os bancos de dados SQL são mais adequados para transações pesadas nos aplicativos especificados. Os bancos de dados NoSQL ainda não são considerados comparáveis ​​em alta carga para aplicativos transacionais complexos.
Os bancos de dados SQL fornecem excelente suporte para seus fornecedores. O banco de dados NoSQL ainda depende do suporte da comunidade. Apenas alguns especialistas estão disponíveis para configuração e implantação para implantações NoSQL em grande escala.
Os bancos de dados SQL se concentram nas propriedades ACID - Atômica, Consistência, Isolamento e Durabilidade. O banco de dados NoSQL se concentra nas propriedades do CAP - consistência, disponibilidade e tolerância de partição.
Os bancos de dados SQL podem ser classificados como open source ou closed source com base nos fornecedores que os optaram. Os bancos de dados NoSQL são classificados com base no tipo de armazenamento. Os bancos de dados NoSQL são de código aberto por padrão.

Por que NoSQL para agilidade?

A comparação mencionada acima mostra que o banco de dados de documentos NoSQL oferece suporte total ao desenvolvimento ágil. É sem esquema e não se concentra totalmente na modelagem de dados. Em vez disso, o NoSQL adia aplicativos e serviços e, assim, os desenvolvedores têm uma ideia melhor de como os dados podem ser modelados. NoSQL define o modelo de dados como o modelo do aplicativo.

Instalação do MongoDB

Ao longo deste tutorial, vamos nos concentrar mais nos exemplos do MongoDB, pois é considerado o melhor “esquema NoSQL”.

Há momentos em que os dados não estão disponíveis no formato relacional e precisamos mantê-los transacionais com a ajuda dos bancos de dados NoSQL.

Neste capítulo, vamos nos concentrar no fluxo de dados do NoSQL. Também aprenderemos como ele é operacional com uma combinação de agile e data science.

Um dos principais motivos para usar o NoSQL com agile é aumentar a velocidade com a competição de mercado. Os motivos a seguir mostram como o NoSQL é a melhor opção para a metodologia de software ágil -

Menos barreiras

Mudar o modelo, que atualmente está passando pelo mid-stream, tem alguns custos reais mesmo em caso de desenvolvimento ágil. Com o NoSQL, os usuários trabalham com dados agregados em vez de perder tempo normalizando os dados. O ponto principal é fazer algo e trabalhar com o objetivo de tornar os dados do modelo perfeitos.

Maior escalabilidade

Sempre que uma organização está criando um produto, ela se concentra mais em sua escalabilidade. O NoSQL sempre é conhecido por sua escalabilidade, mas funciona melhor quando é projetado com escalabilidade horizontal.

Capacidade de aproveitar dados

NoSQL é um modelo de dados sem esquema que permite ao usuário usar prontamente volumes de dados, que inclui vários parâmetros de variabilidade e velocidade. Ao considerar uma escolha de tecnologia, você deve sempre considerar aquela que alavanca os dados em uma escala maior.

Fluxo de dados de NoSQL

Vamos considerar o exemplo a seguir em que mostramos como um modelo de dados se concentra na criação do esquema RDBMS.

A seguir estão os diferentes requisitos de esquema -

  • A identificação do usuário deve ser listada.

  • Cada usuário deve ter pelo menos uma habilidade obrigatória.

  • Os detalhes da experiência de cada usuário devem ser mantidos de maneira adequada.

A tabela do usuário é normalizada com 3 tabelas separadas -

  • Users

  • Habilidades do usuário

  • Experiência de usuário

A complexidade aumenta ao consultar o banco de dados e o consumo de tempo é observado com o aumento da normalização, o que não é bom para a metodologia Agile. O mesmo esquema pode ser projetado com o banco de dados NoSQL conforme mencionado abaixo -

NoSQL mantém a estrutura no formato JSON, que é leve em estrutura. Com JSON, os aplicativos podem armazenar objetos com dados aninhados como documentos únicos.

Neste capítulo, vamos nos concentrar na estrutura JSON, que faz parte da “Metodologia Agile”. MongoDB é uma estrutura de dados NoSQL amplamente usada e opera facilmente para coletar e exibir registros.

Passo 1

Esta etapa envolve estabelecer conexão com MongoDB para criar coleção e modelo de dados especificado. Tudo que você precisa para executar é o comando “mongod” para iniciar a conexão e o comando mongo para se conectar ao terminal especificado.

Passo 2

Crie um novo banco de dados para a criação de registros no formato JSON. Por enquanto, estamos criando um banco de dados fictício chamado “mydb”.

>use mydb
switched to db mydb
>db
mydb
>show dbs
local 0.78125GB
test 0.23012GB
>db.user.insert({"name":"Agile Data Science"})
>show dbs
local 0.78125GB
mydb 0.23012GB
test 0.23012GB

etapa 3

A criação da coleção é obrigatória para obter a lista de registros. Esse recurso é benéfico para pesquisas e resultados científicos de dados.

>use test
switched to db test
>db.createCollection("mycollection")
{ "ok" : 1 }
>show collections
mycollection
system.indexes
>db.createCollection("mycol", { capped : true, autoIndexId : true, size :
 6142800, max : 10000 } )
{ "ok" : 1 }
>db.agiledatascience.insert({"name" : "demoname"})
>show collections
mycol
mycollection
system.indexes
demoname

A visualização de dados desempenha um papel muito importante na ciência de dados. Podemos considerar a visualização de dados como um módulo da ciência de dados. Data Science inclui mais do que construir modelos preditivos. Inclui a explicação de modelos e como usá-los para entender os dados e tomar decisões. A visualização de dados é parte integrante da apresentação de dados da maneira mais convincente.

Do ponto de vista da ciência de dados, a visualização de dados é um recurso de destaque que mostra as mudanças e tendências.

Considere as seguintes diretrizes para uma visualização de dados eficaz -

  • Posicione os dados ao longo da escala comum.

  • O uso de barras é mais eficaz em comparação com círculos e quadrados.

  • A cor adequada deve ser usada para gráficos de dispersão.

  • Use o gráfico de pizza para mostrar as proporções.

  • A visualização Sunburst é mais eficaz para gráficos hierárquicos.

Agile precisa de uma linguagem de script simples para visualização de dados e com ciência de dados em colaboração “Python” é a linguagem sugerida para visualização de dados.

Exemplo 1

O exemplo a seguir demonstra a visualização de dados do PIB calculado em anos específicos. “Matplotlib” é a melhor biblioteca para visualização de dados em Python. A instalação desta biblioteca é mostrada abaixo -

Considere o seguinte código para entender isso -

import matplotlib.pyplot as plt
years = [1950, 1960, 1970, 1980, 1990, 2000, 2010]
gdp = [300.2, 543.3, 1075.9, 2862.5, 5979.6, 10289.7, 14958.3]

# create a line chart, years on x-axis, gdp on y-axis
plt.plot(years, gdp, color='green', marker='o', linestyle='solid')

# add a title plt.title("Nominal GDP")
# add a label to the y-axis
plt.ylabel("Billions of $")
plt.show()

Resultado

O código acima gera a seguinte saída -

Existem muitas maneiras de personalizar os gráficos com rótulos de eixo, estilos de linha e marcadores de ponto. Vamos nos concentrar no próximo exemplo que demonstra a melhor visualização de dados. Esses resultados podem ser usados ​​para uma melhor saída.

Exemplo 2

import datetime
import random
import matplotlib.pyplot as plt

# make up some data
x = [datetime.datetime.now() + datetime.timedelta(hours=i) for i in range(12)]
y = [i+random.gauss(0,1) for i,_ in enumerate(x)]

# plot
plt.plot(x,y)

# beautify the x-labels
plt.gcf().autofmt_xdate()
plt.show()

Resultado

O código acima gera a seguinte saída -

O enriquecimento de dados se refere a uma gama de processos usados ​​para aprimorar, refinar e melhorar os dados brutos. Refere-se à transformação de dados úteis (dados brutos em informações úteis). O processo de enriquecimento de dados se concentra em tornar os dados um ativo de dados valioso para os negócios ou empresas modernas.

O processo de enriquecimento de dados mais comum inclui a correção de erros ortográficos ou tipográficos no banco de dados por meio do uso de algoritmos de decisão específicos. As ferramentas de enriquecimento de dados adicionam informações úteis a tabelas de dados simples.

Considere o seguinte código para correção ortográfica de palavras -

import re
from collections import Counter
def words(text): return re.findall(r'\w+', text.lower())
WORDS = Counter(words(open('big.txt').read()))

def P(word, N=sum(WORDS.values())):
   "Probabilities of words"
   return WORDS[word] / N
	
def correction(word):
   "Spelling correction of word"
   return max(candidates(word), key=P)
	
def candidates(word):
   "Generate possible spelling corrections for word."
   return (known([word]) or known(edits1(word)) or known(edits2(word)) or [word])
	
def known(words):
   "The subset of `words` that appear in the dictionary of WORDS."
   return set(w for w in words if w in WORDS)
	
def edits1(word):
   "All edits that are one edit away from `word`."
   letters = 'abcdefghijklmnopqrstuvwxyz'
   splits = [(word[:i], word[i:]) for i in range(len(word) + 1)]
   deletes = [L + R[1:] for L, R in splits if R]
   transposes = [L + R[1] + R[0] + R[2:] for L, R in splits if len(R)>1]
   replaces = [L + c + R[1:] for L, R in splits if R for c in letters]
   inserts = [L + c + R for L, R in splits for c in letters]
   return set(deletes + transposes + replaces + inserts)
	
def edits2(word):
   "All edits that are two edits away from `word`."
   return (e2 for e1 in edits1(word) for e2 in edits1(e1))
   print(correction('speling'))
   print(correction('korrectud'))

Neste programa, iremos corresponder com “big.txt” que inclui palavras corrigidas. As palavras correspondem às palavras incluídas no arquivo de texto e imprimem os resultados apropriados de acordo.

Resultado

O código acima irá gerar a seguinte saída -

Neste capítulo, aprenderemos sobre a criação de relatórios, que é um importante módulo da metodologia ágil. Páginas de gráfico de sprints do Agile criadas pela visualização em relatórios completos. Com os relatórios, os gráficos se tornam interativos, as páginas estáticas tornam-se dinâmicas e os dados relacionados à rede. As características do estágio de relatórios da pirâmide de valor dos dados são mostradas abaixo -

Daremos mais ênfase à criação de um arquivo csv, que pode ser usado como relatório para análise de ciência de dados e tirar conclusões. Embora o Agile foque em menos documentação, a geração de relatórios para mencionar o andamento do desenvolvimento do produto é sempre considerada.

import csv
#----------------------------------------------------------------------
def csv_writer(data, path):
   """
      Write data to a CSV file path
   """
   with open(path, "wb") as csv_file:
   writer = csv.writer(csv_file, delimiter=',')
   for line in data:
   writer.writerow(line)
#----------------------------------------------------------------------
if __name__ == "__main__":
   data = ["first_name,last_name,city".split(","),
      "Tyrese,Hirthe,Strackeport".split(","),
      "Jules,Dicki,Lake Nickolasville".split(","),
      "Dedric,Medhurst,Stiedemannberg".split(",")
   ]
	
   path = "output.csv"
   csv_writer(data, path)

O código acima irá ajudá-lo a gerar o “arquivo csv” conforme mostrado abaixo -

Vamos considerar os seguintes benefícios dos relatórios csv (valores separados por vírgula) -

  • É amigável e fácil de editar manualmente.
  • É simples de implementar e analisar.
  • O CSV pode ser processado em todos os aplicativos.
  • É menor e mais rápido de manusear.
  • CSV segue um formato padrão.
  • Ele fornece um esquema simples para cientistas de dados.

Neste capítulo, vamos aprender sobre o papel das previsões na ciência de dados ágil. Os relatórios interativos expõem diferentes aspectos dos dados. As previsões formam a quarta camada do sprint ágil.

Ao fazer previsões, sempre nos referimos aos dados anteriores e os usamos como inferências para iterações futuras. Nesse processo completo, fazemos a transição dos dados do processamento em lote de dados históricos para dados em tempo real sobre o futuro.

O papel das previsões inclui o seguinte -

  • As previsões ajudam na previsão. Algumas previsões são baseadas em inferências estatísticas. Algumas das previsões são baseadas em opiniões de especialistas.

  • A inferência estatística está envolvida com previsões de todos os tipos.

  • Às vezes, as previsões são precisas, enquanto às vezes as previsões são imprecisas.

Análise preditiva

A análise preditiva inclui uma variedade de técnicas estatísticas de modelagem preditiva, aprendizado de máquina e mineração de dados que analisam fatos atuais e históricos para fazer previsões sobre eventos futuros e desconhecidos.

A análise preditiva requer dados de treinamento. Os dados treinados incluem recursos independentes e dependentes. Os recursos dependentes são os valores que um usuário está tentando prever. Recursos independentes são recursos que descrevem as coisas que desejamos prever com base em recursos dependentes.

O estudo de recursos é chamado de engenharia de recursos; isso é crucial para fazer previsões. A visualização de dados e a análise exploratória de dados são partes da engenharia de recursos; estes formam o núcleo deAgile data science.

Fazendo previsões

Existem duas maneiras de fazer previsões na ciência de dados ágil -

  • Regression

  • Classification

A construção de uma regressão ou classificação depende completamente dos requisitos de negócios e de sua análise. A previsão da variável contínua leva ao modelo de regressão e a previsão das variáveis ​​categóricas leva ao modelo de classificação.

Regressão

A regressão considera exemplos que compreendem recursos e, portanto, produz uma saída numérica.

Classificação

A classificação recebe a entrada e produz uma classificação categórica.

Note - O conjunto de dados de exemplo que define a entrada para a previsão estatística e que permite que a máquina aprenda é chamado de “dados de treinamento”.

Neste capítulo, aprenderemos sobre a aplicação dos recursos de extração com PySpark no Agile Data Science.

Visão geral do Spark

O Apache Spark pode ser definido como uma estrutura de processamento rápido em tempo real. Ele faz cálculos para analisar dados em tempo real. O Apache Spark é apresentado como um sistema de processamento de fluxo em tempo real e também pode cuidar do processamento em lote. O Apache Spark oferece suporte a consultas interativas e algoritmos iterativos.

O Spark é escrito na “linguagem de programação Scala”.

O PySpark pode ser considerado uma combinação de Python com Spark. O PySpark oferece o shell PySpark, que vincula a API Python ao núcleo do Spark e inicializa o contexto do Spark. A maioria dos cientistas de dados usa o PySpark para rastrear recursos conforme discutido no capítulo anterior.

Neste exemplo, vamos nos concentrar nas transformações para construir um conjunto de dados chamado contagens e salvá-lo em um arquivo específico.

text_file = sc.textFile("hdfs://...")
counts = text_file.flatMap(lambda line: line.split(" ")) \
   .map(lambda word: (word, 1)) \
   .reduceByKey(lambda a, b: a + b)
counts.saveAsTextFile("hdfs://...")

Usando o PySpark, um usuário pode trabalhar com RDDs na linguagem de programação python. A biblioteca embutida, que cobre os fundamentos de documentos e componentes baseados em dados, ajuda nisso.

A regressão logística refere-se ao algoritmo de aprendizado de máquina usado para prever a probabilidade da variável dependente categórica. Na regressão logística, a variável dependente é a variável binária, que consiste em dados codificados como 1 (valores booleanos de verdadeiro e falso).

Neste capítulo, vamos nos concentrar no desenvolvimento de um modelo de regressão em Python usando variável contínua. O exemplo de modelo de regressão linear enfocará na exploração de dados do arquivo CSV.

O objetivo da classificação é prever se o cliente assinará (1/0) um depósito a prazo.

import pandas as pd
import numpy as np
from sklearn import preprocessing
import matplotlib.pyplot as plt

plt.rc("font", size=14)
from sklearn.linear_model import LogisticRegression
from sklearn.cross_validation import train_test_split

import seaborn as sns
sns.set(style="white")
sns.set(style="whitegrid", color_codes=True)
data = pd.read_csv('bank.csv', header=0)
data = data.dropna()
print(data.shape)
print(list(data.columns))

Siga estas etapas para implementar o código acima no Anaconda Navigator com “Jupyter Notebook” -

Step 1 - Inicie o Notebook Jupyter com o Anaconda Navigator.

Step 2 - Carregue o arquivo csv para obter a saída do modelo de regressão de maneira sistemática.

Step 3 - Crie um novo arquivo e execute a linha de código mencionada acima para obter a saída desejada.

Neste exemplo, aprenderemos como criar e implementar um modelo preditivo que ajuda na previsão dos preços das casas usando o script Python. A importante estrutura usada para implantação de sistema preditivo inclui Anaconda e “Jupyter Notebook”.

Siga estas etapas para implantar um sistema preditivo -

Step 1 - Implemente o código a seguir para converter valores de arquivos csv em valores associados.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import mpl_toolkits

%matplotlib inline
data = pd.read_csv("kc_house_data.csv")
data.head()

O código acima gera a seguinte saída -

Step 2 - Execute a função de descrição para obter os tipos de dados incluídos na atribuição de arquivos csv.

data.describe()

Step 3 - Podemos descartar os valores associados com base na implantação do modelo preditivo que criamos.

train1 = data.drop(['id', 'price'],axis=1)
train1.head()

Step 4- Você pode visualizar os dados conforme os registros. Os dados podem ser usados ​​para análise de ciência de dados e produção de white papers.

data.floors.value_counts().plot(kind='bar')

A biblioteca de aprendizado de máquina, também chamada de “SparkML” ou “MLLib”, consiste em algoritmos de aprendizado comuns, incluindo classificação, regressão, clustering e filtragem colaborativa.

Por que aprender SparkML para Agile?

O Spark está se tornando a plataforma de fato para a construção de aplicativos e algoritmos de aprendizado de máquina. Os desenvolvedores trabalham no Spark para implementar algoritmos de máquina de maneira escalonável e concisa na estrutura do Spark. Aprenderemos os conceitos de aprendizado de máquina, seus utilitários e algoritmos com este framework. O Agile sempre opta por um framework, que entrega resultados curtos e rápidos.

Algoritmos de ML

Os algoritmos de ML incluem algoritmos de aprendizagem comuns, como classificação, regressão, agrupamento e filtragem colaborativa.

Características

Inclui extração, transformação, redução de dimensão e seleção de recursos.

Pipelines

Pipelines fornecem ferramentas para construir, avaliar e ajustar pipelines de aprendizado de máquina.

Algoritmos populares

A seguir estão alguns algoritmos populares -

  • Estatísticas Básicas

  • Regression

  • Classification

  • Sistema de Recomendação

  • Clustering

  • Redução de dimensionalidade

  • Extração de característica

  • Optimization

Sistema de Recomendação

Um sistema de recomendação é uma subclasse de sistema de filtragem de informações que busca a previsão de “classificação” e “preferência” que um usuário sugere para um determinado item.

O sistema de recomendação inclui vários sistemas de filtragem, que são usados ​​da seguinte forma -

Filtragem colaborativa

Inclui a construção de um modelo com base no comportamento anterior, bem como em decisões semelhantes feitas por outros usuários. Este modelo de filtragem específico é usado para prever itens que um usuário está interessado em receber.

Filtragem baseada em conteúdo

Inclui a filtragem de características discretas de um item para recomendar e adicionar novos itens com propriedades semelhantes.

Em nossos capítulos subsequentes, vamos nos concentrar no uso de sistema de recomendação para resolver um problema específico e melhorar o desempenho de previsão do ponto de vista da metodologia ágil.

Neste capítulo, vamos nos concentrar em corrigir um problema de previsão com a ajuda de um cenário específico.

Considere que uma empresa deseja automatizar os detalhes de elegibilidade do empréstimo de acordo com os detalhes do cliente fornecidos por meio do formulário de inscrição online. Os detalhes incluem nome do cliente, sexo, estado civil, valor do empréstimo e outros detalhes obrigatórios.

Os detalhes são registrados no arquivo CSV conforme mostrado abaixo -

Execute o seguinte código para avaliar o problema de previsão -

import pandas as pd
from sklearn import ensemble
import numpy as np

from scipy.stats import mode
from sklearn import preprocessing,model_selection
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import LabelEncoder

#loading the dataset
data=pd.read_csv('train.csv',index_col='Loan_ID')
def num_missing(x):
   return sum(x.isnull())
 
#imputing the the missing values from the data
data['Gender'].fillna(mode(list(data['Gender'])).mode[0], inplace=True)
data['Married'].fillna(mode(list(data['Married'])).mode[0], inplace=True)
data['Self_Employed'].fillna(mode(list(data['Self_Employed'])).mode[0], inplace=True)

# print (data.apply(num_missing, axis=0))
# #imputing mean for the missing value
data['LoanAmount'].fillna(data['LoanAmount'].mean(), inplace=True)
mapping={'0':0,'1':1,'2':2,'3+':3}
data = data.replace({'Dependents':mapping})
data['Dependents'].fillna(data['Dependents'].mean(), inplace=True)
data['Loan_Amount_Term'].fillna(method='ffill',inplace=True)
data['Credit_History'].fillna(method='ffill',inplace=True)
print (data.apply(num_missing,axis=0))

#converting the cateogorical data to numbers using the label encoder
var_mod = ['Gender','Married','Education','Self_Employed','Property_Area','Loan_Status']
le = LabelEncoder()
for i in var_mod:
   le.fit(list(data[i].values))
   data[i] = le.transform(list(data[i]))
 
#Train test split
x=['Gender','Married','Education','Self_Employed','Property_Area','LoanAmount', 'Loan_Amount_Term','Credit_History','Dependents']
y=['Loan_Status']
print(data[x])
X_train,X_test,y_train,y_test=model_selection.train_test_split(data[x],data[y], test_size=0.2)

#
# #Random forest classifier
# clf=ensemble.RandomForestClassifier(n_estimators=100,
criterion='gini',max_depth=3,max_features='auto',n_jobs=-1)
clf=ensemble.RandomForestClassifier(n_estimators=200,max_features=3,min_samples
   _split=5,oob_score=True,n_jobs=-1,criterion='entropy')
	
clf.fit(X_train,y_train)
accuracy=clf.score(X_test,y_test)
print(accuracy)

Resultado

O código acima gera a seguinte saída.

Neste capítulo, vamos nos concentrar na construção de um modelo que ajude na previsão do desempenho do aluno com uma série de atributos incluídos nele. O foco é exibir o resultado da reprovação dos alunos em um exame.

Processo

O valor alvo da avaliação é G3. Esses valores podem ser categorizados e posteriormente classificados como falha e sucesso. Se o valor de G3 for maior ou igual a 10, o aluno passa no exame.

Exemplo

Considere o seguinte exemplo em que um código é executado para prever o desempenho se os alunos -

import pandas as pd
""" Read data file as DataFrame """
df = pd.read_csv("student-mat.csv", sep=";")
""" Import ML helpers """
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import GridSearchCV, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.svm import LinearSVC # Support Vector Machine Classifier model
""" Split Data into Training and Testing Sets """
def split_data(X, Y):
 return train_test_split(X, Y, test_size=0.2, random_state=17)
""" Confusion Matrix """
def confuse(y_true, y_pred):
 cm = confusion_matrix(y_true=y_true, y_pred=y_pred)
 # print("\nConfusion Matrix: \n", cm)
  fpr(cm)
 ffr(cm)
""" False Pass Rate """
def fpr(confusion_matrix):
 fp = confusion_matrix[0][1]
 tf = confusion_matrix[0][0]
 rate = float(fp) / (fp + tf)
 print("False Pass Rate: ", rate)
""" False Fail Rate """
def ffr(confusion_matrix):
 ff = confusion_matrix[1][0]
 tp = confusion_matrix[1][1]
 rate = float(ff) / (ff + tp)
 print("False Fail Rate: ", rate)
 return rate
""" Train Model and Print Score """
def train_and_score(X, y):
 X_train, X_test, y_train, y_test = split_data(X, y)
 clf = Pipeline([
 ('reduce_dim', SelectKBest(chi2, k=2)),
 ('train', LinearSVC(C=100))
 ])
 scores = cross_val_score(clf, X_train, y_train, cv=5, n_jobs=2)
 print("Mean Model Accuracy:", np.array(scores).mean())
 clf.fit(X_train, y_train)
 confuse(y_test, clf.predict(X_test))
 print()
""" Main Program """
def main():
 print("\nStudent Performance Prediction")
 # For each feature, encode to categorical values
 class_le = LabelEncoder()
 for column in df[["school", "sex", "address", "famsize", "Pstatus", "Mjob",
"Fjob", "reason", "guardian", "schoolsup", "famsup", "paid", "activities",
"nursery", "higher", "internet", "romantic"]].columns:
 df[column] = class_le.fit_transform(df[column].values)
 # Encode G1, G2, G3 as pass or fail binary values
 for i, row in df.iterrows():
 if row["G1"] >= 10:
 df["G1"][i] = 1
 else:
 df["G1"][i] = 0
 if row["G2"] >= 10:
 df["G2"][i] = 1
 else:
 df["G2"][i] = 0
 if row["G3"] >= 10:
 df["G3"][i] = 1
 else:
 df["G3"][i] = 0
 # Target values are G3
 y = df.pop("G3")
 # Feature set is remaining features
 X = df
 print("\n\nModel Accuracy Knowing G1 & G2 Scores")
 print("=====================================")
 train_and_score(X, y)
 # Remove grade report 2
 X.drop(["G2"], axis = 1, inplace=True)
 print("\n\nModel Accuracy Knowing Only G1 Score")
 print("=====================================")
 train_and_score(X, y)
 # Remove grade report 1
 X.drop(["G1"], axis=1, inplace=True)
 print("\n\nModel Accuracy Without Knowing Scores")
 print("=====================================")
 train_and_score(X, y)
main()

Resultado

O código acima gera a saída conforme mostrado abaixo

A previsão é tratada com referência a apenas uma variável. Com referência a uma variável, a previsão de desempenho do aluno é mostrada abaixo -

A metodologia ágil ajuda as organizações a se adaptarem às mudanças, competir no mercado e construir produtos de alta qualidade. Observa-se que as organizações amadurecem com metodologia ágil, com mudanças crescentes de requisitos dos clientes. Compilar e sincronizar dados com equipes ágeis de organização é significativo para acumular dados de acordo com o portfólio necessário.

Crie um plano melhor

O desempenho ágil padronizado depende exclusivamente do plano. O esquema de dados ordenado aumenta a produtividade, a qualidade e a capacidade de resposta do progresso da organização. O nível de consistência dos dados é mantido com cenários históricos e em tempo real.

Considere o diagrama a seguir para entender o ciclo do experimento de ciência de dados -

A ciência de dados envolve a análise de requisitos seguida da criação de algoritmos baseados nos mesmos. Uma vez que os algoritmos são projetados junto com a configuração ambiental, um usuário pode criar experimentos e coletar dados para uma melhor análise.

Essa ideologia computa o último sprint do agile, que é chamado de “ações”.

Actionsenvolve todas as tarefas obrigatórias para o último sprint ou nível de metodologia ágil. O controle das fases da ciência de dados (com relação ao ciclo de vida) pode ser mantido com cartões de história como itens de ação.

Análise preditiva e Big data

O futuro do planejamento está totalmente na customização dos relatórios de dados com os dados coletados na análise. Também incluirá manipulação com análise de big data. Com a ajuda do big data, peças discretas de informação podem ser analisadas, efetivamente com o fatiamento e o fatiamento das métricas da organização. A análise é sempre considerada a melhor solução.

Existem várias metodologias utilizadas no processo de desenvolvimento ágil. Essas metodologias podem ser usadas para o processo de pesquisa de ciência de dados também.

O fluxograma abaixo mostra as diferentes metodologias -

Scrum

Em termos de desenvolvimento de software, scrum significa gerenciar o trabalho com uma pequena equipe e gerenciar um projeto específico para revelar os pontos fortes e fracos do projeto.

Metodologias de cristal

As metodologias Crystal incluem técnicas inovadoras para gerenciamento e execução de produtos. Com esse método, as equipes podem realizar tarefas semelhantes de maneiras diferentes. A família Crystal é uma das metodologias mais fáceis de aplicar.

Método de Desenvolvimento de Software Dinâmico

Esta estrutura de entrega é usada principalmente para implementar o sistema de conhecimento atual na metodologia de software.

Desenvolvimento orientado para o futuro

O foco deste ciclo de vida de desenvolvimento são os recursos envolvidos no projeto. Ele funciona melhor para modelagem de objeto de domínio, código e desenvolvimento de recursos para propriedade.

Desenvolvimento de software enxuto

Programação extrema

Extreme Programming é uma metodologia de desenvolvimento de software única, que se concentra na melhoria da qualidade do software. Isso entra em vigor quando o cliente não tem certeza sobre a funcionalidade de qualquer projeto.

As metodologias ágeis estão se enraizando no fluxo da ciência de dados e são consideradas como a metodologia de software importante. Com a auto-organização ágil, as equipes multifuncionais podem trabalhar juntas de maneira eficaz. Conforme mencionado, existem seis categorias principais de desenvolvimento ágil e cada uma delas pode ser transmitida com ciência de dados de acordo com os requisitos. A ciência de dados envolve um processo iterativo para insights estatísticos. Agile ajuda a quebrar os módulos de ciência de dados e ajuda no processamento de iterações e sprints de maneira eficaz.

O processo de Agile Data Science é uma maneira incrível de entender como e por que o módulo de ciência de dados é implementado. Ele resolve problemas de maneira criativa.