Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon.

Introductie

Lineaire regressie brengt een vector in kaart x naar een j. Als we de lineaire regressie-uitvoer in het bereik van 0 tot 1 kunnen pletten, kan dit worden geïnterpreteerd als een waarschijnlijkheid. We kunnen een classificator hebben die de waarschijnlijkheid van het klasselabel voor binaire classificatietaken geeft door de uitvoer van een lineair regressiemodel te pletten. Deze gesuperviseerde leerclassificator staat bekend als een logistieke regressieclassificator.

Hier voorspelt de sigmoïde functie, ook bekend als de logistische functie, de waarschijnlijkheid dat een binaire uitkomst optreedt. De Sigmoid-functie is een activeringsfunctie die wordt gebruikt om niet-lineariteit in een machine learning-model te introduceren. Het neemt een waarde en converteert het tussen 0 en 1. De functie is als volgt:

Logistische regressie voorspelt dus het klasselabel door de verbinding tussen de onafhankelijke kenmerkvariabelen te identificeren. De beslissingsgrens is lineair en wordt gebruikt voor classificatiedoeleinden. De verliesfunctie is als volgt:

Voordelen van logistieke regressie

Nadelen van logistieke regressie

Toepassingen

1. Classificeren of een e-mail spam is of niet
2. Het classificeren van de kwaliteit van water is goed of niet

dataset

