Použití Apache Spark MLlib k sestavení služby machine learning aplikací a analyzovat datové sadyUse Apache Spark MLlib to build a machine learning application and analyze a dataset

Další informace o použití Apache Spark MLlib k vytvoření služby machine learning aplikace provést jednoduché prediktivní analýzy pro otevřete datovou sadu.Learn how to use Apache Spark MLlib to create a machine learning application to do simple predictive analysis on an open dataset. Spark integrované strojového učení knihovny, tento příklad používá klasifikace prostřednictvím logistické regrese.From Spark's built-in machine learning libraries, this example uses classification through logistic regression.

MLlib je knihovna Spark core, která poskytuje řadu nástrojů, které jsou užitečné pro úlohy strojového učení, včetně nástroje, které jsou vhodné pro:MLlib is a core Spark library that provides many utilities useful for machine learning tasks, including utilities that are suitable for:

  • KlasifikaceClassification
  • RegreseRegression
  • Vytváření clusterůClustering
  • Téma modelováníTopic modeling
  • Rozložené singulární hodnotu (SVD) a analýzy hlavních komponentách (DPS)Singular value decomposition (SVD) and principal component analysis (PCA)
  • Předpoklad testování a výpočtu statistik vzorkuHypothesis testing and calculating sample statistics

Klasifikace a logistické regreseUnderstand classification and logistic regression

Klasifikace, oblíbené služby machine learning úkol, je proces řazení do kategorií vstupní data.Classification, a popular machine learning task, is the process of sorting input data into categories. Je úloha klasifikační algoritmus, zjistěte, jak přiřadit "popisky" pro vstupní data, která zadáte.It is the job of a classification algorithm to figure out how to assign "labels" to input data that you provide. Například může představit algoritmu strojového učení, který přijímá jako vstup základní informace a stock rozdělí do dvou kategorií:, které by měl prodávat a populací, které byste měli mít.For example, you could think of a machine learning algorithm that accepts stock information as input and divides the stock into two categories: stocks that you should sell and stocks that you should keep.

Logistické regrese je algoritmus, který používáte pro klasifikaci.Logistic regression is the algorithm that you use for classification. Spark logistické regrese rozhraní API je užitečné pro binární klasifikace, nebo klasifikaci vstupní data do jedné ze dvou skupin.Spark's logistic regression API is useful for binary classification, or classifying input data into one of two groups. Další informace o logistické regrese, naleznete v tématu Wikipedia.For more information about logistic regressions, see Wikipedia.

Stručně řečeno, vytvoří proces logistickou regresi logistické funkce , který lze použít k predikci pravděpodobnosti, že vstupní vektoru patří do jedné skupiny, nebo druhé.In summary, the process of logistic regression produces a logistic function that can be used to predict the probability that an input vector belongs in one group or the other.

Příklad prediktivní analýzy na data kontroly potravinPredictive analysis example on food inspection data

V tomto příkladu pomocí Spark provádět některé prediktivní analýzy dat kontroly potravin (Food_Inspections1.csv), který byl získán prostřednictvím portál data město Chicago.In this example, you use Spark to perform some predictive analysis on food inspection data (Food_Inspections1.csv) that was acquired through the City of Chicago data portal. Tato datová sada obsahuje informace o kontroly potravin zařízení, které byly provedeny v Chicagu, včetně informací o jednotlivých zařízení (pokud existuje) bylo zjištěno narušení a výsledky kontroly.This dataset contains information about food establishment inspections that were conducted in Chicago, including information about each establishment, the violations found (if any), and the results of the inspection. Datový soubor CSV je již k dispozici v účtu úložiště přidruženého clusteru na /HdiSamples/HdiSamples/FoodInspectionData/Food_Inspections1.csv.The CSV data file is already available in the storage account associated with the cluster at /HdiSamples/HdiSamples/FoodInspectionData/Food_Inspections1.csv.

V následujících krocích vývoj modelu, pokud chcete zobrazit, co je potřeba k úspěšné nebo neúspěšné kontroly potravin.In the steps below, you develop a model to see what it takes to pass or fail a food inspection.

