fbpx
Sigmoidal
  • Home
  • Cursos
  • Pós-Graduação
  • Blog
  • Sobre Mim
  • Contato
Sem Resultado
Ver Todos Resultados
  • English
  • Home
  • Cursos
  • Pós-Graduação
  • Blog
  • Sobre Mim
  • Contato
Sem Resultado
Ver Todos Resultados
Sigmoidal
Sem Resultado
Ver Todos Resultados

k-Nearest Neighbors (k-NN) para Classificação de Estrelas RR Lyrae

Carlos Melo por Carlos Melo
dezembro 29, 2023
em Aeroespacial, Data Science, Machine Learning, Python, Tutoriais
0
24
COMPARTILHAMENTOS
813
VIEWS
Publicar no LinkedInCompartilhar no FacebookCompartilhar no Whatsapp

Ao explorar conceitos avançados como redes neurais convolucionais, transformers e Inteligência Artificial (IA) Generativa, é natural questionar a relevância de métodos clássicos como o k-Nearest Neighbors (k-NN) em 2024.

Essa dúvida surge frequentemente, pois, seduzidos pela hype de tecnologias emergentes, muitos profissionais adotam uma “visão de túnel”, focando excessivamente em uma única técnica e negligenciando o valor das abordagens fundamentais que formaram a base para os avanços atuais. É como o ditado que diz:

“Quando tudo que você tem é um martelo, tudo parece um prego”.

Porém, o conhecimento em tecnologia não é apenas sobre teoria; é sobre ter um arsenal variado de ferramentas para abordar problemas diversificados. Idealmente, após uma análise detalhada do contexto empresarial, você definiria métricas e cenários para abordar a questão de maneira eficaz e eficiente.

Existem muitos casos em que a aplicação do k-NN pode ser a solução mais direta e prática. Então me acompanhe neste artigo para aprender como implementar essa técnica usando a biblioteca Scikit-Learn.

Clique aqui para baixar o código-fonte deste post

Como funciona o k-NN

O k-NN é reconhecido como um dos algoritmos de classificação mais intuitivos e simples em machine learning. Diferente de outros métodos que “aprendem” padrões em um conjunto de dados, o k-NN opera sob a premissa de que dados similares tendem a se agrupar no espaço de características.

Isso significa que o k-NN utiliza a distância entre vetores de features para realizar suas predições, dependendo diretamente dessa métrica para classificar novos pontos.

Considere pares (X_1, Y_1), (X_2, Y_2), \dots, (X_n, Y_n) em \mathbb{R}^d \times \{1, 2\}, onde X representa os atributos dos pontos de dados em um espaço d-dimensional, e Y é o rótulo da classe de X, indicando a qual das duas classes o ponto pertence.

k-Nearest Neighbors (kNN)

Cada X condicional a Y=r segue uma distribuição de probabilidade P_r para r=1, 2. Isso significa que, dado um rótulo de classe específico, a distribuição dos pontos de dados em X segue um padrão específico, descrito pela distribuição P_r.

Dada uma norma \|\cdot\| em \mathbb{R}^d e um ponto x \in \mathbb{R}^d, ordenamos os dados de treinamento tal que (X_{(1)}, Y_{(1)}), \dots, (X_{(n)}, Y_{(n)}) de forma que \|X_{(1)} - x\| \leq \dots \leq \|X_{(n)} - x\|.

Em outras palavras, reorganizamos os dados de treinamento com base na proximidade de cada ponto X_i ao ponto de consulta x, do mais próximo ao mais distante.

Intuição por trás do k-NN

Imagine que você queira classificar os ingredientes da sua despensa com base em duas features que você supõe, possam ser mensuradas pelo seu paladar perspicaz: doçura e crocância.

Cada ingrediente foi cuidadosamente provado e mensurado em uma escala arbitrária, e o resultado pode ser observado na imagem abaixo, retirada do livro Machine Learning with R (Brett Lantz, 2019).

Intuição por trás do k-Nearest Neighbors (k-NN)
Intuição por trás do k-Nearest Neighbors (k-NN). Fonte: Machine Learning with R (Brett Lantz, 2019).

