Schlagwort-Archive: KI

Ein Roboter darf keinen Menschen verletzen! LOL

Bild aus dem Film I Robot
I Robot

Ich finde es immer noch amüsant, was sich Asimov in Runaround schon 1943 ausdachte:
1.) Ein Roboter darf kein menschliches Wesen verletzen oder durch Untätigkeit gestatten, dass einem menschlichen Wesen Schaden zugefügt wird.
2.) Ein Roboter muss den ihm von einem Menschen gegebenen Befehlen gehorchen – es sei denn, ein solcher Befehl würde mit Regel eins kollidieren.
3.) Ein Roboter muss seine Existenz beschützen, solange dieser Schutz nicht mit Regel eins oder zwei kollidiert
0.) Ein Roboter darf die Menschheit nicht verletzen oder durch Passivität zulassen, dass die Menschheit zu Schaden kommt
In den letzten Jahrzehnten verfolgte ich einige sehr langweilige Diskussionen, in denen es um die Rechte von Androiden ging. Jetzt wird mit der Schuldfrage bei selbstfahrenden Autos das Thema wieder ein wenig realistischer und interessanter.
Selbstfahrende Autos: Wer haftet?
Wer haftet, wenn selbstfahrende Autos Unfälle bauen?
Noch interessanter finde ich Aussagen vom EU-Abgeordneten Mady Delvaus: Wir müssen in Erwägung ziehen, dass die KI die intellektuellen Fähigkeiten des Menschen innerhalb nur weniger Jahrzehnte überflügeln könnte.“ Das weitere Schlussfolgerungen aus dieser Möglichkeit zu der Frage führen, ob sich die Spezies Mensch mit dieser Entwicklung selbst gefährdet, liegt auf der Hand.
Meiner Meinung nach liegt es jetzt noch bei uns, ob selbstlernende Roboter eine Gefahr für die Menschheit, oder, ob sie zum Segen der Menschheit werden. Daher ist es essentiell, dass wir uns dafür einen international gültigen rechtlichen Rahmen für die weitere Forschung und Entwicklung zulegen. Morgen könnte es dazu bereits zu spät sein, denn wenn wir alleine die Risiken und Herausforderungen eines immer engeren Zusammenwirkens von Menschen und Robotern im Alltag berücksichtigen, werde sogar ich einen selbstlernenden Androiden besitzen, bevor es eine Gesetzesgrundlage dafür gibt, was er darf und was nicht.
Ich bin unbedingt für technischen Fortschritt und träume von einer objektiven, logischen KI, welche die Fehler, emotionaler, habgieriger, religiöser Fanatiker und Menschen korrigiert, aber nicht um jeden Preis. Vielleicht wäre es momentan sinnvoller sich darum zu bemühen, dass die Menschen weltweit ein friedvolles, erfülltes Leben führen können. Denn auf dieser Basis hätten wir auch von einer mächtigen KI nichts zu befürchten, weil wir sie (noch) entwerfen. Entwickeln wir sie um Macht über andere zu erlangen, um Kriege zu gewinnen und andere zu unterdrücken, dann kann ich nur froh darüber sein, dass ich heute lebe und die zukünftigen Generationen bedauern.
Will sich jemand dazu einen kalten Schauder über den Rücken laufen lassen und ein Horrorszenario in Form einen Sci-Fi Romanes lesen, der findet hier die Heliosis.

Weblinks:
Robotik und Künstliche Intelligenz: EU Parlament verabschiedet erste „Robotergesetze“
Charta der Digitalen Grundrechte der Europäischen Union
CHARTA DER DIGITALEN GRUNDRECHTE DER EUROPÄISCHEN UNION
ENTWURF EINES BERICHTS mit Empfehlungen an die Kommission zu zivilrechtlichen Regelungen im Bereich Robotik (2015/2103(INL))
Künstliche Intelligenz und künstliche Moral (1) – von dummen Mördern und künstlichen Polizisten

Wie lange noch ist unser Gehirn Maschinen überlegen?