Vytvoření aplikace Apache Spark MLlib machine learningCreate an Apache Spark MLlib machine learning app

  1. Vytvořte poznámkový blok Jupyter pomocí jádra PySpark.Create a Jupyter notebook using the PySpark kernel. Pokyny najdete v tématu Vytvoření poznámkového bloku Jupyter.For the instructions, see Create a Jupyter notebook.

  2. Importujte typy požadované pro tuto aplikaci.Import the types required for this application. Zkopírujte a vložte následující kód do prázdné buňky a stiskněte klávesu SHIFT + ENTER.Copy and paste the following code into an empty cell, and then press SHIFT + ENTER.

    from pyspark.ml import Pipeline
    from pyspark.ml.classification import LogisticRegression
    from pyspark.ml.feature import HashingTF, Tokenizer
    from pyspark.sql import Row
    from pyspark.sql.functions import UserDefinedFunction
    from pyspark.sql.types import *
    

    Z důvodu jádra PySpark není nutné explicitně tvořit kontexty.Because of the PySpark kernel, you do not need to create any contexts explicitly. Kontexty Spark a Hive se automaticky vytvoří za vás při spuštění první buňky kódu.The Spark and Hive contexts are automatically created for you when you run the first code cell.

Vytvořit vstupní datový rámecConstruct the input dataframe

