<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Nesrine Ammar on Medium]]></title>
        <description><![CDATA[Stories by Nesrine Ammar on Medium]]></description>
        <link>https://medium.com/@nesrine.ammar?source=rss-4ff5ec04fd71------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*xsZelbuPSqgwZMQgrWwN1w@2x.jpeg</url>
            <title>Stories by Nesrine Ammar on Medium</title>
            <link>https://medium.com/@nesrine.ammar?source=rss-4ff5ec04fd71------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 07:18:47 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@nesrine.ammar/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Bit El Mouna — Ayshek.com]]></title>
            <link>https://medium.com/@nesrine.ammar/bit-el-mouna-ayshek-com-f311650cfaac?source=rss-4ff5ec04fd71------2</link>
            <guid isPermaLink="false">https://medium.com/p/f311650cfaac</guid>
            <category><![CDATA[grocery-shopping]]></category>
            <category><![CDATA[tunisie]]></category>
            <category><![CDATA[tunisia]]></category>
            <category><![CDATA[couscous]]></category>
            <category><![CDATA[products-online]]></category>
            <dc:creator><![CDATA[Nesrine Ammar]]></dc:creator>
            <pubDate>Sun, 09 Jan 2022 11:33:52 GMT</pubDate>
            <atom:updated>2022-01-09T11:33:52.725Z</atom:updated>
            <content:encoded><![CDATA[<h3>Bit El Mouna — Ayshek.com</h3><p><a href="https://ayshek.com/">Ayshek</a> puts at your disposal in the <a href="https://ayshek.com/product-category/terroir/">Diari-Terroir</a> category all the necessary products from the Tunisian grocery store,<em> couscous, mhamsa, harissa,</em> <em>hrouss, bsissa, drôo</em> … to make your <strong>Mouna</strong> at home wherever you are.</p><p><strong>El oula</strong> is an ancestral culinary Tunisian tradition. For decades, the Tunisian family used to stock up on food called <strong>Mouna</strong> in Tunisia. El mouna is the food provisions that men and women prepared during the summer for the winter. This consists of raw materials, such as cereals or dried food intended for future consumption. It is an ancestral practice common to all regions of the country.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aVutL8E6U_eLyEUWQrMj_g.jpeg" /></figure><p>For example, in the summer, women go to great lengths to stock up on couscous to take advantage of the summer sun to dry it naturally. To prepare couscous and make elaoula for the family, women used to grind wheat before. Then they passed it through several sieves to separate the bran from the seeds, then they passed the rest to separate the fine semolina from the coarse semolina. The fine semolina was used to make Mhamsa. Like that, they took advantage of preparing their elaoula of Mhammas. Finally, with the coarse semolina they made couscous.</p><p>With the couscous making process going on, they would prepare the couscous with a fine sieve to give it the thickness they wanted. Then they steamed it using a couscous maker. They would spread it out on white sheets right after to dry it in the sun. In fact, that’s why he was called Cousksi Chems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/267/1*lN2G7vDJzSO9AhPI7L2Fpg.jpeg" /></figure><p>After the couscous dried, they put it in cloth bags and put them in a storage room within the house that served as a pantry called Bit El Mouna. It is in this room that the Tunisian family reserves the el oula that they prepared during the summer.</p><p>Ayshek, Tunisia at home.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f311650cfaac" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ayshek.com brings Tunisia to your home]]></title>
            <link>https://medium.com/@nesrine.ammar/ayshek-tunisia-at-your-place-11c03841264?source=rss-4ff5ec04fd71------2</link>
            <guid isPermaLink="false">https://medium.com/p/11c03841264</guid>
            <category><![CDATA[tunisia]]></category>
            <category><![CDATA[tunisie]]></category>
            <category><![CDATA[products-online]]></category>
            <category><![CDATA[shopping]]></category>
            <dc:creator><![CDATA[Nesrine Ammar]]></dc:creator>
            <pubDate>Thu, 30 Dec 2021 10:44:31 GMT</pubDate>
            <atom:updated>2021-12-30T10:50:40.735Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Ayshek épicerie tunisienne en ligne" src="https://cdn-images-1.medium.com/max/1024/1*j7DX0-r4bUkc62yzJKAKQQ.jpeg" /><figcaption>Lucienne CAPEDEVIELLE (1885–1961), “Le marché tunisien”</figcaption></figure><p><a href="https://ayshek.com/">Ayshek</a> is the leader in online sales of 100% Tunisian grocery products and handmade crafts with more than 1,000 products.</p><p>Ayshek.com is a real revolution for all Tunisians living abroad. Because all the objects they need are either scattered in dozens of different shops or they are not sold where they live! Completely innovative, Ayshek.com brings together a multitude of 100% Tunisian products in one place. With more than 1,000 products in multiple categories, Ayshek.com brings Tunisia closer to all Tunisians:</p><ul><li><a href="https://ayshek.com/product-category/artisanat/"><strong>Arts and crafts:</strong></a> floral waters, foutas, kitchen utensils natural olive wood, copper products, handmade berber carpets…</li><li><a href="https://ayshek.com/product-category/patisserie/"><strong>Traditional Tunisian pastry</strong></a></li><li><a href="https://ayshek.com/product-category/epicerie-sucree/"><strong>Sweet groceries:</strong></a> grain d’or, halva chamia, cookie and chocolate, bsissa, drôo (Sorgho), zgougou…</li><li><a href="https://ayshek.com/product-category/epicerie-salee/"><strong>Salty grocery:</strong></a> handmade harissa, couscous, 100% BIO spices, olive oil, chorba, nwasser, mhammes…</li><li><a href="https://ayshek.com/product-category/divers/"><strong>Various:</strong></a><strong> </strong>Tunisian scarf, straw products, chkobba, Rami card games…</li></ul><p>Discover all the products and offers on <a href="https://ayshek.com/">Ayshek.com</a>.</p><p>Enjoy!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=11c03841264" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beginner’s guide for Time series / date functionality]]></title>
            <link>https://medium.com/@nesrine.ammar/beginners-guide-for-time-series-date-functionality-fe2d542925ef?source=rss-4ff5ec04fd71------2</link>
            <guid isPermaLink="false">https://medium.com/p/fe2d542925ef</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[time-series-data]]></category>
            <category><![CDATA[pandas]]></category>
            <category><![CDATA[dataframes]]></category>
            <dc:creator><![CDATA[Nesrine Ammar]]></dc:creator>
            <pubDate>Sat, 11 Apr 2020 10:54:39 GMT</pubDate>
            <atom:updated>2020-04-11T11:18:32.251Z</atom:updated>
            <content:encoded><![CDATA[<h3>A beginner’s guide to Time series / date functionality</h3><p>Pandas contains extensive capabilities and features for working with time series data for all domains.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VfVg5CFBVaK6q8331a9fKg.jpeg" /></figure><h3>Timestamps and Periods</h3><p><strong>Timestamp :</strong> references particular moment in time and associates values with data points in time. Timestamped data is the most basic type of time series data that associates values with points in time. For pandas objects it means using the points in time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eXbhGsmfU2nHKCWY259yOQ.png" /></figure><p><strong>Period :</strong> represents an interval and associates things like change variables with a time span.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DGNaZuIOyzh9-xXeWBvfkg.png" /></figure><p><strong>Timestamp</strong> and <strong>Period</strong> can serve as an index. Lists of Timestamp and Period are automatically coerced to <strong>DatetimeIndex</strong> and <strong>PeriodIndex</strong> respectively.</p><p>The index of a timestamp is <strong>DatetimeIndex</strong>. Let’s look at a quick example. First, let’s create our example series df1, we’ll use the Timestamp of January 1st, 2nd and 3rd of 2020. When we look at the series, each Timestamp is the index and has a value associated with it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8EVtEWsS1Yb-bxiNSE1tVA.png" /></figure><p>Similarly, the index of period is <strong>PeriodIndex</strong>. Let’s create another example series df2. This time, we’ll use the values d, e, and f and match them with the period January, February and Mars 2020.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sdv8x9rWvJ9vXSvLIevA2Q.png" /></figure><h3>Converting to Datatime</h3><p>Now, let’s look into how to convert to <strong>Datetime</strong>. Suppose we have a list of dates as strings. If we create a DataFrame using these dates as the index. Then, we generate some randomly data, this is the DataFrame df3 that we get. Looking at the index we can see that it’s pretty messy and the dates are all in different formats.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D3VCCkMa8rgg5Ec5SRBvSQ.png" /></figure><p>Using pandas to_datetime function, pandas will try to convert these to Datetime and put them in a standard format as TimeStamp.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8FDi0HN_9J4G26Y3a24Uhg.png" /></figure><p>If you pass a single string to to_datetime, it returns a single Timestamp.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HFIXBR5cyz4hlL-s-C5KHQ.png" /></figure><p>We can also use the <strong>DatetimeIndex</strong> constructor directly. Example:</p><pre>df4 = pd.DataFrame({ &#39;name&#39;:[&#39;john&#39;,&#39;mary&#39;,&#39;peter&#39;,&#39;jeff&#39;,&#39;bill&#39;], &#39;date_of_birth&#39;:[&#39;2000-01-01&#39;, &#39;1999-12-20&#39;, &#39;2000-11-01&#39;, &#39;1995-02-25&#39;, &#39;1992-06-30&#39;],})</pre><pre>datetime_index = pd.DatetimeIndex(df4[&#39;date_of_birth&#39;].values)<br>df4 = df4.set_index(datetime_index)<br>df4.drop(&#39;date_of_birth&#39;,axis=1,inplace=True)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C_2NiwqbYUfGBbPHQTdqxA.png" /></figure><h3>Timedeltas</h3><p><strong>Time deltas</strong>: An absolute time duration. Similar to datetime.timedelta from the standard library.</p><p>We can see that when we take the difference between January 3rd and January 1st, we get a<strong> Timedelta</strong> of two days. We can also do something like find what the date and time is for 12 days past January 1st, at 8:00 AM. Then, 12 days and four seconds past.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*85YjNooa4MKiZbVcUUfxhQ.png" /></figure><h3>Working with dates in Dataframe</h3><p>Let’s create a fixed frequency DatetimeIndex of 9 dates with freq = M. <strong>date_range has </strong>four parameters start, end, periods, and freq, exactly three must be specified. If freq is omitted, the resulting DatetimeIndex will have periods linearly spaced elements between start and end.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zeGno_Jksl65zW8T9DWUNQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*41VidCJ7GG3oZU80ipO_aw.png" /></figure><p>We can use<strong> diff()</strong> to find the difference between each date’s value.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lgTxhMH0cqngNYZFI9CNxw.png" /></figure><p>Suppose we wanted to know what the <strong>mean</strong> count is for each year in our DataFrame. We can do this using <strong>resample</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NMD6OspuaUOOhOmpHmosPA.png" /></figure><p>We can use partial string indexing to find values from a particular year ‘2018’, or from a particular month ‘January 2020’, or we can even slice on a range of dates from ‘January 2019’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OqGxW0VNsMZLpyCGTxKSEA.png" /></figure><p>Let’s change the frequency of our dates in our DataFrame using <strong>asfreq</strong>. If we use this to change the frequency from ‘3M’ to ‘2M’, we’ll end up with missing values every other month. So let’s use the forward fill method on those missing values by propagating last valid observation forward to next valid.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VdYVticbHjVD500TYNauYw.png" /></figure><p>One last thing I wanted to briefly touch upon is plotting time series. Importing <strong>matplotlib.pyplot</strong>, and using the iPython magic <strong>%mapplotlib inline</strong>, will allow you to visualize the time series of df5 in the notebook.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2hfbj13W-tQ5xXZ5zOL2Uw.png" /></figure><p><strong>References:</strong></p><p><a href="https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html">https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html</a> <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.asfreq.html">https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.asfreq.html</a> <a href="https://docs.wradlib.org/en/stable/notebooks/python/mplintro.html">https://docs.wradlib.org/en/stable/notebooks/python/mplintro.html</a></p><p><strong>Thanks for reading :)</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fe2d542925ef" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Multiple confusion matrices into one curve: ROC]]></title>
            <link>https://medium.com/@nesrine.ammar/multiple-confusion-matrices-into-one-curve-roc-77f5c3d4e357?source=rss-4ff5ec04fd71------2</link>
            <guid isPermaLink="false">https://medium.com/p/77f5c3d4e357</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[machine-learnin]]></category>
            <category><![CDATA[roc-curve]]></category>
            <category><![CDATA[performance-metrics]]></category>
            <dc:creator><![CDATA[Nesrine Ammar]]></dc:creator>
            <pubDate>Wed, 08 Apr 2020 16:53:02 GMT</pubDate>
            <atom:updated>2020-04-08T16:53:02.855Z</atom:updated>
            <content:encoded><![CDATA[<p>ROC (Receiver Operator Characteristic) graphs are useful for consolidating the information from a ton of confusion matrices into a single, easy to interpret graph.</p><p>The purpose of this article is to serve as an introduction to ROC graphs and we’ll talk about:</p><ul><li><em>Classifier performance</em></li><li><em>ROC space</em></li><li><em>Random performance</em></li><li><em>Curves in ROC space</em></li><li><em>ROC curve in Python</em></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6Ui1LTBc5Xs462zHLbFsnA.jpeg" /></figure><h3><strong>Classifier performance</strong></h3><p>A classifier is a mapping from instances to predicted classes. Some classification models produce a <strong>continuous</strong> output (an estimate of the class membership probability) to which different thresholds may be applied to predict class membership. Other models produce a <strong>discrete</strong> class label indicating only the predicted class of the instance.</p><p>Given a classifier and an instance, there are four possible outcomes. If the instance is positive and it is classified as positive, it is counted as a <strong>True Positive (TP)</strong>; if it is classified as negative, it is counted as a<strong> False Negative (FN)</strong>. If the instance is negative and it is classified as negative, it is counted as a <strong>True Negative (TN)</strong>; if it is classified as positive, it is counted as a <strong>False Positive (FP)</strong>.</p><p>A two-by-two <strong>confusion matrix</strong> can be constructed representing the dispositions of the set of instances.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/356/0*50RlpFLVTPpK50XY.png" /><figcaption>Confusion matrix</figcaption></figure><figure><img alt="TPR : True Positive Rate — FPR : False Positive Rate" src="https://cdn-images-1.medium.com/max/416/1*W-ZKG-_d3jW45m6E6Pto6Q.png" /><figcaption>TPR : True Positive Rate — FPR : False Positive Rate</figcaption></figure><h3><strong>ROC space</strong></h3><p><strong>ROC</strong> graphs are two-dimensional graphs in which true positive rate is plotted on the Y axis and false positive rate is plotted on the X axis for a number of different candidate threshold values between 0 and 1. An <strong>ROC</strong> graph depicts relative tradeoffs between benefits (true positives) and costs (false positives).</p><p>Several points in <strong>ROC</strong> space are important to note. The lower left point (0, 0) represents the strategy of never issuing a positive classification, such a classifier commits no false positive errors but also gains no true positives. The point (0, 1) represents perfect classification.</p><p>A <strong>discrete</strong> classifier is one that outputs only a class label. Each discrete classifier produces an (FPR, TPR) pair corresponding to a single point in ROC space.</p><p><strong><em>Random performance</em></strong></p><p>The diagonal line y = x represents the strategy of randomly guessing a class. For example, if a classifier randomly guesses the positive class half the time, it can be expected to get half the positives and half the negatives correct; this yields the point (0.5, 0.5) in ROC space. If it guesses the positive class 90% of the time, it can be expected to get 90% of the positives correct but its false positive rate will increase to 90% as well, yielding (0.9, 0.9) in ROC space. Any classifier that appears in the lower right triangle performs worse than random guessing.</p><h3><strong>Curves in ROC space</strong></h3><p>Many classifiers, such as decision trees or rule sets, are designed to produce only a <strong>class decision</strong>, i.e., a 0 or 1 on each instance. When such a discrete classifier is applied to a test set, it yields a single confusion matrix, which in turn corresponds to one ROC point. Thus, a discrete classifier produces only a single point in ROC space.</p><p>Some classifiers, such as a Logistic Regression or a neural network, naturally yield an instance<strong> probability or score</strong>, a numeric value that represents the degree to which an instance is a member of a class. These values can be strict probabilities, in which case they adhere to standard theorems of probability.</p><p>Such a ranking or scoring classifier can be used with a <strong>threshold</strong> to produce a discrete (binary) classifier: if the classifier output is above the threshold, the classifier produces a 1, else a 0. Each <strong>threshold</strong> value produces a different point in <strong>ROC</strong> space. Conceptually, we may imagine varying a threshold from 0 to 1 and tracing a curve through <strong>ROC </strong>space.</p><p>An example of a ROC curve is present in following fig. The instances in the table are sorted by their scores, and each point in the ROC graph is labeled by the score threshold that produces it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/632/1*IymTKXKjiOoXgbwQFdbkpg.png" /><figcaption>20 instances: 10 positive instances and 10 negative instances</figcaption></figure><p>Each point in the curve is computed from the generated confusion matrix of the selected threshold. Based on the selected instances, each time we select a <strong>new threshold</strong>, we get a <strong>new confusion matrix</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Bkwnl7YYUlipQEcCnAC9vA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/676/1*DKmH9C1uOwcw75BkIsloeQ.png" /><figcaption>The ROC ‘‘curve’’ created by thresholding a test set of the 20 instances</figcaption></figure><ul><li>Smaller values on the x-axis of the plot indicate lower false positives and higher true negatives.</li><li>Larger values on the y-axis of the plot indicate higher true positives and lower false negatives.</li><li>The ROC point at (0.1, 0.5) produces its highest accuracy. This is equivalent to saying that the classifier is better at identifying likely positives than at identifying likely negatives.</li></ul><h3><strong>ROC curve in Python</strong></h3><p>First, let’s generate a random 2-class classification problem with 1000 samples using the <strong>make_classification()</strong> function of <em>sklearn</em>. Then, we split the data into random train and test subsets.</p><pre>from sklearn.datasets import make_classification<br>from sklearn.linear_model import LogisticRegression<br>from sklearn.model_selection import train_test_split<br>from sklearn.metrics import roc_curve<br>from matplotlib import pyplot</pre><pre># generate 2 class dataset<br>X, y = make_classification(n_samples=1000, n_classes=2, random_state=1)</pre><pre># split into train/test sets<br>train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.5, random_state=2)</pre><p>To compare our ROC curve of the already generated dataset with a random performance, we are going to generate a no skill prediction (majority class).</p><pre>random_probs = [0 for _ in range(len(test_y))]</pre><p>Now, we fit our model. Then, we return the probability of the samples for each class in the model, where classes are ordered by the their label.</p><pre># fit a model<br>model = LogisticRegression()<br>model.fit(train_X, train_y)</pre><pre># predict probabilities<br>probs_y = model.predict_proba(test_X)</pre><p>Let’s keep probabilities for the positive outcome only.</p><pre>probs_y = probs_y[:, 1]</pre><p>We calculate the ROC curves using the roc_curve() function.</p><pre>ns_fpr, ns_tpr, _ = roc_curve(test_y, random_probs)<br>lr_fpr, lr_tpr, _ = roc_curve(test_y, probs_y)</pre><p>Finally, we can visualize the ROC curve.</p><pre># plot the roc curve for the model<br>pyplot.plot(ns_fpr, ns_tpr, linestyle=&#39;--&#39;, label=&#39;No Skill&#39;)<br>pyplot.plot(lr_fpr, lr_tpr, marker=&#39;.&#39;, label=&#39;Logistic&#39;)<br># axis labels<br>pyplot.xlabel(&#39;False Positive Rate&#39;)<br>pyplot.ylabel(&#39;True Positive Rate&#39;)<br># show the legend<br>pyplot.legend()<br># show the plot<br>pyplot.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*v47sQuSPARl1Cp5yQQ_0zw.png" /></figure><p>To learn more about ROC curves, here is some references.</p><ul><li><a href="https://machinelearningmastery.com/roc-curves-and-precision-recall-curves-for-classification-in-python/">How to Use ROC Curves and Precision-Recall Curves for Classification in Python - Machine Learning Mastery</a></li><li><a href="https://www.sciencedirect.com/science/article/abs/pii/S016786550500303X">An introduction to ROC analysis</a></li></ul><p><strong>Thanks for reading.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=77f5c3d4e357" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How learning_curve function from scikit-learn works?]]></title>
            <link>https://medium.com/@nesrine.ammar/how-learning-curve-function-from-scikit-learn-works-692d7d566d17?source=rss-4ff5ec04fd71------2</link>
            <guid isPermaLink="false">https://medium.com/p/692d7d566d17</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[scikit-learn]]></category>
            <category><![CDATA[learning-curve]]></category>
            <dc:creator><![CDATA[Nesrine Ammar]]></dc:creator>
            <pubDate>Thu, 02 Apr 2020 13:00:55 GMT</pubDate>
            <atom:updated>2020-04-02T18:27:09.156Z</atom:updated>
            <content:encoded><![CDATA[<p>Determines cross-validated training and test scores for different training set sizes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0ZQa2qcBZOj-pn2cABbxrQ.jpeg" /></figure><p>A cross-validation generator splits the whole dataset k times in training and test data. Subsets of the training set with varying sizes will be used to train the estimator and a score for each training subset size and the test set will be computed. Afterwards, the scores will be averaged over all k runs for each training subset size.</p><blockquote><strong>learning_curve(estimator</strong>, <strong>X</strong>, <strong>y</strong>, <strong>groups</strong>=None, <strong>train_sizes</strong>=np.linspace(0.1, 1.0, 5), <strong>cv</strong>=None,<strong> scoring</strong>=None, <strong>exploit_incremental_learning</strong>=False, <strong>n_jobs</strong>=None, <strong>pre_dispatch</strong>=”all”, verbose=0, <strong>shuffle</strong>=False, <strong>random_state</strong>=None, <strong>error_score</strong>=np.nan, <strong>return_times</strong>=False<strong>)</strong></blockquote><p>Let’s see how learning_curve() do the splits if <strong>shuffle</strong>=False. To do so, we are going to take a look at the <strong>source</strong> <strong>code</strong> of the <strong>learning_curve</strong> from <strong>sklearn</strong>.</p><p>First let’s generate a random classification dataset using.</p><pre>from sklearn.datasets import make_classification</pre><pre>X, y = make_classification(n_samples=10000, n_classes=2, random_state=1)</pre><p>From the source code of sklean, let’s see how <strong>learning_curve</strong> works, the check_cv returns value is a cross-validator which generates the train/test splits via the split method. The classifier parameter allows to check whether the task is a classification task, in which case stratified KFold will be used. is_classifier returns True if the given estimator is a classifier.</p><pre>from sklearn.linear_model import LogisticRegression<br>from sklearn.model_selection import check_cv<br>from sklearn.base import is_classifier<br>from sklearn.utils import check_random_state</pre><pre>cv = 5<br>estimator= LogisticRegression()<br>cv = check_cv(cv, y, classifier=is_classifier(estimator))<br>cv_iter = list(cv.split(X, y))</pre><p>cv_iter shape is a (5, 2). In our case, cv = 5, so there will be five splits. For each split, indices are generated to split data into training and test set. Thus, each row in cv_iter designates a split, the first column designates the training set indices for that split and second column designates the testing set indices for that split.</p><p>Let’s take a look at the splits indices generated for the train and test set.</p><pre>for train, test in cv_iter:<br>    print(train, test)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Cdv2Dkz6SONvi2sR_uAu8Q.png" /></figure><p>For a train_sizes = [100, 1000, 1500], let’s inspect the other variables to see what learning_curve() returned:</p><pre>from sklearn.linear_model import LogisticRegression<br>from sklearn.model_selection import learning_curve<br><br>train_sizes, train_scores, validation_scores = learning_curve(<br>estimator = LogisticRegression(),<br>X = X, y = y, train_sizes = [100, 1000, 1500], cv = 5)</pre><p>Since we specified 3 training set sizes, you might have expected 3 values for each kind of score (training score and validation score). Instead, we got 3 rows for each, and every row has 5 error scores because in our case, cv = 5, so there will be five splits. For each split, an estimator is trained for every training set size specified. Each column in the two arrays above designates a split, and each row corresponds to a set size. Below is a table for the training error scores to help you understand the process better:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1008/1*IDhOW-snV3-kpHV_Q9fAWQ.png" /></figure><p>To plot the <strong>learning curves</strong>, we need only a single error score per training set size, not 5. For this reason, we take the mean value of each row.</p><pre>train_scores_mean = train_scores.mean(axis = 1)<br>validation_scores_mean = validation_scores.mean(axis = 1)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/634/1*RcCB0h7cEjEMZYyizDhTOA.png" /></figure><p>Let’s make an important observation. You might have noticed that some error scores on the <em>training</em> sets are the same. This is caused by not randomizing the <em>training</em> data for each split. Let’s take a look at the learning_curve source code from sklearn.model_selection: we see that the train set indices for each set train size is selected from the beginning of each train set, leading to have the same train set for 4 splits when the train sizes are small, e.g. [100, 1000, 1500]. We can check that again at the generated splits above.</p><pre>train_test_proportions = []<br>for train, test in cv_iter:<br>    for n_train_samples in train_sizes_abs:<br>        train_test_proportions.append((train[:n_train_samples], test))</pre><p>This figure illustrates this observation with cv = 5, the first split the train set is select from the indices following the validation set. However, for the 4 remaining splits the train set is select from the beginning until the set size. If the set size equals 100, we’ll be having the same train set four times.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AuN2a4r1KIS-ccKzseWacA.png" /></figure><p>To stop this behavior, we need to set the shuffle parameter to True in the learning_curve() function. This will randomize the indices for the <em>training</em> data for each split. shuffle indicates whether to shuffle <strong>training data</strong> before taking prefixes of it based on train_sizes.</p><p>Let’s take a look at the <strong>source code</strong> from <strong>sklearn</strong> behind the learning_curve function for the shuffle parameter :</p><pre>if shuffle:<br>    rng = check_random_state(random_state)<br>    cv_iter = ((rng.permutation(train), test) for train, test in cv_iter)</pre><p>Now, let’s check the generated splits when shuffle = True. We see that the train sets (the first column) indices are shuffled for each split, in our case we have 5 splits (each row designates a split) as cv = 5.</p><pre>for train, test in cv_iter:<br>    print(train, test)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xi2sG9syTjdKHPBToLmUIQ.png" /></figure><p>Using the learning_curve() function we just have to set shuffle = True.</p><pre>train_sizes, train_scores, validation_scores = learning_curve(<br>estimator = LogisticRegression(),<br>X = X, y = y, train_sizes = [100, 1000, 1500], cv = 5, <br>shuffle = True, random_state = 45)</pre><h4><a href="https://scikit-learn.org/stable/modules/classes.html#module-sklearn.model_selection">sklearn.model_selection</a>.learning_curve :</h4><p><a href="https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.learning_curve.html">sklearn.model_selection.learning_curve</a></p><p>Source code : <a href="https://github.com/scikit-learn/scikit-learn/blob/95d4f0841/sklearn/model_selection/_validation.py#L1080">https://github.com/scikit-learn/scikit-learn/blob/95d4f0841/sklearn/model_selection/_validation.py#L1080</a></p><h4>Thanks for reading.</h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=692d7d566d17" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How do I choose performance metrics for classification algorithm?]]></title>
            <link>https://medium.com/@nesrine.ammar/how-do-i-choose-performance-metrics-for-classification-algorithm-a575c592c840?source=rss-4ff5ec04fd71------2</link>
            <guid isPermaLink="false">https://medium.com/p/a575c592c840</guid>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[classification]]></category>
            <category><![CDATA[metrics]]></category>
            <dc:creator><![CDATA[Nesrine Ammar]]></dc:creator>
            <pubDate>Tue, 31 Mar 2020 17:29:50 GMT</pubDate>
            <atom:updated>2020-03-31T17:52:07.615Z</atom:updated>
            <content:encoded><![CDATA[<p>Pick a performance metric that reflects the kind of task your algorithm is performing and how you would like your algorithm to behave.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PZCQ6sliqHQ-UfD8WLazBQ.jpeg" /><figcaption>Garden by the Bay, Singapore</figcaption></figure><p>In <strong>classification</strong> problems we are working with <em>discrete</em> data and trying to make discrete predictions, therefore, below are some metrics that are widely used in classification problems.</p><h3>Confusion matrix</h3><p>A two-by-two <strong>confusion matrix</strong> can be constructed representing the dispositions of the set of instances.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UY64rMy1eKjffXWi4gnASQ.png" /></figure><ul><li><strong>True Positive : </strong>if the instance is positive and it is classified as positive;</li><li><strong>False Negative : </strong>if the instance is positive and it is classified as negative;</li><li><strong>True Negative : </strong>if the instance is negative and it is classified as negative;</li><li><strong>False Positive : </strong>if the instance is negative and it is classified as positive.</li></ul><h3>Accuracy</h3><p>Accuracy measures the proportion of instances that are classified correctly. It is the most straightforward performance metric for classifiers quality.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/926/1*2PftRuLMzA1AzzU-9Hp0Fw.png" /></figure><p>Keep in mind that accuracy metric has some shortcomings: it doesn’t work well with skewed classes that can have many items of the same class and few into the other class.</p><p>Let’s say we have 5 instances of class 1 and 95 instances of class 0 in our train set. We have trained the classifier and we tested it on a test set and find that we’re making 99% correct predictions. Seems like a really impressive result, right. We’re correct 99% percent of the time. In this case, the model just predicts 0 no matter what the input is.</p><p>So, if we have very skewed classes it becomes much harder to use just classification accuracy, because we can get very high classification accuracy, and it’s not always clear if doing so is really improving the quality of your classifier because predicting y equals 0 all the time doesn’t seem like a particularly good classifier.</p><h3>Recall</h3><p>Recall Metric shows how many True Positives the model has classified from the total number of positive values.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/550/1*NCTrW7Hn6SFRq00T0fkzow.png" /></figure><p>In medical testing, if we have a model that predicts no one has cancer all the time, then, this classifier will have a <strong>recall</strong> = 0 because there won’t be any <strong>True Positive</strong>. A learning algorithm, that is predicting all patients as do not have cancer when some of them actually are positives, isn’t a good classifier. In such classification issue, it is critical to focus on <strong>False Negatives</strong> and better to minimize them.</p><p>So if we want to focus on <strong>False Negatives</strong>, we have to make recall as higher as possible. If we are looking at performance on a specific class, then we are looking at the recall. <strong>High recall</strong> actually reflects a good classifier, and this gives us a more useful evaluation metric that is a more direct way to actually understand whether, the trained algorithm is be doing well.</p><h3>Precision</h3><p>This metric represents the number of True Positives which are really positive compared to the total number of positively predicted values.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/614/1*1zX9Dx4k1MA4c2sMTFwWQw.png" /></figure><p>First, let’s consider the problem of <strong>cancer classification</strong>. For the patients that we went to and we told them, “ You have cancer.” Of all those patients, what fraction of them actually have cancer? So that’s called precision. High precision means that for most of them do have cancer and we had actually made accurate predictions on them. In such case, minimizing <strong>False Negatives</strong> is more critical and important than minimizing <strong>False Positives.</strong></p><p>We consider an other example where minimizing <strong>False Positive</strong>s is how we want our classification algorithm to behave : let’s say we would like to make a spam and not spam classification. The data is labeled as follow : 1 refers to ‘spam’ email and 0 refers to ‘not spam’. Say that the learning algorithm classified an important email as ‘spam’, considered as a <strong>False Positive.</strong> Then, in this case minimizing <strong>False Positives</strong> is more important than <strong>False Negatives.</strong></p><p>So for the problem of <strong>skewed</strong> classes <strong>precision recall</strong> gives us more direct insight into how the learning algorithm is doing and this is often a much better way to evaluate our classifiers.</p><h3><strong>Precision and Recall tradeoff</strong></h3><p>For example, using logistic regression to classify patients as having cancer y=1 or not y=0, we can end up predicting y=1 when the probability output is greater than some threshold. And so in general, for most classifiers there is going to be a trade off between precision and recall as we vary the value of this threshold that we join here, you can actually plot out some curve that trades off precision and recall. If the threshold is low, we can increase the chance to catch patient having cancer, resulting in high recall. However, a low threshold also results many False Positives which leads to low precision. If the threshold is very high, the situation is the other way round: precision is good while recall is low. Precision/recall-curves are used to visualize this trade-off by plotting precision over recall for various threshold levels.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/559/0*vgcoVTPQr8-T2UUG.png" /><figcaption>precision/recall-curves visualizing the trade-off between precision and recall</figcaption></figure><p>Curve<strong> A</strong> shows a classifier that is performing quite poorly: there is no point, where precision and recall simultaneously have high values. The curve <strong>B</strong> performs slightly better. Curve <strong>C</strong> reflects an algorithm whose predictions are mostly correct.</p><h3>F1 score</h3><p>From <strong>recall</strong> and <strong>precision</strong> another metric is derived <strong>F1 score</strong>. It reaches its best value at 1 and worst at 0.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*U0PhE0iEhKscYGxsSkbE7Q.png" /></figure><p>So instead of looking to two metrics precision and recall, we use just one metric to decide much more quickly which algorithm is better. One natural way that you might try is to look at the<strong> average </strong>precision and recall and look at what classifier has the highest average value. But this turns out not to be such a good solution, because similar to the example we had earlier it turns out that if we have a classifier that predicts y=1 all the time, then if we do that we get a very high recall, but we end up with a very low value of precision, see algorithm 3 we ended up having a good average value.</p><p>In contrast, there’s a different way for combining precision and recall. This is called the F1 Score and it uses that formula. And so in this example, here are the F1 Scores that we got.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dTN6wEVbQNoUgXA1tKe5HQ.png" /></figure><p>The higher the quality of the algorithm, the higher the F1 Score. If precision and recall both approach zero, the limit of the F1 Score is also zero.</p><p>More references about performance metrics for classification problems:</p><ul><li><a href="https://www.coursera.org/learn/machine-learning/lecture/tKMWX/error-metrics-for-skewed-classes">Error Metrics for Skewed Classes - Machine Learning System Design | Coursera</a></li><li><a href="https://machinelearningmastery.com/metrics-evaluate-machine-learning-algorithms-python/">Metrics To Evaluate Machine Learning Algorithms in Python - Machine Learning Mastery</a></li></ul><p><strong>Thanks for reading.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a575c592c840" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A beginner’s guide to NumPy]]></title>
            <link>https://medium.com/@nesrine.ammar/a-beginners-guide-to-numpy-fcc012841ac5?source=rss-4ff5ec04fd71------2</link>
            <guid isPermaLink="false">https://medium.com/p/fcc012841ac5</guid>
            <category><![CDATA[numpy]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Nesrine Ammar]]></dc:creator>
            <pubDate>Tue, 24 Mar 2020 17:39:21 GMT</pubDate>
            <atom:updated>2020-03-24T17:51:23.371Z</atom:updated>
            <content:encoded><![CDATA[<p>This article presents the basics of NumPy , a package for scientific computing with Python.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/775/1*dWt72wZzP7TwErFXYDVkWw.png" /></figure><p>We’ll cover a few categories of basic array manipulations here:</p><ul><li><em>Creating NumPy arrays</em></li><li><em>Reshaping of arrays</em></li><li><em>Math operations with NumPy</em></li><li><em>Indexing and slicing of arrays</em></li><li><em>Iterating over arrays</em></li></ul><p>First, let’s import NumPy as np. This lets us use the shortcut np to refer to NumPy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JJVqWUaIasBHss6mfr3LDg.png" /></figure><p>Now let’s make our first array using the <strong>array()</strong> function.</p><p>In general, numerical data arranged in an array-like structure in Python can be converted to arrays. The most obvious examples are lists and tuples.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PSedM1iLvmxp-BDYRjGyGA.png" /></figure><p>The <strong>shape</strong> attribute is used to return the current shape of an array. It is a tuple of integers giving the lengths of the corresponding array dimensions.</p><p>For the <strong>arange()</strong> function, we pass in a start, a stop, and a step size, and it returns evenly spaced values within a given interval.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HKaZJl3j_9VzwPbT_sUf9g.png" /></figure><p>So suppose we wanted to convert this array of numbers to a three by five array. We can use <strong>reshape</strong> to do that.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qa22lvm0fSvq98HVS7t1Dg.png" /></figure><p>The <strong>linspace()</strong> function is similar to <strong>arange</strong>, except we tell it how many numbers we want returned, and it will split up the interval accordingly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4iBlAiwcv9cC4Jwd2L_1rg.png" /></figure><p>We can use<strong> resize</strong> to return a new array with the specified shape.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FcQdBmyzuUjtsOELcvPnmw.png" /></figure><p>NumPy provides several functions to create arrays of given shape, type and initialized values. <strong>ones()</strong> returns an array of ones, <strong>zeros()</strong> an array of zeros. <strong>eye()</strong> returns an array with ones on the diagonal and zeros everywhere else, and <strong>diag()</strong> constructs a diagonal array.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5N_L89S-yqvJTq1iUO6BtA.png" /></figure><p>To create an array with repeated values, we can pass in a repeated list, or we can use the Numpy <strong>repeat()</strong> function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nb9UJz_Oh4HVYWZfddVkcw.png" /></figure><p>We can also combine arrays to create new ones using for example the <strong>vstack()</strong> and <strong>hstack()</strong> function to stack arrays in sequence vertically (row wise) and in sequence horizontally (column wise), respectively.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IW-NgRL3fr0mogd0jsv1kQ.png" /></figure><p>Now, let’s look into some of the operations you can do with Numpy arrays! Performing addition, subtraction, multiplication, and division is straightforward, as is raising all the numbers of an array to a power.</p><p>The <strong>dot()</strong> function returns the dot product of two arrays. For 2-D vectors, it is the equivalent to matrix multiplication. For 1-D arrays, it is the inner product of the vectors.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Pp2QKgrjPT7LoJh9_AvZIA.png" /></figure><p>Let’s create a new array using a previous array y and its squared values. The shape of this array is (2, 3). We can also take the transpose of an array using the <strong>T method</strong>, permute the dimensions of an array.. The shape of the transposed array is (3, 2).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zIXlaDVJoJKeYycjldYT3A.png" /></figure><p>NumPy also has many useful math functions that we can use. <strong>sum()</strong> function returns the sum of array elements over a given axis. <strong>max()</strong> returns the maximum of an array or maximum along an axis. <strong>min()</strong> returns the minimum of an array or minimum along an axis. <strong>mean()</strong> returns the average of the array elements. The average is taken over the flattened array by default, otherwise over the specified axis.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yUgl9QfaYRNLr6_JOMo3nw.png" /></figure><p>To find the index of a maximum or minimum value, we can use <strong>argmax()</strong> and <strong>argmin()</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-z34mxMejzYaJXy8CugTqw.png" /></figure><p>Let’s learn about indexing and slicing!</p><p>We first create an array with the squares of 0 through 12. We can use bracket notation to get the value at a particular index, and the colon notation to get a range. See the following examples.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tVLtKZAxI_ri56HrKpne0w.png" /></figure><p>Let’s get a slice of the last three elements of the array.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SExyg2CP22RUqrVo0sVUdQ.png" /></figure><p>Here, we’re starting fourth from the end to the beginning of the array and counting backwards by three.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wiQnYZydv2hbbHuw55sHCg.png" /></figure><p>The following example shows how this extends to a two-dimensional array.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xscPePBVaZlixe27wPIYkA.png" /></figure><p>This example returns an array that is the elements of our original array that are greater than 31.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1sI148szn-WtIM3nsuk1eQ.png" /></figure><p>The following assignment will take those elements within our original array and assign them to a new value 0.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7rANUraoVvHCfdoMWPlY_w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q8J7TvCAa1J9dJ-xp9bwGQ.png" /></figure><p>Let’s create a new array r2, which is a slice of the array r. Now, let’s set all the elements of this array to one. When we look at the original version of the array r, we can see that the slice in r2 in r has also been changed.</p><p>If we wish to create a copy of the r array that will not change the original array, we can use the <strong>copy()</strong> function of NumPy. We see that if we change the values of all the elements in r_copy to 5, r remains unchanged.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OVaxQoxcau1zAZEDWWQa_w.png" /></figure><p>Lastly, let’s see how to iterate over arrays.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-WUtSil2iqIcWa-JW8aQHQ.png" /></figure><p>If we wish to iterate through two arrays, we can use <strong>zip()</strong>. See the example below :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*83qYlyPSUa0aLL7n1GaOOw.png" /></figure><p>If you’re interested to learn more about NumPy:</p><p>More details about functions and modules in NumPy, describing what they are and what they do in <a href="https://docs.scipy.org/doc/">https://docs.scipy.org/doc/</a></p><p>A tutorial with more examples in:</p><p><a href="https://numpy.org/devdocs/user/quickstart.html">NumPy quickstart - NumPy v1.23.dev0 Manual</a></p><p><strong>Thanks for reading.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fcc012841ac5" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>