Wie lange noch ist unser Gehirn Maschinen überlegen? Fragt man sich heute schon bei „Die Welt“.
Es ist also nur mehr eine Frage der Zeit. Vor 20 Jahren war mir das schon klar, als ich die „3. Generation von Gott“ und ähnliches schrieb. Damals wurde ich ausgelacht, als Spinner bezeichnet und IT-Fachleute betonten immer wieder, dass der Blechtrottel nie mehr können kann, als ihm der Programmierer ermöglicht. Er kann nicht selbstständig entscheiden und sich nicht verbessern und weiterentwickeln, hieß es. Heute weiß man es anscheinend sogar schon bei „Der Welt“, obwohl der Artkel kaum etwas hergibt, außer oberflächliche, allgemeine Aussagen, ohne jeden technischen Hintergrund, aber es ist eben nur ein „Verpixelbildrätzel“, dass selbstständiges Lernen und ein sich selbst optimieren und reproduzieren für Maschinen heute nicht mehr außergewöhlich ist. Wer sich informiert, wie weit man in Spracherkennung, Semantik, Bildanalyse, Objekterkennung, Übersetzung, Roboti, KI … heute bereits ist, währen er/sie vom Auto selbstständig ans Ziel gebracht wird, dem wird klar, dass es tatsächlich nur eine Frage der Zeit ist.

Ein Lernalgorithmus in Python für ein Perzeptron

Was man sich vorher ansehen sollte.
NumPy: Quickstart tutorial bzw. NumPy v1.12.dev0 Manual oder Tentative NumPy Tutorial bzw. auf GitHub scipy-tentative-numpy-tutorials. Wer ein älteres pdf bevorzugt findet es hier doc_numpy-pdf_1

Pandas: https://pandas.pydata.org/pandas-docs/stable/tutorials.html
Matplotlib: https://matplotlib.org/users/beginner.html

Von Python sollte eine 3er Version installiert sein. python -V sagt mir, dass ich Python 3.5.2 installiert habe, womit ich zufrieden bin.
Auf Python 3.5.2 documentation findet man die Doku zu Python und um pip braucht man sich seit der 3.4 Version auch nicht mehr kümmern, da der Paketmanager für PyPI schon automatisch mitinstalliert wird.
Wir verwenden also NumPy, pandas und matplotlib zum Einlesen, Verarbeiten und Visualisieren der Daten und wir werden einen einfachen Algorithmus zur linearen Klassifikation implementieren.
Zuerst schaue ich einmal, ob ich die neueste Version von pip habe und komme mit „pip install –upgrade pip“ auf pip-9.0.1 und schon habe ich falsch gedacht. Ich muss ja pip für Python 3.x installieren mit sudo apt install python3-pip Dann wieder ein –upgrade und ein sudo pip3 install numpy

 

 

 

 

 

Zum Code:

import numpy as np
class Perceptron(object):
"""Perceptron classifier.

Parameters
------------
eta : float
Learning rate (between 0.0 and 1.0)
n_iter : int
Passes over the training dataset.

Attributes
-----------
w_ : 1d-array
Weights after fitting.
errors_ : list
Number of misclassifications in every epoch.

"""
def __init__(self, eta=0.01, n_iter=10):
self.eta = eta
self.n_iter = n_iter

def fit(self, X, y):
"""Fit training data.

Parameters
----------
X : {array-like}, shape = [n_samples, n_features]
Training vectors, where n_samples is the number of samples and
n_features is the number of features.
y : array-like, shape = [n_samples]
Target values.

Returns
-------
self : object

"""
self.w_ = np.zeros(1 + X.shape[1])
self.errors_ = []

for _ in range(self.n_iter):
errors = 0
for xi, target in zip(X, y):
update = self.eta * (target - self.predict(xi))
self.w_[1:] += update * xi
self.w_[0] += update
errors += int(update != 0.0)
self.errors_.append(errors)
return self

def net_input(self, X):
"""Calculate net input"""
return np.dot(X, self.w_[1:]) + self.w_[0]

def predict(self, X):
"""Return class label after unit step"""
return np.where(self.net_input(X) >= 0.0, 1, -1)

 

 
So, soweit funktioniert es und nächstes mal werde ich das Perzeptron-Modell mit den Iris Datensätzen trainieren.


Quelle: Python Machine Learning von Sebastian Raschka; Published 2015-09-23
Weblinks:
httpss://github.com/arnaudbenard/python-machine-learning
https://stackoverflow.com/questions/36532585/passing-an-array-to-numpy-dot-in-python-implementation-of-perceptron-learning
httpss://github.com/rasbt/python-machine-learning-book/blob/master/code/optional-py-scripts/ch02.py
https://natureofcode.com/book/chapter-10-neural-networks/
https://stackoverflow.com/questions/36532585/passing-an-array-to-numpy-dot-in-python-implementation-of-perceptron-learning