As frutas, geralmente mais doces, agrupam-se na parte mais afastada da origem em relação ao eixo x, enquanto as verduras, menos doces e mais crocantes, e as proteínas, menos doces e menos crocantes, se agrupam em áreas distintas do gráfico. Este padrão visual nos fornece uma pista clara: a doçura e a crocância são bons indicadores para classificar um ingrediente disponíveis na nossa lista.

Agora, digamos que temos uma fruta desconhecida e queremos classificá-la usando k-NN. Começamos localizando a fruta no gráfico baseando-nos em sua doçura e crocância. Em seguida, selecionamos um número ‘k’ de pontos de dados mais próximos – neste caso, os ingredientes mais próximos no gráfico.

Se escolhermos, por exemplo, k=3, identificaremos os três ingredientes mais próximos da nossa fruta desconhecida no gráfico. Se dois deles forem ‘frutas’ e um for ‘vegetal’, então, pela regra da maioria, o k-NN classificará a fruta desconhecida como ‘fruta’. Esse processo é intuitivo e espelha a forma como muitas vezes fazemos escolhas baseadas em semelhanças óbvias.

Obviamente esse foi um exemplo didático e intuitivo. Mas para lidar com problemas reais, é essencial escolher um valor adequado para ‘k’, além de uma métrica de distância que reflita a natureza e dimensionalidade dos dados.

Métricas de Distância

As métricas de distância são fundamentais no algoritmo k-NN, pois definem como a “proximidade” entre os pontos de dados é calculada. Aqui estão algumas métricas mais comumente utilizadas:

Distância Euclidiana: A mais comum e intuitiva entre as métricas, usada para medir a distância linear entre dois pontos, sendo particularmente útil quando as imagens ou pontos de dados são representados em um espaço euclidiano, fornecendo uma medida direta da “linha reta” entre eles. Se tivermos dois pontos, P e Q em um espaço n-dimensional, a distância Euclidiana entre eles é dada por:

    \[ d(P, Q) = \sqrt{(p_1 - q_1)^2 + (p_2 - q_2)^2 + \cdots + (p_n - q_n)^2} \]

Distância Manhattan (city block): Também conhecida como norma L1, esta métrica mede a distância entre dois pontos se movendo apenas em linhas retas ao longo dos eixos (como um táxi se movendo em uma grade de ruas da cidade), sendo adequada para quando o caminho entre pontos é uma grade. Para os mesmos pontos P e Q acima, a distância Manhattan é calculada como:

    \[ d(P, Q) = |p_1 - q_1| + |p_2 - q_2| + \cdots + |p_n - q_n| \]

Outras métricas: Dependendo do tipo de dados e do problema, outras métricas de distância podem ser mais apropriadas, como a distância de Minkowski. Generalização das distâncias Euclidiana e Manhattan, é definida como (\sum{|p_i - q_i|^r})^{1/r}, onde r é um parâmetro que determina a natureza da distância.

Como escolher o k

A escolha de k no algoritmo k-NN pode variar significativamente dependendo do conjunto de dados. Não existe uma regra única, mas com base na experiência, aqui estão algumas diretrizes gerais:

  • Um k pequeno, como 3 ou 5, geralmente é uma boa escolha para evitar a influência de outliers e manter a decisão localizada próxima ao ponto de interrogação. No entanto, um valor muito baixo pode ser sensível a ruídos nos dados.
  • Um k maior oferece uma decisão mais “democrática”, considerando mais vizinhos, o que pode ser útil para conjuntos de dados com muita variação. Contudo, um valor muito grande pode suavizar demais as fronteiras de decisão, levando a classificações menos precisas.

Uma técnica comum é usar validação cruzada para experimentar diferentes valores de k e escolher aquele que oferece o melhor desempenho no conjunto de validação. Isso ajuda a encontrar um equilíbrio entre subajuste e sobreajuste. Acima de tudo, a escolha deve levar em conta os insights gerados durante a fase do business understanding.

Classificação com K-Nearest Neighbors (k-NN) usando Scikit-Learn

Agora que já passamos pela apresentação e conceituação do k-NN, vamos ver como podemos usar o scikit-learn para problemas de classificação em aprendizado supervisionado. Antes de irmos para um projeto mais prático, vamos primeiro usar a biblioteca numpy do Python para gerar valores aleatórios e ver como eles estão distribuídos.

# Importing the necessary libraries
import numpy as np
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt

# Generating a random dataset
np.random.seed(0)
X = np.random.rand(100, 2)  # 100 points in 2 dimensions
y = np.where(X[:, 0] + X[:, 1] > 1, 1, 0)  # Classification based on the sum of features

# Visualizing the data
plt.figure(figsize=(8, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='red', label='Class 0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='blue', label='Class 1')
plt.title('Generated Dataset')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend()
plt.show()

Os samples gerados foram distribuídos entre os labels Class 0 e Class 1. Agora, se quisermos identificar a fronteira de decisão, precisamos antes treinar o modelo. Para isso, defini o número de vizinhos mais próximos como k = 3, e depois de instanciar um objeto KNeighborsClassifier, basta executar o método knn.fit(X, y) com os dados sintéticos.

Importante lembrar que durante esse processo, o modelo k-NN não aprende uma função discriminativa como em outros métodos de aprendizado supervisionado; em vez disso, ele memoriza os exemplos de treinamento.

Posteriormente, ao fazer previsões, ele utiliza esses dados memorizados para encontrar os k vizinhos mais próximos de um novo ponto e realiza uma votação baseada nos rótulos desses vizinhos para determinar a classificação.

# Defining the number of neighbors
k = 3

# Creating the k-NN model
knn = KNeighborsClassifier(n_neighbors=k)

# Training the model with the generated data
knn.fit(X, y)

# Generating test points for decision boundary visualization
x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1
y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1
xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np.linspace(y_min, y_max, 100))
Z = knn.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# Visualizing the decision boundary
plt.figure(figsize=(8, 6))
plt.contourf(xx, yy, Z, alpha=0.4)
plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')
plt.title('k-NN Decision Boundary')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.show()

Neste exemplo básico, o objetivo foi apenas demonstrar a implementação e a aplicação do k-NN em um conjunto de dados sintéticos. Mas que tal aproveitar a inércia e usar a mesma técnica para classificar estrelas RR Lyrae?

Aplicando k-NN para Classificar Estrelas RR Lyrae

Nesta última parte do artigo, vamos usar o algoritmo k-NN para classificar estrelas variáveis RR Lyrae, um tipo distinto de estrelas pulsantes usadas como importantes marcadores astronômicos para medir a galáxia e a expansão do universo.

Filtros Fotométricos SDSS e Espectro Estelar, onde cada curva colorida representa um filtro (u, g, r, i, z). Fonte: Ivezić et al. (2019).

As RR Lyrae têm características periódicas bem definidas, que permitem que astrônomos as identifiquem e estudem suas propriedades em detalhes. O conjunto de dados que utilizaremos pode ser facilmente baixado através do pacote astroML.

Especificamente, a função fetch_rrlyrae_combined faz o trabalho de combinar dados fotométricos das estrelas RR Lyrae com cores padrões do Sloan Digital Sky Survey (SDSS), retornando a diferença entre as magnitudes medidas em cada um dos cinco filtros fotométricos:

  • X: Matriz de características, contendo as diferenças de cor (u-g, g-r, r-i, i-z) entre os 5 filtros para cada estrela. Portanto, a dimensionalidade de X é (n\_samples, 4), onde cada coluna representa uma das diferenças de cor calculadas.
  • y: Vetor de rótulos, onde 1 indica uma estrela RR Lyrae e 0 uma estrela de fundo.
# Importing the necessary libraries
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
from astroML.datasets import fetch_rrlyrae_combined
import numpy as np  # Adding this import for array operations

# Defining the directory where the data will be saved
DATA_HOME = './data'

# Loading the data
X, y = fetch_rrlyrae_combined(data_home=DATA_HOME)

# Initial exploration
print("Shape of X:", X.shape)
print("Shape of y:", y.shape)
print("Number of RR Lyrae stars:", np.sum(y == 1))
print("Number of background stars:", np.sum(y == 0))

# Statistical analysis
print("Basic statistics for each column of X (u-g, g-r, r-i, i-z):")
print("Mean:", np.mean(X, axis=0))
print("Median:", np.median(X, axis=0))
print("Standard deviation:", np.std(X, axis=0))
Shape of X: (93141, 4)
Shape of y: (93141,)
Number of RR Lyrae stars: 483
Number of background stars: 92658
Basic statistics for each column of X (u-g, g-r, r-i, i-z):
Mean: [0.9451376 0.3240073 0.12292135 0.0672943 ]
Median: [0.941 0.33600044 0.12800026 0.05599976]
Standard deviation: [0.10446888 0.06746367 0.04031635 0.05786987]

Após executar a célula acima, os dados serão baixados na pasta ./data. Vamos aproveitar esta oportunidade para dar uma rápida olhada em uma amostra do conjunto de dados e fazer uma comparação visual entre as duas classes.

# Selecting a sample for easier visualization
X_sample = X[-5000:]
y_sample = y[-5000:]

# Split stars from RR Lyrae based on the value of y
X_rrlyrae = X_sample[y_sample == 1]
X_background = X_sample[y_sample == 0]

# Creating an enhanced scatter plot of the data with a black background
plt.style.use('dark_background')
fig, ax = plt.subplots(figsize=(10, 8))

# Plotting background stars
ax.scatter(X_background[:, 0], X_background[:, 1], color='grey', s=20, label='Background', alpha=0.7)

# Plotting RR Lyrae stars
ax.scatter(X_rrlyrae[:, 0], X_rrlyrae[:, 1], color='yellow', s=20, label='RR Lyrae', alpha=0.7)

# Enhancing the plot with titles and labels
ax.set_title('Color-Color Diagram of Stars in the Universe', fontsize=18, color='white')
ax.set_xlabel('u-g', fontsize=14, color='white')
ax.set_ylabel('g-r', fontsize=14, color='white')

# Remove grid and borders
ax.grid(False)
for spine in ax.spines.values():
    spine.set_visible(False)

# Adding a legend with a white font color
ax.legend(title='Type of Stars', title_fontsize='13', fontsize='12', facecolor='black', edgecolor='white', labelcolor='white')

# Displaying the plot
plt.show()

O primeiro passo no código é dividir os dados em conjuntos de treinamento e teste usando a função train_test_split do módulo sklearn.model_selection. O parâmetro test_size está definido como 0.2, o que significa que 20% dos dados serão usados para teste e os 80% restantes para treinamento. O parâmetro random_state está definido como 42 para garantir que as divisões geradas sejam reproduzíveis.

Em seguida, o classificador KNN é inicializado com n_neighbors=5, dado que a quantidade de entradas é consideravelmente maior que no nosso primeiro exemplo do artigo. O classificador é então treinado usando o método fit, que recebe os dados de treinamento e os labels como argumentos.

Uma vez concluída a fase de treinamento, o classificador já pode ser testado usando o método predict(). Como você pode acompanhar, os dados de teste foram utilizados para avaliar o desempenho do classificador, juntamente com as funções classification_report, confusion_matrix e accuracy_score. Por fim, eu incluí dois gráficos para fazer uma comparação visual.

# Splitting the data into training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train the classifier
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)