Vzhledem k tomu, že nezpracovaná data se ve formátu CSV, můžete o přijetí změn souboru do paměti jako nestrukturovaného textu pomocí kontextu Spark a pak použít k analýze každý řádek dat knihovna Python pro sdílený svazek clusteru.Because the raw data is in a CSV format, you can use the Spark context to pull the file into memory as unstructured text, and then use Python's CSV library to parse each line of the data.

  1. Spusťte následující řádky k vytvoření odolné Distributed Dataset (RDD) tak, že import a analýza vstupní data.Run the following lines to create a Resilient Distributed Dataset (RDD) by importing and parsing the input data.

    def csvParse(s):
        import csv
        from StringIO import StringIO
        sio = StringIO(s)
        value = csv.reader(sio).next()
        sio.close()
        return value
    
    inspections = sc.textFile('/HdiSamples/HdiSamples/FoodInspectionData/Food_Inspections1.csv')\
                    .map(csvParse)
    
  2. Spusťte následující kód k načtení jeden řádek z RDD, aby mohl podívat schématu dat:Run the following code to retrieve one row from the RDD, so you can take a look of the data schema:

    inspections.take(1)
    

    Výstup bude:The output is:

    [['413707',
        'LUNA PARK INC',
        'LUNA PARK  DAY CARE',
        '2049789',
        "Children's Services Facility",
        'Risk 1 (High)',
        '3250 W FOSTER AVE ',
        'CHICAGO',
        'IL',
        '60625',
        '09/21/2010',
        'License-Task Force',
        'Fail',
        '24. DISH WASHING FACILITIES: PROPERLY DESIGNED, CONSTRUCTED, MAINTAINED, INSTALLED, LOCATED AND OPERATED - Comments: All dishwashing machines must be of a type that complies with all requirements of the plumbing section of the Municipal Code of Chicago and Rules and Regulation of the Board of Health. OBSEVERD THE 3 COMPARTMENT SINK BACKING UP INTO THE 1ST AND 2ND COMPARTMENT WITH CLEAR WATER AND SLOWLY DRAINING OUT. INST NEED HAVE IT REPAIR. CITATION ISSUED, SERIOUS VIOLATION 7-38-030 H000062369-10 COURT DATE 10-28-10 TIME 1 P.M. ROOM 107 400 W. SURPERIOR. | 36. LIGHTING: REQUIRED MINIMUM FOOT-CANDLES OF LIGHT PROVIDED, FIXTURES SHIELDED - Comments: Shielding to protect against broken glass falling into food shall be provided for all artificial lighting sources in preparation, service, and display facilities. LIGHT SHIELD ARE MISSING UNDER HOOD OF  COOKING EQUIPMENT AND NEED TO REPLACE LIGHT UNDER UNIT. 4 LIGHTS ARE OUT IN THE REAR CHILDREN AREA,IN THE KINDERGARDEN CLASS ROOM. 2 LIGHT ARE OUT EAST REAR, LIGHT FRONT WEST ROOM. NEED TO REPLACE ALL LIGHT THAT ARE NOT WORKING. | 35. WALLS, CEILINGS, ATTACHED EQUIPMENT CONSTRUCTED PER CODE: GOOD REPAIR, SURFACES CLEAN AND DUST-LESS CLEANING METHODS - Comments: The walls and ceilings shall be in good repair and easily cleaned. MISSING CEILING TILES WITH STAINS IN WEST,EAST, IN FRONT AREA WEST, AND BY THE 15MOS AREA. NEED TO BE REPLACED. | 32. FOOD AND NON-FOOD CONTACT SURFACES PROPERLY DESIGNED, CONSTRUCTED AND MAINTAINED - Comments: All food and non-food contact equipment and utensils shall be smooth, easily cleanable, and durable, and shall be in good repair. SPLASH GUARDED ARE NEEDED BY THE EXPOSED HAND SINK IN THE KITCHEN AREA | 34. FLOORS: CONSTRUCTED PER CODE, CLEANED, GOOD REPAIR, COVING INSTALLED, DUST-LESS CLEANING METHODS USED - Comments: The floors shall be constructed per code, be smooth and easily cleaned, and be kept clean and in good repair. INST NEED TO ELEVATE ALL FOOD ITEMS 6INCH OFF THE FLOOR 6 INCH AWAY FORM WALL.  ',
        '41.97583445690982',
        '-87.7107455232781',
        '(41.97583445690982, -87.7107455232781)']]
    

    Výstup obsahuje představu o schéma vstupního souboru.The output gives you an idea of the schema of the input file. Obsahuje název každé zařízení, na typu zařízení, adresu, data z kontrol a umístění, mimo jiné.It includes the name of every establishment, the type of establishment, the address, the data of the inspections, and the location, among other things.

  3. Spuštěním následujícího kódu vytvořte datový rámec (df) a dočasnou tabulku (CountResults) s několika sloupců, které jsou užitečné pro prediktivní analýzu.Run the following code to create a dataframe (df) and a temporary table (CountResults) with a few columns that are useful for the predictive analysis. sqlContext slouží k provádění transformací na strukturovaná data.sqlContext is used to perform transformations on structured data.

    schema = StructType([
    StructField("id", IntegerType(), False),
    StructField("name", StringType(), False),
    StructField("results", StringType(), False),
    StructField("violations", StringType(), True)])
    
    df = spark.createDataFrame(inspections.map(lambda l: (int(l[0]), l[1], l[12], l[13])) , schema)
    df.registerTempTable('CountResults')
    

    Čtyři sloupce zájem datového rámce jsou id, název, výsledky, a porušení.The four columns of interest in the dataframe are id, name, results, and violations.

  4. Spusťte následující kód slouží k získání malým vzorkem dat:Run the following code to get a small sample of the data:

    df.show(5)
    

    Výstup bude:The output is:

    +------+--------------------+-------+--------------------+
    |    id|                name|results|          violations|
    +------+--------------------+-------+--------------------+
    |413707|       LUNA PARK INC|   Fail|24. DISH WASHING ...|
    |391234|       CAFE SELMARIE|   Fail|2. FACILITIES TO ...|
    |413751|          MANCHU WOK|   Pass|33. FOOD AND NON-...|
    |413708|BENCHMARK HOSPITA...|   Pass|                    |
    |413722|           JJ BURGER|   Pass|                    |
    +------+--------------------+-------+--------------------+
    

Pochopení datUnderstand the data

