A nova caça do OURO, que são os DADOS. Lapidando esse Ouro com PYTHON.

Então, era natal no final do ano 1989, em algum lugar no centro de pesquisa de CWI (Centrum Wiskunde & Informatica) na Holanda. Guido van Rossum, já viaja na maionese, em seus delírios em busca de uma linguagem prática e fácil, fácil? Nos delírios desse que escreve esse artigo: “não existe nada fácil, nas linguagens de programação, pois se não ligar o computador na energia e não possuir sinal de internet, o MUNDO para, e ninguém consegue descer.”

Voltando para Guido van Rossum; nascido em 1956, nos Países Baixos, matemático, formação que o levou a programação, voltando a falar sobre os seus delírios, que o levou pensar “fora da caixinha”, dos nós (PROGRAMADORES – DESENVOLVEDORES, etc), pensamos iguais, que leva a todos os momentos a criar misteriosa CAIXA PRETA (IA PRETIDIVA E IA GENERATIVA).

O sonho de Guido era empacotar em várias bibliotecas, em uma linguagem de Programação as ciências da matemática, estatística, etc. Em 1991, Guido laçou a linguagem de programação Python, Esse nome vem das fantasias e uma fuga das forças ocultas que são barreiras as quaisquer ser vivo, homenagem ao grupo de comédia britânico Monty Python.

Iremos ta o pontapé inicial, exemplificando o contexto destas Bibliotecas nas áreas criadas deste o surgimento do NUMERAIS.

NUMPY – Fundamental na matemática para gerir a ciência dos numerais, matrizes com gerenciamento de campos e linhas, em um avanço contínuo com o SciPy, SymPy, MetplotLib, Pandas, entre tantas.

Eis os BIG DATAS

Tudo se originam da coleta de DADOS

Python
 import numpy as Np
 
 # Criar um array de exemplo
 array = np.array([1, 2, 3, 4, 5])
 
 # Calcular a média
 media = np.mean(array)
 print(f"Média: {media}")
 
 # Calcular a mediana
 mediana = np.median(array)
 print(f"Mediana: {mediana}")
 
 # Calcular a variância
 variancia = np.var(array)
 print(f"Variância: {variancia}")
 
 # Calcular o desvio padrão
 desvio_padrao = np.std(array)
 print(f"Desvio Padrão: {desvio_padrao}")

Vamos abortar nesse Artigo, PYTHON COM DADOS, seguindo uma regressão temporal, por volta do ano de 1956, já se falava na teoria do PERCEPTRON, que ser origina da teoria de se aproximar da percepção humana a Máquinas, a partir de 1960, surgem as analises exploratórias, cunhada por John Tukey, que demonstra de forma simples os resultados a evolução dos Dados, pois que é uma ação, gera um Dado; esse Dado tem que ser lapidados, para gerar uma informação, que vai gerar um conhecimento.

No ano de 1974, surge o termo "ciência de dados", descrito por Peter Naur em seu livro "Concise Survey of Computer Methods".  Esta ciência engloba todas as outras através de pesquisas em seus DADOS gerados e certificados, Através de analise PRETIDIVAS E DESCRITIVAS, criação de modelos, implantações e monitoramento.

ANALISE PRETIDIVAS

A partir das pesquisas destes dados, com uso intenso da ciência das Estatísticas, e ensinar a máquina, a tão falada machine learning, prevendo resultados futuros, em uma regressão temporal destes dados dentre uma série históricas. Um ponto crucial é identificar e padronizar esses dados, dentre os padrões desta previsões para um futuro, parem o futuro quando se chega, se torna presente a passa em um milésimo de um segundo, e no prisma dos nossos olhares, ONDE ESTAR ESSE FUTURO?

           QUAL O PROBLEMA: Para acertar no alvo dos objetivos de um projeto com um ciclo de vida.

           Desenvolver formas de coleta de DADOS.

           Lapidar esses DADOS, como se fosse Ouro, literalmente.

           Transformar esses DADOS em informações.

           E finalmente, O CONHECIMENTO, para a solução do PROBLEMA.   

           Modelando esse Conhecimento

           Avaliando esse Modelo

           Implantando e Monitorando esse Modelo.

