Видео

Hey! I love your tips, especially the one about openings-it's truly shocking! You're right-legal check is indeed algorithmically inefficient in my implementation. And telling the model which side it's playing sounds so logical! However, I still think it should have an extra channel indicating which pieces it can move (this should be tested in an experiment). Though I agree, telling WHERE it can move them is really ambiguous. By the way, accuracy doesn't seem like a reasonable metric here (I understand it's easier to compute). I would suggest Top-3 or Top-5 Accuracy, since sometimes there can be up to even 10 decent moves

@@_NickTech Yes, you could absolutely be right about the extra channel, but maybe one could create some system to embed more information inside it instead of using only 1s and 0s? For example some kind of embedding to make it possible for the model to understand exactly which piece can move to some specific square. It would be really interesting to see how these kinds of inputs change the outcome of the model, especially if it is a solution you come up with by yourself! And yes, you are completely right about the accuracy, it is a super good tip and something I will implement now! Looking forward to the reinforcement 😉

I think js has some AI packages

@@magix6638 I ended up using a compiled stockfish to js, chessboard.js and chess.js, it is a much straightforward approach

Thanks for the kind words! 😊 I haven’t coded in Processing before

Thanks! I appreciate it!

You got it right! Though no one forbids using arbitrary-precision arithmetic

Glad to hear it! Thank you for watching!

Hey, you got it correctly! However, when the dataset is quite large, the probability that there won't be a needed move is really low (unless you start playing 'exotic' chess). You can plot a graph of the number of unique moves versus the number of parsed games. The convergence to the asymptote is good. But sure, you can create an action space that includes all possible moves

Thank you for watching.

Then the result will obviously be false (due to the type check), and the example will be obscure. By the way, it's a matter of coding style, though === is preferred by the majority (and for good reason)

@@_NickTech yes i said === is preferred by googles typescript style guide

I appreciate your kind words, thank you!

Thank you for your support! I'm actively working on improving my speech. Hopefully, it'll be easier to follow me in the future

i didn't mind the accent, i could understand everything and it's not annoying to me:) you know what _is_ annoying? javascr

​@@_NickTech please don't change your accent just for these people. Accents are normal they're just mad you don't have an american accent like it's the only one there

I mean I see what you mean but it's not hard to understand Even as an American, I can make out everything

Hey, OpenCV, TensorFlow, PyTorch, YOLO, Detectron2 are good options. OpenCV is known for its simplicity and ease of use, so I would recommend to start with it

i love javascript because it put food on the table. and i dont really hate it.may be a little, for being weird.

Sure! Thank you for advising

Hey, thanks for your comment! 😊 The dataset includes sequential moves where each move depends on previous states. Shuffling helps prevent the model from learning sequential dependencies that do not generalize well to new games. Otherwise, it might only learn specific openings, for example. Shuffling ensures that the model sees a variety of positions in each batch, which is beneficial for learning. Using an MLP for this task is interesting, but I doubt it would catch any patterns as effectively as a CNN. CNNs seem logical to me for this kind of data. And yes, you are right: evaluation calculation is not only needed but essential! For the CNN model, there is no difference between a blunder and a brilliant move. Only evaluation can solve that problem. Regarding endgames, there is one obvious issue: there are so many possible positions. Openings are relatively standard: develop pieces, control the center, and castle your king. Middlegames are trickier, but endgames are extraordinarily varied! There are no clear patterns in them

it's on my TODO list, though I've been told that convergence will be poor. We'll see

@@_NickTech why pytorch one is considerably better even with same architecture can you explain? How much ram ,vram does it used,also have you use multiprocessing

You mean in comparison with the TF model from my other video? If so, the architecture is different: I changed the input (there were 12 channels; I added one more). If you apply that change to the TF model, then you will get a similar result. Though PyTorch has a more efficient memory management system (for example, it uses a dynamic computation graph rather than a static one like in TF), which allowed me to train a model using more data. I didn't use multiprocessing, though you can easily add it to the data loading by specifying *num_workers*: data_loader = DataLoader(dataset, batch_size, num_workers=4) About RAM: 16-30 GB were in use, depending on how many samples you keep in your dataset.

@@_NickTech may I create a interface for that(I can use the frontend from by University project with improvements)

@@ponmuthu..4796 My friend has already created an interface for it, which I'll cover in the next video: setday.github.io/chess-engine-online/ his github repo: github.com/setday/chess-engine-online But you can create it as well for the sake of practicing :)

Thanks for watching!

Hey, "TensorFlow" is in the title and on the thumbnail 😁. That's a great idea, thank you! I want to do it, though not in assembly, I'm afraid. But in C/C++ with the usage of GSL for linear algebra, I guess

You can also add a 14th dimension for even better results. The 13th channel shows where you can move pieces, but it doesn't show from which squares you can move them. I've already tried it; the results will be better, though blunders are inevitable, of course. Here is how you can modify the board_to_matrix function to include the 14th dimension (auxiliary_func.py, from line 22): for move in legal_moves: to_square = move.to_square from_square = move.from_square row_to, col_to = divmod(to_square, 8) row_from, col_from = divmod(from_square, 8) matrix[12, row_to, col_to] = 1 matrix[13, row_from, col_from] = 1 And thanks a lot for your comment! I'm glad you liked the video!