Začněme představu, co obsahuje datovou sadu.Let's start to get a sense of what the dataset contains.

  1. Spusťte následující kód k zobrazení jedinečných hodnot v výsledky sloupce:Run the following code to show the distinct values in the results column:

    df.select('results').distinct().show()
    

    Výstup bude:The output is:

    +--------------------+
    |             results|
    +--------------------+
    |                Fail|
    |Business Not Located|
    |                Pass|
    |  Pass w/ Conditions|
    |     Out of Business|
    +--------------------+
    
  2. Spusťte následující kód k vizualizaci distribuce tyto výsledky:Run the following code to visualize the distribution of these results:

    %%sql -o countResultsdf
    SELECT COUNT(results) AS cnt, results FROM CountResults GROUP BY results
    

    %%sql Magic, za nímž následuje -o countResultsdf zajistí, že výstup dotazu se ukládají místně na serveru Jupyter (obvykle hlavního uzlu clusteru).The %%sql magic followed by -o countResultsdf ensures that the output of the query is persisted locally on the Jupyter server (typically the headnode of the cluster). Výstup se ukládají jako Pandas datový rámec se zadaným názvem countResultsdf.The output is persisted as a Pandas dataframe with the specified name countResultsdf. Další informace o %%sql magic a dalších Magic, které jsou k dispozici s jádrem pyspark, najdete v části jádra dostupná v poznámkových blocích Jupyter s clustery Apache Spark HDInsight.For more information about the %%sql magic, and other magics available with the PySpark kernel, see Kernels available on Jupyter notebooks with Apache Spark HDInsight clusters.

    Výstup bude:The output is:

    Výstup dotazu SQLSQL query output

  3. Můžete také použít Matplotlib, knihovna použitý k vytvoření vizualizace dat, k vytvoření vykreslení.You can also use Matplotlib, a library used to construct visualization of data, to create a plot. Protože vykreslení musí být vytvořeny z místně trvalý countResultsdf datového rámce, fragment kódu musí začínat %%local magic.Because the plot must be created from the locally persisted countResultsdf dataframe, the code snippet must begin with the %%local magic. Tím se zajistí, že je kód spuštěn místně na serveru Jupyter.This ensures that the code is run locally on the Jupyter server.

    %%local
    %matplotlib inline
    import matplotlib.pyplot as plt
    
    labels = countResultsdf['results']
    sizes = countResultsdf['cnt']
    colors = ['turquoise', 'seagreen', 'mediumslateblue', 'palegreen', 'coral']
    plt.pie(sizes, labels=labels, autopct='%1.1f%%', colors=colors)
    plt.axis('equal')
    

    Výstup bude:The output is:

    Výstup Spark machine learningu aplikace - výsečový graf s pěti různých výsledkůSpark machine learning application output - pie chart with five distinct inspection results

    Pro předpověď výsledků kontroly potravin, budete muset vyvinout model založený na porušení zásad.To predict a food inspection outcome, you need to develop a model based on the violations. Protože logistické regrese je metoda binární klasifikace, je vhodné seskupit Výsledná data do dvou kategorií: Selhání a předat:Because logistic regression is a binary classification method, it makes sense to group the result data into two categories: Fail and Pass:

    • PrůchodPass

      • PrůchodPass
      • Předejte plánovaným bodem obnovení kratším podmínkyPass w/ conditions
    • ChybaFail

      • ChybaFail
    • ZahozeníDiscard

      • Firmy, které se nenacházíBusiness not located
      • Nevyvíjí obchodní činnostOut of Business

      Nejsou užitečné údaje s další výsledky ("Obchodní není umístěný" nebo "obchodní z") a jsou velmi malé procento výsledky přesto provést.Data with the other results ("Business Not Located" or "Out of Business") are not useful, and they make up a very small percentage of the results anyway.

  4. Spusťte následující kód pro převod existujícího datového rámce (df) do struktury dataframe nové, kde každé kontrole reprezentované jako dvojici popisek porušení.Run the following code to convert the existing dataframe(df) into a new dataframe where each inspection is represented as a label-violations pair. V tomto případě popisek 0.0 představuje selhání popisek 1.0 představuje úspěch a jako popisek -1.0 představuje některé výsledky kromě těchto dvou.In this case, a label of 0.0 represents a failure, a label of 1.0 represents a success, and a label of -1.0 represents some results besides those two.

    def labelForResults(s):
        if s == 'Fail':
            return 0.0
        elif s == 'Pass w/ Conditions' or s == 'Pass':
            return 1.0
        else:
            return -1.0
    label = UserDefinedFunction(labelForResults, DoubleType())
    labeledData = df.select(label(df.results).alias('label'), df.violations).where('label >= 0')
    
  5. Spusťte následující kód, který zobrazí jeden řádek s popisky dat:Run the following code to show one row of the labeled data:

    labeledData.take(1)
    

    Výstup bude:The output is:

    [Row(label=0.0, violations=u"41. PREMISES MAINTAINED FREE OF LITTER, UNNECESSARY ARTICLES, CLEANING  EQUIPMENT PROPERLY STORED - Comments: All parts of the food establishment and all parts of the property used in connection with the operation of the establishment shall be kept neat and clean and should not produce any offensive odors.  REMOVE MATTRESS FROM SMALL DUMPSTER. | 35. WALLS, CEILINGS, ATTACHED EQUIPMENT CONSTRUCTED PER CODE: GOOD REPAIR, SURFACES CLEAN AND DUST-LESS CLEANING METHODS - Comments: The walls and ceilings shall be in good repair and easily cleaned.  REPAIR MISALIGNED DOORS AND DOOR NEAR ELEVATOR.  DETAIL CLEAN BLACK MOLD LIKE SUBSTANCE FROM WALLS BY BOTH DISH MACHINES.  REPAIR OR REMOVE BASEBOARD UNDER DISH MACHINE (LEFT REAR KITCHEN). SEAL ALL GAPS.  REPLACE MILK CRATES USED IN WALK IN COOLERS AND STORAGE AREAS WITH PROPER SHELVING AT LEAST 6' OFF THE FLOOR.  | 38. VENTILATION: ROOMS AND EQUIPMENT VENTED AS REQUIRED: PLUMBING: INSTALLED AND MAINTAINED - Comments: The flow of air discharged from kitchen fans shall always be through a duct to a point above the roofline.  REPAIR BROKEN VENTILATION IN MEN'S AND WOMEN'S WASHROOMS NEXT TO DINING AREA. | 32. FOOD AND NON-FOOD CONTACT SURFACES PROPERLY DESIGNED, CONSTRUCTED AND MAINTAINED - Comments: All food and non-food contact equipment and utensils shall be smooth, easily cleanable, and durable, and shall be in good repair.  REPAIR DAMAGED PLUG ON LEFT SIDE OF 2 COMPARTMENT SINK.  REPAIR SELF CLOSER ON BOTTOM LEFT DOOR OF 4 DOOR PREP UNIT NEXT TO OFFICE.")]
    

