Categoria: Deep Learning

Categorias
Algoritmo Deep Learning Reconhecimento de imagem Redes Neurais

Aprenda a Criar e Treinar Uma Rede Neural Convolucional (CNN)

As redes neurais convolucionais (CNN) se utilizam de uma arquitetura especial que é particularmente bem adequada para classificar imagens. O uso dessa arquitetura torna as redes convolucionais rápidas de treinar, o que é vantajoso para trabalhar com redes profundas. Hoje, a CNN ,ou alguma variante próxima, é usada na maioria dos modelos para reconhecimento de imagem.

Neste artigo, vamos entender como criar e treinar uma (CNN) simples para classificar dígitos manuscritos de um conjunto de dados popular.

Figura 1: dataset MNIST ( imagem:en.wikipedia.org/wiki/MNIST_database) 

Pré-requisito

Embora cada etapa seja detalhada neste tutorial, certamente quem já possui algum conhecimento teórico sobre o funcionamento da CNN será beneficiado. Além disso, é bom ter algum conhecimento prévio do TensorFlow2 , mas não é necessário.

Rede Neural Convolucional

Ao longo dos anos, o CNN se popularizou como técnica para a classificação de imagens para visões computacionais e tem sido usada nos domínios da saúde. Isso indica que o CNN é um modelo de deep learning confiável para uma previsão automatizada de ponta a ponta. Ele essencialmente extrai recursos ‘úteis’ de uma entrada fornecida automaticamente, facilitando nosso trabalho.

Figura 2: Processo end to end de CNN

Um modelo que utiliza CNN consiste, em suas versões mais simples, em três camadas principais: Camada Convolucional, Camada de Pooling e Camada Totalmente Conectada.

  1. Camada Convolucional: Esta camada extrai recursos de alto nível dos dados de entrada e os repassa para a próxima camada na forma de mapas de recursos.
  2. Camada de Pooling: É usada para reduzir as dimensões dos dados aplicando camadas de agrupamento (Pooling). Essa camada recebe cada saída do mapa de recursos da camada convolucional e prepara um mapa de características condensadas.
  3. Camada Totalmente Conectada: Finalmente, a tarefa de classificação é feita pela camada totalmente conectada. As pontuações de probabilidade são calculadas para cada rótulo de classe por uma função de ativação popularmente chamada de função softmax.

Dataset

O dataset que está sendo usado aqui é o de classificação de dígitos MNIST. O Keras é uma API de deep learning escrita em Python e ele traz consigo o MNIST. Este conjunto de dados consiste em 60.000 imagens de treinamento e 10.000 imagens de teste, o que o torna ideal para quem precisa experimentar o reconhecimento de padrões, pois ele é executado em apenas um minuto.

Quando a API do Keras é chamada, quatro valores são retornados. São eles: 

x_train,

y_train, 

x_test, 

y_test . 

Não se preocupe, você será orientado(a) sobre isso.

Carregando o dataset

A linguagem usada aqui é Python. Vamos usar o Google Colab para escrever e executar o código. Você também pode escolher um Jupyter notebook. o Google Colab foi escolhido aqui por fornecer acesso fácil a notebooks a qualquer hora e em qualquer lugar. Também é possível conectar um notebook Colab a um repositório GitHub. Você pode aprender mais sobre o Google Colab aqui.

Além disso, o código usado neste tutorial está disponível neste repositório Github. Portanto, se você se sentir confuso em alguma fase, verifique esse repositório. Para manter este tutorial relevante para todos, explicaremos o código mais crítico.

  1. Crie e nomeie um notebook.
  2. Depois de carregar as bibliotecas necessárias, carregue o dataset MNIST conforme mostrado abaixo:
(X_train,y_train),(X_test,y_test)=keras.datasets.mnist.load_data()

Como discutimos anteriormente, este conjunto de dados retorna quatro valores e na mesma ordem mencionada acima: x_train, y_train, x_test e y_test , que são representações para datasets divididos em treinamento e teste.

Muito bem! Você acabou de carregar seu dataset e está pronto para passar para a próxima etapa, que é processar os dados.

Processando o dataset

Os dados devem ser processados e limpos para melhorar sua qualidade. Para que a CNN aprenda é preciso que o dataset não contenha nenhum valor nulo, que tenha todos os dados numéricos e que seja normalizado. Então, aqui vamos realizar algumas etapas para garantir que tudo esteja perfeitamente adequado para um modelo CNN aprender. Daqui em diante, até criarmos o modelo, trabalharemos apenas no dataset de treinamento. 

