def main():
args = parse()
match args.task:
case 'play':
play(args)
case 'gen':
generate(args)
def ask_operation(chunk):
'ask the operator to classify this chunk'
question = Menu(TRUTH_OPTIONS,
title="Who's speaking in the audio you just heard?")
if chunk.truth not in TRUTH_OPTIONS:
play(chunk.cut(audio))
chunk.truth = question.ask()
def _user_key(self, key):
""" user pressed this key or button """
if (key > 0) and (key <= vivi_defines.CATEGORIES_NUMBER):
self.judged_cat.emit(key - vivi_defines.CATEGORIES_CENTER_OFFSET)
elif key == 8:
utils.play(self.judge_filename + '.wav')
elif key == 9:
self.judged_cat.emit(JUDGEMENT_CANCEL)
elif key == 0:
self.judged_cat.emit(vivi_defines.CATEGORY_WEIRD)
def _user_key(self, key):
""" user pressed this key or button """
if (key > 0) and (key <= vivi_defines.CATEGORIES_NUMBER):
self.judged_cat.emit(key - vivi_defines.CATEGORIES_CENTER_OFFSET)
elif key == 8:
utils.play(self.judge_filename+'.wav')
elif key == 9:
self.judged_cat.emit(JUDGEMENT_CANCEL)
elif key == 0:
self.judged_cat.emit(vivi_defines.CATEGORY_WEIRD)
def get_interplay_data(agent1, agent2, num_episode):
experiences = []
for i in range(num_episode//2):
experience, z = utils.play(agent1, agent2)
for i, e in enumerate(experience):
experiences.append(e + [z if i % 2 == 0 else -z])
experience, z = utils.play(agent2, agent1)
for i, e in enumerate(experience):
experiences.append(e + [z if i % 2 == 0 else -z])
return experiences
def get_win_rate(agent1, agent2, num):
sum_z = 0
for i in range(num//2):
_, z = utils.play(agent1, agent2)
sum_z += z
_, z = utils.play(agent2, agent1)
sum_z -= z
if num%2 == 1:
if np.random.random() > 0.5:
_, z = utils.play(agent1, agent2)
sum_z += z
else:
_, z = utils.play(agent2, agent1)
sum_z -= z
return sum_z / num / 2 + 0.5
def playLive(name, quality):
"""
:param name: string: stream/channel name
:param quality: string: qualities[quality]
0 = Source, 1 = 1080p60, 2 = 1080p30, 3 = 720p60, 4 = 720p30, 5 = 540p30, 6 = 480p30, 7 = 360p30, 8 = 240p30, 9 = 144p30
-1 = Choose quality dialog
* any other value for quality will use addon setting
"""
videoQuality = utils.getVideoQuality(quality)
if videoQuality != -1:
# videoQuality == -1 if quality dialog was cancelled
stream = CONVERTER.convertStreamToPlayItem(TWITCHTV.getStreamInfo(name))
stream['path'] = TWITCHTV.getLiveStream(name, videoQuality)
utils.play(stream['path'], stream)
utils.execIrcPlugin(name)
def playLive(name, quality):
"""
:param name: string: stream/channel name
:param quality: string: qualities[quality]
qualities = {'-1': -1, '0': 0, '1': 1, '2': 2, '3': 3, '4': 4}
0 = Best, 1 = 720, 2 = 480, 3 = 360, 4 = 226,
-1 = Choose quality dialog
* any other value for quality will use addon setting
"""
videoQuality = utils.getVideoQuality(quality)
if videoQuality != -1:
# videoQuality == -1 if quality dialog was cancelled
stream = CONVERTER.convertStreamToPlayItem(TWITCHTV.getStreamInfo(name))
stream['path'] = TWITCHTV.getLiveStream(name, videoQuality)
utils.play(stream['path'], stream)
utils.execIrcPlugin(name)
def get_selfplay_data(agent, num_episode):
experiences = []
for i in range(num_episode):
experience, z = utils.play(agent, agent)
for i, e in enumerate(experience):
experiences.append(e + [z if i % 2 == 0 else -z])
return experiences
def playLive(name, quality):
"""
:param name: string: stream/channel name
:param quality: string: qualities[quality]
qualities = {'-1': -1, '0': 0, '1': 1, '2': 2, '3': 3, '4': 4}
0 = Best, 1 = 720, 2 = 480, 3 = 360, 4 = 226,
-1 = Choose quality dialog
* any other value for quality will use addon setting
"""
videoQuality = utils.getVideoQuality(quality)
if videoQuality != -1:
# videoQuality == -1 if quality dialog was cancelled
stream = CONVERTER.convertStreamToPlayItem(TWITCHTV.getStreamInfo(name))
stream['path'] = TWITCHTV.getLiveStream(name, videoQuality)
utils.play(stream['path'], stream)
utils.execIrcPlugin(name)
def play(self):
if not self.examine_note.basename:
return
if self.plot_actions.has_selection():
start, dur = self.get_zoom_seconds()
#print "play zoom in on: ", start, dur
#utils.play(self.examine_note.wavfile,
# start, dur)
#return
else:
start = self.examine_note.note_start
dur = self.examine_note.note_length
# to avoid icky blimps in the big grid display
start += CONVOLUTION_DELAY
dur -= CONVOLUTION_DELAY
#print "play note: ", start, dur
utils.play(self.examine_note.basename + '.wav', start, dur)
def minimizer(state: dict, depth: int):
if is_final(state) or depth == 0:
return heur(state)
value = inf
for x in range(0, LINE_SIZE):
if pos_is_playable(state, x, PLAYER_0):
played = play(state, x, PLAYER_0)
value = min(value, maximizer(played, depth - 1))
return value
def playVideo(_id, quality):
"""
:param _id: string: video id
:param quality: string: qualities[quality]
qualities = {'-1': -1, '0': 0, '1': 1, '2': 2, '3': 3, '4': 4}
0 = Best, 1 = 720, 2 = 480, 3 = 360, 4 = 226,
-1 = Choose quality dialog
* any other value for quality will use addon setting
"""
videoQuality = utils.getVideoQuality(quality)
if videoQuality != -1:
# videoQuality == -1 if quality dialog was cancelled
videoInfo = CONVERTER.getVideoInfo(TWITCHTV.getVideo(_id))
simplePlaylist = TWITCHTV.getVideoPlaylist(_id, videoQuality)
playlistItems = PLAYLIST_CONVERTER.convertToXBMCPlaylist(simplePlaylist, videoInfo.get('title', ''),
videoInfo.get('thumbnail', ''))
if playlistItems != ():
(playlist, listItem) = playlistItems
utils.play(listItem.get('path', ''), listItem)
else:
raise TwitchException(TwitchException.NO_PLAYABLE)
def playVideo(_id, quality):
"""
:param _id: string: video id
:param quality: string: qualities[quality]
0 = Source, 1 = 1080p60, 2 = 1080p30, 3 = 720p60, 4 = 720p30, 5 = 540p30, 6 = 480p30, 7 = 360p30, 8 = 240p30, 9 = 144p30
-1 = Choose quality dialog
* any other value for quality will use addon setting
"""
videoQuality = utils.getVideoQuality(quality)
oauthtoken = utils.getOauthToken()
if videoQuality != -1:
# videoQuality == -1 if quality dialog was cancelled
videoInfo = CONVERTER.getVideoInfo(TWITCHTV.getVideo(_id))
simplePlaylist = TWITCHTV.getVideoPlaylist(_id, videoQuality, oauthtoken)
playlistItems = PLAYLIST_CONVERTER.convertToXBMCPlaylist(simplePlaylist, videoInfo.get('title', ''),
videoInfo.get('thumbnail', ''))
if playlistItems != ():
(playlist, listItem) = playlistItems
utils.play(listItem.get('path', ''), listItem)
else:
raise TwitchException(TwitchException.NO_PLAYABLE)
def playVideo(_id, quality):
"""
:param _id: string: video id
:param quality: string: qualities[quality]
qualities = {'-1': -1, '0': 0, '1': 1, '2': 2, '3': 3, '4': 4}
0 = Best, 1 = 720, 2 = 480, 3 = 360, 4 = 226,
-1 = Choose quality dialog
* any other value for quality will use addon setting
"""
videoQuality = utils.getVideoQuality(quality)
if videoQuality != -1:
# videoQuality == -1 if quality dialog was cancelled
videoInfo = CONVERTER.getVideoInfo(TWITCHTV.getVideo(_id))
simplePlaylist = TWITCHTV.getVideoPlaylist(_id, videoQuality)
playlistItems = PLAYLIST_CONVERTER.convertToXBMCPlaylist(
simplePlaylist, videoInfo.get('title', ''),
videoInfo.get('thumbnail', ''))
if playlistItems != ():
(playlist, listItem) = playlistItems
utils.play(listItem.get('path', ''), listItem)
else:
raise TwitchException(TwitchException.NO_PLAYABLE)
def minimax(state: dict, depth: int):
to_play = -1
value = -inf
for x in range(0, LINE_SIZE):
if pos_is_playable(state, x, PLAYER_1):
played = play(state, x, PLAYER_1)
game_value = minimizer(played, depth)
if game_value > value:
value = game_value
to_play = x
return to_play
def post(self):
args = self.reqparse.parse_args()
token = args['token']
move = args['move']
register = game['register']
status = game['status']
player = utils.get_key(register, token)
if player != -1:
game['status'][player] = move
if status['player1'] != None and status['player2'] != None:
previousGame = utils.play(status['player1'], status['player2'])
status['previousGame'] = previousGame
print(game)
return 1
else:
return -1
def minimizer(state: dict, depth: int, alpha: float, beta: float):
if is_final(state) or depth == 0:
return heur(state)
value = inf
for x in range(0, LINE_SIZE):
if pos_is_playable(state, x, PLAYER_0):
played = play(state, x, PLAYER_0)
value = min(value, maximizer(played, depth - 1, alpha, beta))
if value <= alpha:
return value
beta = min(beta, value)
return value
1j * phase) # that fixes the abs() ope previously done
features = np.transpose(features, (1, 0))
return feature_extractor.get_audio_from_stft_spectrogram(features)
for pred, target, phase in train_dataset:
# pred = np.transpose(pred, (1, 0))
# target = np.transpose(target, (1, 0))
print("Min:", np.min(pred), "Max:", np.max(pred))
print("Min:", np.min(target), "Max:", np.max(target))
print("Min:", np.min(phase), "Max:", np.max(phase))
phase = np.transpose(phase.numpy(), (1, 0))
print("Pred:", pred.shape)
print("Phase:", phase.shape)
print("target:", target.shape)
audio = revert_features_to_audio(target.numpy(), phase)
break
print("Audio length:", len(audio))
play(audio, sample_rate=16000)
# Min: -0.5883574 Max: 10.728247
# Min: -4.8901606 Max: 7.3664904
# Min: -3.1415927 Max: 3.1415927
# Phase: (129, 201)
# target: (201, 129, 1, 1)
# Audio length: 12800
from utils import play
if __name__ == '__main__':
play()
from TicTacToe import TicTacToe
from Players.Human import Human
from Players.AI import WeakAI, SmartAI
from utils import play
if __name__ == '__main__':
x_player = Human('X')
o_player = SmartAI('O')
t = TicTacToe()
play(t, x_player, o_player, print_game=True)
def user_judge(self, judge_filename):
""" prompt user to judge this audio file """
self.judge_filename = judge_filename
self.display()
utils.play(self.judge_filename + '.wav')
def user_judge(self, judge_filename):
""" prompt user to judge this audio file """
self.judge_filename = judge_filename
self.display()
utils.play(self.judge_filename+'.wav')
def table_play(self):
row = self.table.currentRow()
if row >= 0:
wavfile = self.data[row][0]
utils.play(wavfile)
def connect4(path='data/connect4', seed=161831415):
env = envs.Connect4()
rand_epochs = 1000
ai_epochs = 0
test_games = 500
mem_size = 200
log_freq = 100
# 3 states per position
depth = 3
# The state is preprocessed and has this shape now
dim_state = [depth, *env.n_state]
log = Logger(log_freq)
# Simple dqn
net = dqn.Conn(depth, env.n_action)
ai = agents.DQNAgent(env.n_state,
env.n_action,
net,
logger=log,
lr=1e-3,
discount_factor=.98,
exploration_decay=.98,
exploration_min=.1,
state_preprocessor=f_one_hot_state(depth,
-1,
new_size=[1] +
dim_state))
mem = LinearMemory(dim_state, mem_size, ai.learn)
# Train first against random agent
rand_act = envs.Connect4.random_act()
# Loading
# TODO : ai.load(path)
# Training
print('Training vs random')
train(ai, rand_act, mem, env, rand_epochs, log, False)
# print('Training vs ai')
# TODO : train(ai, ai.act, mem, env, ai_epochs, log, True)
# Saving
# TODO : ai.save(path)
# Testing
ai.exploration_rate = 0
win, draw = test(ai.act,
rand_act,
env,
games=test_games,
state_preprocessor=ai.state_preprocessor)
print(f'Test on {test_games} games : Victories : {win} Draws : {draw}')
print(f'Win or draw rate : {(win + draw) / test_games * 100:.1f} %')
# Playing
while 1:
print('New Game')
p1, p2 = play(ai.act,
user_act(env.n_action),
env,
state_preprocessor=ai.state_preprocessor)
if p1 > 0:
print('AI won')
elif p2 > 0:
print('You won')
else:
print('Error / Draw')
def confirm_truth(clf,
audio,
chunk_group_or_voice,
group=10,
limit=10,
speed=1):
'''Successively confirm truth suggestions of groups of chunks.
Spawns refit and repredict on new ground truth
whenever possible, on a separate thread.'''
features = get_features(audio)
chunks = get_chunks(audio)
print('Confirm label classifications.')
print('Type:')
print(' * just ENTER to confirm'
' * "s" to set SPEAKER as ground truth\n'
' * "t" to set TRANSLATOR as ground truth\n'
' * "b" to set BOTH as ground truth\n'
' * "a" to hear it again\n'
' * "/" to inspect one by one\n'
' * and anything else to stop.')
def _refit_and_predict():
training_chunks = {
voice: [c for c in chunks if c.truth == voice]
for voice in VOICES
}
spawn_refit_and_predict(clf, features, training_chunks, chunks)
while (limit):
limit = limit - 1 # we need to explicitly decrement to enable repeat
if chunk_group_or_voice in VOICES:
unknown = [
c for c in chunks
if not c.truth and c.label[0] == chunk_group_or_voice
]
else:
unknown = [c for c in chunk_group_or_voice if not c.truth]
best_first = get_best_labeled(unknown, group, 1000)
if not best_first:
# give up min audible length
best_first = get_best_labeled(unknown, group, 0)
if not best_first:
# really done
break
for best in best_first:
print('#' * 30, best.label, chunks.index(best))
play(sum(best.cut(audio) for best in best_first), speed)
typed = raw_input().strip().lower()
truth_option = {'s': SPEAKER, 't': TRANSLATOR, 'b': BOTH}.get(typed)
if not typed:
# default to label as ground truth
for best in best_first:
best.truth = best.label[0]
_refit_and_predict()
elif truth_option:
# truth value set explicitly
for best in best_first:
best.truth = truth_option
_refit_and_predict()
elif typed == 'a':
# play again
limit = limit + 1 # restore limit
continue
elif typed == '/':
# start inspecting one by one
# increase limit to inspect at least all group
limit = limit + group
group = 1
speed = 1 # slow down
continue
else:
break
ax.set_xlabel('Time step [frame]')
ax.legend(['Threshold', 'Likelihood', 'Mask'])
ax = axes[0 + has_mask]
ax.plot(batch_np['loudness_db'][:TRIM])
ax.plot(audio_features_mod['loudness_db'][:TRIM])
ax.set_ylabel('loudness_db')
ax.legend(['Original', 'Adjusted'])
ax = axes[1 + has_mask]
ax.plot(librosa.hz_to_midi(batch_np['f0_hz'][:TRIM]))
ax.plot(librosa.hz_to_midi(audio_features_mod['f0_hz'][:TRIM]))
ax.set_ylabel('f0 [midi]')
_ = ax.legend(['Original', 'Adjusted'])
plt.show()
else:
print(
'\nSkipping auto-adjust (no notes detected or ADJUST box empty).')
# Resynthesize audio.
af = batch if audio_features_mod is None else audio_features_mod
outputs = model(af, training=False)
audio_gen = model.get_audio_from_outputs(outputs)
play(audio_gen, savefile=jbprompt.selected_filename)
print("Finished Playing Sound")
if not ate: self.body.pop(0)
self.update_state()
return self.state, reward, False, {}
if __name__ == "__main__":
env = Snake()
agent = Rainbow_DQN_Agent(environment=env,
model_class=SnakeModel,
learning_rate=0.001,
gamma=0.99,
replay_buffer_size=20000,
minimum_buffer_size=5000,
noisy_net=True,
epsilon=1,
epsilon_decay=0.999,
epsilon_min=0.01,
prioritized_sample=True,
alpha=0.5,
beta0=0.6,
beta_iters=100000,
transfer_frequency=1000,
device=torch.device('cuda:0'))
agent.train(num_episodes=2000,
save_path='models/snake_model.pth',
batch_size=128)
play(environment=env,
model_class=SnakeModel,
model_path='models/snake_model.pth',
num_episodes=1)
import fileinput
import re
from utils import play
if __name__ == "__main__":
m = re.match(f"(.+) players; last marble is worth (.+) points", list(fileinput.input())[0])
nplayers, nmarbles = int(m.group(1)), int(m.group(2))
score = play(nplayers, nmarbles, list)
players = list(score.keys())
players.sort(key=lambda x: score[x], reverse=True)
print(f"Player {players[0]} has highest score with {score[players[0]]}")
def play(request):
return utils.play(request)
x = torch.relu(self.fc2(x))
x = self.fc3(x)
return x
if __name__ == "__main__":
env = gym.make('MountainCar-v0')
agent = Rainbow_DQN_Agent(
environment = env,
model_class = CartPoleModel,
learning_rate = 0.01,
gamma = 0.95,
replay_buffer_size = 10000,
minimum_buffer_size = 1000,
prioritized_sample = False,
alpha = 0,
beta0 = 0,
beta_iters = 0,
transfer_frequency = 200,
device = torch.device('cpu')
)
agent.train(
num_episodes = 500,
save_path = 'models/mountaincar_model.pth',
batch_size = 128
)
play(
environment = env,
model_class = CartPoleModel,
model_path = 'models/mountaincar_model.pth',
num_episodes = 1
)
def table_play(self):
row = self.table.currentRow()
if row >= 0:
wavfile = self.data[row][0]
utils.play(wavfile)
def inner(*_, **__):
nonlocal id
play(id)
heuristic1 = heuristic_1 # Red
heuristic2 = random_heuristic # Blue
timeouts = sorted(
set([float(x) if (x % 50 == 0) else 50 for x in range(50, 1001)]))
search_depths = list([x for x in range(1, 6)])
plt.ylabel('maximum depth')
plt.xlabel('maximum timeout')
plt.title('Heuristics results')
for depth in search_depths:
for timeout in timeouts:
print(' depth: ', depth, ' timeout: ', timeout)
player1 = QuixoPlayer(depth, timeout, heuristic1) # X
player2 = QuixoPlayer(depth, timeout, heuristic2) # O
try:
game = play(player1, player2)
except Exception:
plt.plot(timeout, depth, c='black', marker='o', linewidth=1.0)
continue
if (game.game_over('X')): # If X is the winner
plt.plot(timeout, depth, c='red', marker='o', linewidth=1.0)
else:
if (game.game_over('O')): # If O is the winner
plt.plot(timeout, depth, c='blue', marker='o', linewidth=1.0)
else: # Tie
plt.plot(timeout, depth, c='black', marker='o', linewidth=1.0)
plt.show()
global current_synthesized_model, synthesizer
encoder.load_model("Real_Time_Voice_Cloning/pretrained/encoder/saved_models/pretrained.pt", "cpu") # what is this used for
vocoder.load_model("Real_Time_Voice_Cloning/pretrained/vocoder/saved_models/pretrained.pt", verbose=False)
# todo: figure out how the multiple utterances work
synthesizer = get_synthesizer("Real_Time_Voice_Cloning/pretrained/synthesizer/saved_models/logs-pretrained")
if len(text) > 4 and text[-4:] == ".txt": # check if file
words = ""
with open(text) as file:
for line in file:
words += line
text = words
del words
if isinstance(audio_samples, str):
utterance = Utterance("name", "speaker_name", None, None, np.load(audio_samples), None, None)
else:
utterance = create_utterance(audio_samples)
current_synthesized_model = generate_spectrogram(text, utterance)
audio_file = decode_spectrogram(*current_synthesized_model)
return audio_file, utterance.embed
if __name__ == '__main__':
sample_rate = syn_params.hparams.sample_rate
while True:
input("Hit enter to record:")
wav = utils.record(sample_rate, 5)
input("Hit enter to play")
utils.play(wav, sample_rate)
print(wav.shape)
