prepare to integrate

Author: =

tensorflow/ann_game.py

@@ -0,0 +1,123 @@
+# youtube thenewboston python game development
+# https://youtu.be/pNjSyBlbl_Q?list=PL6gx4Cwl9DGAjkwJocj7vlc_mFU-4wXJq
+
+import pygame
+
+print(pygame.init())
+
+WINDOW_HEIGHT = 200
+WINDOW_WIDTH = 200
+
+PLAYER_WIDTH = 10
+PLAYER_HEIGHT = 30
+PLAYER_X_POS = 20
+PLAYER_Y_POS = WINDOW_HEIGHT - PLAYER_HEIGHT
+PLAYER_Y_ORIGINAL_POS = WINDOW_HEIGHT - PLAYER_HEIGHT
+PLAYER_Y_POS_CHANGE = 0
+JUMP_HEIGHT = 100
+
+POS_CHANGE_GRANULARITY = 5
+
+OBSTACLE_WIDTH = 30
+OBSTACLE_HEIGHT = 40
+OBSTACLE_Y_POS = WINDOW_WIDTH - OBSTACLE_HEIGHT
+OBSTACLE_X_POS = WINDOW_WIDTH
+OBSTACLE_X_POS_CHANGE = 2
+
+obstaclePositions = []
+
+screenshotCount = 0
+iterationCOunt = 0
+gameExit = False
+FRAME_RATE = 60
+
+white = (255,255,255)
+black = (0, 0, 0)
+
+gameDisplay = pygame.display.set_mode((WINDOW_WIDTH,WINDOW_HEIGHT))
+pygame.display.set_caption('jumper')
+windowSurface = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT), 0, 32)
+
+pygame.display.update()
+
+clock = pygame.time.Clock()
+
+def drawObstacles():
+	for obstacleXPos in obstaclePositions:
+		pygame.draw.rect(gameDisplay, black, [obstacleXPos,OBSTACLE_Y_POS, OBSTACLE_WIDTH, OBSTACLE_HEIGHT])
+
+def addRandomObstacle():
+	randomValBetween_0_and_50 = 50
+	obstaclePositions.append(WINDOW_WIDTH-randomValBetween_0_and_50)
+
+def putLabelInFile(value):	
+	scoresFile.write(value+"\n")	
+
+def isOkayToJump():
+	# check for an obstacle nearing the player
+	for obstacleXPos in obstaclePositions:
+		if obstacleXPos <= PLAYER_X_POS+20:
+			return True
+	return False
+	
+def jump():
+	PLAYER_Y_POS_CHANGE = -1*POS_CHANGE_GRANULARITY
+
+scoresFile = open("labels.txt","a")
+while not gameExit:
+
+	# event loop
+	for event in pygame.event.get():
+		if event.type == pygame.QUIT:
+			gameExit = True
+		if event.type == pygame.KEYDOWN:
+			if event.key == pygame.K_q:
+				gameExit = True
+			if event.key == pygame.K_SPACE:			
+				# make the player start going up only if it is stationary
+				if PLAYER_Y_POS_CHANGE == 0:
+					PLAYER_Y_POS_CHANGE = -1*POS_CHANGE_GRANULARITY
+
+	# when you have jumped high enough come back
+	if PLAYER_Y_POS == PLAYER_Y_ORIGINAL_POS - JUMP_HEIGHT:
+		PLAYER_Y_POS_CHANGE = POS_CHANGE_GRANULARITY
+	
+	# PLAYER_Y_POS_CHANGE > 0 means that the player is coming down
+	if PLAYER_Y_POS_CHANGE > 0 and PLAYER_Y_POS == PLAYER_Y_ORIGINAL_POS:
+		PLAYER_Y_POS_CHANGE = 0
+
+	# update the position of player
+	PLAYER_Y_POS += PLAYER_Y_POS_CHANGE
+	
+	# update the position of the each obstacle
+	for index, position in enumerate(obstaclePositions):
+		obstaclePositions[index] -= OBSTACLE_X_POS_CHANGE
+	
+	# remove the passed obstacle from the obstacle list
+	for index, obstacleXPos in enumerate(obstaclePositions):
+		if obstacleXPos < 0:
+			obstaclePositions.pop(index)
+		
+	# add an obstacle every 100th iteration
+	if iterationCOunt % 100 == 0:
+		addRandomObstacle()	
+
+	# check if an obstacle collided with the player 
+	for obstacleXPos in obstaclePositions:
+		# check if obstacle has crossed into the player's territory
+		if obstacleXPos < PLAYER_X_POS+PLAYER_WIDTH:
+			# check if player is blocking
+			if OBSTACLE_Y_POS <= PLAYER_Y_POS:
+				gameExit = True
+
+	gameDisplay.fill(white)
+	pygame.draw.rect(gameDisplay, black, [PLAYER_X_POS,PLAYER_Y_POS, PLAYER_WIDTH, PLAYER_HEIGHT])	
+	drawObstacles()
+	pygame.display.update()
+	iterationCOunt += 1
+
+	clock.tick(FRAME_RATE)
+	
+scoresFile.close()
+pygame.quit()
+quit()