Vytvoření modelu logistické regrese ze vstupního datového rámceCreate a logistic regression model from the input dataframe

Posledním úkolem je označené data převést do formátu, který mohou být analyzovány pomocí logistické regrese.The final task is to convert the labeled data into a format that can be analyzed by logistic regression. Vstup algoritmu logistické regrese musí být sada funkce popisků vektoru dvojice, kde vektoru"funkce" představuje vektor čísel vstupní bod.The input to a logistic regression algorithm needs be a set of label-feature vector pairs, where the "feature vector" is a vector of numbers representing the input point. Ano musíte převést sloupci "porušení", který je částečně strukturovaných a obsahuje mnoho komentáře v prostého textu, do pole reálná čísla, které může snadno pochopit na počítači.So, you need to convert the "violations" column, which is semi-structured and contains many comments in free-text, to an array of real numbers that a machine could easily understand.

Jeden standardní strojového učení pro zpracování přirozeného jazyka přístup je k přiřazení všech jedinečných slov "index" a pak předejte vektor se strojovým učením algoritmus, tak, aby každý index hodnota obsahuje relativní četnost toto slovo v textovém řetězci.One standard machine learning approach for processing natural language is to assign each distinct word an "index", and then pass a vector to the machine learning algorithm such that each index's value contains the relative frequency of that word in the text string.

