def segnet_predict():
import cv2
from src.timer import Timer
rotation = False
# set True for running segmentation test
segmentation_test = True
jaccard_sum_previous = 0
jaccard_sum_proposed = 0
time_previous = [0, 0, 0, 0]
time_proposed = 0
if segmentation_test:
# 指領域抽出実験用
# for segmentation test
X_test, file_names = load_x(
'datasets' + os.sep + 'segmentation_test' + os.sep + 'image',
rotation)
else:
# normal predict
X_test, file_names = load_x(
'datasets' + os.sep + 'test' + os.sep + 'image', rotation)
input_channel_count = 1
output_channel_count = 1
first_layer_filter_count = FIRST_LAYER_FILTER_COUNT
model = segnet(input_channel_count, output_channel_count,
first_layer_filter_count)
model.load_weights('segnet_weights.hdf5')
model.summary()
BATCH_SIZE = 8
timer = Timer()
Y_pred = model.predict(X_test, BATCH_SIZE)
#time_proposed += timer.time_elapsed()
for i, y in enumerate(Y_pred):
# testDataフォルダ配下にleft_imagesフォルダを置いている
img = cv2.imread(
'datasets' + os.sep + 'test' + os.sep + 'image' + os.sep +
file_names[i], 0)
#cv2.equalizeHist(img ,img)
if rotation:
y = cv2.resize(y, (img.shape[0], img.shape[0]))
else:
y = cv2.resize(y, (img.shape[1], img.shape[0]))
y_dn = denormalize_y(y)
y_dn = np.uint8(y_dn)
#ret, mask = cv2.threshold(y_dn, 0, 255, cv2.THRESH_OTSU)
ret, mask = cv2.threshold(y_dn, 127, 255, cv2.THRESH_BINARY)
#hist, bins = np.histogram(mask.ravel(), 256, [0, 256])
mask_binary = normalize_y(mask)
timer.reset()
masked = cv2.bitwise_and(img, mask)
mask_rest = cv2.bitwise_not(mask)
masked = cv2.bitwise_or(masked, mask_rest)
#image_user_processed = high_boost_filter(masked)
cv2.imwrite('prediction' + os.sep + file_names[i], mask)
time_proposed += timer.time_elapsed()
if segmentation_test:
img = cv2.imread(
'datasets' + os.sep + 'segmentation_test' + os.sep + 'image' +
os.sep + file_names[i], 0)
mask_previous, _, time_list_previous = opening_masking(img)
time_previous[0] += time_list_previous[0]
time_previous[1] += time_list_previous[1] - time_list_previous[0]
time_previous[2] += time_list_previous[2] - time_list_previous[1]
time_previous[3] += time_list_previous[3] - time_list_previous[2]
mask_previous_binary = normalize_y(mask_previous)
print(mask_previous_binary.shape)
label = cv2.imread(
'datasets' + os.sep + 'segmentation_test' + os.sep + 'label' +
os.sep + file_names[i], 0)
label_binary = normalize_y(label)
jaccard_previous = K.get_value(
jaccard_coefficient(mask_previous_binary, label_binary))
jaccard_proposed = K.get_value(
jaccard_coefficient(mask_binary, label_binary))
print('previous:', jaccard_previous)
jaccard_sum_previous += jaccard_previous
print('proposed:', jaccard_proposed)
jaccard_sum_proposed += jaccard_proposed
print('sum_previous:', jaccard_sum_previous)
print('sum_proposed:', jaccard_sum_proposed)
print('mean_previous:', jaccard_sum_previous / len(Y_pred))
print('mean_proposed:', jaccard_sum_proposed / len(Y_pred))
print('mean_time_previous:',
list(map(lambda x: x / len(Y_pred), time_previous)))
print('mean_time_proposed', time_proposed / len(Y_pred))
return 0
def cross_validation_segnet():
from sklearn.model_selection import KFold
from sklearn.model_selection import train_test_split
from src.plot import plot_loss_accuracy, plot_dice_coefficient_cv
from src.timer import Timer
segmentation_test = True
rotation = False
jaccards_previous = []
jaccards_proposed = []
# training_validation dataset path
training_validation_path = 'datasets' + os.sep + 'training_validation'
# 学習・検証用データセットのロード
# load dataset for training, validation
x_all, file_names = load_x(training_validation_path + os.sep + 'image')
y_all = load_y(training_validation_path + os.sep + 'label')
# testデータの分割だがこれは今回あらかじめ分けておくので無視する
#x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=7)
# 指領域抽出実験用
X_test, file_names = load_x(
'datasets' + os.sep + 'segmentation_test' + os.sep + 'image', rotation)
# 入力はグレースケール1チャンネル
input_channel_count = 1
# 出力はグレースケール1チャンネル
output_channel_count = 1
# hyper parameters
BATCH_SIZE = 8
NUM_EPOCH = 300
# dice係数の最終値を記憶するlist
# lists for get last dice coefficient values
final_dices = []
final_val_dices = []
# dice係数のlistを記憶するlist
# list for get dice coefficient
dice_lists = []
training_times = []
label_names = ['1st', '2nd', '3rd', '4th']
kf = KFold(n_splits=4, shuffle=True)
timer = Timer()
# kFoldループを行う(36データを4つに分割)
# kFold loop (split 36 data to 4 data)
for train_index, val_index in kf.split(x_all, y_all):
print(train_index, val_index)
x_train = x_all[train_index]
y_train = y_all[train_index]
x_validation = x_all[val_index]
y_validation = y_all[val_index]
print(x_train.shape, x_validation.shape)
# SegNetの定義
model = segnet(input_channel_count, output_channel_count,
FIRST_LAYER_FILTER_COUNT)
model.compile(loss=dice_coefficient_loss,
optimizer=Adam(lr=1e-3),
metrics=[dice_coefficient, 'accuracy'])
timer.reset()
history = model.fit(x_train,
y_train,
batch_size=BATCH_SIZE,
epochs=NUM_EPOCH,
verbose=1,
validation_data=(x_validation, y_validation))
training_times.append(timer.time_elapsed())
# dice_coefficientの最終値を記録
# get last dice coefficient value
final_dices.append(history.history['dice_coefficient'][-1])
final_val_dices.append(history.history['val_dice_coefficient'][-1])
dice_lists.append(history.history['dice_coefficient'])
plot_loss_accuracy(history)
#Y_pred = model.predict(X_test, BATCH_SIZE)
if segmentation_test:
Y_pred = model.predict(X_test, BATCH_SIZE)
for i, y in enumerate(Y_pred):
# testDataフォルダ配下にleft_imagesフォルダを置いている
img = cv2.imread(
'datasets' + os.sep + 'segmentation_test' + os.sep +
'image' + os.sep + file_names[i], 0)
if rotation:
y = cv2.resize(y, (img.shape[0], img.shape[0]))
else:
y = cv2.resize(y, (img.shape[1], img.shape[0]))
# 提案手法
# proposed method
y_dn = denormalize_y(y)
y_dn = np.uint8(y_dn)
# ret, mask = cv2.threshold(y_dn, 0, 255, cv2.THRESH_OTSU)
ret, mask = cv2.threshold(y_dn, 127, 255, cv2.THRESH_BINARY)
# hist, bins = np.histogram(mask.ravel(), 256, [0, 256])
mask_binary = normalize_y(mask)
# 従来手法
# previous method
mask_previous, _ = opening_masking(img)
mask_previous_binary = normalize_y(mask_previous)
# ラベル読み込み
# load label images
label = cv2.imread(
'datasets' + os.sep + 'segmentation_test' + os.sep +
'label' + os.sep + file_names[i], 0)
label_binary = normalize_y(label)
dice_previous = K.get_value(
jaccard_coefficient(mask_previous_binary, label_binary))
dice_proposed = K.get_value(
jaccard_coefficient(mask_binary, label_binary))
print('previous:', dice_previous)
jaccards_previous.append(dice_previous)
print('proposed:', dice_proposed)
jaccards_proposed.append(dice_proposed)
print(final_dices)
print('平均訓練精度', np.mean(final_dices)) # mean training precision
print(final_val_dices)
print('平均検証精度', np.mean(final_val_dices)) # mean validation precision
print(training_times)
print('平均学習時間', np.mean(training_times)) # mean training time
print(jaccards_previous)
print('従来手法精度',
np.mean(jaccards_previous)) # extract-precision by previous method
print(jaccards_proposed)
print('提案手法精度',
np.mean(jaccards_proposed)) # extract-precision by proposed method
plot_dice_coefficient_cv(dice_lists, label_names)
return 0
class Enviroment:
# Variables de pygame
screen: pygame.Surface
screen_width: int
screen_height: int
# Variables del entorno
done: bool
winner: bool
the_winner: int
play_number: int
# Pantallas cuando ganan
player1_win: pygame.image
player2_win: pygame.image
empate: pygame.image
player_win: pygame.image
# Jugadores
player1: Player
player2: Player
# Turno del jugador
player1_turn: bool
# Constantes
play_count: int
PLAY_LIMIT = 100
# Tablero de ajedrez
chessboard: Chessboard
# Booleana de configuracion para identificar si se grafica el tablero o no
graph_mode: bool
def __init__(self,
screen_width: int,
screen_height: int,
player1_command: str,
player2_command: str,
graph_mode=True):
self.graph_mode = graph_mode
# Inicializando pygame
pygame.init()
if self.graph_mode:
self.screen = pygame.display.set_mode(
(screen_width, screen_height))
pygame.display.set_caption("Ajedrez")
self.screen_height = screen_height
self.screen_width = screen_width
s_size = (screen_width, screen_height)
# Limite de jugadas
self.play_count = 0
# Obtienendo directorio para la carga de recursos
dirname = os.path.dirname(__file__)
# Creando tablero
path = os.path.join(dirname, "assets/Tablero.jpg")
skin = pygame.image.load(path)
self.chessboard = Chessboard(skin, screen_width, screen_height)
# Cargando imagenes de victoria
path = os.path.join(dirname, "assets/Player 1 win.png")
self.player1_win = pygame.image.load(path)
self.player1_win = pygame.transform.scale(self.player1_win, s_size)
path = os.path.join(dirname, "assets/Player 2 win.png")
self.player2_win = pygame.image.load(path)
self.player2_win = pygame.transform.scale(self.player2_win, s_size)
path = os.path.join(dirname, "assets/Empate.png")
self.empate = pygame.image.load(path)
self.empate = pygame.transform.scale(self.empate, s_size)
# Creando jugadores
self.player1 = Player(Player.PLAYER_ONE, Controller(player1_command))
self.player2 = Player(Player.PLAYER_TWO, Controller(player2_command))
self._add_knights()
self.player1_turn = True
self.done = False
self.winner = False
self.play_number = 0
self.timer = Timer()
def _add_knights(self):
"""
Agrega los caballos iniciales a los jugadores y al tablero
"""
# Altura y anchura de los caballos
width = self.screen_width / 8
height = self.screen_height / 8
# Obteniendo Path de los caballos
dirname = os.path.dirname(__file__)
caballo_blanco = os.path.join(dirname, "assets/Caballo blanco.png")
caballo_negro = os.path.join(dirname, "assets/Caballo negro.png")
for player_number in [Player.PLAYER_ONE, Player.PLAYER_TWO]:
# Obteniendo player
player = self.player1 if player_number == Player.PLAYER_ONE \
else self.player2
# Cargando imagen del caballo
file_path = caballo_blanco if player_number == Player.PLAYER_ONE \
else caballo_negro
skin = pygame.image.load(file_path)
# Creando caballos del jugador
for nc in range(16):
id_caballo = player_number * 100 + nc
# Calculando posicion del caballo
x = nc % 8
desp_y = 0 if player_number == Player.PLAYER_ONE else 6
y = int(nc / 8) + desp_y
# Creando caballo
knight = Knight(x, y, skin, width, height, id_caballo)
# Agregando caballo
player.add_knight(knight)
self.chessboard.add_knight(knight)
def launch_turns(self):
play_limit = self.PLAY_LIMIT * 2
while not self.winner and not self.done and self.play_count < play_limit:
self.play_count += 1
# Obteniendo jugador en turno
self.player1_turn = not self.player1_turn
player = self.player1 if self.player1_turn else self.player2
other_player = self.player1 if not self.player1_turn \
else self.player2
# Obteniendo accion del jugador
state = self.chessboard.get_state(player, other_player)
self.timer.reset()
good_movement = False
time_out = False
while not good_movement:
try:
action = player.get_action(state,
self.timer.current_time())
# print("Action: ")
# print(action.knight_id)
# print(action.knight_movement)
# Aplicando accion
self.chessboard.move(player, action.knight_id,
action.knight_movement)
good_movement = True
except NameError as e:
print(f"Player {player.player_number} error: {e}")
# Si el controlador se demora mas de 5 segundos queda
# eliminado
if e.__str__() == "TimeOut":
time_out = True
break
except Exception as e:
print("Error raro")
print(e)
# Registrando eliminacion por time out
if time_out or not good_movement:
self.winner = True
self.the_winner = other_player.player_number
# Actualizando jugador ganador
self.player_win = self.player1_win if self.the_winner == \
Player.PLAYER_ONE else self.player2_win
print(f"Player {player.player_number} pierde por time out")
# Registrando ganador
if player.point == 16:
self.winner = True
self.the_winner = player.player_number
# Actualizando jugador ganador
self.player_win = self.player1_win if self.the_winner == \
Player.PLAYER_ONE else self.player2_win
print(f"Player {player.player_number} win")
# else:
# time.sleep(0.1)
# Obteniendo ganador por limite de jugadas
if self.play_count == play_limit:
self.winner = True
if self.player1.point > self.player2.point:
self.the_winner = Player.PLAYER_ONE
self.player_win = self.player1_win
elif self.player1.point < self.player2.point:
self.the_winner = Player.PLAYER_TWO
self.player_win = self.player2_win
else:
self.the_winner = Player.PLAYER_PAR
self.player_win = self.empate
def run(self):
"""
Comprende el ciclo del juego. Este finaliza cuando alguno de los
jugadores gana.
"""
t = threading.Thread(target=self.launch_turns)
t.start()
while not self.done and self.graph_mode:
# Actualizando eventos
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.done = True
continue
player = self.player1 if self.player1_turn else self.player2
other_player = self.player1 if not self.player1_turn \
else self.player2
# Limpiando ventana
self.screen.fill((33, 33, 33))
# Dibujando tablero y jugadores
self.chessboard.draw(self.screen)
other_player.draw(self.screen)
player.draw(self.screen)
# Dibujando timer
self.timer.draw(self.screen)
# Dibujando ganador de la partida
if self.winner:
self.screen.blit(self.player_win, (0, 0))
# Actualizando tablero
pygame.display.update()
print("Esperando hilos")
t.join()
print("Juego finalizado")
print("Puntaje del jugador 1: ", self.player1.point)
print("Puntaje del jugador 2: ", self.player2.point)
