o Ti@sxddlmZmZddlmZddlmZeGdddZddZe dkr:eeZ e dZ ee j e je jd Sd S) ) dataclassfield)Dataset)HfArgumentParserc@sZeZdZUdZedddidZeed<edddidZe ed <ed dd idZ e ed <d S)ScriptArgumentsa Arguments for the script. Args: test_size (`float`, *optional*, defaults to `0.1`): Fraction of the dataset to include in the test split. push_to_hub (`bool`, *optional*, defaults to `False`): Whether to push the dataset to the Hugging Face Hub. repo_id (`str`, *optional*, defaults to `"trl-internal-testing/zen"`): Hugging Face repository ID to push the dataset to. g?helpz5Fraction of the dataset to include in the test split.)defaultmetadata test_sizeFz4Whether to push the dataset to the Hugging Face Hub. push_to_hubztrl-internal-testing/zenz2Hugging Face repository ID to push the dataset to.repo_idN) __name__ __module__ __qualname____doc__rr float__annotations__r boolr strrrP/home/ubuntu/.local/lib/python3.10/site-packages/scripts/generate_zen_dataset.pyrs  rcCsv tdgdi}|j|dd}|r|j|ddtdgdi}|j|dd}|r2|j|d dtgdgd d }|j|dd}|rN|j|d dtgdgd gd d}|j|dd}|rm|j|ddtgdgdd}|j|dd}|r|j|ddtgdgdgdd}|j|dd}|r|j|ddtgdddggdddgddgdd gd!gd"gd#d$gd%d&gd'd(gd)ggd*d+d,gd-gd.gd/gd0gd1d2gd3ggdd4ggd5dd4gd4d4gd4dgd4gdgd4dgddgddgd4ggd6d4d4gdgd4gdgdgd4d4gdggd7} | j|dd} |r&| j|d8dtd9d:d;d<d=d>d<gd:d?d<d=d@d<gd:dAd<d=dBd<gd:dCd<d=dDd<gd:dEd<d=dFd<gd:dGd<d=dHd<gd:dId<d=dJd<gd:dKd<d=dLd<gd:dMd<d=dNd<gd:dOd<d=dPd<gd:dQd<d=dRd<gd:dSd<d=dTd<gd:dUd<d=dVd<gd:dWd<d=dXd<gd:dYd<d=dZd<gd:d[d<d=d\d<gd:d]d<d=d^d<gd:d_d<d=d`d<gd:dad<d=dbd<ggi} | j|dd} |r| j|dcdtdd:d;d<gd:d?d<gd:dAd<gd:dCd<gd:dEd<gd:dGd<gd:dId<gd:dKd<gd:dMd<gd:dOd<gd:dQd<gd:dSd<gd:dUd<gd:dWd<gd:dYd<gd:d[d<gd:d]d<gd:d_d<gd:dad<ggi} | j|dd} |r`| j|dddtd:d;d<gd:d?d<gd:dAd<gd:dCd<gd:dEd<gd:dGd<gd:dId<gd:dKd<gd:dMd<gd:dOd<gd:dQd<gd:dSd<gd:dUd<gd:dWd<gd:dYd<gd:d[d<gd:d]d<gd:d_d<gd:dad<ggd=d>d<gd=d@d<gd=dBd<gd=dDd<gd=dFd<gd=dHd<gd=dJd<gd=dLd<gd=dNd<gd=dPd<gd=dRd<gd=dTd<gd=dVd<gd=dXd<gd=dZd<gd=d\d<gd=d^d<gd=d`d<gd=dbd<ggd } | j|dd} |r7| j|dedtd:d;d<gd:d?d<gd:dAd<gd:dCd<gd:dEd<gd:dGd<gd:dId<gd:dKd<gd:dMd<gd:dOd<gd:dQd<gd:dSd<gd:dUd<gd:dWd<gd:dYd<gd:d[d<gd:d]d<gd:d_d<gd:dad<ggd=d>d<gd=d@d<gd=dBd<gd=dDd<gd=dFd<gd=dHd<gd=dJd<gd=dLd<gd=dNd<gd=dPd<gd=dRd<gd=dTd<gd=dVd<gd=dXd<gd=dZd<gd=d\d<gd=d^d<gd=d`d<gd=dbd<ggd=dfd<gd=dgd<gd=dhd<gd=did<gd=djd<gd=dkd<gd=dld<gd=dmd<gd=dnd<gd=dod<gd=dpd<gd=dqd<gd=drd<gd=dsd<gd=dtd<gd=dud<gd=dvd<gd=d^d<gd=dwd<ggd} | j|dd} |rn| j|dxdtd:d;d<d=d>d<gd:d?d<d=d@d<gd:dAd<d=dBd<gd:dCd<d=dDd<gd:dEd<d=dFd<gd:dGd<d=dHd<gd:dId<d=dJd<gd:dKd<d=dLd<gd:dMd<d=dNd<gd:dOd<d=dPd<gd:dQd<d=dRd<gd:dSd<d=dTd<gd:dUd<d=dVd<gd:dWd<d=dXd<gd:dYd<d=dZd<gd:d[d<d=d\d<gd:d]d<d=d^d<gd:d_d<d=d`d<gd:dad<d=dbd<ggd:d;d<d=dfd<gd:d?d<d=dgd<gd:dAd<d=dhd<gd:dCd<d=did<gd:dEd<d=djd<gd:dGd<d=dkd<gd:dId<d=dld<gd:dKd<d=dmd<gd:dMd<d=dnd<gd:dOd<d=dod<gd:dQd<d=dpd<gd:dSd<d=dqd<gd:dUd<d=drd<gd:dWd<d=dsd<gd:dYd<d=dtd<gd:d[d<d=dud<gd:d]d<d=dvd<gd:d_d<d=d^d<gd:dad<d=dwd<ggd}|j|dd}|r|j|dydtd:d;d<gd:d?d<gd:dAd<gd:dCd<gd:dEd<gd:dGd<gd:dId<gd:dKd<gd:dMd<gd:dOd<gd:dQd<gd:dSd<gd:dUd<gd:dWd<gd:dYd<gd:d[d<gd:d]d<gd:d_d<gd:dad<ggd=d>d<gd=d@d<gd=dBd<gd=did<gd=dFd<gd=dHd<gd=dJd<gd=dmd<gd=dNd<gd=dod<gd=dRd<gd=dqd<gd=dVd<gd=dsd<gd=dtd<gd=d\d<gd=d^d<gd=d`d<gd=dbd<gggdzd}|j|dd}|r|j|d{ddSdS)|Ntext)zBeautiful is better than ugly.z!Explicit is better than implicit.zSimple is better than complex.z#Complex is better than complicated.zFlat is better than nested.zSparse is better than dense.zReadability counts.z7Special cases aren't special enough to break the rules.z#Although practicality beats purity.z"Errors should never pass silently.zUnless explicitly silenced.z9In the face of ambiguity, refuse the temptation to guess.zEThere should be one-- and preferably only one --obvious way to do it.zBAlthough that way may not be obvious at first unless you're Dutch.Now is better than never.z0Although never is often better than *right* now.z:If the implementation is hard to explain, it's a bad idea.z@If the implementation is easy to explain, it may be a good idea.z@Namespaces are one honking great idea -- let's do more of those!F)r shufflestandard_language_modeling) config_nameprompt)Beautiful is better thanz Explicit iszSimple is betterComplexFlat is better thanzSparse is better ReadabilityzSpecial cases aren't specialAlthough practicality beatszErrors should neverzUnless explicitly In the face of ambiguity, refusez$There should be one-- and preferablyz;Although that way may not be obvious at first unless you'rezNow iszAlthough never is oftenz)If the implementation is hard to explain,zIf the implementation is easyz Namespaces are one honking greatstandard_prompt_only) ugly.z better than implicit.z than complex. is better than complicated. nested.z than dense. counts.z enough to break the rules. purity. pass silently.z silenced. the temptation to guess.! only one --obvious way to do it.z Dutch. better than never.z better than *right* now. it's a bad idea.z# to explain, it may be a good idea.z idea -- let's do more of those!)r completionstandard_prompt_completion)z the moon. worse than nothing. than a long vacation.z is always the answer.z chocolate. without any context.z is optional. enough to become unicorns.z reality.z pass their driving test. forgotten.z the opportunity to laugh.z two or more confusing methods. a time traveler.z never better. not even a possibility.z it's clearly the best choice. it's probably magic. watermelon -- let's plant some!)rchosenrejectedstandard_preference)z"Beautiful is better than the moon.zExplicit is worse than nothing.z&Simple is better than a long vacation.zComplex is always the answer.zFlat is better than chocolate.z%Sparse is better without any context.zReadability is optional.z7Special cases aren't special enough to become unicorns.z$Although practicality beats reality.z,Errors should never pass their driving test.zUnless explicitly forgotten.z:In the face of ambiguity, refuse the opportunity to laugh.zCThere should be one-- and preferably two or more confusing methods.zLAlthough that way may not be obvious at first unless you're a time traveler.zNow is never better.z/Although never is often not even a possibility.zGIf the implementation is hard to explain, it's clearly the best choice.z2If the implementation is easy it's probably magic.z@Namespaces are one honking great watermelon -- let's plant some!)r9r:#standard_implicit_prompt_preference)r$r0r1r%r&r2r'r3r(r)r4r*r+r5r,r6r-r7r8)TFFTTFTFTTFTTFTFTFF)rr.labelstandard_unpaired_preference)rzExplicit is better thanzSimple is better thanzComplex is better thanrzSparse is better thanzReadability countsz#Special cases aren't special enoughr!zErrors should never passr"z0There should be one-- and preferably only one --zAlthough that way may not bezNow is better thanzNever is often better thanz.If the implementation is hard to explain, it'sz,If the implementation is easy to explain, itzNamespaces are onez-Although practicality sometimes beats purity,z, let me think...r$)z , of course,z implicit.z because clarity matters.z... let's keep it basic,z complex.z when needed,z complicated.z in terms of structure,r&z... especially for readability.z especially when others read it.z , unless...z they follow the rules.z some theoretical elegance,r(z silently,z unless explicitly silenced.r*)z way to do it,z but sometimes it's not obvious.z3 especially when there's more than one possibility.z clear at first,z it will eventually emerge.z later.z problematic fixes.z% likely because it's too complicated.z might be a good design.z of those great ideas,z that solve many problems.z' the code should still aim for balance.T)FTF)TTF)r completionslabelsstandard_stepwise_supervisionmessagesuserzWhat is better than ugly?)rolecontent assistantz Beautiful.zWhat is better than implicit?z Explicit.zWhat is better than complex?zSimple.z What is better than complicated?zComplex.zWhat is better than nested?zFlat.zWhat is better than dense?zSparse.z What counts?z Readability.z,Are special cases enough to break the rules?z;No, special cases aren't special enough to break the rules.zWhat beats purity?z Practicality.z What should never pass silently?zErrors.zWhen can errors pass silently?zWhen explicitly silenced.z,What should you do in the face of ambiguity?zRefuse the temptation to guess.z'How many ways should there be to do it?zOne, and preferably only one.z-For whom may the way not be obvious at first?zDutch.zWhat is better than never?rz!Is never better than *right* now?z Yes, often.z;What does it mean if the implementation is hard to explain?zIt means it's a bad idea.z;What does it mean if the implementation is easy to explain?zIt means it may be a good idea.zAny great ideas?z&Namespaces are one honking great idea. conversational_language_modelingconversational_prompt_only conversational_prompt_completionz Acceptable.z Explained.z Very complex.zVery complicated.z Circular.zHeavy.zLooking complicated.z9Yes, special cases are special enough to break the rules.zNothing.z Warnings.zNever.zGive up.zAs many as possible.zFrench.z Some day.z No, never.zIt means it's a good idea.z Recursion.conversational_preference)conversational_implicit_prompt_preference)TTTFTTTFTFTFTFFTTTT"conversational_unpaired_preference)r from_dicttrain_test_splitr )r r r "standard_language_modeling_datasetstandard_prompt_only_dataset"standard_prompt_completion_datasetstandard_preference_dataset+standard_implicit_prompt_preference_dataset$standard_unpaired_preference_dataset%standard_stepwise_supervision_dataset(conversational_language_modeling_dataset"conversational_prompt_only_dataset(conversational_prompt_completion_dataset!conversational_preference_dataset1conversational_implicit_prompt_preference_dataset*conversational_unpaired_preference_datasetrrrmain1s,A,-@                                                         ,                                                         A,                                      -r\__main__N) dataclassesrrdatasetsr transformersrrr\r parserparse_args_into_dataclasses script_argsr r r rrrrs  d