tensorflow/game.py

@@ -109,6 +109,9 @@ def jump():
 			# check if player is blocking
 			if OBSTACLE_Y_POS <= PLAYER_Y_POS:
 				gameExit = True
+
+
+	# AUTOMATION OF JUMP AND SCREENSHOT FOR TRAINING 
 
 	# screen shot only when the player is stationary
 	print(screenshotCount)

tensorflow/trainAnn.py

@@ -23,16 +23,16 @@
 DATADIR = "screenshots"
 LABELFILE = "labels.txt"
 
-TRAINING_COUNT = 20000
-LAST_NUMBER = 21000
+TRAINING_AMOUNT = 20000
+TESTING_AMOUNT = 1000
 
 training_data_samples = []
 def create_training_samples():
 	#for imgName in range(1, 194776):
 	path = os.path.join(DATADIR)
 
 	IMG_SIZE = 100
-	for img in tqdm(range(1, TRAINING_COUNT+1)):
+	for img in tqdm(range(0, TRAINING_AMOUNT)):
 		try:
 			img_array = cv2.imread(os.path.join(path,str(img)+".jpeg") ,cv2.IMREAD_GRAYSCALE)
 			new_array = cv2.resize(img_array, (IMG_SIZE, IMG_SIZE))
@@ -47,7 +47,7 @@ def create_test_samples():
 	path = os.path.join(DATADIR)
 
 	IMG_SIZE = 100
-	for img in tqdm(range(TRAINING_COUNT+1, LAST_NUMBER+1)):
+	for img in tqdm(range(TRAINING_AMOUNT, TRAINING_AMOUNT+TESTING_AMOUNT)):
 		try:
 			img_array = cv2.imread(os.path.join(path,str(img)+".jpeg") ,cv2.IMREAD_GRAYSCALE)
 			new_array = cv2.resize(img_array, (IMG_SIZE, IMG_SIZE))
@@ -58,25 +58,25 @@ def create_test_samples():
 
 training_data_labels = []
 def create_training_labels():
-	count = 1
+	count = 0
 	img_name = ""
 	with open(LABELFILE) as f:
 		for line in f:
-			if count >= TRAINING_COUNT+1:
+			if count >= TRAINING_AMOUNT:
 				break
 			array_of_words = line.split(',')
 			training_data_labels.append(int(array_of_words[1]))
 			img_name = array_of_words[0]
 
 			count += 1
-
+			
 test_data_labels = []
 def create_test_labels():
-	count = 1
+	count = 0
 	img_name = ""
 	with open(LABELFILE) as f:
 		for line in f:
-			if count > TRAINING_COUNT and count < LAST_NUMBER+1:
+			if count >= TRAINING_AMOUNT and count < TRAINING_AMOUNT+TESTING_AMOUNT:
 				array_of_words = line.split(',')
 				test_data_labels.append(int(array_of_words[1]))
 				img_name = array_of_words[0]
@@ -90,16 +90,14 @@ def create_test_labels():
 create_test_labels()
 
 x_train = training_data_samples
-y_train = np.zeros((20000,), dtype=int)
+y_train = np.zeros((TRAINING_AMOUNT,), dtype=int)
 for index, val in enumerate(training_data_labels):
 	y_train[index] = val
-#y_train = training_data_labels
 
 x_test = test_data_samples
-y_test = np.zeros((1000,), dtype=int)
+y_test = np.zeros((TESTING_AMOUNT,), dtype=int)
 for index, val in enumerate(test_data_labels):
 	y_test[index] = val
-#y_test = test_data_labels
 
 
 
@@ -131,10 +129,8 @@ def create_test_labels():
 predictions = model.predict(x_test)
 print("---------------------------")
 
-#print(np.argmax(predictions[50]))
-
-count = 1
+count = 0
 for prediction in predictions:
 	if np.argmax(prediction) == 1:
-		print(20000+count, '--', np.argmax(prediction), '--', y_test[count-1])
+		print(TRAINING_AMOUNT+count, '--', np.argmax(prediction), '--', y_test[count])
 	count += 1