# Test the classifier
y_pred = knn.predict(X_test)

# Evaluate the classifier
print("Classification Report:\n", classification_report(y_test, y_pred))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred))
print("Accuracy:", accuracy_score(y_test, y_pred))

# Plot the results
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.scatter(X_test[y_test == 0][:, 0], X_test[y_test == 0][:, 1], color='red', label='Background', s=10)
plt.scatter(X_test[y_test == 1][:, 0], X_test[y_test == 1][:, 1], color='blue', label='RR Lyrae', s=10)
plt.title('Real Test Data')
plt.xlabel('u-g')
plt.ylabel('g-r')
plt.legend()

plt.subplot(1, 2, 2)
plt.scatter(X_test[y_pred == 0][:, 0], X_test[y_pred == 0][:, 1], color='red', label='Background', s=10)
plt.scatter(X_test[y_pred == 1][:, 0], X_test[y_pred == 1][:, 1], color='blue', label='RR Lyrae', s=10)
plt.title('Predicted Test Data')
plt.xlabel('u-g')
plt.ylabel('g-r')
plt.legend()

plt.show()
Classification Report:
               precision    recall  f1-score   support

         0.0       1.00      1.00      1.00     18530
         1.0       0.67      0.61      0.63        99

    accuracy                           1.00     18629
   macro avg       0.83      0.80      0.82     18629
weighted avg       1.00      1.00      1.00     18629

Confusion Matrix:
 [[18500    30]
 [   39    60]]
Accuracy: 0.9962960974824199

