Problemy pomiarowe — 1

Tym artykułem rozpocznę nową mini serię dotyczącą problemów pomiarowych, które zajmują ważne miejsce w dziedzinie data science.

Ta seria będzie się składać z trzech głównych tytułów:

• Produkty oceniające
• Sortowanie produktów
• Sortowanie recenzji

Załóżmy, że decydujemy się na zakup produktu. Kiedy szukamy dowolnego produktu, który chcemy kupić w Internecie, widzimy, że istnieje wiele opcji.

Co zatem pomoże nam w podjęciu decyzji w takiej sytuacji?

Dowód społeczny

Społeczny dowód słuszności to akt kopiowania zachowań innych ludzi. To znaczy, kiedy decydujemy się na zakup produktu, patrzymy na komentarze i oceny innych osób, zastanawiając się, który wybrać, a to wpływa na nas przy zakupie produktu.

Oczywiście nie potrafię wyjaśnić tej definicji psychologicznie, ale myślę, że mogę powiedzieć, że zasadniczo uzyskanie tego, co wszyscy aprobują, powoduje, że czujemy się w strefie komfortu.

Termin Social Proof został zaproponowany w jego książce wydanej w 1984 roku przez Roberta Cialdiniego.

To prowadzi nas do innej definicji:

Mądrość tłumów

Poczucie, że skoro wszyscy kupili ten produkt wśród tylu produktów, to ja też powinienem go kupić. Bo czemu nie i nie chce mi się za dużo myśleć!

Problemy pomiarowe

W tym przypadku rynek musi posortować produkty w najbardziej dokładny i obiektywny sposób dla klientów.

Podczas wykonywania tej czynności napotkano pewne problemy pomiarowe.

W pierwszej części serii zajmiemy się kwestią oceniania produktów.

• Produkty oceniające

*Przeciętny

*Średnia ważona w czasie

*Średnia ważona oparta na użytkownikach

*Ocena ważona

Postaram się na przykładzie wyjaśnić wyżej wymienione metody, którymi będziemy posługiwać się przy ocenie produktów.

W tym przykładzie zbadamy oceny kursu online.

Instaluj i importuj

import pandas as pd
import datetime as dt
import math
import scipy.stats as st
from sklearn.preprocessing import MinMaxScaler
pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', None)
pd.set_option('display.width', 500)
pd.set_option('display.expand_frame_repr', False)
pd.set_option('display.float_format', lambda x: '%5f' % x)

df = pd.read_csv(r'C:\course_reviews.csv')
df.head()
df.shape

df['Rating'].value_counts()

df['Questions Asked'].value_counts()

df.groupby('Questions Asked').agg({'Questions Asked': 'count',
                                   'Rating': 'mean'})

df['Rating'].mean()

W tej chwili może nastąpić wzrost lub spadek wyników, to również należy ocenić.

W takim przypadku powinniśmy użyć średniej ważonej opartej na czasie, aby ocenić również inne sytuacje.

*Średnia ważona w czasie

Przekonwertujmy zmienną „Timestamp” na zmienną czasu

df['Timestamp'] = pd.to_datetime(df['Timestamp'])
current_date = pd.to_datetime('2021-02-10 0:0:0')

df['days'] = (current_date - df['Timestamp']).dt.days

df[df['days'] <= 30] .count()

df.loc[df['days'] <= 30, 'Rating'].mean()

df.loc[df['days'] <= 30, 'Rating'].mean() * 28/100 + \
df.loc[(df['days'] > 30) & (df['days'] <= 90), 'Rating'].mean() * 26/100 + \
df.loc[(df['days'] > 90) & (df['days'] <= 180), 'Rating'].mean() * 24/100 + \
df.loc[(df['days'] > 180), 'Rating'].mean() * 22/100

def time_based_weighted_average(dataframe, w1=28, w2=26, w3=24, w4=22):
    return  dataframe.loc[df['days'] <= 30, 'Rating'].mean() * w1/100 + \
            dataframe.loc[(df['days'] > 30) & (dataframe['days'] <= 90), 'Rating'].mean() * w2/100 + \
            dataframe.loc[(df['days'] > 90) & (dataframe['days'] <= 180), 'Rating'].mean() * w3/100 + \
            dataframe.loc[(df['days'] > 180), 'Rating'].mean() * w4/100

time_based_weighted_average(df)
time_based_weighted_average(df, 30, 26, 22, 22)

*Średnia ważona oparta na użytkownikach

Oceny użytkowników, którzy oglądali kurs w różnym tempie, należy oceniać różnymi wagami:

df.groupby('Progress').agg({'Rating': 'mean'})

Aby obliczyć ważony wynik ze statusem oglądania kursu:

df.loc[df['Progress'] <= 10, 'Rating'].mean() * 22/100 + \
    df.loc[(df['Progress'] > 10) & (df['Progress'] <= 45), 'Rating'].mean() * 24/100 + \
    df.loc[(df['Progress'] > 45) & (df['Progress'] <= 75), 'Rating'].mean() * 26/100 + \
    df.loc[(df['Progress'] > 75), 'Rating'].mean() * 28/100

def user_based_weighted_average(dataframe, w1=22, w2=24, w3=26, w4=28):
    return  dataframe.loc[df['Progress'] <= 10, 'Rating'].mean() * w1/100 + \
            dataframe.loc[(df['Progress'] > 10) & (dataframe['Progress'] <= 45), 'Rating'].mean() * w2/100 + \
            dataframe.loc[(df['Progress'] > 45) & (dataframe['Progress'] <= 75), 'Rating'].mean() * w3/100 + \
            dataframe.loc[(df['Progress'] > 75), 'Rating'].mean() * w4/100

user_based_weighted_average(df)
user_based_weighted_average(df, 20, 24, 26, 30)

*Ocena ważona

Połączymy obliczenia średniej ważonej opartej na czasie i średniej ważonej opartej na użytkownikach w jednej funkcji.

def course_weighted_rating(dataframe, time_w=50, user_w=50):
    return time_based_weighted_average(dataframe) * time_w/100 + user_based_weighted_average(dataframe) * user_w/100

course_weighted_rating(df)

Wniosek

W tym artykule wyjaśniłem rzeczy, które pomogą nam zdecydować, kiedy chcemy kupić produkt, a także widzieliśmy problemy z pomiarem, które mogą się pojawić, gdy chcemy posortować produkty w najbardziej dokładny i obiektywny sposób.

W kolejnym artykule zajmiemy się kwestią sortowania produktów.

Przekonajcie, a będziecie przekonani!

Najlepsze, Neslihan