Bei der Daten­be­rei­ni­gung geht es darum, beschä­digte oder unge­naue Daten­sätze in einem Daten­satz zu erken­nen und zu kor­ri­gie­ren. Die­ser Pro­zess umfasst die Iden­ti­fi­zie­rung unvoll­stän­di­ger, fal­scher, unge­nauer oder irrele­van­ter Teile der Daten und das anschlie­ßende Erset­zen, Ändern oder Löschen der ver­schmutz­ten oder gro­ben Daten.

Unter­su­chun­gen zei­gen, dass Unter­neh­men im Durch­schnitt fast 30 % ihrer Daten als unge­nau ein­schät­zen. Sol­che nicht auf­be­rei­te­ten oder „schmut­zi­gen“ Daten ver­ur­sa­chen den Unter­neh­men erheb­li­che Kos­ten, die etwa 12 % ihres Gesamt­um­sat­zes aus­ma­chen. Die Aus­wir­kun­gen gehen über bloße finan­zi­elle Ver­luste hin­aus und unter­strei­chen, wie wich­tig sau­bere und zuver­läs­sige Daten sind. Daher kann die Bedeu­tung sau­be­rer Daten gar nicht hoch genug ein­ge­schätzt werden.

Die Bedeu­tung des Daten­be­rei­ni­gungs­pro­zes­ses kann gar nicht hoch genug ein­ge­schätzt wer­den, da er es uns ermög­licht, kon­sis­tente, struk­tu­rierte und genaue Daten zu pro­du­zie­ren und damit die Grund­lage für fun­dierte Ent­schei­dun­gen zu schaf­fen, die wert­volle Zeit und finan­zi­elle Res­sour­cen sparen.

Im Bereich der Daten­ana­lyse ste­hen zahl­rei­che Tools für die Daten­be­rei­ni­gung zur Ver­fü­gung, wie Excel, SQL, Python, R usw. Im Rah­men die­ses Tuto­ri­als wer­den wir uns jedoch auf die Ver­wen­dung von SQL konzentrieren.

SQL ist ein schnel­les und effi­zi­en­tes Werk­zeug für die Durch­füh­rung von Daten­be­rei­ni­gungs­auf­ga­ben in unse­ren Daten­be­stän­den. Seine Fähig­kei­ten umfas­sen ver­schie­dene wesent­li­che Funk­tio­nen, ein­schließ­lich der Fähig­keit, irrele­vante Daten her­aus­zu­fil­tern, dop­pelte Werte zu ver­wal­ten, Daten­satz­for­mate zu stan­dar­di­sie­ren und feh­lende Werte zu behan­deln, neben ande­ren Funktionalitäten.

In die­sem Pro­jekt wer­den wir grund­le­gende Daten­be­rei­ni­gungs­auf­ga­ben an einem Daten­satz durch­füh­ren, der aus dem Inter­net ent­nom­mene Stel­len­an­zei­gen von Glass­door für Jobs in den Daten­wis­sen­schaf­ten ent­hält. Sie fin­den den Daten­satz hier.

Als Haupt­tool wird SQL (SQLite) verwendet.

Das Pro­jekt

Hier fin­den Sie einen Über­blick über das Projekt.

SELECT *
FROM Uncleaned_DS_jobs
LIMIT 10;

Unser Haupt­ziel in die­sem Pro­jekt ist es, den Daten­satz zu unter­su­chen, irrele­vante und dop­pelte Daten zu ent­fer­nen, struk­tu­relle Feh­ler zu kor­ri­gie­ren, Typ­kon­ver­tie­run­gen durch­zu­füh­ren, feh­lende Daten zu behan­deln und unse­ren Daten­satz zu stan­dar­di­sie­ren und zu validieren.

Schritt 1. Erstel­len einer neuen Tabelle für die Arbeit.

Unser ers­ter Schritt besteht darin, eine neue Kopie der Tabelle/des Daten­sat­zes zu erstel­len, mit der/dem wir arbei­ten, da wir die Ori­gi­nal­da­ten nicht ver­än­dern wollen.

CREATE TABLE jobs AS
SELECT *
FROM Uncleaned_DS_jobs;

Die obige Abfrage erstellt eine neue Tabelle „jobs“, die im Wesent­li­chen eine Kopie unse­rer ursprüng­li­chen Daten ist.

Schritt 2. Unter­su­chen Sie die Tabellenstruktur.

Der nächste Schritt besteht darin, die Struk­tur unse­rer Tabelle zu unter­su­chen, um Infor­ma­tio­nen über die Spal­ten in der Tabelle zu erhal­ten, z. B. die Spal­ten­na­men und Daten­ty­pen usw.

PRAGMA table_info(jobs);

Schritt 3: Stan­dar­di­sie­rung der Spaltennamen

Wie man an den Spal­ten­na­men sehen kann, könnte man sie etwas berei­ni­gen. Ich bevor­zuge Spal­ten­na­men in Groß- und Klein­schrei­bung. Die Groß­schrei­bung ist eine Namens­kon­ven­tion, bei der jedes Leer­zei­chen durch einen Unter­strich (_) ersetzt wird und die Wör­ter klein geschrie­ben werden.

