Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 2 years ago.
Improve this question
I am going through this paper to have a better understanding of how deep learning for Vision-related task works. I am not able to completely understand what exactly is "semantically-driven reconstruction" in this paragraph. -
The model is trained sequentially, starting from the lowest layer.
This allows to achieve good semantically-driven reconstruction results
at smaller scales that are working with images of very low resolution
and thus performing mostly global image manipulations.
Can anyone paraphrase this paragraph for easy understanding?
Thank You.
This PDF presentation should help, but the basic idea is that rather than simply parsing the image on pixels (e.g. boundaries, contours, depth), a semantic reconstruction would allow for image features to be labeled and the scene to be "understood" in a more human sense. In the context of this paragraph, then, they claim that by training their each model layer separately (rather than training all layers at once), they can successfully label and manipulate image features, even if the image resolution is low.
Related
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 2 years ago.
Improve this question
In the Reinforcement Learning book by Sutton & Barto, version 2018, authors provided a formula (Eq. 7.14, page 151) of the off-policy form with control variate :
How can I understand this equation? I can understand if we are on-policy, the later two terms inside the gamma part cancels out. But anyone why do we have to multiply the rho with G_{t+1:h}? How does this formula make any sense?
The \rho_{t+1} should always be there, even without control variate. This is because this equation concerns state-action values. It becomes clearer when you write out the arguments of the returns:
where , with pi and b the target and behavior policies respectively, and A_{t+1} was sampled according to the behavior policy.
The book in this section 7.4 is a bit confusing, because it goes straight from on-policy to off-policy with covariates, skipping over the recursive expressions of the returns for off-policy without covariates.
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 5 years ago.
Improve this question
I am creating a chess variant. The rules and pieces are the same with classic chess. The only different is the size of the board (12x12 instead of 8x8).
My goal is to validate and apply moves only. What options I have aside from writing everything from scratch?
Most popular formats seem to be limited to 8x8 boards only.
I am fine with any popular programming language.
There are three general approaches chess engines take in move generation. In chess programming jargon these are commonly known as:
1)Bitboards
2)Mailbox (chess jargon for arrays with padding)
3)Piece lists
The most common method used today is Bitboards, which unfortunately is not easily modifiable to larger boards. This shouldn't be too bad for you, however. The reason bitboards are the de-facto standard is not because the are the easiest to implement (they are in fact the most complex), but because they are much faster for move generation (and by extension validation). However, this is only pertinent for use in a search function that needs to validate moves tens of millions of times per second. If you just want good old simple move validation, the method two should be more than adequate, and easily adaptable to larger boards. If you want to see chess engines that utilize this method, look up engiines that use a mailbox or oX88 board representation. I think the didactic CPW engine uses mailbox.
https://chessprogramming.wikispaces.com/CPW-Engine
and here is an article about move generation:
https://chessprogramming.wikispaces.com/Move+Generation
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking us to recommend or find a tool, library or favorite off-site resource are off-topic for Stack Overflow as they tend to attract opinionated answers and spam. Instead, describe the problem and what has been done so far to solve it.
Closed 8 years ago.
Improve this question
I have a CSS file and an icon set which is referenced from that CSS file. The 500 icons are around 200k altogether, so I think inlining them into the CSS file at wherever they are referenced would not increase used bandwidth, and significantly decrease the amount of requests sent to the server.
Does anyone here know a tool or script to automate the replacement of
url('images/....png')
with
url(data:image/png;base64,....)
Perhaps there is already a tool that automates this?
Otherwise I'll have to write my own regexp. Is a bash script the way to go?
if you really want to decrease the amount of requests then look for a way to convert all the icons into a sprite! it is basically all your images pasted on to one single image file with a css file which has position of all the images have a look at glyphicons:
http://getbootstrap.com/components/
usage of sprite will not reduce the size but will surely reduce the number of requests being sent to server as the client will download one single big image, which will have all the icons and according to css properties will show the relevant icons
use this for generating sprites
http://css.spritegen.com/
and i would never recommend to use inline styling. If needed should be used minimally. Because it does slow down the rendering
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 8 years ago.
Improve this question
I am trying to see if my understanding of "othello" fame is correct or not. According to the rules, we flip the dark/light sides if we get some sequence like X000X => XXXXX. The question I have is if in the process of flipping 0->X or X-> 0, do we also need to consider the rows/columns/diagonals of newly flipped elements? e.g. consider board state as shown in above image(New element X is placed # 2,3)
When we update board, we mark elements from 2,3 to 6,3 as Xs but in this process elements like horizontal 4,3 to 4,5 and diagonal 2,3 to 4,5 are also eligible for update? so do we update those elements as well? or just the elements which have starting as 2,3 (i.e update rows/column/diagonal whose starting point is the element we are dealing with, in our case 2,3?)
Please help me understand it
No. Newly flipped pieces are not considered recursively.
No, this would unbalance the game significantly. Some friends and I actually tried playing like this a long time ago. The game turned out to be barely playable. It was less a matter of strategy and more a matter of luck and who happened to go first, reach a side first, etc.
In any given turn, tiles are flipped only outward from the piece which was placed during that turn.
(Note also in the example board in your question, O has seriously given up the game to X. He has no chance at this point :)
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 9 years ago.
Improve this question
Canvas from html5 was introduced some time ago. Currently it's used (almost) only for demonstrations how cool it is - it's mainly related to painting, games and charts. Many of them can be found at Canvas demos.
How creatively / unusually can canvas be used?
Some examples:
jsAscii - ASCII art from images with
Javascript and Canvas (yea, I
know, it's painting but not the
classic one)
Javascript compression using PNG and
Canvas
There's a really cool tool called Detexify which uses machine learning on the back end which allows you to draw the LaTeX symbol you're interested in knowing the LaTeX code of and it will suggest one for you based on what it's learned from other users.
My two favorite are:
Processing.js - an implementation of the processing language in javascript/canvas.
Bespin - a collaborative coding IDE that feels more like a beautiful native app.
I always thought of creating a simple image editor with the canvas tag. It would be easy to use it for cropping, resizing, changing color values, removing red eyes etc.