Se você escrever X_train[0], obterá a 0ª imagem com valores entre 0-255, representando a intensidade da cor (preto ao branco). A imagem é uma matriz bidimensional. É claro, não saberemos o que o dígito manuscrito X_train[0] representa, para saber isso escreva y_train[0] e você obterá 5 como saída. Isso significa que a 0ª imagem deste dataset de treinamento representa o número 5. 

Vamos normalizar este dataset de treinamento e de teste, colocando os valores entre 0 e 1 conforme mostrado abaixo:

X_train=X_train/255
X_test=X_test/255

 

Em seguida, precisamos redimensionar a matriz para se adequar a API do Keras. Ela espera que cada entrada tenha 3 dimensões: uma pra linha, uma para a coluna e uma para a cor. Normalmente, essa 3ª dimensão é usada quando trabalhamos com imagens coloridas e temos múltiplos canais de cor (ex: RGB). Porém, como trabalhamos com imagens monocromáticas, essa terceira dimensão terá apenas um elemento.

X_train=X_train.reshape(-1,28,28,1) #conjunto de treinamento
X_test=X_test.reshape(-1,28,28,1) #conjunto de teste

Agora que está tudo em ordem, é hora de criarmos uma rede neural convolucional.

Criação e treinamento de uma CNN

Vamos criar um modelo CNN usando a biblioteca TensorFlow. O modelo é criado da seguinte maneira:

convolutional_neural_network=models.Sequential([  
layers.Conv2D(filters=25,kernel_size=(3,3),activation='relu',input_shape=(28,28,1)),
layers.MaxPooling2D((2,2)),
layers.Conv2D(filters=64,kernel_size=(3,3),activation='relu'),
layers.MaxPooling2D((2,2)),
layers.Conv2D(filters=64,kernel_size=(3,3),activation='relu'),
layers.MaxPooling2D((2, 2)),
layers.Flatten(),
layers.Dense(64,activation='relu'),
layers.Dense(10,activation='softmax')]
)

 

Reserve algum tempo para permitir que todo o código seja absorvido. É importante que você entenda cada parte dele. No modelo CNN criado acima, há uma camada CNN de entrada, seguida por duas camadas CNN ocultas, uma camada densa oculta e, finalmente, uma camada densa de saída. Em termos mais simples, as funções de ativação são responsáveis ​​por tomar decisões de passar o que foi identificado adiante ou não. Em uma rede neural profunda como a CNN, existem muitos neurônios e, com base nas funções de ativação, os neurônios disparam e a rede avança. Se você não entende muito sobre as funções de ativação use ‘relu’, pois ele é mais popular devido sua versatilidade.

Uma vez que o modelo foi criado, é hora de compilá-lo e treiná- lo . Durante o processo de treino, o modelo percorrerá o dataset e aprenderá os padrões. Ele treinará quantas vezes for definido (as chamadas épocas). Em nosso exemplo, definimos 10 épocas. Durante o processo, o modelo da CNN vai aprender e também cometer erros. Para cada erro (previsões erradas) que o modelo comete, há uma penalidade (ou um custo) e isso é representado no valor da perda (loss) para cada época (veja o GIF abaixo). Resumindo, o modelo deve gerar o mínimo de perda e a maior precisão possível no final da última época.

 

Modelo de treinamento |  classificação de dígitos manuscritos CNN

GIF 1: Treinamento CNN e as precisões aprimoradas durante cada época

Fazendo previsões

Para avaliar o modelo CNN assim criado, você pode executar:

convolutional_neural_network.evaluate(X_test,y_test)

É hora de usar nosso conjunto de testes para ver o desempenho do modelo CNN.

y_predicted_by_model=convolutional_neural_network.predict(X_test)

O código acima usará o modelo convolutional_neural_network para fazer previsões para o conjunto de teste e armazená-lo no dataframe y_predicted_by_model. Para cada um dos 10 dígitos possíveis, uma pontuação de probabilidade será calculada. A classe com a pontuação de probabilidade mais alta é a previsão feita pelo modelo. Por exemplo, se você quiser ver qual é o dígito na primeira linha do conjunto de teste:

y_predicted_by_model[0]

A saída será mais ou menos assim:

array([3.4887790e-09,3.4696127e-06,7.7428967e-07,2.9782784e-08,6.3373392e-08,6.1983449e-08,7.4500317e-10,9.9999511e-01,4.2418694e-08,3.8616824e-07],dtype=float32)

Como é realmente difícil identificar o rótulo da classe de saída com a pontuação de probabilidade mais alta, vamos escrever outro código:

np.argmax(y_predicted[0])