A análise do resultado apresentado revela um desempenho satisfatório para um modelo simples de classificação, como o k-NN. O relatório indica que o modelo é altamente preciso em identificar a classe Background e também é eficaz em recuperar instâncias dessa classe.

Por outro lado, a classe RR Lyrae, alvo de maior interesse nosso, exibe um desempenho inferior, com uma precisão de 0.67 e recall de 0.61, indicando que o modelo tem uma precisão razoável, mas está perdendo algumas instâncias dessa classe.

A métrica F1-score, que combina precisão e recall, é de 0.63 para a classe 1.0. A acurácia geral é de 0.996, o que sugere que o modelo está fazendo previsões corretas na grande maioria das instâncias. A matriz de confusão também fornece informações detalhadas sobre os verdadeiros positivos, falsos positivos, verdadeiros negativos e falsos negativos.

Mas para os propósitos deste artigo, o modelo atende ao seu objetivo didático, demonstrando o quão rápido e simples o k-NN pode ser como uma ferramenta de classificação.

Conclusão

Neste artigo, você conheceu o modelo de classificação K-Nearest Neighbors (KNN) e aprendeu como implementá-lo para a tarefa de classificar estrelas RR Lyrae usando a biblioteca scikit-learn.

No mundo real, a escolha do algoritmo de classificação depende da natureza dos dados e dos objetivos do projeto. No entanto, o que temos visto atualmente são profissionais que buscam aprender na prática, ferramentas que estão na moda, e por vezes esquecem de investir tempo para reforçar o seu alicerce teórico.

E a verdade é que o KNN é apenas uma das muitas ferramentas disponíveis para os cientistas de dados, e que podem ser a melhor escolha em diversos tipos de situações.

Afinal, assim como você não utilizaria um míssil AIM-9X Sidewinder para eliminar uma barata (mesmo uma barata cascuda!), querer usar Deep Learning para todas as situações pode ser um sintoma de que você ainda desconhece as ferramentas clássicas e veteranas, já validadas em combate real.

Compartilhar2Compartilhar10Enviar
Post Anterior

Cervejas e Fraldas: A Correlação Impossível

Próximo Post

O que é a Computação Espacial

Carlos Melo

Carlos Melo

Engenheiro de Visão Computacional graduado em Ciências Aeronáuticas pela Academia da Força Aérea (AFA) e Mestre em Engenharia Aeroespacial pelo Instituto Tecnológico de Aeronáutica (ITA).

Relacionado Artigos

Curso de Pós-Graduação em Data Science
Data Science

Vale a pena fazer uma Pós-Graduação em Data Science?

por Carlos Melo
janeiro 20, 2025
Review do Livro “Mãos à obra: Aprendizado de Máquina com Scikit-Learn, Keras & TensorFlow”
Livros

Review do Livro “Mãos à obra: Aprendizado de Máquina com Scikit-Learn, Keras & TensorFlow”

janeiro 18, 2025
Carlos Melo e Sérgio Sacani – Ciência Sem Fim
Youtube

Carlos Melo e Sérgio Sacani – Ciência Sem Fim

por Carlos Melo
janeiro 16, 2025
Carlos Melo da Pós Graduação em Data Science do Sigmoidal
Aeroespacial

Oportunidades no Setor Espacial para Cientistas de Dados

por Carlos Melo
janeiro 15, 2025
Visão Computacional

Processamento de Nuvens de Pontos com Open3D e Python

por Carlos Melo
janeiro 2, 2025
Próximo Post
O que é a Computação Espacial

O que é a Computação Espacial

Deixe um comentário Cancelar resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Pós-Graduação em Data Science Pós-Graduação em Data Science Pós-Graduação em Data Science

Mais Populares

  • Introdução ao MediaPipe e Pose Estimation

    Introdução ao MediaPipe e Pose Estimation

    451 compartilhamentos
    Compartilhar 180 Tweet 113
  • Equalização de Histograma com OpenCV e Python

    112 compartilhamentos
    Compartilhar 45 Tweet 28
  • ORB-SLAM 3: Tutorial Completo para Mapeamento 3D e Localização em Tempo Real

    385 compartilhamentos
    Compartilhar 154 Tweet 96
  • Geometria da Formação de Imagens: Matrizes, Transformações e Sistemas de Coordenadas

    368 compartilhamentos
    Compartilhar 147 Tweet 92
  • Redes Neurais Convolucionais com Python

    92 compartilhamentos
    Compartilhar 37 Tweet 23
  • Em Alta
  • Comentários
  • Mais Recente
