478 lines
14 KiB
Python
478 lines
14 KiB
Python
#### MD #######
|
|
|
|
import pandas as pd
|
|
import pygame
|
|
from sklearn.model_selection import train_test_split
|
|
from sklearn.preprocessing import LabelEncoder
|
|
from sklearn.tree import DecisionTreeClassifier
|
|
from sklearn.metrics import accuracy_score
|
|
from sklearn.metrics import confusion_matrix
|
|
from pygame.locals import *
|
|
import numpy as np
|
|
import matplotlib.pyplot as plt
|
|
from sklearn import tree
|
|
import random
|
|
from textpygame import get_key, ask, display_box
|
|
###### /MD ######
|
|
|
|
|
|
import math
|
|
import pickle
|
|
|
|
|
|
########################
|
|
### WS ###
|
|
########################
|
|
# For CNN:
|
|
|
|
import keras
|
|
from keras.preprocessing import image
|
|
from keras.models import Sequential
|
|
from keras.layers import Convolution2D
|
|
from keras.layers import MaxPooling2D
|
|
from keras.layers import Flatten
|
|
from keras.layers import Dense
|
|
|
|
|
|
#initializing:
|
|
cnn_model = Sequential()
|
|
#Convolution:
|
|
cnn_model.add(Convolution2D(32, (3, 3), input_shape =(256, 256, 3), activation = "relu"))
|
|
#Pooling:
|
|
cnn_model.add(MaxPooling2D(pool_size = (2,2)))
|
|
|
|
# Adding a second convolutional layer
|
|
cnn_model.add(Convolution2D(32, 3, 3, activation = 'relu'))
|
|
cnn_model.add(MaxPooling2D(pool_size = (2, 2)))
|
|
|
|
#Flattening:
|
|
cnn_model.add(Flatten())
|
|
|
|
#Fully connected layers::
|
|
cnn_model.add(Dense(units = 128, activation = "relu"))
|
|
cnn_model.add(Dense(units = 3, activation = "softmax"))
|
|
|
|
# loading weigjts:
|
|
cnn_model.load_weights('s444523/best_model_weights2.h5')
|
|
#Making CNN:
|
|
cnn_model.compile(optimizer = "adam", loss = "categorical_crossentropy", metrics = ["accuracy"])
|
|
|
|
########################
|
|
### /WS ###
|
|
########################
|
|
|
|
|
|
|
|
#### MD#####
|
|
|
|
#read csv file
|
|
dataset= pd.read_csv("veganism.csv")
|
|
|
|
|
|
#create a new dataset
|
|
newdataset = pd.DataFrame(dataset, columns=['ethnicity', 'gender', 'appearence', 'vegan'])
|
|
|
|
# creating instance of labelencoder
|
|
labelencoder = LabelEncoder()
|
|
# Assigning numerical values and storing in another column
|
|
newdataset['ethnicity_no'] = labelencoder.fit_transform(newdataset['ethnicity'])
|
|
newdataset['gender_no']= labelencoder.fit_transform(newdataset['gender'])
|
|
newdataset['appearence_no']= labelencoder.fit_transform(newdataset['appearence'])
|
|
|
|
|
|
# for x values drop unimportant columns, axis=1 specifies that we want the columns not rows
|
|
Y=newdataset['vegan']
|
|
X=newdataset.drop(newdataset.columns[0:4], axis=1)
|
|
|
|
|
|
#test 14% of the data
|
|
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.15)
|
|
classifier = DecisionTreeClassifier()
|
|
classifier.fit(X_train, Y_train)
|
|
y_pred = classifier.predict(X_test)
|
|
|
|
|
|
|
|
fn=['ethnicity','gender','appearence']
|
|
cn=['yes', 'no']
|
|
|
|
# Setting dpi = 300 to make image clearer than default (for the decision tree visualisation)
|
|
fig, axes = plt.subplots(nrows = 1,ncols = 1,figsize = (4,4), dpi=300)
|
|
|
|
tree.plot_tree(classifier,
|
|
feature_names = fn,
|
|
class_names=cn,
|
|
filled = True);
|
|
|
|
fig.savefig('imagenamenew.png')
|
|
|
|
|
|
class Customer:
|
|
def __init__(self, coordinate_i, coordinate_j):
|
|
self.coordinate_i = coordinate_i
|
|
self.coordinate_j = coordinate_j
|
|
change_value(coordinate_i, coordinate_j,1 , 4)
|
|
class CustomerPlace:
|
|
def __init__(self, coordinate_i, coordinate_j):
|
|
self.coordinate_i = coordinate_i
|
|
self.coordinate_j = coordinate_j
|
|
change_value(coordinate_i, coordinate_j,1 , 5)
|
|
|
|
|
|
|
|
###### /MD #######
|
|
# Colors:
|
|
# Define some colors
|
|
BLACK = (0, 0, 0)
|
|
WHITE = (255, 255, 255)
|
|
GREEN = (0, 255, 0)
|
|
RED = (255, 0, 0)
|
|
BLUE = (0, 0, 240)
|
|
YELLOW = (255, 255, 0)
|
|
#Width and Height of each square:
|
|
WIDTH = 20
|
|
HEIGHT = 20
|
|
|
|
#Margin:
|
|
MARGIN = 5
|
|
grid = [[0 for x in range(16)] for y in range(16)]
|
|
|
|
def change_value(i, j, width, n):
|
|
for r in range (i, i+width):
|
|
for c in range (j, j+width):
|
|
grid[r][c] = n
|
|
|
|
class Table:
|
|
def __init__(self, coordinate_i, coordinate_j):
|
|
self.coordinate_i = coordinate_i
|
|
self.coordinate_j = coordinate_j
|
|
change_value(coordinate_i, coordinate_j, 2, 1)
|
|
def get_destination_coor(self):
|
|
return [self.coordinate_i+2, self.coordinate_j+2]
|
|
|
|
########################
|
|
### WS ###
|
|
########################
|
|
|
|
# The finction "state of meal" chooses a photo of a plate at the given table.
|
|
def state_of_meal(self):
|
|
## !!!!!!###
|
|
num = np.random.randint(67, 100)
|
|
## !!!!!!###
|
|
|
|
if num<=67:
|
|
img_name = 'plates/{}.png'.format(num)
|
|
else:
|
|
img_name = 'plates/{}.jpg'.format(num)
|
|
return img_name
|
|
|
|
# The function "change state" changes the value of the state variable.
|
|
# It informs, whether the client are waiting for the waiter to make an order
|
|
# (0 - empty plates) are eating (2 - full plates) or are waiting for the
|
|
# waiter to get a recipt (1 - dirty plates)
|
|
|
|
def change_state(self, st):
|
|
self.state = st
|
|
|
|
########################
|
|
### /WS ###
|
|
########################
|
|
|
|
class Kitchen:
|
|
def __init__(self, coordinate_i, coordinate_j):
|
|
self.coordinate_i = coordinate_i
|
|
self.coordinate_j = coordinate_j
|
|
change_value(coordinate_i, coordinate_j, 3, 2)
|
|
|
|
class Agent:
|
|
def __init__(self,orig_coordinate_i, orig_coordinate_j):
|
|
self.orig_coordinate_i = orig_coordinate_i
|
|
self.orig_coordinate_j = orig_coordinate_j
|
|
self.state = np.array([orig_coordinate_i,orig_coordinate_j])
|
|
change_value(orig_coordinate_j, orig_coordinate_j, 1, 3)
|
|
self.state_update(orig_coordinate_i, orig_coordinate_j)
|
|
|
|
def state_update(self, c1, c2):
|
|
self.state[0] = c1
|
|
self.state[1] = c2
|
|
|
|
def leave(self):
|
|
change_value(self.state[0], self.state[1], 1, 0)
|
|
|
|
|
|
def move_to(self, nextPos):
|
|
self.leave()
|
|
nextPos_x, nextPos_y = nextPos
|
|
self.state_update(nextPos_x, nextPos_y)
|
|
change_value(self.state[0], self.state[1], 1, 3)
|
|
|
|
########################
|
|
### WS ###
|
|
########################
|
|
|
|
#The function "define_table" serches for the apropriate table in the
|
|
# table_dict (to enable the usage of class attributes and methods)
|
|
def define_table(self, t_num):
|
|
t_num = 'table{}'.format(t_num)
|
|
t_num = table_dict[t_num]
|
|
return t_num
|
|
|
|
# The function "check_plates" uses the pretrained CNN model to classify
|
|
# the plate on the table as empty(0), full(2) or dirty(1)
|
|
def check_plates(self, table_number):
|
|
table = self.define_table(table_number)
|
|
plate = table.state_of_meal()
|
|
plate= image.load_img(plate, target_size = (256, 256))
|
|
plate = image.img_to_array(plate)
|
|
#plate = plate.reshape((256, 256))
|
|
plate = np.expand_dims(plate, axis = 0)
|
|
|
|
result = cnn_model.predict(plate)[0]
|
|
print(result)
|
|
if result[1] == 1:
|
|
result[1] = 0
|
|
x = int(input("Excuse me, have You done eating? 1=Yes, 2 = No \n"))
|
|
result[x] = 1
|
|
for i, x in enumerate(result):
|
|
if result[i] == 1:
|
|
table.change_state(i)
|
|
return i
|
|
########################
|
|
### /WS ###
|
|
########################
|
|
|
|
|
|
def check_done():
|
|
for event in pygame.event.get(): # Checking for the event
|
|
if event.type == pygame.QUIT: # If the program is closed:
|
|
return True # To exit the loop
|
|
|
|
def draw_grid():
|
|
for row in range(16): # Drawing the grid
|
|
for column in range(16):
|
|
color = WHITE
|
|
if grid[row][column] == 1:
|
|
color = GREEN
|
|
if grid[row][column] == 2:
|
|
color = RED
|
|
if grid[row][column] == 3:
|
|
color = BLUE
|
|
pygame.draw.rect(screen,
|
|
color,
|
|
[(MARGIN + WIDTH) * column + MARGIN,
|
|
(MARGIN + HEIGHT) * row + MARGIN,
|
|
WIDTH,
|
|
HEIGHT])
|
|
|
|
|
|
## default positions of the agent:
|
|
x = 12
|
|
y = 12
|
|
agent = Agent(x, y)
|
|
table1 = Table(2, 2)
|
|
table2 = Table (2,7)
|
|
table3 = Table(2, 12)
|
|
table4 = Table(7, 2)
|
|
table5 = Table(7, 7)
|
|
table6 = Table(7, 12)
|
|
table7 = Table(12, 2)
|
|
table8 = Table(12, 7)
|
|
|
|
|
|
################### WS #####################
|
|
# I added the dict to loop through tables.
|
|
table_dict = {"table1":table1, "table2":table2, "table3":table3,"table4":table4,
|
|
"table5":table5,"table6":table6,"table7":table7,"table8":table8
|
|
}
|
|
################### WS #####################
|
|
|
|
pygame.init()
|
|
|
|
|
|
####MD ####
|
|
'''
|
|
# create a font object.
|
|
# 1st parameter is the font file
|
|
# which is present in pygame.
|
|
# 2nd parameter is size of the font
|
|
font = pygame.font.Font('freesansbold.ttf', 14)
|
|
X = 400
|
|
Y = 400
|
|
# create a text suface object,
|
|
# on which text is drawn on it.
|
|
text = font.render('waiter: hello, let me help you with your order.', True, WHITE, BLACK)
|
|
userText=font.render('user: ', True, BLUE, BLACK)
|
|
# create a rectangular object for the
|
|
# text surface object
|
|
textRect = text.get_rect()
|
|
inputRect = userText.get_rect()
|
|
# set the center of the rectangular object.
|
|
textRect.center= (200, 340)
|
|
inputRect.center=(200,370)
|
|
|
|
'''
|
|
#### /MD ####
|
|
|
|
|
|
#class Kitchen:
|
|
kitchen = Kitchen(13, 13)
|
|
|
|
WINDOW_SIZE = [405, 405]
|
|
screen = pygame.display.set_mode(WINDOW_SIZE)
|
|
|
|
pygame.display.set_caption("Waiter_Grid3")
|
|
|
|
done = False
|
|
|
|
clock = pygame.time.Clock()
|
|
|
|
with open('res_targets_4-1.data', 'rb') as filehandle:
|
|
# read the data as binary data stream
|
|
trained_route = pickle.load(filehandle)
|
|
|
|
destination = (4, 14)
|
|
trained_route.append(destination)
|
|
|
|
table_targets = [(9, 4),(4, 4),(4, 9),(4, 14)]
|
|
|
|
|
|
destination_tables = []
|
|
|
|
###### MD /########3
|
|
x=[2,7,12]
|
|
y=[2,7]
|
|
|
|
random_customer_seat_x=random.choice(x)
|
|
random_customer_seat_y=random.choice(y)
|
|
print(random_customer_seat_x,random_customer_seat_y)
|
|
seat=Customer(random_customer_seat_x,random_customer_seat_y)
|
|
|
|
next_to=CustomerPlace(random_customer_seat_x,random_customer_seat_y-1)
|
|
|
|
WINDOW_SIZE = [405, 405]
|
|
screen = pygame.display.set_mode(WINDOW_SIZE)
|
|
|
|
pygame.display.set_caption("Waiter_Grid3")
|
|
|
|
done = False
|
|
print(random_customer_seat_x,random_customer_seat_y-1)
|
|
clock = pygame.time.Clock()
|
|
|
|
|
|
|
|
#updating the drawing
|
|
def updateDraw():
|
|
x = agent.state[0]
|
|
y = agent.state[1]
|
|
screen.fill(BLACK) # Background color
|
|
for row in range(16): # Drawing the grid
|
|
for column in range(16):
|
|
color = WHITE
|
|
if grid[row][column] == 1:
|
|
color = GREEN
|
|
if grid[row][column] == 2:
|
|
color = RED
|
|
if grid[row][column] == 3:
|
|
color = BLUE
|
|
if grid[row][column] == 4:
|
|
color = MAGENTA
|
|
surface = pygame.draw.rect(screen,
|
|
color,
|
|
|
|
[(MARGIN + WIDTH) * column + MARGIN,
|
|
(MARGIN + HEIGHT) * row + MARGIN,
|
|
WIDTH,
|
|
HEIGHT])
|
|
|
|
def customer():
|
|
screen.blit(text, textRect)
|
|
ethnicity3 = input("Excuse me, What's you're ethnicity? <black>, <asian>, <white>\n")
|
|
gender3= input("Excuse me, What's you're gender? <male>, <female>, <other> \n")
|
|
appearence3=input("Excuse me, What's you're appearance? <hippie>, <other> \n")
|
|
if (ethnicity3 =="black"):
|
|
ethnicity3 = 1
|
|
elif ethnicity3 == "asian":
|
|
ethnicity3 = 0
|
|
else:
|
|
ethnicity3 = 2
|
|
|
|
if gender3 == "male":
|
|
gender3 = 0
|
|
else:
|
|
gender3 = 1
|
|
|
|
if appearence3 == "hippie":
|
|
appearence3= 0
|
|
else:
|
|
appearence3 = 1
|
|
prediction = classifier.predict([[ethnicity3, gender3, appearence3]])
|
|
#pygame.quit()
|
|
|
|
if prediction == [0]:
|
|
print("You're probably not vegan. Would you like a regular menu?")
|
|
else:
|
|
print("It seems like you're vegan. Would you like a vegan menu?")
|
|
#exit()
|
|
###### /MD ###
|
|
# -------- Main Program Loop -----------
|
|
exit_counter = 0
|
|
while not done:
|
|
screen.fill(BLACK) # Background color
|
|
draw_grid()
|
|
done = check_done()
|
|
new_route = trained_route[:]
|
|
for value in table_dict.values():
|
|
destination_tables.append(value.get_destination_coor())
|
|
num_of_table = 1
|
|
while len(new_route) != 0:
|
|
# move to next grid
|
|
agent.move_to(new_route[0])
|
|
|
|
# update the grid
|
|
pygame.time.delay(150)
|
|
screen.fill(BLACK)
|
|
draw_grid()
|
|
# Drawing the grid
|
|
clock.tick(100) # Limit to 60 frames per second
|
|
pygame.display.flip() # Updating the screen
|
|
|
|
# get current grid coordinate
|
|
x = agent.state[0]
|
|
y = agent.state[1]
|
|
# if reached the table, ask to collect the plates
|
|
if [x, y] in destination_tables:
|
|
########################
|
|
### WS ###
|
|
########################
|
|
#pygame.time.delay(100)
|
|
print("I'm at a table no. {}".format(num_of_table))
|
|
## Checking at what state are the plates:
|
|
state_of_table = agent.check_plates(num_of_table)
|
|
num_of_table +=1
|
|
|
|
if state_of_table == 0:
|
|
customer()
|
|
|
|
# Early stopping (after 10 rounds)
|
|
exit_counter += 1
|
|
print("exit_counter", exit_counter)
|
|
if exit_counter == 10:
|
|
play_again = 1
|
|
play_again = int(input("Exit? 0=No, 1=Yes \n"))
|
|
if play_again:
|
|
pygame.quit()
|
|
else:
|
|
exit_counter = 0
|
|
|
|
########################
|
|
### /WS ###
|
|
########################
|
|
destination_tables = destination_tables[1:]
|
|
|
|
new_route = new_route[1:]
|
|
|
|
# After each fool loop, we can quit the program:.
|
|
|
|
|
|
|
|
pygame.quit() |