A análise de dados com Python

Python mergulhado em um labirinto de Dados, eis questão, ser ou não ser, chama o psicólogo. Com essa técnica para entrar em um labirinto de Dados, que conhecemos como Big Datas, com Dados estruturados, semi estruturados e não estruturados.

1. Instalação das Bibliotecas

Em primeiro lugar vamos entrar em uma grande biblioteca, como a Biblioteca Nacional, no centro da cidade do Rio de Janeiro, pegasse todos o livros de estatísticas, matemáticas e principalmente da Linguagem SQL, criada pela IBM em 1970, e como em um passe de mágica, engloba se tudo em uma só função, separadas em objetivos, sintaxe e parâmetros, vamos conhece essas bibliotecas:

Pandas: Uma manipulação simples e prática na análise de dados, otimizando a lendária linguagem SQL .

• NumPy: As funções matemáticas e os arrays, e seus atributos e valores, iniciando do ponto Zero .
• Matplotlib e Seaborn: A maquiagem da visualização de dados, de forma em gráficos, mas sem excesso no batom.
• Scikit-learn: Ensinar a máquina (machine learning) e mineração de dados.

Instalando essas bibliotecas (pip);

pip install pandas numpy matplotlib seaborn scikit-learn

2. Carga de Dados

Após a instalaçãos, seque entre passos com o Pandas:

python
import pandas as pd

df = pd.read_csv('seu_arquivo.csv')
print(df.head()) # Mostra as primeiras linhas do DataFrame
3. Lapidando o Ouro (Dados)
Dados brutos, sujos, com bugs, nulos e duplicados não valem um centavo. Sem Limpeza de dados com Pandas:
python
df.drop_duplicates(inplace=True) # Remove duplicados
df.dropna(inplace=True) # Remove valores nulos
df.fillna(0, inplace=True) # Substitui valores nulos por 0

Analisar os dados contribui para reconhecer padrões e tendências. Utilizamos as bibliotecas Matplotlib e Seaborn para a criação de gráficos:

python
import matplotlib.pyplot as plt
import seaborn as sns

# Gráfico de dispersão
sns.scatterplot(x='coluna_x', y='coluna_y', data=df)
plt.show()

# Histograma
plt.hist(df['coluna'])
plt.show()

Python disponibiliza instrumentos potentes para a modelagem de dados e o aprendizado de máquina. A biblioteca Scikit-learn é frequentemente utilizada para essa finalidade:

python
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

X = df[['feature1', 'feature2']]
y = df['target']

# Dividindo os dados em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Treinando o modelo
modelo = LinearRegression()
modelo.fit(X_train, y_train)

# Fazendo previsões
previsoes = modelo.predict(X_test)

Análise do Modelo de Avaliação

Finalmente, a performance do modelo é avaliada para assegurar que está operando adequadamente. Podemos empregar indicadores como o Erro Médio Absoluto (MAE) ou o Erro Médio Quadrado (MSE): 

python
from sklearn.metrics import mean_absolute_error, mean_squared_error

mae = mean_absolute_error(y_test, previsoes)
mse = mean_squared_error(y_test, previsoes)

print(f'MAE: {mae}')
print(f'MSE: {mse}')

Com estas fases, estará apto a executar análises de dados completas com Python.

A extração de dados com Python é crucial em diversos campos, desde a análise de dados até o aprendizado de máquina e o desenvolvimento web. Aqui está um manual completo de como usar Python para coletar dados de várias fontes. 

Implementação das Bibliotecas Requeridas

Inicialmente, será necessário instalar algumas bibliotecas que auxiliam na extração de dados:

• Pandas: Utilizados para manipulação e interpretação de dados.

• BeautifulSoup: Utilizado para extrair informações de HTML e XML.

• Solicitações: Para realizar solicitações HTTP.

• Selenium: Utilizado para automatizar a navegação na internet.

Essas bibliotecas podem ser instaladas através do pip: 