E com isso, você obterá um dos dez dígitos como saída (0 a 9). Para saber a representação direta do dígito, aplique o resultado do argmax nas classes do modelo.

Em suma

Após aprender como um dataset é dividido em treinamento e teste, utilizando o MNIST para fazer previsões de dígitos manuscritos de 0 a 9, criamos um modelo CNN treinado no dataset de treinamento. Por fim, com o modelo treinado, as previsões são realizadas.

Incentivamos você a experimentar por conta própria a ajustar os hiperparâmetros do modelo na expectativa de saber se eles são capazes de alcançar precisões mais altas ou não. Se você quer aprender sempre mais, acompanhe esta aula de Redes Neurais Convolucionais. Ficamos felizes em colaborar com a sua aprendizagem!

Referências

  1. Equipe, K. (nd). Documentação Keras: conjunto de dados de classificação de dígitos MNIST. Keras. https://keras.io/api/datasets/mnist/.
  2. manav_m. (2021, 1º de maio). CNN para Aprendizado Profundo: Redes Neurais Convolucionais (CNN). Analytics Vidhya. https://www.analyticsvidhya.com/blog/2021/05/convolutional-neural-networks-cnn/.
  3. YouTube. (2020, 14 de outubro). Explicação simples da rede neural convolucional | Tutorial de aprendizado profundo 23 (Tensorflow e Python). YouTube. https://www.youtube.com/watch?v=zfiSAzpy9NM&list=PLeo1K3hjS3uvCeTYTeyfe0-rN5r8zn9rw&index=61. 

 

Artigo traduzido Analytics Vidhya : Classification of Handwritten Digits Using CNN.

Fonte de pesquisa: Deep Learning Book

 

Categorias
Deep Learning Inteligência Artificial Keras Python

5 Passos para criar seu 1º Projeto de Deep Learning com Python e Keras

Keras é uma biblioteca aberta de Deep Learning implementada utilizando TensorFlow para diversas linguagens/plataformas, como Python e R, como foco na sua facilidade para utilização. Ela permite modelar e treinar modelos de redes neurais com poucas linhas de código, como você verá no tutorial a seguir.

Nesse tutorial, vamos utilizar o Keras para criar um modelo capaz de classificar se membros de uma população indígena possuem ou não diabetes.

Preparações

Para seguir esse projeto, você precisará ter instalados:

  • Python 3;
  • Bibliotecas SciPy e Numpy;
  • Bibliotecas TensorFlow e Keras;
  • Jupyter Notebook;

Alternativamente, você pode realizar este tutorial na plataforma Google Colab, que já possui todas as dependências instaladas e prontas para que você execute o tutorial no seu navegador.

Após isso, basta criar um novo notebook com o título “projeto_deep_learning” (ou qualquer outro nome), e iniciar o tutorial.

 

1. Carregando os dados

Em uma célula, importe as seguintes bibliotecas Python: 

from numpy import loadtxt
import numpy as np
from keras.models import Sequential
from keras.layers import Dense

Na célula seguinte, carregue os dados da base Pima Indians Diabetes. Essa base possui inicialmente 9 colunas, sendo as 8 primeiras as entradas e a última o resultado esperado. Todas as entradas dessa base são numéricas, assim como as saídas, o que facilita a computação dos dados por modelos de Deep Learning.

 # carregue a base de dados
dataset = loadtxt('https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv', delimiter=',')

 

Em seguida, utilizando a funcionalidade de slice do Python, separe o conjunto de dados entre “Entradas” (X) e “Saídas” (y).

# separe os dados entre entradas (X) e saídas (y)
X = dataset[:,0:8]
y = dataset[:,8]

 

2. Criar o modelo utilizando Keras

Agora que nossos dados foram carregados e ajustados entre entradas e saídas, podemos definir nosso modelo utilizando a biblioteca Keras.

Modelos Keras são definidos como uma sequência de camadas. Nesse tutorial, vamos criar um modelo sequencial e adicionar uma camada de cada.

Primeiramente, precisamos garantir que a camada de entrada tem a quantidade correta de inputs de entrada. Isso pode ser especificado no Keras utilizando o argumento input_dim e o ajustando para 8, nosso número de entradas.

Para esse tutorial, vamos utilizar camadas completamente conectadas, que são definidas no Keras pela classe Dense. Esse projeto utilizará 3 camadas, as quais as duas primeiras utilizarão a função de ativação ReLU e a função Sigmoid na última. Podemos especificar o número de neurônios no primeiro argumento, e a função de ativação com o parâmetro activation.