In SQL kön­nen wir dies mit den fol­gen­den Abfra­gen erreichen.

ALTER TABLE jobs
    RENAME 'Job Title' TO 'job_title';
    
ALTER TABLE jobs
    RENAME 'Salary Estimate' TO 'salary_estimate';

ALTER TABLE jobs
    RENAME COLUMN 'Job Description' TO 'job_description';

ALTER TABLE jobs
    RENAME COLUMN 'Rating' TO 'rating';

ALTER TABLE jobs
    RENAME COLUMN 'Company Name' TO 'company_name';

ALTER TABLE jobs
    RENAME COLUMN 'Location' TO 'location';

ALTER TABLE jobs
    RENAME COLUMN 'Headquarters' TO 'headquarters';

ALTER TABLE jobs
    RENAME COLUMN 'Size' TO 'size';

ALTER TABLE jobs
    RENAME COLUMN 'Founded' TO 'founded';

ALTER TABLE jobs
    RENAME COLUMN 'Type of ownership' TO 'type_of_ownership';

ALTER TABLE jobs
    RENAME COLUMN 'Industry' TO 'industry';

ALTER TABLE jobs
    RENAME COLUMN 'Sector' TO 'sector';

ALTER TABLE jobs
    RENAME COLUMN 'Revenue' TO 'revenue';

ALTER TABLE jobs
    RENAME COLUMN 'Competitors' TO 'competitors';

SCHRITT 4: Berei­ni­gung der Spalte job_title

Bei genauer Betrach­tung der Spalte job_title zeigt sich, dass sie meh­rere Varia­tio­nen des Wor­tes „senior“ und „junior“ ent­hält, die wir har­mo­ni­sie­ren müs­sen, um sie alle in einer Form zu halten.

Mit die­ser Abfrage kön­nen wir die ver­schie­de­nen Berufs­be­zeich­nun­gen untersuchen.

SELECT DISTINCT(job_title), COUNT(*) AS job_count
FROM jobs
GROUP BY job_title
ORDER BY job_count DESC;

Wir kön­nen eine Reihe von UPDATE-Anwei­sun­gen ver­wen­den, um bestimmte Stel­len­be­zeich­nun­gen in der Tabelle jobs zu stan­dar­di­sie­ren und zu ändern. Der Zweck die­ser Aktua­li­sie­run­gen ist die Ver­ein­heit­li­chung der Stel­len­be­zeich­nun­gen, um die Kon­sis­tenz und Les­bar­keit der Spalte job_title zu gewährleisten.

Jede UPDATE-Anwei­sung würde die Funk­tion REPLACE() ver­wen­den, um bestimmte Instan­zen von Stel­len­be­zeich­nun­gen in der Spalte job_title zu fin­den und sie durch unsere stan­dar­di­sier­ten Ver­sio­nen oder geän­der­ten Bezeich­nun­gen zu ersetzen.

-- standardize the data
UPDATE jobs
SET job_title = REPLACE(job_title, 'Sr Data Scientist', 'Senior Data Scientist');

UPDATE jobs
SET job_title = REPLACE(job_title,  'Sr Data Engineer (Sr BI Developer)', 'Senior Data Engineer (Senior BI Developer');

UPDATE jobs
SET job_title = REPLACE(job_title, 'Jr. Business Data Analyst (position added 6/12/2020)', 'Junior Business Data Analyst');

UPDATE jobs
SET job_title = REPLACE(job_title,  'Jr. Data Engineer', 'Junior Data Engineer');

UPDATE jobs
SET job_title = REPLACE(job_title, 'Data Scientist 3 (718)', 'Data Scientist 3');

UPDATE jobs
SET job_title = REPLACE(job_title, '(Sr.) Data Scientist -', 'Senior Data Scientist');

UPDATE jobs
SET job_title = REPLACE(job_title, 'Sr. ML/Data Scientist - AI/NLP/Chatbot', 'Senior ML/Data Scientist - AI/NLP/Chatbot');

UPDATE jobs
SET job_title = REPLACE(job_title, 'Sr Scientist - Extractables & Leachables', 'Senior Scientist - Extractables & Leachables');

UPDATE jobs
SET job_title = REPLACE(job_title,  'Sr Data Analyst', 'Senior Data Analyst');

UPDATE jobs
SET job_title = REPLACE(job_title, 'Machine Learning Scientist - Bay Area, CA', 'Machine Learning Scientist');

UPDATE jobs
SET job_title = REPLACE(job_title,  'Sr. Data Scientist II', 'Senior Data Scientist II');

UPDATE jobs
SET job_title = REPLACE(job_title, 'Data Scientist - TS/SCI FSP or CI Required', 'Data Scientist');

UPDATE jobs
SET job_title = REPLACE(job_title, 'ENGINEER - COMPUTER SCIENTIST - RESEARCH COMPUTER SCIENTIST - SIGNAL PROCESSING - SAN ANTONIO OR', 'Research Computing Scientist');

UPDATE jobs
SET job_title = REPLACE(job_title, 'Sr. Research Associate/ Scientist, NGS prep & Molecular Genomics', 'Senior Research Associate / Scientist, NGS prep & Molecular Genomics');