Lendo e extraindo os dados de arquivos CSV, Excel, JSON,.......

python
import pandas as pd

# Arquivo CSV
df_csv = pd.read_csv('dados.csv')

# Arquivo Excel
df_excel = pd.read_excel('dados.xlsx')

# Arquivo JSON
df_json = pd.read_json('dados.json')

A coleta de dados na internet, também chamada de web scraping, é frequente quando os dados estão disponíveis em páginas web. Segue um caso de uso com BeautifulSoup e Requests:

python
import requests
from bs4 import BeautifulSoup

url = 'https://exemplo.com'
response = requests.get(url)
soup = BeautifulSoup(response.content, 'html.parser')

# Encontrar todos os links na página
links = soup.find_all('a')
for link in links:
 print(link.get('href'))

Com formas dinâmicas que curtir e vibra com esse conteúdo via JavaScript, Selenium é a escolha certa:

python
from selenium import webdriver

driver = webdriver.Chrome()
driver.get('https://exemplo.com')

# Extraindo dados da página
elemento = driver.find_element_by_id('id_elemento')
print(elemento.text)

driver.quit()

"4. Coleta de dados de APIs

Frequentemente, as informações estão acessíveis em APIs (Interfaces de Programação de Aplicativos). Você pode solicitar essas APIs e obter os dados:

python 
Solicitações de importação 
endereço eletrônico = 'https://api.exemplo.com/dados' 
Resposta = requisições.obter(url) 
informações = resposta.json() 

for item na base de dados: 
imprimir(itens['campo']) 

Cinco. Retirada de Informações de Banco de Dados

Conectar a bases de dados e obter informações através de bibliotecas como SQLite3, SQLAlchemy ou PyMySQL: 

python
import sqlite3

conn = sqlite3.connect('dados.db')
cursor = conn.cursor()

# Executando uma consulta
cursor.execute('SELECT * FROM tabela')
resultados = cursor.fetchall()

for linha in resultados:
 print(linha)

conn.close()

Armazenamento de Dados

na extração e limpeza, você pode querer armazenar os dados em um formato, conforme a regra de negócio:
python
# Salvando em CSV
df.to_csv('dados_limpos.csv', index=False)

# Salvando em Excel
df.to_excel('dados_limpos.xlsx', index=False)

# Salvando em JSON
df.to_json('dados_limpos.json')

proveniente de diversas fontes, tais como redes sociais, sensores, transações bancárias e mais. Com sua ampla variedade de bibliotecas e facilidade de utilização, o Python é uma ferramenta eficaz para gerenciar Big Data. Aqui estão algumas formas de usar Python no ambiente de Big Data.

2. Bibliotecas Indispensáveis:

Algumas bibliotecas são essenciais para trabalhar com Big Data em Python:

• Pandas: Utilizados para manipulação e interpretação de dados.

• Tarefa: Facilita o manuseio de vastas quantidades de dados que não cabem na memória.

PySpark: Interface Python para o Apache Spark, utilizada para processamento em larga escala.

• Hadoop: Apesar de não ser uma biblioteca Python, trata-se de um ecossistema amplamente usado que pode ser incorporado ao Python através do Pydoop.

.:. Manipulação e Apagamento de Informações

Tratar de volumes extensos

import pandas as pd
import dask.dataframe as dd

# Usando Pandas
df = pd.read_csv('dados.csv')
df = df.dropna().drop_duplicates()

# Usando Dask para grandes conjuntos de dados
ddf = dd.read_csv('grandes_dados.csv')
ddf = ddf.dropna().drop_duplicates()

Exame e Tratamento de Dados

PySpark é um instrumento indispensável para a manipulação de grandes volumes de dados. Ele possibilita o processamento em paralelo e distribuído, fator essencial para o processamento de grandes volumes de dados: 

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName('BigData').getOrCreate()
df = spark.read.csv('grandes_dados.csv', header=True, inferSchema=True)

# Processamento de dados com PySpark
df = df.dropna().dropDuplicates()
df.show()

Aprendizado de Máquina com Big Data

