Update README.md

README.md

@@ -16,4 +16,142 @@ tags:
 - pytorch
 - alphago-style
 pretty_name: Go Game Dataset for Neural Network Training
----
+---
+# Dataset Card for Go Game Dataset for Neural Network Training
+
+This is a high-quality dataset designed for Go neural network training, containing board positions extracted from curated SGF game records. The dataset is divided into three strength categories: Standard, Strong, and Elite, with approximately 1,000 samples per category.
+
+## Dataset Details
+
+### Dataset Description
+
+This dataset contains Go board positions and corresponding moves extracted from high-quality SGF game files, specifically designed for training Go policy networks. Each sample includes a 19x19 board state (represented as a 3-channel tensor) and the corresponding next move (represented as a one-dimensional index).
+
+The dataset is divided into three strength categories based on game quality:
+- Standard level (Quality 80-85): High-level amateur and entry-level professional games
+- Strong level (Quality 86-92): Mid to high-level professional games
+- Elite level (Quality 93-100): Top professional player games
+
+The dataset contains approximately 3,000 board position samples, stored in PyTorch tensor format for direct use in deep learning model training.
+
+- **Curated by:** The dataset was compiled by the user based on publicly available Go game records
+- **Language(s) (NLP):** zh, en
+- **License:** Apache 2.0
+
+### Dataset Sources
+
+- **Repository:** Original SGF game records from https://homepages.cwi.nl/~aeb/go/games/
+- **Paper:** No related papers
+- **Demo:** No demonstration site available
+
+## Uses
+
+### Direct Use
+
+This dataset is suitable for the following uses:
+- Training Go policy networks (predicting the next best move)
+- Initial training of Go AI systems
+- Research on Go pattern recognition and pattern mining
+- Studying style and strategy differences between players of different levels
+- Supervised learning pre-training phase in reinforcement learning
+
+### Out-of-Scope Use
+
+The following uses are not suitable or effective:
+- Building complete Go AI systems (requires techniques like Monte Carlo Tree Search)
+- Training value networks (dataset does not include win probability estimates)
+- Large-scale commercial Go engine training (sample size is relatively small)
+- Training for non-19x19 Go boards
+- Training for other board games like chess, xiangqi, etc.
+
+## Dataset Structure
+
+The dataset is divided into train, val, and test subsets with approximately 80:10:10 ratio, containing the following files:
+
+Each subset directory contains:
+- `boards.pt`: Board state tensors, shape (N, 3, 19, 19)
+  - Channel 0: Black stone positions (1 indicates black stone, 0 indicates none)
+  - Channel 1: White stone positions (1 indicates white stone, 0 indicates none)
+  - Channel 2: Next player (all 1s for black's turn, all 0s for white's turn)
+- `moves.pt`: Actual next move, shape (N,), values range 0-360 (representing positions on 19x19 board)
+- `colors.pt`: Color of the next player, shape (N,), 1 for black, 0 for white
+- `metadata.json`: Contains sample information such as category, game ID, etc.
+
+The root directory also contains:
+- `stats.json`: Dataset processing statistics
+- `README.md`: Dataset usage instructions
+
+## Dataset Creation
+
+### Curation Rationale
+
+The motivation for creating this dataset was to provide a high-quality, graded, and easy-to-use training resource for Go AI research. Existing Go datasets are often unfiltered or lack quality ratings. This dataset implements strict quality filtering (scores above 80) and categorizes by player strength, allowing researchers to train and analyze models for different skill levels. Additionally, providing tensor data directly in PyTorch format greatly simplifies the workflow from raw SGF files to neural network training.
+
+### Source Data
+
+#### Data Collection and Processing
+
+The data processing workflow:
+1. Using custom tool `gogames_organizer.py` to organize and quality-score original SGF files
+2. Filtering for high-quality games with scores ≥80
+3. Dividing games into three strength categories based on quality score
+4. Randomly sampling approximately 1,000 board positions from games in each strength category
+5. Converting each board position to a 3-channel tensor representation
+6. Converting corresponding next moves to one-dimensional indices in the range 0-360
+7. Using `go_dataset_builder.py` to package into PyTorch tensor format and split into train/validation/test sets
+
+The data processing used PyTorch, NumPy, and tqdm libraries. To prevent memory overflow, a chunked processing strategy was implemented. For each game, a maximum of 10 board positions were randomly sampled from the middle phase (skipping the first 30 and last 30 moves).
+
+#### Who are the source data producers?
+
+The source data consists of professional and high-level amateur Go game SGF records, primarily from players in China, Japan, Korea, and Western regions. Player levels range from high-level amateurs to world champion professional 9-dans. These game records document high-level Go matches from the 1950s to the present, reflecting Go styles and techniques from different periods and schools.
+
+### Personal and Sensitive Information
+
+The dataset only contains publicly available Go game data, including public information such as player names. It does not include any sensitive or private information. All data is derived from publicly published game records and belongs to the public knowledge domain.
+
+## Bias, Risks, and Limitations
+
+This dataset has the following biases, risks, and limitations:
+
+1. **Limited sample size**: Approximately 1,000 samples per strength category, which is relatively small for modern deep learning requirements.
+
+2. **Era bias**: SGF game records may include games from different eras, and changes in Go style after the emergence of modern AI may not be fully captured.
+
+3. **Data representation limitations**: Only includes current board state, not historical information or global context.
+
+4. **Classification subjectivity**: Strength classification is based on quality scoring, which has some subjectivity in its criteria.
+
+5. **Technical limitations**: Does not include game results or win probability information, not directly suitable for training value networks.
+
+### Recommendations
+
+When using this dataset, it is recommended to:
+
+1. View it as an entry-level or benchmark dataset, not as the sole data source for building a complete Go AI system.
+
+2. Combine it with other techniques such as self-play and reinforcement learning to compensate for limitations in dataset scale and representation.
+
+3. For research-grade models, consider expanding the training data to include more modern professional player games.
+
+4. Consider using time-series methods to enhance board state representation by adding historical information.
+
+5. Be aware that model performance is limited by dataset size and diversity, and interpret experimental results cautiously.
+
+## More Information
+
+This dataset uses a custom quality scoring system, with scoring factors including:
+- Player level (professional dan rank)
+- Tournament importance
+- Game era
+- Game record details (annotations available)
+
+The dataset processing tools support multi-process processing, but may require reduced parallelism in memory-constrained environments. For best training results, it is recommended to combine policy networks and value networks, and use Monte Carlo Tree Search for actual gameplay.
+
+## Dataset Card Authors
+
+This dataset card was created by 杨亦锋(Karesis) .
+
+## Dataset Card Contact
+
+For questions, please contact the dataset creator.