Como Tratar Dados Ausentes com Pandas

Como Tratar Dados Ausentes com Pandas

agosto 13, 2019
Como usar o DALL-E 2 para gerar imagens a partir de textos

Como usar o DALL-E 2 para gerar imagens a partir de textos

dezembro 25, 2022
Introdução ao MediaPipe e Pose Estimation

Introdução ao MediaPipe e Pose Estimation

julho 15, 2023

ORB-SLAM 3: Tutorial Completo para Mapeamento 3D e Localização em Tempo Real

abril 10, 2023
Como Analisar Ações da Bolsa com Python

Como Analisar Ações da Bolsa com Python

15
Setembro Amarelo: Análise do Suicídio no Brasil, com Data Science

Setembro Amarelo: Análise do Suicídio no Brasil, com Data Science

13
Como Aprender Data Science?

Como Aprender Data Science?

9
Qual o Cenário de Data Science no Brasil hoje?

Qual o Cenário de Data Science no Brasil hoje?

8
DeepSeek vazamento de dados de usuários

DeepSeek: Vazamento de dados expõe dados de usuários

fevereiro 1, 2025
DeepSeek R1 vs OpenAI o1 – Qual é o Melhor Modelo de IA

DeepSeek R1 vs OpenAI o1 – Qual é o Melhor Modelo de IA?

janeiro 25, 2025
Trump Anuncia Investimento de US$ 500 Bilhões em Infraestrutura de IA

Trump Anuncia Investimento de US$ 500 Bilhões em Infraestrutura de IA

janeiro 22, 2025
Trump revoga decreto de Biden sobre regulação de Inteligência Artificial

Trump revoga decreto de Biden sobre regulação de Inteligência Artificial

janeiro 21, 2025

Seguir

  • 🇺🇸 Green Card por Habilidade Extraordinária em Data Science e Machine Learning

Após nossa mudança para os EUA, muitas pessoas me perguntaram como consegui o Green Card tão rapidamente. Por isso, decidi compartilhar um pouco dessa jornada.

O EB-1A é um dos vistos mais seletivos para imigração, sendo conhecido como “The Einstein Visa”, já que o próprio Albert Einstein obteve sua residência permanente através desse processo em 1933.

Apesar do apelido ser um exagero moderno, é fato que esse é um dos vistos mais difíceis de conquistar. Seus critérios rigorosos permitem a obtenção do Green Card sem a necessidade de uma oferta de emprego.

Para isso, o aplicante precisa comprovar, por meio de evidências, que está entre os poucos profissionais de sua área que alcançaram e se mantêm no topo, demonstrando um histórico sólido de conquistas e reconhecimento.

O EB-1A valoriza não apenas um único feito, mas uma trajetória consistente de excelência e liderança, destacando o conjunto de realizações ao longo da carreira.

No meu caso específico, após escrever uma petição com mais de 1.300 páginas contendo todas as evidências necessárias, tive minha solicitação aprovada pelo USCIS, órgão responsável pela imigração nos Estados Unidos.

Fui reconhecido como um indivíduo com habilidade extraordinária em Data Science e Machine Learning, capaz de contribuir em áreas de importância nacional, trazendo benefícios substanciais para os EUA.

Para quem sempre me perguntou sobre o processo de imigração e como funciona o EB-1A, espero que esse resumo ajude a esclarecer um pouco mais. Se tiver dúvidas, estou à disposição para compartilhar mais sobre essa experiência! #machinelearning #datascience
  • 🚀Domine a tecnologia que está revolucionando o mundo.

A Pós-Graduação em Visão Computacional & Deep Learning prepara você para atuar nos campos mais avançados da Inteligência Artificial - de carros autônomos a robôs industriais e drones.

🧠 CARGA HORÁRIA: 400h
💻 MODALIDADE: EAD
📅 INÍCIO DAS AULAS: 29 de maio

Garanta sua vaga agora e impulsione sua carreira com uma formação prática, focada no mercado de trabalho.

Matricule-se já!

