>> [მუსიკალური სათამაშო]
DUSTIN TRAN: Hi.
ჩემი სახელის Dustin.
ასე რომ მე იქნება წარდგენის მონაცემთა ანალიზი რ
უბრალოდ ცოტა თავს.
მე გაკეთებული კურსდამთავრებული საინჟინრო და გამოყენებითი მეცნიერებები.
ვსწავლობ კვეთა მანქანა სწავლისა და სტატისტიკა
ასე მონაცემთა ანალიზი R არის მართლაც ფუნდამენტური რა
გავაკეთო ყოველდღიურად.
>> და R განსაკუთრებით კარგი მონაცემების ანალიზი
იმიტომ, რომ ეს ძალიან კარგი prototyping.
და, როგორც წესი, როდესაც თქვენ აკეთებთ გარკვეული მონაცემთა ანალიზი, ბევრი პრობლემა
ვაპირებთ შემეცნებითი.
და ასე რომ თქვენ უბრალოდ გვინდა ზოგიერთი მართლაც კარგი ენა, რომელიც
მხოლოდ კარგი აკეთებს ჩაშენებული ფუნქციები, როგორც ეწინააღმდეგებოდა
მქონე გამკლავება დაბალი დონე რამ.
ასე დასაწყისში, მე უბრალოდ აპირებს დანერგვა რა არის R, რატომ
თქვენ გინდათ გამოიყენოთ იგი, და მერე მეტი შევიდა რამდენიმე დემო,
და მერე იქიდან.
>> რა არის R?
R უბრალოდ ენა მიერ შემუშავებული სტატისტიკური computing
და ვიზუალიზაცია.
რა ეს იმას ნიშნავს, რომ ეს არის ძალიან კარგი ენის
ნებისმიერი სახის რამ, რომელიც ეხება გაურკვევლობის ან მონაცემების ვიზუალიზაცია.
ასე რომ თქვენ გაქვთ ყველა ამ ალბათობა დისტრიბუციის.
იქ იქნება ჩაშენებული ფუნქციები.
თქვენ ასევე აქვს შესანიშნავი შეთქმულება პაკეტები.
>> პითონი არის კიდევ ერთი კონკურენტი ენის მონაცემები.
და ერთი რამ, რომ მე რომ R არის ბევრად უკეთესი ვიზუალიზაცია.
ასე რომ, რას დავინახავთ დემო კარგად არის უბრალოდ ძალიან ინტუიტიური ენის
რომ მხოლოდ მუშაობს ძალიან კარგად.
ეს არის ასევე უფასო და ღია კოდის, როგორც ნებისმიერი სხვა კარგი ენის ვფიქრობ.
>> და აქ, რამოდენიმე უბრალოდ საკვანძო სიტყვები ესროლეს თქვენ.
ეს დინამიური, რაც იმას ნიშნავს, თუ თქვენ გაქვთ კონკრეტული ტიპის ენიჭება ობიექტი
ვიდრე ეს უბრალოდ შეცვლის შესახებ fly.
ეს ზარმაცი ისე, რომ ჭკვიანი შესახებ როგორ აკეთებს გათვლები.
ფუნქციური მნიშვნელობით იგი ნამდვილად მოქმედებს ეფუძნება off ფუნქცია, ასე რომ არაფერი
ნებისმიერი სახის მანიპულირება თქვენ აკეთებს, ეს იქნება დაფუძნებული off ფუნქციები.
>> ასე ბინარული ოპერატორები, მაგალითად, არის მხოლოდ არსებითად ფუნქციები.
და ყველაფერი, რაც თქვენ გაკეთებას აპირებს
იქნება გაიქცევა ფუნქციები თავად.
და შემდეგ ობიექტზე ორიენტირებული ასევე.
>> ასე რომ, აქ არის xkcd ნაკვეთი.
არა მხოლოდ იმიტომ, რომ ვგრძნობ, როგორიცაა Xkcd არის ფუნდამენტური ნებისმიერი სახის
პრეზენტაცია, არამედ იმიტომ, მე ვგრძნობ, რომ ეს მართლაც
hammers იმ თვალსაზრისით, რომ ბევრი დრო, როდესაც თქვენ აკეთებთ გარკვეული მონაცემები
ანალიზი, პრობლემა არ არის იმდენად, რამდენად სწრაფად გადის,
მაგრამ რამდენი ხანი აპირებს გადაგიყვანთ პროგრამის ამოცანა.
ასე რომ, აქ მხოლოდ ანალიზის თუ სტრატეგია ან ბ უფრო ეფექტური.
ეს იქნება რაღაც, რომ თქვენ
აპირებთ გაუმკლავდეთ ბევრი in სახის დაბალი დონის ენაზე
სადაც თქვენ საქმე seg ხარვეზებით, მეხსიერების გამოყოფის, initializations,
მაშინაც კი, რაც ჩაშენებული ფუნქციები.
და ამ პერსონალის არის ყველა სიფრთხილით ძალიან, ძალიან ელეგანტურად R.
>> ასე რომ მხოლოდ ჩაქუჩი ამ წერტილი, დიდი bottleneck
იქნება შემეცნებითი.
ასე მონაცემთა ანალიზი არის ძალიან რთული პრობლემაა.
თუ თქვენ აკეთებთ მანქანა სწავლის ან თქვენ
აკეთებს მხოლოდ გარკვეული ძირითადი მონაცემების მოძიება,
თქვენ არ გსურთ აქვს მიიღოს დოკუმენტი
და შემდეგ ადგენენ რაღაც ყველა დროის
გვინდა, რა სვეტი ჰგავს, რა მასალაა matrix
ჰგავს.
ასე, რომ თქვენ უბრალოდ გვინდა ზოგიერთი მართლაც ლამაზი ინტერფეისი
თქვენ შეგიძლიათ აწარმოებს მარტივი ფუნქცია რომ ინდექსები, რაც არ უნდა
გსურთ და უბრალოდ გაუშვით იქიდან.
და თქვენ უნდა domain კონკრეტულ ენებზე ამ.
და R ნამდვილად დაგეხმარებათ განსაზღვრავს პრობლემა და გადაწყვიტოს იგი ამ გზით.
>> ასე რომ, აქ არის მიწის ნაჩვენებია პროგრამირების პოპულარობა R, როგორც ის წავიდა დროთა განმავლობაში.
ასე რომ, როგორც ხედავთ, როგორიცაა 2013 ან ასე რომ მხოლოდ ააფეთქეს საოცრად.
და ეს უკვე მხოლოდ იმიტომ, რომ დიდი ტენდენცია ტექნოლოგია ინდუსტრიაში
შესახებ დიდი მონაცემები.
ასევე, არა მხოლოდ ტექნიკა მრეწველობის, მაგრამ ნამდვილად
ნებისმიერ ინდუსტრიაში that-- რადგან ბევრი მრეწველობის
არსებობს ერთგვარი ფუნდამენტური ცდილობს ამ პრობლემების მოგვარებას.
და, როგორც წესი, შეგიძლიათ რამდენიმე კარგი გზა საზომი ამ პრობლემების
ან თუნდაც განსაზღვრავს მათ ან მათი გადაჭრის გამოყენებით მონაცემები.
ამიტომ მე ვფიქრობ, ახლა R -11 ყველაზე პოპულარული ენა TIOBE
და ეს უკვე იზრდება მას შემდეგ.
>> ასე რომ, აქ არის კიდევ რამდენიმე მახასიათებლები R. მას აქვს
უზარმაზარი რაოდენობის პაკეტები და ყველა ამ სხვადასხვა რამ.
ისე ნებისმიერ დროს თქვენ გაქვთ გარკვეული პრობლემა, ყველაზე
დრო R ექნება რომ ფუნქცია თქვენთვის.
ასე რომ, თუ გსურთ ავაშენოთ გარკვეული მანქანა
სწავლის ალგორითმი მოუწოდა შემთხვევითი ტყის ან გადაწყვეტილება ხეები,
ან თუნდაც მიიღოს საშუალო ფუნქცია ან ამ პერსონალის,
R ექნება, რომ.
>> და თუ თქვენ აინტერესებს ოპტიმიზაცია, ერთი რამ, რომ საერთო
ის არის, რომ მას შემდეგ, რაც თქვენ გაკეთდეს prototyping გარკვეული მაღალი დონის ენა,
თქვენ იმისათვის, რომ in-- თქვენ მხოლოდ პორტი, რომ მეტი
ზოგიერთი დაბალი დონის ენა.
რა არის კარგი R არის, რომ ერთხელ თქვენ კეთდება prototyping it, თქვენ შეგიძლიათ აწარმოებს C ++,
ან Fortran, ან ეს ქვედა დონეზე, ვინც პირდაპირ R.
ასე რომ, ერთი ნამდვილად მაგარი თვისება შესახებ R,
თუ თქვენ ნამდვილად აინტერესებს ოპტიმიზაციის წერტილი.
>> და ეს ასევე ძალიან კარგი ვებ თვალსაჩინოება.
ასე D3.js, მაგალითად, ვფიქრობ სხვა სემინარზე
რომ ჩვენ პრეზენტაცია დღეს გაიმართა.
და ეს მართლაც გასაოცარია აკეთებს ინტერაქტიული თვალსაჩინოება.
და D3.js ვარაუდობს, რომ თქვენ უნდა გარკვეული მონაცემები უნდა პროპაგანდისტულ
და R არის დიდი გზა, რომ ვერ გააკეთებს მონაცემების ანალიზი, სანამ ექსპორტის მას
მეტი D3.js ან თუნდაც უბრალოდ აწარმოებს D3.js ბრძანებები R თავად,
ისევე, როგორც ყველა ამ სხვა ბიბლიოთეკების ასევე.
>> ისე, რომ მხოლოდ დანერგვა რა არის R და რატომ შეიძლება გამოიყენოს იგი.
ასე რომ, იმედია, მე დარწმუნებულნი ვართ, რაღაც
უბრალოდ ცდილობს დაინახოს, რასაც ის, როგორც.
ამიტომ, მე ვაპირებ წავიდეთ წინ და გაიაროს გარკვეული საფუძვლები შესახებ R ობიექტები
და რა შეგიძლიათ ნამდვილად.
>> ასე რომ, აქ არის მხოლოდ bunch of მათემატიკის ბრძანებები.
ასე ვთქვათ you're-- გსურთ აშენება ენის თავს და თქვენ უბრალოდ
აქვს bunch სხვადასხვა ინსტრუმენტები.
ნებისმიერი სახის ოპერაცია ფიქრობთ ნეტავ მინდა საკმაოდ ბევრი იქნება R.
>> ასე რომ აქ არის 2 plus 2.
აქ არის 2 ჯერ pi.
R აქვს რამოდენიმე ჩაშენებული მუდმივები ის, რომ თქვენ ხშირად იყენებენ, როგორიცაა pi, e.
>> და მაშინ, აქ არის 7 plus runif, ასე runif 1.
ეს არის ფუნქცია, რომელიც არის საერთოდ ერთი შემთხვევითი ერთიანი 0-დან 1.
და შემდეგ იქ 3 ძალა 4.
იქ მოედანზე ფესვები.
>> იქ შესვლა.
ასე რომ შედით გააკეთებს ბაზა exponential თავისთავად.
და მაშინ, თუ თქვენ მიერ მითითებული ბაზა, მაშინ შეგიძლიათ გააკეთოთ რასაც ბაზაზე გსურთ.
და მაშინ აქ არის რამოდენიმე სხვა ბრძანებები.
ასე რომ თქვენ უნდა 23 mod 2.
მაშინ თქვენ გაქვთ დარჩენილი.
მაშინ თქვენ უნდა სამეცნიერო ნოტაცია თუ ასევე
მინდა ამის გაკეთება მხოლოდ უფრო და უფრო რთული რამ.
>> ასე რომ აქ არის დავალება.
იმდენად ტიპიური დავალებები R კეთდება arrow
ასე რომ, ნაკლები და შემდეგ დეფისი.
ასე რომ, აქ მე უბრალოდ მინიჭების 3 ცვლადი val.
>> და მაშინ მე დაბეჭდვისას val და მერე ბეჭდავს out სამი.
სტანდარტულად in R თარჯიმანი, ის ბეჭდვა რამ out თქვენთვის
ასე რომ თქვენ არ უნდა მიუთითოთ ბეჭდვა val ნებისმიერ დროს გსურთ ბეჭდვა რაღაც.
შეგიძლიათ უბრალოდ val და შემდეგ ის ყველაფერს გააკეთებს, რომ თქვენ.
>> ასევე, შეგიძლიათ გამოიყენოთ ტოლია ტექნიკურად როგორც დავალება ოპერატორი.
არსებობს მცირე ნიუანსები შორის გამოყენებით arrow
ოპერატორი და ტოლობის ოპერატორი დავალებები.
ძირითადად კონვენციის, ყველას უბრალოდ გამოიყენოთ arrow ოპერატორი.
>> და აქ, მე მინიჭების ეს oblique notation მოუწოდა 1 colon 6.
ეს წარმოშობს ვექტორი 1-დან 6.
და ეს მართლაც კარგია, რადგან მაშინ თქვენ დაავალოს ვექტორი val
და რომ მუშაობს თავისთავად.
>> ასე რომ, ეს უკვე მიმდინარეობს from single-- ძალიან ინტუიციური მონაცემები
სტრუქტურა უბრალოდ ორმაგი ზოგიერთი ტიპის ტიპის შევიდა ვექტორი
და რომელიც შეაგროვოს ყველა სკალარული ღირებულებების თქვენთვის.
ასე შემდეგ აპირებს საწყისი სკალარული, თქვენ აქვს R ობიექტები და ეს არის ვექტორი.
ვექტორი არის ნებისმიერი სახის კოლექცია იგივე ტიპის.
ასე რომ, აქ არის რამოდენიმე ვექტორები.
>> ასე რომ, ეს არის რიცხვითი.
რიცხვითი არის R გზა ამბობდა ორმაგი.
და ასე იყოს, რომ ნებისმიერი ნომერი იქნება ორმაგი.
>> ასე რომ, თუ თქვენ გაქვთ c 1.1, 3, უარყოფითი 5.7, c ფუნქცია.
ამ concatenates სამივე ნომრები შევიდა ვექტორი.
და ეს be-- ასე რომ, თუ თქვენ შეამჩნევთ 3 თავისთავად,
ჩვეულებრივ, თქვენ ვივარაუდოთ, რომ ეს არის, როგორც მთელი რიცხვი,
არამედ იმიტომ, რომ ვექტორები არის იგივე ტიპის,
ეს არის ვექტორი ორადგილიანი ან რიცხვითი ამ შემთხვევაში.
>> rnorm არის ფუნქცია, რომელიც ქმნის სტანდარტული ნორმალური ცვლადის
ან სტანდარტული ნორმალური ღირებულებებს.
და მე მითითებით ორი მათგანი.
ასე რომ მე ვაკეთებ rnorm 2, იმის, რომ devs, და შემდეგ მე დაბეჭდვისას devs.
ასე რომ ეს არის მხოლოდ ორი შემთხვევითი ნორმალური ღირებულებებს.
>> და შემდეგ ints თუ თქვენ აკეთებთ თქვენ აინტერესებს რიცხვებით.
ასე რომ, ეს არის მხოლოდ მეხსიერება გამოყოფა და გადარჩენის მეხსიერების ზომა.
ასე, რომ თქვენ უნდა დამატება თქვენი ნომრები კაპიტალის L.
>> ზოგადად, ეს არის R ისტორიული notation
რაღაც მოუწოდა ხანგრძლივი რიცხვი.
ასე რომ ყველაზე მეტად დროს, თქვენ იქნება საქმე ორჯერ.
და თუ ოდესმე მოგვიანებით on ოპტიმიზაცია თქვენი კოდი,
თქვენ შეგიძლიათ დაამატოთ ეს L's ამის შემდეგ ან დროს, მასში
თუ თქვენ, ისევე precognitive შესახებ, თუ რა თქვენ ვაპირებთ გავაკეთოთ ამ ცვლადებს.
>> ასე რომ, აქ არის ხასიათი ვექტორი.
ასე რომ, კიდევ ერთხელ, მე ინტეგრირების სამი სტრიქონები ამ დროს.
გაითვალისწინეთ, რომ ორმაგი strings და ერთი სიმები არის იგივე რ
ასე რომ, მე arthur და marvin და ასე როდესაც მე ბეჭდვა ეს, ყველა მათგანი
ვაპირებთ, რომ ნახოთ ორმაგი strings.
და თუ თქვენ ასევე მინდა მოიცავს ორმაგი ან ერთჯერადი string
თქვენი პერსონაჟი, მაშინ თქვენ შეგიძლიათ ან ალტერნატიული თქვენს სიმები.
>> ასე marvin ის, მეორე ელემენტს, ეს არის
აპირებს show-- თქვენ უბრალოდ ორმაგი strings
და შემდეგ ერთი string ასე რომ, ეს არის ცვლადი.
წინააღმდეგ შემთხვევაში, თუ გსურთ გამოიყენოთ ორმაგი string ოპერატორი ორმაგი სიმებიანი
როდესაც თქვენ გამოცხადების მას, მაშინ უბრალოდ გამოიყენოთ გაქცევის ოპერატორი.
ასე რომ თქვენ წარმატებული ორმაგი სიმებიანი.
>> და ბოლოს, ჩვენ ასევე ლოგიკური ვექტორები.
ასე logical-- ასე TRUE და FALSE, და ისინი
იქნება ყველა ასოებით.
და შემდეგ, კიდევ ერთხელ, მე ინტეგრირების მათ და შემდეგ იმის მათ bools.
ასე bools აპირებს აჩვენებს თქვენ TRUE, FALSE, და სიმართლე.
>> ასე რომ აქ არის vectorized ინდექსირებას.
ასე დასაწყისში, I ვიღებ ფუნქცია
ეს ეწოდება sequence-- თანმიმდევრობა 2 დან 12.
და მე აღების თანმიმდევრობა 2.
ასე რომ, ის აპირებს 2, 4, 6, 8, 10 და 12.
და მაშინ, მე ინდექსირებას მიიღოს მესამე ელემენტს.
>> ასე რომ ერთი რამ უნდა გვახსოვდეს არის რომ R ინდექსები მიერ დაწყებული 1.
ასე vals 3 აპირებს თქვენ მესამე ელემენტს.
ეს არის ერთგვარი განსხვავდება სხვა ენებზე, სადაც იგი იწყებს ნულიდან.
ასე რომ, C ან C ++, მაგალითად, თქვენ აპირებს მიიღოს მეოთხე ელემენტს.
>> და აქ არის vals 3-დან 5.
ასე რომ, ერთი რამ, რომ მართლაც მაგარი ის არის, რომ თქვენ
შეგიძლიათ გენერირება დროებითი ცვლადები შიგნით და მხოლოდ მაშინ გამოიყენეთ მათ on the fly.
ასე რომ აქ არის 3 დან 5.
ასე რომ, მე მომტანი ვექტორი 3, 4, 5 და მაშინ
მე ინდექსირებას მიიღოს მესამე, მეოთხე და მეხუთე ელემენტს.
>> ისე ანალოგიურად, თქვენ შეგიძლიათ აბსტრაქტული ამ უბრალოდ
ნებისმიერი სახის ვექტორი რომელიც გაძლევთ ინდექსირებას.
ასე რომ აქ არის vals და შემდეგ პირველი, მესამე და მეექვსე ელემენტებს.
და მაშინ, თუ გსურთ გავაკეთოთ დაკომპლექტდეს,
ასე რომ თქვენ უბრალოდ მინუს შემდგომ და სწორედ ამას
გაძლევთ ყველაფერი, რაც არ არის პირველი, მესამე, ან მეექვსე ელემენტს.
ასე რომ, ეს იქნება 4, 8 და 10.
>> და თუ გსურთ მიიღოთ კიდევ უფრო მოწინავე,
თქვენ შეგიძლიათ concatenate ლოგიკური ვექტორები.
ასე რომ, ეს ინდექსი აპირებს მოგცემთ ეს ლოგიკური ვექტორი სიგრძის 6.
ასე rep TRUE მძიმით 3.
ეს იქნება გავიმეორო TRUE სამჯერ.
ასე რომ, ეს მოგცემთ ვექტორი TRUE, ნამდვილი, ჭეშმარიტი.
>> rep FALSE 4-- ამ აპირებს მოგცემთ ვექტორი, ყალბი, ყალბი, ყალბი, ყალბი.
და მაშინ c აპირებს concatenate ამ ორი Booleans ერთად.
ასე რომ თქვენ აპირებთ მისაღებად სამი Trues და შემდეგ ოთხი FALSEs.
>> ასე რომ, როდესაც თქვენ ინდექსი vals, თქვენ აპირებს მიიღოს ნამდვილი, ჭეშმარიტი, ნამდვილი.
ასე რომ აპირებს ვთქვა, დიახ, მინდა იმ სამი ელემენტები.
და მაშინ ყალბი, ყალბი, ყალბი, ყალბი აპირებს
ვთქვათ, მე არ მინდა იმ ელემენტებს ასე რომ ის არ აპირებს დაბრუნებას მათ.
>> და მე ვფიქრობ, რომ რეალურად ტექსტის არასწორი ფრაგმენტი აქ იმიტომ, რომ ეს ამბობს განმეორებითი TRUE 3
და ვიმეორებ FALSE 4, ტექნიკურად, თქვენ მხოლოდ ექვსი ელემენტები ისე, ვიმეორებ FALSE,
ეს უნდა იყოს განმეორებითი FALSE 3.
მე ვფიქრობ, R, ასევე ჭკვიანი საკმარისი ასეთი იმ შემთხვევაში, თუ თქვენ უბრალოდ მიუთითოთ 4 აქ, მაშინ
ის კი არ შეცდომას.
ეს იქნება მხოლოდ გადმოგცეთ ეს მნიშვნელობა.
ასე რომ, ეს უბრალოდ იგნორირება, რომ მეოთხე FALSE.
>> ასე რომ აქ არის vectorized დავალება.
ასე set.seed-- ეს უბრალოდ ადგენს სათესლე pseudorandom ნომრები.
ასე რომ, მე შექმნის თესლი 42, რაც იმას ნიშნავს, რომ თუ მე გენერირება
სამი შემთხვევითი ნორმალური ღირებულებები, და შემდეგ, თუ
აწარმოებს set.seed საკუთარი კომპიუტერის გამოყენებით იგივე ღირებულება 42,
მაშინ თქვენ ასევე იგივე სამი შემთხვევითი normals.
>> ასე რომ, ეს არის ძალიან კარგი for reproducibility.
როგორც წესი, როდესაც თქვენ აკეთებთ ზოგიერთი ერთგვარი მეცნიერული ანალიზი,
თქვენ სურს შექმნას თესლი.
რომ გზა სხვა მეცნიერები შეგიძლიათ მხოლოდ რეპროდუცირება ზუსტად იგივე კოდი თქვენ
კეთდება იმიტომ, რომ ისინი უნდა ზუსტი ამავე შემთხვევითი ცვლადები that-- ან შემთხვევითი
ღირებულებები, რომ თქვენ მიღებული ასევე.
>> და ასე vectorized დავალება აქ ნაჩვენებია vals 1 2.
ისე სჭირდება პირველი ორი ელემენტები of vals და შემდეგ ანიჭებს მათ 0.
და შემდეგ, ასევე შეგიძლიათ მხოლოდ ამის მსგავსი რამ ერთად Booleans.
>> ასე vals არ არის უტოლდება 0 ნება გაძლევთ ვექტორი ყალბი, ყალბი, TRUE
ამ შემთხვევაში.
და შემდეგ, ის აპირებს ვთქვათ, რომ ნებისმიერი იმ ინდექსები ეს იყო ნამდვილი,
შემდეგ ის აპირებს დაავალოს, რომ 5.
ისე სჭირდება მესამე ელემენტს აქ და შემდეგ ანიჭებს მას 5.
>> და ეს მართლაც ლამაზი შედარებით დაბალი დონის ენებზე
სადაც თქვენ უნდა გამოიყენოთ მარყუჟების ყველაფერი ეს vectorized პერსონალი
რადგან ეს მხოლოდ ძალიან ინტუიტიური და ეს ერთი ლაინერი.
და რა დიდი vectorized notation
ის არის, რომ R, ეს არის ერთგვარი ჩაშენებული ისე, რომ ისინი თითქმის სწრაფად
როგორც აკეთებს დაბალი დონის ენის, როგორც განსხვავებით მიღების for loop in R
და შემდეგ მქონე ეს უნდა გააკეთოს დინამიური ინდექსირებას თავად.
და რომ ვიქნები ნელა, ვიდრე აკეთებს ამ სახის vectorized რამ
სადაც მას შეუძლია გააკეთოს ის პარალელურად, სადაც ის აკეთებს ამას threading ძირითადად.
>> ასე რომ, აქ არის ვექტორიზებული ოპერაციებში.
ასე რომ, მე მომტანი მნიშვნელობა 1-დან 3, მინიჭების, რომ vec1, 3 დან 5, vec2,
დამატებით მათ ერთად.
ის დასძენს, რომ მათ კომპონენტი ბრძენი ასე ეს არის 1 + 3, 2 პლუს 4, და ასე შემდეგ.
>> vec1 ჯერ vec2.
ამ მრავლდება ორ აფასებს კომპონენტი ბრძენი.
ასე რომ, ეს 1-ჯერ 3, 2 ჯერ 4, და შემდეგ 3-ჯერ 5.
>> და შემდეგ, ისევე, როგორც თქვენ შეგიძლიათ ამის გაკეთება comparisons-- ლოგიკური შედარება.
ასე რომ, ეს FALSE FALSE TRUE ამ საქმე, რადგან 1 არ აღემატება 3,
2 არ აღემატება 4.
ეს არის, ვფიქრობ, კიდევ typo, 3 ნამდვილად არ აღემატება 5.
Yeah.
და ასე რომ თქვენ შეგიძლიათ უბრალოდ ყველა ეს მარტივი ოპერაციები
იმიტომ, რომ მათ მემკვიდრეობით საწყისი კლასების თავს.
>> ისე, რომ მხოლოდ ვექტორი.
და ეს ერთგვარი ყველაზე ფუნდამენტურ R ობიექტი რადგან მოცემულ ვექტორი,
შეგიძლიათ აშენება უფრო მოწინავე ობიექტები.
>> ასე რომ აქ matrix.
ეს არის არსებითად აბსტრაქცია რა მატრიცა არის თავისთავად.
ასე რომ, ამ შემთხვევაში, ეს სამი სხვადასხვა ვექტორები, სადაც თითოეული სვეტი,
ან შეგიძლიათ განიხილოს ეს როგორც თითოეული ზედიზედ.
>> ასე რომ, მე შენახვის matrix 1-დან 9 და შემდეგ მე მითითებით 3 რიგები.
ასე 1-დან 9 მოგცემთ ვექტორი 1, 2, 3, 4, 5, 6, და ყველა გზა 9.
>> ერთი რამ უნდა გავითვალისწინოთ ის არის, რომ R მაღაზიები ღირებულებების სვეტი ძირითადი ფორმატში.
სხვა სიტყვებით, როდესაც ხედავთ 1 9, ის აპირებს შესანახად them--
ეს იქნება 1, 2, 3 პირველი სვეტი,
და შემდეგ ის ყველაფერს გააკეთებს, 4, 5, 6 მეორე სვეტი,
და შემდეგ 7, 8, 9, მესამე სვეტი.
>> და აქ არის რამოდენიმე სხვა საერთო ფუნქციები შეგიძლიათ გამოიყენოთ.
ასე dim mat, ეს მოგცემთ ზომები matrix.
ის აპირებს დაბრუნებას თქვენ ვექტორი განზომილებაში.
ასე რომ, ამ შემთხვევაში, რადგან ჩვენი matrix 3 3,
ის აპირებს მოგცემთ რიცხვითი ვექტორი, რომ 3 3.
>> და აქ მხოლოდ აჩვენებს matrix გამრავლება.
ასე ჩვეულებრივ, თუ უბრალოდ asterisk-- ასე mat ვარსკვლავით mat--
ეს იქნება კომპონენტი ბრძენი ოპერაცია
ან რასაც Hadamard პროდუქტი.
ამიტომ აპირებს გააკეთოს ყოველ ელემენტის კომპონენტის ბრძენი.
თუმცა, თუ გსურთ matrix გამრავლება
ასე გამრავლებით პირველი რიგის ჯერ მეორე matrix პირველი სვეტი
და ასე შემდეგ, თქვენ გამოიყენებს ეს პროცენტი ოპერაცია.
>> და ტ mat მხოლოდ ოპერაცია transpose.
ასე რომ, მე ვამბობ, მიიღოს transpose in მატრიცა, გავამრავლოთ ის მიერ matrix
თავად.
და შემდეგ ის აპირებს დაბრუნდება თქვენ კიდევ 3
3 matrix ჩვენება პროდუქტის თქვენ მინდა.
>> და ისე, რომ matrix.
აქ არის ის, რაც ე.წ. მონაცემების ფარგლებში.
მონაცემების ფარგლებში შეგიძლიათ წარმოიდგინოთ, როგორც მატრიცა, მაგრამ თითოეული სვეტის თავად
იქნება სხვადასხვა ტიპის.
>> რა არის მართლაც მაგარი მონაცემები ფარგლებში ის არის, რომ მონაცემთა ანალიზი თავად,
თქვენ აპირებს ყველა ამ ჰეტეროგენული მონაცემები და ყველა ეს მართლაც
ბინძურ რამ, სადაც თითოეული სვეტების თავად შეიძლება იყოს სხვადასხვა ტიპის.
ასე რომ, აქ მე ვამბობ, შექმნას მონაცემების ფარგლებში, ნუ ints 1-დან 3,
და შემდეგ ასევე აქვს ხასიათი ვექტორი.
ასე რომ, შემიძლია ინდექსი მეშვეობით თითოეული ეს სვეტები
და მაშინ მე კიდევ ღირებულებების თავს.
და ასევე შეგიძლიათ გავაკეთოთ გარკვეული ოპერაციების მონაცემები ფარგლებში.
და ყველაზე მეტი დრო, როდესაც თქვენ აკეთებს მონაცემთა ანალიზი და გარკვეული
of preprocessing, თქვენ უნდა მუშაობს ამ მონაცემების სტრუქტურები
სადაც ყოველი სვეტი აპირებს იყოს სხვადასხვა ტიპის.
>> საბოლოოდ, ასე რომ ეს არის არსებითად მხოლოდ ოთხი ძირითადი ობიექტების R. სია
უბრალოდ შეგროვება ნებისმიერი სხვა ობიექტები გსურთ.
ასე რომ შეინახავს ამ ერთ ცვლადი, რომ თქვენ შეგიძლიათ მარტივად.
>> ასე რომ, აქ, მე აღების სიაში.
მე ვამბობ, პერსონალის უდრის 3.
ამიტომ, მე ვაპირებ აქვს ერთ ელემენტს სიაში, და ეს ეწოდება პერსონალი,
და ის აპირებს აქვს მნიშვნელობა 3.
>> მე ასევე შეგიძლიათ შექმნათ matrix.
ასე რომ ეს არის 1 დან 4 და ბოლოს row უდრის 2, ასე რომ 2 by 2 matrix.
სიაში ასევე და ეს ე.წ. mat.
moreStuff, ხასიათი სიმებიანი, და კიდევ ერთი ნუსხა თავისთავად.
>> ასე რომ, ეს სია რომ 5 და დათვი.
ასე რომ, ეს ღირებულება 5 და ხასიათი აქვს string დათვი
და ეს სიაში სიაში.
ასე რომ თქვენ გაქვთ ეს რეკურსიული რამ, სადაც
თქვენ უნდა another-- ჩაწერეთ ფარგლებში ტიპის.
ისე ანალოგიურად, შეგიძლიათ აქვს matrix შიგნით კიდევ matrix და ასე შემდეგ.
და სიაში არის მხოლოდ კარგი გზა შეგროვება და აგრეგაცია
ყველა ამ სხვადასხვა ობიექტები.
>> და ბოლოს, აქ მხოლოდ დაეხმარება საქმე ეს მხოლოდ წავიდა ძალიან სწრაფად.
ასე რომ ნებისმიერ დროს თქვენ დაბნეული შესახებ გარკვეული ფუნქცია,
თქვენ შეგიძლიათ ამის დახმარებით, რომ ფუნქცია.
ასე რომ თქვენ შეგიძლიათ დახმარებას matrix ან კითხვის ნიშნის matrix.
და დახმარება და კითხვის ნიშნის არიან უბრალოდ სტენოგრამის იგივე
ასე რომ, ისინი მაგალითი.
>> lm არის ფუნქცია, რომელიც უბრალოდ არ წრფივი მოდელი.
მაგრამ თუ უბრალოდ არ ვიცი როგორ, რომ სამუშაოები, თქვენ შეგიძლიათ უბრალოდ დახმარებით lm
და რომ მოგცემთ ზოგიერთი სახის დოკუმენტაცია, რომ
გამოიყურება სახის მოსწონს კაცი გვერდი Unix, სადაც
თქვენ გაქვთ მოკლე აღწერა, თუ რა ეს ასეა, ასევე, რა არის მისი არგუმენტები,
ის, რაც დააბრუნებს, და მხოლოდ რჩევა, თუ როგორ გამოიყენოს იგი, და რამდენიმე მაგალითები, ასევე.
>> ნება მომეცით წავიდეთ წინ და შოუ ზოგიერთი დემო გამოყენებით R. OK.
ასე მივედი ძალიან სწრაფად მხოლოდ მონაცემები
სტრუქტურები და გარკვეული op-- ზოგიერთი ოპერაცია.
აქ არის გარკვეული ფუნქციები.
>> ასე რომ, აქ მე უბრალოდ აპირებს განსაზღვროს ფუნქცია.
ასე რომ მე ასევე გამოყენებით დავალება ოპერატორი აქ,
და მაშინ მე ვამბობ, აცხადებენ ეს ფუნქცია.
და ეს ხდება ღირებულება x.
ასე რომ, ეს არის ნებისმიერი ღირებულების გსურთ და მე ვაპირებ დაბრუნებას x თავად.
ასე რომ, ეს არის პირადობის ფუნქცია.
>> და რა არის cool შესახებ ეს შედარებით სხვა ენებზე
და კიდევ ერთი დაბალი დონის ენების, რომ x
შეიძლება იყოს ნებისმიერი ტიპის თავად და ეს კიდე დაბრუნდება ტიპის.
ასე რომ თქვენ შეგიძლიათ imagine-- ასე მიადევნე მე უბრალოდ გაუშვით ეს სწრაფად.
უკაცრავად.
>> ასე რომ, ერთი რამ უნდა აღინიშნოს, ის არის, რომ ამ რედაქტორი მე გამოყენებით
ეწოდება rstudio.
ეს არის ის, რაც ე.წ. IDE.
და ერთი რამ, რომ მართლაც ლამაზი ამ
არის ის, რომ აერთიანებს ბევრი რამ გვინდა გავაკეთოთ R თავისთავად
უბრალოდ ძალიან ინტუიციურად.
>> ასე რომ აქ არის თარჯიმნის კონსოლი.
ისე ანალოგიურად, ასევე შეგიძლიათ ეს console ნედლეული უბრალოდ ამით დედაქალაქში R.
და ეს არის ზუსტად იგივე როგორც კონსოლი.
ასე რომ, მე შემიძლია უბრალოდ id ფუნქცია x, x, x.
და შემდეგ, ხოლო შემდეგ კარგად იქნება თავად.
>> ასე rstudio დიდი იმიტომ, რომ მას კონსოლი.
მას ასევე აქვს დოკუმენტები გსურთ აწარმოებს.
და მაშინ მას აქვს რამდენიმე ცვლადი რომ თქვენ ხედავთ გარემოში.
და მაშინ, თუ თქვენ გაქვთ უნდა გავაკეთოთ ნაკვეთები, მაშინ თქვენ
შეგიძლიათ უბრალოდ ვხედავ აქ, როგორც ეწინააღმდეგებოდა მართვის ყველა ამ სხვადასხვა შუშები
თავად.
>> მე რეალურად პირადად გამოიყენოთ Vim, მაგრამ მე გრძნობს, როგორც rstudio არის შესანიშნავი მხოლოდ
მიღების კარგი იდეა თუ როგორ გამოიყენოთ R. როგორც წესი,
როდესაც თქვენ ცდილობთ ვისწავლოთ ახალი ამოცანა,
თქვენ არ გსურთ გაუმკლავდეს ძალიან ბევრი რამ ერთდროულად.
ასე R მხოლოდ very-- rstudio არის ძალიან კარგი გზა სწავლის R
გარეშე გამკლავება ყველა ამ სხვა რამ.
>> ასე რომ, აქ მე გაშვებული id hello.
ამ ბრუნდება hello.
id 123.
აქ არის ვექტორული რიცხვებით.
ასე ერთნაირად, რადგან თქვენ შეგიძლიათ მიიღოს ნებისმიერი გარკვეული ღირებულება,
თქვენ შეგიძლიათ ამის დაბრუნების პირადობის x ამიტომ დააბრუნებს 1234 და 5.
>> და ნება მომეცით უბრალოდ გაჩვენებთ, რომ ეს მართლაც რიცხვი.
და ანალოგიურად, თუ კლასი id x, ეს იქნება მთელი რიცხვი.
და შემდეგ, ასევე შეგიძლიათ შედარების ორი და ეს სიმართლეა.
ასე რომ, მე შემოწმების თუ id of x შეადგენს შეადგენს x და ცნობა
ის, რომ გაძლევთ ორი Trues.
ასე რომ, ეს არ ვამბობ არიან ორი ობიექტები იდენტურია,
მაგრამ თითოეული მასალა ფარგლებში ვექტორები იდენტურია.
>> აქ არის bounded.compare.
ასე რომ ეს არის ოდნავ უფრო რთული რომ მას აქვს თუ მდგომარეობა და სხვა
და მაშინ იგი იღებს ორი არგუმენტები დროს.
ასე რომ X არის ნებისმიერი ტიპის.
და მე რომ ამ მეორე არგუმენტი არის.
ეს შეიძლება იყოს არაფერი, ისევე.
მაგრამ ჩვეულებრივ, იგი აპირებს 5 თუ არ აკონკრეტებს არაფერი.
>> ასე რომ აქ მე ვაპირებ ვთქვა თუ x მეტია.
ასე რომ, თუ მე არ დააკონკრეტა, ეს ამბობს, თუ x მეტია 5,
შემდეგ მე ვაპირებ დაბრუნებას TRUE.
სხვას, მე ვაპირებ დაბრუნებას FALSE.
ნება მომეცით წავიდეთ წინ და განისაზღვროს ამ.
>> და ახლა მე ვაპირებ აწარმოებს bounded.compare 3.
ასე რომ, ეს ნათქვამია 3 ნაკლები ვიდრე 3 აღემატება 5.
არა, ეს ასე არ არის FALSE.
>> და bounded.compare 3 და მე ვაპირებ შედარების გამოყენებით უდრის 2.
ასე რომ, ახლა მე ვამბობ დიახ, ახლა მე გინდათ, რომ იყოს რაღაც.
ამიტომ, მე ვაპირებ ვთქვა, თქვენ უნდა იყოს 2.
>> მე შეგიძლიათ ეს ერთგვარი notation და მე ვიტყვი უდრის 2.
ეს უფრო იკითხება რომ, როდესაც თქვენ
ეძებს ამ მართლაც რთული ფუნქციები, რომელიც
მრავალჯერადი არგუმენტები და ეს შეიძლება იყოს ათობით oftentimes-- უბრალოდ ვამბობ,
უდრის 2 უფრო იკითხება ასე რომ, მოგვიანებით მომავალში
თქვენ იცით, რას ვაკეთებთ.
>> ასე რომ, ამ შემთხვევაში, მე გამონათქვამი 3 მეტია 2.
დიახ, ეს არის.
და ანალოგიურად, მე შემიძლია მხოლოდ ამოიღონ ამ და აცხადებენ, 3 მეტია 2
სადაც უდრის 2.
და ეს ასეა.
დიახ?
>> აუდიტორია: თქვენ შესრულებაში ხაზს?
>> DUSTIN TRAN: დიახ, მე ვარ.
ასე, რასაც მე ვაკეთებ აქ აღების ამ ტექსტის document--
და რა დიდი rstudio ის არის, რომ შემიძლია უბრალოდ აწარმოებს short-- გასაღები კომბინაცია.
ასე რომ მე ვაკეთებ Control-Enter.
>> და მაშინ, მე აღების ხაზი ტექსტური დოკუმენტი
და შემდეგ აყენებს კონსოლი.
ასე რომ, აქ მე ვამბობ, bounded.compare და მე ამით Control-X.
ასე, რომ შეიძლება უბრალოდ არ აწარმოებს აქაც.
და მაშინ, რომ მიიღოს ხაზი და შემდეგ დააყენა აქ.
და მაშინ ანალოგიურად, მე შემიძლია არ აწარმოებს აქ.
და მაშინ ის უბრალოდ შეინახოს განსაზღვრის ხაზები შევიდა კონსოლი, როგორიცაა, რომ.
>> და თუ თქვენ ასევე შეამჩნევთ curly braces არსებობს ისევე, როგორც C სინტაქსი.
რომ X, თუ, თუ მდგომარეობა არის ასევე აპირებთ გამოიყენოთ ფრჩხილებში და შემდეგ
შეგიძლიათ გამოიყენოთ სხვა.
კიდევ ერთი არის სხვაგან თუ.
ასე რომ, ეს იქნება x უდრის უდრის, მაგალითად.
და შემდეგ მე ვაპირებ დაბრუნდეს რაღაც აქ.
>> შეამჩნია, რომ არსებობს ორი განსხვავებული რამ აქ რომ ხდება.
ერთი ის არის, რომ აქ მე მითითებით დაბრუნების ღირებულება TRUE.
აქ მე უბრალოდ ვამბობ x.
ასე R, როგორც წესი, იყოს მიიღოს ბოლო არგუმენტები
ან ბოლო ხაზი კოდი, და რომ იქნება, რასაც ის დაბრუნდა.
ასე რომ, აქ ეს არის იგივე რამ, როგორც აკეთებს დაბრუნების x.
>> და მხოლოდ გაჩვენოთ.
და შემდეგ, ის იმუშავებს მხოლოდ, რომ.
ნება მომეცით, გავაგრძელოთ ამ.
>> ასე რომ სხვაგან თუ.
და მართლაც, მე შეიძლება დაბრუნდეს არაფერი მინდა.
ასე რომ, მე კი არ უნდა დაბრუნება Booleans ყველა დროის,
მე შემიძლია უბრალოდ დააბრუნოს რაღაც.
ასე შემიძლია დაბრუნების დათვი.
>> ასე რომ, თუ x უდრის უდრის, ის დაბრუნებას აპირებს დათვი.
წინააღმდეგ შემთხვევაში, ეს დაბრუნებას აპირებს TRUE.
მე ასევე შეგიძლიათ ვექტორი ან მართლაც არაფერი.
>> და ჩვეულებრივ statically აკრეფილი ენაზე,
ნეტავ უნდა მიუთითოთ ტიპის აქ.
და შეამჩნია, რომ მას შეუძლია უბრალოდ არაფერი.
და R არის ჭკვიანი საკმარისი, რომ ეს უბრალოდ ამის გაკეთება და ეს იმუშავებს ჯარიმა.
>> ნება მომეცით, განსაზღვროს ამ.
Unexpected-- ბოდიში.
ეს უნდა იყოს Curly გაუწიოს აქ.
OK.
მაგარი.
ყველა უფლება.
ახლა მოდით შედარების 3 და შეადგენს 3.
ასე რომ უნდა დაბრუნდეს yeah-- ღირებულება დათვი.
>> ასე რომ, ახლა უფრო ზოგადი რამ ჰგავს რაც შეეხება სხვა მონაცემთა სტრუქტურები.
ასე რომ თქვენ გაქვთ ამ ფუნქციის.
ეს იმუშავებს ნებისმიერ ღირებულება, როგორიცაა 3 ან ნებისმიერი რიცხვი,
სხვა სიტყვებით რომ ვთქვათ, ორმაგი.
>> მაგრამ რაც შეეხება რაღაც ვექტორი.
რა მოხდება, თუ თქვენ გავაკეთოთ ასე ვარ აპირებს დაავალოს val, ვთქვათ, 4-დან 6.
ასე რომ, თუ დავბრუნდები, ამ ვექტორული 4, 5, 6.
>> ახლა ვნახოთ, რა მოხდება თუ ამის გაკეთება bounded.compare val.
ასე რომ, ეს აპირებს მოგცემთ 15 1251.
ასე რომ, სხვა სიტყვებით რომ ვთქვათ, ის ამბობდა, თუ გადავხედავთ ამ მდგომარეობაში
ასე რომ ამბობს x ნაკლებია მეტი ან რამე.
ასე რომ ეს არის ოდნავ გაუგებარია, რადგან ახლა
უბრალოდ არ ვიცი, რა ხდება.
ამიტომ ვფიქრობ, რომ ერთი რამ, რომ ნამდვილად კარგი უბრალოდ ცდილობს გამართვის
არის, რომ თქვენ შეგიძლიათ უბრალოდ val არის უფრო დიდი, მეტი და ვნახოთ, რა მოხდება იქ.
>> ასე val-- სტანდარტულად 5 ასე მოდით უბრალოდ Val მეტია 5.
ასე რომ, ეს არის ვექტორული FALSE FALSE TRUE.
ასე რომ, ახლა, როდესაც თქვენ ეძებს ეს, ის აპირებს ვთქვა, თუ,
და მაშინ ის გადმოგცეთ ეს არის ვექტორი FALSE FALSE TRUE.
>> ასე რომ, როდესაც თქვენ გაიაროს ეს შევიდა R, R არ აქვს იდეა, თუ რას აკეთებს.
იმის გამო, რომ იგი იმედოვნებს, ერთი ღირებულება, რომელიც არის ლოგიკური, და ახლა
თქვენ ვაძლევთ მას ვექტორი Booleans.
ასე რომ იყოს, R არის მხოლოდ ვაპირებ ვთქვა, თუ რა heck,
მე ვაპირებ ვივარაუდოთ, რომ თქვენ აპირებს, რომ პირველი ელემენტი აქ.
ამიტომ, მე ვაპირებ ვთქვა, მე ვაპირებ უნდა ვივარაუდოთ, რომ ეს არის მცდარი.
ასე რომ, ის აპირებს ამბობენ არა, ეს არ არის სწორი.
>> ანალოგიურად, ის აპირებს იყოს val უდრის უდრის.
არა, ბოდიში 5.
და ეს ასევე იქნება ყალბი, ასევე.
ამიტომ აპირებს, უარი თქვას, ეს არ არის სიმართლე, ისევე, ასე, რომ ეს
დაბრუნებას აპირებს ამ ბოლო ერთი.
>> ასე რომ, ეს არის ან კარგია, ან ცუდი რამ, რაც დამოკიდებულია იმაზე, თუ როგორ ჩაირთოს.
რადგან, როდესაც თქვენ ქმნის ამ ფუნქციებს,
თქვენ არ ვიცი რეალურად რა ხდება.
ისე ხანდახან თქვენ მინდა შეცდომა, ან იქნებ უბრალოდ მინდა გაფრთხილება.
ამ შემთხვევაში, R არ გაგვაჩნია.
ასე რომ, ეს მართლაც მდე თქვენ ეფუძნება off რა
როგორ ფიქრობთ, ენის უნდა გავაკეთოთ ამ შემთხვევაში
თუ თქვენ გაივლის ვექტორი Booleans როდესაც თქვენ აკეთებთ თუ მდგომარეობა.
>> ასე ვთქვათ, რომ თქვენ ჰქონდა ორიგინალური ერთი თუ სხვაგან დაბრუნების ჭეშმარიტი და თქვენ
დაბრუნებას აპირებს FALSE.
ასე რომ ერთი გზა abstracting ეს კი იმას ნიშნავს, რომ მე
კი არ უნდა ამ პირობითი რამ.
კიდევ ერთი რამ, რისი გაკეთებაც შემიძლია მხოლოდ დაბრუნების ღირებულებებს თავს.
ასე რომ, თუ თქვენ შეამჩნევთ, თუ გავაკეთოთ val მეტია 5,
ეს დაბრუნებას აპირებს ვექტორი FALSE FALSE TRUE.
>> იქნებ ეს არის ის, რაც თქვენ გსურთ bounded.compare.
გსურთ დაბრუნებას ვექტორი Booleans სადაც მას ადარებს თითოეული ღირებულებების
საკუთარ თავს.
ასე რომ თქვენ შეგიძლიათ უბრალოდ bounded.compare ფუნქცია x, შეადგენს 5.
და შემდეგ ნაცვლად აკეთებს ეს თუ სხვაგან მდგომარეობა,
მე უბრალოდ დაბრუნებას აპირებს x მეტია 5.
ასე რომ, თუ ეს სიმართლეა, მაშინ ის დაბრუნებას აპირებს TRUE.
და მაშინ, თუ ის არ არის, ეს დაბრუნებას აპირებს FALSE.
>> და ეს იმუშავებს ნებისმიერი ამ სტრუქტურებში.
ასე, რომ შეიძლება bounded.compare გ 1 6 ან 9 და შემდეგ მე ვაპირებ ვთქვა ტოლია 6,
მაგალითად.
და შემდეგ ის აპირებს გაძლევთ უფლებას ლოგიკური
ვექტორი, რომ თქვენ დიზაინის.
>> ასე რომ, ეს უბრალოდ ფუნქციები და ახლა ნება მომეცით მხოლოდ
გაჩვენებთ რამდენიმე ინტერაქტიული ვიზუალური.
მე არ ვფიქრობ, რომ რეალურად აქვს Wi-Fi აქ ნება მომეცით, უბრალოდ წავიდეთ წინ
და გამოტოვოთ ეს ერთი ვფიქრობ.
>> მაგრამ ერთი რამ, რომ მაგარი მიუხედავად იმისა, რომ ის არის, რომ თუ თქვენ მხოლოდ
გსურთ შეამოწმოთ რამოდენიმე სხვადასხვა მონაცემებით, ბრძანებები,
არსებობს რამოდენიმე განსხვავებული მონაცემების რომ უკვე preloaded შევიდა R.
ასე რომ ერთი მათგანი არის მოუწოდა iris ნაკრებს.
ეს არის ერთ-ერთი ყველაზე ცნობილი პირობა მანქანა სწავლის.
თქვენ, როგორც წესი, უბრალოდ გავაკეთოთ გარკვეული ტესტის, რომ თქვენი კოდი ეშვება.
მოდით უბრალოდ შემოწმება, თუ რა iris არის.
>> ასე რომ, ეს რამ აპირებს იყოს მონაცემების ფარგლებში.
და ეს სახის ხანგრძლივი, რადგან მე მხოლოდ დაბეჭდილი iris.
ეს დაბეჭდვისას მთელი რამ.
ასე რომ ყველა ეს სხვადასხვა სახელები.
ასე iris არის კოლექცია სხვადასხვა ყვავილები.
ამ შემთხვევაში, ეს ეუბნება, თქვენ სახეობა ის,
ყველა ამ სხვადასხვა widths და სიგრძის sepal და petal.
>> და ასე, ჩვეულებრივ, თუ გსურთ ბეჭდვა iris,
მაგალითად, თქვენ არ გინდათ ეს ყველაფერი ეს იმის გამო, რომ შეუძლია მიიღოს მეტი
თქვენი კონსოლი.
ასე რომ, ერთი რამ, რომ ნამდვილად ლამაზი არის ხელმძღვანელი ფუნქცია.
ასე რომ, თუ თქვენ უბრალოდ უფროსი iris, ეს მოგცემთ
პირველ ხუთ რიგები, ან ექვსი ვფიქრობ.
და მაშინ კარგად, თქვენ შეგიძლიათ უბრალოდ მიუთითოთ აქ.
ასე 20-- ეს მისცემს თქვენ პირველი 20 რიგები.
და მე რეალურად იყო სახის გაკვირვებული, რომ ეს
მომცა ექვსი ნება მომეცით წავიდეთ წინ და შემოწმება iris-- ან ხელმძღვანელი, უკაცრავად.
და აქ მისცემს თქვენ დოკუმენტაცია
რა მნიშვნელობა ხელმძღვანელი აკეთებს.
ამიტომ დააბრუნებს პირველი ან ბოლო ობიექტი.
და შემდეგ მე ვაპირებ შევხედოთ დეფოლტის.
და მერე ამბობს ნაგულისხმები მეთოდი ხელმძღვანელი x და n უდრის 6L.
ასე რომ, ეს დააბრუნებს პირველი ექვსი ელემენტები.
და ანალოგიურად, თუ თქვენ შეამჩნევთ აქ, მე არ უნდა მიუთითოთ n უდრის 6.
იყოს იგი იყენებს ექვსი, ვფიქრობ.
და მაშინ, თუ მინდა მიუთითოთ გარკვეული ღირებულება, მაშინ შემიძლია, რომ ისევე.
>> ასე რომ, არის რამდენიმე მარტივი ბრძანებები და აქ არის კიდევ ერთი, რომ just-- კარგად,
მე can-- ეს არის რეალურად ცოტა უფრო რთული,
მაგრამ ეს მხოლოდ მიიღოს კლასი ყოველი სვეტი iris ნაკრებს.
ასე რომ, ეს გამოჩნდება, თუ რა თითოეული ეს სვეტების თვალსაზრისით მათი ტიპის.
ასე sepal სიგრძე რიცხვითი, sepal სიგანე numeric.
ყველა ამ ფასეულობების უბრალოდ რიცხვითი იმიტომ, რომ თქვენ შეუძლია თქვას, ეს მონაცემები
სტრუქტურა ეს არის ყველა აპირებს numeric.
>> და სახეობების სვეტი იქნება ფაქტორი.
ასე რომ, ჩვეულებრივ, თქვენ ფიქრობთ, რომ ეს არის, როგორც ხასიათი სტრიქონი.
მაგრამ თუ უბრალოდ irisSpecies, და შემდეგ მე ვაპირებ გავაკეთოთ ხელმძღვანელი 5,
და ამ აპირებს ბეჭდვა out პირველი ხუთი ღირებულებებს.
>> და შემდეგ შეამჩნევთ ამ დონეზე.
ასე რომ, ეს saying-- ეს არის R გზა მქონე კატეგორიული ცვლადები.
ასე რომ ნაცვლად მხოლოდ რომელსაც ხასიათის სტრიქონები,
მას აქვს დონის მითითებით რომელიც ამ რამ.
>> ასე ვთქვათ irisSpecies 1.
ასე რომ, რა გსურთ აქ არის მე ვარ subsetting ამ სახეობების სვეტი.
ასე რომ, ეს იღებს სახეობა, სვეტი და შემდეგ
ეს ინდექსები მისაღებად პირველ ელემენტს.
ასე რომ, ეს უნდა გადმოგცეთ setosa.
და ასევე გაძლევთ დონეზე აქ.
>> ასე რომ თქვენ ასევე შეგიძლიათ შეადაროთ ეს ხასიათი setosa
და ეს არ აპირებს უნდა იყოს ჭეშმარიტი, რადგან ერთი
არის სხვადასხვა ტიპის, ვიდრე სხვა.
ან მე ვფიქრობ, რომ ეს მართლაც ასეა, რადგან R უფრო ჭკვიანი, ვიდრე.
და ის უყურებს და შემდეგ ამბობს, იქნებ ეს არის ის, რაც გსურთ.
ასე რომ, ის აპირებს ამბობენ ხასიათი string setosa არის იგივე როგორც ეს ერთი.
და მაშინ ანალოგიურად, შეგიძლიათ ასევე უბრალოდ აითვისებდა ამ როგორიცაა ასე შემდეგ.
>> ასე რომ, ეს მხოლოდ გარკვეული სწრაფი ბრძანებები ნაკრებს.
ასე რომ, აქ ზოგიერთი მონაცემების მოძიება.
ასე რომ, ეს ცოტა მეტი ჩართული მონაცემების ანალიზი.
და ეს არის აღებული ზოგიერთი bootcamp in R წელს Berkeley.
>> ასე ბიბლიოთეკა უცხო.
ამიტომ, მე ვაპირებ ჩატვირთვა ბიბლიოთეკა, რომელიც ე.წ. უცხო.
ასე რომ, ეს აპირებს მომეცი read.dta ამიტომ ვარაუდობენ, რომ მე ამ ნაკრებს.
ამ ინახება მიმდინარე სამუშაო დირექტორია ჩემი კონსოლი.
მოდით უბრალოდ ვნახოთ, რა სამუშაო დირექტორია.
>> ასე რომ, აქ არის ჩემი სამუშაო დირექტორია.
და წაიკითხეთ dot მონაცემებით, ამ რამ, განაცხადა, რომ ეს ფაილი
მდებარეობს მონაცემები საქაღალდეში მიმდინარე სამუშაო დირექტორია.
და read.dta ეს არ არის ნაგულისხმები ბრძანება.
ვფიქრობ, მე დატვირთული ეს უკვე.
Iei ვივარაუდოთ, მე დატვირთული ეს უკვე.
>> მაგრამ ასე read.dta არ აპირებს იყოს ძირითადად ბრძანება.
და ამიტომაც ვაპირებთ აქვს ჩატვირთვა ამ ბიბლიოთეკაში package--
ეს პაკეტი მოუწოდა უცხოელ.
და თუ არ აქვს პაკეტი, მე ვფიქრობ,
საგარეო ერთ-ერთი ჩაშენებული პირობა.
წინააღმდეგ შემთხვევაში, შეგიძლიათ ასევე გავაკეთოთ install.packages
და ეს იქნება დააყენოთ პაკეტი.
და ეს მოგცემთ R. Uh, არა.
და მაშინ მე უბრალოდ აპირებს შეწყვიტოს ეს იმიტომ, რომ მე უკვე აქვს.
>> მაგრამ რა მართლაც ლამაზი შესახებ R ის არის, რომ პაკეტი მართვა
სისტემა არის ძალიან ელეგანტური.
იმიტომ, რომ ეს შესანახად ყველაფერი მართლაც ლამაზად თქვენთვის.
ასე რომ, ამ შემთხვევაში, ის აპირებს შესანახად მას, მე მჯერა, რომ ეს ბიბლიოთეკა აქ.
>> ასე რომ ნებისმიერ დროს გსურთ დააყენოთ ახალი პაკეტი,
ეს ისეთივე მარტივია, როგორც აკეთებს install.packages
და R შეძლებს ყველა პაკეტების თქვენთვის.
ასე რომ თქვენ არ უნდა გავაკეთოთ რაღაც Python, სადაც თქვენ უნდა გარე პაკეტი
მენეჯერები, როგორიცაა ქაღალდი Anaconda, სადაც თქვენ
აკეთებს თქვენ დააყენოთ პაკეტების გარეთ Python
და მაშინ ცდილობენ აწარმოებს მათ თავს.
ასე რომ, ეს მართლაც ლამაზი გზა.
>> და install.packages მოითხოვს ინტერნეტით.
ის იღებს სერვერზე და საცავი,
აგროვებს ყველა პაკეტები ეწოდება Cran.
და თქვენ შეგიძლიათ მიუთითოთ, თუ რა სახის სარკე გსურთ ჩამოტვირთოთ პაკეტები.
>> ასე რომ, აქ ვიღებ ამ ნაკრებს.
მე კითხულობს ის გამოყენებით ამ ფუნქციას.
ნება მომეცით წავიდეთ წინ და ამის გაკეთება.
>> მოდით ვივარაუდოთ, რომ თქვენ გაქვთ ეს ნაკრებს
და თქვენ აბსოლუტურად არ ვიცი, რა არის ეს.
და ეს რეალურად მოდის საკმაოდ ხშირად ინდუსტრიაში
სადაც თქვენ უბრალოდ უნდა ეს ტონა და ტონა ბინძურ რამ
და ისინი ძალიან unlabeled.
ასე რომ აქ მაქვს ეს ნაკრებს და მე არ ვიცი,
რა არის ასე ვარ ნაჩვენებია შეამოწმეთ იგი out.
>> ამიტომ, მე ვაპირებ გავაკეთოთ ხელმძღვანელი პირველი.
ასე რომ, მე შეამოწმოთ პირველი ექვსი სვეტები, რაც ამ ნაკრებს არის.
ასე რომ ეს არის სახელმწიფო, pres04 და შემდეგ ყველა ამ სხვადასხვა სახის სვეტები.
და რა არის საინტერესო აქ, ვფიქრობ, ის არის, რომ თქვენ
რომ ვივარაუდოთ, რომ ეს გამოიყურება როგორიცაა გარკვეული არჩევნებში.
და ვფიქრობ, მხოლოდ ეხლა ეძებს ფაილი
სახელი ეს გარკვეული კოლექცია მონაცემები კანდიდატების ან ამომრჩევლების
ვინც ხმა მისცა კონკრეტული პრეზიდენტები ან პრეზიდენტის კანდიდატები
2004 წლის არჩევნებისთვის.
>> ასე რომ აქ არის ღირებულებების 1, 2 ასე რომ, ერთი გზა შენახვის
პრეზიდენტის კანდიდატები მათი სახელები.
ამ შემთხვევაში, როგორც ჩანს, ისინი უბრალოდ რიცხვი ღირებულებებს.
ასე, 2004 წელს ეს იყო ბუშის წინააღმდეგ კერი მე მჯერა.
და ახლა, ვთქვათ თქვენ უბრალოდ არ ვიცი თუ არა 1 შეესაბამება ბუშის ან 2
შეესაბამება Kerry ან და ასე შემდეგ და ასე შემდეგ, არა?
>> და ეს არის, უბრალოდ, ჩემთვის, საკმაოდ გავრცელებული პრობლემაა.
რა შეგიძლიათ გააკეთოთ ამ შემთხვევაში?
მოდით შევამოწმოთ ყველა ამ სხვა რამ.
>> სახელმწიფო, მე თუ ვთქვათ ეს მოდის სხვადასხვა ქვეყნებში.
partyid, შემოსავალი.
მოდით შევხედოთ partyid.
ასე რომ, შესაძლოა, ერთი რამ შეგიძლიათ გააკეთოთ შევხედოთ თითოეული დაკვირვებები
რომ აქვს partyid რესპუბლიკური ან დემოკრატი ან რამე.
მოდით უბრალოდ შეხედეთ რა partyid არის.
>> ასე რომ, მე ვაპირებ dat და შემდეგ მე ვაპირებ
გავაკეთოთ ეს დოლარის ნიშანი ოპერატორი, რომელიც მე ადრე
და ამ აპირებს subset რომ სვეტი.
და შემდეგ მე ვაპირებ უხელმძღვანელებს ამ 20, უბრალოდ, რა ამ ჰგავს.
>> ასე რომ, ეს მხოლოდ რამოდენიმე NAS.
ასე რომ, სხვა სიტყვებით, თქვენ უნდა დაკარგული მონაცემების შესახებ ამ ბიჭებს.
მაგრამ თქვენ ასევე შეამჩნია ეს dat partyid არის ფაქტორი
ასე რომ, ეს გაძლევთ სხვადასხვა კატეგორიები.
ასე რომ, სხვა სიტყვებით რომ ვთქვათ, partyid შეუძლია დემოკრატი, რესპუბლიკური, დამოუკიდებელი,
ან რაღაც.
>> მოდით წავიდეთ წინ და მოდით ვნახოთ, რომელიც ამ is-- oh, OK.
ასე რომ, მე ვაპირებ subset to partyid და შემდეგ
შევხედოთ რაც პირობა არის დემოკრატი, მაგალითად.
ამ აპირებს მოგცემთ ლოგიკური, დიდი ლოგიკური of Trues და FALSEs.
>> და ახლა, ვთქვათ, მინდა to subset ამ ბიჭებს.
ასე რომ, ეს აპირებს ჩემი dat და subset რომელი დაკვირვების
აქვს partyid ტოლია ტოლია დემოკრატი.
და ეს არის საკმაოდ ხანგრძლივი, რადგან არსებობს ძალიან ბევრი მათგანი.
ასე რომ, ახლა, მე ვაპირებ უხელმძღვანელებს ამ 20.
>> და თქვენ შეამჩნევთ, შეადგენს შეადგენს საინტერესოა, რომ თქვენ
already-- თქვენ ასევე მათ შორის NAS.
ასე რომ, ამ შემთხვევაში, თქვენ მაინც ვერ ნებისმიერი ინფორმაცია, რადგან ახლა თქვენ გაქვთ Nas
და თქვენ უბრალოდ უნდა, თუ რომელი სადამკვირვებლო შეესაბამება დემოკრატი
და არა ამ დაკარგული აფასებს საკუთარ თავს.
ისე როგორ იქნებოდა თქვენ დავაღწიოთ ამ Nas?
>> ასე რომ, აქ მე უბრალოდ გამოყენებით up გასაღები ჩემს კურსორი და თქვა მოძრაობდნენ.
და მერე აქ მე უბრალოდ აპირებს ვთქვა is.na datpartyid.
ასე რომ, ეს და და მიიღებს ორი სხვადასხვა ლოგიკური ვექტორები
და აცხადებენ, რომ ეს იქნება ჭეშმარიტი და ცრუ მაგალითად.
ასე რომ, ის აპირებს ამის გაკეთებას კომპონენტი ბრძენი.
ასე რომ, აქ მე ვამბობ, მიიღოს მონაცემები ჩარჩო, subset
პირობა, რომელიც შეესაბამება დემოკრატი, და წაშალოს ნებისმიერი მათგანი, რომლებიც არ არიან NA.
>> ასე რომ, ეს will-- უნდა მოგაწვდით რაღაც.
ვნახოთ, is.na.
მოდით ცდილობენ is.na datpartyid.
და ეს უნდა მისცეს თქვენგანი ბოდიში უბრალოდ ლოგიკური ვექტორი.
და მაშინ, იმიტომ რომ ამდენი ხანი, მე ვაპირებ subset 20.
OK.
ასე რომ, ეს უნდა იმუშაოს.
>> და ეს ასე იქნება Trues.
Ah, ჩემი შეცდომა ის არის, რომ I'm-- I გამოყენება C ++ და R interchangeably ისე მე
ეს შეცდომა ყველა დროის.
და ოპერატორი რეალურად გსურთ.
თქვენ არ გსურთ გამოიყენოთ ორი ampersands, მხოლოდ ერთი.
OK.
>> ასე რომ, ვნახოთ.
ასე რომ, ჩვენ subsetted რომ partyid სადაც ისინი დემოკრატი
და ისინი არ დაკარგული ღირებულებების.
და ახლა მოდით შევხედოთ რომელიც პირობა მისცა ხმა.
ასე რომ, როგორც ჩანს, ყველაზე მისცემდა ხმას 1.
ამიტომ, მე ვაპირებ წავიდეთ წინ და ვთქვათ, რომ არის კერი.
>> და ანალოგიურად, თქვენ შეგიძლიათ აგრეთვე რესპუბლიკური
და იმედია, ეს უნდა მოგაწვდით 2.
ეს მხოლოდ bunch სხვადასხვა სვეტები.
და მართლაც, ეს 2.
ასე partyid ყველა რესპუბლიკური, მათი უმრავლესობა ხმას 2.
>> ასე რომ, როგორც ჩანს, ისევე, მიერ ეძებს ამ,
რესპუბლიკური იქნება very-- ან partyid
იქნება ძალიან დიდი ფაქტორი განმსაზღვრელი
რომელ კანდიდატს ისინი აპირებს ხმის მიცემას.
და ეს არის აშკარად მართალია ზოგადად.
და ეს შეესაბამება თქვენი ინტუიცია, რა თქმა უნდა.
ასე რომ, როგორც ჩანს, როგორიც მე ვარ გადის დრო ასე
ნება მომეცით უბრალოდ უნდა წავიდეთ წინ და აჩვენებს რამოდენიმე სწრაფი images.
ასე რომ, აქ არის რაღაც, რომ ოდნავ უფრო რთული ვიზუალიზაცია.
ასე რომ, ამ შემთხვევაში, ეს არის ძალიან მარტივი ანალიზი მხოლოდ შემოწმების რა
პრეზიდენტი '04 არის.
>> ასე რომ, ამ შემთხვევაში, ვთქვათ თქვენ სურდა ამ კითხვაზე პასუხი.
ამიტომ ვარაუდობენ, გვინდოდა ვიცი ხმის მიცემის ქცევა 2004 პრეზიდენტის არჩევნები
და როგორ, რომ მერყეობს რასის.
ასე არა მხოლოდ გინდათ ვხედავ საარჩევნო ქცევის,
მაგრამ გსურთ subset თითოეული რასის და ერთგვარი შეჯამება რომ.
და თქვენ შეგიძლიათ მხოლოდ გითხრათ, ამ რთული notation
რომ ეს არის სახის მიღების hazy.
>> ასე რომ, ერთი მოწინავე R პაკეტი, რომელიც ასევე სახის ბოლო
ეწოდება dplyr.
ასე რომ ამ ერთი უფლება აქ.
და ggg-- ggplot2 მხოლოდ ლამაზი გზა აკეთებს უკეთესი თვალსაჩინოება
ვიდრე ჩაშენებული ერთი.
>> ამიტომ, მე ვაპირებ ჩატვირთვა ამ ორ ბიბლიოთეკას.
და მერე, მე ვაპირებ წავიდეთ წინ და აწარმოებს ამ ბრძანებას.
თქვენ შეგიძლიათ მხოლოდ ჩათვალოს როგორც შავი ყუთი.
>> რა ხდება არის ის, რომ ეს მილსადენი ოპერატორი გავლის ეს არგუმენტი
შევიდა აქ.
ამიტომ მე ვამბობ ჯგუფი dat რასის და შემდეგ პრეზიდენტი 04.
და შემდეგ, ყველა ეს სხვა ბრძანებები ფილტრაცია და მაშინ შემაჯამებელი
სადაც მე ვაკეთებ რაოდენობა და მაშინ მე შეთქმულება აქ.
OK cool.
მოდით წავიდეთ წინ და ვნახოთ, რა ამ ჰგავს.
>> ასე, რა ხდება აქ არის ის, რომ მე მხოლოდ პროპაგანდისტულ თითოეული რასის და შემდეგ
რომელიც პირობა მისცა ხმა.
და ეს ორი სხვადასხვა ღირებულებების შეესაბამება 2 და 1.
თუ გვინდა, რომ იყოს უფრო ელეგანტური, ასევე შეგიძლიათ
მხოლოდ დააკონკრეტა, რომ 2 Kerry-- ან 2 ბუში და შემდეგ 1 კერი.
და ასევე შეგიძლიათ აქვს რომ თქვენს ლეგენდა.
>> და ასევე შეგიძლიათ გაყოფილი ამ ბარი გრაფიკების.
რადგან ერთი რამ რომ, თუ თქვენ შეამჩნევთ,
ეს არ არის ძალიან ადვილი იდენტიფიკაცია რომელიც ამ ორი ღირებულებები უფრო დიდი.
ასე რომ ერთი რამ მინდა მინდა არის მიიღოს ეს ლურჯი ნაკვეთი
და მხოლოდ გადატანა მეტი აქ, ასე რომ თქვენ შეგიძლიათ შეადაროთ ეს ორი გვერდით.
და ვფიქრობ, რომ ეს რაღაც მე არ გაქვთ დრო, რომ ახლა,
მაგრამ ეს ასევე არის ძალიან ადვილია.
შეგიძლიათ უბრალოდ შესასწავლად კაცი გვერდებზე ggplot.
ასე რომ თქვენ შეგიძლიათ უბრალოდ ggplot, როგორიცაა რომ და წაიკითხავს ამ კაცს გვერდზე.
>> ნება მომეცით, უბრალოდ სწრაფად გაჩვენებთ რამდენიმე მაგარი რამ.
მოდით წავიდეთ წინ და რომელთა მიზანია მხოლოდ გამოყენების მანქანა სწავლის.
ასე ვთქვათ ჩვენ გვაქვს ეს სამი პაკეტი, ასე რომ მე ვაპირებ ჩატვირთვა ამ წელს.
ასე რომ, ეს უბრალოდ ბეჭდავს out ზოგიერთი ინფორმაცია შემდეგ მე დატვირთული რამ.
ასე რომ, მე ამას ვამბობ read.csv, ამ ნაკრებს, და ახლა
მე ვაპირებ წავიდეთ წინ და შეხედეთ და ვნახოთ, რა არის შიგნით ამ ნაკრებს.
>> ასე რომ, პირველი 20 დაკვირვებები.
ამიტომ უბრალოდ უნდა X1, X2, და Y. ასე რომ როგორც ჩანს, bunch ამ ფასეულობების
დაწყებული შესაძლოა 20-დან 80 ან იმდენად.
და მაშინ ანალოგიურად for X2 და შემდეგ ამ Y ჩანს ეტიკეტები 0 და 1.
>> გადაამოწმონ ამ, მე შემიძლია მხოლოდ ამის შემაჯამებელი მონაცემები X1.
და მაშინ ანალოგიურად for ყველა ეს სხვა სვეტები.
ასე შემაჯამებელი არის სწრაფი გზა უბრალოდ გვიჩვენებს თქვენ სწრაფი ღირებულებებს.
ოჰ, უკაცრავად.
ეს უნდა იყოს Y.
>> ასე რომ, ამ შემთხვევაში, იძლევა quantiles, medians, maxes ასევე.
ამ შემთხვევაში, dataY, ხედავთ რომ ის უბრალოდ იქნება 0 და 1.
ასევე საშუალო ამბობს 0.6, მხოლოდ იმას ნიშნავს, რომ ეს
როგორც ჩანს, როგორიც მე უფრო 1s, ვიდრე 0S.
>> ნება მომეცით წავიდეთ წინ და შოუ თქვენ რა ამ ჰგავს.
ასე რომ მე უბრალოდ აპირებს მონიშვნას.
ვნახოთ, როგორ გარკვევა ამ.
Oh OK.
OK.
>> ასე რომ, ეს არის ის, რაც ჰგავს.
ასე რომ, როგორც ჩანს, ყვითელი I მითითებული როგორც 0, და შემდეგ წითელი I მითითებული, როგორც 1s.
ასე რომ, აქ ჰგავს ეტიკეტების რაოდენობა და ეს
როგორც ჩანს, უბრალოდ სურდა სახის კლასტერული ამ.
>> და ნება მომეცით უბრალოდ წავიდეთ წინ და შოუ თქვენ ზოგიერთი ჩაშენებული ფუნქციები.
ასე რომ აქ არის lm.
ასე რომ, ეს უბრალოდ ცდილობს შეესაბამება ხაზი, რომ ეს.
ასე რომ, რა არის საუკეთესო გზა რომ შემიძლია ჯდება ხაზი, როგორიცაა
რომ ეს იქნება საუკეთესო გამოყოფა ამ სახის კლასტერული.
და იდეალურად, შეგიძლიათ უბრალოდ ნახეთ რომ მე უბრალოდ აწარმოებს ყველა ეს ბრძანებები
და მაშინ, მე ვაპირებ წინ და დაამატოთ ხაზი.
>> ასე რომ, ეს, როგორც ჩანს, საუკეთესო ვხვდები.
ის აღების საუკეთესო, რომელიც ამცირებს შეცდომა ცდილობს მოერგოს ამ ხაზის.
ცხადია, ეს გამოიყურება სახის კარგი, მაგრამ ეს არ არის საუკეთესო.
და წრფივი მოდელების ზოგადად, იქნება
მართლაც დიდი თეორია და მხოლოდ სახის სამშენებლო საფუძვლები მანქანა
სასწავლო.
მაგრამ პრაქტიკაში, თქვენ აპირებს მინდა, რომ რამე უფრო ზოგადი.
>> ასე რომ თქვენ შეგიძლიათ ვცდილობთ გაშვებული რაღაც მოუწოდა ნერვული ქსელი.
ეს ყველაფერი უფრო გავრცელებული.
და ისინი უბრალოდ მუშაობა fantastically დიდი მონაცემების.
ასე რომ, ამ შემთხვევაში, ჩვენ მხოლოდ ფლობის ვნახოთ, ჩვენ გვაქვს ÑROW.
ასე ÑROW უბრალოდ ვამბობ, სტრიქონების რაოდენობა.
ასე რომ, ამ შემთხვევაში, მე აქვს 100 დაკვირვებები.
>> ნება მომეცით წავიდეთ წინ და რათა ნერვული ქსელი.
ასე რომ, ეს მართლაც ლამაზი იმიტომ, რომ მე, უბრალოდ, ვამბობთ Nnet
და მაშინ მე წავედით Y. ასე რომ Y არის, რომ სვეტი.
და მერე წავედით ეს სხვა ორი ცვლადი.
ასე რომ ეს არის მოკლე ნოტაცია X1 და X2.
>> მოდით წავიდეთ წინ და აწარმოებს ამ.
ოჰ, უკაცრავად.
მე უნდა აწარმოებს ამ მთელი რამ.
და ეს მხოლოდ დაბეჭდვის notation რამდენად სწრაფად თუ არა სწრაფად
თანხვედრა.
ასე გამოიყურება ეს არ გადავიდეს.
ნება მომეცით წავიდეთ წინ და ბეჭდვა გაირკვეს, თუ რა ამ ჰგავს.
>> იხილეთ აქ არის სურათი და აქ არის კონტური ნაჩვენებია, თუ რამდენად კარგად ჯდება.
და ეს არის just-- თქვენ ხედავთ ეს, რომ ეს არის ძალიან ლამაზი.
ეს შეიძლება იყოს overfitting, მაგრამ ასევე შეგიძლიათ
ანგარიშზე ამ სხვა ტექნიკას, როგორიცაა ჯვარი დადასტურება.
და ეს ასევე ჩაშენებული R.
>> და ნება მომეცით უბრალოდ გაჩვენებთ მხარდაჭერა ვექტორი მანქანა.
ეს არის კიდევ ერთი მართლაც საერთო ტექნიკა მანქანა სწავლის.
ეს ძალიან ჰგავს წრფივი მოდელები, მაგრამ იგი იყენებს, რასაც kernel მეთოდი.
და ვნახოთ, რამდენად კარგად რომ აკეთებს.
ასე რომ, ეს არის ძალიან გავს როგორ ასევე ნერვული ქსელი ასრულებს,
მაგრამ ეს ბევრად უფრო გამარტივებას.
და ეს ეფუძნება off საქართველოს, რა, როგორ SVMs მუშაობა.
>> ასე რომ, ეს უბრალოდ ძალიან სწრაფი მიმოხილვა ზოგიერთი
ჩაშენებული ფუნქციები შეგიძლიათ გააკეთოთ და ასევე ზოგიერთი მონაცემები exploration.
ნება მომეცით წავიდეთ წინ და დაბრუნდეს სლაიდები.
>> ამიტომ ცხადია, რომ ეს არის არ ძალიან ყოვლისმომცველი.
და ეს მართლაც მხოლოდ teaser აჩვენებს, თუ რა შეგიძლიათ ნამდვილად არ რ
ასე რომ, თუ თქვენ უბრალოდ მინდა მეტი, აქ
არსებობს რამოდენიმე განსხვავებული რესურსები.
>> ასე რომ, თუ თქვენ უყვარს სახელმძღვანელოების ან თქვენ უბრალოდ უყვარდა კითხულობს რამ შემოსული,
მაშინ ეს არის ფანტასტიკური ერთი ჰედლიმ Wickham,
რომელიც ასევე შექმნილია ყველა ეს მართლაც მაგარი პაკეტები.
თუ თქვენ უყვარს videos, მაშინ Berkeley აქვს გასაოცარია bootcamp
რომ არის several-- რომ სახის ხანგრძლივი.
და ის თქვენ გასწავლით თითქმის ყველაფერი ნეტავ მინდა იცოდეთ R.
>> და ანალოგიურად, არსებობს Codeacademy და ყველა ეს სხვა სახის
ინტერაქტიული საიტებზე.
ისინი ასევე მიღების common-- უფრო და უფრო გავრცელებული.
ასე რომ, ეს ძალიან ჰგავს Codeacademy.
და ბოლოს, თუ თქვენ მხოლოდ მინდა Community და დახმარება,
ეს არის რამოდენიმე რამ შეგიძლიათ წასვლა.
ცხადია, ჩვენ მაინც გამოყენება დაგზავნები, უბრალოდ
ისევე როგორც თითქმის ყველა სხვა პროგრამირების ენა თანამეგობრობას.
და #rstats, ეს არის ჩვენი საზოგადოების Twitter.
რომ რეალურად საკმაოდ გავრცელებული.
და მერე შესახებ!
არის მხოლოდ ჩვენი კონფერენცია.
>> და მაშინ, რა თქმა უნდა, თქვენ შეგიძლიათ გამოიყენონ ყველა ამ სხვა Q & A რამ,
როგორიცაა Stack Overflow, Google, და შემდეგ GitHub.
იმიტომ, რომ ყველაზე მეტად ამ პაკეტები და ბევრი თანამეგობრობას
იქნება ორიენტირებული გარშემო ვითარდება კოდი, რადგან ის ღია წყარო.
და ეს მხოლოდ მართლაც ლამაზი GitHub.
და ბოლოს, თქვენ შეგიძლიათ დამიკავშირდეს თუ თქვენ უბრალოდ უნდა რაიმე სწრაფი შეკითხვებს.
ასე რომ თქვენ შეგიძლიათ me on Twitter აქ, ჩემი ნახვა, და მხოლოდ ჩემი ელ.
ასე რომ, იმედია, რომ იყო რაღაც მხოლოდ მოკლე teaser
რა R მართლაც შეუძლია აკეთებს.
და იმედია, თქვენ უბრალოდ შეამოწმეთ ამ სამი ბმულები
და ვნახოთ, რა შეგიძლიათ გააკეთოთ მეტი.
და ვფიქრობ, რომ ის მხოლოდ ამის შესახებ.
მადლობა.
>> [ტაში]