diff --git a/ch06/Text_Classification.ipynb b/ch06/Text_Classification.ipynb index 1fa429f..7b8ccd8 100644 --- a/ch06/Text_Classification.ipynb +++ b/ch06/Text_Classification.ipynb @@ -47,18 +47,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "You are working on a local system.\n", - "Files will be searched relative to \"..\".\n" - ] - } - ], + "outputs": [], "source": [ "import sys, os\n", "ON_COLAB = 'google.colab' in sys.modules\n", @@ -79,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -102,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -143,87 +134,9 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Index(['Issue_id', 'Priority', 'Component', 'Duplicated_issue', 'Title',\n", - " 'Description', 'Status', 'Resolution', 'Version', 'Created_time',\n", - " 'Resolved_time'],\n", - " dtype='object')\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Issue_idPriorityComponentTitleDescription
38438239715P3UINo property tester for TestCaseElement for property projectNatureI20080613-2000; ; Not sure if this belongs to JDT/Debug or Platform/Debug.; ; I saw this error message several times today in my error log but Im not yet sure how to reproduce it.; ; -- Error Details --; Date: Sun Jul 06 16:04:00 CEST 2008; Message: No property tester contributes a property org.eclipse.debug.ui.projectNature to type class org.eclipse.jdt.internal.junit.model.TestCaseElement; Severity: Error; Plugin: org.eclipse.core.expressions
44129395007P3UI[package explorer] Refresh action not available on Java package foldersM3.; ; F5 (Refresh) is available as a context menu entry for ordinary source folders but not for Java package folders in the e4 Java Package explorer.; ; Please restore the 3.x functionality.
\n", - "
" - ], - "text/plain": [ - " Issue_id Priority Component \\\n", - "38438 239715 P3 UI \n", - "44129 395007 P3 UI \n", - "\n", - " Title \\\n", - "38438 No property tester for TestCaseElement for property projectNature \n", - "44129 [package explorer] Refresh action not available on Java package folders \n", - "\n", - " Description \n", - "38438 I20080613-2000; ; Not sure if this belongs to JDT/Debug or Platform/Debug.; ; I saw this error message several times today in my error log but Im not yet sure how to reproduce it.; ; -- Error Details --; Date: Sun Jul 06 16:04:00 CEST 2008; Message: No property tester contributes a property org.eclipse.debug.ui.projectNature to type class org.eclipse.jdt.internal.junit.model.TestCaseElement; Severity: Error; Plugin: org.eclipse.core.expressions \n", - "44129 M3.; ; F5 (Refresh) is available as a context menu entry for ordinary source folders but not for Java package folders in the e4 Java Package explorer.; ; Please restore the 3.x functionality. " - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "file = \"eclipse_jdt.csv\"\n", "file = f\"{BASE_DIR}/data/jdt-bugs-dataset/eclipse_jdt.csv.gz\" ### real location\n", @@ -234,155 +147,31 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
11811
Issue_id33113
PriorityP3
ComponentDebug
TitleEvaluating for loop suspends in URLClassLoader
DescriptionDebug to a breakpoint in some HelloWorld program. In the DisplayView; highlight and ; Display the following code snippet:; ; for (int i = 0; i < 10; i++) {; System.out.println(i);; }; ; Instead of just reporting No explicit return value; the debugger suspends in the ; URLClassLoader; apparently trying to load the class int. You have hit Resume several ; more times before the evaluation completes. The DebugView does not indicate why it ; has stopped (the thread is just labelled Evaluating). This behavior does not happen if ; you turn of the Suspend on uncaught exceptions preference.
StatusVERIFIED
ResolutionFIXED
Version2.1
Created_time2003-02-25 15:40:00 -0500
Resolved_time2003-03-05 17:11:17 -0500
\n", - "
" - ], - "text/plain": [ - " 11811\n", - "Issue_id 33113 \n", - "Priority P3 \n", - "Component Debug \n", - "Title Evaluating for loop suspends in URLClassLoader \n", - "Description Debug to a breakpoint in some HelloWorld program. In the DisplayView; highlight and ; Display the following code snippet:; ; for (int i = 0; i < 10; i++) {; System.out.println(i);; }; ; Instead of just reporting No explicit return value; the debugger suspends in the ; URLClassLoader; apparently trying to load the class int. You have hit Resume several ; more times before the evaluation completes. The DebugView does not indicate why it ; has stopped (the thread is just labelled Evaluating). This behavior does not happen if ; you turn of the Suspend on uncaught exceptions preference.\n", - "Status VERIFIED \n", - "Resolution FIXED \n", - "Version 2.1 \n", - "Created_time 2003-02-25 15:40:00 -0500 \n", - "Resolved_time 2003-03-05 17:11:17 -0500 " - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ + "import pandas as pd\n", + "\n", "df = df.drop(columns=['Duplicated_issue']) ###\n", - "pd.set_option('display.max_colwidth', -1)\n", + "pd.set_option('display.max_colwidth', None)\n", "df.sample(1, random_state=123).T" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "df['Priority'].value_counts().sort_index().plot(kind='bar')" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "UI 17479\n", - "Core 13669\n", - "Debug 7542 \n", - "Text 5901 \n", - "APT 406 \n", - "Doc 299 \n", - "Name: Component, dtype: int64" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "df['Component'].value_counts()" ] @@ -403,20 +192,9 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Index(['Priority', 'text'], dtype='object')" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "df = df[['Title','Description','Priority']]\n", "df = df.dropna()\n", @@ -427,64 +205,9 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Prioritytext
42439P3Regression in TypeHierarchyPerfTest#testOpenObjectHierarchy() I20110329-0800; ; http://download.eclipse.org/eclipse/downloads/drops/I20110329-0800/performance/eplnx2/Scenario415.html; ; The regression can be seen on all platforms.; ; Also TypeHierarchyPerfTest#testOpenCollHierarchy() shows erratic behavior on all platforms.
30486P3introduce indirection: misleading warning about duplicate method 3.2 M5 testing; ; have two classes; Foo and Bar; Foo with method m; refactor introduce indirection on m; warning: duplicate method m in declaring class (ok); change declaring class to Bar; ; the warning is still there; despite that Bar does not contain any methods; expected: the warning goes away as the declaring class is changed
\n", - "
" - ], - "text/plain": [ - " Priority \\\n", - "42439 P3 \n", - "30486 P3 \n", - "\n", - " text \n", - "42439 Regression in TypeHierarchyPerfTest#testOpenObjectHierarchy() I20110329-0800; ; http://download.eclipse.org/eclipse/downloads/drops/I20110329-0800/performance/eplnx2/Scenario415.html; ; The regression can be seen on all platforms.; ; Also TypeHierarchyPerfTest#testOpenCollHierarchy() shows erratic behavior on all platforms. \n", - "30486 introduce indirection: misleading warning about duplicate method 3.2 M5 testing; ; have two classes; Foo and Bar; Foo with method m; refactor introduce indirection on m; warning: duplicate method m in declaring class (ok); change declaring class to Bar; ; the warning is still there; despite that Bar does not contain any methods; expected: the warning goes away as the declaring class is changed " - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from blueprints.preparation import clean\n", "df['text'] = df['text'].apply(clean)\n", @@ -501,18 +224,9 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Size of Training Data 36040\n", - "Size of Test Data 9011\n" - ] - } - ], + "outputs": [], "source": [ "X_train, X_test, Y_train, Y_test = train_test_split(df['text'],\n", " df['Priority'],\n", @@ -533,7 +247,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -543,20 +257,9 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "LinearSVC(random_state=0, tol=1e-05)" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "model1 = LinearSVC(random_state=0, tol=1e-5)\n", "model1.fit(X_train_tf, Y_train)" @@ -571,7 +274,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -580,17 +283,9 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Accuracy Score - 0.8761513705471091\n" - ] - } - ], + "outputs": [], "source": [ "Y_pred = model1.predict(X_test_tf)\n", "print ('Accuracy Score - ', accuracy_score(Y_test, Y_pred))" @@ -598,27 +293,9 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "DummyClassifier(random_state=42, strategy='most_frequent')" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Accuracy Score - 0.8769281988680502\n" - ] - } - ], + "outputs": [], "source": [ "clf = DummyClassifier(strategy='most_frequent', random_state=42)\n", "clf.fit(X_train, Y_train)\n", @@ -635,24 +312,9 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 19, 1, 199, 4, 0],\n", - " [ 6, 18, 576, 8, 0],\n", - " [ 8, 48, 7827, 19, 0],\n", - " [ 0, 5, 192, 31, 0],\n", - " [ 0, 0, 50, 0, 0]])" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "Y_pred = model1.predict(X_test_tf)\n", "confusion_matrix(Y_test, Y_pred)" @@ -660,30 +322,9 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "## Old code:\n", "\n", @@ -702,28 +343,9 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " precision recall f1-score support\n", - "\n", - " P1 0.58 0.09 0.15 223\n", - " P2 0.25 0.03 0.05 608\n", - " P3 0.89 0.99 0.93 7902\n", - " P4 0.50 0.14 0.21 228\n", - " P5 0.00 0.00 0.00 50\n", - "\n", - " accuracy 0.88 9011\n", - " macro avg 0.44 0.25 0.27 9011\n", - "weighted avg 0.82 0.88 0.83 9011\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "print(classification_report(Y_test, Y_pred))" ] @@ -737,25 +359,9 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "P3 4000\n", - "P2 3038\n", - "P4 1138\n", - "P1 1117\n", - "P5 252 \n", - "Name: Priority, dtype: int64" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Filter bug reports with priority P3 and sample 4000 rows from it\n", "df_sampleP3 = df[df['Priority'] == 'P3'].sample(n=4000, random_state=123)\n", @@ -779,47 +385,9 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Size of Training Data 7636\n", - "Size of Test Data 1909\n" - ] - }, - { - "data": { - "text/plain": [ - "LinearSVC(random_state=0, tol=1e-05)" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Accuracy Score - 0.5028810895756941\n", - " precision recall f1-score support\n", - "\n", - " P1 0.44 0.29 0.35 223\n", - " P2 0.45 0.48 0.46 608\n", - " P3 0.56 0.66 0.60 800\n", - " P4 0.47 0.34 0.39 228\n", - " P5 0.00 0.00 0.00 50\n", - "\n", - " accuracy 0.50 1909\n", - " macro avg 0.38 0.35 0.36 1909\n", - "weighted avg 0.48 0.50 0.49 1909\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "# Loading the balanced dataframe\n", "\n", @@ -857,27 +425,9 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "DummyClassifier(random_state=21, strategy='stratified')" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Accuracy Score - 0.31691985332634887\n" - ] - } - ], + "outputs": [], "source": [ "clf = DummyClassifier(strategy='stratified', random_state=21)\n", "clf.fit(X_train, Y_train)\n", @@ -887,67 +437,9 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
textactualpredicted
8461Variable view show old instance using build 20020917; ; Step to reproduce:; 1) create a selfhosting workspace (20020917).; 2) put a breakpoint in CompletionEngine at line 774 ; CompilationUnitDeclaration parsedUnit = parser.dietParse(...).; 3) create a launch configuration Runtime Workbench.; 4) launch this configuration in debugger.; 5) create a Java project.; 6) create a class.; 7) do ctrl+space in editor to hit breakpoint.; 8) look the id of the parser field of CompletionEngine in the variable view .; 9) step into parser.dietParse(...).; 10) in variable view the id of the parser is the same as step 8.; 11) do resume.; 12) do ctrl+space in editor to hit breakpoint.; 13) the id of the parser field is the same as step 8 (but it should not be the ; same instance of CompletionParser).; 14) step into parser.dietParse(...).; 15) the id of parser is a new id (as expected).; ; It seems that variable view doesnt show the right instance in the step 13.P1P1
34854model proxy created for Java debug target in var view While investigating bug 177910; I found that the deltas for thread creation were duplicated in the output produced by Walter. I discovered that two model proxies are created for Java debug targets because the JavaModelProxyFactory does not limit the creation of proxies for targets to the debug view (as it should).P2P2
\n", - "
" - ], - "text/plain": [ - " text \\\n", - "8461 Variable view show old instance using build 20020917; ; Step to reproduce:; 1) create a selfhosting workspace (20020917).; 2) put a breakpoint in CompletionEngine at line 774 ; CompilationUnitDeclaration parsedUnit = parser.dietParse(...).; 3) create a launch configuration Runtime Workbench.; 4) launch this configuration in debugger.; 5) create a Java project.; 6) create a class.; 7) do ctrl+space in editor to hit breakpoint.; 8) look the id of the parser field of CompletionEngine in the variable view .; 9) step into parser.dietParse(...).; 10) in variable view the id of the parser is the same as step 8.; 11) do resume.; 12) do ctrl+space in editor to hit breakpoint.; 13) the id of the parser field is the same as step 8 (but it should not be the ; same instance of CompletionParser).; 14) step into parser.dietParse(...).; 15) the id of parser is a new id (as expected).; ; It seems that variable view doesnt show the right instance in the step 13. \n", - "34854 model proxy created for Java debug target in var view While investigating bug 177910; I found that the deltas for thread creation were duplicated in the output produced by Walter. I discovered that two model proxies are created for Java debug targets because the JavaModelProxyFactory does not limit the creation of proxies for targets to the debug view (as it should). \n", - "\n", - " actual predicted \n", - "8461 P1 P1 \n", - "34854 P2 P2 " - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "## Create a dataframe combining the Title and Description, \n", "## Actual and Predicted values that we can explore\n", @@ -960,67 +452,9 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
textactualpredicted
40065Too many semicolons after constructor completion I20090611-1540; ; public class Try {; Object m() {; return null;; }; }; ; select null; type new Runna; Ctrl+Space; press Enter to select the anonymous proposal for Runnable(); ; => Result:; ; public class Try {; Object m() {; return new Runnable() {; ; public void run() {; // TODO Auto-generated method stub; ; }; };;;; };P2P3
7178Next/Previous buttons have double image 20020606 XP; ; 1) Open Java editor; Outline; Search view; 2) Click in editor; click in outline; click in search; 3) Note that the show previous/ show next buttons have a double image.; Hover over the button and the imgae is correctedP2P3
\n", - "
" - ], - "text/plain": [ - " text \\\n", - "40065 Too many semicolons after constructor completion I20090611-1540; ; public class Try {; Object m() {; return null;; }; }; ; select null; type new Runna; Ctrl+Space; press Enter to select the anonymous proposal for Runnable(); ; => Result:; ; public class Try {; Object m() {; return new Runnable() {; ; public void run() {; // TODO Auto-generated method stub; ; }; };;;; }; \n", - "7178 Next/Previous buttons have double image 20020606 XP; ; 1) Open Java editor; Outline; Search view; 2) Click in editor; click in outline; click in search; 3) Note that the show previous/ show next buttons have a double image.; Hover over the button and the imgae is corrected \n", - "\n", - " actual predicted \n", - "40065 P2 P3 \n", - "7178 P2 P3 " - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "result[((result['actual'] == 'P1') | (result['actual'] == 'P2')) &\n", " (result['actual'] != result['predicted'])].sample(2, random_state=33)" @@ -1251,7 +685,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "blueprints", "language": "python", "name": "python3" }, @@ -1265,7 +699,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.12.8" }, "toc": { "base_numbering": 1,