#deeplearning #machinelearning #visãocomputacional
  • Green Card aprovado! 🥳 Despedida do Brasil e rumo à nova vida nos 🇺🇸 com a família!
  • Haverá sinais… aprovado na petição do visto EB1A, visto reservado para pessoas com habilidades extraordinárias!

Texas, we are coming! 🤠
  • O que EU TENHO EM COMUM COM O TOM CRUISE??

Clama, não tem nenhuma “semana” aberta. Mas como@é quinta-feira (dia de TBT), olha o que eu resgatei!

Diretamente do TÚNEL DO TEMPO: Carlos Melo &Tom Cruise!
  • Bate e Volta DA ITÁLIA PARA A SUÍÇA 🇨🇭🇮🇹

Aproveitei o dia de folga após o Congresso Internacional de Astronáutica (IAC 2024) e fiz uma viagem “bate e volta” para a belíssima cidade de Lugano, Suíça.

Assista ao vlog e escreve nos comentários se essa não é a cidade mais linda que você já viu!

🔗 LINK NOS STORIES
  • Um paraíso de águas transparentes, e que fica no sul da Suíça!🇨🇭 

Conheça o Lago de Lugano, cercado pelos Alpes Suíços. 

#suiça #lugano #switzerland #datascience
  • Sim, você PRECISA de uma PÓS-GRADUAÇÃO em DATA SCIENCE.
  • 🇨🇭Deixei minha bagagem em um locker no aeroporto de Milão, e vim aproveitar esta última semana nos Alpes suíços!
  • Assista à cobertura completa no YT! Link nos stories 🚀
  • Traje espacial feito pela @axiom.space em parceria com a @prada 

Esse traje será usados pelos astronautas na lua.
para acompanhar as novidades do maior evento sobre espaço do mundo, veja os Stories!

#space #nasa #astronaut #rocket
  • INTERNATIONAL ASTRONAUTICAL CONGRESS - 🇮🇹IAC 2024🇮🇹

Veja a cobertura completa do evento nos DESTAQUES do meu perfil.

Esse é o maior evento de ESPAÇO do mundo! Eu e a @bnp.space estamos representando o Brasil nele 🇧🇷

#iac #space #nasa #spacex
  • 🚀 @bnp.space is building the Next Generation of Sustainable Rocket Fuel.

Join us in transforming the Aerospace Sector with technological and sustainable innovations.
  • 🚀👨‍🚀 Machine Learning para Aplicações Espaciais

Participei do maior congresso de Astronáutica do mundo, e trouxe as novidades e oportunidade da área de dados e Machine Learning para você!

#iac #nasa #spacex
  • 🚀👨‍🚀ACOMPANHE NOS STORIES

Congresso Internacional de Astronáutica (IAC 2024), Milão 🇮🇹
  • Projeto Aeroespacial do final de semana!👨‍🚀
Instagram Youtube LinkedIn Twitter
Sigmoidal

O melhor conteúdo técnico de Data Science, com projetos práticos e exemplos do mundo real.

Seguir no Instagram

Categorias

  • Aeroespacial
  • Artigos
  • Blog
  • Carreira
  • Cursos
  • Data Science
  • Deep Learning
  • Destaques
  • Entrevistas
  • IA Generativa
  • Livros
  • Machine Learning
  • Notícias
  • Python
  • Teoria
  • Tutoriais
  • Visão Computacional
  • Youtube

Navegar por Tags

camera calibration carreira chatgpt cientista de dados cnn computer vision Cursos dados desbalanceados data science data science na prática decision tree deep learning gpt-3 histograma IA generativa image formation inteligência artificial jupyter kaggle keras machine learning matplotlib mnist nft openai opencv overfitting pandas profissão python redes neurais redes neurais convolucionais regressão linear regressão logística salário scikit-learn seaborn sklearn tensorflow titanic tutorial visão computacional vídeo youtube árvore de decisão

© 2024 Sigmoidal - Aprenda Data Science, Visão Computacional e Python na prática.

Welcome Back!

Login to your account below

Forgotten Password?

Retrieve your password

Please enter your username or email address to reset your password.

Log In

Add New Playlist

Sem Resultado
Ver Todos Resultados
  • Home
  • Cursos
  • Pós-Graduação
  • Blog
  • Sobre Mim
  • Contato
  • English

© 2024 Sigmoidal - Aprenda Data Science, Visão Computacional e Python na prática.