# definir o modelo com keras
# inicializar o modelo sequencial
model = Sequential()
# inicializar a primeira camada, com 12 neurônios, 8 entradas utilizando a função ReLU
model.add(Dense(12, input_dim=8, activation='relu'))
# inicializar a segunda camada com 8 neurônios e a função ReLU
model.add(Dense(8, activation='relu'))
# inicializar a última camada (camada de saída) com um neurônio e a função Sigmoid
model.add(Dense(1, activation='sigmoid'))

 

3. Compilando o modelo

Com nosso modelo definido, precisamos compilá-lo. A compilação ocorre utilizando bibliotecas como Theano ou TensorFlow, onde a melhor forma de representar a rede para treinar e fazer predições utilizando o hardware disponível é selecionada.

Ao compilar, precisamos especificar algumas propriedades, como a função de perda, otimizador e a métrica que será utilizada para avaliar o modelo. Foge ao escopo do tutorial apresentar esses conceitos, mas vamos utilizar a função de perda de Entropia Cruzada Binária, o otimizador Adam (que utiliza o gradiente descendente) e acurácia como métrica.

# compile the keras model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

 

4. Treinando o modelo

Como nosso modelo definido e compilado, precisamos treiná-lo, ou seja, executar o modelo utilizando nossos dados. Para treinar o modelo, basta chamar a função fit() para o modelo.

O treinamento ocorre através de épocas, e cada época é dividida em lotes, onde uma época é uma passagem por todas as linhas do conjunto de testes, e um lote é composto de uma ou mais amostras (quantidade definida pelo usuário) consideradas pelo modelo antes que seja feita a atualização dos seus pesos.  Aqui, vamos executar 150 épocas com lotes de tamanho 10 (um número considerado pequeno). 

# treinar o modelo keras
model.fit(X, y, epochs=150, batch_size=10)

5. Avaliando o modelo

Agora que estamos com nosso modelo treinado, precisamos avaliá-lo. Essa avaliação vai dizer o quão bem o modelo foi construído utilizando o conjunto de dados de treinamento. Esse pequeno projeto foi construído para ser simples, mas você pode separar os dados entre dados de treinamento e de teste para avaliar o desempenho do modelo com novos dados.

Para avaliar como o modelo se comportou para os dados de treinamento, basta passar os mesmos dados de entrada e saída para a função evaluate() . Essa função retorna uma lista com a perda e a acurácia do modelo para o conjunto de dados.

# avaliando o modelo keras
_, accuracy = model.evaluate(X, y)
print('Acurácia: %.2f' % (accuracy*100))

Conclusão

Com esse tutorial, podemos acompanhar em 5 passos o ciclo de vida de um modelo de Deep Learning, da sua concepção até a sua avaliação. Você pode expandir o que foi feito neste tutorial para, por exemplo, ajustar o modelo (é possível obter uma acurácia maior do que a obtida?), salvar o modelo (para utilização em outros projetos), plotar a curva de aprendizado, entre outras ideias.

 

Para mais tutoriais, continue atento ao nosso Blog.

 

Este texto foi baseado no tutorial disponibilizado em: Your First Deep Learning Project in Python with Keras Step-By-Step

 

 

Categorias
Biblioteca Deep Learning Python

8 bibliotecas de Deep Learning mais usadas em Python

Se você se interessa por Deep Learning, dos neurônios mais simples aos mais complexos, mas não sabe qual é a melhor biblioteca para seu projeto, nós te damos uma força! Esta lista com 8 bibliotecas tem a finalidade de ajudar você na sua escolha, apresentando de maneira resumida e direta cada biblioteca. Vamos lá?!

 

1. Pytorch

O PyTorch é classificado como “Tensores e redes neurais dinâmicas em Python com forte aceleração de GPU”. Tensores são uma construção matemática usada pesadamente em física e engenharia. Um tensor de rank dois é um tipo especial de matriz; pegar o produto interno de um vetor com o tensor produz outro vetor com uma nova magnitude e uma nova direção. 

A aceleração de GPU é uma das mais modernas estruturas das Deep Neural Networks. Uma rede neural dinâmica é aquela que pode mudar de iteração para iteração, por exemplo, permitindo que um modelo PyTorch adicione e remova camadas ocultas durante o treinamento para melhorar sua precisão e generalidade. O PyTorch recria o grafo em tempo real em cada etapa de iteração. Em contraste, o TensorFlow, por padrão, cria um único grafo de fluxo de dados, otimiza o código do grafo para desempenho e depois treina o modelo.

