Skip to content
The Chat Archive
qwq-32b LMArena Human Preference 140K

Aby przeprowadzić pełną analizę i przewidywanie danych liczbowych, konieczne byłoby…

  1. User

    Aby przeprowadzić pełną analizę i przewidywanie danych liczbowych, konieczne byłoby zastosowanie odpowiednich narzędzi analitycznych i programistycznych, takich jak Python z bibliotekami NumPy, Pandas, Scikit-learn. prosze o pomoc w opracowaniu konkretnych kodów lub algorytmów.

  2. Assistant

    Oto kompletny przewodnik wraz z kodem Pythona do analizy i predykcji danych liczbowych, wykorzystując biblioteki NumPy, Pandas, Scikit-learn, Matplotlib i Seaborn. Przykład będzie oparty na zbiorze danych "Boston Housing" (klasyczny zbiór do regresji).


    1. Importowanie bibliotek

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    import seaborn as sns
    from sklearn.datasets import load_boston
    from sklearn.model_selection import train_test_split, GridSearchCV
    from sklearn.preprocessing import StandardScaler
    from sklearn.feature_selection import SelectKBest, f_regression
    from sklearn.linear_model import LinearRegression
    from sklearn.ensemble import RandomForestRegressor
    from sklearn.svm import SVR
    from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
    

    2. Wczytanie i wstępna analiza danych

    # Wczytanie zbioru Boston Housing
    boston = load_boston()
    df = pd.DataFrame(boston.data, columns=boston.feature_names)
    df['PRICE'] = boston.target  # Czynnik docelowy: cena domu
    
    # Wyświetlenie pierwszych 5 wierszy
    print(df.head())
    
    # Podstawowe statystyki
    print(df.describe())
    
    # Sprawdzenie brakujących wartości
    print(df.isnull().sum())
    

    3. Wizualizacja danych

    # Macierz korelacji
    plt.figure(figsize=(12, 8))
    sns.heatmap(df.corr(), annot=True, cmap='coolwarm')
    plt.title('Macierz korelacji')
    plt.show()
    
    # Wykres rozrzutu dla kluczowych zmiennych
    plt.figure(figsize=(10, 6))
    sns.scatterplot(x='RM', y='PRICE', data=df)
    plt.title('Liczba pokoi vs Cena')
    plt.xlabel('Średnia liczba pokoi na mieszkanie')
    plt.ylabel('Cena w tys. $')
    plt.show()
    

    4. Przygotowanie danych (Preprocessing)

    # Wybór cech i zmiennej docelowej
    X = df.drop('PRICE', axis=1)
    y = df['PRICE']
    
    # Standaryzacja cech (w przypadku algorytmów wrażliwych na skalę)
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)
    
    # Selekcja kluczowych cech (np. 5 najlepszych)
    selector = SelectKBest(score_func=f_regression, k=5)
    X_selected = selector.fit_transform(X_scaled, y)
    selected_features = X.columns[selector.get_support()]
    
    print("Wybrane cechy:", selected_features.tolist())
    

    5. Podział na zbiory treningowy i testowy

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

    6. Trenowanie modeli regresji

    Model 1: Regresja liniowa

    model_lr = LinearRegression()
    model_lr.fit(X_train, y_train)
    y_pred_lr = model_lr.predict(X_test)
    

    Model 2: Random Forest

    model_rf = RandomForestRegressor(n_estimators=100, random_state=42)
    model_rf.fit(X_train, y_train)
    y_pred_rf = model_rf.predict(X_test)
    

    Model 3: SVM (Support Vector Machine)

    model_svr = SVR(kernel='rbf', C=100, gamma=0.1, epsilon=0.1)
    model_svr.fit(X_train, y_train)
    y_pred_svr = model_svr.predict(X_test)
    

    7. Ocena modeli

    def evaluate_model(y_true, y_pred, name):
        print(f"\nWyniki dla {name}:")
        print("RMSE:", np.sqrt(mean_squared_error(y_true, y_pred)))
        print("MAE:", mean_absolute_error(y_true, y_pred))
        print("R²:", r2_score(y_true, y_pred))
    
    evaluate_model(y_test, y_pred_lr, "Regresja liniowa")
    evaluate_model(y_test, y_pred_rf, "Random Forest")
    evaluate_model(y_test, y_pred_svr, "SVM")
    

    8. Wizualizacja wyników

    # Wykres残差
    plt.figure(figsize=(10, 6))
    sns.residplot(y_test, y_pred_rf, lowess=True, line_kws={'color': 'red'})
    plt.title('Residual Plot dla Random Forest')
    plt.xlabel('Wartości rzeczywiste')
    plt.ylabel('Residuals')
    plt.show()
    
    # Ważność cech w Random Forest
    feature_imp = pd.Series(model_rf.feature_importances_, index=selected_features).sort_values(ascending=False)
    plt.figure(figsize=(10, 6))
    sns.barplot(x=feature_imp, y=feature_imp.index)
    plt.title('Ważność cech')
    plt.xlabel('Waga')
    plt.ylabel('Cecha')
    plt.show()
    

    9. Optymalizacja hiperparametrów (Grid Search)

    param_grid = {
        'n_estimators': [50, 100, 200],
        'max_depth': [None, 10, 20],
        'min_samples_split': [2, 5, 10]
    }
    
    grid_search = GridSearchCV(
        estimator=RandomForestRegressor(),
        param_grid=param_grid,
        cv=5,
        n_jobs=-1,
        verbose=2
    )
    
    grid_search.fit(X_train, y_train)
    best_model = grid_search.best_estimator_
    y_pred_best = best_model.predict(X_test)
    evaluate_model(y_test, y_pred_best, "Random Forest (Optymalizowany)")
    

    10. Zapis i wczytywanie modelu

    from joblib import dump, load
    
    # Zapis modelu
    dump(best_model, 'best_model.joblib')
    
    # Wczytanie modelu
    loaded_model = load('best_model.joblib')
    y_pred_loaded = loaded_model.predict(X_test)
    

    Wyjaśnienie kroków:

    1. Analiza Eksploracyjna:

      • Macierz korelacji pokazuje zależności między cechami.
      • Wykresy rozrzutu ułatwiają zrozumienie relacji zmiennych.
    2. Preprocessing:

      • Standaryzacja cech (np. StandardScaler) jest konieczna dla algorytmów jak SVM lub Regresja liniowa.
      • Selekcja cech (SelectKBest) redukuje wymiarowość, eliminując zbędne zmienne.
    3. Modele:

      • Regresja liniowa – prosta metoda do porównania z bardziej skomplikowanymi modelami.
      • Random Forest – silny model do regresji, obsługujący nieliniowe relacje.
      • SVM – efektywny w przypadku małych zbiorów danych, ale wymaga dobrej regularyzacji.
    4. Ocena:

      • RMSE/MAE – miary błędu, które pokazują dokładność predykcji.
      • R² – współczynnik determinacji, który wskazuje, jaki procent zmienności zmiennej docelowej wyjaśnia model.
    5. Optymalizacja:

      • Grid Search automatycznie wybiera najlepsze hiperparametry, co zwiększa dokładność modelu.

    Uwagi:

    • Zastąp load_boston() własnym zbiorem danych (np. zaimportuj z pliku CSV).
    • Dla kategorialnych cech użyj OneHotEncoder lub LabelEncoder.
    • Przykłady hiperparametrów w GridSearchCV można dostosować do konkretnych potrzeb.
    • Dodaj obsługę brakujących danych, jeśli potrzebne (np. SimpleImputer).

    Jeśli potrzebujesz więcej szczegółów lub innych algorytmów (np. XGBoost, sieci neuronowe), daj znać!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.