MLlib poskytuje snadný způsob, jak provést tuto operaci.MLlib provides an easy way to perform this operation. Nejprve "tokenizaci" každý řetězec narušení zobrazíte jednotlivých slov v každém řetězci.First, "tokenize" each violations string to get the individual words in each string. Potom použijte HashingTF k převedení každou sadu tokeny do funkce vektoru, který je pak možné předat algoritmu logistické regrese k vytvoření modelu.Then, use a HashingTF to convert each set of tokens into a feature vector that can then be passed to the logistic regression algorithm to construct a model. Proveďte všechny kroky v pořadí pomocí "kanál".You conduct all of these steps in sequence using a "pipeline".

tokenizer = Tokenizer(inputCol="violations", outputCol="words")
hashingTF = HashingTF(inputCol=tokenizer.getOutputCol(), outputCol="features")
lr = LogisticRegression(maxIter=10, regParam=0.01)
pipeline = Pipeline(stages=[tokenizer, hashingTF, lr])

model = pipeline.fit(labeledData)

Vyhodnocení modelu pomocí jiné datové sadyEvaluate the model using another dataset

Můžete použít model, který jste vytvořili dříve na předpovědět co nových kontrol, budou výsledky, založené na porušení zásad, které byly dodrženy.You can use the model you created earlier to predict what the results of new inspections will be, based on the violations that were observed. Školení tento model na datové sadě Food_Inspections1.csv.You trained this model on the dataset Food_Inspections1.csv. Můžete použít datové sady druhé Food_Inspections2.csvdo vyhodnotit sílu tento model na nová data.You can use a second dataset, Food_Inspections2.csv, to evaluate the strength of this model on the new data. Druhé sadě dat (Food_Inspections2.csv) je ve výchozím kontejneru úložiště přidružené ke clusteru.This second data set (Food_Inspections2.csv) is in the default storage container associated with the cluster.

  1. Spusťte následující kód k vytvoření nového datového rámce, predictionsDf předpovědi generované modelem, který obsahuje.Run the following code to create a new dataframe, predictionsDf that contains the prediction generated by the model. Fragment kódu vytvoří dočasné tabulky nazývané také předpovědi podle datového rámce.The snippet also creates a temporary table called Predictions based on the dataframe.

    testData = sc.textFile('wasbs:///HdiSamples/HdiSamples/FoodInspectionData/Food_Inspections2.csv')\
                .map(csvParse) \
                .map(lambda l: (int(l[0]), l[1], l[12], l[13]))
    testDf = spark.createDataFrame(testData, schema).where("results = 'Fail' OR results = 'Pass' OR results = 'Pass w/ Conditions'")
    predictionsDf = model.transform(testDf)
    predictionsDf.registerTempTable('Predictions')
    predictionsDf.columns
    

    Zobrazený výstup by měl vypadat asi takto:You should see an output like the following:

    ['id',
        'name',
        'results',
        'violations',
        'words',
        'features',
        'rawPrediction',
        'probability',
        'prediction']
    
  2. Podívejte se na jednu předpovědí.Look at one of the predictions. Spusťte tento fragment kódu:Run this snippet:

    predictionsDf.take(1)
    

    Není k dispozici předpovědi pro první položku v sadě dat testu.There is a prediction for the first entry in the test data set.

  3. model.transform() Metoda vztahuje stejnou transformaci na žádná nová data se stejným schématem a získat predikce toho, jak klasifikovat data.The model.transform() method applies the same transformation to any new data with the same schema, and arrive at a prediction of how to classify the data. Můžete provést některé jednoduché statistické představu, jak přesný bylo předpovědí:You can do some simple statistics to get a sense of how accurate the predictions were:

    numSuccesses = predictionsDf.where("""(prediction = 0 AND results = 'Fail') OR
                                            (prediction = 1 AND (results = 'Pass' OR
                                                                results = 'Pass w/ Conditions'))""").count()
    numInspections = predictionsDf.count()
    
    print "There were", numInspections, "inspections and there were", numSuccesses, "successful predictions"
    print "This is a", str((float(numSuccesses) / float(numInspections)) * 100) + "%", "success rate"
    

    Výstup vypadá takto:The output looks like the following:

    There were 9315 inspections and there were 8087 successful predictions
    This is a 86.8169618894% success rate
    

    Logistické regrese pomocí Spark poskytuje model přesné relace mezi porušení popisy v angličtině a určuje, zda by daný obchodní úspěšné nebo neúspěšné kontroly potravin.Using logistic regression with Spark gives you an accurate model of the relationship between violations descriptions in English and whether a given business would pass or fail a food inspection.