​@@_NickTech I implemented your idea and something wasnt working so i decided to use your exact same architecture and it worked perfectly fine. Could you please explain how you decided to take that exact architecture? thanks! This was my architecture before: class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.a1 = nn.Conv2d(5, 16, kernel_size=3, padding=1) self.a2 = nn.Conv2d(16, 16, kernel_size=3, padding=1) self.a3 = nn.Conv2d(16, 32, kernel_size=3, stride=2) self.b1 = nn.Conv2d(32, 32, kernel_size=3, padding=1) self.b2 = nn.Conv2d(32, 32, kernel_size=3, padding=1) self.b3 = nn.Conv2d(32, 64, kernel_size=3, stride=2) self.c1 = nn.Conv2d(64, 64, kernel_size=2, padding=1) self.c2 = nn.Conv2d(64, 64, kernel_size=2, padding=1) self.c3 = nn.Conv2d(64, 128, kernel_size=2, stride=2) self.d1 = nn.Conv2d(128, 128, kernel_size=1) self.d2 = nn.Conv2d(128, 128, kernel_size=1) self.d3 = nn.Conv2d(128, 128, kernel_size=1) self.last = nn.Linear(128, 1) def forward(self, x): x = F.relu(self.a1(x)) x = F.relu(self.a2(x)) x = F.relu(self.a3(x)) # 4x4 x = F.relu(self.b1(x)) x = F.relu(self.b2(x)) x = F.relu(self.b3(x)) # 2x2 x = F.relu(self.c1(x)) x = F.relu(self.c2(x)) x = F.relu(self.c3(x)) # 1x128 x = F.relu(self.d1(x)) x = F.relu(self.d2(x)) x = F.relu(self.d3(x)) x = x.view(-1, 128) x = self.last(x) # value output return F.tanh(x)

@nmxnunezz8214 hey, I see two major issues: 1. Why nn.Linear(128, 1) at the end? Are you solving a regression task? And why scale the output to the range [-1, 1] with F.tanh(x)? This should be a classification task, not regression. The last layer should be nn.Linear(128, number_of_unique_moves). Then apply softmax to get probabilities. 2. Do you only have 5 channels? Why so few? I inferred this from nn.Conv2d(5, ... ).

Yes! You're absolutely right! The 13th channel did all the work here. (I don't remember the precise numbers, but when I trained the TF model with the 13th channel, the convergence and performance were about the same). It's actually logical because this 13th channel indicates some rules of chess, and the correlation with the target is obviously high. I should've mentioned this in the video 😬 Thank you for your comment!

@@_NickTech Thanks for the response. Good luck with your future videos!

In ML and DL, people usually use Python, unless it's for HFT. Speed was not my primary concern in this project, so coding with Python was much faster and easier. That's it. Typically, drafts are written in Python first and only rewritten in C/C++ if necessary

Hey, thank you for such a detailed comment! You are totally right - without knowledge of the game and predicting only the next move, any pure NN method is doomed. I love the idea of solving a regression task with scoring. But to get a score for each move, would you need to use Stockfish or another engine? If so, it seems strange to me: using one engine to build another, esp. which will perform much worse

@@_NickTech I mean it all depends on how you frame it, to me the "scoring" methodology is just as important to the process of Machine Learning as is applying the model type. You can also build any of these "scoring engines" from scratch, with the basic ones using pure addition/subtraction and a recursive loop w/ a depth limit. In the instance of a classification model, it's not scoring but you can create a category of the legal moves being "good", "decent", "bad" to better apply the concept of choose-from-all-legal-moves. A pure NN approach is interesting but yeah it will always be awful considering that it's just sort being fed a garbage-in garbage-out without any means to score each individual move given the board state. If, however, you wanted to do a no-think-ahead engine you could consider the following - generally, a move is "losing" closer to the end of the game. So using the move counter of the game, and that knowledge, you could apply a more-negative score to moves made nearing the end of the game on the side that loses, and inverse for the side that wins. Then just flat apply some metric to the earlier moves to balance the distribution. And then in the instance of a draw, score the moves by the game length to achieve the draw, with a more even-random distribution. There are a million things to try, but ultimately there's a reason that every top engine is "score + neural net" and no flat-neural net classifier has done well (even the 2016 alpha zero taught itself how to score)

​@@trevoreguitar I see what you mean. Thank you for your insights. By the way, an interesting fact: Stockfish neither use scoring nor neural nets when there are <= 7 pieces on the board. Stockfish solves the game perfectly using endgame databases

Glad you like it! Thanks for kind words!

Stockfish can already easily defeat any human, as far as I know 😄 And then there's AlphaZero as well... 😱 Still, it's a nice idea, thank you!

Best of luck to you in learning Python! When you come back, feel free to ask any questions!

Thanks! I appreciate your kind comment!

Thanks for watching! More content is on the way, so stay tuned! 😊

Hey! Thanks for your support, I appreciate it! ❤ About RAM - yeah, it's a common problem with neural networks, esp. CNNs, because of the size of tensors X and Y. But you can manage it in stages. Just remember, the last layer's size has to match the vocabulary (total number of legal moves in the dataset). This layer must stay fixed-you can't change the NN structure after training. So, start by creating a big array of unique targets (as long as it fits in memory). Once you've fixed the size and set up mappings like int_to_move & move_to_int, you can split X into segments (X_1, X_2, ..., X_n) and train the model iteratively with each segment. It should work fine, but it'll take hours, days, weeks, months... Using multiple computers: Yep, it's possible (called "distributed and parallel training"). TensorFlow and Keras support this approach, though I haven't tried it myself yet (

@@_NickTech Cool! Thanks for the explanation. I would love to see this project turned into a series...