Em relação ao aprendizado de máquina com grandes quantidades de dados, o PySpark MLlib é uma das ferramentas mais empregadas: 
from pyspark.ml.feature import VectorAssembler
from pyspark.ml.regression import LinearRegression

# Preparando os dados para o modelo
assembler = VectorAssembler(inputCols=['feature1', 'feature2'], outputCol='features')
df = assembler.transform(df)

# Aplicando o modelo de regressão linear
lr = LinearRegression(featuresCol='features', labelCol='label')
modelo = lr.fit(df)
predicoes = modelo.transform(df)

Exibição de Informações

Para visualizar grandes quantidades de dados, é necessário utilizar ferramentas como Matplotlib, Seaborn e Plotly, em conjunto com Dask e PySpark: 
import matplotlib.pyplot as plt

# Visualizando dados com Matplotlib
df_pd = df.toPandas()
plt.scatter(df_pd['feature1'], df_pd['feature2'])
plt.show()

No ambiente de Big Data.

Neste aprendizado de máquina (ML) é uma área da inteligência artificial, será? ou é a vida real, que possibilita aos sistemas evoluir a partir destas experiências, sem de serem claramente programados. Python é uma linguagem bastante utilizada em ML por sua simplicidade e pelo amplo ecossistema de bibliotecas que oferece. Aqui está um manual sobre como usar Python para aprendizado de máquina.

2. Bibliotecas Requeridas

Inicialmente, instale as bibliotecas essenciais para ML:

• NumPy: Utilizado para manipular arrays e realizar operações matemáticas.

• Pandas: Utilizados para manipulação e interpretação de dados.

• Scikit-learn: Conjunto de instrumentos para atividades de Machine Learning.

• Matplotlib e Seaborn: Utilizados para a apresentação de dados.

Implement numpy, pandas, scikit-learn, matplotlib.

.:. Transportar e Organizar

import seaborn as sns

import matplotlib.pyplot as plt

# Visualizar a distribuição dos dados

sns.pairplot(df)

plt.show()

# Estatísticas descritivas

print(df.describe())

4. Preparação dos Dados

Prepare os dados antes de treiná-los, incluindo limpeza, normalização e divisão em conjuntos de treino e teste:

python

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

# Dividir os dados em recursos e alvo

X = df.drop('alvo', axis=1)

y = df['alvo']

# Dividir em treino e teste

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Normalizar os dados

scaler = StandardScaler()

X_train = scaler.fit_transform(X_train)

X_test = scaler.transform(X_test)

5. Treinamento do Modelo

Escolha e treine um modelo. Scikit-learn oferece várias opções, como regressão linear, árvores de decisão e redes neurais:

python

from sklearn.linear_model import LinearRegression

# Treinamento do modelo

modelo = LinearRegression()

modelo.fit(X_train, y_train)

# Fazer previsões

previsoes = modelo.predict(X_test)

6. Avaliação do Modelo

Avalie a performance do modelo usando métricas como a precisão, o erro médio absoluto (MAE) e o erro quadrático médio (MSE):

python

from sklearn.metrics import mean_absolute_error, mean_squared_error

mae = mean_absolute_error(y_test, previsoes)

mse = mean_squared_error(y_test, previsoes)

print(f'MAE: {mae}')

print(f'MSE: {mse}')

7. Aprimoramento do Modelo

Baseado na avaliação, você pode ajustar o modelo para melhorar a performance, experimentando diferentes algoritmos, ajustando hiperparâmetros, ou utilizando técnicas como validação cruzada:

python

from sklearn.model_selection import GridSearchCV

# Definir a grade de parâmetros

param_grid = {'alpha': [0.1, 0.5, 1.0, 5.0]}

# Realizar a busca em grade

grid_search = GridSearchCV(LinearRegression(), param_grid, cv=5)

grid_search.fit(X_train, y_train)

# Melhor modelo

melhor_modelo = grid_search.best_estimator_

print(grid_search.best_params_)

Machine Learning com Python é poderoso devido à ampla gama de bibliotecas e ferramentas que facilitam o desenvolvimento e a implementação de modelos.