From 747ef1be37dde8869bf929fe782eb57bf4159b90 Mon Sep 17 00:00:00 2001 From: Armaan Bhojwani Date: Sat, 19 Aug 2023 16:25:51 -0400 Subject: [PATCH 1/1] Initial commit --- .gitignore | 161 +++ .gitmodules | 3 + Data/countries.txt | 196 +++ Data/names.txt | 2000 ++++++++++++++++++++++++++++ External/differential-privacy | 1 + Incomplete/renyi.ipynb | 194 +++ Incomplete/zero_concentrated.ipynb | 107 ++ LICENSE | 19 + README | 82 ++ bayesian_attacker.ipynb | 145 ++ common.py | 52 + exponential_mechanism.ipynb | 285 ++++ gaussian_mechanism.ipynb | 532 ++++++++ laplace_example_class_height.ipynb | 586 ++++++++ laplace_mechanism.ipynb | 450 +++++++ requirements.txt | 6 + 16 files changed, 4819 insertions(+) create mode 100644 .gitignore create mode 100644 .gitmodules create mode 100644 Data/countries.txt create mode 100644 Data/names.txt create mode 160000 External/differential-privacy create mode 100644 Incomplete/renyi.ipynb create mode 100644 Incomplete/zero_concentrated.ipynb create mode 100644 LICENSE create mode 100644 README create mode 100644 bayesian_attacker.ipynb create mode 100644 common.py create mode 100644 exponential_mechanism.ipynb create mode 100644 gaussian_mechanism.ipynb create mode 100644 laplace_example_class_height.ipynb create mode 100644 laplace_mechanism.ipynb create mode 100644 requirements.txt diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b1cb160 --- /dev/null +++ b/.gitignore @@ -0,0 +1,161 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..214eb18 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "External/differential-privacy"] + path = External/differential-privacy + url = https://github.com/google/differential-privacy diff --git a/Data/countries.txt b/Data/countries.txt new file mode 100644 index 0000000..83c9940 --- /dev/null +++ b/Data/countries.txt @@ -0,0 +1,196 @@ +Afghanistan +Albania +Algeria +Andorra +Angola +Antigua_and_Barbuda +Argentina +Armenia +Australia +Austria +Azerbaijan +The_Bahamas +Bahrain +Bangladesh +Barbados +Belarus +Belgium +Belize +Benin +Bhutan +Bolivia +Bosnia_and_Herzegovina +Botswana +Brazil +Brunei +Bulgaria +Burkina_Faso +Burundi +Cambodia +Cameroon +Canada +Cape_Verde +Central_African_Republic +Chad +Chile +China +Colombia +Comoros +Congo,_Republic_of_the +Congo,_Democratic_Republic_of_the +Costa_Rica +Cote_d'Ivoire +Croatia +Cuba +Cyprus +Czech_Republic +Denmark +Djibouti +Dominica +Dominican_Republic +East_Timor_(Timor-Leste) +Ecuador +Egypt +El_Salvador +Equatorial_Guinea +Eritrea +Estonia +Ethiopia +Fiji +Finland +France +Gabon +The_Gambia +Georgia +Germany +Ghana +Greece +Grenada +Guatemala +Guinea +Guinea-Bissau +Guyana +Haiti +Honduras +Hungary +Iceland +India +Indonesia +Iran +Iraq +Ireland +Israel +Italy +Jamaica +Japan +Jordan +Kazakhstan +Kenya +Kiribati +Korea,_North +Korea,_South +Kosovo +Kuwait +Kyrgyzstan +Laos +Latvia +Lebanon +Lesotho +Liberia +Libya +Liechtenstein +Lithuania +Luxembourg +Macedonia +Madagascar +Malawi +Malaysia +Maldives +Mali +Malta +Marshall_Islands +Mauritania +Mauritius +Mexico +Micronesia,_Federated_States_of +Moldova +Monaco +Mongolia +Montenegro +Morocco +Mozambique +Myanmar_(Burma) +Namibia +Nauru +Nepal +Netherlands +New_Zealand +Nicaragua +Niger +Nigeria +Norway +Oman +Pakistan +Palau +Panama +Papua_New_Guinea +Paraguay +Peru +Philippines +Poland +Portugal +Qatar +Romania +Russia +Rwanda +Saint_Kitts_and_Nevis +Saint_Lucia +Saint_Vincent_and_the_Grenadines +Samoa +San_Marino +Sao_Tome_and_Principe +Saudi_Arabia +Senegal +Serbia +Seychelles +Sierra_Leone +Singapore +Slovakia +Slovenia +Solomon_Islands +Somalia +South_Africa +South_Sudan +Spain +Sri_Lanka +Sudan +Suriname +Swaziland +Sweden +Switzerland +Syria +Taiwan +Tajikistan +Tanzania +Thailand +Togo +Tonga +Trinidad_and_Tobago +Tunisia +Turkey +Turkmenistan +Tuvalu +Uganda +Ukraine +United_Arab_Emirates +United_Kingdom +United_States_of_America +Uruguay +Uzbekistan +Vanuatu +Vatican_City_(Holy_See) +Venezuela +Vietnam +Yemen +Zambia +Zimbabwe diff --git a/Data/names.txt b/Data/names.txt new file mode 100644 index 0000000..11b0c79 --- /dev/null +++ b/Data/names.txt @@ -0,0 +1,2000 @@ +James +John +Robert +Michael +William +David +Richard +Charles +Joseph +Thomas +Christopher +Daniel +Paul +Mark +Donald +George +Kenneth +Steven +Edward +Brian +Ronald +Anthony +Kevin +Jason +Matthew +Gary +Timothy +Jose +Larry +Jeffrey +Frank +Scott +Eric +Stephen +Andrew +Raymond +Gregory +Joshua +Jerry +Dennis +Walter +Patrick +Peter +Harold +Douglas +Henry +Carl +Arthur +Ryan +Roger +Joe +Juan +Jack +Albert +Jonathan +Justin +Terry +Gerald +Keith +Samuel +Willie +Ralph +Lawrence +Nicholas +Roy +Benjamin +Bruce +Brandon +Adam +Harry +Fred +Wayne +Billy +Steve +Louis +Jeremy +Aaron +Randy +Howard +Eugene +Carlos +Russell +Bobby +Victor +Martin +Ernest +Phillip +Todd +Jesse +Craig +Alan +Shawn +Clarence +Sean +Philip +Chris +Johnny +Earl +Jimmy +Antonio +Danny +Bryan +Tony +Luis +Mike +Stanley +Leonard +Nathan +Dale +Manuel +Rodney +Curtis +Norman +Allen +Marvin +Vincent +Glenn +Jeffery +Travis +Jeff +Chad +Jacob +Lee +Melvin +Alfred +Kyle +Francis +Bradley +Jesus +Herbert +Frederick +Ray +Joel +Edwin +Don +Eddie +Ricky +Troy +Randall +Barry +Alexander +Bernard +Mario +Leroy +Francisco +Marcus +Micheal +Theodore +Clifford +Miguel +Oscar +Jay +Jim +Tom +Calvin +Alex +Jon +Ronnie +Bill +Lloyd +Tommy +Leon +Derek +Warren +Darrell +Jerome +Floyd +Leo +Alvin +Tim +Wesley +Gordon +Dean +Greg +Jorge +Dustin +Pedro +Derrick +Dan +Lewis +Zachary +Corey +Herman +Maurice +Vernon +Roberto +Clyde +Glen +Hector +Shane +Ricardo +Sam +Rick +Lester +Brent +Ramon +Charlie +Tyler +Gilbert +Gene +Marc +Reginald +Ruben +Brett +Angel +Nathaniel +Rafael +Leslie +Edgar +Milton +Raul +Ben +Chester +Cecil +Duane +Franklin +Andre +Elmer +Brad +Gabriel +Ron +Mitchell +Roland +Arnold +Harvey +Jared +Adrian +Karl +Cory +Claude +Erik +Darryl +Jamie +Neil +Jessie +Christian +Javier +Fernando +Clinton +Ted +Mathew +Tyrone +Darren +Lonnie +Lance +Cody +Julio +Kelly +Kurt +Allan +Nelson +Guy +Clayton +Hugh +Max +Dwayne +Dwight +Armando +Felix +Jimmie +Everett +Jordan +Ian +Wallace +Ken +Bob +Jaime +Casey +Alfredo +Alberto +Dave +Ivan +Johnnie +Sidney +Byron +Julian +Isaac +Morris +Clifton +Willard +Daryl +Ross +Virgil +Andy +Marshall +Salvador +Perry +Kirk +Sergio +Marion +Tracy +Seth +Kent +Terrance +Rene +Eduardo +Terrence +Enrique +Freddie +Wade +Austin +Stuart +Fredrick +Arturo +Alejandro +Jackie +Joey +Nick +Luther +Wendell +Jeremiah +Evan +Julius +Dana +Donnie +Otis +Shannon +Trevor +Oliver +Luke +Homer +Gerard +Doug +Kenny +Hubert +Angelo +Shaun +Lyle +Matt +Lynn +Alfonso +Orlando +Rex +Carlton +Ernesto +Cameron +Neal +Pablo +Lorenzo +Omar +Wilbur +Blake +Grant +Horace +Roderick +Kerry +Abraham +Willis +Rickey +Jean +Ira +Andres +Cesar +Johnathan +Malcolm +Rudolph +Damon +Kelvin +Rudy +Preston +Alton +Archie +Marco +Wm +Pete +Randolph +Garry +Geoffrey +Jonathon +Felipe +Bennie +Gerardo +Ed +Dominic +Robin +Loren +Delbert +Colin +Guillermo +Earnest +Lucas +Benny +Noel +Spencer +Rodolfo +Myron +Edmund +Garrett +Salvatore +Cedric +Lowell +Gregg +Sherman +Wilson +Devin +Sylvester +Kim +Roosevelt +Israel +Jermaine +Forrest +Wilbert +Leland +Simon +Guadalupe +Clark +Irving +Carroll +Bryant +Owen +Rufus +Woodrow +Sammy +Kristopher +Mack +Levi +Marcos +Gustavo +Jake +Lionel +Marty +Taylor +Ellis +Dallas +Gilberto +Clint +Nicolas +Laurence +Ismael +Orville +Drew +Jody +Ervin +Dewey +Al +Wilfred +Josh +Hugo +Ignacio +Caleb +Tomas +Sheldon +Erick +Frankie +Stewart +Doyle +Darrel +Rogelio +Terence +Santiago +Alonzo +Elias +Bert +Elbert +Ramiro +Conrad +Pat +Noah +Grady +Phil +Cornelius +Lamar +Rolando +Clay +Percy +Dexter +Bradford +Merle +Darin +Amos +Terrell +Moses +Irvin +Saul +Roman +Darnell +Randal +Tommie +Timmy +Darrin +Winston +Brendan +Toby +Van +Abel +Dominick +Boyd +Courtney +Jan +Emilio +Elijah +Cary +Domingo +Santos +Aubrey +Emmett +Marlon +Emanuel +Jerald +Edmond +Emil +Dewayne +Will +Otto +Teddy +Reynaldo +Bret +Morgan +Jess +Trent +Humberto +Emmanuel +Stephan +Louie +Vicente +Lamont +Stacy +Garland +Miles +Micah +Efrain +Billie +Logan +Heath +Rodger +Harley +Demetrius +Ethan +Eldon +Rocky +Pierre +Junior +Freddy +Eli +Bryce +Antoine +Robbie +Kendall +Royce +Sterling +Mickey +Chase +Grover +Elton +Cleveland +Dylan +Chuck +Damian +Reuben +Stan +August +Leonardo +Jasper +Russel +Erwin +Benito +Hans +Monte +Blaine +Ernie +Curt +Quentin +Agustin +Murray +Jamal +Devon +Adolfo +Harrison +Tyson +Burton +Brady +Elliott +Wilfredo +Bart +Jarrod +Vance +Denis +Damien +Joaquin +Harlan +Desmond +Elliot +Darwin +Ashley +Gregorio +Buddy +Xavier +Kermit +Roscoe +Esteban +Anton +Solomon +Scotty +Norbert +Elvin +Williams +Nolan +Carey +Rod +Quinton +Hal +Brain +Rob +Elwood +Kendrick +Darius +Moises +Son +Marlin +Fidel +Thaddeus +Cliff +Marcel +Ali +Jackson +Raphael +Bryon +Armand +Alvaro +Jeffry +Dane +Joesph +Thurman +Ned +Sammie +Rusty +Michel +Monty +Rory +Fabian +Reggie +Mason +Graham +Kris +Isaiah +Vaughn +Gus +Avery +Loyd +Diego +Alexis +Adolph +Norris +Millard +Rocco +Gonzalo +Derick +Rodrigo +Gerry +Stacey +Carmen +Wiley +Rigoberto +Alphonso +Ty +Shelby +Rickie +Noe +Vern +Bobbie +Reed +Jefferson +Elvis +Bernardo +Mauricio +Hiram +Donovan +Basil +Riley +Ollie +Nickolas +Maynard +Scot +Vince +Quincy +Eddy +Sebastian +Federico +Ulysses +Heriberto +Donnell +Cole +Denny +Davis +Gavin +Emery +Ward +Romeo +Jayson +Dion +Dante +Clement +Coy +Odell +Maxwell +Jarvis +Bruno +Issac +Mary +Dudley +Brock +Sanford +Colby +Carmelo +Barney +Nestor +Hollis +Stefan +Donny +Art +Linwood +Beau +Weldon +Galen +Isidro +Truman +Delmar +Johnathon +Silas +Frederic +Dick +Kirby +Irwin +Cruz +Merlin +Merrill +Charley +Marcelino +Lane +Harris +Cleo +Carlo +Trenton +Kurtis +Hunter +Aurelio +Winfred +Vito +Collin +Denver +Carter +Leonel +Emory +Pasquale +Mohammad +Mariano +Danial +Blair +Landon +Dirk +Branden +Adan +Numbers +Clair +Buford +German +Bernie +Wilmer +Joan +Emerson +Zachery +Fletcher +Jacques +Errol +Dalton +Monroe +Josue +Dominique +Edwardo +Booker +Wilford +Sonny +Shelton +Carson +Theron +Raymundo +Daren +Tristan +Houston +Robby +Lincoln +Jame +Genaro +Gale +Bennett +Octavio +Cornell +Laverne +Hung +Arron +Antony +Herschel +Alva +Giovanni +Garth +Cyrus +Cyril +Ronny +Stevie +Lon +Freeman +Erin +Duncan +Kennith +Carmine +Augustine +Young +Erich +Chadwick +Wilburn +Russ +Reid +Myles +Anderson +Morton +Jonas +Forest +Mitchel +Mervin +Zane +Rich +Jamel +Lazaro +Alphonse +Randell +Major +Johnie +Jarrett +Brooks +Ariel +Abdul +Dusty +Luciano +Lindsey +Tracey +Seymour +Scottie +Eugenio +Mohammed +Sandy +Valentin +Chance +Arnulfo +Lucien +Ferdinand +Thad +Ezra +Sydney +Aldo +Rubin +Royal +Mitch +Earle +Abe +Wyatt +Marquis +Lanny +Kareem +Jamar +Boris +Isiah +Emile +Elmo +Aron +Leopoldo +Everette +Josef +Gail +Eloy +Dorian +Rodrick +Reinaldo +Lucio +Jerrod +Weston +Hershel +Barton +Parker +Lemuel +Lavern +Burt +Jules +Gil +Eliseo +Ahmad +Nigel +Efren +Antwan +Alden +Margarito +Coleman +Refugio +Dino +Osvaldo +Les +Deandre +Normand +Kieth +Ivory +Andrea +Trey +Norberto +Napoleon +Jerold +Fritz +Rosendo +Milford +Sang +Deon +Christoper +Alfonzo +Lyman +Josiah +Brant +Wilton +Rico +Jamaal +Dewitt +Carol +Brenton +Yong +Olin +Foster +Faustino +Claudio +Judson +Gino +Edgardo +Berry +Alec +Tanner +Jarred +Donn +Trinidad +Tad +Shirley +Prince +Porfirio +Odis +Maria +Lenard +Chauncey +Chang +Tod +Mel +Marcelo +Kory +Augustus +Keven +Hilario +Bud +Sal +Rosario +Orval +Mauro +Dannie +Zachariah +Olen +Anibal +Milo +Jed +Frances +Thanh +Dillon +Amado +Newton +Connie +Lenny +Tory +Richie +Lupe +Horacio +Brice +Mohamed +Delmer +Dario +Reyes +Dee +Mac +Jonah +Jerrold +Robt +Hank +Sung +Rupert +Rolland +Kenton +Damion +Chi +Antone +Waldo +Fredric +Bradly +Quinn +Kip +Burl +Walker +Tyree +Jefferey +Ahmed +Mary +Patricia +Linda +Barbara +Elizabeth +Jennifer +Maria +Susan +Margaret +Dorothy +Lisa +Nancy +Karen +Betty +Helen +Sandra +Donna +Carol +Ruth +Sharon +Michelle +Laura +Sarah +Kimberly +Deborah +Jessica +Shirley +Cynthia +Angela +Melissa +Brenda +Amy +Anna +Rebecca +Virginia +Kathleen +Pamela +Martha +Debra +Amanda +Stephanie +Carolyn +Christine +Marie +Janet +Catherine +Frances +Ann +Joyce +Diane +Alice +Julie +Heather +Teresa +Doris +Gloria +Evelyn +Jean +Cheryl +Mildred +Katherine +Joan +Ashley +Judith +Rose +Janice +Kelly +Nicole +Judy +Christina +Kathy +Theresa +Beverly +Denise +Tammy +Irene +Jane +Lori +Rachel +Marilyn +Andrea +Kathryn +Louise +Sara +Anne +Jacqueline +Wanda +Bonnie +Julia +Ruby +Lois +Tina +Phyllis +Norma +Paula +Diana +Annie +Lillian +Emily +Robin +Peggy +Crystal +Gladys +Rita +Dawn +Connie +Florence +Tracy +Edna +Tiffany +Carmen +Rosa +Cindy +Grace +Wendy +Victoria +Edith +Kim +Sherry +Sylvia +Josephine +Thelma +Shannon +Sheila +Ethel +Ellen +Elaine +Marjorie +Carrie +Charlotte +Monica +Esther +Pauline +Emma +Juanita +Anita +Rhonda +Hazel +Amber +Eva +Debbie +April +Leslie +Clara +Lucille +Jamie +Joanne +Eleanor +Valerie +Danielle +Megan +Alicia +Suzanne +Michele +Gail +Bertha +Darlene +Veronica +Jill +Erin +Geraldine +Lauren +Cathy +Joann +Lorraine +Lynn +Sally +Regina +Erica +Beatrice +Dolores +Bernice +Audrey +Yvonne +Annette +June +Samantha +Marion +Dana +Stacy +Ana +Renee +Ida +Vivian +Roberta +Holly +Brittany +Melanie +Loretta +Yolanda +Jeanette +Laurie +Katie +Kristen +Vanessa +Alma +Sue +Elsie +Beth +Jeanne +Vicki +Carla +Tara +Rosemary +Eileen +Terri +Gertrude +Lucy +Tonya +Ella +Stacey +Wilma +Gina +Kristin +Jessie +Natalie +Agnes +Vera +Willie +Charlene +Bessie +Delores +Melinda +Pearl +Arlene +Maureen +Colleen +Allison +Tamara +Joy +Georgia +Constance +Lillie +Claudia +Jackie +Marcia +Tanya +Nellie +Minnie +Marlene +Heidi +Glenda +Lydia +Viola +Courtney +Marian +Stella +Caroline +Dora +Jo +Vickie +Mattie +Terry +Maxine +Irma +Mabel +Marsha +Myrtle +Lena +Christy +Deanna +Patsy +Hilda +Gwendolyn +Jennie +Nora +Margie +Nina +Cassandra +Leah +Penny +Kay +Priscilla +Naomi +Carole +Brandy +Olga +Billie +Dianne +Tracey +Leona +Jenny +Felicia +Sonia +Miriam +Velma +Becky +Bobbie +Violet +Kristina +Toni +Misty +Mae +Shelly +Daisy +Ramona +Sherri +Erika +Katrina +Claire +Lindsey +Lindsay +Geneva +Guadalupe +Belinda +Margarita +Sheryl +Cora +Faye +Ada +Natasha +Sabrina +Isabel +Marguerite +Hattie +Harriet +Molly +Cecilia +Kristi +Brandi +Blanche +Sandy +Rosie +Joanna +Iris +Eunice +Angie +Inez +Lynda +Madeline +Amelia +Alberta +Genevieve +Monique +Jodi +Janie +Maggie +Kayla +Sonya +Jan +Lee +Kristine +Candace +Fannie +Maryann +Opal +Alison +Yvette +Melody +Luz +Susie +Olivia +Flora +Shelley +Kristy +Mamie +Lula +Lola +Verna +Beulah +Antoinette +Candice +Juana +Jeannette +Pam +Kelli +Hannah +Whitney +Bridget +Karla +Celia +Latoya +Patty +Shelia +Gayle +Della +Vicky +Lynne +Sheri +Marianne +Kara +Jacquelyn +Erma +Blanca +Myra +Leticia +Pat +Krista +Roxanne +Angelica +Johnnie +Robyn +Francis +Adrienne +Rosalie +Alexandra +Brooke +Bethany +Sadie +Bernadette +Traci +Jody +Kendra +Jasmine +Nichole +Rachael +Chelsea +Mable +Ernestine +Muriel +Marcella +Elena +Krystal +Angelina +Nadine +Kari +Estelle +Dianna +Paulette +Lora +Mona +Doreen +Rosemarie +Angel +Desiree +Antonia +Hope +Ginger +Janis +Betsy +Christie +Freda +Mercedes +Meredith +Lynette +Teri +Cristina +Eula +Leigh +Meghan +Sophia +Eloise +Rochelle +Gretchen +Cecelia +Raquel +Henrietta +Alyssa +Jana +Kelley +Gwen +Kerry +Jenna +Tricia +Laverne +Olive +Alexis +Tasha +Silvia +Elvira +Casey +Delia +Sophie +Kate +Patti +Lorena +Kellie +Sonja +Lila +Lana +Darla +May +Mindy +Essie +Mandy +Lorene +Elsa +Josefina +Jeannie +Miranda +Dixie +Lucia +Marta +Faith +Lela +Johanna +Shari +Camille +Tami +Shawna +Elisa +Ebony +Melba +Ora +Nettie +Tabitha +Ollie +Jaime +Winifred +Kristie +Marina +Alisha +Aimee +Rena +Myrna +Marla +Tammie +Latasha +Bonita +Patrice +Ronda +Sherrie +Addie +Francine +Deloris +Stacie +Adriana +Cheri +Shelby +Abigail +Celeste +Jewel +Cara +Adele +Rebekah +Lucinda +Dorthy +Chris +Effie +Trina +Reba +Shawn +Sallie +Aurora +Lenora +Etta +Lottie +Kerri +Trisha +Nikki +Estella +Francisca +Josie +Tracie +Marissa +Karin +Brittney +Janelle +Lourdes +Laurel +Helene +Fern +Elva +Corinne +Kelsey +Ina +Bettie +Elisabeth +Aida +Caitlin +Ingrid +Iva +Eugenia +Christa +Goldie +Cassie +Maude +Jenifer +Therese +Frankie +Dena +Lorna +Janette +Latonya +Candy +Morgan +Consuelo +Tamika +Rosetta +Debora +Cherie +Polly +Dina +Jewell +Fay +Jillian +Dorothea +Nell +Trudy +Esperanza +Patrica +Kimberley +Shanna +Helena +Carolina +Cleo +Stefanie +Rosario +Ola +Janine +Mollie +Lupe +Alisa +Lou +Maribel +Susanne +Bette +Susana +Elise +Cecile +Isabelle +Lesley +Jocelyn +Paige +Joni +Rachelle +Leola +Daphne +Alta +Ester +Petra +Graciela +Imogene +Jolene +Keisha +Lacey +Glenna +Gabriela +Keri +Ursula +Lizzie +Kirsten +Shana +Adeline +Mayra +Jayne +Jaclyn +Gracie +Sondra +Carmela +Marisa +Rosalind +Charity +Tonia +Beatriz +Marisol +Clarice +Jeanine +Sheena +Angeline +Frieda +Lily +Robbie +Shauna +Millie +Claudette +Cathleen +Angelia +Gabrielle +Autumn +Katharine +Summer +Jodie +Staci +Lea +Christi +Jimmie +Justine +Elma +Luella +Margret +Dominique +Socorro +Rene +Martina +Margo +Mavis +Callie +Bobbi +Maritza +Lucile +Leanne +Jeannine +Deana +Aileen +Lorie +Ladonna +Willa +Manuela +Gale +Selma +Dolly +Sybil +Abby +Lara +Dale +Ivy +Dee +Winnie +Marcy +Luisa +Jeri +Magdalena +Ofelia +Meagan +Audra +Matilda +Leila +Cornelia +Bianca +Simone +Bettye +Randi +Virgie +Latisha +Barbra +Georgina +Eliza +Leann +Bridgette +Rhoda +Haley +Adela +Nola +Bernadine +Flossie +Ila +Greta +Ruthie +Nelda +Minerva +Lilly +Terrie +Letha +Hilary +Estela +Valarie +Brianna +Rosalyn +Earline +Catalina +Ava +Mia +Clarissa +Lidia +Corrine +Alexandria +Concepcion +Tia +Sharron +Rae +Dona +Ericka +Jami +Elnora +Chandra +Lenore +Neva +Marylou +Melisa +Tabatha +Serena +Avis +Allie +Sofia +Jeanie +Odessa +Nannie +Harriett +Loraine +Penelope +Milagros +Emilia +Benita +Allyson +Ashlee +Tania +Tommie +Esmeralda +Karina +Eve +Pearlie +Zelma +Malinda +Noreen +Tameka +Saundra +Hillary +Amie +Althea +Rosalinda +Jordan +Lilia +Alana +Gay +Clare +Alejandra +Elinor +Michael +Lorrie +Jerri +Darcy +Earnestine +Carmella +Taylor +Noemi +Marcie +Liza +Annabelle +Louisa +Earlene +Mallory +Carlene +Nita +Selena +Tanisha +Katy +Julianne +John +Lakisha +Edwina +Maricela +Margery +Kenya +Dollie +Roxie +Roslyn +Kathrine +Nanette +Charmaine +Lavonne +Ilene +Kris +Tammi +Suzette +Corine +Kaye +Jerry +Merle +Chrystal +Lina +Deanne +Lilian +Juliana +Aline +Luann +Kasey +Maryanne +Evangeline +Colette +Melva +Lawanda +Yesenia +Nadia +Madge +Kathie +Eddie +Ophelia +Valeria +Nona +Mitzi +Mari +Georgette +Claudine +Fran +Alissa +Roseann +Lakeisha +Susanna +Reva +Deidre +Chasity +Sheree +Carly +James +Elvia +Alyce +Deirdre +Gena +Briana +Araceli +Katelyn +Rosanne +Wendi +Tessa +Berta +Marva +Imelda +Marietta +Marci +Leonor +Arline +Sasha +Madelyn +Janna +Juliette +Deena +Aurelia +Josefa +Augusta +Liliana +Young +Christian +Lessie +Amalia +Savannah +Anastasia +Vilma +Natalia +Rosella +Lynnette +Corina +Alfreda +Leanna +Carey +Amparo +Coleen +Tamra +Aisha +Wilda +Karyn +Cherry +Queen +Maura +Mai +Evangelina +Rosanna +Hallie +Erna +Enid +Mariana +Lacy +Juliet +Jacklyn +Freida +Madeleine +Mara +Hester +Cathryn +Lelia +Casandra +Bridgett +Angelita +Jannie +Dionne +Annmarie +Katina +Beryl +Phoebe +Millicent +Katheryn +Diann +Carissa +Maryellen +Liz +Lauri +Helga +Gilda +Adrian +Rhea +Marquita +Hollie +Tisha +Tamera +Angelique +Francesca +Britney +Kaitlin +Lolita +Florine +Rowena +Reyna +Twila +Fanny +Janell +Ines +Concetta +Bertie +Alba +Brigitte +Alyson +Vonda +Pansy +Elba +Noelle +Letitia +Kitty +Deann +Brandie +Louella +Leta +Felecia +Sharlene +Lesa +Beverley +Robert +Isabella +Herminia +Terra +Celina \ No newline at end of file diff --git a/External/differential-privacy b/External/differential-privacy new file mode 160000 index 0000000..ffed059 --- /dev/null +++ b/External/differential-privacy @@ -0,0 +1 @@ +Subproject commit ffed059b680b311e877cb5a762e7cf47ec2c7dab diff --git a/Incomplete/renyi.ipynb b/Incomplete/renyi.ipynb new file mode 100644 index 0000000..cfb846a --- /dev/null +++ b/Incomplete/renyi.ipynb @@ -0,0 +1,194 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "49e2a702", + "metadata": {}, + "source": [ + "# Renyi Differential Privacy\n", + "\n", + "By [Armaan Bhojwani](https://armaanb.net) under [Praneeth Vepakomma](https://praneeth.mit.edu/)\n", + "\n", + "This notebook features some examples of using the dp_accounting Renyi accountant to translate between epsilon, delta and alpha, rho interpretations of Renyi DP, and for usk in compositions.\n", + "\n", + "### Dependencies\n", + "- matplotlib\n", + "- dp_accounting\n", + "\n", + "### Status\n", + "Incomplete" + ] + }, + { + "cell_type": "markdown", + "id": "378ba024", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "id": "062e3b39", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# Privacy parameters\n", + "# (https://github.com/google/differential-privacy/blob/main/python/dp_accounting/rdp/rdp_privacy_accountant.py#L781)\n", + "custom_orders = False # Set to array of custom orders, otherwise use defaults\n", + "\n", + "sensitivity = 99 # Sensitivity of the function\n", + "epsilon = 2 # Privacy garuntee\n", + "delta = 10e-7\n", + "\n", + "# Data parameters\n", + "data_len = 1500 # Length of dataset\n", + "data_low = 0 # Lowest value of dataset\n", + "data_high = 99 # Highest value of dataset\n", + "\n", + "# Initialize Numpy RNG\n", + "rng = np.random.default_rng()\n", + "\n", + "# Increment data_high so that it includes the value specified\n", + "data_high += 1\n", + "\n", + "# Create dataset as defined by above parameters\n", + "x = rng.integers(low=data_low, high=data_high, size=(data_len))" + ] + }, + { + "cell_type": "markdown", + "id": "25510bc4", + "metadata": {}, + "source": [ + "## Implementation" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "id": "a74d9ba6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "found noise multiplier: 2.382578592961857\n" + ] + } + ], + "source": [ + "import dp_accounting as dpa\n", + "import dp_accounting.rdp as rdpa\n", + "\n", + "# noise_multiplier is the ratio of the standard deviation of the Gaussian\n", + "# noise to the l2-sensitivity of the function to which it is added\n", + "noise_multiplier = dpa.calibrate_dp_mechanism(rdpa.RdpAccountant,\n", + " dpa.GaussianDpEvent, epsilon,\n", + " delta)\n", + "\n", + "print(f\"found noise multiplier: {noise_multiplier}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "id": "7451e486", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "found epsilon: 1.9999992100966923\n", + "found delta: 1.0000000000000023e-06\n", + "────────────────────────────────────────\n", + "found alpha: 12.0\n", + "found rho: 1.0569556863430245\n" + ] + } + ], + "source": [ + "from common import *\n", + "\n", + "accountant = rdpa.RdpAccountant(\n", + " orders=custom_orders) if custom_orders else rdpa.RdpAccountant()\n", + "\n", + "event = dpa.GaussianDpEvent(noise_multiplier)\n", + "accountant = accountant.compose(event)\n", + "\n", + "t_epsilon, alpha = accountant.get_epsilon_and_optimal_order(delta)\n", + "t_delta = accountant.get_delta(t_epsilon)\n", + "\n", + "alpha_idx = np.where(accountant._orders == alpha)\n", + "rho = accountant._rdp[alpha_idx][0]\n", + "\n", + "print(f\"found epsilon: {t_epsilon}\")\n", + "print(f\"found delta: {t_delta}\")\n", + "print_hline(40)\n", + "print(f\"found alpha: {alpha}\")\n", + "print(f\"found rho: {rho}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "id": "6c295418", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using sigma: 2.382578592961857\n", + "non-private sum: 75550\n", + "private sum: 75548\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def gaussian_mech_RDP(x, sensitivity, alpha, rho, sigma=0):\n", + " sigma = np.sqrt((sensitivity**2 * alpha) / (2 * rho)) if sigma == 0 else sigma\n", + " print(f\"Using sigma: {sigma}\")\n", + " return x + np.random.normal(loc=0, scale=sigma)\n", + "\n", + "# https://programming-dp.com/ch6.html#vector-valued-functions-and-their-sensitivities\n", + "l2_sensitivity = sensitivity ** 0.5\n", + "\n", + "sum_x = np.sum(x)\n", + "sigma = noise_multiplier * l2_sensitivity\n", + "sum_X = round(gaussian_mech_RDP(sum_x, l2_sensitivity, alpha, rho, sigma=sigma))\n", + "\n", + "print(f\"non-private sum: {sum_x}\")\n", + "print(f\"private sum: {sum_X}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Incomplete/zero_concentrated.ipynb b/Incomplete/zero_concentrated.ipynb new file mode 100644 index 0000000..a298952 --- /dev/null +++ b/Incomplete/zero_concentrated.ipynb @@ -0,0 +1,107 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "68ccfda8", + "metadata": {}, + "source": [ + "# Zero-Concentrated Differential Privacy" + ] + }, + { + "cell_type": "markdown", + "id": "a771110f", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cb67fa6a", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# Set parameters for dataset\n", + "data_len = 1500 # Length of dataset\n", + "data_low = 0 # Lowest value of dataset\n", + "data_high = 50 # Highest value of dataset\n", + "\n", + "# Initialize Numpy RNG\n", + "rng = np.random.default_rng()\n", + "\n", + "# Increment data_high so that it includes the value specified\n", + "data_high += 1\n", + "\n", + "# Create dataset as defined by above parameters\n", + "x = rng.integers(low=data_low, high=data_high, size=(data_len))" + ] + }, + { + "cell_type": "markdown", + "id": "558888c5", + "metadata": {}, + "source": [ + "## Implementation\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a8babf68", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def gaussian_mech_zCDP(vec, sensitivity, rho):\n", + " sigma = np.sqrt((sensitivity**2) / (2 * rho))\n", + " return [v + np.random.normal(loc=0, scale=sigma) for v in vec]\n", + "\n", + "sigma = 200\n", + "sensitivity = 1\n", + "\n", + "rho = 1/(2*sigma**2)\n", + "zCDP = gaussian_mech_zCDP(x, sensitivity, rho)\n", + "\n", + "plt.hist(zCDP)\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..04dd3f7 --- /dev/null +++ b/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2023 Armaan Bhojwani + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/README b/README new file mode 100644 index 0000000..2550f25 --- /dev/null +++ b/README @@ -0,0 +1,82 @@ + ___ _ _ + / _ \_ _| |_| |__ ___ _ __ + / /_)/ | | | __| '_ \ / _ \| '_ \ +/ ___/| |_| | |_| | | | (_) | | | | +\/ \__, |\__|_| |_|\___/|_| |_| + |___/ ___ _ __ __ _ _ _ + / (_)/ _|/ _| ___ _ __ ___ _ __ | |_(_) __ _| | + / /\ / | |_| |_ / _ \ '__/ _ \ '_ \| __| |/ _` | | + / /_//| | _| _| __/ | | __/ | | | |_| | (_| | | + /___,' |_|_| |_| \___|_| \___|_| |_|\__|_|\__,_|_| + ___ _ + / _ \_ __(_)_ ____ _ ___ _ _ + / /_)/ '__| \ \ / / _` |/ __| | | | + / ___/| | | |\ V / (_| | (__| |_| | + \/ |_| |_| \_/ \__,_|\___|\__, | + |___/ +-------------------------------------------------------------------------------- + +This repository shows some example implementations of differential privacy[1] +in Python via Jupyter Notebooks. Each notebook contains further references and +information. This work may contain blunders, and it's accuracy has not been +verified, however it should still be able to give you a good starting point +for work with differential privacy. + +You can use nbviewer[2] or GitHub[3] to view the notebooks online. + +This work was completed under the guidance of Praneeth Vepakomma [4] + +1: https://en.wikipedia.org/wiki/Differential_privacy +2: https://nbviewer.org +3: https://github.com/acheam0/python_dp +4: https://praneeth.mit.edu/ + +-------------------------------------------------------------------------------- + ++-------+ +| INDEX | ++-------+ + +- Approximate differential privacy (epsilon-delta): + - gaussian_mechanism.ipynb + +- Bayes rule: + - bayesian_attacker.ipynb + +- Choice query: + - exponential_mechanism.ipynb + +- Clipping: + - laplace_example_class_height.ipynb + +- Compositions: + - gaussian_mechanism.ipynb + +- Exponential mechanism: + - exponential_mechanism.ipynb + +- Histogram query: + - laplace_mechanism.ipynb + +- Helper functions: + - common.py + +- Privacy loss distributions: + - gaussian_mechanism.ipynb + +- Privacy loss random variable: + - gaussian_mechanism.ipynb + +- Pure differential privacy (epsilon): + - laplace_example_class_height.ipynb + - laplace_mechanism.ipynb + +- Sum, count, mean queries: + - laplace_example_class_height.ipynb + - laplace_mechanism.ipynb + +In addition to these, there are some incomplete notebooks in the "Incomplete/" +subdirectory. + +-------------------------------------------------------------------------------- +Copyright (c) 2023 Armaan Bhojwani , MIT License diff --git a/bayesian_attacker.ipynb b/bayesian_attacker.ipynb new file mode 100644 index 0000000..337c139 --- /dev/null +++ b/bayesian_attacker.ipynb @@ -0,0 +1,145 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "58967cbf", + "metadata": {}, + "source": [ + "# Plot epsilon's effect on privacy (attacker's perspective)\n", + "By [Armaan Bhojwani](https://armaanb.net) under [Praneeth Vepakomma](https://praneeth.mit.edu/)\n", + "\n", + "Inspired by https://desfontain.es/privacy/differential-privacy-in-more-detail.html, see link for further explanation.\n", + "\n", + "### Dependencies\n", + "- seaborn\n", + "\n", + "### Status\n", + "- Complete" + ] + }, + { + "cell_type": "markdown", + "id": "cf22d83b", + "metadata": {}, + "source": [ + "### Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4dfb69fe", + "metadata": {}, + "outputs": [], + "source": [ + "max_epsilon = 4 # Maximum epsilon value to plot\n", + "epsilon_step = 0.5 # Step size between epsilons\n", + "\n", + "# See http://seaborn.pydata.org/tutorial/color_palettes.html\n", + "color_palette = \"Blues\"" + ] + }, + { + "cell_type": "markdown", + "id": "7722414b", + "metadata": {}, + "source": [ + "### Code" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2963cf7f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import matplotlib.patches as mpatches\n", + "import seaborn as sns\n", + "import numpy as np\n", + "import math\n", + "\n", + "# Parameters\n", + "x_resolution = 500\n", + "e = math.e\n", + "\n", + "# Color palette\n", + "num_values = int(max_epsilon / epsilon_step)\n", + "colors = sns.color_palette(color_palette, num_values)\n", + "\n", + "x = np.linspace(0, 1, x_resolution)\n", + "\n", + "# Setup plot\n", + "fig, ax = plt.subplots()\n", + "handles, labels = ax.get_legend_handles_labels()\n", + "\n", + "for i in range(num_values, 0, -1):\n", + " epsilon = i * epsilon_step\n", + " \n", + " # Lower bound\n", + " y1 = x / ((e**epsilon) + (1 - (e**epsilon)) * x)\n", + "\n", + " # Upper bound\n", + " y2 = (e**epsilon * x) / (1 + (e**epsilon - 1) * x)\n", + "\n", + " # Plot bounds\n", + " color = colors[i - 1]\n", + " ax.fill_between(x, y1, y2, linewidth=0, color=color)\n", + "\n", + " # Add legend\n", + " handles.append(mpatches.Patch(color=color, label=epsilon))\n", + "\n", + "# Plot x = y line\n", + "ax.plot(x, x, linewidth=2, color='w', linestyle=\"dotted\")\n", + "\n", + "# Plot legend\n", + "box = ax.get_position()\n", + "ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])\n", + "ax.legend(handles=handles,\n", + " loc='center left',\n", + " bbox_to_anchor=(1, 0.5),\n", + " title=r'$\\epsilon$')\n", + "\n", + "# Set axes\n", + "ax.set_xlabel(\"Initial suspicion\")\n", + "ax.set_ylabel(\"Updated suspicion\")\n", + "plt.title(\"Privacy levels of various epsilons\")\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/common.py b/common.py new file mode 100644 index 0000000..ede76fa --- /dev/null +++ b/common.py @@ -0,0 +1,52 @@ +# Implementations of common functions across these privacy notebooks + +from random import getrandbits, randint + +import numpy as np + + +def create_neighbour(x, verbose=False): + """ Creates a neighbouring dataset + Inputs: + x: original dataset + verbose: print detail + Output: + neighbouring dataset to x with 1 random value added or removed + """ + + x2 = np.copy(x) + np.random.default_rng().shuffle(x2) + + # Randomly chose whether to add or subtract a value + if getrandbits(1): + x2 = x2[1:] + if verbose: print("Subtracting value") + else: + x2 = np.append(x2, randint(min(x), max(x))) + if verbose: print("Adding value") + + return x2 + +def print_hline(length): + """ Prints a horizontal line + Inputs: + length: length of the line in characters + + Output: + Unicode horizontal line printed to console + """ + + print(u'\u2500' * length) + +def get_epsilons(max_epsilon, epsilon_step): + """ Create array of epsilon values to test using given parameters + Inputs: + max_epsilon: maximum epsilon value + epsilon_step: step size between epsilons + + Output: + Array of epsilon values to test + """ + + epsilon_div = 1 / epsilon_step + return [i / epsilon_div for i in range(1, int(max_epsilon * epsilon_div))] diff --git a/exponential_mechanism.ipynb b/exponential_mechanism.ipynb new file mode 100644 index 0000000..f2c5e2e --- /dev/null +++ b/exponential_mechanism.ipynb @@ -0,0 +1,285 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6b9078e7", + "metadata": {}, + "source": [ + "# Exponential mechanism DP\n", + "\n", + "By [Armaan Bhojwani](https://armaanb.net) under [Praneeth Vepakomma](https://praneeth.mit.edu/)\n", + "\n", + "This notebook features the following differentially private operations on a finite set:\n", + "- Exponential mechanism\n", + " - Choice\n", + "\n", + "### Dependencies\n", + "- tqdm\n", + "- matplotlib\n", + "\n", + "### Status\n", + "- Complete\n", + "\n", + "### References\n", + "- https://programming-dp.com/ch9.html" + ] + }, + { + "cell_type": "markdown", + "id": "f961bc8f", + "metadata": {}, + "source": [ + "## Choosing the best country to hold a conference in\n", + "You are tasked with hosting a conference on nuclear disarmarment in, ideally, the country with the most nuclear weapons. The catch is you can't reveal which country has the most nukes. In this example, the input database is a 2x196 table with 196 countries in the first column and a triangularly distributed number of theoretical nukes in the second." + ] + }, + { + "cell_type": "markdown", + "id": "84841604", + "metadata": {}, + "source": [ + "### Parameters\n", + "\n", + "Epsilon is the privacy-accuracy trade-off\n", + "\n", + "Sensitivity is 1 as we are essentially performing a max query on the privatized probabilities we create" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c18e3ee5", + "metadata": {}, + "outputs": [], + "source": [ + "# Privacy\n", + "epsilon = 5\n", + "sensitivity = 1\n", + "\n", + "# Data\n", + "nukes_low = 0 # Minimum number of nukes a country can have\n", + "nukes_high = 10000 # Maximum number of nukes a country can have\n", + "\n", + "# Analysis\n", + "max_epsilon = 10 # Largest epsilon value to test\n", + "epsilon_step = 0.25 # Step size between epsilons\n", + "num_samples = 20000 # Number of times to run lim x->inf functions" + ] + }, + { + "cell_type": "markdown", + "id": "38fc1651", + "metadata": {}, + "source": [ + "### Build the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bb8b815b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top 25 countries with the most nukes (non-private):\n", + " 1: ('Czech Republic', 9547)\n", + " 2: ('Dominica', 9377)\n", + " 3: ('Brunei', 9323)\n", + " 4: ('Andorra', 8885)\n", + " 5: ('Saint Vincent and the Grenadines', 8851)\n", + " 6: ('Bangladesh', 8603)\n", + " 7: ('Djibouti', 8437)\n", + " 8: ('Bhutan', 8131)\n", + " 9: ('Dominican Republic', 8119)\n", + "10: ('Japan', 8048)\n", + "11: ('Malta', 7912)\n", + "12: ('Lebanon', 7905)\n", + "13: ('Bulgaria', 7903)\n", + "14: ('Slovakia', 7850)\n", + "15: ('Belgium', 7694)\n", + "16: ('Honduras', 7677)\n", + "17: ('Cuba', 7598)\n", + "18: ('Saudi Arabia', 7534)\n", + "19: ('Equatorial Guinea', 7496)\n", + "20: ('United States of America', 7461)\n", + "21: ('New Zealand', 7398)\n", + "22: ('Turkmenistan', 7396)\n", + "23: ('Pakistan', 7348)\n", + "24: ('Somalia', 7288)\n", + "25: ('Monaco', 7267)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "rng = np.random.default_rng()\n", + "\n", + "countries = np.loadtxt(\"./Data/countries.txt\", dtype='str')\n", + "countries = [y.replace('_', ' ') for y in countries]\n", + "nukes_avg = (nukes_low + nukes_high) / 2\n", + "nukes = rng.triangular(nukes_low,\n", + " nukes_avg,\n", + " nukes_high,\n", + " size=np.shape(countries))\n", + "nukes = [round(y) for y in nukes]\n", + "\n", + "x = list(zip(countries, nukes))\n", + "x.sort(key=lambda tup: tup[1], reverse=True)\n", + "\n", + "print(\"Top 25 countries with the most nukes (non-private):\")\n", + "for i, y in enumerate(x[:25]):\n", + " print(f\"{1 + i:2}: {y}\")" + ] + }, + { + "cell_type": "markdown", + "id": "22e2bf56", + "metadata": {}, + "source": [ + "### Apply exponential model" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "58ba906b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using epsilon 5, the algorithm chose Turkmenistan, which is the number 22 best choice.\n" + ] + } + ], + "source": [ + "def exponential_mech(nukes, nukes_high, epsilon):\n", + " # Create list of privatized probabilities for each country\n", + " nukesX = [4 * i / nukes_high for i in nukes]\n", + " nukesX = [np.exp(epsilon * i / (2 * sensitivity)) for i in nukesX]\n", + " nukesProb = nukesX / np.linalg.norm(nukesX, ord=1)\n", + "\n", + " # Pick a country according to the privatized probabilities\n", + " choice = rng.choice(countries, 1, p=nukesProb)[0]\n", + " place = [y[0] for y in x].index(choice) + 1\n", + " \n", + " return choice, place\n", + "\n", + "choice, place = exponential_mech(nukes, nukes_high, epsilon)\n", + "\n", + "print(f\"Using epsilon {epsilon}, the algorithm chose {choice}, which is the \" +\n", + " f\"number {place} best choice.\")" + ] + }, + { + "cell_type": "markdown", + "id": "3f0a0af7", + "metadata": {}, + "source": [ + "### Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e09e3c58", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0fe00cb9502543f59894a5c989feddde", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/39 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(epsilons, data)\n", + "plt.xlabel(\"Epsilon\")\n", + "plt.ylabel(\"Mean distance from ideal choice\")\n", + "plt.title(\"Effect of epsilon on privacy\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/gaussian_mechanism.ipynb b/gaussian_mechanism.ipynb new file mode 100644 index 0000000..8fd7e4f --- /dev/null +++ b/gaussian_mechanism.ipynb @@ -0,0 +1,532 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "112c2ca0", + "metadata": {}, + "source": [ + "# Gaussian mechanism PLRV\n", + "\n", + "By [Armaan Bhojwani](https://armaanb.net) under [Praneeth Vepakomma](https://praneeth.mit.edu/)\n", + "\n", + "### Preface\n", + "This notebook features the following differentially private operations utilizing [Google's Differential Privacy Accounting library](https://github.com/google/differential-privacy/tree/main/python).\n", + "\n", + "- Gaussian mechanism\n", + " - Privacy loss random variable\n", + " - Privacy loss distribution\n", + " - Observations 1, 2, 3 from [Google Privacy Loss Distributions paper](https://github.com/google/differential-privacy/blob/main/common_docs/Privacy_Loss_Distributions.pdf)\n", + "\n", + "### Dependencies\n", + "- dp_accounting\n", + "- matplotlib\n", + "- scipy\n", + "- tqdm\n", + "\n", + "This notebook makes extensive use of Google's `dp_accounting` library. To install, obtain the [sources here](https://github.com/google/differential-privacy/tree/main/python) or from the included git submodule (the submodule is in the `External/` directory, and the sources are in the `External/python/dp_accounting` subdirectory), and install using setuptools (`python3 setup.py install`).\n", + "\n", + "### References\n", + "- https://programming-dp.com/ch6.html\n", + "- https://desfontain.es/privacy/almost-differential-privacy.html\n", + "- https://desfontain.es/privacy/gaussian-noise.html\n", + "- https://github.com/google/differential-privacy/tree/main/python\n", + "- https://github.com/google/differential-privacy/blob/main/common_docs/Privacy_Loss_Distributions.pdf\n", + "\n", + " \n", + "### Status\n", + "- Complete" + ] + }, + { + "cell_type": "markdown", + "id": "f9940fdd", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "`epsilon` and `delta` are the standard DP parameters. `sensitivity` is the sensitivity of the particular function that you want to test. See [Programming Differential Privacy Chapter 5](https://programming-dp.com/ch5.html#calculating-sensitivity)\n", + "\n", + "### Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e4f4beed", + "metadata": {}, + "outputs": [], + "source": [ + "epsilon = 3 # Privacy level\n", + "delta = 10e-7 # Probability of failure. Should be much less than (length of dataset)^-1\n", + "sensitivity = 2 # Sensitivity of function" + ] + }, + { + "cell_type": "markdown", + "id": "ffa5bfc2", + "metadata": {}, + "source": [ + "### Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a6129fcd", + "metadata": {}, + "outputs": [], + "source": [ + "from dp_accounting.pld import privacy_loss_distribution as pld\n", + "from dp_accounting.pld import privacy_loss_mechanism as plm\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from tqdm.notebook import tqdm\n", + "\n", + "from math import e\n", + "import math" + ] + }, + { + "cell_type": "markdown", + "id": "8b192e1a", + "metadata": {}, + "source": [ + "## Privacy loss analysis\n", + "### Fitting sigma\n", + "\n", + "The `dp_accounting` library expects you to provide the sensitivity of the function and the standard deviation of the gaussian mechanism to use. This doesn't help us much as we would like to work the other way around, providing the sensitivity of the mechanism, and our privacy tolerances (epsilon and delta) and let the algorithm choose the best standard deviation to use. This function finds the optimal standard deviation to use in the gaussian function while satisfying the given privacy parameters.\n", + "\n", + "A potential replacement for this function is the `calibrate_dp_mechanism` function from the dp_accounting library." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5ef86f2b", + "metadata": {}, + "outputs": [], + "source": [ + "def fit_sigma_from_params(delta, epsilon, sensitivity, verbose=False):\n", + " \"\"\" Find the ideal sigma value given privacy parameters.\n", + " \n", + " This function iteratively increases the standard deviation of a gaussian\n", + " PLD until it finds a value that creates a PLD that meets the given privacy\n", + " parameters. It takes a first pass refining until it validates epsilon, \n", + " then it takes a second pass for delta.\n", + " \n", + " A potential replacement for this function is the calibrate_dp_mechanism\n", + " function from the dp_accounting library.\n", + " \n", + " Inputs:\n", + " delta: delta value to use\n", + " epsilon: epsilon value to use\n", + " sensitivity: sensitivity of mechanism\n", + " \n", + " Output:\n", + " Optimal standard deviation of the gaussian mechanism\n", + " \"\"\"\n", + "\n", + " def find_epsilon(sigma, delta, sensitivity):\n", + " gauss_pld = pld.from_gaussian_mechanism(\n", + " sigma, sensitivity=sensitivity, value_discretization_interval=0.01)\n", + " epsilon = gauss_pld.get_epsilon_for_delta(delta)\n", + " return epsilon\n", + "\n", + " def find_delta(sigma, epsilon, sensitivity):\n", + " gauss_pld = pld.from_gaussian_mechanism(\n", + " sigma, sensitivity=sensitivity, value_discretization_interval=0.01)\n", + " epsilon = gauss_pld.get_delta_for_epsilon(epsilon)\n", + " return epsilon\n", + "\n", + " # While loop fitting epsilon\n", + " sigma = 1\n", + " test_epsilon = 0\n", + " with tqdm() as t:\n", + " while not math.isclose(test_epsilon, epsilon):\n", + " test_epsilon = find_epsilon(sigma, delta, sensitivity)\n", + " epsilon_range = test_epsilon - epsilon\n", + " sigma += (epsilon_range / 4)\n", + "\n", + " t.update()\n", + "\n", + " if verbose: print(f\"(Epsilon layer) Fit to sigma of: {sigma}\")\n", + "\n", + " # Do-while loop fitting delta\n", + " with tqdm() as t:\n", + " cond = True\n", + " while cond:\n", + " test_delta = find_delta(sigma, epsilon, sensitivity)\n", + " sigma += 10e-8\n", + " cond = test_delta >= delta\n", + "\n", + " t.update()\n", + "\n", + " if verbose: print(f\"(Delta layer) Fit to sigma of: {sigma}\")\n", + "\n", + " return sigma\n", + "\n", + "\n", + "# sigma = fit_sigma_from_params(delta, epsilon, sensitivity, verbose=True)" + ] + }, + { + "cell_type": "markdown", + "id": "4b0a9fd2", + "metadata": {}, + "source": [ + "### Privacy loss distribution functions" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4f66b640", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a5e4e242ec154f93a107d482b8c192ad", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(Epsilon layer) Fit to sigma of: 3.087722833683524\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8d1989247d75415aa2b8d42aefc1a547", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(Delta layer) Fit to sigma of: 3.0877230336835235\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj0AAAGzCAYAAADEw6Y0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABopUlEQVR4nO3deVhUZf8/8PcMywyyurEpKhmmqamJ8OASmRSWlbRompWS2/NLS7PlyUptsSi18rEsH1u0xdJosXIrUstSxN1Sy7TQFANUZFB2Zu7fH/d3BkZAGTycM8v7dV3nOscz98x85sDtfLi3oxNCCBARERG5Ob3WARARERGpgUkPEREReQQmPUREROQRmPQQERGRR2DSQ0RERB6BSQ8RERF5BCY9RERE5BGY9BAREZFHYNJDREREHoFJD9Elmjt3Li677DJ4eXmhZ8+eWofTKDqdDs8884zdue3bt6Nv377w9/eHTqfDnj178Mwzz0Cn0yn63tdeey2uvfZaRV/T2XXo0AFjxozROgzNXHvttejWrZsm790Uv8PkOpj0kKaWLl0KnU5n24xGIzp16oTJkycjLy/PVu6HH36ATqfDZ599dsHXq/la3t7eaNGiBXr37o0pU6bgwIEDisf/3Xff4fHHH0e/fv2wZMkSvPjii4q/hxYqKysxbNgwFBQU4LXXXsOHH36I9u3bax0WLBYLPvjgA1x//fVo1aoVfHx8EBoaihtuuAGLFy9GeXm51iE6tZr17eeff671uBACUVFR0Ol0uPnmmzWIkKhpeWsdABEAPPfcc4iOjkZZWRl+/vlnvPXWW1izZg327duHZs2aOfRa119/Pe677z4IIWAymbB37168//77ePPNN/Hyyy9j2rRpisW9YcMG6PV6vPvuu/D19VXsddVWWloKb+/q/w7+/PNPHD16FG+//TbGjRtnO//000/jiSee0CJElJaW4rbbbsO3336Lvn374tFHH0VYWBgKCgrw448/4oEHHkBWVhbeffddTeJzxMGDB6HXa/c3p9FoxMcff4z+/fvbnf/xxx9x/PhxGAwGjSJrelr+DpP2mPSQU7jxxhsRGxsLABg3bhxatmyJV199FV999RVGjhzp0Gt16tQJ99xzj925l156CbfccgseeeQRdO7cGTfddJMicefn58PPz8+lEx5AfgnWlJ+fDwAICQmxO+/t7W2XHKnp4Ycfxrfffov58+djypQpdo898sgjOHToEDIyMjSJzVFaJxU33XQT0tPTsWDBAruf58cff4zevXvj1KlTGkbXtLT8HSbtsXuLnNJ1110HAMjOzlbk9Vq2bInly5fD29sbL7zwwkXLV1VV4fnnn0fHjh1hMBjQoUMHPPnkk3bdJzqdDkuWLEFxcbGty2Dp0qX1vuahQ4dwxx13IDw8HEajEW3btsWIESNgMpnsXnPy5MlYtmwZrrjiChiNRvTu3RubNm2q9Xo5OTm4//77ERYWBoPBgK5du+K9996rVa6srAzPPPMMOnXqBKPRiIiICNx+++34888/7d7XOqZnzJgxSExMBAAMGzYMOp3ONuamvvEQH330EXr37g0/Pz+0aNECI0aMwLFjx2qVW7x4MTp27Ag/Pz/ExcXhp59+qvd61XTs2DG88847GDx4cK2ExyomJgYPPPCA3bl58+ahb9++aNmyJfz8/NC7d+9aXaRHjhyp92d3/lins2fPYurUqejQoQMMBgNCQ0Nx/fXXY9euXbYyDfk5nz+mp6CgAI8++ii6d++OgIAABAUF4cYbb8TevXvt4rF283766ad44YUX0LZtWxiNRgwaNAiHDx++2GW0GTlyJE6fPm2XJFZUVOCzzz7D3XffXedzLBYL5s+fj65du8JoNCIsLAwTJ07EmTNnapVdu3YtEhMTERgYiKCgIPTp0wcff/xxrXIHDhzAwIED0axZM7Rp0wZz5syxe7yiogIzZ85E7969ERwcDH9/fwwYMAAbN260K2f9Gc6bN8/2O2YwGNCnTx9s377drmxdv8MZGRno378/QkJCEBAQgCuuuAJPPvmk7fGa1/3ZZ59FmzZtEBgYiDvvvBMmkwnl5eWYOnUqQkNDERAQgNTUVHa1Oimmu+SUrF/ILVu2VOw127Vrh8TERGzcuBFFRUUICgqqt+y4cePw/vvv484778QjjzyCrKwspKWl4bfffsOXX34JAPjwww+xePFibNu2De+88w4AoG/fvnW+XkVFBZKTk1FeXo4HH3wQ4eHhyMnJwapVq1BYWIjg4GBb2R9//BErVqzAQw89BIPBgDfffBODBw/Gtm3bbIM/8/Ly8K9//cuWJLVu3Rpr167F2LFjUVRUhKlTpwIAzGYzbr75Zqxfvx4jRozAlClTcPbsWWRkZGDfvn3o2LFjrVgnTpyINm3a4MUXX8RDDz2EPn36ICwsrN5r9cILL2DGjBkYPnw4xo0bh5MnT+L111/HNddcg927d9tai959911MnDgRffv2xdSpU/HXX3/h1ltvRYsWLRAVFVX/Dw7yS9RsNtdqwbuY//73v7j11lsxatQoVFRUYPny5Rg2bBhWrVqFIUOGOPRaAPDvf/8bn332GSZPnowrr7wSp0+fxs8//4zffvsNV199tUM/55r++usvrFy5EsOGDUN0dDTy8vLwv//9D4mJiThw4AAiIyPtyr/00kvQ6/V49NFHYTKZMGfOHIwaNQpZWVkN+hwdOnRAQkICPvnkE9x4440A5DU2mUwYMWIEFixYUOs5EydOxNKlS5GamoqHHnoI2dnZeOONN7B7925s3rwZPj4+AOS4ofvvvx9du3bF9OnTERISgt27d2PdunV2CdWZM2cwePBg3H777Rg+fDg+++wz/Oc//0H37t1tMRUVFeGdd97ByJEjMX78eJw9exbvvvsukpOTsW3btloTBz7++GOcPXsWEydOhE6nw5w5c3D77bfjr7/+ssV3vv379+Pmm2/GVVddheeeew4GgwGHDx/G5s2ba5VNS0uDn58fnnjiCRw+fBivv/46fHx8oNfrcebMGTzzzDPYunUrli5diujoaMycObNBPw9SkSDS0JIlSwQA8f3334uTJ0+KY8eOieXLl4uWLVsKPz8/cfz4cSGEEBs3bhQARHp6+gVfD4CYNGlSvY9PmTJFABB79+6tt8yePXsEADFu3Di7848++qgAIDZs2GA7N3r0aOHv73/Rz7l79+4Gxw9A7Nixw3bu6NGjwmg0ittuu812buzYsSIiIkKcOnXK7vkjRowQwcHBoqSkRAghxHvvvScAiFdffbXWe1ksFrv3nTVrlu3f9V3vWbNmiZr/bRw5ckR4eXmJF154wa7cr7/+Kry9vW3nKyoqRGhoqOjZs6coLy+3lVu8eLEAIBITEy94XR5++GEBQOzZs8fufHl5uTh58qRtO/96WK+DVUVFhejWrZu47rrrbOeys7MFALFkyZJa73v+dQkODr7g71dDf87t27cXo0ePtv27rKxMmM1muzLZ2dnCYDCI5557znbO+nPp0qWL3XX873//KwCIX3/99YLva61v27dvF2+88YYIDAy0XaNhw4aJgQMH2uIbMmSI7Xk//fSTACCWLVtm93rr1q2zO19YWCgCAwNFfHy8KC0ttStb8/ctMTFRABAffPCB7Vx5ebkIDw8Xd9xxh+1cVVWV3ecUQogzZ86IsLAwcf/999tdKwCiZcuWoqCgwHb+q6++EgDEN998Yzt3/u/wa6+9JgCIkydP1nvdrNe9W7duoqKiwnZ+5MiRQqfTiRtvvNGufEJCgmjfvn29r0faYfcWOYWkpCS0bt0aUVFRGDFiBAICAvDll1+iTZs2ir5PQEAAANlNUZ81a9YAQK0Bz4888ggAYPXq1Q6/r/Uv/G+//RYlJSUXLJuQkIDevXvb/t2uXTsMHToU3377LcxmM4QQ+Pzzz3HLLbdACIFTp07ZtuTkZJhMJlt3y+eff45WrVrhwQcfrPU+Skzb/eKLL2CxWDB8+HC7OMLDwxETE2PrhtixYwfy8/Px73//227805gxY+pt/aipqKgIQPXPz2rNmjVo3bq1bTt/hpmfn5/t+MyZMzCZTBgwYIBdd5QjQkJCkJWVhRMnTtT5uCM/55oMBoNtYLPZbMbp06dt3Sx1xZqammp3HQcMGABAthg11PDhw1FaWopVq1bh7NmzWLVqVb1dW+np6QgODsb1119v93Pu3bs3AgICbD/njIwMnD17Fk888UStcWLn/74FBATYtdz5+voiLi7O7jN4eXnZPqfFYkFBQQGqqqoQGxtb53W566670Lx5c4eui7Ul8quvvoLFYqm3HADcd999di1G8fHxEELg/vvvtysXHx+PY8eOoaqq6oKvR+pj0kNOYeHChcjIyMDGjRtx4MAB/PXXX0hOTlb8fc6dOwcACAwMrLfM0aNHodfrcfnll9udDw8PR0hICI4ePerw+0ZHR2PatGl455130KpVKyQnJ2PhwoV24zysYmJiap3r1KkTSkpKcPLkSZw8eRKFhYVYvHix3Rd+69atkZqaCqB6IPKff/6JK664oskGbh46dAhCCMTExNSK5bfffrPFYb1m5382Hx8fXHbZZRd9H+vPy/rzs+rXrx8yMjKQkZGBG264odbzVq1ahX/9618wGo1o0aIFWrdujbfeeqvO694Qc+bMwb59+xAVFYW4uDg888wzdl+ojvyca7JYLHjttdcQExMDg8GAVq1aoXXr1vjll1/qfG67du3s/m39oq9rfE19WrdujaSkJHz88cf44osvYDabceedd9ZZ9tChQzCZTAgNDa31cz537pzd7xuABq3B07Zt21qJUPPmzWt9hvfffx9XXXUVjEYjWrZsidatW2P16tWKXZe77roL/fr1w7hx4xAWFoYRI0bg008/rTMBOv/1rUnu+d2zwcHBsFgsjf49o6bDMT3kFOLi4myzt5rSvn374OXlhejo6IuWVXoBs1deeQVjxozBV199he+++w4PPfQQ0tLSsHXrVrRt27bBr2P9z/iee+7B6NGj6yxz1VVXKRJzQ2LR6XRYu3YtvLy8aj1+fstMY3Xu3BmA/Pn16NHDdt76xQ3IwdQ1/fTTT7j11ltxzTXX4M0330RERAR8fHywZMkSu0G19f2czWZzrXPDhw/HgAED8OWXX+K7777D3Llz8fLLL+OLL76wjUNpzM/5xRdfxIwZM3D//ffj+eefR4sWLaDX6zF16tQ6v3zrutaAXGfHEXfffTfGjx+P3Nxc3HjjjbVm61lZLBaEhoZi2bJldT7eunVrh94XaNhn+OijjzBmzBikpKTgscceQ2hoKLy8vJCWlmY3EN+R1zyfn58fNm3ahI0bN2L16tVYt24dVqxYgeuuuw7fffed3WvW9/pK/Tyo6THpIY/x999/48cff0RCQsIFW3rat28Pi8WCQ4cOoUuXLrbzeXl5KCwsvKRF+rp3747u3bvj6aefxpYtW9CvXz8sWrQIs2fPtpU5dOhQref98ccfaNasme3LJTAwEGaz2faFX5+OHTsiKysLlZWV9Q7kvBQdO3aEEALR0dHo1KlTveWs1+zQoUO2mXmAXAQxOzvbLpGpy4033ggvLy8sW7YMo0aNalBsn3/+OYxGI7799lu7KeJLliyxK2dtDSgsLLQ7X1+LXkREBB544AE88MADyM/Px9VXX40XXnjBlvQADfs51/TZZ59h4MCBtdYYKiwsRKtWrRr0eRvjtttuw8SJE7F161asWLGi3nIdO3bE999/j379+tl1GdZVDpDJ6fktpY3x2Wef4bLLLsMXX3xhl5zOmjXrkl+7Jr1ej0GDBmHQoEF49dVX8eKLL+Kpp57Cxo0bL1rHyLWwe4s8QkFBAUaOHAmz2YynnnrqgmWta/jMnz/f7vyrr74KAI2a9VNUVFSrf7979+7Q6/W1prZmZmbajVc4duwYvvrqK9xwww3w8vKCl5cX7rjjDnz++efYt29frfc6efKk7fiOO+7AqVOn8MYbb9Qqp8Rfobfffju8vLzw7LPP1no9IQROnz4NAIiNjUXr1q2xaNEiVFRU2MosXbq0VrJRl3bt2uH+++/H2rVr6/ws1verycvLCzqdzq7F5siRI1i5cqVduaCgILRq1arWsgBvvvmm3b/NZnOt7orQ0FBERkbafoaO/JzPj/X8+NPT05GTk1Pvc5QQEBCAt956C8888wxuueWWessNHz4cZrMZzz//fK3HqqqqbD/DG264AYGBgUhLS0NZWZlducb8vllbUGo+NysrC5mZmQ6/Vn0KCgpqnbPOCuO0c/fDlh5yKZ9//jl+//33WudHjx5t61f/448/8NFHH0EIgaKiIuzduxfp6ek4d+4cXn31VQwePPiC79GjRw+MHj0aixcvRmFhIRITE7Ft2za8//77SElJwcCBAx2Oe8OGDZg8eTKGDRuGTp06oaqqCh9++KEtgampW7duSE5OtpuyDgDPPvusrcxLL72EjRs3Ij4+HuPHj8eVV16JgoIC7Nq1C99//73tP/L77rsPH3zwAaZNm4Zt27ZhwIABKC4uxvfff48HHngAQ4cOdfiz1NSxY0fMnj0b06dPx5EjR5CSkoLAwEBkZ2fjyy+/xIQJE/Doo4/Cx8cHs2fPxsSJE3HdddfhrrvuQnZ2NpYsWdKgMT2ATEKzs7Px4IMPYvny5bjlllsQGhqKU6dOYfPmzfjmm29wxRVX2MoPGTLE9vO+++67kZ+fj4ULF+Lyyy/HL7/8Yvfa48aNw0svvYRx48YhNjYWmzZtwh9//GFX5uzZs2jbti3uvPNO9OjRAwEBAfj++++xfft2vPLKKwAc+znXdPPNN+O5555Damoq+vbti19//RXLli1r8LW5FPV1kdaUmJiIiRMnIi0tDXv27MENN9wAHx8fHDp0COnp6fjvf/+LO++8E0FBQXjttdcwbtw49OnTB3fffTeaN2+OvXv3oqSkBO+//75Dsd1888344osvcNttt2HIkCHIzs7GokWLcOWVV9Ya39VYzz33HDZt2oQhQ4agffv2yM/Px5tvvom2bdvWWrGa3IDq88WIaqg5hfZCrFNG69t++uknIYSwO6fX60VISIjo1auXmDJliti/f3+D46qsrBTPPvusiI6OFj4+PiIqKkpMnz5dlJWV2ZVr6JT1v/76S9x///2iY8eOwmg0ihYtWoiBAweK77//3q4c/m/K/UcffSRiYmKEwWAQvXr1Ehs3bqz1mnl5eWLSpEkiKipK+Pj4iPDwcDFo0CCxePFiu3IlJSXiqaeesn2W8PBwceedd4o///zT7n0bM2Xd6vPPPxf9+/cX/v7+wt/fX3Tu3FlMmjRJHDx40K7cm2++KaKjo4XBYBCxsbFi06ZNIjEx8aJT1q2qqqrEkiVLxHXXXSdatGghvL29RatWrcSgQYPEokWLak2Tfvfdd23XsXPnzmLJkiV1foaSkhIxduxYERwcLAIDA8Xw4cNFfn6+3XUpLy8Xjz32mOjRo4cIDAwU/v7+okePHuLNN9+0vU5Df851TVl/5JFHREREhPDz8xP9+vUTmZmZta5NfT+XC027r6mh9e38KetWixcvFr179xZ+fn4iMDBQdO/eXTz++OPixIkTduW+/vpr0bdvX+Hn5yeCgoJEXFyc+OSTT2yPJyYmiq5du9Z6/dGjR9tN9bZYLOLFF18U7du3t9WFVatW1Spn/fxz586t9Zrn/26f//Nfv369GDp0qIiMjBS+vr4iMjJSjBw5Uvzxxx+2MvVd9/qup/U9LjQNnrShE4IjrYichU6nw6RJk+rtwiEiosbjmB4iIiLyCEx6iIiIyCMw6SEiIiKPwNlbRE6EQ+yIiJoOW3qIiIjIIzDpISIiIo/A7q0aLBYLTpw4gcDAQMXvu0RERERNQwiBs2fPIjIyEnp9/e05THpqOHHiRK275RIREZFrOHbs2AVv4MykpwbrTSiPHTuGoKAgjaMhIiKihigqKkJUVNQFbyYNMOmxY+3SCgoKYtJDDqmoAP77X3k8ZQrg66ttPESuhPWHlHKxoSm8DUUNRUVFCA4OhslkYtJDDikuBgIC5PG5c4C/v7bxELkS1h+6VA39/mZLD5ECvL0B682qvVmriBzC+kNqYUtPDWzpISIicj0N/f7mOj1ERETkEZj0EBERkUdg0kOkgOJiICREbsXFWkdD5FpYf0gtHDJGpBCTSesIiFwX6w+pgUkPkQL8/IA//qg+JqKGY/0htTDpIVKAXg/ExGgdBZFrYv0htXBMDxEREXkEtvQQKaCyEli8WB5PmAD4+GgbD5ErYf0htXBxwhq4OCE1FpfRJ2o81h+6VLwNBZGKvLyAO++sPibXUVQEfPABkJcH3Hor0KeP1hF5HtYfUgtbempgSw+RZzl6FEhKAg4flv/W6eTdvh98UNu4iMgxvA0FEdEFVFYCw4fLhCcqCrj5ZkAIYMoUYP16raMjoqbApIeIPNLbbwPbtslVgH/6Cfj6a2DcOJn4PPCATIqIyL0w6SFSQEkJ0KaN3EpKtI6GLqasDHjhBXk8ezbQvr3s2po3DwgNlQvlLV+ubYyehPWH1MKkh0gBQgAnTsiNo+ScX3q6/Fm1bStbd6yCg2X3FiATIP4s1cH6Q2ppVNKzcOFCdOjQAUajEfHx8di2bdsFy6enp6Nz584wGo3o3r071qxZY/e4EAIzZ85EREQE/Pz8kJSUhEOHDtmVKSgowKhRoxAUFISQkBCMHTsW586dq/U68+bNQ6dOnWAwGNCmTRu8YP1zjqgJGY3A7t1yMxq1joYu5t135X7CBMBgsH/s//0/+TP85Rdg1y71Y/NErD+kFoeTnhUrVmDatGmYNWsWdu3ahR49eiA5ORn5+fl1lt+yZQtGjhyJsWPHYvfu3UhJSUFKSgr27dtnKzNnzhwsWLAAixYtQlZWFvz9/ZGcnIyysjJbmVGjRmH//v3IyMjAqlWrsGnTJkyYMMHuvaZMmYJ33nkH8+bNw++//46vv/4acXFxjn5EIod5eQE9e8qNU26d259/Aj/+KLuzxoyp/Xjz5sDQofL4o49UDc1jsf6QaoSD4uLixKRJk2z/NpvNIjIyUqSlpdVZfvjw4WLIkCF25+Lj48XEiROFEEJYLBYRHh4u5s6da3u8sLBQGAwG8cknnwghhDhw4IAAILZv324rs3btWqHT6UROTo6tjLe3t/j9998d/Ug2JpNJABAmk6nRr0FEzm3OHCEAIZKS6i/zzTeyTFiYEGazerERUeM09PvboZaeiooK7Ny5E0lJSbZzer0eSUlJyMzMrPM5mZmZduUBIDk52VY+Ozsbubm5dmWCg4MRHx9vK5OZmYmQkBDExsbayiQlJUGv1yMrKwsA8M033+Cyyy7DqlWrEB0djQ4dOmDcuHEoKCio9/OUl5ejqKjIbiNqjMpKYOlSuXHWj3P75hu5T0mpv0xyMhAUJBcs3LFDlbA8GusPqcWhpOfUqVMwm80ICwuzOx8WFobc3Nw6n5Obm3vB8tb9xcqEhobaPe7t7Y0WLVrYyvz11184evQo0tPT8cEHH2Dp0qXYuXMn7rQu81mHtLQ0BAcH27aoqKiLXQKiOlVUAKmpcquo0Doaqs/p08DmzfL45pvrL+fjA9xwgzxevbrp4/J0rD+kFreZvWWxWFBeXo4PPvgAAwYMwLXXXot3330XGzduxMGDB+t8zvTp02EymWzbsWPHVI6a3IWXF3DTTXLjmATntXYtYLEAPXrIaeoXMmSI3DPpaXqsP6QWh+691apVK3h5eSEvL8/ufF5eHsLDw+t8Tnh4+AXLW/d5eXmIiIiwK9OzZ09bmfMHSldVVaGgoMD2/IiICHh7e6NTp062Ml26dAEA/P3337jiiitqxWYwGGA4f+oGUSMYjfxydAXWlZYHD7542RtvlPudO4GTJ4HWrZsuLk/H+kNqcailx9fXF71798b6Gmu0WywWrF+/HgkJCXU+JyEhwa48AGRkZNjKR0dHIzw83K5MUVERsrKybGUSEhJQWFiInTt32sps2LABFosF8fHxAIB+/fqhqqoKf/75p63MH3/8AQBof7E/6YjII/z4o9xfe+3Fy4aFAV27yuOffmqykIhITY6OkF6+fLkwGAxi6dKl4sCBA2LChAkiJCRE5ObmCiGEuPfee8UTTzxhK79582bh7e0t5s2bJ3777Tcxa9Ys4ePjI3799VdbmZdeekmEhISIr776Svzyyy9i6NChIjo6WpSWltrKDB48WPTq1UtkZWWJn3/+WcTExIiRI0faHjebzeLqq68W11xzjdi1a5fYsWOHiI+PF9dff32DPxtnbxG5r6NH5YwsLy8hiooa9pwHHpDPmTKlSUMjokvU0O9vh5MeIYR4/fXXRbt27YSvr6+Ii4sTW7dutT2WmJgoRo8ebVf+008/FZ06dRK+vr6ia9euYvXq1XaPWywWMWPGDBEWFiYMBoMYNGiQOHjwoF2Z06dPi5EjR4qAgAARFBQkUlNTxdmzZ+3K5OTkiNtvv10EBASIsLAwMWbMGHH69OkGfy4mPdRYxcVCXH653IqLtY6G6vLBBzKBiYtr+HOWL5fP6dmz6eIi1h+6dA39/tYJwUW/rRp6a3qi8xUXAwEB8vjcOcDfX9t4qLaxY4H33gMeewyYM6dhz/nnHyAyUi5kWFAgb05KymP9oUvV0O9vhwYyE1HdjEbg55+rj8n5bNki9wMGNPw5ERHA5ZcDhw8DmZnVg5tJWaw/pBYmPUQK8PIC+vXTOgqqT1ERYF25wtE708THy6Rn+3YmPU2F9YfU4jbr9BAR1WfXLnn37qgoOSvLEX36yP327crHRUTqYksPkQKqqoAvv5THt90GeLNmORVrwmJNYBxhfc6OHTJx0umUi4sk1h9SC3+1iBRQXg4MHy6Pz53jf9rO5lKSHuudv3NzgZwcoG1bRUMjsP6QevirRaQAvR5ITKw+JudivWloY5KeZs2Abt2AvXtl8sSkR3msP6QWJj1ECvDzA374QesoqC6nTgHZ2fK4d+/GvUafPtVJz223KRcbSaw/pBbm1ETk1nbtkvuYmMavs2NNlvbuVSQkItIIkx4icmu//ir3PXo0/jW6d5f7X3659HiISDtMeogUUFoqB7z27CmPyXlYkx5r4tIY3brJ/fHjwJkzlx4T2WP9IbVwTA+RAiyW6q4Pi0XbWMieEklPcDDQvj1w9Kh8vWuuUSY2klh/SC1MeogUYDQC331XfUzOwWwGDhyQx5eS9ADAVVfJpOeXX5j0KI31h9TCpIdIAV5ewPXXax0Fne/wYaCsTE47v+yyS3utq64CvvmmuuWIlMP6Q2rhmB4iclvWBKVr10tf/4WDmYlcH1t6iBRQVQV8+608Tk7mirLOQonxPFZXXVX9mhYLF9FTEusPqYW/WkQKKC8Hbr5ZHnMZfeehZNITEwMYDEBxMXDkyKV3l1E11h9SC3+1iBSg1wOxsdXH5Bz27ZN7JZIeb2+gUyeZSB08yKRHSaw/pBYmPUQK8POrvqklOYfycuDPP+XxlVcq85qdO8uk5/ffgRtvVOY1ifWH1MOcmojc0p9/yrE3gYFAeLgyr3nFFXL/++/KvB4RqYtJDxG5pYMH5b5zZ0CnU+Y1O3eWeyY9RK6JSQ+RAkpLgX795MZl9J2DNTGxts4ogUlP02D9IbVwTA+RAiwWYMuW6mPSnrWlR8mkx/pa+flAQQHQooVyr+3JWH9ILUx6iBRgMABffll9TNpriqQnIABo21beePTgQSAhQbnX9mSsP6QWJj1ECvD2BlJStI6CrIRomqQHkF1cx4/LLi4mPcpg/SG1cEwPEbmdU6eAM2fkAOaYGGVfm+N6iFwXW3qIFGA2Az/9JI8HDJA3UCTtWFt52rWTa8AoiUmP8lh/SC1MeogUUFYGDBwoj8+dA/z9tY3H09Wcrq40rtWjPNYfUguTHiIF6HTVq/4qtSYMNV5TjecBqrvLsrNlCwVbJS4d6w+phUkPkQKaNQP279c6CrJqyqSnbVvAxweorASOHQM6dFD+PTwN6w+phQOZicjtHDok9506Kf/aXl7VNxu13tuLiFwDkx4icisWC/DXX/K4Y8emeY/LL5f7w4eb5vWJqGkw6SFSQGkpcP31cuMy+tr65x95h3VvbyAqqmnew5pMMelRBusPqYVjeogUYLEA339ffUzasXY5tW8vE5+mYG3pYfeWMlh/SC1MeogUYDAAH31UfUzasSYiTdW1BbB7S2msP6QWJj1ECvD2BkaN0joKAqqTHutg46ZgTaj+/FPe8oLTrC8N6w+phWN6iMitNPUgZkBOU9frgZISIDe36d6HiJTFpIdIAWYzsH273MxmraPxbGp0b/n6yjFDALu4lMD6Q2ph0kOkgLIyIC5ObmVlWkfj2dTo3gI4rkdJrD+kFiY9RArQ6eRf/u3bc3yHlkwm4PRpedzUSU/NcT10aVh/SC0cyEykgGbNgCNHtI6CrON5QkOBwMCmfS+29CiH9YfUwpYeInIbanVtAWzpIXJFTHqIyG2oMYjZKjpa7tlCQeQ6mPQQKaCsDEhJkRsHYmpHjenqVtbZW6dOAefONf37uTPWH1ILx/QQKcBsBr76qvqYtKFm91ZIiNwKC2VrT7duTf+e7or1h9TSqJaehQsXokOHDjAajYiPj8e2bdsuWD49PR2dO3eG0WhE9+7dsWbNGrvHhRCYOXMmIiIi4Ofnh6SkJBw6dMiuTEFBAUaNGoWgoCCEhIRg7NixOFfjz6sjR45Ap9PV2rZu3dqYj0jkEF9fYPFiufn6ah2N51KzewtgF5dSWH9ILQ4nPStWrMC0adMwa9Ys7Nq1Cz169EBycjLy8/PrLL9lyxaMHDkSY8eOxe7du5GSkoKUlBTs27fPVmbOnDlYsGABFi1ahKysLPj7+yM5ORllNdo5R40ahf379yMjIwOrVq3Cpk2bMGHChFrv9/333+Off/6xbb1793b0IxI5zMcHGD9ebj4+WkfjmaqqgGPH5LEaLT2AXJkZYNJzqVh/SDXCQXFxcWLSpEm2f5vNZhEZGSnS0tLqLD98+HAxZMgQu3Px8fFi4sSJQgghLBaLCA8PF3PnzrU9XlhYKAwGg/jkk0+EEEIcOHBAABDbt2+3lVm7dq3Q6XQiJydHCCFEdna2ACB2797t6EeyMZlMAoAwmUyNfg0i0kZ2thCAEL6+QpjN6rznww/L95w2TZ33I6K6NfT726GWnoqKCuzcuRNJSUm2c3q9HklJScjMzKzzOZmZmXblASA5OdlWPjs7G7m5uXZlgoODER8fbyuTmZmJkJAQxMbG2sokJSVBr9cjKyvL7rVvvfVWhIaGon///vj6668v+HnKy8tRVFRktxE1hsUC7N8vN4tF62g809Gjct+unbwvlhrYvaUM1h9Si0P/NZw6dQpmsxlhYWF258PCwpBbz133cnNzL1jeur9YmdDQULvHvb290aJFC1uZgIAAvPLKK0hPT8fq1avRv39/pKSkXDDxSUtLQ3BwsG2Lioq62CUgqlNpqRzI2q2bPCb1WRMPa5eTGti9pQzWH1KL28zeatWqFaZNm2b7d58+fXDixAnMnTsXt956a53PmT59ut1zioqKmPhQo7VqpXUEns3a0mOdSq4Ga0tPdrZ67+muWH9IDQ619LRq1QpeXl7Iy8uzO5+Xl4fw8PA6nxMeHn7B8tb9xcqcP1C6qqoKBQUF9b4vAMTHx+PwBdaINxgMCAoKstuIGsPfHzh5Um7+/lpH45m0SHqs73XmjLzvFzUO6w+pxaGkx9fXF71798b69ett5ywWC9avX4+EhIQ6n5OQkGBXHgAyMjJs5aOjoxEeHm5XpqioCFlZWbYyCQkJKCwsxM6dO21lNmzYAIvFgvj4+Hrj3bNnDyIiIhz5iETkorTo3goMBFq2lMfWpIuInJfD3VvTpk3D6NGjERsbi7i4OMyfPx/FxcVITU0FANx3331o06YN0tLSAABTpkxBYmIiXnnlFQwZMgTLly/Hjh07sHjxYgCATqfD1KlTMXv2bMTExCA6OhozZsxAZGQkUlJSAABdunTB4MGDMX78eCxatAiVlZWYPHkyRowYgcjISADA+++/D19fX/Tq1QsA8MUXX+C9997DO++8c8kXiYicnxYtPYDs4jp9WnZxXXWVuu9NRI5xOOm56667cPLkScycORO5ubno2bMn1q1bZxuI/Pfff0NfY+pE37598fHHH+Ppp5/Gk08+iZiYGKxcuRLdaixf+vjjj6O4uBgTJkxAYWEh+vfvj3Xr1sFoNNrKLFu2DJMnT8agQYOg1+txxx13YMGCBXaxPf/88zh69Ci8vb3RuXNnrFixAnfeeafDF4XIUWVlwNix8vjdd4Eav7qkAosF+Ptveax20tOhA7BjBwczXwrWH1KLTgghtA7CWRQVFSE4OBgmk4nje8ghxcVAQIA8PneO4xLUlpMDtG0LeHnJL1BvFadoPPYYMG8eMHUq8Npr6r2vO2H9oUvV0O9vt5m9RaQlX9/qLzwuo68+a9dW27bqJjwAZ3ApgfWH1MKkh0gBPj7yL33ShrVrSe2uLYBr9SiB9YfUotK6pURETcfa0qPmzC0rrspM5DqY9BApwGKRX3pHjnAZfS1oNXOr5nuaTEBhofrv7w5Yf0gt7N4iUkBpafVf/ByIqT4t1uixatZMriZ86pS8y3tIiPoxuDrWH1ILW3qIFNKsmdxIfVq29ADyJqdA9bR5chzrD6mBSQ+RAvz95bTb4mL+lao2IbRPeqy37GPS0zisP6QWJj1E5NJOnpTdIzpddfKhNrb0ELkGJj1E5NKsrTwREYDBoE0MTHqIXAOTHiIFlJcD48fLrbxc62g8i9ZdWwCTnkvF+kNqYdJDpICqKuCdd+RWVaV1NJ5Fy5lbVkx6Lg3rD6mFU9aJFODjA8yeXX1M6nGmlp6cHPmlrfatMFwd6w+phVWTSAG+vsBTT2kdhWdyhqQnPFx+WVdWAv/8o92AalfF+kNqYfcWEbm0Y8fk3traogW9Xt7stGY8ROR8mPQQKUAIOXX65El5TOqxJhlat65wrZ7GY/0htbB7i0gBJSVAaKg85jL66ikpAU6flsfWlhatcDBz47H+kFrY0kNELisnR+79/bW/5xWTHiLnx5YeIgX4+7NZXgs1u7Z0Om1jYdLTeKw/pBa29BCRy7ImPVp3bQFMeohcAZMeInJZx4/LvdaDmAEmPUSugEkPkQLKy4GpU+XGZfTV4ywzt2rGcOYMcPastrG4GtYfUguTHiIFVFUB//2v3LiMvnqcqXsrKAgIDpbHXKvHMaw/pBYOZCZSgI8P8OST1cekDmfq3gJkF9evv8qk58ortY7GdbD+kFqY9BApwNcXeOEFraPwPM7UvQVUJz0c1+MY1h9SC7u3iMglFRfL8TOAc3RvARzMTOTs2NJDpAAh5KqyANCsmfZrxngCa9dWYGD1WBqtMelpHNYfUgtbeogUUFICBATIzfqfNzUtZ+vaApj0NBbrD6mFSQ8RuSRnmrllZU16jh7VNg4iqhu7t4gU0KyZvFGi9ZianrPN3AKqY8nJASwWQM8/KxuE9YfUwqSHSAE6He8MrTZn7N6KiJC/CxUVwKlT1XcOpwtj/SG18O8QInJJzti95esLhIXJY2tLFBE5DyY9RAqoqACeekpuFRVaR+MZnLF7C6iOh6syNxzrD6mFSQ+RAiorgRdflFtlpdbReAZn7N4Cqlue2NLTcKw/pBaO6SFSgLc3MGVK9TE1rbNnAZNJHjtT9xbApKcxWH9ILfz1IlKAwQDMn691FJ7DmlAEB8vFCZ0Ju7ccx/pDamH3FhG5HGft2gLY0kPkzJj0EJHLccaZW1ZMeoicF5MeIgUUF8u1RnQ6eUxNy1lnbgHVMR0/Lu8pRRfH+kNqYdJDRC7Hmbu3IiPlvrxcLlBIRM6DSQ+RApo1A/Lz5cZl9JueM3dvcYFCx7H+kFqY9BApQKcDWreWm06ndTTuz5m7twDO4HIU6w+phUkPEbkcZ+7eAjiYmchZcZ0eIgVUVABz58rjxx6TXRzUNEwmuTgh4JzdWwCTHkex/pBaGtXSs3DhQnTo0AFGoxHx8fHYtm3bBcunp6ejc+fOMBqN6N69O9asWWP3uBACM2fOREREBPz8/JCUlIRDhw7ZlSkoKMCoUaMQFBSEkJAQjB07FufOnavz/Q4fPozAwECEhIQ05uMROayyEnj6ablxGf2mZU0kmjd33jtzs3vLMaw/pBaHk54VK1Zg2rRpmDVrFnbt2oUePXogOTkZ+fn5dZbfsmULRo4cibFjx2L37t1ISUlBSkoK9u3bZyszZ84cLFiwAIsWLUJWVhb8/f2RnJyMsrIyW5lRo0Zh//79yMjIwKpVq7Bp0yZMmDCh1vtVVlZi5MiRGDBggKMfjajRvL2BcePkxmX0m5azd20BbOlxFOsPqUY4KC4uTkyaNMn2b7PZLCIjI0VaWlqd5YcPHy6GDBlidy4+Pl5MnDhRCCGExWIR4eHhYu7cubbHCwsLhcFgEJ988okQQogDBw4IAGL79u22MmvXrhU6nU7k5OTYvfbjjz8u7rnnHrFkyRIRHBzs0GczmUwCgDCZTA49j4jUs3ixEIAQN92kdST1+/FHGePll2sdCZFnaOj3t0MtPRUVFdi5cyeSkpJs5/R6PZKSkpCZmVnnczIzM+3KA0BycrKtfHZ2NnJzc+3KBAcHIz4+3lYmMzMTISEhiI2NtZVJSkqCXq9HVlaW7dyGDRuQnp6OhQsXNujzlJeXo6ioyG4jIufm7DO3AC5QSOSsHEp6Tp06BbPZjDDrIhT/JywsDLm5uXU+Jzc394LlrfuLlQkNDbV73NvbGy1atLCVOX36NMaMGYOlS5ciKCioQZ8nLS0NwcHBti3Kmf8XJSIArtG9ZV2gsKwMOH1a21iIqJrbTFkfP3487r77blxzzTUNfs706dNhMpls2zGOOqRGKi6Wg2r9/bmMflNz5oUJrQwGwPp3Gsf1XBzrD6nFoaSnVatW8PLyQl5ent35vLw8hIeH1/mc8PDwC5a37i9W5vyB0lVVVSgoKLCV2bBhA+bNmwdvb294e3tj7NixMJlM8Pb2xnvvvVdnbAaDAUFBQXYbUWOVlMiNmpYrdG8BnMHlKNYfUoNDSY+vry969+6N9evX285ZLBasX78eCQkJdT4nISHBrjwAZGRk2MpHR0cjPDzcrkxRURGysrJsZRISElBYWIidO3faymzYsAEWiwXx8fEA5LifPXv22LbnnnsOgYGB2LNnD2677TZHPiaRw/z8gOxsufn5aR2N+xLCNbq3AM7gcgTrD6nF4cmB06ZNw+jRoxEbG4u4uDjMnz8fxcXFSE1NBQDcd999aNOmDdLS0gAAU6ZMQWJiIl555RUMGTIEy5cvx44dO7B48WIAgE6nw9SpUzF79mzExMQgOjoaM2bMQGRkJFJSUgAAXbp0weDBgzF+/HgsWrQIlZWVmDx5MkaMGIHI/+s879Kli12cO3bsgF6vR7du3Rp9cYgaSq8HOnTQOgr3V1hY3f3Rpo2moVwUk56GY/0htTic9Nx11104efIkZs6cidzcXPTs2RPr1q2zDUT++++/oddXNyD17dsXH3/8MZ5++mk8+eSTiImJwcqVK+2SkccffxzFxcWYMGECCgsL0b9/f6xbtw5Go9FWZtmyZZg8eTIGDRoEvV6PO+64AwsWLLiUz05ELsaaQLRs6fw3pmT3FpHz0QnBCZVWRUVFCA4Ohslk4vgeckhlJWBdKWHSJMDHR9t43NWaNcCQIUDPnsDu3VpHc2HLlgH33AMMHAhs2KB1NM6N9YcuVUO/v7n2JZECKiqAhx+Wx+PH8z/tpuIKM7es2L3VcKw/pBYmPUQK8PIC7r67+piahqvM3ALsu7eEAHQ6beNxZqw/pBYmPUQKMBpldwY1LVeZuQXYL1BYUCDHIVHdWH9ILW6zOCERuT9X6t4yGoHWreUxu7iInAOTHiJyGa7UvQVwBheRs2HSQ6SA4mL5V33r1lxGv6m40sKEVhzM3DCsP6QWjukhUsipU1pH4N7OnAFKS+Wxsy9MaMWkp+FYf0gNTHqIFODnB+zbV31MyrO28rRuLcfLuAJ2bzUM6w+phUkPkQL0eqBrV62jcG+u1rUFsKWnoVh/SC0c00NELsGaOLjCzC0rJj1EzoUtPUQKqKwEli6Vx2PGcEXZpuCKLT1coLBhWH9ILUx6iBRQUQFMmCCP776b/2k3BVdMeqwDrktL5UDsFi20jcdZsf6QWpj0ECnAywsYOrT6mJTnit1bRiPQqpWcmXT8OJOe+rD+kFqY9BApwGgEVq7UOgr35kqrMdcUFSWTnmPHgKuu0joa58T6Q2rhQGYicnpCuN5qzFYczEzkPJj0EJHTO31a3rgTcJ2FCa2sSRqTHiLtMekhUkBJCdChg9xKSrSOxv1Yu7bCwgCDQdtYHGVt6eEChfVj/SG1cEwPkQKEAI4erT4mZbniIGYrdm9dHOsPqYVJD5ECjEZg27bqY1KWK05Xt2L31sWx/pBamPQQKcDLC+jTR+so3JerztwC7Lu3uEBh3Vh/SC0c00NETs9VZ24B1UlPSYlcoJCItMOkh0gBVVXAsmVyq6rSOhr348rdW0ajvDM8wMHM9WH9IbUw6SFSQHk5cM89cisv1zoa9+PKA5kBzuC6GNYfUgvH9BApQK8HkpKqj0k5rrwwoVVUFLB7N5Oe+rD+kFqY9BApwM8PyMjQOgr3dOqU/OtfpwMiI7WOpnFq3m2damP9IbUwpyYip1ZzYUJfX21jaSwmPUTOgUkPETk1Vx7EbMWkh8g5MOkhUkBJCdC1q9y4jL6yXH0QM8Ck52JYf0gtHNNDpAAhgAMHqo9JOe7U0nP8OGCxcLDu+Vh/SC1MeogUYDQCGzdWH5NyXH3mFiDvDK/TARUVcmB2aKjWETkX1h9SC5MeIgV4eQHXXqt1FO7JlW9BYeXjA4SHA//8Iz8Pkx57rD+kFjayEpFTc4fuLYDjeoicAZMeIgVUVQErV8qNy+grx2IBcnLksSu39ABclflCWH9ILezeIlJAeTlw223y+Nw5wJs1SxEnT8pxMK68MKEVW3rqx/pDauGvFpEC9Hqgb9/qY1KGdRBzRIQcF+PKmPTUj/WH1MKkh0gBfn7A5s1aR+F+3GEQsxWTnvqx/pBamFMTkdNyh+nqVkx6iLTHpIeInJY7tvTk5ABms7axEHkqJj1ECigtBfr0kVtpqdbRuA93ma4OyHFJXl4y4cnN1Toa58L6Q2rhmB4iBVgswI4d1cekDHfq3vLykjPQjh2TW5s2WkfkPFh/SC1MeogUYDAAq1ZVH5My3Kl7C5DJ27Fj1ckcSaw/pBYmPUQK8PYGhgzROgr3UnNhQndo6QE4mLk+rD+kFo7pISKnlJ8PVFbKdVsiIrSORhlMeoi0xZYeIgWYzcCGDfL4uuvk+A26NNbEICLCfVbo5a0o6sb6Q2ppVEvPwoUL0aFDBxiNRsTHx2Pbtm0XLJ+eno7OnTvDaDSie/fuWLNmjd3jQgjMnDkTERER8PPzQ1JSEg4dOmRXpqCgAKNGjUJQUBBCQkIwduxYnDt3zvb4wYMHMXDgQISFhcFoNOKyyy7D008/jcrKysZ8RCKHlJUBN9wgt7IyraNxD+40iNmKLT11Y/0htTic9KxYsQLTpk3DrFmzsGvXLvTo0QPJycnIz8+vs/yWLVswcuRIjB07Frt370ZKSgpSUlKwb98+W5k5c+ZgwYIFWLRoEbKysuDv74/k5GSU1fjtHzVqFPbv34+MjAysWrUKmzZtwoQJE2yP+/j44L777sN3332HgwcPYv78+Xj77bcxa9YsRz8ikcP0eqBHD7lxGX1luNsgZoBJT31Yf0g1wkFxcXFi0qRJtn+bzWYRGRkp0tLS6iw/fPhwMWTIELtz8fHxYuLEiUIIISwWiwgPDxdz5861PV5YWCgMBoP45JNPhBBCHDhwQAAQ27dvt5VZu3at0Ol0Iicnp95YH374YdG/f/8GfzaTySQACJPJ1ODnEFHTeOwxIQAhHn5Y60iU888/8jPpdEJUVGgdDZH7aOj3t0M5dUVFBXbu3ImkpCTbOb1ej6SkJGRmZtb5nMzMTLvyAJCcnGwrn52djdzcXLsywcHBiI+Pt5XJzMxESEgIYmNjbWWSkpKg1+uRlZVV5/sePnwY69atQ2JiYr2fp7y8HEVFRXYbETkHd2zpCQ2VN04VAjhxQutoiDyPQ0nPqVOnYDabERYWZnc+LCwMufUsMZqbm3vB8tb9xcqEhobaPe7t7Y0WLVrUet++ffvCaDQiJiYGAwYMwHPPPVfv50lLS0NwcLBti3KnwQNELs4dx/To9RzMTKQlt+s9XbFiBXbt2oWPP/4Yq1evxrx58+otO336dJhMJtt2jP8LUSOVlgLXXis3LqOvDHe6BUVNHNdTG+sPqcWhiaCtWrWCl5cX8vLy7M7n5eUhPDy8zueEh4dfsLx1n5eXh4gai3Hk5eWhZ8+etjLnD5SuqqpCQUFBrfe1ttZceeWVMJvNmDBhAh555BF41TEH0mAwwMDlP0kBFgvw44/Vx3Rpai5M6E7dWwCTnrqw/pBaHGrp8fX1Re/evbF+/XrbOYvFgvXr1yMhIaHO5yQkJNiVB4CMjAxb+ejoaISHh9uVKSoqQlZWlq1MQkICCgsLsXPnTluZDRs2wGKxID4+vt54LRYLKisrYWEtoiZmMACffio35tGX7p9/gKoquV6LuyxMaMWkpzbWH1KLw0t+TZs2DaNHj0ZsbCzi4uIwf/58FBcXIzU1FQBw3333oU2bNkhLSwMATJkyBYmJiXjllVcwZMgQLF++HDt27MDixYsBADqdDlOnTsXs2bMRExOD6OhozJgxA5GRkUhJSQEAdOnSBYMHD8b48eOxaNEiVFZWYvLkyRgxYgQiIyMBAMuWLYOPjw+6d+8Og8GAHTt2YPr06bjrrrvg4+OjxLUiqpe3NzBsmNZRuI+//5b7tm3db6E6a9LD+29VY/0htTic9Nx11104efIkZs6cidzcXPTs2RPr1q2zDUT++++/oa+x0ELfvn3x8ccf4+mnn8aTTz6JmJgYrFy5Et26dbOVefzxx1FcXIwJEyagsLAQ/fv3x7p162A0Gm1lli1bhsmTJ2PQoEHQ6/W44447sGDBguoP4u2Nl19+GX/88QeEEGjfvj0mT56Mhx9+uFEXhoi0Y0162rfXNo6mwIHMRNrRCSGE1kE4i6KiIgQHB8NkMiEoKEjrcMiFmM3A1q3y+F//cr/WCbXNnQs8/jhwzz3Ahx9qHY2ydu8Grr5aTl8/b7ijx2L9oUvV0O9vN7mjDZG2ysqA/v3l8blzgL+/tvG4uqNH5b5dO23jaArW7q38fKC8nGNYANYfUg+THiIF6HTA5ZdXH9OlsXZvuWPS07IlYDTKL/rjx4GOHbWOSHusP6QWJj1ECmjWDDjvHrl0Cdx5TI9OJ1t7Dh2S43qY9LD+kHrcbnFCInJ97ty9BXDaOpFWmPQQkVMpKgIKC+Uxkx4iUhKTHiIFlJUBQ4bIraxM62hcmzURaNECCAjQNpamYk16rN14no71h9TCMT1ECjCbgTVrqo+p8dy9awuoHqtk/ayejvWH1MKkh0gBvr7AkiXVx9R47jxzy6pDB7ln0iOx/pBamPQQKcDHBxgzRuso3IMnJD01W3qE4DRt1h9SC8f0EJFTsbZ+uON0dSvrmJ6SEuD0aW1jIfIkTHqIFGA2A3v2yI1jEi6NJ7T0GI1AeLg8ZhcX6w+ph0kPkQLKyoBeveTG2SeXxhOSHoCDmWti/SG1MOkhUoBOB0RGys3Tx2dciqoqICdHHrtz9xbApKcm1h9SCwcyEymgWbPqL2tqvBMnZPeGjw8QFqZ1NE3LmvQcOaJpGE6B9YfUwpYeInIa1q6tqChA7+b/O7Glh0h9bv7fChG5Ek8ZzwNwrR4iLTDpIVJAWRkwbJjcOBCz8TxhuroVW3qqsf6QWpj0ECnAbAY++0xunHLbeJ7U0mNNes6cAc6e1TYWrbH+kFo4kJlIAb6+wBtvVB9T43hS0hMYCDRvLpOeo0eBbt20jkg7rD+kFiY9RArw8QEmTdI6CtfnSd1bgPycTHpYf0g97N4iIqcghGfcYb0mjushUhdbeogUYLEAf/4pjzt2dP/p1k2hsBA4d04eW+9N5e64Vo/E+kNqYdJDpIDSUqBTJ3l87hzg769tPK4oO1vuw8LkYnWegC09EusPqYVJD5FCgoO1jsC1WZOe6Ght41AT1+qpxvpDamDSQ6QAf3/ZPUONZ+3isSYCnoAtPRLrD6mFPadE5BQ8saXHmvTk5nJRPiI1MOkhIqdgbenxpKSnZcvq8UvHjmkbC5EnYNJDpIDycmDMGLmVl2sdjWuytvR4UveWTscuLoD1h9TDpIdIAVVVwPvvy62qSutoXI8QntnSAzDpAVh/SD0cyEykAB8fYM6c6mNyzMmTQEmJbPnwlIUJrZj0sP6Qepj0ECnA1xd47DGto3Bd1q6tNm08795L1u48T16gkPWH1MLuLSLSnCfO3LKyfmbrNSCipsOWHiIFWCzAP//I44gILqPvKE9co8fqssvk/q+/tI1DS6w/pBYmPUQKKC0F2raVx1xG33Ge3NJjTXpOnJC/R35+2sajBdYfUgvzaSKFeHvLjRznqTO3AKBFCyAoSB578rge1h9SA5MeIgX4+wOVlXLjX6mO88Q1eqx0OnZxsf6QWpj0EJGmLJbq6dqe2NIDMOkhUguTHiLS1D//ABUVsmujTRuto9EGkx4idTDpIVJAeTkwaZLcuIy+Y6xdW1FRnjumw9OTHtYfUguTHiIFVFUBb74pNy6j7xhPHsRs5elJD+sPqcVD/64iUpaPDzBrVvUxNZwnT1e3qpn0CCEHN3sS1h9SC5MeIgX4+gLPPKN1FK7Jk2duWbVvLxOdkhIgPx8IC9M6InWx/pBa2L1FRJr680+579hR2zi05OsrxzQBntvFRaQGJj1EChACKCyUmxBaR+NaDh+W+8sv1zYOrXnyPbhYf0gtjUp6Fi5ciA4dOsBoNCI+Ph7btm27YPn09HR07twZRqMR3bt3x5o1a+weF0Jg5syZiIiIgJ+fH5KSknDo0CG7MgUFBRg1ahSCgoIQEhKCsWPH4ty5c7bHf/jhBwwdOhQRERHw9/dHz549sWzZssZ8PCKHlZQAzZvLraRE62hcR0mJvP0C4NktPYBnD2Zm/SG1OJz0rFixAtOmTcOsWbOwa9cu9OjRA8nJycjPz6+z/JYtWzBy5EiMHTsWu3fvRkpKClJSUrBv3z5bmTlz5mDBggVYtGgRsrKy4O/vj+TkZJSVldnKjBo1Cvv370dGRgZWrVqFTZs2YcKECXbvc9VVV+Hzzz/HL7/8gtTUVNx3331YtWqVox+RiFRi/YJv3lzejsGTeXLSQ6Qa4aC4uDgxadIk27/NZrOIjIwUaWlpdZYfPny4GDJkiN25+Ph4MXHiRCGEEBaLRYSHh4u5c+faHi8sLBQGg0F88sknQgghDhw4IACI7du328qsXbtW6HQ6kZOTU2+sN910k0hNTa338bKyMmEymWzbsWPHBABhMpkucAWIarNYhKiokJvFonU0ruPLL4UAhIiN1ToS7S1bJq9FYqLWkaiP9YculclkatD3t0MtPRUVFdi5cyeSkpJs5/R6PZKSkpCZmVnnczIzM+3KA0BycrKtfHZ2NnJzc+3KBAcHIz4+3lYmMzMTISEhiI2NtZVJSkqCXq9HVlZWvfGaTCa0uMCfj2lpaQgODrZtUdaRhEQO0unkVFsfH8+bbnwprIOYPX08D+DZLT2sP6QWh5KeU6dOwWw2I+y8+ZRhYWHIzc2t8zm5ubkXLG/dX6xMaGio3ePe3t5o0aJFve/76aefYvv27UhNTa3380yfPh0mk8m2HTt2rN6yRKQ8DmKuZk16jh/nqsRETcUt1+nZuHEjUlNT8fbbb6Nr1671ljMYDDAYDCpGRu6qogJ46il5/MILcgoyXRynq1dr3VreYby4WN6AtVMnrSNSD+sPqcWhlp5WrVrBy8sLeXl5dufz8vIQHh5e53PCw8MvWN66v1iZ8wdKV1VVoaCgoNb7/vjjj7jlllvw2muv4b777nPk4xE1WmUlMG+e3CortY7GdbClp5pOV93aY70unoL1h9TiUNLj6+uL3r17Y/369bZzFosF69evR0JCQp3PSUhIsCsPABkZGbby0dHRCA8PtytTVFSErKwsW5mEhAQUFhZi586dtjIbNmyAxWJBfHy87dwPP/yAIUOG4OWXX7ab2UXU1Hx8gEcflRuX0W+YigrZogGwpccqJkbuz1uxw+2x/pBqHB0hvXz5cmEwGMTSpUvFgQMHxIQJE0RISIjIzc0VQghx7733iieeeMJWfvPmzcLb21vMmzdP/Pbbb2LWrFnCx8dH/Prrr7YyL730kggJCRFfffWV+OWXX8TQoUNFdHS0KC0ttZUZPHiw6NWrl8jKyhI///yziImJESNHjrQ9vmHDBtGsWTMxffp08c8//9i206dPN/izNXT0NxFduj/+kLOVmjXjjB2r//xHXpMaE2SJqAEa+v3tcNIjhBCvv/66aNeunfD19RVxcXFi69attscSExPF6NGj7cp/+umnolOnTsLX11d07dpVrF692u5xi8UiZsyYIcLCwoTBYBCDBg0SBw8etCtz+vRpMXLkSBEQECCCgoJEamqqOHv2rO3x0aNHCwC1tkQH5n8y6SFSz9q18gu+e3etI3Ee774rr8kNN2gdCZFraej3t04ILvptVVRUhODgYJhMJgQFBWkdDrkQIYCqKnns7c1ptw3xxhvAgw8Ct90GfPGF1tE4h59+Aq65Rt6SwpOmrrP+0KVq6Pc3771FpICSEjnjxNeXy+g3FGdu1WYd03P0qGdNW2f9IbUw6SEiTXDmVm1hYUBgIGCxeFZLD5FamPQQKaBZM+DMGbk1a6Z1NK7BmvSwpaeaTueZM7hYf0gtTHqIFKDTASEhcuN4hIszm4HsbHnMlh571qTnjz+0jUNNrD+kFiY9RKQ665gVgwHgLe/sWVdi9qSWHiK1uOVtKIjUVlEBvPiiPH7ySS6jfzEHD8p9TAzg5aVtLM7GE7u3WH9ILUx6iBRQWQk8+6w8fuwx/qd9Mdak54ortI3DGXli9xbrD6mFSQ+RAry9gQceqD6mC2PSUz9r91ZOjpy+7QkDe1l/SC389SJSgMEALFyodRSuw5r0dO6sbRzOqEULuRUUyBluV12ldURNj/WH1MKBzESkOrb0XJgndnERqYFJDxGp6uxZ4MQJecykp26eOJiZSA1MeogUUFwM+PjIrbhY62icm7WVJywMCA7WNhZnZR3X4yktPaw/pBaO6SFSiPWGiXRh7Nq6OOtYp99+0zYONbH+kBqY9BApwM8POH68+pjqx6Tn4rp0kfvffpN3IHf3VYpZf0gtTHqIFKDXA23aaB2Fa2DSc3HWRRuLioB//gEiI7WOqGmx/pBaOKaHiFTFpOfiDIbqG7F6UhcXUVNj0kOkgIoKYO5cuVVUaB2N87JYqgfnMum5MGsX14ED2sahBtYfUguTHiIFVFYCjz8ut8pKraNxXsePA6WlcpZOdLTW0Ti3K6+Ue09o6WH9IbVwTA+RAry9gdGjq4+pbvv3y32nTrxOF1NzMLO7Y/0htfDXi0gBBgOwdKnWUTg/a9LTtau2cbgCT+reYv0htbB7i4hUw6Sn4axr9eTny/twEdGlY9JDRKph0tNwAQFAu3by2BO6uIjUwKSHSAHFxUBIiNy4jH7dLJbqrhomPQ3jKV1crD+kFiY9RAoxmeRGdTt6VH6h+foCl1+udTSuwZNmcLH+kBo4kJlIAX5+1evPcBn9ulm7tq64gjN0GspTZnCx/pBa+F8PkQL0ennrAKqfNenp1k3bOFyJtaVn3z5t42hqrD+kFnZvEZEqOIjZcdYE8fhx4MwZbWMhcgdMeogUUFkJLFwoN64oWzcmPY4LDgY6dJDHv/6qaShNivWH1MKkh0gBFRXA5Mly472DajObOXOrsa66Su737tU2jqbE+kNq4ZgeIgV4eQF33ll9TPays4GyMsBoBC67TOtoXMtVVwFffw388ovWkTQd1h9SC5MeIgUYjUB6utZROC/rF3aXLvxSc5S1pcedkx7WH1ILu7eIqMnt2SP3vXppGoZLsiY9+/bJbkIiajwmPUTU5KxJT8+eWkbhmi6/XK5dU1IC/PWX1tEQuTYmPUQKKCkB2rSRW0mJ1tE4H7b0NJ6XV/XUdXcdzMz6Q2ph0kOkACGAEyfkJoTW0TiX06eBY8fksbWrhhzj7uN6WH9ILRzITKQAoxHYvbv6mKpZW3k6dgSCgjQNxWW5e9LD+kNqYdJDpAAvL45XqQ/H81w6d1+rh/WH1MLuLSJqUkx6Lp016TlyhLejILoUTHqIFFBZCSxdKjcuo2+PSc+la9GielHHnTu1jaUpsP6QWpj0ECmgogJITZUbl9GvVlYG/PabPObMrUsTGyv3O3ZoG0dTYP0htXBMD5ECvLyAm26qPibp11/lgnotWwKRkVpH49piY4FPP3XPpIf1h9TCpIdIAUYjsHq11lE4n+3b5b5PH0Cn0zYWV2dt6XHH7i3WH1ILu7eIqMls2yb3cXHaxuEOrr5a7o8cAU6d0jQUIpfVqKRn4cKF6NChA4xGI+Lj47HN+j9bPdLT09G5c2cYjUZ0794da9assXtcCIGZM2ciIiICfn5+SEpKwqFDh+zKFBQUYNSoUQgKCkJISAjGjh2Lc+fO2R4vKyvDmDFj0L17d3h7eyMlJaUxH42IFMSkRznBwUCnTvLYHVt7iNTgcNKzYsUKTJs2DbNmzcKuXbvQo0cPJCcnIz8/v87yW7ZswciRIzF27Fjs3r0bKSkpSElJwb59+2xl5syZgwULFmDRokXIysqCv78/kpOTUVZWZiszatQo7N+/HxkZGVi1ahU2bdqECRMm2B43m83w8/PDQw89hKSkJEc/FtElKSkBYmLkxmX0paIi4Pff5XGfPtrG4i7cdTAz6w+pRjgoLi5OTJo0yfZvs9ksIiMjRVpaWp3lhw8fLoYMGWJ3Lj4+XkycOFEIIYTFYhHh4eFi7ty5tscLCwuFwWAQn3zyiRBCiAMHDggAYvv27bYya9euFTqdTuTk5NR6z9GjR4uhQ4c6+tGEyWQSAITJZHL4ueTZzp0TQi6gL49JiA0b5PXo0EHrSNzHq6/Ka5qSonUkymL9oUvV0O9vh1p6KioqsHPnTruWFL1ej6SkJGRmZtb5nMzMzFotL8nJybby2dnZyM3NtSsTHByM+Ph4W5nMzEyEhIQg1vpnDoCkpCTo9XpkZWU58hHslJeXo6ioyG4jagyjEfj5Z7lxGX2JXVvKs/4XaB0g7i5Yf0gtDiU9p06dgtlsRlhYmN35sLAw5Obm1vmc3NzcC5a37i9WJjQ01O5xb29vtGjRot73bYi0tDQEBwfbtqioqEa/Fnk2Ly+gXz+5ccqtZE162LWlnKuvlr9fOTnVN3F1B6w/pBaPnr01ffp0mEwm23bMnf4XIdIYW3qU5+8P9Oghj7ds0TYWIlfkUNLTqlUreHl5IS8vz+58Xl4ewsPD63xOeHj4Bctb9xcrc/5A6aqqKhQUFNT7vg1hMBgQFBRktxE1RlUVkJ4ut6oqraPR3okTwPHjgF5fPdWalNGvn9y7U9LD+kNqcSjp8fX1Re/evbF+/XrbOYvFgvXr1yMhIaHO5yQkJNiVB4CMjAxb+ejoaISHh9uVKSoqQlZWlq1MQkICCgsLsbPGPM0NGzbAYrEgPj7ekY9A1CTKy4Hhw+VWXq51NNr7+We579EDCAjQNhZ307ev3G/erG0cSmL9IbU4vCLztGnTMHr0aMTGxiIuLg7z589HcXExUlNTAQD33Xcf2rRpg7S0NADAlClTkJiYiFdeeQVDhgzB8uXLsWPHDixevBgAoNPpMHXqVMyePRsxMTGIjo7GjBkzEBkZaVtrp0uXLhg8eDDGjx+PRYsWobKyEpMnT8aIESMQWWNt+wMHDqCiogIFBQU4e/Ys9vzfnQ578k6H1MT0eiAxsfrY0/30k9wPGKBtHO7I2tKzZw9QXCy7vFwd6w+ppjFTw15//XXRrl074evrK+Li4sTWrVttjyUmJorRo0fblf/0009Fp06dhK+vr+jatatYvXq13eMWi0XMmDFDhIWFCYPBIAYNGiQOHjxoV+b06dNi5MiRIiAgQAQFBYnU1FRx9uxZuzLt27cXAGptDcUp60TK6NFDTj/+9FOtI3FPbdvK67thg9aREDmHhn5/64QQQsOcy6kUFRUhODgYJpOJ43uIGslkApo3l6uunDgBRERoHZH7GTECWLECeP554OmntY6GSHsN/f5mQyIRKWrLFpnwdOzIhKepuONgZiI1MOkhUkBpKdCzp9xKS7WORlvWQcwcz9N0ag5mdofZTqw/pBaHBzITUW0WC7B3b/WxJ7MOYu7fX9s43FnPnkBICFBYCOza5fprIbH+kFqY9BApwGgEvvuu+thTlZQA1jvDsKWn6Xh5AddeC6xcCWzY4PpJD+sPqYXdW0QK8PICrr9ebp68jP7PPwMVFUBUlLxjNjWd666T+/OWQXNJrD+kFiY9RKSYjAy5T0oCdDptY3F3gwbJ/c8/c0E/ooZi0kOkgKoqYPVqubnDwNLGsiY911+vbRyeoEsXIDwcKCsDMjO1jubSsP6QWpj0ECmgvBy4+Wa5eepf3fn51YNRra0Q1HR0uuourg0btI3lUrH+kFqY9BApQK8HYmPl5qnL6FvHlvToAYSGahuLp7AmPdYWNlfF+kNq4ewtIgX4+QHbt2sdhbZqjuchdQweLPdZWcDJk0Dr1trG01isP6QW5tREdMksFmDNGnls/SKmptemjVyzRwhg7VqtoyFyfkx6iOiSbd8O5OUBQUHANddoHY1nuflmuV+1Sts4iFwBkx4iBZSWyvsh9evnmcvof/213A8eDPj6ahuLp7EmPd9+C1RWahtLY3l6/SH1cEwPkQIsluqbP3riMvrffCP3t96qbRyeqE8fOZbn5Em5Zs/AgVpH5DhPrz+kHiY9RAowGIAvv6w+9iRHjgC//ipX0r3xRq2j8Tx6PXDTTcD778sWN1dMejy5/pC62L1FpABvbyAlRW7eHvanxMqVct+vH9CihaaheKyUFLlPT3fNlhJPrj+kLiY9RHRJli+X+2HDtI3Dkw0eLAeR5+RUdxMRUW1MeogUYDYDP/wgN7NZ62jUk50t14jR64E779Q6Gs9lNAJDh8rjFSu0jaUxPLX+kPqY9BApoKxMjqUYOFAeewprK8/AgfI+UKSdu+6S+88+c73EwVPrD6mPvadECtDpgCuvrD72FNakZ+RIbeMgeZPXkBAgNxfYtMm1BjR7av0h9bGlh0gBzZoB+/fLrVkzraNRxy+/yM3HB7jtNq2jIV/f6i7GJUu0jcVRnlh/SBtMeoioUd5+W+6HDuWsLWcxbpzcp6cDhYWahkLklJj0EJHDSkqADz+Ux+PHaxsLVYuLA7p1k+NiPvlE62iInA+THiIFlJbKMRXXX+8Zy+h/9hlgMgEdOvCu6s5EpwPGjpXH77yjbSyO8LT6Q9ph0kOkAIsF+P57ubni4nCOeustuR87Vk5XJ+dxzz1yfM+uXUBmptbRNIyn1R/SDmdvESnAYAA++qj62J1t2QJs3Sq/WK1jSMh5tGolE5/33gNeeUW2yjk7T6o/pC2dEEJoHYSzKCoqQnBwMEwmE4KCgrQOh8gp3X67vE/S2LGu1YXiSfbvl2N7dDrg0CGgY0etIyJqWg39/mbDNBE12KFD1ffaeuQRTUOhC+jaVd78VQjg1Ve1jobIeTDpIVKA2Qxs3y43V1sN1xHPPy+/SG++GejSReto6EIefVTu330XOHZM21guxlPqD2mPSQ+RAsrK5HThuDj3XUZ/377qcRfPPKNpKNQAAwcCiYlAeblMVp2ZJ9Qfcg5MeogUoNMB7dvLzV2X0Z8xQ7by3Hkn0Lu31tHQxeh0wAsvyOP33gP++EPbeC7EE+oPOQcmPUQKaNYMOHJEbu64jP769XIsj14PPPec1tFQQ/XrBwwZIruMHnlEJq3OyN3rDzkPJj1EdEHl5cCkSfL4gQc4lsfVzJsn74+2ahXw1VdaR0OkLSY9RHRBL78MHDwIhIUBs2drHQ05qnNn4LHH5PFDDwFFRdrGQ6QlJj1ECigrA1JS5OZOAzG3baseBPvaa0BwsLbxUOM89RQQHS1ncT34oNbR1Oau9YecDxcnrIGLE1JjFRcDAQHy+Nw5wN9f23iUcPYs0KsX8OefwF13yRtYcpCp69q8GbjmGnmbh2XLgLvv1jqiau5Yf0hdDf3+5m0oiBTg6wssXlx97OrMZvml+OefQFSUvNcWEx7X1q8fMHOmXG5g/HjZ7XX11VpHJblb/SHnxZaeGtjSQyRn+EybBsyfDxiNwA8/APHxWkdFSqiqkrO5vvsOiIgAsrJkUkvk6ngbCiJymBDA00/LhAcA3n+fCY878fYGPv1U3qbin3+A665z/tWaiZTEpIdIARaLvMnj/v3y2BWZzbKF58UX5b//+19g+HBtYyLlBQcDq1cDHToAhw/LVZsPHdI2JneoP+QamPQQKaC0VN7Vuls3eexqzpwBbr21uoVnwQI5vZncU/v2wI8/yruvZ2cDffoAa9ZoF4+r1x9yHUx6iBTSqpXcXM3atfLLZs0awM8PWLHCOac1k7LatQN+/lkOcDaZ5FifSZPkrD0tuGr9IdfCpIdIAf7+wMmTcnOV6bb79wO33ALcdBNw4gTQqRPw00/s0vIk4eHAhg3VK26/+aZccXvxYqCyUr04XLH+kGti0kPkQaqqZMvOkCFA9+7y1gReXnIsz549vJGoJ/L1Bd54Q95fLToayMkBJk4EYmKAtDQgN1frCImU06ikZ+HChejQoQOMRiPi4+Oxbdu2C5ZPT09H586dYTQa0b17d6w5r/NYCIGZM2ciIiICfn5+SEpKwqHzRtYVFBRg1KhRCAoKQkhICMaOHYtz587Zlfnll18wYMAAGI1GREVFYc6cOY35eERu5fhxID0dSE2Vf9nfdJPsyhICuOMO2eLzyiuya4s813XXAQcOyAHsoaHA0aPAk08CbdrIRQ3nzQN27lS3BYhIccJBy5cvF76+vuK9994T+/fvF+PHjxchISEiLy+vzvKbN28WXl5eYs6cOeLAgQPi6aefFj4+PuLXX3+1lXnppZdEcHCwWLlypdi7d6+49dZbRXR0tCgtLbWVGTx4sOjRo4fYunWr+Omnn8Tll18uRo4caXvcZDKJsLAwMWrUKLFv3z7xySefCD8/P/G///2vwZ/NZDIJAMJkMjl6WcjDlZYKcffdcqvxa6uK8nIhjh8XYvduIdatE+Ktt4R4+GEhbr5ZiKgoIWR6U721bCkfP3RI3TjJdZSUCLF0qRD/+lft3x+jUYiEBCFSU4V48UUh0tOF2LxZiMOHhSgqEsJicfz9tKw/5B4a+v3t8OKE8fHx6NOnD9544w0AgMViQVRUFB588EE88cQTtcrfddddKC4uxqpVq2zn/vWvf6Fnz55YtGgRhBCIjIzEI488gkcffRQAYDKZEBYWhqVLl2LEiBH47bffcOWVV2L79u2IjY0FAKxbtw433XQTjh8/jsjISLz11lt46qmnkJubC9//W9LziSeewMqVK/H777/X+VnKy8tRXl5u+3dRURGioqIUX5xw1SogI8P+XF1X3dPPOUscjTlXVQV88YU8vu02uR6KUu9hscj7EZWW2m8lJXLJ/ovdQFKvB3r0kH+tp6QA/fvXjo+oPkePAt98I1sHMzOBwsILlzcagcBAOTan5mY0yq5Ub+/qvfVYCODDD+Xz779f3hW+5grgTXFM2rn5ZiApSdnXbJLbUFRUVGDnzp2YPn267Zxer0dSUhIyMzPrfE5mZiamTZtmdy45ORkrV64EAGRnZyM3NxdJNa5AcHAw4uPjkZmZiREjRiAzMxMhISG2hAcAkpKSoNfrkZWVhdtuuw2ZmZm45pprbAmP9X1efvllnDlzBs2bN68VW1paGp599llHLkGjbNkipwCTZ/jyS/Xf08sLaN1abu3by/EYnTrJWw3Exlbf14jIUe3bA5Mny81ikWv67Nol94cOyVuV5OYC+fnyHlplZXI7ebJx7/fee8rGT84nPFz5pKehHEp6Tp06BbPZjLCwMLvzYWFh9bam5Obm1lk+9/9Gx1n3FysTGhpqH7i3N1q0aGFXJjo6utZrWB+rK+mZPn26XUJmbelR2rXXyr+2z1fXXx0NPXepz1f6HONp2tc0GoFmzeS4G+vWrJn8C7p1ayAkpO7fMSIl6fXAFVfIrS7FxTLZOXdOHtfcysrkAphVVfXvrS2dNVs8m+KYtJWQoN17e3Qjt8FggMFgaPL3ueEGuRERuTNrVxaRs3Lob8NWrVrBy8sLeXl5dufz8vIQHh5e53PCw8MvWN66v1iZ/Px8u8erqqpQUFBgV6au16j5HkRNxWIBjhyRG5fRJ3IM6w+pxaGkx9fXF71798b69ett5ywWC9avX4+EetqrEhIS7MoDQEZGhq18dHQ0wsPD7coUFRUhKyvLViYhIQGFhYXYuXOnrcyGDRtgsVgQ/393Q0xISMCmTZtQWWM+ZUZGBq644oo6u7aIlFRaKtc4iY7mMvpEjmL9IdU4Oi1s+fLlwmAwiKVLl4oDBw6ICRMmiJCQEJGbmyuEEOLee+8VTzzxhK385s2bhbe3t5g3b5747bffxKxZs+qcsh4SEiK++uor8csvv4ihQ4fWOWW9V69eIisrS/z8888iJibGbsp6YWGhCAsLE/fee6/Yt2+fWL58uWjWrBmnrJMqzp0TolkzuZ07p3U0RK6F9YcuVUO/vx1OeoQQ4vXXXxft2rUTvr6+Ii4uTmzdutX2WGJiohg9erRd+U8//VR06tRJ+Pr6iq5du4rVq1fbPW6xWMSMGTNEWFiYMBgMYtCgQeLgwYN2ZU6fPi1GjhwpAgICRFBQkEhNTRVnz561K7N3717Rv39/YTAYRJs2bcRLL73k0Odi0kNEROR6mmydHnfW0Hn+RERE5Dwa+v3NSa5ERETkEZj0ECmgvBwYP15uNRb5JqIGYP0htbB7qwZ2b1FjFRdXr3p87hzXKiFyBOsPXaomuQ0FEdXNxweYPbv6mIgajvWH1MKWnhrY0kNEROR6OJCZiIiIqAZ2bxEpQAjg1Cl53KpV/TciJaLaWH9ILUx6iBRQUgKEhspjDsQkcgzrD6mFSU8N1uFNRUVFGkdCrqa4uPq4qAgwm7WLhcjVsP7QpbJ+b19smDKTnhrOnj0LAIiKitI4EnJlkZFaR0Dkulh/6FKcPXsWwcHB9T7O2Vs1WCwWnDhxAoGBgdA5aadyUVERoqKicOzYMc4w+z+8JrXxmtTGa1Ibr0ltvCa1ucI1EULg7NmziIyMhF5f/xwttvTUoNfr0bZtW63DaJCgoCCn/eXTCq9JbbwmtfGa1MZrUhuvSW3Ofk0u1MJjxSnrRERE5BGY9BAREZFHYNLjYgwGA2bNmgWDwaB1KE6D16Q2XpPaeE1q4zWpjdekNne6JhzITERERB6BLT1ERETkEZj0EBERkUdg0kNEREQegUkPEREReQQmPUREROQRmPS4uNWrVyM+Ph5+fn5o3rw5UlJStA7JKZSXl6Nnz57Q6XTYs2eP1uFo5siRIxg7diyio6Ph5+eHjh07YtasWaioqNA6NFUtXLgQHTp0gNFoRHx8PLZt26Z1SJpKS0tDnz59EBgYiNDQUKSkpODgwYNah+VUXnrpJeh0OkydOlXrUDSVk5ODe+65By1btoSfnx+6d++OHTt2aB1WozHpcWGff/457r33XqSmpmLv3r3YvHkz7r77bq3DcgqPP/44InnnQvz++++wWCz43//+h/379+O1117DokWL8OSTT2odmmpWrFiBadOmYdasWdi1axd69OiB5ORk5Ofnax2aZn788UdMmjQJW7duRUZGBiorK3HDDTeguObtzj3Y9u3b8b///Q9XXXWV1qFo6syZM+jXrx98fHywdu1aHDhwAK+88gqaN2+udWiNJ8glVVZWijZt2oh33nlH61Cczpo1a0Tnzp3F/v37BQCxe/durUNyKnPmzBHR0dFah6GauLg4MWnSJNu/zWaziIyMFGlpaRpG5Vzy8/MFAPHjjz9qHYrmzp49K2JiYkRGRoZITEwUU6ZM0TokzfznP/8R/fv31zoMRbGlx0Xt2rULOTk50Ov16NWrFyIiInDjjTdi3759Woemqby8PIwfPx4ffvghmjVrpnU4TslkMqFFixZah6GKiooK7Ny5E0lJSbZzer0eSUlJyMzM1DAy52IymQDAY34vLmTSpEkYMmSI3e+Mp/r6668RGxuLYcOGITQ0FL169cLbb7+tdViXhEmPi/rrr78AAM888wyefvpprFq1Cs2bN8e1116LgoICjaPThhACY8aMwb///W/ExsZqHY5TOnz4MF5//XVMnDhR61BUcerUKZjNZoSFhdmdDwsLQ25urkZROReLxYKpU6eiX79+6Natm9bhaGr58uXYtWsX0tLStA7FKfz111946623EBMTg2+//Rb/7//9Pzz00EN4//33tQ6t0Zj0OJknnngCOp3ugpt1nAYAPPXUU7jjjjvQu3dvLFmyBDqdDunp6Rp/CmU19Jq8/vrrOHv2LKZPn651yE2uodekppycHAwePBjDhg3D+PHjNYqcnM2kSZOwb98+LF++XOtQNHXs2DFMmTIFy5Ytg9Fo1Docp2CxWHD11VfjxRdfRK9evTBhwgSMHz8eixYt0jq0RvPWOgCy98gjj2DMmDEXLHPZZZfhn3/+AQBceeWVtvMGgwGXXXYZ/v7776YMUXUNvSYbNmxAZmZmrZvixcbGYtSoUS7918n5GnpNrE6cOIGBAweib9++WLx4cRNH5zxatWoFLy8v5OXl2Z3Py8tDeHi4RlE5j8mTJ2PVqlXYtGkT2rZtq3U4mtq5cyfy8/Nx9dVX286ZzWZs2rQJb7zxBsrLy+Hl5aVhhOqLiIiw+44BgC5duuDzzz/XKKJLx6THybRu3RqtW7e+aLnevXvDYDDg4MGD6N+/PwCgsrISR44cQfv27Zs6TFU19JosWLAAs2fPtv37xIkTSE5OxooVKxAfH9+UIaquodcEkC08AwcOtLUG6vWe08Dr6+uL3r17Y/369bblHCwWC9avX4/JkydrG5yGhBB48MEH8eWXX+KHH35AdHS01iFpbtCgQfj111/tzqWmpqJz5874z3/+43EJDwD069ev1lIGf/zxh0t/xzDpcVFBQUH497//jVmzZiEqKgrt27fH3LlzAQDDhg3TODpttGvXzu7fAQEBAICOHTt67F+xOTk5uPbaa9G+fXvMmzcPJ0+etD3mKS0d06ZNw+jRoxEbG4u4uDjMnz8fxcXFSE1N1To0zUyaNAkff/wxvvrqKwQGBtrGNwUHB8PPz0/j6LQRGBhYa0yTv78/WrZs6bFjnR5++GH07dsXL774IoYPH45t27Zh8eLFLt1azKTHhc2dOxfe3t649957UVpaivj4eGzYsMG111AgRWVkZODw4cM4fPhwrcRPCKFRVOq66667cPLkScycORO5ubno2bMn1q1bV2twsyd56623AADXXnut3fklS5ZctNuUPEefPn3w5ZdfYvr06XjuuecQHR2N+fPnY9SoUVqH1mg64Sn/8xEREZFH85zOfSIiIvJoTHqIiIjIIzDpISIiIo/ApIeIiIg8ApMeIiIi8ghMeoiIiMgjMOkhIiIij8Ckh4iIiDwCkx4iIiLyCEx6iIiIyCMw6SEiIiKP8P8B7mM6lssJv04AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def make_gauss_pld(sigma, sensitivity):\n", + " \"\"\" Makes a guassian PLD from standard deviation\n", + " \n", + " Inputs:\n", + " sigma: standard deviation of gaussian mechanism\n", + " sensitivity: sensitivity of mechanism\n", + " \n", + " Output:\n", + " dp_accounting.pld.PrivacyLossDistribution object\n", + " \"\"\"\n", + "\n", + " return pld.from_gaussian_mechanism(sigma,\n", + " sensitivity=sensitivity,\n", + " value_discretization_interval=0.001)\n", + "\n", + "\n", + "def make_gauss_pld_from_params(delta,\n", + " epsilon,\n", + " sensitivity,\n", + " verbose=False,\n", + " *args):\n", + " \"\"\" Makes a guassian PLD from privacy parameters\n", + " \n", + " Inputs:\n", + " delta: delta value to use\n", + " epsilon: epsilon to use\n", + " sensitivity: sensitivity of mechanism\n", + " \n", + " Output:\n", + " dp_accounting.pld.PrivacyLossDistribution object\n", + " \"\"\"\n", + "\n", + " sigma = fit_sigma_from_params(delta, epsilon, sensitivity, verbose=verbose)\n", + " return make_gauss_pld(sigma, sensitivity, *args)\n", + "\n", + "\n", + "def analyze_gauss_pld(gauss_pld, color='blue', verbose=False):\n", + " \"\"\" Create a PMF from a PLD object\n", + " \n", + " Inputs:\n", + " gauss_pld: dp_accounting.pld.PrivacyLossDistribution object\n", + " color: color to use in plots\n", + " verbose: print detail and charts\n", + " \n", + " Output:\n", + " Returns (x, y) PMF of PLD\n", + " If verbose, shows a matplotlib chart of the data\n", + " \"\"\"\n", + " gauss_pmf = gauss_pld._pmf_add.to_dense_pmf()\n", + "\n", + " y = gauss_pmf._probs\n", + " y = (y - y.min()) / (y - y.min()).sum() # Normalize\n", + "\n", + " x = [gauss_pmf._discretization * gauss_pmf._lower_loss]\n", + " [x.append(gauss_pmf._discretization + x[i - 1]) for i in range(1, len(y))]\n", + "\n", + " if verbose:\n", + " plt.title(f\"PLD of specified Gaussian Mechanism\")\n", + " plt.plot(x, y, c=color)\n", + " plt.axvline(epsilon, c=color, linestyle='dotted')\n", + " plt.axvline(-epsilon, c=color, linestyle='dotted')\n", + " plt.show()\n", + "\n", + " return (x, y)\n", + "\n", + "\n", + "gauss_pld = make_gauss_pld_from_params(delta,\n", + " epsilon,\n", + " sensitivity,\n", + " verbose=True)\n", + "x, y = analyze_gauss_pld(gauss_pld, verbose=True)" + ] + }, + { + "cell_type": "markdown", + "id": "58b8e9b9", + "metadata": {}, + "source": [ + "### Sampling from the PLD" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8863591f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAGzCAYAAADNKAZOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA+hklEQVR4nO3de1hVdf7+/xvQDXjYGzUBSVTKUjHTPOHubJG7ooOjNmpmpGZpaCmTBxoHtKnRrMZDeMiaEa8pP6mVHSQxw9RviYcwS02ZMgvLNmLK3koFCuv3x/xY4x7RwNOG5fNxXeu63Ov9Wmu91rq64r7ee621AwzDMAQAAGAxgf5uAAAA4Hwg5AAAAEsi5AAAAEsi5AAAAEsi5AAAAEsi5AAAAEsi5AAAAEsi5AAAAEsi5AAAAEsi5AC4YAICAjR58uQLesyCggL169dPTZo0UUBAgGbOnHlBjw/Afwg5QC2zfft29evXTy1btlRISIguvfRS3XbbbXrppZf83VqNNHbsWK1atUopKSn617/+pdtvv93fLZ3Sd999p4CAAHMJCgpSixYt9Ic//EHbtm3zqQ0ICNCoUaNOu7+bb77Z3FdgYKDsdrvatGmjwYMHa/Xq1efxTICaoY6/GwBQdRs2bFDPnj3VokULDR8+XJGRkdq3b582btyoWbNmafTo0f5uscZZs2aN7r33Xj355JP+bqXKBg4cqDvvvFNlZWXatWuX5s2bp5UrV2rjxo3q1KlTtfbVvHlzTZ06VZJUXFysb775Rm+//bZee+01/fGPf9Rrr72munXrnoezAPyPkAPUIs8++6wcDoe2bNmisLAwn7EDBw74p6ka7sCBAyddq8oUFxerfv3657+hKujcubMeeOAB8/N1112ne+65R/PmzdPLL79crX05HA6ffUnStGnT9Pjjj2vu3Llq1aqVnnvuuXPSN1DT8HUVUIvs2bNH7du3r/SPdnh4uM/nhQsX6pZbblF4eLiCg4MVGxurefPmnbRdq1atdNddd2nt2rXq2rWrQkND1aFDB61du1aS9Pbbb6tDhw4KCQlRly5d9Pnnn/ts/9BDD6lBgwb69ttv5XK5VL9+fUVFRenpp5+WYRi/e04//vijhg4dqoiICAUHB6t9+/b65z//eVLdSy+9pPbt26tevXpq1KiRunbtqsWLF59yvxkZGQoICJBhGJozZ475tc2JY+vWrdNjjz2m8PBwNW/e3Nx27ty5at++vYKDgxUVFaWkpCQVFRX57P/mm2/WVVddpS+//FI33XST6tWrp9atW+vNN9+UJK1bt05xcXEKDQ1VmzZt9NFHH/3utTiVW265RZK0d+/eM97HiYKCgjR79mzFxsYqPT1dHo/nnOwXqGkIOUAt0rJlS+Xm5mrHjh2/Wztv3jy1bNlSTz31lF588UVFR0frscce05w5c06q/eabb3T//ffr7rvv1tSpU3X48GHdfffdev311zV27Fg98MADmjJlivbs2aM//vGPKi8v99m+rKxMt99+uyIiIjR9+nR16dJFaWlpSktLO22PBQUF6tGjhz766CONGjVKs2bNUuvWrTVs2DCfG4RfeeUVPf7444qNjdXMmTM1ZcoUderUSZs2bTrlvm+88Ub961//kiTddttt+te//mV+rvDYY4/pq6++UmpqqiZOnChJmjx5spKSkhQVFaUXX3xRffv21csvv6xevXrp2LFjPtsfPnxYd911l+Li4jR9+nQFBwdrwIABWrJkiQYMGKA777xT06ZNU3Fxsfr166cjR46c9nqcyp49eyRJTZo0OaPtKxMUFKSBAwfql19+0SeffHLO9gvUKAaAWuPDDz80goKCjKCgIMPpdBrjx483Vq1aZZSWlp5U+8svv5y0zuVyGZdddpnPupYtWxqSjA0bNpjrVq1aZUgyQkNDje+//95c//LLLxuSjI8//thcl5iYaEgyRo8eba4rLy83EhISDJvNZhQWFprrJRlpaWnm52HDhhnNmjUzDh486NPTgAEDDIfDYZ7Dvffea7Rv3/53rk7lJBlJSUk+6xYuXGhIMq6//nrj+PHj5voDBw4YNpvN6NWrl1FWVmauT09PNyQZ//znP811N910kyHJWLx4sblu9+7dhiQjMDDQ2Lhxo7m+4nouXLjwtL3u3bvXkGRMmTLFKCwsNNxut7F27VrjmmuuMSQZb7311mnP63/ddNNNp71uy5cvNyQZs2bNOu1+gNqKmRygFrntttuUk5Oje+65R1988YWmT58ul8ulSy+9VO+9955PbWhoqPlvj8ejgwcP6qabbtK333570tcTsbGxcjqd5ue4uDhJ//mapEWLFiet//bbb0/q7cQnfSqe/CktLT3l1zSGYeitt97S3XffLcMwdPDgQXNxuVzyeDzaunWrJCksLEw//PCDtmzZUqXrVFXDhw9XUFCQ+fmjjz5SaWmpxowZo8DAQJ86u92uzMxMn+0bNGigAQMGmJ/btGmjsLAwtWvXzrxW0umvW2XS0tLUtGlTRUZG6uabb9aePXv03HPPqU+fPmd0nqfSoEEDSTrjGSagpuPGY6CW6datm95++22Vlpbqiy++0PLlyzVjxgz169dP27ZtU2xsrCTp008/VVpamnJycvTLL7/47MPj8cjhcJifTwwyksyx6OjoStcfPnzYZ31gYKAuu+wyn3VXXnmlpP88Fl2ZwsJCFRUVacGCBVqwYEGlNRU3U0+YMEEfffSRunfvrtatW6tXr166//77dd1111W6XVXFxMT4fP7+++8l/SesnMhms+myyy4zxys0b97cvM+ngsPhqPJ1O5VHHnlE9913nwIDAxUWFmbeH3SuHT16VJLUsGHDc75voCYg5AC1lM1mU7du3dStWzddeeWVGjJkiJYtW6a0tDTt2bNHt956q9q2bau///3vio6Ols1m0wcffKAZM2acdE/NibMZVVlvVOGG4t9T0cMDDzygxMTESmuuvvpqSVK7du2Ul5enFStWKCsrS2+99Zbmzp2r1NRUTZky5Yx7OHG260ycr+t2xRVXKD4+/oz7qqqKe7tat2593o8F+AMhB7CArl27SpJ++uknSdL777+vkpISvffeez6zNB9//PF5OX55ebm+/fZbc/ZGkv79739L+s/TW5Vp2rSpGjZsqLKysir9Qa9fv7769++v/v37q7S0VH369NGzzz6rlJQUhYSEnJPzaNmypSQpLy/PZ2aqtLRUe/fuvSDB40IpKyvT4sWLVa9ePV1//fX+bgc4L7gnB6hFPv7440pnAz744ANJ//2apWIm4cRaj8ejhQsXnrfe0tPTzX8bhqH09HTVrVtXt956a6X1QUFB6tu3r956661KnxYrLCw0//3zzz/7jNlsNsXGxsowjJOeeDob8fHxstlsmj17ts+1+8c//iGPx6OEhIRzdix/Kisr0+OPP65du3bp8ccfl91u93dLwHnBTA5Qi4wePVq//PKL/vCHP6ht27YqLS3Vhg0btGTJErVq1UpDhgyRJPXq1Us2m0133323Hn30UR09elSvvPKKwsPDzdmecykkJERZWVlKTExUXFycVq5cqczMTD311FNq2rTpKbebNm2aPv74Y8XFxWn48OGKjY3VoUOHtHXrVn300Uc6dOiQeT6RkZG67rrrFBERoV27dik9PV0JCQnn9H6Spk2bKiUlRVOmTNHtt9+ue+65R3l5eZo7d666det20kv1/O2zzz7TM888c9L6m2++2Zyd8Xg8eu211yRJv/zyi/nG4z179mjAgAH661//ekF7Bi4kQg5Qi7zwwgtatmyZPvjgAy1YsEClpaVq0aKFHnvsMU2aNMl8SWCbNm305ptvatKkSXryyScVGRmpkSNHqmnTpho6dOg57ysoKEhZWVkaOXKkxo0bp4YNGyotLU2pqamn3S4iIkKbN2/W008/rbfffltz585VkyZN1L59e5+38D766KN6/fXX9fe//11Hjx5V8+bN9fjjj2vSpEnn/FwmT56spk2bKj09XWPHjlXjxo31yCOP6G9/+1uN+/mDTZs2VfquoL/+9a9myPnhhx80ePBgSf95mqpZs2ZyOp2aN2+ebrvttgvaL3ChBRjn4g5CABethx56SG+++ab5pA4A1BTckwMAACyJkAMAACyJkAMAACyJe3IAAIAlMZMDAAAsiZADAAAs6aJ+T055ebn279+vhg0bnvQjewAAoGYyDENHjhxRVFSUAgNPPV9zUYec/fv3n/RrwQAAoHbYt2+fmjdvfsrxizrkVLwOft++ffx2CwAAtYTX61V0dPTv/qzLRR1yKr6istvthBwAAGqZ37vVpFo3HpeVlekvf/mLYmJiFBoaqssvv1x//etffX6t1zAMpaamqlmzZgoNDVV8fLy+/vprn/0cOnRIgwYNkt1uV1hYmIYNG3bSK+G//PJL3XDDDQoJCVF0dLSmT59+Uj/Lli1T27ZtFRISog4dOpi/xAwAAFCtkPPcc89p3rx5Sk9P165du/Tcc89p+vTpeumll8ya6dOna/bs2Zo/f742bdqk+vXry+Vy6bfffjNrBg0apJ07d2r16tVasWKF1q9fr0ceecQc93q96tWrl1q2bKnc3Fw9//zzmjx5shYsWGDWbNiwQQMHDtSwYcP0+eefq3fv3urdu7d27NhxNtcDAABYhVENCQkJxtChQ33W9enTxxg0aJBhGIZRXl5uREZGGs8//7w5XlRUZAQHBxv/93//ZxiGYXz11VeGJGPLli1mzcqVK42AgADjxx9/NAzDMObOnWs0atTIKCkpMWsmTJhgtGnTxvz8xz/+0UhISPDpJS4uznj00UerfD4ej8eQZHg8nipvAwAA/Kuqf7+rNZNz7bXXKjs7W//+978lSV988YU++eQT3XHHHZKkvXv3yu12Kz4+3tzG4XAoLi5OOTk5kqScnByFhYWpa9euZk18fLwCAwO1adMms+bGG2+UzWYza1wul/Ly8nT48GGz5sTjVNRUHKcyJSUl8nq9PgsAALCmat14PHHiRHm9XrVt21ZBQUEqKyvTs88+q0GDBkmS3G63JCkiIsJnu4iICHPM7XYrPDzct4k6ddS4cWOfmpiYmJP2UTHWqFEjud3u0x6nMlOnTtWUKVOqc8oAAKCWqtZMztKlS/X6669r8eLF2rp1qxYtWqQXXnhBixYtOl/9nVMpKSnyeDzmsm/fPn+3BAAAzpNqzeSMGzdOEydO1IABAyRJHTp00Pfff6+pU6cqMTFRkZGRkqSCggI1a9bM3K6goECdOnWSJEVGRurAgQM++z1+/LgOHTpkbh8ZGamCggKfmorPv1dTMV6Z4OBgBQcHV+eUAQBALVWtmZxffvnlpNcnBwUFqby8XJIUExOjyMhIZWdnm+Ner1ebNm2S0+mUJDmdThUVFSk3N9esWbNmjcrLyxUXF2fWrF+/XseOHTNrVq9erTZt2qhRo0ZmzYnHqaipOA4AALjIVedu5sTEROPSSy81VqxYYezdu9d4++23jUsuucQYP368WTNt2jQjLCzMePfdd40vv/zSuPfee42YmBjj119/NWtuv/1245prrjE2bdpkfPLJJ8YVV1xhDBw40BwvKioyIiIijMGDBxs7duww3njjDaNevXrGyy+/bNZ8+umnRp06dYwXXnjB2LVrl5GWlmbUrVvX2L59e5XPh6erAACofar697taIcfr9RpPPPGE0aJFCyMkJMS47LLLjD//+c8+j3qXl5cbf/nLX4yIiAgjODjYuPXWW428vDyf/fz888/GwIEDjQYNGhh2u90YMmSIceTIEZ+aL774wrj++uuN4OBg49JLLzWmTZt2Uj9Lly41rrzySsNmsxnt27c3MjMzq3M6hBwAAGqhqv79DjCME15XfJHxer1yOBzyeDz8rAMAALVEVf9+V+ueHAAAgNqCkAMAACyJkAMAACypWu/JAYCaotXEzN+t+W5awgXoBEBNxUwOAACwJEIOAACwJEIOAACwJEIOAACwJEIOAACwJEIOAACwJEIOAACwJN6TA6DGqco7cM7VfniXDmBdzOQAAABLIuQAAABLIuQAAABLIuQAAABLIuQAAABLIuQAAABLIuQAAABLIuQAAABLIuQAAABLIuQAAABLIuQAAABLIuQAAABLIuQAAABLIuQAAABLIuQAAABLIuQAAABLIuQAAABLquPvBgBcXFpNzPR3CwAuEszkAAAASyLkAAAASyLkAAAAS+KeHAAXtarcI/TdtIQL0AmAc42ZHAAAYEnVCjmtWrVSQEDASUtSUpIk6bffflNSUpKaNGmiBg0aqG/fviooKPDZR35+vhISElSvXj2Fh4dr3LhxOn78uE/N2rVr1blzZwUHB6t169bKyMg4qZc5c+aoVatWCgkJUVxcnDZv3lzNUwcAAFZWrZCzZcsW/fTTT+ayevVqSdJ9990nSRo7dqzef/99LVu2TOvWrdP+/fvVp08fc/uysjIlJCSotLRUGzZs0KJFi5SRkaHU1FSzZu/evUpISFDPnj21bds2jRkzRg8//LBWrVpl1ixZskTJyclKS0vT1q1b1bFjR7lcLh04cOCsLgYAALCOAMMwjDPdeMyYMVqxYoW+/vpreb1eNW3aVIsXL1a/fv0kSbt371a7du2Uk5OjHj16aOXKlbrrrru0f/9+RURESJLmz5+vCRMmqLCwUDabTRMmTFBmZqZ27NhhHmfAgAEqKipSVlaWJCkuLk7dunVTenq6JKm8vFzR0dEaPXq0Jk6ceMp+S0pKVFJSYn72er2Kjo6Wx+OR3W4/08sAoBpq43tyuCcHqFm8Xq8cDsfv/v0+43tySktL9dprr2no0KEKCAhQbm6ujh07pvj4eLOmbdu2atGihXJyciRJOTk56tChgxlwJMnlcsnr9Wrnzp1mzYn7qKip2Edpaalyc3N9agIDAxUfH2/WnMrUqVPlcDjMJTo6+kxPHwAA1HBnHHLeeecdFRUV6aGHHpIkud1u2Ww2hYWF+dRFRETI7XabNScGnIrxirHT1Xi9Xv366686ePCgysrKKq2p2MeppKSkyOPxmMu+ffuqdc4AAKD2OONHyP/xj3/ojjvuUFRU1Lns57wKDg5WcHCwv9sAAAAXwBnN5Hz//ff66KOP9PDDD5vrIiMjVVpaqqKiIp/agoICRUZGmjX/+7RVxeffq7Hb7QoNDdUll1yioKCgSmsq9gEAAHBGIWfhwoUKDw9XQsJ/b8br0qWL6tatq+zsbHNdXl6e8vPz5XQ6JUlOp1Pbt2/3eQpq9erVstvtio2NNWtO3EdFTcU+bDabunTp4lNTXl6u7OxsswYAAKDaX1eVl5dr4cKFSkxMVJ06/93c4XBo2LBhSk5OVuPGjWW32zV69Gg5nU716NFDktSrVy/FxsZq8ODBmj59utxutyZNmqSkpCTza6QRI0YoPT1d48eP19ChQ7VmzRotXbpUmZn/fSIjOTlZiYmJ6tq1q7p3766ZM2equLhYQ4YMOdvrAQAALKLaIeejjz5Sfn6+hg4detLYjBkzFBgYqL59+6qkpEQul0tz5841x4OCgrRixQqNHDlSTqdT9evXV2Jiop5++mmzJiYmRpmZmRo7dqxmzZql5s2b69VXX5XL5TJr+vfvr8LCQqWmpsrtdqtTp07Kyso66WZkAABw8Tqr9+TUdlV9zh7AucN7cgCcrfP+nhwAAICajJADAAAsiZADAAAsiZADAAAsiZADAAAsiZADAAAsiZADAAAsiZADAAAsiZADAAAsiZADAAAsiZADAAAsiZADAAAsqdq/Qg4Ap1Ibf3wTgHUxkwMAACyJkAMAACyJkAMAACyJkAMAACyJkAMAACyJp6sA4HdU5amx76YlXIBOAFQHMzkAAMCSCDkAAMCSCDkAAMCSCDkAAMCSCDkAAMCSCDkAAMCSCDkAAMCSCDkAAMCSCDkAAMCSCDkAAMCSCDkAAMCSCDkAAMCSCDkAAMCSCDkAAMCSCDkAAMCSqh1yfvzxRz3wwANq0qSJQkND1aFDB3322WfmuGEYSk1NVbNmzRQaGqr4+Hh9/fXXPvs4dOiQBg0aJLvdrrCwMA0bNkxHjx71qfnyyy91ww03KCQkRNHR0Zo+ffpJvSxbtkxt27ZVSEiIOnTooA8++KC6pwMAACyqWiHn8OHDuu6661S3bl2tXLlSX331lV588UU1atTIrJk+fbpmz56t+fPna9OmTapfv75cLpd+++03s2bQoEHauXOnVq9erRUrVmj9+vV65JFHzHGv16tevXqpZcuWys3N1fPPP6/JkydrwYIFZs2GDRs0cOBADRs2TJ9//rl69+6t3r17a8eOHWdzPQAAgEUEGIZhVLV44sSJ+vTTT/X//t//q3TcMAxFRUXpT3/6k5588klJksfjUUREhDIyMjRgwADt2rVLsbGx2rJli7p27SpJysrK0p133qkffvhBUVFRmjdvnv785z/L7XbLZrOZx37nnXe0e/duSVL//v1VXFysFStWmMfv0aOHOnXqpPnz51fpfLxerxwOhzwej+x2e1UvA4BTaDUx098t+M130xL83QJw0ajq3+9qzeS899576tq1q+677z6Fh4frmmuu0SuvvGKO7927V263W/Hx8eY6h8OhuLg45eTkSJJycnIUFhZmBhxJio+PV2BgoDZt2mTW3HjjjWbAkSSXy6W8vDwdPnzYrDnxOBU1FcepTElJibxer88CAACsqVoh59tvv9W8efN0xRVXaNWqVRo5cqQef/xxLVq0SJLkdrslSRERET7bRUREmGNut1vh4eE+43Xq1FHjxo19airbx4nHOFVNxXhlpk6dKofDYS7R0dHVOX0AAFCLVCvklJeXq3Pnzvrb3/6ma665Ro888oiGDx9e5a+H/C0lJUUej8dc9u3b5++WAADAeVKtkNOsWTPFxsb6rGvXrp3y8/MlSZGRkZKkgoICn5qCggJzLDIyUgcOHPAZP378uA4dOuRTU9k+TjzGqWoqxisTHBwsu93uswAAAGuqVsi57rrrlJeX57Pu3//+t1q2bClJiomJUWRkpLKzs81xr9erTZs2yel0SpKcTqeKioqUm5tr1qxZs0bl5eWKi4sza9avX69jx46ZNatXr1abNm3MJ7mcTqfPcSpqKo4DAAAubtUKOWPHjtXGjRv1t7/9Td98840WL16sBQsWKCkpSZIUEBCgMWPG6JlnntF7772n7du368EHH1RUVJR69+4t6T8zP7fffruGDx+uzZs369NPP9WoUaM0YMAARUVFSZLuv/9+2Ww2DRs2TDt37tSSJUs0a9YsJScnm7088cQTysrK0osvvqjdu3dr8uTJ+uyzzzRq1KhzdGkAAEBtVq1HyCVpxYoVSklJ0ddff62YmBglJydr+PDh5rhhGEpLS9OCBQtUVFSk66+/XnPnztWVV15p1hw6dEijRo3S+++/r8DAQPXt21ezZ89WgwYNzJovv/xSSUlJ2rJliy655BKNHj1aEyZM8Oll2bJlmjRpkr777jtdccUVmj59uu68884qnwuPkANVdzE/Hl4VPEIOXDhV/ftd7ZBjJYQcoOoIOadHyAEunPPynhwAAIDagpADAAAsiZADAAAsiZADAAAsiZADAAAsiZADAAAsiZADAAAsiZADAAAsiZADAAAsiZADAAAsqY6/GwAAK6jKz17w0w/AhcVMDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsKRqhZzJkycrICDAZ2nbtq05/ttvvykpKUlNmjRRgwYN1LdvXxUUFPjsIz8/XwkJCapXr57Cw8M1btw4HT9+3Kdm7dq16ty5s4KDg9W6dWtlZGSc1MucOXPUqlUrhYSEKC4uTps3b67OqQAAAIur9kxO+/bt9dNPP5nLJ598Yo6NHTtW77//vpYtW6Z169Zp//796tOnjzleVlamhIQElZaWasOGDVq0aJEyMjKUmppq1uzdu1cJCQnq2bOntm3bpjFjxujhhx/WqlWrzJolS5YoOTlZaWlp2rp1qzp27CiXy6UDBw6c6XUAAAAWE2AYhlHV4smTJ+udd97Rtm3bThrzeDxq2rSpFi9erH79+kmSdu/erXbt2iknJ0c9evTQypUrddddd2n//v2KiIiQJM2fP18TJkxQYWGhbDabJkyYoMzMTO3YscPc94ABA1RUVKSsrCxJUlxcnLp166b09HRJUnl5uaKjozV69GhNnDixyifv9XrlcDjk8Xhkt9urvB1wMWo1MdPfLdR6301L8HcLgCVU9e93tWdyvv76a0VFRemyyy7ToEGDlJ+fL0nKzc3VsWPHFB8fb9a2bdtWLVq0UE5OjiQpJydHHTp0MAOOJLlcLnm9Xu3cudOsOXEfFTUV+ygtLVVubq5PTWBgoOLj482aUykpKZHX6/VZAACANVUr5MTFxSkjI0NZWVmaN2+e9u7dqxtuuEFHjhyR2+2WzWZTWFiYzzYRERFyu92SJLfb7RNwKsYrxk5X4/V69euvv+rgwYMqKyurtKZiH6cydepUORwOc4mOjq7O6QMAgFqkTnWK77jjDvPfV199teLi4tSyZUstXbpUoaGh57y5cy0lJUXJycnmZ6/XS9ABAMCizuoR8rCwMF155ZX65ptvFBkZqdLSUhUVFfnUFBQUKDIyUpIUGRl50tNWFZ9/r8Zutys0NFSXXHKJgoKCKq2p2MepBAcHy263+ywAAMCaqjWT87+OHj2qPXv2aPDgwerSpYvq1q2r7Oxs9e3bV5KUl5en/Px8OZ1OSZLT6dSzzz6rAwcOKDw8XJK0evVq2e12xcbGmjUffPCBz3FWr15t7sNms6lLly7Kzs5W7969Jf3nxuPs7GyNGjXqbE4HuChxQzEAq6rWTM6TTz6pdevW6bvvvtOGDRv0hz/8QUFBQRo4cKAcDoeGDRum5ORkffzxx8rNzdWQIUPkdDrVo0cPSVKvXr0UGxurwYMH64svvtCqVas0adIkJSUlKTg4WJI0YsQIffvttxo/frx2796tuXPnaunSpRo7dqzZR3Jysl555RUtWrRIu3bt0siRI1VcXKwhQ4acw0sDAABqs2rN5Pzwww8aOHCgfv75ZzVt2lTXX3+9Nm7cqKZNm0qSZsyYocDAQPXt21clJSVyuVyaO3euuX1QUJBWrFihkSNHyul0qn79+kpMTNTTTz9t1sTExCgzM1Njx47VrFmz1Lx5c7366qtyuVxmTf/+/VVYWKjU1FS53W516tRJWVlZJ92MDAAALl7Vek+O1fCeHICvqy4k3pMDnBvn7T05AAAAtQEhBwAAWBIhBwAAWBIhBwAAWBIhBwAAWNJZvQwQAFB1VXmSjSewgHOHmRwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJhBwAAGBJZxVypk2bpoCAAI0ZM8Zc99tvvykpKUlNmjRRgwYN1LdvXxUUFPhsl5+fr4SEBNWrV0/h4eEaN26cjh8/7lOzdu1ade7cWcHBwWrdurUyMjJOOv6cOXPUqlUrhYSEKC4uTps3bz6b0wEAABZyxiFny5Ytevnll3X11Vf7rB87dqzef/99LVu2TOvWrdP+/fvVp08fc7ysrEwJCQkqLS3Vhg0btGjRImVkZCg1NdWs2bt3rxISEtSzZ09t27ZNY8aM0cMPP6xVq1aZNUuWLFFycrLS0tK0detWdezYUS6XSwcOHDjTUwIAABYSYBiGUd2Njh49qs6dO2vu3Ll65pln1KlTJ82cOVMej0dNmzbV4sWL1a9fP0nS7t271a5dO+Xk5KhHjx5auXKl7rrrLu3fv18RERGSpPnz52vChAkqLCyUzWbThAkTlJmZqR07dpjHHDBggIqKipSVlSVJiouLU7du3ZSeni5JKi8vV3R0tEaPHq2JEydW6Ty8Xq8cDoc8Ho/sdnt1LwNgCa0mZvq7BZzgu2kJ/m4BqPGq+vf7jGZykpKSlJCQoPj4eJ/1ubm5OnbsmM/6tm3bqkWLFsrJyZEk5eTkqEOHDmbAkSSXyyWv16udO3eaNf+7b5fLZe6jtLRUubm5PjWBgYGKj483aypTUlIir9frswAAAGuqU90N3njjDW3dulVbtmw5acztdstmsyksLMxnfUREhNxut1lzYsCpGK8YO12N1+vVr7/+qsOHD6usrKzSmt27d5+y96lTp2rKlClVO1HAApilAXAxq9ZMzr59+/TEE0/o9ddfV0hIyPnq6bxJSUmRx+Mxl3379vm7JQAAcJ5UK+Tk5ubqwIED6ty5s+rUqaM6depo3bp1mj17turUqaOIiAiVlpaqqKjIZ7uCggJFRkZKkiIjI0962qri8+/V2O12hYaG6pJLLlFQUFClNRX7qExwcLDsdrvPAgAArKlaIefWW2/V9u3btW3bNnPp2rWrBg0aZP67bt26ys7ONrfJy8tTfn6+nE6nJMnpdGr79u0+T0GtXr1adrtdsbGxZs2J+6ioqdiHzWZTly5dfGrKy8uVnZ1t1gAAgItbte7Jadiwoa666iqfdfXr11eTJk3M9cOGDVNycrIaN24su92u0aNHy+l0qkePHpKkXr16KTY2VoMHD9b06dPldrs1adIkJSUlKTg4WJI0YsQIpaena/z48Ro6dKjWrFmjpUuXKjPzv/cXJCcnKzExUV27dlX37t01c+ZMFRcXa8iQIWd1QQAAgDVU+8bj3zNjxgwFBgaqb9++Kikpkcvl0ty5c83xoKAgrVixQiNHjpTT6VT9+vWVmJiop59+2qyJiYlRZmamxo4dq1mzZql58+Z69dVX5XK5zJr+/fursLBQqampcrvd6tSpk7Kysk66GRkAAFyczug9OVbBe3JgdTxdVfvwnhzg953X9+QAAADUdIQcAABgSef8nhwAwJmryleMfKUFVA0zOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJIIOQAAwJLq+LsBAGem1cRMf7cAADUaMzkAAMCSCDkAAMCSCDkAAMCSCDkAAMCSqhVy5s2bp6uvvlp2u112u11Op1MrV640x3/77TclJSWpSZMmatCggfr27auCggKffeTn5yshIUH16tVTeHi4xo0bp+PHj/vUrF27Vp07d1ZwcLBat26tjIyMk3qZM2eOWrVqpZCQEMXFxWnz5s3VORUAAGBx1Qo5zZs317Rp05Sbm6vPPvtMt9xyi+69917t3LlTkjR27Fi9//77WrZsmdatW6f9+/erT58+5vZlZWVKSEhQaWmpNmzYoEWLFikjI0Opqalmzd69e5WQkKCePXtq27ZtGjNmjB5++GGtWrXKrFmyZImSk5OVlpamrVu3qmPHjnK5XDpw4MDZXg8AAGARAYZhGGezg8aNG+v5559Xv3791LRpUy1evFj9+vWTJO3evVvt2rVTTk6OevTooZUrV+quu+7S/v37FRERIUmaP3++JkyYoMLCQtlsNk2YMEGZmZnasWOHeYwBAwaoqKhIWVlZkqS4uDh169ZN6enpkqTy8nJFR0dr9OjRmjhxYpV793q9cjgc8ng8stvtZ3MZgAuOR8gvXt9NS/B3C4BfVfXv9xnfk1NWVqY33nhDxcXFcjqdys3N1bFjxxQfH2/WtG3bVi1atFBOTo4kKScnRx06dDADjiS5XC55vV5zNignJ8dnHxU1FfsoLS1Vbm6uT01gYKDi4+PNmlMpKSmR1+v1WQAAgDVVO+Rs375dDRo0UHBwsEaMGKHly5crNjZWbrdbNptNYWFhPvURERFyu92SJLfb7RNwKsYrxk5X4/V69euvv+rgwYMqKyurtKZiH6cydepUORwOc4mOjq7u6QMAgFqi2m88btOmjbZt2yaPx6M333xTiYmJWrdu3fno7ZxLSUlRcnKy+dnr9RJ0ANQ6Vfmqkq+0gDMIOTabTa1bt5YkdenSRVu2bNGsWbPUv39/lZaWqqioyGc2p6CgQJGRkZKkyMjIk56Cqnj66sSa/30iq6CgQHa7XaGhoQoKClJQUFClNRX7OJXg4GAFBwdX95QBAEAtdNbvySkvL1dJSYm6dOmiunXrKjs72xzLy8tTfn6+nE6nJMnpdGr79u0+T0GtXr1adrtdsbGxZs2J+6ioqdiHzWZTly5dfGrKy8uVnZ1t1gAAAFRrJiclJUV33HGHWrRooSNHjmjx4sVau3atVq1aJYfDoWHDhik5OVmNGzeW3W7X6NGj5XQ61aNHD0lSr169FBsbq8GDB2v69Olyu92aNGmSkpKSzBmWESNGKD09XePHj9fQoUO1Zs0aLV26VJmZ/52eTU5OVmJiorp27aru3btr5syZKi4u1pAhQ87hpQEAALVZtULOgQMH9OCDD+qnn36Sw+HQ1VdfrVWrVum2226TJM2YMUOBgYHq27evSkpK5HK5NHfuXHP7oKAgrVixQiNHjpTT6VT9+vWVmJiop59+2qyJiYlRZmamxo4dq1mzZql58+Z69dVX5XK5zJr+/fursLBQqampcrvd6tSpk7Kysk66GRkAAFy8zvo9ObUZ78lBbcZ7cnA63HgMKzvv78kBAACoyQg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkgg5AADAkur4uwEAJ2s1MdPfLQBArcdMDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCRCDgAAsCQeIQcAC6rKawi+m5ZwAToB/IeZHAAAYEmEHAAAYEmEHAAAYEmEHAAAYEmEHAAAYEmEHAAAYEnVCjlTp05Vt27d1LBhQ4WHh6t3797Ky8vzqfntt9+UlJSkJk2aqEGDBurbt68KCgp8avLz85WQkKB69eopPDxc48aN0/Hjx31q1q5dq86dOys4OFitW7dWRkbGSf3MmTNHrVq1UkhIiOLi4rR58+bqnA4AALCwaoWcdevWKSkpSRs3btTq1at17Ngx9erVS8XFxWbN2LFj9f7772vZsmVat26d9u/frz59+pjjZWVlSkhIUGlpqTZs2KBFixYpIyNDqampZs3evXuVkJCgnj17atu2bRozZowefvhhrVq1yqxZsmSJkpOTlZaWpq1bt6pjx45yuVw6cODA2VwPAABgEQGGYRhnunFhYaHCw8O1bt063XjjjfJ4PGratKkWL16sfv36SZJ2796tdu3aKScnRz169NDKlSt11113af/+/YqIiJAkzZ8/XxMmTFBhYaFsNpsmTJigzMxM7dixwzzWgAEDVFRUpKysLElSXFycunXrpvT0dElSeXm5oqOjNXr0aE2cOLFK/Xu9XjkcDnk8Htnt9jO9DMA5V5UXuQFni5cBoraq6t/vs7onx+PxSJIaN24sScrNzdWxY8cUHx9v1rRt21YtWrRQTk6OJCknJ0cdOnQwA44kuVwueb1e7dy506w5cR8VNRX7KC0tVW5urk9NYGCg4uPjzZrKlJSUyOv1+iwAAMCazjjklJeXa8yYMbruuut01VVXSZLcbrdsNpvCwsJ8aiMiIuR2u82aEwNOxXjF2OlqvF6vfv31Vx08eFBlZWWV1lTsozJTp06Vw+Ewl+jo6OqfOAAAqBXOOOQkJSVpx44deuONN85lP+dVSkqKPB6Puezbt8/fLQEAgPPkjH6gc9SoUVqxYoXWr1+v5s2bm+sjIyNVWlqqoqIin9mcgoICRUZGmjX/+xRUxdNXJ9b87xNZBQUFstvtCg0NVVBQkIKCgiqtqdhHZYKDgxUcHFz9EwYAALVOtWZyDMPQqFGjtHz5cq1Zs0YxMTE+4126dFHdunWVnZ1trsvLy1N+fr6cTqckyel0avv27T5PQa1evVp2u12xsbFmzYn7qKip2IfNZlOXLl18asrLy5WdnW3WAACAi1u1ZnKSkpK0ePFivfvuu2rYsKF5/4vD4VBoaKgcDoeGDRum5ORkNW7cWHa7XaNHj5bT6VSPHj0kSb169VJsbKwGDx6s6dOny+12a9KkSUpKSjJnWUaMGKH09HSNHz9eQ4cO1Zo1a7R06VJlZv73iZPk5GQlJiaqa9eu6t69u2bOnKni4mINGTLkXF0bAABQi1Ur5MybN0+SdPPNN/usX7hwoR566CFJ0owZMxQYGKi+ffuqpKRELpdLc+fONWuDgoK0YsUKjRw5Uk6nU/Xr11diYqKefvppsyYmJkaZmZkaO3asZs2apebNm+vVV1+Vy+Uya/r376/CwkKlpqbK7XarU6dOysrKOulmZAAAcHE6q/fk1Ha8Jwc1Fe/JwYXAe3JQW12Q9+QAAADUVIQcAABgSYQcAABgSYQcAABgSWf0MkAAZ46bigHgwmAmBwAAWBIhBwAAWBIhBwAAWBIhBwAAWBIhBwAAWBJPVwHARaoqT/rx0w+ozZjJAQAAlkTIAQAAlkTIAQAAlkTIAQAAlkTIAQAAlkTIAQAAlkTIAQAAlkTIAQAAlkTIAQAAlkTIAQAAlkTIAQAAlkTIAQAAlkTIAQAAlkTIAQAAlkTIAQAAllTH3w0AVtJqYqa/WwAA/P+YyQEAAJZEyAEAAJZEyAEAAJZEyAEAAJZEyAEAAJbE01UAgFOqyhOD301LuACdANXHTA4AALCkaoec9evX6+6771ZUVJQCAgL0zjvv+IwbhqHU1FQ1a9ZMoaGhio+P19dff+1Tc+jQIQ0aNEh2u11hYWEaNmyYjh496lPz5Zdf6oYbblBISIiio6M1ffr0k3pZtmyZ2rZtq5CQEHXo0EEffPBBdU8HAABYVLVDTnFxsTp27Kg5c+ZUOj59+nTNnj1b8+fP16ZNm1S/fn25XC799ttvZs2gQYO0c+dOrV69WitWrND69ev1yCOPmONer1e9evVSy5YtlZubq+eff16TJ0/WggULzJoNGzZo4MCBGjZsmD7//HP17t1bvXv31o4dO6p7SgAAwIICDMMwznjjgAAtX75cvXv3lvSfWZyoqCj96U9/0pNPPilJ8ng8ioiIUEZGhgYMGKBdu3YpNjZWW7ZsUdeuXSVJWVlZuvPOO/XDDz8oKipK8+bN05///Ge53W7ZbDZJ0sSJE/XOO+9o9+7dkqT+/furuLhYK1asMPvp0aOHOnXqpPnz51epf6/XK4fDIY/HI7vdfqaXATDxxmNcjLgnBxdaVf9+n9N7cvbu3Su32634+HhzncPhUFxcnHJyciRJOTk5CgsLMwOOJMXHxyswMFCbNm0ya2688UYz4EiSy+VSXl6eDh8+bNaceJyKmorjVKakpERer9dnAQAA1nROQ47b7ZYkRURE+KyPiIgwx9xut8LDw33G69Spo8aNG/vUVLaPE49xqpqK8cpMnTpVDofDXKKjo6t7igAAoJa4qJ6uSklJkcfjMZd9+/b5uyUAAHCenNOQExkZKUkqKCjwWV9QUGCORUZG6sCBAz7jx48f16FDh3xqKtvHicc4VU3FeGWCg4Nlt9t9FgAAYE3nNOTExMQoMjJS2dnZ5jqv16tNmzbJ6XRKkpxOp4qKipSbm2vWrFmzRuXl5YqLizNr1q9fr2PHjpk1q1evVps2bdSoUSOz5sTjVNRUHAcAAFzcqh1yjh49qm3btmnbtm2S/nOz8bZt25Sfn6+AgACNGTNGzzzzjN577z1t375dDz74oKKioswnsNq1a6fbb79dw4cP1+bNm/Xpp59q1KhRGjBggKKioiRJ999/v2w2m4YNG6adO3dqyZIlmjVrlpKTk80+nnjiCWVlZenFF1/U7t27NXnyZH322WcaNWrU2V8VAABQ61X7Zx0+++wz9ezZ0/xcETwSExOVkZGh8ePHq7i4WI888oiKiop0/fXXKysrSyEhIeY2r7/+ukaNGqVbb71VgYGB6tu3r2bPnm2OOxwOffjhh0pKSlKXLl10ySWXKDU11eddOtdee60WL16sSZMm6amnntIVV1yhd955R1ddddUZXQgAAGAtZ/WenNqO9+TgXOM9ObgY8Z4cXGhV/fvND3QCVUSAAYDa5aJ6hBwAAFw8CDkAAMCSCDkAAMCSuCcHAHBWqnK/Gjcnwx+YyQEAAJZEyAEAAJZEyAEAAJZEyAEAAJZEyAEAAJZEyAEAAJZEyAEAAJZEyAEAAJZEyAEAAJbEG48B8QvjAGBFzOQAAABLIuQAAABL4usqAMB5x494wh+YyQEAAJZEyAEAAJZEyAEAAJZEyAEAAJZEyAEAAJbE01WwPF70BwAXJ0IOAKBG4DFznGt8XQUAACyJkAMAACyJkAMAACyJkAMAACyJG49Rq/HkFADgVAg5AIBagyewUB18XQUAACyJkAMAACyJr6tQY3G/DQDgbNT6kDNnzhw9//zzcrvd6tixo1566SV1797d320BAPyE+3ZQoVaHnCVLlig5OVnz589XXFycZs6cKZfLpby8PIWHh/u7PZwGszQAgPMtwDAMw99NnKm4uDh169ZN6enpkqTy8nJFR0dr9OjRmjhx4u9u7/V65XA45PF4ZLfbz3e7OAEhB0BNx2xPzVXVv9+1diantLRUubm5SklJMdcFBgYqPj5eOTk5lW5TUlKikpIS87PH45H0n4uFqrkqbZW/WwCAC6LF2GW/W7NjiusCdIL/VfF3+/fmaWptyDl48KDKysoUERHhsz4iIkK7d++udJupU6dqypQpJ62Pjo4+Lz0CAKzNMdPfHVzcjhw5IofDccrxWhtyzkRKSoqSk5PNz+Xl5Tp06JCaNGmigICA393e6/UqOjpa+/bt4+utSnB9To1rc3pcn9Pj+pwa1+b0rHp9DMPQkSNHFBUVddq6WhtyLrnkEgUFBamgoMBnfUFBgSIjIyvdJjg4WMHBwT7rwsLCqn1su91uqf9YzjWuz6lxbU6P63N6XJ9T49qcnhWvz+lmcCrU2pcB2mw2denSRdnZ2ea68vJyZWdny+l0+rEzAABQE9TamRxJSk5OVmJiorp27aru3btr5syZKi4u1pAhQ/zdGgAA8LNaHXL69++vwsJCpaamyu12q1OnTsrKyjrpZuRzJTg4WGlpaSd95YX/4PqcGtfm9Lg+p8f1OTWuzeld7NenVr8nBwAA4FRq7T05AAAAp0PIAQAAlkTIAQAAlkTIAQAAlkTIAQAAlkTIOUP33HOPWrRooZCQEDVr1kyDBw/W/v37/d1WjfDdd99p2LBhiomJUWhoqC6//HKlpaWptLTU363VCM8++6yuvfZa1atX74zeuG01c+bMUatWrRQSEqK4uDht3rzZ3y3VGOvXr9fdd9+tqKgoBQQE6J133vF3SzXG1KlT1a1bNzVs2FDh4eHq3bu38vLy/N1WjTFv3jxdffXV5puOnU6nVq5c6e+2LjhCzhnq2bOnli5dqry8PL311lvas2eP+vXr5++2aoTdu3ervLxcL7/8snbu3KkZM2Zo/vz5euqpp/zdWo1QWlqq++67TyNHjvR3K363ZMkSJScnKy0tTVu3blXHjh3lcrl04MABf7dWIxQXF6tjx46aM2eOv1upcdatW6ekpCRt3LhRq1ev1rFjx9SrVy8VFxf7u7UaoXnz5po2bZpyc3P12Wef6ZZbbtG9996rnTt3+ru1C8vAOfHuu+8aAQEBRmlpqb9bqZGmT59uxMTE+LuNGmXhwoWGw+Hwdxt+1b17dyMpKcn8XFZWZkRFRRlTp071Y1c1kyRj+fLl/m6jxjpw4IAhyVi3bp2/W6mxGjVqZLz66qv+buOCYibnHDh06JBef/11XXvttapbt66/26mRPB6PGjdu7O82UIOUlpYqNzdX8fHx5rrAwEDFx8crJyfHj52hNvJ4PJLE/2cqUVZWpjfeeEPFxcUX3W87EnLOwoQJE1S/fn01adJE+fn5evfdd/3dUo30zTff6KWXXtKjjz7q71ZQgxw8eFBlZWUn/QxLRESE3G63n7pCbVReXq4xY8bouuuu01VXXeXvdmqM7du3q0GDBgoODtaIESO0fPlyxcbG+rutC4qQc4KJEycqICDgtMvu3bvN+nHjxunzzz/Xhx9+qKCgID344IMyLPwrGdW9PpL0448/6vbbb9d9992n4cOH+6nz8+9Mrg2AcyMpKUk7duzQG2+84e9WapQ2bdpo27Zt2rRpk0aOHKnExER99dVX/m7rguK3q05QWFion3/++bQ1l112mWw220nrf/jhB0VHR2vDhg2WnQ6s7vXZv3+/br75ZvXo0UMZGRkKDLRupj6T/3YyMjI0ZswYFRUVnefuaqbS0lLVq1dPb775pnr37m2uT0xMVFFRETOj/yMgIEDLly/3uVaQRo0apXfffVfr169XTEyMv9up0eLj43X55Zfr5Zdf9ncrF0yt/hXyc61p06Zq2rTpGW1bXl4uSSopKTmXLdUo1bk+P/74o3r27KkuXbpo4cKFlg440tn9t3Oxstls6tKli7Kzs80/3OXl5crOztaoUaP82xxqPMMwNHr0aC1fvlxr164l4FRBeXm5pf9GVYaQcwY2bdqkLVu26Prrr1ejRo20Z88e/eUvf9Hll19u2Vmc6vjxxx918803q2XLlnrhhRdUWFhojkVGRvqxs5ohPz9fhw4dUn5+vsrKyrRt2zZJUuvWrdWgQQP/NneBJScnKzExUV27dlX37t01c+ZMFRcXa8iQIf5urUY4evSovvnmG/Pz3r17tW3bNjVu3FgtWrTwY2f+l5SUpMWLF+vdd99Vw4YNzfu4HA6HQkND/dyd/6WkpOiOO+5QixYtdOTIES1evFhr167VqlWr/N3aheXfh7tqpy+//NLo2bOn0bhxYyM4ONho1aqVMWLECOOHH37wd2s1wsKFCw1JlS4wjMTExEqvzccff+zv1vzipZdeMlq0aGHYbDaje/fuxsaNG/3dUo3x8ccfV/rfSmJior9b87tT/T9m4cKF/m6tRhg6dKjRsmVLw2azGU2bNjVuvfVW48MPP/R3Wxcc9+QAAABLsvaNEgAA4KJFyAEAAJZEyAEAAJZEyAEAAJZEyAEAAJZEyAEAAJZEyAEAAJZEyAEAAJZEyAEAAJZEyAEAAJZEyAEAAJb0/wGzG9Ouq5VofQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def sample_from_pmf(data, num_samples=1000000, num_bins=50, verbose=False):\n", + " \"\"\" Draw samples from a PMF\n", + " \n", + " Inputs:\n", + " data: PMF in the form of (x, y)\n", + " num_samples: number of samples to draw\n", + " num_bins: number of bins to draw in histogram\n", + " verbose: print details and plots\n", + " \n", + " Output:\n", + " array of samples\n", + " If verbose, matplotlib histogram\n", + " \"\"\"\n", + " rng = np.random.default_rng()\n", + " choices = rng.choice(data[0], num_samples, p=data[1])\n", + "\n", + " if verbose:\n", + " plt.title(\"Samples from PLD\")\n", + " plt.hist(choices, bins=num_bins)\n", + " plt.show()\n", + "\n", + " return choices\n", + "\n", + "\n", + "_ = sample_from_pmf((x, y), verbose=True)" + ] + }, + { + "cell_type": "markdown", + "id": "8f23c674", + "metadata": {}, + "source": [ + "### Google paper observations\n", + "Empirical testing of the observations in [this paper](https://github.com/google/differential-privacy/blob/main/common_docs/Privacy_Loss_Distributions.pdf)\n", + "\n", + "#### Observation 1\n", + "Epsilon-hockey stick divergence is less than or equal to delta" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "28b65fc1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epsilon-Hockey Stick Div: 9.999984507048863e-07\n", + "Delta: 1e-06\n", + "Observation 1 true?: True\n" + ] + } + ], + "source": [ + "EHSD = gauss_pld.get_delta_for_epsilon(epsilon)\n", + "\n", + "print(f\"Epsilon-Hockey Stick Div: {EHSD}\")\n", + "print(f\"Delta: {delta}\")\n", + "print(f\"Observation 1 true?: {EHSD <= delta}\")" + ] + }, + { + "cell_type": "markdown", + "id": "945a5af4", + "metadata": {}, + "source": [ + "#### Observation 2\n", + "Epsilon-hockey stick divergence is equal to the given equation" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "eef91f41", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "23b0ec7170a341f2bc9fe43f40f140d1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000000 [00:00 0 else 0)\n", + "\n", + " return np.mean(obs) # Expected value\n", + "\n", + "\n", + "obs2 = observation2(x, y, num_samples)\n", + "cond = math.isclose(obs2, EHSD, abs_tol=10e-7)\n", + "\n", + "print(f\"Obs. 2 result: {obs2}\")\n", + "print(f\"Epsilon-Hockey Stick Div: {EHSD}\")\n", + "print(f\"Obs. 2 true? (result == EHSD): {cond}\")" + ] + }, + { + "cell_type": "markdown", + "id": "8e2155be", + "metadata": {}, + "source": [ + "#### Observation 3\n", + "Composing mechanisms results in the convolution of their respective PLRVs. In this case, for ease, we self compose the mechanism.\n", + "\n", + "By observation 3, the two histograms should be roughly equal." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "339a2b2d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Convolution (Definition 2)\n", + "x1 = sample_from_pmf((x, y)) + sample_from_pmf((x, y))\n", + "\n", + "# Composition\n", + "mech2 = gauss_pld.compose(gauss_pld)\n", + "x2 = sample_from_pmf(analyze_gauss_pld(mech2))\n", + "\n", + "# They're the same! (Observation 3)\n", + "plt.hist(x1, bins=100, label=\"Convolution\")\n", + "plt.hist(x2, bins=100, alpha=0.5, label=\"Composition\")\n", + "plt.title(\"Convolution vs Composition PLDs\")\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/laplace_example_class_height.ipynb b/laplace_example_class_height.ipynb new file mode 100644 index 0000000..55c1397 --- /dev/null +++ b/laplace_example_class_height.ipynb @@ -0,0 +1,586 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e2c530b2", + "metadata": {}, + "source": [ + "# Example implementation of pure differential privacy\n", + "\n", + "By [Armaan Bhojwani](https://armaanb.net) under [Praneeth Vepakomma](https://praneeth.mit.edu/)\n", + "\n", + "Privatizing the height data of a class using the laplace mechanism.\n", + "\n", + "In this notebook we do the following:\n", + "1. Define parameters with which to operate\n", + "1. Generate a dataset to work on\n", + "1. Implement functions that return differentially private versions of sum, count, and mean\n", + "1. Clip for sensitivity\n", + "1. Analyze the accuracy of the private mean across various epsilons\n", + "\n", + "### Dependencies\n", + "- matplotlib\n", + "- scipy\n", + "- tqdm\n", + "\n", + "### Status\n", + "- Complete\n", + "- Could make the clipping process epsilon-delta DP" + ] + }, + { + "cell_type": "markdown", + "id": "2413eb87", + "metadata": {}, + "source": [ + "## Parameters\n", + "\n", + "### Data parameters\n", + "\n", + "For our data, we will draw `num_records` number of samples from a gaussian distribution with parameters `height_loc` and `height_std` for mean and standard deviation respectively. This should create a distribution of heights fairly accurate to what you might find in the real world. The default values of 175 and 7 for the height distribution parameters are accurate for the US in centimeters." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "77642ebc", + "metadata": {}, + "outputs": [], + "source": [ + "num_records = 8000 # Number of records to create\n", + "height_loc = 175 # Mean of height distribution (175 is USA mean)\n", + "height_std = 7 # Standard deviation of height distributlon (7 is USA std)" + ] + }, + { + "cell_type": "markdown", + "id": "d1ebce1f", + "metadata": {}, + "source": [ + "### Analysis parameters\n", + "The `max_epsilon` and `epsilon_step` parameters are used to create a list of epsilons which we will use to show how the efficacy of DP changes with varying epsilon.\n", + "\n", + "`num_samples` is the number of times to run these tests. Higher is better, but will take longer." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "80c7682b", + "metadata": {}, + "outputs": [], + "source": [ + "max_epsilon = 10 # Largest epsilon value to test\n", + "epsilon_step = 0.25 # Step size between epsilons\n", + "# With these parameters, we test epsilons [0.25, 0.5... 9.75, 10]\n", + "\n", + "num_samples = 20000 # Number of times to run lim x->inf functions" + ] + }, + { + "cell_type": "markdown", + "id": "5cdd14c9", + "metadata": {}, + "source": [ + "### Clipping parameters\n", + "\n", + "Reccomended reading: https://programming-dp.com/ch5.html#clipping\n", + "\n", + "These parameters configure the process for clipping for the bounds of the `sum` function sensitivity. The `max_height` parameter is the upper bound for calculating the clipping of the sensitivity of the sum query. It should be higher than any expected height in the distribution, but not so high as to waste computational power. `clipping_epsilon` is the epsilon value used when adding noise during the clipping process. With small datasets, epsilon should be high so that the scale of the noise does not overcome the scale of the data. For larger datasets, the `clipping_epsilon` can be more reasonable. `smoothing_width` and `slope_width` determine how much smoothing to do during the smoothing and slope steps respectively. Lower epsilons can allow for lower `smoothing_width` and `slope_width`. `growth_bound` is the value at which growth in the cumulative sum can be considered negligible." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e5315ef9", + "metadata": {}, + "outputs": [], + "source": [ + "max_height = 250 # Clipping bound greater than any height in the dataset\n", + "clipping_epsilon = 3 # Epsilon to use when calculating clipping bound\n", + "smoothing_width = 15 # Width of window to use for initial smoothing\n", + "slope_width = 10 # Width of window to use when calculating rolling slope\n", + "growth_bound = 0.25 # Slope at which to consider change negligible" + ] + }, + { + "cell_type": "markdown", + "id": "358975fd", + "metadata": {}, + "source": [ + "## Building the data\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "89abe686", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Create height distribution and draw from it to create our height data\n", + "rng = np.random.default_rng()\n", + "heights = rng.normal(loc=height_loc, scale=height_std, size=num_records)\n", + "heights = np.asarray([round(height, 2) for height in heights])\n", + "\n", + "# Plot\n", + "plt.title(\"Distribution of Heights\")\n", + "plt.xlabel(\"Height (cm)\")\n", + "plt.ylabel(\"Count\")\n", + "plt.hist(heights, bins=15)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c7c5b3d4", + "metadata": {}, + "source": [ + "## Differential Privacy\n", + "### Laplace noise functions\n", + "\n", + "Implementations of adding laplace noise to given functions." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ca8ec0a9", + "metadata": {}, + "outputs": [], + "source": [ + "def laplace_mech(epsilon, sensitivity):\n", + " \"\"\" Sample adequate laplace noise\n", + " Inputs:\n", + " epsilon: epsilon value to use\n", + " sensitivity: sensitivity to use\n", + " \n", + " Output:\n", + " Laplace noise given the parameters\n", + " \"\"\"\n", + " return rng.laplace(scale=sensitivity / epsilon)\n", + "\n", + "\n", + "def dp_sum(data, epsilon, sensitivity):\n", + " \"\"\" Differentially private sum\n", + " Inputs:\n", + " data: array of numbers to sum\n", + " epsilon: epsilon value to use\n", + " sensitivity: sensitivity to use.\n", + "\n", + " Output:\n", + " Non private sum + appropriate laplace noise\n", + " \"\"\"\n", + " return np.sum(data) + laplace_mech(epsilon, sensitivity)\n", + "\n", + "\n", + "def dp_count(data, epsilon):\n", + " \"\"\" Differentially private count\n", + " Inputs:\n", + " data: array of numbers to sum\n", + " epsilon: epsilon value to use\n", + "\n", + " Output:\n", + " Non private count + appropriate laplace noise\n", + " \"\"\"\n", + " sensitivity = 1\n", + " return np.size(data) + laplace_mech(epsilon, sensitivity)\n", + "\n", + "\n", + "def dp_mean(data, epsilon, sum_sensitivity=0):\n", + " \"\"\" Differentially private mean utilizing dp_sum and dp_count functions\n", + " Inputs:\n", + " data: array of numbers to sum\n", + " epsilon: epsilon value to use\n", + " sum_sensitivity: sensitivity to use for the sum query\n", + " Defaults to the maximum value in the dataset\n", + "\n", + " Output:\n", + " Differentially private mean\n", + " \"\"\"\n", + " return dp_sum(data, epsilon, sum_sensitivity) / dp_count(data, epsilon)" + ] + }, + { + "cell_type": "markdown", + "id": "98a732fa", + "metadata": {}, + "source": [ + "### Clipping\n", + "See https://programming-dp.com/ch5.html#clipping and the documentation in the parameters section\n", + "\n", + "#### Step 1" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0b381105", + "metadata": {}, + "outputs": [], + "source": [ + "from tqdm.notebook import tqdm\n", + "\n", + "\n", + "def clipping_step1(heights, clipping_epsilon, max_height):\n", + " \"\"\" Step 1 of the clipping process\n", + " Calculates privacy cumulative sums of the data\n", + " Inputs:\n", + " heights: height data\n", + " clipping_epsilon: epsilon to use in clipping\n", + " max_height: value to stop testing at\n", + "\n", + " Output:\n", + " Array of cumulative sums with laplace noise\n", + " \"\"\"\n", + " epsilon_i = clipping_epsilon / max_height\n", + " data1 = [\n", + " heights.clip(min=0, max=i).sum() + laplace_mech(epsilon_i, i)\n", + " for i in range(max_height)\n", + " ]\n", + "\n", + " return data1\n", + "\n", + "\n", + "data1 = clipping_step1(heights, clipping_epsilon, max_height)" + ] + }, + { + "cell_type": "markdown", + "id": "9faebe55", + "metadata": {}, + "source": [ + "#### Step 2" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e217b0d9", + "metadata": {}, + "outputs": [], + "source": [ + "def clipping_step2(data1, smoothing_width):\n", + " \"\"\" Step 2 of the clipping process\n", + " Smooths the data gathered in step 1\n", + " Inputs:\n", + " data1: data collected in step 1\n", + " smoothing_width: width of the window to smooth over\n", + "\n", + " Output:\n", + " Smoothed version of data from step1\n", + " \"\"\"\n", + " cumsum_vec = np.cumsum(np.insert(data1, 0, 0))\n", + " data2 = (cumsum_vec[smoothing_width:] -\n", + " cumsum_vec[:-smoothing_width]) / smoothing_width\n", + "\n", + " return data2\n", + "\n", + "\n", + "data2 = clipping_step2(data1, smoothing_width)" + ] + }, + { + "cell_type": "markdown", + "id": "e76c572b", + "metadata": {}, + "source": [ + "#### Step 3" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "476de948", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10449.964151012013\n" + ] + } + ], + "source": [ + "from scipy.stats import linregress\n", + "\n", + "\n", + "def clipping_step3(data2, slope_width, growth_bound):\n", + " \"\"\" Step 3 of the clipping process\n", + " Calculates the rate of change over a rolling window of data\n", + " gathered in step 2\n", + " Inputs:\n", + " data2: data collected in step 2\n", + " slope_width: width of the window over which to calculate the slope\n", + " growth_bound: slope at which to consider growth negligible\n", + "\n", + " Output:\n", + " Derivative of step 2, differentially private sensitivity to use\n", + " \"\"\"\n", + " # Calculate maximum slope between heights\n", + " deviations = np.diff(data2)\n", + " print(max(deviations))\n", + "\n", + " data3 = []\n", + " for i in range(slope_width, len(data2) - slope_width + 1):\n", + " area = range(i - slope_width, i + slope_width)\n", + " data3.append(linregress(area, [data2[i] for i in area])[0])\n", + "\n", + " data3 = np.asarray(data3)\n", + " upper_bound = np.where(data3 <= growth_bound)[0][0]\n", + "\n", + " return data3, upper_bound\n", + "\n", + "\n", + "data3, sum_sensitivity = clipping_step3(data2, slope_width, growth_bound)" + ] + }, + { + "cell_type": "markdown", + "id": "2a3b1433", + "metadata": {}, + "source": [ + "#### Plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d13dc1d8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax1 = plt.subplots()\n", + "\n", + "colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + "plt.title(\"Summary of the clipping process\")\n", + "plt.xlabel(\"Height (cm)\")\n", + "\n", + "# Axis 1\n", + "plt.ylabel(\"Sums\")\n", + "plt.plot(data1, label=\"Step 1 (Cumulative sum)\")\n", + "plt.plot(data2, label=\"Step 2 (Smoothed cumulative sum)\")\n", + "\n", + "# Axis 2\n", + "ax2 = ax1.twinx()\n", + "plt.ylabel(\"Slopes\")\n", + "\n", + "plt.plot(data3,\n", + " label=\"Step 3 (Smoothed derivative of step 2)\",\n", + " color=colors[2])\n", + "plt.axhline(growth_bound,\n", + " linestyle=\"dashed\",\n", + " label=\"Growth bound (negligible growth cutoff)\",\n", + " color=colors[3])\n", + "\n", + "# Intersect\n", + "plt.axvline(sum_sensitivity,\n", + " linestyle=\"dashed\",\n", + " label=\"Growth bound intersect with step 3\",\n", + " color=colors[4])\n", + "plt.xticks(np.append(ax2.get_xticks(), sum_sensitivity).clip(min=0))\n", + "\n", + "# Legend\n", + "handles, labels = [], []\n", + "for ax in fig.axes:\n", + " for h, l in zip(*ax.get_legend_handles_labels()):\n", + " handles.append(h)\n", + " labels.append(l)\n", + "\n", + "plt.legend(handles, labels, loc='center left', bbox_to_anchor=(1.12, 0.5))\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "971f3107", + "metadata": {}, + "source": [ + "### Analysis of mean\n", + "\n", + "Find the mean height at various epsilons given the parameters above and record the data." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f2c9ec81", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "17f9e67eac1a489987a6a6ea91da1df1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/39 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dp_height_mean_maxes = [np.max(i) for i in data]\n", + "dp_height_mean_mins = [np.min(i) for i in data]\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.fill_between(epsilons, dp_height_mean_maxes, dp_height_mean_mins)\n", + "\n", + "heights_mean = np.mean(heights)\n", + "plt.axhline(heights_mean,\n", + " color=\"orange\",\n", + " label=f\"True mean ({round(heights_mean, 2)})\")\n", + "\n", + "plt.xticks(np.arange(max(epsilons)))\n", + "plt.title(\"Possible Private Responses vs Epsilon\\n(Mean Query)\")\n", + "plt.xlabel(\"Epsilon\")\n", + "plt.ylabel(\"Possible Private Responses (cm)\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "715f7cef", + "metadata": {}, + "source": [ + "From this data, we can see that you start to get diminishing returns around an epsilon of 5, thus for good privacy you should select an epsilon value lower than that." + ] + }, + { + "cell_type": "markdown", + "id": "846912ac", + "metadata": {}, + "source": [ + "### Plot range data\n", + "\n", + "Plot the range of the DP results found, and their difference from the true (non-private) mean." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "98cc7a55", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(epsilons, range_data, label=\"Range (max - min) of DP result\")\n", + "plt.plot(epsilons, [i / 2 for i in range_data],\n", + " label=\"Difference of DP result from true mean\")\n", + "plt.title(\"Accuracy of Private Responses\\n(Mean Query)\")\n", + "plt.xlabel(\"Epsilon\")\n", + "plt.ylabel(\"Centimeters\")\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/laplace_mechanism.ipynb b/laplace_mechanism.ipynb new file mode 100644 index 0000000..8b8edb6 --- /dev/null +++ b/laplace_mechanism.ipynb @@ -0,0 +1,450 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6b9078e7", + "metadata": {}, + "source": [ + "# Laplace Differential Privacy\n", + "\n", + "By [Armaan Bhojwani](https://armaanb.net) under [Praneeth Vepakomma](https://praneeth.mit.edu/)\n", + "\n", + "This notebook features the following differentially private operations on 1 dimensional dataset of ints with set bounds.\n", + "- Laplace Mechanism:\n", + " - Sum\n", + " - Count\n", + " - Mean\n", + " - Histogram\n", + " - Privacy Loss Random Variable\n", + " - Privacy Loss Distribution\n", + " \n", + "For operations on a dataset without set bounds (utilizing clipping), see laplace_example_class_height.ipynb\n", + " \n", + "### References\n", + "- https://programming-dp.com\n", + "- B. Pejó and D. Desfontaines, Guide to Differential Privacy Modifications\n", + "- https://github.com/google/differential-privacy/blob/main/common_docs/Privacy_Loss_Distributions.pdf\n", + "\n", + "### Status\n", + "- Complete" + ] + }, + { + "cell_type": "markdown", + "id": "5db8a18d", + "metadata": {}, + "source": [ + "## Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "88f65cb9", + "metadata": {}, + "outputs": [], + "source": [ + "# Privacy\n", + "epsilon = 1\n", + "\n", + "# Data\n", + "data_len = 150 # Length of dataset\n", + "data_low = 0 # Lowest value of dataset\n", + "data_high = 99 # Highest value of dataset" + ] + }, + { + "cell_type": "markdown", + "id": "c445c076", + "metadata": {}, + "source": [ + "## Build the dataset\n", + "Create dataset of ints that we can work with" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "584e2eba", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# Initialize Numpy RNG\n", + "rng = np.random.default_rng()\n", + "\n", + "# Increment data_high so that it includes the value specified\n", + "data_high += 1\n", + "\n", + "# Create dataset as defined by above parameters\n", + "x = rng.integers(low=data_low, high=data_high, size=(data_len))" + ] + }, + { + "cell_type": "markdown", + "id": "dcf7d907", + "metadata": {}, + "source": [ + "## Helper functions" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "95edf89e", + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "from scipy.stats import laplace\n", + "from common import *\n", + "\n", + "def laplace_noise(epsilon, sensitivity):\n", + " \"\"\" Generate laplace noise given parameters\n", + " Inputs:\n", + " epsilon: epsilon value to use\n", + " sensitivity: sensivitity of the mechanism\n", + " Output:\n", + " laplace noise (float) with specified parameters\n", + " \"\"\"\n", + "\n", + " return rng.laplace(scale=sensitivity / epsilon)\n", + "\n", + "\n", + "def laplace_mech(x, mech, epsilon, sensitivity, verbose=False):\n", + " \"\"\" Calculate a differentially private result using laplace noise\n", + " Inputs:\n", + " x: input dataset\n", + " mech: function to run on input, should take single parameter (x)\n", + " epsilon: epsilon value to use\n", + " sensitivity: sensitivity to use\n", + " verbose: print detail\n", + " Output:\n", + " (mech(x), mech(x) + laplace noise)\n", + " \"\"\"\n", + " mech_x = mech(x)\n", + " noise = laplace_noise(epsilon, sensitivity)\n", + "\n", + " # We round here so that the result with added noise is still an int, like\n", + " # the input. This is do-able because of DP's post-processing properties\n", + " mech_X = mech_x + round(noise)\n", + "\n", + " if verbose:\n", + " print(f\"Non-private {mech.__name__}: {mech_x}\")\n", + " print(f\"Private {mech.__name__}: {mech_X}\")\n", + "\n", + " return (mech_x, mech_X)" + ] + }, + { + "cell_type": "markdown", + "id": "f445ac2c", + "metadata": {}, + "source": [ + "## Query implementations\n", + "### Sum\n", + "Because the data is arbitrary and has publically-known bounds we can manually set the sensitivity to the data's range, however if the upper bound of the data was unknown, we should use a differentially private method of calculating the sensitivity, such as clipping. See the `laplace_example_class_height.ipynb` notebook for an example of this." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d267ca84", + "metadata": {}, + "outputs": [], + "source": [ + "sum_sensitivity = data_high - data_low\n", + "\n", + "sum_x, sum_X = laplace_mech(x, np.sum, epsilon, sum_sensitivity, verbose=True)" + ] + }, + { + "cell_type": "markdown", + "id": "ac4edb3c", + "metadata": {}, + "source": [ + "### Size\n", + "\n", + "The most that the sensitivity could be is 1, because we are doing a count query, and thus when adding or removing a record from the dataset, the most the result can change is 1." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a98163e4", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "size_sensitivity = 1\n", + "\n", + "size_x, size_X = laplace_mech(x, np.size, epsilon, size_sensitivity, verbose=True)" + ] + }, + { + "cell_type": "markdown", + "id": "332f4872", + "metadata": {}, + "source": [ + "### Mean\n", + "We can build off of the sum and to find the mean. It is important to apply DP to each of the individual steps of finding the mean, as opposed to finding the mean and then applying DP." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "96d2d36d", + "metadata": {}, + "outputs": [], + "source": [ + "# Find non-private mean\n", + "mean_x = sum_x / size_x\n", + "\n", + "# Find differentially private mean\n", + "mean_X = sum_X / size_X\n", + "\n", + "print(f\"Original mean: {mean_x}\")\n", + "\n", + "# Round private mean to same number of decimal places as original mean\n", + "print(f\"Private mean: {round(mean_X, len(str(mean_x).split('.')[1]))}\")" + ] + }, + { + "cell_type": "markdown", + "id": "8fe66045", + "metadata": {}, + "source": [ + "### Differentially private histogram" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "39a24954", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from matplotlib import ticker\n", + "\n", + "# Parameters\n", + "num_bins = 10\n", + "\n", + "# Generate non-private histogram\n", + "x_counts, bins = np.histogram(x, bins=num_bins)\n", + "\n", + "# Recount the bins in a private way\n", + "X_counts = [laplace_mech(i, lambda x: x, epsilon, 1)[1] for i in x_counts]\n", + "\n", + "\n", + "def plot_hist(bins, weights):\n", + " \"\"\" Styles DP histogram\n", + " Inputs:\n", + " bins: array of bin boundaries to use\n", + " weights: counts for each bin\n", + " Output:\n", + " Matplotlib plot ready to be plotted. Add whatever extra styling you \n", + " want, then call plt.show().\n", + " \"\"\"\n", + " \n", + " ax = plt.gca()\n", + "\n", + " # Set Y-Axis to reasonable bounds\n", + " if min(weights) > 20:\n", + " ax.set_ylim([0.9 * min(weights), max(weights) + 0.1 * min(weights)])\n", + " else:\n", + " ax.set_ylim([0, max(weights) + 2])\n", + " ax.set_yticks(\n", + " [i for i in range(int(max(weights)) + 2) if (i % 2 == 0)])\n", + "\n", + " # Set axis ticks\n", + " ax.yaxis.set_minor_locator(ticker.AutoMinorLocator())\n", + " plt.xticks(bins)\n", + "\n", + " # Add vertical lines between bars\n", + " [plt.axvline(x=i, color=\"w\") for i in bins]\n", + "\n", + " # Add counts to each bar\n", + " centers = [(bins[i] + bins[i + 1]) / 2 for i in range(np.size(weights))]\n", + " for yc, xc in zip(weights, centers):\n", + " ax.text(xc, yc + 0.5, \"%d\" % yc, ha=\"center\")\n", + "\n", + " # Plot\n", + " plt.hist(bins[:-1], bins, weights=weights)\n", + "\n", + "\n", + "# Plot non-private histogram\n", + "plt.title(\"Non-private histogram\")\n", + "plot_hist(bins, x_counts)\n", + "plt.show()\n", + "\n", + "# Plot private histogram\n", + "plt.title(\"Private histogram\")\n", + "plot_hist(bins, X_counts)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "597577b2", + "metadata": {}, + "source": [ + "## Quantifying privacy loss" + ] + }, + { + "cell_type": "markdown", + "id": "1f646ef3", + "metadata": {}, + "source": [ + "### Calculating privacy loss random variable (PLRV)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "fc945135", + "metadata": {}, + "outputs": [], + "source": [ + "from tqdm.notebook import tqdm\n", + "\n", + "\n", + "def calc_PLRV(x, mech, epsilon, sensitivity, num_samples=1, verbose=False):\n", + " \"\"\" Calculates the privacy loss random variable of a laplace DP mechanism\n", + " Inputs:\n", + " x: dataset to operate on\n", + " mech: query to apply on x\n", + " epsilon: epsilon value to use\n", + " sensitivity: mechanism sensitivity\n", + " num_samples: how many time to sample to PLRV\n", + " verbose: print detail\n", + " Output:\n", + " an array of samples of the PLRV with length num_samples\n", + " \"\"\"\n", + " \n", + " # Calculate original and private mech(x)\n", + " if verbose: print(\"On original database:\")\n", + " mech_x, mech_X = laplace_mech(x,\n", + " mech,\n", + " epsilon,\n", + " sensitivity,\n", + " verbose=verbose)\n", + "\n", + " output = []\n", + "\n", + " for i in tqdm(range(num_samples), disable=(num_samples < 5000)):\n", + " # Calculate original and private mech(x) on neighbouring dataset\n", + " x2 = create_neighbour(x, verbose=verbose)\n", + " if verbose: print(\"On neighbouring database:\")\n", + " mech_x2, mech_X2 = laplace_mech(x2,\n", + " mech,\n", + " epsilon,\n", + " sensitivity,\n", + " verbose=verbose)\n", + "\n", + " # Calculate PLRV\n", + " # See section 3.1 of Google paper\n", + " delta = abs(mech_x - mech_x2)\n", + " delta_tilde = delta / (sensitivity / epsilon)\n", + "\n", + " w = laplace.rvs(0, 1)\n", + " if w <= 0:\n", + " output.append(delta_tilde)\n", + " elif w >= delta_tilde:\n", + " output.append(-delta_tilde)\n", + " elif 0 < w and w < delta_tilde:\n", + " output.append(delta_tilde - 2 * w)\n", + "\n", + " return output\n", + "\n", + "\n", + "size_plrv = calc_PLRV(x, np.size, epsilon, size_sensitivity, 1, verbose=True)\n", + "print(f\"The PLRV of a size query is: {size_plrv}\")" + ] + }, + { + "cell_type": "markdown", + "id": "921727f2", + "metadata": {}, + "source": [ + "### Plotting privacy loss distribution (PLD)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "112aae28", + "metadata": {}, + "outputs": [], + "source": [ + "# Parameters\n", + "num_samples = 20000\n", + "num_bins = 50\n", + "\n", + "def plot_PLD(*plrv_func_args):\n", + " \"\"\" Plots the PLD\n", + " Inputs:\n", + " plrv_func_args: arguments to pass to calc_PLRV function\n", + " Output:\n", + " Matplotlib plots and prints\n", + " \"\"\"\n", + " data = calc_PLRV(*plrv_func_args)\n", + " plt.hist(data, bins=num_bins)\n", + " plt.title(\"Privacy loss distribution histogram for query\")\n", + " plt.show()\n", + "\n", + " plt.hist(data, bins=500, cumulative=True, histtype='step')\n", + " plt.title(\"Privacy loss distribution CDF for query\")\n", + " plt.show()\n", + "\n", + " abs_data = [abs(i) for i in data]\n", + " expected = np.mean(abs_data)\n", + " print(f\"The expected absolute value of the PLRV is {expected}\")" + ] + }, + { + "cell_type": "markdown", + "id": "b062b4dc", + "metadata": {}, + "source": [ + "### PLD of size query" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "efa65d51", + "metadata": {}, + "outputs": [], + "source": [ + "plot_PLD(x, np.size, epsilon, size_sensitivity, num_samples)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..46b3595 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +matplotlib +numpy +scipy +tqdm +seaborn +notebook \ No newline at end of file -- 2.39.2