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

Merge pull request #544 from microsoft/copilot/fix-29ebefe6-65da-4b28-915b-008ce65f0519 

Fix ValueError in Perceptron.ipynb for NumPy 2.x compatibility
This commit is contained in:
Lee Stott 2025-10-03 14:00:33 +01:00 committed by GitHub
parent 894549dd42 7fd6b80ef1
commit 6923c22e49
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
49 changed files with 148 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
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)"
]
@ -1078,4 +1077,4 @@
},
"nbformat": 4,
"nbformat_minor": 2
}
}

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)"
]