Enquanto o  modo de execução ávido é uma opção relativamente nova no TensorFlow, é a única maneira de executar o PyTorch: chamadas de API são executadas quando invocadas, em vez de serem adicionadas a um grafo para serem executadas posteriormente.

O PyTorch integra bibliotecas de aceleração como Intel MKL e Nvidia cuDNN e NCCL (Nvidia Collective Communications Library) para maximizar a velocidade. Seus principais backend são gravados como bibliotecas independentes com uma API C99. Ao mesmo tempo, o PyTorch não é uma ligação do Python em um framework monolítico de C ++. A intenção é que ele seja profundamente integrado ao Python e permita o uso de outras bibliotecas Python.

 

2. Theano

Sem o Theano, não existiria nada perto da quantidade de bibliotecas de deep learning que temos hoje, especificamente em Python. Da mesma forma que sem o NumPy, não poderíamos ter SciPy, scikit-learn e scikit-image, o mesmo pode ser dito sobre Theano e abstrações de alto nível de aprendizagem profunda.

Basicamente, Theano é uma biblioteca Python usada para definir, otimizar e avaliar  expressões matemáticas envolvendo matrizes multidimensionais. Esta biblioteca consegue isso através de forte integração com NumPy e o uso transparente da GPU.

Embora você  possa construir redes de aprendizagem profunda em Theano, podemos pensar nesta biblioteca como blocos de construção para redes neurais, da mesma forma que o NumPy serve como os blocos de construção para a computação científica. Na verdade, a maioria das bibliotecas mencionadas nesta matéria envolve o Theano para torná-lo mais conveniente e acessível.

Embora não seja uma comparação perfeita, construir uma rede neural convolucional no Theano é como escrever uma máquina de vetores de suporte (SVM) em Python nativo com apenas uma pitada de NumPy.

 

3. Lasagne

Lasagne é uma leve e de fácil manipulação, usada para construir e treinar redes em Theano. Sua leveza não se destina a ser um invólucro pesado em torno de Theano como Keras é. Embora isso faça com que seu código seja mais detalhado, esta biblioteca o libera de quaisquer restrições, enquanto fornece blocos de construção modulares baseados em Theano.

Simplificando: Lasagne funciona como um meio-termo entre a programação de baixo nível de Theano e as abstrações de alto nível de Keras.

 

4. TensorFlow

Semelhante ao Theano, o TensorFlow é uma biblioteca de código aberto para computação numérica usando grafos de fluxo de dados, que é tudo o que uma rede neural realmente é. Originalmente desenvolvida pelos pesquisadores da equipe do Google Brain, na organização de pesquisa Machine Intelligence do Google, a biblioteca desde então é de código aberto e disponibilizada ao público.

Um benefício principal do TensorFlow (em comparação com Theano) é a  computação distribuída, especialmente entre várias GPUs, embora isso seja algo que está sendo trabalhado no Theano. É bom lembrar que desde sua 2ª versão o Tensor-Flow incorporou o Keras, trazendo uma API muito mais amigável.

 

5. Keras

Sem dúvidas, uma das bibliotecas Python de deep learning mais querida por programadores. Keras é uma biblioteca de rede neural modular que pode usar tanto Theano ou TensorFlow como um backend. A principal motivação por trás do Keras é que você deve ser capaz de experimentar rapidamente e ir da ideia ao resultado o  mais rápido possível.

Arquitetar redes em Keras parece fácil e natural. Inclui alguns dos algoritmos de última geração para otimizadores (Adam, RMSProp), normalização (BatchNorm) e camadas de ativação (PReLU, ELU, LeakyReLU).

Esta biblioteca também dá grande ênfase às Redes Neurais Convolucionais, o que é extremamente valioso do ponto de vista da visão computacional.

Mais especificamente, você pode construir facilmente redes baseadas em sequência (onde as entradas fluem linearmente pela rede) e redes baseadas em grafos (onde as entradas podem “pular” certas camadas, apenas para serem concatenadas posteriormente). Isso torna a implementação de arquiteturas de rede mais complexas, como GoogLeNet e SqueezeNet,  muito mais fácil.

 

6. mxnet

Esta biblioteca Python de Deep Learning possui o foco em redes de classificação de imagem de treinamento. Apesar de exigir um pouco mais de código para criar uma rede em mxnet, o que esta biblioteca oferece é um número incrível de ligações de linguagem (C ++, Python, R, JavaScript, etc.)

A biblioteca mxnet realmente brilha para computação distribuída, permitindo treinar sua rede em várias máquinas CPU / GPU e até mesmo em clusters AWS, Azure e YARN.

