SI_Traktor/Kamila.py

import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn import metrics
import numpy

header = ["ready", "hydration", "weeds", "empty", "TODO"]
work = ["Zebrac","Podlac","Odchwascic","Zasadzic"]
#0 - 3
#1 - 0
#2 - 1
#3 - 2
def check_p(field):
    if field == 0:
        return [0, 0, 0, 0, "Zasadzic"]
    elif field == 1:
        return [0, 0, 1, 0, "Odchwascic"]
    elif field == 2:
        return [0, 0, 0, 1, "Podlac"]
    elif field == 3:
        return [0, 0, 1, 1, "Odchwascic"]
    elif field == 4:
        return [0, 1, 0, 0, "Zasadzic"]
    elif field == 5:
        return [0, 1, 1, 0, "Odchwascic"]
    elif field == 6:
        return [0, 1, 0, 1, "Ignoruj"]
    elif field == 7:
        return [0, 1, 1, 1, "Odchwascic"]
    elif field == 8:
        return [1, 0, 0, 1, "Zebrac"]
    else:
        print("wrong field number")


def check(field):
    if field == 0:
        return [[0, 0, 0, 1, "Zasadzic"],[0,0,0,1,"Podlac"]]
    elif field == 1:
        return [[0, 0, 1, 1, "Odchwascic"], [0,0,1,1,"Podlac"], [0,0,1,1,"Zasadzic"]]
    elif field == 2:
        return [[0, 0, 0, 0, "Podlac"]]
    elif field == 3:
        return [[0, 0, 1, 0, "Odchwascic"],[0,0,1,0,"Podlac"]]
    elif field == 4:
        return [[0, 1, 0, 1, "Zasadzic"]]
    elif field == 5:
        return [[0, 1, 1, 1, "Odchwascic"],[0,1,1,1,"Zasadzic"]]
    elif field == 6:
        return []
    elif field == 7:
        return [[0, 1, 1, 0, "Odchwascic"]]
    elif field == 8:
        return [[1, 0, 0, 0, "Zebrac"],[1, 0, 0, 0, "Potem podlac"],[1, 0, 0, 0, "Potem zasadzic"]]
    else:
        print("wrong field number")

def un_values(rows, col):
    return set([row[col] for row in rows])


def class_counts(rows):
    counts = {}
    for row in rows:
        label = row[-1]
        if label not in counts:
            counts[label] = 0
        counts[label] += 1
    return counts


def is_numeric(value):
    return isinstance(value, int) or isinstance(value, float)


class Question():
    def __init__(self, column, value):
        self.column = column
        self.value = value

    def match(self, example):
        val = example[self.column]
        if is_numeric(val):
            return val == self.value
        else:
            return val != self.value

    def __repr__(self):
        condition = "!="
        if is_numeric(self.value):
            condition = "=="
        return "Is %s %s %s?" %(
            header[self.column], condition, str(self.value)
        )


def partition(rows, question):
    true_rows, false_rows = [], []
    for row in rows:
        if question.match(row):
            true_rows.append(row)
        else:
            false_rows.append(row)
    return true_rows, false_rows


def gini(rows):
    counts = class_counts(rows)
    impurity = 1
    for lbl in counts:
        prob_of_lbl = counts[lbl]/float(len(rows))
        impurity -= prob_of_lbl**2
    return impurity


def info_gain(left, right, current_uncertainty):
    p = float(len(left))/(len(left) + len(right))
    return current_uncertainty - p*gini(left) - (1-p) * gini(right)


def find_best_split(rows):
    best_gain = 0
    best_question = None
    current_uncertainty = gini(rows)
    n_features = len(rows[0]) - 1

    for col in range(n_features):

        values = set([row[col] for row in rows])

        for val in values:
            question = Question(col, val)
            true_rows, false_rows = partition(rows, question)
            if len(true_rows) == 0 or len(false_rows) == 0:
                continue
            gain = info_gain(true_rows,false_rows,current_uncertainty)
            if gain >= best_gain:
                best_gain, best_question = gain, question

    return best_gain, best_question


class Leaf:
    def __init__(self, rows):
        self.predictions = class_counts(rows)


class DecisionNode:
    def __init__(self, question, true_branch, false_branch):
        self.question = question
        self.true_branch = true_branch
        self.false_branch = false_branch


def build_tree(rows):
    gain, question = find_best_split(rows)
    if gain == 0:
        return Leaf(rows)
    true_rows, false_rows = partition(rows, question)

    true_branch = build_tree(true_rows)
    false_branch = build_tree(false_rows)

    return DecisionNode(question, true_branch, false_branch)


def print_tree(node, spacing=""):
    if isinstance(node, Leaf):
        print(spacing + "Predict", node.predictions)
        return

    print(spacing + str(node.question))

    print(spacing + '--> True: ')
    print_tree(node.true_branch, spacing + " ")

    print(spacing + '--> False: ')
    print_tree(node.false_branch, spacing + " ")


def classify(row, node):
    if isinstance(node, Leaf):
        return node.predictions
    if node.question.match(row):
        return classify(row, node.true_branch)
    else:
        return classify(row,node.false_branch)


def print_leaf(counts):
    total = sum(counts.values()) * 1.0
    probs = {}
    for lbl in counts.keys():
        probs[lbl] = str(int(counts[lbl]/total * 100)) + "%"
    return probs


class main():
    def __init__(self,traktor,field,ui,path):
        self.traktor = traktor
        self.field = field
        self.ui = ui
        self.path = path
        self.best_action = 0
    def main(self):
        array = ([[8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
                  [7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
                  [6, 6, 6, 6, 6, 6, 6, 6, 6, 6],
                  [5, 5, 5, 5, 5, 5, 5, 5, 5, 5],
                  [4, 4, 4, 4, 4, 4, 4, 4, 4, 4],
                  [3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
                  [2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
                  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
                  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
        while (self.best_action != -1):
            self.find_best_action()
            self.do_best_action()
        print("Koniec roboty")


    def find_best_action(self):
        testing_data = []
        matrix = self.field.get_matrix()
        matrix_todo = []
        #print(self.field)
        for i in range(10):
            matrix_todo.append([])
            verse = matrix[i]
            for j in range(len(verse)):
                coord = (i, j)
                current_field = check(verse[j]) #czynnosci ktore trzeba jeszcze zrobic na kazdym polu
                matrix_todo[i].append([])
                for action in current_field:
                    matrix_todo[i][j].append(action[-1])
                testing_data.extend(current_field)
                #testing_data.append(current_field)
        if len(testing_data) > 0:
            x = build_tree(testing_data)
            print_tree(x)
            if isinstance(x, Leaf):
                self.best_action = self.find_remaining_action(matrix_todo)
                return
            self.best_action = x.question.column
            print(header[x.question.column])
            print(x.question.value)
        else:
            self.best_action = self.find_remaining_action(matrix_todo)
            return
        #for row in testing_data:
         #   print("Actual: %s. Predicted %s" %
          #        (row[-1], print_leaf(classify(row, x))))
        #for row in matrix_todo:
        #   print(row)

    def do_best_action(self):
        self.traktor.set_mode((self.best_action+3) % 4)
        while self.path.pathfinding(self.traktor,self.field,self.ui) != 0:
            pass
# 0 - 3
# 1 - 0
# 2 - 1
# 3 - 2
    def find_remaining_action(self, matrix_todo):
        for row in matrix_todo:
            for field in row:
                for action in field:
                    print(action)
                    return work.index(action)
        return -1