ALGORITMO DE REGRESSÃO
Quando as pessoas começam a aprender sobre estudo de dados, geralmente começam com a retorno linear. Há uma boa razão para isso – é uma das maneiras mais úteis e diretas de entender porquê funciona a retorno. As abordagens mais comuns para retorno linear são chamadas de “Métodos dos Mínimos Quadrados” – eles funcionam encontrando padrões nos dados, minimizando as diferenças quadradas entre as previsões e os valores reais. O tipo mais essencial é Mínimos Quadrados Ordinários (OLS), que encontra a melhor maneira de traçar uma risco reta através dos seus pontos de dados.
Às vezes, porém, o OLS não é suficiente, mormente quando seus dados têm muitos recursos relacionados que podem tornar os resultados instáveis. É onde Retrocesso de cume entra. A retorno Ridge faz o mesmo trabalho que o OLS, mas adiciona um controle privativo que ajuda a evitar que o protótipo se torne muito sensível a qualquer recurso único.
Cá, examinaremos dois tipos principais de retorno de mínimos quadrados, explorando porquê esses algoritmos deslizam suavemente pelos pontos de dados e veremos suas diferenças na teoria.
Sua visita nos ajuda a continuar oferecendo o melhor para você! ns ia py nu nv nw pz ny nz oa qa oc od oe qb og oh oi gn bk">A retorno linear é um método estatístico que prevê valores numéricos usando uma equação linear. Ele modela o relacionamento entre uma variável dependente e uma ou mais variáveis independentes ajustando uma risco reta (ou projecto, em múltiplas dimensões) através dos pontos de dados. O protótipo calcula coeficientes para cada recurso, representando seu impacto no resultado. Para obter um resultado, você insere os valores dos recursos dos seus dados na equação linear para calcular o valor previsto.
Para ilustrar nossos conceitos, usaremos nosso conjunto de dados padrão que prevê o número de golfistas visitantes em um determinado dia. Oriente conjunto de dados inclui variáveis porquê previsão do tempo, temperatura, umidade e condições de vento.
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split# Create dataset
dataset_dict = {
'Outlook': ['sunny', 'sunny', 'overcast', 'rain', 'rain', 'rain', 'overcast', 'sunny', 'sunny', 'rain', 'sunny', 'overcast', 'overcast', 'rain', 'sunny', 'overcast', 'rain', 'sunny', 'sunny', 'rain', 'overcast', 'rain', 'sunny', 'overcast', 'sunny', 'overcast', 'rain', 'overcast'],
'Temp.': [85.0, 80.0, 83.0, 70.0, 68.0, 65.0, 64.0, 72.0, 69.0, 75.0, 75.0, 72.0, 81.0, 71.0, 81.0, 74.0, 76.0, 78.0, 82.0, 67.0, 85.0, 73.0, 88.0, 77.0, 79.0, 80.0, 66.0, 84.0],
'Humid.': [85.0, 90.0, 78.0, 96.0, 80.0, 70.0, 65.0, 95.0, 70.0, 80.0, 70.0, 90.0, 75.0, 80.0, 88.0, 92.0, 85.0, 75.0, 92.0, 90.0, 85.0, 88.0, 65.0, 70.0, 60.0, 95.0, 70.0, 78.0],
'Wind': [False, True, False, False, False, True, True, False, False, False, True, True, False, True, True, False, False, True, False, True, True, False, True, False, False, True, False, False],
'Num_Players': [52, 39, 43, 37, 28, 19, 43, 47, 56, 33, 49, 23, 42, 13, 33, 29, 25, 51, 41, 14, 34, 29, 49, 36, 57, 21, 23, 41]
}
df = pd.DataFrame(dataset_dict)
# One-hot encode 'Outlook' column
df = pd.get_dummies(df, columns=['Outlook'],prefix='',prefix_sep='')
# Convert 'Wind' column to binary
df['Wind'] = df['Wind'].astype(int)
# Split data into features and target, then into training and test sets
X, y = df.drop(columns='Num_Players'), df['Num_Players']
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.5, shuffle=False)
Embora não seja obrigatório, para usar efetivamente a retorno linear – incluindo a retorno de cume – podemos padronizar primeiro os recursos numéricos.
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.compose import ColumnTransformer# Create dataset
data = {
'Outlook': ['sunny', 'sunny', 'overcast', 'rain', 'rain', 'rain', 'overcast', 'sunny', 'sunny',
'rain', 'sunny', 'overcast', 'overcast', 'rain', 'sunny', 'overcast', 'rain', 'sunny',
'sunny', 'rain', 'overcast', 'rain', 'sunny', 'overcast', 'sunny', 'overcast', 'rain', 'overcast'],
'Temperature': [85, 80, 83, 70, 68, 65, 64, 72, 69, 75, 75, 72, 81, 71, 81, 74, 76, 78, 82,
67, 85, 73, 88, 77, 79, 80, 66, 84],
'Humidity': [85, 90, 78, 96, 80, 70, 65, 95, 70, 80, 70, 90, 75, 80, 88, 92, 85, 75, 92,
90, 85, 88, 65, 70, 60, 95, 70, 78],
'Wind': [False, True, False, False, False, True, True, False, False, False, True, True, False,
True, True, False, False, True, False, True, True, False, True, False, False, True, False, False],
'Num_Players': [52, 39, 43, 37, 28, 19, 43, 47, 56, 33, 49, 23, 42, 13, 33, 29, 25, 51, 41,
14, 34, 29, 49, 36, 57, 21, 23, 41]
}
# Process data
df = pd.get_dummies(pd.DataFrame(data), columns=['Outlook'])
df['Wind'] = df['Wind'].astype(int)
# Split data
X, y = df.drop(columns='Num_Players'), df['Num_Players']
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.5, shuffle=False)
# Scale numerical features
numerical_cols = ['Temperature', 'Humidity']
ct = ColumnTransformer([('scaler', StandardScaler(), numerical_cols)], remainder='passthrough')
# Transform data
X_train_scaled = pd.DataFrame(
ct.fit_transform(X_train),
columns=numerical_cols + [col for col in X_train.columns if col not in numerical_cols],
índice=X_train.índice
)
X_test_scaled = pd.DataFrame(
ct.transform(X_test),
columns=X_train_scaled.columns,
índice=X_test.índice
)
A retorno linear prevê números criando uma risco reta (ou hiperplano) a partir dos dados:
- O protótipo encontra a melhor risco fazendo com que as lacunas entre os valores reais e os valores previstos da risco sejam tão pequenas quanto provável. Isso é chamado de “mínimos quadrados”.
- Cada ingressão recebe um número (coeficiente/peso) que mostra o quanto ela altera a resposta final. Há também um número inicial (interceptação/viés) que é usado quando todas as entradas são zero.
- Para prever uma novidade resposta, o protótipo pega cada ingressão, multiplica-a pelo seu número, soma tudo isso e adiciona o número inicial. Isso lhe dá a resposta prevista.
Vamos estrear com os Mínimos Quadrados Ordinários (OLS) — a abordagem fundamental para a retorno linear. O objetivo do OLS é encontrar a reta mais adequada através de nossos pontos de dados. Fazemos isso medindo o quão “erradas” nossas previsões estão em conferência com os valores reais e, em seguida, encontrando a risco que torna esses erros tão pequenos quanto provável. Quando dizemos “erro”, queremos manifestar a intervalo vertical entre cada ponto e a nossa reta – por outras palavras, quão longe estão as nossas previsões da veras. Vamos ver primeiro o que aconteceu no caso 2D.
Em caso 2D
No caso 2D, podemos imaginar o algoritmo de retorno linear assim:
Cá está a explicação do processo supra:
1. Começamos com um conjunto de treinamento, onde cada risco possui:
· x : nosso recurso de ingressão (os números 1, 2, 3, 1, 2)
· sim : nossos valores intuito (0, 1, 1, 2, 3)
2. Podemos simbolizar esses pontos em um gráfico de dissipação e queremos encontrar uma risco sim = b₀ + b₁x que melhor se adapta a esses pontos
3. Para qualquer risco (qualquer b₀ e b₁), podemos medir o quão bom é:
· Calculando a intervalo vertical (d₁, d₂, d₃, d₄, d₅) de cada ponto até a risco
· Essas distâncias são |sim – (b₀ + b₁x)| para cada ponto
4. Nosso objetivo de otimização é encontrar b₀ e b₁ que minimizam a soma das distâncias quadradas: d₁² + d₂² + d₃² + d₄² + d₅². Na notação vetorial, isso é escrito porquê ||sim – Xβ||², onde X = [1 x] contém nossos dados de ingressão (com 1 para a interceptação) e b = [β₀ β₁]ᵀ contém nossos coeficientes.
5. A solução ótima tem forma fechada: b = (XᵀX)⁻¹XSim. Calculando isso obtemos b₀ = -0,196 (interceptação), b₁ = 0,761 (inclinação).
Essa notação vetorial torna a fórmula mais compacta e mostra que estamos realmente trabalhando com matrizes e vetores em vez de pontos individuais. Veremos mais detalhes do nosso operação a seguir no caso multidimensional.
Em caso multidimensional (📊 conjunto de dados)
Novamente, o objetivo do OLS é encontrar coeficientes (b) que minimizam as diferenças quadradas entre nossas previsões e os valores reais. Matematicamente, expressamos isso porquê minimizando ||sim – Xβ||², onde X é a nossa matriz de dados e sim contém nossos valores intuito.
O processo de treinamento segue estas etapas principais:
Lanço de treinamento
1. Prepare nossa matriz de dados X. Isso envolve aditar uma pilastra de uns para contabilizar o termo de polarização/interceptação (b₀).
2. Em vez de procurar iterativamente os melhores coeficientes, podemos calculá-los diretamente usando a equação normal:
b = (XᵀX)⁻¹Xᵀsim
onde:
· b é o vetor de coeficientes estimados,
· X é a matriz do conjunto de dados (incluindo uma pilastra para a interceptação),
· sim é o rótulo,
· Xᵀ representa a transposta da matriz X,
· ⁻¹ representa o inverso da matriz.
Vamos decompô-lo:
um. Nós multiplicamos Xᵀ (X transpor) por Xnos dando uma matriz quadrada
b. Calculamos o inverso desta matriz
c. Nós calculamos Xᵀsim
d. Nós multiplicamos (XᵀX)⁻¹ e Xᵀsim para obter nossos coeficientes
Lanço de teste
Logo que tivermos nossos coeficientes, fazer previsões é simples: simplesmente multiplicamos nosso novo ponto de dados por esses coeficientes para obter nossa previsão.
Na notação matricial, para um novo ponto de dados x*, a previsão sim* é calculado porquê
sim* = x*b = [1, x₁, x₂, …, xₚ] × [β₀, β₁, β₂, …, βₚ]ᵀ,
onde b₀ é a interceptação e b₁ através bₚ são os coeficientes para cada recurso.
Lanço de avaliação
Podemos fazer o mesmo processo para todos os pontos de dados. Para nosso conjunto de dados, cá está também o resultado final com o RMSE.
Agora, vamos considerar a retorno de Ridge, que se baseia no OLS, abordando algumas de suas limitações. O principal insight da retorno de Ridge é que às vezes a solução ideal de OLS envolve coeficientes muito grandeso que pode levar ao sobreajuste.
Ridge Regression adiciona um termo de penalidade (eu||b||²) para a função objetivo. Oriente termo desencoraja coeficientes grandes, adicionando seus valores quadrados ao que estamos minimizando. O objetivo completo passa a ser:
min ||sim – Xβ||² + λ||b||²
O eu O parâmetro (lambda) controla o quanto penalizamos coeficientes grandes. Quando eu = 0, obtemos MQO; porquê eu aumenta, os coeficientes diminuem para zero (mas nunca o alcançam).
Lanço de treinamento
- Assim porquê OLS, prepare nossa matriz de dados X. Isso envolve aditar uma pilastra de uns para contabilizar o termo de interceptação (b₀).
- O processo de treinamento para Ridge segue um padrão semelhante ao OLS, mas com uma modificação. A solução de forma fechada torna-se:
b = (XᵀX+λI)⁻¹Xᵀsim
onde:
· EU é a matriz identidade (com o primeiro elemento, correspondendo a b₀, às vezes definido porquê 0 para excluir a interceptação da regularização em algumas implementações),
· λ é o valor de regularização.
· S é o vetor de valores de variáveis dependentes observadas.
· Outros símbolos permanecem conforme definidos na seção OLS.
Sua visita nos ajuda a continuar oferecendo o melhor para você! od oe of og oh oi gn bk">Vamos decompô-lo:
um. Nós adicionamos eueu para XᵀX. O valor de eu pode ser qualquer número positivo (digamos 0,1).
b. Calculamos o inverso desta matriz. Os benefícios de aditar λI a XᵀX antes da inversão são:
· Torna a matriz invertível, mesmo que XᵀX não é (resolvendo um problema numérico chave com OLS)
· Reduz os coeficientes proporcionalmente para eu
c. Nós multiplicamos (XᵀX+ eu)⁻¹ e Xᵀsim para obter nossos coeficientes
Lanço de teste
O processo de previsão permanece o mesmo do OLS – multiplique os novos pontos de dados pelos coeficientes. A diferença reside nos próprios coeficientes, que são tipicamente menores e mais estáveis do que os seus homólogos MQO.
Lanço de avaliação
Podemos fazer o mesmo processo para todos os pontos de dados. Para nosso conjunto de dados, cá está também o resultado final com o RMSE.
Observações Finais: Escolhendo entre OLS e Ridge
A escolha entre OLS e Ridge geralmente depende dos seus dados:
- Use OLS quando tiver dados muito comportados com pouca multicolinearidade e amostras suficientes (em relação aos recursos)
- Use Ridge quando você tiver:
– Muitos recursos (em relação às amostras)
– Multicolinearidade em seus recursos
– Sinais de overfitting com OLS
Com Ridge, você precisará escolher eu. Comece com um pausa de valores (geralmente espaçados logaritmicamente) e escolha aquele que oferece o melhor desempenho de validação.
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.compose import ColumnTransformer
from sklearn.linear_model import LinearRegression
from sklearn.metrics import root_mean_squared_error
from sklearn.linear_model import Ridge# Create dataset
data = {
'Outlook': ['sunny', 'sunny', 'overcast', 'rain', 'rain', 'rain', 'overcast', 'sunny', 'sunny',
'rain', 'sunny', 'overcast', 'overcast', 'rain', 'sunny', 'overcast', 'rain', 'sunny',
'sunny', 'rain', 'overcast', 'rain', 'sunny', 'overcast', 'sunny', 'overcast', 'rain', 'overcast'],
'Temperature': [85, 80, 83, 70, 68, 65, 64, 72, 69, 75, 75, 72, 81, 71, 81, 74, 76, 78, 82,
67, 85, 73, 88, 77, 79, 80, 66, 84],
'Humidity': [85, 90, 78, 96, 80, 70, 65, 95, 70, 80, 70, 90, 75, 80, 88, 92, 85, 75, 92,
90, 85, 88, 65, 70, 60, 95, 70, 78],
'Wind': [False, True, False, False, False, True, True, False, False, False, True, True, False,
True, True, False, False, True, False, True, True, False, True, False, False, True, False, False],
'Num_Players': [52, 39, 43, 37, 28, 19, 43, 47, 56, 33, 49, 23, 42, 13, 33, 29, 25, 51, 41,
14, 34, 29, 49, 36, 57, 21, 23, 41]
}
# Process data
df = pd.get_dummies(pd.DataFrame(data), columns=['Outlook'], prefix='', prefix_sep='', dtype=int)
df['Wind'] = df['Wind'].astype(int)
df = df[['sunny','overcast','rain','Temperature','Humidity','Wind','Num_Players']]
# Split data
X, y = df.drop(columns='Num_Players'), df['Num_Players']
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.5, shuffle=False)
# Scale numerical features
numerical_cols = ['Temperature', 'Humidity']
ct = ColumnTransformer([('scaler', StandardScaler(), numerical_cols)], remainder='passthrough')
# Transform data
X_train_scaled = pd.DataFrame(
ct.fit_transform(X_train),
columns=numerical_cols + [col for col in X_train.columns if col not in numerical_cols],
índice=X_train.índice
)
X_test_scaled = pd.DataFrame(
ct.transform(X_test),
columns=X_train_scaled.columns,
índice=X_test.índice
)
# Initialize and train the model
#model = LinearRegression() # Option 1: OLS Regression
model = Ridge(alpha=0.1) # Option 2: Ridge Regression (alpha is the regularization strength, equivalent to λ)
# Fit the model
model.fit(X_train_scaled, y_train)
# Make predictions
y_pred = model.predict(X_test_scaled)
# Calculate and print RMSE
rmse = root_mean_squared_error(y_test, y_pred)
print(f"RMSE: {rmse:.4f}")
# Additional information about the model
print("nModel Coefficients:")
print(f"Intercept : {model.intercept_:.2f}")
for feature, coef in zip(X_train_scaled.columns, model.coef_):
print(f"{feature:13}: {coef:.2f}")
Tags:
Crédito: Manadeira Original