Vytvoření vizuální znázornění do predikce.Create a visual representation of the prediction

Nyní můžete vytvořit finální vizualizace umožňující odůvodnitelný výsledky tohoto testu.You can now construct a final visualization to help you reason about the results of this test.

  1. Začnete tím, že extrahování různých předpovědi a výsledky z předpovědi dočasnou tabulku vytvořili dříve.You start by extracting the different predictions and results from the Predictions temporary table created earlier. Následující dotazy oddělení výstup jako true_positive, false_positive, true_negative, a false_negative.The following queries separate the output as true_positive, false_positive, true_negative, and false_negative. V níže uvedené dotazy vypnete vizualizace s využitím -q a také uložit výstup (s použitím -o) jako datových rámců, který lze potom použít s %%local magic.In the queries below, you turn off visualization by using -q and also save the output (by using -o) as dataframes that can be then used with the %%local magic.

    %%sql -q -o true_positive
    SELECT count(*) AS cnt FROM Predictions WHERE prediction = 0 AND results = 'Fail'
    
    %%sql -q -o false_positive
    SELECT count(*) AS cnt FROM Predictions WHERE prediction = 0 AND (results = 'Pass' OR results = 'Pass w/ Conditions')
    
    %%sql -q -o true_negative
    SELECT count(*) AS cnt FROM Predictions WHERE prediction = 1 AND results = 'Fail'
    
    %%sql -q -o false_negative
    SELECT count(*) AS cnt FROM Predictions WHERE prediction = 1 AND (results = 'Pass' OR results = 'Pass w/ Conditions')
    
  2. Nakonec použijte následující fragment kódu a vytvořte pomocí vykreslení Matplotlib.Finally, use the following snippet to generate the plot using Matplotlib.

    %%local
    %matplotlib inline
    import matplotlib.pyplot as plt
    
    labels = ['True positive', 'False positive', 'True negative', 'False negative']
    sizes = [true_positive['cnt'], false_positive['cnt'], false_negative['cnt'], true_negative['cnt']]
    colors = ['turquoise', 'seagreen', 'mediumslateblue', 'palegreen', 'coral']
    plt.pie(sizes, labels=labels, autopct='%1.1f%%', colors=colors)
    plt.axis('equal')
    

    Měl by se zobrazit následující výstup:You should see the following output:

    Spark machine learningu výstup aplikace – procenta výsečový graf neúspěšných potravin kontrol. Spark machine learning application output - pie chart percentages of failed food inspections.

    V tomto grafu "pozitivní" výsledek odkazuje na potravin neúspěšné kontroly, zatímco záporný výsledek odkazuje na úspěch kontroly.In this chart, a "positive" result refers to the failed food inspection, while a negative result refers to a passed inspection.

Poznámkový blok vypnoutShut down the notebook

Po dokončení spuštění aplikace byste měli vypínat Poznámkový blok a uvolnit tak prostředky.After you have finished running the application, you should shut down the notebook to release the resources. Provedete to tak, že v nabídce Soubor poznámkového bloku vyberete Zavřít a zastavit.To do so, from the File menu on the notebook, select Close and Halt. Toto vypnutí a zavření poznámkového bloku.This shuts down and closes the notebook.

Viz takéSee also

ScénářeScenarios

Vytvoření a spouštění aplikacíCreate and run applications

Nástroje a rozšířeníTools and extensions

Správa prostředkůManage resources