UPDATE jobs
SET job_title = REPLACE(job_title, 'Sr. Data Analyst', 'Senior Data Analyst');

UPDATE jobs
SET job_title = REPLACE(job_title, 'COMPUTER SCIENTIST - ENGINEER - RESEARCH COMPUTER SCIENTIST - TRANSPORTATION TECHNOLOGY', 'Research Computer Scientist');

UPDATE jobs
SET job_title = REPLACE(job_title, 'ELISA RESEARCH SCIENTIST (CV-15)', 'ELISA Research Scientist (CV-15');

UPDATE jobs 
SET job_title = REPLACE(job_title, 'Health Plan Data Analyst, Sr', 'Health Plan Data Analyst, Senior');

UPDATE jobs
SET job_title = REPLACE(job_title, 'Machine Learning Engineer, Sr.', 'Machine Learning Engineer, Senior');

Jetzt haben wir eine sau­be­rere Version.

SCHRITT 5: Extra­hie­ren unnö­ti­ger Zei­chen aus der Spalte salary_estimate

Im nächs­ten Schritt extra­hie­ren wir die Werte „(Glass­door est.)“ aus der Spalte, wobei wir nur die Zah­len behal­ten und den Daten­typ in VARCHAR konvertieren.

-- examine salary_estimate column
SELECT salary_estimate
FROM jobs
LIMIT 5;

--- Add a cleaned salary_estimate column to the table
ALTER TABLE ds_jobs
ADD COLUMN cleaned_salary_estimate VARCHAR(11); 
-- Update the new column with values based on the SUBSTRING() function
UPDATE ds_jobs
SET cleaned_salary_estimate = SUBSTRING(salary_estimate, 1, 11);
-- Delete the salary_estimate column as it is no longer useful.
ALTER TABLE ds_jobs
DROP COLUMN salary_estimate;

Step 6: Berei­ni­gen Sie die Spalte company_name.

Wie oben zu sehen ist, ent­hält diese Spalte einige unnö­tige Zei­chen, die ent­fernt wer­den müs­sen. Wir kön­nen dies mit der fol­gen­den Abfrage tun:

-- clean out unnecessary characters
SELECT 
    company_name, 
    SUBSTR(company_name, 1, LENGTH(company_name) - 4) AS cleaned_company_name
FROM jobs;

-- update our table
UPDATE jobs
SET company_name = SUBSTR(company_name, 1, LENGTH(company_name) - 4);

Diese Abfrage ver­wen­det die Funk­tion SUBSTR(), um die Zei­chen aus der Spalte company_name abzu­ru­fen, begin­nend mit dem ers­ten Zei­chen (Index 1) und unter Aus­schluss der letz­ten 3 Zei­chen (-3).

Schritt 7: Fixie­ren Sie die Spalte size.

Die Grö­ßen­spalte kann ein wenig gesäu­bert wer­den, damit sie anspre­chen­der aussieht.

SELECT size, 
    CASE
        WHEN size = '-1' THEN '1'
        ELSE REPLACE(size, ' to ', '-')
    END AS cleaned_size
FROM jobs;

Schritt 8: Berei­ni­gen Sie die Spalte type_of_ownership.

-- clean type of ownership column
SELECT type_of_ownership
FROM jobs
GROUP BY type_of_ownership;

Wie oben zu sehen ist, ent­hält diese Spalte Daten, die wir stan­dar­di­sie­ren müs­sen, d. h. wir erset­zen die „-1“-Werte durch „unbe­kannt“ und ändern die Werte „Unter­neh­men – pri­vat“ und „Unter­neh­men – öffent­lich“, damit sie leich­ter zu lesen sind.

Dies kön­nen wir mit CASE WHEN-Anwei­sun­gen erreichen.

UPDATE jobs
SET type_of_ownership = 
    CASE 
        WHEN type_of_ownership = 'Company - Private' THEN 'Private Company'
        WHEN type_of_ownership = 'Company - Public' THEN 'Public Company'
        WHEN type_of_ownership = -1 THEN 'Unknown'
        ELSE type_of_ownership -- Keeps other values unchanged
    END;

Schritt 9: Berei­ni­gen Sie die Spalte der Mitbewerber.

Zum Schluss kön­nen wir die Spalte der Mit­be­wer­ber berei­ni­gen, da die meis­ten Werte als ‑1 ange­zeigt wer­den. Auch hier wür­den wir sie als „unbe­kannt“ anzeigen.

SELECT competitors, COUNT(competitors)
FROM ds_jobs
GROUP BY competitors;

--- most of the values show -1, replace with unknown
SELECT competitors,
      CASE WHEN competitors = -1 THEN 'Unknown'
      ELSE competitors
      END AS cleaned_competition
FROM jobs;

--- update TABLE
UPDATE jobs
SET competitors = 
    CASE 
        WHEN competitors = -1 THEN 'Unknown'
        ELSE competitors
    END;

Voilà!

Jetzt haben wir einen sau­be­ren Daten­satz, mit dem wir EDA oder wei­tere Ana­ly­sen durch­füh­ren können.

Quelle: medium.com