är motordet just nu. Några otroliga saker görs med hjälp av maskininlärning. Från att vara vår personlig assistent , att besluta om vår resvägar , hjälper oss att handla, hjälper oss att driva våra företag, att ta hand om våra hälsa och välmående, maskininlärning är integrerad i vår dagliga existens på sådana grundläggande nivåer att vi oftast inte ens inser att vi litar på det. I den här artikeln följer vi en nybörjars strategi för att implementera standard en maskininlärningsklassificering i Python.
- Översikt över maskininlärning
- En mall för maskininlärningsklassificerare
- Problem med maskininlärningsklassificering
Översikt över maskininlärning
Machine Learning är ett koncept som gör det möjligt för maskinen att lära sig av exempel och erfarenheter, och det utan att vara uttryckligen programmerad. Så istället för att du skriver koden, vad du gör är att du matar data till den generiska algoritmen, och algoritmen / maskinen bygger logiken baserat på den givna informationen.
Maskininlärning innefattar maskinernas förmåga att fatta beslut, bedöma resultaten av sina handlingar och förbättra deras beteende för att få bättre resultat successivt.
Inlärningsprocessen sker på tre huvudsakliga sätt
- Övervakat lärande
- Oövervakat lärande
- Förstärkning lärande
En mall för maskininlärningsklassificerare
Maskininlärningsverktyg tillhandahålls ganska bekvämt i ett Python-bibliotek som heter scikit-learning, vilket är mycket enkelt att komma åt och tillämpa.
Installera scikit-lär genom kommandotolken med:
pip install -U scikit-learn
Om du är anaconda-användare kan du i anaconda-prompten använda:
conda installera scikit-lär
Installationen kräver tidigare installation av NumPy- och SciPy-paket på ditt system.
Förbehandling: Det första och mest nödvändiga steget i någon maskininlärningsbaserad dataanalys är förbehandlingsdelen. Korrekt representation och rengöring av data är absolut nödvändigt för att ML-modellen ska träna bra och prestera till sin potential.
Steg 1 - Importera nödvändiga bibliotek
importera numpy som np importera pandor som pd importera matplotlib.pyplot som plt
Steg 2 - Importera datasetet
dataset = pd.read_csv ()
Sedan delar vi upp datauppsättningen i oberoende och beroende variabler. De oberoende variablerna ska vara indata, och den beroende variabeln är utdata.
X = dataset.iloc []. Värden y = dataset.iloc []. Värden
Steg 3 - Hantera data som saknas
Datauppsättningen kan innehålla tomma eller nollvärden, vilket kan orsaka fel i våra resultat. Därför måste vi hantera sådana poster. En vanlig praxis är att ersätta nollvärdena med ett gemensamt värde, som medelvärdet eller det vanligaste värdet i den kolumnen.
från sklearn.preprocessing import Imputer imputer = Imputer (missing_values = 'NaN', strategy = 'mean', axis = 0) imputer = imputer.fit (X []) X [] = imputer.transform (X [])
Steg 4 - Konvertera kategoriska variabler till numeriska variabler
från sklearn.preprocessing importera LabelEncoder le_X = LabelEncoder () X [] = le_X.fit_transform (X []) labelencoder_y = LabelEncoder () y = labelencoder_y.fit_transform (y)
Efter kodning kan det hända att maskinen antar numeriska data som en rangordning för de kodade kolumnerna. Således, för att ge lika vikt, måste vi konvertera siffrorna till en heta vektorer, med hjälp av klassen OneHotEncoder.
från sklearn.preprocessing importerar OneHotEncoder oneHE = OneHotEncoder (categorical_features = []) X = oneHE.fit_transform (X) .toarray ()
Steg 5 - Utför skalning
Detta steg är att hantera avvikelser som uppstår på grund av felaktiga skalor för variablerna. Därför skalar vi dem alla till samma intervall så att de får samma vikt samtidigt som de matas in i modellen. Vi använder ett objekt av klassen StandardScaler för detta ändamål.
från sklearn.preprocessing import StandardScaler sc_X = StandardScaler () X = sc_X.fit_transform (X)
Steg 6 - Dela datauppsättningen i tränings- och testdata
Som det sista steget med förbehandling måste datasetet delas in i en träningsuppsättning och testuppsättning. Standardförhållandet för tågtestdelningen är 75% -25%. Vi kan ändra enligt kraven. Train_test_split () -funktionen kan göra detta för oss.
från sklearn.model_selection importera train_test_split X_train, X_test, y_train, y_test = train_test_split (X, y, test_size = 0.25)
Modellbyggnad: Detta steg är faktiskt ganska enkelt. När vi väl har bestämt vilken modell som ska tillämpas på data kan vi skapa ett objekt av motsvarande klass och passa in objektet på vår träningssats, med tanke på X_train som ingång och y_train som output.
från sklearn. importera klassificerare = () klassificerare.fit (X_train, y_train)
Modellen är nu utbildad och redo. Vi kan nu tillämpa vår modell på testuppsättningen och hitta förutsagda utdata.
y_pred = classifier.predict (X_test)
Visningsresultat: Prestandan för en klassificerare kan bedömas med parametrarna noggrannhet, precision, återkallande och f1-poäng. Dessa värden kan ses med en metod som kallas klassificeringsrapport (). t kan också ses som en förvirringsmatris som hjälper oss att veta hur många av vilka datakategorier som har klassificerats korrekt.
från sklearn.metrics importerar confusion_matrix cm = confusion_matrix (y_test, y_pred) skriv ut (cm) från sklearn.metrics importerar klassificeringsrapport målnamn = [] skriv ut (klassificeringsrapport (y_test, y_pred, målnamn = målnamn))
Machine Learning Classifier Problem
Vi kommer att använda den mycket populära och enkla Iris-datasetet, som innehåller dimensioner av blommor i tre kategorier - Iris-setosa, Iris-versicolor och Iris-virginica. Det finns 150 poster i datasetet.
# Importera biblioteken importera numpy som np importera matplotlib.pyplot som plt importera pandor som pd # Importera datasetet = pd.read_csv ('iris.csv')Låt oss se datamängden nu.
dataset.head ()
Vi har fyra oberoende variabler (exklusive Id), nämligen kolumnnummer 1-4, och kolumn 5 är den beroende variabeln. Så vi kan skilja dem ut.
X = dataset.iloc [:, 1: 5] .värden y = dataset.iloc [:, 5] .värden
Nu kan vi dela upp datauppsättningen i utbildning och testning.
# Dela datauppsättningen i träningsuppsättningen och testuppsättningen från sklearn.model_selection importera train_test_split X_train, X_test, y_train, y_test = train_test_split (X, y, test_size = 0.25)
Nu kommer vi att tillämpa en Logistic Regression-klassificerare på datasetet.
# Bygga och träna modellen från sklearn.linear_model import LogisticRegression classifier = LogisticRegression () classifier.fit (X_train, y_train) # Förutsäg testresultaten y_pred = classifier.predict (X_test)
Det sista steget blir att analysera prestanda för den utbildade modellen.
retracement sekvens java för loop
# Att göra förvirringsmatrisen från sklearn.metrics importera confusion_matrix cm = confusion_matrix (y_test, y_pred) print (cm)
Detta visar oss att 13 poster i den första kategorin, 11 i den andra och 9 i den tredje kategorin är korrekt förutsagda av modellen.
# Genererar noggrannhet, precision, återkallande och f1-poäng från sklearn.metrics import klassificering_rapport target_names = ['Iris-setosa', 'Iris-versicolor', 'Iris-virginica'] utskrift (klassificeringsrapport (y_test, y_pred, target_names = target_names) )
Rapporten visar precision, återkallande, f1-poäng och noggrannhetsvärden för modellen på vår testuppsättning, som består av 38 poster (25% av datasetet).
Grattis, du har framgångsrikt skapat och implementerat din första maskininlärningsklassificering i Python! Att få fördjupad kunskap om tillsammans med dess olika applikationer kan du registrera dig för live Python online-utbildning med support dygnet runt och livstidsåtkomst.