Lembre-se, é necessário um pouco mais de código para colocar um experimento em execução no mxnet (em comparação com Keras), mas se você deseja distribuir o treinamento em várias GPUs ou sistemas, o recomendável seria o mxnet.

 

7. Sklearn-theano

Há momentos em que você não precisa treinar uma Rede Neural Convolucional (RNC) de ponta a ponta. Em vez disso, você precisa tratar a RNC como um extrator de recursos. Isso é especialmente útil em situações em que você não tem dados suficientes para treinar uma RNC completa do zero. Em vez disso, basta passar suas imagens de entrada por uma arquitetura pré-treinada popular, como OverFeat, AlexNet, VGGNet ou GoogLeNet, e extrair recursos das camadas FC ou qualquer camada que você decidir usar.

Simplificando, isso é exatamente o que sklearn-theano permite que você faça. Você não pode treinar um modelo do zero com ele, mas é  fantástico para tratar redes como extratores de recursos.

 

8. Nolearn

Enquanto Keras envolve Theano e TensorFlow em uma API mais amigável, Nolearn faz o mesmo, apenas para Lasagne. Além disso, todo o código no Nolearn é compatível com o scikit-learn, o que é um grande bônus.

Uma dica é usar o Nolearn para implementação de Deep Belief Networks (DBNs).

—

Gostou de mais esta dica Insigth? Quais bibliotecas você incluiria na lista?

 

Fonte: Pyimagesearch e CIO.

 

Categorias
Deep Learning Dica de Leitura Inteligência Artificial

As superpotências de inteligência artificial sob o olhar de Kai-Fuu Lee

“Hoje, o Insight indica o livro “Inteligência Artificial” (AI Superpowers – China, Silicon Valley, and the New World Order), escrito por uma das maiores autoridade de IA, Kai-Fuu Lee.


Esse livro nos ajuda a entender as grandes transformações positivas que a inteligência artificial pode trazer e como as maiores potências do mundo, EUA e China, estão desenvolvendo essa ciência dentro de realidades e posições específicas.

 

As posições de liderança ocupadas por China e Estados Unidos em muitos momentos ganham o contorno de confronto. E isso se reflete nas palavras usadas pelo autor quando afirma que a grande quantidade de engenheiros de IA consistentes será tão importante quanto a qualidade de pesquisadores de elite, e “a China está treinando exatamente esse exército“.


Também é destacado que, apesar dos Estados Unidos serem pioneiros na IA, hoje a China já é um superpotência na área. Isso é resultado, afirma Lee, de aspectos específicos do país asiático, como “dados abundantes, empreendedores tenazes, cientistas de IA bem treinados e um ambiente político favorável”.


