RomanNum3ral
/
AI-For-Beginners
mirror of https://github.com/microsoft/AI-For-Beginners.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix ValueError in all translated Perceptron.ipynb files for NumPy 2.x 

Co-authored-by: leestott <2511341+leestott@users.noreply.github.com>
This commit is contained in:
copilot-swe-agent[bot] 2025-10-03 12:50:39 +00:00
parent ab98173e7f
commit 7fd6b80ef1
48 changed files with 144 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
translations/ar/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/bg/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/bn/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -462,10 +462,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -477,7 +476,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/br/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/cs/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/da/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/de/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/el/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/en/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/es/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/fa/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/fi/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/fr/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/he/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -462,10 +462,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -477,7 +476,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/hi/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/hk/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/hr/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/hu/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/id/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/it/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/ja/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/ko/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/lt/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/mo/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/mr/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/ms/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/my/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -458,10 +458,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -473,7 +472,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/ne/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/nl/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/no/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/pa/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/pl/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/pt/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/ro/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/ru/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/sk/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/sl/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -462,10 +462,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -477,7 +476,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/sr/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/sv/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/sw/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/th/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/tl/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/tr/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/tw/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/uk/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/ur/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/vi/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]

7
translations/zh/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb
View File

@ -460,10 +460,9 @@
" neg_out = np.dot(negative_examples, weights) \n",
" pos_correct = (pos_out >= 0).sum() / float(pos_count)\n",
" neg_correct = (neg_out < 0).sum() / float(neg_count)\n",
" # make correction a list so it is homogeneous to weights list then numpy array accepts\n",
" snapshots.append((np.concatenate(weights),[(pos_correct+neg_correct)/2.0,0,0]))\n",
" snapshots.append([np.copy(weights).flatten(), (pos_correct+neg_correct)/2.0])\n",
"\n",
" return np.array(snapshots)\n",
" return np.array(snapshots, dtype=object)\n",
"\n",
"snapshots = train_graph(pos_examples,neg_examples)\n",
"\n",
@ -475,7 +474,7 @@
" pylab.plot(np.arange(len(snapshots[:,1])), snapshots[:,1])\n",
" pylab.ylabel('Accuracy')\n",
" pylab.xlabel('Iteration')\n",
" pylab.plot(step, snapshots[step,1][0], \"bo\")\n",
" pylab.plot(step, snapshots[step,1], \"bo\")\n",
" pylab.show()\n",
"def pl1(step): plotit(pos_examples,neg_examples,snapshots,step)"
]