Introduction to the Deutschland Cup International
The Deutschland Cup International is an annual ice hockey tournament that draws top-tier teams from around the globe. This prestigious event not only showcases the best talents in ice hockey but also offers fans a thrilling experience with fresh matches updated daily. With expert betting predictions available, enthusiasts can engage in informed wagers, adding an extra layer of excitement to the games.
Hosted in Germany, the tournament features a blend of national and international teams, each vying for supremacy on the ice. The competition is fierce, and every match is a display of skill, strategy, and sportsmanship. Fans can follow live updates and expert analyses to stay informed about their favorite teams' performances.
Understanding the Format
The Deutschland Cup follows a round-robin format initially, where each team plays against all others in their group. This ensures that every team gets ample opportunity to showcase their skills on the ice. Following the group stages, top-performing teams advance to knockout rounds, culminating in a final showdown for the championship title.
- Group Stage: Teams are divided into groups based on their rankings and previous performances.
- Knockout Rounds: The top two teams from each group move on to this stage, where they compete in single-elimination matches.
- Finals: The ultimate test of skill and strategy, determining the champion of the tournament.
This format not only maintains high levels of excitement but also allows for strategic gameplay as teams aim to secure their place in the knockout rounds.
The Importance of Expert Betting Predictions
For many fans, betting adds an extra dimension to watching sports. Expert betting predictions provide insights based on comprehensive analysis of team performance, player statistics, and historical data. These predictions help bettors make informed decisions, enhancing their overall experience.
- Data Analysis: Experts analyze vast amounts of data to predict outcomes accurately.
- Trend Monitoring: Keeping track of current trends and team dynamics is crucial for making precise predictions.
- Expert Insights: Seasoned analysts provide valuable insights that go beyond mere statistics.
By leveraging these expert predictions, fans can engage more deeply with the tournament and enjoy a richer viewing experience.
Daily Match Updates
One of the highlights of following the Deutschland Cup is accessing daily match updates. These updates keep fans informed about scores, key moments, and standout performances as they happen. With real-time information at your fingertips, you never miss out on any action.
- Scores: Stay updated with live scores throughout each match.
- Moments: Catch highlights and pivotal moments that could turn the game around.
- Performances: Learn about individual player achievements and contributions.
Daily updates ensure that fans remain engaged with ongoing developments in the tournament.
Famous Teams and Players
<|repo_name|>nathanscroggins/mtg-drafting-simulator<|file_sep>/src/index.tsx
import React from 'react';
import ReactDOM from 'react-dom';
import './index.css';
import App from './App';
import * as serviceWorker from './serviceWorker';
ReactDOM.render(, document.getElementById('root'));
// If you want your app to work offline and load faster, you can change
// unregister() to register() below. Note this comes with some pitfalls.
// Learn more about service workers: https://bit.ly/CRA-PWA
serviceWorker.unregister();
const noop = () => {};
type DraftSimulatorState = {
simulations: number;
seed: number;
totalCards: number;
cardsPerPack: number;
packsPerDraft: number;
deckSize: number;
recommendedDeckSize?: number;
};
class DraftSimulator {
state: DraftSimulatorState;
constructor(state: Partial) {
this.state = {
simulations: state.simulations || Math.pow(10,6),
seed: state.seed || Date.now(),
totalCards: state.totalCards || Math.pow(10,5),
cardsPerPack: state.cardsPerPack || Math.pow(10 ,3),
packsPerDraft: state.packsPerDraft || Math.pow(10 ,1),
deckSize: state.deckSize || Math.pow(10 ,4)
};
}
updateState = (stateChangeCallback = noop) => {
const newState = Object.assign({}, this.state);
stateChangeCallback(newState);
Object.keys(newState).forEach(key => {
this.state[key] = newState[key];
});
return this.state;
}
runSimulation = (simulationCallback = noop) => {
const { simulations } = this.state;
let simulationResults = [];
for (let i=0; i
totalScore.map((score:number,i:number) => score + currentScore[i]), new Array(this.state.deckSize).fill(0));
}
runSimulationsAndCalculateAverageScoresForAllDecksInPoolOfTotalCards =
runSimulationsAndCalculateAverageScoresForAllDecksInPoolOfTotalCards.bind(
this.runSimulation,
this.calculateAverageScoresForAllDecksInPoolOfTotalCards.bind(this)
)
calculateAverageScoresForAllDecksInPoolOfTotalCards =
calculateAverageScoresForAllDecksInPoolOfTotalCards.bind(
this.generateRandomPacksFromPoolOfTotalCards.bind(this),
this.simulateDraft.bind(this)
)
generateRandomPacksFromPoolOfTotalCards =
generateRandomPacksFromPoolOfTotalCards.bind(
this.generateRandomCardPoolFromListOfCardRatings.bind(this),
this.createRandomOrderArray.bind(this)
)
createRandomOrderArray =
createRandomOrderArray.bind(
this.createShuffledArrayWithoutDuplicatingElements.bind(this)
)
createShuffledArrayWithoutDuplicatingElements =
createShuffledArrayWithoutDuplicatingElements.bind(
this.shuffleArrayUsingFisherYatesAlgorithm.bind(this)
)
shuffleArrayUsingFisherYatesAlgorithm =
shuffleArrayUsingFisherYatesAlgorithm
generateRandomCardPoolFromListOfCardRatings =
generateRandomCardPoolFromListOfCardRatings.bind(
this.generateArrayOfUniqueNumbersInRangeUpToMaxNumber.bind(this),
this.getRandomIntInRangeUpToMaxNumberWithSeedBasedOnIndexOrCurrentTimestamp.bind(this)
)
getRandomIntInRangeUpToMaxNumberWithSeedBasedOnIndexOrCurrentTimestamp =
getRandomIntInRangeUpToMaxNumberWithSeedBasedOnIndexOrCurrentTimestamp
simulateDraft =
simulateDraft
}
const shuffleArrayUsingFisherYatesAlgorithm = (array:any[]):any[] => {
let currentIndex:any[] | any;
for (let i=array.length-1; i>=0; i--) {
currentIndex = [i];
const randomIndex:number | undefined = getRandomIntBetweenZeroAndMax(array.length-1);
if (!randomIndex) return array;
array[currentIndex[0]] = array[randomIndex];
array[randomIndex] = currentIndex[0];
}
return array;
}
const createShuffledArrayWithoutDuplicatingElements = (
arrayCreatorFunction:(...args:any[])=>any[],
args:any[]
):any[] => {
const shuffledArray:any[] | any[] | null | undefined =
shuffleArrayUsingFisherYatesAlgorithm(arrayCreatorFunction(...args));
if (!shuffledArray) return [];
return shuffledArray.filter((element,index,array)=>array.indexOf(element)===index);
}
const createRandomOrderArray =(maxNumber:number):number[] =>
createShuffledArrayWithoutDuplicatingElements(generateArrayOfUniqueNumbersInRangeUpToMaxNumber,maxNumber);
const generateArrayOfUniqueNumbersInRangeUpToMaxNumber =(maxNumber:number):number[] =>
Array.from(Array(maxNumber).keys());
const getRandomIntBetweenZeroAndMax =(max:number):number | undefined =>
getRandomIntInRangeUpToMaxNumberWithSeedBasedOnIndexOrCurrentTimestamp(max,this.state.seed);
const getRandomIntInRangeUpToMaxNumberWithSeedBasedOnIndexOrCurrentTimestamp =(max:number,index?:number):number | undefined => {
const seedValue:string | number |
index ? `draft-simulator-seed-${this.state.seed}-${index}` :
Date.now();
return Math.floor(Math.random()*Math.floor(max)) + seedValue;
}
const simulateDraft =(packs:Array):number[] => {
const { deckSize } = this.state;
let draftDeck:Array;
draftDeck= packs.reduce((draftDeckAccumulator,numberSet)=>{
draftDeckAccumulator.push(...numberSet);
return draftDeckAccumulator;
},new Array());
draftDeck.sort((a,b)=>b-a);
if (draftDeck.length > deckSize){
draftDeck.splice(deckSize,draftDeck.length-deckSize);
}
return draftDeck.slice(0,this.state.recommendedDeckSize||deckSize);
}
const generateRandomPacksFromPoolOfTotalCards =(cardRatings:Array):number[][]=>{
const { cardsPerPack,packsPerDraft }=this.state;
let packs:Array=[];
for(let pack=0; pack=createRandomOrderArray(cardRatings.length);
let packToAddToArray:Array=[];
for(let card=0; card,simulationResults:Array
){
let averageScoresForAllDecksInPoolOfTotalCards:Array;
let totalNumberOfPossibleUniqueDecks:Number=
cardRatings.length**this.state.cardsPerPack*this.state.packsPerDraft;
if(!simulationResults || simulationResults.length !==totalNumberOfPossibleUniqueDecks){
throw new Error("Simulation results should be an array whose length equals total possible unique decks");
return null;
}
averageScoresForAllDecksInPoolOfTotalCards=
simulationResults.reduce((averageScoreAccumulator,currentSimulationResult,index)=>{
averageScoreAccumulator[index]=currentSimulationResult/this.state.simulations;
return averageScoreAccumulator;
},new Array(cardRatings.length**this.state.cardsPerPack*this.state.packsPerDraft).fill(0));
return averageScoresForAllDecksInPoolOfTotalCards.slice(0,this.state.recommendedDeckSize||cardRatings.length**this.state.cardsPerPack*this.state.packsPerDraft);
}
function main(){
let draftSimulator=new DraftSimulator({});
let listOfCardRatings=new Array(draftSimulator.updateState().totalCards).fill(1).map(()=>Math.floor(Math.random()*100));
console.log("Calculating average scores for all decks...");
let averageScores=draftSimulator.runSimulationsAndCalculateAverageScoresForAllDecksInPoolOfTotalCards(listOfCardRatings);
console.log("Done!");
console.log("Finding highest scoring deck...");
let indexOfHighestScoringDeck=averageScores.indexOf(Math.max(...averageScores));
console.log(`Highest scoring deck has index ${indexOfHighestScoringDeck} with score ${averageScores[indexOfHighestScoringDeck]}`);
console.log("Finding lowest scoring deck...");
let indexOfLowestScoringDeck=averageScores.indexOf(Math.min(...averageScores));
console.log(`Lowest scoring deck has index ${indexOfLowestScoringDeck} with score ${averageScores[indexOfLowestScoringDeck]}`);
console.log("Finding median scoring deck...");
let indexOfMedianScoringDeck=Math.floor(averageScores.length/2);
console.log(`Median scoring deck has index ${indexOfMedianScoringDeck} with score ${averageScores[indexOfMedianScoringDeck]}`);
}
main();
<|repo_name|>nathanscroggins/mtg-drafting-simulator<|file_sep|RFID Tag Reader
==================
An RFID tag reader which reads RFID tags using an ESP32 microcontroller.
The RFID tag reader consists of two components:
* An Arduino sketch which runs on an ESP32 microcontroller connected via USB or Wi-Fi.
* A web application which communicates over WebSockets.
## Hardware Setup
### ESP32 Microcontroller Setup
The ESP32 microcontroller needs to be set up using an Arduino IDE.
### RFID Module Setup
The RFID module needs to be set up by connecting it's TX pin to RX pin on ESP32 microcontroller.
## Software Setup
### Arduino Sketch Setup
The Arduino sketch needs to be loaded onto ESP32 microcontroller using Arduino IDE.
### Web Application Setup
The web application needs to be run using Node.js.
## Usage
Once everything is set up correctly:
* Connect ESP32 microcontroller via USB or Wi-Fi.
* Run web application using Node.js.
* Open web application in browser.
* Scan RFID tags using RFID module connected to ESP32 microcontroller.<|repo_name|>nathanscroggins/mtg-drafting-simulator<|file_sep>> # MTG Draft Simulator
This project uses TypeScript React components along with d3js visualizations.
# Installation instructions
Clone repo:
git clone [email protected]:nathanscroggins/mtg-drafting-simulator.git mtg-draft-simulator
cd mtg-draft-simulator/
Install dependencies:
npm install
Start development server:
npm start
# How it works:
This simulator takes a list of cards ranked by power level (eg [20 most powerful cards],[19th most powerful cards], etc.) It then generates all possible drafts from those cards given parameters such as how many cards per pack there are or how many packs per draft there are or how large a deck size is allowed etc.
It then simulates multiple drafts by randomly selecting one possible draft per simulation until it reaches user specified amount of simulations.
Finally it calculates average score for each possible deck size given parameters such as total amount of cards allowed in pool or how many simulations were performed etc.
# Features:
- Simulate multiple drafts at once based on user input parameters such as total amount of cards allowed in pool or how many simulations were performed etc.
- Calculate average score for each possible deck size given parameters such as total amount of cards allowed in pool or how many simulations were performed etc.
# Examples:
Here are some examples showing what kind results you might expect when running this simulator:
## Example #1 - Simulating drafts with different amounts of cards per pack:
As we can see from this example above when we increase amount cards per pack we get higher average scores across all possible decks sizes because there are more combinations available which result into higher quality decks being generated during simulation process.
## Example #2 - Simulating drafts with different amounts packs per draft:
As we can see from this example above when we increase amount packs per draft we get lower average scores across all possible decks sizes because there are less combinations available which result into lower quality decks being generated during simulation process.
# Conclusion:
This simulator provides useful insight into what kind results you might expect when simulating drafts based on user input parameters such as total amount cards allowed in pool or how many simulations were performed etc.
# Future Work:
Some ideas for future work include adding support for other types input formats such as JSON files containing list ranked by power level instead just text files containing list ranked by power level etc.<|file_sepjavascript
var express=require('express');
var http=require('http');
var path=require('path');
var socketio=require('socket.io');
var app=express();
app.use(express.static(path.join(__dirname,'public')));
var server=http.createServer(app);
server.listen(process.env.PORT||3000);
console.log('Server listening at port '+server.address().port);
var io=socketio(server);
io.on('connection',function(socket){
socket.on('tag-scanned',function(tag){
socket.emit('tag-scanned',tag);
io.emit('tag-scanned',tag);
});
});
<|repo_name|>HJZhang/PyTorch-Deep-Learning-Cookbook<|file_sep|RFID Tag Reader API Reference Manual
=======================================
.. automodule:: rfid_reader.rfid_reader
.. autoclass:: rfid_reader.rfid_reader.RFIDReader
RFID Reader Class Reference
---------------------------
.. autoclass:: rfid_reader.rfid_reader.RFIDReader
RFID Reader API Methods
^^^^^^^^^^^^^^^^^^^^^^^
.. automethod:: rfid_reader.rfid_reader.RFIDReader.__init__
.. automethod:: rfid_reader.rfid_reader.RFIDReader.read_tag_id
.. automethod:: rfid_reader.rfid_reader.RFIDReader.read_tag_id_loop
RFID Reader API Exceptions
--------------------------
.. autoexception:: rfid_reader.rfid_exceptions.NoTagException
.. autoexception:: rfid_reader.rfid_exceptions.ReaderException
RFID Constants Reference
------------------------
rfid_constants.py file defines constants used within ``rfid-reader`` library.
They are documented here.
.. autodata:: rfid_constants.TAG_READ_TIMEOUT_SEC
.. autodata:: rfid_constants.TAG_READ_MAX_RETRY_COUNT
.. autodata:: rfid_constants.READER_SLEEP_TIME_SEC_BETWEEN_RETRIES
RFID Exceptions Reference
-------------------------
rfid_exceptions.py file defines exceptions used within ``rfid-reader`` library.
They are documented here.
NoTagException Exception Class Reference
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
NoTagException exception class indicates no tag was detected within specified timeout.
NoTagException inherits ``IOError`` exception class.
NoTagException inherits ``ReaderException`` exception class.
.. autoclass:: rfid_exceptions.NoTagException
ReaderException Exception Class Reference
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
ReaderException exception class indicates general error occurred while communicating
with reader hardware.
ReaderException inherits ``IOError`` exception class.
.. autoclass:: rfid_exceptions.ReaderException
RFID Reader Configuration File Reference
---------------------------------------
rfid_config.py file defines configuration variables used within ``rfid-reader`` library.
They are documented here.
Default serial port name variable:
.. autodata:: config.DEFAULT_SERIAL_PORT_NAME
Python Script Examples Using RFID Reader Library:
--------------------------------------------------
Simple Python Script Example Using RFID Reader Library:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Below example shows simple python script using ``read_tag_id_loop()`` method
of ``rfid-reader`` library:
>>> import timeit
>>> import sys
>>> import os.path
>>> sys.path.append(os.path.abspath(os.path.dirname(__file__)) + "/../lib")
>>> import config
>>> import reader
>>> if __name__ == "__main__":
... try:
... reader_obj = reader.RFIDReader(serial_port=config.DEFAULT_SERIAL_PORT_NAME)
... print "Waiting for tag ..."
... while True:
... tag_id_str_hexadecimal_lower_case =
... reader_obj.read_tag_id_loop()
... print "Detected tag ID string (%s)" % tag_id_str_hexadecimal_lower_case
... time.sleep(reader.TAG_READ_SLEEP_TIME_SEC_BETWEEN_RETRIES)
... except IOError:
... print "IOError occurred."
Output:
$ python simple_read_tag_id_loop_example.py
Waiting for tag ...
Detected tag ID string (aabbccddeeff00112233445566778899)
Detected tag ID string (aabbccddeeff00112233445566778899)
Detected tag ID string (aabbccddeeff00112233445566778899)
Note that even though read operation may succeed multiple times without
raising any exceptions,
if read operation fails due timeout after maximum retry count,
then NoTagException exception will be raised.
Thus it is necessary check whether read operation succeeded before printing out detected
tag ID string value:
>>> import timeit
>>> import sys
>>> import os.path
>>> sys.path.append(os.path.abspath(os.path.dirname(__file__)) + "/../lib")
>>> import config
>>> import reader
>>> if __name__ == "__main__":
... try:
... reader_obj = reader.RFIDReader(serial_port=config.DEFAULT_SERIAL_PORT_NAME)
... print "Waiting for tag ..."
... while True:
try:
tag_id_str_hexadecimal_lower_case =
reader_obj.read_tag_id()
print "Detected tag ID string (%s)" %
str(tag_id_str_hexadecimal_lower_case)
except reader.NoTagException:
print "No Tag Detected."
time.sleep(reader.TAG_READ_SLEEP_TIME_SEC_BETWEEN_RETRIES)
except IOError:
print "IOError occurred."
Output:
$ python simple_read_tag_id_example.py
Waiting for tag ...
No Tag Detected.
No Tag Detected.
Detected tag ID string ('AABBCCDDEEFF00112233445566778899')
No Tag Detected.
No Tag Detected.
Detected tag ID string ('AABBCCDDEEFF00112233445566778899')
Advanced Python Script Example Using RFID Reader Library:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Below example shows advanced python script using ``read_tag_id()`` method
of ``rfid-reader`` library:
Note that even though read operation may succeed multiple times without raising any exceptions,
if read operation fails due timeout after maximum retry count,
then NoTagException exception will be raised.
Thus it is necessary check whether read operation succeeded before printing out detected
tag ID string value:
Import required libraries:
>>>
import timeit
import sys
import os.path
sys.path.append(os.path.abspath(os.path.dirname(__file__)) + "/../lib")
import config
import logging
logging.basicConfig(level=logging.DEBUG)
from datetime import datetime
from functools import wraps
def log_timing(func):
def wrapper(*args,**kwargs):
start_time=datetime.now()
func(*args,**kwargs)
end_time=datetime.now()
print "%r function took %f seconds" %
(func.__name__,end_time-start_time)
return func(*args,**kwargs)
import re
import traceback
import serial
import pexpect
import exceptions
import pytz
from pytz.exceptions import AmbiguousTimeError
from pytz.exceptions import NonExistentTimeError
from pytz.exceptions import InvalidTimezoneArgument
class InvalidSerialPortName(exceptions.Exception):
def __init__(self,msg=None):
self.msg=msg
def __str__(self):
return self.msg
def log_error_and_raise_exception(func):
def wrapper(*args,**kwargs):
try:
func(*args,**kwargs)
except Exception,e:
print e.message,"n",traceback.format_exc()
raise e
return wrapper(*args,**kwargs)
Define helper functions used within script below:
>>>
def validate_serial_port_name(serial_port_name):
if serial_port_name.find('/') >=0 :
raise InvalidSerialPortName(msg="Invalid Serial Port Name.")
else :
try :
serial.Serial(serial_port_name)
except serial.SerialException,e :
raise InvalidSerialPortName(msg="Invalid Serial Port Name.")
def log_and_print_detected_tag(tag_data_str):
print "nn"
print "-" *80,"n"
print "t",datetime.now(pytz.timezone(config.TIMEZONE)).strftime("%I:%M:%S%p %Z"),"n"
print "-" *80,"n"
logging.debug("tt%sn"%repr(tag_data_str))
return str(tag_data_str)
Define main function below which uses functions defined above along with
functions provided by imported libraries including ones provided by
rfid-reader library itself :
>>>
@log_timing @log_error_and_raise_exception @validate_serial_port_name @log_and_print_detected_tag
def main():
reader_obj=reader.RFIDReader(serial_port=config.DEFAULT_SERIAL_PORT_NAME)
while True :
try :
reader_obj.read_tag_id()
except reader.NoTagException,e :
print e.message,"n",traceback.format_exc()
time.sleep(reader.TAG_READ_SLEEP_TIME_SEC_BETWEEN_RETRIES)
except IOError,e :
print e.message,"n",traceback.format_exc()
if __name__ == "__main__" :
main()
Output sample shown below assuming script was run successfully without errors occurring during execution:
$ python advanced_read_tag_example.py
advanced_read_tag_example.py function took .002000 seconds
------------------------------------------------------------------------
Tue Oct3103PM EDT
------------------------------------------------------------------------
Tue Oct31PM EDT22:30AM EDT2016 No Tag Detected.
Traceback (most recent call last):
File "./advanced_read_tag_example.py", line XXXX,in main NoTagTimeoutError : Timeout occured after maximum retry count exceeded.,Traceback (most recent call last):
File "./advanced_read_tag_example.py", line XXXX,in read_retry_count_exceeded Maximum retry count exceeded.,Traceback (most recent call last):
File "./advanced_read_tag_example.py", line XXXX,in _read_retry_count_exceeded Maximum retry count exceeded.,Traceback (most recent call last):
File "./advanced_read_tag_example.py", line XXXX,in _read_retry_count_exceeded Maximum retry count exceeded.,Traceback (most recent call last):
File "./advanced_read_tag_example.py", line XXXX,in _read_retry_count_exceeded Maximum retry count exceeded.,Traceback (most recent call last):
File "./advanced_read_tag_example.py", line XXXX,in _read_retry_count_exceeded Maximum retry count exceeded.,Traceback (most recent call last):
File "./advanced_read_tag_example.py", line XXXX,in _read_retry_count_exceeded Maximum retry count exceeded.,Traceback (most recent call last):
File "./advanced_read_tag_example.py", line XXXX,_get_response_from_device raise IOError(e),IOError(: Operation timed out),
------------------------------------------------------------------------
Tue Oct31PM EDT
------------------------------------------------------------------------
Tue Oct31PM EDT22:30AM EDT2016 Detected Tag Data String ([u'A',u'A',u'B',u'B',u'C',u'C',u'D',u'D',u'E',u'E',u'F',u'F', u'0', u'0' , u'1', u'1' , u'2' , u'2' , u'3' , u'3' , u'4'
5','4','5','6','6','7','7','8','8','9','9'])
Note that following message appears indicating no tags detected yet followed by another message indicating detected tags data shown above successfully printed out after some delay assuming no errors occur during execution :
$ python advanced_read_tag_example.py
advanced_read_tag_example.py function took .002000 seconds
------------------------------------------------------------------------
Tue Oct31PM EDT
------------------------------------------------------------------------
Tue Oct31PM EDT22:30AM EDT2016 No Tag Detected.
Timeout occured after maximum retry count exceeded.
Maximum retry count exceeded.
Maximum retry count exceeded.
Maximum retry count exceeded.
Maximum retry count exceeded.
Maximum retry count exceeded.
Operation timed out
------------------------------------------------------------------------
Tue Oct31PM EDT
------------------------------------------------------------------------
Tue Oct31PM EDT22:30AM EDT2016 Detected Tag Data String ([u'A',
u'A',
u'B',
u'B',
u'C',
u'C',
u'D',
u'D',
u'E',
u'E',
u'F',
u'F',
u'0',
u'0'
, u'1',
u'1'
, u'2'
, u'2'
, u'3'
, u'3'
, u'4'
5','4','5','6','6','7','7','8','8','9','9'])
<|repo_name|>HJZhang/PyTorch-Deep-Learning-Cookbook<|file_sep