No entanto, como alertado em artigo do The Washington Post, “alguns leriam ‘dados abundantes’ como ‘vigilância` e ‘um ambiente de política favorável’ como ‘tomada de decisão de cima para baixo que não é impedida pela opinião pública.’”


Kai-Fuu Lee compartilha conosco uma reflexão sobre o processo desta corrida desenvolvimentista entre Estado Unidos e China e suas implicações. Uma das preocupações destacadas é que o domínio dessas duas potências gere desigualdade global também no campo de IA. Os dois países já são lideranças massivas no resto do mundo, e isso pode se aprofundar se esse poder tecnológico permanecer tão concentrado.


Além disso, o livro trata da antiga e a cada dia renovada preocupação sobre o papel que a IA ocupará no mundo. E isso significa pensar qual lugar nós ocuparemos num mundo tão automatizado por essas máquinas, muito mais adequadas que os seres humanos para certas tarefas, mas frutos da criatividade e inteligência humana. 

 

O autor*

Imagem: vídeo – Como a IA pode salvar nossa humanidade (TED)

 

 

 

 

 

 

 

 

 

 

 

Kai-Fu Lee tem uma perspectiva única na indústria de tecnologia global, tendo trabalhado extensivamente entre os Estados Unidos e a China pesquisando, desenvolvendo e investindo em inteligência artificial há mais de 30 anos. Ele é um dos maiores investidores em tecnologia da China, realizando um trabalho pioneiro no campo da IA e trabalhando com vários gigantes da tecnologia dos EUA.

 

Lee já foi presidente do Google China e ocupou cargos executivos na Microsoft, SGI e Apple, e fundou a Microsoft Research China. Mais tarde renomeado “Microsoft Research Asia”, este instituto treinou a maioria dos líderes de IA na China, incluindo chefes de IA da Baidu, Tencent, Alibaba, Lenovo, Huawei e Haier. Enquanto estava na Apple, Lee liderou projetos de IA em fala e linguagem natural que foram destaques na mídia americana.

 

Atualmente, Kai-Fuu Lee é o presidente e CEO da Sinovation Ventures, empresa líder de investimentos em tecnologia com foco no desenvolvimento de companhias chinesas de alta tecnologia.

 

*Informações retiradas do perfil de Kai-Fu Lee no site TED.

 

Categorias
Deep Learning Inteligência Artificial Machine Learning

O futuro da IA mostrado na série “The Age of A.I.”

Buscando alguma série para assistir neste fim de semana? Nós temos uma dica: “The Age of A.I.”, série documental produzida pelo YouTube Originals.

Apresentada pelo ator Robert Downey Junior, a série mostra o trabalho de alguns dos pesquisadores mais influentes no desenvolvimento do potencial da inteligência artificial. Em quatro episódios, vamos acompanhar a quais níveis a IA já chegou e o que se espera que sejamos capazes de produzir com ela no futuro, como o aperfeiçoamento da computação afetiva, onde máquinas aprendem a sentir e reagir de uma forma cada vez mais humana.

Categorias
Deep Learning Inteligência Artificial

Tudo que você precisa saber para trabalhar com Inteligência Artificial

O mercado para profissionais com bagagem em inteligência artificial não para de crescer. Em fevereiro, a ONU informou que os números de pedidos de patentes para inovações baseadas em inteligência artificial aumentaram exponencialmente nos últimos anos.

O estudo de inteligência artificial começou, ainda na década de 50 na Universidade de Carnegie Mellon, nos EUA. De lá pra cá muita coisa mudou. Na época, o objetivo dos pesquisadores pioneiros, Hebert Simon, Allen Newell e Jonh McCarthy era criar um “ser” que simulasse uma vida humana.

Hoje, a inteligência artificial sustenta a automação de muitos negócios, com software que aprende a tomar as melhores decisões analisando os dados gerados de decisões anteriores.

Na prática, a inteligência artificial já habita um amplo espectro de nossas rotinas. Seja com a recomendação de músicas no Spotify seja com o melhor caminho para você chegar ao trabalho através do Waze.

Mas para aqueles que desejam trabalhar na área, por onde começar? Afinal, o conhecimento em inteligência artificial é muito amplo e exigido em cargos que vão desde um Cientista de Dados até um Engenheiro Aeroespacial. Aqueles com habilidades para analisar, organizar e traduzir bits de informação digital em experiências humanas significativas, certamente vão encontrar na carreira de inteligência artificial uma oportunidade recompensadora.

Por esse motivo, a redação do IT Trends preparou um guia completo, com tudo que você precisa saber para trabalhar com Inteligência Artificial. Confira.

Carreiras em inteligência artificial

De acordo com o Computer Science Degree Hub, carreiras em inteligência artificial podem ser encontradas em diversos ambientes, como empresas públicas e privadas, organizações educacionais, artes, instalações de saúde, agências governamentais e militares, entre outros.

Em alguns desses ambientes, as vagas podem exigir alto nível de responsabilidade e segurança, principalmente quando se trata de dados, dependendo da sensibilidade das informações, empresas podem até exigir certificações em segurança.

Confira a lista de cargos com atuação em inteligência artificial:

  • Analistas e Desenvolvedores de softwares e sistemas;
  • Cientistas e Engenheiros da computação;
  • Cientistas e Engenheiros de Machine Learning;
  • Cientistas e Engenheiros de aplicações e plataformas;
  • Cientistas e Engenheiros de Integração de Hardware;
  • Arquiteto de Dados;
  • Especialistas em algoritmos;
  • Cientistas de pesquisa e consultores de engenharia;
  • Engenheiros mecânicos e técnicos de manutenção;
  • Engenheiros elétricos e de manufatura;
  • Técnicos cirúrgicos trabalhando com ferramentas robóticas;
  • Profissionais de saúde médicos que trabalham com membros artificiais, próteses, aparelhos auditivos e dispositivos de restauração da visão;
  • Eletricistas militares e de aviação que trabalham com simuladores de voo, drones e armamentos;
  • Designers gráficos, músicos digitais, produtores de entretenimento, fabricantes de têxteis e arquitetos;
  • Professores pós-secundários em escolas técnicas e comerciais, centros vocacionais e universidades;

Conhecimentos e habilidades exigidos

Uma carreira em inteligência artificial é caracterizada pelo contato muito próximo com a automação, robótica, programação, algoritmos e uso de softwares específicos, sendo assim necessário que o interessado tenha disposição para adotar esses conceitos no seu dia a dia. No entanto, para adotar esses conceitos na rotina é necessário conhecimentos básicos e fundamentais, como matemática, tecnologia, lógica e engenharia.

Trabalhar com inteligência artificial exige também características comportamentais, como pensamento analítico e capacidade de resolver problemas com soluções eficientes e sustentáveis.

Os profissionais de inteligência artificial devem ser capazes de traduzir informações altamente técnicas, de modo que outras pessoas e colegas possam entender. Isso requer habilidades de comunicação interpessoal além de eficiência em trabalhos em equipe.

É importante lembrar que cada cargo, empresa ou área de atuação dentro da inteligência artificial pode ter exigências de conhecimentos específicos para a vaga. Os interessados em uma carreia em inteligência artificial devem investigar quais são os conhecimentos necessários para cada vaga, individualmente.

Educação

Mesmo que a área de tecnologia seja aberta para profissionais sem diplomas de ensino tradicional, inteligência artificial é um conceito muito discutido na academia, sendo um diferencial, um curso superior, mesmo para cargos de entrada.

Para trabalhar com inteligência artificial é necessário conhecimentos básicos em informática, matemática e lógica de computadores, que é a fundação da maioria dos programas de inteligência artificial.

É interessante também, procurar se especializar com cursos específicos da área. Diversas instituições de ensino oferecem cursos de pós-graduação em inteligência artificial. A FIAP por exemplo, oferece o programa de MBA: Artificial Intelligence & Machine Learning onde os alunos estudam majoritariamente:

  • História da inteligência artificial
  • Tipos de aprendizagem e algoritmos: aprendizagem e algoritmos por reforço, aprendizagem e algoritmos não supervisionados e aprendizagem e algoritmos supervisionados.
  • Heurísticas e meta-heurísticas de busca.
  • Deep learning e reinforcement Learning.
  • Redes neurais, convolucionais, recorrentes e recursivas
  • Manipulação de dados com Python e R
  • Modelagem de dados e big data
  • Indexação de documentos, text mining, cluster e chatbot.
  • Visão computacional, manipulação e segmentação de imagens, realidade aumentada
  • Conceitos de robótica e smart devices
  • Empreendedorismo

Outro exemplo é o curso “Inteligência Artificial em saúde: o uso de machine learning em saúde”, que é oferecido de forma completamente gratuita pela Universidade de São Paulo (USP) e ministrado pelo professor e pesquisador Alexandre Chiavegatto.

A USP explica que o curso cobre tópicos como predição, linguagens de programação R e Python, redes neurais, deep learning, consequências do uso de machine learning na economia e sociedade, entre outros.

Sendo assim, os interessados em conseguir uma oportunidade em uma carreira de inteligência artificial devem se atentar a esses detalhes como o que estudar e quais tipos de empresas precisam de profissionais especializados em inteligência artificial para conseguir uma vaga.

Fonte:  Computerworld
Categorias
Deep Learning

Detecção de Objetos Usando Aprendizado Profundo: R-CNN, YOLO, SSD

Neste post, explicarei a detecção de objetos e vários algoritmos como Faster R-CNN, YOLO, SSD. Começaremos do nível dos iniciantes e avançaremos até o estado da arte na detecção de objetos, entendendo a intuição, a abordagem e as principais características de cada método.

O que é classificação de imagem?

A classificação da imagem obtém uma imagem e prevê o objeto em uma imagem.

O problema de identificar a localização de um objeto (dada a classe) em uma imagem é chamado de localização. No entanto, se a classe de objeto não for conhecida, precisamos não apenas determinar a localização, mas também prever a classe de cada objeto.

Prever a localização do objeto junto com a classe é chamado de detecção de objeto. Em vez de prever a classe de objeto a partir de uma imagem, agora precisamos prever a classe e também um retângulo (chamado caixa delimitadora) contendo esse objeto. São necessárias 4 variáveis ​​para identificar exclusivamente um retângulo. Portanto, para cada instância do objeto na imagem, preveremos as seguintes variáveis:

  • class_name,
  • bounding_box_top_left_x_coordinate,
  • bounding_box_top_left_y_coordinate,
  • bounding_box_width,
  • bounding_box_height

Este artigo explica as seguintes técnicas:

  • Object Detection using Hog Features
  • Region-based Convolutional Neural Networks(R-CNN)
  • Spatial Pyramid Pooling(SPP-net)
  • Fast R-CNN
  • Faster R-CNN and Regression-based Detectors
  • YOLO(You only Look Once)
  • Single Shot Detector(SSD)

O artigo completo está disponível aqui.

Fonte:  Data Science Central
Sair da versão mobile