De dataset die voor dit project wordt gebruikt, is de Wine Quality Binary-classificatiedataset van Kaggle (https://www.kaggle.com/nareshbhat/wine-quality-binary-classification). Deze dataset bevat informatie over de verschillende factoren die de kwaliteit van rode wijn beïnvloeden.

Aantal instanties: 1600
Ontbrekende waarden: NA
Aantal attributen: 12
Kenmerkinformatie:
Invoervariabelen: (allemaal numeriek gewaardeerd)
1 – vaste zuurgraad
2 – vluchtige zuren
3 – citroenzuur
4 – restsuiker
5 – chloriden
6 – vrij zwaveldioxide
7 – totaal zwaveldioxide
8 – dichtheid
9 – pH
10 – sulfaten
11 – alkohol

Uitvoervariabele: (detecteren of de kwaliteit goed of slecht is)
12 – kwaliteit (0-slecht, 1-goed)

Importeer de vereiste Python-bibliotheken

importeer panda's als pd importeer numpy als np importeer matplotlib.pyplot als plt importeer seaborn als sns importeer waarschuwingen warnings.filterwarnings('ignore')

Laad de dataset

We zullen onze wijndataset laden, een CSV-bestand met behulp van de panda-bibliotheek van Python.

df=pd.read_csv("wijn.csv") df.head()

Data Preprocessing

#preprocessing #De kwaliteitskolom in de dataset moet worden toegewezen als- 0 voor slecht en 1 voor goed. df = df.replace({'kwaliteit': {'goed': 1, 'slecht': 0}}) df.head()

Controleren op ontbrekende waarden

#controleren op ontbrekende waarden df.isna().any().any()

Uitgang: False

Algemene statistieken en plots

df.describe ()

#We zullen een countplot gebruiken om het aantal waarnemingen voor de kolom 'kwaliteit' te visualiseren. sns.countplot(x ='kwaliteit', data = df)

#Distributie van de kolom – alcoholgegevens = df['alcohol'] sns.distplot(data) plt.show()

Functie Belang Score

importeer waarschuwingen warnings.filterwarnings('ignore') van sklearn.ensemble importeer ExtraTreesClassifier model = ExtraTreesClassifier() model.fit(features,target) print(model.feature_importances_) imp = pd.Series(model.feature_importances_, index=features.columns ) imp.nlargest(10).plot(kind='barh') plt.show()

Functies en de doelvariabele definiëren

#kenmerken die voor classificatie worden gebruikt, zijn: #alcohol, sulfaten, totaal zwaveldioxide, vluchtige zuren, citroenzuur en restsuiker. #target=kwaliteitsdoel = df.iloc[:,11] features=df.iloc[:,[10,9,6,1,2,3]]

Standaardiseer de kenmerkvectoren

#standardize feature vectors from sklearn.preprocessing import StandardScaler #StandardScaler() zal de feature waarden herschalen zodat hun standaarddeviatie 1 is en .mean is 0. sc=StandardScaler() scaled_features=sc.fit_transform(features)

Logistiek regressiemodel

We zullen het ingebouwde logistische regressiemodel uit de sklearn-bibliotheek van Python gebruiken, waar we ook de verliesfunctie kunnen definiëren en de voorspellingen kunnen doen.

We beginnen door eerst onze dataset in twee delen te splitsen; één als een trainingsset voor het model en de andere als een testset om de voorspellingen van het model te valideren. Als we deze stap overslaan, wordt het model getraind en getest op dezelfde dataset en wordt het werkelijke foutenpercentage onderschat, een fenomeen dat overfitting wordt genoemd. We stellen de testgrootte in op 0.3, dwz 70% van het klasselabel wordt toegewezen aan de trainingsset en de resterende 30% wordt gebruikt als testset. We zullen dit doen met behulp van de train_test_split-methode in de sklearn-bibliotheek van Python. Het model. fit() methode kan de trainingsgegevens als argumenten gebruiken. Hier is onze modelnaam LR. Dit model haalt enkele niet-gelabelde gegevens uit de testgegevensset en kan elk voorbeeld effectief een waarschijnlijkheid van 0 tot 1 toewijzen. Dit is het cruciale kenmerk van een logistiek regressiemodel. Daarna zullen we ons model evalueren op basis van de testgegevens.

Logistische regressie met behulp van Standard Gradient Descent-algoritme met splitsing 70:30

van sklearn.linear_model import LogisticRegression van sklearn.linear_model import SGDClassifier #70% trainingsgegevens X_train, X_test, y_train, y_test = train_test_split(scaled_features, target, test_size=0.3, random_state=42) lr=LogisticRegression(X_train,lr. y_train) print(classification_report(y_test,lr.predict(X_test)))

Logistieke regressie met behulp van Gradient Descent from Scratch

De kostenfunctie van een logistiek regressiemodel kan worden geminimaliseerd

Het is een iteratief optimalisatiealgoritme en vindt het minimum van een differentieerbare functie. Eerst moet u een willekeurig punt uit de functie selecteren. Dan zou het helpen als je de afgeleide van de functie berekent. Nu kunt u de resulterende gradiënt vermenigvuldigen met onze leersnelheid. Dan moet je het resultaat aftrekken om het nieuwe te krijgen. Deze update moet voor elke iteratie gelijktijdig worden uitgevoerd. Herhaal deze stappen totdat u het lokale of globale minimum bereikt. U hebt het laagst mogelijke verlies in uw voorspelling bereikt door het wereldwijde minimum te bereiken.

van sklearn.datasets.samples_generator import make_blobs van matplotlib import pyplot als plt van panda's import DataFrame import numpy als np X, Y = make_blobs(n_samples=100, centers=2, n_features=2, cluster_std=5, random_state=11) m = 100

#retourneert een array met sigmoid van de invoerarray def sigmoid(z): return 1 / (1 + np.exp(-z)) #retourneert een array met de voorspellingen van onze invoerarray def hy(w,X): z = np.array(w[0] + w[1]*np.array(X[:,0]) + w[2]*np.array(X[:,1])) return sigmoid(z) # kostenfunctie def kosten(w, X, Y): y_predictions = hy(w,X) #toewijzing van de voorspellingswaarden return -1 * sum(Y*np.log(y_predictions) + (1-Y)*np.log( 1-j_voorspellingen))

#gradient descent def partiële_derivatives(w, X, Y): y_predictions = hy(w,X) j = [0]*3 j[0] = -1 * sum(Y*(1-y_predictions) - (1-Y )*y_predictions) #opslaan van partiële afgeleiden j[1] = -1 * sum(Y*(1-y_predictions)*X[:,0] - (1-Y)*y_predictions*X[:,0]) j[ 2] = -1 * sum(Y*(1-y_predictions)*X[:,1] - (1-Y)*y_predictions*X[:,1]) return j #returns array met partiële afgeleiden def gradient_descent(w_new , w_prev, learning_rate): print(w_prev) print(cost(w_prev, X, Y)) j=0 while True: w_prev = w_new #updating weights in elke iteratie w0 = w_prev[0] - learning_rate*partial_derivatives(w_prev, X , Y)[0] w1 = w_prev[1] - learning_rate*partial_derivatives(w_prev, X, Y)[1] w2 = w_prev[2] - learning_rate*partial_derivatives(w_prev, X, Y)[2] w_new = [w0 , w1, w2] print(w_new) print(cost(w_new, X, Y)) if (w_new[0]-w_prev[0])**2 + (w_new[1]-w_prev[1])**2 + (w_new[2]-w_prev[2])**2 100: return w_new j+=1

w=[1,1,1] w = gradient_descent(w,w,0.0099) print(w)

def vergelijking(x): return (-w[0]-w[1]*x)/w[2] def grafiek(formule, x_bereik): x = np.array(x_bereik) y = formule(x) plt. plot(x, y) df = DataFrame(dict(x=X[:,0], y=X[:,1], label=Y)) kleuren = {0:'rood', 1:'groen'} fig, ax = plt.subplots() g = df.groupby('label') voor sleutel, groep in g: group.plot(ax=ax, kind='scatter', x='x', y='y ', label=sleutel, kleur=kleuren[sleutel]) grafiek(vergelijking, bereik(-20,15)) plt.xlabel('x0') plt.ylabel('x1') plt.show()

Lees meer artikelen op basis van Logistic Regression op onze van de.

Conclusie

Logistische regressie is dus een statistische analysemethode. Ons model heeft 72% van de testgegevens nauwkeurig gelabeld en we zouden de nauwkeurigheid nog kunnen vergroten door een ander algoritme voor de dataset te gebruiken.

De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt. 

Verwant

Bron: https://www.analyticsvidhya.com/blog/2022/01/logistic-regression-an-introductory-note/